VirtualBox

儲存庫 vbox 的更動 48123


忽略:
時間撮記:
2013-8-28 上午11:57:34 (11 年 以前)
作者:
vboxsync
訊息:

BIOS: Trailing spaces, begone!

位置:
trunk/src/VBox/Devices/PC/BIOS
檔案:
修改 15 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/VBox/Devices/PC/BIOS/ahci.c

    r44529 r48123  
    345345    /* Lock memory needed for DMA. */
    346346    ahci->edds.num_avail = NUM_EDDS_SG;
    347     DBG_AHCI("AHCI: S/G list for %lu bytes (skip %u)\n", 
     347    DBG_AHCI("AHCI: S/G list for %lu bytes (skip %u)\n",
    348348             (uint32_t)n_sect * sectsz, bios_dsk->drqp.skip_a);
    349349    vds_build_sg_list(&ahci->edds, bios_dsk->drqp.buffer, (uint32_t)n_sect * sectsz);
    … …  
    484484 *
    485485 * @returns status code.
    486  * @param   bios_dsk    Pointer to disk request packet (in the 
     486 * @param   bios_dsk    Pointer to disk request packet (in the
    487487 *                      EBDA).
    488488 */
    … …  
    515515 *
    516516 * @returns status code.
    517  * @param   bios_dsk    Pointer to disk request packet (in the 
     517 * @param   bios_dsk    Pointer to disk request packet (in the
    518518 *                      EBDA).
    519519 */
    … …  
    544544#define ATA_DATA_OUT     0x02
    545545
    546 uint16_t ahci_cmd_packet(uint16_t device_id, uint8_t cmdlen, char __far *cmdbuf, 
     546uint16_t ahci_cmd_packet(uint16_t device_id, uint8_t cmdlen, char __far *cmdbuf,
    547547                         uint16_t skip_b, uint32_t length, uint8_t inout, char __far *buffer)
    548548{
    … …  
    566566
    567567    DBG_AHCI("%s: reading %lu bytes, skip %u/%u, device %d, port %d\n", __func__,
    568              length, bios_dsk->drqp.skip_b, bios_dsk->drqp.skip_a, 
     568             length, bios_dsk->drqp.skip_b, bios_dsk->drqp.skip_a,
    569569             device_id, bios_dsk->ahcidev[device_id].port);
    570570    DBG_AHCI("%s: reading %u %u-byte sectors\n", __func__,
    … …  
    732732                hdcount = read_byte(0x40, 0x75);
    733733                hdcount++;
    734                 write_byte(0x40, 0x75, hdcount);               
     734                write_byte(0x40, 0x75, hdcount);
    735735            }
    736736            else if (val == 0xeb140101)
    … …  
    807807    bio_dsk_t __far     *bios_dsk;
    808808    ahci_t __far        *ahci;
    809    
     809
    810810
    811811    ebda_seg = read_word(0x0040, 0x000E);
    … …  
    824824        return 0;
    825825    }
    826     DBG_AHCI("AHCI: ahci_seg=%04x, size=%04x, pointer at EBDA:%04x (EBDA size=%04x)\n", 
     826    DBG_AHCI("AHCI: ahci_seg=%04x, size=%04x, pointer at EBDA:%04x (EBDA size=%04x)\n",
    827827             ahci_seg, sizeof(ahci_t), (uint16_t)&EbdaData->bdisk.ahci_seg, sizeof(ebda_data_t));
    828828

  • trunk/src/VBox/Devices/PC/BIOS/apm.c

    r42935 r48123  
    219219        // @todo: error should be different if interface not connected + engaged
    220220        SET_AH(APM_ERR_NO_EVENTS);  /* PM events don't happen. */
    221         SET_CF();       
     221        SET_CF();
    222222        break;
    223223    default:

  • trunk/src/VBox/Devices/PC/BIOS/ata.c

    r44692 r48123  
    8383    uint8_t         channel, device;
    8484    bio_dsk_t __far *bios_dsk;
    85    
     85
    8686    bios_dsk = read_word(0x0040, 0x000E) :> &EbdaData->bdisk;
    87    
     87
    8888    // Channels info init.
    8989    for (channel=0; channel<BX_MAX_ATA_INTERFACES; channel++) {
    … …  
    9393        bios_dsk->channels[channel].irq     = 0;
    9494    }
    95    
     95
    9696    // Devices info init.
    9797    for (device=0; device<BX_MAX_ATA_DEVICES; device++) {
    … …  
    111111        bios_dsk->devices[device].sectors     = 0;
    112112    }
    113    
     113
    114114    // hdidmap  and cdidmap init.
    115115    for (device=0; device<BX_MAX_STORAGE_DEVICES; device++) {
    … …  
    117117        bios_dsk->cdidmap[device] = BX_MAX_STORAGE_DEVICES;
    118118    }
    119    
     119
    120120    bios_dsk->hdcount = 0;
    121121    bios_dsk->cdcount = 0;
    … …  
    135135    uint16_t        pdelay;
    136136    bio_dsk_t __far *bios_dsk;
    137    
     137
    138138    bios_dsk = read_word(0x0040, 0x000E) :> &EbdaData->bdisk;
    139139    channel = device / 2;
    140140    slave = device % 2;
    141    
     141
    142142    iobase1 = bios_dsk->channels[channel].iobase1;
    143143    iobase2 = bios_dsk->channels[channel].iobase2;
    … …  
    185185    while(--max>0) {
    186186        uint8_t status = inb(iobase1+ATA_CB_STAT);
    187         if ((status & ATA_CB_STAT_RDY) != 0) 
     187        if ((status & ATA_CB_STAT_RDY) != 0)
    188188            break;
    189189    }
    190    
     190
    191191    // Enable interrupts
    192192    outb(iobase2+ATA_CB_DC, ATA_CB_DC_HD15);
    … …  
    236236            blksize >>= 1;
    237237    }
    238    
     238
    239239    status = inb(iobase1 + ATA_CB_STAT);
    240240    if (status & ATA_CB_STAT_BSY)
    … …  
    272272        head = ((uint16_t) (lba & 0x0000000fL)) | 0x40;
    273273    }
    274    
     274
    275275    outb(iobase2 + ATA_CB_DC, ATA_CB_DC_HD15 | ATA_CB_DC_NIEN);
    276276    outb(iobase1 + ATA_CB_FR, 0x00);
    … …  
    281281    outb(iobase1 + ATA_CB_DH, (slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0) | (uint8_t) head );
    282282    outb(iobase1 + ATA_CB_CMD, command);
    283    
     283
    284284    if (command == ATA_CMD_READ_MULTIPLE || command == ATA_CMD_READ_MULTIPLE_EXT) {
    285285        mult_blk_cnt = count;
    … …  
    288288        mult_blk_cnt = 1;
    289289    }
    290    
     290
    291291    while (1) {
    292292        status = inb(iobase1 + ATA_CB_STAT);
    … …  
    294294            break;
    295295    }
    296    
     296
    297297    if (status & ATA_CB_STAT_ERR) {
    298298        BX_DEBUG_ATA("%s: read error\n", __func__);
    … …  
    306306        return 3;
    307307    }
    308    
     308
    309309    // FIXME : move seg/off translation here
    310    
     310
    311311    int_enable(); // enable higher priority interrupts
    312    
     312
    313313    while (1) {
    314    
     314
    315315        // adjust if there will be an overrun. 2K max sector size
    316316        if (FP_OFF(buffer) >= 0xF800)
    317317            buffer = MK_FP(FP_SEG(buffer) + 0x80, FP_OFF(buffer) - 0x800);
    318        
     318
    319319        if (mode == ATA_MODE_PIO32) {
    320320            buffer = rep_insd(buffer, blksize, iobase1);
    … …  
    365365    uint8_t         buffer[0x0200];
    366366    bio_dsk_t __far *bios_dsk;
    367    
     367
    368368    bios_dsk = ebda_seg :> &EbdaData->bdisk;
    369369
    … …  
    405405        uint8_t     channel, slave;
    406406        uint8_t     sc, sn, cl, ch, st;
    407        
     407
    408408        channel = device / 2;
    409409        slave = device % 2;
    410        
     410
    411411        iobase1 = bios_dsk->channels[channel].iobase1;
    412412        iobase2 = bios_dsk->channels[channel].iobase2;
    413        
     413
    414414        // Disable interrupts
    415415        outb(iobase2+ATA_CB_DC, ATA_CB_DC_HD15 | ATA_CB_DC_NIEN);
    416        
     416
    417417        // Look for device
    418418        outb(iobase1+ATA_CB_DH, slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0);
    … …  
    423423        outb(iobase1+ATA_CB_SC, 0x55);
    424424        outb(iobase1+ATA_CB_SN, 0xaa);
    425        
     425
    426426        // If we found something
    427427        sc = inb(iobase1+ATA_CB_SC);
    … …  
    616616                    if (*(model+i) == 0x20)
    617617                        *(model+i) = 0x00;
    618                     else 
     618                    else
    619619                        break;
    620620                }
    … …  
    692692    uint8_t         channel, slave;
    693693    uint8_t         status, mode;
    694    
     694
    695695    device  = bios_dsk->drqp.dev_id;
    696696    channel = device / 2;
    697697    slave   = device % 2;
    698    
     698
    699699    iobase1 = bios_dsk->channels[channel].iobase1;
    700700    iobase2 = bios_dsk->channels[channel].iobase2;
    … …  
    705705    else
    706706        blksize >>= 1;
    707    
     707
    708708    status = inb(iobase1 + ATA_CB_STAT);
    709709    if (status & ATA_CB_STAT_BSY)
    … …  
    740740        head = ((uint16_t) (lba & 0x0000000fL)) | 0x40;
    741741    }
    742    
     742
    743743    outb(iobase2 + ATA_CB_DC, ATA_CB_DC_HD15 | ATA_CB_DC_NIEN);
    744744    outb(iobase1 + ATA_CB_FR, 0x00);
    … …  
    749749    outb(iobase1 + ATA_CB_DH, (slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0) | (uint8_t) head );
    750750    outb(iobase1 + ATA_CB_CMD, command);
    751    
     751
    752752    while (1) {
    753753        status = inb(iobase1 + ATA_CB_STAT);
    … …  
    755755            break;
    756756    }
    757    
     757
    758758    if (status & ATA_CB_STAT_ERR) {
    759759        BX_DEBUG_ATA("%s: write error\n", __func__);
    … …  
    767767        return 3;
    768768    }
    769    
     769
    770770    // FIXME : move seg/off translation here
    771    
     771
    772772    int_enable(); // enable higher priority interrupts
    773    
     773
    774774    while (1) {
    775    
     775
    776776        // adjust if there will be an overrun. 2K max sector size
    777777        if (FP_OFF(buffer) >= 0xF800)
    778778            buffer = MK_FP(FP_SEG(buffer) + 0x80, FP_OFF(buffer) - 0x800);
    779        
     779
    780780        if (mode == ATA_MODE_PIO32) {
    781781            buffer = rep_outsd(buffer, blksize, iobase1);
    … …  
    783783            buffer = rep_outsw(buffer, blksize, iobase1);
    784784        }
    785        
     785
    786786        bios_dsk->drqp.trsfsectors++;
    787787        count--;
    … …  
    822822 *
    823823 * @returns status code.
    824  * @param   bios_dsk    Pointer to disk request packet (in the 
     824 * @param   bios_dsk    Pointer to disk request packet (in the
    825825 *                      EBDA).
    826826 */
    … …  
    856856 *
    857857 * @returns status code.
    858  * @param   bios_dsk    Pointer to disk request packet (in the 
     858 * @param   bios_dsk    Pointer to disk request packet (in the
    859859 *                      EBDA).
    860860 */
    … …  
    887887      // 3 : error
    888888      // 4 : not ready
    889 uint16_t ata_cmd_packet(uint16_t device, uint8_t cmdlen, char __far *cmdbuf, 
     889uint16_t ata_cmd_packet(uint16_t device, uint8_t cmdlen, char __far *cmdbuf,
    890890                        uint16_t header, uint32_t length, uint8_t inout, char __far *buffer)
    891891{
    … …  
    907907        return 1;
    908908    }
    909    
     909
    910910    // The header length must be even
    911911    if (header & 1) {
    … …  
    913913        return 1;
    914914    }
    915    
     915
    916916    iobase1  = bios_dsk->channels[channel].iobase1;
    917917    iobase2  = bios_dsk->channels[channel].iobase2;
    918918    mode     = bios_dsk->devices[device].mode;
    919919    transfer = 0L;
    920    
     920
    921921    if (cmdlen < 12)
    922922        cmdlen = 12;
    … …  
    924924        cmdlen = 16;
    925925    cmdlen >>= 1;
    926    
     926
    927927    // Reset count of transferred data
    928928    // @todo: clear in calling code?
    929929    bios_dsk->drqp.trsfsectors = 0;
    930930    bios_dsk->drqp.trsfbytes   = 0;
    931    
     931
    932932    status = inb(iobase1 + ATA_CB_STAT);
    933933    if (status & ATA_CB_STAT_BSY)
    934934        return 2;
    935    
     935
    936936    outb(iobase2 + ATA_CB_DC, ATA_CB_DC_HD15 | ATA_CB_DC_NIEN);
    937937    // outb(iobase1 + ATA_CB_FR, 0x00);
    … …  
    942942    outb(iobase1 + ATA_CB_DH, slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0);
    943943    outb(iobase1 + ATA_CB_CMD, ATA_CMD_PACKET);
    944    
     944
    945945    // Device should ok to receive command
    946946    while (1) {
    … …  
    948948        if ( !(status & ATA_CB_STAT_BSY) ) break;
    949949    }
    950    
     950
    951951    if (status & ATA_CB_STAT_CHK) {
    952952        BX_DEBUG_ATA("%s: error, status is %02x\n", __func__, status);
    … …  
    960960        return 4;
    961961    }
    962    
     962
    963963    int_enable(); // enable higher priority interrupts
    964    
     964
    965965    // Normalize address
    966966    BX_DEBUG_ATA("acp1 buffer ptr: %04x:%04x wlen %04x\n", FP_SEG(cmdbuf), FP_OFF(cmdbuf), cmdlen);
    … …  
    968968    //  cmdseg += (cmdoff / 16);
    969969    //  cmdoff %= 16;
    970    
     970
    971971    // Send command to device
    972972    rep_outsw(cmdbuf, cmdlen, iobase1);
    973    
     973
    974974    if (inout == ATA_DATA_NO) {
    975975        status = inb(iobase1 + ATA_CB_STAT);
    … …  
    977977    else {
    978978        while (1) {
    979        
     979
    980980            while (1) {
    981981                status = inb(iobase1 + ATA_CB_STAT);
    982                 if ( !(status & ATA_CB_STAT_BSY) ) 
     982                if ( !(status & ATA_CB_STAT_BSY) )
    983983                    break;
    984984            }
    985            
     985
    986986            // Check if command completed
    987987            if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_DRQ) ) ==0 )
    988988                break;
    989            
     989
    990990            if (status & ATA_CB_STAT_CHK) {
    991991                BX_DEBUG_ATA("%s: error (status %02x)\n", __func__, status);
    … …  
    994994                return 3;
    995995            }
    996            
     996
    997997            // Device must be ready to send data
    998998            if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DRQ | ATA_CB_STAT_CHK) )
    … …  
    10031003                return 4;
    10041004            }
    1005            
     1005
    10061006            // Normalize address
    10071007            BX_DEBUG_ATA("acp2 buffer ptr: %04x:%04x\n", FP_SEG(buffer), FP_OFF(buffer));
    … …  
    10091009            //      bufseg += (bufoff / 16);
    10101010            //      bufoff %= 16;
    1011            
     1011
    10121012            // Get the byte count
    10131013            lcount =  ((uint16_t)(inb(iobase1 + ATA_CB_CH))<<8)+inb(iobase1 + ATA_CB_CL);
    1014            
     1014
    10151015            // adjust to read what we want
    10161016            if (header>lcount) {
    … …  
    10241024                lcount -= lbefore;
    10251025            }
    1026            
     1026
    10271027            if (lcount>length) {
    10281028                lafter = lcount - length;
    … …  
    10341034                length -= lcount;
    10351035            }
    1036            
     1036
    10371037            // Save byte count
    10381038            count = lcount;
    1039            
     1039
    10401040            BX_DEBUG_ATA("Trying to read %04x bytes (%04x %04x %04x) ",lbefore+lcount+lafter,lbefore,lcount,lafter);
    10411041            BX_DEBUG_ATA("to 0x%04x:0x%04x\n",FP_SEG(buffer),FP_OFF(buffer));
    1042            
     1042
    10431043            // If counts not dividable by 4, use 16bits mode
    10441044            lmode = mode;
    … …  
    10491049            if (lafter  & 0x03)
    10501050                lmode = ATA_MODE_PIO16;
    1051            
     1051
    10521052            // adds an extra byte if count are odd. before is always even
    10531053            if (lcount & 0x01) {
    … …  
    10571057                }
    10581058            }
    1059            
     1059
    10601060            if (lmode == ATA_MODE_PIO32) {
    10611061                lcount  >>= 2;
    … …  
    10681068                lafter  >>= 1;
    10691069            }
    1070            
     1070
    10711071            if (lmode == ATA_MODE_PIO32) {
    10721072                if (lbefore)
    … …  
    10821082                    insw_discard(lafter, iobase1);
    10831083            }
    1084            
    1085            
     1084
     1085
    10861086            // Compute new buffer address
    10871087            buffer += count;
    1088            
     1088
    10891089            // Save transferred bytes count
    10901090            transfer += count;
    … …  
    10921092        }
    10931093    }
    1094    
     1094
    10951095    // Final check, device must be ready
    10961096    if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DF | ATA_CB_STAT_DRQ | ATA_CB_STAT_CHK) )
    … …  
    11011101        return 4;
    11021102    }
    1103    
     1103
    11041104    // Enable interrupts
    11051105    outb(iobase2+ATA_CB_DC, ATA_CB_DC_HD15);
    … …  
    11321132    outb(iobase1 + ATA_CB_DH, slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0);
    11331133    outb(iobase1 + ATA_CB_CMD, ATA_CMD_DEVICE_RESET);
    1134    
     1134
    11351135    /* Wait for the device to clear BSY. */
    11361136    while (1) {
    … …  
    11381138        if ( !(status & ATA_CB_STAT_BSY) ) break;
    11391139    }
    1140    
     1140
    11411141    /* Final check, device must be ready */
    11421142    if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DF | ATA_CB_STAT_DRQ | ATA_CB_STAT_CHK) )
    … …  
    11471147        return 1;
    11481148    }
    1149    
     1149
    11501150    /* Enable interrupts */
    11511151    outb(iobase2+ATA_CB_DC, ATA_CB_DC_HD15);

  • trunk/src/VBox/Devices/PC/BIOS/biosint.h

    r44528 r48123  
    238238#define BX_PANIC(...)   bios_printf(BIOS_PRINTF_DEBHALT, __VA_ARGS__)
    239239
    240 /* Because we don't tell the recompiler when guest physical memory 
     240/* Because we don't tell the recompiler when guest physical memory
    241241 * is written, it can incorrectly cache guest code overwritten by
    242242 * DMA (bus master or not). We just re-write the memory block to flush

  • trunk/src/VBox/Devices/PC/BIOS/boot.c

    r44528 r48123  
    9292{
    9393    int     i;
    94    
     94
    9595    // cdboot contains 0 if lan/floppy/harddisk, 1 otherwise
    9696    // lanboot contains 0 if floppy/harddisk, 1 otherwise
    9797    // drive contains real/emulated boot drive
    98    
     98
    9999    if(cdboot)i=2;                    // CD-Rom
    100100    else if(lanboot)i=3;              // LAN
    … …  
    102102    else if((drive&0x0080)==0x80)i=1; // Hard drive
    103103    else return;
    104    
     104
    105105    BX_INFO("Booting from %s...\n",drivetypes[i]);
    106106}
    … …  
    111111//--------------------------------------------------------------------------
    112112//@todo: pass inputs as bit flags rather than bytes?
    113 void print_boot_failure(uint8_t cdboot, uint8_t lanboot, uint8_t drive, 
     113void print_boot_failure(uint8_t cdboot, uint8_t lanboot, uint8_t drive,
    114114                        uint8_t reason, uint8_t lastdrive)
    115115{
    116116    uint16_t    drivenum = drive&0x7f;
    117    
     117
    118118    // cdboot: 1 if boot from cd, 0 otherwise
    119119    // lanboot: 1 if boot from lan, 0 otherwise
    … …  
    121121    // reason: 0 signature check failed, 1 read error
    122122    // lastdrive: 1 boot drive is the last one in boot sequence
    123    
     123
    124124    if (cdboot)
    125125        BX_INFO("Boot from %s failed\n",drivetypes[2]);
    … …  
    130130    else
    131131        BX_INFO("Boot from %s %d failed\n", drivetypes[0],drivenum);
    132    
     132
    133133    if (lastdrive==1) {
    134134        if (reason==0)
    … …  
    162162    uint16_t    status;
    163163    uint8_t     lastdrive=0;
    164    
     164
    165165    // if BX_ELTORITO_BOOT is not defined, old behavior
    166166    //   check bit 5 in CMOS reg 0x2d.  load either 0x00 or 0x80 into DL
    … …  
    181181    //     0x04 : local area network
    182182    //     else : boot failure
    183    
     183
    184184    // Get the boot sequence
    185185#if BX_ELTORITO_BOOT
    … …  
    192192    if (bseqnr == 1)
    193193        delay_boot((inb_cmos(0x3c) & 0xf0) >> 4); /* Implemented in logo.c */
    194    
     194
    195195    if (bseqnr==2) bootseq >>= 4;
    196196    if (bseqnr==3) bootseq >>= 8;
    … …  
    199199    bootdrv=0x00; bootcd=0;
    200200    bootlan=0;
    201     BX_INFO("Boot : bseqnr=%d, bootseq=%x\r\n",bseqnr, bootseq);   
    202    
     201    BX_INFO("Boot : bseqnr=%d, bootseq=%x\r\n",bseqnr, bootseq);
     202
    203203    switch(bootseq & 0x0f) {
    204204    case 0x01:
    … …  
    210210        // Get the Boot drive.
    211211        uint8_t boot_drive = read_byte(ebda_seg, (uint16_t)&EbdaData->uForceBootDrive);
    212        
     212
    213213        bootdrv = boot_drive + 0x80;
    214214        bootcd=0;
    … …  
    224224#else
    225225    bootseq=inb_cmos(0x2d);
    226    
     226
    227227    if (bseqnr==2) {
    228228        bootseq ^= 0x20;
    … …  
    232232    if((bootseq&0x20)==0) bootdrv=0x80;
    233233#endif // BX_ELTORITO_BOOT
    234    
     234
    235235#if BX_ELTORITO_BOOT
    236236    // We have to boot from cd
    237237    if (bootcd != 0) {
    238238        status = cdrom_boot();
    239    
     239
    240240        // If failure
    241241        if ( (status & 0x00ff) !=0 ) {
    … …  
    244244            return 0x00000000;
    245245        }
    246        
     246
    247247        bootseg = read_word(ebda_seg,(uint16_t)&EbdaData->cdemu.load_segment);
    248248        bootdrv = (uint8_t)(status>>8);
    249249    }
    250    
     250
    251251#endif // BX_ELTORITO_BOOT
    252    
     252
    253253    // Check for boot from LAN first
    254254    if (bootlan == 1) {
    … …  
    271271                    netboot_entry = (void __far *)(fplan + 6);
    272272                    netboot_entry();
    273                 } 
     273                }
    274274                else
    275275                {
    … …  
    282282            }
    283283        }
    284        
     284
    285285        // boot from LAN will not return if successful.
    286286        print_boot_failure(bootcd, bootlan, bootdrv, 1, lastdrive);
    … …  
    291291    if (bootcd == 0 && bootlan == 0) {
    292292        bootseg=0x07c0;
    293                
     293
    294294        status = read_boot_sec(bootdrv,bootseg);
    295295        if (status != 0) {
    … …  
    298298        }
    299299    }
    300    
     300
    301301    // There is *no* requirement whatsoever for a valid floppy boot sector
    302302    // to have a 55AAh signature. UNIX boot floppies typically have no such
    … …  
    310310    if (bootdrv != 0) bootchk = 0;
    311311    else bootchk = 1; /* disable 0x55AA signature check on drive A: */
    312    
     312
    313313#if BX_ELTORITO_BOOT
    314314    // if boot from cd, no signature check
    … …  
    316316        bootchk = 1;
    317317#endif // BX_ELTORITO_BOOT
    318    
     318
    319319    if (read_word(bootseg,0) == read_word(bootseg,2)
    320320      || (bootchk == 0 && read_word(bootseg,0x1fe) != 0xaa55))
    … …  
    323323        return 0x00000000;
    324324    }
    325    
     325
    326326#if BX_ELTORITO_BOOT
    327327    // Print out the boot string
    … …  
    330330    print_boot_device(0, bootlan, bootdrv);
    331331#endif // BX_ELTORITO_BOOT
    332    
     332
    333333    // return the boot segment
    334334    return (((uint32_t)bootdrv) << 16) + bootseg;

  • trunk/src/VBox/Devices/PC/BIOS/ebda.h

    r44692 r48123  
    217217extern uint16_t ahci_cmd_packet(uint16_t device_id, uint8_t cmdlen, char __far *cmdbuf,
    218218                                uint16_t header, uint32_t length, uint8_t inout, char __far *buffer);
    219 extern uint16_t scsi_cmd_packet(uint16_t device, uint8_t cmdlen, char __far *cmdbuf, 
     219extern uint16_t scsi_cmd_packet(uint16_t device, uint8_t cmdlen, char __far *cmdbuf,
    220220                                uint16_t header, uint32_t length, uint8_t inout, char __far *buffer);
    221 extern uint16_t ata_cmd_packet(uint16_t device, uint8_t cmdlen, char __far *cmdbuf, 
     221extern uint16_t ata_cmd_packet(uint16_t device, uint8_t cmdlen, char __far *cmdbuf,
    222222                               uint16_t header, uint32_t length, uint8_t inout, char __far *buffer);
    223223

  • trunk/src/VBox/Devices/PC/BIOS/keyboard.c

    r44528 r48123  
    167167    // If you're getting a 993 keyboard panic here,
    168168    // please see the comment in keyboard_init
    169    
     169
    170170    BX_PANIC("Keyboard error:%u\n",status);
    171171}
    … …  
    313313{
    314314    uint16_t    buffer_start, buffer_end, buffer_head, buffer_tail, temp_tail;
    315    
     315
    316316#if BX_CPU < 2
    317317    buffer_start = 0x001E;
    … …  
    321321    buffer_end   = read_word(0x0040, 0x0082);
    322322#endif
    323    
     323
    324324    buffer_head = read_word(0x0040, 0x001A);
    325325    buffer_tail = read_word(0x0040, 0x001C);
    326    
     326
    327327    temp_tail = buffer_tail;
    328328    buffer_tail += 2;
    329329    if (buffer_tail >= buffer_end)
    330330        buffer_tail = buffer_start;
    331    
     331
    332332    if (buffer_tail == buffer_head)
    333333        return(0);
    334    
     334
    335335    write_byte(0x0040, temp_tail, ascii_code);
    336336    write_byte(0x0040, temp_tail+1, scan_code);
    … …  
    347347    uint8_t scancode, asciicode, shift_flags;
    348348    uint8_t mf2_flags, mf2_state, flag;
    349    
     349
    350350    //
    351351    // DS has been set to F000 before call
    352352    //
    353    
    354    
     353
     354
    355355    scancode = GET_AL();
    356    
     356
    357357    if (scancode == 0) {
    358358        BX_INFO("KBD: int09 handler: AL=0\n");
    359359        return;
    360360    }
    361    
    362    
     361
     362
    363363    shift_flags = read_byte(0x0040, 0x17);
    364364    mf2_flags = read_byte(0x0040, 0x18);
    365365    mf2_state = read_byte(0x0040, 0x96);
    366366    asciicode = 0;
    367    
     367
    368368    switch (scancode) {
    369369    case 0x3a: /* Caps Lock press */
    … …  
    419419        }
    420420        break;
    421    
     421
    422422    case 0x38: /* Alt press */
    423423        shift_flags |= 0x08;
    … …  
    442442        }
    443443        break;
    444    
     444
    445445    case 0x45: /* Num Lock press */
    446446        if ((mf2_state & 0x03) == 0) {
    … …  
    457457        }
    458458        break;
    459    
     459
    460460    case 0x46: /* Scroll Lock press */
    461461        mf2_flags |= 0x10;
    … …  
    464464        write_byte(0x0040, 0x17, shift_flags);
    465465        break;
    466    
     466
    467467    case 0xc6: /* Scroll Lock release */
    468468        mf2_flags &= ~0x10;
    469469        write_byte(0x0040, 0x18, mf2_flags);
    470470        break;
    471    
     471
    472472    case 0x53: /* Del press */
    473473        if ((shift_flags & 0x0c) == 0x0c)
    474474            jmp_post();
    475475        /* fall through */
    476    
     476
    477477    default:
    478478        if (scancode & 0x80) {
    … …  
    496496            /* check if lock state should be ignored
    497497             * because a SHIFT key are pressed */
    498        
     498
    499499            if (shift_flags & scan_to_scanascii[scancode].lock_flags) {
    500500                asciicode = scan_to_scanascii[scancode].normal;
    … …  
    531531    uint16_t    buffer_start, buffer_end, buffer_head, buffer_tail;
    532532    uint8_t     acode, scode;
    533    
     533
    534534#if BX_CPU < 2
    535535    buffer_start = 0x001E;
    … …  
    539539    buffer_end   = read_word(0x0040, 0x0082);
    540540#endif
    541    
     541
    542542    buffer_head = read_word(0x0040, 0x001a);
    543543    buffer_tail = read_word(0x0040, 0x001c);
    544    
     544
    545545    if (buffer_head != buffer_tail) {
    546546        acode = read_byte(0x0040, buffer_head);
    … …  
    581581    uint8_t     scan_code, ascii_code, shift_flags, led_flags, count;
    582582    uint16_t    kbd_code, max;
    583    
     583
    584584    BX_DEBUG_INT16("int16: AX=%04x BX=%04x CX=%04x DX=%04x \n", AX, BX, CX, DX);
    585    
     585
    586586    shift_flags = read_byte(0x0040, 0x17);
    587587    led_flags   = read_byte(0x0040, 0x97);
    … …  
    601601        int_enable();
    602602    }
    603    
     603
    604604    switch (GET_AH()) {
    605605    case 0x00: /* read keyboard input */
    … …  
    613613        AX = (scan_code << 8) | ascii_code;
    614614        break;
    615    
     615
    616616    case 0x01: /* check keyboard status */
    617617        SET_IF();   /* Enable interrupts. Some callers depend on that! */
    … …  
    627627        CLEAR_ZF();
    628628        break;
    629    
     629
    630630    case 0x02: /* get shift flag status */
    631631        shift_flags = read_byte(0x0040, 0x17);
    632632        SET_AL(shift_flags);
    633633        break;
    634    
     634
    635635    case 0x05: /* store key-stroke into buffer */
    636636        if ( !enqueue_key(GET_CH(), GET_CL()) ) {
    … …  
    641641        }
    642642        break;
    643    
     643
    644644    case 0x09: /* GET KEYBOARD FUNCTIONALITY */
    645645        // bit Bochs Description
    … …  
    655655        SET_AL(0x30);
    656656        break;
    657        
     657
    658658    case 0x0A: /* GET KEYBOARD ID */
    659659        count = 2;
    … …  
    681681        BX=kbd_code;
    682682        break;
    683    
     683
    684684    case 0x10: /* read MF-II keyboard input */
    685685        if ( !dequeue_key(&scan_code, &ascii_code, 1) ) {
    … …  
    690690        AX = (scan_code << 8) | ascii_code;
    691691        break;
    692    
     692
    693693    case 0x11: /* check MF-II keyboard status */
    694694        SET_IF();
    … …  
    702702        CLEAR_ZF();
    703703        break;
    704    
     704
    705705    case 0x12: /* get extended keyboard status */
    706706        shift_flags = read_byte(0x0040, 0x17);
    … …  
    711711        BX_DEBUG_INT16("int16: func 12 sending %04x\n",AX);
    712712        break;
    713    
     713
    714714    case 0x92: /* keyboard capability check called by DOS 5.0+ keyb */
    715715        SET_AH(0x80); // function int16 ah=0x10-0x12 supported
    716716        break;
    717    
     717
    718718    case 0xA2: /* 122 keys capability check called by DOS 5.0+ keyb */
    719719        // don't change AH : function int16 ah=0x20-0x22 NOT supported
    720720        break;
    721    
     721
    722722    //@todo: what's the point of handling this??
    723723#if 0
    … …  
    726726        SET_AH(0x02); // unsupported, aka normal keyboard
    727727#endif
    728    
     728
    729729    default:
    730730        BX_INFO("KBD: unsupported int 16h function %02x\n", GET_AH());

  • trunk/src/VBox/Devices/PC/BIOS/parallel.c

    r44528 r48123  
    5050
    5151    int_enable();
    52    
     52
    5353    addr = read_word(0x0040, (regs.u.r16.dx << 1) + 8);
    5454    if ((regs.u.r8.ah < 3) && (regs.u.r16.dx < 3) && (addr > 0)) {

  • trunk/src/VBox/Devices/PC/BIOS/pciutil.c

    r39366 r48123  
    102102    "xchg   cx, dx"         \
    103103    "shl    ecx, 16"        \
    104     "mov    cx, dx"         \   
     104    "mov    cx, dx"         \
    105105    "int    0x1a"           \
    106106    parm [ax] [bx] [di] [dx cx];

  • trunk/src/VBox/Devices/PC/BIOS/print.c

    r45401 r48123  
    153153    int         i;
    154154    uint16_t    arg, nibble, hibyte, format_width, hexadd;
    155     va_list     args; 
    156    
     155    va_list     args;
     156
    157157    va_start( args, s );
    158    
     158
    159159    in_format = 0;
    160160    format_width = 0;
    161    
     161
    162162    if ((action & BIOS_PRINTF_DEBHALT) == BIOS_PRINTF_DEBHALT) {
    163163        bios_printf (BIOS_PRINTF_SCREEN, "FATAL: ");

  • trunk/src/VBox/Devices/PC/BIOS/ps2mouse.c

    r38832 r48123  
    8080    while ((inb(0x64) & 0x21) != 0x21 && retries)
    8181        --retries;
    82    
     82
    8383    if (!retries)
    8484        return(1);
    … …  
    9393    if (inb(0x64) & 0x02)
    9494        BX_PANIC(panic_msg_keyb_buffer_full,"setkbdcomm");
    95    
     95
    9696    outb(0x64, 0x60); // write command byte
    9797    outb(0x60, command_byte);
    … …  
    105105    uint8_t     in_byte, index, package_count;
    106106    uint8_t     mouse_flags_1, mouse_flags_2;
    107    
     107
    108108    BX_DEBUG_INT74("entering int74_function\n");
    109109    make_farcall = 0;
    110    
     110
    111111    in_byte = inb(0x64);
    112112    if ( (in_byte & 0x21) != 0x21 ) {
    … …  
    115115    in_byte = inb(0x60);
    116116    BX_DEBUG_INT74("int74: read byte %02x\n", in_byte);
    117    
     117
    118118    mouse_flags_1 = read_byte(ebda_seg, 0x0026);
    119119    mouse_flags_2 = read_byte(ebda_seg, 0x0027);
    120    
     120
    121121    if ( (mouse_flags_2 & 0x80) != 0x80 ) {
    122122        return;
    123123    }
    124    
     124
    125125    package_count = mouse_flags_2 & 0x07;
    126126    index = mouse_flags_1 & 0x07;
    127127    write_byte(ebda_seg, 0x28 + index, in_byte);
    128    
     128
    129129    if ( index >= package_count ) {
    130130        BX_DEBUG_INT74("int74_function: make_farcall=1\n");
    … …  
    165165    // 05: cannot enable mouse, since no far call has been installed
    166166    // 80/86: mouse service not implemented
    167    
     167
    168168    if (regs.u.r8.al > 7) {
    169169        BX_DEBUG_INT15_MS("unsupported subfn\n");
    … …  
    173173        return;
    174174    }
    175    
     175
    176176    // Valid subfn; disable AUX input and IRQ12, assume no error
    177177    set_kbd_command_byte(0x65);
    178178    CLEAR_CF();
    179179    regs.u.r8.ah = 0;
    180    
     180
    181181    switch (regs.u.r8.al) {
    182182    case 0: // Disable/Enable Mouse
    … …  
    203203            mouse_cmd = 0xF4;   // enable mouse command
    204204        }
    205        
     205
    206206        ret = send_to_mouse_ctrl(mouse_cmd);  // disable mouse command
    207207        if (ret == 0) {
    … …  
    212212            }
    213213        }
    214        
     214
    215215        // interface error
    216216        SET_CF();
    217217        regs.u.r8.ah = 3;
    218218        break;
    219    
     219
    220220    case 5: // Initialize Mouse
    221221        // Valid package sizes are 1 to 8
    … …  
    229229        write_byte(ebda_seg, 0x0027, mouse_flags_2);
    230230        // fall through!
    231    
     231
    232232    case 1: // Reset Mouse
    233233        BX_DEBUG_INT15_MS("case 1 or 5:\n");
    … …  
    260260            }
    261261        }
    262        
     262
    263263        // interface error
    264264        SET_CF();
    265265        regs.u.r8.ah = 3;
    266266        break;
    267    
     267
    268268    case 2: // Set Sample Rate
    269269        BX_DEBUG_INT15_MS("case 2:\n");
    … …  
    296296        }
    297297        break;
    298    
     298
    299299    case 3: // Set Resolution
    300300        BX_DEBUG_INT15_MS("case 3:\n");
    … …  
    326326        }
    327327        break;
    328    
     328
    329329    case 4: // Get Device ID
    330330        BX_DEBUG_INT15_MS("case 4:\n");
    … …  
    341341        }
    342342        break;
    343    
     343
    344344    case 6: // Return Status & Set Scaling Factor...
    345345        BX_DEBUG_INT15_MS("case 6:\n");
    … …  
    368368                }
    369369            }
    370            
     370
    371371            // interface error
    372372            SET_CF();
    373373            regs.u.r8.ah = 3;
    374374            break;
    375        
     375
    376376        case 1: // Set Scaling Factor to 1:1
    377377        case 2: // Set Scaling Factor to 2:1
    … …  
    391391            }
    392392            break;
    393        
     393
    394394        default:
    395395            BX_PANIC("INT 15h C2 AL=6, BH=%02x\n", (unsigned) regs.u.r8.bh);
    … …  
    399399        }
    400400        break;
    401    
     401
    402402    case 7: // Set Mouse Handler Address
    403403        BX_DEBUG_INT15_MS("case 7:\n");
    … …  
    419419        write_byte(ebda_seg, 0x0027, mouse_flags_2);
    420420        break;
    421    
     421
    422422    default:
    423423        BX_PANIC("INT 15h C2 default case entered\n");

  • trunk/src/VBox/Devices/PC/BIOS/scsi.c

    r46241 r48123  
    9494    while (status & VBSCSI_BUSY);
    9595
    96    
     96
    9797    sizes = ((length >> 12) & 0xF0) | cbCDB;
    9898    outb(io_base + VBSCSI_REGISTER_COMMAND, target_id);                 /* Write the target ID. */
    … …  
    100100    outb(io_base + VBSCSI_REGISTER_COMMAND, sizes);                     /* Write CDB size and top bufsize bits. */
    101101    outb(io_base + VBSCSI_REGISTER_COMMAND, length);                    /* Write the buffer size. */
    102     outb(io_base + VBSCSI_REGISTER_COMMAND, (length >> 8));   
     102    outb(io_base + VBSCSI_REGISTER_COMMAND, (length >> 8));
    103103    for (i = 0; i < cbCDB; i++)                                         /* Write the CDB. */
    104104        outb(io_base + VBSCSI_REGISTER_COMMAND, aCDB[i]);
    … …  
    136136    while (status & VBSCSI_BUSY);
    137137
    138    
     138
    139139    sizes = ((length >> 12) & 0xF0) | cbCDB;
    140140    outb(io_base + VBSCSI_REGISTER_COMMAND, target_id);                 /* Write the target ID. */
    … …  
    171171 *
    172172 * @returns status code.
    173  * @param   bios_dsk    Pointer to disk request packet (in the 
     173 * @param   bios_dsk    Pointer to disk request packet (in the
    174174 *                      EBDA).
    175175 */
    … …  
    203203             count, device_id, bios_dsk->scsidev[device_id].target_id);
    204204
    205     rc = scsi_cmd_data_in(io_base, target_id, (void __far *)&cdb, 10, 
     205    rc = scsi_cmd_data_in(io_base, target_id, (void __far *)&cdb, 10,
    206206                          bios_dsk->drqp.buffer, (count * 512L));
    207207
    … …  
    220220 *
    221221 * @returns status code.
    222  * @param   bios_dsk    Pointer to disk request packet (in the 
     222 * @param   bios_dsk    Pointer to disk request packet (in the
    223223 *                      EBDA).
    224224 */
    … …  
    274274 *
    275275 * @returns status code.
    276  * @param   bios_dsk    Pointer to disk request packet (in the 
     276 * @param   bios_dsk    Pointer to disk request packet (in the
    277277 *                      EBDA).
    278278 */
    279 uint16_t scsi_cmd_packet(uint16_t device_id, uint8_t cmdlen, char __far *cmdbuf, 
     279uint16_t scsi_cmd_packet(uint16_t device_id, uint8_t cmdlen, char __far *cmdbuf,
    280280                         uint16_t before, uint32_t length, uint8_t inout, char __far *buffer)
    281281{
    … …  
    440440                }
    441441
    442                 /* We need to calculate the geometry for the disk. From 
    443                  * the BusLogic driver in the Linux kernel. 
     442                /* We need to calculate the geometry for the disk. From
     443                 * the BusLogic driver in the Linux kernel.
    444444                 */
    445445                if (sectors >= (uint32_t)4 * 1024 * 1024)

  • trunk/src/VBox/Devices/PC/BIOS/serial.c

    r44528 r48123  
    5050
    5151    int_enable();
    52    
     52
    5353    addr = read_word(0x0040, (regs.u.r16.dx << 1));
    5454    timeout = read_byte(0x0040, 0x007C + regs.u.r16.dx);

  • trunk/src/VBox/Devices/PC/BIOS/timepci.c

    r44528 r48123  
    8181    // The count I use below guarantees coverage or more than
    8282    // this time, with any reasonable IPS setting.
    83    
     83
    8484    uint16_t    iter;
    85    
     85
    8686    iter = 25000;
    8787    while (--iter != 0) {
    … …  
    103103    // INT 70h: IRQ 8 - CMOS RTC interrupt from periodic or alarm modes
    104104    uint8_t   registerB = 0, registerC = 0;
    105    
     105
    106106    // Check which modes are enabled and have occurred.
    107107    registerB = inb_cmos( 0xB );
    108108    registerC = inb_cmos( 0xC );
    109    
     109
    110110    if( ( registerB & 0x60 ) != 0 ) {
    111111        if( ( registerC & 0x20 ) != 0 ) {
    … …  
    117117        if( ( registerC & 0x40 ) != 0 ) {
    118118            // Handle Periodic Interrupt.
    119            
     119
    120120            if( read_byte( 0x40, 0xA0 ) != 0 ) {
    121121                // Wait Interval (Int 15, AH=83) active.
    122122                uint32_t    time;
    123                
     123
    124124                time = read_dword( 0x40, 0x9C );  // Time left in microseconds.
    125125                if( time < 0x3D1 ) {
    126126                    // Done waiting.
    127127                    uint16_t    segment, offset;
    128                    
     128
    129129                    segment = read_word( 0x40, 0x98 );
    130130                    offset  = read_word( 0x40, 0x9A );
    … …  
    150150    uint8_t     val8;
    151151
    152     BX_DEBUG_INT1A("int1a: AX=%04x BX=%04x CX=%04x DX=%04x DS=%04x\n", 
     152    BX_DEBUG_INT1A("int1a: AX=%04x BX=%04x CX=%04x DX=%04x DS=%04x\n",
    153153                   regs.u.r16.ax, regs.u.r16.bx, regs.u.r16.cx, regs.u.r16.dx, ds);
    154     int_enable();   
    155    
     154    int_enable();
     155
    156156    switch (regs.u.r8.ah) {
    157157    case 0: // get current clock count
    … …  
    165165        ClearCF(iret_addr.flags); // OK
    166166        break;
    167    
     167
    168168    case 1: // Set Current Clock Count
    169169        int_disable();
    … …  
    175175        ClearCF(iret_addr.flags); // OK
    176176        break;
    177        
     177
    178178    case 2: // Read CMOS Time
    179179        if (rtc_updating()) {
    … …  
    181181            break;
    182182        }
    183        
     183
    184184        regs.u.r8.dh = inb_cmos(0x00); // Seconds
    185185        regs.u.r8.cl = inb_cmos(0x02); // Minutes
    … …  
    190190        ClearCF(iret_addr.flags); // OK
    191191        break;
    192    
     192
    193193    case 3: // Set CMOS Time
    194194        // Using a debugger, I notice the following masking/setting
    … …  
    217217        ClearCF(iret_addr.flags); // OK
    218218        break;
    219    
     219
    220220    case 4: // Read CMOS Date
    221221        regs.u.r8.ah = 0;
    … …  
    231231        ClearCF(iret_addr.flags); // OK
    232232        break;
    233    
     233
    234234    case 5: // Set CMOS Date
    235235        // Using a debugger, I notice the following masking/setting
    … …  
    258258        ClearCF(iret_addr.flags); // OK
    259259        break;
    260    
     260
    261261    case 6: // Set Alarm Time in CMOS
    262262        // Using a debugger, I notice the following masking/setting
    … …  
    289289        ClearCF(iret_addr.flags); // OK
    290290        break;
    291    
     291
    292292    case 7: // Turn off Alarm
    293293        // Using a debugger, I notice the following masking/setting
    … …  
    308308        ClearCF(iret_addr.flags); // OK
    309309        break;
    310    
     310
    311311    default:
    312312        BX_DEBUG_INT1A("int1a: AX=%04x unsupported\n", regs.u.r16.ax);

  • trunk/src/VBox/Devices/PC/BIOS/vds.c

    r39559 r48123  
    6161
    6262/*
    63  * Convert a real mode 16:16 segmented address to a simple 32-bit 
    64  * linear address. 
     63 * Convert a real mode 16:16 segmented address to a simple 32-bit
     64 * linear address.
    6565 */
    6666uint32_t vds_real_to_lin( void __far *ptr )
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette