Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    ra44abb3e r4802dd7  
    104104static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    105105
    106 static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
     106static int ata_bd_open(bd_srv_t *);
    107107static int ata_bd_close(bd_srv_t *);
    108108static int ata_bd_read_blocks(bd_srv_t *, uint64_t ba, size_t cnt, void *buf,
    … …  
    114114static int ata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
    115115
    116 static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t cnt,
     116static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
    117117    void *buf);
    118 static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
     118static int ata_rcmd_write(int disk_id, 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(disk_t *disk, void *buf);
    122 static int identify_pkt_dev(disk_t *disk, void *buf);
    123 static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
     121static int drive_identify(int drive_id, void *buf);
     122static int identify_pkt_dev(int dev_idx, void *buf);
     123static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
    124124    void *obuf, size_t obuf_size);
    125 static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size);
    126 static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
     125static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size);
     126static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
    127127    void *obuf, size_t obuf_size);
    128 static int ata_pcmd_read_toc(disk_t *disk, uint8_t ses,
     128static int ata_pcmd_read_toc(int dev_idx, uint8_t ses,
    129129    void *obuf, size_t obuf_size);
    130130static void disk_print_summary(disk_t *d);
    … …  
    146146static disk_t *bd_srv_disk(bd_srv_t *bd)
    147147{
    148         return (disk_t *)bd->srvs->sarg;
    149 }
    150 
    151 static int disk_dev_idx(disk_t *disk)
    152 {
    153         return (disk->disk_id & 1);
     148        return (disk_t *)bd->arg;
    154149}
    155150
    … …  
    301296{
    302297        service_id_t dsid;
    303         int i;
    304         disk_t *disk;
     298        int disk_id, i;
    305299
    306300        /* Get the device service ID. */
    … …  
    308302
    309303        /* Determine which disk device is the client connecting to. */
    310         disk = NULL;
     304        disk_id = -1;
    311305        for (i = 0; i < MAX_DISKS; i++)
    312306                if (ata_disk[i].service_id == dsid)
    313                         disk = &ata_disk[i];
    314 
    315         if (disk == NULL || disk->present == false) {
     307                        disk_id = i;
     308
     309        if (disk_id < 0 || ata_disk[disk_id].present == false) {
    316310                async_answer_0(iid, EINVAL);
    317311                return;
    318312        }
    319313
    320         bd_conn(iid, icall, &disk->bds);
     314        bd_conn(iid, icall, &ata_disk[disk_id].bd);
    321315}
    322316
    … …  
    342336        fibril_mutex_initialize(&d->lock);
    343337
    344         bd_srvs_init(&d->bds);
    345         d->bds.ops = &ata_bd_ops;
    346         d->bds.sarg = d;
     338        bd_srv_init(&d->bd);
     339        d->bd.ops = &ata_bd_ops;
     340        d->bd.arg = d;
    347341
    348342        /* Try identify command. */
    349         rc = drive_identify(d, &idata);
     343        rc = drive_identify(disk_id, &idata);
    350344        if (rc == EOK) {
    351345                /* Success. It's a register (non-packet) device. */
    … …  
    367361
    368362                if (bc == PDEV_SIGNATURE_BC) {
    369                         rc = identify_pkt_dev(d, &idata);
     363                        rc = identify_pkt_dev(disk_id, &idata);
    370364                        if (rc == EOK) {
    371365                                /* We have a packet device. */
    … …  
    451445        if (d->dev_type == ata_pkt_dev) {
    452446                /* Send inquiry. */
    453                 rc = ata_pcmd_inquiry(d, &inq_data, sizeof(inq_data));
     447                rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
    454448                if (rc != EOK) {
    455449                        printf("Device inquiry failed.\n");
    … …  
    473467}
    474468
    475 static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     469static int ata_bd_open(bd_srv_t *bd)
    476470{
    477471        return EOK;
    … …  
    494488
    495489        while (cnt > 0) {
    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,
     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,
    500494                            disk->block_size);
    501                 }
    502495
    503496                if (rc != EOK)
    … …  
    517510        disk_t *disk = bd_srv_disk(bd);
    518511
    519         return ata_pcmd_read_toc(disk, session, buf, size);
     512        return ata_pcmd_read_toc(disk->disk_id, session, buf, size);
    520513}
    521514
    … …  
    534527
    535528        while (cnt > 0) {
    536                 rc = ata_rcmd_write(disk, ba, 1, buf);
     529                rc = ata_rcmd_write(disk->disk_id, ba, 1, buf);
    537530                if (rc != EOK)
    538531                        return rc;
    … …  
    569562 * whether an ATA device is present and if so, to determine its parameters.
    570563 *
    571  * @param disk          Disk
     564 * @param disk_id       Device ID, 0 or 1.
    572565 * @param buf           Pointer to a 512-byte buffer.
    573566 *
    … …  
    575568 *                      not present). EIO if device responds with error.
    576569 */
    577 static int drive_identify(disk_t *disk, void *buf)
     570static int drive_identify(int disk_id, void *buf)
    578571{
    579572        uint16_t data;
    … …  
    582575        size_t i;
    583576
    584         drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
     577        drv_head = ((disk_id != 0) ? DHR_DRV : 0);
    585578
    586579        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    628621 * whether an ATAPI device is present and if so, to determine its parameters.
    629622 *
    630  * @param disk          Disk
     623 * @param dev_idx       Device index, 0 or 1.
    631624 * @param buf           Pointer to a 512-byte buffer.
    632625 */
    633 static int identify_pkt_dev(disk_t *disk, void *buf)
     626static int identify_pkt_dev(int dev_idx, void *buf)
    634627{
    635628        uint16_t data;
    … …  
    638631        size_t i;
    639632
    640         drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
     633        drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
    641634
    642635        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    673666 * Only data-in commands are supported (e.g. inquiry, read).
    674667 *
    675  * @param disk          Disk
     668 * @param dev_idx       Device index (0 or 1)
    676669 * @param obuf          Buffer for storing data read from device
    677670 * @param obuf_size     Size of obuf in bytes
    … …  
    679672 * @return EOK on success, EIO on error.
    680673 */
    681 static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
     674static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
    682675    void *obuf, size_t obuf_size)
    683676{
    … …  
    685678        uint8_t status;
    686679        uint8_t drv_head;
     680        disk_t *d;
    687681        size_t data_size;
    688682        uint16_t val;
    689683
    690         fibril_mutex_lock(&disk->lock);
     684        d = &ata_disk[dev_idx];
     685        fibril_mutex_lock(&d->lock);
    691686
    692687        /* New value for Drive/Head register */
    693688        drv_head =
    694             ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
     689            ((dev_idx != 0) ? DHR_DRV : 0);
    695690
    696691        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    697                 fibril_mutex_unlock(&disk->lock);
     692                fibril_mutex_unlock(&d->lock);
    698693                return EIO;
    699694        }
    … …  
    702697
    703698        if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    704                 fibril_mutex_unlock(&disk->lock);
     699                fibril_mutex_unlock(&d->lock);
    705700                return EIO;
    706701        }
    … …  
    713708
    714709        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    715                 fibril_mutex_unlock(&disk->lock);
     710                fibril_mutex_unlock(&d->lock);
    716711                return EIO;
    717712        }
    … …  
    722717
    723718        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    724                 fibril_mutex_unlock(&disk->lock);
     719                fibril_mutex_unlock(&d->lock);
    725720                return EIO;
    726721        }
    727722
    728723        if ((status & SR_DRQ) == 0) {
    729                 fibril_mutex_unlock(&disk->lock);
     724                fibril_mutex_unlock(&d->lock);
    730725                return EIO;
    731726        }
    … …  
    738733        if (data_size > obuf_size) {
    739734                /* Output buffer is too small to store data. */
    740                 fibril_mutex_unlock(&disk->lock);
     735                fibril_mutex_unlock(&d->lock);
    741736                return EIO;
    742737        }
    … …  
    749744
    750745        if (status & SR_ERR) {
    751                 fibril_mutex_unlock(&disk->lock);
    752                 return EIO;
    753         }
    754 
    755         fibril_mutex_unlock(&disk->lock);
     746                fibril_mutex_unlock(&d->lock);
     747                return EIO;
     748        }
     749
     750        fibril_mutex_unlock(&d->lock);
    756751
    757752        return EOK;
    … …  
    760755/** Issue ATAPI Inquiry.
    761756 *
    762  * @param disk          Disk
     757 * @param dev_idx       Device index (0 or 1)
    763758 * @param obuf          Buffer for storing inquiry data read from device
    764759 * @param obuf_size     Size of obuf in bytes
    … …  
    766761 * @return EOK on success, EIO on error.
    767762 */
    768 static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size)
     763static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size)
    769764{
    770765        ata_pcmd_inquiry_t cp;
    … …  
    776771        cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    777772
    778         rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
     773        rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
    779774        if (rc != EOK)
    780775                return rc;
    … …  
    788783 * function will fail.
    789784 *
    790  * @param disk          Disk
     785 * @param dev_idx       Device index (0 or 1)
    791786 * @param ba            Starting block address
    792787 * @param cnt           Number of blocks to read
    … …  
    796791 * @return EOK on success, EIO on error.
    797792 */
    798 static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
     793static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
    799794    void *obuf, size_t obuf_size)
    800795{
    … …  
    811806        cp.nblocks = host2uint32_t_be(cnt);
    812807
    813         rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
     808        rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
    814809        if (rc != EOK)
    815810                return rc;
    … …  
    828823 * function will fail.
    829824 *
    830  * @param disk          Disk
     825 * @param dev_idx       Device index (0 or 1)
    831826 * @param session       Starting session
    832827 * @param obuf          Buffer for storing inquiry data read from device
    … …  
    835830 * @return EOK on success, EIO on error.
    836831 */
    837 static int ata_pcmd_read_toc(disk_t *disk, uint8_t session, void *obuf,
     832static int ata_pcmd_read_toc(int dev_idx, uint8_t session, void *obuf,
    838833    size_t obuf_size)
    839834{
    … …  
    859854/** Read a physical from the device.
    860855 *
    861  * @param disk          Disk
     856 * @param disk_id       Device index (0 or 1)
    862857 * @param ba            Address the first block.
    863858 * @param cnt           Number of blocks to transfer.
    … …  
    866861 * @return EOK on success, EIO on error.
    867862 */
    868 static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t blk_cnt,
     863static int ata_rcmd_read(int disk_id, uint64_t ba, size_t blk_cnt,
    869864    void *buf)
    870865{
    … …  
    873868        uint8_t status;
    874869        uint8_t drv_head;
     870        disk_t *d;
    875871        block_coord_t bc;
    876872
     873        d = &ata_disk[disk_id];
     874       
    877875        /* Silence warning. */
    878876        memset(&bc, 0, sizeof(bc));
    879877
    880878        /* Compute block coordinates. */
    881         if (coord_calc(disk, ba, &bc) != EOK)
     879        if (coord_calc(d, ba, &bc) != EOK)
    882880                return EINVAL;
    883881
    884882        /* New value for Drive/Head register */
    885883        drv_head =
    886             ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
    887             ((disk->amode != am_chs) ? DHR_LBA : 0) |
     884            ((disk_id != 0) ? DHR_DRV : 0) |
     885            ((d->amode != am_chs) ? DHR_LBA : 0) |
    888886            (bc.h & 0x0f);
    889887
    890         fibril_mutex_lock(&disk->lock);
     888        fibril_mutex_lock(&d->lock);
    891889
    892890        /* Program a Read Sectors operation. */
    893891
    894892        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    895                 fibril_mutex_unlock(&disk->lock);
     893                fibril_mutex_unlock(&d->lock);
    896894                return EIO;
    897895        }
    … …  
    900898
    901899        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    902                 fibril_mutex_unlock(&disk->lock);
     900                fibril_mutex_unlock(&d->lock);
    903901                return EIO;
    904902        }
    … …  
    907905        coord_sc_program(&bc, 1);
    908906
    909         pio_write_8(&cmd->command, disk->amode == am_lba48 ?
     907        pio_write_8(&cmd->command, d->amode == am_lba48 ?
    910908            CMD_READ_SECTORS_EXT : CMD_READ_SECTORS);
    911909
    912910        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    913                 fibril_mutex_unlock(&disk->lock);
     911                fibril_mutex_unlock(&d->lock);
    914912                return EIO;
    915913        }
    … …  
    918916                /* Read data from the device buffer. */
    919917
    920                 for (i = 0; i < disk->block_size / 2; i++) {
     918                for (i = 0; i < ata_disk[disk_id].block_size / 2; i++) {
    921919                        data = pio_read_16(&cmd->data_port);
    922920                        ((uint16_t *) buf)[i] = data;
    … …  
    927925                return EIO;
    928926
    929         fibril_mutex_unlock(&disk->lock);
     927        fibril_mutex_unlock(&d->lock);
    930928        return EOK;
    931929}
    … …  
    933931/** Write a physical block to the device.
    934932 *
    935  * @param disk          Disk
     933 * @param disk_id       Device index (0 or 1)
    936934 * @param ba            Address of the first block.
    937935 * @param cnt           Number of blocks to transfer.
    … …  
    940938 * @return EOK on success, EIO on error.
    941939 */
    942 static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
     940static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
    943941    const void *buf)
    944942{
    … …  
    946944        uint8_t status;
    947945        uint8_t drv_head;
     946        disk_t *d;
    948947        block_coord_t bc;
    949948
     949        d = &ata_disk[disk_id];
     950       
    950951        /* Silence warning. */
    951952        memset(&bc, 0, sizeof(bc));
    952953
    953954        /* Compute block coordinates. */
    954         if (coord_calc(disk, ba, &bc) != EOK)
     955        if (coord_calc(d, ba, &bc) != EOK)
    955956                return EINVAL;
    956957
    957958        /* New value for Drive/Head register */
    958959        drv_head =
    959             ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
    960             ((disk->amode != am_chs) ? DHR_LBA : 0) |
     960            ((disk_id != 0) ? DHR_DRV : 0) |
     961            ((d->amode != am_chs) ? DHR_LBA : 0) |
    961962            (bc.h & 0x0f);
    962963
    963         fibril_mutex_lock(&disk->lock);
     964        fibril_mutex_lock(&d->lock);
    964965
    965966        /* Program a Write Sectors operation. */
    966967
    967968        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    968                 fibril_mutex_unlock(&disk->lock);
     969                fibril_mutex_unlock(&d->lock);
    969970                return EIO;
    970971        }
    … …  
    973974
    974975        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    975                 fibril_mutex_unlock(&disk->lock);
     976                fibril_mutex_unlock(&d->lock);
    976977                return EIO;
    977978        }
    … …  
    980981        coord_sc_program(&bc, 1);
    981982
    982         pio_write_8(&cmd->command, disk->amode == am_lba48 ?
     983        pio_write_8(&cmd->command, d->amode == am_lba48 ?
    983984            CMD_WRITE_SECTORS_EXT : CMD_WRITE_SECTORS);
    984985
    985986        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    986                 fibril_mutex_unlock(&disk->lock);
     987                fibril_mutex_unlock(&d->lock);
    987988                return EIO;
    988989        }
    … …  
    991992                /* Write data to the device buffer. */
    992993
    993                 for (i = 0; i < disk->block_size / 2; i++) {
     994                for (i = 0; i < d->block_size / 2; i++) {
    994995                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    995996                }
    996997        }
    997998
    998         fibril_mutex_unlock(&disk->lock);
     999        fibril_mutex_unlock(&d->lock);
    9991000
    10001001        if (status & SR_ERR)
Note: See TracChangeset for help on using the changeset viewer.