Changes in / [42cfd91:1724745f] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/ata_bd/ata_bd.c

    r42cfd91 r1724745f  
    3636 *
    3737 * This driver currently works only with CHS addressing and uses PIO.
    38  * Currently based on the (now obsolete) ATA-1, ATA-2 standards.
     38 * Currently based on the (now obsolete) ANSI X3.221-1994 (ATA-1) standard.
     39 * At this point only reading is possible, not writing.
    3940 *
    4041 * The driver services a single controller which can have up to two disks
    … …  
    9596                return -1;
    9697
     98        /* Put drives to reset, disable interrupts. */
     99        printf("Reset drives... ");
     100        fflush(stdout);
     101
     102        pio_write_8(&ctl->device_control, DCR_SRST);
     103        /* FIXME: Find out how to do this properly. */
     104        async_usleep(100);
     105        pio_write_8(&ctl->device_control, 0);
     106
     107        do {
     108                status = pio_read_8(&cmd->status);
     109        } while ((status & SR_BSY) != 0);
     110        printf("Done\n");
     111
    97112        (void) drive_identify(0, &disk[0]);
    98113        (void) drive_identify(1, &disk[1]);
    … …  
    133148        uint16_t data;
    134149        uint8_t status;
    135         uint8_t drv_head;
    136150        size_t i;
    137151
    … …  
    139153        fflush(stdout);
    140154
    141         drv_head = ((disk_id != 0) ? DHR_DRV : 0);
     155        pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
     156        async_usleep(100);
     157        pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
     158
     159        status = pio_read_8(&cmd->status);
     160
    142161        d->present = false;
    143 
    144         do {
    145                 status = pio_read_8(&cmd->status);
    146         } while ((status & SR_BSY) != 0);
    147 
    148         pio_write_8(&cmd->drive_head, drv_head);
    149162
    150163        /*
    … …  
    152165         * do the right thing to work with real drives.
    153166         */
    154         do {
    155                 status = pio_read_8(&cmd->status);
    156         } while ((status & SR_BSY) != 0);
    157 
    158167        if ((status & SR_DRDY) == 0) {
    159168                printf("None attached.\n");
    160169                return ENOENT;
    161170        }
    162         /***/
    163 
    164         do {
    165                 status = pio_read_8(&cmd->status);
    166         } while ((status & SR_BSY) != 0 || (status & SR_DRDY) == 0);
    167 
    168         pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
    169 
    170         do {
    171                 status = pio_read_8(&cmd->status);
    172         } while ((status & SR_BSY) != 0);
    173 
    174         /* Read data from the disk buffer. */
    175 
    176         if ((status & SR_DRQ) != 0) {
    177 //              for (i = 0; i < block_size / 2; i++) {
    178 //                      data = pio_read_16(&cmd->data_port);
    179 //                      ((uint16_t *) buf)[i] = data;
    180 //              }
    181 
    182                 for (i = 0; i < block_size / 2; i++) {
    183                         data = pio_read_16(&cmd->data_port);
    184 
    185                         switch (i) {
    186                         case 1: d->cylinders = data; break;
    187                         case 3: d->heads = data; break;
    188                         case 6: d->sectors = data; break;
    189                         }
     171
     172        for (i = 0; i < block_size / 2; i++) {
     173                do {
     174                        status = pio_read_8(&cmd->status);
     175                } while ((status & SR_DRDY) == 0);
     176
     177                data = pio_read_16(&cmd->data_port);
     178
     179                switch (i) {
     180                case 1: d->cylinders = data; break;
     181                case 3: d->heads = data; break;
     182                case 6: d->sectors = data; break;
    190183                }
    191184        }
    192 
    193         if ((status & SR_ERR) != 0)
    194                 return EIO;
    195185
    196186        d->blocks = d->cylinders * d->heads * d->sectors;
    … …  
    371361        /* Program a Read Sectors operation. */
    372362
    373         do {
    374                 status = pio_read_8(&cmd->status);
    375         } while ((status & SR_BSY) != 0);
    376 
    377363        pio_write_8(&cmd->drive_head, drv_head);
    378 
    379         do {
    380                 status = pio_read_8(&cmd->status);
    381         } while ((status & SR_BSY) != 0 || (status & SR_DRDY) == 0);
    382 
    383364        pio_write_8(&cmd->sector_count, 1);
    384365        pio_write_8(&cmd->sector_number, s);
    385366        pio_write_8(&cmd->cylinder_low, c & 0xff);
    386367        pio_write_8(&cmd->cylinder_high, c >> 16);
    387 
    388368        pio_write_8(&cmd->command, CMD_READ_SECTORS);
    389369
    390         do {
    391                 status = pio_read_8(&cmd->status);
    392         } while ((status & SR_BSY) != 0);
    393 
    394370        /* Read data from the disk buffer. */
    395371
    396         if ((status & SR_DRQ) != 0) {
    397                 for (i = 0; i < block_size / 2; i++) {
    398                         data = pio_read_16(&cmd->data_port);
    399                         ((uint16_t *) buf)[i] = data;
    400                 }
    401         }
    402 
    403         if ((status & SR_ERR) != 0)
    404                 return EIO;
     372        for (i = 0; i < block_size / 2; i++) {
     373                do {
     374                        status = pio_read_8(&cmd->status);
     375                } while ((status & SR_DRDY) == 0);
     376
     377                data = pio_read_16(&cmd->data_port);
     378                ((uint16_t *) buf)[i] = data;
     379        }
    405380
    406381        fibril_mutex_unlock(&d->lock);
    … …  
    440415        /* Program a Read Sectors operation. */
    441416
    442         do {
    443                 status = pio_read_8(&cmd->status);
    444         } while ((status & SR_BSY) != 0);
    445        
    446417        pio_write_8(&cmd->drive_head, drv_head);
    447 
    448         do {
    449                 status = pio_read_8(&cmd->status);
    450         } while ((status & SR_BSY) != 0 || (status & SR_DRDY) == 0);
    451 
    452418        pio_write_8(&cmd->sector_count, 1);
    453419        pio_write_8(&cmd->sector_number, s);
    454420        pio_write_8(&cmd->cylinder_low, c & 0xff);
    455421        pio_write_8(&cmd->cylinder_high, c >> 16);
    456 
    457422        pio_write_8(&cmd->command, CMD_WRITE_SECTORS);
    458423
    459         do {
    460                 status = pio_read_8(&cmd->status);
    461         } while ((status & SR_BSY) != 0);
    462 
    463424        /* Write data to the disk buffer. */
    464425
    465         if ((status & SR_DRQ) != 0) {
    466                 for (i = 0; i < block_size / 2; i++) {
    467                         pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    468                 }
     426        for (i = 0; i < block_size / 2; i++) {
     427                do {
     428                        status = pio_read_8(&cmd->status);
     429                } while ((status & SR_DRDY) == 0);
     430
     431                pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    469432        }
    470433
    471434        fibril_mutex_unlock(&d->lock);
    472 
    473         if (status & SR_ERR)
    474                 return EIO;
    475 
    476435        return EOK;
    477436}
     437
    478438
    479439/**
Note: See TracChangeset for help on using the changeset viewer.