Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset a44abb3e in mainline


Ignore:
Timestamp:
2012-08-15T22:42:02Z (9 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
b8b742e
Parents:
c5a6076
Message:

Favor disk_t pointer over disk_id in ata_bd.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/bd/ata_bd/ata_bd.c

    rc5a6076 ra44abb3e  
    114114static int ata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
    115115
    116 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
     116static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t cnt,
    117117    void *buf);
    118 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     118static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
    119119    const void *buf);
    120120static int disk_init(disk_t *d, int disk_id);
    121 static int drive_identify(int drive_id, void *buf);
    122 static int identify_pkt_dev(int dev_idx, void *buf);
    123 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
     121static int drive_identify(disk_t *disk, void *buf);
     122static int identify_pkt_dev(disk_t *disk, void *buf);
     123static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
    124124    void *obuf, size_t obuf_size);
    125 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size);
    126 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
     125static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size);
     126static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
    127127    void *obuf, size_t obuf_size);
    128 static int ata_pcmd_read_toc(int dev_idx, uint8_t ses,
     128static int ata_pcmd_read_toc(disk_t *disk, uint8_t ses,
    129129    void *obuf, size_t obuf_size);
    130130static void disk_print_summary(disk_t *d);
     
    147147{
    148148        return (disk_t *)bd->srvs->sarg;
     149}
     150
     151static int disk_dev_idx(disk_t *disk)
     152{
     153        return (disk->disk_id & 1);
    149154}
    150155
     
    296301{
    297302        service_id_t dsid;
    298         int disk_id, i;
     303        int i;
     304        disk_t *disk;
    299305
    300306        /* Get the device service ID. */
     
    302308
    303309        /* Determine which disk device is the client connecting to. */
    304         disk_id = -1;
     310        disk = NULL;
    305311        for (i = 0; i < MAX_DISKS; i++)
    306312                if (ata_disk[i].service_id == dsid)
    307                         disk_id = i;
    308 
    309         if (disk_id < 0 || ata_disk[disk_id].present == false) {
     313                        disk = &ata_disk[i];
     314
     315        if (disk == NULL || disk->present == false) {
    310316                async_answer_0(iid, EINVAL);
    311317                return;
    312318        }
    313319
    314         bd_conn(iid, icall, &ata_disk[disk_id].bds);
     320        bd_conn(iid, icall, &disk->bds);
    315321}
    316322
     
    341347
    342348        /* Try identify command. */
    343         rc = drive_identify(disk_id, &idata);
     349        rc = drive_identify(d, &idata);
    344350        if (rc == EOK) {
    345351                /* Success. It's a register (non-packet) device. */
     
    361367
    362368                if (bc == PDEV_SIGNATURE_BC) {
    363                         rc = identify_pkt_dev(disk_id, &idata);
     369                        rc = identify_pkt_dev(d, &idata);
    364370                        if (rc == EOK) {
    365371                                /* We have a packet device. */
     
    445451        if (d->dev_type == ata_pkt_dev) {
    446452                /* Send inquiry. */
    447                 rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
     453                rc = ata_pcmd_inquiry(d, &inq_data, sizeof(inq_data));
    448454                if (rc != EOK) {
    449455                        printf("Device inquiry failed.\n");
     
    488494
    489495        while (cnt > 0) {
    490                 if (disk->dev_type == ata_reg_dev)
    491                         rc = ata_rcmd_read(disk->disk_id, ba, 1, buf);
    492                 else
    493                         rc = ata_pcmd_read_12(disk->disk_id, ba, 1, buf,
     496                if (disk->dev_type == ata_reg_dev) {
     497                        rc = ata_rcmd_read(disk, ba, 1, buf);
     498                } else {
     499                        rc = ata_pcmd_read_12(disk, ba, 1, buf,
    494500                            disk->block_size);
     501                }
    495502
    496503                if (rc != EOK)
     
    510517        disk_t *disk = bd_srv_disk(bd);
    511518
    512         return ata_pcmd_read_toc(disk->disk_id, session, buf, size);
     519        return ata_pcmd_read_toc(disk, session, buf, size);
    513520}
    514521
     
    527534
    528535        while (cnt > 0) {
    529                 rc = ata_rcmd_write(disk->disk_id, ba, 1, buf);
     536                rc = ata_rcmd_write(disk, ba, 1, buf);
    530537                if (rc != EOK)
    531538                        return rc;
     
    562569 * whether an ATA device is present and if so, to determine its parameters.
    563570 *
    564  * @param disk_id       Device ID, 0 or 1.
     571 * @param disk          Disk
    565572 * @param buf           Pointer to a 512-byte buffer.
    566573 *
     
    568575 *                      not present). EIO if device responds with error.
    569576 */
    570 static int drive_identify(int disk_id, void *buf)
     577static int drive_identify(disk_t *disk, void *buf)
    571578{
    572579        uint16_t data;
     
    575582        size_t i;
    576583
    577         drv_head = ((disk_id != 0) ? DHR_DRV : 0);
     584        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    578585
    579586        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
     
    621628 * whether an ATAPI device is present and if so, to determine its parameters.
    622629 *
    623  * @param dev_idx       Device index, 0 or 1.
     630 * @param disk          Disk
    624631 * @param buf           Pointer to a 512-byte buffer.
    625632 */
    626 static int identify_pkt_dev(int dev_idx, void *buf)
     633static int identify_pkt_dev(disk_t *disk, void *buf)
    627634{
    628635        uint16_t data;
     
    631638        size_t i;
    632639
    633         drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
     640        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    634641
    635642        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
     
    666673 * Only data-in commands are supported (e.g. inquiry, read).
    667674 *
    668  * @param dev_idx       Device index (0 or 1)
     675 * @param disk          Disk
    669676 * @param obuf          Buffer for storing data read from device
    670677 * @param obuf_size     Size of obuf in bytes
     
    672679 * @return EOK on success, EIO on error.
    673680 */
    674 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
     681static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
    675682    void *obuf, size_t obuf_size)
    676683{
     
    678685        uint8_t status;
    679686        uint8_t drv_head;
    680         disk_t *d;
    681687        size_t data_size;
    682688        uint16_t val;
    683689
    684         d = &ata_disk[dev_idx];
    685         fibril_mutex_lock(&d->lock);
     690        fibril_mutex_lock(&disk->lock);
    686691
    687692        /* New value for Drive/Head register */
    688693        drv_head =
    689             ((dev_idx != 0) ? DHR_DRV : 0);
     694            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    690695
    691696        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    692                 fibril_mutex_unlock(&d->lock);
     697                fibril_mutex_unlock(&disk->lock);
    693698                return EIO;
    694699        }
     
    697702
    698703        if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    699                 fibril_mutex_unlock(&d->lock);
     704                fibril_mutex_unlock(&disk->lock);
    700705                return EIO;
    701706        }
     
    708713
    709714        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    710                 fibril_mutex_unlock(&d->lock);
     715                fibril_mutex_unlock(&disk->lock);
    711716                return EIO;
    712717        }
     
    717722
    718723        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    719                 fibril_mutex_unlock(&d->lock);
     724                fibril_mutex_unlock(&disk->lock);
    720725                return EIO;
    721726        }
    722727
    723728        if ((status & SR_DRQ) == 0) {
    724                 fibril_mutex_unlock(&d->lock);
     729                fibril_mutex_unlock(&disk->lock);
    725730                return EIO;
    726731        }
     
    733738        if (data_size > obuf_size) {
    734739                /* Output buffer is too small to store data. */
    735                 fibril_mutex_unlock(&d->lock);
     740                fibril_mutex_unlock(&disk->lock);
    736741                return EIO;
    737742        }
     
    744749
    745750        if (status & SR_ERR) {
    746                 fibril_mutex_unlock(&d->lock);
    747                 return EIO;
    748         }
    749 
    750         fibril_mutex_unlock(&d->lock);
     751                fibril_mutex_unlock(&disk->lock);
     752                return EIO;
     753        }
     754
     755        fibril_mutex_unlock(&disk->lock);
    751756
    752757        return EOK;
     
    755760/** Issue ATAPI Inquiry.
    756761 *
    757  * @param dev_idx       Device index (0 or 1)
     762 * @param disk          Disk
    758763 * @param obuf          Buffer for storing inquiry data read from device
    759764 * @param obuf_size     Size of obuf in bytes
     
    761766 * @return EOK on success, EIO on error.
    762767 */
    763 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size)
     768static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size)
    764769{
    765770        ata_pcmd_inquiry_t cp;
     
    771776        cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    772777
    773         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     778        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    774779        if (rc != EOK)
    775780                return rc;
     
    783788 * function will fail.
    784789 *
    785  * @param dev_idx       Device index (0 or 1)
     790 * @param disk          Disk
    786791 * @param ba            Starting block address
    787792 * @param cnt           Number of blocks to read
     
    791796 * @return EOK on success, EIO on error.
    792797 */
    793 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
     798static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
    794799    void *obuf, size_t obuf_size)
    795800{
     
    806811        cp.nblocks = host2uint32_t_be(cnt);
    807812
    808         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     813        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    809814        if (rc != EOK)
    810815                return rc;
     
    823828 * function will fail.
    824829 *
    825  * @param dev_idx       Device index (0 or 1)
     830 * @param disk          Disk
    826831 * @param session       Starting session
    827832 * @param obuf          Buffer for storing inquiry data read from device
     
    830835 * @return EOK on success, EIO on error.
    831836 */
    832 static int ata_pcmd_read_toc(int dev_idx, uint8_t session, void *obuf,
     837static int ata_pcmd_read_toc(disk_t *disk, uint8_t session, void *obuf,
    833838    size_t obuf_size)
    834839{
     
    854859/** Read a physical from the device.
    855860 *
    856  * @param disk_id       Device index (0 or 1)
     861 * @param disk          Disk
    857862 * @param ba            Address the first block.
    858863 * @param cnt           Number of blocks to transfer.
     
    861866 * @return EOK on success, EIO on error.
    862867 */
    863 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t blk_cnt,
     868static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t blk_cnt,
    864869    void *buf)
    865870{
     
    868873        uint8_t status;
    869874        uint8_t drv_head;
    870         disk_t *d;
    871875        block_coord_t bc;
    872876
    873         d = &ata_disk[disk_id];
    874        
    875877        /* Silence warning. */
    876878        memset(&bc, 0, sizeof(bc));
    877879
    878880        /* Compute block coordinates. */
    879         if (coord_calc(d, ba, &bc) != EOK)
     881        if (coord_calc(disk, ba, &bc) != EOK)
    880882                return EINVAL;
    881883
    882884        /* New value for Drive/Head register */
    883885        drv_head =
    884             ((disk_id != 0) ? DHR_DRV : 0) |
    885             ((d->amode != am_chs) ? DHR_LBA : 0) |
     886            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     887            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    886888            (bc.h & 0x0f);
    887889
    888         fibril_mutex_lock(&d->lock);
     890        fibril_mutex_lock(&disk->lock);
    889891
    890892        /* Program a Read Sectors operation. */
    891893
    892894        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    893                 fibril_mutex_unlock(&d->lock);
     895                fibril_mutex_unlock(&disk->lock);
    894896                return EIO;
    895897        }
     
    898900
    899901        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    900                 fibril_mutex_unlock(&d->lock);
     902                fibril_mutex_unlock(&disk->lock);
    901903                return EIO;
    902904        }
     
    905907        coord_sc_program(&bc, 1);
    906908
    907         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     909        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    908910            CMD_READ_SECTORS_EXT : CMD_READ_SECTORS);
    909911
    910912        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    911                 fibril_mutex_unlock(&d->lock);
     913                fibril_mutex_unlock(&disk->lock);
    912914                return EIO;
    913915        }
     
    916918                /* Read data from the device buffer. */
    917919
    918                 for (i = 0; i < ata_disk[disk_id].block_size / 2; i++) {
     920                for (i = 0; i < disk->block_size / 2; i++) {
    919921                        data = pio_read_16(&cmd->data_port);
    920922                        ((uint16_t *) buf)[i] = data;
     
    925927                return EIO;
    926928
    927         fibril_mutex_unlock(&d->lock);
     929        fibril_mutex_unlock(&disk->lock);
    928930        return EOK;
    929931}
     
    931933/** Write a physical block to the device.
    932934 *
    933  * @param disk_id       Device index (0 or 1)
     935 * @param disk          Disk
    934936 * @param ba            Address of the first block.
    935937 * @param cnt           Number of blocks to transfer.
     
    938940 * @return EOK on success, EIO on error.
    939941 */
    940 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     942static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
    941943    const void *buf)
    942944{
     
    944946        uint8_t status;
    945947        uint8_t drv_head;
    946         disk_t *d;
    947948        block_coord_t bc;
    948949
    949         d = &ata_disk[disk_id];
    950        
    951950        /* Silence warning. */
    952951        memset(&bc, 0, sizeof(bc));
    953952
    954953        /* Compute block coordinates. */
    955         if (coord_calc(d, ba, &bc) != EOK)
     954        if (coord_calc(disk, ba, &bc) != EOK)
    956955                return EINVAL;
    957956
    958957        /* New value for Drive/Head register */
    959958        drv_head =
    960             ((disk_id != 0) ? DHR_DRV : 0) |
    961             ((d->amode != am_chs) ? DHR_LBA : 0) |
     959            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     960            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    962961            (bc.h & 0x0f);
    963962
    964         fibril_mutex_lock(&d->lock);
     963        fibril_mutex_lock(&disk->lock);
    965964
    966965        /* Program a Write Sectors operation. */
    967966
    968967        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    969                 fibril_mutex_unlock(&d->lock);
     968                fibril_mutex_unlock(&disk->lock);
    970969                return EIO;
    971970        }
     
    974973
    975974        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    976                 fibril_mutex_unlock(&d->lock);
     975                fibril_mutex_unlock(&disk->lock);
    977976                return EIO;
    978977        }
     
    981980        coord_sc_program(&bc, 1);
    982981
    983         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     982        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    984983            CMD_WRITE_SECTORS_EXT : CMD_WRITE_SECTORS);
    985984
    986985        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    987                 fibril_mutex_unlock(&d->lock);
     986                fibril_mutex_unlock(&disk->lock);
    988987                return EIO;
    989988        }
     
    992991                /* Write data to the device buffer. */
    993992
    994                 for (i = 0; i < d->block_size / 2; i++) {
     993                for (i = 0; i < disk->block_size / 2; i++) {
    995994                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    996995                }
    997996        }
    998997
    999         fibril_mutex_unlock(&d->lock);
     998        fibril_mutex_unlock(&disk->lock);
    1000999
    10011000        if (status & SR_ERR)
Note: See TracChangeset for help on using the changeset viewer.