Changeset a46e56b in mainline for uspace/lib/drv/generic/remote_nic.c


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

Prefer handle over ID in naming handle variables

File:
1 edited

Legend:

Unmodified
Added
Removed

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

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