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

Changeset 42d0eeb6 in mainline


Ignore:
Timestamp:
2015-04-12T11:25:17Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
73e894c
Parents:
c4f32fff
Message:

Rename the soft state type to ddisk_t.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/block/ddisk/ddisk.c

    rc4f32fff r42d0eeb6  
    113113
    114114        bd_srvs_t bds;
    115 } ddisk_dev_t;
     115} ddisk_t;
    116116
    117117static int ddisk_bd_open(bd_srvs_t *, bd_srv_t *);
     
    179179            (uint32_t) IPC_GET_ARG1(*icall));
    180180
    181         ddisk_dev_t *ddisk_dev = (ddisk_dev_t *) ddf_dev_data_get(dev);
     181        ddisk_t *ddisk = (ddisk_t *) ddf_dev_data_get(dev);
    182182       
    183         fibril_mutex_lock(&ddisk_dev->lock);
    184         fibril_condvar_broadcast(&ddisk_dev->io_cv);
    185         fibril_mutex_unlock(&ddisk_dev->lock);
     183        fibril_mutex_lock(&ddisk->lock);
     184        fibril_condvar_broadcast(&ddisk->io_cv);
     185        fibril_mutex_unlock(&ddisk->lock);
    186186}
    187187
     
    197197
    198198static
    199 int ddisk_rw_block(ddisk_dev_t *ddisk_dev, bool read, aoff64_t ba, void *buf)
    200 {
    201         fibril_mutex_lock(&ddisk_dev->lock);
     199int ddisk_rw_block(ddisk_t *ddisk, bool read, aoff64_t ba, void *buf)
     200{
     201        fibril_mutex_lock(&ddisk->lock);
    202202
    203203        ddf_msg(LVL_DEBUG, "ddisk_rw_block(): read=%d, ba=%" PRId64 ", buf=%p",
    204204            read, ba, buf);
    205205
    206         if (ba >= ddisk_dev->blocks)
     206        if (ba >= ddisk->blocks)
    207207                return ELIMIT;
    208208
    209         while (ddisk_dev->io_busy)
    210                 fibril_condvar_wait(&ddisk_dev->io_cv, &ddisk_dev->lock);
    211 
    212         ddisk_dev->io_busy = true;
     209        while (ddisk->io_busy)
     210                fibril_condvar_wait(&ddisk->io_cv, &ddisk->lock);
     211
     212        ddisk->io_busy = true;
    213213
    214214        if (!read)
    215                 memcpy(ddisk_dev->dma_buffer, buf, DDISK_BLOCK_SIZE);
     215                memcpy(ddisk->dma_buffer, buf, DDISK_BLOCK_SIZE);
    216216       
    217         pio_write_32(&ddisk_dev->ddisk_regs->dma_buffer,
    218             ddisk_dev->dma_buffer_phys);
    219         pio_write_32(&ddisk_dev->ddisk_regs->block, (uint32_t) ba);
    220         pio_write_32(&ddisk_dev->ddisk_regs->command,
     217        pio_write_32(&ddisk->ddisk_regs->dma_buffer,
     218            ddisk->dma_buffer_phys);
     219        pio_write_32(&ddisk->ddisk_regs->block, (uint32_t) ba);
     220        pio_write_32(&ddisk->ddisk_regs->command,
    221221            read ? DDISK_CMD_READ : DDISK_CMD_WRITE);
    222222
    223         fibril_condvar_wait(&ddisk_dev->io_cv, &ddisk_dev->lock);
     223        fibril_condvar_wait(&ddisk->io_cv, &ddisk->lock);
    224224
    225225        if (read)
    226                 memcpy(buf, ddisk_dev->dma_buffer, DDISK_BLOCK_SIZE);
    227 
    228         ddisk_dev->io_busy = false;
    229         fibril_condvar_signal(&ddisk_dev->io_cv);
    230         fibril_mutex_unlock(&ddisk_dev->lock);
     226                memcpy(buf, ddisk->dma_buffer, DDISK_BLOCK_SIZE);
     227
     228        ddisk->io_busy = false;
     229        fibril_condvar_signal(&ddisk->io_cv);
     230        fibril_mutex_unlock(&ddisk->lock);
    231231
    232232        return EOK;
     
    237237    size_t size, bool is_read)
    238238{
    239         ddisk_dev_t *ddisk_dev = (ddisk_dev_t *) bd->srvs->sarg;
     239        ddisk_t *ddisk = (ddisk_t *) bd->srvs->sarg;
    240240        aoff64_t i;
    241241        int rc;
     
    245245
    246246        for (i = 0; i < cnt; i++) {
    247                 rc = ddisk_rw_block(ddisk_dev, is_read, ba + i,
     247                rc = ddisk_rw_block(ddisk, is_read, ba + i,
    248248                    buf + i * DDISK_BLOCK_SIZE);
    249249                if (rc != EOK)
     
    274274int ddisk_bd_get_num_blocks(bd_srv_t *bd, aoff64_t *rnb)
    275275{
    276         ddisk_dev_t *ddisk_dev = (ddisk_dev_t *) bd->srvs->sarg;
    277 
    278         *rnb = ddisk_dev->blocks;
     276        ddisk_t *ddisk = (ddisk_t *) bd->srvs->sarg;
     277
     278        *rnb = ddisk->blocks;
    279279        return EOK;     
    280280}
     
    315315}
    316316
    317 static int ddisk_fun_create(ddisk_dev_t *ddisk_dev)
     317static int ddisk_fun_create(ddisk_t *ddisk)
    318318{
    319319        int rc;
    320320        ddf_fun_t *fun = NULL;
    321321
    322         fun = ddf_fun_create(ddisk_dev->dev, fun_exposed, DDISK_FUN_NAME);
     322        fun = ddf_fun_create(ddisk->dev, fun_exposed, DDISK_FUN_NAME);
    323323        if (fun == NULL) {
    324324                ddf_msg(LVL_ERROR, "Failed creating DDF function.");
     
    338338
    339339        ddf_fun_add_to_category(fun, "bd");
    340         ddisk_dev->fun = fun;
     340        ddisk->fun = fun;
    341341
    342342        return EOK;
     
    348348}
    349349
    350 static int ddisk_fun_remove(ddisk_dev_t *ddisk_dev)
    351 {
    352         int rc;
    353 
    354         if (ddisk_dev->fun == NULL)
     350static int ddisk_fun_remove(ddisk_t *ddisk)
     351{
     352        int rc;
     353
     354        if (ddisk->fun == NULL)
    355355                return EOK;
    356356
    357         ddf_msg(LVL_DEBUG, "ddisk_fun_remove(%p, '%s')", ddisk_dev,
     357        ddf_msg(LVL_DEBUG, "ddisk_fun_remove(%p, '%s')", ddisk,
    358358            DDISK_FUN_NAME);
    359         rc = ddf_fun_offline(ddisk_dev->fun);
     359        rc = ddf_fun_offline(ddisk->fun);
    360360        if (rc != EOK) {
    361361                ddf_msg(LVL_ERROR, "Error offlining function '%s'.",
     
    364364        }
    365365
    366         rc = ddf_fun_unbind(ddisk_dev->fun);
     366        rc = ddf_fun_unbind(ddisk->fun);
    367367        if (rc != EOK) {
    368368                ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.",
     
    371371        }
    372372
    373         ddf_fun_destroy(ddisk_dev->fun);
    374         ddisk_dev->fun = NULL;
     373        ddf_fun_destroy(ddisk->fun);
     374        ddisk->fun = NULL;
    375375        rc = EOK;
    376376
     
    379379}
    380380
    381 static int ddisk_fun_unbind(ddisk_dev_t *ddisk_dev)
    382 {
    383         int rc;
    384 
    385         if (ddisk_dev->fun == NULL)
     381static int ddisk_fun_unbind(ddisk_t *ddisk)
     382{
     383        int rc;
     384
     385        if (ddisk->fun == NULL)
    386386                return EOK;
    387387
    388         ddf_msg(LVL_DEBUG, "ddisk_fun_unbind(%p, '%s')", ddisk_dev,
     388        ddf_msg(LVL_DEBUG, "ddisk_fun_unbind(%p, '%s')", ddisk,
    389389            DDISK_FUN_NAME);
    390         rc = ddf_fun_unbind(ddisk_dev->fun);
     390        rc = ddf_fun_unbind(ddisk->fun);
    391391        if (rc != EOK) {
    392392                ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.",
     
    395395        }
    396396
    397         ddf_fun_destroy(ddisk_dev->fun);
    398         ddisk_dev->fun = NULL;
     397        ddf_fun_destroy(ddisk->fun);
     398        ddisk->fun = NULL;
    399399        rc = EOK;
    400400
     
    410410static int ddisk_dev_add(ddf_dev_t *dev)
    411411{
    412         ddisk_dev_t *ddisk_dev;
     412        ddisk_t *ddisk;
    413413        ddisk_res_t res;
    414414        int rc;
     
    426426         * Allocate soft state.
    427427         */
    428         ddisk_dev = ddf_dev_data_alloc(dev, sizeof(ddisk_dev_t));
    429         if (!ddisk_dev) {
     428        ddisk = ddf_dev_data_alloc(dev, sizeof(ddisk_t));
     429        if (!ddisk) {
    430430                ddf_msg(LVL_ERROR, "Failed allocating soft state.");
    431431                rc = ENOMEM;
     
    436436         * Initialize soft state.
    437437         */
    438         fibril_mutex_initialize(&ddisk_dev->lock);
    439         ddisk_dev->dev = dev;
    440         ddisk_dev->ddisk_res = res;
    441 
    442         fibril_condvar_initialize(&ddisk_dev->io_cv);
    443         ddisk_dev->io_busy = false;
    444 
    445         bd_srvs_init(&ddisk_dev->bds);
    446         ddisk_dev->bds.ops = &ddisk_bd_ops;
    447         ddisk_dev->bds.sarg = ddisk_dev;
     438        fibril_mutex_initialize(&ddisk->lock);
     439        ddisk->dev = dev;
     440        ddisk->ddisk_res = res;
     441
     442        fibril_condvar_initialize(&ddisk->io_cv);
     443        ddisk->io_busy = false;
     444
     445        bd_srvs_init(&ddisk->bds);
     446        ddisk->bds.ops = &ddisk_bd_ops;
     447        ddisk->bds.sarg = ddisk;
    448448
    449449        /*
     
    456456                goto error;
    457457        }
    458         ddisk_dev->ddisk_regs = vaddr;
    459 
    460         ddisk_dev->size = (int32_t) pio_read_32(&ddisk_dev->ddisk_regs->size);
    461         ddisk_dev->blocks = ddisk_dev->size / DDISK_BLOCK_SIZE;
    462 
    463         if (ddisk_dev->size <= 0) {
     458        ddisk->ddisk_regs = vaddr;
     459
     460        ddisk->size = (int32_t) pio_read_32(&ddisk->ddisk_regs->size);
     461        ddisk->blocks = ddisk->size / DDISK_BLOCK_SIZE;
     462
     463        if (ddisk->size <= 0) {
    464464                ddf_msg(LVL_WARN, "No disk detected.");
    465465                rc = EIO;
     
    470470         * Allocate DMA buffer.
    471471         */
    472         ddisk_dev->dma_buffer = AS_AREA_ANY;
     472        ddisk->dma_buffer = AS_AREA_ANY;
    473473        rc = dmamem_map_anonymous(DDISK_BLOCK_SIZE, DMAMEM_4GiB,
    474             AS_AREA_READ | AS_AREA_WRITE, 0, &ddisk_dev->dma_buffer_phys,
    475             &ddisk_dev->dma_buffer);
     474            AS_AREA_READ | AS_AREA_WRITE, 0, &ddisk->dma_buffer_phys,
     475            &ddisk->dma_buffer);
    476476        if (rc != EOK) {
    477477                ddf_msg(LVL_ERROR, "Cannot allocate DMA memory.");
     
    480480
    481481        ddf_msg(LVL_NOTE, "Allocated DMA buffer at %p virtual and %p physical.",
    482             ddisk_dev->dma_buffer, (void *) ddisk_dev->dma_buffer_phys);
     482            ddisk->dma_buffer, (void *) ddisk->dma_buffer_phys);
    483483
    484484        /*
    485485         * Create an exposed function.
    486486         */
    487         rc = ddisk_fun_create(ddisk_dev);
     487        rc = ddisk_fun_create(ddisk);
    488488        if (rc != EOK) {
    489489                ddf_msg(LVL_ERROR, "Failed initializing ddisk controller.");
     
    499499        ddisk_irq_commands[0].addr = (void *) &res_phys->status;
    500500        ddisk_irq_commands[3].addr = (void *) &res_phys->command;
    501         rc = register_interrupt_handler(dev, ddisk_dev->ddisk_res.irq,
     501        rc = register_interrupt_handler(dev, ddisk->ddisk_res.irq,
    502502            ddisk_irq_handler, &ddisk_irq_code);
    503503        if (rc != EOK) {
     
    511511        ddf_msg(LVL_NOTE,
    512512            "Device at %p with %zd blocks (%zuB) using interrupt %d",
    513             (void *) ddisk_dev->ddisk_res.base, ddisk_dev->blocks,
    514             ddisk_dev->size, ddisk_dev->ddisk_res.irq);
     513            (void *) ddisk->ddisk_res.base, ddisk->blocks,
     514            ddisk->size, ddisk->ddisk_res.irq);
    515515
    516516        return EOK;
    517517
    518518error:
    519         if (ddisk_dev->ddisk_regs)
    520                 pio_disable(ddisk_dev->ddisk_regs, sizeof(ddisk_regs_t));
    521         if (ddisk_dev->dma_buffer)
    522                 dmamem_unmap_anonymous(ddisk_dev->dma_buffer);
     519        if (ddisk->ddisk_regs)
     520                pio_disable(ddisk->ddisk_regs, sizeof(ddisk_regs_t));
     521        if (ddisk->dma_buffer)
     522                dmamem_unmap_anonymous(ddisk->dma_buffer);
    523523
    524524        return rc;
     
    526526
    527527
    528 static int ddisk_dev_remove_common(ddisk_dev_t *ddisk_dev, bool surprise)
     528static int ddisk_dev_remove_common(ddisk_t *ddisk, bool surprise)
    529529{
    530530        int rc;
    531531
    532532        if (!surprise)
    533                 rc = ddisk_fun_remove(ddisk_dev);
     533                rc = ddisk_fun_remove(ddisk);
    534534        else
    535                 rc = ddisk_fun_unbind(ddisk_dev);
     535                rc = ddisk_fun_unbind(ddisk);
    536536
    537537        if (rc != EOK) {
     
    541541        }
    542542       
    543         rc = pio_disable(ddisk_dev->ddisk_regs, sizeof(ddisk_regs_t));
     543        rc = pio_disable(ddisk->ddisk_regs, sizeof(ddisk_regs_t));
    544544        if (rc != EOK) {
    545545                ddf_msg(LVL_ERROR, "Unable to disable PIO.");
     
    547547        }
    548548
    549         dmamem_unmap_anonymous(ddisk_dev->dma_buffer);
     549        dmamem_unmap_anonymous(ddisk->dma_buffer);
    550550
    551551        return EOK;
     
    554554static int ddisk_dev_remove(ddf_dev_t *dev)
    555555{
    556         ddisk_dev_t *ddisk_dev = (ddisk_dev_t *) ddf_dev_data_get(dev);
     556        ddisk_t *ddisk = (ddisk_t *) ddf_dev_data_get(dev);
    557557
    558558        ddf_msg(LVL_DEBUG, "ddisk_dev_remove(%p)", dev);
    559         return ddisk_dev_remove_common(ddisk_dev, false);
     559        return ddisk_dev_remove_common(ddisk, false);
    560560}
    561561
    562562static int ddisk_dev_gone(ddf_dev_t *dev)
    563563{
    564         ddisk_dev_t *ddisk_dev = (ddisk_dev_t *) ddf_dev_data_get(dev);
     564        ddisk_t *ddisk = (ddisk_t *) ddf_dev_data_get(dev);
    565565
    566566        ddf_msg(LVL_DEBUG, "ddisk_dev_gone(%p)", dev);
    567         return ddisk_dev_remove_common(ddisk_dev, true);
     567        return ddisk_dev_remove_common(ddisk, true);
    568568}
    569569
     
    583583static void ddisk_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    584584{
    585         ddisk_dev_t *ddisk_dev;
     585        ddisk_t *ddisk;
    586586        ddf_fun_t *fun = (ddf_fun_t *) arg;
    587587
    588         ddisk_dev = (ddisk_dev_t *) ddf_dev_data_get(ddf_fun_get_dev(fun));
    589         bd_conn(iid, icall, &ddisk_dev->bds);
     588        ddisk = (ddisk_t *) ddf_dev_data_get(ddf_fun_get_dev(fun));
     589        bd_conn(iid, icall, &ddisk->bds);
    590590}
    591591
Note: See TracChangeset for help on using the changeset viewer.