Changeset a46e56b in mainline for uspace/lib/drv/generic


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

Location:
uspace/lib/drv/generic
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/drv/generic/driver.c

    r3e242d2 ra46e56b  
    118118}
    119119
    120 static void driver_dev_add(cap_call_handle_t iid, ipc_call_t *icall)
     120static void driver_dev_add(cap_call_handle_t icall_handle, ipc_call_t *icall)
    121121{
    122122        devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
    … …  
    126126        errno_t rc = async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
    127127        if (rc != EOK) {
    128                 async_answer_0(iid, rc);
     128                async_answer_0(icall_handle, rc);
    129129                return;
    130130        }
    … …  
    134134        if (stopping) {
    135135                fibril_rwlock_read_unlock(&stopping_lock);
    136                 async_answer_0(iid, EIO);
     136                async_answer_0(icall_handle, EIO);
    137137                return;
    138138        }
    … …  
    142142                fibril_rwlock_read_unlock(&stopping_lock);
    143143                free(dev_name);
    144                 async_answer_0(iid, ENOMEM);
     144                async_answer_0(icall_handle, ENOMEM);
    145145                return;
    146146        }
    … …  
    162162                fibril_rwlock_read_unlock(&stopping_lock);
    163163                dev_del_ref(dev);
    164                 async_answer_0(iid, res);
     164                async_answer_0(icall_handle, res);
    165165                return;
    166166        }
    … …  
    171171        fibril_rwlock_read_unlock(&stopping_lock);
    172172
    173         async_answer_0(iid, res);
    174 }
    175 
    176 static void driver_dev_remove(cap_call_handle_t iid, ipc_call_t *icall)
     173        async_answer_0(icall_handle, res);
     174}
     175
     176static void driver_dev_remove(cap_call_handle_t icall_handle, ipc_call_t *icall)
    177177{
    178178        devman_handle_t devh = IPC_GET_ARG1(*icall);
    … …  
    185185
    186186        if (dev == NULL) {
    187                 async_answer_0(iid, ENOENT);
     187                async_answer_0(icall_handle, ENOENT);
    188188                return;
    189189        }
    … …  
    204204
    205205        dev_del_ref(dev);
    206         async_answer_0(iid, rc);
    207 }
    208 
    209 static void driver_dev_gone(cap_call_handle_t iid, ipc_call_t *icall)
     206        async_answer_0(icall_handle, rc);
     207}
     208
     209static void driver_dev_gone(cap_call_handle_t icall_handle, ipc_call_t *icall)
    210210{
    211211        devman_handle_t devh = IPC_GET_ARG1(*icall);
    … …  
    218218
    219219        if (dev == NULL) {
    220                 async_answer_0(iid, ENOENT);
     220                async_answer_0(icall_handle, ENOENT);
    221221                return;
    222222        }
    … …  
    237237
    238238        dev_del_ref(dev);
    239         async_answer_0(iid, rc);
    240 }
    241 
    242 static void driver_fun_online(cap_call_handle_t iid, ipc_call_t *icall)
     239        async_answer_0(icall_handle, rc);
     240}
     241
     242static void driver_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
    243243{
    244244        devman_handle_t funh = IPC_GET_ARG1(*icall);
    … …  
    258258
    259259        if (fun == NULL) {
    260                 async_answer_0(iid, ENOENT);
     260                async_answer_0(icall_handle, ENOENT);
    261261                return;
    262262        }
    … …  
    272272        fun_del_ref(fun);
    273273
    274         async_answer_0(iid, rc);
    275 }
    276 
    277 static void driver_fun_offline(cap_call_handle_t iid, ipc_call_t *icall)
     274        async_answer_0(icall_handle, rc);
     275}
     276
     277static void driver_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
    278278{
    279279        devman_handle_t funh = IPC_GET_ARG1(*icall);
    … …  
    293293
    294294        if (fun == NULL) {
    295                 async_answer_0(iid, ENOENT);
     295                async_answer_0(icall_handle, ENOENT);
    296296                return;
    297297        }
    … …  
    305305                rc = ENOTSUP;
    306306
    307         async_answer_0(iid, rc);
    308 }
    309 
    310 static void driver_stop(cap_call_handle_t iid, ipc_call_t *icall)
     307        async_answer_0(icall_handle, rc);
     308}
     309
     310static void driver_stop(cap_call_handle_t icall_handle, ipc_call_t *icall)
    311311{
    312312        /* Prevent new devices from being added */
    … …  
    321321                stopping = false;
    322322                fibril_rwlock_write_unlock(&stopping_lock);
    323                 async_answer_0(iid, EBUSY);
     323                async_answer_0(icall_handle, EBUSY);
    324324                return;
    325325        }
    … …  
    333333
    334334        /* Reply with success and terminate */
    335         async_answer_0(iid, EOK);
     335        async_answer_0(icall_handle, EOK);
    336336        exit(0);
    337337}
    338338
    339 static void driver_connection_devman(cap_call_handle_t iid, ipc_call_t *icall,
     339static void driver_connection_devman(cap_call_handle_t icall_handle, ipc_call_t *icall,
    340340    void *arg)
    341341{
    342342        /* Accept connection */
    343         async_answer_0(iid, EOK);
     343        async_answer_0(icall_handle, EOK);
    344344
    345345        while (true) {
    346346                ipc_call_t call;
    347                 cap_call_handle_t callid = async_get_call(&call);
     347                cap_call_handle_t chandle = async_get_call(&call);
    348348
    349349                if (!IPC_GET_IMETHOD(call))
    … …  
    352352                switch (IPC_GET_IMETHOD(call)) {
    353353                case DRIVER_DEV_ADD:
    354                         driver_dev_add(callid, &call);
     354                        driver_dev_add(chandle, &call);
    355355                        break;
    356356                case DRIVER_DEV_REMOVE:
    357                         driver_dev_remove(callid, &call);
     357                        driver_dev_remove(chandle, &call);
    358358                        break;
    359359                case DRIVER_DEV_GONE:
    360                         driver_dev_gone(callid, &call);
     360                        driver_dev_gone(chandle, &call);
    361361                        break;
    362362                case DRIVER_FUN_ONLINE:
    363                         driver_fun_online(callid, &call);
     363                        driver_fun_online(chandle, &call);
    364364                        break;
    365365                case DRIVER_FUN_OFFLINE:
    366                         driver_fun_offline(callid, &call);
     366                        driver_fun_offline(chandle, &call);
    367367                        break;
    368368                case DRIVER_STOP:
    369                         driver_stop(callid, &call);
     369                        driver_stop(chandle, &call);
    370370                        break;
    371371                default:
    372                         async_answer_0(callid, ENOTSUP);
     372                        async_answer_0(chandle, ENOTSUP);
    373373                }
    374374        }
    … …  
    381381 *
    382382 */
    383 static void driver_connection_gen(cap_call_handle_t iid, ipc_call_t *icall, bool drv)
     383static void driver_connection_gen(cap_call_handle_t icall_handle, ipc_call_t *icall, bool drv)
    384384{
    385385        /*
    … …  
    398398                printf("%s: driver_connection_gen error - no function with handle"
    399399                    " %" PRIun " was found.\n", driver->name, handle);
    400                 async_answer_0(iid, ENOENT);
     400                async_answer_0(icall_handle, ENOENT);
    401401                return;
    402402        }
    … …  
    404404        if (fun->conn_handler != NULL) {
    405405                /* Driver has a custom connection handler. */
    406                 (*fun->conn_handler)(iid, icall, (void *)fun);
     406                (*fun->conn_handler)(icall_handle, icall, (void *)fun);
    407407                fun_del_ref(fun);
    408408                return;
    … …  
    419419                ret = (*fun->ops->open)(fun);
    420420
    421         async_answer_0(iid, ret);
     421        async_answer_0(icall_handle, ret);
    422422        if (ret != EOK) {
    423423                fun_del_ref(fun);
    … …  
    426426
    427427        while (true) {
    428                 cap_call_handle_t callid;
     428                cap_call_handle_t chandle;
    429429                ipc_call_t call;
    430                 callid = async_get_call(&call);
     430                chandle = async_get_call(&call);
    431431                sysarg_t method = IPC_GET_IMETHOD(call);
    432432
    … …  
    435435                        if (fun->ops != NULL && fun->ops->close != NULL)
    436436                                (*fun->ops->close)(fun);
    437                         async_answer_0(callid, EOK);
     437                        async_answer_0(chandle, EOK);
    438438                        fun_del_ref(fun);
    439439                        return;
    … …  
    448448                            function_get_default_handler(fun);
    449449                        if (default_handler != NULL) {
    450                                 (*default_handler)(fun, callid, &call);
     450                                (*default_handler)(fun, chandle, &call);
    451451                                continue;
    452452                        }
    … …  
    459459                            "invalid interface id %d.",
    460460                            driver->name, iface_idx);
    461                         async_answer_0(callid, ENOTSUP);
     461                        async_answer_0(chandle, ENOTSUP);
    462462                        continue;
    463463                }
    … …  
    471471                        printf("Function with handle %" PRIun " has no interface "
    472472                            "with id %d.\n", handle, iface_idx);
    473                         async_answer_0(callid, ENOTSUP);
     473                        async_answer_0(chandle, ENOTSUP);
    474474                        continue;
    475475                }
    … …  
    490490                        printf("%s: driver_connection_gen error - "
    491491                            "invalid interface method.", driver->name);
    492                         async_answer_0(callid, ENOTSUP);
     492                        async_answer_0(chandle, ENOTSUP);
    493493                        continue;
    494494                }
    … …  
    500500                 * associated with the function by its driver.
    501501                 */
    502                 (*iface_method_ptr)(fun, ops, callid, &call);
    503         }
    504 }
    505 
    506 static void driver_connection_driver(cap_call_handle_t iid, ipc_call_t *icall,
     502                (*iface_method_ptr)(fun, ops, chandle, &call);
     503        }
     504}
     505
     506static void driver_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall,
    507507    void *arg)
    508508{
    509         driver_connection_gen(iid, icall, true);
    510 }
    511 
    512 static void driver_connection_client(cap_call_handle_t iid, ipc_call_t *icall,
     509        driver_connection_gen(icall_handle, icall, true);
     510}
     511
     512static void driver_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall,
    513513    void *arg)
    514514{
    515         driver_connection_gen(iid, icall, false);
     515        driver_connection_gen(icall_handle, icall, false);
    516516}
    517517

  • uspace/lib/drv/generic/remote_ahci.c

    r3e242d2 ra46e56b  
    210210
    211211void remote_ahci_get_sata_device_name(ddf_fun_t *fun, void *iface,
    212     cap_call_handle_t callid, ipc_call_t *call)
     212    cap_call_handle_t chandle, ipc_call_t *call)
    213213{
    214214        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    215215
    216216        if (ahci_iface->get_sata_device_name == NULL) {
    217                 async_answer_0(callid, ENOTSUP);
     217                async_answer_0(chandle, ENOTSUP);
    218218                return;
    219219        }
    … …  
    224224        char* sata_dev_name = malloc(sata_dev_name_length);
    225225        if (sata_dev_name == NULL) {
    226                 async_answer_0(callid, ENOMEM);
     226                async_answer_0(chandle, ENOMEM);
    227227                return;
    228228        }
    … …  
    232232
    233233        size_t real_size;
    234         cap_call_handle_t cid;
    235         if ((async_data_read_receive(&cid, &real_size)) &&
     234        cap_call_handle_t call_handle;
     235        if ((async_data_read_receive(&call_handle, &real_size)) &&
    236236            (real_size == sata_dev_name_length))
    237                 async_data_read_finalize(cid, sata_dev_name, sata_dev_name_length);
     237                async_data_read_finalize(call_handle, sata_dev_name,
     238                    sata_dev_name_length);
    238239
    239240        free(sata_dev_name);
    240         async_answer_0(callid, ret);
     241        async_answer_0(chandle, ret);
    241242}
    242243
    243244static void remote_ahci_get_num_blocks(ddf_fun_t *fun, void *iface,
    244     cap_call_handle_t callid, ipc_call_t *call)
     245    cap_call_handle_t chandle, ipc_call_t *call)
    245246{
    246247        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    247248
    248249        if (ahci_iface->get_num_blocks == NULL) {
    249                 async_answer_0(callid, ENOTSUP);
     250                async_answer_0(chandle, ENOTSUP);
    250251                return;
    251252        }
    … …  
    255256
    256257        if (ret != EOK)
    257                 async_answer_0(callid, ret);
     258                async_answer_0(chandle, ret);
    258259        else
    259                 async_answer_2(callid, EOK, HI(blocks), LO(blocks));
     260                async_answer_2(chandle, EOK, HI(blocks), LO(blocks));
    260261}
    261262
    262263static void remote_ahci_get_block_size(ddf_fun_t *fun, void *iface,
    263     cap_call_handle_t callid, ipc_call_t *call)
     264    cap_call_handle_t chandle, ipc_call_t *call)
    264265{
    265266        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    266267
    267268        if (ahci_iface->get_block_size == NULL) {
    268                 async_answer_0(callid, ENOTSUP);
     269                async_answer_0(chandle, ENOTSUP);
    269270                return;
    270271        }
    … …  
    274275
    275276        if (ret != EOK)
    276                 async_answer_0(callid, ret);
     277                async_answer_0(chandle, ret);
    277278        else
    278                 async_answer_1(callid, EOK, blocks);
     279                async_answer_1(chandle, EOK, blocks);
    279280}
    280281
    281282void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface,
    282     cap_call_handle_t callid, ipc_call_t *call)
     283    cap_call_handle_t chandle, ipc_call_t *call)
    283284{
    284285        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    285286
    286287        if (ahci_iface->read_blocks == NULL) {
    287                 async_answer_0(callid, ENOTSUP);
     288                async_answer_0(chandle, ENOTSUP);
    288289                return;
    289290        }
    … …  
    292293        unsigned int flags;
    293294
    294         cap_call_handle_t cid;
    295         async_share_out_receive(&cid, &maxblock_size, &flags);
     295        cap_call_handle_t call_handle;
     296        async_share_out_receive(&call_handle, &maxblock_size, &flags);
    296297
    297298        void *buf;
    298         async_share_out_finalize(cid, &buf);
     299        async_share_out_finalize(call_handle, &buf);
    299300
    300301        const uint64_t blocknum =
    … …  
    305306        const errno_t ret = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
    306307
    307         async_answer_0(callid, ret);
    308 }
    309 
    310 void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t callid,
     308        async_answer_0(chandle, ret);
     309}
     310
     311void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle,
    311312    ipc_call_t *call)
    312313{
    … …  
    314315
    315316        if (ahci_iface->read_blocks == NULL) {
    316                 async_answer_0(callid, ENOTSUP);
     317                async_answer_0(chandle, ENOTSUP);
    317318                return;
    318319        }
    … …  
    321322        unsigned int flags;
    322323
    323         cap_call_handle_t cid;
    324         async_share_out_receive(&cid, &maxblock_size, &flags);
     324        cap_call_handle_t call_handle;
     325        async_share_out_receive(&call_handle, &maxblock_size, &flags);
    325326
    326327        void *buf;
    327         async_share_out_finalize(cid, &buf);
     328        async_share_out_finalize(call_handle, &buf);
    328329
    329330        const uint64_t blocknum =
    … …  
    334335        const errno_t ret = ahci_iface->write_blocks(fun, blocknum, cnt, buf);
    335336
    336         async_answer_0(callid, ret);
     337        async_answer_0(chandle, ret);
    337338}
    338339

  • uspace/lib/drv/generic/remote_audio_mixer.c

    r3e242d2 ra46e56b  
    219219
    220220void remote_audio_mixer_get_info(
    221     ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     221    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    222222{
    223223        audio_mixer_iface_t *mixer_iface = iface;
    224224
    225225        if (!mixer_iface->get_info) {
    226                 async_answer_0(callid, ENOTSUP);
     226                async_answer_0(chandle, ENOTSUP);
    227227                return;
    228228        }
    … …  
    231231        const errno_t ret = mixer_iface->get_info(fun, &name, &items);
    232232        const size_t name_size = name ? str_size(name) + 1 : 0;
    233         async_answer_2(callid, ret, name_size, items);
     233        async_answer_2(chandle, ret, name_size, items);
    234234        /* Send the name. */
    235235        if (ret == EOK && name_size > 0) {
    … …  
    249249
    250250void remote_audio_mixer_get_item_info(
    251     ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     251    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    252252{
    253253        audio_mixer_iface_t *mixer_iface = iface;
    254254
    255255        if (!mixer_iface->get_item_info) {
    256                 async_answer_0(callid, ENOTSUP);
     256                async_answer_0(chandle, ENOTSUP);
    257257                return;
    258258        }
    … …  
    263263        const errno_t ret = mixer_iface->get_item_info(fun, item, &name, &values);
    264264        const size_t name_size = name ? str_size(name) + 1 : 0;
    265         async_answer_2(callid, ret, name_size, values);
     265        async_answer_2(chandle, ret, name_size, values);
    266266        /* Send the name. */
    267267        if (ret == EOK && name_size > 0) {
    … …  
    281281
    282282void remote_audio_mixer_set_item_level(
    283     ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     283    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    284284{
    285285        audio_mixer_iface_t *mixer_iface = iface;
    286286
    287287        if (!mixer_iface->set_item_level) {
    288                 async_answer_0(callid, ENOTSUP);
     288                async_answer_0(chandle, ENOTSUP);
    289289                return;
    290290        }
    … …  
    292292        const unsigned value = DEV_IPC_GET_ARG2(*call);
    293293        const errno_t ret = mixer_iface->set_item_level(fun, item, value);
    294         async_answer_0(callid, ret);
     294        async_answer_0(chandle, ret);
    295295}
    296296
    297297void remote_audio_mixer_get_item_level(
    298     ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     298    ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    299299{
    300300        audio_mixer_iface_t *mixer_iface = iface;
    301301
    302302        if (!mixer_iface->get_item_level) {
    303                 async_answer_0(callid, ENOTSUP);
     303                async_answer_0(chandle, ENOTSUP);
    304304                return;
    305305        }
    … …  
    308308        const errno_t ret =
    309309            mixer_iface->get_item_level(fun, item, &current);
    310         async_answer_1(callid, ret, current);
     310        async_answer_1(chandle, ret, current);
    311311}
    312312

  • uspace/lib/drv/generic/remote_audio_pcm.c

    r3e242d2 ra46e56b  
    632632
    633633void remote_audio_pcm_get_info_str(ddf_fun_t *fun, void *iface,
    634     cap_call_handle_t callid, ipc_call_t *call)
     634    cap_call_handle_t chandle, ipc_call_t *call)
    635635{
    636636        const audio_pcm_iface_t *pcm_iface = iface;
    637637
    638638        if (!pcm_iface->get_info_str) {
    639                 async_answer_0(callid, ENOTSUP);
     639                async_answer_0(chandle, ENOTSUP);
    640640                return;
    641641        }
    … …  
    643643        const errno_t ret = pcm_iface->get_info_str(fun, &name);
    644644        const size_t name_size = name ? str_size(name) + 1 : 0;
    645         async_answer_1(callid, ret, name_size);
     645        async_answer_1(chandle, ret, name_size);
    646646        /* Send the string. */
    647647        if (ret == EOK && name_size > 0) {
    … …  
    660660}
    661661
    662 void remote_audio_pcm_query_caps(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     662void remote_audio_pcm_query_caps(ddf_fun_t *fun, void *iface,
     663    cap_call_handle_t chandle, ipc_call_t *call)
    663664{
    664665        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    666667        if (pcm_iface->query_cap) {
    667668                const unsigned value = pcm_iface->query_cap(fun, cap);
    668                 async_answer_1(callid, EOK, value);
     669                async_answer_1(chandle, EOK, value);
    669670        } else {
    670                 async_answer_0(callid, ENOTSUP);
    671         }
    672 }
    673 
    674 static void remote_audio_pcm_events_register(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     671                async_answer_0(chandle, ENOTSUP);
     672        }
     673}
     674
     675static void remote_audio_pcm_events_register(ddf_fun_t *fun, void *iface,
     676    cap_call_handle_t chandle, ipc_call_t *call)
    675677{
    676678        const audio_pcm_iface_t *pcm_iface = iface;
    677679        if (!pcm_iface->get_event_session ||
    678680            !pcm_iface->set_event_session) {
    679                 async_answer_0(callid, ENOTSUP);
    680                 return;
    681         }
    682 
    683         async_answer_0(callid, EOK);
     681                async_answer_0(chandle, ENOTSUP);
     682                return;
     683        }
     684
     685        async_answer_0(chandle, EOK);
    684686
    685687        ipc_call_t callback_call;
    686         cap_call_handle_t callback_id = async_get_call(&callback_call);
     688        cap_call_handle_t callback_handle = async_get_call(&callback_call);
    687689        async_sess_t *sess =
    688690            async_callback_receive_start(EXCHANGE_ATOMIC, &callback_call);
    689691        if (sess == NULL) {
    690692                ddf_msg(LVL_DEBUG, "Failed to create event callback");
    691                 async_answer_0(callback_id, EAGAIN);
     693                async_answer_0(callback_handle, EAGAIN);
    692694                return;
    693695        }
    … …  
    696698                ddf_msg(LVL_DEBUG, "Failed to set event callback.");
    697699                async_hangup(sess);
    698                 async_answer_0(callback_id, ret);
    699                 return;
    700         }
    701         async_answer_0(callback_id, EOK);
    702 }
    703 
    704 static void remote_audio_pcm_events_unregister(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     700                async_answer_0(callback_handle, ret);
     701                return;
     702        }
     703        async_answer_0(callback_handle, EOK);
     704}
     705
     706static void remote_audio_pcm_events_unregister(ddf_fun_t *fun, void *iface,
     707    cap_call_handle_t chandle, ipc_call_t *call)
    705708{
    706709        const audio_pcm_iface_t *pcm_iface = iface;
    707710        if (!pcm_iface->get_event_session ||
    708711            !pcm_iface->set_event_session) {
    709                 async_answer_0(callid, ENOTSUP);
     712                async_answer_0(chandle, ENOTSUP);
    710713                return;
    711714        }
    … …  
    715718                pcm_iface->set_event_session(fun, NULL);
    716719        }
    717         async_answer_0(callid, EOK);
    718 }
    719 
    720 void remote_audio_pcm_get_buffer_pos(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     720        async_answer_0(chandle, EOK);
     721}
     722
     723void remote_audio_pcm_get_buffer_pos(ddf_fun_t *fun, void *iface,
     724    cap_call_handle_t chandle, ipc_call_t *call)
    721725{
    722726        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    724728        const errno_t ret = pcm_iface->get_buffer_pos ?
    725729            pcm_iface->get_buffer_pos(fun, &pos) : ENOTSUP;
    726         async_answer_1(callid, ret, pos);
    727 }
    728 
    729 void remote_audio_pcm_test_format(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     730        async_answer_1(chandle, ret, pos);
     731}
     732
     733void remote_audio_pcm_test_format(ddf_fun_t *fun, void *iface,
     734    cap_call_handle_t chandle, ipc_call_t *call)
    730735{
    731736        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    735740        const errno_t ret = pcm_iface->test_format ?
    736741            pcm_iface->test_format(fun, &channels, &rate, &format) : ENOTSUP;
    737         async_answer_3(callid, ret, channels, rate, format);
     742        async_answer_3(chandle, ret, channels, rate, format);
    738743}
    739744
    740745void remote_audio_pcm_get_buffer(ddf_fun_t *fun, void *iface,
    741     cap_call_handle_t callid, ipc_call_t *call)
     746    cap_call_handle_t chandle, ipc_call_t *call)
    742747{
    743748        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    745750        if (!pcm_iface->get_buffer ||
    746751            !pcm_iface->release_buffer) {
    747                 async_answer_0(callid, ENOTSUP);
     752                async_answer_0(chandle, ENOTSUP);
    748753                return;
    749754        }
    … …  
    751756        size_t size = DEV_IPC_GET_ARG1(*call);
    752757        errno_t ret = pcm_iface->get_buffer(fun, &buffer, &size);
    753         async_answer_1(callid, ret, size);
     758        async_answer_1(chandle, ret, size);
    754759        if (ret != EOK || size == 0)
    755760                return;
    … …  
    788793
    789794void remote_audio_pcm_release_buffer(ddf_fun_t *fun, void *iface,
    790     cap_call_handle_t callid, ipc_call_t *call)
     795    cap_call_handle_t chandle, ipc_call_t *call)
    791796{
    792797        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    794799        const errno_t ret = pcm_iface->release_buffer ?
    795800            pcm_iface->release_buffer(fun) : ENOTSUP;
    796         async_answer_0(callid, ret);
     801        async_answer_0(chandle, ret);
    797802}
    798803
    799804void remote_audio_pcm_start_playback(ddf_fun_t *fun, void *iface,
    800     cap_call_handle_t callid, ipc_call_t *call)
     805    cap_call_handle_t chandle, ipc_call_t *call)
    801806{
    802807        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    810815            ? pcm_iface->start_playback(fun, frames, channels, rate, format)
    811816            : ENOTSUP;
    812         async_answer_0(callid, ret);
     817        async_answer_0(chandle, ret);
    813818}
    814819
    815820void remote_audio_pcm_stop_playback(ddf_fun_t *fun, void *iface,
    816     cap_call_handle_t callid, ipc_call_t *call)
     821    cap_call_handle_t chandle, ipc_call_t *call)
    817822{
    818823        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    821826        const errno_t ret = pcm_iface->stop_playback ?
    822827            pcm_iface->stop_playback(fun, immediate) : ENOTSUP;
    823         async_answer_0(callid, ret);
     828        async_answer_0(chandle, ret);
    824829}
    825830
    826831void remote_audio_pcm_start_capture(ddf_fun_t *fun, void *iface,
    827     cap_call_handle_t callid, ipc_call_t *call)
     832    cap_call_handle_t chandle, ipc_call_t *call)
    828833{
    829834        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    837842            ? pcm_iface->start_capture(fun, frames, channels, rate, format)
    838843            : ENOTSUP;
    839         async_answer_0(callid, ret);
     844        async_answer_0(chandle, ret);
    840845}
    841846
    842847void remote_audio_pcm_stop_capture(ddf_fun_t *fun, void *iface,
    843     cap_call_handle_t callid, ipc_call_t *call)
     848    cap_call_handle_t chandle, ipc_call_t *call)
    844849{
    845850        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    848853        const errno_t ret = pcm_iface->stop_capture ?
    849854            pcm_iface->stop_capture(fun, immediate) : ENOTSUP;
    850         async_answer_0(callid, ret);
     855        async_answer_0(chandle, ret);
    851856}
    852857

  • uspace/lib/drv/generic/remote_battery_dev.c

    r3e242d2 ra46e56b  
    118118 */
    119119static void
    120 remote_battery_status_get(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
     120remote_battery_status_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
    121121    ipc_call_t *call)
    122122{
    … …  
    124124
    125125        if (bops->battery_status_get == NULL) {
    126                 async_answer_0(callid, ENOTSUP);
     126                async_answer_0(chandle, ENOTSUP);
    127127                return;
    128128        }
    … …  
    132132
    133133        if (rc != EOK)
    134                 async_answer_0(callid, rc);
     134                async_answer_0(chandle, rc);
    135135        else
    136                 async_answer_1(callid, rc, batt_status);
     136                async_answer_1(chandle, rc, batt_status);
    137137}
    138138
    … …  
    144144 */
    145145static void
    146 remote_battery_charge_level_get(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
     146remote_battery_charge_level_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
    147147    ipc_call_t *call)
    148148{
    … …  
    150150
    151151        if (bops->battery_charge_level_get == NULL) {
    152                 async_answer_0(callid, ENOTSUP);
     152                async_answer_0(chandle, ENOTSUP);
    153153                return;
    154154        }
    … …  
    158158
    159159        if (rc != EOK)
    160                 async_answer_0(callid, rc);
     160                async_answer_0(chandle, rc);
    161161        else
    162                 async_answer_1(callid, rc, battery_level);
     162                async_answer_1(chandle, rc, battery_level);
    163163}
    164164

  • uspace/lib/drv/generic/remote_clock_dev.c

    r3e242d2 ra46e56b  
    6969 */
    7070static void
    71 remote_clock_time_get(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
     71remote_clock_time_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
    7272    ipc_call_t *call)
    7373{
    7474        clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops;
    75         cap_call_handle_t cid;
     75        cap_call_handle_t call_handle;
    7676        struct tm t;
    7777        errno_t rc;
    7878        size_t len;
    7979
    80         if (!async_data_read_receive(&cid, &len)) {
     80        if (!async_data_read_receive(&call_handle, &len)) {
    8181                /* TODO: Handle protocol error */
    82                 async_answer_0(callid, EINVAL);
     82                async_answer_0(chandle, EINVAL);
    8383                return;
    8484        }
    … …  
    8686        if (!clock_dev_ops->time_get) {
    8787                /* The driver does not provide the time_get() functionality */
    88                 async_answer_0(cid, ENOTSUP);
    89                 async_answer_0(callid, ENOTSUP);
     88                async_answer_0(call_handle, ENOTSUP);
     89                async_answer_0(chandle, ENOTSUP);
    9090                return;
    9191        }
    … …  
    9595        if (rc != EOK) {
    9696                /* Some error occurred */
    97                 async_answer_0(cid, rc);
    98                 async_answer_0(callid, rc);
     97                async_answer_0(call_handle, rc);
     98                async_answer_0(chandle, rc);
    9999                return;
    100100        }
    101101
    102102        /* The operation was successful */
    103         async_data_read_finalize(cid, &t, sizeof(struct tm));
    104         async_answer_0(callid, rc);
     103        async_data_read_finalize(call_handle, &t, sizeof(struct tm));
     104        async_answer_0(chandle, rc);
    105105}
    106106
    … …  
    111111 */
    112112static void remote_clock_time_set(ddf_fun_t *fun, void *ops,
    113     cap_call_handle_t callid, ipc_call_t *call)
     113    cap_call_handle_t chandle, ipc_call_t *call)
    114114{
    115115        clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops;
    116116        errno_t      rc;
    117117        struct tm    t;
    118         cap_call_handle_t cid;
     118        cap_call_handle_t call_handle;
    119119        size_t       len;
    120120
    121         if (!async_data_write_receive(&cid, &len)) {
     121        if (!async_data_write_receive(&call_handle, &len)) {
    122122                /* TODO: Handle protocol error */
    123                 async_answer_0(callid, EINVAL);
     123                async_answer_0(chandle, EINVAL);
    124124                return;
    125125        }
    … …  
    127127        if (!clock_dev_ops->time_set) {
    128128                /* The driver does not support the time_set() functionality */
    129                 async_answer_0(cid, ENOTSUP);
    130                 async_answer_0(callid, ENOTSUP);
     129                async_answer_0(call_handle, ENOTSUP);
     130                async_answer_0(chandle, ENOTSUP);
    131131                return;
    132132        }
    133133
    134         async_data_write_finalize(cid, &t, sizeof(struct tm));
     134        async_data_write_finalize(call_handle, &t, sizeof(struct tm));
    135135
    136136        rc = (*clock_dev_ops->time_set)(fun, &t);
    137137
    138         async_answer_0(callid, rc);
     138        async_answer_0(chandle, rc);
    139139}
    140140

  • uspace/lib/drv/generic/remote_hw_res.c

    r3e242d2 ra46e56b  
    6969
    7070static void remote_hw_res_enable_interrupt(ddf_fun_t *fun, void *ops,
    71     cap_call_handle_t callid, ipc_call_t *call)
     71    cap_call_handle_t chandle, ipc_call_t *call)
    7272{
    7373        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    7474
    7575        if (hw_res_ops->enable_interrupt == NULL) {
    76                 async_answer_0(callid, ENOTSUP);
     76                async_answer_0(chandle, ENOTSUP);
    7777                return;
    7878        }
    … …  
    8080        const int irq = DEV_IPC_GET_ARG1(*call);
    8181        const errno_t ret = hw_res_ops->enable_interrupt(fun, irq);
    82         async_answer_0(callid, ret);
     82        async_answer_0(chandle, ret);
    8383}
    8484
    8585static void remote_hw_res_disable_interrupt(ddf_fun_t *fun, void *ops,
    86     cap_call_handle_t callid, ipc_call_t *call)
     86    cap_call_handle_t chandle, ipc_call_t *call)
    8787{
    8888        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    8989
    9090        if (hw_res_ops->disable_interrupt == NULL) {
    91                 async_answer_0(callid, ENOTSUP);
     91                async_answer_0(chandle, ENOTSUP);
    9292                return;
    9393        }
    … …  
    9595        const int irq = DEV_IPC_GET_ARG1(*call);
    9696        const errno_t ret = hw_res_ops->disable_interrupt(fun, irq);
    97         async_answer_0(callid, ret);
     97        async_answer_0(chandle, ret);
    9898}
    9999
    100100static void remote_hw_res_clear_interrupt(ddf_fun_t *fun, void *ops,
    101     cap_call_handle_t callid, ipc_call_t *call)
     101    cap_call_handle_t chandle, ipc_call_t *call)
    102102{
    103103        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    104104
    105105        if (hw_res_ops->clear_interrupt == NULL) {
    106                 async_answer_0(callid, ENOTSUP);
     106                async_answer_0(chandle, ENOTSUP);
    107107                return;
    108108        }
    … …  
    110110        const int irq = DEV_IPC_GET_ARG1(*call);
    111111        const errno_t ret = hw_res_ops->enable_interrupt(fun, irq);
    112         async_answer_0(callid, ret);
     112        async_answer_0(chandle, ret);
    113113}
    114114
    115115static void remote_hw_res_get_resource_list(ddf_fun_t *fun, void *ops,
    116     cap_call_handle_t callid, ipc_call_t *call)
     116    cap_call_handle_t chandle, ipc_call_t *call)
    117117{
    118118        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    119119
    120120        if (hw_res_ops->get_resource_list == NULL) {
    121                 async_answer_0(callid, ENOTSUP);
     121                async_answer_0(chandle, ENOTSUP);
    122122                return;
    123123        }
    … …  
    125125        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(fun);
    126126        if (hw_resources == NULL){
    127                 async_answer_0(callid, ENOENT);
     127                async_answer_0(chandle, ENOENT);
    128128                return;
    129129        }
    130130
    131         async_answer_1(callid, EOK, hw_resources->count);
     131        async_answer_1(chandle, EOK, hw_resources->count);
    132132
    133133        size_t len;
    134         if (!async_data_read_receive(&callid, &len)) {
     134        if (!async_data_read_receive(&chandle, &len)) {
    135135                /* Protocol error - the recipient is not accepting data */
    136136                return;
    137137        }
    138         async_data_read_finalize(callid, hw_resources->resources, len);
     138        async_data_read_finalize(chandle, hw_resources->resources, len);
    139139}
    140140
    141141static void remote_hw_res_dma_channel_setup(ddf_fun_t *fun, void *ops,
    142     cap_call_handle_t callid, ipc_call_t *call)
     142    cap_call_handle_t chandle, ipc_call_t *call)
    143143{
    144144        hw_res_ops_t *hw_res_ops = ops;
    145145
    146146        if (hw_res_ops->dma_channel_setup == NULL) {
    147                 async_answer_0(callid, ENOTSUP);
     147                async_answer_0(chandle, ENOTSUP);
    148148                return;
    149149        }
    … …  
    155155        const errno_t ret = hw_res_ops->dma_channel_setup(
    156156            fun, channel, address, size, mode);
    157         async_answer_0(callid, ret);
     157        async_answer_0(chandle, ret);
    158158}
    159159
    160160static void remote_hw_res_dma_channel_remain(ddf_fun_t *fun, void *ops,
    161     cap_call_handle_t callid, ipc_call_t *call)
     161    cap_call_handle_t chandle, ipc_call_t *call)
    162162{
    163163        hw_res_ops_t *hw_res_ops = ops;
    164164
    165165        if (hw_res_ops->dma_channel_setup == NULL) {
    166                 async_answer_0(callid, ENOTSUP);
     166                async_answer_0(chandle, ENOTSUP);
    167167                return;
    168168        }
    … …  
    170170        size_t remain = 0;
    171171        const errno_t ret = hw_res_ops->dma_channel_remain(fun, channel, &remain);
    172         async_answer_1(callid, ret, remain);
     172        async_answer_1(chandle, ret, remain);
    173173}
    174174/**

  • uspace/lib/drv/generic/remote_ieee80211.c

    r3e242d2 ra46e56b  
    268268
    269269static void remote_ieee80211_get_scan_results(ddf_fun_t *fun, void *iface,
    270     cap_call_handle_t callid, ipc_call_t *call)
     270    cap_call_handle_t chandle, ipc_call_t *call)
    271271{
    272272        ieee80211_iface_t *ieee80211_iface = (ieee80211_iface_t *) iface;
    … …  
    280280        errno_t rc = ieee80211_iface->get_scan_results(fun, &scan_results, now);
    281281        if (rc == EOK) {
    282                 cap_call_handle_t data_callid;
     282                cap_call_handle_t data_chandle;
    283283                size_t max_len;
    284                 if (!async_data_read_receive(&data_callid, &max_len)) {
    285                         async_answer_0(data_callid, EINVAL);
    286                         async_answer_0(callid, EINVAL);
     284                if (!async_data_read_receive(&data_chandle, &max_len)) {
     285                        async_answer_0(data_chandle, EINVAL);
     286                        async_answer_0(chandle, EINVAL);
    287287                        return;
    288288                }
    289289
    290290                if (max_len < sizeof(ieee80211_scan_results_t)) {
    291                         async_answer_0(data_callid, ELIMIT);
    292                         async_answer_0(callid, ELIMIT);
     291                        async_answer_0(data_chandle, ELIMIT);
     292                        async_answer_0(chandle, ELIMIT);
    293293                        return;
    294294                }
    295295
    296                 async_data_read_finalize(data_callid, &scan_results,
     296                async_data_read_finalize(data_chandle, &scan_results,
    297297                    sizeof(ieee80211_scan_results_t));
    298298        }
    299299
    300         async_answer_0(callid, rc);
     300        async_answer_0(chandle, rc);
    301301}
    302302
    303303static void remote_ieee80211_connect(ddf_fun_t *fun, void *iface,
    304     cap_call_handle_t callid, ipc_call_t *call)
     304    cap_call_handle_t chandle, ipc_call_t *call)
    305305{
    306306        ieee80211_iface_t *ieee80211_iface = (ieee80211_iface_t *) iface;
    … …  
    310310        char password[MAX_STRING_SIZE];
    311311
    312         cap_call_handle_t data_callid;
     312        cap_call_handle_t data_chandle;
    313313        size_t len;
    314         if (!async_data_write_receive(&data_callid, &len)) {
    315                 async_answer_0(data_callid, EINVAL);
    316                 async_answer_0(callid, EINVAL);
     314        if (!async_data_write_receive(&data_chandle, &len)) {
     315                async_answer_0(data_chandle, EINVAL);
     316                async_answer_0(chandle, EINVAL);
    317317                return;
    318318        }
    319319
    320320        if (len > MAX_STRING_SIZE) {
    321                 async_answer_0(data_callid, EINVAL);
    322                 async_answer_0(callid, EINVAL);
    323                 return;
    324         }
    325 
    326         errno_t rc = async_data_write_finalize(data_callid, ssid_start, len);
     321                async_answer_0(data_chandle, EINVAL);
     322                async_answer_0(chandle, EINVAL);
     323                return;
     324        }
     325
     326        errno_t rc = async_data_write_finalize(data_chandle, ssid_start, len);
    327327        if (rc != EOK) {
    328                 async_answer_0(data_callid, EINVAL);
    329                 async_answer_0(callid, EINVAL);
    330                 return;
    331         }
    332 
    333         if (!async_data_write_receive(&data_callid, &len)) {
    334                 async_answer_0(data_callid, EINVAL);
    335                 async_answer_0(callid, EINVAL);
     328                async_answer_0(data_chandle, EINVAL);
     329                async_answer_0(chandle, EINVAL);
     330                return;
     331        }
     332
     333        if (!async_data_write_receive(&data_chandle, &len)) {
     334                async_answer_0(data_chandle, EINVAL);
     335                async_answer_0(chandle, EINVAL);
    336336                return;
    337337        }
    338338
    339339        if (len > MAX_STRING_SIZE) {
    340                 async_answer_0(data_callid, EINVAL);
    341                 async_answer_0(callid, EINVAL);
    342                 return;
    343         }
    344 
    345         rc = async_data_write_finalize(data_callid, password, len);
     340                async_answer_0(data_chandle, EINVAL);
     341                async_answer_0(chandle, EINVAL);
     342                return;
     343        }
     344
     345        rc = async_data_write_finalize(data_chandle, password, len);
    346346        if (rc != EOK) {
    347                 async_answer_0(data_callid, EINVAL);
    348                 async_answer_0(callid, EINVAL);
     347                async_answer_0(data_chandle, EINVAL);
     348                async_answer_0(chandle, EINVAL);
    349349                return;
    350350        }
    … …  
    352352        rc = ieee80211_iface->connect(fun, ssid_start, password);
    353353
    354         async_answer_0(callid, rc);
     354        async_answer_0(chandle, rc);
    355355}
    356356
    357357static void remote_ieee80211_disconnect(ddf_fun_t *fun, void *iface,
    358     cap_call_handle_t callid, ipc_call_t *call)
     358    cap_call_handle_t chandle, ipc_call_t *call)
    359359{
    360360        ieee80211_iface_t *ieee80211_iface = (ieee80211_iface_t *) iface;
    361361        assert(ieee80211_iface->disconnect);
    362362        errno_t rc = ieee80211_iface->disconnect(fun);
    363         async_answer_0(callid, rc);
     363        async_answer_0(chandle, rc);
    364364}
    365365

  • uspace/lib/drv/generic/remote_led_dev.c

    r3e242d2 ra46e56b  
    6666 *
    6767 */
    68 static void remote_led_color_set(ddf_fun_t *fun, void *ops, cap_call_handle_t callid,
     68static void remote_led_color_set(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
    6969    ipc_call_t *call)
    7070{
    … …  
    7373
    7474        if (!led_dev_ops->color_set) {
    75                 async_answer_0(callid, ENOTSUP);
     75                async_answer_0(chandle, ENOTSUP);
    7676                return;
    7777        }
    7878
    7979        errno_t rc = (*led_dev_ops->color_set)(fun, color);
    80         async_answer_0(callid, rc);
     80        async_answer_0(chandle, rc);
    8181}
    8282

  • uspace/lib/drv/generic/remote_nic.c

    r3e242d2 ra46e56b  
    13371337
    13381338static void remote_nic_send_frame(ddf_fun_t *dev, void *iface,
    1339     cap_call_handle_t callid, ipc_call_t *call)
     1339    cap_call_handle_t chandle, ipc_call_t *call)
    13401340{
    13411341        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13481348        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    13491349        if (rc != EOK) {
    1350                 async_answer_0(callid, EINVAL);
     1350                async_answer_0(chandle, EINVAL);
    13511351                return;
    13521352        }
    13531353
    13541354        rc = nic_iface->send_frame(dev, data, size);
    1355         async_answer_0(callid, rc);
     1355        async_answer_0(chandle, rc);
    13561356        free(data);
    13571357}
    13581358
    13591359static void remote_nic_callback_create(ddf_fun_t *dev, void *iface,
    1360     cap_call_handle_t callid, ipc_call_t *call)
     1360    cap_call_handle_t chandle, ipc_call_t *call)
    13611361{
    13621362        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13641364
    13651365        errno_t rc = nic_iface->callback_create(dev);
    1366         async_answer_0(callid, rc);
     1366        async_answer_0(chandle, rc);
    13671367}
    13681368
    13691369static void remote_nic_get_state(ddf_fun_t *dev, void *iface,
    1370     cap_call_handle_t callid, ipc_call_t *call)
     1370    cap_call_handle_t chandle, ipc_call_t *call)
    13711371{
    13721372        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13761376
    13771377        errno_t rc = nic_iface->get_state(dev, &state);
    1378         async_answer_1(callid, rc, state);
     1378        async_answer_1(chandle, rc, state);
    13791379}
    13801380
    13811381static void remote_nic_set_state(ddf_fun_t *dev, void *iface,
    1382     cap_call_handle_t callid, ipc_call_t *call)
     1382    cap_call_handle_t chandle, ipc_call_t *call)
    13831383{
    13841384        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13881388
    13891389        errno_t rc = nic_iface->set_state(dev, state);
    1390         async_answer_0(callid, rc);
     1390        async_answer_0(chandle, rc);
    13911391}
    13921392
    13931393static void remote_nic_get_address(ddf_fun_t *dev, void *iface,
    1394     cap_call_handle_t callid, ipc_call_t *call)
     1394    cap_call_handle_t chandle, ipc_call_t *call)
    13951395{
    13961396        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    14031403        if (rc == EOK) {
    14041404                size_t max_len;
    1405                 cap_call_handle_t data_callid;
     1405                cap_call_handle_t data_chandle;
    14061406
    14071407                /* All errors will be translated into EPARTY anyway */
    1408                 if (!async_data_read_receive(&data_callid, &max_len)) {
    1409                         async_answer_0(data_callid, EINVAL);
    1410                         async_answer_0(callid, EINVAL);
     1408                if (!async_data_read_receive(&data_chandle, &max_len)) {
     1409                        async_answer_0(data_chandle, EINVAL);
     1410                        async_answer_0(chandle, EINVAL);
    14111411                        return;
    14121412                }
    14131413
    14141414                if (max_len != sizeof(nic_address_t)) {
    1415                         async_answer_0(data_callid, ELIMIT);
    1416                         async_answer_0(callid, ELIMIT);
    1417                         return;
    1418                 }
    1419 
    1420                 async_data_read_finalize(data_callid, &address,
     1415                        async_answer_0(data_chandle, ELIMIT);
     1416                        async_answer_0(chandle, ELIMIT);
     1417                        return;
     1418                }
     1419
     1420                async_data_read_finalize(data_chandle, &address,
    14211421                    sizeof(nic_address_t));
    14221422        }
    14231423
    1424         async_answer_0(callid, rc);
     1424        async_answer_0(chandle, rc);
    14251425}
    14261426
    14271427static void remote_nic_set_address(ddf_fun_t *dev, void *iface,
    1428     cap_call_handle_t callid, ipc_call_t *call)
     1428    cap_call_handle_t chandle, ipc_call_t *call)
    14291429{
    14301430        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    14311431
    14321432        size_t length;
    1433         cap_call_handle_t data_callid;
    1434         if (!async_data_write_receive(&data_callid, &length)) {
    1435                 async_answer_0(data_callid, EINVAL);
    1436                 async_answer_0(callid, EINVAL);
     1433        cap_call_handle_t data_chandle;
     1434        if (!async_data_write_receive(&data_chandle, &length)) {
     1435                async_answer_0(data_chandle, EINVAL);
     1436                async_answer_0(chandle, EINVAL);
    14371437                return;
    14381438        }
    14391439
    14401440        if (length > sizeof(nic_address_t)) {
    1441                 async_answer_0(data_callid, ELIMIT);
    1442                 async_answer_0(callid, ELIMIT);
     1441                async_answer_0(data_chandle, ELIMIT);
     1442                async_answer_0(chandle, ELIMIT);
    14431443                return;
    14441444        }
    14451445
    14461446        nic_address_t address;
    1447         if (async_data_write_finalize(data_callid, &address, length) != EOK) {
    1448                 async_answer_0(callid, EINVAL);
     1447        if (async_data_write_finalize(data_chandle, &address, length) != EOK) {
     1448                async_answer_0(chandle, EINVAL);
    14491449                return;
    14501450        }
    … …  
    14521452        if (nic_iface->set_address != NULL) {
    14531453                errno_t rc = nic_iface->set_address(dev, &address);
    1454                 async_answer_0(callid, rc);
     1454                async_answer_0(chandle, rc);
    14551455        } else
    1456                 async_answer_0(callid, ENOTSUP);
     1456                async_answer_0(chandle, ENOTSUP);
    14571457}
    14581458
    14591459static void remote_nic_get_stats(ddf_fun_t *dev, void *iface,
    1460     cap_call_handle_t callid, ipc_call_t *call)
     1460    cap_call_handle_t chandle, ipc_call_t *call)
    14611461{
    14621462        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    14631463        if (nic_iface->get_stats == NULL) {
    1464                 async_answer_0(callid, ENOTSUP);
     1464                async_answer_0(chandle, ENOTSUP);
    14651465                return;
    14661466        }
    … …  
    14711471        errno_t rc = nic_iface->get_stats(dev, &stats);
    14721472        if (rc == EOK) {
    1473                 cap_call_handle_t data_callid;
     1473                cap_call_handle_t data_chandle;
    14741474                size_t max_len;
    1475                 if (!async_data_read_receive(&data_callid, &max_len)) {
    1476                         async_answer_0(data_callid, EINVAL);
    1477                         async_answer_0(callid, EINVAL);
     1475                if (!async_data_read_receive(&data_chandle, &max_len)) {
     1476                        async_answer_0(data_chandle, EINVAL);
     1477                        async_answer_0(chandle, EINVAL);
    14781478                        return;
    14791479                }
    14801480
    14811481                if (max_len < sizeof(nic_device_stats_t)) {
    1482                         async_answer_0(data_callid, ELIMIT);
    1483                         async_answer_0(callid, ELIMIT);
    1484                         return;
    1485                 }
    1486 
    1487                 async_data_read_finalize(data_callid, &stats,
     1482                        async_answer_0(data_chandle, ELIMIT);
     1483                        async_answer_0(chandle, ELIMIT);
     1484                        return;
     1485                }
     1486
     1487                async_data_read_finalize(data_chandle, &stats,
    14881488                    sizeof(nic_device_stats_t));
    14891489        }
    14901490
    1491         async_answer_0(callid, rc);
     1491        async_answer_0(chandle, rc);
    14921492}
    14931493
    14941494static void remote_nic_get_device_info(ddf_fun_t *dev, void *iface,
    1495     cap_call_handle_t callid, ipc_call_t *call)
     1495    cap_call_handle_t chandle, ipc_call_t *call)
    14961496{
    14971497        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    14981498        if (nic_iface->get_device_info == NULL) {
    1499                 async_answer_0(callid, ENOTSUP);
     1499                async_answer_0(chandle, ENOTSUP);
    15001500                return;
    15011501        }
    … …  
    15061506        errno_t rc = nic_iface->get_device_info(dev, &info);
    15071507        if (rc == EOK) {
    1508                 cap_call_handle_t data_callid;
     1508                cap_call_handle_t data_chandle;
    15091509                size_t max_len;
    1510                 if (!async_data_read_receive(&data_callid, &max_len)) {
    1511                         async_answer_0(data_callid, EINVAL);
    1512                         async_answer_0(callid, EINVAL);
     1510                if (!async_data_read_receive(&data_chandle, &max_len)) {
     1511                        async_answer_0(data_chandle, EINVAL);
     1512                        async_answer_0(chandle, EINVAL);
    15131513                        return;
    15141514                }
    15151515
    15161516                if (max_len < sizeof (nic_device_info_t)) {
    1517                         async_answer_0(data_callid, ELIMIT);
    1518                         async_answer_0(callid, ELIMIT);
    1519                         return;
    1520                 }
    1521 
    1522                 async_data_read_finalize(data_callid, &info,
     1517                        async_answer_0(data_chandle, ELIMIT);
     1518                        async_answer_0(chandle, ELIMIT);
     1519                        return;
     1520                }
     1521
     1522                async_data_read_finalize(data_chandle, &info,
    15231523                    sizeof(nic_device_info_t));
    15241524        }
    15251525
    1526         async_answer_0(callid, rc);
     1526        async_answer_0(chandle, rc);
    15271527}
    15281528
    15291529static void remote_nic_get_cable_state(ddf_fun_t *dev, void *iface,
    1530     cap_call_handle_t callid, ipc_call_t *call)
     1530    cap_call_handle_t chandle, ipc_call_t *call)
    15311531{
    15321532        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15331533        if (nic_iface->get_cable_state == NULL) {
    1534                 async_answer_0(callid, ENOTSUP);
     1534                async_answer_0(chandle, ENOTSUP);
    15351535                return;
    15361536        }
    … …  
    15391539
    15401540        errno_t rc = nic_iface->get_cable_state(dev, &cs);
    1541         async_answer_1(callid, rc, (sysarg_t) cs);
     1541        async_answer_1(chandle, rc, (sysarg_t) cs);
    15421542}
    15431543
    15441544static void remote_nic_get_operation_mode(ddf_fun_t *dev, void *iface,
    1545     cap_call_handle_t callid, ipc_call_t *call)
     1545    cap_call_handle_t chandle, ipc_call_t *call)
    15461546{
    15471547        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15481548        if (nic_iface->get_operation_mode == NULL) {
    1549                 async_answer_0(callid, ENOTSUP);
     1549                async_answer_0(chandle, ENOTSUP);
    15501550                return;
    15511551        }
    … …  
    15561556
    15571557        errno_t rc = nic_iface->get_operation_mode(dev, &speed, &duplex, &role);
    1558         async_answer_3(callid, rc, (sysarg_t) speed, (sysarg_t) duplex,
     1558        async_answer_3(chandle, rc, (sysarg_t) speed, (sysarg_t) duplex,
    15591559            (sysarg_t) role);
    15601560}
    15611561
    15621562static void remote_nic_set_operation_mode(ddf_fun_t *dev, void *iface,
    1563     cap_call_handle_t callid, ipc_call_t *call)
     1563    cap_call_handle_t chandle, ipc_call_t *call)
    15641564{
    15651565        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15661566        if (nic_iface->set_operation_mode == NULL) {
    1567                 async_answer_0(callid, ENOTSUP);
     1567                async_answer_0(chandle, ENOTSUP);
    15681568                return;
    15691569        }
    … …  
    15741574
    15751575        errno_t rc = nic_iface->set_operation_mode(dev, speed, duplex, role);
    1576         async_answer_0(callid, rc);
     1576        async_answer_0(chandle, rc);
    15771577}
    15781578
    15791579static void remote_nic_autoneg_enable(ddf_fun_t *dev, void *iface,
    1580     cap_call_handle_t callid, ipc_call_t *call)
     1580    cap_call_handle_t chandle, ipc_call_t *call)
    15811581{
    15821582        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15831583        if (nic_iface->autoneg_enable == NULL) {
    1584                 async_answer_0(callid, ENOTSUP);
     1584                async_answer_0(chandle, ENOTSUP);
    15851585                return;
    15861586        }
    … …  
    15891589
    15901590        errno_t rc = nic_iface->autoneg_enable(dev, advertisement);
    1591         async_answer_0(callid, rc);
     1591        async_answer_0(chandle, rc);
    15921592}
    15931593
    15941594static void remote_nic_autoneg_disable(ddf_fun_t *dev, void *iface,
    1595     cap_call_handle_t callid, ipc_call_t *call)
     1595    cap_call_handle_t chandle, ipc_call_t *call)
    15961596{
    15971597        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15981598        if (nic_iface->autoneg_disable == NULL) {
    1599                 async_answer_0(callid, ENOTSUP);
     1599                async_answer_0(chandle, ENOTSUP);
    16001600                return;
    16011601        }
    16021602
    16031603        errno_t rc = nic_iface->autoneg_disable(dev);
    1604         async_answer_0(callid, rc);
     1604        async_answer_0(chandle, rc);
    16051605}
    16061606
    16071607static void remote_nic_autoneg_probe(ddf_fun_t *dev, void *iface,
    1608     cap_call_handle_t callid, ipc_call_t *call)
     1608    cap_call_handle_t chandle, ipc_call_t *call)
    16091609{
    16101610        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16111611        if (nic_iface->autoneg_probe == NULL) {
    1612                 async_answer_0(callid, ENOTSUP);
     1612                async_answer_0(chandle, ENOTSUP);
    16131613                return;
    16141614        }
    … …  
    16211621        errno_t rc = nic_iface->autoneg_probe(dev, &our_adv, &their_adv, &result,
    16221622            &their_result);
    1623         async_answer_4(callid, rc, our_adv, their_adv, (sysarg_t) result,
     1623        async_answer_4(chandle, rc, our_adv, their_adv, (sysarg_t) result,
    16241624            (sysarg_t) their_result);
    16251625}
    16261626
    16271627static void remote_nic_autoneg_restart(ddf_fun_t *dev, void *iface,
    1628     cap_call_handle_t callid, ipc_call_t *call)
     1628    cap_call_handle_t chandle, ipc_call_t *call)
    16291629{
    16301630        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16311631        if (nic_iface->autoneg_restart == NULL) {
    1632                 async_answer_0(callid, ENOTSUP);
     1632                async_answer_0(chandle, ENOTSUP);
    16331633                return;
    16341634        }
    16351635
    16361636        errno_t rc = nic_iface->autoneg_restart(dev);
    1637         async_answer_0(callid, rc);
     1637        async_answer_0(chandle, rc);
    16381638}
    16391639
    16401640static void remote_nic_get_pause(ddf_fun_t *dev, void *iface,
    1641     cap_call_handle_t callid, ipc_call_t *call)
     1641    cap_call_handle_t chandle, ipc_call_t *call)
    16421642{
    16431643        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16441644        if (nic_iface->get_pause == NULL) {
    1645                 async_answer_0(callid, ENOTSUP);
     1645                async_answer_0(chandle, ENOTSUP);
    16461646                return;
    16471647        }
    … …  
    16521652
    16531653        errno_t rc = nic_iface->get_pause(dev, &we_send, &we_receive, &pause);
    1654         async_answer_3(callid, rc, we_send, we_receive, pause);
     1654        async_answer_3(chandle, rc, we_send, we_receive, pause);
    16551655}
    16561656
    16571657static void remote_nic_set_pause(ddf_fun_t *dev, void *iface,
    1658     cap_call_handle_t callid, ipc_call_t *call)
     1658    cap_call_handle_t chandle, ipc_call_t *call)
    16591659{
    16601660        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16611661        if (nic_iface->set_pause == NULL) {
    1662                 async_answer_0(callid, ENOTSUP);
     1662                async_answer_0(chandle, ENOTSUP);
    16631663                return;
    16641664        }
    … …  
    16701670        errno_t rc = nic_iface->set_pause(dev, allow_send, allow_receive,
    16711671            pause);
    1672         async_answer_0(callid, rc);
     1672        async_answer_0(chandle, rc);
    16731673}
    16741674
    16751675static void remote_nic_unicast_get_mode(ddf_fun_t *dev, void *iface,
    1676     cap_call_handle_t callid, ipc_call_t *call)
     1676    cap_call_handle_t chandle, ipc_call_t *call)
    16771677{
    16781678        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16791679        if (nic_iface->unicast_get_mode == NULL) {
    1680                 async_answer_0(callid, ENOTSUP);
     1680                async_answer_0(chandle, ENOTSUP);
    16811681                return;
    16821682        }
    … …  
    16881688                address_list = malloc(max_count * sizeof (nic_address_t));
    16891689                if (!address_list) {
    1690                         async_answer_0(callid, ENOMEM);
     1690                        async_answer_0(chandle, ENOMEM);
    16911691                        return;
    16921692                }
    … …  
    17021702        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    17031703                free(address_list);
    1704                 async_answer_2(callid, rc, mode, address_count);
    1705                 return;
    1706         }
    1707 
    1708         cap_call_handle_t data_callid;
     1704                async_answer_2(chandle, rc, mode, address_count);
     1705                return;
     1706        }
     1707
     1708        cap_call_handle_t data_chandle;
    17091709        size_t max_len;
    1710         if (!async_data_read_receive(&data_callid, &max_len)) {
    1711                 async_answer_0(data_callid, EINVAL);
    1712                 async_answer_2(callid, rc, mode, address_count);
     1710        if (!async_data_read_receive(&data_chandle, &max_len)) {
     1711                async_answer_0(data_chandle, EINVAL);
     1712                async_answer_2(chandle, rc, mode, address_count);
    17131713                free(address_list);
    17141714                return;
    … …  
    17211721                max_len = max_count * sizeof(nic_address_t);
    17221722
    1723         async_data_read_finalize(data_callid, address_list, max_len);
    1724         async_answer_0(data_callid, EINVAL);
     1723        async_data_read_finalize(data_chandle, address_list, max_len);
     1724        async_answer_0(data_chandle, EINVAL);
    17251725
    17261726        free(address_list);
    1727         async_answer_2(callid, rc, mode, address_count);
     1727        async_answer_2(chandle, rc, mode, address_count);
    17281728}
    17291729
    17301730static void remote_nic_unicast_set_mode(ddf_fun_t *dev, void *iface,
    1731     cap_call_handle_t callid, ipc_call_t *call)
     1731    cap_call_handle_t chandle, ipc_call_t *call)
    17321732{
    17331733        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    17391739
    17401740        if (address_count) {
    1741                 cap_call_handle_t data_callid;
    1742                 if (!async_data_write_receive(&data_callid, &length)) {
    1743                         async_answer_0(data_callid, EINVAL);
    1744                         async_answer_0(callid, EINVAL);
     1741                cap_call_handle_t data_chandle;
     1742                if (!async_data_write_receive(&data_chandle, &length)) {
     1743                        async_answer_0(data_chandle, EINVAL);
     1744                        async_answer_0(chandle, EINVAL);
    17451745                        return;
    17461746                }
    17471747
    17481748                if (length != address_count * sizeof(nic_address_t)) {
    1749                         async_answer_0(data_callid, ELIMIT);
    1750                         async_answer_0(callid, ELIMIT);
     1749                        async_answer_0(data_chandle, ELIMIT);
     1750                        async_answer_0(chandle, ELIMIT);
    17511751                        return;
    17521752                }
    … …  
    17541754                address_list = malloc(length);
    17551755                if (address_list == NULL) {
    1756                         async_answer_0(data_callid, ENOMEM);
    1757                         async_answer_0(callid, ENOMEM);
    1758                         return;
    1759                 }
    1760 
    1761                 if (async_data_write_finalize(data_callid, address_list,
     1756                        async_answer_0(data_chandle, ENOMEM);
     1757                        async_answer_0(chandle, ENOMEM);
     1758                        return;
     1759                }
     1760
     1761                if (async_data_write_finalize(data_chandle, address_list,
    17621762                    length) != EOK) {
    1763                         async_answer_0(callid, EINVAL);
     1763                        async_answer_0(chandle, EINVAL);
    17641764                        free(address_list);
    17651765                        return;
    … …  
    17701770                errno_t rc = nic_iface->unicast_set_mode(dev, mode, address_list,
    17711771                    address_count);
    1772                 async_answer_0(callid, rc);
     1772                async_answer_0(chandle, rc);
    17731773        } else
    1774                 async_answer_0(callid, ENOTSUP);
     1774                async_answer_0(chandle, ENOTSUP);
    17751775
    17761776        free(address_list);
    … …  
    17781778
    17791779static void remote_nic_multicast_get_mode(ddf_fun_t *dev, void *iface,
    1780     cap_call_handle_t callid, ipc_call_t *call)
     1780    cap_call_handle_t chandle, ipc_call_t *call)
    17811781{
    17821782        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    17831783        if (nic_iface->multicast_get_mode == NULL) {
    1784                 async_answer_0(callid, ENOTSUP);
     1784                async_answer_0(chandle, ENOTSUP);
    17851785                return;
    17861786        }
    … …  
    17921792                address_list = malloc(max_count * sizeof(nic_address_t));
    17931793                if (!address_list) {
    1794                         async_answer_0(callid, ENOMEM);
     1794                        async_answer_0(chandle, ENOMEM);
    17951795                        return;
    17961796                }
    … …  
    18071807        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    18081808                free(address_list);
    1809                 async_answer_2(callid, rc, mode, address_count);
    1810                 return;
    1811         }
    1812 
    1813         cap_call_handle_t data_callid;
     1809                async_answer_2(chandle, rc, mode, address_count);
     1810                return;
     1811        }
     1812
     1813        cap_call_handle_t data_chandle;
    18141814        size_t max_len;
    1815         if (!async_data_read_receive(&data_callid, &max_len)) {
    1816                 async_answer_0(data_callid, EINVAL);
    1817                 async_answer_2(callid, rc, mode, address_count);
     1815        if (!async_data_read_receive(&data_chandle, &max_len)) {
     1816                async_answer_0(data_chandle, EINVAL);
     1817                async_answer_2(chandle, rc, mode, address_count);
    18181818                free(address_list);
    18191819                return;
    … …  
    18261826                max_len = max_count * sizeof(nic_address_t);
    18271827
    1828         async_data_read_finalize(data_callid, address_list, max_len);
     1828        async_data_read_finalize(data_chandle, address_list, max_len);
    18291829
    18301830        free(address_list);
    1831         async_answer_2(callid, rc, mode, address_count);
     1831        async_answer_2(chandle, rc, mode, address_count);
    18321832}
    18331833
    18341834static void remote_nic_multicast_set_mode(ddf_fun_t *dev, void *iface,
    1835     cap_call_handle_t callid, ipc_call_t *call)
     1835    cap_call_handle_t chandle, ipc_call_t *call)
    18361836{
    18371837        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    18421842
    18431843        if (address_count) {
    1844                 cap_call_handle_t data_callid;
     1844                cap_call_handle_t data_chandle;
    18451845                size_t length;
    1846                 if (!async_data_write_receive(&data_callid, &length)) {
    1847                         async_answer_0(data_callid, EINVAL);
    1848                         async_answer_0(callid, EINVAL);
     1846                if (!async_data_write_receive(&data_chandle, &length)) {
     1847                        async_answer_0(data_chandle, EINVAL);
     1848                        async_answer_0(chandle, EINVAL);
    18491849                        return;
    18501850                }
    18511851
    18521852                if (length != address_count * sizeof (nic_address_t)) {
    1853                         async_answer_0(data_callid, ELIMIT);
    1854                         async_answer_0(callid, ELIMIT);
     1853                        async_answer_0(data_chandle, ELIMIT);
     1854                        async_answer_0(chandle, ELIMIT);
    18551855                        return;
    18561856                }
    … …  
    18581858                address_list = malloc(length);
    18591859                if (address_list == NULL) {
    1860                         async_answer_0(data_callid, ENOMEM);
    1861                         async_answer_0(callid, ENOMEM);
    1862                         return;
    1863                 }
    1864 
    1865                 if (async_data_write_finalize(data_callid, address_list,
     1860                        async_answer_0(data_chandle, ENOMEM);
     1861                        async_answer_0(chandle, ENOMEM);
     1862                        return;
     1863                }
     1864
     1865                if (async_data_write_finalize(data_chandle, address_list,
    18661866                    length) != EOK) {
    1867                         async_answer_0(callid, EINVAL);
     1867                        async_answer_0(chandle, EINVAL);
    18681868                        free(address_list);
    18691869                        return;
    … …  
    18741874                errno_t rc = nic_iface->multicast_set_mode(dev, mode, address_list,
    18751875                    address_count);
    1876                 async_answer_0(callid, rc);
     1876                async_answer_0(chandle, rc);
    18771877        } else
    1878                 async_answer_0(callid, ENOTSUP);
     1878                async_answer_0(chandle, ENOTSUP);
    18791879
    18801880        free(address_list);
    … …  
    18821882
    18831883static void remote_nic_broadcast_get_mode(ddf_fun_t *dev, void *iface,
    1884     cap_call_handle_t callid, ipc_call_t *call)
     1884    cap_call_handle_t chandle, ipc_call_t *call)
    18851885{
    18861886        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    18871887        if (nic_iface->broadcast_get_mode == NULL) {
    1888                 async_answer_0(callid, ENOTSUP);
     1888                async_answer_0(chandle, ENOTSUP);
    18891889                return;
    18901890        }
    … …  
    18931893
    18941894        errno_t rc = nic_iface->broadcast_get_mode(dev, &mode);
    1895         async_answer_1(callid, rc, mode);
     1895        async_answer_1(chandle, rc, mode);
    18961896}
    18971897
    18981898static void remote_nic_broadcast_set_mode(ddf_fun_t *dev, void *iface,
    1899     cap_call_handle_t callid, ipc_call_t *call)
     1899    cap_call_handle_t chandle, ipc_call_t *call)
    19001900{
    19011901        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19021902        if (nic_iface->broadcast_set_mode == NULL) {
    1903                 async_answer_0(callid, ENOTSUP);
     1903                async_answer_0(chandle, ENOTSUP);
    19041904                return;
    19051905        }
    … …  
    19081908
    19091909        errno_t rc = nic_iface->broadcast_set_mode(dev, mode);
    1910         async_answer_0(callid, rc);
     1910        async_answer_0(chandle, rc);
    19111911}
    19121912
    19131913static void remote_nic_defective_get_mode(ddf_fun_t *dev, void *iface,
    1914     cap_call_handle_t callid, ipc_call_t *call)
     1914    cap_call_handle_t chandle, ipc_call_t *call)
    19151915{
    19161916        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19171917        if (nic_iface->defective_get_mode == NULL) {
    1918                 async_answer_0(callid, ENOTSUP);
     1918                async_answer_0(chandle, ENOTSUP);
    19191919                return;
    19201920        }
    … …  
    19231923
    19241924        errno_t rc = nic_iface->defective_get_mode(dev, &mode);
    1925         async_answer_1(callid, rc, mode);
     1925        async_answer_1(chandle, rc, mode);
    19261926}
    19271927
    19281928static void remote_nic_defective_set_mode(ddf_fun_t *dev, void *iface,
    1929     cap_call_handle_t callid, ipc_call_t *call)
     1929    cap_call_handle_t chandle, ipc_call_t *call)
    19301930{
    19311931        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19321932        if (nic_iface->defective_set_mode == NULL) {
    1933                 async_answer_0(callid, ENOTSUP);
     1933                async_answer_0(chandle, ENOTSUP);
    19341934                return;
    19351935        }
    … …  
    19381938
    19391939        errno_t rc = nic_iface->defective_set_mode(dev, mode);
    1940         async_answer_0(callid, rc);
     1940        async_answer_0(chandle, rc);
    19411941}
    19421942
    19431943static void remote_nic_blocked_sources_get(ddf_fun_t *dev, void *iface,
    1944     cap_call_handle_t callid, ipc_call_t *call)
     1944    cap_call_handle_t chandle, ipc_call_t *call)
    19451945{
    19461946        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19471947        if (nic_iface->blocked_sources_get == NULL) {
    1948                 async_answer_0(callid, ENOTSUP);
     1948                async_answer_0(chandle, ENOTSUP);
    19491949                return;
    19501950        }
    … …  
    19561956                address_list = malloc(max_count * sizeof(nic_address_t));
    19571957                if (!address_list) {
    1958                         async_answer_0(callid, ENOMEM);
     1958                        async_answer_0(chandle, ENOMEM);
    19591959                        return;
    19601960                }
    … …  
    19681968
    19691969        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    1970                 async_answer_1(callid, rc, address_count);
     1970                async_answer_1(chandle, rc, address_count);
    19711971                free(address_list);
    19721972                return;
    19731973        }
    19741974
    1975         cap_call_handle_t data_callid;
     1975        cap_call_handle_t data_chandle;
    19761976        size_t max_len;
    1977         if (!async_data_read_receive(&data_callid, &max_len)) {
    1978                 async_answer_0(data_callid, EINVAL);
    1979                 async_answer_1(callid, rc, address_count);
     1977        if (!async_data_read_receive(&data_chandle, &max_len)) {
     1978                async_answer_0(data_chandle, EINVAL);
     1979                async_answer_1(chandle, rc, address_count);
    19801980                free(address_list);
    19811981                return;
    … …  
    19881988                max_len = max_count * sizeof(nic_address_t);
    19891989
    1990         async_data_read_finalize(data_callid, address_list, max_len);
    1991         async_answer_0(data_callid, EINVAL);
     1990        async_data_read_finalize(data_chandle, address_list, max_len);
     1991        async_answer_0(data_chandle, EINVAL);
    19921992
    19931993        free(address_list);
    1994         async_answer_1(callid, rc, address_count);
     1994        async_answer_1(chandle, rc, address_count);
    19951995}
    19961996
    19971997static void remote_nic_blocked_sources_set(ddf_fun_t *dev, void *iface,
    1998     cap_call_handle_t callid, ipc_call_t *call)
     1998    cap_call_handle_t chandle, ipc_call_t *call)
    19991999{
    20002000        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    20052005
    20062006        if (address_count) {
    2007                 cap_call_handle_t data_callid;
    2008                 if (!async_data_write_receive(&data_callid, &length)) {
    2009                         async_answer_0(data_callid, EINVAL);
    2010                         async_answer_0(callid, EINVAL);
     2007                cap_call_handle_t data_chandle;
     2008                if (!async_data_write_receive(&data_chandle, &length)) {
     2009                        async_answer_0(data_chandle, EINVAL);
     2010                        async_answer_0(chandle, EINVAL);
    20112011                        return;
    20122012                }
    20132013
    20142014                if (length != address_count * sizeof(nic_address_t)) {
    2015                         async_answer_0(data_callid, ELIMIT);
    2016                         async_answer_0(callid, ELIMIT);
     2015                        async_answer_0(data_chandle, ELIMIT);
     2016                        async_answer_0(chandle, ELIMIT);
    20172017                        return;
    20182018                }
    … …  
    20202020                address_list = malloc(length);
    20212021                if (address_list == NULL) {
    2022                         async_answer_0(data_callid, ENOMEM);
    2023                         async_answer_0(callid, ENOMEM);
    2024                         return;
    2025                 }
    2026 
    2027                 if (async_data_write_finalize(data_callid, address_list,
     2022                        async_answer_0(data_chandle, ENOMEM);
     2023                        async_answer_0(chandle, ENOMEM);
     2024                        return;
     2025                }
     2026
     2027                if (async_data_write_finalize(data_chandle, address_list,
    20282028                    length) != EOK) {
    2029                         async_answer_0(callid, EINVAL);
     2029                        async_answer_0(chandle, EINVAL);
    20302030                        free(address_list);
    20312031                        return;
    … …  
    20362036                errno_t rc = nic_iface->blocked_sources_set(dev, address_list,
    20372037                    address_count);
    2038                 async_answer_0(callid, rc);
     2038                async_answer_0(chandle, rc);
    20392039        } else
    2040                 async_answer_0(callid, ENOTSUP);
     2040                async_answer_0(chandle, ENOTSUP);
    20412041
    20422042        free(address_list);
    … …  
    20442044
    20452045static void remote_nic_vlan_get_mask(ddf_fun_t *dev, void *iface,
    2046     cap_call_handle_t callid, ipc_call_t *call)
     2046    cap_call_handle_t chandle, ipc_call_t *call)
    20472047{
    20482048        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    20492049        if (nic_iface->vlan_get_mask == NULL) {
    2050                 async_answer_0(callid, ENOTSUP);
     2050                async_answer_0(chandle, ENOTSUP);
    20512051                return;
    20522052        }
    … …  
    20572057        errno_t rc = nic_iface->vlan_get_mask(dev, &vlan_mask);
    20582058        if (rc == EOK) {
    2059                 cap_call_handle_t data_callid;
     2059                cap_call_handle_t data_chandle;
    20602060                size_t max_len;
    2061                 if (!async_data_read_receive(&data_callid, &max_len)) {
    2062                         async_answer_0(data_callid, EINVAL);
    2063                         async_answer_0(callid, EINVAL);
     2061                if (!async_data_read_receive(&data_chandle, &max_len)) {
     2062                        async_answer_0(data_chandle, EINVAL);
     2063                        async_answer_0(chandle, EINVAL);
    20642064                        return;
    20652065                }
    20662066
    20672067                if (max_len != sizeof(nic_vlan_mask_t)) {
    2068                         async_answer_0(data_callid, EINVAL);
    2069                         async_answer_0(callid, EINVAL);
    2070                         return;
    2071                 }
    2072 
    2073                 async_data_read_finalize(data_callid, &vlan_mask, max_len);
    2074         }
    2075 
    2076         async_answer_0(callid, rc);
     2068                        async_answer_0(data_chandle, EINVAL);
     2069                        async_answer_0(chandle, EINVAL);
     2070                        return;
     2071                }
     2072
     2073                async_data_read_finalize(data_chandle, &vlan_mask, max_len);
     2074        }
     2075
     2076        async_answer_0(chandle, rc);
    20772077}
    20782078
    20792079static void remote_nic_vlan_set_mask(ddf_fun_t *dev, void *iface,
    2080     cap_call_handle_t callid, ipc_call_t *call)
     2080    cap_call_handle_t chandle, ipc_call_t *call)
    20812081{
    20822082        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    20872087
    20882088        if (vlan_mask_set) {
    2089                 cap_call_handle_t data_callid;
     2089                cap_call_handle_t data_chandle;
    20902090                size_t length;
    2091                 if (!async_data_write_receive(&data_callid, &length)) {
    2092                         async_answer_0(data_callid, EINVAL);
    2093                         async_answer_0(callid, EINVAL);
     2091                if (!async_data_write_receive(&data_chandle, &length)) {
     2092                        async_answer_0(data_chandle, EINVAL);
     2093                        async_answer_0(chandle, EINVAL);
    20942094                        return;
    20952095                }
    20962096
    20972097                if (length != sizeof(nic_vlan_mask_t)) {
    2098                         async_answer_0(data_callid, ELIMIT);
    2099                         async_answer_0(callid, ELIMIT);
    2100                         return;
    2101                 }
    2102 
    2103                 if (async_data_write_finalize(data_callid, &vlan_mask,
     2098                        async_answer_0(data_chandle, ELIMIT);
     2099                        async_answer_0(chandle, ELIMIT);
     2100                        return;
     2101                }
     2102
     2103                if (async_data_write_finalize(data_chandle, &vlan_mask,
    21042104                    length) != EOK) {
    2105                         async_answer_0(callid, EINVAL);
     2105                        async_answer_0(chandle, EINVAL);
    21062106                        return;
    21072107                }
    … …  
    21122112        if (nic_iface->vlan_set_mask != NULL) {
    21132113                errno_t rc = nic_iface->vlan_set_mask(dev, vlan_mask_pointer);
    2114                 async_answer_0(callid, rc);
     2114                async_answer_0(chandle, rc);
    21152115        } else
    2116                 async_answer_0(callid, ENOTSUP);
     2116                async_answer_0(chandle, ENOTSUP);
    21172117}
    21182118
    21192119static void remote_nic_vlan_set_tag(ddf_fun_t *dev, void *iface,
    2120     cap_call_handle_t callid, ipc_call_t *call)
     2120    cap_call_handle_t chandle, ipc_call_t *call)
    21212121{
    21222122        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21232123
    21242124        if (nic_iface->vlan_set_tag == NULL) {
    2125                 async_answer_0(callid, ENOTSUP);
     2125                async_answer_0(chandle, ENOTSUP);
    21262126                return;
    21272127        }
    … …  
    21322132
    21332133        errno_t rc = nic_iface->vlan_set_tag(dev, tag, add, strip);
    2134         async_answer_0(callid, rc);
     2134        async_answer_0(chandle, rc);
    21352135}
    21362136
    21372137static void remote_nic_wol_virtue_add(ddf_fun_t *dev, void *iface,
    2138     cap_call_handle_t callid, ipc_call_t *call)
     2138    cap_call_handle_t chandle, ipc_call_t *call)
    21392139{
    21402140        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21412141
    21422142        int send_data = (int) IPC_GET_ARG3(*call);
    2143         cap_call_handle_t data_callid;
     2143        cap_call_handle_t data_chandle;
    21442144
    21452145        if (nic_iface->wol_virtue_add == NULL) {
    21462146                if (send_data) {
    2147                         async_data_write_receive(&data_callid, NULL);
    2148                         async_answer_0(data_callid, ENOTSUP);
    2149                 }
    2150 
    2151                 async_answer_0(callid, ENOTSUP);
     2147                        async_data_write_receive(&data_chandle, NULL);
     2148                        async_answer_0(data_chandle, ENOTSUP);
     2149                }
     2150
     2151                async_answer_0(chandle, ENOTSUP);
    21522152        }
    21532153
    … …  
    21562156
    21572157        if (send_data) {
    2158                 if (!async_data_write_receive(&data_callid, &length)) {
    2159                         async_answer_0(data_callid, EINVAL);
    2160                         async_answer_0(callid, EINVAL);
     2158                if (!async_data_write_receive(&data_chandle, &length)) {
     2159                        async_answer_0(data_chandle, EINVAL);
     2160                        async_answer_0(chandle, EINVAL);
    21612161                        return;
    21622162                }
    … …  
    21642164                data = malloc(length);
    21652165                if (data == NULL) {
    2166                         async_answer_0(data_callid, ENOMEM);
    2167                         async_answer_0(callid, ENOMEM);
    2168                         return;
    2169                 }
    2170 
    2171                 if (async_data_write_finalize(data_callid, data,
     2166                        async_answer_0(data_chandle, ENOMEM);
     2167                        async_answer_0(chandle, ENOMEM);
     2168                        return;
     2169                }
     2170
     2171                if (async_data_write_finalize(data_chandle, data,
    21722172                    length) != EOK) {
    2173                         async_answer_0(callid, EINVAL);
     2173                        async_answer_0(chandle, EINVAL);
    21742174                        free(data);
    21752175                        return;
    … …  
    21812181
    21822182        errno_t rc = nic_iface->wol_virtue_add(dev, type, data, length, &id);
    2183         async_answer_1(callid, rc, (sysarg_t) id);
     2183        async_answer_1(chandle, rc, (sysarg_t) id);
    21842184        free(data);
    21852185}
    21862186
    21872187static void remote_nic_wol_virtue_remove(ddf_fun_t *dev, void *iface,
    2188     cap_call_handle_t callid, ipc_call_t *call)
     2188    cap_call_handle_t chandle, ipc_call_t *call)
    21892189{
    21902190        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21912191
    21922192        if (nic_iface->wol_virtue_remove == NULL) {
    2193                 async_answer_0(callid, ENOTSUP);
     2193                async_answer_0(chandle, ENOTSUP);
    21942194                return;
    21952195        }
    … …  
    21982198
    21992199        errno_t rc = nic_iface->wol_virtue_remove(dev, id);
    2200         async_answer_0(callid, rc);
     2200        async_answer_0(chandle, rc);
    22012201}
    22022202
    22032203static void remote_nic_wol_virtue_probe(ddf_fun_t *dev, void *iface,
    2204     cap_call_handle_t callid, ipc_call_t *call)
     2204    cap_call_handle_t chandle, ipc_call_t *call)
    22052205{
    22062206        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    22072207
    22082208        if (nic_iface->wol_virtue_probe == NULL) {
    2209                 async_answer_0(callid, ENOTSUP);
     2209                async_answer_0(chandle, ENOTSUP);
    22102210                return;
    22112211        }
    … …  
    22152215        nic_wv_type_t type = NIC_WV_NONE;
    22162216        size_t length = 0;
    2217         cap_call_handle_t data_callid;
     2217        cap_call_handle_t data_chandle;
    22182218        void *data = NULL;
    22192219
    … …  
    22212221                data = malloc(max_length);
    22222222                if (data == NULL) {
    2223                         async_answer_0(callid, ENOMEM);
     2223                        async_answer_0(chandle, ENOMEM);
    22242224                        return;
    22252225                }
    … …  
    22332233        if ((max_length != 0) && (length != 0)) {
    22342234                size_t req_length;
    2235                 if (!async_data_read_receive(&data_callid, &req_length)) {
    2236                         async_answer_0(data_callid, EINVAL);
    2237                         async_answer_0(callid, EINVAL);
     2235                if (!async_data_read_receive(&data_chandle, &req_length)) {
     2236                        async_answer_0(data_chandle, EINVAL);
     2237                        async_answer_0(chandle, EINVAL);
    22382238                        free(data);
    22392239                        return;
    … …  
    22462246                        req_length = max_length;
    22472247
    2248                 async_data_read_finalize(data_callid, data, req_length);
    2249         }
    2250 
    2251         async_answer_2(callid, rc, (sysarg_t) type, (sysarg_t) length);
     2248                async_data_read_finalize(data_chandle, data, req_length);
     2249        }
     2250
     2251        async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) length);
    22522252        free(data);
    22532253}
    22542254
    22552255static void remote_nic_wol_virtue_list(ddf_fun_t *dev, void *iface,
    2256     cap_call_handle_t callid, ipc_call_t *call)
     2256    cap_call_handle_t chandle, ipc_call_t *call)
    22572257{
    22582258        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    22592259        if (nic_iface->wol_virtue_list == NULL) {
    2260                 async_answer_0(callid, ENOTSUP);
     2260                async_answer_0(chandle, ENOTSUP);
    22612261                return;
    22622262        }
    … …  
    22662266        size_t count = 0;
    22672267        nic_wv_id_t *id_list = NULL;
    2268         cap_call_handle_t data_callid;
     2268        cap_call_handle_t data_chandle;
    22692269
    22702270        if (max_count != 0) {
    22712271                id_list = malloc(max_count * sizeof(nic_wv_id_t));
    22722272                if (id_list == NULL) {
    2273                         async_answer_0(callid, ENOMEM);
     2273                        async_answer_0(chandle, ENOMEM);
    22742274                        return;
    22752275                }
    … …  
    22832283        if ((max_count != 0) && (count != 0)) {
    22842284                size_t req_length;
    2285                 if (!async_data_read_receive(&data_callid, &req_length)) {
    2286                         async_answer_0(data_callid, EINVAL);
    2287                         async_answer_0(callid, EINVAL);
     2285                if (!async_data_read_receive(&data_chandle, &req_length)) {
     2286                        async_answer_0(data_chandle, EINVAL);
     2287                        async_answer_0(chandle, EINVAL);
    22882288                        free(id_list);
    22892289                        return;
    … …  
    22962296                        req_length = max_count * sizeof(nic_wv_id_t);
    22972297
    2298                 rc = async_data_read_finalize(data_callid, id_list, req_length);
    2299         }
    2300 
    2301         async_answer_1(callid, rc, (sysarg_t) count);
     2298                rc = async_data_read_finalize(data_chandle, id_list, req_length);
     2299        }
     2300
     2301        async_answer_1(chandle, rc, (sysarg_t) count);
    23022302        free(id_list);
    23032303}
    23042304
    23052305static void remote_nic_wol_virtue_get_caps(ddf_fun_t *dev, void *iface,
    2306     cap_call_handle_t callid, ipc_call_t *call)
     2306    cap_call_handle_t chandle, ipc_call_t *call)
    23072307{
    23082308        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23092309        if (nic_iface->wol_virtue_get_caps == NULL) {
    2310                 async_answer_0(callid, ENOTSUP);
     2310                async_answer_0(chandle, ENOTSUP);
    23112311                return;
    23122312        }
    … …  
    23162316
    23172317        errno_t rc = nic_iface->wol_virtue_get_caps(dev, type, &count);
    2318         async_answer_1(callid, rc, (sysarg_t) count);
     2318        async_answer_1(chandle, rc, (sysarg_t) count);
    23192319}
    23202320
    23212321static void remote_nic_wol_load_info(ddf_fun_t *dev, void *iface,
    2322     cap_call_handle_t callid, ipc_call_t *call)
     2322    cap_call_handle_t chandle, ipc_call_t *call)
    23232323{
    23242324        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23252325        if (nic_iface->wol_load_info == NULL) {
    2326                 async_answer_0(callid, ENOTSUP);
     2326                async_answer_0(chandle, ENOTSUP);
    23272327                return;
    23282328        }
    … …  
    23362336                data = malloc(max_length);
    23372337                if (data == NULL) {
    2338                         async_answer_0(callid, ENOMEM);
     2338                        async_answer_0(chandle, ENOMEM);
    23392339                        return;
    23402340                }
    … …  
    23462346            &frame_length);
    23472347        if (rc == EOK) {
    2348                 cap_call_handle_t data_callid;
     2348                cap_call_handle_t data_chandle;
    23492349                size_t req_length;
    2350                 if (!async_data_read_receive(&data_callid, &req_length)) {
    2351                         async_answer_0(data_callid, EINVAL);
    2352                         async_answer_0(callid, EINVAL);
     2350                if (!async_data_read_receive(&data_chandle, &req_length)) {
     2351                        async_answer_0(data_chandle, EINVAL);
     2352                        async_answer_0(chandle, EINVAL);
    23532353                        free(data);
    23542354                        return;
    … …  
    23572357                req_length = req_length > max_length ? max_length : req_length;
    23582358                req_length = req_length > frame_length ? frame_length : req_length;
    2359                 async_data_read_finalize(data_callid, data, req_length);
    2360         }
    2361 
    2362         async_answer_2(callid, rc, (sysarg_t) type, (sysarg_t) frame_length);
     2359                async_data_read_finalize(data_chandle, data, req_length);
     2360        }
     2361
     2362        async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) frame_length);
    23632363        free(data);
    23642364}
    23652365
    23662366static void remote_nic_offload_probe(ddf_fun_t *dev, void *iface,
    2367     cap_call_handle_t callid, ipc_call_t *call)
     2367    cap_call_handle_t chandle, ipc_call_t *call)
    23682368{
    23692369        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23702370        if (nic_iface->offload_probe == NULL) {
    2371                 async_answer_0(callid, ENOTSUP);
     2371                async_answer_0(chandle, ENOTSUP);
    23722372                return;
    23732373        }
    … …  
    23772377
    23782378        errno_t rc = nic_iface->offload_probe(dev, &supported, &active);
    2379         async_answer_2(callid, rc, supported, active);
     2379        async_answer_2(chandle, rc, supported, active);
    23802380}
    23812381
    23822382static void remote_nic_offload_set(ddf_fun_t *dev, void *iface,
    2383     cap_call_handle_t callid, ipc_call_t *call)
     2383    cap_call_handle_t chandle, ipc_call_t *call)
    23842384{
    23852385        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23862386        if (nic_iface->offload_set == NULL) {
    2387                 async_answer_0(callid, ENOTSUP);
     2387                async_answer_0(chandle, ENOTSUP);
    23882388                return;
    23892389        }
    … …  
    23932393
    23942394        errno_t rc = nic_iface->offload_set(dev, mask, active);
    2395         async_answer_0(callid, rc);
     2395        async_answer_0(chandle, rc);
    23962396}
    23972397
    23982398static void remote_nic_poll_get_mode(ddf_fun_t *dev, void *iface,
    2399     cap_call_handle_t callid, ipc_call_t *call)
     2399    cap_call_handle_t chandle, ipc_call_t *call)
    24002400{
    24012401        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    24022402        if (nic_iface->poll_get_mode == NULL) {
    2403                 async_answer_0(callid, ENOTSUP);
     2403                async_answer_0(chandle, ENOTSUP);
    24042404                return;
    24052405        }
    … …  
    24152415        if ((rc == EOK) && (request_data)) {
    24162416                size_t max_len;
    2417                 cap_call_handle_t data_callid;
    2418 
    2419                 if (!async_data_read_receive(&data_callid, &max_len)) {
    2420                         async_answer_0(data_callid, EINVAL);
    2421                         async_answer_0(callid, EINVAL);
     2417                cap_call_handle_t data_chandle;
     2418
     2419                if (!async_data_read_receive(&data_chandle, &max_len)) {
     2420                        async_answer_0(data_chandle, EINVAL);
     2421                        async_answer_0(chandle, EINVAL);
    24222422                        return;
    24232423                }
    24242424
    24252425                if (max_len != sizeof(struct timeval)) {
    2426                         async_answer_0(data_callid, ELIMIT);
    2427                         async_answer_0(callid, ELIMIT);
    2428                         return;
    2429                 }
    2430 
    2431                 async_data_read_finalize(data_callid, &period,
     2426                        async_answer_0(data_chandle, ELIMIT);
     2427                        async_answer_0(chandle, ELIMIT);
     2428                        return;
     2429                }
     2430
     2431                async_data_read_finalize(data_chandle, &period,
    24322432                    sizeof(struct timeval));
    24332433        }
    24342434
    2435         async_answer_1(callid, rc, (sysarg_t) mode);
     2435        async_answer_1(chandle, rc, (sysarg_t) mode);
    24362436}
    24372437
    24382438static void remote_nic_poll_set_mode(ddf_fun_t *dev, void *iface,
    2439     cap_call_handle_t callid, ipc_call_t *call)
     2439    cap_call_handle_t chandle, ipc_call_t *call)
    24402440{
    24412441        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    24482448
    24492449        if (has_period) {
    2450                 cap_call_handle_t data_callid;
    2451                 if (!async_data_write_receive(&data_callid, &length)) {
    2452                         async_answer_0(data_callid, EINVAL);
    2453                         async_answer_0(callid, EINVAL);
     2450                cap_call_handle_t data_chandle;
     2451                if (!async_data_write_receive(&data_chandle, &length)) {
     2452                        async_answer_0(data_chandle, EINVAL);
     2453                        async_answer_0(chandle, EINVAL);
    24542454                        return;
    24552455                }
    24562456
    24572457                if (length != sizeof(struct timeval)) {
    2458                         async_answer_0(data_callid, ELIMIT);
    2459                         async_answer_0(callid, ELIMIT);
     2458                        async_answer_0(data_chandle, ELIMIT);
     2459                        async_answer_0(chandle, ELIMIT);
    24602460                        return;
    24612461                }
    24622462
    24632463                period = &period_buf;
    2464                 if (async_data_write_finalize(data_callid, period,
     2464                if (async_data_write_finalize(data_chandle, period,
    24652465                    length) != EOK) {
    2466                         async_answer_0(callid, EINVAL);
     2466                        async_answer_0(chandle, EINVAL);
    24672467                        return;
    24682468                }
    … …  
    24712471        if (nic_iface->poll_set_mode != NULL) {
    24722472                errno_t rc = nic_iface->poll_set_mode(dev, mode, period);
    2473                 async_answer_0(callid, rc);
     2473                async_answer_0(chandle, rc);
    24742474        } else
    2475                 async_answer_0(callid, ENOTSUP);
     2475                async_answer_0(chandle, ENOTSUP);
    24762476}
    24772477
    24782478static void remote_nic_poll_now(ddf_fun_t *dev, void *iface,
    2479     cap_call_handle_t callid, ipc_call_t *call)
     2479    cap_call_handle_t chandle, ipc_call_t *call)
    24802480{
    24812481        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    24822482        if (nic_iface->poll_now == NULL) {
    2483                 async_answer_0(callid, ENOTSUP);
     2483                async_answer_0(chandle, ENOTSUP);
    24842484                return;
    24852485        }
    24862486
    24872487        errno_t rc = nic_iface->poll_now(dev);
    2488         async_answer_0(callid, rc);
     2488        async_answer_0(chandle, rc);
    24892489}
    24902490

  • uspace/lib/drv/generic/remote_pci.c

    r3e242d2 ra46e56b  
    150150};
    151151
    152 void remote_config_space_read_8(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     152void remote_config_space_read_8(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    153153{
    154154        assert(iface);
    155155        pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
    156156        if (pci_iface->config_space_read_8 == NULL) {
    157                 async_answer_0(callid, ENOTSUP);
     157                async_answer_0(chandle, ENOTSUP);
    158158                return;
    159159        }
    … …  
    162162        errno_t ret = pci_iface->config_space_read_8(fun, address, &value);
    163163        if (ret != EOK) {
    164                 async_answer_0(callid, ret);
    165         } else {
    166                 async_answer_1(callid, EOK, value);
    167         }
    168 }
    169 
    170 void remote_config_space_read_16(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     164                async_answer_0(chandle, ret);
     165        } else {
     166                async_answer_1(chandle, EOK, value);
     167        }
     168}
     169
     170void remote_config_space_read_16(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    171171{
    172172        assert(iface);
    173173        pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
    174174        if (pci_iface->config_space_read_16 == NULL) {
    175                 async_answer_0(callid, ENOTSUP);
     175                async_answer_0(chandle, ENOTSUP);
    176176                return;
    177177        }
    … …  
    180180        errno_t ret = pci_iface->config_space_read_16(fun, address, &value);
    181181        if (ret != EOK) {
    182                 async_answer_0(callid, ret);
    183         } else {
    184                 async_answer_1(callid, EOK, value);
    185         }
    186 }
    187 void remote_config_space_read_32(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     182                async_answer_0(chandle, ret);
     183        } else {
     184                async_answer_1(chandle, EOK, value);
     185        }
     186}
     187void remote_config_space_read_32(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    188188{
    189189        assert(iface);
    190190        pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
    191191        if (pci_iface->config_space_read_32 == NULL) {
    192                 async_answer_0(callid, ENOTSUP);
     192                async_answer_0(chandle, ENOTSUP);
    193193                return;
    194194        }
    … …  
    197197        errno_t ret = pci_iface->config_space_read_32(fun, address, &value);
    198198        if (ret != EOK) {
    199                 async_answer_0(callid, ret);
    200         } else {
    201                 async_answer_1(callid, EOK, value);
    202         }
    203 }
    204 
    205 void remote_config_space_write_8(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     199                async_answer_0(chandle, ret);
     200        } else {
     201                async_answer_1(chandle, EOK, value);
     202        }
     203}
     204
     205void remote_config_space_write_8(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    206206{
    207207        assert(iface);
    208208        pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
    209209        if (pci_iface->config_space_write_8 == NULL) {
    210                 async_answer_0(callid, ENOTSUP);
     210                async_answer_0(chandle, ENOTSUP);
    211211                return;
    212212        }
    … …  
    215215        errno_t ret = pci_iface->config_space_write_8(fun, address, value);
    216216        if (ret != EOK) {
    217                 async_answer_0(callid, ret);
    218         } else {
    219                 async_answer_0(callid, EOK);
    220         }
    221 }
    222 
    223 void remote_config_space_write_16(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     217                async_answer_0(chandle, ret);
     218        } else {
     219                async_answer_0(chandle, EOK);
     220        }
     221}
     222
     223void remote_config_space_write_16(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    224224{
    225225        assert(iface);
    226226        pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
    227227        if (pci_iface->config_space_write_16 == NULL) {
    228                 async_answer_0(callid, ENOTSUP);
     228                async_answer_0(chandle, ENOTSUP);
    229229                return;
    230230        }
    … …  
    233233        errno_t ret = pci_iface->config_space_write_16(fun, address, value);
    234234        if (ret != EOK) {
    235                 async_answer_0(callid, ret);
    236         } else {
    237                 async_answer_0(callid, EOK);
    238         }
    239 }
    240 
    241 void remote_config_space_write_32(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     235                async_answer_0(chandle, ret);
     236        } else {
     237                async_answer_0(chandle, EOK);
     238        }
     239}
     240
     241void remote_config_space_write_32(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    242242{
    243243        assert(iface);
    244244        pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface;
    245245        if (pci_iface->config_space_write_32 == NULL) {
    246                 async_answer_0(callid, ENOTSUP);
     246                async_answer_0(chandle, ENOTSUP);
    247247                return;
    248248        }
    … …  
    251251        errno_t ret = pci_iface->config_space_write_32(fun, address, value);
    252252        if (ret != EOK) {
    253                 async_answer_0(callid, ret);
    254         } else {
    255                 async_answer_0(callid, EOK);
     253                async_answer_0(chandle, ret);
     254        } else {
     255                async_answer_0(chandle, EOK);
    256256        }
    257257}

  • uspace/lib/drv/generic/remote_pio_window.c

    r3e242d2 ra46e56b  
    5353
    5454static void remote_pio_window_get(ddf_fun_t *fun, void *ops,
    55     cap_call_handle_t callid, ipc_call_t *call)
     55    cap_call_handle_t chandle, ipc_call_t *call)
    5656{
    5757        pio_window_ops_t *pio_win_ops = (pio_window_ops_t *) ops;
    … …  
    5959
    6060        if (!pio_win_ops->get_pio_window) {
    61                 async_answer_0(callid, ENOTSUP);
     61                async_answer_0(chandle, ENOTSUP);
    6262                return;
    6363        }
    … …  
    6565        pio_window_t *pio_window = pio_win_ops->get_pio_window(fun);
    6666        if (!pio_window) {
    67                 async_answer_0(callid, ENOENT);
     67                async_answer_0(chandle, ENOENT);
    6868                return;
    6969        }
    7070
    71         async_answer_0(callid, EOK);
     71        async_answer_0(chandle, EOK);
    7272
    73         if (!async_data_read_receive(&callid, &len)) {
     73        if (!async_data_read_receive(&chandle, &len)) {
    7474                /* Protocol error - the recipient is not accepting data */
    7575                return;
    7676        }
    7777
    78         async_data_read_finalize(callid, pio_window, len);
     78        async_data_read_finalize(chandle, pio_window, len);
    7979}
    8080

  • uspace/lib/drv/generic/remote_usb.c

    r3e242d2 ra46e56b  
    107107
    108108void remote_usb_get_my_description(ddf_fun_t *fun, void *iface,
    109     cap_call_handle_t callid, ipc_call_t *call)
     109    cap_call_handle_t chandle, ipc_call_t *call)
    110110{
    111111        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
    112112
    113113        if (usb_iface->get_my_description == NULL) {
    114                 async_answer_0(callid, ENOTSUP);
     114                async_answer_0(chandle, ENOTSUP);
    115115                return;
    116116        }
    … …  
    119119        const errno_t ret = usb_iface->get_my_description(fun, &desc);
    120120        if (ret != EOK) {
    121                 async_answer_0(callid, ret);
     121                async_answer_0(chandle, ret);
    122122        } else {
    123                 async_answer_5(callid, EOK,
     123                async_answer_5(chandle, EOK,
    124124                    (sysarg_t) desc.address,
    125125                    (sysarg_t) desc.depth,

  • uspace/lib/drv/generic/remote_usbdiag.c

    r3e242d2 ra46e56b  
    144144
    145145void remote_usbdiag_test_in(ddf_fun_t *fun, void *iface,
    146     cap_call_handle_t callid, ipc_call_t *call)
     146    cap_call_handle_t chandle, ipc_call_t *call)
    147147{
    148148        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    149149
    150150        size_t size;
    151         cap_call_handle_t data_callid;
    152         if (!async_data_write_receive(&data_callid, &size)) {
    153                 async_answer_0(data_callid, EINVAL);
    154                 async_answer_0(callid, EINVAL);
     151        cap_call_handle_t data_chandle;
     152        if (!async_data_write_receive(&data_chandle, &size)) {
     153                async_answer_0(data_chandle, EINVAL);
     154                async_answer_0(chandle, EINVAL);
    155155                return;
    156156        }
    157157
    158158        if (size != sizeof(usbdiag_test_params_t)) {
    159                 async_answer_0(data_callid, EINVAL);
    160                 async_answer_0(callid, EINVAL);
     159                async_answer_0(data_chandle, EINVAL);
     160                async_answer_0(chandle, EINVAL);
    161161                return;
    162162        }
    163163
    164164        usbdiag_test_params_t params;
    165         if (async_data_write_finalize(data_callid, &params, size) != EOK) {
    166                 async_answer_0(callid, EINVAL);
     165        if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
     166                async_answer_0(chandle, EINVAL);
    167167                return;
    168168        }
    … …  
    173173
    174174        if (ret != EOK) {
    175                 async_answer_0(callid, ret);
    176                 return;
    177         }
    178 
    179         if (!async_data_read_receive(&data_callid, &size)) {
    180                 async_answer_0(data_callid, EINVAL);
    181                 async_answer_0(callid, EINVAL);
     175                async_answer_0(chandle, ret);
     176                return;
     177        }
     178
     179        if (!async_data_read_receive(&data_chandle, &size)) {
     180                async_answer_0(data_chandle, EINVAL);
     181                async_answer_0(chandle, EINVAL);
    182182                return;
    183183        }
    184184
    185185        if (size != sizeof(usbdiag_test_results_t)) {
    186                 async_answer_0(data_callid, EINVAL);
    187                 async_answer_0(callid, EINVAL);
    188                 return;
    189         }
    190 
    191         if (async_data_read_finalize(data_callid, &results, size) != EOK) {
    192                 async_answer_0(callid, EINVAL);
    193                 return;
    194         }
    195 
    196         async_answer_0(callid, ret);
     186                async_answer_0(data_chandle, EINVAL);
     187                async_answer_0(chandle, EINVAL);
     188                return;
     189        }
     190
     191        if (async_data_read_finalize(data_chandle, &results, size) != EOK) {
     192                async_answer_0(chandle, EINVAL);
     193                return;
     194        }
     195
     196        async_answer_0(chandle, ret);
    197197}
    198198
    199199void remote_usbdiag_test_out(ddf_fun_t *fun, void *iface,
    200     cap_call_handle_t callid, ipc_call_t *call)
     200    cap_call_handle_t chandle, ipc_call_t *call)
    201201{
    202202        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    203203
    204204        size_t size;
    205         cap_call_handle_t data_callid;
    206         if (!async_data_write_receive(&data_callid, &size)) {
    207                 async_answer_0(data_callid, EINVAL);
    208                 async_answer_0(callid, EINVAL);
     205        cap_call_handle_t data_chandle;
     206        if (!async_data_write_receive(&data_chandle, &size)) {
     207                async_answer_0(data_chandle, EINVAL);
     208                async_answer_0(chandle, EINVAL);
    209209                return;
    210210        }
    211211
    212212        if (size != sizeof(usbdiag_test_params_t)) {
    213                 async_answer_0(data_callid, EINVAL);
    214                 async_answer_0(callid, EINVAL);
     213                async_answer_0(data_chandle, EINVAL);
     214                async_answer_0(chandle, EINVAL);
    215215                return;
    216216        }
    217217
    218218        usbdiag_test_params_t params;
    219         if (async_data_write_finalize(data_callid, &params, size) != EOK) {
    220                 async_answer_0(callid, EINVAL);
     219        if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
     220                async_answer_0(chandle, EINVAL);
    221221                return;
    222222        }
    … …  
    227227
    228228        if (ret != EOK) {
    229                 async_answer_0(callid, ret);
    230                 return;
    231         }
    232 
    233         if (!async_data_read_receive(&data_callid, &size)) {
    234                 async_answer_0(data_callid, EINVAL);
    235                 async_answer_0(callid, EINVAL);
     229                async_answer_0(chandle, ret);
     230                return;
     231        }
     232
     233        if (!async_data_read_receive(&data_chandle, &size)) {
     234                async_answer_0(data_chandle, EINVAL);
     235                async_answer_0(chandle, EINVAL);
    236236                return;
    237237        }
    238238
    239239        if (size != sizeof(usbdiag_test_results_t)) {
    240                 async_answer_0(data_callid, EINVAL);
    241                 async_answer_0(callid, EINVAL);
    242                 return;
    243         }
    244 
    245         if (async_data_read_finalize(data_callid, &results, size) != EOK) {
    246                 async_answer_0(callid, EINVAL);
    247                 return;
    248         }
    249 
    250         async_answer_0(callid, ret);
     240                async_answer_0(data_chandle, EINVAL);
     241                async_answer_0(chandle, EINVAL);
     242                return;
     243        }
     244
     245        if (async_data_read_finalize(data_chandle, &results, size) != EOK) {
     246                async_answer_0(chandle, EINVAL);
     247                return;
     248        }
     249
     250        async_answer_0(chandle, ret);
    251251}
    252252

  • uspace/lib/drv/generic/remote_usbhc.c

    r3e242d2 ra46e56b  
    232232static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    233233static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    234 static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call);
     234static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call);
    235235
    236236/** Remote USB interface operations. */
    … …  
    257257
    258258void remote_usbhc_default_address_reservation(ddf_fun_t *fun, void *iface,
    259     cap_call_handle_t callid, ipc_call_t *call)
     259    cap_call_handle_t chandle, ipc_call_t *call)
    260260{
    261261        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
    262262
    263263        if (usbhc_iface->default_address_reservation == NULL) {
    264                 async_answer_0(callid, ENOTSUP);
     264                async_answer_0(chandle, ENOTSUP);
    265265                return;
    266266        }
    … …  
    268268        const bool reserve = IPC_GET_ARG2(*call);
    269269        const errno_t ret = usbhc_iface->default_address_reservation(fun, reserve);
    270         async_answer_0(callid, ret);
     270        async_answer_0(chandle, ret);
    271271}
    272272
    273273
    274274static void remote_usbhc_device_enumerate(ddf_fun_t *fun, void *iface,
    275     cap_call_handle_t callid, ipc_call_t *call)
     275    cap_call_handle_t chandle, ipc_call_t *call)
    276276{
    277277        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
    278278
    279279        if (usbhc_iface->device_enumerate == NULL) {
    280                 async_answer_0(callid, ENOTSUP);
     280                async_answer_0(chandle, ENOTSUP);
    281281                return;
    282282        }
    … …  
    285285        usb_speed_t speed = DEV_IPC_GET_ARG2(*call);
    286286        const errno_t ret = usbhc_iface->device_enumerate(fun, port, speed);
    287         async_answer_0(callid, ret);
     287        async_answer_0(chandle, ret);
    288288}
    289289
    290290static void remote_usbhc_device_remove(ddf_fun_t *fun, void *iface,
    291     cap_call_handle_t callid, ipc_call_t *call)
     291    cap_call_handle_t chandle, ipc_call_t *call)
    292292{
    293293        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
    294294
    295295        if (usbhc_iface->device_remove == NULL) {
    296                 async_answer_0(callid, ENOTSUP);
     296                async_answer_0(chandle, ENOTSUP);
    297297                return;
    298298        }
    … …  
    300300        const unsigned port = DEV_IPC_GET_ARG1(*call);
    301301        const errno_t ret = usbhc_iface->device_remove(fun, port);
    302         async_answer_0(callid, ret);
     302        async_answer_0(chandle, ret);
    303303}
    304304
    305305static void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
    306     cap_call_handle_t callid, ipc_call_t *call)
     306    cap_call_handle_t chandle, ipc_call_t *call)
    307307{
    308308        assert(fun);
    … …  
    313313
    314314        if (!usbhc_iface->register_endpoint) {
    315                 async_answer_0(callid, ENOTSUP);
     315                async_answer_0(chandle, ENOTSUP);
    316316                return;
    317317        }
    318318
    319319        usb_endpoint_descriptors_t ep_desc;
    320         cap_call_handle_t data_callid;
     320        cap_call_handle_t data_chandle;
    321321        size_t len;
    322322
    323         if (!async_data_write_receive(&data_callid, &len)
     323        if (!async_data_write_receive(&data_chandle, &len)
    324324            || len != sizeof(ep_desc)) {
    325                 async_answer_0(callid, EINVAL);
    326                 return;
    327         }
    328         async_data_write_finalize(data_callid, &ep_desc, sizeof(ep_desc));
     325                async_answer_0(chandle, EINVAL);
     326                return;
     327        }
     328        async_data_write_finalize(data_chandle, &ep_desc, sizeof(ep_desc));
    329329
    330330        usb_pipe_desc_t pipe_desc;
    331331
    332332        const errno_t rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
    333         async_answer_0(callid, rc);
    334 
    335         if (!async_data_read_receive(&data_callid, &len)
     333        async_answer_0(chandle, rc);
     334
     335        if (!async_data_read_receive(&data_chandle, &len)
    336336            || len != sizeof(pipe_desc)) {
    337337                return;
    338338        }
    339         async_data_read_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
     339        async_data_read_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
    340340}
    341341
    342342static void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
    343     cap_call_handle_t callid, ipc_call_t *call)
     343    cap_call_handle_t chandle, ipc_call_t *call)
    344344{
    345345        assert(fun);
    … …  
    350350
    351351        if (!usbhc_iface->unregister_endpoint) {
    352                 async_answer_0(callid, ENOTSUP);
     352                async_answer_0(chandle, ENOTSUP);
    353353                return;
    354354        }
    355355
    356356        usb_pipe_desc_t pipe_desc;
    357         cap_call_handle_t data_callid;
     357        cap_call_handle_t data_chandle;
    358358        size_t len;
    359359
    360         if (!async_data_write_receive(&data_callid, &len)
     360        if (!async_data_write_receive(&data_chandle, &len)
    361361            || len != sizeof(pipe_desc)) {
    362                 async_answer_0(callid, EINVAL);
    363                 return;
    364         }
    365         async_data_write_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
     362                async_answer_0(chandle, EINVAL);
     363                return;
     364        }
     365        async_data_write_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
    366366
    367367        const errno_t rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
    368         async_answer_0(callid, rc);
     368        async_answer_0(chandle, rc);
    369369}
    370370
    … …  
    410410
    411411        errno_t err;
    412         cap_call_handle_t data_callid;
     412        cap_call_handle_t data_chandle;
    413413        size_t size;
    414414        unsigned flags;
    415415
    416         if (!async_share_out_receive(&data_callid, &size, &flags))
     416        if (!async_share_out_receive(&data_chandle, &size, &flags))
    417417                return EPARTY;
    418418
    419419        if (size < required_size || (flags & required_flags) != required_flags) {
    420                 async_answer_0(data_callid, EINVAL);
     420                async_answer_0(data_chandle, EINVAL);
    421421                return EINVAL;
    422422        }
    423423
    424         if ((err = async_share_out_finalize(data_callid, &trans->request.buffer.virt)))
     424        if ((err = async_share_out_finalize(data_chandle, &trans->request.buffer.virt)))
    425425                return err;
    426426
    … …  
    445445}
    446446
    447 void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
     447void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
    448448{
    449449        assert(fun);
    … …  
    454454
    455455        if (!usbhc_iface->transfer) {
    456                 async_answer_0(callid, ENOTSUP);
    457                 return;
    458         }
    459 
    460         async_transaction_t *trans = async_transaction_create(callid);
     456                async_answer_0(chandle, ENOTSUP);
     457                return;
     458        }
     459
     460        async_transaction_t *trans = async_transaction_create(chandle);
    461461        if (trans == NULL) {
    462                 async_answer_0(callid, ENOMEM);
     462                async_answer_0(chandle, ENOMEM);
    463463                return;
    464464        }
    … …  
    466466        errno_t err = EPARTY;
    467467
    468         cap_call_handle_t data_callid;
     468        cap_call_handle_t data_chandle;
    469469        size_t len;
    470         if (!async_data_write_receive(&data_callid, &len)
     470        if (!async_data_write_receive(&data_chandle, &len)
    471471            || len != sizeof(trans->request)) {
    472                 async_answer_0(data_callid, EINVAL);
     472                async_answer_0(data_chandle, EINVAL);
    473473                goto err;
    474474        }
    475475
    476         if ((err = async_data_write_finalize(data_callid,
     476        if ((err = async_data_write_finalize(data_chandle,
    477477                            &trans->request, sizeof(trans->request))))
    478478                goto err;
    … …  
    494494
    495495err:
    496         async_answer_0(callid, err);
     496        async_answer_0(chandle, err);
    497497        async_transaction_destroy(trans);
    498498}

  • uspace/lib/drv/generic/remote_usbhid.c

    r3e242d2 ra46e56b  
    309309
    310310void remote_usbhid_get_event_length(ddf_fun_t *fun, void *iface,
    311     cap_call_handle_t callid, ipc_call_t *call)
     311    cap_call_handle_t chandle, ipc_call_t *call)
    312312{
    313313        printf("remote_usbhid_get_event_length()\n");
    … …  
    317317        if (!hid_iface->get_event_length) {
    318318                printf("Get event length not set!\n");
    319                 async_answer_0(callid, ENOTSUP);
     319                async_answer_0(chandle, ENOTSUP);
    320320                return;
    321321        }
    … …  
    325325//              len = EEMPTY;
    326326//      }
    327         async_answer_1(callid, EOK, len);
     327        async_answer_1(chandle, EOK, len);
    328328
    329329//      if (len < 0) {
    330 //              async_answer_0(callid, len);
     330//              async_answer_0(chandle, len);
    331331//      } else {
    332 //              async_answer_1(callid, EOK, len);
     332//              async_answer_1(chandle, EOK, len);
    333333//      }
    334334}
    335335
    336336void remote_usbhid_get_event(ddf_fun_t *fun, void *iface,
    337     cap_call_handle_t callid, ipc_call_t *call)
     337    cap_call_handle_t chandle, ipc_call_t *call)
    338338{
    339339        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    340340
    341341        if (!hid_iface->get_event) {
    342                 async_answer_0(callid, ENOTSUP);
     342                async_answer_0(chandle, ENOTSUP);
    343343                return;
    344344        }
    … …  
    347347
    348348        size_t len;
    349         cap_call_handle_t data_callid;
    350         if (!async_data_read_receive(&data_callid, &len)) {
    351                 async_answer_0(callid, EPARTY);
     349        cap_call_handle_t data_chandle;
     350        if (!async_data_read_receive(&data_chandle, &len)) {
     351                async_answer_0(chandle, EPARTY);
    352352                return;
    353353        }
    … …  
    357357//      }
    358358        if (len == 0) {
    359                 async_answer_0(data_callid, EINVAL);
    360                 async_answer_0(callid, EINVAL);
     359                async_answer_0(data_chandle, EINVAL);
     360                async_answer_0(chandle, EINVAL);
    361361                return;
    362362        }
    … …  
    366366        uint8_t *data = malloc(len);
    367367        if (data == NULL) {
    368                 async_answer_0(data_callid, ENOMEM);
    369                 async_answer_0(callid, ENOMEM);
     368                async_answer_0(data_chandle, ENOMEM);
     369                async_answer_0(chandle, ENOMEM);
    370370                return;
    371371        }
    … …  
    376376        if (rc != EOK) {
    377377                free(data);
    378                 async_answer_0(data_callid, rc);
    379                 async_answer_0(callid, rc);
     378                async_answer_0(data_chandle, rc);
     379                async_answer_0(chandle, rc);
    380380                return;
    381381        }
    … …  
    386386        }
    387387
    388         async_data_read_finalize(data_callid, data, act_length);
     388        async_data_read_finalize(data_chandle, data, act_length);
    389389
    390390        free(data);
    391391
    392         async_answer_1(callid, EOK, event_nr);
     392        async_answer_1(chandle, EOK, event_nr);
    393393}
    394394
    395395void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
    396     cap_call_handle_t callid, ipc_call_t *call)
     396    cap_call_handle_t chandle, ipc_call_t *call)
    397397{
    398398        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    399399
    400400        if (!hid_iface->get_report_descriptor_length) {
    401                 async_answer_0(callid, ENOTSUP);
     401                async_answer_0(chandle, ENOTSUP);
    402402                return;
    403403        }
    404404
    405405        size_t len = hid_iface->get_report_descriptor_length(fun);
    406         async_answer_1(callid, EOK, (sysarg_t) len);
     406        async_answer_1(chandle, EOK, (sysarg_t) len);
    407407}
    408408
    409409void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
    410     cap_call_handle_t callid, ipc_call_t *call)
     410    cap_call_handle_t chandle, ipc_call_t *call)
    411411{
    412412        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    413413
    414414        if (!hid_iface->get_report_descriptor) {
    415                 async_answer_0(callid, ENOTSUP);
     415                async_answer_0(chandle, ENOTSUP);
    416416                return;
    417417        }
    418418
    419419        size_t len;
    420         cap_call_handle_t data_callid;
    421         if (!async_data_read_receive(&data_callid, &len)) {
    422                 async_answer_0(callid, EINVAL);
     420        cap_call_handle_t data_chandle;
     421        if (!async_data_read_receive(&data_chandle, &len)) {
     422                async_answer_0(chandle, EINVAL);
    423423                return;
    424424        }
    425425
    426426        if (len == 0) {
    427                 async_answer_0(data_callid, EINVAL);
    428                 async_answer_0(callid, EINVAL);
     427                async_answer_0(data_chandle, EINVAL);
     428                async_answer_0(chandle, EINVAL);
    429429                return;
    430430        }
    … …  
    432432        uint8_t *descriptor = malloc(len);
    433433        if (descriptor == NULL) {
    434                 async_answer_0(data_callid, ENOMEM);
    435                 async_answer_0(callid, ENOMEM);
     434                async_answer_0(data_chandle, ENOMEM);
     435                async_answer_0(chandle, ENOMEM);
    436436                return;
    437437        }
    … …  
    445445        if (rc != EOK) {
    446446                free(descriptor);
    447                 async_answer_0(data_callid, rc);
    448                 async_answer_0(callid, rc);
    449                 return;
    450         }
    451 
    452         async_data_read_finalize(data_callid, descriptor, act_len);
    453         async_answer_0(callid, EOK);
     447                async_answer_0(data_chandle, rc);
     448                async_answer_0(chandle, rc);
     449                return;
     450        }
     451
     452        async_data_read_finalize(data_chandle, descriptor, act_len);
     453        async_answer_0(chandle, EOK);
    454454
    455455        free(descriptor);
Note: See TracChangeset for help on using the changeset viewer.