Index: uspace/lib/drv/include/usbhc_iface.h =================================================================== --- uspace/lib/drv/include/usbhc_iface.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/drv/include/usbhc_iface.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -1,4 +1,5 @@ /* * Copyright (c) 2010 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -26,5 +27,4 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libdrv * @addtogroup usb @@ -46,5 +46,5 @@ 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, +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, Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/Makefile (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -37,8 +37,8 @@ src/class.c \ src/ddfiface.c \ + src/dev.c \ src/debug.c \ src/dump.c \ src/hc.c \ - src/resolve.c \ src/usb.c Index: uspace/lib/usb/include/usb/classes/hub.h =================================================================== --- uspace/lib/usb/include/usb/classes/hub.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/include/usb/classes/hub.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -84,7 +84,8 @@ /** - * @brief usb hub descriptor - * - * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + * @brief usb hub descriptor + * + * For more information see Universal Serial Bus Specification Revision 1.1 + * chapter 11.16.2 */ typedef struct usb_hub_descriptor_type { Index: uspace/lib/usb/include/usb/dev.h =================================================================== --- uspace/lib/usb/include/usb/dev.h (revision 2943db4eacf000472ce550d084e8e01062821b25) +++ uspace/lib/usb/include/usb/dev.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusb + * @{ + */ +/** @file + * Common USB types and functions. + */ +#ifndef LIBUSB_DEV_H_ +#define LIBUSB_DEV_H_ + +#include +#include + +int usb_get_info_by_handle(devman_handle_t, + devman_handle_t *, usb_address_t *, int *); + +static inline int usb_get_hc_by_handle(devman_handle_t dev, devman_handle_t *hc) +{ + return usb_get_info_by_handle(dev, hc, NULL, NULL); +} + +static inline int usb_get_address_by_handle( + devman_handle_t dev, usb_address_t *address) +{ + return usb_get_info_by_handle(dev, NULL, address, NULL); +} + +static inline int usb_get_iface_by_handle(devman_handle_t dev, int *iface) +{ + return usb_get_info_by_handle(dev, NULL, NULL, iface); +} + +int usb_resolve_device_handle(const char *, devman_handle_t *, usb_address_t *, + devman_handle_t *); +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/hc.h =================================================================== --- uspace/lib/usb/include/usb/hc.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/include/usb/hc.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -1,4 +1,5 @@ /* * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -26,23 +27,27 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusb * @{ */ /** @file - * General communication with host controller driver. + * General communication with host controller. */ #ifndef LIBUSB_HC_H_ #define LIBUSB_HC_H_ -#include -#include -#include +#include +#include #include #include -#include +#include #include -/** Connection to the host controller driver. */ +/** Connection to the host controller driver. + * + * This is a high level IPC communication wrapper. After the structure has been + * initialized using devman handle of an USB host controller, it + * will manage all communication to that host controller, including session + * creation/destruction and proper IPC protocol. + */ typedef struct { /** Devman handle of the host controller. */ @@ -50,25 +55,64 @@ /** 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); + +void usb_hc_connection_deinitialize(usb_hc_connection_t *); int usb_hc_connection_open(usb_hc_connection_t *); -bool usb_hc_connection_is_opened(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); -usb_address_t usb_get_address_by_handle(devman_handle_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_find(devman_handle_t, devman_handle_t *); +int usb_hc_read(usb_hc_connection_t *, usb_address_t, usb_endpoint_t, + uint64_t, void *, size_t, size_t *); +int usb_hc_write(usb_hc_connection_t *, usb_address_t, usb_endpoint_t, + uint64_t, const void *, size_t); -int usb_resolve_device_handle(const char *, devman_handle_t *, usb_address_t *, - devman_handle_t *); - -int usb_ddf_get_hc_handle_by_sid(service_id_t, devman_handle_t *); - +/** 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. + */ +static inline int usb_ddf_get_hc_handle_by_sid( + service_id_t sid, devman_handle_t *handle) +{ + devman_handle_t h; + return devman_fun_sid_to_handle(sid, handle ? handle : &h); +} #endif Index: uspace/lib/usb/include/usb/usb.h =================================================================== --- uspace/lib/usb/include/usb/usb.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/include/usb/usb.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -26,5 +26,4 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusb * @{ Index: uspace/lib/usb/src/ddfiface.c =================================================================== --- uspace/lib/usb/src/ddfiface.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/src/ddfiface.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -44,4 +44,6 @@ #include +#include + /** DDF interface for USB device, implementation for typical hub. */ usb_iface_t usb_iface_hub_impl = { @@ -66,5 +68,5 @@ { assert(fun); - return usb_hc_find(fun->handle, handle); + return usb_get_hc_by_handle(fun->handle, handle); } @@ -97,23 +99,5 @@ { assert(fun); - - async_sess_t *parent_sess = - devman_parent_device_connect(EXCHANGE_SERIALIZE, fun->handle, - IPC_FLAG_BLOCKING); - if (!parent_sess) - return ENOMEM; - - async_exch_t *exch = async_exchange_begin(parent_sess); - if (!exch) { - async_hangup(parent_sess); - return ENOMEM; - } - - const int ret = usb_get_my_address(exch, address); - - async_exchange_end(exch); - async_hangup(parent_sess); - - return ret; + return usb_get_address_by_handle(fun->handle, address); } @@ -134,5 +118,5 @@ assert(fun); assert(fun->driver_data); - usb_hub_attached_device_t *device = fun->driver_data; + const usb_hub_attached_device_t *device = fun->driver_data; assert(device->fun == fun); if (address) Index: uspace/lib/usb/src/dev.c =================================================================== --- uspace/lib/usb/src/dev.c (revision 2943db4eacf000472ce550d084e8e01062821b25) +++ uspace/lib/usb/src/dev.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -0,0 +1,301 @@ +/* + * Copyright (c) 2011 Jan Vesely + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include + +#define MAX_DEVICE_PATH 1024 + +/** Find host controller handle, address and iface number for the device. + * + * @param[in] device_handle Device devman handle. + * @param[out] hc_handle Where to store handle of host controller + * controlling device with @p device_handle handle. + * @param[out] address Place to store the device's address + * @param[out] iface Place to stoer the assigned USB interface number. + * @return Error code. + */ +int usb_get_info_by_handle(devman_handle_t device_handle, + devman_handle_t *hc_handle, usb_address_t *address, int *iface) +{ + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_ATOMIC, device_handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return ENOMEM; + + async_exch_t *exch = async_exchange_begin(parent_sess); + if (!exch) { + async_hangup(parent_sess); + return ENOMEM; + } + + usb_address_t tmp_address; + devman_handle_t tmp_handle; + int tmp_iface; + + if (address) { + const int ret = usb_get_my_address(exch, &tmp_address); + if (ret != EOK) { + async_exchange_end(exch); + async_hangup(parent_sess); + return ret; + } + } + + if (hc_handle) { + const int ret = usb_get_hc_handle(exch, &tmp_handle); + if (ret != EOK) { + async_exchange_end(exch); + async_hangup(parent_sess); + return ret; + } + } + + if (iface) { + const int ret = usb_get_my_interface(exch, &tmp_iface); + switch (ret) { + case ENOTSUP: + /* Implementing GET_MY_INTERFACE is voluntary. */ + tmp_iface = -1; + case EOK: + break; + default: + async_exchange_end(exch); + async_hangup(parent_sess); + return ret; + } + } + + if (hc_handle) + *hc_handle = tmp_handle; + + if (address) + *address = tmp_address; + + if (iface) + *iface = tmp_iface; + + async_exchange_end(exch); + async_hangup(parent_sess); + + return EOK; +} + +static bool try_parse_bus_and_address(const char *path, + char **func_start, + devman_handle_t *out_hc_handle, usb_address_t *out_device_address) +{ + uint64_t sid; + size_t address; + int rc; + char *ptr; + + rc = str_uint64(path, &ptr, 10, false, &sid); + if (rc != EOK) { + return false; + } + if ((*ptr == ':') || (*ptr == '.')) { + ptr++; + } else { + return false; + } + rc = str_size_t(ptr, func_start, 10, false, &address); + if (rc != EOK) { + return false; + } + rc = usb_ddf_get_hc_handle_by_sid(sid, out_hc_handle); + if (rc != EOK) { + return false; + } + if (out_device_address != NULL) { + *out_device_address = (usb_address_t) address; + } + return true; +} + +static int get_device_handle_by_address(devman_handle_t hc_handle, int addr, + devman_handle_t *dev_handle) +{ + usb_hc_connection_t conn; + usb_hc_connection_initialize(&conn, hc_handle); + + const int rc = usb_hc_get_handle_by_address(&conn, addr, dev_handle); + + return rc; +} + +/** Resolve handle and address of USB device from its path. + * + * This is a wrapper working on best effort principle. + * If the resolving fails, if will not give much details about what + * is wrong. + * Typically, error from this function would be reported to the user + * as "bad device specification" or "device does not exist". + * + * The path can be specified in following format: + * - devman path (e.g. /hw/pci0/.../usb01_a5 + * - bus number and device address (e.g. 5.1) + * - bus number, device address and device function (e.g. 2.1/HID0/keyboard) + * + * @param[in] dev_path Path to the device. + * @param[out] out_hc_handle Where to store handle of a parent host controller. + * @param[out] out_dev_addr Where to store device (USB) address. + * @param[out] out_dev_handle Where to store device handle. + * @return Error code. + */ +int usb_resolve_device_handle(const char *dev_path, devman_handle_t *out_hc_handle, + usb_address_t *out_dev_addr, devman_handle_t *out_dev_handle) +{ + if (dev_path == NULL) { + return EBADMEM; + } + + bool found_hc = false; + bool found_addr = false; + devman_handle_t hc_handle, dev_handle; + usb_address_t dev_addr = -1; + int rc; + bool is_bus_addr; + char *func_start = NULL; + char *path = NULL; + + /* First try the BUS.ADDR format. */ + is_bus_addr = try_parse_bus_and_address(dev_path, &func_start, + &hc_handle, &dev_addr); + if (is_bus_addr) { + found_hc = true; + found_addr = true; + /* + * Now get the handle of the device. We will need that + * in both cases. If there is only BUS.ADDR, it will + * be the handle to be returned to the caller, otherwise + * we will need it to resolve the path to which the + * suffix would be appended. + */ + /* If there is nothing behind the BUS.ADDR, we will + * get the device handle from the host controller. + * Otherwise, we will + */ + rc = get_device_handle_by_address(hc_handle, dev_addr, + &dev_handle); + if (rc != EOK) { + return rc; + } + if (str_length(func_start) > 0) { + char tmp_path[MAX_DEVICE_PATH]; + rc = devman_fun_get_path(dev_handle, + tmp_path, MAX_DEVICE_PATH); + if (rc != EOK) { + return rc; + } + rc = asprintf(&path, "%s%s", tmp_path, func_start); + if (rc < 0) { + return ENOMEM; + } + } else { + /* Everything is resolved. Get out of here. */ + goto copy_out; + } + } else { + path = str_dup(dev_path); + if (path == NULL) { + return ENOMEM; + } + } + + /* First try to get the device handle. */ + rc = devman_fun_get_handle(path, &dev_handle, 0); + if (rc != EOK) { + free(path); + /* Invalid path altogether. */ + return rc; + } + + /* Remove suffixes and hope that we will encounter device node. */ + while (str_length(path) > 0) { + /* Get device handle first. */ + devman_handle_t tmp_handle; + rc = devman_fun_get_handle(path, &tmp_handle, 0); + if (rc != EOK) { + free(path); + return rc; + } + + /* Try to find its host controller. */ + if (!found_hc) { + rc = usb_get_hc_by_handle(tmp_handle, &hc_handle); + if (rc == EOK) { + found_hc = true; + } + } + + /* Try to get its address. */ + if (!found_addr) { + rc = usb_get_address_by_handle(tmp_handle, &dev_addr); + if (rc == 0) { + found_addr = true; + } + } + + /* Speed-up. */ + if (found_hc && found_addr) { + break; + } + + /* Remove the last suffix. */ + char *slash_pos = str_rchr(path, '/'); + if (slash_pos != NULL) { + *slash_pos = 0; + } + } + + free(path); + + if (!found_addr || !found_hc) { + return ENOENT; + } + +copy_out: + if (out_dev_addr != NULL) { + *out_dev_addr = dev_addr; + } + if (out_hc_handle != NULL) { + *out_hc_handle = hc_handle; + } + if (out_dev_handle != NULL) { + *out_dev_handle = dev_handle; + } + + return EOK; +} Index: uspace/lib/usb/src/hc.c =================================================================== --- uspace/lib/usb/src/hc.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/src/hc.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -1,4 +1,5 @@ /* * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -26,5 +27,4 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusb * @{ @@ -33,13 +33,72 @@ * General communication with host controller driver (implementation). */ -#include -#include -#include -#include +#include + +#include +#include #include +#include #include -#include -#include -#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); + if (connection->ref_count == 0) { + /* Closing already closed connection... */ + assert(connection->hc_sess = NULL); + fibril_mutex_unlock(&connection->guard); + return EOK; + } + --connection->ref_count; + int ret = EOK; + if (connection->ref_count == 0) { + assert(connection->hc_sess); + ret = async_hangup(connection->hc_sess); + connection->hc_sess = NULL; + } + 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 +118,27 @@ 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_get_hc_by_handle(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; -} - +/*----------------------------------------------------------------------------*/ +void usb_hc_connection_deinitialize(usb_hc_connection_t *connection) +{ + assert(connection); + fibril_mutex_lock(&connection->guard); + if (connection->ref_count != 0) { + usb_log_warning("%u stale reference(s) to HC connection.\n", + connection->ref_count); + assert(connection->hc_sess); + async_hangup(connection->hc_sess); + connection->hc_sess = NULL; + connection->ref_count = 0; + } + fibril_mutex_unlock(&connection->guard); +} +/*----------------------------------------------------------------------------*/ /** Open connection to host controller. * @@ -93,52 +148,51 @@ 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; -} - -/** Tells whether connection to host controller is opened. + return usb_hc_connection_add_ref(connection); +} +/*----------------------------------------------------------------------------*/ +/** Close connection to the host controller. * * @param connection Connection to the host controller. - * @return Whether connection is opened. - */ -bool usb_hc_connection_is_opened(const usb_hc_connection_t *connection) -{ - assert(connection); - return (connection->hc_sess != NULL); -} - -/** Close connection to the host controller. - * - * @param connection Connection to the host controller. * @return Error code. */ 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,90 +205,75 @@ 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; -} - -/** Tell USB address assigned to device with given handle. - * - * @param dev_handle Devman handle of the USB device in question. - * @return USB address or negative error code. - */ -usb_address_t usb_get_address_by_handle(devman_handle_t dev_handle) -{ - async_sess_t *parent_sess = - devman_parent_device_connect(EXCHANGE_ATOMIC, dev_handle, - IPC_FLAG_BLOCKING); - if (!parent_sess) - return ENOMEM; - - async_exch_t *exch = async_exchange_begin(parent_sess); - if (!exch) { - async_hangup(parent_sess); - return ENOMEM; - } - usb_address_t address; - const int ret = usb_get_my_address(exch, &address); - - async_exchange_end(exch); - async_hangup(parent_sess); - - if (ret != EOK) - return ret; - - return address; -} - - -/** 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. - * - * @param[in] device_handle Device devman handle. - * @param[out] hc_handle Where to store handle of host controller - * controlling device with @p device_handle handle. - * @return Error code. - */ -int usb_hc_find(devman_handle_t device_handle, devman_handle_t *hc_handle) -{ - async_sess_t *parent_sess = - devman_parent_device_connect(EXCHANGE_ATOMIC, device_handle, - IPC_FLAG_BLOCKING); - if (!parent_sess) - return ENOMEM; - - async_exch_t *exch = async_exchange_begin(parent_sess); - if (!exch) { - async_hangup(parent_sess); - return ENOMEM; - } - const int ret = usb_get_hc_handle(exch, hc_handle); - - async_exchange_end(exch); - async_hangup(parent_sess); - + + 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_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_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; } Index: uspace/lib/usb/src/resolve.c =================================================================== --- uspace/lib/usb/src/resolve.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ (revision ) @@ -1,244 +1,0 @@ -/* - * Copyright (c) 2011 Vojtech Horky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libusb - * @{ - */ -/** @file - * - */ -#include -#include -#include -#include -#include -#include - -#define MAX_DEVICE_PATH 1024 - -static bool try_parse_bus_and_address(const char *path, - char **func_start, - devman_handle_t *out_hc_handle, usb_address_t *out_device_address) -{ - uint64_t sid; - size_t address; - int rc; - char *ptr; - - rc = str_uint64(path, &ptr, 10, false, &sid); - if (rc != EOK) { - return false; - } - if ((*ptr == ':') || (*ptr == '.')) { - ptr++; - } else { - return false; - } - rc = str_size_t(ptr, func_start, 10, false, &address); - if (rc != EOK) { - return false; - } - rc = usb_ddf_get_hc_handle_by_sid(sid, out_hc_handle); - if (rc != EOK) { - return false; - } - if (out_device_address != NULL) { - *out_device_address = (usb_address_t) address; - } - return true; -} - -static int get_device_handle_by_address(devman_handle_t hc_handle, int addr, - devman_handle_t *dev_handle) -{ - int rc; - usb_hc_connection_t conn; - - usb_hc_connection_initialize(&conn, hc_handle); - rc = usb_hc_connection_open(&conn); - if (rc != EOK) { - return rc; - } - - rc = usb_hc_get_handle_by_address(&conn, addr, dev_handle); - - usb_hc_connection_close(&conn); - - return rc; -} - -/** Resolve handle and address of USB device from its path. - * - * This is a wrapper working on best effort principle. - * If the resolving fails, if will not give much details about what - * is wrong. - * Typically, error from this function would be reported to the user - * as "bad device specification" or "device does not exist". - * - * The path can be specified in following format: - * - devman path (e.g. /hw/pci0/.../usb01_a5 - * - bus number and device address (e.g. 5.1) - * - bus number, device address and device function (e.g. 2.1/HID0/keyboard) - * - * @param[in] dev_path Path to the device. - * @param[out] out_hc_handle Where to store handle of a parent host controller. - * @param[out] out_dev_addr Where to store device (USB) address. - * @param[out] out_dev_handle Where to store device handle. - * @return Error code. - */ -int usb_resolve_device_handle(const char *dev_path, devman_handle_t *out_hc_handle, - usb_address_t *out_dev_addr, devman_handle_t *out_dev_handle) -{ - if (dev_path == NULL) { - return EBADMEM; - } - - bool found_hc = false; - bool found_addr = false; - devman_handle_t hc_handle, dev_handle; - usb_address_t dev_addr = -1; - int rc; - bool is_bus_addr; - char *func_start = NULL; - char *path = NULL; - - /* First try the BUS.ADDR format. */ - is_bus_addr = try_parse_bus_and_address(dev_path, &func_start, - &hc_handle, &dev_addr); - if (is_bus_addr) { - found_hc = true; - found_addr = true; - /* - * Now get the handle of the device. We will need that - * in both cases. If there is only BUS.ADDR, it will - * be the handle to be returned to the caller, otherwise - * we will need it to resolve the path to which the - * suffix would be appended. - */ - /* If there is nothing behind the BUS.ADDR, we will - * get the device handle from the host controller. - * Otherwise, we will - */ - rc = get_device_handle_by_address(hc_handle, dev_addr, - &dev_handle); - if (rc != EOK) { - return rc; - } - if (str_length(func_start) > 0) { - char tmp_path[MAX_DEVICE_PATH ]; - rc = devman_fun_get_path(dev_handle, - tmp_path, MAX_DEVICE_PATH); - if (rc != EOK) { - return rc; - } - rc = asprintf(&path, "%s%s", tmp_path, func_start); - if (rc < 0) { - return ENOMEM; - } - } else { - /* Everything is resolved. Get out of here. */ - goto copy_out; - } - } else { - path = str_dup(dev_path); - if (path == NULL) { - return ENOMEM; - } - } - - /* First try to get the device handle. */ - rc = devman_fun_get_handle(path, &dev_handle, 0); - if (rc != EOK) { - free(path); - /* Invalid path altogether. */ - return rc; - } - - /* Remove suffixes and hope that we will encounter device node. */ - while (str_length(path) > 0) { - /* Get device handle first. */ - devman_handle_t tmp_handle; - rc = devman_fun_get_handle(path, &tmp_handle, 0); - if (rc != EOK) { - free(path); - return rc; - } - - /* Try to find its host controller. */ - if (!found_hc) { - rc = usb_hc_find(tmp_handle, &hc_handle); - if (rc == EOK) { - found_hc = true; - } - } - - /* Try to get its address. */ - if (!found_addr) { - dev_addr = usb_get_address_by_handle(tmp_handle); - if (dev_addr >= 0) { - found_addr = true; - } - } - - /* Speed-up. */ - if (found_hc && found_addr) { - break; - } - - /* Remove the last suffix. */ - char *slash_pos = str_rchr(path, '/'); - if (slash_pos != NULL) { - *slash_pos = 0; - } - } - - free(path); - - if (!found_addr || !found_hc) { - return ENOENT; - } - -copy_out: - if (out_dev_addr != NULL) { - *out_dev_addr = dev_addr; - } - if (out_hc_handle != NULL) { - *out_hc_handle = hc_handle; - } - if (out_dev_handle != NULL) { - *out_dev_handle = dev_handle; - } - - return EOK; -} - - -/** - * @} - */ - Index: uspace/lib/usb/src/usb.c =================================================================== --- uspace/lib/usb/src/usb.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usb/src/usb.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -39,27 +39,27 @@ static const char *str_speed[] = { - "low", - "full", - "high" + [USB_SPEED_LOW] = "low", + [USB_SPEED_FULL] = "full", + [USB_SPEED_HIGH] = "high", }; static const char *str_transfer_type[] = { - "control", - "isochronous", - "bulk", - "interrupt" + [USB_TRANSFER_CONTROL] = "control", + [USB_TRANSFER_ISOCHRONOUS] = "isochronous", + [USB_TRANSFER_BULK] = "bulk", + [USB_TRANSFER_INTERRUPT] = "interrupt", }; static const char *str_transfer_type_short[] = { - "ctrl", - "iso", - "bulk", - "intr" + [USB_TRANSFER_CONTROL] = "ctrl", + [USB_TRANSFER_ISOCHRONOUS] = "iso", + [USB_TRANSFER_BULK] = "bulk", + [USB_TRANSFER_INTERRUPT] = "intr", }; static const char *str_direction[] = { - "in", - "out", - "both" + [USB_DIRECTION_IN] = "in", + [USB_DIRECTION_OUT] = "out", + [USB_DIRECTION_BOTH] = "both", }; Index: uspace/lib/usbdev/Makefile =================================================================== --- uspace/lib/usbdev/Makefile (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/Makefile (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -40,9 +40,6 @@ src/dp.c \ src/hub.c \ - src/pipepriv.c \ - src/pipepriv.h \ src/pipes.c \ src/pipesinit.c \ - src/pipesio.c \ src/recognise.c \ src/request.c Index: uspace/lib/usbdev/include/usb/dev/driver.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/driver.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/include/usb/dev/driver.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -36,4 +36,6 @@ #define LIBUSBDEV_DRIVER_H_ +#include +#include #include @@ -72,4 +74,6 @@ /** USB device structure. */ typedef struct { + /** Connection to USB hc, used by wire and arbitrary requests. */ + usb_hc_connection_t hc_conn; /** Connection backing the pipes. * Typically, you will not need to use this attribute at all. @@ -169,8 +173,8 @@ void usb_device_release_descriptors(usb_device_descriptors_t *); -int usb_device_create_pipes(const ddf_dev_t *, usb_device_connection_t *, +int usb_device_create_pipes(usb_device_connection_t *, const usb_endpoint_description_t **, const uint8_t *, size_t, int, int, usb_endpoint_mapping_t **, size_t *); -int usb_device_destroy_pipes(const ddf_dev_t *, usb_endpoint_mapping_t *, size_t); +void usb_device_destroy_pipes(usb_endpoint_mapping_t *, size_t); void * usb_device_data_alloc(usb_device_t *, size_t); Index: uspace/lib/usbdev/include/usb/dev/hub.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/hub.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/include/usb/dev/hub.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -40,4 +40,5 @@ #include #include +#include #include @@ -59,9 +60,15 @@ } usb_hub_attached_device_t; -usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_address_t, - bool, usb_speed_t); -int usb_hc_register_device(usb_hc_connection_t *, +int usb_hub_register_device(usb_hc_connection_t *, const usb_hub_attached_device_t *); -int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t); + +static inline int usb_hub_unregister_device(usb_hc_connection_t *conn, + const usb_hub_attached_device_t *attached_device) +{ + assert(conn); + if (attached_device == NULL) + return EBADMEM; + return usb_hc_release_address(conn, attached_device->address); +} #endif Index: uspace/lib/usbdev/include/usb/dev/pipes.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/pipes.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/include/usb/dev/pipes.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -26,5 +26,4 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusbdev * @{ @@ -37,38 +36,18 @@ #include -#include -#include -#include #include #include #include -#include +#include +#include +#include -/** Abstraction of a physical connection to the device. - * This type is an abstraction of the USB wire that connects the host and - * the function (device). +#define CTRL_PIPE_MIN_PACKET_SIZE 8 +/** Abstraction of a logical connection to USB device endpoint. + * It encapsulates endpoint attributes (transfer type etc.). + * This endpoint must be bound with existing usb_device_connection_t + * (i.e. the wire to send data over). */ typedef struct { - /** Handle of the host controller device is connected to. */ - devman_handle_t hc_handle; - /** Address of the device. */ - usb_address_t address; -} usb_device_connection_t; - -/** Abstraction of a logical connection to USB device endpoint. - * It encapsulates endpoint attributes (transfer type etc.) as well - * as information about currently running sessions. - * This endpoint must be bound with existing usb_device_connection_t - * (i.e. the wire to send data over). - * - * Locking order: if you want to lock both mutexes - * (@c guard and @c hc_sess_mutex), lock @c guard first. - * It is not necessary to lock @c guard if you want to lock @c hc_sess_mutex - * only. - */ -typedef struct { - /** Guard of the whole pipe. */ - fibril_mutex_t guard; - /** The connection used for sending the data. */ usb_device_connection_t *wire; @@ -86,33 +65,4 @@ size_t max_packet_size; - /** Session to the host controller. - * NULL when no session is active. - * It is an error to access this member without @c hc_sess_mutex - * being locked. - * If call over the phone is to be made, it must be preceeded by - * call to pipe_add_ref() [internal libusb function]. - */ - async_sess_t *hc_sess; - - /** Guard for serialization of requests over the session. */ - fibril_mutex_t hc_sess_mutex; - - /** Number of active transfers over the pipe. */ - int refcount; - /** Number of failed attempts to open the HC phone. - * When user requests usb_pipe_start_long_transfer() and the operation - * fails, there is no way to report this to the user. - * That the soft reference counter is increased to record the attempt. - * When the user then request e.g. usb_pipe_read(), it will try to - * add reference as well. - * If that fails, it is reported to the user. If it is okay, the - * real reference counter is incremented. - * The problem might arise when ending the long transfer (since - * the number of references would be only 1, but logically it shall be - * two). - * Decrementing the soft counter first shall solve this. - */ - int refcount_soft; - /** Whether to automatically reset halt on the endpoint. * Valid only for control endpoint zero. @@ -120,5 +70,4 @@ bool auto_reset_halt; } usb_pipe_t; - /** Description of endpoint characteristics. */ @@ -156,25 +105,18 @@ } usb_endpoint_mapping_t; -int usb_device_connection_initialize_on_default_address( - usb_device_connection_t *, usb_hc_connection_t *); -int usb_device_connection_initialize_from_device(usb_device_connection_t *, - const ddf_dev_t *); -int usb_device_connection_initialize(usb_device_connection_t *, - devman_handle_t, usb_address_t); - -int usb_device_get_assigned_interface(const ddf_dev_t *); - int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *, usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t); int usb_pipe_initialize_default_control(usb_pipe_t *, usb_device_connection_t *); + int usb_pipe_probe_default_control(usb_pipe_t *); int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *, size_t, const uint8_t *, size_t, usb_device_connection_t *); -int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *); -int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *); -void usb_pipe_start_long_transfer(usb_pipe_t *); -void usb_pipe_end_long_transfer(usb_pipe_t *); +int usb_pipe_register(usb_pipe_t *, unsigned); +int usb_pipe_unregister(usb_pipe_t *); + +int usb_pipe_start_long_transfer(usb_pipe_t *); +int usb_pipe_end_long_transfer(usb_pipe_t *); int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *); Index: uspace/lib/usbdev/include/usb/dev/poll.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/poll.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/include/usb/dev/poll.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -39,4 +39,5 @@ #include +/** Parameters and callbacks for automated polling. */ typedef struct { /** Level of debugging messages from auto polling. @@ -82,8 +83,10 @@ */ bool (*on_error)(usb_device_t *dev, int err_code, void *arg); + /** Argument to pass to callbacks. */ + void *arg; } usb_device_auto_polling_t; int usb_device_auto_polling(usb_device_t *, size_t, - const usb_device_auto_polling_t *, size_t, void *); + const usb_device_auto_polling_t *, size_t); typedef bool (*usb_polling_callback_t)(usb_device_t *, Index: uspace/lib/usbdev/include/usb/dev/request.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/request.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/include/usb/dev/request.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -83,4 +83,10 @@ uint8_t request_type; #define SETUP_REQUEST_TYPE_DEVICE_TO_HOST (1 << 7) +#define SETUP_REQUEST_TYPE_GET_TYPE(rt) ((rt >> 5) & 0x3) +#define SETUP_REQUEST_TYPE_GET_RECIPIENT(rec) (rec & 0x1f) +#define SETUP_REQUEST_TO_HOST(type, recipient) \ + (uint8_t)((1 << 7) | ((type & 0x3) << 5) | (recipient & 0x1f)) +#define SETUP_REQUEST_TO_DEVICE(type, recipient) \ + (uint8_t)(((type & 0x3) << 5) | (recipient & 0x1f)) /** Request identification. */ Index: uspace/lib/usbdev/include/usb/dev/usb_device_connection.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/usb_device_connection.h (revision 2943db4eacf000472ce550d084e8e01062821b25) +++ uspace/lib/usbdev/include/usb/dev/usb_device_connection.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Common USB types and functions. + */ +#ifndef LIBUSBDEV_DEVICE_CONNECTION_H_ +#define LIBUSBDEV_DEVICE_CONNECTION_H_ + +#include +#include +#include +#include + + +/** Abstraction of a physical connection to the device. + * This type is an abstraction of the USB wire that connects the host and + * the function (device). + */ +typedef struct { + /** Connection to the host controller device is connected to. */ + usb_hc_connection_t *hc_connection; + /** Address of the device. */ + usb_address_t address; +} usb_device_connection_t; + +/** Initialize device connection. Set address and hc connection. + * @param instance Structure to initialize. + * @param hc_connection. Host controller connection to use. + * @param address USB address. + * @return Error code. + */ +static inline int usb_device_connection_initialize( + usb_device_connection_t *instance, usb_hc_connection_t *hc_connection, + usb_address_t address) +{ + assert(instance); + if (hc_connection == NULL) + return EBADMEM; + if ((address < 0) || (address >= USB11_ADDRESS_MAX)) + return EINVAL; + + instance->hc_connection = hc_connection; + instance->address = address; + return EOK; +} +/*----------------------------------------------------------------------------*/ +/** Register endpoint on the device. + * @param instance device connection structure to use. + * @param ep USB endpoint number. + * @param type Communication type of the endpoint. + * @param direction Communication direction. + * @param packet_size Maximum packet size for the endpoint. + * @param interval Preferrred interval between communication. + * @return Error code. + */ +static inline int usb_device_register_endpoint( + usb_device_connection_t *instance, usb_endpoint_t ep, + usb_transfer_type_t type, usb_direction_t direction, + size_t packet_size, unsigned interval) +{ + assert(instance); + return usb_hc_register_endpoint(instance->hc_connection, + instance->address, ep, type, direction, packet_size, interval); +} +/*----------------------------------------------------------------------------*/ +/** Unregister endpoint on the device. + * @param instance device connection structure + * @param ep Endpoint number. + * @param dir Communication direction. + * @return Error code. + */ +static inline int usb_device_unregister_endpoint( + usb_device_connection_t *instance, usb_endpoint_t ep, usb_direction_t dir) +{ + assert(instance); + return usb_hc_unregister_endpoint(instance->hc_connection, + instance->address, ep, dir); +} +/*----------------------------------------------------------------------------*/ +/** Get data from the device. + * @param[in] instance device connection structure to use. + * @param[in] ep target endpoint's number. + * @param[in] setup Setup stage data (control transfers). + * @param[in] data data buffer. + * @param[in] size size of the data buffer. + * @param[out] rsize bytes actually copied to the buffer. + * @return Error code. + */ +static inline int usb_device_control_read(usb_device_connection_t *instance, + usb_endpoint_t ep, uint64_t setup, void *data, size_t size, size_t *rsize) +{ + assert(instance); + return usb_hc_read(instance->hc_connection, + instance->address, ep, setup, data, size, rsize); +} +/*----------------------------------------------------------------------------*/ +/** Send data to the device. + * @param instance device connection structure to use. + * @param ep target endpoint's number. + * @param setup Setup stage data (control transfers). + * @param data data buffer. + * @param size size of the data buffer. + * @return Error code. + */ +static inline int usb_device_control_write(usb_device_connection_t *instance, + usb_endpoint_t ep, uint64_t setup, const void *data, size_t size) +{ + assert(instance); + return usb_hc_write(instance->hc_connection, + instance->address, ep, setup, data, size); +} +/*----------------------------------------------------------------------------*/ +/** Wrapper for read calls with no setup stage. + * @param[in] instance device connection structure. + * @param[in] address USB device address. + * @param[in] endpoint USB device endpoint. + * @param[in] data Data buffer. + * @param[in] size Size of the buffer. + * @param[out] real_size Size of the transferred data. + * @return Error code. + */ +static inline int usb_device_read(usb_device_connection_t *instance, + usb_endpoint_t ep, void *data, size_t size, size_t *real_size) +{ + return usb_device_control_read(instance, ep, 0, data, size, real_size); +} +/*----------------------------------------------------------------------------*/ +/** Wrapper for write calls with no setup stage. + * @param instance device connection structure. + * @param address USB device address. + * @param endpoint USB device endpoint. + * @param data Data buffer. + * @param size Size of the buffer. + * @return Error code. + */ +static inline int usb_device_write(usb_device_connection_t *instance, + usb_endpoint_t ep, const void *data, size_t size) +{ + return usb_device_control_write(instance, ep, 0, data, size); +} +#endif +/** + * @} + */ Index: uspace/lib/usbdev/src/altiface.c =================================================================== --- uspace/lib/usbdev/src/altiface.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/altiface.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -167,9 +167,13 @@ } -void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *alternate) +/** Clean initialized structure. + * @param instance structure do deinitialize. + */ +void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *instance) { - if (!alternate) + if (!instance) return; - free(alternate->alternatives); + free(instance->alternatives); + instance->alternatives = NULL; } /** Index: uspace/lib/usbdev/src/devdrv.c =================================================================== --- uspace/lib/usbdev/src/devdrv.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/devdrv.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -1,4 +1,5 @@ /* * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -26,5 +27,4 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusbdev * @{ @@ -36,5 +36,5 @@ #include #include -#include +#include #include #include @@ -56,5 +56,4 @@ static const usb_driver_t *driver = NULL; - /** Main routine of USB device driver. * @@ -75,5 +74,5 @@ return ddf_driver_main(&generic_driver); } - +/*----------------------------------------------------------------------------*/ /** Count number of pipes the driver expects. * @@ -85,40 +84,6 @@ { size_t count; - for (count = 0; endpoints && endpoints[count] != NULL; ++count); + for (count = 0; endpoints != NULL && endpoints[count] != NULL; ++count); return count; -} - -/** Initialize endpoint pipes, excluding default control one. - * - * @param drv The device driver. - * @param dev Device to be initialized. - * @return Error code. - */ -static int initialize_other_pipes(const usb_endpoint_description_t **endpoints, - usb_device_t *dev, int alternate_setting) -{ - assert(dev); - - if (endpoints == NULL) { - dev->pipes = NULL; - dev->pipes_count = 0; - return EOK; - } - - usb_endpoint_mapping_t *pipes; - size_t pipes_count; - - int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints, - dev->descriptors.configuration, dev->descriptors.configuration_size, - dev->interface_no, alternate_setting, &pipes, &pipes_count); - - if (rc != EOK) { - return rc; - } - - dev->pipes = pipes; - dev->pipes_count = pipes_count; - - return EOK; } /*----------------------------------------------------------------------------*/ @@ -136,4 +101,5 @@ assert(driver->ops->device_add); + /* Get place for driver data. */ usb_device_t *dev = ddf_dev_data_alloc(gen_dev, sizeof(usb_device_t)); if (dev == NULL) { @@ -142,4 +108,6 @@ return ENOMEM; } + + /* Initialize generic USB driver data. */ const char *err_msg = NULL; int rc = usb_device_init(dev, gen_dev, driver->endpoints, &err_msg); @@ -150,4 +118,5 @@ } + /* Start USB driver specific initialization. */ rc = driver->ops->device_add(dev); if (rc != EOK) @@ -169,6 +138,11 @@ if (driver->ops->device_rem == NULL) return ENOTSUP; - /* Just tell the driver to stop whatever it is doing, keep structures */ - return driver->ops->device_rem(gen_dev->driver_data); + /* Just tell the driver to stop whatever it is doing */ + usb_device_t *usb_dev = gen_dev->driver_data; + const int ret = driver->ops->device_rem(usb_dev); + if (ret != EOK) + return ret; + usb_device_deinit(usb_dev); + return EOK; } /*----------------------------------------------------------------------------*/ @@ -197,20 +171,12 @@ * * @param dev Device where to destroy the pipes. - * @return Error code. - */ -static int destroy_current_pipes(usb_device_t *dev) -{ - int rc = usb_device_destroy_pipes(dev->ddf_dev, - dev->pipes, dev->pipes_count); - if (rc != EOK) { - return rc; - } - + */ +static void destroy_current_pipes(usb_device_t *dev) +{ + usb_device_destroy_pipes(dev->pipes, dev->pipes_count); dev->pipes = NULL; dev->pipes_count = 0; - - return EOK; -} - +} +/*----------------------------------------------------------------------------*/ /** Change interface setting of a device. * This function selects new alternate setting of an interface by issuing @@ -242,14 +208,9 @@ } - int rc; - /* Destroy existing pipes. */ - rc = destroy_current_pipes(dev); - if (rc != EOK) { - return rc; - } + destroy_current_pipes(dev); /* Change the interface itself. */ - rc = usb_request_set_interface(&dev->ctrl_pipe, dev->interface_no, + int rc = usb_request_set_interface(&dev->ctrl_pipe, dev->interface_no, alternate_setting); if (rc != EOK) { @@ -258,5 +219,8 @@ /* Create new pipes. */ - rc = initialize_other_pipes(endpoints, dev, (int) alternate_setting); + rc = usb_device_create_pipes(&dev->wire, endpoints, + dev->descriptors.configuration, dev->descriptors.configuration_size, + dev->interface_no, (int)alternate_setting, + &dev->pipes, &dev->pipes_count); return rc; @@ -316,5 +280,4 @@ * - registers endpoints with the host controller * - * @param[in] dev Generic DDF device backing the USB one. * @param[in] wire Initialized backing connection to the host controller. * @param[in] endpoints Endpoints description, NULL terminated. @@ -329,5 +292,5 @@ * @return Error code. */ -int usb_device_create_pipes(const ddf_dev_t *dev, usb_device_connection_t *wire, +int usb_device_create_pipes(usb_device_connection_t *wire, const usb_endpoint_description_t **endpoints, const uint8_t *config_descr, size_t config_descr_size, @@ -335,7 +298,5 @@ usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr) { - assert(dev != NULL); assert(wire != NULL); - assert(endpoints != NULL); assert(config_descr != NULL); assert(config_descr_size > 0); @@ -359,5 +320,5 @@ } - /* Now allocate and fully initialize. */ + /* Now initialize. */ for (i = 0; i < pipe_count; i++) { pipes[i].description = endpoints[i]; @@ -370,23 +331,13 @@ config_descr, config_descr_size, wire); if (rc != EOK) { - goto rollback_free_only; - } - - /* Register the endpoints with HC. */ - usb_hc_connection_t hc_conn; - rc = usb_hc_connection_initialize_from_device(&hc_conn, dev); - if (rc != EOK) { - goto rollback_free_only; - } - - rc = usb_hc_connection_open(&hc_conn); - if (rc != EOK) { - goto rollback_free_only; - } - + free(pipes); + return rc; + } + + /* Register created pipes. */ for (i = 0; i < pipe_count; i++) { if (pipes[i].present) { rc = usb_pipe_register(&pipes[i].pipe, - pipes[i].descriptor->poll_interval, &hc_conn); + pipes[i].descriptor->poll_interval); if (rc != EOK) { goto rollback_unregister_endpoints; @@ -394,8 +345,4 @@ } } - - if (usb_hc_connection_close(&hc_conn) != EOK) - usb_log_warning("%s: Failed to close connection.\n", - __FUNCTION__); *pipes_ptr = pipes; @@ -415,20 +362,9 @@ for (i = 0; i < pipe_count; i++) { if (pipes[i].present) { - usb_pipe_unregister(&pipes[i].pipe, &hc_conn); + usb_pipe_unregister(&pipes[i].pipe); } } - if (usb_hc_connection_close(&hc_conn) != EOK) - usb_log_warning("usb_device_create_pipes(): " - "Failed to close connection.\n"); - - /* - * Jump here if something went wrong before some actual communication - * with HC. Then the only thing that needs to be done is to free - * allocated memory. - */ -rollback_free_only: free(pipes); - return rc; } @@ -436,48 +372,18 @@ /** Destroy pipes previously created by usb_device_create_pipes. * - * @param[in] dev Generic DDF device backing the USB one. * @param[in] pipes Endpoint mapping to be destroyed. * @param[in] pipes_count Number of endpoints. */ -int usb_device_destroy_pipes(const ddf_dev_t *dev, - usb_endpoint_mapping_t *pipes, size_t pipes_count) -{ - assert(dev != NULL); - - if (pipes_count == 0) { - assert(pipes == NULL); - return EOK; - } - assert(pipes != NULL); - - int rc; - - /* Prepare connection to HC to allow endpoint unregistering. */ - usb_hc_connection_t hc_conn; - rc = usb_hc_connection_initialize_from_device(&hc_conn, dev); - if (rc != EOK) { - return rc; - } - rc = usb_hc_connection_open(&hc_conn); - if (rc != EOK) { - return rc; - } - +void usb_device_destroy_pipes(usb_endpoint_mapping_t *pipes, size_t pipes_count) +{ /* Destroy the pipes. */ - size_t i; - for (i = 0; i < pipes_count; i++) { - usb_log_debug2("Unregistering pipe %zu (%spresent).\n", + for (size_t i = 0; i < pipes_count; ++i) { + assert(pipes); + usb_log_debug2("Unregistering pipe %zu: %spresent.\n", i, pipes[i].present ? "" : "not "); if (pipes[i].present) - usb_pipe_unregister(&pipes[i].pipe, &hc_conn); - } - - if (usb_hc_connection_close(&hc_conn) != EOK) - usb_log_warning("usb_device_destroy_pipes(): " - "Failed to close connection.\n"); - + usb_pipe_unregister(&pipes[i].pipe); + } free(pipes); - - return EOK; } @@ -505,7 +411,21 @@ usb_dev->pipes = NULL; + /* Get assigned params */ + devman_handle_t hc_handle; + usb_address_t address; + + int rc = usb_get_info_by_handle(ddf_dev->handle, + &hc_handle, &address, &usb_dev->interface_no); + if (rc != EOK) { + *errstr_ptr = "device parameters retrieval"; + return rc; + } + + /* Initialize hc connection. */ + usb_hc_connection_initialize(&usb_dev->hc_conn, hc_handle); + /* Initialize backing wire and control pipe. */ - int rc = usb_device_connection_initialize_from_device( - &usb_dev->wire, ddf_dev); + rc = usb_device_connection_initialize( + &usb_dev->wire, &usb_dev->hc_conn, address); if (rc != EOK) { *errstr_ptr = "device connection initialization"; @@ -515,6 +435,6 @@ /* This pipe was registered by the hub driver, * during device initialization. */ - rc = usb_pipe_initialize_default_control(&usb_dev->ctrl_pipe, - &usb_dev->wire); + rc = usb_pipe_initialize_default_control( + &usb_dev->ctrl_pipe, &usb_dev->wire); if (rc != EOK) { *errstr_ptr = "default control pipe initialization"; @@ -522,12 +442,17 @@ } - /* Get our interface. */ - usb_dev->interface_no = usb_device_get_assigned_interface(ddf_dev); + /* Open hc connection for pipe registration. */ + rc = usb_hc_connection_open(&usb_dev->hc_conn); + if (rc != EOK) { + *errstr_ptr = "hc connection open"; + return rc; + } /* Retrieve standard descriptors. */ - rc = usb_device_retrieve_descriptors(&usb_dev->ctrl_pipe, - &usb_dev->descriptors); + rc = usb_device_retrieve_descriptors( + &usb_dev->ctrl_pipe, &usb_dev->descriptors); if (rc != EOK) { *errstr_ptr = "descriptor retrieval"; + usb_hc_connection_close(&usb_dev->hc_conn); return rc; } @@ -543,7 +468,12 @@ (rc == EOK) ? usb_dev->alternate_interfaces.current : 0; - /* TODO Add comment here. */ - rc = initialize_other_pipes(endpoints, usb_dev, alternate_iface); - if (rc != EOK) { + /* Create and register other pipes than default control (EP 0) */ + rc = usb_device_create_pipes(&usb_dev->wire, endpoints, + usb_dev->descriptors.configuration, + usb_dev->descriptors.configuration_size, + usb_dev->interface_no, (int)alternate_iface, + &usb_dev->pipes, &usb_dev->pipes_count); + if (rc != EOK) { + usb_hc_connection_close(&usb_dev->hc_conn); /* Full configuration descriptor is allocated. */ usb_device_release_descriptors(&usb_dev->descriptors); @@ -554,4 +484,5 @@ } + usb_hc_connection_close(&usb_dev->hc_conn); return EOK; } @@ -566,13 +497,20 @@ { if (dev) { + /* Destroy existing pipes. */ + destroy_current_pipes(dev); /* Ignore errors and hope for the best. */ - destroy_current_pipes(dev); - + usb_hc_connection_deinitialize(&dev->hc_conn); usb_alternate_interfaces_deinit(&dev->alternate_interfaces); usb_device_release_descriptors(&dev->descriptors); free(dev->driver_data); - } -} - + dev->driver_data = NULL; + } +} + +/** Allocate driver specific data. + * @param usb_dev usb_device structure. + * @param size requested data size. + * @return Pointer to the newly allocated space, NULL on failure. + */ void * usb_device_data_alloc(usb_device_t *usb_dev, size_t size) { Index: uspace/lib/usbdev/src/devpoll.c =================================================================== --- uspace/lib/usbdev/src/devpoll.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/devpoll.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -46,11 +46,15 @@ /** Data needed for polling. */ typedef struct { + /** Parameters for automated polling. */ usb_device_auto_polling_t auto_polling; + /** USB device to poll. */ usb_device_t *dev; + /** Device pipe to use for polling. */ size_t pipe_index; + /** Size of the recieved data. */ size_t request_size; + /** Data buffer. */ uint8_t *buffer; - void *custom_arg; } polling_data_t; @@ -119,5 +123,5 @@ ++failed_attempts; const bool cont = (params->on_error == NULL) ? true : - params->on_error(data->dev, rc, data->custom_arg); + params->on_error(data->dev, rc, params->arg); if (!cont) { failed_attempts = params->max_failures; @@ -129,5 +133,5 @@ assert(params->on_data); const bool carry_on = params->on_data( - data->dev, data->buffer, actual_size, data->custom_arg); + data->dev, data->buffer, actual_size, params->arg); if (!carry_on) { @@ -149,5 +153,5 @@ if (params->on_polling_end != NULL) { - params->on_polling_end(data->dev, failed, data->custom_arg); + params->on_polling_end(data->dev, failed, params->arg); } @@ -199,8 +203,9 @@ .on_polling_end = terminated_callback, .on_error = NULL, + .arg = arg, }; return usb_device_auto_polling(dev, pipe_index, &auto_polling, - request_size, arg); + request_size); } @@ -224,5 +229,5 @@ int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index, const usb_device_auto_polling_t *polling, - size_t request_size, void *arg) + size_t request_size) { if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) { @@ -252,5 +257,4 @@ polling_data->dev = dev; polling_data->pipe_index = pipe_index; - polling_data->custom_arg = arg; /* Copy provided settings. */ Index: uspace/lib/usbdev/src/hub.c =================================================================== --- uspace/lib/usbdev/src/hub.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/hub.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -38,5 +38,4 @@ #include #include -#include #include #include @@ -45,46 +44,8 @@ #include -/** How much time to wait between attempts to register endpoint 0:0. +/** How much time to wait between attempts to get the default address. * The value is based on typical value for port reset + some overhead. */ -#define ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC (1000 * (10 + 2)) - -/** Check that HC connection is alright. - * - * @param conn Connection to be checked. - */ -#define CHECK_CONNECTION(conn) \ - do { \ - assert((conn)); \ - if (!usb_hc_connection_is_opened((conn))) { \ - usb_log_error("Connection not open.\n"); \ - return ENOTCONN; \ - } \ - } while (false) - -/** 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) -{ - CHECK_CONNECTION(connection); - - async_exch_t *exch = async_exchange_begin(connection->hc_sess); - 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); - return ret == EOK ? address : ret; -} +#define DEFAULT_ADDRESS_ATTEMPT_DELAY_USEC (1000 * (10 + 2)) /** Inform host controller about new device. @@ -94,39 +55,12 @@ * @return Error code. */ -int usb_hc_register_device(usb_hc_connection_t *connection, +int usb_hub_register_device(usb_hc_connection_t *connection, const usb_hub_attached_device_t *attached_device) { - CHECK_CONNECTION(connection); + assert(connection); if (attached_device == NULL || attached_device->fun == NULL) - return EINVAL; - - async_exch_t *exch = async_exchange_begin(connection->hc_sess); - if (!exch) - return ENOMEM; - const int ret = usbhc_bind_address(exch, + return EBADMEM; + return usb_hc_bind_address(connection, attached_device->address, attached_device->fun->handle); - async_exchange_end(exch); - - return ret; -} - -/** Inform host controller about device removal. - * - * @param connection Opened connection to host controller. - * @param address Address of the device that is being removed. - * @return Error code. - */ -int usb_hc_unregister_device(usb_hc_connection_t *connection, - usb_address_t address) -{ - CHECK_CONNECTION(connection); - - async_exch_t *exch = async_exchange_begin(connection->hc_sess); - if (!exch) - return ENOMEM; - const int ret = usbhc_release_address(exch, address); - async_exchange_end(exch); - - return ret; } @@ -145,6 +79,5 @@ * @return Error code. */ -static int usb_request_set_address(usb_pipe_t *pipe, usb_address_t new_address, - usb_hc_connection_t *hc_conn) +static int usb_request_set_address(usb_pipe_t *pipe, usb_address_t new_address) { if ((new_address < 0) || (new_address >= USB11_ADDRESS_MAX)) { @@ -152,5 +85,4 @@ } assert(pipe); - assert(hc_conn); assert(pipe->wire != NULL); @@ -166,11 +98,15 @@ /* TODO: prevent others from accessing the wire now. */ - if (usb_pipe_unregister(pipe, hc_conn) != EOK) { + if (usb_pipe_unregister(pipe) != EOK) { usb_log_warning( "Failed to unregister the old pipe on address change.\n"); } + /* Address changed. We can release the old one, thus + * allowing other to us it. */ + usb_hc_release_address(pipe->wire->hc_connection, pipe->wire->address); + /* The address is already changed so set it in the wire */ pipe->wire->address = new_address; - rc = usb_pipe_register(pipe, 0, hc_conn); + rc = usb_pipe_register(pipe, 0); if (rc != EOK) return EADDRNOTAVAIL; @@ -220,14 +156,10 @@ */ int usb_hc_new_device_wrapper(ddf_dev_t *parent, - usb_hc_connection_t *connection, usb_speed_t dev_speed, + usb_hc_connection_t *hc_conn, usb_speed_t dev_speed, int (*enable_port)(void *arg), void *arg, usb_address_t *assigned_address, ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun) { - if (new_fun == NULL || connection == NULL) + if (new_fun == NULL || hc_conn == NULL) return EINVAL; - - // TODO: Why not use provided connection? - usb_hc_connection_t hc_conn; - usb_hc_connection_initialize(&hc_conn, connection->hc_handle); int rc; @@ -239,14 +171,13 @@ } - rc = usb_hc_connection_open(&hc_conn); + /* We are gona do a lot of communication better open it in advance. */ + rc = usb_hc_connection_open(hc_conn); if (rc != EOK) { return rc; } - /* - * Request new address. - */ + /* Request a new address. */ usb_address_t dev_addr = - usb_hc_request_address(&hc_conn, 0, false, dev_speed); + usb_hc_request_address(hc_conn, 0, false, dev_speed); if (dev_addr < 0) { rc = EADDRNOTAVAIL; @@ -254,31 +185,33 @@ } + /* Initialize connection to device. */ + usb_device_connection_t dev_conn; + rc = usb_device_connection_initialize( + &dev_conn, hc_conn, USB_ADDRESS_DEFAULT); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_free_address; + } + + /* Initialize control pipe on default address. Don't register yet. */ + usb_pipe_t ctrl_pipe; + rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_free_address; + } + /* - * We will not register control pipe on default address. - * The registration might fail. That means that someone else already - * registered that endpoint. We will simply wait and try again. + * The default address request might fail. + * That means that someone else is already using that address. + * We will simply wait and try again. * (Someone else already wants to add a new device.) */ - usb_device_connection_t dev_conn; - rc = usb_device_connection_initialize_on_default_address(&dev_conn, - &hc_conn); - if (rc != EOK) { - rc = ENOTCONN; - goto leave_release_free_address; - } - - usb_pipe_t ctrl_pipe; - rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn); - if (rc != EOK) { - rc = ENOTCONN; - goto leave_release_free_address; - } - do { - rc = usb_hc_request_address(&hc_conn, USB_ADDRESS_DEFAULT, + rc = usb_hc_request_address(hc_conn, USB_ADDRESS_DEFAULT, true, dev_speed); if (rc == ENOENT) { /* Do not overheat the CPU ;-). */ - async_usleep(ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC); + async_usleep(DEFAULT_ADDRESS_ATTEMPT_DELAY_USEC); } } while (rc == ENOENT); @@ -287,6 +220,6 @@ } - /* Register control pipe on default address. */ - rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn); + /* Register control pipe on default address. 0 means no interval. */ + rc = usb_pipe_register(&ctrl_pipe, 0); if (rc != EOK) { rc = ENOTCONN; @@ -295,5 +228,4 @@ struct timeval end_time; - rc = gettimeofday(&end_time, NULL); if (rc != EOK) { @@ -330,5 +262,5 @@ } - rc = usb_request_set_address(&ctrl_pipe, dev_addr, &hc_conn); + rc = usb_request_set_address(&ctrl_pipe, dev_addr); if (rc != EOK) { rc = ESTALL; @@ -336,7 +268,4 @@ } - /* Address changed. We can release the default, thus - * allowing other to access the default address. */ - usb_hc_unregister_device(&hc_conn, USB_ADDRESS_DEFAULT); /* Register the device with devman. */ @@ -356,5 +285,5 @@ /* Inform the host controller about the handle. */ - rc = usb_hc_register_device(&hc_conn, &new_device); + rc = usb_hub_register_device(hc_conn, &new_device); if (rc != EOK) { /* We know nothing about that data. */ @@ -381,18 +310,20 @@ */ leave_release_default_address: - usb_hc_unregister_device(&hc_conn, USB_ADDRESS_DEFAULT); + if (usb_hc_release_address(hc_conn, USB_ADDRESS_DEFAULT) != EOK) + usb_log_warning("%s: Failed to release defaut address.\n", + __FUNCTION__); leave_release_free_address: /* This might be either 0:0 or dev_addr:0 */ - if (usb_pipe_unregister(&ctrl_pipe, &hc_conn) != EOK) + if (usb_pipe_unregister(&ctrl_pipe) != EOK) usb_log_warning("%s: Failed to unregister default pipe.\n", __FUNCTION__); - if (usb_hc_unregister_device(&hc_conn, dev_addr) != EOK) - usb_log_warning("%s: Failed to unregister device.\n", - __FUNCTION__); + if (usb_hc_release_address(hc_conn, dev_addr) != EOK) + usb_log_warning("%s: Failed to release address: %d.\n", + __FUNCTION__, dev_addr); close_connection: - if (usb_hc_connection_close(&hc_conn) != EOK) + if (usb_hc_connection_close(hc_conn) != EOK) usb_log_warning("%s: Failed to close hc connection.\n", __FUNCTION__); Index: uspace/lib/usbdev/src/pipepriv.c =================================================================== --- uspace/lib/usbdev/src/pipepriv.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ (revision ) @@ -1,148 +1,0 @@ -/* - * Copyright (c) 2011 Vojtech Horky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libusbdev - * @{ - */ -/** @file - * Library internal functions on USB pipes (implementation). - */ -#include "pipepriv.h" -#include -#include -#include - -/** Ensure exclusive access to the IPC phone of given pipe. - * - * @param pipe Pipe to be exclusively accessed. - */ -void pipe_start_transaction(usb_pipe_t *pipe) -{ - fibril_mutex_lock(&pipe->hc_sess_mutex); -} - -/** Terminate exclusive access to the IPC phone of given pipe. - * - * @param pipe Pipe to be released from exclusive usage. - */ -void pipe_end_transaction(usb_pipe_t *pipe) -{ - fibril_mutex_unlock(&pipe->hc_sess_mutex); -} - -/** Ensure exclusive access to the pipe as a whole. - * - * @param pipe Pipe to be exclusively accessed. - */ -void pipe_acquire(usb_pipe_t *pipe) -{ - fibril_mutex_lock(&pipe->guard); -} - -/** Terminate exclusive access to the pipe as a whole. - * - * @param pipe Pipe to be released from exclusive usage. - */ -void pipe_release(usb_pipe_t *pipe) -{ - fibril_mutex_unlock(&pipe->guard); -} - -/** Add reference of active transfers over the pipe. - * - * @param pipe The USB pipe. - * @param hide_failure Whether to hide failure when adding reference - * (use soft refcount). - * @return Error code. - * @retval EOK Currently always. - */ -int pipe_add_ref(usb_pipe_t *pipe, bool hide_failure) -{ - pipe_acquire(pipe); - - if (pipe->refcount == 0) { - assert(pipe->hc_sess == NULL); - /* Need to open the phone by ourselves. */ - async_sess_t *sess = - devman_device_connect(EXCHANGE_SERIALIZE, pipe->wire->hc_handle, 0); - if (!sess) { - if (hide_failure) { - pipe->refcount_soft++; - pipe_release(pipe); - return EOK; - } - - pipe_release(pipe); - return ENOMEM; - } - - /* - * No locking is needed, refcount is zero and whole pipe - * mutex is locked. - */ - - pipe->hc_sess = sess; - } - - pipe->refcount++; - pipe_release(pipe); - - return EOK; -} - -/** Drop active transfer reference on the pipe. - * - * @param pipe The USB pipe. - */ -void pipe_drop_ref(usb_pipe_t *pipe) -{ - pipe_acquire(pipe); - - if (pipe->refcount_soft > 0) { - pipe->refcount_soft--; - pipe_release(pipe); - return; - } - - assert(pipe->refcount > 0); - - pipe->refcount--; - - if (pipe->refcount == 0) { - /* We were the last users, let's hang-up. */ - async_hangup(pipe->hc_sess); - pipe->hc_sess = NULL; - } - - pipe_release(pipe); -} - - -/** - * @} - */ Index: uspace/lib/usbdev/src/pipepriv.h =================================================================== --- uspace/lib/usbdev/src/pipepriv.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ (revision ) @@ -1,54 +1,0 @@ -/* - * Copyright (c) 2011 Vojtech Horky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libusbdev - * @{ - */ -/** @file - * Library internal functions on USB pipes. - */ -#ifndef LIBUSBDEV_PIPEPRIV_H_ -#define LIBUSBDEV_PIPEPRIV_H_ - -#include -#include - -void pipe_acquire(usb_pipe_t *); -void pipe_release(usb_pipe_t *); - -void pipe_start_transaction(usb_pipe_t *); -void pipe_end_transaction(usb_pipe_t *); - -int pipe_add_ref(usb_pipe_t *, bool); -void pipe_drop_ref(usb_pipe_t *); - - -#endif -/** - * @} - */ Index: uspace/lib/usbdev/src/pipes.c =================================================================== --- uspace/lib/usbdev/src/pipes.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/pipes.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -1,4 +1,5 @@ /* * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 Jan Vesely * All rights reserved. * @@ -26,198 +27,313 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusbdev * @{ */ /** @file - * USB endpoint pipes miscellaneous functions. - */ -#include + * USB endpoint pipes functions. + */ #include -#include -#include -#include -#include -#include +#include #include #include -#include "pipepriv.h" - -#define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */ - -/** Tell USB address assigned to given device. - * - * @param sess Session to parent device. - * @param dev Device in question. - * @return USB address or error code. - */ -static usb_address_t get_my_address(async_sess_t *sess, const ddf_dev_t *dev) -{ - assert(sess); - async_exch_t *exch = async_exchange_begin(sess); - if (!exch) - return ENOMEM; - - usb_address_t address; - const int ret = usb_get_my_address(exch, &address); - - async_exchange_end(exch); - - return (ret == EOK) ? address : ret; -} - -/** Tell USB interface assigned to given device. - * - * @param device Device in question. - * @return Error code (ENOTSUP means any). - */ -int usb_device_get_assigned_interface(const ddf_dev_t *device) -{ - assert(device); - async_sess_t *parent_sess = - devman_parent_device_connect(EXCHANGE_ATOMIC, device->handle, - IPC_FLAG_BLOCKING); - if (!parent_sess) - return ENOMEM; - - async_exch_t *exch = async_exchange_begin(parent_sess); - if (!exch) { - async_hangup(parent_sess); - return ENOMEM; - } - - int iface_no; - const int ret = usb_get_my_interface(exch, &iface_no); - - return ret == EOK ? iface_no : ret; -} - -/** Initialize connection to USB device. - * - * @param connection Connection structure to be initialized. - * @param dev Generic device backing the USB device. - * @return Error code. - */ -int usb_device_connection_initialize_from_device( - usb_device_connection_t *connection, const ddf_dev_t *dev) -{ + +/** Prepare pipe for a long transfer. + * + * Long transfer is transfer consisting of several requests to the HC. + * Calling this function is optional and it has positive effect of + * improved performance because IPC session is initiated only once. + * + * @param pipe Pipe over which the transfer will happen. + * @return Error code. + */ +int usb_pipe_start_long_transfer(usb_pipe_t *pipe) +{ + assert(pipe); + assert(pipe->wire); + assert(pipe->wire->hc_connection); + return usb_hc_connection_open(pipe->wire->hc_connection); +} +/*----------------------------------------------------------------------------*/ +/** Terminate a long transfer on a pipe. + * @param pipe Pipe where to end the long transfer. + * @return Error code. + * @see usb_pipe_start_long_transfer + */ +int usb_pipe_end_long_transfer(usb_pipe_t *pipe) +{ + assert(pipe); + assert(pipe->wire); + assert(pipe->wire->hc_connection); + return usb_hc_connection_close(pipe->wire->hc_connection); +} +/*----------------------------------------------------------------------------*/ +/** Try to clear endpoint halt of default control pipe. + * + * @param pipe Pipe for control endpoint zero. + */ +static void clear_self_endpoint_halt(usb_pipe_t *pipe) +{ + assert(pipe != NULL); + + if (!pipe->auto_reset_halt || (pipe->endpoint_no != 0)) { + return; + } + + /* Prevent infinite recursion. */ + pipe->auto_reset_halt = false; + usb_request_clear_endpoint_halt(pipe, 0); + pipe->auto_reset_halt = true; +} +/*----------------------------------------------------------------------------*/ +/** Request a control read transfer on an endpoint pipe. + * + * This function encapsulates all three stages of a control transfer. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] setup_buffer Buffer with the setup packet. + * @param[in] setup_buffer_size Size of the setup packet (in bytes). + * @param[out] data_buffer Buffer for incoming data. + * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes). + * @param[out] data_transfered_size Number of bytes that were actually + * transfered during the DATA stage. + * @return Error code. + */ +int usb_pipe_control_read(usb_pipe_t *pipe, + const void *setup_buffer, size_t setup_buffer_size, + void *buffer, size_t buffer_size, size_t *transfered_size) +{ + assert(pipe); + + if ((setup_buffer == NULL) || (setup_buffer_size != 8)) { + return EINVAL; + } + + if ((buffer == NULL) || (buffer_size == 0)) { + return EINVAL; + } + + if ((pipe->direction != USB_DIRECTION_BOTH) + || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { + return EBADF; + } + + uint64_t setup_packet; + memcpy(&setup_packet, setup_buffer, 8); + + size_t act_size = 0; + const int rc = usb_device_control_read(pipe->wire, + pipe->endpoint_no, setup_packet, buffer, buffer_size, &act_size); + + if (rc == ESTALL) { + clear_self_endpoint_halt(pipe); + } + + if (rc == EOK && transfered_size != NULL) { + *transfered_size = act_size; + } + + return rc; +} +/*----------------------------------------------------------------------------*/ +/** Request a control write transfer on an endpoint pipe. + * + * This function encapsulates all three stages of a control transfer. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] setup_buffer Buffer with the setup packet. + * @param[in] setup_buffer_size Size of the setup packet (in bytes). + * @param[in] data_buffer Buffer with data to be sent. + * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes). + * @return Error code. + */ +int usb_pipe_control_write(usb_pipe_t *pipe, + const void *setup_buffer, size_t setup_buffer_size, + const void *buffer, size_t buffer_size) +{ + assert(pipe); + + if ((setup_buffer == NULL) || (setup_buffer_size != 8)) { + return EINVAL; + } + + if ((buffer == NULL) && (buffer_size > 0)) { + return EINVAL; + } + + if ((buffer != NULL) && (buffer_size == 0)) { + return EINVAL; + } + + if ((pipe->direction != USB_DIRECTION_BOTH) + || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { + return EBADF; + } + + uint64_t setup_packet; + memcpy(&setup_packet, setup_buffer, 8); + + const int rc = usb_device_control_write(pipe->wire, + pipe->endpoint_no, setup_packet, buffer, buffer_size); + + if (rc == ESTALL) { + clear_self_endpoint_halt(pipe); + } + + return rc; +} +/*----------------------------------------------------------------------------*/ +/** Request a read (in) transfer on an endpoint pipe. + * + * @param[in] pipe Pipe used for the transfer. + * @param[out] buffer Buffer where to store the data. + * @param[in] size Size of the buffer (in bytes). + * @param[out] size_transfered Number of bytes that were actually transfered. + * @return Error code. + */ +int usb_pipe_read(usb_pipe_t *pipe, + void *buffer, size_t size, size_t *size_transfered) +{ + assert(pipe); + + if (buffer == NULL) { + return EINVAL; + } + + if (size == 0) { + return EINVAL; + } + + if (pipe->direction != USB_DIRECTION_IN) { + return EBADF; + } + + if (pipe->transfer_type == USB_TRANSFER_CONTROL) { + return EBADF; + } + + /* Isochronous transfer are not supported (yet) */ + if (pipe->transfer_type != USB_TRANSFER_INTERRUPT && + pipe->transfer_type != USB_TRANSFER_BULK) + return ENOTSUP; + + size_t act_size = 0; + const int rc = usb_device_read(pipe->wire, + pipe->endpoint_no, buffer, size, &act_size); + + if (rc == EOK && size_transfered != NULL) { + *size_transfered = act_size; + } + + return rc; +} +/*----------------------------------------------------------------------------*/ +/** Request a write (out) transfer on an endpoint pipe. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] buffer Buffer with data to transfer. + * @param[in] size Size of the buffer (in bytes). + * @return Error code. + */ +int usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size) +{ + assert(pipe); + + if (buffer == NULL || size == 0) { + return EINVAL; + } + + if (pipe->direction != USB_DIRECTION_OUT) { + return EBADF; + } + + if (pipe->transfer_type == USB_TRANSFER_CONTROL) { + return EBADF; + } + + /* Isochronous transfer are not supported (yet) */ + if (pipe->transfer_type != USB_TRANSFER_INTERRUPT && + pipe->transfer_type != USB_TRANSFER_BULK) + return ENOTSUP; + + return usb_device_write(pipe->wire, + pipe->endpoint_no, buffer, size); +} +/*----------------------------------------------------------------------------*/ +/** Initialize USB endpoint pipe. + * + * @param pipe Endpoint pipe to be initialized. + * @param connection Connection to the USB device backing this pipe (the wire). + * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15). + * @param transfer_type Transfer type (e.g. interrupt or bulk). + * @param max_packet_size Maximum packet size in bytes. + * @param direction Endpoint direction (in/out). + * @return Error code. + */ +int usb_pipe_initialize(usb_pipe_t *pipe, + usb_device_connection_t *connection, usb_endpoint_t endpoint_no, + usb_transfer_type_t transfer_type, size_t max_packet_size, + usb_direction_t direction) +{ + assert(pipe); assert(connection); - assert(dev); - - int rc; - devman_handle_t hc_handle; - usb_address_t my_address; - - rc = usb_hc_find(dev->handle, &hc_handle); - if (rc != EOK) - return rc; - - async_sess_t *parent_sess = - devman_parent_device_connect(EXCHANGE_ATOMIC, dev->handle, - IPC_FLAG_BLOCKING); - if (!parent_sess) - return ENOMEM; - - /* - * Asking for "my" address may require several attempts. - * That is because following scenario may happen: - * - parent driver (i.e. driver of parent device) announces new device - * and devman launches current driver - * - parent driver is preempted and thus does not send address-handle - * binding to HC driver - * - this driver gets here and wants the binding - * - the HC does not know the binding yet and thus it answers ENOENT - * So, we need to wait for the HC to learn the binding. - */ - - do { - my_address = get_my_address(parent_sess, dev); - - if (my_address == ENOENT) { - /* Be nice, let other fibrils run and try again. */ - async_usleep(IPC_AGAIN_DELAY); - } else if (my_address < 0) { - /* Some other problem, no sense trying again. */ - rc = my_address; - goto leave; - } - - } while (my_address < 0); - - rc = usb_device_connection_initialize(connection, - hc_handle, my_address); - -leave: - async_hangup(parent_sess); + + pipe->wire = connection; + pipe->endpoint_no = endpoint_no; + pipe->transfer_type = transfer_type; + pipe->max_packet_size = max_packet_size; + pipe->direction = direction; + pipe->auto_reset_halt = false; + + return EOK; +} +/*----------------------------------------------------------------------------*/ +/** Initialize USB endpoint pipe as the default zero control pipe. + * + * @param pipe Endpoint pipe to be initialized. + * @param connection Connection to the USB device backing this pipe (the wire). + * @return Error code. + */ +int usb_pipe_initialize_default_control(usb_pipe_t *pipe, + usb_device_connection_t *connection) +{ + assert(pipe); + assert(connection); + + int rc = usb_pipe_initialize(pipe, connection, 0, USB_TRANSFER_CONTROL, + CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH); + + pipe->auto_reset_halt = true; + return rc; } - -/** Initialize connection to USB device. - * - * @param connection Connection structure to be initialized. - * @param host_controller_handle Devman handle of host controller device is - * connected to. - * @param device_address Device USB address. - * @return Error code. - */ -int usb_device_connection_initialize(usb_device_connection_t *connection, - devman_handle_t host_controller_handle, usb_address_t device_address) -{ - assert(connection); - - if ((device_address < 0) || (device_address >= USB11_ADDRESS_MAX)) { - return EINVAL; - } - - connection->hc_handle = host_controller_handle; - connection->address = device_address; - - return EOK; -} - -/** Initialize connection to USB device on default address. - * - * @param dev_connection Device connection structure to be initialized. - * @param hc_connection Initialized connection to host controller. - * @return Error code. - */ -int usb_device_connection_initialize_on_default_address( - usb_device_connection_t *dev_connection, - usb_hc_connection_t *hc_connection) -{ - assert(dev_connection); - - if (hc_connection == NULL) { - return EBADMEM; - } - - return usb_device_connection_initialize(dev_connection, - hc_connection->hc_handle, (usb_address_t) 0); -} - -/** Prepare pipe for a long transfer. - * - * By a long transfer is mean transfer consisting of several - * requests to the HC. - * Calling such function is optional and it has positive effect of - * improved performance because IPC session is initiated only once. - * - * @param pipe Pipe over which the transfer will happen. - * @return Error code. - */ -void usb_pipe_start_long_transfer(usb_pipe_t *pipe) -{ - (void) pipe_add_ref(pipe, true); -} - -/** Terminate a long transfer on a pipe. - * - * @see usb_pipe_start_long_transfer - * - * @param pipe Pipe where to end the long transfer. - */ -void usb_pipe_end_long_transfer(usb_pipe_t *pipe) -{ - pipe_drop_ref(pipe); +/*----------------------------------------------------------------------------*/ +/** Register endpoint with the host controller. + * + * @param pipe Pipe to be registered. + * @param interval Polling interval. + * @return Error code. + */ +int usb_pipe_register(usb_pipe_t *pipe, unsigned interval) +{ + assert(pipe); + assert(pipe->wire); + + return usb_device_register_endpoint(pipe->wire, + pipe->endpoint_no, pipe->transfer_type, + pipe->direction, pipe->max_packet_size, interval); +} +/*----------------------------------------------------------------------------*/ +/** Revert endpoint registration with the host controller. + * + * @param pipe Pipe to be unregistered. + * @return Error code. + */ +int usb_pipe_unregister(usb_pipe_t *pipe) +{ + assert(pipe); + assert(pipe->wire); + + return usb_device_unregister_endpoint(pipe->wire, + pipe->endpoint_no, pipe->direction); } Index: uspace/lib/usbdev/src/pipesinit.c =================================================================== --- uspace/lib/usbdev/src/pipesinit.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/pipesinit.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -31,5 +31,5 @@ */ /** @file - * Initialization of endpoint pipes. + * Non trivial initialization of endpoint pipes. * */ @@ -38,11 +38,8 @@ #include #include -#include #include #include -#define CTRL_PIPE_MIN_PACKET_SIZE 8 #define DEV_DESCR_MAX_PACKET_SIZE_OFFSET 7 - #define NESTING(parentname, childname) \ @@ -327,59 +324,4 @@ return EOK; -} - -/** Initialize USB endpoint pipe. - * - * @param pipe Endpoint pipe to be initialized. - * @param connection Connection to the USB device backing this pipe (the wire). - * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15). - * @param transfer_type Transfer type (e.g. interrupt or bulk). - * @param max_packet_size Maximum packet size in bytes. - * @param direction Endpoint direction (in/out). - * @return Error code. - */ -int usb_pipe_initialize(usb_pipe_t *pipe, - usb_device_connection_t *connection, usb_endpoint_t endpoint_no, - usb_transfer_type_t transfer_type, size_t max_packet_size, - usb_direction_t direction) -{ - assert(pipe); - assert(connection); - - fibril_mutex_initialize(&pipe->guard); - pipe->wire = connection; - pipe->hc_sess = NULL; - fibril_mutex_initialize(&pipe->hc_sess_mutex); - pipe->endpoint_no = endpoint_no; - pipe->transfer_type = transfer_type; - pipe->max_packet_size = max_packet_size; - pipe->direction = direction; - pipe->refcount = 0; - pipe->refcount_soft = 0; - pipe->auto_reset_halt = false; - - return EOK; -} - - -/** Initialize USB endpoint pipe as the default zero control pipe. - * - * @param pipe Endpoint pipe to be initialized. - * @param connection Connection to the USB device backing this pipe (the wire). - * @return Error code. - */ -int usb_pipe_initialize_default_control(usb_pipe_t *pipe, - usb_device_connection_t *connection) -{ - assert(pipe); - assert(connection); - - int rc = usb_pipe_initialize(pipe, connection, - 0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE, - USB_DIRECTION_BOTH); - - pipe->auto_reset_halt = true; - - return rc; } @@ -435,57 +377,4 @@ } -/** Register endpoint with the host controller. - * - * @param pipe Pipe to be registered. - * @param interval Polling interval. - * @param hc_connection Connection to the host controller (must be opened). - * @return Error code. - */ -int usb_pipe_register(usb_pipe_t *pipe, unsigned interval, - usb_hc_connection_t *hc_connection) -{ - assert(pipe); - 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); - 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); - return ret; -} - -/** Revert endpoint registration with the host controller. - * - * @param pipe Pipe to be unregistered. - * @param hc_connection Connection to the host controller (must be opened). - * @return Error code. - */ -int usb_pipe_unregister(usb_pipe_t *pipe, - usb_hc_connection_t *hc_connection) -{ - assert(pipe); - 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); - if (!exch) - return ENOMEM; - const int ret = usbhc_unregister_endpoint(exch, - pipe->wire->address, pipe->endpoint_no, pipe->direction); - async_exchange_end(exch); - - return ret; -} - /** * @} Index: uspace/lib/usbdev/src/pipesio.c =================================================================== --- uspace/lib/usbdev/src/pipesio.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ (revision ) @@ -1,316 +1,0 @@ -/* - * Copyright (c) 2011 Vojtech Horky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libusbdev - * @{ - */ -/** @file - * Input and output functions (reads and writes) on endpoint pipes. - * - * Note on synchronousness of the operations: there is ABSOLUTELY NO - * guarantee that a call to particular function will not trigger a fibril - * switch. - * - * Note about the implementation: the transfer requests are always divided - * into two functions. - * The outer one does checking of input parameters (e.g. that session was - * already started, buffers are not NULL etc), while the inner one - * (with _no_checks suffix) does the actual IPC (it checks for IPC errors, - * obviously). - */ - -#include -#include -#include -#include -#include -#include -#include -#include "pipepriv.h" - -/** Request an in transfer, no checking of input parameters. - * - * @param[in] pipe Pipe used for the transfer. - * @param[out] buffer Buffer where to store the data. - * @param[in] size Size of the buffer (in bytes). - * @param[out] size_transfered Number of bytes that were actually transfered. - * @return Error code. - */ -static int usb_pipe_read_no_check(usb_pipe_t *pipe, uint64_t setup, - void *buffer, size_t size, size_t *size_transfered) -{ - /* Isochronous transfer are not supported (yet) */ - if (pipe->transfer_type != USB_TRANSFER_INTERRUPT && - pipe->transfer_type != USB_TRANSFER_BULK && - pipe->transfer_type != USB_TRANSFER_CONTROL) - return ENOTSUP; - - int ret = pipe_add_ref(pipe, false); - if (ret != EOK) { - return ret; - } - - /* Ensure serialization over the phone. */ - pipe_start_transaction(pipe); - async_exch_t *exch = async_exchange_begin(pipe->hc_sess); - if (!exch) { - pipe_end_transaction(pipe); - pipe_drop_ref(pipe); - return ENOMEM; - } - - ret = usbhc_read(exch, pipe->wire->address, pipe->endpoint_no, - setup, buffer, size, size_transfered); - async_exchange_end(exch); - pipe_end_transaction(pipe); - pipe_drop_ref(pipe); - return ret; -} - -/** Request an out transfer, no checking of input parameters. - * - * @param[in] pipe Pipe used for the transfer. - * @param[in] buffer Buffer with data to transfer. - * @param[in] size Size of the buffer (in bytes). - * @return Error code. - */ -static int usb_pipe_write_no_check(usb_pipe_t *pipe, uint64_t setup, - const void *buffer, size_t size) -{ - /* Only interrupt and bulk transfers are supported */ - if (pipe->transfer_type != USB_TRANSFER_INTERRUPT && - pipe->transfer_type != USB_TRANSFER_BULK && - pipe->transfer_type != USB_TRANSFER_CONTROL) - return ENOTSUP; - - int ret = pipe_add_ref(pipe, false); - if (ret != EOK) { - return ret; - } - - /* Ensure serialization over the phone. */ - pipe_start_transaction(pipe); - async_exch_t *exch = async_exchange_begin(pipe->hc_sess); - if (!exch) { - pipe_end_transaction(pipe); - pipe_drop_ref(pipe); - return ENOMEM; - } - ret = usbhc_write(exch, pipe->wire->address, pipe->endpoint_no, - setup, buffer, size); - async_exchange_end(exch); - pipe_end_transaction(pipe); - pipe_drop_ref(pipe); - return ret; -} - -/** Try to clear endpoint halt of default control pipe. - * - * @param pipe Pipe for control endpoint zero. - */ -static void clear_self_endpoint_halt(usb_pipe_t *pipe) -{ - assert(pipe != NULL); - - if (!pipe->auto_reset_halt || (pipe->endpoint_no != 0)) { - return; - } - - - /* Prevent infinite recursion. */ - pipe->auto_reset_halt = false; - usb_request_clear_endpoint_halt(pipe, 0); - pipe->auto_reset_halt = true; -} - -/** Request a control read transfer on an endpoint pipe. - * - * This function encapsulates all three stages of a control transfer. - * - * @param[in] pipe Pipe used for the transfer. - * @param[in] setup_buffer Buffer with the setup packet. - * @param[in] setup_buffer_size Size of the setup packet (in bytes). - * @param[out] data_buffer Buffer for incoming data. - * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes). - * @param[out] data_transfered_size Number of bytes that were actually - * transfered during the DATA stage. - * @return Error code. - */ -int usb_pipe_control_read(usb_pipe_t *pipe, - const void *setup_buffer, size_t setup_buffer_size, - void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size) -{ - assert(pipe); - - if ((setup_buffer == NULL) || (setup_buffer_size != 8)) { - return EINVAL; - } - - if ((data_buffer == NULL) || (data_buffer_size == 0)) { - return EINVAL; - } - - if ((pipe->direction != USB_DIRECTION_BOTH) - || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { - return EBADF; - } - - uint64_t setup_packet; - memcpy(&setup_packet, setup_buffer, 8); - - size_t act_size = 0; - const int rc = usb_pipe_read_no_check(pipe, setup_packet, - data_buffer, data_buffer_size, &act_size); - - if (rc == ESTALL) { - clear_self_endpoint_halt(pipe); - } - - if (rc == EOK && data_transfered_size != NULL) { - *data_transfered_size = act_size; - } - - return rc; -} - -/** Request a control write transfer on an endpoint pipe. - * - * This function encapsulates all three stages of a control transfer. - * - * @param[in] pipe Pipe used for the transfer. - * @param[in] setup_buffer Buffer with the setup packet. - * @param[in] setup_buffer_size Size of the setup packet (in bytes). - * @param[in] data_buffer Buffer with data to be sent. - * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes). - * @return Error code. - */ -int usb_pipe_control_write(usb_pipe_t *pipe, - const void *setup_buffer, size_t setup_buffer_size, - const void *data_buffer, size_t data_buffer_size) -{ - assert(pipe); - - if ((setup_buffer == NULL) || (setup_buffer_size != 8)) { - return EINVAL; - } - - if ((data_buffer == NULL) && (data_buffer_size > 0)) { - return EINVAL; - } - - if ((data_buffer != NULL) && (data_buffer_size == 0)) { - return EINVAL; - } - - if ((pipe->direction != USB_DIRECTION_BOTH) - || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { - return EBADF; - } - - uint64_t setup_packet; - memcpy(&setup_packet, setup_buffer, 8); - - const int rc = usb_pipe_write_no_check(pipe, setup_packet, - data_buffer, data_buffer_size); - - if (rc == ESTALL) { - clear_self_endpoint_halt(pipe); - } - - return rc; -} - -/** Request a read (in) transfer on an endpoint pipe. - * - * @param[in] pipe Pipe used for the transfer. - * @param[out] buffer Buffer where to store the data. - * @param[in] size Size of the buffer (in bytes). - * @param[out] size_transfered Number of bytes that were actually transfered. - * @return Error code. - */ -int usb_pipe_read(usb_pipe_t *pipe, - void *buffer, size_t size, size_t *size_transfered) -{ - assert(pipe); - - if (buffer == NULL) { - return EINVAL; - } - - if (size == 0) { - return EINVAL; - } - - if (pipe->direction != USB_DIRECTION_IN) { - return EBADF; - } - - if (pipe->transfer_type == USB_TRANSFER_CONTROL) { - return EBADF; - } - - size_t act_size = 0; - const int rc = usb_pipe_read_no_check(pipe, 0, buffer, size, &act_size); - - - if (rc == EOK && size_transfered != NULL) { - *size_transfered = act_size; - } - - return rc; -} - -/** Request a write (out) transfer on an endpoint pipe. - * - * @param[in] pipe Pipe used for the transfer. - * @param[in] buffer Buffer with data to transfer. - * @param[in] size Size of the buffer (in bytes). - * @return Error code. - */ -int usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size) -{ - assert(pipe); - - if (buffer == NULL || size == 0) { - return EINVAL; - } - - if (pipe->direction != USB_DIRECTION_OUT) { - return EBADF; - } - - if (pipe->transfer_type == USB_TRANSFER_CONTROL) { - return EBADF; - } - - return usb_pipe_write_no_check(pipe, 0, buffer, size); -} - -/** - * @} - */ Index: uspace/lib/usbdev/src/recognise.c =================================================================== --- uspace/lib/usbdev/src/recognise.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbdev/src/recognise.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -45,9 +45,4 @@ #include #include - -/** Index to append after device name for uniqueness. */ -static size_t device_name_index = 0; -/** Mutex guard for device_name_index. */ -static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex); /** DDF operations of child devices. */ @@ -329,7 +324,8 @@ } - fibril_mutex_lock(&device_name_index_mutex); - const size_t this_device_name_index = device_name_index++; - fibril_mutex_unlock(&device_name_index_mutex); + /** Index to append after device name for uniqueness. */ + static atomic_t device_name_index = {0}; + const size_t this_device_name_index = + (size_t) atomic_preinc(&device_name_index); ddf_fun_t *child = NULL; Index: uspace/lib/usbhost/include/usb/host/endpoint.h =================================================================== --- uspace/lib/usbhost/include/usb/host/endpoint.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/include/usb/host/endpoint.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -95,9 +95,9 @@ /** list_get_instance wrapper. * @param item Pointer to link member. - * @return Pointer to enpoint_t structure. + * @return Pointer to endpoint_t structure. */ static inline endpoint_t * endpoint_get_instance(link_t *item) { - return list_get_instance(item, endpoint_t, link); + return item ? list_get_instance(item, endpoint_t, link) : NULL; } #endif Index: uspace/lib/usbhost/include/usb/host/usb_device_manager.h =================================================================== --- uspace/lib/usbhost/include/usb/host/usb_device_manager.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/include/usb/host/usb_device_manager.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -59,5 +59,7 @@ devman_handle_t handle; /**< Devman handle of the device. */ } devices[USB_ADDRESS_COUNT]; + /** Maximum speed allowed. */ usb_speed_t max_speed; + /** Protect access to members. */ fibril_mutex_t guard; /** The last reserved address */ Index: uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h =================================================================== --- uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -65,10 +65,17 @@ */ size_t setup_size; - /** Actually used portion of the buffer */ - size_t transfered_size; - /** Indicates success/failure of the communication */ - int error; /** Host controller function, passed to callback function */ ddf_fun_t *fun; + + /** Actually used portion of the buffer + * This member is never accessed by functions provided in this header, + * with the exception of usb_transfer_batch_finish. For external use. + */ + size_t transfered_size; + /** Indicates success/failure of the communication + * This member is never accessed by functions provided in this header, + * with the exception of usb_transfer_batch_finish. For external use. + */ + int error; /** Driver specific data */ @@ -106,20 +113,18 @@ void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance); -void usb_transfer_batch_finish(const usb_transfer_batch_t *instance, - const void* data, size_t size); +void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance, + const void* data, size_t size, int error); /*----------------------------------------------------------------------------*/ -/** Override error value and finishes transfer. +/** Finish batch using stored error value and transferred size. * * @param[in] instance Batch structure to use. * @param[in] data Data to copy to the output buffer. - * @param[in] size Size of @p data. - * @param[in] error Set batch status to this error value. */ -static inline void usb_transfer_batch_finish_error( - usb_transfer_batch_t *instance, const void* data, size_t size, int error) +static inline void usb_transfer_batch_finish( + const usb_transfer_batch_t *instance, const void* data) { assert(instance); - instance->error = error; - usb_transfer_batch_finish(instance, data, size); + usb_transfer_batch_finish_error( + instance, data, instance->transfered_size, instance->error); } /*----------------------------------------------------------------------------*/ Index: uspace/lib/usbhost/src/iface.c =================================================================== --- uspace/lib/usbhost/src/iface.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/src/iface.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -39,4 +39,14 @@ #include +/** Prepare generic usb_transfer_batch and schedule it. + * @param fun DDF fun + * @param target address and endpoint number. + * @param setup_data Data to use in setup stage (Control communication type) + * @param in Callback for device to host communication. + * @param out Callback for host to device communication. + * @param arg Callback parameter. + * @param name Communication identifier (for nicer output). + * @return Error code. + */ static inline int send_batch( ddf_fun_t *fun, usb_target_t target, usb_direction_t direction, @@ -89,4 +99,9 @@ } /*----------------------------------------------------------------------------*/ +/** Calls ep_add_hook upon endpoint registration. + * @param ep Endpoint to be registered. + * @param arg hcd_t in disguise. + * @return Error code. + */ static int register_helper(endpoint_t *ep, void *arg) { @@ -99,4 +114,8 @@ } /*----------------------------------------------------------------------------*/ +/** Calls ep_remove_hook upon endpoint removal. + * @param ep Endpoint to be unregistered. + * @param arg hcd_t in disguise. + */ static void unregister_helper(endpoint_t *ep, void *arg) { @@ -108,4 +127,8 @@ } /*----------------------------------------------------------------------------*/ +/** Calls ep_remove_hook upon endpoint removal. Prints warning. + * @param ep Endpoint to be unregistered. + * @param arg hcd_t in disguise. + */ static void unregister_helper_warn(endpoint_t *ep, void *arg) { @@ -119,9 +142,11 @@ } /*----------------------------------------------------------------------------*/ -/** Request address interface function +/** Request address interface function. * * @param[in] fun DDF function that was called. + * @param[in] address Pointer to preferred USB address. + * @param[out] address Place to write a new address. + * @param[in] strict Fail if the preferred address is not available. * @param[in] speed Speed to associate with the new default address. - * @param[out] address Place to write a new address. * @return Error code. */ @@ -140,5 +165,5 @@ } /*----------------------------------------------------------------------------*/ -/** Bind address interface function +/** Bind address interface function. * * @param[in] fun DDF function that was called. @@ -148,5 +173,5 @@ */ static int bind_address( - ddf_fun_t *fun, usb_address_t address, devman_handle_t handle) + ddf_fun_t *fun, usb_address_t address, devman_handle_t handle) { assert(fun); @@ -176,5 +201,5 @@ } /*----------------------------------------------------------------------------*/ -/** Release address interface function +/** Release address interface function. * * @param[in] fun DDF function that was called. @@ -194,8 +219,18 @@ } /*----------------------------------------------------------------------------*/ +/** Register endpoint interface function. + * @param fun DDF function. + * @param address USB address of the device. + * @param endpoint USB endpoint number to be registered. + * @param transfer_type Endpoint's transfer type. + * @param direction USB communication direction the endpoint is capable of. + * @param max_packet_size Maximu size of packets the endpoint accepts. + * @param interval Preferred timeout between communication. + * @return Error code. + */ static int register_endpoint( ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint, usb_transfer_type_t transfer_type, usb_direction_t direction, - size_t max_packet_size, unsigned int interval) + size_t max_packet_size, unsigned interval) { assert(fun); @@ -220,4 +255,11 @@ } /*----------------------------------------------------------------------------*/ +/** Unregister endpoint interface function. + * @param fun DDF function. + * @param address USB address of the endpoint. + * @param endpoint USB endpoint number. + * @param direction Communication direction of the enpdoint to unregister. + * @return Error code. + */ static int unregister_endpoint( ddf_fun_t *fun, usb_address_t address, @@ -233,4 +275,14 @@ } /*----------------------------------------------------------------------------*/ +/** Inbound communication interface function. + * @param fun DDF function. + * @param target Communication target. + * @param setup_data Data to use in setup stage (control transfers). + * @param data Pointer to data buffer. + * @param size Size of the data buffer. + * @param callback Function to call on communication end. + * @param arg Argument passed to the callback function. + * @return Error code. + */ static int usb_read(ddf_fun_t *fun, usb_target_t target, uint64_t setup_data, uint8_t *data, size_t size, usbhc_iface_transfer_in_callback_t callback, @@ -241,4 +293,14 @@ } /*----------------------------------------------------------------------------*/ +/** Outbound communication interface function. + * @param fun DDF function. + * @param target Communication target. + * @param setup_data Data to use in setup stage (control transfers). + * @param data Pointer to data buffer. + * @param size Size of the data buffer. + * @param callback Function to call on communication end. + * @param arg Argument passed to the callback function. + * @return Error code. + */ static int usb_write(ddf_fun_t *fun, usb_target_t target, uint64_t setup_data, const uint8_t *data, size_t size, @@ -249,4 +311,5 @@ } /*----------------------------------------------------------------------------*/ +/** usbhc Interface implementation using hcd_t from libusbhost library. */ usbhc_iface_t hcd_iface = { .request_address = request_address, Index: uspace/lib/usbhost/src/usb_device_manager.c =================================================================== --- uspace/lib/usbhost/src/usb_device_manager.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/src/usb_device_manager.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -26,5 +26,4 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - /** @addtogroup libusbhost * @{ @@ -41,5 +40,4 @@ * * @param[in] instance Device manager structure to use. - * @param[in] speed Speed of the device requiring address. * @return Free address, or error code. */ @@ -133,4 +131,5 @@ * @param[in] handle Devman handle of the device. * @return Error code. + * @note Won't accept binding for default address. */ int usb_device_manager_bind_address(usb_device_manager_t *instance, @@ -184,5 +183,5 @@ } /*----------------------------------------------------------------------------*/ -/** Find USB address associated with the device +/** Find USB address associated with the device. * * @param[in] instance Device manager structure to use. @@ -208,5 +207,4 @@ /*----------------------------------------------------------------------------*/ /** Find devman handle and speed assigned to USB address. - * Intentionally refuse to work on default address. * * @param[in] instance Device manager structure to use. Index: uspace/lib/usbhost/src/usb_endpoint_manager.c =================================================================== --- uspace/lib/usbhost/src/usb_endpoint_manager.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/src/usb_endpoint_manager.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -26,4 +26,10 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/** @addtogroup libusbhost + * @{ + */ +/** @file + * HC Endpoint management. + */ #include @@ -56,5 +62,5 @@ } /*----------------------------------------------------------------------------*/ -/** Get list that holds endpints for given address. +/** Get list that holds endpoints for given address. * @param instance usb_endpoint_manager structure, non-null. * @param addr USB address, must be >= 0. @@ -75,4 +81,5 @@ * @return Pointer to endpoint_t structure representing given communication * target, NULL if there is no such endpoint registered. + * @note Assumes that the internal mutex is locked. */ static endpoint_t * find_locked(usb_endpoint_manager_t *instance, @@ -169,4 +176,5 @@ * * Really ugly one. Resets toggle bit on all endpoints that need it. + * @TODO Use tools from libusbdev requests.h */ void usb_endpoint_manager_reset_eps_if_need(usb_endpoint_manager_t *instance, @@ -184,4 +192,5 @@ case 0x01: /* Clear Feature -- resets only cleared ep */ /* Recipient is endpoint, value is zero (ENDPOINT_STALL) */ + // TODO Use macros in libusbdev requests.h if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) { fibril_mutex_lock(&instance->guard); @@ -202,5 +211,7 @@ /* Recipient must be device, this resets all endpoints, * In fact there should be no endpoints but EP 0 registered - * as different interfaces use different endpoints. */ + * as different interfaces use different endpoints, + * unless you're changing configuration or alternative + * interface of an already setup device. */ if ((data[0] & 0xf) == 0) { fibril_mutex_lock(&instance->guard); @@ -385,4 +396,13 @@ } /*----------------------------------------------------------------------------*/ +/** Unregister and destroy all endpoints using given address. + * @param instance usb_endpoint_manager structure, non-null. + * @param address USB address. + * @param endpoint USB endpoint number. + * @param direction Communication direction. + * @param callback Function to call after unregister, before destruction. + * @arg Argument to pass to the callback function. + * @return Error code. + */ void usb_endpoint_manager_remove_address(usb_endpoint_manager_t *instance, usb_address_t address, void (*callback)(endpoint_t *, void *), void *arg) @@ -403,2 +423,5 @@ fibril_mutex_unlock(&instance->guard); } +/** + * @} + */ Index: uspace/lib/usbhost/src/usb_transfer_batch.c =================================================================== --- uspace/lib/usbhost/src/usb_transfer_batch.c (revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9) +++ uspace/lib/usbhost/src/usb_transfer_batch.c (revision 2943db4eacf000472ce550d084e8e01062821b25) @@ -33,5 +33,5 @@ */ #include -#include +#include #include @@ -48,4 +48,5 @@ * @param func_in callback on IN transfer completion. * @param func_out callback on OUT transfer completion. + * @param fun DDF function (passed to callback function). * @param arg Argument to pass to the callback function. * @param private_data driver specific per batch data. @@ -121,7 +122,8 @@ * @param[in] data Data to copy to the output buffer. * @param[in] size Size of @p data. + * @param[in] error Error value to use. */ -void usb_transfer_batch_finish( - const usb_transfer_batch_t *instance, const void *data, size_t size) +void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance, + const void *data, size_t size, int error) { assert(instance); @@ -133,5 +135,5 @@ /* Check for commands that reset toggle bit */ if (instance->ep->transfer_type == USB_TRANSFER_CONTROL - && instance->error == EOK) { + && error == EOK) { const usb_target_t target = {{ instance->ep->address, instance->ep->endpoint }}; @@ -139,17 +141,15 @@ instance->setup_buffer); } - instance->callback_out(instance->fun, - instance->error, instance->arg); + instance->callback_out(instance->fun, error, instance->arg); } if (instance->callback_in) { /* We care about the data and there are some to copy */ + const size_t safe_size = min(size, instance->buffer_size); if (data) { - const size_t min_size = size < instance->buffer_size - ? size : instance->buffer_size; - memcpy(instance->buffer, data, min_size); + memcpy(instance->buffer, data, safe_size); } - instance->callback_in(instance->fun, instance->error, - instance->transfered_size, instance->arg); + instance->callback_in(instance->fun, error, + safe_size, instance->arg); } }