Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    ref40434 r50b581d  
    8484 */
    8585typedef enum {
     86        /** Asks for address assignment by host controller.
     87         * Answer:
     88         * - ELIMIT - host controller run out of address
     89         * - EOK - address assigned
     90         * Answer arguments:
     91         * - assigned address
     92         *
     93         * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
     94         */
     95        IPC_M_USBHC_REQUEST_ADDRESS,
     96
     97        /** Bind USB address with devman handle.
     98         * Parameters:
     99         * - USB address
     100         * - devman handle
     101         * Answer:
     102         * - EOK - address binded
     103         * - ENOENT - address is not in use
     104         */
     105        IPC_M_USBHC_BIND_ADDRESS,
     106
    86107        /** Get handle binded with given USB address.
    87108         * Parameters
    … …  
    92113         */
    93114        IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
     115
     116        /** Release address in use.
     117         * Arguments:
     118         * - address to be released
     119         * Answer:
     120         * - ENOENT - address not in use
     121         * - EPERM - trying to release default USB address
     122         */
     123        IPC_M_USBHC_RELEASE_ADDRESS,
    94124
    95125        /** Register endpoint attributes at host controller.
    … …  
    131161} usbhc_iface_funcs_t;
    132162
    133 
    134 
     163int usbhc_request_address(async_exch_t *exch, usb_address_t *address,
     164    bool strict, usb_speed_t speed)
     165{
     166        if (!exch || !address)
     167                return EINVAL;
     168        sysarg_t new_address;
     169        const int ret = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     170            IPC_M_USBHC_REQUEST_ADDRESS, *address, strict, speed, &new_address);
     171        if (ret == EOK)
     172                *address = (usb_address_t)new_address;
     173        return ret;
     174}
     175/*----------------------------------------------------------------------------*/
     176int usbhc_bind_address(async_exch_t *exch, usb_address_t address,
     177    devman_handle_t handle)
     178{
     179        if (!exch)
     180                return EINVAL;
     181        return async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     182            IPC_M_USBHC_BIND_ADDRESS, address, handle);
     183}
     184/*----------------------------------------------------------------------------*/
    135185int usbhc_get_handle(async_exch_t *exch, usb_address_t address,
    136186    devman_handle_t *handle)
    137187{
    138188        if (!exch)
    139                 return EBADMEM;
     189                return EINVAL;
    140190        sysarg_t h;
    141191        const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    … …  
    145195        return ret;
    146196}
    147 
     197/*----------------------------------------------------------------------------*/
     198int usbhc_release_address(async_exch_t *exch, usb_address_t address)
     199{
     200        if (!exch)
     201                return EINVAL;
     202        return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     203            IPC_M_USBHC_RELEASE_ADDRESS, address);
     204}
     205/*----------------------------------------------------------------------------*/
    148206int usbhc_register_endpoint(async_exch_t *exch, usb_address_t address,
    149207    usb_endpoint_t endpoint, usb_transfer_type_t type,
    … …  
    151209{
    152210        if (!exch)
    153                 return EBADMEM;
     211                return EINVAL;
    154212        const usb_target_t target =
    155213            {{ .address = address, .endpoint = endpoint }};
    … …  
    162220#undef _PACK2
    163221}
    164 
     222/*----------------------------------------------------------------------------*/
    165223int usbhc_unregister_endpoint(async_exch_t *exch, usb_address_t address,
    166224    usb_endpoint_t endpoint, usb_direction_t direction)
    167225{
    168226        if (!exch)
    169                 return EBADMEM;
     227                return EINVAL;
    170228        return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    171229            IPC_M_USBHC_UNREGISTER_ENDPOINT, address, endpoint, direction);
    172230}
    173 
     231/*----------------------------------------------------------------------------*/
    174232int usbhc_read(async_exch_t *exch, usb_address_t address,
    175233    usb_endpoint_t endpoint, uint64_t setup, void *data, size_t size,
    176234    size_t *rec_size)
    177235{
    178         if (!exch)
    179                 return EBADMEM;
    180 
    181236        if (size == 0 && setup == 0)
    182237                return EOK;
    183238
     239        if (!exch)
     240                return EINVAL;
    184241        const usb_target_t target =
    185242            {{ .address = address, .endpoint = endpoint }};
    … …  
    227284        return EOK;
    228285}
    229 
     286/*----------------------------------------------------------------------------*/
    230287int usbhc_write(async_exch_t *exch, usb_address_t address,
    231288    usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size)
    232289{
    233         if (!exch)
    234                 return EBADMEM;
    235 
    236290        if (size == 0 && setup == 0)
    237291                return EOK;
    238292
     293        if (!exch)
     294                return EINVAL;
    239295        const usb_target_t target =
    240296            {{ .address = address, .endpoint = endpoint }};
    … …  
    263319        return (int) opening_request_rc;
    264320}
    265 
    266 
     321/*----------------------------------------------------------------------------*/
     322
     323static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     324static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    267325static void remote_usbhc_get_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     326static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    268327static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    269328static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    … …  
    274333/** Remote USB host controller interface operations. */
    275334static remote_iface_func_ptr_t remote_usbhc_iface_ops[] = {
     335        [IPC_M_USBHC_REQUEST_ADDRESS] = remote_usbhc_request_address,
     336        [IPC_M_USBHC_RELEASE_ADDRESS] = remote_usbhc_release_address,
     337        [IPC_M_USBHC_BIND_ADDRESS] = remote_usbhc_bind_address,
    276338        [IPC_M_USBHC_GET_HANDLE_BY_ADDRESS] = remote_usbhc_get_handle,
    277339
    … …  
    322384        return trans;
    323385}
    324 
    325 
     386/*----------------------------------------------------------------------------*/
     387void remote_usbhc_request_address(ddf_fun_t *fun, void *iface,
     388    ipc_callid_t callid, ipc_call_t *call)
     389{
     390        const usbhc_iface_t *usb_iface = iface;
     391
     392        if (!usb_iface->request_address) {
     393                async_answer_0(callid, ENOTSUP);
     394                return;
     395        }
     396
     397        usb_address_t address = DEV_IPC_GET_ARG1(*call);
     398        const bool strict = DEV_IPC_GET_ARG2(*call);
     399        const usb_speed_t speed = DEV_IPC_GET_ARG3(*call);
     400
     401        const int rc = usb_iface->request_address(fun, &address, strict, speed);
     402        if (rc != EOK) {
     403                async_answer_0(callid, rc);
     404        } else {
     405                async_answer_1(callid, EOK, (sysarg_t) address);
     406        }
     407}
     408/*----------------------------------------------------------------------------*/
     409void remote_usbhc_bind_address(ddf_fun_t *fun, void *iface,
     410    ipc_callid_t callid, ipc_call_t *call)
     411{
     412        const usbhc_iface_t *usb_iface = iface;
     413
     414        if (!usb_iface->bind_address) {
     415                async_answer_0(callid, ENOTSUP);
     416                return;
     417        }
     418
     419        const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
     420        const devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call);
     421
     422        const int ret = usb_iface->bind_address(fun, address, handle);
     423        async_answer_0(callid, ret);
     424}
     425/*----------------------------------------------------------------------------*/
    326426void remote_usbhc_get_handle(ddf_fun_t *fun, void *iface,
    327427    ipc_callid_t callid, ipc_call_t *call)
    … …  
    344444        }
    345445}
    346 
    347 
    348 static void callback_out(int outcome, void *arg)
     446/*----------------------------------------------------------------------------*/
     447void remote_usbhc_release_address(ddf_fun_t *fun, void *iface,
     448    ipc_callid_t callid, ipc_call_t *call)
     449{
     450        const usbhc_iface_t *usb_iface = iface;
     451
     452        if (!usb_iface->release_address) {
     453                async_answer_0(callid, ENOTSUP);
     454                return;
     455        }
     456
     457        const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
     458
     459        const int ret = usb_iface->release_address(fun, address);
     460        async_answer_0(callid, ret);
     461}
     462/*----------------------------------------------------------------------------*/
     463static void callback_out(ddf_fun_t *fun,
     464    int outcome, void *arg)
    349465{
    350466        async_transaction_t *trans = arg;
    … …  
    354470        async_transaction_destroy(trans);
    355471}
    356 
    357 static void callback_in(int outcome, size_t actual_size, void *arg)
     472/*----------------------------------------------------------------------------*/
     473static void callback_in(ddf_fun_t *fun,
     474    int outcome, size_t actual_size, void *arg)
    358475{
    359476        async_transaction_t *trans = (async_transaction_t *)arg;
    … …  
    377494        async_transaction_destroy(trans);
    378495}
    379 
     496/*----------------------------------------------------------------------------*/
    380497void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
    381498    ipc_callid_t callid, ipc_call_t *call)
    … …  
    477594        }
    478595}
    479 
     596/*----------------------------------------------------------------------------*/
    480597void remote_usbhc_write(
    481598    ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
Note: See TracChangeset for help on using the changeset viewer.