Changeset a46e56b in mainline for uspace/lib/usbvirt/src/ipc_dev.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/usbvirt/src/ipc_dev.c

    r3e242d2 ra46e56b  
    4949 */
    5050static void ipc_get_name(usbvirt_device_t *dev,
    51     cap_call_handle_t iid, ipc_call_t *icall)
     51    cap_call_handle_t icall_handle, ipc_call_t *icall)
    5252{
    5353        if (dev->name == NULL) {
    54                 async_answer_0(iid, ENOENT);
     54                async_answer_0(icall_handle, ENOENT);
    5555        }
    5656
    5757        size_t size = str_size(dev->name);
    5858
    59         cap_call_handle_t callid;
     59        cap_call_handle_t chandle;
    6060        size_t accepted_size;
    61         if (!async_data_read_receive(&callid, &accepted_size)) {
    62                 async_answer_0(iid, EINVAL);
     61        if (!async_data_read_receive(&chandle, &accepted_size)) {
     62                async_answer_0(icall_handle, EINVAL);
    6363                return;
    6464        }
    … …  
    6767                accepted_size = size;
    6868        }
    69         async_data_read_finalize(callid, dev->name, accepted_size);
    70 
    71         async_answer_1(iid, EOK, accepted_size);
     69        async_data_read_finalize(chandle, dev->name, accepted_size);
     70
     71        async_answer_1(icall_handle, EOK, accepted_size);
    7272}
    7373
    … …  
    7979 */
    8080static void ipc_control_read(usbvirt_device_t *dev,
    81     cap_call_handle_t iid, ipc_call_t *icall)
     81    cap_call_handle_t icall_handle, ipc_call_t *icall)
    8282{
    8383        errno_t rc;
    … …  
    9090            1, 1024, 0, &setup_packet_len);
    9191        if (rc != EOK) {
    92                 async_answer_0(iid, rc);
    93                 return;
    94         }
    95 
    96         cap_call_handle_t data_callid;
    97         if (!async_data_read_receive(&data_callid, &data_len)) {
    98                 async_answer_0(iid, EPARTY);
     92                async_answer_0(icall_handle, rc);
     93                return;
     94        }
     95
     96        cap_call_handle_t data_chandle;
     97        if (!async_data_read_receive(&data_chandle, &data_len)) {
     98                async_answer_0(icall_handle, EPARTY);
    9999                free(setup_packet);
    100100                return;
    … …  
    103103        void *buffer = malloc(data_len);
    104104        if (buffer == NULL) {
    105                 async_answer_0(iid, ENOMEM);
     105                async_answer_0(icall_handle, ENOMEM);
    106106                free(setup_packet);
    107107                return;
    … …  
    113113
    114114        if (rc != EOK) {
    115                 async_answer_0(data_callid, rc);
    116                 async_answer_0(iid, rc);
     115                async_answer_0(data_chandle, rc);
     116                async_answer_0(icall_handle, rc);
    117117                free(setup_packet);
    118118                free(buffer);
    … …  
    120120        }
    121121
    122         async_data_read_finalize(data_callid, buffer, actual_len);
    123         async_answer_0(iid, EOK);
     122        async_data_read_finalize(data_chandle, buffer, actual_len);
     123        async_answer_0(icall_handle, EOK);
    124124
    125125        free(setup_packet);
    … …  
    134134 */
    135135static void ipc_control_write(usbvirt_device_t *dev,
    136     cap_call_handle_t iid, ipc_call_t *icall)
     136    cap_call_handle_t icall_handle, ipc_call_t *icall)
    137137{
    138138        size_t data_buffer_len = IPC_GET_ARG1(*icall);
    … …  
    146146            1, 0, 0, &setup_packet_len);
    147147        if (rc != EOK) {
    148                 async_answer_0(iid, rc);
     148                async_answer_0(icall_handle, rc);
    149149                return;
    150150        }
    … …  
    154154                    1, 0, 0, &data_buffer_len);
    155155                if (rc != EOK) {
    156                         async_answer_0(iid, rc);
     156                        async_answer_0(icall_handle, rc);
    157157                        free(setup_packet);
    158158                        return;
    … …  
    163163            data_buffer, data_buffer_len);
    164164
    165         async_answer_0(iid, rc);
     165        async_answer_0(icall_handle, rc);
    166166
    167167        free(setup_packet);
    … …  
    179179static void ipc_data_in(usbvirt_device_t *dev,
    180180    usb_transfer_type_t transfer_type,
    181     cap_call_handle_t iid, ipc_call_t *icall)
     181    cap_call_handle_t icall_handle, ipc_call_t *icall)
    182182{
    183183        usb_endpoint_t endpoint = IPC_GET_ARG1(*icall);
    … …  
    186186
    187187        size_t data_len = 0;
    188         cap_call_handle_t data_callid;
    189         if (!async_data_read_receive(&data_callid, &data_len)) {
    190                 async_answer_0(iid, EPARTY);
     188        cap_call_handle_t data_chandle;
     189        if (!async_data_read_receive(&data_chandle, &data_len)) {
     190                async_answer_0(icall_handle, EPARTY);
    191191                return;
    192192        }
    … …  
    194194        void *buffer = malloc(data_len);
    195195        if (buffer == NULL) {
    196                 async_answer_0(iid, ENOMEM);
     196                async_answer_0(icall_handle, ENOMEM);
    197197                return;
    198198        }
    … …  
    203203
    204204        if (rc != EOK) {
    205                 async_answer_0(data_callid, rc);
    206                 async_answer_0(iid, rc);
     205                async_answer_0(data_chandle, rc);
     206                async_answer_0(icall_handle, rc);
    207207                free(buffer);
    208208                return;
    209209        }
    210210
    211         async_data_read_finalize(data_callid, buffer, actual_len);
    212         async_answer_0(iid, EOK);
     211        async_data_read_finalize(data_chandle, buffer, actual_len);
     212        async_answer_0(icall_handle, EOK);
    213213
    214214        free(buffer);
    … …  
    223223static void ipc_data_out(usbvirt_device_t *dev,
    224224    usb_transfer_type_t transfer_type,
    225     cap_call_handle_t iid, ipc_call_t *icall)
     225    cap_call_handle_t icall_handle, ipc_call_t *icall)
    226226{
    227227        usb_endpoint_t endpoint = IPC_GET_ARG1(*icall);
    … …  
    233233            1, 0, 0, &data_buffer_size);
    234234        if (rc != EOK) {
    235                 async_answer_0(iid, rc);
     235                async_answer_0(icall_handle, rc);
    236236                return;
    237237        }
    … …  
    240240            data_buffer, data_buffer_size);
    241241
    242         async_answer_0(iid, rc);
     242        async_answer_0(icall_handle, rc);
    243243
    244244        free(data_buffer);
    … …  
    248248 *
    249249 * @param dev Target USB device.
    250  * @param callid Caller id.
     250 * @param chandle Caller id.
    251251 * @param call Incoming call.
    252252 * @return Whether the call was handled.
    253253 */
    254254bool usbvirt_ipc_handle_call(usbvirt_device_t *dev,
    255     cap_call_handle_t callid, ipc_call_t *call)
     255    cap_call_handle_t chandle, ipc_call_t *call)
    256256{
    257257        switch (IPC_GET_IMETHOD(*call)) {
    258258        case IPC_M_USBVIRT_GET_NAME:
    259                 ipc_get_name(dev, callid, call);
     259                ipc_get_name(dev, chandle, call);
    260260                break;
    261261
    262262        case IPC_M_USBVIRT_CONTROL_READ:
    263                 ipc_control_read(dev, callid, call);
     263                ipc_control_read(dev, chandle, call);
    264264                break;
    265265
    266266        case IPC_M_USBVIRT_CONTROL_WRITE:
    267                 ipc_control_write(dev, callid, call);
     267                ipc_control_write(dev, chandle, call);
    268268                break;
    269269
    270270        case IPC_M_USBVIRT_INTERRUPT_IN:
    271                 ipc_data_in(dev, USB_TRANSFER_INTERRUPT, callid, call);
     271                ipc_data_in(dev, USB_TRANSFER_INTERRUPT, chandle, call);
    272272                break;
    273273
    274274        case IPC_M_USBVIRT_BULK_IN:
    275                 ipc_data_in(dev, USB_TRANSFER_BULK, callid, call);
     275                ipc_data_in(dev, USB_TRANSFER_BULK, chandle, call);
    276276                break;
    277277
    278278        case IPC_M_USBVIRT_INTERRUPT_OUT:
    279                 ipc_data_out(dev, USB_TRANSFER_INTERRUPT, callid, call);
     279                ipc_data_out(dev, USB_TRANSFER_INTERRUPT, chandle, call);
    280280                break;
    281281
    282282        case IPC_M_USBVIRT_BULK_OUT:
    283                 ipc_data_out(dev, USB_TRANSFER_BULK, callid, call);
     283                ipc_data_out(dev, USB_TRANSFER_BULK, chandle, call);
    284284                break;
    285285
Note: See TracChangeset for help on using the changeset viewer.