Index: uspace/lib/usb/include/usb/hc.h =================================================================== --- uspace/lib/usb/include/usb/hc.h (revision 266976f9f0c0fc2a4e8fb9b481130c14c0d1b4f9) +++ uspace/lib/usb/include/usb/hc.h (revision 6df14c51d616cbf1e61302a8b1257b88cbe815a5) @@ -42,4 +42,5 @@ #include #include +#include #include @@ -50,19 +51,70 @@ /** Session to the host controller. */ async_sess_t *hc_sess; + /** Session guard. */ + fibril_mutex_t guard; + /** Use counter. */ + unsigned ref_count; } usb_hc_connection_t; + +/** Initialize connection to USB host controller. + * + * @param connection Connection to be initialized. + * @param hc_handle Devman handle of the host controller. + * @return Error code. + */ +static inline void usb_hc_connection_initialize(usb_hc_connection_t *connection, + devman_handle_t hc_handle) +{ + assert(connection); + connection->hc_handle = hc_handle; + connection->hc_sess = NULL; + connection->ref_count = 0; + fibril_mutex_initialize(&connection->guard); + +} int usb_hc_connection_initialize_from_device(usb_hc_connection_t *, const ddf_dev_t *); -int usb_hc_connection_initialize(usb_hc_connection_t *, devman_handle_t); int usb_hc_connection_open(usb_hc_connection_t *); -bool usb_hc_connection_is_opened(const usb_hc_connection_t *); +bool usb_hc_connection_is_open(const usb_hc_connection_t *); int usb_hc_connection_close(usb_hc_connection_t *); + +usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_address_t, bool, + usb_speed_t); +int usb_hc_bind_address(usb_hc_connection_t *, usb_address_t, devman_handle_t); int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t, devman_handle_t *); +int usb_hc_release_address(usb_hc_connection_t *, usb_address_t); + +int usb_hc_register_endpoint(usb_hc_connection_t *, usb_address_t, + usb_endpoint_t, usb_transfer_type_t, usb_direction_t, size_t, unsigned int); +int usb_hc_unregister_endpoint(usb_hc_connection_t *, usb_address_t, + usb_endpoint_t, usb_direction_t); + +int usb_hc_control_read(usb_hc_connection_t *, usb_address_t, usb_endpoint_t, + uint64_t, void *, size_t, size_t *); +int usb_hc_control_write(usb_hc_connection_t *, usb_address_t, usb_endpoint_t, + uint64_t, const void *, size_t); + +static inline int usb_hc_read(usb_hc_connection_t *connection, + usb_address_t address, usb_endpoint_t endpoint, void *data, size_t size, + size_t *real_size) +{ + return usb_hc_control_read( + connection, address, endpoint, 0, data, size, real_size); +} + +static inline int usb_hc_write(usb_hc_connection_t *connection, + usb_address_t address, usb_endpoint_t endpoint, const void *data, + size_t size) +{ + return usb_hc_control_write( + connection, address, endpoint, 0, data, size); +} usb_address_t usb_get_address_by_handle(devman_handle_t); -int usb_hc_find(devman_handle_t, devman_handle_t *); +int usb_find_hc(devman_handle_t, devman_handle_t *); int usb_resolve_device_handle(const char *, devman_handle_t *, usb_address_t *, @@ -71,5 +123,4 @@ int usb_ddf_get_hc_handle_by_sid(service_id_t, devman_handle_t *); - #endif /** Index: uspace/lib/usb/src/ddfiface.c =================================================================== --- uspace/lib/usb/src/ddfiface.c (revision 266976f9f0c0fc2a4e8fb9b481130c14c0d1b4f9) +++ uspace/lib/usb/src/ddfiface.c (revision 6df14c51d616cbf1e61302a8b1257b88cbe815a5) @@ -66,5 +66,5 @@ { assert(fun); - return usb_hc_find(fun->handle, handle); + return usb_find_hc(fun->handle, handle); } Index: uspace/lib/usb/src/hc.c =================================================================== --- uspace/lib/usb/src/hc.c (revision 266976f9f0c0fc2a4e8fb9b481130c14c0d1b4f9) +++ uspace/lib/usb/src/hc.c (revision 6df14c51d616cbf1e61302a8b1257b88cbe815a5) @@ -1,4 +1,5 @@ /* * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -43,4 +44,58 @@ #include +static int usb_hc_connection_add_ref(usb_hc_connection_t *connection) +{ + assert(connection); + fibril_mutex_lock(&connection->guard); + if (connection->ref_count == 0) { + assert(connection->hc_sess == NULL); + /* Parallel exchange for us */ + connection->hc_sess = devman_device_connect(EXCHANGE_PARALLEL, + connection->hc_handle, 0); + if (!connection->hc_sess) { + fibril_mutex_unlock(&connection->guard); + return ENOMEM; + } + } + ++connection->ref_count; + fibril_mutex_unlock(&connection->guard); + return EOK; +} +/*----------------------------------------------------------------------------*/ +static int usb_hc_connection_del_ref(usb_hc_connection_t *connection) +{ + assert(connection); + fibril_mutex_lock(&connection->guard); + --connection->ref_count; + int ret = EOK; + if (connection->ref_count == 0) { + assert(connection->hc_sess); + ret = async_hangup(connection->hc_sess); + } + fibril_mutex_unlock(&connection->guard); + return ret; +} + +#define EXCH_INIT(connection, exch) \ +do { \ + exch = NULL; \ + if (!connection) \ + return EBADMEM; \ + const int ret = usb_hc_connection_add_ref(connection); \ + if (ret != EOK) \ + return ret; \ + exch = async_exchange_begin(connection->hc_sess); \ + if (exch == NULL) { \ + usb_hc_connection_del_ref(connection); \ + return ENOMEM; \ + } \ +} while (0) + +#define EXCH_FINI(connection, exch) \ +if (exch) { \ + async_exchange_end(exch); \ + usb_hc_connection_del_ref(connection); \ +} else (void)0 + /** Initialize connection to USB host controller. * @@ -59,31 +114,12 @@ devman_handle_t hc_handle; - int rc = usb_hc_find(device->handle, &hc_handle); - if (rc != EOK) { - return rc; - } - - rc = usb_hc_connection_initialize(connection, hc_handle); + const int rc = usb_find_hc(device->handle, &hc_handle); + if (rc == EOK) { + usb_hc_connection_initialize(connection, hc_handle); + } return rc; } - -/** Manually initialize connection to USB host controller. - * - * @param connection Connection to be initialized. - * @param hc_handle Devman handle of the host controller. - * @return Error code. - */ -int usb_hc_connection_initialize(usb_hc_connection_t *connection, - devman_handle_t hc_handle) -{ - assert(connection); - - connection->hc_handle = hc_handle; - connection->hc_sess = NULL; - - return EOK; -} - +/*----------------------------------------------------------------------------*/ /** Open connection to host controller. * @@ -93,18 +129,7 @@ int usb_hc_connection_open(usb_hc_connection_t *connection) { - assert(connection); - - if (usb_hc_connection_is_opened(connection)) - return EBUSY; - - async_sess_t *sess = devman_device_connect(EXCHANGE_ATOMIC, - connection->hc_handle, 0); - if (!sess) - return ENOMEM; - - connection->hc_sess = sess; - return EOK; -} - + return usb_hc_connection_add_ref(connection); +} +/*----------------------------------------------------------------------------*/ /** Tells whether connection to host controller is opened. * @@ -112,10 +137,10 @@ * @return Whether connection is opened. */ -bool usb_hc_connection_is_opened(const usb_hc_connection_t *connection) +bool usb_hc_connection_is_open(const usb_hc_connection_t *connection) { assert(connection); return (connection->hc_sess != NULL); } - +/*----------------------------------------------------------------------------*/ /** Close connection to the host controller. * @@ -125,20 +150,41 @@ int usb_hc_connection_close(usb_hc_connection_t *connection) { - assert(connection); - - if (!usb_hc_connection_is_opened(connection)) { - return ENOENT; - } - - int rc = async_hangup(connection->hc_sess); - if (rc != EOK) { - return rc; - } - - connection->hc_sess = NULL; - - return EOK; -} - + return usb_hc_connection_del_ref(connection); +} +/*----------------------------------------------------------------------------*/ +/** Ask host controller for free address assignment. + * + * @param connection Opened connection to host controller. + * @param preferred Preferred SUB address. + * @param strict Fail if the preferred address is not avialable. + * @param speed Speed of the new device (device that will be assigned + * the returned address). + * @return Assigned USB address or negative error code. + */ +usb_address_t usb_hc_request_address(usb_hc_connection_t *connection, + usb_address_t preferred, bool strict, usb_speed_t speed) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + usb_address_t address = preferred; + const int ret = usbhc_request_address(exch, &address, strict, speed); + + EXCH_FINI(connection, exch); + return ret == EOK ? address : ret; +} +/*----------------------------------------------------------------------------*/ +int usb_hc_bind_address(usb_hc_connection_t * connection, + usb_address_t address, devman_handle_t handle) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + const int ret = usbhc_bind_address(exch, address, handle); + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ /** Get handle of USB device with given address. * @@ -151,15 +197,96 @@ usb_address_t address, devman_handle_t *handle) { - if (!usb_hc_connection_is_opened(connection)) - return ENOENT; - - async_exch_t *exch = async_exchange_begin(connection->hc_sess); - if (!exch) - return ENOMEM; + async_exch_t *exch; + EXCH_INIT(connection, exch); + const int ret = usbhc_get_handle(exch, address, handle); - async_exchange_end(exch); - return ret; -} - + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ +int usb_hc_release_address(usb_hc_connection_t *connection, + usb_address_t address) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + const int ret = usbhc_release_address(exch, address); + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ +int usb_hc_register_endpoint(usb_hc_connection_t *connection, + usb_address_t address, usb_endpoint_t endpoint, usb_transfer_type_t type, + usb_direction_t direction, size_t packet_size, unsigned interval) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + const int ret = usbhc_register_endpoint(exch, address, endpoint, + type, direction, packet_size, interval); + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ +int usb_hc_unregister_endpoint(usb_hc_connection_t *connection, + usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + const int ret = + usbhc_unregister_endpoint(exch, address, endpoint, direction); + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ +int usb_hc_control_read(usb_hc_connection_t *connection, usb_address_t address, + usb_endpoint_t endpoint, uint64_t setup, void *data, size_t size, + size_t *real_size) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + const int ret = + usbhc_read(exch, address, endpoint, setup, data, size, real_size); + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ +int usb_hc_control_write(usb_hc_connection_t *connection, usb_address_t address, + usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size) +{ + async_exch_t *exch; + EXCH_INIT(connection, exch); + + const int ret = usbhc_write(exch, address, endpoint, setup, data, size); + + EXCH_FINI(connection, exch); + return ret; +} +/*----------------------------------------------------------------------------*/ +/** Get host controller handle by its class index. + * + * @param sid Service ID of the HC function. + * @param hc_handle Where to store the HC handle + * (can be NULL for existence test only). + * @return Error code. + */ +int usb_ddf_get_hc_handle_by_sid(service_id_t sid, devman_handle_t *hc_handle) +{ + devman_handle_t handle; + + const int ret = devman_fun_sid_to_handle(sid, &handle); + if (ret == EOK && hc_handle != NULL) + *hc_handle = handle; + + return ret; +} +/*----------------------------------------------------------------------------*/ /** Tell USB address assigned to device with given handle. * @@ -192,25 +319,5 @@ } - -/** Get host controller handle by its class index. - * - * @param sid Service ID of the HC function. - * @param hc_handle Where to store the HC handle - * (can be NULL for existence test only). - * @return Error code. - */ -int usb_ddf_get_hc_handle_by_sid(service_id_t sid, devman_handle_t *hc_handle) -{ - devman_handle_t handle; - int rc; - - rc = devman_fun_sid_to_handle(sid, &handle); - if (hc_handle != NULL) - *hc_handle = handle; - - return rc; -} - -/** Find host controller handle that is ancestor of given device. +/** Find host controller handle for the device. * * @param[in] device_handle Device devman handle. @@ -219,5 +326,5 @@ * @return Error code. */ -int usb_hc_find(devman_handle_t device_handle, devman_handle_t *hc_handle) +int usb_find_hc(devman_handle_t device_handle, devman_handle_t *hc_handle) { async_sess_t *parent_sess = Index: uspace/lib/usb/src/resolve.c =================================================================== --- uspace/lib/usb/src/resolve.c (revision 266976f9f0c0fc2a4e8fb9b481130c14c0d1b4f9) +++ uspace/lib/usb/src/resolve.c (revision 6df14c51d616cbf1e61302a8b1257b88cbe815a5) @@ -192,5 +192,5 @@ /* Try to find its host controller. */ if (!found_hc) { - rc = usb_hc_find(tmp_handle, &hc_handle); + rc = usb_find_hc(tmp_handle, &hc_handle); if (rc == EOK) { found_hc = true;