Index: uspace/drv/bus/usb/ehci/hc_iface.c =================================================================== --- uspace/drv/bus/usb/ehci/hc_iface.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/drv/bus/usb/ehci/hc_iface.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -149,5 +149,5 @@ .request_address = request_address, .bind_address = bind_address, - .find_by_address = find_by_address, + .get_handle = find_by_address, .release_address = release_address, Index: uspace/drv/bus/usb/vhc/connhost.c =================================================================== --- uspace/drv/bus/usb/vhc/connhost.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/drv/bus/usb/vhc/connhost.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -508,5 +508,5 @@ .request_address = request_address, .bind_address = bind_address, - .find_by_address = find_by_address, + .get_handle = find_by_address, .release_address = release_address, Index: uspace/lib/drv/generic/remote_usbhc.c =================================================================== --- uspace/lib/drv/generic/remote_usbhc.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/drv/generic/remote_usbhc.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -1,4 +1,5 @@ /* * Copyright (c) 2010-2011 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -42,7 +43,285 @@ #define USB_MAX_PAYLOAD_SIZE 1020 +/** IPC methods for communication with HC through DDF interface. + * + * Notes for async methods: + * + * Methods for sending data to device (OUT transactions) + * - e.g. IPC_M_USBHC_INTERRUPT_OUT - + * always use the same semantics: + * - first, IPC call with given method is made + * - argument #1 is target address + * - argument #2 is target endpoint + * - argument #3 is max packet size of the endpoint + * - this call is immediately followed by IPC data write (from caller) + * - the initial call (and the whole transaction) is answer after the + * transaction is scheduled by the HC and acknowledged by the device + * or immediately after error is detected + * - the answer carries only the error code + * + * Methods for retrieving data from device (IN transactions) + * - e.g. IPC_M_USBHC_INTERRUPT_IN - + * also use the same semantics: + * - first, IPC call with given method is made + * - argument #1 is target address + * - argument #2 is target endpoint + * - this call is immediately followed by IPC data read (async version) + * - the call is not answered until the device returns some data (or until + * error occurs) + * + * Some special methods (NO-DATA transactions) do not send any data. These + * might behave as both OUT or IN transactions because communication parts + * where actual buffers are exchanged are omitted. + ** + * For all these methods, wrap functions exists. Important rule: functions + * for IN transactions have (as parameters) buffers where retrieved data + * will be stored. These buffers must be already allocated and shall not be + * touch until the transaction is completed + * (e.g. not before calling usb_wait_for() with appropriate handle). + * OUT transactions buffers can be freed immediately after call is dispatched + * (i.e. after return from wrapping function). + * + */ +typedef enum { + /** Asks for address assignment by host controller. + * Answer: + * - ELIMIT - host controller run out of address + * - EOK - address assigned + * Answer arguments: + * - assigned address + * + * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS. + */ + IPC_M_USBHC_REQUEST_ADDRESS, + + /** Bind USB address with devman handle. + * Parameters: + * - USB address + * - devman handle + * Answer: + * - EOK - address binded + * - ENOENT - address is not in use + */ + IPC_M_USBHC_BIND_ADDRESS, + + /** Get handle binded with given USB address. + * Parameters + * - USB address + * Answer: + * - EOK - address binded, first parameter is the devman handle + * - ENOENT - address is not in use at the moment + */ + IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, + + /** Release address in use. + * Arguments: + * - address to be released + * Answer: + * - ENOENT - address not in use + * - EPERM - trying to release default USB address + */ + IPC_M_USBHC_RELEASE_ADDRESS, + + /** Register endpoint attributes at host controller. + * This is used to reserve portion of USB bandwidth. + * When speed is invalid, speed of the device is used. + * Parameters: + * - USB address + endpoint number + * - packed as ADDR << 16 + EP + * - speed + transfer type + direction + * - packed as ( SPEED << 8 + TYPE ) << 8 + DIR + * - maximum packet size + interval (in milliseconds) + * - packed as MPS << 16 + INT + * Answer: + * - EOK - reservation successful + * - ELIMIT - not enough bandwidth to satisfy the request + */ + IPC_M_USBHC_REGISTER_ENDPOINT, + + /** Revert endpoint registration. + * Parameters: + * - USB address + * - endpoint number + * - data direction + * Answer: + * - EOK - endpoint unregistered + * - ENOENT - unknown endpoint + */ + IPC_M_USBHC_UNREGISTER_ENDPOINT, + + /** Get data from device. + * See explanation at usb_iface_funcs_t (IN transaction). + */ + IPC_M_USBHC_READ, + + /** Send data to device. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_WRITE, +} usbhc_iface_funcs_t; + +int usbhc_request_address(async_exch_t *exch, usb_address_t *address, + bool strict, usb_speed_t speed) +{ + if (!exch || !address) + return EINVAL; + sysarg_t new_address; + const int ret = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_REQUEST_ADDRESS, *address, strict, speed, &new_address); + if (ret == EOK) + *address = (usb_address_t)new_address; + return ret; +} +/*----------------------------------------------------------------------------*/ +int usbhc_bind_address(async_exch_t *exch, usb_address_t address, + devman_handle_t handle) +{ + if (!exch) + return EINVAL; + return async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_BIND_ADDRESS, address, handle); +} +/*----------------------------------------------------------------------------*/ +int usbhc_get_handle(async_exch_t *exch, usb_address_t address, + devman_handle_t *handle) +{ + if (!exch) + return EINVAL; + sysarg_t h; + const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, address, &h); + if (ret == EOK && handle) + *handle = (devman_handle_t)h; + return ret; +} +/*----------------------------------------------------------------------------*/ +int usbhc_release_address(async_exch_t *exch, usb_address_t address) +{ + if (!exch) + return EINVAL; + return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RELEASE_ADDRESS, address); +} +/*----------------------------------------------------------------------------*/ +int usbhc_register_endpoint(async_exch_t *exch, usb_address_t address, + usb_endpoint_t endpoint, usb_transfer_type_t type, + usb_direction_t direction, size_t mps, unsigned interval) +{ + if (!exch) + return EINVAL; + const usb_target_t target = + {{ .address = address, .endpoint = endpoint }}; +#define _PACK2(high, low) (((high & 0xffff) << 16) | (low & 0xffff)) + + return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_REGISTER_ENDPOINT, target.packed, + _PACK2(type, direction), _PACK2(mps, interval)); + +#undef _PACK2 +} +/*----------------------------------------------------------------------------*/ +int usbhc_unregister_endpoint(async_exch_t *exch, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction) +{ + if (!exch) + return EINVAL; + return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_UNREGISTER_ENDPOINT, address, endpoint, direction); +} +/*----------------------------------------------------------------------------*/ +int usbhc_read(async_exch_t *exch, usb_address_t address, + usb_endpoint_t endpoint, uint64_t setup, void *data, size_t size, + size_t *rec_size) +{ + if (size == 0 && setup == 0) + return EOK; + + if (!exch) + return EINVAL; + const usb_target_t target = + {{ .address = address, .endpoint = endpoint }}; + + /* Make call identifying target USB device and type of transfer. */ + aid_t opening_request = async_send_4(exch, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_READ, target.packed, + (setup & UINT32_MAX), (setup >> 32), NULL); + + if (opening_request == 0) { + return ENOMEM; + } + + /* Retrieve the data. */ + ipc_call_t data_request_call; + aid_t data_request = + async_data_read(exch, data, size, &data_request_call); + + if (data_request == 0) { + // FIXME: How to let the other side know that we want to abort? + async_wait_for(opening_request, NULL); + return ENOMEM; + } + + /* Wait for the answer. */ + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer the return code of the opening request. */ + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } else { + return (int) data_request_rc; + } + } + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } + + *rec_size = IPC_GET_ARG2(data_request_call); + return EOK; +} +/*----------------------------------------------------------------------------*/ +int usbhc_write(async_exch_t *exch, usb_address_t address, + usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size) +{ + if (size == 0 && setup == 0) + return EOK; + + if (!exch) + return EINVAL; + const usb_target_t target = + {{ .address = address, .endpoint = endpoint }}; + + aid_t opening_request = async_send_5(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_WRITE, target.packed, size, + (setup & UINT32_MAX), (setup >> 32), NULL); + + if (opening_request == 0) { + return ENOMEM; + } + + /* Send the data if any. */ + if (size > 0) { + const int ret = async_data_write_start(exch, data, size); + if (ret != EOK) { + async_wait_for(opening_request, NULL); + return ret; + } + } + + /* Wait for the answer. */ + sysarg_t opening_request_rc; + async_wait_for(opening_request, &opening_request_rc); + + return (int) opening_request_rc; +} +/*----------------------------------------------------------------------------*/ + static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); -static void remote_usbhc_find_by_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_get_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); @@ -57,5 +336,5 @@ [IPC_M_USBHC_RELEASE_ADDRESS] = remote_usbhc_release_address, [IPC_M_USBHC_BIND_ADDRESS] = remote_usbhc_bind_address, - [IPC_M_USBHC_GET_HANDLE_BY_ADDRESS] = remote_usbhc_find_by_address, + [IPC_M_USBHC_GET_HANDLE_BY_ADDRESS] = remote_usbhc_get_handle, [IPC_M_USBHC_REGISTER_ENDPOINT] = remote_usbhc_register_endpoint, @@ -107,9 +386,9 @@ return trans; } - +/*----------------------------------------------------------------------------*/ void remote_usbhc_request_address(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) { - usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + const usbhc_iface_t *usb_iface = iface; if (!usb_iface->request_address) { @@ -129,9 +408,9 @@ } } - +/*----------------------------------------------------------------------------*/ void remote_usbhc_bind_address(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) { - usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + const usbhc_iface_t *usb_iface = iface; if (!usb_iface->bind_address) { @@ -140,37 +419,36 @@ } - usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); - devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call); - - int rc = usb_iface->bind_address(fun, address, handle); - - async_answer_0(callid, rc); -} - -void remote_usbhc_find_by_address(ddf_fun_t *fun, void *iface, + const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + const devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call); + + const int ret = usb_iface->bind_address(fun, address, handle); + async_answer_0(callid, ret); +} +/*----------------------------------------------------------------------------*/ +void remote_usbhc_get_handle(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) { - usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; - - if (!usb_iface->find_by_address) { - async_answer_0(callid, ENOTSUP); - return; - } - - usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + const usbhc_iface_t *usb_iface = iface; + + if (!usb_iface->get_handle) { + async_answer_0(callid, ENOTSUP); + return; + } + + const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); devman_handle_t handle; - int rc = usb_iface->find_by_address(fun, address, &handle); - - if (rc == EOK) { - async_answer_1(callid, EOK, handle); + const int ret = usb_iface->get_handle(fun, address, &handle); + + if (ret == EOK) { + async_answer_1(callid, ret, handle); } else { - async_answer_0(callid, rc); - } -} - + async_answer_0(callid, ret); + } +} +/*----------------------------------------------------------------------------*/ void remote_usbhc_release_address(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) { - usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + const usbhc_iface_t *usb_iface = iface; if (!usb_iface->release_address) { @@ -179,12 +457,10 @@ } - usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); - - int rc = usb_iface->release_address(fun, address); - - async_answer_0(callid, rc); -} - - + const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + + const int ret = usb_iface->release_address(fun, address); + async_answer_0(callid, ret); +} +/*----------------------------------------------------------------------------*/ static void callback_out(ddf_fun_t *fun, int outcome, void *arg) Index: uspace/lib/drv/include/usbhc_iface.h =================================================================== --- uspace/lib/drv/include/usbhc_iface.h (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/drv/include/usbhc_iface.h (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -42,122 +42,16 @@ #include - -/** IPC methods for communication with HC through DDF interface. - * - * Notes for async methods: - * - * Methods for sending data to device (OUT transactions) - * - e.g. IPC_M_USBHC_INTERRUPT_OUT - - * always use the same semantics: - * - first, IPC call with given method is made - * - argument #1 is target address - * - argument #2 is target endpoint - * - argument #3 is max packet size of the endpoint - * - this call is immediately followed by IPC data write (from caller) - * - the initial call (and the whole transaction) is answer after the - * transaction is scheduled by the HC and acknowledged by the device - * or immediately after error is detected - * - the answer carries only the error code - * - * Methods for retrieving data from device (IN transactions) - * - e.g. IPC_M_USBHC_INTERRUPT_IN - - * also use the same semantics: - * - first, IPC call with given method is made - * - argument #1 is target address - * - argument #2 is target endpoint - * - this call is immediately followed by IPC data read (async version) - * - the call is not answered until the device returns some data (or until - * error occurs) - * - * Some special methods (NO-DATA transactions) do not send any data. These - * might behave as both OUT or IN transactions because communication parts - * where actual buffers are exchanged are omitted. - ** - * For all these methods, wrap functions exists. Important rule: functions - * for IN transactions have (as parameters) buffers where retrieved data - * will be stored. These buffers must be already allocated and shall not be - * touch until the transaction is completed - * (e.g. not before calling usb_wait_for() with appropriate handle). - * OUT transactions buffers can be freed immediately after call is dispatched - * (i.e. after return from wrapping function). - * - */ -typedef enum { - /** Asks for address assignment by host controller. - * Answer: - * - ELIMIT - host controller run out of address - * - EOK - address assigned - * Answer arguments: - * - assigned address - * - * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS. - */ - IPC_M_USBHC_REQUEST_ADDRESS, - - /** Bind USB address with devman handle. - * Parameters: - * - USB address - * - devman handle - * Answer: - * - EOK - address binded - * - ENOENT - address is not in use - */ - IPC_M_USBHC_BIND_ADDRESS, - - /** Get handle binded with given USB address. - * Parameters - * - USB address - * Answer: - * - EOK - address binded, first parameter is the devman handle - * - ENOENT - address is not in use at the moment - */ - IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, - - /** Release address in use. - * Arguments: - * - address to be released - * Answer: - * - ENOENT - address not in use - * - EPERM - trying to release default USB address - */ - IPC_M_USBHC_RELEASE_ADDRESS, - - /** Register endpoint attributes at host controller. - * This is used to reserve portion of USB bandwidth. - * When speed is invalid, speed of the device is used. - * Parameters: - * - USB address + endpoint number - * - packed as ADDR << 16 + EP - * - speed + transfer type + direction - * - packed as ( SPEED << 8 + TYPE ) << 8 + DIR - * - maximum packet size + interval (in milliseconds) - * - packed as MPS << 16 + INT - * Answer: - * - EOK - reservation successful - * - ELIMIT - not enough bandwidth to satisfy the request - */ - IPC_M_USBHC_REGISTER_ENDPOINT, - - /** Revert endpoint registration. - * Parameters: - * - USB address - * - endpoint number - * - data direction - * Answer: - * - EOK - endpoint unregistered - * - ENOENT - unknown endpoint - */ - IPC_M_USBHC_UNREGISTER_ENDPOINT, - - /** Get data from device. - * See explanation at usb_iface_funcs_t (IN transaction). - */ - IPC_M_USBHC_READ, - - /** Send data to device. - * See explanation at usb_iface_funcs_t (OUT transaction). - */ - IPC_M_USBHC_WRITE, -} usbhc_iface_funcs_t; +int usbhc_request_address(async_exch_t *, usb_address_t *, bool, usb_speed_t); +int usbhc_bind_address(async_exch_t *, usb_address_t, devman_handle_t); +int usbhc_get_handle(async_exch_t *, usb_address_t, devman_handle_t *); +int usbhc_release_address(async_exch_t *, usb_address_t); +int usbhc_register_endpoint(async_exch_t *, usb_address_t, usb_endpoint_t, + usb_transfer_type_t, usb_direction_t, size_t, unsigned int); +int usbhc_unregister_endpoint(async_exch_t *, usb_address_t, usb_endpoint_t, + usb_direction_t); +int usbhc_read(async_exch_t *, usb_address_t, usb_endpoint_t, + uint64_t, void *, size_t, size_t *); +int usbhc_write(async_exch_t *, usb_address_t, usb_endpoint_t, + uint64_t, const void *, size_t); /** Callback for outgoing transfer. */ @@ -172,5 +66,6 @@ int (*request_address)(ddf_fun_t *, usb_address_t *, bool, usb_speed_t); int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t); - int (*find_by_address)(ddf_fun_t *, usb_address_t, devman_handle_t *); + int (*get_handle)(ddf_fun_t *, usb_address_t, + devman_handle_t *); int (*release_address)(ddf_fun_t *, usb_address_t); Index: uspace/lib/usb/src/hc.c =================================================================== --- uspace/lib/usb/src/hc.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/usb/src/hc.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -153,18 +153,11 @@ if (!usb_hc_connection_is_opened(connection)) return ENOENT; - + async_exch_t *exch = async_exchange_begin(connection->hc_sess); - - sysarg_t tmp; - int rc = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, - address, &tmp); - + if (!exch) + return ENOMEM; + const int ret = usbhc_get_handle(exch, address, handle); async_exchange_end(exch); - - if ((rc == EOK) && (handle != NULL)) - *handle = tmp; - - return rc; + return ret; } Index: uspace/lib/usbdev/src/hub.c =================================================================== --- uspace/lib/usbdev/src/hub.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/usbdev/src/hub.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -76,17 +76,14 @@ { CHECK_CONNECTION(connection); - + async_exch_t *exch = async_exchange_begin(connection->hc_sess); - - sysarg_t address; - int rc = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_REQUEST_ADDRESS, preferred, strict, speed, &address); - + if (!exch) + return (usb_address_t)ENOMEM; + + usb_address_t address = preferred; + const int ret = usbhc_request_address(exch, &address, strict, speed); + async_exchange_end(exch); - - if (rc != EOK) - return (usb_address_t) rc; - - return (usb_address_t) address; + return ret == EOK ? address : ret; } @@ -97,19 +94,19 @@ * @return Error code. */ -int usb_hc_register_device(usb_hc_connection_t * connection, +int usb_hc_register_device(usb_hc_connection_t *connection, const usb_hub_attached_device_t *attached_device) { CHECK_CONNECTION(connection); - - if (attached_device == NULL) - return EBADMEM; - + if (attached_device == NULL || attached_device->fun == NULL) + return EINVAL; + async_exch_t *exch = async_exchange_begin(connection->hc_sess); - int rc = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_BIND_ADDRESS, + if (!exch) + return ENOMEM; + const int ret = usbhc_bind_address(exch, attached_device->address, attached_device->fun->handle); async_exchange_end(exch); - - return rc; + + return ret; } @@ -124,11 +121,12 @@ { CHECK_CONNECTION(connection); - + async_exch_t *exch = async_exchange_begin(connection->hc_sess); - int rc = async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_RELEASE_ADDRESS, address); + if (!exch) + return ENOMEM; + const int ret = usbhc_release_address(exch, address); async_exchange_end(exch); - - return rc; + + return ret; } Index: uspace/lib/usbdev/src/pipesinit.c =================================================================== --- uspace/lib/usbdev/src/pipesinit.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/usbdev/src/pipesinit.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -405,9 +405,4 @@ } -#define TRY_LOOP(attempt_var) \ - for (attempt_var = 0; attempt_var < 3; attempt_var++) - - size_t failed_attempts; - int rc; usb_pipe_start_long_transfer(pipe); @@ -415,5 +410,6 @@ uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE]; size_t transferred_size; - TRY_LOOP(failed_attempts) { + int rc; + for (size_t attempt_var = 0; attempt_var < 3; ++attempt_var) { rc = usb_request_get_descriptor(pipe, USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, USB_DESCTYPE_DEVICE, @@ -450,22 +446,18 @@ { assert(pipe); + assert(pipe->wire); assert(hc_connection); if (!usb_hc_connection_is_opened(hc_connection)) return EBADF; - - const usb_target_t target = - {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }}; -#define _PACK2(high, low) (((high & 0xffff) << 16) | (low & 0xffff)) - async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess); - int rc = async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_REGISTER_ENDPOINT, target.packed, - _PACK2(pipe->transfer_type, pipe->direction), - _PACK2(pipe->max_packet_size, interval)); + if (!exch) + return ENOMEM; + const int ret = usbhc_register_endpoint(exch, + pipe->wire->address, pipe->endpoint_no, pipe->transfer_type, + pipe->direction, pipe->max_packet_size, interval); + async_exchange_end(exch); - -#undef _PACK2 - return rc; + return ret; } @@ -482,15 +474,16 @@ assert(pipe->wire); assert(hc_connection); - + if (!usb_hc_connection_is_opened(hc_connection)) return EBADF; - + async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess); - int rc = async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_UNREGISTER_ENDPOINT, + if (!exch) + return ENOMEM; + const int ret = usbhc_unregister_endpoint(exch, pipe->wire->address, pipe->endpoint_no, pipe->direction); async_exchange_end(exch); - - return rc; + + return ret; } Index: uspace/lib/usbdev/src/pipesio.c =================================================================== --- uspace/lib/usbdev/src/pipesio.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/usbdev/src/pipesio.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -70,69 +70,17 @@ return ENOTSUP; - const usb_target_t target = - {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }}; - /* Ensure serialization over the phone. */ pipe_start_transaction(pipe); async_exch_t *exch = async_exchange_begin(pipe->hc_sess); - - /* - * Make call identifying target USB device and type of transfer. - */ - aid_t opening_request = async_send_2(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_READ, target.packed, NULL); - - if (opening_request == 0) { - async_exchange_end(exch); + if (!exch) { pipe_end_transaction(pipe); return ENOMEM; } - - /* - * Retrieve the data. - */ - ipc_call_t data_request_call; - aid_t data_request = async_data_read(exch, buffer, size, - &data_request_call); - - /* - * Since now on, someone else might access the backing phone - * without breaking the transfer IPC protocol. - */ + + const int ret = usbhc_read(exch, pipe->wire->address, pipe->endpoint_no, + 0, buffer, size, size_transfered); async_exchange_end(exch); pipe_end_transaction(pipe); - - if (data_request == 0) { - /* - * FIXME: - * How to let the other side know that we want to abort? - */ - async_wait_for(opening_request, NULL); - return ENOMEM; - } - - /* - * Wait for the answer. - */ - sysarg_t data_request_rc; - sysarg_t opening_request_rc; - async_wait_for(data_request, &data_request_rc); - async_wait_for(opening_request, &opening_request_rc); - - if (data_request_rc != EOK) { - /* Prefer the return code of the opening request. */ - if (opening_request_rc != EOK) { - return (int) opening_request_rc; - } else { - return (int) data_request_rc; - } - } - if (opening_request_rc != EOK) { - return (int) opening_request_rc; - } - - *size_transfered = IPC_GET_ARG2(data_request_call); - - return EOK; + return ret; } @@ -209,47 +157,17 @@ return ENOTSUP; - const usb_target_t target = - {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }}; - /* Ensure serialization over the phone. */ pipe_start_transaction(pipe); async_exch_t *exch = async_exchange_begin(pipe->hc_sess); - - /* - * Make call identifying target USB device and type of transfer. - */ - aid_t opening_request = async_send_3(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_WRITE, target.packed, size, NULL); - - if (opening_request == 0) { - async_exchange_end(exch); + if (!exch) { pipe_end_transaction(pipe); return ENOMEM; } - - /* - * Send the data. - */ - int rc = async_data_write_start(exch, buffer, size); - - /* - * Since now on, someone else might access the backing phone - * without breaking the transfer IPC protocol. - */ + const int ret = + usbhc_write(exch, pipe->wire->address, pipe->endpoint_no, + 0, buffer, size); async_exchange_end(exch); pipe_end_transaction(pipe); - - if (rc != EOK) { - async_wait_for(opening_request, NULL); - return rc; - } - - /* - * Wait for the answer. - */ - sysarg_t opening_request_rc; - async_wait_for(opening_request, &opening_request_rc); - - return (int) opening_request_rc; + return ret; } @@ -334,65 +252,19 @@ pipe_start_transaction(pipe); - const usb_target_t target = - {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }}; - assert(setup_buffer_size == 8); uint64_t setup_packet; memcpy(&setup_packet, setup_buffer, 8); - /* - * Make call identifying target USB device and control transfer type. - */ + async_exch_t *exch = async_exchange_begin(pipe->hc_sess); - aid_t opening_request = async_send_4(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_READ, target.packed, - (setup_packet & UINT32_MAX), (setup_packet >> 32), NULL); - - if (opening_request == 0) { - async_exchange_end(exch); + if (!exch) { + pipe_end_transaction(pipe); return ENOMEM; } - /* - * Retrieve the data. - */ - ipc_call_t data_request_call; - aid_t data_request = async_data_read(exch, data_buffer, - data_buffer_size, &data_request_call); - - /* - * Since now on, someone else might access the backing phone - * without breaking the transfer IPC protocol. - */ + const int ret = usbhc_read(exch, pipe->wire->address, pipe->endpoint_no, + setup_packet, data_buffer, data_buffer_size, data_transfered_size); async_exchange_end(exch); pipe_end_transaction(pipe); - - if (data_request == 0) { - async_wait_for(opening_request, NULL); - return ENOMEM; - } - - /* - * Wait for the answer. - */ - sysarg_t data_request_rc; - sysarg_t opening_request_rc; - async_wait_for(data_request, &data_request_rc); - async_wait_for(opening_request, &opening_request_rc); - - if (data_request_rc != EOK) { - /* Prefer the return code of the opening request. */ - if (opening_request_rc != EOK) { - return (int) opening_request_rc; - } else { - return (int) data_request_rc; - } - } - if (opening_request_rc != EOK) { - return (int) opening_request_rc; - } - - *data_transfered_size = IPC_GET_ARG2(data_request_call); - - return EOK; + return ret; } @@ -475,51 +347,20 @@ pipe_start_transaction(pipe); - const usb_target_t target = - {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }}; assert(setup_buffer_size == 8); uint64_t setup_packet; memcpy(&setup_packet, setup_buffer, 8); - /* - * Make call identifying target USB device and control transfer type. - */ + /* Make call identifying target USB device and control transfer type. */ async_exch_t *exch = async_exchange_begin(pipe->hc_sess); - aid_t opening_request = async_send_5(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), - IPC_M_USBHC_WRITE, target.packed, data_buffer_size, - (setup_packet & UINT32_MAX), (setup_packet >> 32), NULL); - - if (opening_request == 0) { - async_exchange_end(exch); + if (!exch) { pipe_end_transaction(pipe); return ENOMEM; } - - /* - * Send the data (if any). - */ - if (data_buffer_size > 0) { - int rc = async_data_write_start(exch, data_buffer, data_buffer_size); - - /* All data sent, pipe can be released. */ - async_exchange_end(exch); - pipe_end_transaction(pipe); - - if (rc != EOK) { - async_wait_for(opening_request, NULL); - return rc; - } - } else { - /* No data to send, we can release the pipe for others. */ - async_exchange_end(exch); - pipe_end_transaction(pipe); - } - - /* - * Wait for the answer. - */ - sysarg_t opening_request_rc; - async_wait_for(opening_request, &opening_request_rc); - - return (int) opening_request_rc; + const int ret = + usbhc_write(exch, pipe->wire->address, pipe->endpoint_no, + setup_packet, data_buffer, data_buffer_size); + async_exchange_end(exch); + pipe_end_transaction(pipe); + return ret; } Index: uspace/lib/usbhost/src/iface.c =================================================================== --- uspace/lib/usbhost/src/iface.c (revision 56bdd9a4306c6d99a59c72a07fe62501b10576c1) +++ uspace/lib/usbhost/src/iface.c (revision 02fc5c403d52648f5ee6dcf5158ad19197c73795) @@ -252,5 +252,5 @@ .request_address = request_address, .bind_address = bind_address, - .find_by_address = find_by_address, + .get_handle = find_by_address, .release_address = release_address,