Changeset 03362fbd in mainline for uspace/srv/bd/ata_bd/ata_bd.c


Ignore:
Timestamp:
2013-02-09T23:14:45Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
22dfd38
Parents:
b5d2e57 (diff), 005b765 (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:

Merge mainline changes.

Conflict resulting from bool.h → stdbool.h move and ddf structs turning opaque.
Fails to boot to shell console.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb5d2e57 r03362fbd  
    4949
    5050#include <stdio.h>
    51 #include <libarch/ddi.h>
    5251#include <ddi.h>
    53 #include <ipc/bd.h>
    5452#include <async.h>
    5553#include <as.h>
     54#include <bd_srv.h>
    5655#include <fibril_synch.h>
    5756#include <stdint.h>
    … …  
    6160#include <inttypes.h>
    6261#include <errno.h>
    63 #include <bool.h>
     62#include <stdbool.h>
    6463#include <byteorder.h>
    6564#include <task.h>
    … …  
    9897
    9998/** Per-disk state. */
    100 static disk_t disk[MAX_DISKS];
     99static disk_t ata_disk[MAX_DISKS];
    101100
    102101static void print_syntax(void);
    103102static int ata_bd_init(void);
    104103static 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,
     104
     105static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
     106static int ata_bd_close(bd_srv_t *);
     107static int ata_bd_read_blocks(bd_srv_t *, uint64_t ba, size_t cnt, void *buf,
     108    size_t);
     109static int ata_bd_read_toc(bd_srv_t *, uint8_t session, void *buf, size_t);
     110static int ata_bd_write_blocks(bd_srv_t *, uint64_t ba, size_t cnt,
     111    const void *buf, size_t);
     112static int ata_bd_get_block_size(bd_srv_t *, size_t *);
     113static int ata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
     114
     115static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t cnt,
    106116    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,
     117static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
    112118    const void *buf);
    113119static 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,
     120static int drive_identify(disk_t *disk, void *buf);
     121static int identify_pkt_dev(disk_t *disk, void *buf);
     122static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
    117123    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,
     124static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size);
     125static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
    120126    void *obuf, size_t obuf_size);
    121 static int ata_pcmd_read_toc(int dev_idx, uint8_t ses,
     127static int ata_pcmd_read_toc(disk_t *disk, uint8_t ses,
    122128    void *obuf, size_t obuf_size);
    123129static void disk_print_summary(disk_t *d);
    … …  
    126132static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
    127133    unsigned timeout);
     134
     135static bd_ops_t ata_bd_ops = {
     136        .open = ata_bd_open,
     137        .close = ata_bd_close,
     138        .read_blocks = ata_bd_read_blocks,
     139        .read_toc = ata_bd_read_toc,
     140        .write_blocks = ata_bd_write_blocks,
     141        .get_block_size = ata_bd_get_block_size,
     142        .get_num_blocks = ata_bd_get_num_blocks
     143};
     144
     145static disk_t *bd_srv_disk(bd_srv_t *bd)
     146{
     147        return (disk_t *)bd->srvs->sarg;
     148}
     149
     150static int disk_dev_idx(disk_t *disk)
     151{
     152        return (disk->disk_id & 1);
     153}
    128154
    129155int main(int argc, char **argv)
    … …  
    161187                fflush(stdout);
    162188
    163                 rc = disk_init(&disk[i], i);
     189                rc = disk_init(&ata_disk[i], i);
    164190
    165191                if (rc == EOK) {
    166                         disk_print_summary(&disk[i]);
     192                        disk_print_summary(&ata_disk[i]);
    167193                } else {
    168194                        printf("Not found.\n");
    … …  
    174200        for (i = 0; i < MAX_DISKS; i++) {
    175201                /* Skip unattached drives. */
    176                 if (disk[i].present == false)
     202                if (ata_disk[i].present == false)
    177203                        continue;
    178204               
    179205                snprintf(name, 16, "%s/ata%udisk%d", NAMESPACE, ctl_num, i);
    180                 rc = loc_service_register(name, &disk[i].service_id);
     206                rc = loc_service_register(name, &ata_disk[i].service_id);
    181207                if (rc != EOK) {
    182208                        printf(NAME ": Unable to register device %s.\n", name);
    … …  
    217243                case am_chs:
    218244                        printf("CHS %u cylinders, %u heads, %u sectors",
    219                             disk->geom.cylinders, disk->geom.heads,
    220                             disk->geom.sectors);
     245                            d->geom.cylinders, d->geom.heads,
     246                            d->geom.sectors);
    221247                        break;
    222248                case am_lba28:
    … …  
    273299static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    274300{
    275         void *fs_va = NULL;
    276         ipc_callid_t callid;
    277         ipc_call_t call;
    278         sysarg_t method;
    279301        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;
     302        int i;
     303        disk_t *disk;
    286304
    287305        /* Get the device service ID. */
    … …  
    289307
    290308        /* Determine which disk device is the client connecting to. */
    291         disk_id = -1;
     309        disk = NULL;
    292310        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) {
     311                if (ata_disk[i].service_id == dsid)
     312                        disk = &ata_disk[i];
     313
     314        if (disk == NULL || disk->present == false) {
    297315                async_answer_0(iid, EINVAL);
    298316                return;
    299317        }
    300318
    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         }
     319        bd_conn(iid, icall, &disk->bds);
    367320}
    368321
    … …  
    384337        unsigned i;
    385338
     339        d->disk_id = disk_id;
    386340        d->present = false;
    387341        fibril_mutex_initialize(&d->lock);
    388342
     343        bd_srvs_init(&d->bds);
     344        d->bds.ops = &ata_bd_ops;
     345        d->bds.sarg = d;
     346
    389347        /* Try identify command. */
    390         rc = drive_identify(disk_id, &idata);
     348        rc = drive_identify(d, &idata);
    391349        if (rc == EOK) {
    392350                /* Success. It's a register (non-packet) device. */
    … …  
    408366
    409367                if (bc == PDEV_SIGNATURE_BC) {
    410                         rc = identify_pkt_dev(disk_id, &idata);
     368                        rc = identify_pkt_dev(d, &idata);
    411369                        if (rc == EOK) {
    412370                                /* We have a packet device. */
    … …  
    492450        if (d->dev_type == ata_pkt_dev) {
    493451                /* Send inquiry. */
    494                 rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
     452                rc = ata_pcmd_inquiry(d, &inq_data, sizeof(inq_data));
    495453                if (rc != EOK) {
    496454                        printf("Device inquiry failed.\n");
    … …  
    514472}
    515473
     474static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     475{
     476        return EOK;
     477}
     478
     479static int ata_bd_close(bd_srv_t *bd)
     480{
     481        return EOK;
     482}
     483
    516484/** 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 
     485static int ata_bd_read_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
     486    void *buf, size_t size)
     487{
     488        disk_t *disk = bd_srv_disk(bd);
    520489        int rc;
    521490
     491        if (size < cnt * disk->block_size)
     492                return EINVAL;
     493
    522494        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);
     495                if (disk->dev_type == ata_reg_dev) {
     496                        rc = ata_rcmd_read(disk, ba, 1, buf);
     497                } else {
     498                        rc = ata_pcmd_read_12(disk, ba, 1, buf,
     499                            disk->block_size);
     500                }
    528501
    529502                if (rc != EOK)
    … …  
    532505                ++ba;
    533506                --cnt;
    534                 buf += disk[disk_id].block_size;
    535         }
    536 
    537         return EOK;
     507                buf += disk->block_size;
     508        }
     509
     510        return EOK;
     511}
     512
     513/** Read TOC from device. */
     514static int ata_bd_read_toc(bd_srv_t *bd, uint8_t session, void *buf, size_t size)
     515{
     516        disk_t *disk = bd_srv_disk(bd);
     517
     518        return ata_pcmd_read_toc(disk, session, buf, size);
    538519}
    539520
    540521/** 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 
     522static int ata_bd_write_blocks(bd_srv_t *bd, uint64_t ba, size_t cnt,
     523    const void *buf, size_t size)
     524{
     525        disk_t *disk = bd_srv_disk(bd);
    544526        int rc;
    545527
    546         if (disk[disk_id].dev_type != ata_reg_dev)
     528        if (disk->dev_type != ata_reg_dev)
    547529                return ENOTSUP;
    548530
     531        if (size < cnt * disk->block_size)
     532                return EINVAL;
     533
    549534        while (cnt > 0) {
    550                 rc = ata_rcmd_write(disk_id, ba, 1, buf);
     535                rc = ata_rcmd_write(disk, ba, 1, buf);
    551536                if (rc != EOK)
    552537                        return rc;
    … …  
    554539                ++ba;
    555540                --cnt;
    556                 buf += disk[disk_id].block_size;
    557         }
    558 
     541                buf += disk->block_size;
     542        }
     543
     544        return EOK;
     545}
     546
     547/** Get device block size. */
     548static int ata_bd_get_block_size(bd_srv_t *bd, size_t *rbsize)
     549{
     550        disk_t *disk = bd_srv_disk(bd);
     551
     552        *rbsize = disk->block_size;
     553        return EOK;
     554}
     555
     556/** Get device number of blocks. */
     557static int ata_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
     558{
     559        disk_t *disk = bd_srv_disk(bd);
     560
     561        *rnb = disk->blocks;
    559562        return EOK;
    560563}
    … …  
    565568 * whether an ATA device is present and if so, to determine its parameters.
    566569 *
    567  * @param disk_id       Device ID, 0 or 1.
     570 * @param disk          Disk
    568571 * @param buf           Pointer to a 512-byte buffer.
    569572 *
    … …  
    571574 *                      not present). EIO if device responds with error.
    572575 */
    573 static int drive_identify(int disk_id, void *buf)
     576static int drive_identify(disk_t *disk, void *buf)
    574577{
    575578        uint16_t data;
    … …  
    578581        size_t i;
    579582
    580         drv_head = ((disk_id != 0) ? DHR_DRV : 0);
     583        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    581584
    582585        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    624627 * whether an ATAPI device is present and if so, to determine its parameters.
    625628 *
    626  * @param dev_idx       Device index, 0 or 1.
     629 * @param disk          Disk
    627630 * @param buf           Pointer to a 512-byte buffer.
    628631 */
    629 static int identify_pkt_dev(int dev_idx, void *buf)
     632static int identify_pkt_dev(disk_t *disk, void *buf)
    630633{
    631634        uint16_t data;
    … …  
    634637        size_t i;
    635638
    636         drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
     639        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    637640
    638641        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    669672 * Only data-in commands are supported (e.g. inquiry, read).
    670673 *
    671  * @param dev_idx       Device index (0 or 1)
     674 * @param disk          Disk
    672675 * @param obuf          Buffer for storing data read from device
    673676 * @param obuf_size     Size of obuf in bytes
    … …  
    675678 * @return EOK on success, EIO on error.
    676679 */
    677 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
     680static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
    678681    void *obuf, size_t obuf_size)
    679682{
    … …  
    681684        uint8_t status;
    682685        uint8_t drv_head;
    683         disk_t *d;
    684686        size_t data_size;
    685687        uint16_t val;
    686688
    687         d = &disk[dev_idx];
    688         fibril_mutex_lock(&d->lock);
     689        fibril_mutex_lock(&disk->lock);
    689690
    690691        /* New value for Drive/Head register */
    691692        drv_head =
    692             ((dev_idx != 0) ? DHR_DRV : 0);
     693            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    693694
    694695        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    695                 fibril_mutex_unlock(&d->lock);
     696                fibril_mutex_unlock(&disk->lock);
    696697                return EIO;
    697698        }
    … …  
    700701
    701702        if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    702                 fibril_mutex_unlock(&d->lock);
     703                fibril_mutex_unlock(&disk->lock);
    703704                return EIO;
    704705        }
    … …  
    711712
    712713        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    713                 fibril_mutex_unlock(&d->lock);
     714                fibril_mutex_unlock(&disk->lock);
    714715                return EIO;
    715716        }
    … …  
    720721
    721722        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    722                 fibril_mutex_unlock(&d->lock);
     723                fibril_mutex_unlock(&disk->lock);
    723724                return EIO;
    724725        }
    725726
    726727        if ((status & SR_DRQ) == 0) {
    727                 fibril_mutex_unlock(&d->lock);
     728                fibril_mutex_unlock(&disk->lock);
    728729                return EIO;
    729730        }
    … …  
    736737        if (data_size > obuf_size) {
    737738                /* Output buffer is too small to store data. */
    738                 fibril_mutex_unlock(&d->lock);
     739                fibril_mutex_unlock(&disk->lock);
    739740                return EIO;
    740741        }
    … …  
    747748
    748749        if (status & SR_ERR) {
    749                 fibril_mutex_unlock(&d->lock);
    750                 return EIO;
    751         }
    752 
    753         fibril_mutex_unlock(&d->lock);
     750                fibril_mutex_unlock(&disk->lock);
     751                return EIO;
     752        }
     753
     754        fibril_mutex_unlock(&disk->lock);
    754755
    755756        return EOK;
    … …  
    758759/** Issue ATAPI Inquiry.
    759760 *
    760  * @param dev_idx       Device index (0 or 1)
     761 * @param disk          Disk
    761762 * @param obuf          Buffer for storing inquiry data read from device
    762763 * @param obuf_size     Size of obuf in bytes
    … …  
    764765 * @return EOK on success, EIO on error.
    765766 */
    766 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size)
     767static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size)
    767768{
    768769        ata_pcmd_inquiry_t cp;
    … …  
    774775        cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    775776
    776         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     777        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    777778        if (rc != EOK)
    778779                return rc;
    … …  
    786787 * function will fail.
    787788 *
    788  * @param dev_idx       Device index (0 or 1)
     789 * @param disk          Disk
    789790 * @param ba            Starting block address
    790791 * @param cnt           Number of blocks to read
    … …  
    794795 * @return EOK on success, EIO on error.
    795796 */
    796 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
     797static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
    797798    void *obuf, size_t obuf_size)
    798799{
    … …  
    809810        cp.nblocks = host2uint32_t_be(cnt);
    810811
    811         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     812        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    812813        if (rc != EOK)
    813814                return rc;
    … …  
    826827 * function will fail.
    827828 *
    828  * @param dev_idx       Device index (0 or 1)
     829 * @param disk          Disk
    829830 * @param session       Starting session
    830831 * @param obuf          Buffer for storing inquiry data read from device
    … …  
    833834 * @return EOK on success, EIO on error.
    834835 */
    835 static int ata_pcmd_read_toc(int dev_idx, uint8_t session, void *obuf,
     836static int ata_pcmd_read_toc(disk_t *disk, uint8_t session, void *obuf,
    836837    size_t obuf_size)
    837838{
    … …  
    857858/** Read a physical from the device.
    858859 *
    859  * @param disk_id       Device index (0 or 1)
     860 * @param disk          Disk
    860861 * @param ba            Address the first block.
    861862 * @param cnt           Number of blocks to transfer.
    … …  
    864865 * @return EOK on success, EIO on error.
    865866 */
    866 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t blk_cnt,
     867static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t blk_cnt,
    867868    void *buf)
    868869{
    … …  
    871872        uint8_t status;
    872873        uint8_t drv_head;
    873         disk_t *d;
    874874        block_coord_t bc;
    875875
    876         d = &disk[disk_id];
    877        
    878876        /* Silence warning. */
    879877        memset(&bc, 0, sizeof(bc));
    880878
    881879        /* Compute block coordinates. */
    882         if (coord_calc(d, ba, &bc) != EOK)
     880        if (coord_calc(disk, ba, &bc) != EOK)
    883881                return EINVAL;
    884882
    885883        /* New value for Drive/Head register */
    886884        drv_head =
    887             ((disk_id != 0) ? DHR_DRV : 0) |
    888             ((d->amode != am_chs) ? DHR_LBA : 0) |
     885            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     886            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    889887            (bc.h & 0x0f);
    890888
    891         fibril_mutex_lock(&d->lock);
     889        fibril_mutex_lock(&disk->lock);
    892890
    893891        /* Program a Read Sectors operation. */
    894892
    895893        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    896                 fibril_mutex_unlock(&d->lock);
     894                fibril_mutex_unlock(&disk->lock);
    897895                return EIO;
    898896        }
    … …  
    901899
    902900        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    903                 fibril_mutex_unlock(&d->lock);
     901                fibril_mutex_unlock(&disk->lock);
    904902                return EIO;
    905903        }
    … …  
    908906        coord_sc_program(&bc, 1);
    909907
    910         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     908        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    911909            CMD_READ_SECTORS_EXT : CMD_READ_SECTORS);
    912910
    913911        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    914                 fibril_mutex_unlock(&d->lock);
     912                fibril_mutex_unlock(&disk->lock);
    915913                return EIO;
    916914        }
    … …  
    919917                /* Read data from the device buffer. */
    920918
    921                 for (i = 0; i < disk[disk_id].block_size / 2; i++) {
     919                for (i = 0; i < disk->block_size / 2; i++) {
    922920                        data = pio_read_16(&cmd->data_port);
    923921                        ((uint16_t *) buf)[i] = data;
    … …  
    928926                return EIO;
    929927
    930         fibril_mutex_unlock(&d->lock);
     928        fibril_mutex_unlock(&disk->lock);
    931929        return EOK;
    932930}
    … …  
    934932/** Write a physical block to the device.
    935933 *
    936  * @param disk_id       Device index (0 or 1)
     934 * @param disk          Disk
    937935 * @param ba            Address of the first block.
    938936 * @param cnt           Number of blocks to transfer.
    … …  
    941939 * @return EOK on success, EIO on error.
    942940 */
    943 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     941static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
    944942    const void *buf)
    945943{
    … …  
    947945        uint8_t status;
    948946        uint8_t drv_head;
    949         disk_t *d;
    950947        block_coord_t bc;
    951948
    952         d = &disk[disk_id];
    953        
    954949        /* Silence warning. */
    955950        memset(&bc, 0, sizeof(bc));
    956951
    957952        /* Compute block coordinates. */
    958         if (coord_calc(d, ba, &bc) != EOK)
     953        if (coord_calc(disk, ba, &bc) != EOK)
    959954                return EINVAL;
    960955
    961956        /* New value for Drive/Head register */
    962957        drv_head =
    963             ((disk_id != 0) ? DHR_DRV : 0) |
    964             ((d->amode != am_chs) ? DHR_LBA : 0) |
     958            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     959            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    965960            (bc.h & 0x0f);
    966961
    967         fibril_mutex_lock(&d->lock);
     962        fibril_mutex_lock(&disk->lock);
    968963
    969964        /* Program a Write Sectors operation. */
    970965
    971966        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    972                 fibril_mutex_unlock(&d->lock);
     967                fibril_mutex_unlock(&disk->lock);
    973968                return EIO;
    974969        }
    … …  
    977972
    978973        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    979                 fibril_mutex_unlock(&d->lock);
     974                fibril_mutex_unlock(&disk->lock);
    980975                return EIO;
    981976        }
    … …  
    984979        coord_sc_program(&bc, 1);
    985980
    986         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     981        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    987982            CMD_WRITE_SECTORS_EXT : CMD_WRITE_SECTORS);
    988983
    989984        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    990                 fibril_mutex_unlock(&d->lock);
     985                fibril_mutex_unlock(&disk->lock);
    991986                return EIO;
    992987        }
    … …  
    995990                /* Write data to the device buffer. */
    996991
    997                 for (i = 0; i < disk[disk_id].block_size / 2; i++) {
     992                for (i = 0; i < disk->block_size / 2; i++) {
    998993                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    999994                }
    1000995        }
    1001996
    1002         fibril_mutex_unlock(&d->lock);
     997        fibril_mutex_unlock(&disk->lock);
    1003998
    1004999        if (status & SR_ERR)
Note: See TracChangeset for help on using the changeset viewer.