Changeset 984a9ba in mainline for uspace/lib/drv/generic


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

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

Legend:

Unmodified
Added
Removed

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

    r76f566d r984a9ba  
    118118}
    119119
    120 static void driver_dev_add(cap_call_handle_t icall_handle, ipc_call_t *icall)
     120static void driver_dev_add(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(icall_handle, rc);
     128                async_answer_0(icall, rc);
    129129                return;
    130130        }
    … …  
    134134        if (stopping) {
    135135                fibril_rwlock_read_unlock(&stopping_lock);
    136                 async_answer_0(icall_handle, EIO);
     136                async_answer_0(icall, EIO);
    137137                return;
    138138        }
    … …  
    142142                fibril_rwlock_read_unlock(&stopping_lock);
    143143                free(dev_name);
    144                 async_answer_0(icall_handle, ENOMEM);
     144                async_answer_0(icall, ENOMEM);
    145145                return;
    146146        }
    … …  
    162162                fibril_rwlock_read_unlock(&stopping_lock);
    163163                dev_del_ref(dev);
    164                 async_answer_0(icall_handle, res);
     164                async_answer_0(icall, res);
    165165                return;
    166166        }
    … …  
    171171        fibril_rwlock_read_unlock(&stopping_lock);
    172172
    173         async_answer_0(icall_handle, res);
    174 }
    175 
    176 static void driver_dev_remove(cap_call_handle_t icall_handle, ipc_call_t *icall)
     173        async_answer_0(icall, res);
     174}
     175
     176static void driver_dev_remove(ipc_call_t *icall)
    177177{
    178178        devman_handle_t devh = IPC_GET_ARG1(*icall);
    … …  
    185185
    186186        if (dev == NULL) {
    187                 async_answer_0(icall_handle, ENOENT);
     187                async_answer_0(icall, ENOENT);
    188188                return;
    189189        }
    … …  
    204204
    205205        dev_del_ref(dev);
    206         async_answer_0(icall_handle, rc);
    207 }
    208 
    209 static void driver_dev_gone(cap_call_handle_t icall_handle, ipc_call_t *icall)
     206        async_answer_0(icall, rc);
     207}
     208
     209static void driver_dev_gone(ipc_call_t *icall)
    210210{
    211211        devman_handle_t devh = IPC_GET_ARG1(*icall);
    … …  
    218218
    219219        if (dev == NULL) {
    220                 async_answer_0(icall_handle, ENOENT);
     220                async_answer_0(icall, ENOENT);
    221221                return;
    222222        }
    … …  
    237237
    238238        dev_del_ref(dev);
    239         async_answer_0(icall_handle, rc);
    240 }
    241 
    242 static void driver_fun_online(cap_call_handle_t icall_handle, ipc_call_t *icall)
     239        async_answer_0(icall, rc);
     240}
     241
     242static void driver_fun_online(ipc_call_t *icall)
    243243{
    244244        devman_handle_t funh = IPC_GET_ARG1(*icall);
    … …  
    258258
    259259        if (fun == NULL) {
    260                 async_answer_0(icall_handle, ENOENT);
     260                async_answer_0(icall, ENOENT);
    261261                return;
    262262        }
    … …  
    272272        fun_del_ref(fun);
    273273
    274         async_answer_0(icall_handle, rc);
    275 }
    276 
    277 static void driver_fun_offline(cap_call_handle_t icall_handle, ipc_call_t *icall)
     274        async_answer_0(icall, rc);
     275}
     276
     277static void driver_fun_offline(ipc_call_t *icall)
    278278{
    279279        devman_handle_t funh = IPC_GET_ARG1(*icall);
    … …  
    293293
    294294        if (fun == NULL) {
    295                 async_answer_0(icall_handle, ENOENT);
     295                async_answer_0(icall, ENOENT);
    296296                return;
    297297        }
    … …  
    305305                rc = ENOTSUP;
    306306
    307         async_answer_0(icall_handle, rc);
    308 }
    309 
    310 static void driver_stop(cap_call_handle_t icall_handle, ipc_call_t *icall)
     307        async_answer_0(icall, rc);
     308}
     309
     310static void driver_stop(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(icall_handle, EBUSY);
     323                async_answer_0(icall, EBUSY);
    324324                return;
    325325        }
    … …  
    333333
    334334        /* Reply with success and terminate */
    335         async_answer_0(icall_handle, EOK);
     335        async_answer_0(icall, EOK);
    336336        exit(0);
    337337}
    338338
    339 static void driver_connection_devman(cap_call_handle_t icall_handle, ipc_call_t *icall,
    340     void *arg)
     339static void driver_connection_devman(ipc_call_t *icall, void *arg)
    341340{
    342341        /* Accept connection */
    343         async_answer_0(icall_handle, EOK);
     342        async_answer_0(icall, EOK);
    344343
    345344        while (true) {
    346345                ipc_call_t call;
    347                 cap_call_handle_t chandle = async_get_call(&call);
     346                async_get_call(&call);
    348347
    349348                if (!IPC_GET_IMETHOD(call))
    … …  
    352351                switch (IPC_GET_IMETHOD(call)) {
    353352                case DRIVER_DEV_ADD:
    354                         driver_dev_add(chandle, &call);
     353                        driver_dev_add(&call);
    355354                        break;
    356355                case DRIVER_DEV_REMOVE:
    357                         driver_dev_remove(chandle, &call);
     356                        driver_dev_remove(&call);
    358357                        break;
    359358                case DRIVER_DEV_GONE:
    360                         driver_dev_gone(chandle, &call);
     359                        driver_dev_gone(&call);
    361360                        break;
    362361                case DRIVER_FUN_ONLINE:
    363                         driver_fun_online(chandle, &call);
     362                        driver_fun_online(&call);
    364363                        break;
    365364                case DRIVER_FUN_OFFLINE:
    366                         driver_fun_offline(chandle, &call);
     365                        driver_fun_offline(&call);
    367366                        break;
    368367                case DRIVER_STOP:
    369                         driver_stop(chandle, &call);
     368                        driver_stop(&call);
    370369                        break;
    371370                default:
    372                         async_answer_0(chandle, ENOTSUP);
     371                        async_answer_0(&call, ENOTSUP);
    373372                }
    374373        }
    … …  
    381380 *
    382381 */
    383 static void driver_connection_gen(cap_call_handle_t icall_handle, ipc_call_t *icall, bool drv)
     382static void driver_connection_gen(ipc_call_t *icall, bool drv)
    384383{
    385384        /*
    … …  
    398397                printf("%s: driver_connection_gen error - no function with handle"
    399398                    " %" PRIun " was found.\n", driver->name, handle);
    400                 async_answer_0(icall_handle, ENOENT);
     399                async_answer_0(icall, ENOENT);
    401400                return;
    402401        }
    … …  
    404403        if (fun->conn_handler != NULL) {
    405404                /* Driver has a custom connection handler. */
    406                 (*fun->conn_handler)(icall_handle, icall, (void *)fun);
     405                (*fun->conn_handler)(icall, (void *)fun);
    407406                fun_del_ref(fun);
    408407                return;
    … …  
    419418                ret = (*fun->ops->open)(fun);
    420419
    421         async_answer_0(icall_handle, ret);
     420        async_answer_0(icall, ret);
    422421        if (ret != EOK) {
    423422                fun_del_ref(fun);
    … …  
    426425
    427426        while (true) {
    428                 cap_call_handle_t chandle;
    429427                ipc_call_t call;
    430                 chandle = async_get_call(&call);
     428                async_get_call(&call);
     429
    431430                sysarg_t method = IPC_GET_IMETHOD(call);
    432431
    … …  
    435434                        if (fun->ops != NULL && fun->ops->close != NULL)
    436435                                (*fun->ops->close)(fun);
    437                         async_answer_0(chandle, EOK);
     436                        async_answer_0(&call, EOK);
    438437                        fun_del_ref(fun);
    439438                        return;
    … …  
    448447                            function_get_default_handler(fun);
    449448                        if (default_handler != NULL) {
    450                                 (*default_handler)(fun, chandle, &call);
     449                                (*default_handler)(fun, &call);
    451450                                continue;
    452451                        }
    … …  
    459458                            "invalid interface id %d.",
    460459                            driver->name, iface_idx);
    461                         async_answer_0(chandle, ENOTSUP);
     460                        async_answer_0(&call, ENOTSUP);
    462461                        continue;
    463462                }
    … …  
    471470                        printf("Function with handle %" PRIun " has no interface "
    472471                            "with id %d.\n", handle, iface_idx);
    473                         async_answer_0(chandle, ENOTSUP);
     472                        async_answer_0(&call, ENOTSUP);
    474473                        continue;
    475474                }
    … …  
    490489                        printf("%s: driver_connection_gen error - "
    491490                            "invalid interface method.", driver->name);
    492                         async_answer_0(chandle, ENOTSUP);
     491                        async_answer_0(&call, ENOTSUP);
    493492                        continue;
    494493                }
    … …  
    500499                 * associated with the function by its driver.
    501500                 */
    502                 (*iface_method_ptr)(fun, ops, chandle, &call);
    503         }
    504 }
    505 
    506 static void driver_connection_driver(cap_call_handle_t icall_handle, ipc_call_t *icall,
    507     void *arg)
    508 {
    509         driver_connection_gen(icall_handle, icall, true);
    510 }
    511 
    512 static void driver_connection_client(cap_call_handle_t icall_handle, ipc_call_t *icall,
    513     void *arg)
    514 {
    515         driver_connection_gen(icall_handle, icall, false);
     501                (*iface_method_ptr)(fun, ops, &call);
     502        }
     503}
     504
     505static void driver_connection_driver(ipc_call_t *icall, void *arg)
     506{
     507        driver_connection_gen(icall, true);
     508}
     509
     510static void driver_connection_client(ipc_call_t *icall, void *arg)
     511{
     512        driver_connection_gen(icall, false);
    516513}
    517514

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

    r76f566d r984a9ba  
    182182}
    183183
    184 static void remote_ahci_get_sata_device_name(ddf_fun_t *, void *, cap_call_handle_t,
    185     ipc_call_t *);
    186 static void remote_ahci_get_num_blocks(ddf_fun_t *, void *, cap_call_handle_t,
    187     ipc_call_t *);
    188 static void remote_ahci_get_block_size(ddf_fun_t *, void *, cap_call_handle_t,
    189     ipc_call_t *);
    190 static void remote_ahci_read_blocks(ddf_fun_t *, void *, cap_call_handle_t,
    191     ipc_call_t *);
    192 static void remote_ahci_write_blocks(ddf_fun_t *, void *, cap_call_handle_t,
    193     ipc_call_t *);
     184static void remote_ahci_get_sata_device_name(ddf_fun_t *, void *, ipc_call_t *);
     185static void remote_ahci_get_num_blocks(ddf_fun_t *, void *, ipc_call_t *);
     186static void remote_ahci_get_block_size(ddf_fun_t *, void *, ipc_call_t *);
     187static void remote_ahci_read_blocks(ddf_fun_t *, void *, ipc_call_t *);
     188static void remote_ahci_write_blocks(ddf_fun_t *, void *, ipc_call_t *);
    194189
    195190/** Remote AHCI interface operations. */
    … …  
    210205
    211206void remote_ahci_get_sata_device_name(ddf_fun_t *fun, void *iface,
    212     cap_call_handle_t chandle, ipc_call_t *call)
     207    ipc_call_t *call)
    213208{
    214209        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    215210
    216211        if (ahci_iface->get_sata_device_name == NULL) {
    217                 async_answer_0(chandle, ENOTSUP);
     212                async_answer_0(call, ENOTSUP);
    218213                return;
    219214        }
    … …  
    224219        char *sata_dev_name = malloc(sata_dev_name_length);
    225220        if (sata_dev_name == NULL) {
    226                 async_answer_0(chandle, ENOMEM);
     221                async_answer_0(call, ENOMEM);
    227222                return;
    228223        }
    … …  
    231226            sata_dev_name_length, sata_dev_name);
    232227
     228        ipc_call_t data;
    233229        size_t real_size;
    234         cap_call_handle_t call_handle;
    235         if ((async_data_read_receive(&call_handle, &real_size)) &&
     230        if ((async_data_read_receive(&data, &real_size)) &&
    236231            (real_size == sata_dev_name_length))
    237                 async_data_read_finalize(call_handle, sata_dev_name,
     232                async_data_read_finalize(&data, sata_dev_name,
    238233                    sata_dev_name_length);
    239234
    240235        free(sata_dev_name);
    241         async_answer_0(chandle, ret);
     236        async_answer_0(call, ret);
    242237}
    243238
    244239static void remote_ahci_get_num_blocks(ddf_fun_t *fun, void *iface,
    245     cap_call_handle_t chandle, ipc_call_t *call)
     240    ipc_call_t *call)
    246241{
    247242        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    248243
    249244        if (ahci_iface->get_num_blocks == NULL) {
    250                 async_answer_0(chandle, ENOTSUP);
     245                async_answer_0(call, ENOTSUP);
    251246                return;
    252247        }
    … …  
    256251
    257252        if (ret != EOK)
    258                 async_answer_0(chandle, ret);
     253                async_answer_0(call, ret);
    259254        else
    260                 async_answer_2(chandle, EOK, HI(blocks), LO(blocks));
     255                async_answer_2(call, EOK, HI(blocks), LO(blocks));
    261256}
    262257
    263258static void remote_ahci_get_block_size(ddf_fun_t *fun, void *iface,
    264     cap_call_handle_t chandle, ipc_call_t *call)
     259    ipc_call_t *call)
    265260{
    266261        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    267262
    268263        if (ahci_iface->get_block_size == NULL) {
    269                 async_answer_0(chandle, ENOTSUP);
     264                async_answer_0(call, ENOTSUP);
    270265                return;
    271266        }
    … …  
    275270
    276271        if (ret != EOK)
    277                 async_answer_0(chandle, ret);
     272                async_answer_0(call, ret);
    278273        else
    279                 async_answer_1(chandle, EOK, blocks);
    280 }
    281 
    282 void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface,
    283     cap_call_handle_t chandle, ipc_call_t *call)
     274                async_answer_1(call, EOK, blocks);
     275}
     276
     277void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    284278{
    285279        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    286280
    287281        if (ahci_iface->read_blocks == NULL) {
    288                 async_answer_0(chandle, ENOTSUP);
    289                 return;
    290         }
    291 
     282                async_answer_0(call, ENOTSUP);
     283                return;
     284        }
     285
     286        ipc_call_t data;
    292287        size_t maxblock_size;
    293288        unsigned int flags;
    294 
    295         cap_call_handle_t call_handle;
    296         async_share_out_receive(&call_handle, &maxblock_size, &flags);
     289        async_share_out_receive(&data, &maxblock_size, &flags);
    297290
    298291        void *buf;
    299         async_share_out_finalize(call_handle, &buf);
     292        async_share_out_finalize(&data, &buf);
    300293
    301294        const uint64_t blocknum =
    … …  
    306299        const errno_t ret = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
    307300
    308         async_answer_0(chandle, ret);
    309 }
    310 
    311 void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle,
    312     ipc_call_t *call)
     301        async_answer_0(call, ret);
     302}
     303
     304void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    313305{
    314306        const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
    315307
    316308        if (ahci_iface->read_blocks == NULL) {
    317                 async_answer_0(chandle, ENOTSUP);
    318                 return;
    319         }
    320 
     309                async_answer_0(call, ENOTSUP);
     310                return;
     311        }
     312
     313        ipc_call_t data;
    321314        size_t maxblock_size;
    322315        unsigned int flags;
    323 
    324         cap_call_handle_t call_handle;
    325         async_share_out_receive(&call_handle, &maxblock_size, &flags);
     316        async_share_out_receive(&data, &maxblock_size, &flags);
    326317
    327318        void *buf;
    328         async_share_out_finalize(call_handle, &buf);
     319        async_share_out_finalize(&data, &buf);
    329320
    330321        const uint64_t blocknum =
    … …  
    335326        const errno_t ret = ahci_iface->write_blocks(fun, blocknum, cnt, buf);
    336327
    337         async_answer_0(chandle, ret);
     328        async_answer_0(call, ret);
    338329}
    339330

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

    r76f566d r984a9ba  
    203203 * SERVER SIDE
    204204 */
    205 static void remote_audio_mixer_get_info(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    206 static void remote_audio_mixer_get_item_info(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    207 static void remote_audio_mixer_get_item_level(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    208 static void remote_audio_mixer_set_item_level(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
     205static void remote_audio_mixer_get_info(ddf_fun_t *, void *, ipc_call_t *);
     206static void remote_audio_mixer_get_item_info(ddf_fun_t *, void *, ipc_call_t *);
     207static void remote_audio_mixer_get_item_level(ddf_fun_t *, void *, ipc_call_t *);
     208static void remote_audio_mixer_set_item_level(ddf_fun_t *, void *, ipc_call_t *);
    209209
    210210/** Remote audio mixer interface operations. */
    … …  
    222222};
    223223
    224 void remote_audio_mixer_get_info(
    225     ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     224void remote_audio_mixer_get_info(ddf_fun_t *fun, void *iface, ipc_call_t *icall)
    226225{
    227226        audio_mixer_iface_t *mixer_iface = iface;
    228227
    229228        if (!mixer_iface->get_info) {
    230                 async_answer_0(chandle, ENOTSUP);
     229                async_answer_0(icall, ENOTSUP);
    231230                return;
    232231        }
     232
    233233        const char *name = NULL;
    234234        unsigned items = 0;
    235235        const errno_t ret = mixer_iface->get_info(fun, &name, &items);
    236236        const size_t name_size = name ? str_size(name) + 1 : 0;
    237         async_answer_2(chandle, ret, name_size, items);
     237        async_answer_2(icall, ret, name_size, items);
     238
    238239        /* Send the name. */
    239240        if (ret == EOK && name_size > 0) {
     241                ipc_call_t call;
    240242                size_t size;
    241                 cap_call_handle_t name_id;
    242                 if (!async_data_read_receive(&name_id, &size)) {
    243                         async_answer_0(name_id, EPARTY);
     243                if (!async_data_read_receive(&call, &size)) {
     244                        async_answer_0(&call, EPARTY);
    244245                        return;
    245246                }
     247
    246248                if (size != name_size) {
    247                         async_answer_0(name_id, ELIMIT);
     249                        async_answer_0(&call, ELIMIT);
    248250                        return;
    249251                }
    250                 async_data_read_finalize(name_id, name, name_size);
    251         }
    252 }
    253 
    254 void remote_audio_mixer_get_item_info(
    255     ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     252
     253                async_data_read_finalize(&call, name, name_size);
     254        }
     255}
     256
     257void remote_audio_mixer_get_item_info(ddf_fun_t *fun, void *iface,
     258    ipc_call_t *icall)
    256259{
    257260        audio_mixer_iface_t *mixer_iface = iface;
    258261
    259262        if (!mixer_iface->get_item_info) {
    260                 async_answer_0(chandle, ENOTSUP);
     263                async_answer_0(icall, ENOTSUP);
    261264                return;
    262265        }
    263266
    264         const unsigned item = DEV_IPC_GET_ARG1(*call);
     267        const unsigned item = DEV_IPC_GET_ARG1(*icall);
    265268        const char *name = NULL;
    266269        unsigned values = 0;
    267270        const errno_t ret = mixer_iface->get_item_info(fun, item, &name, &values);
    268271        const size_t name_size = name ? str_size(name) + 1 : 0;
    269         async_answer_2(chandle, ret, name_size, values);
     272        async_answer_2(icall, ret, name_size, values);
     273
    270274        /* Send the name. */
    271275        if (ret == EOK && name_size > 0) {
     276                ipc_call_t call;
    272277                size_t size;
    273                 cap_call_handle_t name_id;
    274                 if (!async_data_read_receive(&name_id, &size)) {
    275                         async_answer_0(name_id, EPARTY);
     278                if (!async_data_read_receive(&call, &size)) {
     279                        async_answer_0(&call, EPARTY);
    276280                        return;
    277281                }
     282
    278283                if (size != name_size) {
    279                         async_answer_0(name_id, ELIMIT);
     284                        async_answer_0(&call, ELIMIT);
    280285                        return;
    281286                }
    282                 async_data_read_finalize(name_id, name, name_size);
    283         }
    284 }
    285 
    286 void remote_audio_mixer_set_item_level(
    287     ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     287
     288                async_data_read_finalize(&call, name, name_size);
     289        }
     290}
     291
     292void remote_audio_mixer_set_item_level(ddf_fun_t *fun, void *iface,
     293    ipc_call_t *icall)
    288294{
    289295        audio_mixer_iface_t *mixer_iface = iface;
    290296
    291297        if (!mixer_iface->set_item_level) {
    292                 async_answer_0(chandle, ENOTSUP);
     298                async_answer_0(icall, ENOTSUP);
    293299                return;
    294300        }
    295         const unsigned item = DEV_IPC_GET_ARG1(*call);
    296         const unsigned value = DEV_IPC_GET_ARG2(*call);
     301
     302        const unsigned item = DEV_IPC_GET_ARG1(*icall);
     303        const unsigned value = DEV_IPC_GET_ARG2(*icall);
    297304        const errno_t ret = mixer_iface->set_item_level(fun, item, value);
    298         async_answer_0(chandle, ret);
    299 }
    300 
    301 void remote_audio_mixer_get_item_level(
    302     ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     305        async_answer_0(icall, ret);
     306}
     307
     308void remote_audio_mixer_get_item_level(ddf_fun_t *fun, void *iface,
     309    ipc_call_t *icall)
    303310{
    304311        audio_mixer_iface_t *mixer_iface = iface;
    305312
    306313        if (!mixer_iface->get_item_level) {
    307                 async_answer_0(chandle, ENOTSUP);
     314                async_answer_0(icall, ENOTSUP);
    308315                return;
    309316        }
    310         const unsigned item = DEV_IPC_GET_ARG1(*call);
     317
     318        const unsigned item = DEV_IPC_GET_ARG1(*icall);
    311319        unsigned current = 0;
    312320        const errno_t ret =
    313321            mixer_iface->get_item_level(fun, item, &current);
    314         async_answer_1(chandle, ret, current);
     322        async_answer_1(icall, ret, current);
    315323}
    316324

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

    r76f566d r984a9ba  
    600600 * SERVER SIDE
    601601 */
    602 static void remote_audio_pcm_get_info_str(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    603 static void remote_audio_pcm_query_caps(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    604 static void remote_audio_pcm_events_register(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    605 static void remote_audio_pcm_events_unregister(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    606 static void remote_audio_pcm_get_buffer_pos(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    607 static void remote_audio_pcm_test_format(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    608 static void remote_audio_pcm_get_buffer(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    609 static void remote_audio_pcm_release_buffer(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    610 static void remote_audio_pcm_start_playback(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    611 static void remote_audio_pcm_stop_playback(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    612 static void remote_audio_pcm_start_capture(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    613 static void remote_audio_pcm_stop_capture(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
     602static void remote_audio_pcm_get_info_str(ddf_fun_t *, void *, ipc_call_t *);
     603static void remote_audio_pcm_query_caps(ddf_fun_t *, void *, ipc_call_t *);
     604static void remote_audio_pcm_events_register(ddf_fun_t *, void *, ipc_call_t *);
     605static void remote_audio_pcm_events_unregister(ddf_fun_t *, void *, ipc_call_t *);
     606static void remote_audio_pcm_get_buffer_pos(ddf_fun_t *, void *, ipc_call_t *);
     607static void remote_audio_pcm_test_format(ddf_fun_t *, void *, ipc_call_t *);
     608static void remote_audio_pcm_get_buffer(ddf_fun_t *, void *, ipc_call_t *);
     609static void remote_audio_pcm_release_buffer(ddf_fun_t *, void *, ipc_call_t *);
     610static void remote_audio_pcm_start_playback(ddf_fun_t *, void *, ipc_call_t *);
     611static void remote_audio_pcm_stop_playback(ddf_fun_t *, void *, ipc_call_t *);
     612static void remote_audio_pcm_start_capture(ddf_fun_t *, void *, ipc_call_t *);
     613static void remote_audio_pcm_stop_capture(ddf_fun_t *, void *, ipc_call_t *);
    614614
    615615/** Remote audio pcm buffer interface operations. */
    … …  
    636636
    637637void remote_audio_pcm_get_info_str(ddf_fun_t *fun, void *iface,
    638     cap_call_handle_t chandle, ipc_call_t *call)
     638    ipc_call_t *call)
    639639{
    640640        const audio_pcm_iface_t *pcm_iface = iface;
    641641
    642642        if (!pcm_iface->get_info_str) {
    643                 async_answer_0(chandle, ENOTSUP);
    644                 return;
    645         }
     643                async_answer_0(call, ENOTSUP);
     644                return;
     645        }
     646
    646647        const char *name = NULL;
    647648        const errno_t ret = pcm_iface->get_info_str(fun, &name);
    648649        const size_t name_size = name ? str_size(name) + 1 : 0;
    649         async_answer_1(chandle, ret, name_size);
     650        async_answer_1(call, ret, name_size);
     651
    650652        /* Send the string. */
    651653        if (ret == EOK && name_size > 0) {
     654                ipc_call_t call;
    652655                size_t size;
    653                 cap_call_handle_t name_id;
    654                 if (!async_data_read_receive(&name_id, &size)) {
    655                         async_answer_0(name_id, EPARTY);
     656                if (!async_data_read_receive(&call, &size)) {
     657                        async_answer_0(&call, EPARTY);
    656658                        return;
    657659                }
     660
    658661                if (size != name_size) {
    659                         async_answer_0(name_id, ELIMIT);
     662                        async_answer_0(&call, ELIMIT);
    660663                        return;
    661664                }
    662                 async_data_read_finalize(name_id, name, name_size);
     665
     666                async_data_read_finalize(&call, name, name_size);
    663667        }
    664668}
    665669
    666670void remote_audio_pcm_query_caps(ddf_fun_t *fun, void *iface,
    667     cap_call_handle_t chandle, ipc_call_t *call)
     671    ipc_call_t *call)
    668672{
    669673        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    671675        if (pcm_iface->query_cap) {
    672676                const unsigned value = pcm_iface->query_cap(fun, cap);
    673                 async_answer_1(chandle, EOK, value);
     677                async_answer_1(call, EOK, value);
    674678        } else {
    675                 async_answer_0(chandle, ENOTSUP);
     679                async_answer_0(call, ENOTSUP);
    676680        }
    677681}
    678682
    679683static void remote_audio_pcm_events_register(ddf_fun_t *fun, void *iface,
    680     cap_call_handle_t chandle, ipc_call_t *call)
     684    ipc_call_t *call)
    681685{
    682686        const audio_pcm_iface_t *pcm_iface = iface;
    683687        if (!pcm_iface->get_event_session ||
    684688            !pcm_iface->set_event_session) {
    685                 async_answer_0(chandle, ENOTSUP);
    686                 return;
    687         }
    688 
    689         async_answer_0(chandle, EOK);
     689                async_answer_0(call, ENOTSUP);
     690                return;
     691        }
     692
     693        async_answer_0(call, EOK);
    690694
    691695        ipc_call_t callback_call;
    692         cap_call_handle_t callback_handle = async_get_call(&callback_call);
     696        async_get_call(&callback_call);
    693697        async_sess_t *sess =
    694698            async_callback_receive_start(EXCHANGE_ATOMIC, &callback_call);
    695699        if (sess == NULL) {
    696700                ddf_msg(LVL_DEBUG, "Failed to create event callback");
    697                 async_answer_0(callback_handle, EAGAIN);
    698                 return;
    699         }
     701                async_answer_0(&callback_call, EAGAIN);
     702                return;
     703        }
     704
    700705        const errno_t ret = pcm_iface->set_event_session(fun, sess);
    701706        if (ret != EOK) {
    702707                ddf_msg(LVL_DEBUG, "Failed to set event callback.");
    703708                async_hangup(sess);
    704                 async_answer_0(callback_handle, ret);
    705                 return;
    706         }
    707         async_answer_0(callback_handle, EOK);
     709                async_answer_0(&callback_call, ret);
     710                return;
     711        }
     712
     713        async_answer_0(&callback_call, EOK);
    708714}
    709715
    710716static void remote_audio_pcm_events_unregister(ddf_fun_t *fun, void *iface,
    711     cap_call_handle_t chandle, ipc_call_t *call)
     717    ipc_call_t *call)
    712718{
    713719        const audio_pcm_iface_t *pcm_iface = iface;
    714720        if (!pcm_iface->get_event_session ||
    715721            !pcm_iface->set_event_session) {
    716                 async_answer_0(chandle, ENOTSUP);
    717                 return;
    718         }
     722                async_answer_0(call, ENOTSUP);
     723                return;
     724        }
     725
    719726        async_sess_t *sess = pcm_iface->get_event_session(fun);
    720727        if (sess) {
    … …  
    722729                pcm_iface->set_event_session(fun, NULL);
    723730        }
    724         async_answer_0(chandle, EOK);
     731
     732        async_answer_0(call, EOK);
    725733}
    726734
    727735void remote_audio_pcm_get_buffer_pos(ddf_fun_t *fun, void *iface,
    728     cap_call_handle_t chandle, ipc_call_t *call)
     736    ipc_call_t *call)
    729737{
    730738        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    732740        const errno_t ret = pcm_iface->get_buffer_pos ?
    733741            pcm_iface->get_buffer_pos(fun, &pos) : ENOTSUP;
    734         async_answer_1(chandle, ret, pos);
     742        async_answer_1(call, ret, pos);
    735743}
    736744
    737745void remote_audio_pcm_test_format(ddf_fun_t *fun, void *iface,
    738     cap_call_handle_t chandle, ipc_call_t *call)
     746    ipc_call_t *call)
    739747{
    740748        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    744752        const errno_t ret = pcm_iface->test_format ?
    745753            pcm_iface->test_format(fun, &channels, &rate, &format) : ENOTSUP;
    746         async_answer_3(chandle, ret, channels, rate, format);
     754        async_answer_3(call, ret, channels, rate, format);
    747755}
    748756
    749757void remote_audio_pcm_get_buffer(ddf_fun_t *fun, void *iface,
    750     cap_call_handle_t chandle, ipc_call_t *call)
     758    ipc_call_t *call)
    751759{
    752760        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    754762        if (!pcm_iface->get_buffer ||
    755763            !pcm_iface->release_buffer) {
    756                 async_answer_0(chandle, ENOTSUP);
     764                async_answer_0(call, ENOTSUP);
    757765                return;
    758766        }
    … …  
    760768        size_t size = DEV_IPC_GET_ARG1(*call);
    761769        errno_t ret = pcm_iface->get_buffer(fun, &buffer, &size);
    762         async_answer_1(chandle, ret, size);
     770        async_answer_1(call, ret, size);
    763771        if (ret != EOK || size == 0)
    764772                return;
    765773
    766774        /* Share the buffer. */
     775        ipc_call_t share;
    767776        size_t share_size = 0;
    768         cap_call_handle_t share_id = 0;
    769777
    770778        ddf_msg(LVL_DEBUG2, "Receiving share request.");
    771         if (!async_share_in_receive(&share_id, &share_size)) {
     779        if (!async_share_in_receive(&share, &share_size)) {
    772780                ddf_msg(LVL_DEBUG, "Failed to share pcm buffer.");
    773781                pcm_iface->release_buffer(fun);
    774                 async_answer_0(share_id, EPARTY);
     782                async_answer_0(&share, EPARTY);
    775783                return;
    776784        }
    … …  
    780788                ddf_msg(LVL_DEBUG, "Incorrect pcm buffer size requested.");
    781789                pcm_iface->release_buffer(fun);
    782                 async_answer_0(share_id, ELIMIT);
     790                async_answer_0(&share, ELIMIT);
    783791                return;
    784792        }
    785793
    786794        ddf_msg(LVL_DEBUG2, "Calling share finalize.");
    787         ret = async_share_in_finalize(share_id, buffer, AS_AREA_WRITE |
     795        ret = async_share_in_finalize(&share, buffer, AS_AREA_WRITE |
    788796            AS_AREA_READ);
    789797        if (ret != EOK) {
    … …  
    797805
    798806void remote_audio_pcm_release_buffer(ddf_fun_t *fun, void *iface,
    799     cap_call_handle_t chandle, ipc_call_t *call)
     807    ipc_call_t *call)
    800808{
    801809        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    803811        const errno_t ret = pcm_iface->release_buffer ?
    804812            pcm_iface->release_buffer(fun) : ENOTSUP;
    805         async_answer_0(chandle, ret);
     813        async_answer_0(call, ret);
    806814}
    807815
    808816void remote_audio_pcm_start_playback(ddf_fun_t *fun, void *iface,
    809     cap_call_handle_t chandle, ipc_call_t *call)
     817    ipc_call_t *call)
    810818{
    811819        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    819827            pcm_iface->start_playback(fun, frames, channels, rate, format) :
    820828            ENOTSUP;
    821         async_answer_0(chandle, ret);
     829        async_answer_0(call, ret);
    822830}
    823831
    824832void remote_audio_pcm_stop_playback(ddf_fun_t *fun, void *iface,
    825     cap_call_handle_t chandle, ipc_call_t *call)
     833    ipc_call_t *call)
    826834{
    827835        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    830838        const errno_t ret = pcm_iface->stop_playback ?
    831839            pcm_iface->stop_playback(fun, immediate) : ENOTSUP;
    832         async_answer_0(chandle, ret);
     840        async_answer_0(call, ret);
    833841}
    834842
    835843void remote_audio_pcm_start_capture(ddf_fun_t *fun, void *iface,
    836     cap_call_handle_t chandle, ipc_call_t *call)
     844    ipc_call_t *call)
    837845{
    838846        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    846854            pcm_iface->start_capture(fun, frames, channels, rate, format) :
    847855            ENOTSUP;
    848         async_answer_0(chandle, ret);
     856        async_answer_0(call, ret);
    849857}
    850858
    851859void remote_audio_pcm_stop_capture(ddf_fun_t *fun, void *iface,
    852     cap_call_handle_t chandle, ipc_call_t *call)
     860    ipc_call_t *call)
    853861{
    854862        const audio_pcm_iface_t *pcm_iface = iface;
    … …  
    857865        const errno_t ret = pcm_iface->stop_capture ?
    858866            pcm_iface->stop_capture(fun, immediate) : ENOTSUP;
    859         async_answer_0(chandle, ret);
     867        async_answer_0(call, ret);
    860868}
    861869
    … …  
    863871 * @}
    864872 */
    865 

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

    r76f566d r984a9ba  
    9090}
    9191
    92 static void remote_battery_status_get(ddf_fun_t *, void *, cap_call_handle_t,
    93     ipc_call_t *);
    94 static void remote_battery_charge_level_get(ddf_fun_t *, void *, cap_call_handle_t,
    95     ipc_call_t *);
     92static void remote_battery_status_get(ddf_fun_t *, void *, ipc_call_t *);
     93static void remote_battery_charge_level_get(ddf_fun_t *, void *, ipc_call_t *);
    9694
    9795/** Remote battery interface operations */
    … …  
    114112/** Process the status_get() request from the remote client
    115113 *
    116  * @param fun    The function from which the battery status is read
    117  * @param ops    The local ops structure
     114 * @param fun The function from which the battery status is read
     115 * @param ops The local ops structure
     116 *
    118117 */
    119 static void
    120 remote_battery_status_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
     118static void remote_battery_status_get(ddf_fun_t *fun, void *ops,
    121119    ipc_call_t *call)
    122120{
    … …  
    124122
    125123        if (bops->battery_status_get == NULL) {
    126                 async_answer_0(chandle, ENOTSUP);
     124                async_answer_0(call, ENOTSUP);
    127125                return;
    128126        }
    … …  
    132130
    133131        if (rc != EOK)
    134                 async_answer_0(chandle, rc);
     132                async_answer_0(call, rc);
    135133        else
    136                 async_answer_1(chandle, rc, batt_status);
     134                async_answer_1(call, rc, batt_status);
    137135}
    138136
    139137/** Process the battery_charge_level_get() request from the remote client
    140138 *
    141  * @param fun    The function from which the battery charge level is read
    142  * @param ops    The local ops structure
     139 * @param fun  The function from which the battery charge level is read
     140 * @param ops The local ops structure
    143141 *
    144142 */
    145 static void
    146 remote_battery_charge_level_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
     143static void remote_battery_charge_level_get(ddf_fun_t *fun, void *ops,
    147144    ipc_call_t *call)
    148145{
    … …  
    150147
    151148        if (bops->battery_charge_level_get == NULL) {
    152                 async_answer_0(chandle, ENOTSUP);
     149                async_answer_0(call, ENOTSUP);
    153150                return;
    154151        }
    … …  
    158155
    159156        if (rc != EOK)
    160                 async_answer_0(chandle, rc);
     157                async_answer_0(call, rc);
    161158        else
    162                 async_answer_1(chandle, rc, battery_level);
     159                async_answer_1(call, rc, battery_level);
    163160}
    164 

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

    r76f566d r984a9ba  
    4242#include <ddf/driver.h>
    4343
    44 static void remote_clock_time_get(ddf_fun_t *, void *, cap_call_handle_t,
    45     ipc_call_t *);
    46 static void remote_clock_time_set(ddf_fun_t *, void *, cap_call_handle_t,
    47     ipc_call_t *);
     44static void remote_clock_time_get(ddf_fun_t *, void *, ipc_call_t *);
     45static void remote_clock_time_set(ddf_fun_t *, void *, ipc_call_t *);
    4846
    4947/** Remote clock interface operations */
    … …  
    6563/** Process the time_get() request from the remote client
    6664 *
    67  * @param fun   The function from which the time is read
    68  * @param ops   The local ops structure
     65 * @param fun The function from which the time is read
     66 * @param ops The local ops structure
     67 *
    6968 */
    70 static void
    71 remote_clock_time_get(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
    72     ipc_call_t *call)
     69static void remote_clock_time_get(ddf_fun_t *fun, void *ops, ipc_call_t *call)
    7370{
    7471        clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops;
    75         cap_call_handle_t call_handle;
    7672        struct tm t;
    7773        errno_t rc;
     74
     75        ipc_call_t data;
    7876        size_t len;
    79 
    80         if (!async_data_read_receive(&call_handle, &len)) {
     77        if (!async_data_read_receive(&data, &len)) {
    8178                /* TODO: Handle protocol error */
    82                 async_answer_0(chandle, EINVAL);
     79                async_answer_0(call, EINVAL);
    8380                return;
    8481        }
    … …  
    8683        if (!clock_dev_ops->time_get) {
    8784                /* The driver does not provide the time_get() functionality */
    88                 async_answer_0(call_handle, ENOTSUP);
    89                 async_answer_0(chandle, ENOTSUP);
     85                async_answer_0(&data, ENOTSUP);
     86                async_answer_0(call, ENOTSUP);
    9087                return;
    9188        }
    … …  
    9592        if (rc != EOK) {
    9693                /* Some error occurred */
    97                 async_answer_0(call_handle, rc);
    98                 async_answer_0(chandle, rc);
     94                async_answer_0(&data, rc);
     95                async_answer_0(call, rc);
    9996                return;
    10097        }
    10198
    10299        /* The operation was successful */
    103         async_data_read_finalize(call_handle, &t, sizeof(struct tm));
    104         async_answer_0(chandle, rc);
     100        async_data_read_finalize(&data, &t, sizeof(struct tm));
     101        async_answer_0(call, rc);
    105102}
    106103
    107104/** Process the time_set() request from the remote client
    108105 *
    109  * @param fun   The function to which the data are written
    110  * @param ops   The local ops structure
     106 * @param fun The function to which the data are written
     107 * @param ops The local ops structure
     108 *
    111109 */
    112 static void remote_clock_time_set(ddf_fun_t *fun, void *ops,
    113     cap_call_handle_t chandle, ipc_call_t *call)
     110static void remote_clock_time_set(ddf_fun_t *fun, void *ops, ipc_call_t *call)
    114111{
    115112        clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops;
    116         errno_t      rc;
    117         struct tm    t;
    118         cap_call_handle_t call_handle;
    119         size_t       len;
     113        errno_t rc;
     114        struct tm t;
    120115
    121         if (!async_data_write_receive(&call_handle, &len)) {
     116        ipc_call_t data;
     117        size_t len;
     118
     119        if (!async_data_write_receive(&data, &len)) {
    122120                /* TODO: Handle protocol error */
    123                 async_answer_0(chandle, EINVAL);
     121                async_answer_0(call, EINVAL);
    124122                return;
    125123        }
    … …  
    127125        if (!clock_dev_ops->time_set) {
    128126                /* The driver does not support the time_set() functionality */
    129                 async_answer_0(call_handle, ENOTSUP);
    130                 async_answer_0(chandle, ENOTSUP);
     127                async_answer_0(&data, ENOTSUP);
     128                async_answer_0(call, ENOTSUP);
    131129                return;
    132130        }
    133131
    134         async_data_write_finalize(call_handle, &t, sizeof(struct tm));
     132        async_data_write_finalize(&data, &t, sizeof(struct tm));
    135133
    136134        rc = (*clock_dev_ops->time_set)(fun, &t);
    137135
    138         async_answer_0(chandle, rc);
     136        async_answer_0(call, rc);
    139137}
    140138
    … …  
    142140 * @}
    143141 */
    144 

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

    r76f566d r984a9ba  
    4141#include "ddf/driver.h"
    4242
    43 static void remote_hw_res_get_resource_list(ddf_fun_t *, void *, cap_call_handle_t,
    44     ipc_call_t *);
    45 static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, cap_call_handle_t,
    46     ipc_call_t *);
    47 static void remote_hw_res_disable_interrupt(ddf_fun_t *, void *, cap_call_handle_t,
    48     ipc_call_t *);
    49 static void remote_hw_res_clear_interrupt(ddf_fun_t *, void *, cap_call_handle_t,
    50     ipc_call_t *);
    51 static void remote_hw_res_dma_channel_setup(ddf_fun_t *, void *, cap_call_handle_t,
    52     ipc_call_t *);
    53 static void remote_hw_res_dma_channel_remain(ddf_fun_t *, void *, cap_call_handle_t,
    54     ipc_call_t *);
     43static void remote_hw_res_get_resource_list(ddf_fun_t *, void *, ipc_call_t *);
     44static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, ipc_call_t *);
     45static void remote_hw_res_disable_interrupt(ddf_fun_t *, void *, ipc_call_t *);
     46static void remote_hw_res_clear_interrupt(ddf_fun_t *, void *, ipc_call_t *);
     47static void remote_hw_res_dma_channel_setup(ddf_fun_t *, void *, ipc_call_t *);
     48static void remote_hw_res_dma_channel_remain(ddf_fun_t *, void *, ipc_call_t *);
    5549
    5650static const remote_iface_func_ptr_t remote_hw_res_iface_ops [] = {
    … …  
    6963
    7064static void remote_hw_res_enable_interrupt(ddf_fun_t *fun, void *ops,
    71     cap_call_handle_t chandle, ipc_call_t *call)
     65    ipc_call_t *call)
    7266{
    7367        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    7468
    7569        if (hw_res_ops->enable_interrupt == NULL) {
    76                 async_answer_0(chandle, ENOTSUP);
     70                async_answer_0(call, ENOTSUP);
    7771                return;
    7872        }
    … …  
    8074        const int irq = DEV_IPC_GET_ARG1(*call);
    8175        const errno_t ret = hw_res_ops->enable_interrupt(fun, irq);
    82         async_answer_0(chandle, ret);
     76        async_answer_0(call, ret);
    8377}
    8478
    8579static void remote_hw_res_disable_interrupt(ddf_fun_t *fun, void *ops,
    86     cap_call_handle_t chandle, ipc_call_t *call)
     80    ipc_call_t *call)
    8781{
    8882        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    8983
    9084        if (hw_res_ops->disable_interrupt == NULL) {
    91                 async_answer_0(chandle, ENOTSUP);
     85                async_answer_0(call, ENOTSUP);
    9286                return;
    9387        }
    … …  
    9589        const int irq = DEV_IPC_GET_ARG1(*call);
    9690        const errno_t ret = hw_res_ops->disable_interrupt(fun, irq);
    97         async_answer_0(chandle, ret);
     91        async_answer_0(call, ret);
    9892}
    9993
    10094static void remote_hw_res_clear_interrupt(ddf_fun_t *fun, void *ops,
    101     cap_call_handle_t chandle, ipc_call_t *call)
     95    ipc_call_t *call)
    10296{
    10397        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    10498
    10599        if (hw_res_ops->clear_interrupt == NULL) {
    106                 async_answer_0(chandle, ENOTSUP);
     100                async_answer_0(call, ENOTSUP);
    107101                return;
    108102        }
    … …  
    110104        const int irq = DEV_IPC_GET_ARG1(*call);
    111105        const errno_t ret = hw_res_ops->enable_interrupt(fun, irq);
    112         async_answer_0(chandle, ret);
     106        async_answer_0(call, ret);
    113107}
    114108
    115109static void remote_hw_res_get_resource_list(ddf_fun_t *fun, void *ops,
    116     cap_call_handle_t chandle, ipc_call_t *call)
     110    ipc_call_t *call)
    117111{
    118112        hw_res_ops_t *hw_res_ops = (hw_res_ops_t *) ops;
    119113
    120114        if (hw_res_ops->get_resource_list == NULL) {
    121                 async_answer_0(chandle, ENOTSUP);
     115                async_answer_0(call, ENOTSUP);
    122116                return;
    123117        }
    … …  
    125119        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(fun);
    126120        if (hw_resources == NULL) {
    127                 async_answer_0(chandle, ENOENT);
     121                async_answer_0(call, ENOENT);
    128122                return;
    129123        }
    130124
    131         async_answer_1(chandle, EOK, hw_resources->count);
     125        async_answer_1(call, EOK, hw_resources->count);
    132126
     127        ipc_call_t data;
    133128        size_t len;
    134         if (!async_data_read_receive(&chandle, &len)) {
     129        if (!async_data_read_receive(&data, &len)) {
    135130                /* Protocol error - the recipient is not accepting data */
    136131                return;
    137132        }
    138         async_data_read_finalize(chandle, hw_resources->resources, len);
     133
     134        async_data_read_finalize(&data, hw_resources->resources, len);
    139135}
    140136
    141137static void remote_hw_res_dma_channel_setup(ddf_fun_t *fun, void *ops,
    142     cap_call_handle_t chandle, ipc_call_t *call)
     138    ipc_call_t *call)
    143139{
    144140        hw_res_ops_t *hw_res_ops = ops;
    145141
    146142        if (hw_res_ops->dma_channel_setup == NULL) {
    147                 async_answer_0(chandle, ENOTSUP);
     143                async_answer_0(call, ENOTSUP);
    148144                return;
    149145        }
     146
    150147        const unsigned channel = DEV_IPC_GET_ARG1(*call) & 0xffff;
    151148        const uint8_t  mode = DEV_IPC_GET_ARG1(*call) >> 16;
    … …  
    155152        const errno_t ret = hw_res_ops->dma_channel_setup(
    156153            fun, channel, address, size, mode);
    157         async_answer_0(chandle, ret);
     154        async_answer_0(call, ret);
    158155}
    159156
    160157static void remote_hw_res_dma_channel_remain(ddf_fun_t *fun, void *ops,
    161     cap_call_handle_t chandle, ipc_call_t *call)
     158    ipc_call_t *call)
    162159{
    163160        hw_res_ops_t *hw_res_ops = ops;
    164161
    165162        if (hw_res_ops->dma_channel_setup == NULL) {
    166                 async_answer_0(chandle, ENOTSUP);
     163                async_answer_0(call, ENOTSUP);
    167164                return;
    168165        }
     166
    169167        const unsigned channel = DEV_IPC_GET_ARG1(*call);
    170168        size_t remain = 0;
    171169        const errno_t ret = hw_res_ops->dma_channel_remain(fun, channel, &remain);
    172         async_answer_1(chandle, ret, remain);
     170        async_answer_1(call, ret, remain);
    173171}
     172
    174173/**
    175174 * @}

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

    r76f566d r984a9ba  
    268268
    269269static void remote_ieee80211_get_scan_results(ddf_fun_t *fun, void *iface,
    270     cap_call_handle_t chandle, ipc_call_t *call)
     270    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_chandle;
     282                ipc_call_t data;
    283283                size_t max_len;
    284                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    285                         async_answer_0(data_chandle, EINVAL);
    286                         async_answer_0(chandle, EINVAL);
     284                if (!async_data_read_receive(&data, &max_len)) {
     285                        async_answer_0(&data, EINVAL);
     286                        async_answer_0(call, EINVAL);
    287287                        return;
    288288                }
    289289
    290290                if (max_len < sizeof(ieee80211_scan_results_t)) {
    291                         async_answer_0(data_chandle, ELIMIT);
    292                         async_answer_0(chandle, ELIMIT);
     291                        async_answer_0(&data, ELIMIT);
     292                        async_answer_0(call, ELIMIT);
    293293                        return;
    294294                }
    295295
    296                 async_data_read_finalize(data_chandle, &scan_results,
     296                async_data_read_finalize(&data, &scan_results,
    297297                    sizeof(ieee80211_scan_results_t));
    298298        }
    299299
    300         async_answer_0(chandle, rc);
     300        async_answer_0(call, rc);
    301301}
    302302
    303303static void remote_ieee80211_connect(ddf_fun_t *fun, void *iface,
    304     cap_call_handle_t chandle, ipc_call_t *call)
     304    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_chandle;
     312        ipc_call_t data;
    313313        size_t len;
    314         if (!async_data_write_receive(&data_chandle, &len)) {
    315                 async_answer_0(data_chandle, EINVAL);
    316                 async_answer_0(chandle, EINVAL);
     314        if (!async_data_write_receive(&data, &len)) {
     315                async_answer_0(&data, EINVAL);
     316                async_answer_0(call, EINVAL);
    317317                return;
    318318        }
    319319
    320320        if (len > MAX_STRING_SIZE) {
    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);
     321                async_answer_0(&data, EINVAL);
     322                async_answer_0(call, EINVAL);
     323                return;
     324        }
     325
     326        errno_t rc = async_data_write_finalize(&data, ssid_start, len);
    327327        if (rc != EOK) {
    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);
     328                async_answer_0(&data, EINVAL);
     329                async_answer_0(call, EINVAL);
     330                return;
     331        }
     332
     333        if (!async_data_write_receive(&data, &len)) {
     334                async_answer_0(&data, EINVAL);
     335                async_answer_0(call, EINVAL);
    336336                return;
    337337        }
    338338
    339339        if (len > MAX_STRING_SIZE) {
    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);
     340                async_answer_0(&data, EINVAL);
     341                async_answer_0(call, EINVAL);
     342                return;
     343        }
     344
     345        rc = async_data_write_finalize(&data, password, len);
    346346        if (rc != EOK) {
    347                 async_answer_0(data_chandle, EINVAL);
    348                 async_answer_0(chandle, EINVAL);
     347                async_answer_0(&data, EINVAL);
     348                async_answer_0(call, EINVAL);
    349349                return;
    350350        }
    … …  
    352352        rc = ieee80211_iface->connect(fun, ssid_start, password);
    353353
    354         async_answer_0(chandle, rc);
     354        async_answer_0(call, rc);
    355355}
    356356
    357357static void remote_ieee80211_disconnect(ddf_fun_t *fun, void *iface,
    358     cap_call_handle_t chandle, ipc_call_t *call)
     358    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(chandle, rc);
     363        async_answer_0(call, rc);
    364364}
    365365

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

    r76f566d r984a9ba  
    4141#include <ddf/driver.h>
    4242
    43 static void remote_led_color_set(ddf_fun_t *, void *, cap_call_handle_t,
    44     ipc_call_t *);
     43static void remote_led_color_set(ddf_fun_t *, void *, ipc_call_t *);
    4544
    4645/** Remote LED interface operations */
    … …  
    6665 *
    6766 */
    68 static void remote_led_color_set(ddf_fun_t *fun, void *ops, cap_call_handle_t chandle,
    69     ipc_call_t *call)
     67static void remote_led_color_set(ddf_fun_t *fun, void *ops, ipc_call_t *call)
    7068{
    7169        led_dev_ops_t *led_dev_ops = (led_dev_ops_t *) ops;
    … …  
    7371
    7472        if (!led_dev_ops->color_set) {
    75                 async_answer_0(chandle, ENOTSUP);
     73                async_answer_0(call, ENOTSUP);
    7674                return;
    7775        }
    7876
    7977        errno_t rc = (*led_dev_ops->color_set)(fun, color);
    80         async_answer_0(chandle, rc);
     78        async_answer_0(call, rc);
    8179}
    8280

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

    r76f566d r984a9ba  
    13371337
    13381338static void remote_nic_send_frame(ddf_fun_t *dev, void *iface,
    1339     cap_call_handle_t chandle, ipc_call_t *call)
     1339    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(chandle, EINVAL);
     1350                async_answer_0(call, EINVAL);
    13511351                return;
    13521352        }
    13531353
    13541354        rc = nic_iface->send_frame(dev, data, size);
    1355         async_answer_0(chandle, rc);
     1355        async_answer_0(call, rc);
    13561356        free(data);
    13571357}
    13581358
    13591359static void remote_nic_callback_create(ddf_fun_t *dev, void *iface,
    1360     cap_call_handle_t chandle, ipc_call_t *call)
     1360    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(chandle, rc);
     1366        async_answer_0(call, rc);
    13671367}
    13681368
    13691369static void remote_nic_get_state(ddf_fun_t *dev, void *iface,
    1370     cap_call_handle_t chandle, ipc_call_t *call)
     1370    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(chandle, rc, state);
     1378        async_answer_1(call, rc, state);
    13791379}
    13801380
    13811381static void remote_nic_set_state(ddf_fun_t *dev, void *iface,
    1382     cap_call_handle_t chandle, ipc_call_t *call)
     1382    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(chandle, rc);
     1390        async_answer_0(call, rc);
    13911391}
    13921392
    13931393static void remote_nic_get_address(ddf_fun_t *dev, void *iface,
    1394     cap_call_handle_t chandle, ipc_call_t *call)
     1394    ipc_call_t *call)
    13951395{
    13961396        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    14021402        errno_t rc = nic_iface->get_address(dev, &address);
    14031403        if (rc == EOK) {
     1404                ipc_call_t data;
    14041405                size_t max_len;
    1405                 cap_call_handle_t data_chandle;
    14061406
    14071407                /* All errors will be translated into EPARTY anyway */
    1408                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    1409                         async_answer_0(data_chandle, EINVAL);
    1410                         async_answer_0(chandle, EINVAL);
     1408                if (!async_data_read_receive(&data, &max_len)) {
     1409                        async_answer_0(&data, EINVAL);
     1410                        async_answer_0(call, EINVAL);
    14111411                        return;
    14121412                }
    14131413
    14141414                if (max_len != sizeof(nic_address_t)) {
    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,
     1415                        async_answer_0(&data, ELIMIT);
     1416                        async_answer_0(call, ELIMIT);
     1417                        return;
     1418                }
     1419
     1420                async_data_read_finalize(&data, &address,
    14211421                    sizeof(nic_address_t));
    14221422        }
    14231423
    1424         async_answer_0(chandle, rc);
     1424        async_answer_0(call, rc);
    14251425}
    14261426
    14271427static void remote_nic_set_address(ddf_fun_t *dev, void *iface,
    1428     cap_call_handle_t chandle, ipc_call_t *call)
    1429 {
    1430         nic_iface_t *nic_iface = (nic_iface_t *) iface;
    1431 
     1428    ipc_call_t *call)
     1429{
     1430        nic_iface_t *nic_iface = (nic_iface_t *) iface;
     1431
     1432        ipc_call_t data;
    14321433        size_t length;
    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);
     1434        if (!async_data_write_receive(&data, &length)) {
     1435                async_answer_0(&data, EINVAL);
     1436                async_answer_0(call, EINVAL);
    14371437                return;
    14381438        }
    14391439
    14401440        if (length > sizeof(nic_address_t)) {
    1441                 async_answer_0(data_chandle, ELIMIT);
    1442                 async_answer_0(chandle, ELIMIT);
     1441                async_answer_0(&data, ELIMIT);
     1442                async_answer_0(call, ELIMIT);
    14431443                return;
    14441444        }
    14451445
    14461446        nic_address_t address;
    1447         if (async_data_write_finalize(data_chandle, &address, length) != EOK) {
    1448                 async_answer_0(chandle, EINVAL);
     1447        if (async_data_write_finalize(&data, &address, length) != EOK) {
     1448                async_answer_0(call, 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(chandle, rc);
     1454                async_answer_0(call, rc);
    14551455        } else
    1456                 async_answer_0(chandle, ENOTSUP);
     1456                async_answer_0(call, ENOTSUP);
    14571457}
    14581458
    14591459static void remote_nic_get_stats(ddf_fun_t *dev, void *iface,
    1460     cap_call_handle_t chandle, ipc_call_t *call)
     1460    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(chandle, ENOTSUP);
     1464                async_answer_0(call, ENOTSUP);
    14651465                return;
    14661466        }
    … …  
    14711471        errno_t rc = nic_iface->get_stats(dev, &stats);
    14721472        if (rc == EOK) {
    1473                 cap_call_handle_t data_chandle;
     1473                ipc_call_t data;
    14741474                size_t max_len;
    1475                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    1476                         async_answer_0(data_chandle, EINVAL);
    1477                         async_answer_0(chandle, EINVAL);
     1475                if (!async_data_read_receive(&data, &max_len)) {
     1476                        async_answer_0(&data, EINVAL);
     1477                        async_answer_0(call, EINVAL);
    14781478                        return;
    14791479                }
    14801480
    14811481                if (max_len < sizeof(nic_device_stats_t)) {
    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,
     1482                        async_answer_0(&data, ELIMIT);
     1483                        async_answer_0(call, ELIMIT);
     1484                        return;
     1485                }
     1486
     1487                async_data_read_finalize(&data, &stats,
    14881488                    sizeof(nic_device_stats_t));
    14891489        }
    14901490
    1491         async_answer_0(chandle, rc);
     1491        async_answer_0(call, rc);
    14921492}
    14931493
    14941494static void remote_nic_get_device_info(ddf_fun_t *dev, void *iface,
    1495     cap_call_handle_t chandle, ipc_call_t *call)
     1495    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(chandle, ENOTSUP);
     1499                async_answer_0(call, 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_chandle;
     1508                ipc_call_t data;
    15091509                size_t max_len;
    1510                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    1511                         async_answer_0(data_chandle, EINVAL);
    1512                         async_answer_0(chandle, EINVAL);
     1510                if (!async_data_read_receive(&data, &max_len)) {
     1511                        async_answer_0(&data, EINVAL);
     1512                        async_answer_0(call, EINVAL);
    15131513                        return;
    15141514                }
    15151515
    15161516                if (max_len < sizeof (nic_device_info_t)) {
    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,
     1517                        async_answer_0(&data, ELIMIT);
     1518                        async_answer_0(call, ELIMIT);
     1519                        return;
     1520                }
     1521
     1522                async_data_read_finalize(&data, &info,
    15231523                    sizeof(nic_device_info_t));
    15241524        }
    15251525
    1526         async_answer_0(chandle, rc);
     1526        async_answer_0(call, rc);
    15271527}
    15281528
    15291529static void remote_nic_get_cable_state(ddf_fun_t *dev, void *iface,
    1530     cap_call_handle_t chandle, ipc_call_t *call)
     1530    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(chandle, ENOTSUP);
     1534                async_answer_0(call, ENOTSUP);
    15351535                return;
    15361536        }
    … …  
    15391539
    15401540        errno_t rc = nic_iface->get_cable_state(dev, &cs);
    1541         async_answer_1(chandle, rc, (sysarg_t) cs);
     1541        async_answer_1(call, rc, (sysarg_t) cs);
    15421542}
    15431543
    15441544static void remote_nic_get_operation_mode(ddf_fun_t *dev, void *iface,
    1545     cap_call_handle_t chandle, ipc_call_t *call)
     1545    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(chandle, ENOTSUP);
     1549                async_answer_0(call, ENOTSUP);
    15501550                return;
    15511551        }
    … …  
    15561556
    15571557        errno_t rc = nic_iface->get_operation_mode(dev, &speed, &duplex, &role);
    1558         async_answer_3(chandle, rc, (sysarg_t) speed, (sysarg_t) duplex,
     1558        async_answer_3(call, 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 chandle, ipc_call_t *call)
     1563    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(chandle, ENOTSUP);
     1567                async_answer_0(call, ENOTSUP);
    15681568                return;
    15691569        }
    … …  
    15741574
    15751575        errno_t rc = nic_iface->set_operation_mode(dev, speed, duplex, role);
    1576         async_answer_0(chandle, rc);
     1576        async_answer_0(call, rc);
    15771577}
    15781578
    15791579static void remote_nic_autoneg_enable(ddf_fun_t *dev, void *iface,
    1580     cap_call_handle_t chandle, ipc_call_t *call)
     1580    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(chandle, ENOTSUP);
     1584                async_answer_0(call, ENOTSUP);
    15851585                return;
    15861586        }
    … …  
    15891589
    15901590        errno_t rc = nic_iface->autoneg_enable(dev, advertisement);
    1591         async_answer_0(chandle, rc);
     1591        async_answer_0(call, rc);
    15921592}
    15931593
    15941594static void remote_nic_autoneg_disable(ddf_fun_t *dev, void *iface,
    1595     cap_call_handle_t chandle, ipc_call_t *call)
     1595    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(chandle, ENOTSUP);
     1599                async_answer_0(call, ENOTSUP);
    16001600                return;
    16011601        }
    16021602
    16031603        errno_t rc = nic_iface->autoneg_disable(dev);
    1604         async_answer_0(chandle, rc);
     1604        async_answer_0(call, rc);
    16051605}
    16061606
    16071607static void remote_nic_autoneg_probe(ddf_fun_t *dev, void *iface,
    1608     cap_call_handle_t chandle, ipc_call_t *call)
     1608    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(chandle, ENOTSUP);
     1612                async_answer_0(call, 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(chandle, rc, our_adv, their_adv, (sysarg_t) result,
     1623        async_answer_4(call, 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 chandle, ipc_call_t *call)
     1628    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(chandle, ENOTSUP);
     1632                async_answer_0(call, ENOTSUP);
    16331633                return;
    16341634        }
    16351635
    16361636        errno_t rc = nic_iface->autoneg_restart(dev);
    1637         async_answer_0(chandle, rc);
     1637        async_answer_0(call, rc);
    16381638}
    16391639
    16401640static void remote_nic_get_pause(ddf_fun_t *dev, void *iface,
    1641     cap_call_handle_t chandle, ipc_call_t *call)
     1641    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(chandle, ENOTSUP);
     1645                async_answer_0(call, ENOTSUP);
    16461646                return;
    16471647        }
    … …  
    16521652
    16531653        errno_t rc = nic_iface->get_pause(dev, &we_send, &we_receive, &pause);
    1654         async_answer_3(chandle, rc, we_send, we_receive, pause);
     1654        async_answer_3(call, 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 chandle, ipc_call_t *call)
     1658    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(chandle, ENOTSUP);
     1662                async_answer_0(call, ENOTSUP);
    16631663                return;
    16641664        }
    … …  
    16701670        errno_t rc = nic_iface->set_pause(dev, allow_send, allow_receive,
    16711671            pause);
    1672         async_answer_0(chandle, rc);
     1672        async_answer_0(call, rc);
    16731673}
    16741674
    16751675static void remote_nic_unicast_get_mode(ddf_fun_t *dev, void *iface,
    1676     cap_call_handle_t chandle, ipc_call_t *call)
     1676    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(chandle, ENOTSUP);
     1680                async_answer_0(call, ENOTSUP);
    16811681                return;
    16821682        }
    … …  
    16881688                address_list = malloc(max_count * sizeof (nic_address_t));
    16891689                if (!address_list) {
    1690                         async_answer_0(chandle, ENOMEM);
     1690                        async_answer_0(call, ENOMEM);
    16911691                        return;
    16921692                }
    … …  
    17021702        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    17031703                free(address_list);
    1704                 async_answer_2(chandle, rc, mode, address_count);
    1705                 return;
    1706         }
    1707 
    1708         cap_call_handle_t data_chandle;
     1704                async_answer_2(call, rc, mode, address_count);
     1705                return;
     1706        }
     1707
     1708        ipc_call_t data;
    17091709        size_t max_len;
    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);
     1710        if (!async_data_read_receive(&data, &max_len)) {
     1711                async_answer_0(&data, EINVAL);
     1712                async_answer_2(call, 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_chandle, address_list, max_len);
    1724         async_answer_0(data_chandle, EINVAL);
     1723        async_data_read_finalize(&data, address_list, max_len);
    17251724
    17261725        free(address_list);
    1727         async_answer_2(chandle, rc, mode, address_count);
     1726        async_answer_2(call, rc, mode, address_count);
    17281727}
    17291728
    17301729static void remote_nic_unicast_set_mode(ddf_fun_t *dev, void *iface,
    1731     cap_call_handle_t chandle, ipc_call_t *call)
     1730    ipc_call_t *call)
    17321731{
    17331732        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    17391738
    17401739        if (address_count) {
    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);
     1740                ipc_call_t data;
     1741                if (!async_data_write_receive(&data, &length)) {
     1742                        async_answer_0(&data, EINVAL);
     1743                        async_answer_0(call, EINVAL);
    17451744                        return;
    17461745                }
    17471746
    17481747                if (length != address_count * sizeof(nic_address_t)) {
    1749                         async_answer_0(data_chandle, ELIMIT);
    1750                         async_answer_0(chandle, ELIMIT);
     1748                        async_answer_0(&data, ELIMIT);
     1749                        async_answer_0(call, ELIMIT);
    17511750                        return;
    17521751                }
    … …  
    17541753                address_list = malloc(length);
    17551754                if (address_list == NULL) {
    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,
     1755                        async_answer_0(&data, ENOMEM);
     1756                        async_answer_0(call, ENOMEM);
     1757                        return;
     1758                }
     1759
     1760                if (async_data_write_finalize(&data, address_list,
    17621761                    length) != EOK) {
    1763                         async_answer_0(chandle, EINVAL);
     1762                        async_answer_0(call, EINVAL);
    17641763                        free(address_list);
    17651764                        return;
    … …  
    17701769                errno_t rc = nic_iface->unicast_set_mode(dev, mode, address_list,
    17711770                    address_count);
    1772                 async_answer_0(chandle, rc);
     1771                async_answer_0(call, rc);
    17731772        } else
    1774                 async_answer_0(chandle, ENOTSUP);
     1773                async_answer_0(call, ENOTSUP);
    17751774
    17761775        free(address_list);
    … …  
    17781777
    17791778static void remote_nic_multicast_get_mode(ddf_fun_t *dev, void *iface,
    1780     cap_call_handle_t chandle, ipc_call_t *call)
     1779    ipc_call_t *call)
    17811780{
    17821781        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    17831782        if (nic_iface->multicast_get_mode == NULL) {
    1784                 async_answer_0(chandle, ENOTSUP);
     1783                async_answer_0(call, ENOTSUP);
    17851784                return;
    17861785        }
    … …  
    17921791                address_list = malloc(max_count * sizeof(nic_address_t));
    17931792                if (!address_list) {
    1794                         async_answer_0(chandle, ENOMEM);
     1793                        async_answer_0(call, ENOMEM);
    17951794                        return;
    17961795                }
    … …  
    18071806        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    18081807                free(address_list);
    1809                 async_answer_2(chandle, rc, mode, address_count);
    1810                 return;
    1811         }
    1812 
    1813         cap_call_handle_t data_chandle;
     1808                async_answer_2(call, rc, mode, address_count);
     1809                return;
     1810        }
     1811
     1812        ipc_call_t data;
    18141813        size_t max_len;
    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);
     1814        if (!async_data_read_receive(&data, &max_len)) {
     1815                async_answer_0(&data, EINVAL);
     1816                async_answer_2(call, rc, mode, address_count);
    18181817                free(address_list);
    18191818                return;
    … …  
    18261825                max_len = max_count * sizeof(nic_address_t);
    18271826
    1828         async_data_read_finalize(data_chandle, address_list, max_len);
     1827        async_data_read_finalize(&data, address_list, max_len);
    18291828
    18301829        free(address_list);
    1831         async_answer_2(chandle, rc, mode, address_count);
     1830        async_answer_2(call, rc, mode, address_count);
    18321831}
    18331832
    18341833static void remote_nic_multicast_set_mode(ddf_fun_t *dev, void *iface,
    1835     cap_call_handle_t chandle, ipc_call_t *call)
     1834    ipc_call_t *call)
    18361835{
    18371836        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    18421841
    18431842        if (address_count) {
    1844                 cap_call_handle_t data_chandle;
     1843                ipc_call_t data;
    18451844                size_t length;
    1846                 if (!async_data_write_receive(&data_chandle, &length)) {
    1847                         async_answer_0(data_chandle, EINVAL);
    1848                         async_answer_0(chandle, EINVAL);
     1845                if (!async_data_write_receive(&data, &length)) {
     1846                        async_answer_0(&data, EINVAL);
     1847                        async_answer_0(call, EINVAL);
    18491848                        return;
    18501849                }
    18511850
    18521851                if (length != address_count * sizeof (nic_address_t)) {
    1853                         async_answer_0(data_chandle, ELIMIT);
    1854                         async_answer_0(chandle, ELIMIT);
     1852                        async_answer_0(&data, ELIMIT);
     1853                        async_answer_0(call, ELIMIT);
    18551854                        return;
    18561855                }
    … …  
    18581857                address_list = malloc(length);
    18591858                if (address_list == NULL) {
    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,
     1859                        async_answer_0(&data, ENOMEM);
     1860                        async_answer_0(call, ENOMEM);
     1861                        return;
     1862                }
     1863
     1864                if (async_data_write_finalize(&data, address_list,
    18661865                    length) != EOK) {
    1867                         async_answer_0(chandle, EINVAL);
     1866                        async_answer_0(call, EINVAL);
    18681867                        free(address_list);
    18691868                        return;
    … …  
    18741873                errno_t rc = nic_iface->multicast_set_mode(dev, mode, address_list,
    18751874                    address_count);
    1876                 async_answer_0(chandle, rc);
     1875                async_answer_0(call, rc);
    18771876        } else
    1878                 async_answer_0(chandle, ENOTSUP);
     1877                async_answer_0(call, ENOTSUP);
    18791878
    18801879        free(address_list);
    … …  
    18821881
    18831882static void remote_nic_broadcast_get_mode(ddf_fun_t *dev, void *iface,
    1884     cap_call_handle_t chandle, ipc_call_t *call)
     1883    ipc_call_t *call)
    18851884{
    18861885        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    18871886        if (nic_iface->broadcast_get_mode == NULL) {
    1888                 async_answer_0(chandle, ENOTSUP);
     1887                async_answer_0(call, ENOTSUP);
    18891888                return;
    18901889        }
    … …  
    18931892
    18941893        errno_t rc = nic_iface->broadcast_get_mode(dev, &mode);
    1895         async_answer_1(chandle, rc, mode);
     1894        async_answer_1(call, rc, mode);
    18961895}
    18971896
    18981897static void remote_nic_broadcast_set_mode(ddf_fun_t *dev, void *iface,
    1899     cap_call_handle_t chandle, ipc_call_t *call)
     1898    ipc_call_t *call)
    19001899{
    19011900        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19021901        if (nic_iface->broadcast_set_mode == NULL) {
    1903                 async_answer_0(chandle, ENOTSUP);
     1902                async_answer_0(call, ENOTSUP);
    19041903                return;
    19051904        }
    … …  
    19081907
    19091908        errno_t rc = nic_iface->broadcast_set_mode(dev, mode);
    1910         async_answer_0(chandle, rc);
     1909        async_answer_0(call, rc);
    19111910}
    19121911
    19131912static void remote_nic_defective_get_mode(ddf_fun_t *dev, void *iface,
    1914     cap_call_handle_t chandle, ipc_call_t *call)
     1913    ipc_call_t *call)
    19151914{
    19161915        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19171916        if (nic_iface->defective_get_mode == NULL) {
    1918                 async_answer_0(chandle, ENOTSUP);
     1917                async_answer_0(call, ENOTSUP);
    19191918                return;
    19201919        }
    … …  
    19231922
    19241923        errno_t rc = nic_iface->defective_get_mode(dev, &mode);
    1925         async_answer_1(chandle, rc, mode);
     1924        async_answer_1(call, rc, mode);
    19261925}
    19271926
    19281927static void remote_nic_defective_set_mode(ddf_fun_t *dev, void *iface,
    1929     cap_call_handle_t chandle, ipc_call_t *call)
     1928    ipc_call_t *call)
    19301929{
    19311930        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19321931        if (nic_iface->defective_set_mode == NULL) {
    1933                 async_answer_0(chandle, ENOTSUP);
     1932                async_answer_0(call, ENOTSUP);
    19341933                return;
    19351934        }
    … …  
    19381937
    19391938        errno_t rc = nic_iface->defective_set_mode(dev, mode);
    1940         async_answer_0(chandle, rc);
     1939        async_answer_0(call, rc);
    19411940}
    19421941
    19431942static void remote_nic_blocked_sources_get(ddf_fun_t *dev, void *iface,
    1944     cap_call_handle_t chandle, ipc_call_t *call)
     1943    ipc_call_t *call)
    19451944{
    19461945        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19471946        if (nic_iface->blocked_sources_get == NULL) {
    1948                 async_answer_0(chandle, ENOTSUP);
     1947                async_answer_0(call, ENOTSUP);
    19491948                return;
    19501949        }
    … …  
    19561955                address_list = malloc(max_count * sizeof(nic_address_t));
    19571956                if (!address_list) {
    1958                         async_answer_0(chandle, ENOMEM);
     1957                        async_answer_0(call, ENOMEM);
    19591958                        return;
    19601959                }
    … …  
    19681967
    19691968        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    1970                 async_answer_1(chandle, rc, address_count);
     1969                async_answer_1(call, rc, address_count);
    19711970                free(address_list);
    19721971                return;
    19731972        }
    19741973
    1975         cap_call_handle_t data_chandle;
     1974        ipc_call_t data;
    19761975        size_t max_len;
    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);
     1976        if (!async_data_read_receive(&data, &max_len)) {
     1977                async_answer_0(&data, EINVAL);
     1978                async_answer_1(call, rc, address_count);
    19801979                free(address_list);
    19811980                return;
    … …  
    19881987                max_len = max_count * sizeof(nic_address_t);
    19891988
    1990         async_data_read_finalize(data_chandle, address_list, max_len);
    1991         async_answer_0(data_chandle, EINVAL);
     1989        async_data_read_finalize(&data, address_list, max_len);
    19921990
    19931991        free(address_list);
    1994         async_answer_1(chandle, rc, address_count);
     1992        async_answer_1(call, rc, address_count);
    19951993}
    19961994
    19971995static void remote_nic_blocked_sources_set(ddf_fun_t *dev, void *iface,
    1998     cap_call_handle_t chandle, ipc_call_t *call)
     1996    ipc_call_t *call)
    19991997{
    20001998        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    20052003
    20062004        if (address_count) {
    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);
     2005                ipc_call_t data;
     2006                if (!async_data_write_receive(&data, &length)) {
     2007                        async_answer_0(&data, EINVAL);
     2008                        async_answer_0(call, EINVAL);
    20112009                        return;
    20122010                }
    20132011
    20142012                if (length != address_count * sizeof(nic_address_t)) {
    2015                         async_answer_0(data_chandle, ELIMIT);
    2016                         async_answer_0(chandle, ELIMIT);
     2013                        async_answer_0(&data, ELIMIT);
     2014                        async_answer_0(call, ELIMIT);
    20172015                        return;
    20182016                }
    … …  
    20202018                address_list = malloc(length);
    20212019                if (address_list == NULL) {
    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,
     2020                        async_answer_0(&data, ENOMEM);
     2021                        async_answer_0(call, ENOMEM);
     2022                        return;
     2023                }
     2024
     2025                if (async_data_write_finalize(&data, address_list,
    20282026                    length) != EOK) {
    2029                         async_answer_0(chandle, EINVAL);
     2027                        async_answer_0(call, EINVAL);
    20302028                        free(address_list);
    20312029                        return;
    … …  
    20362034                errno_t rc = nic_iface->blocked_sources_set(dev, address_list,
    20372035                    address_count);
    2038                 async_answer_0(chandle, rc);
     2036                async_answer_0(call, rc);
    20392037        } else
    2040                 async_answer_0(chandle, ENOTSUP);
     2038                async_answer_0(call, ENOTSUP);
    20412039
    20422040        free(address_list);
    … …  
    20442042
    20452043static void remote_nic_vlan_get_mask(ddf_fun_t *dev, void *iface,
    2046     cap_call_handle_t chandle, ipc_call_t *call)
     2044    ipc_call_t *call)
    20472045{
    20482046        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    20492047        if (nic_iface->vlan_get_mask == NULL) {
    2050                 async_answer_0(chandle, ENOTSUP);
     2048                async_answer_0(call, ENOTSUP);
    20512049                return;
    20522050        }
    … …  
    20572055        errno_t rc = nic_iface->vlan_get_mask(dev, &vlan_mask);
    20582056        if (rc == EOK) {
    2059                 cap_call_handle_t data_chandle;
     2057                ipc_call_t data;
    20602058                size_t max_len;
    2061                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    2062                         async_answer_0(data_chandle, EINVAL);
    2063                         async_answer_0(chandle, EINVAL);
     2059                if (!async_data_read_receive(&data, &max_len)) {
     2060                        async_answer_0(&data, EINVAL);
     2061                        async_answer_0(call, EINVAL);
    20642062                        return;
    20652063                }
    20662064
    20672065                if (max_len != sizeof(nic_vlan_mask_t)) {
    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);
     2066                        async_answer_0(&data, EINVAL);
     2067                        async_answer_0(call, EINVAL);
     2068                        return;
     2069                }
     2070
     2071                async_data_read_finalize(&data, &vlan_mask, max_len);
     2072        }
     2073
     2074        async_answer_0(call, rc);
    20772075}
    20782076
    20792077static void remote_nic_vlan_set_mask(ddf_fun_t *dev, void *iface,
    2080     cap_call_handle_t chandle, ipc_call_t *call)
     2078    ipc_call_t *call)
    20812079{
    20822080        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    20872085
    20882086        if (vlan_mask_set) {
    2089                 cap_call_handle_t data_chandle;
     2087                ipc_call_t data;
    20902088                size_t length;
    2091                 if (!async_data_write_receive(&data_chandle, &length)) {
    2092                         async_answer_0(data_chandle, EINVAL);
    2093                         async_answer_0(chandle, EINVAL);
     2089                if (!async_data_write_receive(&data, &length)) {
     2090                        async_answer_0(&data, EINVAL);
     2091                        async_answer_0(call, EINVAL);
    20942092                        return;
    20952093                }
    20962094
    20972095                if (length != sizeof(nic_vlan_mask_t)) {
    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,
     2096                        async_answer_0(&data, ELIMIT);
     2097                        async_answer_0(call, ELIMIT);
     2098                        return;
     2099                }
     2100
     2101                if (async_data_write_finalize(&data, &vlan_mask,
    21042102                    length) != EOK) {
    2105                         async_answer_0(chandle, EINVAL);
     2103                        async_answer_0(call, EINVAL);
    21062104                        return;
    21072105                }
    … …  
    21122110        if (nic_iface->vlan_set_mask != NULL) {
    21132111                errno_t rc = nic_iface->vlan_set_mask(dev, vlan_mask_pointer);
    2114                 async_answer_0(chandle, rc);
     2112                async_answer_0(call, rc);
    21152113        } else
    2116                 async_answer_0(chandle, ENOTSUP);
     2114                async_answer_0(call, ENOTSUP);
    21172115}
    21182116
    21192117static void remote_nic_vlan_set_tag(ddf_fun_t *dev, void *iface,
    2120     cap_call_handle_t chandle, ipc_call_t *call)
     2118    ipc_call_t *call)
    21212119{
    21222120        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21232121
    21242122        if (nic_iface->vlan_set_tag == NULL) {
    2125                 async_answer_0(chandle, ENOTSUP);
     2123                async_answer_0(call, ENOTSUP);
    21262124                return;
    21272125        }
    … …  
    21322130
    21332131        errno_t rc = nic_iface->vlan_set_tag(dev, tag, add, strip);
    2134         async_answer_0(chandle, rc);
     2132        async_answer_0(call, rc);
    21352133}
    21362134
    21372135static void remote_nic_wol_virtue_add(ddf_fun_t *dev, void *iface,
    2138     cap_call_handle_t chandle, ipc_call_t *call)
     2136    ipc_call_t *call)
    21392137{
    21402138        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21412139
    21422140        int send_data = (int) IPC_GET_ARG3(*call);
    2143         cap_call_handle_t data_chandle;
     2141        ipc_call_t data;
    21442142
    21452143        if (nic_iface->wol_virtue_add == NULL) {
    21462144                if (send_data) {
    2147                         async_data_write_receive(&data_chandle, NULL);
    2148                         async_answer_0(data_chandle, ENOTSUP);
    2149                 }
    2150 
    2151                 async_answer_0(chandle, ENOTSUP);
     2145                        async_data_write_receive(&data, NULL);
     2146                        async_answer_0(&data, ENOTSUP);
     2147                }
     2148
     2149                async_answer_0(call, ENOTSUP);
    21522150        }
    21532151
    21542152        size_t length = 0;
    2155         void *data = NULL;
     2153        void *virtue = NULL;
    21562154
    21572155        if (send_data) {
    2158                 if (!async_data_write_receive(&data_chandle, &length)) {
    2159                         async_answer_0(data_chandle, EINVAL);
    2160                         async_answer_0(chandle, EINVAL);
    2161                         return;
    2162                 }
    2163 
    2164                 data = malloc(length);
    2165                 if (data == NULL) {
    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,
     2156                if (!async_data_write_receive(&data, &length)) {
     2157                        async_answer_0(&data, EINVAL);
     2158                        async_answer_0(call, EINVAL);
     2159                        return;
     2160                }
     2161
     2162                virtue = malloc(length);
     2163                if (virtue == NULL) {
     2164                        async_answer_0(&data, ENOMEM);
     2165                        async_answer_0(call, ENOMEM);
     2166                        return;
     2167                }
     2168
     2169                if (async_data_write_finalize(&data, virtue,
    21722170                    length) != EOK) {
    2173                         async_answer_0(chandle, EINVAL);
    2174                         free(data);
     2171                        async_answer_0(call, EINVAL);
     2172                        free(virtue);
    21752173                        return;
    21762174                }
    … …  
    21802178        nic_wv_type_t type = (nic_wv_type_t) IPC_GET_ARG2(*call);
    21812179
    2182         errno_t rc = nic_iface->wol_virtue_add(dev, type, data, length, &id);
    2183         async_answer_1(chandle, rc, (sysarg_t) id);
    2184         free(data);
     2180        errno_t rc = nic_iface->wol_virtue_add(dev, type, virtue, length, &id);
     2181        async_answer_1(call, rc, (sysarg_t) id);
     2182        free(virtue);
    21852183}
    21862184
    21872185static void remote_nic_wol_virtue_remove(ddf_fun_t *dev, void *iface,
    2188     cap_call_handle_t chandle, ipc_call_t *call)
     2186    ipc_call_t *call)
    21892187{
    21902188        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21912189
    21922190        if (nic_iface->wol_virtue_remove == NULL) {
    2193                 async_answer_0(chandle, ENOTSUP);
     2191                async_answer_0(call, ENOTSUP);
    21942192                return;
    21952193        }
    … …  
    21982196
    21992197        errno_t rc = nic_iface->wol_virtue_remove(dev, id);
    2200         async_answer_0(chandle, rc);
     2198        async_answer_0(call, rc);
    22012199}
    22022200
    22032201static void remote_nic_wol_virtue_probe(ddf_fun_t *dev, void *iface,
    2204     cap_call_handle_t chandle, ipc_call_t *call)
     2202    ipc_call_t *call)
    22052203{
    22062204        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    22072205
    22082206        if (nic_iface->wol_virtue_probe == NULL) {
    2209                 async_answer_0(chandle, ENOTSUP);
     2207                async_answer_0(call, ENOTSUP);
    22102208                return;
    22112209        }
    … …  
    22152213        nic_wv_type_t type = NIC_WV_NONE;
    22162214        size_t length = 0;
    2217         cap_call_handle_t data_chandle;
    2218         void *data = NULL;
     2215        ipc_call_t data;
     2216        void *virtue = NULL;
    22192217
    22202218        if (max_length != 0) {
    2221                 data = malloc(max_length);
    2222                 if (data == NULL) {
    2223                         async_answer_0(chandle, ENOMEM);
    2224                         return;
    2225                 }
    2226         }
    2227 
    2228         memset(data, 0, max_length);
     2219                virtue = malloc(max_length);
     2220                if (virtue == NULL) {
     2221                        async_answer_0(call, ENOMEM);
     2222                        return;
     2223                }
     2224        }
     2225
     2226        memset(virtue, 0, max_length);
    22292227
    22302228        errno_t rc = nic_iface->wol_virtue_probe(dev, id, &type, max_length,
    2231             data, &length);
     2229            virtue, &length);
    22322230
    22332231        if ((max_length != 0) && (length != 0)) {
    22342232                size_t req_length;
    2235                 if (!async_data_read_receive(&data_chandle, &req_length)) {
    2236                         async_answer_0(data_chandle, EINVAL);
    2237                         async_answer_0(chandle, EINVAL);
    2238                         free(data);
     2233                if (!async_data_read_receive(&data, &req_length)) {
     2234                        async_answer_0(&data, EINVAL);
     2235                        async_answer_0(call, EINVAL);
     2236                        free(virtue);
    22392237                        return;
    22402238                }
    … …  
    22462244                        req_length = max_length;
    22472245
    2248                 async_data_read_finalize(data_chandle, data, req_length);
    2249         }
    2250 
    2251         async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) length);
    2252         free(data);
     2246                async_data_read_finalize(&data, virtue, req_length);
     2247        }
     2248
     2249        async_answer_2(call, rc, (sysarg_t) type, (sysarg_t) length);
     2250        free(virtue);
    22532251}
    22542252
    22552253static void remote_nic_wol_virtue_list(ddf_fun_t *dev, void *iface,
    2256     cap_call_handle_t chandle, ipc_call_t *call)
     2254    ipc_call_t *call)
    22572255{
    22582256        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    22592257        if (nic_iface->wol_virtue_list == NULL) {
    2260                 async_answer_0(chandle, ENOTSUP);
     2258                async_answer_0(call, ENOTSUP);
    22612259                return;
    22622260        }
    … …  
    22662264        size_t count = 0;
    22672265        nic_wv_id_t *id_list = NULL;
    2268         cap_call_handle_t data_chandle;
     2266        ipc_call_t data;
    22692267
    22702268        if (max_count != 0) {
    22712269                id_list = malloc(max_count * sizeof(nic_wv_id_t));
    22722270                if (id_list == NULL) {
    2273                         async_answer_0(chandle, ENOMEM);
     2271                        async_answer_0(call, ENOMEM);
    22742272                        return;
    22752273                }
    … …  
    22832281        if ((max_count != 0) && (count != 0)) {
    22842282                size_t req_length;
    2285                 if (!async_data_read_receive(&data_chandle, &req_length)) {
    2286                         async_answer_0(data_chandle, EINVAL);
    2287                         async_answer_0(chandle, EINVAL);
     2283                if (!async_data_read_receive(&data, &req_length)) {
     2284                        async_answer_0(&data, EINVAL);
     2285                        async_answer_0(call, EINVAL);
    22882286                        free(id_list);
    22892287                        return;
    … …  
    22962294                        req_length = max_count * sizeof(nic_wv_id_t);
    22972295
    2298                 rc = async_data_read_finalize(data_chandle, id_list, req_length);
    2299         }
    2300 
    2301         async_answer_1(chandle, rc, (sysarg_t) count);
     2296                rc = async_data_read_finalize(&data, id_list, req_length);
     2297        }
     2298
     2299        async_answer_1(call, rc, (sysarg_t) count);
    23022300        free(id_list);
    23032301}
    23042302
    23052303static void remote_nic_wol_virtue_get_caps(ddf_fun_t *dev, void *iface,
    2306     cap_call_handle_t chandle, ipc_call_t *call)
     2304    ipc_call_t *call)
    23072305{
    23082306        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23092307        if (nic_iface->wol_virtue_get_caps == NULL) {
    2310                 async_answer_0(chandle, ENOTSUP);
     2308                async_answer_0(call, ENOTSUP);
    23112309                return;
    23122310        }
    … …  
    23162314
    23172315        errno_t rc = nic_iface->wol_virtue_get_caps(dev, type, &count);
    2318         async_answer_1(chandle, rc, (sysarg_t) count);
     2316        async_answer_1(call, rc, (sysarg_t) count);
    23192317}
    23202318
    23212319static void remote_nic_wol_load_info(ddf_fun_t *dev, void *iface,
    2322     cap_call_handle_t chandle, ipc_call_t *call)
     2320    ipc_call_t *call)
    23232321{
    23242322        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23252323        if (nic_iface->wol_load_info == NULL) {
    2326                 async_answer_0(chandle, ENOTSUP);
     2324                async_answer_0(call, ENOTSUP);
    23272325                return;
    23282326        }
    … …  
    23312329        size_t frame_length = 0;
    23322330        nic_wv_type_t type = NIC_WV_NONE;
    2333         uint8_t *data = NULL;
     2331        uint8_t *info = NULL;
    23342332
    23352333        if (max_length != 0) {
    2336                 data = malloc(max_length);
    2337                 if (data == NULL) {
    2338                         async_answer_0(chandle, ENOMEM);
    2339                         return;
    2340                 }
    2341         }
    2342 
    2343         memset(data, 0, max_length);
    2344 
    2345         errno_t rc = nic_iface->wol_load_info(dev, &type, max_length, data,
     2334                info = malloc(max_length);
     2335                if (info == NULL) {
     2336                        async_answer_0(call, ENOMEM);
     2337                        return;
     2338                }
     2339        }
     2340
     2341        memset(info, 0, max_length);
     2342
     2343        errno_t rc = nic_iface->wol_load_info(dev, &type, max_length, info,
    23462344            &frame_length);
    23472345        if (rc == EOK) {
    2348                 cap_call_handle_t data_chandle;
     2346                ipc_call_t data;
    23492347                size_t req_length;
    2350                 if (!async_data_read_receive(&data_chandle, &req_length)) {
    2351                         async_answer_0(data_chandle, EINVAL);
    2352                         async_answer_0(chandle, EINVAL);
    2353                         free(data);
     2348                if (!async_data_read_receive(&data, &req_length)) {
     2349                        async_answer_0(&data, EINVAL);
     2350                        async_answer_0(call, EINVAL);
     2351                        free(info);
    23542352                        return;
    23552353                }
    … …  
    23572355                req_length = req_length > max_length ? max_length : req_length;
    23582356                req_length = req_length > frame_length ? frame_length : req_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);
    2363         free(data);
     2357                async_data_read_finalize(&data, info, req_length);
     2358        }
     2359
     2360        async_answer_2(call, rc, (sysarg_t) type, (sysarg_t) frame_length);
     2361        free(info);
    23642362}
    23652363
    23662364static void remote_nic_offload_probe(ddf_fun_t *dev, void *iface,
    2367     cap_call_handle_t chandle, ipc_call_t *call)
     2365    ipc_call_t *call)
    23682366{
    23692367        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23702368        if (nic_iface->offload_probe == NULL) {
    2371                 async_answer_0(chandle, ENOTSUP);
     2369                async_answer_0(call, ENOTSUP);
    23722370                return;
    23732371        }
    … …  
    23772375
    23782376        errno_t rc = nic_iface->offload_probe(dev, &supported, &active);
    2379         async_answer_2(chandle, rc, supported, active);
     2377        async_answer_2(call, rc, supported, active);
    23802378}
    23812379
    23822380static void remote_nic_offload_set(ddf_fun_t *dev, void *iface,
    2383     cap_call_handle_t chandle, ipc_call_t *call)
     2381    ipc_call_t *call)
    23842382{
    23852383        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23862384        if (nic_iface->offload_set == NULL) {
    2387                 async_answer_0(chandle, ENOTSUP);
     2385                async_answer_0(call, ENOTSUP);
    23882386                return;
    23892387        }
    … …  
    23932391
    23942392        errno_t rc = nic_iface->offload_set(dev, mask, active);
    2395         async_answer_0(chandle, rc);
     2393        async_answer_0(call, rc);
    23962394}
    23972395
    23982396static void remote_nic_poll_get_mode(ddf_fun_t *dev, void *iface,
    2399     cap_call_handle_t chandle, ipc_call_t *call)
     2397    ipc_call_t *call)
    24002398{
    24012399        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    24022400        if (nic_iface->poll_get_mode == NULL) {
    2403                 async_answer_0(chandle, ENOTSUP);
     2401                async_answer_0(call, ENOTSUP);
    24042402                return;
    24052403        }
    … …  
    24142412        errno_t rc = nic_iface->poll_get_mode(dev, &mode, &period);
    24152413        if ((rc == EOK) && (request_data)) {
     2414                ipc_call_t data;
    24162415                size_t max_len;
    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);
     2416
     2417                if (!async_data_read_receive(&data, &max_len)) {
     2418                        async_answer_0(&data, EINVAL);
     2419                        async_answer_0(call, EINVAL);
    24222420                        return;
    24232421                }
    24242422
    24252423                if (max_len != sizeof(struct timeval)) {
    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,
     2424                        async_answer_0(&data, ELIMIT);
     2425                        async_answer_0(call, ELIMIT);
     2426                        return;
     2427                }
     2428
     2429                async_data_read_finalize(&data, &period,
    24322430                    sizeof(struct timeval));
    24332431        }
    24342432
    2435         async_answer_1(chandle, rc, (sysarg_t) mode);
     2433        async_answer_1(call, rc, (sysarg_t) mode);
    24362434}
    24372435
    24382436static void remote_nic_poll_set_mode(ddf_fun_t *dev, void *iface,
    2439     cap_call_handle_t chandle, ipc_call_t *call)
     2437    ipc_call_t *call)
    24402438{
    24412439        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    24482446
    24492447        if (has_period) {
    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);
     2448                ipc_call_t data;
     2449                if (!async_data_write_receive(&data, &length)) {
     2450                        async_answer_0(&data, EINVAL);
     2451                        async_answer_0(call, EINVAL);
    24542452                        return;
    24552453                }
    24562454
    24572455                if (length != sizeof(struct timeval)) {
    2458                         async_answer_0(data_chandle, ELIMIT);
    2459                         async_answer_0(chandle, ELIMIT);
     2456                        async_answer_0(&data, ELIMIT);
     2457                        async_answer_0(call, ELIMIT);
    24602458                        return;
    24612459                }
    24622460
    24632461                period = &period_buf;
    2464                 if (async_data_write_finalize(data_chandle, period,
     2462                if (async_data_write_finalize(&data, period,
    24652463                    length) != EOK) {
    2466                         async_answer_0(chandle, EINVAL);
     2464                        async_answer_0(call, EINVAL);
    24672465                        return;
    24682466                }
    … …  
    24712469        if (nic_iface->poll_set_mode != NULL) {
    24722470                errno_t rc = nic_iface->poll_set_mode(dev, mode, period);
    2473                 async_answer_0(chandle, rc);
     2471                async_answer_0(call, rc);
    24742472        } else
    2475                 async_answer_0(chandle, ENOTSUP);
     2473                async_answer_0(call, ENOTSUP);
    24762474}
    24772475
    24782476static void remote_nic_poll_now(ddf_fun_t *dev, void *iface,
    2479     cap_call_handle_t chandle, ipc_call_t *call)
     2477    ipc_call_t *call)
    24802478{
    24812479        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    24822480        if (nic_iface->poll_now == NULL) {
    2483                 async_answer_0(chandle, ENOTSUP);
     2481                async_answer_0(call, ENOTSUP);
    24842482                return;
    24852483        }
    24862484
    24872485        errno_t rc = nic_iface->poll_now(dev);
    2488         async_answer_0(chandle, rc);
     2486        async_answer_0(call, rc);
    24892487}
    24902488

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

    r76f566d r984a9ba  
    124124}
    125125
    126 static void remote_config_space_read_8(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    127 static void remote_config_space_read_16(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    128 static void remote_config_space_read_32(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    129 
    130 static void remote_config_space_write_8(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    131 static void remote_config_space_write_16(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    132 static void remote_config_space_write_32(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
     126static void remote_config_space_read_8(ddf_fun_t *, void *, ipc_call_t *);
     127static void remote_config_space_read_16(ddf_fun_t *, void *, ipc_call_t *);
     128static void remote_config_space_read_32(ddf_fun_t *, void *, ipc_call_t *);
     129
     130static void remote_config_space_write_8(ddf_fun_t *, void *, ipc_call_t *);
     131static void remote_config_space_write_16(ddf_fun_t *, void *, ipc_call_t *);
     132static void remote_config_space_write_32(ddf_fun_t *, void *, ipc_call_t *);
    133133
    134134/** Remote USB interface operations. */
    … …  
    150150};
    151151
    152 void remote_config_space_read_8(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     152void remote_config_space_read_8(ddf_fun_t *fun, void *iface, 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(chandle, ENOTSUP);
     157                async_answer_0(call, 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(chandle, ret);
    165         } else {
    166                 async_answer_1(chandle, EOK, value);
    167         }
    168 }
    169 
    170 void remote_config_space_read_16(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     164                async_answer_0(call, ret);
     165        } else {
     166                async_answer_1(call, EOK, value);
     167        }
     168}
     169
     170void remote_config_space_read_16(ddf_fun_t *fun, void *iface, 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(chandle, ENOTSUP);
     175                async_answer_0(call, 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(chandle, ret);
    183         } else {
    184                 async_answer_1(chandle, EOK, value);
    185         }
    186 }
    187 void remote_config_space_read_32(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     182                async_answer_0(call, ret);
     183        } else {
     184                async_answer_1(call, EOK, value);
     185        }
     186}
     187void remote_config_space_read_32(ddf_fun_t *fun, void *iface, 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(chandle, ENOTSUP);
     192                async_answer_0(call, 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(chandle, ret);
    200         } else {
    201                 async_answer_1(chandle, EOK, value);
    202         }
    203 }
    204 
    205 void remote_config_space_write_8(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     199                async_answer_0(call, ret);
     200        } else {
     201                async_answer_1(call, EOK, value);
     202        }
     203}
     204
     205void remote_config_space_write_8(ddf_fun_t *fun, void *iface, 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(chandle, ENOTSUP);
     210                async_answer_0(call, 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(chandle, ret);
    218         } else {
    219                 async_answer_0(chandle, EOK);
    220         }
    221 }
    222 
    223 void remote_config_space_write_16(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     217                async_answer_0(call, ret);
     218        } else {
     219                async_answer_0(call, EOK);
     220        }
     221}
     222
     223void remote_config_space_write_16(ddf_fun_t *fun, void *iface, 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(chandle, ENOTSUP);
     228                async_answer_0(call, 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(chandle, ret);
    236         } else {
    237                 async_answer_0(chandle, EOK);
    238         }
    239 }
    240 
    241 void remote_config_space_write_32(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     235                async_answer_0(call, ret);
     236        } else {
     237                async_answer_0(call, EOK);
     238        }
     239}
     240
     241void remote_config_space_write_32(ddf_fun_t *fun, void *iface, 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(chandle, ENOTSUP);
     246                async_answer_0(call, 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(chandle, ret);
    254         } else {
    255                 async_answer_0(chandle, EOK);
    256         }
    257 }
    258 
     253                async_answer_0(call, ret);
     254        } else {
     255                async_answer_0(call, EOK);
     256        }
     257}
    259258
    260259/**
    261260 * @}
    262261 */
    263 

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

    r76f566d r984a9ba  
    4040#include "ddf/driver.h"
    4141
    42 static void remote_pio_window_get(ddf_fun_t *, void *, cap_call_handle_t,
    43     ipc_call_t *);
     42static void remote_pio_window_get(ddf_fun_t *, void *, ipc_call_t *);
    4443
    4544static const remote_iface_func_ptr_t remote_pio_window_iface_ops [] = {
    … …  
    5352
    5453static void remote_pio_window_get(ddf_fun_t *fun, void *ops,
    55     cap_call_handle_t chandle, ipc_call_t *call)
     54    ipc_call_t *call)
    5655{
    5756        pio_window_ops_t *pio_win_ops = (pio_window_ops_t *) ops;
    58         size_t len;
    5957
    6058        if (!pio_win_ops->get_pio_window) {
    61                 async_answer_0(chandle, ENOTSUP);
     59                async_answer_0(call, ENOTSUP);
    6260                return;
    6361        }
    … …  
    6563        pio_window_t *pio_window = pio_win_ops->get_pio_window(fun);
    6664        if (!pio_window) {
    67                 async_answer_0(chandle, ENOENT);
     65                async_answer_0(call, ENOENT);
    6866                return;
    6967        }
    7068
    71         async_answer_0(chandle, EOK);
     69        async_answer_0(call, EOK);
    7270
    73         if (!async_data_read_receive(&chandle, &len)) {
     71        ipc_call_t data;
     72        size_t len;
     73        if (!async_data_read_receive(&data, &len)) {
    7474                /* Protocol error - the recipient is not accepting data */
    7575                return;
    7676        }
    7777
    78         async_data_read_finalize(chandle, pio_window, len);
     78        async_data_read_finalize(&data, pio_window, len);
    7979}
    8080

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

    r76f566d r984a9ba  
    9595}
    9696
    97 static void remote_usb_get_my_description(ddf_fun_t *, void *,
    98     cap_call_handle_t, ipc_call_t *);
     97static void remote_usb_get_my_description(ddf_fun_t *, void *, ipc_call_t *);
    9998
    10099/** Remote USB interface operations. */
    … …  
    111110
    112111void remote_usb_get_my_description(ddf_fun_t *fun, void *iface,
    113     cap_call_handle_t chandle, ipc_call_t *call)
     112    ipc_call_t *call)
    114113{
    115114        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
    116115
    117116        if (usb_iface->get_my_description == NULL) {
    118                 async_answer_0(chandle, ENOTSUP);
     117                async_answer_0(call, ENOTSUP);
    119118                return;
    120119        }
    … …  
    123122        const errno_t ret = usb_iface->get_my_description(fun, &desc);
    124123        if (ret != EOK) {
    125                 async_answer_0(chandle, ret);
     124                async_answer_0(call, ret);
    126125        } else {
    127                 async_answer_5(chandle, EOK,
     126                async_answer_5(call, EOK,
    128127                    (sysarg_t) desc.address,
    129128                    (sysarg_t) desc.depth,

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

    r76f566d r984a9ba  
    126126}
    127127
    128 static void remote_usbdiag_test_in(ddf_fun_t *, void *,
    129     cap_call_handle_t, ipc_call_t *);
    130 static void remote_usbdiag_test_out(ddf_fun_t *, void *,
    131     cap_call_handle_t, ipc_call_t *);
     128static void remote_usbdiag_test_in(ddf_fun_t *, void *, ipc_call_t *);
     129static void remote_usbdiag_test_out(ddf_fun_t *, void *, ipc_call_t *);
    132130
    133131/** Remote USB diagnostic interface operations. */
    … …  
    143141};
    144142
    145 void remote_usbdiag_test_in(ddf_fun_t *fun, void *iface,
    146     cap_call_handle_t chandle, ipc_call_t *call)
     143void remote_usbdiag_test_in(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    147144{
    148145        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    149146
     147        ipc_call_t data;
    150148        size_t size;
    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);
     149        if (!async_data_write_receive(&data, &size)) {
     150                async_answer_0(&data, EINVAL);
     151                async_answer_0(call, EINVAL);
    155152                return;
    156153        }
    157154
    158155        if (size != sizeof(usbdiag_test_params_t)) {
    159                 async_answer_0(data_chandle, EINVAL);
    160                 async_answer_0(chandle, EINVAL);
     156                async_answer_0(&data, EINVAL);
     157                async_answer_0(call, EINVAL);
    161158                return;
    162159        }
    163160
    164161        usbdiag_test_params_t params;
    165         if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
    166                 async_answer_0(chandle, EINVAL);
     162        if (async_data_write_finalize(&data, &params, size) != EOK) {
     163                async_answer_0(call, EINVAL);
    167164                return;
    168165        }
    … …  
    173170
    174171        if (ret != EOK) {
    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);
     172                async_answer_0(call, ret);
     173                return;
     174        }
     175
     176        if (!async_data_read_receive(&data, &size)) {
     177                async_answer_0(&data, EINVAL);
     178                async_answer_0(call, EINVAL);
    182179                return;
    183180        }
    184181
    185182        if (size != sizeof(usbdiag_test_results_t)) {
    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);
    197 }
    198 
    199 void remote_usbdiag_test_out(ddf_fun_t *fun, void *iface,
    200     cap_call_handle_t chandle, ipc_call_t *call)
     183                async_answer_0(&data, EINVAL);
     184                async_answer_0(call, EINVAL);
     185                return;
     186        }
     187
     188        if (async_data_read_finalize(&data, &results, size) != EOK) {
     189                async_answer_0(call, EINVAL);
     190                return;
     191        }
     192
     193        async_answer_0(call, ret);
     194}
     195
     196void remote_usbdiag_test_out(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    201197{
    202198        const usbdiag_iface_t *diag_iface = (usbdiag_iface_t *) iface;
    203199
     200        ipc_call_t data;
    204201        size_t size;
    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);
     202        if (!async_data_write_receive(&data, &size)) {
     203                async_answer_0(&data, EINVAL);
     204                async_answer_0(call, EINVAL);
    209205                return;
    210206        }
    211207
    212208        if (size != sizeof(usbdiag_test_params_t)) {
    213                 async_answer_0(data_chandle, EINVAL);
    214                 async_answer_0(chandle, EINVAL);
     209                async_answer_0(&data, EINVAL);
     210                async_answer_0(call, EINVAL);
    215211                return;
    216212        }
    217213
    218214        usbdiag_test_params_t params;
    219         if (async_data_write_finalize(data_chandle, &params, size) != EOK) {
    220                 async_answer_0(chandle, EINVAL);
     215        if (async_data_write_finalize(&data, &params, size) != EOK) {
     216                async_answer_0(call, EINVAL);
    221217                return;
    222218        }
    … …  
    227223
    228224        if (ret != EOK) {
    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);
     225                async_answer_0(call, ret);
     226                return;
     227        }
     228
     229        if (!async_data_read_receive(&data, &size)) {
     230                async_answer_0(&data, EINVAL);
     231                async_answer_0(call, EINVAL);
    236232                return;
    237233        }
    238234
    239235        if (size != sizeof(usbdiag_test_results_t)) {
    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);
     236                async_answer_0(&data, EINVAL);
     237                async_answer_0(call, EINVAL);
     238                return;
     239        }
     240
     241        if (async_data_read_finalize(&data, &results, size) != EOK) {
     242                async_answer_0(call, EINVAL);
     243                return;
     244        }
     245
     246        async_answer_0(call, ret);
    251247}
    252248

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

    r76f566d r984a9ba  
    227227}
    228228
    229 static void remote_usbhc_default_address_reservation(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    230 static void remote_usbhc_device_enumerate(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    231 static void remote_usbhc_device_remove(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    232 static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    233 static 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 chandle, ipc_call_t *call);
     229static void remote_usbhc_default_address_reservation(ddf_fun_t *, void *, ipc_call_t *);
     230static void remote_usbhc_device_enumerate(ddf_fun_t *, void *, ipc_call_t *);
     231static void remote_usbhc_device_remove(ddf_fun_t *, void *, ipc_call_t *);
     232static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_call_t *);
     233static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_call_t *);
     234static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, ipc_call_t *call);
    235235
    236236/** Remote USB interface operations. */
    … …  
    252252
    253253typedef struct {
    254         cap_call_handle_t caller;
     254        ipc_call_t call;
    255255        usbhc_iface_transfer_request_t request;
    256256} async_transaction_t;
    257257
    258258void remote_usbhc_default_address_reservation(ddf_fun_t *fun, void *iface,
    259     cap_call_handle_t chandle, ipc_call_t *call)
     259    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(chandle, ENOTSUP);
     264                async_answer_0(call, 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(chandle, ret);
     270        async_answer_0(call, ret);
    271271}
    272272
    273273
    274274static void remote_usbhc_device_enumerate(ddf_fun_t *fun, void *iface,
    275     cap_call_handle_t chandle, ipc_call_t *call)
     275    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(chandle, ENOTSUP);
     280                async_answer_0(call, 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(chandle, ret);
     287        async_answer_0(call, ret);
    288288}
    289289
    290290static void remote_usbhc_device_remove(ddf_fun_t *fun, void *iface,
    291     cap_call_handle_t chandle, ipc_call_t *call)
     291    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(chandle, ENOTSUP);
     296                async_answer_0(call, 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(chandle, ret);
     302        async_answer_0(call, ret);
    303303}
    304304
    305305static void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
    306     cap_call_handle_t chandle, ipc_call_t *call)
     306    ipc_call_t *call)
    307307{
    308308        assert(fun);
    … …  
    313313
    314314        if (!usbhc_iface->register_endpoint) {
    315                 async_answer_0(chandle, ENOTSUP);
     315                async_answer_0(call, ENOTSUP);
    316316                return;
    317317        }
    318318
    319319        usb_endpoint_descriptors_t ep_desc;
    320         cap_call_handle_t data_chandle;
     320        ipc_call_t data;
    321321        size_t len;
    322322
    323         if (!async_data_write_receive(&data_chandle, &len) ||
     323        if (!async_data_write_receive(&data, &len) ||
    324324            len != sizeof(ep_desc)) {
    325                 async_answer_0(chandle, EINVAL);
    326                 return;
    327         }
    328         async_data_write_finalize(data_chandle, &ep_desc, sizeof(ep_desc));
     325                async_answer_0(call, EINVAL);
     326                return;
     327        }
     328
     329        async_data_write_finalize(&data, &ep_desc, sizeof(ep_desc));
    329330
    330331        usb_pipe_desc_t pipe_desc;
    331332
    332333        const errno_t rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
    333         async_answer_0(chandle, rc);
    334 
    335         if (!async_data_read_receive(&data_chandle, &len) ||
     334        async_answer_0(call, rc);
     335
     336        if (!async_data_read_receive(&data, &len) ||
    336337            len != sizeof(pipe_desc)) {
    337338                return;
    338339        }
    339         async_data_read_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
     340        async_data_read_finalize(&data, &pipe_desc, sizeof(pipe_desc));
    340341}
    341342
    342343static void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
    343     cap_call_handle_t chandle, ipc_call_t *call)
     344    ipc_call_t *call)
    344345{
    345346        assert(fun);
    … …  
    350351
    351352        if (!usbhc_iface->unregister_endpoint) {
    352                 async_answer_0(chandle, ENOTSUP);
     353                async_answer_0(call, ENOTSUP);
    353354                return;
    354355        }
    355356
    356357        usb_pipe_desc_t pipe_desc;
    357         cap_call_handle_t data_chandle;
     358        ipc_call_t data;
    358359        size_t len;
    359360
    360         if (!async_data_write_receive(&data_chandle, &len) ||
     361        if (!async_data_write_receive(&data, &len) ||
    361362            len != sizeof(pipe_desc)) {
    362                 async_answer_0(chandle, EINVAL);
    363                 return;
    364         }
    365         async_data_write_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
     363                async_answer_0(call, EINVAL);
     364                return;
     365        }
     366        async_data_write_finalize(&data, &pipe_desc, sizeof(pipe_desc));
    366367
    367368        const errno_t rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
    368         async_answer_0(chandle, rc);
     369        async_answer_0(call, rc);
    369370}
    370371
    … …  
    381382}
    382383
    383 static async_transaction_t *async_transaction_create(cap_call_handle_t caller)
     384static async_transaction_t *async_transaction_create(ipc_call_t *call)
    384385{
    385386        async_transaction_t *trans = calloc(1, sizeof(async_transaction_t));
    386387
    387388        if (trans != NULL)
    388                 trans->caller = caller;
     389                trans->call = *call;
    389390
    390391        return trans;
    … …  
    394395{
    395396        async_transaction_t *trans = arg;
    396         const errno_t err = async_answer_1(trans->caller, error, transferred_size);
     397        const errno_t err = async_answer_1(&trans->call, error, transferred_size);
    397398        async_transaction_destroy(trans);
    398399        return err;
    … …  
    410411
    411412        errno_t err;
    412         cap_call_handle_t data_chandle;
     413        ipc_call_t data;
    413414        size_t size;
    414415        unsigned flags;
    415416
    416         if (!async_share_out_receive(&data_chandle, &size, &flags))
     417        if (!async_share_out_receive(&data, &size, &flags))
    417418                return EPARTY;
    418419
    419420        if (size < required_size || (flags & required_flags) != required_flags) {
    420                 async_answer_0(data_chandle, EINVAL);
     421                async_answer_0(&data, EINVAL);
    421422                return EINVAL;
    422423        }
    423424
    424         if ((err = async_share_out_finalize(data_chandle, &trans->request.buffer.virt)))
     425        if ((err = async_share_out_finalize(&data, &trans->request.buffer.virt)))
    425426                return err;
    426427
    … …  
    445446}
    446447
    447 void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
     448void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, ipc_call_t *call)
    448449{
    449450        assert(fun);
    … …  
    454455
    455456        if (!usbhc_iface->transfer) {
    456                 async_answer_0(chandle, ENOTSUP);
    457                 return;
    458         }
    459 
    460         async_transaction_t *trans = async_transaction_create(chandle);
     457                async_answer_0(call, ENOTSUP);
     458                return;
     459        }
     460
     461        async_transaction_t *trans =
     462            async_transaction_create(call);
    461463        if (trans == NULL) {
    462                 async_answer_0(chandle, ENOMEM);
     464                async_answer_0(call, ENOMEM);
    463465                return;
    464466        }
    … …  
    466468        errno_t err = EPARTY;
    467469
    468         cap_call_handle_t data_chandle;
     470        ipc_call_t data;
    469471        size_t len;
    470         if (!async_data_write_receive(&data_chandle, &len) ||
     472        if (!async_data_write_receive(&data, &len) ||
    471473            len != sizeof(trans->request)) {
    472                 async_answer_0(data_chandle, EINVAL);
     474                async_answer_0(&data, EINVAL);
    473475                goto err;
    474476        }
    475477
    476         if ((err = async_data_write_finalize(data_chandle,
     478        if ((err = async_data_write_finalize(&data,
    477479            &trans->request, sizeof(trans->request))))
    478480                goto err;
    … …  
    494496
    495497err:
    496         async_answer_0(chandle, err);
     498        async_answer_0(call, err);
    497499        async_transaction_destroy(trans);
    498500}

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

    r76f566d r984a9ba  
    283283}
    284284
    285 static void remote_usbhid_get_event_length(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    286 static void remote_usbhid_get_event(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    287 static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
    288 static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
     285static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_call_t *);
     286static void remote_usbhid_get_event(ddf_fun_t *, void *, ipc_call_t *);
     287static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, ipc_call_t *);
     288static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, ipc_call_t *);
    289289
    290290/** Remote USB HID interface operations. */
    … …  
    306306
    307307void remote_usbhid_get_event_length(ddf_fun_t *fun, void *iface,
    308     cap_call_handle_t chandle, ipc_call_t *call)
     308    ipc_call_t *call)
    309309{
    310310        printf("remote_usbhid_get_event_length()\n");
    … …  
    314314        if (!hid_iface->get_event_length) {
    315315                printf("Get event length not set!\n");
    316                 async_answer_0(chandle, ENOTSUP);
     316                async_answer_0(call, ENOTSUP);
    317317                return;
    318318        }
    319319
    320320        size_t len = hid_iface->get_event_length(fun);
    321         async_answer_1(chandle, EOK, len);
     321        async_answer_1(call, EOK, len);
    322322}
    323323
    324324void remote_usbhid_get_event(ddf_fun_t *fun, void *iface,
    325     cap_call_handle_t chandle, ipc_call_t *call)
     325    ipc_call_t *call)
    326326{
    327327        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    328328
    329329        if (!hid_iface->get_event) {
    330                 async_answer_0(chandle, ENOTSUP);
     330                async_answer_0(call, ENOTSUP);
    331331                return;
    332332        }
    … …  
    334334        unsigned int flags = DEV_IPC_GET_ARG1(*call);
    335335
     336        ipc_call_t data;
    336337        size_t len;
    337         cap_call_handle_t data_chandle;
    338         if (!async_data_read_receive(&data_chandle, &len)) {
    339                 async_answer_0(chandle, EPARTY);
     338        if (!async_data_read_receive(&data, &len)) {
     339                async_answer_0(call, EPARTY);
    340340                return;
    341341        }
    342342
    343343        if (len == 0) {
    344                 async_answer_0(data_chandle, EINVAL);
    345                 async_answer_0(chandle, EINVAL);
     344                async_answer_0(&data, EINVAL);
     345                async_answer_0(call, EINVAL);
    346346                return;
    347347        }
    … …  
    349349        errno_t rc;
    350350
    351         uint8_t *data = malloc(len);
    352         if (data == NULL) {
    353                 async_answer_0(data_chandle, ENOMEM);
    354                 async_answer_0(chandle, ENOMEM);
     351        uint8_t *event = malloc(len);
     352        if (event == NULL) {
     353                async_answer_0(&data, ENOMEM);
     354                async_answer_0(call, ENOMEM);
    355355                return;
    356356        }
    … …  
    358358        size_t act_length;
    359359        int event_nr;
    360         rc = hid_iface->get_event(fun, data, len, &act_length, &event_nr, flags);
     360        rc = hid_iface->get_event(fun, event, len, &act_length, &event_nr, flags);
    361361        if (rc != EOK) {
    362                 free(data);
    363                 async_answer_0(data_chandle, rc);
    364                 async_answer_0(chandle, rc);
     362                free(event);
     363                async_answer_0(&data, rc);
     364                async_answer_0(call, rc);
    365365                return;
    366366        }
    … …  
    371371        }
    372372
    373         async_data_read_finalize(data_chandle, data, act_length);
    374 
    375         free(data);
    376 
    377         async_answer_1(chandle, EOK, event_nr);
     373        async_data_read_finalize(&data, event, act_length);
     374
     375        free(event);
     376
     377        async_answer_1(call, EOK, event_nr);
    378378}
    379379
    380380void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
    381     cap_call_handle_t chandle, ipc_call_t *call)
     381    ipc_call_t *call)
    382382{
    383383        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    384384
    385385        if (!hid_iface->get_report_descriptor_length) {
    386                 async_answer_0(chandle, ENOTSUP);
     386                async_answer_0(call, ENOTSUP);
    387387                return;
    388388        }
    389389
    390390        size_t len = hid_iface->get_report_descriptor_length(fun);
    391         async_answer_1(chandle, EOK, (sysarg_t) len);
     391        async_answer_1(call, EOK, (sysarg_t) len);
    392392}
    393393
    394394void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
    395     cap_call_handle_t chandle, ipc_call_t *call)
     395    ipc_call_t *call)
    396396{
    397397        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    398398
    399399        if (!hid_iface->get_report_descriptor) {
    400                 async_answer_0(chandle, ENOTSUP);
    401                 return;
    402         }
    403 
     400                async_answer_0(call, ENOTSUP);
     401                return;
     402        }
     403
     404        ipc_call_t data;
    404405        size_t len;
    405         cap_call_handle_t data_chandle;
    406         if (!async_data_read_receive(&data_chandle, &len)) {
    407                 async_answer_0(chandle, EINVAL);
     406        if (!async_data_read_receive(&data, &len)) {
     407                async_answer_0(call, EINVAL);
    408408                return;
    409409        }
    410410
    411411        if (len == 0) {
    412                 async_answer_0(data_chandle, EINVAL);
    413                 async_answer_0(chandle, EINVAL);
     412                async_answer_0(&data, EINVAL);
     413                async_answer_0(call, EINVAL);
    414414                return;
    415415        }
    … …  
    417417        uint8_t *descriptor = malloc(len);
    418418        if (descriptor == NULL) {
    419                 async_answer_0(data_chandle, ENOMEM);
    420                 async_answer_0(chandle, ENOMEM);
     419                async_answer_0(&data, ENOMEM);
     420                async_answer_0(call, ENOMEM);
    421421                return;
    422422        }
    … …  
    430430        if (rc != EOK) {
    431431                free(descriptor);
    432                 async_answer_0(data_chandle, rc);
    433                 async_answer_0(chandle, rc);
    434                 return;
    435         }
    436 
    437         async_data_read_finalize(data_chandle, descriptor, act_len);
    438         async_answer_0(chandle, EOK);
     432                async_answer_0(&data, rc);
     433                async_answer_0(call, rc);
     434                return;
     435        }
     436
     437        async_data_read_finalize(&data, descriptor, act_len);
     438        async_answer_0(call, EOK);
    439439
    440440        free(descriptor);
    441441}
    442 
    443 
    444442
    445443/**
Note: See TracChangeset for help on using the changeset viewer.