Changeset b4b534ac for uspace/lib – HelenOS

uspace/lib/c/generic/l18n/langs.c

r5b18137	rb4b534ac
66	66	case L18N_WIN_LOCALE_ZULU:
67	67	return "Zulu";
	68	default:
	69	break;
68	70	}
69	71

uspace/lib/c/include/adt/list.h

r5b18137	rb4b534ac
133	133
134	134	/** Returns true if the link is definitely part of a list. False if not sure. */
135		static inline bool link_in_use(link_t *link)
	135	static inline bool link_in_use(const link_t *link)
136	136	{
137	137	return link->prev != NULL && link->next != NULL;
…	…
263	263	*
264	264	*/
265		static inline link_t list_last(list_t list)
	265	static inline link_t list_last(const list_t list)
266	266	{
267	267	return (list->head.prev == &list->head) ? NULL : list->head.prev;
…	…
276	276	*
277	277	*/
278		static inline link_t list_next(link_t link, const list_t *list)
	278	static inline link_t list_next(const link_t link, const list_t *list)
279	279	{
280	280	return (link->next == &list->head) ? NULL : link->next;
…	…
289	289	*
290	290	*/
291		static inline link_t list_prev(link_t link, const list_t *list)
	291	static inline link_t list_prev(const link_t link, const list_t *list)
292	292	{
293	293	return (link->prev == &list->head) ? NULL : link->prev;
…	…
357	357	*
358	358	*/
359		static inline link_t list_nth(list_t list, unsigned long n)
	359	static inline link_t list_nth(const list_t list, unsigned long n)
360	360	{
361	361	unsigned long cnt = 0;

uspace/lib/c/include/l18n/langs.h

-              r5b18137
+              rb4b534ac
         L18N_WIN_LOCALE_SPANISH_TRADITIONAL = 0x040A,
         /* ... */
+        L18N_WIN_LOCALE_ZULU = 0x0435
+        L18N_WIN_LOCALE_ZULU = 0x0435,
+        L18N_WIN_LOCALE_MAX = 0xFFFF
 } l18_win_locales_t;

uspace/lib/c/include/macros.h

r5b18137	rb4b534ac
69	69	#define PADD8 _padd(8, __LINE__)
70	70
	71	#define STATIC_ASSERT(cond) int sassert[(cond) ? 1 : -1]
	72
71	73	/** @}
72	74	*/

uspace/lib/drv/generic/driver.c

-              r5b18137
+              rb4b534ac
         assert(fun->bound == false);
         assert(fun->name != NULL);
+        assert(fun->dev != NULL);
         add_to_functions_list(fun);
 …
 /** Set function ops. */
 void ddf_fun_set_ops(ddf_fun_t *fun, ddf_dev_ops_t *dev_ops)
+void ddf_fun_set_ops(ddf_fun_t *fun, const ddf_dev_ops_t *dev_ops)
+{
         assert(fun->conn_handler == NULL);

uspace/lib/drv/generic/private/driver.h

r5b18137	rb4b534ac
93	93
94	94	/** Implementation of operations provided by this function */
95		ddf_dev_ops_t *ops;
	95	const ddf_dev_ops_t *ops;
96	96
97	97	/** Connection handler or @c NULL to use the DDF default handler. */

uspace/lib/drv/generic/remote_usb.c

-              r5b18137
+              rb4b534ac
 #include <async.h>
+#include <macros.h>
 #include <errno.h>
 #include <macros.h>
+#include <devman.h>
 #include "usb_iface.h"
 #include "ddf/driver.h"
+usb_dev_session_t *usb_dev_connect(devman_handle_t handle)
+{
+        return devman_device_connect(handle, IPC_FLAG_BLOCKING);
+}
+usb_dev_session_t *usb_dev_connect_to_self(ddf_dev_t *dev)
+{
+        return devman_parent_device_connect(ddf_dev_get_handle(dev), IPC_FLAG_BLOCKING);
+}
+void usb_dev_disconnect(usb_dev_session_t *sess)
+{
+        if (sess)
+                async_hangup(sess);
+}
 typedef enum {
-        IPC_M_USB_GET_MY_ADDRESS,
         IPC_M_USB_GET_MY_INTERFACE,
+        IPC_M_USB_GET_HOST_CONTROLLER_HANDLE,
+        IPC_M_USB_GET_MY_DEVICE_HANDLE,
+        IPC_M_USB_RESERVE_DEFAULT_ADDRESS,
+        IPC_M_USB_RELEASE_DEFAULT_ADDRESS,
+        IPC_M_USB_DEVICE_ENUMERATE,
+        IPC_M_USB_DEVICE_REMOVE,
+        IPC_M_USB_REGISTER_ENDPOINT,
+        IPC_M_USB_UNREGISTER_ENDPOINT,
+        IPC_M_USB_READ,
+        IPC_M_USB_WRITE,
 } usb_iface_funcs_t;
-/** Tell USB address assigned to device.
- * @param exch Vaid IPC exchange
- * @param address Pointer to address storage place.
- * @return Error code.
+ *
- * Exch param is an open communication to device implementing usb_iface.
- */
-int usb_get_my_address(async_exch_t *exch, usb_address_t *address)
+{
-        if (!exch)
-                return EBADMEM;
-        sysarg_t addr;
-        const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
-            IPC_M_USB_GET_MY_ADDRESS, &addr);
-        if (ret == EOK && address != NULL)
-                *address = (usb_address_t) addr;
-        return ret;
+}
 /** Tell interface number given device can use.
 …
+}
 /** Tell devman handle of device host controller.
+/** Tell devman handle of the usb device function.
  * @param[in] exch IPC communication exchange
  * @param[out] hc_handle devman handle of the HC used by the target device.
+ * @param[out] handle devman handle of the HC used by the target device.
  * @return Error code.
  */
+int usb_get_hc_handle(async_exch_t *exch, devman_handle_t *hc_handle)
+{
+        if (!exch)
+                return EBADMEM;
+        devman_handle_t h;
+int usb_get_my_device_handle(async_exch_t *exch, devman_handle_t *handle)
+{
+        devman_handle_t h = 0;
         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
             IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
         if (ret == EOK && hc_handle)
                 *hc_handle = (devman_handle_t)h;
+            IPC_M_USB_GET_MY_DEVICE_HANDLE, &h);
+        if (ret == EOK && handle)
+                *handle = (devman_handle_t)h;
         return ret;
+}
+static void remote_usb_get_my_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+/** Reserve default USB address.
+ * @param[in] exch IPC communication exchange
+ * @param[in] speed Communication speed of the newly attached device
+ * @return Error code.
+ */
+int usb_reserve_default_address(async_exch_t *exch, usb_speed_t speed)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_2_0(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_RESERVE_DEFAULT_ADDRESS, speed);
+}
+/** Release default USB address.
+ * @param[in] exch IPC communication exchange
+ * @return Error code.
+ */
+int usb_release_default_address(async_exch_t *exch)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_1_0(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_RELEASE_DEFAULT_ADDRESS);
+}
+/** Trigger USB device enumeration
+ * @param[in] exch IPC communication exchange
+ * @param[out] handle Identifier of the newly added device (if successful)
+ * @return Error code.
+ */
+int usb_device_enumerate(async_exch_t *exch, unsigned port)
+{
+        if (!exch)
+                return EBADMEM;
+        const int ret = async_req_2_0(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_DEVICE_ENUMERATE, port);
+        return ret;
+}
+/** Trigger USB device enumeration
+ * @param[in] exch IPC communication exchange
+ * @param[in] handle Identifier of the device
+ * @return Error code.
+ */
+int usb_device_remove(async_exch_t *exch, unsigned port)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_2_0(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_DEVICE_REMOVE, port);
+}
+int static_assert[sizeof(sysarg_t) >= 4 ? 1 : -1];
+typedef union {
+        uint8_t arr[sizeof(sysarg_t)];
+        sysarg_t arg;
+} pack8_t;
+int usb_register_endpoint(async_exch_t *exch, usb_endpoint_t endpoint,
+    usb_transfer_type_t type, usb_direction_t direction,
+    size_t mps, unsigned packets, unsigned interval)
+{
+        if (!exch)
+                return EBADMEM;
+        pack8_t pack;
+        pack.arr[0] = type;
+        pack.arr[1] = direction;
+        pack.arr[2] = interval;
+        pack.arr[3] = packets;
+        return async_req_4_0(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_REGISTER_ENDPOINT, endpoint, pack.arg, mps);
+}
+int usb_unregister_endpoint(async_exch_t *exch, usb_endpoint_t endpoint,
+    usb_direction_t direction)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_3_0(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_UNREGISTER_ENDPOINT, endpoint, direction);
+}
+int usb_read(async_exch_t *exch, usb_endpoint_t endpoint, uint64_t setup,
+    void *data, size_t size, size_t *rec_size)
+{
+        if (!exch)
+                return EBADMEM;
+        if (size == 0 && setup == 0)
+                return EOK;
+        /* Make call identifying target USB device and type of transfer. */
+        aid_t opening_request = async_send_4(exch,
+            DEV_IFACE_ID(USB_DEV_IFACE), IPC_M_USB_READ, endpoint,
+            (setup & UINT32_MAX), (setup >> 32), NULL);
+        if (opening_request == 0) {
+                return ENOMEM;
+        }
+        /* Retrieve the data. */
+        ipc_call_t data_request_call;
+        aid_t data_request =
+            async_data_read(exch, data, size, &data_request_call);
+        if (data_request == 0) {
+                // FIXME: How to let the other side know that we want to abort?
+                async_forget(opening_request);
+                return ENOMEM;
+        }
+        /* Wait for the answer. */
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(opening_request, &opening_request_rc);
+        if (data_request_rc != EOK) {
+                /* Prefer the return code of the opening request. */
+                if (opening_request_rc != EOK) {
+                        return (int) opening_request_rc;
+                } else {
+                        return (int) data_request_rc;
+                }
+        }
+        if (opening_request_rc != EOK) {
+                return (int) opening_request_rc;
+        }
+        *rec_size = IPC_GET_ARG2(data_request_call);
+        return EOK;
+}
+int usb_write(async_exch_t *exch, usb_endpoint_t endpoint, uint64_t setup,
+    const void *data, size_t size)
+{
+        if (!exch)
+                return EBADMEM;
+        if (size == 0 && setup == 0)
+                return EOK;
+        aid_t opening_request = async_send_5(exch,
+            DEV_IFACE_ID(USB_DEV_IFACE), IPC_M_USB_WRITE, endpoint, size,
+            (setup & UINT32_MAX), (setup >> 32), NULL);
+        if (opening_request == 0) {
+                return ENOMEM;
+        }
+        /* Send the data if any. */
+        if (size > 0) {
+                const int ret = async_data_write_start(exch, data, size);
+                if (ret != EOK) {
+                        async_forget(opening_request);
+                        return ret;
+                }
+        }
+        /* Wait for the answer. */
+        sysarg_t opening_request_rc;
+        async_wait_for(opening_request, &opening_request_rc);
+        return (int) opening_request_rc;
+}
 static void remote_usb_get_my_interface(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_get_hc_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_get_my_device_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_reserve_default_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_release_default_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_device_enumerate(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_device_remove(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_unregister_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usb_read(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call);
+static void remote_usb_write(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call);
 /** Remote USB interface operations. */
 static const remote_iface_func_ptr_t remote_usb_iface_ops [] = {
-        [IPC_M_USB_GET_MY_ADDRESS] = remote_usb_get_my_address,
         [IPC_M_USB_GET_MY_INTERFACE] = remote_usb_get_my_interface,
+        [IPC_M_USB_GET_HOST_CONTROLLER_HANDLE] = remote_usb_get_hc_handle,
+        [IPC_M_USB_GET_MY_DEVICE_HANDLE] = remote_usb_get_my_device_handle,
+        [IPC_M_USB_RESERVE_DEFAULT_ADDRESS] = remote_usb_reserve_default_address,
+        [IPC_M_USB_RELEASE_DEFAULT_ADDRESS] = remote_usb_release_default_address,
+        [IPC_M_USB_DEVICE_ENUMERATE] = remote_usb_device_enumerate,
+        [IPC_M_USB_DEVICE_REMOVE] = remote_usb_device_remove,
+        [IPC_M_USB_REGISTER_ENDPOINT] = remote_usb_register_endpoint,
+        [IPC_M_USB_UNREGISTER_ENDPOINT] = remote_usb_unregister_endpoint,
+        [IPC_M_USB_READ] = remote_usb_read,
+        [IPC_M_USB_WRITE] = remote_usb_write,
 };
 …
 const remote_iface_t remote_usb_iface = {
         .method_count = ARRAY_SIZE(remote_usb_iface_ops),
         .methods = remote_usb_iface_ops
+        .methods = remote_usb_iface_ops,
 };
-void remote_usb_get_my_address(ddf_fun_t *fun, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
+{
-        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
-        if (usb_iface->get_my_address == NULL) {
-                async_answer_0(callid, ENOTSUP);
-                return;
+        }
-        usb_address_t address;
-        const int ret = usb_iface->get_my_address(fun, &address);
-        if (ret != EOK) {
-                async_answer_0(callid, ret);
-        } else {
-                async_answer_1(callid, EOK, address);
+        }
+}
 void remote_usb_get_my_interface(ddf_fun_t *fun, void *iface,
 …
+}
 void remote_usb_get_hc_handle(ddf_fun_t *fun, void *iface,
+void remote_usb_get_my_device_handle(ddf_fun_t *fun, void *iface,
     ipc_callid_t callid, ipc_call_t *call)
+{
         const usb_iface_t *usb_iface = (usb_iface_t *) iface;
         if (usb_iface->get_hc_handle == NULL) {
+        if (usb_iface->get_my_device_handle == NULL) {
                 async_answer_0(callid, ENOTSUP);
                 return;
 …
         devman_handle_t handle;
         const int ret = usb_iface->get_hc_handle(fun, &handle);
+        const int ret = usb_iface->get_my_device_handle(fun, &handle);
         if (ret != EOK) {
                 async_answer_0(callid, ret);
 …
         async_answer_1(callid, EOK, (sysarg_t) handle);
+}
+void remote_usb_reserve_default_address(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
+        if (usb_iface->reserve_default_address == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
+        const int ret = usb_iface->reserve_default_address(fun, speed);
+        async_answer_0(callid, ret);
+}
+void remote_usb_release_default_address(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
+        if (usb_iface->release_default_address == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const int ret = usb_iface->release_default_address(fun);
+        async_answer_0(callid, ret);
+}
+static void remote_usb_device_enumerate(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
+        if (usb_iface->device_enumerate == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const unsigned port = DEV_IPC_GET_ARG1(*call);
+        const int ret = usb_iface->device_enumerate(fun, port);
+        async_answer_0(callid, ret);
+}
+static void remote_usb_device_remove(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usb_iface_t *usb_iface = (usb_iface_t *) iface;
+        if (usb_iface->device_remove == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const unsigned port = DEV_IPC_GET_ARG1(*call);
+        const int ret = usb_iface->device_remove(fun, port);
+        async_answer_0(callid, ret);
+}
+static void remote_usb_register_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usb_iface_t *usb_iface = (usb_iface_t *) iface;
+        if (!usb_iface->register_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_endpoint_t endpoint = DEV_IPC_GET_ARG1(*call);
+        const pack8_t pack = { .arg = DEV_IPC_GET_ARG2(*call)};
+        const size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
+        const usb_transfer_type_t transfer_type = pack.arr[0];
+        const usb_direction_t direction = pack.arr[1];
+        unsigned packets = pack.arr[2];
+        unsigned interval = pack.arr[3];
+        const int ret = usb_iface->register_endpoint(fun, endpoint,
+            transfer_type, direction, max_packet_size, packets, interval);
+        async_answer_0(callid, ret);
+}
+static void remote_usb_unregister_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usb_iface_t *usb_iface = (usb_iface_t *) iface;
+        if (!usb_iface->unregister_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        usb_endpoint_t endpoint = (usb_endpoint_t) DEV_IPC_GET_ARG1(*call);
+        usb_direction_t direction = (usb_direction_t) DEV_IPC_GET_ARG2(*call);
+        int rc = usb_iface->unregister_endpoint(fun, endpoint, direction);
+        async_answer_0(callid, rc);
+}
+typedef struct {
+        ipc_callid_t caller;
+        ipc_callid_t data_caller;
+        void *buffer;
+} async_transaction_t;
+static void async_transaction_destroy(async_transaction_t *trans)
+{
+        if (trans == NULL) {
+                return;
+        }
+        if (trans->buffer != NULL) {
+                free(trans->buffer);
+        }
+        free(trans);
+}
+static async_transaction_t *async_transaction_create(ipc_callid_t caller)
+{
+        async_transaction_t *trans = malloc(sizeof(async_transaction_t));
+        if (trans == NULL) {
+                return NULL;
+        }
+        trans->caller = caller;
+        trans->data_caller = 0;
+        trans->buffer = NULL;
+        return trans;
+}
+static void callback_out(int outcome, void *arg)
+{
+        async_transaction_t *trans = arg;
+        async_answer_0(trans->caller, outcome);
+        async_transaction_destroy(trans);
+}
+static void callback_in(int outcome, size_t actual_size, void *arg)
+{
+        async_transaction_t *trans = (async_transaction_t *)arg;
+        if (outcome != EOK) {
+                async_answer_0(trans->caller, outcome);
+                if (trans->data_caller) {
+                        async_answer_0(trans->data_caller, EINTR);
+                }
+                async_transaction_destroy(trans);
+                return;
+        }
+        if (trans->data_caller) {
+                async_data_read_finalize(trans->data_caller,
+                    trans->buffer, actual_size);
+        }
+        async_answer_0(trans->caller, EOK);
+        async_transaction_destroy(trans);
+}
+void remote_usb_read(
+    ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(fun);
+        assert(iface);
+        assert(call);
+        const usb_iface_t *usb_iface = iface;
+        if (!usb_iface->read) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_endpoint_t ep = DEV_IPC_GET_ARG1(*call);
+        const uint64_t setup =
+            ((uint64_t)DEV_IPC_GET_ARG2(*call)) |
+            (((uint64_t)DEV_IPC_GET_ARG3(*call)) << 32);
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+        size_t size = 0;
+        if (!async_data_read_receive(&trans->data_caller, &size)) {
+                async_answer_0(callid, EPARTY);
+                return;
+        }
+        trans->buffer = malloc(size);
+        if (trans->buffer == NULL) {
+                async_answer_0(trans->data_caller, ENOMEM);
+                async_answer_0(callid, ENOMEM);
+                async_transaction_destroy(trans);
+        }
+        const int rc = usb_iface->read(
+            fun, ep, setup, trans->buffer, size, callback_in, trans);
+        if (rc != EOK) {
+                async_answer_0(trans->data_caller, rc);
+                async_answer_0(callid, rc);
+                async_transaction_destroy(trans);
+        }
+}
+void remote_usb_write(
+    ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(fun);
+        assert(iface);
+        assert(call);
+        const usb_iface_t *usb_iface = iface;
+        if (!usb_iface->write) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_endpoint_t ep = DEV_IPC_GET_ARG1(*call);
+        const size_t data_buffer_len = DEV_IPC_GET_ARG2(*call);
+        const uint64_t setup =
+            ((uint64_t)DEV_IPC_GET_ARG3(*call)) |
+            (((uint64_t)DEV_IPC_GET_ARG4(*call)) << 32);
+        async_transaction_t *trans = async_transaction_create(callid);
+        if (trans == NULL) {
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+        size_t size = 0;
+        if (data_buffer_len > 0) {
+                const int rc = async_data_write_accept(&trans->buffer, false,
+, data_buffer_len, 0, &size);
+                if (rc != EOK) {
+                        async_answer_0(callid, rc);
+                        async_transaction_destroy(trans);
+                        return;
+                }
+        }
+        const int rc = usb_iface->write(
+            fun, ep, setup, trans->buffer, size, callback_out, trans);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_transaction_destroy(trans);
+        }
+}
 /**
  * @}

uspace/lib/drv/generic/remote_usbhc.c

-              r5b18137
+              rb4b534ac
  */
 typedef enum {
-        /** Asks for address assignment by host controller.
-         * Answer:
-         * - ELIMIT - host controller run out of address
-         * - EOK - address assigned
-         * Answer arguments:
-         * - assigned address
+         *
-         * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
-         */
-        IPC_M_USBHC_REQUEST_ADDRESS,
-        /** Bind USB address with devman handle.
-         * Parameters:
-         * - USB address
-         * - devman handle
-         * Answer:
-         * - EOK - address binded
-         * - ENOENT - address is not in use
-         */
-        IPC_M_USBHC_BIND_ADDRESS,
-        /** Get handle binded with given USB address.
-         * Parameters
-         * - USB address
-         * Answer:
-         * - EOK - address binded, first parameter is the devman handle
-         * - ENOENT - address is not in use at the moment
-         */
-        IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
-        /** Release address in use.
-         * Arguments:
-         * - address to be released
-         * Answer:
-         * - ENOENT - address not in use
-         * - EPERM - trying to release default USB address
-         */
-        IPC_M_USBHC_RELEASE_ADDRESS,
-        /** Register endpoint attributes at host controller.
-         * This is used to reserve portion of USB bandwidth.
-         * When speed is invalid, speed of the device is used.
-         * Parameters:
-         * - USB address + endpoint number
-         *   - packed as ADDR << 16 + EP
-         * - speed + transfer type + direction
-         *   - packed as ( SPEED << 8 + TYPE ) << 8 + DIR
-         * - maximum packet size + interval (in milliseconds)
-         *   - packed as MPS << 16 + INT
-         * Answer:
-         * - EOK - reservation successful
-         * - ELIMIT - not enough bandwidth to satisfy the request
-         */
-        IPC_M_USBHC_REGISTER_ENDPOINT,
-        /** Revert endpoint registration.
-         * Parameters:
-         * - USB address
-         * - endpoint number
-         * - data direction
-         * Answer:
-         * - EOK - endpoint unregistered
-         * - ENOENT - unknown endpoint
-         */
-        IPC_M_USBHC_UNREGISTER_ENDPOINT,
         /** Get data from device.
          * See explanation at usb_iface_funcs_t (IN transaction).
 …
         IPC_M_USBHC_WRITE,
 } usbhc_iface_funcs_t;
-int usbhc_request_address(async_exch_t *exch, usb_address_t *address,
-    bool strict, usb_speed_t speed)
+{
-        if (!exch || !address)
-                return EBADMEM;
-        sysarg_t new_address;
-        const int ret = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_REQUEST_ADDRESS, *address, strict, speed, &new_address);
-        if (ret == EOK)
-                *address = (usb_address_t)new_address;
-        return ret;
+}
-int usbhc_bind_address(async_exch_t *exch, usb_address_t address,
-    devman_handle_t handle)
+{
-        if (!exch)
-                return EBADMEM;
-        return async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_BIND_ADDRESS, address, handle);
+}
-int usbhc_get_handle(async_exch_t *exch, usb_address_t address,
-    devman_handle_t *handle)
+{
-        if (!exch)
-                return EBADMEM;
-        sysarg_t h;
-        const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, address, &h);
-        if (ret == EOK && handle)
-                *handle = (devman_handle_t)h;
-        return ret;
+}
-int usbhc_release_address(async_exch_t *exch, usb_address_t address)
+{
-        if (!exch)
-                return EBADMEM;
-        return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RELEASE_ADDRESS, address);
+}
-int usbhc_register_endpoint(async_exch_t *exch, usb_address_t address,
-    usb_endpoint_t endpoint, usb_transfer_type_t type,
-    usb_direction_t direction, size_t mps, unsigned interval)
+{
-        if (!exch)
-                return EBADMEM;
-        const usb_target_t target =
-            {{ .address = address, .endpoint = endpoint }};
-#define _PACK2(high, low) (((high & 0xffff) << 16) | (low & 0xffff))
-        return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_REGISTER_ENDPOINT, target.packed,
-            _PACK2(type, direction), _PACK2(mps, interval));
-#undef _PACK2
+}
-int usbhc_unregister_endpoint(async_exch_t *exch, usb_address_t address,
-    usb_endpoint_t endpoint, usb_direction_t direction)
+{
-        if (!exch)
-                return EBADMEM;
-        return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_UNREGISTER_ENDPOINT, address, endpoint, direction);
+}
 int usbhc_read(async_exch_t *exch, usb_address_t address,
 …
+}
-static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_get_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_read(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_write(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
-//static void remote_usbhc(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 /** Remote USB host controller interface operations. */
 static const remote_iface_func_ptr_t remote_usbhc_iface_ops[] = {
-        [IPC_M_USBHC_REQUEST_ADDRESS] = remote_usbhc_request_address,
-        [IPC_M_USBHC_RELEASE_ADDRESS] = remote_usbhc_release_address,
-        [IPC_M_USBHC_BIND_ADDRESS] = remote_usbhc_bind_address,
-        [IPC_M_USBHC_GET_HANDLE_BY_ADDRESS] = remote_usbhc_get_handle,
-        [IPC_M_USBHC_REGISTER_ENDPOINT] = remote_usbhc_register_endpoint,
-        [IPC_M_USBHC_UNREGISTER_ENDPOINT] = remote_usbhc_unregister_endpoint,
         [IPC_M_USBHC_READ] = remote_usbhc_read,
         [IPC_M_USBHC_WRITE] = remote_usbhc_write,
 …
+}
+void remote_usbhc_request_address(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usb_iface = iface;
+        if (!usb_iface->request_address) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        usb_address_t address = DEV_IPC_GET_ARG1(*call);
+        const bool strict = DEV_IPC_GET_ARG2(*call);
+        const usb_speed_t speed = DEV_IPC_GET_ARG3(*call);
+        const int rc = usb_iface->request_address(fun, &address, strict, speed);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+        } else {
+                async_answer_1(callid, EOK, (sysarg_t) address);
+        }
+}
+void remote_usbhc_bind_address(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usb_iface = iface;
+        if (!usb_iface->bind_address) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
+        const devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call);
+        const int ret = usb_iface->bind_address(fun, address, handle);
+        async_answer_0(callid, ret);
+}
+void remote_usbhc_get_handle(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usb_iface = iface;
+        if (!usb_iface->get_handle) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
+        devman_handle_t handle;
+        const int ret = usb_iface->get_handle(fun, address, &handle);
+        if (ret == EOK) {
+                async_answer_1(callid, ret, handle);
+        } else {
+                async_answer_0(callid, ret);
+        }
+}
+void remote_usbhc_release_address(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usb_iface = iface;
+        if (!usb_iface->release_address) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
+        const int ret = usb_iface->release_address(fun, address);
+        async_answer_0(callid, ret);
+}
+static void callback_out(ddf_fun_t *fun,
+    int outcome, void *arg)
+static void callback_out(int outcome, void *arg)
+{
         async_transaction_t *trans = arg;
 …
+}
+static void callback_in(ddf_fun_t *fun,
+    int outcome, size_t actual_size, void *arg)
+static void callback_in(int outcome, size_t actual_size, void *arg)
+{
         async_transaction_t *trans = (async_transaction_t *)arg;
 …
+}
-void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
+{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        if (!usb_iface->register_endpoint) {
-                async_answer_0(callid, ENOTSUP);
-                return;
+        }
-#define _INIT_FROM_HIGH_DATA2(type, var, arg_no) \
-        type var = (type) (DEV_IPC_GET_ARG##arg_no(*call) >> 16)
-#define _INIT_FROM_LOW_DATA2(type, var, arg_no) \
-        type var = (type) (DEV_IPC_GET_ARG##arg_no(*call) & 0xffff)
-        const usb_target_t target = { .packed = DEV_IPC_GET_ARG1(*call) };
-        _INIT_FROM_HIGH_DATA2(usb_transfer_type_t, transfer_type, 2);
-        _INIT_FROM_LOW_DATA2(usb_direction_t, direction, 2);
-        _INIT_FROM_HIGH_DATA2(size_t, max_packet_size, 3);
-        _INIT_FROM_LOW_DATA2(unsigned int, interval, 3);
-#undef _INIT_FROM_HIGH_DATA2
-#undef _INIT_FROM_LOW_DATA2
-        int rc = usb_iface->register_endpoint(fun, target.address,
-            target.endpoint, transfer_type, direction, max_packet_size, interval);
-        async_answer_0(callid, rc);
+}
-void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
-    ipc_callid_t callid, ipc_call_t *call)
+{
-        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
-        if (!usb_iface->unregister_endpoint) {
-                async_answer_0(callid, ENOTSUP);
-                return;
+        }
-        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
-        usb_endpoint_t endpoint = (usb_endpoint_t) DEV_IPC_GET_ARG2(*call);
-        usb_direction_t direction = (usb_direction_t) DEV_IPC_GET_ARG3(*call);
-        int rc = usb_iface->unregister_endpoint(fun,
-            address, endpoint, direction);
-        async_answer_0(callid, rc);
+}
 void remote_usbhc_read(
     ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)

uspace/lib/drv/include/ddf/driver.h

r5b18137	rb4b534ac
132	132	extern int ddf_fun_offline(ddf_fun_t *);
133	133	extern int ddf_fun_add_match_id(ddf_fun_t , const char , int);
134		extern void ddf_fun_set_ops(ddf_fun_t , ddf_dev_ops_t );
	134	extern void ddf_fun_set_ops(ddf_fun_t , const ddf_dev_ops_t );
135	135	extern void ddf_fun_set_conn_handler(ddf_fun_t *, async_port_handler_t);
136	136	extern int ddf_fun_add_to_category(ddf_fun_t , const char );

uspace/lib/drv/include/usb_iface.h

-              r5b18137
+              rb4b534ac
 #include <usb/usb.h>
+int usb_get_my_address(async_exch_t *, usb_address_t *);
+typedef async_sess_t usb_dev_session_t;
+usb_dev_session_t *usb_dev_connect(devman_handle_t);
+usb_dev_session_t *usb_dev_connect_to_self(ddf_dev_t *);
+void usb_dev_disconnect(usb_dev_session_t *);
 int usb_get_my_interface(async_exch_t *, int *);
+int usb_get_hc_handle(async_exch_t *, devman_handle_t *);
+int usb_get_my_device_handle(async_exch_t *, devman_handle_t *);
+int usb_reserve_default_address(async_exch_t *, usb_speed_t);
+int usb_release_default_address(async_exch_t *);
+int usb_device_enumerate(async_exch_t *, unsigned port);
+int usb_device_remove(async_exch_t *, unsigned port);
+int usb_register_endpoint(async_exch_t *, usb_endpoint_t, usb_transfer_type_t,
+    usb_direction_t, size_t, unsigned, unsigned);
+int usb_unregister_endpoint(async_exch_t *, usb_endpoint_t, usb_direction_t);
+int usb_read(async_exch_t *, usb_endpoint_t, uint64_t, void *, size_t, size_t *);
+int usb_write(async_exch_t *, usb_endpoint_t, uint64_t, const void *, size_t);
+/** Callback for outgoing transfer. */
+typedef void (*usb_iface_transfer_out_callback_t)(int, void *);
+/** Callback for incoming transfer. */
+typedef void (*usb_iface_transfer_in_callback_t)(int, size_t, void *);
 /** USB device communication interface. */
 typedef struct {
-        int (*get_my_address)(ddf_fun_t *, usb_address_t *);
         int (*get_my_interface)(ddf_fun_t *, int *);
+        int (*get_hc_handle)(ddf_fun_t *, devman_handle_t *);
+        int (*get_my_device_handle)(ddf_fun_t *, devman_handle_t *);
+        int (*reserve_default_address)(ddf_fun_t *, usb_speed_t);
+        int (*release_default_address)(ddf_fun_t *);
+        int (*device_enumerate)(ddf_fun_t *, unsigned);
+        int (*device_remove)(ddf_fun_t *, unsigned);
+        int (*register_endpoint)(ddf_fun_t *, usb_endpoint_t,
+            usb_transfer_type_t, usb_direction_t, size_t, unsigned, unsigned);
+        int (*unregister_endpoint)(ddf_fun_t *, usb_endpoint_t,
+            usb_direction_t);
+        int (*read)(ddf_fun_t *, usb_endpoint_t, uint64_t, uint8_t *, size_t,
+            usb_iface_transfer_in_callback_t, void *);
+        int (*write)(ddf_fun_t *, usb_endpoint_t, uint64_t, const uint8_t *,
+            size_t, usb_iface_transfer_out_callback_t, void *);
 } usb_iface_t;

uspace/lib/drv/include/usbhc_iface.h

-              r5b18137
+              rb4b534ac
 #include <stdbool.h>
-int usbhc_request_address(async_exch_t *, usb_address_t *, bool, usb_speed_t);
-int usbhc_bind_address(async_exch_t *, usb_address_t, devman_handle_t);
-int usbhc_get_handle(async_exch_t *, usb_address_t, devman_handle_t *);
-int usbhc_release_address(async_exch_t *, usb_address_t);
-int usbhc_register_endpoint(async_exch_t *, usb_address_t, usb_endpoint_t,
-    usb_transfer_type_t, usb_direction_t, size_t, unsigned int);
-int usbhc_unregister_endpoint(async_exch_t *, usb_address_t, usb_endpoint_t,
-    usb_direction_t);
 int usbhc_read(async_exch_t *, usb_address_t, usb_endpoint_t,
     uint64_t, void *, size_t, size_t *);
 …
 /** Callback for outgoing transfer. */
 typedef void (*usbhc_iface_transfer_out_callback_t)(ddf_fun_t *, int, void *);
+typedef void (*usbhc_iface_transfer_out_callback_t)(int, void *);
 /** Callback for incoming transfer. */
+typedef void (*usbhc_iface_transfer_in_callback_t)(ddf_fun_t *,
+    int, size_t, void *);
+typedef void (*usbhc_iface_transfer_in_callback_t)(int, size_t, void *);
 /** USB host controller communication interface. */
 typedef struct {
-        int (*request_address)(ddf_fun_t *, usb_address_t *, bool, usb_speed_t);
-        int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);
-        int (*get_handle)(ddf_fun_t *, usb_address_t,
-            devman_handle_t *);
-        int (*release_address)(ddf_fun_t *, usb_address_t);
-        int (*register_endpoint)(ddf_fun_t *,
-            usb_address_t, usb_endpoint_t,
-            usb_transfer_type_t, usb_direction_t, size_t, unsigned int);
-        int (*unregister_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
-            usb_direction_t);
         int (*read)(ddf_fun_t *, usb_target_t, uint64_t, uint8_t *, size_t,
             usbhc_iface_transfer_in_callback_t, void *);
         int (*write)(ddf_fun_t *, usb_target_t, uint64_t, const uint8_t *,
             size_t, usbhc_iface_transfer_out_callback_t, void *);

uspace/lib/scsi/include/scsi/spc.h

-              r5b18137
+              rb4b534ac
 /** SCSI command codes defined in SCSI-SPC */
 enum scsi_cmd_spc {
+        SCSI_CMD_INQUIRY        = 0x12,
+        SCSI_CMD_REQUEST_SENSE  = 0x03
+        SCSI_CMD_TEST_UNIT_READY = 0x00,
+        SCSI_CMD_REQUEST_SENSE   = 0x03,
+        SCSI_CMD_INQUIRY         = 0x12,
 };
 …
 extern const char *scsi_get_sense_key_str(unsigned);
+/** SCSI Test Unit Ready command */
+typedef struct {
+        /** Operation code (SCSI_CMD_TEST_UNIT_READY) */
+        uint8_t op_code;
+        /** Reserved */
+        uint32_t reserved;
+        /* Control */
+        uint8_t control;
+} __attribute__((packed)) scsi_cdb_test_unit_ready_t;
 #endif

uspace/lib/usb/Makefile

-              r5b18137
+              rb4b534ac
 SOURCES = \
         src/class.c \
-        src/ddfiface.c \
         src/dev.c \
         src/debug.c \
         src/dump.c \
-        src/hc.c \
         src/usb.c

uspace/lib/usb/include/usb/classes/hub.h

-              r5b18137
+              rb4b534ac
  */
 typedef enum {
+        USB_HUB_FEATURE_C_HUB_LOCAL_POWER = 0,
+        USB_HUB_FEATURE_C_HUB_OVER_CURRENT = 1,
         USB_HUB_FEATURE_HUB_LOCAL_POWER = 0,
         USB_HUB_FEATURE_HUB_OVER_CURRENT = 1,
-        USB_HUB_FEATURE_C_HUB_LOCAL_POWER = 0,
-        USB_HUB_FEATURE_C_HUB_OVER_CURRENT = 1,
         USB_HUB_FEATURE_PORT_CONNECTION = 0,
         USB_HUB_FEATURE_PORT_ENABLE = 1,
 …
         USB_HUB_FEATURE_PORT_POWER = 8,
         USB_HUB_FEATURE_PORT_LOW_SPEED = 9,
+        USB_HUB_FEATURE_PORT_HIGH_SPEED = 10,
         USB_HUB_FEATURE_C_PORT_CONNECTION = 16,
         USB_HUB_FEATURE_C_PORT_ENABLE = 17,
 …
         USB_HUB_FEATURE_C_PORT_OVER_CURRENT = 19,
         USB_HUB_FEATURE_C_PORT_RESET = 20,
+        USB_HUB_FEATURE_PORT_TEST = 21,
+        USB_HUB_FEATURE_PORT_INDICATOR = 22
         /* USB_HUB_FEATURE_ = , */
 } usb_hub_class_feature_t;
 …
         /** Descriptor length. */
         uint8_t length;
         /** Descriptor type (0x29). */
         uint8_t descriptor_type;
         /** Number of downstream ports. */
         uint8_t port_count;
+        /** Characteristics bitmask. */
+        /** Characteristics bitmask.
+         *
+         *  D1..D0: Logical Power Switching Mode
+         *  00: Ganged power switching (all ports power at
+         *  once)
+         *  01: Individual port power switching
+         *  1X: Reserved. Used only on 1.0 compliant hubs
+         *  that implement no power switching.
+         *  D2: Identifies a Compound Device
+         *  0: Hub is not part of a compound device
+         *  1: Hub is part of a compound device
+         *  D4..D3: Over-current Protection Mode
+         *  00: Global Over-current Protection. The hub
+         *  reports over-current as a summation of all
+         *  ports current draw, without a breakdown of
+         *  individual port over-current status.
+         *  01: Individual Port Over-current Protection. The
+         *  hub reports over-current on a per-port basis.
+         *  Each port has an over-current indicator.
+         *  1X: No Over-current Protection. This option is
+         *  allowed only for bus-powered hubs that do not
+         *  implement over-current protection.
+         *  D6..D5: TT think time
+         *  00: At most 8 FS bit times
+         *  01: At most 16 FS bit times
+         *  10: At most 24 FS bit times
+         *  11: At most 32 FS bit times
+         *  D7: Port indicators
+         *  0: Not supported
+         *  1: Supported
+         *  D15...D8: Reserved
+         */
         uint8_t characteristics;
+#define HUB_CHAR_POWER_PER_PORT_FLAG  (1 << 0)
+#define HUB_CHAR_NO_POWER_SWITCH_FLAG (1 << 1)
+        /* Unused part of characteristics field */
+#define HUB_CHAR_POWER_PER_PORT_FLAG    (1 << 0)
+#define HUB_CHAR_NO_POWER_SWITCH_FLAG   (1 << 1)
+#define HUB_CHAR_COMPOUND_DEVICE        (1 << 2)
+#define HUB_CHAR_OC_PER_PORT_FLAG       (1 << 3)
+#define HUB_CHAR_NO_OC_FLAG             (1 << 4)
+#define HUB_CHAR_TT_THINK_16            (1 << 5)
+#define HUB_CHAR_TT_THINK_8             (1 << 6)
+#define HUB_CHAR_INDICATORS_FLAG        (1 << 7)
+        /** Unused part of characteristics field */
         uint8_t characteristics_reserved;
+        /** Time from power-on to stabilization of current on the port. */
+        /** Time from power-on to stabilization of current on the port.
+         *
+         *  Time (in 2ms intervals) from the time the power-on
+         *  sequence begins on a port until power is good on that
+         *  port. The USB System Software uses this value to
+         *  determine how long to wait before accessing a
+         *  powered-on port.
+         */
         uint8_t power_good_time;
+        /** Maximum current requirements in mA. */
+        /** Maximum current requirements in mA.
+         *
+         *  Maximum current requirements of the Hub Controller
+         *  electronics in mA.
+         */
         uint8_t max_current;
 } __attribute__ ((packed)) usb_hub_descriptor_header_t;
+/**
+ * @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 {
+    /** Number of bytes in this descriptor, including this byte */
+    //uint8_t bDescLength;
+    /** Descriptor Type, value: 29H for hub descriptor */
+    //uint8_t bDescriptorType;
+    /** Number of downstream ports that this hub supports */
+    uint8_t port_count;
+    /**
+            D1...D0: Logical Power Switching Mode
+: Ganged power switching (all ports power at
+            once)
+: Individual port power switching
+X: Reserved. Used only on 1.0 compliant hubs
+            that implement no power switching.
+            D2: Identifies a Compound Device
+: Hub is not part of a compound device
+: Hub is part of a compound device
+            D4...D3: Over-current Protection Mode
+: Global Over-current Protection. The hub
+            reports over-current as a summation of all
+            ports current draw, without a breakdown of
+            individual port over-current status.
+: Individual Port Over-current Protection. The
+            hub reports over-current on a per-port basis.
+            Each port has an over-current indicator.
+X: No Over-current Protection. This option is
+            allowed only for bus-powered hubs that do not
+            implement over-current protection.
+            D15...D5:
+            Reserved
+     */
+    uint16_t hub_characteristics;
+    /**
+            Time (in 2ms intervals) from the time the power-on
+            sequence begins on a port until power is good on that
+            port. The USB System Software uses this value to
+            determine how long to wait before accessing a
+            powered-on port.
+     */
+    uint8_t pwr_on_2_good_time;
+    /**
+            Maximum current requirements of the Hub Controller
+            electronics in mA.
+     */
+    uint8_t current_requirement;
+    /**
+            Indicates if a port has a removable device attached.
+            This field is reported on byte-granularity. Within a
+            byte, if no port exists for a given location, the field
+            representing the port characteristics returns 0.
+            Bit value definition:
+B - Device is removable
+B - Device is non-removable
+            This is a bitmap corresponding to the individual ports
+            on the hub:
+            Bit 0: Reserved for future use
+            Bit 1: Port 1
+            Bit 2: Port 2
+            ....
+            Bit n: Port n (implementation-dependent, up to a
+            maximum of 255 ports).
+     */
+    uint8_t devices_removable[32];
+    /**
+            This field exists for reasons of compatibility with
+            software written for 1.0 compliant devices. All bits in
+            this field should be set to 1B. This field has one bit for
+            each port on the hub with additional pad bits, if
+            necessary, to make the number of bits in the field an
+            integer multiple of 8.
+     */
+    //uint8_t * port_pwr_ctrl_mask;
+} usb_hub_descriptor_t;
+/** One bit for the device and one bit for every port */
+#define STATUS_BYTES(ports) ((1 + ports + 7) / 8)
 /**     @brief usb hub specific request types.
 …
     /** */
     USB_HUB_REQUEST_CLEAR_FEATURE = 1,
     /** */
+    /** USB 1.0 only */
     USB_HUB_REQUEST_GET_STATE = 2,
     /** */
 …
     USB_HUB_REQUEST_GET_DESCRIPTOR = 6,
     /** */
+    USB_HUB_REQUEST_SET_DESCRIPTOR = 7
+    USB_HUB_REQUEST_SET_DESCRIPTOR = 7,
+    /** */
+    USB_HUB_REQUEST_CLEAR_TT_BUFFER = 8,
+    /** */
+    USB_HUB_REQUEST_RESET_TT = 9,
+    /** */
+    USB_HUB_GET_TT_STATE = 10,
+    /** */
+    USB_HUB_STOP_TT = 11,
 } usb_hub_request_t;
 …
  */
 /* 7 (basic size) + 2*32 (port bitmasks) */
 #define USB_HUB_MAX_DESCRIPTOR_SIZE 71
+#define USB_HUB_MAX_DESCRIPTOR_SIZE (7 + 2 * 32)
 #endif

uspace/lib/usb/include/usb/classes/massstor.h

r5b18137	rb4b534ac
36	36	#define LIBUSB_CLASS_MASSSTOR_H_
37	37
38		~~#include <sys/types.h>~~
39
40	38	/** USB mass storage subclasses. */
41	39	typedef enum {

uspace/lib/usb/include/usb/debug.h

-              r5b18137
+              rb4b534ac
 #define LIBUSB_DEBUG_H_
 #include <stdio.h>
+#include <inttypes.h>
+#include <usb/usb.h>
+#include <sys/types.h>
 #include <io/log.h>
+#include <assert.h>
 void usb_dump_standard_descriptor(FILE *, const char *, const char *,

uspace/lib/usb/include/usb/descriptor.h

-              r5b18137
+              rb4b534ac
 #define LIBUSB_DESCRIPTOR_H_
 #include <async.h>
+#include <sys/types.h>
 /** Descriptor type. */
 …
         USB_DESCTYPE_INTERFACE = 4,
         USB_DESCTYPE_ENDPOINT = 5,
+        /* New in USB2.0 */
+        USB_DESCTYPE_DEVICE_QUALIFIER = 6,
+        USB_DESCTYPE_OTHER_SPEED_CONFIGURATION = 7,
+        USB_DESCTYPE_INTERFACE_POWER = 8,
+        /* Class specific */
         USB_DESCTYPE_HID = 0x21,
         USB_DESCTYPE_HID_REPORT = 0x22,
 …
 } __attribute__ ((packed)) usb_standard_device_descriptor_t;
+/** USB device qualifier decriptor is basically a cut down version of the device
+ * descriptor with values that would be valid if the device operated on the
+ * other speed (HIGH vs. FULL)
+ */
+typedef struct {
+        /** Size of this descriptor in bytes */
+        uint8_t length;
+        /** Descriptor type (USB_DESCTYPE_DEVICE_QUALIFIER) */
+        uint8_t descriptor_type;
+        /** USB specification release number.
+         * The number shall be coded as binary-coded decimal (BCD).
+         */
+        uint16_t usb_spec_version;
+        /** Device class. */
+        uint8_t device_class;
+        /** Device sub-class. */
+        uint8_t device_subclass;
+        /** Device protocol. */
+        uint8_t device_protocol;
+        /** Maximum packet size for endpoint zero.
+         * Valid values are only 8, 16, 32, 64).
+         */
+        uint8_t max_packet_size;
+        /** Number of possible configurations. */
+        uint8_t configuration_count;
+        uint8_t reserved;
+} __attribute__ ((packed)) usb_standard_device_qualifier_descriptor_t;
 /** Standard USB configuration descriptor.
  */
 …
 } __attribute__ ((packed)) usb_standard_configuration_descriptor_t;
+/** USB Other Speed Configuration descriptor shows values that would change
+ * in the configuration descriptor if the device operated at its other
+ * possible speed (HIGH vs. FULL)
+ */
+typedef usb_standard_configuration_descriptor_t
+    usb_other_speed_configuration_descriptor_t;
 /** Standard USB interface descriptor.
  */
 …
          */
         uint8_t attributes;
+        /** Maximum packet size. */
+        /** Maximum packet size.
+         * Lower 10 bits represent the actuall size
+         * Bits 11,12 specify addtional transfer opportunitities for
+         * HS INT and ISO transfers. */
         uint16_t max_packet_size;
+#define ED_MPS_PACKET_SIZE_MASK  0x3ff
+#define ED_MPS_PACKET_SIZE_GET(value) \
+        ((value) & ED_MPS_PACKET_SIZE_MASK)
+#define ED_MPS_TRANS_OPPORTUNITIES_GET(value) \
+        ((((value) >> 10) & 0x3) + 1)
         /** Polling interval in milliseconds.
          * Ignored for bulk and control endpoints.

uspace/lib/usb/include/usb/dev.h

-              r5b18137
+              rb4b534ac
 #include <devman.h>
-#include <usb/usb.h>
+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 *);
+int usb_resolve_device_handle(const char *, devman_handle_t *);
 #endif
 /**

uspace/lib/usb/include/usb/usb.h

-              r5b18137
+              rb4b534ac
 } usb_speed_t;
+static inline bool usb_speed_is_11(const usb_speed_t s)
+{
+        return (s == USB_SPEED_FULL) || (s == USB_SPEED_LOW);
+}
 const char *usb_str_speed(usb_speed_t);
 …
 #define USB_ADDRESS_DEFAULT 0
 /** Maximum address number in USB 1.1. */
+#define USB11_ADDRESS_MAX 128
+#define USB11_ADDRESS_MAX 127
+#define USB_ADDRESS_COUNT (USB11_ADDRESS_MAX + 1)
+/** Check USB address for allowed values.
+ *
+ * @param ep USB address.
+ * @return True, if value is wihtin limits, false otherwise.
+ */
+static inline bool usb_address_is_valid(usb_address_t a)
+{
+        return (a >= USB_ADDRESS_DEFAULT) && (a <= USB11_ADDRESS_MAX);
+}
 /** USB endpoint number type.
 …
 typedef int16_t usb_endpoint_t;
+/** Maximum endpoint number in USB 1.1.
+ */
+/** Default control endpoint */
+#define USB_ENDPOINT_DEFAULT_CONTROL 0
+/** Maximum endpoint number in USB 1.1. */
 #define USB11_ENDPOINT_MAX 16
+/** Check USB endpoint for allowed values.
+ *
+ * @param ep USB endpoint number.
+ * @return True, if value is wihtin limits, false otherwise.
+ */
+static inline bool usb_endpoint_is_valid(usb_endpoint_t ep)
+{
+        return (ep >= USB_ENDPOINT_DEFAULT_CONTROL) &&
+            (ep < USB11_ENDPOINT_MAX);
+}
 …
 } usb_target_t;
 /** Check USB target for allowed values (address and endpoint).
+ *
 …
 static inline bool usb_target_is_valid(usb_target_t target)
+{
         return !(target.endpoint > 15 || target.endpoint < 0
             || target.address >= USB11_ADDRESS_MAX || target.address < 0);
+        return usb_address_is_valid(target.address) &&
+            usb_endpoint_is_valid(target.endpoint);
+}

uspace/lib/usb/src/class.c

r5b18137	rb4b534ac
34	34	*/
35	35	#include <usb/classes/classes.h>
36		~~#include <errno.h>~~
37	36
38	37	/** Tell string representation of USB class.

uspace/lib/usb/src/debug.c

-              r5b18137
+              rb4b534ac
  * Debugging and logging support.
  */
-#include <adt/list.h>
 #include <fibril_synch.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <ddf/log.h>
 #include <usb/debug.h>

uspace/lib/usb/src/dev.c

-              r5b18137
+              rb4b534ac
 #include <usb/dev.h>
-#include <usb/hc.h>
 #include <errno.h>
 #include <usb_iface.h>
 #include <str.h>
 #include <stdio.h>
-#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(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,
-    const char **func_start,
-    devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
+{
-        uint64_t sid;
-        size_t address;
-        int rc;
-        const char *ptr;
-        rc = str_uint64_t(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.
 …
  * @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)
+int usb_resolve_device_handle(const char *dev_path, devman_handle_t *dev_handle)
+{
         if (dev_path == NULL) {
+        if (dev_path == NULL || dev_handle == 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;
+        const char *func_start = NULL;
+        char *path = NULL;
+        /* First, try to get the device handle. */
+        int rc = devman_fun_get_handle(dev_path, dev_handle, 0);
+        /* 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;
+                }
+        /* Next, try parsing dev_handle from the provided string */
+        if (rc != EOK) {
+                *dev_handle = strtoul(dev_path, NULL, 10);
+                //FIXME: check errno
+                rc = EOK;
+        }
+        /* 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;
+        return rc;
+}

uspace/lib/usb/src/dump.c

-              r5b18137
+              rb4b534ac
  * Descriptor dumping.
  */
-#include <adt/list.h>
-#include <fibril_synch.h>
-#include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
 …
 #include <usb/descriptor.h>
 #include <usb/classes/classes.h>
+#include <usb/classes/hub.h>
+#include <usb/usb.h>
 /** Mapping between descriptor id and dumping function. */
 …
     const uint8_t *descriptor, size_t descriptor_length)
+{
+        /* TODO */
+        usb_hub_descriptor_header_t *d =
+            (usb_hub_descriptor_header_t *) descriptor;
+        if (descriptor_length < sizeof(d))
+                return;
+        PRINTLINE("bDescLength: = %d", d->length);
+        PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type);
+        PRINTLINE("bNbrPorts = %d", d->port_count);
+        PRINTLINE("bHubCharacteristics = 0x%02x%02x (%s;%s%s)",
+            d->characteristics_reserved, d->characteristics,
+            (d->characteristics & HUB_CHAR_NO_POWER_SWITCH_FLAG) ?
+                "No Power Switching" :
+                ((d->characteristics & HUB_CHAR_POWER_PER_PORT_FLAG) ?
+                    "Per-Port Switching" : "Ganged Power Switching"),
+            (d->characteristics & HUB_CHAR_COMPOUND_DEVICE) ?
+                "Compound Device;" : "",
+            (d->characteristics & HUB_CHAR_NO_OC_FLAG) ?
+                "No OC Protection" :
+                    ((d->characteristics & HUB_CHAR_OC_PER_PORT_FLAG) ?
+                        "Individual Port OC Protection" :
+                            "Global OC Protection")
+        );
+        PRINTLINE("bPwrOn2PwrGood = %d (%d ms)",
+            d->power_good_time, d->power_good_time * 2);
+        PRINTLINE("bHubContrCurrent = %d (%d mA)",
+            d->max_current, d->max_current);
+        const size_t port_bytes = (descriptor_length - sizeof(*d)) / 2;
+        const uint8_t *removable_mask = descriptor + sizeof(*d);
+        const uint8_t *powered_mask = descriptor + sizeof(*d) + port_bytes;
+        if (port_bytes == 0
+            || port_bytes > (((d->port_count / (unsigned)8) + 1) * 2)) {
+                PRINTLINE("::CORRUPTED DESCRIPTOR:: (%zu bytes remain)",
+                    port_bytes * 2);
+        }
+        fprintf(output, "%sDeviceRemovable = 0x",
+            line_prefix ? line_prefix : " - ");
+        for (unsigned i = port_bytes; i > 0; --i)
+                fprintf(output, "%02x", removable_mask[i - 1]);
+        fprintf(output, " (0b1 - Device non-removable)%s",
+            line_suffix ? line_suffix : "\n");
+        fprintf(output, "%sPortPwrCtrlMask = 0x",
+            line_prefix ? line_prefix : " - ");
+        for (unsigned i = port_bytes; i > 0; --i)
+                fprintf(output, "%02x", powered_mask[i - 1]);
+        fprintf(output, " (Legacy - All should be 0b1)%s",
+            line_suffix ? line_suffix : "\n");
+}

uspace/lib/usb/src/usb.c

-              r5b18137
+              rb4b534ac
  */
 #include <usb/usb.h>
 #include <errno.h>
+#include <usb/request.h>
+#define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+#include <assert.h>
+#include <byteorder.h>
+#include <macros.h>
 static const char *str_speed[] = {
 …
 const char *usb_str_transfer_type(usb_transfer_type_t t)
+{
         if (t >= ARR_SIZE(str_transfer_type)) {
+        if (t >= ARRAY_SIZE(str_transfer_type)) {
                 return "invalid";
+        }
 …
 const char *usb_str_transfer_type_short(usb_transfer_type_t t)
+{
         if (t >= ARR_SIZE(str_transfer_type_short)) {
+        if (t >= ARRAY_SIZE(str_transfer_type_short)) {
                 return "invl";
+        }
 …
 const char *usb_str_direction(usb_direction_t d)
+{
         if (d >= ARR_SIZE(str_direction)) {
+        if (d >= ARRAY_SIZE(str_direction)) {
                 return "invalid";
+        }
 …
 const char *usb_str_speed(usb_speed_t s)
+{
         if (s >= ARR_SIZE(str_speed)) {
+        if (s >= ARRAY_SIZE(str_speed)) {
                 return "invalid";
+        }
 …
+}
+/** Check setup packet data for signs of toggle reset.
+ *
+ * @param[in] requst Setup requst data.
+ * @retval -1 No endpoints need reset.
+ * @retval 0 All endpoints need reset.
+ * @retval >0 Specified endpoint needs reset.
+ */
+int usb_request_needs_toggle_reset(
+    const usb_device_request_setup_packet_t *request)
+{
+        assert(request);
+        switch (request->request)
+        {
+        /* Clear Feature ENPOINT_STALL */
+        case USB_DEVREQ_CLEAR_FEATURE: /*resets only cleared ep */
+                /* 0x2 ( HOST to device | STANDART | TO ENPOINT) */
+                if ((request->request_type == 0x2) &&
+                    (request->value == USB_FEATURE_ENDPOINT_HALT))
+                        return uint16_usb2host(request->index);
+                break;
+        case USB_DEVREQ_SET_CONFIGURATION:
+        case USB_DEVREQ_SET_INTERFACE:
+                /* 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,
+                 * unless you're changing configuration or alternative
+                 * interface of an already setup device. */
+                if (!(request->request_type & SETUP_REQUEST_TYPE_DEVICE_TO_HOST))
+                        return 0;
+                break;
+        default:
+                break;
+        }
+        return -1;
+}
 /**
  * @}

uspace/lib/usbdev/Makefile

-              r5b18137
+              rb4b534ac
 SOURCES = \
         src/altiface.c \
+        src/driver.c \
         src/devdrv.c \
         src/devpoll.c \
         src/dp.c \
-        src/hub.c \
         src/pipes.c \
         src/pipesinit.c \

uspace/lib/usbdev/include/usb/dev/alternate_ifaces.h

-              r5b18137
+              rb4b534ac
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
+ *
 …
  */
 /** @file
+ * Functions needed by hub drivers.
+ *
+ * For class specific requests, see usb/classes/hub.h.
+ * USB device driver framework.
  */
 #ifndef LIBUSBDEV_HUB_H_
 #define LIBUSBDEV_HUB_H_
+#ifndef LIBUSBDEV_ALTERNATE_IFACES_H_
+#define LIBUSBDEV_ALTERNATE_IFACES_H_
 #include <ddf/driver.h>
+#include <usb/descriptor.h>
 #include <sys/types.h>
-#include <errno.h>
-#include <usb/hc.h>
+extern int usb_hc_new_device_wrapper(ddf_dev_t *, ddf_fun_t *,
+    usb_hc_connection_t *, usb_speed_t, int (*)(void *), void *,
+    usb_address_t *, ddf_dev_ops_t *);
+/** Info about device attached to host controller.
+ *
+ * This structure exists only to keep the same signature of
+ * usb_hc_register_device() when more properties of the device
+ * would have to be passed to the host controller.
+/** Wrapper for data related to alternate interface setting.
+ * The pointers will typically point inside configuration descriptor and
+ * thus you shall not deallocate them.
  */
 typedef struct {
+        /** Device address. */
+        usb_address_t address;
+        /** DDF function (external) of the device. */
+        ddf_fun_t *fun;
+} usb_hub_attached_device_t;
+        /** Interface descriptor. */
+        const usb_standard_interface_descriptor_t *interface;
+        /** Pointer to start of descriptor tree bound with this interface. */
+        const uint8_t *nested_descriptors;
+        /** Size of data pointed by nested_descriptors in bytes. */
+        size_t nested_descriptors_size;
+} usb_alternate_interface_descriptors_t;
+extern int usb_hub_register_device(usb_hc_connection_t *,
+    const usb_hub_attached_device_t *);
+/** Alternate interface settings. */
+typedef struct {
+        /** Array of alternate interfaces descriptions. */
+        const usb_alternate_interface_descriptors_t *alternatives;
+        /** Size of @c alternatives array. */
+        size_t alternative_count;
+        /** Index of currently selected one. */
+        size_t current;
+} usb_alternate_interfaces_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);
+}
+size_t usb_interface_count_alternates(const uint8_t *, size_t, uint8_t);
+int usb_alternate_interfaces_init(usb_alternate_interfaces_t *,
+    const uint8_t *, size_t, int);
+void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *);
 #endif
 /**
  * @}

uspace/lib/usbdev/include/usb/dev/dp.h

-              r5b18137
+              rb4b534ac
 #include <sys/types.h>
-#include <usb/usb.h>
-#include <usb/descriptor.h>
 /** USB descriptors nesting.
 …
     const usb_dp_parser_data_t *, const uint8_t *, const uint8_t *);
 void usb_dp_walk_simple(uint8_t *, size_t, const usb_dp_descriptor_nesting_t *,
     walk_callback_t, void *);
+void usb_dp_walk_simple(const uint8_t *, size_t,
+    const usb_dp_descriptor_nesting_t *, walk_callback_t, void *);
 #endif

uspace/lib/usbdev/include/usb/dev/driver.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBDEV_DRIVER_H_
+#include <usb/hc.h>
+#include <usb/dev/usb_device_connection.h>
+#include <usb/dev/device.h>
 #include <usb/dev/pipes.h>
-/** Descriptors for USB device. */
-typedef struct {
-        /** Standard device descriptor. */
-        usb_standard_device_descriptor_t device;
-        /** Full configuration descriptor of current configuration. */
-        const uint8_t *configuration;
-        size_t configuration_size;
-} usb_device_descriptors_t;
-/** Wrapper for data related to alternate interface setting.
- * The pointers will typically point inside configuration descriptor and
- * thus you shall not deallocate them.
- */
-typedef struct {
-        /** Interface descriptor. */
-        const usb_standard_interface_descriptor_t *interface;
-        /** Pointer to start of descriptor tree bound with this interface. */
-        const uint8_t *nested_descriptors;
-        /** Size of data pointed by nested_descriptors in bytes. */
-        size_t nested_descriptors_size;
-} usb_alternate_interface_descriptors_t;
-/** Alternate interface settings. */
-typedef struct {
-        /** Array of alternate interfaces descriptions. */
-        usb_alternate_interface_descriptors_t *alternatives;
-        /** Size of @c alternatives array. */
-        size_t alternative_count;
-        /** Index of currently selected one. */
-        size_t current;
-} usb_alternate_interfaces_t;
-/** 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.
-         */
-        usb_device_connection_t wire;
-        /** The default control pipe. */
-        usb_pipe_t ctrl_pipe;
-        /** Other endpoint pipes.
-         * This is an array of other endpoint pipes in the same order as
-         * in usb_driver_t.
-         */
-        usb_endpoint_mapping_t *pipes;
-        /** Number of other endpoint pipes. */
-        size_t pipes_count;
-        /** Current interface.
-         * Usually, drivers operate on single interface only.
-         * This item contains the value of the interface or -1 for any.
-         */
-        int interface_no;
-        /** Alternative interfaces. */
-        usb_alternate_interfaces_t alternate_interfaces;
-        /** Some useful descriptors. */
-        usb_device_descriptors_t descriptors;
-        /** Generic DDF device backing this one. DO NOT TOUCH! */
-        ddf_dev_t *ddf_dev;
-        /** Custom driver data.
-         * Do not use the entry in generic device, that is already used
-         * by the framework.
-         */
-        void *driver_data;
-} usb_device_t;
 /** USB driver ops. */
 …
 int usb_driver_main(const usb_driver_t *);
-int usb_device_init(usb_device_t *, ddf_dev_t *,
-    const usb_endpoint_description_t **, const char **);
-void usb_device_deinit(usb_device_t *);
-int usb_device_select_interface(usb_device_t *, uint8_t,
-    const usb_endpoint_description_t **);
-int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *);
-void usb_device_release_descriptors(usb_device_descriptors_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 *);
-void usb_device_destroy_pipes(usb_endpoint_mapping_t *, size_t);
-void * usb_device_data_alloc(usb_device_t *, size_t);
-size_t usb_interface_count_alternates(const uint8_t *, size_t, uint8_t);
-int usb_alternate_interfaces_init(usb_alternate_interfaces_t *,
-    const uint8_t *, size_t, int);
-void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *);
 #endif
 /**

uspace/lib/usbdev/include/usb/dev/pipes.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBDEV_PIPES_H_
-#include <sys/types.h>
-#include <ipc/devman.h>
-#include <ddf/driver.h>
-#include <fibril_synch.h>
 #include <usb/usb.h>
 #include <usb/descriptor.h>
+#include <usb/dev/usb_device_connection.h>
+#include <usb_iface.h>
+#include <stdbool.h>
+#include <sys/types.h>
 #define CTRL_PIPE_MIN_PACKET_SIZE 8
 …
  */
 typedef struct {
-        /** The connection used for sending the data. */
-        usb_device_connection_t *wire;
         /** Endpoint number. */
         usb_endpoint_t endpoint_no;
 …
         size_t max_packet_size;
+        /** Number of packets per frame/uframe.
+         * Only valid for HS INT and ISO transfers. All others should set to 1*/
+        unsigned packets;
         /** Whether to automatically reset halt on the endpoint.
          * Valid only for control endpoint zero.
          */
         bool auto_reset_halt;
+        /** The connection used for sending the data. */
+        usb_dev_session_t *bus_session;
 } usb_pipe_t;
 …
 } usb_endpoint_mapping_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_initialize(usb_pipe_t *, usb_endpoint_t, usb_transfer_type_t,
+    size_t, usb_direction_t, unsigned, usb_dev_session_t *);
+int usb_pipe_initialize_default_control(usb_pipe_t *, usb_dev_session_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 *);
+    size_t, const uint8_t *, size_t, usb_dev_session_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 *);

uspace/lib/usbdev/include/usb/dev/poll.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBDEV_POLL_H_
+#include <usb/dev/driver.h>
+#include <time.h>
+#include <usb/usb.h>
+#include <usb/dev/device.h>
+#include <usb/dev/pipes.h>
+#include <stdbool.h>
+#include <sys/types.h>
 /** Parameters and callbacks for automated polling. */
 …
 } usb_device_auto_polling_t;
+int usb_device_auto_polling(usb_device_t *, size_t,
+typedef bool (*usb_polling_callback_t)(usb_device_t *, uint8_t *, size_t, void *);
+typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
+int usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
     const usb_device_auto_polling_t *, size_t);
+typedef bool (*usb_polling_callback_t)(usb_device_t *,
+    uint8_t *, size_t, void *);
+typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
+int usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
+    usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
+int usb_device_auto_poll(usb_device_t *, size_t,
+    usb_polling_callback_t, size_t, usb_polling_terminted_callback_t, void *);
+int usb_device_auto_polling_desc(usb_device_t *,
+    const usb_endpoint_description_t *, const usb_device_auto_polling_t *,
+    size_t);
+int usb_device_auto_poll_desc(usb_device_t *,
+    const usb_endpoint_description_t *, usb_polling_callback_t, size_t, int,
+    usb_polling_terminted_callback_t, void *);
 #endif

uspace/lib/usbdev/include/usb/dev/recognise.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBDEV_RECOGNISE_H_
+#include <sys/types.h>
+#include <usb/usb.h>
+#include <usb/descriptor.h>
 #include <usb/dev/pipes.h>
+#include <ipc/devman.h>
+#include <devman.h>
 extern int usb_device_create_match_ids_from_device_descriptor(
 …
 extern int usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *);
-extern int usb_device_register_child_in_devman(usb_pipe_t *ctrl_pipe,
-    ddf_dev_t *, ddf_fun_t *, ddf_dev_ops_t *);
 #endif

uspace/lib/usbdev/include/usb/dev/request.h

-              r5b18137
+              rb4b534ac
 #include <usb/dev/pipes.h>
 #include <usb/descriptor.h>
+/** USB device status - device is self powered (opposed to bus powered). */
+#define USB_DEVICE_STATUS_SELF_POWERED ((uint16_t)(1 << 0))
+/** USB device status - remote wake-up signaling is enabled. */
+#define USB_DEVICE_STATUS_REMOTE_WAKEUP ((uint16_t)(1 << 1))
+/** USB endpoint status - endpoint is halted (stalled). */
+#define USB_ENDPOINT_STATUS_HALTED ((uint16_t)(1 << 0))
+/** USB feature selector - endpoint halt (stall). */
+#define USB_FEATURE_SELECTOR_ENDPOINT_HALT (0)
+/** USB feature selector - device remote wake-up. */
+#define USB_FEATURE_SELECTOR_REMOTE_WAKEUP (1)
+/** Standard device request. */
+typedef enum {
+        USB_DEVREQ_GET_STATUS = 0,
+        USB_DEVREQ_CLEAR_FEATURE = 1,
+        USB_DEVREQ_SET_FEATURE = 3,
+        USB_DEVREQ_SET_ADDRESS = 5,
+        USB_DEVREQ_GET_DESCRIPTOR = 6,
+        USB_DEVREQ_SET_DESCRIPTOR = 7,
+        USB_DEVREQ_GET_CONFIGURATION = 8,
+        USB_DEVREQ_SET_CONFIGURATION = 9,
+        USB_DEVREQ_GET_INTERFACE = 10,
+        USB_DEVREQ_SET_INTERFACE = 11,
+        USB_DEVREQ_SYNCH_FRAME = 12,
+        USB_DEVREQ_LAST_STD
+} usb_stddevreq_t;
+/** Device request setup packet.
+ * The setup packet describes the request.
+ */
+typedef struct {
+        /** Request type.
+         * The type combines transfer direction, request type and
+         * intended recipient.
+         */
+        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. */
+        uint8_t request;
+        /** Main parameter to the request. */
+        union __attribute__ ((packed)) {
+                uint16_t value;
+                /* FIXME: add #ifdefs according to host endianness */
+                struct __attribute__ ((packed)) {
+                        uint8_t value_low;
+                        uint8_t value_high;
+                };
+        };
+        /** Auxiliary parameter to the request.
+         * Typically, it is offset to something.
+         */
+        uint16_t index;
+        /** Length of extra data. */
+        uint16_t length;
+} __attribute__ ((packed)) usb_device_request_setup_packet_t;
+#include <usb/request.h>
 int usb_control_request_set(usb_pipe_t *,
     usb_request_type_t, usb_request_recipient_t, uint8_t,
     uint16_t, uint16_t, void *, size_t);
+    uint16_t, uint16_t, const void *, size_t);
 int usb_control_request_get(usb_pipe_t *,
 …
     void *, size_t, size_t *);
 int usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
     int, void **, size_t *);
+    int, const void **, size_t *);
 int usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
     usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t);
+    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, const void *, size_t);
 int usb_request_get_configuration(usb_pipe_t *, uint8_t *);
 int usb_request_set_configuration(usb_pipe_t *, uint8_t);
 int usb_request_get_interface(usb_pipe_t *, uint8_t, uint8_t *);
 int usb_request_set_interface(usb_pipe_t *, uint8_t, uint8_t);

uspace/lib/usbdev/src/altiface.c

-              r5b18137
+              rb4b534ac
  */
+#include <usb/dev/driver.h>
+#include <usb/dev/request.h>
+#include <usb/debug.h>
+#include <usb/dev/alternate_ifaces.h>
 #include <usb/dev/dp.h>
+#include <assert.h>
 #include <errno.h>
+#include <str_error.h>
+#include <assert.h>
+#include <stdlib.h>
 /** Count number of alternate settings of a interface.
 …
+        }
+        alternates->alternative_count
+            = usb_interface_count_alternates(config_descr, config_descr_size,
+                interface_number);
+        const size_t alt_count = usb_interface_count_alternates(config_descr,
+            config_descr_size, interface_number);
         if (alternates->alternative_count == 0) {
+        if (alt_count == 0) {
                 return ENOENT;
+        }
         alternates->alternatives = calloc(alternates->alternative_count,
+        usb_alternate_interface_descriptors_t *alts = calloc(alt_count,
             sizeof(usb_alternate_interface_descriptors_t));
         if (alternates->alternatives == NULL) {
+        if (alts == NULL) {
                 return ENOMEM;
+        }
 …
         };
-        usb_alternate_interface_descriptors_t *iterator
-            = &alternates->alternatives[0];
-        const usb_alternate_interface_descriptors_t *end
-            = &alternates->alternatives[alternates->alternative_count];
         const void *iface_ptr =
             usb_dp_get_nested_descriptor(&dp_parser, &dp_data, dp_data.data);
+        while (iface_ptr != NULL && iterator < end) {
+        usb_alternate_interface_descriptors_t *iterator = alts;
+        for (; iface_ptr != NULL && iterator < &alts[alt_count]; ++iterator) {
                 const usb_standard_interface_descriptor_t *iface = iface_ptr;
 …
                     dp_data.data + dp_data.size : iface_ptr;
+                iterator->nested_descriptors_size
+                    = next - iterator->nested_descriptors;
+                iterator->nested_descriptors_size =
+                    next - iterator->nested_descriptors;
+        }
                 ++iterator;
+        }
+        alternates->alternatives = alts;
+        alternates->alternative_count = alt_count;
         return EOK;

uspace/lib/usbdev/src/devdrv.c

-              r5b18137
+              rb4b534ac
  * USB device driver framework.
  */
+#include <usb/dev/driver.h>
+#include <usb_iface.h>
+#include <usb/dev/alternate_ifaces.h>
+#include <usb/dev/device.h>
+#include <usb/dev/pipes.h>
 #include <usb/dev/request.h>
 #include <usb/debug.h>
+#include <usb/dev.h>
+#include <usb/descriptor.h>
+#include <usb/usb.h>
+#include <assert.h>
+#include <async.h>
+#include <devman.h>
 #include <errno.h>
+#include <str_error.h>
+#include <assert.h>
+static int generic_device_add(ddf_dev_t *);
+static int generic_device_remove(ddf_dev_t *);
+static int generic_device_gone(ddf_dev_t *);
+static driver_ops_t generic_driver_ops = {
+        .dev_add = generic_device_add,
+        .dev_remove = generic_device_remove,
+        .dev_gone = generic_device_gone,
+};
+static driver_t generic_driver = {
+        .driver_ops = &generic_driver_ops
+};
+static const usb_driver_t *driver = NULL;
+/** Main routine of USB device driver.
+ *
+ * Under normal conditions, this function never returns.
+ *
+ * @param drv USB device driver structure.
+ * @return Task exit status.
+ */
+int usb_driver_main(const usb_driver_t *drv)
+{
+        assert(drv != NULL);
+        /* Prepare the generic driver. */
+        generic_driver.name = drv->name;
+        driver = drv;
+        return ddf_driver_main(&generic_driver);
+}
+#include <stdlib.h>
+#include <ddf/driver.h>
+/** USB device structure. */
+typedef struct usb_device {
+        /** Connection to device on USB bus */
+        usb_dev_session_t *bus_session;
+        /** devman handle */
+        devman_handle_t handle;
+        /** The default control pipe. */
+        usb_pipe_t ctrl_pipe;
+        /** Other endpoint pipes.
+         * This is an array of other endpoint pipes in the same order as
+         * in usb_driver_t.
+         */
+        usb_endpoint_mapping_t *pipes;
+        /** Number of other endpoint pipes. */
+        size_t pipes_count;
+        /** Current interface.
+         * Usually, drivers operate on single interface only.
+         * This item contains the value of the interface or -1 for any.
+         */
+        int interface_no;
+        /** Alternative interfaces. */
+        usb_alternate_interfaces_t alternate_interfaces;
+        /** Some useful descriptors for USB device. */
+        usb_device_descriptors_t descriptors;
+        /** Generic DDF device backing this one. DO NOT TOUCH! */
+        ddf_dev_t *ddf_dev;
+        /** Custom driver data.
+         * Do not use the entry in generic device, that is already used
+         * by the framework.
+         */
+        void *driver_data;
+} usb_device_t;
 /** Count number of pipes the driver expects.
 …
  * @return Number of pipes (excluding default control pipe).
  */
+static inline size_t count_other_pipes(
+    const usb_endpoint_description_t **endpoints)
+static inline size_t count_pipes(const usb_endpoint_description_t **endpoints)
+{
         size_t count;
         for (count = 0; endpoints != NULL && endpoints[count] != NULL; ++count);
         return count;
+}
-/** Callback when a new device is supposed to be controlled by this driver.
+ *
- * This callback is a wrapper for USB specific version of @c device_add.
+ *
- * @param gen_dev Device structure as prepared by DDF.
- * @return Error code.
- */
-int generic_device_add(ddf_dev_t *gen_dev)
+{
-        assert(driver);
-        assert(driver->ops);
-        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) {
-                usb_log_error("USB device `%s' structure allocation failed.\n",
-                    ddf_dev_get_name(gen_dev));
-                return ENOMEM;
+        }
-        /* Initialize generic USB driver data. */
-        const char *err_msg = NULL;
-        int rc = usb_device_init(dev, gen_dev, driver->endpoints, &err_msg);
-        if (rc != EOK) {
-                usb_log_error("USB device `%s' init failed (%s): %s.\n",
-                    ddf_dev_get_name(gen_dev), err_msg, str_error(rc));
-                return rc;
+        }
-        /* Start USB driver specific initialization. */
-        rc = driver->ops->device_add(dev);
-        if (rc != EOK)
-                usb_device_deinit(dev);
-        return rc;
+}
-/** Callback when a device is supposed to be removed from the system.
+ *
- * This callback is a wrapper for USB specific version of @c device_remove.
+ *
- * @param gen_dev Device structure as prepared by DDF.
- * @return Error code.
- */
-int generic_device_remove(ddf_dev_t *gen_dev)
+{
-        assert(driver);
-        assert(driver->ops);
-        if (driver->ops->device_rem == NULL)
-                return ENOTSUP;
-        /* Just tell the driver to stop whatever it is doing */
-        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
-        const int ret = driver->ops->device_rem(usb_dev);
-        if (ret != EOK)
-                return ret;
-        usb_device_deinit(usb_dev);
-        return EOK;
+}
-/** Callback when a device was removed from the system.
+ *
- * This callback is a wrapper for USB specific version of @c device_gone.
+ *
- * @param gen_dev Device structure as prepared by DDF.
- * @return Error code.
- */
-int generic_device_gone(ddf_dev_t *gen_dev)
+{
-        assert(driver);
-        assert(driver->ops);
-        if (driver->ops->device_gone == NULL)
-                return ENOTSUP;
-        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
-        const int ret = driver->ops->device_gone(usb_dev);
-        if (ret == EOK)
-                usb_device_deinit(usb_dev);
-        return ret;
+}
-/** Destroy existing pipes of a USB device.
+ *
- * @param dev Device where to destroy the pipes.
- */
-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 Error code.
  */
+int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
+    const usb_endpoint_description_t **endpoints)
+{
+        if (dev->interface_no < 0) {
+int usb_device_select_interface(usb_device_t *usb_dev,
+    uint8_t alternate_setting, const usb_endpoint_description_t **endpoints)
+{
+        assert(usb_dev);
+        if (usb_dev->interface_no < 0) {
                 return EINVAL;
+        }
-        /* Destroy existing pipes. */
-        destroy_current_pipes(dev);
         /* Change the interface itself. */
         int rc = usb_request_set_interface(&dev->ctrl_pipe, dev->interface_no,
             alternate_setting);
+        int rc = usb_request_set_interface(&usb_dev->ctrl_pipe,
+            usb_dev->interface_no, alternate_setting);
         if (rc != EOK) {
                 return rc;
+        }
+        /* Change current alternative */
+        usb_dev->alternate_interfaces.current = alternate_setting;
+        /* Destroy existing pipes. */
+        usb_device_destroy_pipes(usb_dev);
         /* Create new pipes. */
+        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);
+        rc = usb_device_create_pipes(usb_dev, endpoints);
         return rc;
 …
  * @return Error code.
  */
+int usb_device_retrieve_descriptors(usb_pipe_t *ctrl_pipe,
+    usb_device_descriptors_t *descriptors)
+{
+        assert(descriptors != NULL);
+        descriptors->configuration = NULL;
+        int rc;
+        /* It is worth to start a long transfer. */
+        usb_pipe_start_long_transfer(ctrl_pipe);
+static int usb_device_retrieve_descriptors(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        assert(usb_dev->descriptors.full_config == NULL);
         /* Get the device descriptor. */
+        rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device);
+        int rc = usb_request_get_device_descriptor(&usb_dev->ctrl_pipe,
+            &usb_dev->descriptors.device);
         if (rc != EOK) {
                 goto leave;
+                return rc;
+        }
         /* Get the full configuration descriptor. */
         rc = usb_request_get_full_configuration_descriptor_alloc(
+            ctrl_pipe, 0, (void **) &descriptors->configuration,
+            &descriptors->configuration_size);
+leave:
+        usb_pipe_end_long_transfer(ctrl_pipe);
+            &usb_dev->ctrl_pipe, 0,
+            &usb_dev->descriptors.full_config,
+            &usb_dev->descriptors.full_config_size);
         return rc;
 …
  * @param[in] descriptors Where to store the descriptors.
  */
+void usb_device_release_descriptors(usb_device_descriptors_t *descriptors)
+{
+        assert(descriptors);
+        free(descriptors->configuration);
+        descriptors->configuration = NULL;
+static void usb_device_release_descriptors(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        free(usb_dev->descriptors.full_config);
+        usb_dev->descriptors.full_config = NULL;
+        usb_dev->descriptors.full_config_size = 0;
+}
 …
  * - registers endpoints with the host controller
+ *
- * @param[in] wire Initialized backing connection to the host controller.
  * @param[in] endpoints Endpoints description, NULL terminated.
  * @param[in] config_descr Configuration descriptor of active configuration.
 …
  * @return Error code.
  */
+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,
+    int interface_no, int interface_setting,
+    usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr)
+{
+        assert(wire != NULL);
+        assert(config_descr != NULL);
+        assert(config_descr_size > 0);
+        assert(pipes_ptr != NULL);
+        size_t i;
+        int rc;
+        const size_t pipe_count = count_other_pipes(endpoints);
+int usb_device_create_pipes(usb_device_t *usb_dev,
+    const usb_endpoint_description_t **endpoints)
+{
+        assert(usb_dev);
+        assert(usb_dev->descriptors.full_config);
+        assert(usb_dev->pipes == NULL);
+        assert(usb_dev->pipes_count == 0);
+        size_t pipe_count = count_pipes(endpoints);
         if (pipe_count == 0) {
-                if (pipes_count_ptr)
-                        *pipes_count_ptr = pipe_count;
-                *pipes_ptr = NULL;
                 return EOK;
+        }
         usb_endpoint_mapping_t *pipes
             = calloc(pipe_count, sizeof(usb_endpoint_mapping_t));
+        usb_endpoint_mapping_t *pipes =
+            calloc(pipe_count, sizeof(usb_endpoint_mapping_t));
         if (pipes == NULL) {
                 return ENOMEM;
 …
         /* Now initialize. */
         for (i = 0; i < pipe_count; i++) {
+        for (size_t i = 0; i < pipe_count; i++) {
                 pipes[i].description = endpoints[i];
+                pipes[i].interface_no = interface_no;
+                pipes[i].interface_setting = interface_setting;
+                pipes[i].interface_no = usb_dev->interface_no;
+                pipes[i].interface_setting =
+                    usb_dev->alternate_interfaces.current;
+        }
         /* Find the mapping from configuration descriptor. */
+        rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
+            config_descr, config_descr_size, wire);
+        int rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
+            usb_dev->descriptors.full_config,
+            usb_dev->descriptors.full_config_size,
+            usb_dev->bus_session);
         if (rc != EOK) {
                 free(pipes);
 …
         /* Register created pipes. */
         for (i = 0; i < pipe_count; i++) {
+        for (size_t i = 0; i < pipe_count; i++) {
                 if (pipes[i].present) {
                         rc = usb_pipe_register(&pipes[i].pipe,
 …
+        }
+        *pipes_ptr = pipes;
+        if (pipes_count_ptr != NULL) {
+                *pipes_count_ptr = pipe_count;
+        }
+        usb_dev->pipes = pipes;
+        usb_dev->pipes_count = pipe_count;
         return EOK;
 …
          */
 rollback_unregister_endpoints:
         for (i = 0; i < pipe_count; i++) {
+        for (size_t i = 0; i < pipe_count; i++) {
                 if (pipes[i].present) {
                         usb_pipe_unregister(&pipes[i].pipe);
 …
 /** Destroy pipes previously created by usb_device_create_pipes.
+ *
+ * @param[in] pipes Endpoint mapping to be destroyed.
+ * @param[in] pipes_count Number of endpoints.
+ */
+void usb_device_destroy_pipes(usb_endpoint_mapping_t *pipes, size_t pipes_count)
+{
+ * @param[in] usb_dev USB device.
+ */
+void usb_device_destroy_pipes(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        assert(usb_dev->pipes || usb_dev->pipes_count == 0);
         /* Destroy the pipes. */
+        for (size_t i = 0; i < pipes_count; ++i) {
+                assert(pipes);
+        for (size_t i = 0; i < usb_dev->pipes_count; ++i) {
                 usb_log_debug2("Unregistering pipe %zu: %spresent.\n",
+                    i, pipes[i].present ? "" : "not ");
+                if (pipes[i].present)
+                        usb_pipe_unregister(&pipes[i].pipe);
+        }
+        free(pipes);
+                    i, usb_dev->pipes[i].present ? "" : "not ");
+                if (usb_dev->pipes[i].present)
+                        usb_pipe_unregister(&usb_dev->pipes[i].pipe);
+        }
+        free(usb_dev->pipes);
+        usb_dev->pipes = NULL;
+        usb_dev->pipes_count = 0;
+}
+usb_pipe_t *usb_device_get_default_pipe(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return &usb_dev->ctrl_pipe;
+}
+usb_endpoint_mapping_t *usb_device_get_mapped_ep_desc(usb_device_t *usb_dev,
+    const usb_endpoint_description_t *desc)
+{
+        assert(usb_dev);
+        for (unsigned i = 0; i < usb_dev->pipes_count; ++i) {
+                if (usb_dev->pipes[i].description == desc)
+                        return &usb_dev->pipes[i];
+        }
+        return NULL;
+}
+usb_endpoint_mapping_t * usb_device_get_mapped_ep(
+    usb_device_t *usb_dev, usb_endpoint_t ep)
+{
+        assert(usb_dev);
+        for (unsigned i = 0; i < usb_dev->pipes_count; ++i) {
+                if (usb_dev->pipes[i].pipe.endpoint_no == ep)
+                        return &usb_dev->pipes[i];
+        }
+        return NULL;
+}
+int usb_device_get_iface_number(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return usb_dev->interface_no;
+}
+devman_handle_t usb_device_get_devman_handle(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return usb_dev->handle;
+}
+const usb_device_descriptors_t *usb_device_descriptors(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return &usb_dev->descriptors;
+}
+const usb_alternate_interfaces_t * usb_device_get_alternative_ifaces(
+    usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return &usb_dev->alternate_interfaces;
+}
+/** Clean instance of a USB device.
+ *
+ * @param dev Device to be de-initialized.
+ *
+ * Does not free/destroy supplied pointer.
+ */
+static void usb_device_fini(usb_device_t *usb_dev)
+{
+        if (usb_dev) {
+                /* Destroy existing pipes. */
+                usb_device_destroy_pipes(usb_dev);
+                /* Ignore errors and hope for the best. */
+                usb_alternate_interfaces_deinit(&usb_dev->alternate_interfaces);
+                usb_device_release_descriptors(usb_dev);
+                free(usb_dev->driver_data);
+                usb_dev->driver_data = NULL;
+                usb_dev_disconnect(usb_dev->bus_session);
+                usb_dev->bus_session = NULL;
+        }
+}
 …
  * @return Error code.
  */
+int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
+    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
+static int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
+    const usb_endpoint_description_t **endpoints, const char **errstr_ptr,
+    devman_handle_t handle, int interface_no)
+{
         assert(usb_dev != NULL);
         assert(ddf_dev != NULL);
+        assert(errstr_ptr);
         *errstr_ptr = NULL;
         usb_dev->ddf_dev = ddf_dev;
+        usb_dev->handle = handle;
+        usb_dev->interface_no = interface_no;
         usb_dev->driver_data = NULL;
+        usb_dev->descriptors.configuration = NULL;
+        usb_dev->descriptors.full_config = NULL;
+        usb_dev->descriptors.full_config_size = 0;
         usb_dev->pipes_count = 0;
         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_get_handle(ddf_dev),
+            &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. */
+        rc = usb_device_connection_initialize(
+            &usb_dev->wire, &usb_dev->hc_conn, address);
+        if (rc != EOK) {
+                *errstr_ptr = "device connection initialization";
+                return rc;
+        usb_dev->bus_session = usb_dev_connect(handle);
+        if (!usb_dev->bus_session) {
+                *errstr_ptr = "device bus session create";
+                return ENOMEM;
+        }
         /* This pipe was registered by the hub driver,
          * during device initialization. */
         rc = usb_pipe_initialize_default_control(
             &usb_dev->ctrl_pipe, &usb_dev->wire);
+        int rc = usb_pipe_initialize_default_control(
+            &usb_dev->ctrl_pipe, usb_dev->bus_session);
         if (rc != EOK) {
+                usb_dev_disconnect(usb_dev->bus_session);
                 *errstr_ptr = "default control pipe initialization";
                 return rc;
+        }
-        /* 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);
         if (rc != EOK) {
                 *errstr_ptr = "descriptor retrieval";
                 usb_hc_connection_close(&usb_dev->hc_conn);
+                usb_dev_disconnect(usb_dev->bus_session);
                 return rc;
+        }
 …
          * controlling a device. */
         rc = usb_alternate_interfaces_init(&usb_dev->alternate_interfaces,
+            usb_dev->descriptors.configuration,
+            usb_dev->descriptors.configuration_size, usb_dev->interface_no);
+        const int alternate_iface =
+            (rc == EOK) ? usb_dev->alternate_interfaces.current : 0;
+        /* 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);
+                /* Alternate interfaces may be allocated */
+                usb_alternate_interfaces_deinit(&usb_dev->alternate_interfaces);
+                *errstr_ptr = "pipes initialization";
+                return rc;
+        }
+        usb_hc_connection_close(&usb_dev->hc_conn);
+            usb_dev->descriptors.full_config,
+            usb_dev->descriptors.full_config_size, usb_dev->interface_no);
+        if (endpoints) {
+                /* Create and register other pipes than default control (EP 0)*/
+                rc = usb_device_create_pipes(usb_dev, endpoints);
+                if (rc != EOK) {
+                        usb_device_fini(usb_dev);
+                        *errstr_ptr = "pipes initialization";
+                        return rc;
+                }
+        }
         return EOK;
+}
+/** Clean instance of a USB device.
+ *
+ * @param dev Device to be de-initialized.
+ *
+ * Does not free/destroy supplied pointer.
+ */
+void usb_device_deinit(usb_device_t *dev)
+{
+        if (dev) {
+                /* Destroy existing pipes. */
+                destroy_current_pipes(dev);
+                /* Ignore errors and hope for the best. */
+                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;
+        }
+static int usb_device_get_info(async_sess_t *sess, devman_handle_t *handle,
+        int *iface_no)
+{
+        assert(handle);
+        assert(iface_no);
+        async_exch_t *exch = async_exchange_begin(sess);
+        if (!exch)
+                return EPARTY;
+        int ret = usb_get_my_device_handle(exch, handle);
+        if (ret == EOK) {
+                ret = usb_get_my_interface(exch, iface_no);
+                if (ret == ENOTSUP) {
+                        *iface_no = -1;
+                        ret = EOK;
+                }
+        }
+        async_exchange_end(exch);
+        return ret;
+}
+int usb_device_create_ddf(ddf_dev_t *ddf_dev,
+    const usb_endpoint_description_t **desc, const char **err)
+{
+        assert(ddf_dev);
+        assert(err);
+        devman_handle_t h = 0;
+        int iface_no = -1;
+        async_sess_t *sess = devman_parent_device_connect(
+            ddf_dev_get_handle(ddf_dev), IPC_FLAG_BLOCKING);
+        const int ret = usb_device_get_info(sess, &h, &iface_no);
+        async_hangup(sess);
+        if (ret != EOK)
+                return ret;
+        usb_device_t *usb_dev =
+            ddf_dev_data_alloc(ddf_dev, sizeof(usb_device_t));
+        if (usb_dev == NULL) {
+                *err = "DDF data alloc";
+                return ENOMEM;
+        }
+        return usb_device_init(usb_dev, ddf_dev, desc, err, h, iface_no);
+}
+void usb_device_destroy_ddf(ddf_dev_t *ddf_dev)
+{
+        assert(ddf_dev);
+        usb_device_t *usb_dev = ddf_dev_data_get(ddf_dev);
+        assert(usb_dev);
+        usb_device_fini(usb_dev);
+        return;
+}
+usb_device_t * usb_device_create(devman_handle_t handle)
+{
+        devman_handle_t h = 0;
+        int iface_no = -1;
+        async_sess_t *sess = devman_device_connect(handle, IPC_FLAG_BLOCKING);
+        int ret = usb_device_get_info(sess, &h, &iface_no);
+        if (sess)
+                async_hangup(sess);
+        if (ret != EOK)
+                return NULL;
+        usb_device_t *usb_dev = malloc(sizeof(usb_device_t));
+        if (!usb_dev)
+                return NULL;
+        const char* dummy = NULL;
+        ret = usb_device_init(usb_dev, NULL, NULL, &dummy, handle, iface_no);
+        if (ret != EOK) {
+                free(usb_dev);
+                usb_dev = NULL;
+        }
+        return usb_dev;
+}
+void usb_device_destroy(usb_device_t *usb_dev)
+{
+        if (usb_dev) {
+                usb_device_fini(usb_dev);
+                free(usb_dev);
+        }
+}
+const char *usb_device_get_name(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        if (usb_dev->ddf_dev)
+                return ddf_dev_get_name(usb_dev->ddf_dev);
+        return NULL;
+}
+ddf_fun_t *usb_device_ddf_fun_create(usb_device_t *usb_dev, fun_type_t ftype,
+    const char* name)
+{
+        assert(usb_dev);
+        if (usb_dev->ddf_dev)
+                return ddf_fun_create(usb_dev->ddf_dev, ftype, name);
+        return NULL;
+}
+async_exch_t * usb_device_bus_exchange_begin(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return async_exchange_begin(usb_dev->bus_session);
+}
+void usb_device_bus_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
 …
+}
+void * usb_device_data_get(usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return usb_dev->driver_data;
+}
 /**
  * @}

uspace/lib/usbdev/src/devpoll.c

-              r5b18137
+              rb4b534ac
  * USB device driver framework - automatic interrupt polling.
  */
+#include <usb/dev/device.h>
+#include <usb/dev/pipes.h>
 #include <usb/dev/poll.h>
 #include <usb/dev/request.h>
+#include <usb/classes/classes.h>
 #include <usb/debug.h>
+#include <usb/classes/classes.h>
+#include <usb/descriptor.h>
+#include <usb/usb.h>
+#include <assert.h>
+#include <async.h>
 #include <errno.h>
+#include <fibril.h>
+#include <stdbool.h>
+#include <stdlib.h>
 #include <str_error.h>
 #include <assert.h>
+#include <sys/types.h>
 /** Maximum number of failed consecutive requests before announcing failure. */
 …
         /** USB device to poll. */
         usb_device_t *dev;
         /** Device pipe to use for polling. */
         size_t pipe_index;
+        /** Device enpoint mapping to use for polling. */
+        usb_endpoint_mapping_t *polling_mapping;
         /** Size of the recieved data. */
         size_t request_size;
 …
         const usb_device_auto_polling_t *params = &data->auto_polling;
+        usb_pipe_t *pipe
+            = &data->dev->pipes[data->pipe_index].pipe;
+        usb_pipe_t *pipe = &data->polling_mapping->pipe;
         if (params->debug > 0) {
                 const usb_endpoint_mapping_t *mapping
                     = &data->dev->pipes[data->pipe_index];
                 usb_log_debug("Poll%p: started polling of `%s' - " \
+                    = data->polling_mapping;
+                usb_log_debug("Poll (%p): started polling of `%s' - " \
                     "interface %d (%s,%d,%d), %zuB/%zu.\n",
                     data, ddf_dev_get_name(data->dev->ddf_dev),
+                    data, usb_device_get_name(data->dev),
                     (int) mapping->interface->interface_number,
                     usb_str_class(mapping->interface->interface_class),
 …
+        }
-        usb_pipe_start_long_transfer(pipe);
         size_t failed_attempts = 0;
         while (failed_attempts <= params->max_failures) {
 …
                     data->request_size, &actual_size);
                 if (params->debug > 1) {
                         if (rc == EOK) {
+                if (rc == EOK) {
+                        if (params->debug > 1) {
                                 usb_log_debug(
                                     "Poll%p: received: '%s' (%zuB).\n",
 …
                                         actual_size, 16),
                                     actual_size);
+                        } else {
+                        }
+                } else {
                                 usb_log_debug(
                                     "Poll%p: polling failed: %s.\n",
                                     data, str_error(rc));
+                        }
+                }
 …
                          */
                         usb_request_clear_endpoint_halt(
+                            &data->dev->ctrl_pipe, pipe->endpoint_no);
+                            usb_device_get_default_pipe(data->dev),
+                            pipe->endpoint_no);
+                }
 …
                 /* Take a rest before next request. */
+                //TODO: This is broken, the time is in ms not us.
+                // but first we need to fix drivers to actually stop using this,
+                // since polling dealy should be implemented in HC schedule
                 async_usleep(params->delay);
+        }
-        usb_pipe_end_long_transfer(pipe);
         const bool failed = failed_attempts > 0;
 …
                 if (failed) {
                         usb_log_error("Polling of device `%s' terminated: "
                             "recurring failures.\n", ddf_dev_get_name(
                             data->dev->ddf_dev));
+                            "recurring failures.\n",
+                            usb_device_get_name(data->dev));
                 } else {
                         usb_log_debug("Polling of device `%s' terminated: "
                             "driver request.\n", ddf_dev_get_name(
                             data->dev->ddf_dev));
+                            "driver request.\n",
+                            usb_device_get_name(data->dev));
+                }
+        }
 …
+}
 /** Start automatic device polling over interrupt in pipe.
+ *
  * @warning It is up to the callback to produce delays between individual
  * requests.
+ * The polling settings is copied thus it is okay to destroy the structure
+ * after this function returns.
+ *
  * @warning There is no guarantee when the request to the device
 …
+ *
  * @param dev Device to be periodically polled.
+ * @param epm Endpoint mapping to use.
+ * @param polling Polling settings.
+ * @param request_size How many bytes to ask for in each request.
+ * @param arg Custom argument (passed as is to the callbacks).
+ * @return Error code.
+ * @retval EOK New fibril polling the device was already started.
+ */
+static int usb_device_auto_polling_internal(usb_device_t *dev,
+    usb_endpoint_mapping_t *epm, const usb_device_auto_polling_t *polling,
+    size_t request_size)
+{
+        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
+                return EBADMEM;
+        }
+        if (request_size == 0)
+                return EINVAL;
+        if (!epm || (epm->pipe.transfer_type != USB_TRANSFER_INTERRUPT) ||
+            (epm->pipe.direction != USB_DIRECTION_IN))
+                return EINVAL;
+        polling_data_t *polling_data = malloc(sizeof(polling_data_t));
+        if (polling_data == NULL) {
+                return ENOMEM;
+        }
+        /* Fill-in the data. */
+        polling_data->buffer = malloc(sizeof(request_size));
+        if (polling_data->buffer == NULL) {
+                free(polling_data);
+                return ENOMEM;
+        }
+        polling_data->request_size = request_size;
+        polling_data->dev = dev;
+        polling_data->polling_mapping = epm;
+        /* Copy provided settings. */
+        polling_data->auto_polling = *polling;
+        /* Negative value means use descriptor provided value. */
+        if (polling->delay < 0) {
+                polling_data->auto_polling.delay =
+                    epm->descriptor->poll_interval;
+        }
+        fid_t fibril = fibril_create(polling_fibril, polling_data);
+        if (fibril == 0) {
+                free(polling_data->buffer);
+                free(polling_data);
+                return ENOMEM;
+        }
+        fibril_add_ready(fibril);
+        /* Fibril launched. That fibril will free the allocated data. */
+        return EOK;
+}
+/** Start automatic device polling over interrupt in pipe.
+ *
+ * The polling settings is copied thus it is okay to destroy the structure
+ * after this function returns.
+ *
+ * @warning There is no guarantee when the request to the device
+ * will be sent for the first time (it is possible that this
+ * first request would be executed prior to return from this function).
+ *
+ * @param dev Device to be periodically polled.
  * @param pipe_index Index of the endpoint pipe used for polling.
+ * @param polling Polling settings.
+ * @param req_size How many bytes to ask for in each request.
+ * @param arg Custom argument (passed as is to the callbacks).
+ * @return Error code.
+ * @retval EOK New fibril polling the device was already started.
+ */
+int usb_device_auto_polling(usb_device_t *usb_dev, usb_endpoint_t ep,
+    const usb_device_auto_polling_t *polling, size_t req_size)
+{
+        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(usb_dev, ep);
+        return usb_device_auto_polling_internal(usb_dev, epm, polling, req_size);
+}
+/** Start automatic device polling over interrupt in pipe.
+ *
+ * @warning It is up to the callback to produce delays between individual
+ * requests.
+ *
+ * @warning There is no guarantee when the request to the device
+ * will be sent for the first time (it is possible that this
+ * first request would be executed prior to return from this function).
+ *
+ * @param dev Device to be periodically polled.
+ * @param ep Endpoint  used for polling.
  * @param callback Callback when data are available.
  * @param request_size How many bytes to ask for in each request.
+ * @param delay NUmber of ms to wait between queries, -1 to use descriptor val.
  * @param terminated_callback Callback when polling is terminated.
  * @param arg Custom argument (passed as is to the callbacks).
 …
  * @retval EOK New fibril polling the device was already started.
  */
 int usb_device_auto_poll(usb_device_t *dev, size_t pipe_index,
     usb_polling_callback_t callback, size_t request_size,
+int usb_device_auto_poll(usb_device_t *dev, usb_endpoint_t ep,
+    usb_polling_callback_t callback, size_t request_size, int delay,
     usb_polling_terminted_callback_t terminated_callback, void *arg)
+{
 …
                 .debug = 1,
                 .auto_clear_halt = true,
                 .delay = 0,
+                .delay = delay,
                 .max_failures = MAX_FAILED_ATTEMPTS,
                 .on_data = callback,
 …
         };
+        return usb_device_auto_polling(dev, pipe_index, &auto_polling,
+           request_size);
+}
+/** Start automatic device polling over interrupt in pipe.
+ *
+ * The polling settings is copied thus it is okay to destroy the structure
+ * after this function returns.
+ *
+ * @warning There is no guarantee when the request to the device
+ * will be sent for the first time (it is possible that this
+ * first request would be executed prior to return from this function).
+ *
+ * @param dev Device to be periodically polled.
+ * @param pipe_index Index of the endpoint pipe used for polling.
+ * @param polling Polling settings.
+ * @param request_size How many bytes to ask for in each request.
+ * @param arg Custom argument (passed as is to the callbacks).
+ * @return Error code.
+ * @retval EOK New fibril polling the device was already started.
+ */
+int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index,
+    const usb_device_auto_polling_t *polling,
+    size_t request_size)
+{
+        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
+                return EBADMEM;
+        }
+        if (pipe_index >= dev->pipes_count || request_size == 0) {
+                return EINVAL;
+        }
+        if ((dev->pipes[pipe_index].pipe.transfer_type != USB_TRANSFER_INTERRUPT)
+            || (dev->pipes[pipe_index].pipe.direction != USB_DIRECTION_IN)) {
+                return EINVAL;
+        }
+        polling_data_t *polling_data = malloc(sizeof(polling_data_t));
+        if (polling_data == NULL) {
+                return ENOMEM;
+        }
+        /* Fill-in the data. */
+        polling_data->buffer = malloc(sizeof(request_size));
+        if (polling_data->buffer == NULL) {
+                free(polling_data);
+                return ENOMEM;
+        }
+        polling_data->request_size = request_size;
+        polling_data->dev = dev;
+        polling_data->pipe_index = pipe_index;
+        /* Copy provided settings. */
+        polling_data->auto_polling = *polling;
+        /* Negative value means use descriptor provided value. */
+        if (polling->delay < 0) {
+                polling_data->auto_polling.delay =
+                    (int) dev->pipes[pipe_index].descriptor->poll_interval;
+        }
+        fid_t fibril = fibril_create(polling_fibril, polling_data);
+        if (fibril == 0) {
+                free(polling_data->buffer);
+                free(polling_data);
+                return ENOMEM;
+        }
+        fibril_add_ready(fibril);
+        /* Fibril launched. That fibril will free the allocated data. */
+        return EOK;
+        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev, ep);
+        return usb_device_auto_polling_internal(
+            dev, epm, &auto_polling, request_size);
+}
+int usb_device_auto_polling_desc(usb_device_t *usb_dev,
+    const usb_endpoint_description_t *desc,
+    const usb_device_auto_polling_t *polling, size_t req_size)
+{
+        usb_endpoint_mapping_t *epm =
+            usb_device_get_mapped_ep_desc(usb_dev, desc);
+        return usb_device_auto_polling_internal(usb_dev, epm, polling, req_size);
+}
+int usb_device_auto_poll_desc(usb_device_t * usb_dev,
+    const usb_endpoint_description_t *desc, usb_polling_callback_t callback,
+    size_t req_size, int delay,
+    usb_polling_terminted_callback_t terminated_callback, void *arg)
+{
+        const usb_device_auto_polling_t auto_polling = {
+                .debug = 1,
+                .auto_clear_halt = true,
+                .delay = delay,
+                .max_failures = MAX_FAILED_ATTEMPTS,
+                .on_data = callback,
+                .on_polling_end = terminated_callback,
+                .on_error = NULL,
+                .arg = arg,
+        };
+        usb_endpoint_mapping_t *epm =
+            usb_device_get_mapped_ep_desc(usb_dev, desc);
+        return usb_device_auto_polling_internal(
+            usb_dev, epm, &auto_polling, req_size);
+}

uspace/lib/usbdev/src/dp.c

-              r5b18137
+              rb4b534ac
  * sibling.
  */
-#include <stdio.h>
-#include <str_error.h>
-#include <errno.h>
-#include <assert.h>
-#include <stdbool.h>
 #include <usb/dev/dp.h>
 #include <usb/descriptor.h>
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <sys/types.h>
 #define NESTING(parentname, childname) \
 …
  * @param arg Custom (user) argument.
  */
 void usb_dp_walk_simple(uint8_t *descriptors, size_t descriptors_size,
+void usb_dp_walk_simple(const uint8_t *descriptors, size_t descriptors_size,
     const usb_dp_descriptor_nesting_t *descriptor_nesting,
     walk_callback_t callback, void *arg)

uspace/lib/usbdev/src/pipes.c

-              r5b18137
+              rb4b534ac
 #include <usb/dev/pipes.h>
 #include <usb/dev/request.h>
+#include <usb/usb.h>
+#include <usb_iface.h>
+#include <assert.h>
+#include <async.h>
 #include <errno.h>
+#include <assert.h>
+/** 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);
+}
+#include <mem.h>
 /** Try to clear endpoint halt of default control pipe.
 …
         memcpy(&setup_packet, setup_buffer, 8);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
         size_t act_size = 0;
         const int rc = usb_device_control_read(pipe->wire,
+        const int rc = usb_read(exch,
             pipe->endpoint_no, setup_packet, buffer, buffer_size, &act_size);
+        async_exchange_end(exch);
         if (rc == ESTALL) {
 …
         memcpy(&setup_packet, setup_buffer, 8);
+        const int rc = usb_device_control_write(pipe->wire,
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        const int rc = usb_write(exch,
             pipe->endpoint_no, setup_packet, buffer, buffer_size);
+        async_exchange_end(exch);
         if (rc == ESTALL) {
 …
             return ENOTSUP;
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
         size_t act_size = 0;
+        const int rc = usb_device_read(pipe->wire,
+            pipe->endpoint_no, buffer, size, &act_size);
+        const int rc =
+            usb_read(exch, pipe->endpoint_no, 0, buffer, size, &act_size);
+        async_exchange_end(exch);
         if (rc == EOK && size_transfered != NULL) {
 …
             return ENOTSUP;
+        return usb_device_write(pipe->wire,
+            pipe->endpoint_no, buffer, size);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        const int rc = usb_write(exch, pipe->endpoint_no, 0, buffer, size);
+        async_exchange_end(exch);
+        return rc;
+}
 …
+ *
  * @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).
 …
  * @return Error code.
  */
+int usb_pipe_initialize(usb_pipe_t *pipe,
+    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
+int usb_pipe_initialize(usb_pipe_t *pipe, usb_endpoint_t endpoint_no,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
+    usb_direction_t direction)
+{
+        assert(pipe);
+        assert(connection);
+        pipe->wire = connection;
+    usb_direction_t direction, unsigned packets, usb_dev_session_t *bus_session)
+{
+        assert(pipe);
         pipe->endpoint_no = endpoint_no;
         pipe->transfer_type = transfer_type;
+        pipe->packets = packets;
         pipe->max_packet_size = max_packet_size;
         pipe->direction = direction;
         pipe->auto_reset_halt = false;
+        pipe->bus_session = bus_session;
         return EOK;
 …
+ *
  * @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);
+    usb_dev_session_t *bus_session)
+{
+        assert(pipe);
+        const int rc = usb_pipe_initialize(pipe, 0, USB_TRANSFER_CONTROL,
+            CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH, 1, bus_session);
         pipe->auto_reset_halt = true;
 …
+{
         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);
+        assert(pipe->bus_session);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        if (!exch)
+                return ENOMEM;
+        const int ret = usb_register_endpoint(exch, pipe->endpoint_no,
+            pipe->transfer_type, pipe->direction, pipe->max_packet_size,
+            pipe->packets, interval);
+        async_exchange_end(exch);
+        return ret;
+}
 …
+{
         assert(pipe);
+        assert(pipe->wire);
+        return usb_device_unregister_endpoint(pipe->wire,
+            pipe->endpoint_no, pipe->direction);
+        assert(pipe->bus_session);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        if (!exch)
+                return ENOMEM;
+        const int ret = usb_unregister_endpoint(exch, pipe->endpoint_no,
+            pipe->direction);
+        async_exchange_end(exch);
+        return ret;
+}

uspace/lib/usbdev/src/pipesinit.c

-              r5b18137
+              rb4b534ac
+ *
  */
-#include <usb/usb.h>
 #include <usb/dev/pipes.h>
 #include <usb/dev/dp.h>
 #include <usb/dev/request.h>
+#include <usb/usb.h>
+#include <usb/descriptor.h>
+#include <assert.h>
 #include <errno.h>
-#include <assert.h>
 #define DEV_DESCR_MAX_PACKET_SIZE_OFFSET 7
 …
  * @param interface Interface descriptor under which belongs the @p endpoint.
  * @param endpoint Endpoint descriptor.
- * @param wire Connection backing the endpoint pipes.
  * @return Error code.
  */
 …
     usb_standard_interface_descriptor_t *interface,
     usb_standard_endpoint_descriptor_t *endpoint_desc,
     usb_device_connection_t *wire)
+    usb_dev_session_t *bus_session)
+{
 …
+        }
         int rc = usb_pipe_initialize(&ep_mapping->pipe, wire,
+        int rc = usb_pipe_initialize(&ep_mapping->pipe,
             ep_no, description.transfer_type,
+            uint16_usb2host(endpoint_desc->max_packet_size),
+            description.direction);
+            ED_MPS_PACKET_SIZE_GET(
+                uint16_usb2host(endpoint_desc->max_packet_size)),
+            description.direction,
+            ED_MPS_TRANS_OPPORTUNITIES_GET(
+                uint16_usb2host(endpoint_desc->max_packet_size)), bus_session);
         if (rc != EOK) {
                 return rc;
 …
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
     const usb_dp_parser_t *parser, const usb_dp_parser_data_t *parser_data,
     const uint8_t *interface_descriptor)
+    const uint8_t *interface_descriptor, usb_dev_session_t *bus_session)
+{
         const uint8_t *descriptor = usb_dp_get_nested_descriptor(parser,
 …
                             (usb_standard_endpoint_descriptor_t *)
                                 descriptor,
                             (usb_device_connection_t *) parser_data->arg);
+                            bus_session);
+                }
 …
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
     const uint8_t *config_descriptor, size_t config_descriptor_size,
+    usb_device_connection_t *connection)
+{
+        assert(connection);
+    usb_dev_session_t *bus_session)
+{
         if (config_descriptor == NULL) {
 …
                 .data = config_descriptor,
                 .size = config_descriptor_size,
-                .arg = connection
         };
 …
         do {
                 (void) process_interface(mapping, mapping_count,
                     &dp_parser, &dp_data, interface);
+                    &dp_parser, &dp_data, interface, bus_session);
                 interface = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
                     config_descriptor, interface);
 …
                 return EINVAL;
+        }
-        usb_pipe_start_long_transfer(pipe);
         uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE];
 …
+                }
+        }
-        usb_pipe_end_long_transfer(pipe);
         if (rc != EOK) {
                 return rc;

uspace/lib/usbdev/src/recognise.c

-              r5b18137
+              rb4b534ac
  */
-#include <sys/types.h>
-#include <fibril_synch.h>
-#include <usb/debug.h>
-#include <usb/dev/hub.h>
 #include <usb/dev/pipes.h>
 #include <usb/dev/recognise.h>
-#include <usb/ddfiface.h>
 #include <usb/dev/request.h>
 #include <usb/classes/classes.h>
+#include <assert.h>
+#include <errno.h>
 #include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+/** DDF operations of child devices. */
+static ddf_dev_ops_t child_ops = {
+        .interfaces[USB_DEV_IFACE] = &usb_iface_hub_child_impl
+};
+#include <sys/types.h>
 /** Get integer part from BCD coded number. */
 …
                     (int) device_descriptor->product_id,
                     BCD_ARGS(device_descriptor->device_version));
                 /* Next, without release number. */
                 ADD_MATCHID_OR_RETURN(matches, 90,
 …
                     (int) device_descriptor->vendor_id,
                     (int) device_descriptor->product_id);
+        }
+        /*
+         * If the device class points to interface we skip adding
+         * class directly but we add a multi interface device.
+         */
+        if (device_descriptor->device_class != USB_CLASS_USE_INTERFACE) {
+                ADD_MATCHID_OR_RETURN(matches, 50, "usb&class=%s",
+                    usb_str_class(device_descriptor->device_class));
+        } else {
+                ADD_MATCHID_OR_RETURN(matches, 50, "usb&mid");
+        }
+        }
+        /* Class match id */
+        ADD_MATCHID_OR_RETURN(matches, 50, "usb&class=%s",
+            usb_str_class(device_descriptor->device_class));
         /* As a last resort, try fallback driver. */
         ADD_MATCHID_OR_RETURN(matches, 10, "usb&fallback");
 …
+}
-/** Probe for device kind and register it in devman.
+ *
- * @param[in] ctrl_pipe Control pipe to the device.
- * @param[in] parent Parent device.
- * @param[in] dev_ops Child device ops. Default child_ops will be used if NULL.
- * @param[in] dev_data Arbitrary pointer to be stored in the child
- *      as @c driver_data.
- * @param[out] child_fun Storage where pointer to allocated child function
- *      will be written.
- * @return Error code.
+ *
- */
-int usb_device_register_child_in_devman(usb_pipe_t *ctrl_pipe,
-    ddf_dev_t *parent, ddf_fun_t *fun, ddf_dev_ops_t *dev_ops)
+{
-        if (ctrl_pipe == NULL)
-                return EINVAL;
-        if (!dev_ops && ddf_fun_data_get(fun) != NULL) {
-                usb_log_warning("Using standard fun ops with arbitrary "
-                    "driver data. This does not have to work.\n");
+        }
-        /** 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);
-        int rc;
-        /*
-         * TODO: Once the device driver framework support persistent
-         * naming etc., something more descriptive could be created.
-         */
-        char child_name[12];  /* The format is: "usbAB_aXYZ", length 11 */
-        rc = snprintf(child_name, sizeof(child_name),
-            "usb%02zu_a%d", this_device_name_index, ctrl_pipe->wire->address);
-        if (rc < 0) {
-                goto failure;
+        }
-        rc = ddf_fun_set_name(fun, child_name);
-        if (rc != EOK)
-                goto failure;
-        if (dev_ops != NULL)
-                ddf_fun_set_ops(fun, dev_ops);
-        else
-                ddf_fun_set_ops(fun, &child_ops);
-        /*
-         * Store the attached device in fun
-         * driver data if there is no other data
-         */
-        if (ddf_fun_data_get(fun) == NULL) {
-                usb_hub_attached_device_t *new_device = ddf_fun_data_alloc(
-                    fun, sizeof(usb_hub_attached_device_t));
-                if (!new_device) {
-                        rc = ENOMEM;
-                        goto failure;
+                }
-                new_device->address = ctrl_pipe->wire->address;
-                new_device->fun = fun;
+        }
-        match_id_list_t match_ids;
-        init_match_ids(&match_ids);
-        rc = usb_device_create_match_ids(ctrl_pipe, &match_ids);
-        if (rc != EOK)
-                goto failure;
-        list_foreach(match_ids.ids, link, match_id_t, match_id) {
-                rc = ddf_fun_add_match_id(fun, match_id->id, match_id->score);
-                if (rc != EOK) {
-                        clean_match_ids(&match_ids);
-                        goto failure;
+                }
+        }
-        clean_match_ids(&match_ids);
-        rc = ddf_fun_bind(fun);
-        if (rc != EOK)
-                goto failure;
-        return EOK;
-failure:
-        return rc;
+}
 /**
  * @}

uspace/lib/usbdev/src/request.c

-              r5b18137
+              rb4b534ac
  */
 #include <usb/dev/request.h>
+#include <usb/request.h>
+#include <usb/usb.h>
 #include <errno.h>
+#include <assert.h>
+#include <usb/debug.h>
+#include <mem.h>
+#include <stdlib.h>
+#include <str.h>
 #define MAX_DATA_LENGTH ((size_t)(0xFFFF))
 …
  * @param request Actual request (e.g. GET_DESCRIPTOR).
  * @param value Value of @c wValue field of setup packet
  *      (must be in USB endianness).
+ *      (must be in USB endianness).
  * @param index Value of @c wIndex field of setup packet
  *      (must be in USB endianness).
+ *      (must be in USB endianness).
  * @param data Data to be sent during DATA stage
  *      (expected to be in USB endianness).
+ *      (expected to be in USB endianness).
  * @param data_size Size of the @p data buffer (in native endianness).
  * @return Error code.
 …
 int usb_control_request_set(usb_pipe_t *pipe,
     usb_request_type_t request_type, usb_request_recipient_t recipient,
+    uint8_t request,
+    uint16_t value, uint16_t index,
+    void *data, size_t data_size)
+    uint8_t request, uint16_t value, uint16_t index,
+    const void *data, size_t data_size)
+{
         if (pipe == NULL) {
 …
          */
+        usb_device_request_setup_packet_t setup_packet;
+        setup_packet.request_type = (request_type << 5) | recipient;
+        setup_packet.request = request;
+        setup_packet.value = value;
+        setup_packet.index = index;
+        setup_packet.length = (uint16_t) data_size;
+        int rc = usb_pipe_control_write(pipe,
+            &setup_packet, sizeof(setup_packet),
+            data, data_size);
+        return rc;
+        const usb_device_request_setup_packet_t setup_packet = {
+                .request_type = (request_type << 5) | recipient,
+                .request = request,
+                .value = value,
+                .index = index,
+                .length = (uint16_t) data_size,
+        };
+        return usb_pipe_control_write(pipe,
+            &setup_packet, sizeof(setup_packet), data, data_size);
+}
 …
   * @param request Actual request (e.g. GET_DESCRIPTOR).
   * @param value Value of @c wValue field of setup packet
   *     (must be in USB endianness).
+  *     (must be in USB endianness).
   * @param index Value of @c wIndex field of setup packet
   *     (must be in USB endianness).
 …
   *     (they will come in USB endianness).
   * @param data_size Size of the @p data buffer
   *     (in native endianness).
+  *     (in native endianness).
   * @param actual_data_size Actual size of transfered data
   *        (in native endianness).
+  *     (in native endianness).
   * @return Error code.
   * @retval EBADMEM @p pipe is NULL.
 …
 int usb_control_request_get(usb_pipe_t *pipe,
     usb_request_type_t request_type, usb_request_recipient_t recipient,
+    uint8_t request,
+    uint16_t value, uint16_t index,
+    uint8_t request, uint16_t value, uint16_t index,
     void *data, size_t data_size, size_t *actual_data_size)
+{
 …
+{
         if (request_type == USB_REQUEST_TYPE_STANDARD) {
                 if ((recipient == USB_REQUEST_RECIPIENT_DEVICE)
                     && (index != 0)) {
+                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0))
+                {
                         return EINVAL;
+                }
+        }
+        int rc = usb_control_request_set(pipe, request_type, recipient,
+            USB_DEVREQ_CLEAR_FEATURE,
+            uint16_host2usb(feature_selector), uint16_host2usb(index),
+            NULL, 0);
+        return rc;
+        return usb_control_request_set(pipe,
+            request_type, recipient, USB_DEVREQ_CLEAR_FEATURE,
+            uint16_host2usb(feature_selector), uint16_host2usb(index), NULL, 0);
+}
 …
+{
         if (request_type == USB_REQUEST_TYPE_STANDARD) {
                 if ((recipient == USB_REQUEST_RECIPIENT_DEVICE)
                     && (index != 0)) {
+                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0))
+                {
                         return EINVAL;
+                }
+        }
+        int rc = usb_control_request_set(pipe, request_type, recipient,
+            USB_DEVREQ_SET_FEATURE,
+            uint16_host2usb(feature_selector), uint16_host2usb(index),
+            NULL, 0);
+        return rc;
+        return usb_control_request_set(pipe,
+            request_type, recipient, USB_DEVREQ_SET_FEATURE,
+            uint16_host2usb(feature_selector), uint16_host2usb(index), NULL, 0);
+}
 …
+        }
+        /* The wValue field specifies the descriptor type in the high byte
+         * and the descriptor index in the low byte. USB 1.1 spec p. 189
+         */
         const uint16_t wValue = descriptor_index | (descriptor_type << 8);
 …
          * Get only first byte to retrieve descriptor length.
          */
         uint8_t tmp_buffer[1];
+        uint8_t tmp_buffer;
         size_t bytes_transfered;
         rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             &tmp_buffer, 1, &bytes_transfered);
+            &tmp_buffer, sizeof(tmp_buffer), &bytes_transfered);
         if (rc != EOK) {
                 return rc;
+        }
         if (bytes_transfered != 1) {
+                /* FIXME: some better error code? */
+                return ESTALL;
+        }
+        size_t size = tmp_buffer[0];
+                return ELIMIT;
+        }
+        const size_t size = tmp_buffer;
         if (size == 0) {
+                /* FIXME: some better error code? */
+                return ESTALL;
+                return ELIMIT;
+        }
 …
         if (bytes_transfered != size) {
                 free(buffer);
+                /* FIXME: some better error code? */
+                return ESTALL;
+                return ELIMIT;
+        }
 …
         int rc = usb_request_get_descriptor(pipe,
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DESCTYPE_DEVICE, 0, 0,
+            &descriptor_tmp, sizeof(descriptor_tmp),
+            USB_DESCTYPE_DEVICE, 0, 0, &descriptor_tmp, sizeof(descriptor_tmp),
             &actually_transferred);
 …
         size_t actually_transferred = 0;
         usb_standard_configuration_descriptor_t descriptor_tmp;
         int rc = usb_request_get_descriptor(pipe,
+        const int rc = usb_request_get_descriptor(pipe,
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
             USB_DESCTYPE_CONFIGURATION, index, 0,
 …
 int usb_request_get_full_configuration_descriptor_alloc(
     usb_pipe_t *pipe, int index,
     void **descriptor_ptr, size_t *descriptor_size)
+    const void **descriptor_ptr, size_t *descriptor_size)
+{
         int rc;
 …
     usb_request_type_t request_type, usb_request_recipient_t recipient,
     uint8_t descriptor_type, uint8_t descriptor_index,
+    uint16_t language,
+    void *buffer, size_t size)
+    uint16_t language, const void *buffer, size_t size)
+{
         if (buffer == NULL) {
 …
         return usb_control_request_set(pipe,
+            request_type, recipient,
+            USB_DEVREQ_SET_DESCRIPTOR,
+            wValue, language,
+            buffer, size);
+            request_type, recipient, USB_DEVREQ_SET_DESCRIPTOR,
+            wValue, language, buffer, size);
+}
 …
         size_t actual_size;
         int rc = usb_control_request_get(pipe,
+        const int rc = usb_control_request_get(pipe,
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
+            USB_DEVREQ_GET_CONFIGURATION,
+, 0,
+            &value, 1, &actual_size);
+            USB_DEVREQ_GET_CONFIGURATION, 0, 0, &value, 1, &actual_size);
         if (rc != EOK) {
 …
     uint8_t configuration_value)
+{
         uint16_t config_value
+        const uint16_t config_value
             = uint16_host2usb((uint16_t) configuration_value);
 …
         size_t actual_size;
         int rc = usb_control_request_get(pipe,
+        const int rc = usb_control_request_get(pipe,
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_DEVREQ_GET_INTERFACE,
 , uint16_host2usb((uint16_t) interface_index),
             &value, 1, &actual_size);
+            &value, sizeof(value), &actual_size);
         if (rc != EOK) {
 …
     l18_win_locales_t **languages_ptr, size_t *languages_count)
+{
+        int rc;
+        if (languages_ptr == NULL) {
+                return EBADMEM;
+        }
+        if (languages_count == NULL) {
+        if (languages_ptr == NULL || languages_count == NULL) {
                 return EBADMEM;
+        }
 …
         uint8_t *string_descriptor = NULL;
         size_t string_descriptor_size = 0;
         rc = usb_request_get_descriptor_alloc(pipe,
+        const int rc = usb_request_get_descriptor_alloc(pipe,
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
             USB_DESCTYPE_STRING, 0, 0,
 …
+        }
         size_t langs_count = string_descriptor_size / 2;
         l18_win_locales_t *langs
             = malloc(sizeof(l18_win_locales_t) * langs_count);
+        const size_t langs_count = string_descriptor_size / 2;
+        l18_win_locales_t *langs =
+            calloc(langs_count, sizeof(l18_win_locales_t));
         if (langs == NULL) {
                 free(string_descriptor);
 …
+        }
+        size_t i;
+        for (i = 0; i < langs_count; i++) {
+        for (size_t i = 0; i < langs_count; i++) {
                 /* Language code from the descriptor is in USB endianness. */
                 /* FIXME: is this really correct? */
+                uint16_t lang_code = (string_descriptor[2 + 2 * i + 1] << 8)
+                const uint16_t lang_code =
+                    (string_descriptor[2 + 2 * i + 1] << 8)
                     + string_descriptor[2 + 2 * i];
                 langs[i] = uint16_usb2host(lang_code);
 …
+        }
         /* Language is actually two byte value. */
         if (lang > 0xFFFF) {
+        if (lang > L18N_WIN_LOCALE_MAX) {
                 return ERANGE;
+        }
 …
+        }
         size_t string_char_count = string_size / 2;
+        const size_t string_char_count = string_size / 2;
         string_chars = malloc(sizeof(wchar_t) * (string_char_count + 1));
         if (string_chars == NULL) {
 …
          * do not have them).
          */
+        size_t i;
+        for (i = 0; i < string_char_count; i++) {
+                uint16_t uni_char = (string[2 + 2 * i + 1] << 8)
+        for (size_t i = 0; i < string_char_count; i++) {
+                const uint16_t uni_char = (string[2 + 2 * i + 1] << 8)
                     + string[2 + 2 * i];
                 string_chars[i] = uni_char;
 …
 leave:
+        if (string != NULL) {
+                free(string);
+        }
+        if (string_chars != NULL) {
+                free(string_chars);
+        }
+        free(string);
+        free(string_chars);
         return rc;
 …
         return usb_request_clear_feature(pipe,
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT,
             uint16_host2usb(USB_FEATURE_SELECTOR_ENDPOINT_HALT),
+            uint16_host2usb(USB_FEATURE_ENDPOINT_HALT),
             uint16_host2usb(ep_index));
+}

uspace/lib/usbhid/src/hidreport.c

-              r5b18137
+              rb4b534ac
         usb_dp_parser_data_t parser_data = {
                 .data = dev->descriptors.configuration,
                 .size = dev->descriptors.configuration_size,
+                .data = usb_device_descriptors(dev)->full_config,
+                .size = usb_device_descriptors(dev)->full_config_size,
                 .arg = NULL
         };
 …
         const uint8_t *d =
             usb_dp_get_nested_descriptor(&parser, &parser_data,
             dev->descriptors.configuration);
+                usb_device_descriptors(dev)->full_config);
         /*
 …
          */
         int i = 0;
         while (d != NULL && i < dev->interface_no) {
+        while (d != NULL && i < usb_device_get_iface_number(dev)) {
                 d = usb_dp_get_sibling_descriptor(&parser, &parser_data,
                     dev->descriptors.configuration, d);
+                    usb_device_descriptors(dev)->full_config, d);
                 ++i;
+        }
 …
         if (d == NULL) {
                 usb_log_error("The %d. interface descriptor not found!\n",
                     dev->interface_no);
+                    usb_device_get_iface_number(dev));
                 return ENOENT;
+        }
 …
          * Get the descriptor from the device.
          */
         int rc = usb_request_get_descriptor(&dev->ctrl_pipe,
+        int rc = usb_request_get_descriptor(usb_device_get_default_pipe(dev),
             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_DESCTYPE_HID_REPORT, 0, dev->interface_no,
+            USB_DESCTYPE_HID_REPORT, 0, usb_device_get_iface_number(dev),
             *report_desc, length, &actual_size);

uspace/lib/usbhid/src/hidreq.c

-              r5b18137
+              rb4b534ac
         uint16_t value = duration << 8;
         rc = usb_control_request_set(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+        rc = usb_control_request_set(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_SET_IDLE, value, iface_no, NULL, 0);
         if (rc != EOK) {
                 usb_log_warning("Error sending Set Idle request to the device: "
+                usb_log_warning("Device did not accept Set Idle request: "
                     "%s.\n", str_error(rc));
                 return rc;

uspace/lib/usbhost/Makefile

-              r5b18137
+              rb4b534ac
         -I$(LIBUSB_PREFIX)/include \
         -I$(LIBDRV_PREFIX)/include \
+        -Iinclude/usb/host \
         -Iinclude
 SOURCES = \
+        src/ddf_helpers.c \
         src/endpoint.c \
+        src/iface.c \
+        src/usb_device_manager.c \
+        src/usb_endpoint_manager.c \
+        src/hcd.c \
+        src/usb_bus.c \
         src/usb_transfer_batch.c

uspace/lib/usbhost/include/usb/host/ddf_helpers.h

-              r5b18137
+              rb4b534ac
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2012 Jan Vesely
  * All rights reserved.
+ *
 …
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+/** @addtogroup drvusbohci
+/** @addtogroup libusbhost
  * @{
  */
 /** @file
  * PCI related functions needed by OHCI driver.
+ *
  */
+#ifndef DRV_OHCI_RES_H
+#define DRV_OHCI_RES_H
+#ifndef LIBUSBHOST_HOST_DDF_HELPERS_H
+#define LIBUSBHOST_HOST_DDF_HELPERS_H
+#include <usb/host/hcd.h>
+#include <usb/host/usb_bus.h>
+#include <usb/usb.h>
 #include <ddf/driver.h>
+#include <ddf/interrupt.h>
 #include <device/hw_res_parsed.h>
+int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
+int enable_interrupts(ddf_dev_t *);
+typedef int (*driver_init_t)(hcd_t *, const hw_res_list_parsed_t *, bool);
+typedef void (*driver_fini_t)(hcd_t *);
+typedef int (*claim_t)(ddf_dev_t *);
+typedef int (*irq_code_gen_t)(irq_code_t *, const hw_res_list_parsed_t *);
+typedef struct {
+        hcd_ops_t ops;
+        claim_t claim;
+        usb_speed_t hc_speed;
+        driver_init_t init;
+        driver_fini_t fini;
+        interrupt_handler_t *irq_handler;
+        irq_code_gen_t irq_code_gen;
+        const char *name;
+} ddf_hc_driver_t;
+int hcd_ddf_add_hc(ddf_dev_t *device, const ddf_hc_driver_t *driver);
+int hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed,
+    size_t bw, bw_count_func_t bw_count);
+void hcd_ddf_clean_hc(ddf_dev_t *device);
+int hcd_ddf_setup_root_hub(ddf_dev_t *device);
+hcd_t *dev_to_hcd(ddf_dev_t *dev);
+int hcd_ddf_enable_interrupts(ddf_dev_t *device);
+int hcd_ddf_get_registers(ddf_dev_t *device, hw_res_list_parsed_t *hw_res);
+int hcd_ddf_setup_interrupts(ddf_dev_t *device,
+    const hw_res_list_parsed_t *hw_res,
+    interrupt_handler_t handler,
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *));
+void ddf_hcd_gen_irq_handler(ipc_callid_t iid, ipc_call_t *call, ddf_dev_t *dev);
 #endif
 /**
  * @}
  */

uspace/lib/usbhost/include/usb/host/endpoint.h

-              r5b18137
+              rb4b534ac
         /** Maximum size of data packets. */
         size_t max_packet_size;
+        /** Additional opportunities per uframe */
+        unsigned packets;
         /** Necessary bandwidth. */
         size_t bandwidth;
 …
         /** Signals change of active status. */
         fibril_condvar_t avail;
+        /** High speed TT data */
+        struct {
+                usb_address_t address;
+                unsigned port;
+        } tt;
         /** Optional device specific data. */
         struct {
 …
 endpoint_t * endpoint_create(usb_address_t address, usb_endpoint_t endpoint,
     usb_direction_t direction, usb_transfer_type_t type, usb_speed_t speed,
+    size_t max_packet_size, size_t bw);
+    size_t max_packet_size, unsigned packets, size_t bw,
+    usb_address_t tt_address, unsigned tt_port);
 void endpoint_destroy(endpoint_t *instance);

uspace/lib/usbhost/include/usb/host/hcd.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBHOST_HOST_HCD_H
+#include <usb/host/endpoint.h>
+#include <usb/host/usb_bus.h>
+#include <usb/host/usb_transfer_batch.h>
+#include <usb/usb.h>
 #include <assert.h>
 #include <usbhc_iface.h>
+#include <usb/host/usb_device_manager.h>
+#include <usb/host/usb_endpoint_manager.h>
+#include <usb/host/usb_transfer_batch.h>
+#include <sys/types.h>
 typedef struct hcd hcd_t;
+typedef int (*schedule_hook_t)(hcd_t *, usb_transfer_batch_t *);
+typedef int (*ep_add_hook_t)(hcd_t *, endpoint_t *);
+typedef void (*ep_remove_hook_t)(hcd_t *, endpoint_t *);
+typedef void (*interrupt_hook_t)(hcd_t *, uint32_t);
+typedef int (*status_hook_t)(hcd_t *, uint32_t *);
+typedef struct {
+        /** Transfer scheduling, implement in device driver. */
+        schedule_hook_t schedule;
+        /** Hook called upon registering new endpoint. */
+        ep_add_hook_t ep_add_hook;
+        /** Hook called upon removing of an endpoint. */
+        ep_remove_hook_t ep_remove_hook;
+        /** Hook to be called on device interrupt, passes ARG1 */
+        interrupt_hook_t irq_hook;
+        /** Periodic polling hook */
+        status_hook_t status_hook;
+} hcd_ops_t;
 /** Generic host controller driver structure. */
 struct hcd {
-        /** Device manager storing handles and addresses. */
-        usb_device_manager_t dev_manager;
         /** Endpoint manager. */
         usb_endpoint_manager_t ep_manager;
+        usb_bus_t bus;
+        /** Interrupt replacement fibril */
+        fid_t polling_fibril;
+        /** Driver implementation */
+        hcd_ops_t ops;
         /** Device specific driver data. */
+        void *private_data;
+        /** Transfer scheduling, implement in device driver. */
+        int (*schedule)(hcd_t *, usb_transfer_batch_t *);
+        /** Hook called upon registering new endpoint. */
+        int (*ep_add_hook)(hcd_t *, endpoint_t *);
+        /** Hook called upon removing of an endpoint. */
+        void (*ep_remove_hook)(hcd_t *, endpoint_t *);
+        void * driver_data;
 };
+/** Initialize hcd_t structure.
+ * Initializes device and endpoint managers. Sets data and hook pointer to NULL.
+ * @param hcd hcd_t structure to initialize, non-null.
+ * @param bandwidth Available bandwidth, passed to endpoint manager.
+ * @param bw_count Bandwidth compute function, passed to endpoint manager.
+ */
+static inline void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth,
+    size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t))
+void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth,
+    bw_count_func_t bw_count);
+static inline void hcd_set_implementation(hcd_t *hcd, void *data,
+    const hcd_ops_t *ops)
+{
         assert(hcd);
         usb_device_manager_init(&hcd->dev_manager, max_speed);
         usb_endpoint_manager_init(&hcd->ep_manager, bandwidth, bw_count);
         hcd->private_data = NULL;
         hcd->schedule = NULL;
         hcd->ep_add_hook = NULL;
         hcd->ep_remove_hook = NULL;
+        if (ops) {
+                hcd->driver_data = data;
+                hcd->ops = *ops;
+        } else {
+                memset(&hcd->ops, 0, sizeof(hcd->ops));
+        }
+}
+/** Check registered endpoints and reset toggle bit if necessary.
+ * @param hcd hcd_t structure, non-null.
+ * @param target Control communication target.
+ * @param setup_data Setup packet of the control communication.
+ */
+static inline void reset_ep_if_need(hcd_t *hcd, usb_target_t target,
+    const char setup_data[8])
+static inline void * hcd_get_driver_data(hcd_t *hcd)
+{
         assert(hcd);
+        usb_endpoint_manager_reset_eps_if_need(
+            &hcd->ep_manager, target, (const uint8_t *)setup_data);
+        return hcd->driver_data;
+}
+/** Data retrieve wrapper.
+ * @param fun ddf function, non-null.
+ * @return pointer cast to hcd_t*.
+ */
+static inline hcd_t *fun_to_hcd(ddf_fun_t *fun)
+usb_address_t hcd_request_address(hcd_t *hcd, usb_speed_t speed);
+int hcd_release_address(hcd_t *hcd, usb_address_t address);
+int hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed);
+static inline int hcd_release_default_address(hcd_t *hcd)
+{
         return ddf_fun_data_get(fun);
+        return hcd_release_address(hcd, USB_ADDRESS_DEFAULT);
+}
+extern usbhc_iface_t hcd_iface;
+int hcd_add_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir,
+    usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
+    size_t size, usb_address_t tt_address, unsigned tt_port);
+int hcd_remove_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir);
+int hcd_send_batch(hcd_t *hcd, usb_target_t target, usb_direction_t direction,
+    void *data, size_t size, uint64_t setup_data,
+    usbhc_iface_transfer_in_callback_t in,
+    usbhc_iface_transfer_out_callback_t out, void *arg, const char* name);
+ssize_t hcd_send_batch_sync(hcd_t *hcd, usb_target_t target,
+    usb_direction_t dir, void *data, size_t size, uint64_t setup_data,
+    const char* name);
 #endif
 /**
  * @}

uspace/lib/usbhost/include/usb/host/usb_bus.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBHOST_HOST_USB_ENDPOINT_MANAGER_H
+#include <usb/host/endpoint.h>
+#include <usb/usb.h>
 #include <adt/list.h>
 #include <fibril_synch.h>
 #include <usb/usb.h>
+#include <stdbool.h>
-#include <usb/host/endpoint.h>
 /** Bytes per second in FULL SPEED */
 …
 /** 90% of total bandwidth is available for periodic transfers */
 #define BANDWIDTH_AVAILABLE_USB11 ((BANDWIDTH_TOTAL_USB11 / 10) * 9)
+/** 16 addresses per list */
+#define ENDPOINT_LIST_COUNT 8
+//TODO: Implement
+#define BANDWIDTH_AVAILABLE_USB20  1
+typedef size_t (*bw_count_func_t)(usb_speed_t, usb_transfer_type_t, size_t, size_t);
+typedef void (*ep_remove_callback_t)(endpoint_t *, void *);
+typedef int (*ep_add_callback_t)(endpoint_t *, void *);
 /** Endpoint management structure */
+typedef struct usb_endpoint_manager {
+        /** Store endpoint_t instances */
+        list_t endpoint_lists[ENDPOINT_LIST_COUNT];
+typedef struct usb_bus {
+        struct {
+                usb_speed_t speed;      /**< Device speed */
+                bool occupied;          /**< The address is in use. */
+                list_t endpoint_list;   /**< Store endpoint_t instances */
+        } devices[USB_ADDRESS_COUNT];
         /** Prevents races accessing lists */
         fibril_mutex_t guard;
 …
         size_t free_bw;
         /** Use this function to count bw required by EP */
+        size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t);
+} usb_endpoint_manager_t;
+        bw_count_func_t bw_count;
+        /** Maximum speed allowed. */
+        usb_speed_t max_speed;
+        /** The last reserved address */
+        usb_address_t last_address;
+} usb_bus_t;
 size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type,
     size_t size, size_t max_packet_size);
+size_t bandwidth_count_usb20(usb_speed_t speed, usb_transfer_type_t type,
+    size_t size, size_t max_packet_size);
+int usb_endpoint_manager_init(usb_endpoint_manager_t *instance,
+    size_t available_bandwidth,
+    size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t));
+int usb_bus_init(usb_bus_t *instance,
+    size_t available_bandwidth, bw_count_func_t bw_count, usb_speed_t max_speed);
+void usb_endpoint_manager_reset_eps_if_need(usb_endpoint_manager_t *instance,
+    usb_target_t target, const uint8_t data[8]);
+int usb_bus_register_ep(usb_bus_t *instance, endpoint_t *ep, size_t data_size);
+int usb_endpoint_manager_register_ep(
+    usb_endpoint_manager_t *instance, endpoint_t *ep, size_t data_size);
+int usb_endpoint_manager_unregister_ep(
+    usb_endpoint_manager_t *instance, endpoint_t *ep);
+endpoint_t * usb_endpoint_manager_find_ep(usb_endpoint_manager_t *instance,
+int usb_bus_unregister_ep(usb_bus_t *instance, endpoint_t *ep);
+endpoint_t * usb_bus_find_ep(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t ep, usb_direction_t direction);
 int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance,
+int usb_bus_add_ep(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size,
+    size_t data_size, int (*callback)(endpoint_t *, void *), void *arg);
+    usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
+    size_t data_size, ep_add_callback_t callback, void *arg,
+    usb_address_t tt_address, unsigned tt_port);
 int usb_endpoint_manager_remove_ep(usb_endpoint_manager_t *instance,
+int usb_bus_remove_ep(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
     void (*callback)(endpoint_t *, void *), void *arg);
+    ep_remove_callback_t callback, void *arg);
+void usb_endpoint_manager_remove_address(usb_endpoint_manager_t *instance,
+    usb_address_t address, void (*callback)(endpoint_t *, void *), void *arg);
+int usb_bus_reset_toggle(usb_bus_t *instance, usb_target_t target, bool all);
+int usb_bus_remove_address(usb_bus_t *instance,
+    usb_address_t address, ep_remove_callback_t callback, void *arg);
+int usb_bus_request_address(usb_bus_t *instance,
+    usb_address_t *address, bool strict, usb_speed_t speed);
+int usb_bus_get_speed(usb_bus_t *instance,
+    usb_address_t address, usb_speed_t *speed);
 #endif
 /**

uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h

-              r5b18137
+              rb4b534ac
 #define LIBUSBHOST_HOST_USB_TRANSFER_BATCH_H
+#include <adt/list.h>
+#include <usb/host/endpoint.h>
+#include <usb/usb.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <sys/types.h>
 #include <usbhc_iface.h>
-#include <usb/usb.h>
-#include <usb/host/endpoint.h>
 #define USB_SETUP_PACKET_SIZE 8
 …
          */
         size_t setup_size;
-        /** Host controller function, passed to callback function */
-        ddf_fun_t *fun;
         /** Actually used portion of the buffer
 …
          */
         int error;
-        /** Driver specific data */
-        void *private_data;
-        /** Callback to properly remove driver data during destruction */
-        void (*private_data_dtor)(void *p_data);
 } usb_transfer_batch_t;
 …
     usbhc_iface_transfer_in_callback_t func_in,
     usbhc_iface_transfer_out_callback_t func_out,
+    void *arg,
+    ddf_fun_t *fun,
+    void *private_data,
+    void (*private_data_dtor)(void *p_data)
+    void *arg
 );
 void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance);

uspace/lib/usbhost/include/usb/host/utils/malloc32.h

-              r5b18137
+              rb4b534ac
 /*
  * Copyright (c) 2010 Jan Vesely
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
+ *
 …
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup drvusbohci
+/** @addtogroup drvusbehci
  * @{
  */
 /** @file
  * @brief OHCI driver
+ * @brief EHCI driver
  */
 #ifndef DRV_OHCI_UTILS_MALLOC32_H
 #define DRV_OHCI_UTILS_MALLOC32_H
+#ifndef DRV_EHCI_UTILS_MALLOC32_H
+#define DRV_EHCI_UTILS_MALLOC32_H
 #include <assert.h>
 #include <malloc.h>
 #include <unistd.h>
+#include <align.h>
+#include <as.h>
+#include <ddi.h>
 #include <errno.h>
 #include <mem.h>
 #include <as.h>
+#include <stdlib.h>
+#include <sys/types.h>
 /* Generic TDs and EDs require 16byte alignment,
 …
  * buffers do not have to be aligned.
  */
+#define OHCI_ALIGN 32
+#define EHCI_ALIGN   32
+#define EHCI_REQUIRED_PAGE_SIZE   4096
 /** Get physical address translation
 …
  */
 static inline void * malloc32(size_t size)
+        { return memalign(OHCI_ALIGN, size); }
+{
+        uintptr_t phys;
+        void *address = AS_AREA_ANY;
+        size_t real_size = ALIGN_UP(size, PAGE_SIZE);
+        const int ret = dmamem_map_anonymous(real_size,
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
+            &address);
+        if (ret == EOK) {
+                /* Poison, accessing it should be enough to make sure
+                 * the location is mapped, but poison works better */
+                memset(address, 0x5, real_size);
+                return address;
+        }
+        return NULL;
+}
 /** Physical mallocator simulator
 …
  */
 static inline void free32(void *addr)
+        { free(addr); }
+{
+        dmamem_unmap_anonymous(addr);
+}
+/** Create 4KB page mapping
+ *
+ * @return Address of the mapped page, NULL on failure.
+ */
+static inline void *get_page()
+{
+        return malloc32(PAGE_SIZE);
+}
+static inline void return_page(void *page)
+{
+        free32(page);
+}
 #endif
 /**

uspace/lib/usbhost/src/endpoint.c

-              r5b18137
+              rb4b534ac
  */
+#include <usb/host/endpoint.h>
 #include <assert.h>
 #include <stdlib.h>
-#include <errno.h>
-#include <usb/host/endpoint.h>
 /** Allocate ad initialize endpoint_t structure.
 …
 endpoint_t * endpoint_create(usb_address_t address, usb_endpoint_t endpoint,
     usb_direction_t direction, usb_transfer_type_t type, usb_speed_t speed,
+    size_t max_packet_size, size_t bw)
+    size_t max_packet_size, unsigned packets, size_t bw,
+    usb_address_t tt_address, unsigned tt_p)
+{
         endpoint_t *instance = malloc(sizeof(endpoint_t));
 …
                 instance->speed = speed;
                 instance->max_packet_size = max_packet_size;
+                instance->packets = packets;
                 instance->bandwidth = bw;
                 instance->toggle = 0;
                 instance->active = false;
+                instance->tt.address = tt_address;
+                instance->tt.port = tt_p;
                 instance->hc_data.data = NULL;
                 instance->hc_data.toggle_get = NULL;
 …
+{
         assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->hc_data.data = NULL;
+        instance->hc_data.toggle_get = NULL;
+        instance->hc_data.toggle_set = NULL;
+        fibril_mutex_unlock(&instance->guard);
+        endpoint_set_hc_data(instance, NULL, NULL, NULL);
+}

uspace/lib/usbhost/src/usb_bus.c

-              r5b18137
+              rb4b534ac
  */
+#include <stdbool.h>
+#include <usb/host/usb_bus.h>
+#include <usb/debug.h>
 #include <assert.h>
 #include <errno.h>
 #include <usb/debug.h>
+#include <usb/host/usb_endpoint_manager.h>
+#include <macros.h>
+#include <stdbool.h>
 /** Endpoint compare helper function.
 …
 /** Get list that holds endpoints for given address.
  * @param instance usb_endpoint_manager structure, non-null.
+ * @param instance usb_bus structure, non-null.
  * @param addr USB address, must be >= 0.
  * @return Pointer to the appropriate list.
  */
 static list_t * get_list(usb_endpoint_manager_t *instance, usb_address_t addr)
+static list_t * get_list(usb_bus_t *instance, usb_address_t addr)
+{
         assert(instance);
         assert(addr >= 0);
         return &instance->endpoint_lists[addr % ENDPOINT_LIST_COUNT];
+        return &instance->devices[addr % ARRAY_SIZE(instance->devices)].endpoint_list;
+}
 /** Internal search function, works on locked structure.
  * @param instance usb_endpoint_manager structure, non-null.
+ * @param instance usb_bus structure, non-null.
  * @param address USB address, must be valid.
  * @param endpoint USB endpoint number.
 …
  * @note Assumes that the internal mutex is locked.
  */
 static endpoint_t * find_locked(usb_endpoint_manager_t *instance,
+static endpoint_t * find_locked(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
+{
 …
+        }
         return NULL;
+}
+/** Get a free USB address
+ *
+ * @param[in] instance Device manager structure to use.
+ * @return Free address, or error code.
+ */
+static usb_address_t usb_bus_get_free_address(usb_bus_t *instance)
+{
+        usb_address_t new_address = instance->last_address;
+        do {
+                new_address = (new_address + 1) % USB_ADDRESS_COUNT;
+                if (new_address == USB_ADDRESS_DEFAULT)
+                        new_address = 1;
+                if (new_address == instance->last_address)
+                        return ENOSPC;
+        } while (instance->devices[new_address].occupied);
+        assert(new_address != USB_ADDRESS_DEFAULT);
+        instance->last_address = new_address;
+        return new_address;
+}
 …
+}
+/** Calculate bandwidth that needs to be reserved for communication with EP.
+ * Calculation follows USB 2.0 specification.
+ * @param speed Device's speed.
+ * @param type Type of the transfer.
+ * @param size Number of byte to transfer.
+ * @param max_packet_size Maximum bytes in one packet.
+ */
+size_t bandwidth_count_usb20(usb_speed_t speed, usb_transfer_type_t type,
+    size_t size, size_t max_packet_size)
+{
+        /* We care about bandwidth only for interrupt and isochronous. */
+        if ((type != USB_TRANSFER_INTERRUPT)
+            && (type != USB_TRANSFER_ISOCHRONOUS)) {
+                return 0;
+        }
+        //TODO Implement
+        return 0;
+}
 /** Initialize to default state.
  * You need to provide valid bw_count function if you plan to use
  * add_endpoint/remove_endpoint pair.
+ *
  * @param instance usb_endpoint_manager structure, non-null.
+ * @param instance usb_bus structure, non-null.
  * @param available_bandwidth Size of the bandwidth pool.
  * @param bw_count function to use to calculate endpoint bw requirements.
  * @return Error code.
  */
+int usb_endpoint_manager_init(usb_endpoint_manager_t *instance,
+    size_t available_bandwidth,
+    size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t))
+int usb_bus_init(usb_bus_t *instance,
+    size_t available_bandwidth, bw_count_func_t bw_count, usb_speed_t max_speed)
+{
         assert(instance);
 …
         instance->free_bw = available_bandwidth;
         instance->bw_count = bw_count;
+        for (unsigned i = 0; i < ENDPOINT_LIST_COUNT; ++i) {
+                list_initialize(&instance->endpoint_lists[i]);
+        instance->last_address = 0;
+        instance->max_speed = max_speed;
+        for (unsigned i = 0; i < ARRAY_SIZE(instance->devices); ++i) {
+                list_initialize(&instance->devices[i].endpoint_list);
+                instance->devices[i].speed = USB_SPEED_MAX;
+                instance->devices[i].occupied = false;
+        }
         return EOK;
+}
-/** Check setup packet data for signs of toggle reset.
+ *
- * @param[in] instance usb_endpoint_manager structure, non-null.
- * @param[in] target Device to receive setup packet.
- * @param[in] data Setup packet data.
+ *
- * 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,
-    usb_target_t target, const uint8_t data[8])
+{
-        assert(instance);
-        if (!usb_target_is_valid(target)) {
-                usb_log_error("Invalid data when checking for toggle reset.\n");
-                return;
+        }
-        assert(data);
-        switch (data[1])
+        {
-        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);
-                        /* endpoint number is < 16, thus first byte is enough */
-                        list_foreach(*get_list(instance, target.address),
-                            link, endpoint_t, ep) {
-                                if ((ep->address == target.address)
-                                    && (ep->endpoint = data[4])) {
-                                        endpoint_toggle_set(ep,0);
+                                }
+                        }
-                        fibril_mutex_unlock(&instance->guard);
+                }
-        break;
-        case 0x9: /* Set Configuration */
-        case 0x11: /* Set Interface */
-                /* 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,
-                 * unless you're changing configuration or alternative
-                 * interface of an already setup device. */
-                if ((data[0] & 0xf) == 0) {
-                        fibril_mutex_lock(&instance->guard);
-                        list_foreach(*get_list(instance, target.address),
-                            link, endpoint_t, ep) {
-                                if (ep->address == target.address) {
-                                        endpoint_toggle_set(ep,0);
+                                }
+                        }
-                        fibril_mutex_unlock(&instance->guard);
+                }
-        break;
+        }
+}
 /** Register endpoint structure.
  * Checks for duplicates.
  * @param instance usb_endpoint_manager, non-null.
+ * @param instance usb_bus, non-null.
  * @param ep endpoint_t to register.
  * @param data_size Size of data to transfer.
  * @return Error code.
  */
+int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
+    endpoint_t *ep, size_t data_size)
+int usb_bus_register_ep(usb_bus_t *instance, endpoint_t *ep, size_t data_size)
+{
         assert(instance);
 …
         instance->free_bw -= ep->bandwidth;
+        usb_log_debug("Registered EP(%d:%d:%s:%s)\n", ep->address, ep->endpoint,
+            usb_str_transfer_type_short(ep->transfer_type),
+            usb_str_direction(ep->direction));
         fibril_mutex_unlock(&instance->guard);
         return EOK;
 …
 /** Unregister endpoint structure.
  * Checks for duplicates.
  * @param instance usb_endpoint_manager, non-null.
+ * @param instance usb_bus, non-null.
  * @param ep endpoint_t to unregister.
  * @return Error code.
  */
+int usb_endpoint_manager_unregister_ep(
+    usb_endpoint_manager_t *instance, endpoint_t *ep)
+int usb_bus_unregister_ep(usb_bus_t *instance, endpoint_t *ep)
+{
         assert(instance);
 …
         list_remove(&ep->link);
         instance->free_bw += ep->bandwidth;
+        usb_log_debug("Unregistered EP(%d:%d:%s:%s)\n", ep->address,
+            ep->endpoint, usb_str_transfer_type_short(ep->transfer_type),
+            usb_str_direction(ep->direction));
         fibril_mutex_unlock(&instance->guard);
         return EOK;
 …
 /** Find endpoint_t representing the given communication route.
  * @param instance usb_endpoint_manager, non-null.
+ * @param instance usb_bus, non-null.
  * @param address
  */
 endpoint_t * usb_endpoint_manager_find_ep(usb_endpoint_manager_t *instance,
+endpoint_t * usb_bus_find_ep(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
+{
 …
 /** Create and register new endpoint_t structure.
  * @param instance usb_endpoint_manager structure, non-null.
+ * @param instance usb_bus structure, non-null.
  * @param address USB address.
  * @param endpoint USB endpoint number.
 …
  * @return Error code.
  */
 int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance,
+int usb_bus_add_ep(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size,
+    size_t data_size, int (*callback)(endpoint_t *, void *), void *arg)
+    usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
+    size_t data_size, ep_add_callback_t callback, void *arg,
+    usb_address_t tt_address, unsigned tt_port)
+{
         assert(instance);
         if (instance->bw_count == NULL)
                 return ENOTSUP;
+        if (address < 0)
+                return EINVAL;
+        const size_t bw =
+            instance->bw_count(speed, type, data_size, max_packet_size);
+        fibril_mutex_lock(&instance->guard);
+        /* Check for available bandwidth */
+        if (bw > instance->free_bw) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOSPC;
+        if (!usb_address_is_valid(address))
+                return EINVAL;
+        fibril_mutex_lock(&instance->guard);
+        /* Check for speed and address */
+        if (!instance->devices[address].occupied) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOENT;
+        }
 …
+        }
+        ep = endpoint_create(
+            address, endpoint, direction, type, speed, max_packet_size, bw);
+        const usb_speed_t speed = instance->devices[address].speed;
+        const size_t bw =
+            instance->bw_count(speed, type, data_size, max_packet_size);
+        /* Check for available bandwidth */
+        if (bw > instance->free_bw) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOSPC;
+        }
+        ep = endpoint_create(address, endpoint, direction, type, speed,
+            max_packet_size, packets, bw, tt_address, tt_port);
         if (!ep) {
                 fibril_mutex_unlock(&instance->guard);
 …
 /** Unregister and destroy endpoint_t structure representing given route.
  * @param instance usb_endpoint_manager structure, non-null.
+ * @param instance usb_bus structure, non-null.
  * @param address USB address.
  * @param endpoint USB endpoint number.
 …
  * @return Error code.
  */
 int usb_endpoint_manager_remove_ep(usb_endpoint_manager_t *instance,
+int usb_bus_remove_ep(usb_bus_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
     void (*callback)(endpoint_t *, void *), void *arg)
+    ep_remove_callback_t callback, void *arg)
+{
         assert(instance);
 …
+}
+int usb_bus_reset_toggle(usb_bus_t *instance, usb_target_t target, bool all)
+{
+        assert(instance);
+        if (!usb_target_is_valid(target))
+                return EINVAL;
+        int ret = ENOENT;
+        fibril_mutex_lock(&instance->guard);
+        list_foreach(*get_list(instance, target.address), link, endpoint_t, ep) {
+                if ((ep->address == target.address)
+                    && (all || ep->endpoint == target.endpoint)) {
+                        endpoint_toggle_set(ep, 0);
+                        ret = EOK;
+                }
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
 /** Unregister and destroy all endpoints using given address.
  * @param instance usb_endpoint_manager structure, non-null.
+ * @param instance usb_bus structure, non-null.
  * @param address USB address.
  * @param endpoint USB endpoint number.
 …
  * @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)
+{
         list_t *list;
         link_t *link;
         link_t *next;
         assert(address >= 0);
+        assert(instance);
         fibril_mutex_lock(&instance->guard);
+        list = get_list(instance, address);
         link = list_first(list);
         while (link != NULL) {
+int usb_bus_remove_address(usb_bus_t *instance,
+    usb_address_t address, ep_remove_callback_t callback, void *arg)
+{
+        assert(instance);
+        if (!usb_address_is_valid(address))
+                return EINVAL;
+        fibril_mutex_lock(&instance->guard);
+        const int ret = instance->devices[address].occupied ? EOK : ENOENT;
+        instance->devices[address].occupied = false;
+        list_t *list = get_list(instance, address);
+        for (link_t *link = list_first(list); link != NULL; ) {
                 endpoint_t *ep = list_get_instance(link, endpoint_t, link);
+                next = list_next(link, list);
+                link = list_next(link, list);
                 if (ep->address == address) {
                         list_remove(&ep->link);
 …
                         endpoint_destroy(ep);
+                }
+                link = next;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
+/** Request USB address.
+ * @param instance usb_device_manager
+ * @param address Pointer to requested address value, place to store new address
+ * @parma strict Fail if the requested address is not available.
+ * @return Error code.
+ * @note Default address is only available in strict mode.
+ */
+int usb_bus_request_address(usb_bus_t *instance,
+    usb_address_t *address, bool strict, usb_speed_t speed)
+{
+        assert(instance);
+        assert(address);
+        if (speed > instance->max_speed)
+                return ENOTSUP;
+        if (!usb_address_is_valid(*address))
+                return EINVAL;
+        usb_address_t addr = *address;
+        fibril_mutex_lock(&instance->guard);
+        /* Only grant default address to strict requests */
+        if ((addr == USB_ADDRESS_DEFAULT) && !strict) {
+                addr = usb_bus_get_free_address(instance);
+        }
+        if (instance->devices[addr].occupied) {
+                if (strict) {
+                        fibril_mutex_unlock(&instance->guard);
+                        return ENOENT;
+                }
+                addr = usb_bus_get_free_address(instance);
+        }
+        if (usb_address_is_valid(addr)) {
+                assert(instance->devices[addr].occupied == false);
+                assert(addr != USB_ADDRESS_DEFAULT || strict);
+                instance->devices[addr].occupied = true;
+                instance->devices[addr].speed = speed;
+                *address = addr;
+                addr = 0;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return addr;
+}
+/** Get speed assigned to USB address.
+ *
+ * @param[in] instance Device manager structure to use.
+ * @param[in] address Address the caller wants to find.
+ * @param[out] speed Assigned speed.
+ * @return Error code.
+ */
+int usb_bus_get_speed(usb_bus_t *instance, usb_address_t address,
+    usb_speed_t *speed)
+{
+        assert(instance);
+        if (!usb_address_is_valid(address)) {
+                return EINVAL;
+        }
+        fibril_mutex_lock(&instance->guard);
+        const int ret = instance->devices[address].occupied ? EOK : ENOENT;
+        if (speed && instance->devices[address].occupied) {
+                *speed = instance->devices[address].speed;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        return ret;
+}
 /**

uspace/lib/usbhost/src/usb_transfer_batch.c

-              r5b18137
+              rb4b534ac
  * USB transfer transaction structures (implementation).
  */
+#include <usb/host/usb_transfer_batch.h>
+#include <usb/debug.h>
+#include <assert.h>
 #include <errno.h>
 #include <macros.h>
+#include <usb/usb.h>
+#include <usb/debug.h>
+#include <usb/host/usb_transfer_batch.h>
+#include <usb/host/hcd.h>
+#include <mem.h>
+#include <stdlib.h>
+#include <usbhc_iface.h>
 /** Allocate and initialize usb_transfer_batch structure.
 …
     usbhc_iface_transfer_in_callback_t func_in,
     usbhc_iface_transfer_out_callback_t func_out,
+    void *arg,
+    ddf_fun_t *fun,
+    void *private_data,
+    void (*private_data_dtor)(void *)
+    void *arg
+    )
+{
 …
                 instance->buffer_size = buffer_size;
                 instance->setup_size = 0;
-                instance->fun = fun;
-                instance->private_data = private_data;
-                instance->private_data_dtor = private_data_dtor;
                 instance->transfered_size = 0;
                 instance->error = EOK;
 …
                 endpoint_release(instance->ep);
+        }
-        if (instance->private_data) {
-                assert(instance->private_data_dtor);
-                instance->private_data_dtor(instance->private_data);
+        }
         free(instance);
+}
 …
         /* NOTE: Only one of these pointers should be set. */
         if (instance->callback_out) {
+                /* Check for commands that reset toggle bit */
+                if (instance->ep->transfer_type == USB_TRANSFER_CONTROL
+                    && error == EOK) {
+                        const usb_target_t target =
+                            {{ instance->ep->address, instance->ep->endpoint }};
+                        reset_ep_if_need(fun_to_hcd(instance->fun), target,
+                            instance->setup_buffer);
+                }
+                instance->callback_out(instance->fun, error, instance->arg);
+                instance->callback_out(error, instance->arg);
+        }
 …
                         memcpy(instance->buffer, data, safe_size);
+                }
+                instance->callback_in(instance->fun, error,
+                    safe_size, instance->arg);
+                instance->callback_in(error, safe_size, instance->arg);
+        }
+}

uspace/lib/usbvirt/Makefile

-              r5b18137
+              rb4b534ac
         -I$(LIBUSB_PREFIX)/include \
         -I$(LIBUSBDEV_PREFIX)/include \
+        -Iinclude
+        -Iinclude \
+        -Iinclude/usbvirt
 SOURCES = \
 …
         src/ipc_hc.c \
         src/stdreq.c \
+        src/transfer.c
+        src/transfer.c \
+        src/virthub_base.c \
+        src/virthub_descriptors.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/usbvirt/include/usbvirt/device.h

-              r5b18137
+              rb4b534ac
 #include <usb/dev/request.h>
 #include <async.h>
+#include <errno.h>
 /** Maximum number of endpoints supported by virtual USB. */
 …
 typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *dev,
     usb_endpoint_t endpoint, usb_transfer_type_t transfer_type,
     void *buffer, size_t buffer_size);
+    const void *buffer, size_t buffer_size);
 /** Callback for data from device (IN transaction).
 …
     uint8_t *data, size_t *act_data_size);
+/** Create a class request to get data from device
+ *
+ * @param rec Request recipient.
+ * @param req Request code.
+ */
+#define CLASS_REQ_IN(rec, req) \
+        .request_type = SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_CLASS, rec), \
+        .request = req
+/** Create a class request to send data to device
+ *
+ * @param rec Request recipient.
+ * @param req Request code.
+ */
+#define CLASS_REQ_OUT(rec, req) \
+        .request_type = SETUP_REQUEST_TO_DEVICE(USB_REQUEST_TYPE_CLASS, rec), \
+        .request = req
+/** Create a standard request to get data from device
+ *
+ * @param rec Request recipient.
+ * @param req Request code.
+ */
+#define STD_REQ_IN(rec, req) \
+        .request_type = SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, rec), \
+        .request = req
+/** Create a standard request to send data to device
+ *
+ * @param rec Request recipient.
+ * @param req Request code.
+ */
+#define STD_REQ_OUT(rec, req) \
+        .request_type = SETUP_REQUEST_TO_DEVICE(USB_REQUEST_TYPE_STANDARD, rec), \
+        .request = req
 /** Callback for control request on a virtual USB device.
+ *
 …
  */
 typedef struct {
+        /** Request direction (in or out). */
+        usb_direction_t req_direction;
+        /** Request recipient (device, interface or endpoint). */
+        usb_request_recipient_t req_recipient;
+        /** Request type (standard, class or vendor). */
+        usb_request_type_t req_type;
+        /* Request type. See usb/request.h */
+        uint8_t request_type;
         /** Actual request code. */
         uint8_t request;
 …
 typedef struct {
         /** Actual data. */
         uint8_t *data;
+        const uint8_t *data;
         /** Data length. */
         size_t length;
 …
         usb_standard_configuration_descriptor_t *descriptor;
         /** Array of extra data. */
         usbvirt_device_configuration_extras_t *extra;
+        const usbvirt_device_configuration_extras_t *extra;
         /** Length of @c extra array. */
         size_t extra_count;
 …
          * There is always only one such descriptor for the device.
          */
         usb_standard_device_descriptor_t *device;
+        const usb_standard_device_descriptor_t *device;
         /** Configurations. */
 …
          * Last handler is expected to have the @c callback field set to NULL
          */
         usbvirt_control_request_handler_t *control;
+        const usbvirt_control_request_handler_t *control;
         /** Callback when device changes state.
+         *
 …
 /** Virtual USB device. */
 struct usbvirt_device {
+        /** Device does not require USB bus power */
+        bool self_powered;
+        /** Device is allowed to signal remote wakeup */
+        bool remote_wakeup;
         /** Name for debugging purposes. */
         const char *name;
 …
         usbvirt_device_ops_t *ops;
         /** Device descriptors. */
         usbvirt_descriptors_t *descriptors;
+        const usbvirt_descriptors_t *descriptors;
         /** Current device address.
          * You shall treat this field as read only in your code.
 …
 };
+int req_nop(usbvirt_device_t *device,
+    const usb_device_request_setup_packet_t *setup_packet,
+    uint8_t *data, size_t *act_size);
 int usbvirt_device_plug(usbvirt_device_t *, const char *);
 void usbvirt_device_unplug(usbvirt_device_t *);
 void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *,
     uint8_t *, size_t *, void *, size_t);
 int usbvirt_control_write(usbvirt_device_t *, void *, size_t, void *, size_t);
 int usbvirt_control_read(usbvirt_device_t *, void *, size_t, void *, size_t, size_t *);
+    uint8_t *, size_t *, const void *, size_t);
+int usbvirt_control_write(usbvirt_device_t *, const void *, size_t, void *, size_t);
+int usbvirt_control_read(usbvirt_device_t *, const void *, size_t, void *, size_t, size_t *);
 int usbvirt_data_out(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t,
     void *, size_t);
+    const void *, size_t);
 int usbvirt_data_in(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t,
     void *, size_t, size_t *);

uspace/lib/usbvirt/include/usbvirt/virthub_base.h

-              r5b18137
+              rb4b534ac
 /*
  * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2013 Jan Vesely
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup drvusbvhc
+/** @addtogroup libusbvirt
  * @{
  */
 /** @file
  * @brief Virtual USB hub.
+ * Virtual USB device.
  */
 #ifndef VHCD_HUB_H_
 #define VHCD_HUB_H_
+#ifndef LIBUSBVIRT_VIRTHUB_BASE_H_
+#define LIBUSBVIRT_VIRTHUB_BASE_H_
 #include <usbvirt/device.h>
 #include <ddf/driver.h>
+#include <usb/classes/hub.h>
+#include "hub/hub.h"
+#include "hub/virthub.h"
+enum {
+        VIRTHUB_EXTR_DESC = 3,
+};
+extern usbvirt_device_t virtual_hub_device;
+typedef struct {
+        usb_standard_configuration_descriptor_t config_descriptor;
+        usb_standard_endpoint_descriptor_t endpoint_descriptor;
+        usbvirt_device_configuration_extras_t extra[VIRTHUB_EXTR_DESC];
+        usbvirt_device_configuration_t configuration;
+        usbvirt_descriptors_t descriptors;
+        usbvirt_device_t device;
+        void *data;
+} virthub_base_t;
+void virtual_hub_device_init(ddf_fun_t *);
+void *virthub_get_data(usbvirt_device_t *dev);
+int virthub_base_init(virthub_base_t *instance,
+    const char *name, usbvirt_device_ops_t *ops, void *data,
+    const usb_standard_device_descriptor_t *device_desc,
+    const usb_hub_descriptor_header_t *hub_desc, usb_endpoint_t ep);
+usb_address_t virthub_base_get_address(virthub_base_t *instance);
+int virthub_base_request(virthub_base_t *instance, usb_target_t target,
+    usb_direction_t dir, const usb_device_request_setup_packet_t *setup,
+    void *buffer, size_t buffer_size, size_t *real_size);
+int virthub_base_get_hub_descriptor(usbvirt_device_t *dev,
+    const usb_device_request_setup_packet_t *request, uint8_t *data,
+    size_t *act_size);
+int virthub_base_get_null_status(usbvirt_device_t *dev,
+    const usb_device_request_setup_packet_t *request, uint8_t *data,
+    size_t *act_size);
 #endif
 /**
  * @}

uspace/lib/usbvirt/src/ctrltransfer.c

-              r5b18137
+              rb4b534ac
  */
 int process_control_transfer(usbvirt_device_t *dev,
     usbvirt_control_request_handler_t *control_handlers,
     usb_device_request_setup_packet_t *setup,
+    const usbvirt_control_request_handler_t *control_handlers,
+    const usb_device_request_setup_packet_t *setup,
     uint8_t *data, size_t *data_sent_size)
+{
 …
                 return EFORWARD;
+        }
+        usb_direction_t direction = setup->request_type & 128 ?
+            USB_DIRECTION_IN : USB_DIRECTION_OUT;
+        usb_request_recipient_t req_recipient = setup->request_type & 31;
+        usb_request_type_t req_type = (setup->request_type >> 5) & 3;
+        usbvirt_control_request_handler_t *handler = control_handlers;
+        while (handler->callback != NULL) {
+                if (handler->req_direction != direction) {
+                        goto next;
+                }
+                if (handler->req_recipient != req_recipient) {
+                        goto next;
+                }
+                if (handler->req_type != req_type) {
+                        goto next;
+                }
+                if (handler->request != setup->request) {
+                        goto next;
+        const usbvirt_control_request_handler_t *handler = control_handlers;
+        for (;handler->callback != NULL; ++handler) {
+                if (handler->request != setup->request ||
+                    handler->request_type != setup->request_type) {
+                        continue;
+                }
 …
                     usb_debug_str_buffer((uint8_t*) setup, sizeof(*setup), 0));
                 int rc = handler->callback(dev, setup, data, data_sent_size);
                 if (rc == EFORWARD) {
                         goto next;
+                if (rc != EFORWARD) {
+                        return rc;
+                }
-                return rc;
-next:
-                handler++;
+        }

uspace/lib/usbvirt/src/private.h

-              r5b18137
+              rb4b534ac
 int process_control_transfer(usbvirt_device_t *,
     usbvirt_control_request_handler_t *,
     usb_device_request_setup_packet_t *,
+    const usbvirt_control_request_handler_t *,
+    const usb_device_request_setup_packet_t *,
     uint8_t *, size_t *);

uspace/lib/usbvirt/src/stdreq.c

-              r5b18137
+              rb4b534ac
 void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *setup_packet,
     uint8_t *data, size_t *act_size,
     void *actual_data, size_t actual_data_size)
+    const void *actual_data, size_t actual_data_size)
+{
         size_t expected_size = setup_packet->length;
 …
                 *act_size = actual_data_size;
+        }
+}
+/** NOP handler */
+int req_nop(usbvirt_device_t *device,
+    const usb_device_request_setup_packet_t *setup_packet,
+    uint8_t *data, size_t *act_size)
+{
+        return EOK;
+}
 …
+                }
                 /* Copy the data. */
                 usbvirt_device_configuration_t *config = &device->descriptors
                     ->configuration[index];
+                const usbvirt_device_configuration_t *config =
+                    &device->descriptors->configuration[index];
                 uint8_t *all_data = malloc(config->descriptor->total_length);
                 if (all_data == NULL) {
 …
                 size_t i;
                 for (i = 0; i < config->extra_count; i++) {
                         usbvirt_device_configuration_extras_t *extra
+                        const usbvirt_device_configuration_extras_t *extra
                             = &config->extra[i];
                         memcpy(ptr, extra->data, extra->length);
 …
+}
+static int req_get_dev_status(usbvirt_device_t *device,
+    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
+{
+        if (setup_packet->length != 2)
+                return ESTALL;
+        data[0] = (device->self_powered ? 1 : 0) | (device->remote_wakeup ? 2 : 0);
+        data[1] = 0;
+        *act_size = 2;
+        return EOK;
+}
+static int req_get_iface_ep_status(usbvirt_device_t *device,
+    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
+{
+        if (setup_packet->length != 2)
+                return ESTALL;
+        data[0] = 0;
+        data[1] = 0;
+        *act_size = 2;
+        return EOK;
+}
 /** Standard request handlers. */
 usbvirt_control_request_handler_t library_handlers[] = {
+        {
+                .req_direction = USB_DIRECTION_OUT,
+                .req_recipient = USB_REQUEST_RECIPIENT_DEVICE,
+                .req_type = USB_REQUEST_TYPE_STANDARD,
+                .request = USB_DEVREQ_SET_ADDRESS,
+                STD_REQ_OUT(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_SET_ADDRESS),
                 .name = "SetAddress",
                 .callback = req_set_address
         },
+        {
+                .req_direction = USB_DIRECTION_IN,
+                .req_recipient = USB_REQUEST_RECIPIENT_DEVICE,
+                .req_type = USB_REQUEST_TYPE_STANDARD,
+                .request = USB_DEVREQ_GET_DESCRIPTOR,
+                .name = "GetDescriptor",
+                STD_REQ_IN(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_GET_DESCRIPTOR),
+                .name = "GetStdDescriptor",
                 .callback = req_get_descriptor
         },
+        {
+                .req_direction = USB_DIRECTION_OUT,
+                .req_recipient = USB_REQUEST_RECIPIENT_DEVICE,
+                .req_type = USB_REQUEST_TYPE_STANDARD,
+                .request = USB_DEVREQ_SET_CONFIGURATION,
+                STD_REQ_OUT(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_SET_CONFIGURATION),
                 .name = "SetConfiguration",
                 .callback = req_set_configuration
         },
+        {
+                STD_REQ_IN(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_GET_STATUS),
+                .name = "GetDeviceStatus",
+                .callback = req_get_dev_status,
+        },
+        {
+                STD_REQ_IN(USB_REQUEST_RECIPIENT_INTERFACE, USB_DEVREQ_GET_STATUS),
+                .name = "GetInterfaceStatus",
+                .callback = req_get_iface_ep_status,
+        },
+        {
+                /* virtual EPs by default cannot be stalled */
+                STD_REQ_IN(USB_REQUEST_RECIPIENT_ENDPOINT, USB_DEVREQ_GET_STATUS),
+                .name = "GetEndpointStatus",
+                .callback = req_get_iface_ep_status,
+        },
         { .callback = NULL }
 };

uspace/lib/usbvirt/src/transfer.c

-              r5b18137
+              rb4b534ac
  */
 static int usbvirt_control_transfer(usbvirt_device_t *dev,
     void *setup, size_t setup_size,
+    const void *setup, size_t setup_size,
     void *data, size_t data_size, size_t *data_size_sent)
+{
 …
                 return ESTALL;
+        }
         usb_device_request_setup_packet_t *setup_packet = setup;
+        const usb_device_request_setup_packet_t *setup_packet = setup;
         if (data_size != setup_packet->length) {
                 return ESTALL;
 …
  * @return Error code.
  */
 int usbvirt_control_write(usbvirt_device_t *dev, void *setup, size_t setup_size,
     void *data, size_t data_size)
+int usbvirt_control_write(usbvirt_device_t *dev, const void *setup,
+    size_t setup_size, void *data, size_t data_size)
+{
         return usbvirt_control_transfer(dev, setup, setup_size,
 …
  * @return Error code.
  */
 int usbvirt_control_read(usbvirt_device_t *dev, void *setup, size_t setup_size,
+int usbvirt_control_read(usbvirt_device_t *dev, const void *setup, size_t setup_size,
     void *data, size_t data_size, size_t *data_size_sent)
+{
 …
  */
 int usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
     usb_endpoint_t endpoint, void *data, size_t data_size)
+    usb_endpoint_t endpoint, const void *data, size_t data_size)
+{
         if ((endpoint <= 0) || (endpoint >= USBVIRT_ENDPOINT_MAX)) {

Context Navigation

Changeset b4b534ac in mainline for uspace/lib

Legend:

Download in other formats: