Changeset 7cfe5c0 in mainline for uspace/srv/bd/ata_bd/ata_bd.c


Ignore:
Timestamp:
2012-08-20T19:16:24Z (13 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6b99156
Parents:
b9cb911 (diff), 01e397ac (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merged with mainline 0.5.0 changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb9cb911 r7cfe5c0  
    5151#include <libarch/ddi.h>
    5252#include <ddi.h>
    53 #include <ipc/bd.h>
    5453#include <async.h>
    5554#include <as.h>
     55#include <bd_srv.h>
    5656#include <fibril_synch.h>
    5757#include <stdint.h>
    … …  
    9898
    9999/** Per-disk state. */
    100 static disk_t disk[MAX_DISKS];
     100static disk_t ata_disk[MAX_DISKS];
    101101
    102102static void print_syntax(void);
    103103static int ata_bd_init(void);
    104104static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    105 static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt,
     105
     106static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
     107static int ata_bd_close(bd_srv_t *);
     108static int ata_bd_read_blocks(bd_srv_t *, uint64_t ba, size_t cnt, void *buf,
     109    size_t);
     110static int ata_bd_read_toc(bd_srv_t *, uint8_t session, void *buf, size_t);
     111static int ata_bd_write_blocks(bd_srv_t *, uint64_t ba, size_t cnt,
     112    const void *buf, size_t);
     113static int ata_bd_get_block_size(bd_srv_t *, size_t *);
     114static int ata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
     115
     116static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t cnt,
    106117    void *buf);
    107 static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
    108     const void *buf);
    109 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
    110     void *buf);
    111 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,
    112119    const void *buf);
    113120static int disk_init(disk_t *d, int disk_id);
    114 static int drive_identify(int drive_id, void *buf);
    115 static int identify_pkt_dev(int dev_idx, void *buf);
    116 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,
    117124    void *obuf, size_t obuf_size);
    118 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size);
    119 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,
    120127    void *obuf, size_t obuf_size);
    121 static int ata_pcmd_read_toc(int dev_idx, uint8_t ses,
     128static int ata_pcmd_read_toc(disk_t *disk, uint8_t ses,
    122129    void *obuf, size_t obuf_size);
    123130static void disk_print_summary(disk_t *d);
    … …  
    126133static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
    127134    unsigned timeout);
     135
     136static bd_ops_t ata_bd_ops = {
     137        .open = ata_bd_open,
     138        .close = ata_bd_close,
     139        .read_blocks = ata_bd_read_blocks,
     140        .read_toc = ata_bd_read_toc,
     141        .write_blocks = ata_bd_write_blocks,
     142        .get_block_size = ata_bd_get_block_size,
     143        .get_num_blocks = ata_bd_get_num_blocks
     144};
     145
     146static disk_t *bd_srv_disk(bd_srv_t *bd)
     147{
     148        return (disk_t *)bd->srvs->sarg;
     149}
     150
     151static int disk_dev_idx(disk_t *disk)
     152{
     153        return (disk->disk_id & 1);
     154}
    128155
    129156int main(int argc, char **argv)
    … …  
    161188                fflush(stdout);
    162189
    163                 rc = disk_init(&disk[i], i);
     190                rc = disk_init(&ata_disk[i], i);
    164191
    165192                if (rc == EOK) {
    166                         disk_print_summary(&disk[i]);
     193                        disk_print_summary(&ata_disk[i]);
    167194                } else {
    168195                        printf("Not found.\n");
    … …  
    174201        for (i = 0; i < MAX_DISKS; i++) {
    175202                /* Skip unattached drives. */
    176                 if (disk[i].present == false)
     203                if (ata_disk[i].present == false)
    177204                        continue;
    178205               
    179206                snprintf(name, 16, "%s/ata%udisk%d", NAMESPACE, ctl_num, i);
    180                 rc = loc_service_register(name, &disk[i].service_id);
     207                rc = loc_service_register(name, &ata_disk[i].service_id);
    181208                if (rc != EOK) {
    182209                        printf(NAME ": Unable to register device %s.\n", name);
    … …  
    217244                case am_chs:
    218245                        printf("CHS %u cylinders, %u heads, %u sectors",
    219                             disk->geom.cylinders, disk->geom.heads,
    220                             disk->geom.sectors);
     246                            d->geom.cylinders, d->geom.heads,
     247                            d->geom.sectors);
    221248                        break;
    222249                case am_lba28:
    … …  
    273300static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    274301{
    275         void *fs_va = NULL;
    276         ipc_callid_t callid;
    277         ipc_call_t call;
    278         sysarg_t method;
    279302        service_id_t dsid;
    280         size_t comm_size;       /**< Size of the communication area. */
    281         unsigned int flags;
    282         int retval;
    283         uint64_t ba;
    284         size_t cnt;
    285         int disk_id, i;
     303        int i;
     304        disk_t *disk;
    286305
    287306        /* Get the device service ID. */
    … …  
    289308
    290309        /* Determine which disk device is the client connecting to. */
    291         disk_id = -1;
     310        disk = NULL;
    292311        for (i = 0; i < MAX_DISKS; i++)
    293                 if (disk[i].service_id == dsid)
    294                         disk_id = i;
    295 
    296         if (disk_id < 0 || disk[disk_id].present == false) {
     312                if (ata_disk[i].service_id == dsid)
     313                        disk = &ata_disk[i];
     314
     315        if (disk == NULL || disk->present == false) {
    297316                async_answer_0(iid, EINVAL);
    298317                return;
    299318        }
    300319
    301         /* Answer the IPC_M_CONNECT_ME_TO call. */
    302         async_answer_0(iid, EOK);
    303 
    304         if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    305                 async_answer_0(callid, EHANGUP);
    306                 return;
    307         }
    308 
    309         (void) async_share_out_finalize(callid, &fs_va);
    310         if (fs_va == AS_MAP_FAILED) {
    311                 async_answer_0(callid, EHANGUP);
    312                 return;
    313         }
    314 
    315         while (true) {
    316                 callid = async_get_call(&call);
    317                 method = IPC_GET_IMETHOD(call);
    318                
    319                 if (!method) {
    320                         /* The other side has hung up. */
    321                         async_answer_0(callid, EOK);
    322                         return;
    323                 }
    324                
    325                 switch (method) {
    326                 case BD_READ_BLOCKS:
    327                         ba = MERGE_LOUP32(IPC_GET_ARG1(call),
    328                             IPC_GET_ARG2(call));
    329                         cnt = IPC_GET_ARG3(call);
    330                         if (cnt * disk[disk_id].block_size > comm_size) {
    331                                 retval = ELIMIT;
    332                                 break;
    333                         }
    334                         retval = ata_bd_read_blocks(disk_id, ba, cnt, fs_va);
    335                         break;
    336                 case BD_WRITE_BLOCKS:
    337                         ba = MERGE_LOUP32(IPC_GET_ARG1(call),
    338                             IPC_GET_ARG2(call));
    339                         cnt = IPC_GET_ARG3(call);
    340                         if (cnt * disk[disk_id].block_size > comm_size) {
    341                                 retval = ELIMIT;
    342                                 break;
    343                         }
    344                         retval = ata_bd_write_blocks(disk_id, ba, cnt, fs_va);
    345                         break;
    346                 case BD_GET_BLOCK_SIZE:
    347                         async_answer_1(callid, EOK, disk[disk_id].block_size);
    348                         continue;
    349                 case BD_GET_NUM_BLOCKS:
    350                         async_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
    351                             UPPER32(disk[disk_id].blocks));
    352                         continue;
    353                 case BD_READ_TOC:
    354                         cnt = IPC_GET_ARG1(call);
    355                         if (disk[disk_id].dev_type == ata_pkt_dev)
    356                                 retval = ata_pcmd_read_toc(disk_id, cnt, fs_va,
    357                                     disk[disk_id].block_size);
    358                         else
    359                                 retval = EINVAL;
    360                         break;
    361                 default:
    362                         retval = EINVAL;
    363                         break;
    364                 }
    365                 async_answer_0(callid, retval);
    366         }
     320        bd_conn(iid, icall, &disk->bds);
    367321}
    368322
    … …  
    384338        unsigned i;
    385339
     340        d->disk_id = disk_id;
    386341        d->present = false;
    387342        fibril_mutex_initialize(&d->lock);
    388343
     344        bd_srvs_init(&d->bds);
     345        d->bds.ops = &ata_bd_ops;
     346        d->bds.sarg = d;
     347
    389348        /* Try identify command. */
    390         rc = drive_identify(disk_id, &idata);
     349        rc = drive_identify(d, &idata);
    391350        if (rc == EOK) {
    392351                /* Success. It's a register (non-packet) device. */
    … …  
    408367
    409368                if (bc == PDEV_SIGNATURE_BC) {
    410                         rc = identify_pkt_dev(disk_id, &idata);
     369                        rc = identify_pkt_dev(d, &idata);
    411370                        if (rc == EOK) {
    412371                                /* We have a packet device. */
    … …  
    492451        if (d->dev_type == ata_pkt_dev) {
    493452                /* Send inquiry. */
    494                 rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
     453                rc = ata_pcmd_inquiry(d, &inq_data, sizeof(inq_data));
    495454                if (rc != EOK) {
    496455                        printf("Device inquiry failed.\n");
    … …  
    514473}
    515474
     475static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     476{
     477        return EOK;
     478}
     479
     480static int ata_bd_close(bd_srv_t *bd)
     481{
     482        return EOK;
     483}
     484
    516485/** Read multiple blocks from the device. */
    517 static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt,
    518     void *buf) {
    519 
     486static int ata_bd_read_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
     487    void *buf, size_t size)
     488{
     489        disk_t *disk = bd_srv_disk(bd);
    520490        int rc;
    521491
     492        if (size < cnt * disk->block_size)
     493                return EINVAL;
     494
    522495        while (cnt > 0) {
    523                 if (disk[disk_id].dev_type == ata_reg_dev)
    524                         rc = ata_rcmd_read(disk_id, ba, 1, buf);
    525                 else
    526                         rc = ata_pcmd_read_12(disk_id, ba, 1, buf,
    527                             disk[disk_id].block_size);
     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,
     500                            disk->block_size);
     501                }
    528502
    529503                if (rc != EOK)
    … …  
    532506                ++ba;
    533507                --cnt;
    534                 buf += disk[disk_id].block_size;
    535         }
    536 
    537         return EOK;
     508                buf += disk->block_size;
     509        }
     510
     511        return EOK;
     512}
     513
     514/** Read TOC from device. */
     515static int ata_bd_read_toc(bd_srv_t *bd, uint8_t session, void *buf, size_t size)
     516{
     517        disk_t *disk = bd_srv_disk(bd);
     518
     519        return ata_pcmd_read_toc(disk, session, buf, size);
    538520}
    539521
    540522/** Write multiple blocks to the device. */
    541 static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
    542     const void *buf) {
    543 
     523static int ata_bd_write_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
     524    const void *buf, size_t size)
     525{
     526        disk_t *disk = bd_srv_disk(bd);
    544527        int rc;
    545528
    546         if (disk[disk_id].dev_type != ata_reg_dev)
     529        if (disk->dev_type != ata_reg_dev)
    547530                return ENOTSUP;
    548531
     532        if (size < cnt * disk->block_size)
     533                return EINVAL;
     534
    549535        while (cnt > 0) {
    550                 rc = ata_rcmd_write(disk_id, ba, 1, buf);
     536                rc = ata_rcmd_write(disk, ba, 1, buf);
    551537                if (rc != EOK)
    552538                        return rc;
    … …  
    554540                ++ba;
    555541                --cnt;
    556                 buf += disk[disk_id].block_size;
    557         }
    558 
     542                buf += disk->block_size;
     543        }
     544
     545        return EOK;
     546}
     547
     548/** Get device block size. */
     549static int ata_bd_get_block_size(bd_srv_t *bd, size_t *rbsize)
     550{
     551        disk_t *disk = bd_srv_disk(bd);
     552
     553        *rbsize = disk->block_size;
     554        return EOK;
     555}
     556
     557/** Get device number of blocks. */
     558static int ata_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
     559{
     560        disk_t *disk = bd_srv_disk(bd);
     561
     562        *rnb = disk->blocks;
    559563        return EOK;
    560564}
    … …  
    565569 * whether an ATA device is present and if so, to determine its parameters.
    566570 *
    567  * @param disk_id       Device ID, 0 or 1.
     571 * @param disk          Disk
    568572 * @param buf           Pointer to a 512-byte buffer.
    569573 *
    … …  
    571575 *                      not present). EIO if device responds with error.
    572576 */
    573 static int drive_identify(int disk_id, void *buf)
     577static int drive_identify(disk_t *disk, void *buf)
    574578{
    575579        uint16_t data;
    … …  
    578582        size_t i;
    579583
    580         drv_head = ((disk_id != 0) ? DHR_DRV : 0);
     584        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    581585
    582586        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    624628 * whether an ATAPI device is present and if so, to determine its parameters.
    625629 *
    626  * @param dev_idx       Device index, 0 or 1.
     630 * @param disk          Disk
    627631 * @param buf           Pointer to a 512-byte buffer.
    628632 */
    629 static int identify_pkt_dev(int dev_idx, void *buf)
     633static int identify_pkt_dev(disk_t *disk, void *buf)
    630634{
    631635        uint16_t data;
    … …  
    634638        size_t i;
    635639
    636         drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
     640        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    637641
    638642        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    669673 * Only data-in commands are supported (e.g. inquiry, read).
    670674 *
    671  * @param dev_idx       Device index (0 or 1)
     675 * @param disk          Disk
    672676 * @param obuf          Buffer for storing data read from device
    673677 * @param obuf_size     Size of obuf in bytes
    … …  
    675679 * @return EOK on success, EIO on error.
    676680 */
    677 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,
    678682    void *obuf, size_t obuf_size)
    679683{
    … …  
    681685        uint8_t status;
    682686        uint8_t drv_head;
    683         disk_t *d;
    684687        size_t data_size;
    685688        uint16_t val;
    686689
    687         d = &disk[dev_idx];
    688         fibril_mutex_lock(&d->lock);
     690        fibril_mutex_lock(&disk->lock);
    689691
    690692        /* New value for Drive/Head register */
    691693        drv_head =
    692             ((dev_idx != 0) ? DHR_DRV : 0);
     694            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    693695
    694696        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    695                 fibril_mutex_unlock(&d->lock);
     697                fibril_mutex_unlock(&disk->lock);
    696698                return EIO;
    697699        }
    … …  
    700702
    701703        if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    702                 fibril_mutex_unlock(&d->lock);
     704                fibril_mutex_unlock(&disk->lock);
    703705                return EIO;
    704706        }
    … …  
    711713
    712714        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    713                 fibril_mutex_unlock(&d->lock);
     715                fibril_mutex_unlock(&disk->lock);
    714716                return EIO;
    715717        }
    … …  
    720722
    721723        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    722                 fibril_mutex_unlock(&d->lock);
     724                fibril_mutex_unlock(&disk->lock);
    723725                return EIO;
    724726        }
    725727
    726728        if ((status & SR_DRQ) == 0) {
    727                 fibril_mutex_unlock(&d->lock);
     729                fibril_mutex_unlock(&disk->lock);
    728730                return EIO;
    729731        }
    … …  
    736738        if (data_size > obuf_size) {
    737739                /* Output buffer is too small to store data. */
    738                 fibril_mutex_unlock(&d->lock);
     740                fibril_mutex_unlock(&disk->lock);
    739741                return EIO;
    740742        }
    … …  
    747749
    748750        if (status & SR_ERR) {
    749                 fibril_mutex_unlock(&d->lock);
    750                 return EIO;
    751         }
    752 
    753         fibril_mutex_unlock(&d->lock);
     751                fibril_mutex_unlock(&disk->lock);
     752                return EIO;
     753        }
     754
     755        fibril_mutex_unlock(&disk->lock);
    754756
    755757        return EOK;
    … …  
    758760/** Issue ATAPI Inquiry.
    759761 *
    760  * @param dev_idx       Device index (0 or 1)
     762 * @param disk          Disk
    761763 * @param obuf          Buffer for storing inquiry data read from device
    762764 * @param obuf_size     Size of obuf in bytes
    … …  
    764766 * @return EOK on success, EIO on error.
    765767 */
    766 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)
    767769{
    768770        ata_pcmd_inquiry_t cp;
    … …  
    774776        cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    775777
    776         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     778        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    777779        if (rc != EOK)
    778780                return rc;
    … …  
    786788 * function will fail.
    787789 *
    788  * @param dev_idx       Device index (0 or 1)
     790 * @param disk          Disk
    789791 * @param ba            Starting block address
    790792 * @param cnt           Number of blocks to read
    … …  
    794796 * @return EOK on success, EIO on error.
    795797 */
    796 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,
    797799    void *obuf, size_t obuf_size)
    798800{
    … …  
    809811        cp.nblocks = host2uint32_t_be(cnt);
    810812
    811         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     813        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    812814        if (rc != EOK)
    813815                return rc;
    … …  
    826828 * function will fail.
    827829 *
    828  * @param dev_idx       Device index (0 or 1)
     830 * @param disk          Disk
    829831 * @param session       Starting session
    830832 * @param obuf          Buffer for storing inquiry data read from device
    … …  
    833835 * @return EOK on success, EIO on error.
    834836 */
    835 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,
    836838    size_t obuf_size)
    837839{
    … …  
    857859/** Read a physical from the device.
    858860 *
    859  * @param disk_id       Device index (0 or 1)
     861 * @param disk          Disk
    860862 * @param ba            Address the first block.
    861863 * @param cnt           Number of blocks to transfer.
    … …  
    864866 * @return EOK on success, EIO on error.
    865867 */
    866 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,
    867869    void *buf)
    868870{
    … …  
    871873        uint8_t status;
    872874        uint8_t drv_head;
    873         disk_t *d;
    874875        block_coord_t bc;
    875876
    876         d = &disk[disk_id];
    877        
    878877        /* Silence warning. */
    879878        memset(&bc, 0, sizeof(bc));
    880879
    881880        /* Compute block coordinates. */
    882         if (coord_calc(d, ba, &bc) != EOK)
     881        if (coord_calc(disk, ba, &bc) != EOK)
    883882                return EINVAL;
    884883
    885884        /* New value for Drive/Head register */
    886885        drv_head =
    887             ((disk_id != 0) ? DHR_DRV : 0) |
    888             ((d->amode != am_chs) ? DHR_LBA : 0) |
     886            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     887            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    889888            (bc.h & 0x0f);
    890889
    891         fibril_mutex_lock(&d->lock);
     890        fibril_mutex_lock(&disk->lock);
    892891
    893892        /* Program a Read Sectors operation. */
    894893
    895894        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    896                 fibril_mutex_unlock(&d->lock);
     895                fibril_mutex_unlock(&disk->lock);
    897896                return EIO;
    898897        }
    … …  
    901900
    902901        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    903                 fibril_mutex_unlock(&d->lock);
     902                fibril_mutex_unlock(&disk->lock);
    904903                return EIO;
    905904        }
    … …  
    908907        coord_sc_program(&bc, 1);
    909908
    910         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     909        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    911910            CMD_READ_SECTORS_EXT : CMD_READ_SECTORS);
    912911
    913912        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    914                 fibril_mutex_unlock(&d->lock);
     913                fibril_mutex_unlock(&disk->lock);
    915914                return EIO;
    916915        }
    … …  
    919918                /* Read data from the device buffer. */
    920919
    921                 for (i = 0; i < disk[disk_id].block_size / 2; i++) {
     920                for (i = 0; i < disk->block_size / 2; i++) {
    922921                        data = pio_read_16(&cmd->data_port);
    923922                        ((uint16_t *) buf)[i] = data;
    … …  
    928927                return EIO;
    929928
    930         fibril_mutex_unlock(&d->lock);
     929        fibril_mutex_unlock(&disk->lock);
    931930        return EOK;
    932931}
    … …  
    934933/** Write a physical block to the device.
    935934 *
    936  * @param disk_id       Device index (0 or 1)
     935 * @param disk          Disk
    937936 * @param ba            Address of the first block.
    938937 * @param cnt           Number of blocks to transfer.
    … …  
    941940 * @return EOK on success, EIO on error.
    942941 */
    943 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,
    944943    const void *buf)
    945944{
    … …  
    947946        uint8_t status;
    948947        uint8_t drv_head;
    949         disk_t *d;
    950948        block_coord_t bc;
    951949
    952         d = &disk[disk_id];
    953        
    954950        /* Silence warning. */
    955951        memset(&bc, 0, sizeof(bc));
    956952
    957953        /* Compute block coordinates. */
    958         if (coord_calc(d, ba, &bc) != EOK)
     954        if (coord_calc(disk, ba, &bc) != EOK)
    959955                return EINVAL;
    960956
    961957        /* New value for Drive/Head register */
    962958        drv_head =
    963             ((disk_id != 0) ? DHR_DRV : 0) |
    964             ((d->amode != am_chs) ? DHR_LBA : 0) |
     959            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     960            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    965961            (bc.h & 0x0f);
    966962
    967         fibril_mutex_lock(&d->lock);
     963        fibril_mutex_lock(&disk->lock);
    968964
    969965        /* Program a Write Sectors operation. */
    970966
    971967        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    972                 fibril_mutex_unlock(&d->lock);
     968                fibril_mutex_unlock(&disk->lock);
    973969                return EIO;
    974970        }
    … …  
    977973
    978974        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    979                 fibril_mutex_unlock(&d->lock);
     975                fibril_mutex_unlock(&disk->lock);
    980976                return EIO;
    981977        }
    … …  
    984980        coord_sc_program(&bc, 1);
    985981
    986         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     982        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    987983            CMD_WRITE_SECTORS_EXT : CMD_WRITE_SECTORS);
    988984
    989985        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    990                 fibril_mutex_unlock(&d->lock);
     986                fibril_mutex_unlock(&disk->lock);
    991987                return EIO;
    992988        }
    … …  
    995991                /* Write data to the device buffer. */
    996992
    997                 for (i = 0; i < disk[disk_id].block_size / 2; i++) {
     993                for (i = 0; i < disk->block_size / 2; i++) {
    998994                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    999995                }
    1000996        }
    1001997
    1002         fibril_mutex_unlock(&d->lock);
     998        fibril_mutex_unlock(&disk->lock);
    1003999
    10041000        if (status & SR_ERR)
Note: See TracChangeset for help on using the changeset viewer.