Changeset df6ded8 for uspace/lib – HelenOS

uspace/lib/c/include/bitops.h

-              rf5e5f73
+              rdf6ded8
 #define BIT_RANGE_EXTRACT(type, hi, lo, value) \
     (((value) >> (lo)) & BIT_RRANGE(type, (hi) - (lo) + 1))
+/** Insert @a value between bits @a hi .. @a lo. */
+#define BIT_RANGE_INSERT(type, hi, lo, value) \
+    (((value) & BIT_RRANGE(type, (hi) - (lo) + 1)) << (lo))
 /** Return position of first non-zero bit from left (i.e. [log_2(arg)]).

uspace/lib/c/include/byteorder.h

-              rf5e5f73
+              rdf6ded8
 #define ntohl(n)  uint32_t_be2host((n))
+#define uint8_t_be2host(n)  (n)
+#define uint8_t_le2host(n)  (n)
+#define host2uint8_t_be(n)  (n)
+#define host2uint8_t_le(n)  (n)
+#define host2uint8_t_le(n)  (n)
+#define  int8_t_le2host(n)  uint8_t_le2host(n)
+#define int16_t_le2host(n) uint16_t_le2host(n)
+#define int32_t_le2host(n) uint32_t_le2host(n)
+#define int64_t_le2host(n) uint64_t_le2host(n)
+#define  int8_t_be2host(n)  uint8_t_be2host(n)
+#define int16_t_be2host(n) uint16_t_be2host(n)
+#define int32_t_be2host(n) uint32_t_be2host(n)
+#define int64_t_be2host(n) uint64_t_be2host(n)
+#define  host2int8_t_le(n)  host2uint8_t_le(n)
+#define host2int16_t_le(n) host2uint16_t_le(n)
+#define host2int32_t_le(n) host2uint32_t_le(n)
+#define host2int64_t_le(n) host2uint64_t_le(n)
+#define  host2int8_t_be(n)  host2uint8_t_be(n)
+#define host2int16_t_be(n) host2uint16_t_be(n)
+#define host2int32_t_be(n) host2uint32_t_be(n)
+#define host2int64_t_be(n) host2uint64_t_be(n)
 static inline uint64_t uint64_t_byteorder_swap(uint64_t n)
+{

uspace/lib/c/include/ipc/dev_iface.h

-              rf5e5f73
+              rdf6ded8
         /** Audio device pcm buffer interface */
         AUDIO_PCM_BUFFER_IFACE,
         /** Network interface controller interface */
         NIC_DEV_IFACE,
         /** IEEE 802.11 interface controller interface */
         IEEE80211_DEV_IFACE,
         /** Interface provided by any PCI device. */
         PCI_DEV_IFACE,
 …
         /** Interface provided by any USB device. */
         USB_DEV_IFACE,
+        /** Interface provided by USB host controller. */
+        /** Interface provided by USB diagnostic devices. */
+        USBDIAG_DEV_IFACE,
+        /** Interface provided by USB host controller to USB device. */
         USBHC_DEV_IFACE,
         /** Interface provided by USB HID devices. */

uspace/lib/drv/Makefile

rf5e5f73	rdf6ded8
47	47	generic/remote_usb.c \
48	48	generic/remote_pci.c \
	49	generic/remote_usbdiag.c \
49	50	generic/remote_usbhc.c \
50	51	generic/remote_usbhid.c \

uspace/lib/drv/generic/dev_iface.c

-              rf5e5f73
+              rdf6ded8
 #include "remote_ieee80211.h"
 #include "remote_usb.h"
+#include "remote_usbdiag.h"
 #include "remote_usbhc.h"
 #include "remote_usbhid.h"
 …
                 [PCI_DEV_IFACE] = &remote_pci_iface,
                 [USB_DEV_IFACE] = &remote_usb_iface,
+                [USBDIAG_DEV_IFACE] = &remote_usbdiag_iface,
                 [USBHC_DEV_IFACE] = &remote_usbhc_iface,
                 [USBHID_DEV_IFACE] = &remote_usbhid_iface,
 …
         if (iface_method_idx >= rem_iface->method_count)
                 return NULL;
         return rem_iface->methods[iface_method_idx];
+}

uspace/lib/drv/generic/driver.c

rf5e5f73	rdf6ded8
971	971	}
972	972
973		int ddf_driver_main(const driver_t *drv)
	973	errno_t ddf_driver_main(const driver_t *drv)
974	974	{
975	975	/*

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

rf5e5f73	rdf6ded8
1	1	/*
2	2	* Copyright (c) 2010 Vojtech Horky
	3	* Copyright (c) 2017 Ondrej Hlavaty
3	4	* All rights reserved.
4	5	*

uspace/lib/drv/generic/remote_usb.c

-              rf5e5f73
+              rdf6ded8
  * Copyright (c) 2010 Vojtech Horky
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Michal Staruch, Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 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);
+        return devman_parent_device_connect(ddf_dev_get_handle(dev),
+            IPC_FLAG_BLOCKING);
+}
 …
 typedef enum {
+        IPC_M_USB_GET_MY_INTERFACE,
+        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,
+        IPC_M_USB_GET_MY_DESCRIPTION,
 } usb_iface_funcs_t;
 …
  * @return Error code.
  */
+errno_t usb_get_my_interface(async_exch_t *exch, int *usb_iface)
+{
+        if (!exch)
+                return EBADMEM;
+        sysarg_t iface_no;
+        const errno_t ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_MY_INTERFACE, &iface_no);
+        if (ret == EOK && usb_iface)
+                *usb_iface = (int)iface_no;
+        return ret;
+}
+/** Tell devman handle of the usb device function.
+ *
+ * @param[in]  exch   IPC communication exchange
+ * @param[out] handle devman handle of the HC used by the target device.
+ *
+ * @return Error code.
+ *
+ */
+errno_t usb_get_my_device_handle(async_exch_t *exch, devman_handle_t *handle)
+{
+        devman_handle_t h = 0;
+        const errno_t ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_MY_DEVICE_HANDLE, &h);
+        if (ret == EOK && handle)
+                *handle = (devman_handle_t)h;
+        return ret;
+}
+/** Reserve default USB address.
+ * @param[in] exch IPC communication exchange
+ * @param[in] speed Communication speed of the newly attached device
+ * @return Error code.
+ */
+errno_t 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.
+ *
+ */
+errno_t 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.
+ *
+ */
+errno_t usb_device_enumerate(async_exch_t *exch, unsigned port)
+{
+        if (!exch)
+                return EBADMEM;
+        const errno_t 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.
+ *
+ */
+errno_t 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);
+}
+static_assert(sizeof(sysarg_t) >= 4);
+typedef union {
+        uint8_t arr[sizeof(sysarg_t)];
+        sysarg_t arg;
+} pack8_t;
+errno_t 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);
+}
+errno_t 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);
+}
+errno_t usb_read(async_exch_t *exch, usb_endpoint_t endpoint, uint64_t setup,
+    void *data, size_t size, size_t *rec_size)
+errno_t usb_get_my_description(async_exch_t *exch, usb_device_desc_t *desc)
+{
         if (!exch)
                 return EBADMEM;
+        if (size == 0 && setup == 0)
+                return EOK;
+        usb_device_desc_t tmp_desc;
+        /* 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. */
+        errno_t data_request_rc;
+        errno_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 (errno_t) opening_request_rc;
+                } else {
+                        return (errno_t) data_request_rc;
+                }
+        }
+        if (opening_request_rc != EOK) {
+                return (errno_t) opening_request_rc;
+        }
+        *rec_size = IPC_GET_ARG2(data_request_call);
+        return EOK;
+        const errno_t ret = async_req_1_5(exch, DEV_IFACE_ID(USB_DEV_IFACE),
+            IPC_M_USB_GET_MY_DESCRIPTION,
+            (sysarg_t *) &tmp_desc.address,
+            (sysarg_t *) &tmp_desc.depth,
+            (sysarg_t *) &tmp_desc.speed,
+            &tmp_desc.handle,
+            (sysarg_t *) &tmp_desc.iface);
+        if (ret == EOK && desc)
+                *desc = tmp_desc;
+        return ret;
+}
+errno_t 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 errno_t ret = async_data_write_start(exch, data, size);
+                if (ret != EOK) {
+                        async_forget(opening_request);
+                        return ret;
+                }
+        }
+        /* Wait for the answer. */
+        errno_t opening_request_rc;
+        async_wait_for(opening_request, &opening_request_rc);
+        return (errno_t) 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_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);
+static void remote_usb_get_my_description(ddf_fun_t *, void *,
+    ipc_callid_t, ipc_call_t *);
 /** Remote USB interface operations. */
 static const remote_iface_func_ptr_t remote_usb_iface_ops [] = {
+        [IPC_M_USB_GET_MY_INTERFACE] = remote_usb_get_my_interface,
+        [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,
+        [IPC_M_USB_GET_MY_DESCRIPTION] = remote_usb_get_my_description,
 };
 …
 };
 void remote_usb_get_my_interface(ddf_fun_t *fun, void *iface,
+void remote_usb_get_my_description(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_interface == NULL) {
+        if (usb_iface->get_my_description == NULL) {
                 async_answer_0(callid, ENOTSUP);
                 return;
+        }
         int iface_no;
         const errno_t ret = usb_iface->get_my_interface(fun, &iface_no);
+        usb_device_desc_t desc;
+        const errno_t ret = usb_iface->get_my_description(fun, &desc);
         if (ret != EOK) {
                 async_answer_0(callid, ret);
         } else {
+                async_answer_1(callid, EOK, iface_no);
+                async_answer_5(callid, EOK,
+                    (sysarg_t) desc.address,
+                    (sysarg_t) desc.depth,
+                    (sysarg_t) desc.speed,
+                    desc.handle,
+                    desc.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_my_device_handle == NULL) {
-                async_answer_0(callid, ENOTSUP);
-                return;
+        }
-        devman_handle_t handle;
-        const errno_t 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 errno_t 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 errno_t 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 errno_t 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 errno_t 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 errno_t 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);
-        errno_t 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(errno_t outcome, void *arg)
+{
-        async_transaction_t *trans = arg;
-        async_answer_0(trans->caller, outcome);
-        async_transaction_destroy(trans);
+}
-static void callback_in(errno_t 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);
-                async_transaction_destroy(trans);
-                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);
-                return;
+        }
-        const errno_t 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 errno_t 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 errno_t 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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2010-2011 Vojtech Horky
+ * Copyright (c) 2010 Vojtech Horky
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Petr Manek
  * All rights reserved.
+ *
 …
 #include <async.h>
+#include <macros.h>
 #include <errno.h>
 #include <assert.h>
 #include <macros.h>
+#include <devman.h>
+#include <as.h>
 #include "usbhc_iface.h"
 #include "ddf/driver.h"
+#define USB_MAX_PAYLOAD_SIZE 1020
+/** IPC methods for communication with HC through DDF interface.
+ *
+ * Notes for async methods:
+ *
+ * Methods for sending data to device (OUT transactions)
+ * - e.g. IPC_M_USBHC_INTERRUPT_OUT -
+ * always use the same semantics:
+ * - first, IPC call with given method is made
+ *   - argument #1 is target address
+ *   - argument #2 is target endpoint
+ *   - argument #3 is max packet size of the endpoint
+ * - this call is immediately followed by IPC data write (from caller)
+ * - the initial call (and the whole transaction) is answer after the
+ *   transaction is scheduled by the HC and acknowledged by the device
+ *   or immediately after error is detected
+ * - the answer carries only the error code
+ *
+ * Methods for retrieving data from device (IN transactions)
+ * - e.g. IPC_M_USBHC_INTERRUPT_IN -
+ * also use the same semantics:
+ * - first, IPC call with given method is made
+ *   - argument #1 is target address
+ *   - argument #2 is target endpoint
+ * - this call is immediately followed by IPC data read (async version)
+ * - the call is not answered until the device returns some data (or until
+ *   error occurs)
+ *
+ * Some special methods (NO-DATA transactions) do not send any data. These
+ * might behave as both OUT or IN transactions because communication parts
+ * where actual buffers are exchanged are omitted.
+ **
+ * For all these methods, wrap functions exists. Important rule: functions
+ * for IN transactions have (as parameters) buffers where retrieved data
+ * will be stored. These buffers must be already allocated and shall not be
+ * touch until the transaction is completed
+ * (e.g. not before calling usb_wait_for() with appropriate handle).
+ * OUT transactions buffers can be freed immediately after call is dispatched
+ * (i.e. after return from wrapping function).
+ *
+ */
 typedef enum {
+        /** Get data from device.
+         * See explanation at usb_iface_funcs_t (IN transaction).
+         */
+        IPC_M_USBHC_READ,
+        /** Send data to device.
+         * See explanation at usb_iface_funcs_t (OUT transaction).
+         */
+        IPC_M_USBHC_WRITE,
+        IPC_M_USB_DEFAULT_ADDRESS_RESERVATION,
+        IPC_M_USB_DEVICE_ENUMERATE,
+        IPC_M_USB_DEVICE_REMOVE,
+        IPC_M_USB_REGISTER_ENDPOINT,
+        IPC_M_USB_UNREGISTER_ENDPOINT,
+        IPC_M_USB_TRANSFER,
 } usbhc_iface_funcs_t;
+errno_t usbhc_read(async_exch_t *exch, usb_address_t address,
+    usb_endpoint_t endpoint, uint64_t setup, void *data, size_t size,
+    size_t *rec_size)
+{
+        if (!exch)
+                return EBADMEM;
+        if (size == 0 && setup == 0)
+                return EOK;
+        const usb_target_t target =
+            {{ .address = address, .endpoint = endpoint }};
+        /* Make call identifying target USB device and type of transfer. */
+        aid_t opening_request = async_send_4(exch,
+            DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_READ, target.packed,
+            (setup & UINT32_MAX), (setup >> 32), NULL);
+/** Reserve default USB address.
+ * @param[in] exch IPC communication exchange
+ * @return Error code.
+ */
+errno_t usbhc_reserve_default_address(async_exch_t *exch)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USB_DEFAULT_ADDRESS_RESERVATION, true);
+}
+/** Release default USB address.
+ *
+ * @param[in] exch IPC communication exchange
+ *
+ * @return Error code.
+ */
+errno_t usbhc_release_default_address(async_exch_t *exch)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USB_DEFAULT_ADDRESS_RESERVATION, false);
+}
+/**
+ * Trigger USB device enumeration
+ *
+ * @param[in] exch IPC communication exchange
+ * @param[in] port Port number at which the device is attached
+ * @param[in] speed Communication speed of the newly attached device
+ *
+ * @return Error code.
+ */
+errno_t usbhc_device_enumerate(async_exch_t *exch, unsigned port, usb_speed_t speed)
+{
+        if (!exch)
+                return EBADMEM;
+        const errno_t ret = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USB_DEVICE_ENUMERATE, port, speed);
+        return ret;
+}
+/** Trigger USB device enumeration
+ *
+ * @param[in] exch   IPC communication exchange
+ * @param[in] handle Identifier of the device
+ *
+ * @return Error code.
+ *
+ */
+errno_t usbhc_device_remove(async_exch_t *exch, unsigned port)
+{
+        if (!exch)
+                return EBADMEM;
+        return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USB_DEVICE_REMOVE, port);
+}
+errno_t usbhc_register_endpoint(async_exch_t *exch, usb_pipe_desc_t *pipe_desc,
+    const usb_endpoint_descriptors_t *desc)
+{
+        if (!exch)
+                return EBADMEM;
+        if (!desc)
+                return EINVAL;
+        aid_t opening_request = async_send_1(exch,
+            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USB_REGISTER_ENDPOINT, NULL);
         if (opening_request == 0) {
 …
+        }
+        /* 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?
+        errno_t ret = async_data_write_start(exch, desc, sizeof(*desc));
+        if (ret != EOK) {
                 async_forget(opening_request);
                 return ENOMEM;
+                return ret;
+        }
         /* Wait for the answer. */
-        errno_t data_request_rc;
         errno_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 (errno_t) opening_request_rc;
+                } else {
+                        return (errno_t) data_request_rc;
+                }
+        }
+        if (opening_request_rc != EOK) {
+        if (opening_request_rc)
                 return (errno_t) opening_request_rc;
+        }
+        *rec_size = IPC_GET_ARG2(data_request_call);
+        usb_pipe_desc_t dest;
+        ret = async_data_read_start(exch, &dest, sizeof(dest));
+        if (ret != EOK) {
+                return ret;
+        }
+        if (pipe_desc)
+                *pipe_desc = dest;
         return EOK;
+}
+errno_t usbhc_write(async_exch_t *exch, usb_address_t address,
+    usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size)
+{
+        if (!exch)
+                return EBADMEM;
+        if (size == 0 && setup == 0)
+                return EOK;
+        const usb_target_t target =
+            {{ .address = address, .endpoint = endpoint }};
+        aid_t opening_request = async_send_5(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USBHC_WRITE, target.packed, size,
+            (setup & UINT32_MAX), (setup >> 32), NULL);
+errno_t usbhc_unregister_endpoint(async_exch_t *exch, const usb_pipe_desc_t *pipe_desc)
+{
+        if (!exch)
+                return EBADMEM;
+        aid_t opening_request = async_send_1(exch,
+                DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USB_UNREGISTER_ENDPOINT, NULL);
         if (opening_request == 0) {
 …
+        }
+        /* Send the data if any. */
+        if (size > 0) {
+                const errno_t ret = async_data_write_start(exch, data, size);
+        const errno_t ret = async_data_write_start(exch, pipe_desc, sizeof(*pipe_desc));
+        if (ret != EOK) {
+                async_forget(opening_request);
+                return ret;
+        }
+        /* Wait for the answer. */
+        errno_t opening_request_rc;
+        async_wait_for(opening_request, &opening_request_rc);
+        return (errno_t) opening_request_rc;
+}
+/**
+ * Issue a USB transfer with a data contained in memory area. That area is
+ * temporarily shared with the HC.
+ */
+errno_t usbhc_transfer(async_exch_t *exch,
+    const usbhc_iface_transfer_request_t *req, size_t *transferred)
+{
+        if (transferred)
+                *transferred = 0;
+        if (!exch)
+                return EBADMEM;
+        ipc_call_t call;
+        aid_t opening_request = async_send_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
+            IPC_M_USB_TRANSFER, &call);
+        if (opening_request == 0)
+                return ENOMEM;
+        const errno_t ret = async_data_write_start(exch, req, sizeof(*req));
+        if (ret != EOK) {
+                async_forget(opening_request);
+                return ret;
+        }
+        /* Share the data, if any. */
+        if (req->size > 0) {
+                unsigned flags = (req->dir == USB_DIRECTION_IN)
+                        ? AS_AREA_WRITE : AS_AREA_READ;
+                const errno_t ret = async_share_out_start(exch, req->buffer.virt, flags);
                 if (ret != EOK) {
                         async_forget(opening_request);
 …
         async_wait_for(opening_request, &opening_request_rc);
+        if (transferred)
+                *transferred = IPC_GET_ARG1(call);
         return (errno_t) opening_request_rc;
+}
+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 *);
+/** Remote USB host controller interface operations. */
+static const remote_iface_func_ptr_t remote_usbhc_iface_ops[] = {
+        [IPC_M_USBHC_READ] = remote_usbhc_read,
+        [IPC_M_USBHC_WRITE] = remote_usbhc_write,
+static void remote_usbhc_default_address_reservation(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_device_enumerate(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_device_remove(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_transfer(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_usbhc_iface_ops [] = {
+        [IPC_M_USB_DEFAULT_ADDRESS_RESERVATION] = remote_usbhc_default_address_reservation,
+        [IPC_M_USB_DEVICE_ENUMERATE] = remote_usbhc_device_enumerate,
+        [IPC_M_USB_DEVICE_REMOVE] = remote_usbhc_device_remove,
+        [IPC_M_USB_REGISTER_ENDPOINT] = remote_usbhc_register_endpoint,
+        [IPC_M_USB_UNREGISTER_ENDPOINT] = remote_usbhc_unregister_endpoint,
+        [IPC_M_USB_TRANSFER] = remote_usbhc_transfer,
 };
 /** Remote USB host controller interface structure.
+/** Remote USB interface structure.
  */
 const remote_iface_t remote_usbhc_iface = {
         .method_count = ARRAY_SIZE(remote_usbhc_iface_ops),
         .methods = remote_usbhc_iface_ops
+        .methods = remote_usbhc_iface_ops,
 };
 typedef struct {
         ipc_callid_t caller;
+        ipc_callid_t data_caller;
+        void *buffer;
+        usbhc_iface_transfer_request_t request;
 } 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(errno_t outcome, void *arg)
+{
+        async_transaction_t *trans = arg;
+        async_answer_0(trans->caller, outcome);
+        async_transaction_destroy(trans);
+}
+static void callback_in(errno_t 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_usbhc_read(
+    ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+void remote_usbhc_default_address_reservation(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
+        if (usbhc_iface->default_address_reservation == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const bool reserve = IPC_GET_ARG2(*call);
+        const errno_t ret = usbhc_iface->default_address_reservation(fun, reserve);
+        async_answer_0(callid, ret);
+}
+static void remote_usbhc_device_enumerate(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
+        if (usbhc_iface->device_enumerate == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const unsigned port = DEV_IPC_GET_ARG1(*call);
+        usb_speed_t speed = DEV_IPC_GET_ARG2(*call);
+        const errno_t ret = usbhc_iface->device_enumerate(fun, port, speed);
+        async_answer_0(callid, ret);
+}
+static void remote_usbhc_device_remove(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
+        if (usbhc_iface->device_remove == NULL) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const unsigned port = DEV_IPC_GET_ARG1(*call);
+        const errno_t ret = usbhc_iface->device_remove(fun, port);
+        async_answer_0(callid, ret);
+}
+static void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
         assert(fun);
 …
         assert(call);
         const usbhc_iface_t *hc_iface = iface;
         if (!hc_iface->read) {
+        const usbhc_iface_t *usbhc_iface = iface;
+        if (!usbhc_iface->register_endpoint) {
                 async_answer_0(callid, ENOTSUP);
                 return;
+        }
+        const usb_target_t target = { .packed = DEV_IPC_GET_ARG1(*call) };
+        const uint64_t setup =
+            ((uint64_t)DEV_IPC_GET_ARG2(*call)) |
+            (((uint64_t)DEV_IPC_GET_ARG3(*call)) << 32);
+        usb_endpoint_descriptors_t ep_desc;
+        ipc_callid_t data_callid;
+        size_t len;
+        if (!async_data_write_receive(&data_callid, &len)
+            || len != sizeof(ep_desc)) {
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+        async_data_write_finalize(data_callid, &ep_desc, sizeof(ep_desc));
+        usb_pipe_desc_t pipe_desc;
+        const errno_t rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
+        async_answer_0(callid, rc);
+        if (!async_data_read_receive(&data_callid, &len)
+            || len != sizeof(pipe_desc)) {
+                return;
+        }
+        async_data_read_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+}
+static void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(fun);
+        assert(iface);
+        assert(call);
+        const usbhc_iface_t *usbhc_iface = iface;
+        if (!usbhc_iface->unregister_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        usb_pipe_desc_t pipe_desc;
+        ipc_callid_t data_callid;
+        size_t len;
+        if (!async_data_write_receive(&data_callid, &len)
+            || len != sizeof(pipe_desc)) {
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+        async_data_write_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+        const errno_t rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
+        async_answer_0(callid, rc);
+}
+static void async_transaction_destroy(async_transaction_t *trans)
+{
+        if (trans == NULL) {
+                return;
+        }
+        if (trans->request.buffer.virt != NULL) {
+                as_area_destroy(trans->request.buffer.virt);
+        }
+        free(trans);
+}
+static async_transaction_t *async_transaction_create(ipc_callid_t caller)
+{
+        async_transaction_t *trans = calloc(1, sizeof(async_transaction_t));
+        if (trans != NULL)
+                trans->caller = caller;
+        return trans;
+}
+static errno_t transfer_finished(void *arg, errno_t error, size_t transferred_size)
+{
+        async_transaction_t *trans = arg;
+        const errno_t err = async_answer_1(trans->caller, error, transferred_size);
+        async_transaction_destroy(trans);
+        return err;
+}
+static errno_t receive_memory_buffer(async_transaction_t *trans)
+{
+        assert(trans);
+        assert(trans->request.size > 0);
+        const size_t required_size = trans->request.offset + trans->request.size;
+        const unsigned required_flags =
+                (trans->request.dir == USB_DIRECTION_IN)
+                ? AS_AREA_WRITE : AS_AREA_READ;
+        errno_t err;
+        ipc_callid_t data_callid;
+        size_t size;
+        unsigned flags;
+        if (!async_share_out_receive(&data_callid, &size, &flags))
+                return EPARTY;
+        if (size < required_size || (flags & required_flags) != required_flags) {
+                async_answer_0(data_callid, EINVAL);
+                return EINVAL;
+        }
+        if ((err = async_share_out_finalize(data_callid, &trans->request.buffer.virt)))
+                return err;
+        /*
+         * As we're going to get physical addresses of the mapping, we must make
+         * sure the memory is actually mapped. We must do it right now, because
+         * the area might be read-only or write-only, and we may be unsure
+         * later.
+         */
+        if (flags & AS_AREA_READ) {
+                char foo = 0;
+                volatile const char *buf = trans->request.buffer.virt + trans->request.offset;
+                for (size_t i = 0; i < size; i += PAGE_SIZE)
+                        foo += buf[i];
+        } else {
+                volatile char *buf = trans->request.buffer.virt + trans->request.offset;
+                for (size_t i = 0; i < size; i += PAGE_SIZE)
+                        buf[i] = 0xff;
+        }
+        return EOK;
+}
+void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(fun);
+        assert(iface);
+        assert(call);
+        const usbhc_iface_t *usbhc_iface = iface;
+        if (!usbhc_iface->transfer) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
         async_transaction_t *trans = async_transaction_create(callid);
 …
+        }
+        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);
+                return;
+        }
+        const errno_t rc = hc_iface->read(
+            fun, target, 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_usbhc_write(
+    ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(fun);
+        assert(iface);
+        assert(call);
+        const usbhc_iface_t *hc_iface = iface;
+        if (!hc_iface->write) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        const usb_target_t target = { .packed = 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 errno_t rc = async_data_write_accept(&trans->buffer, false,
+, USB_MAX_PAYLOAD_SIZE,
+, &size);
+                if (rc != EOK) {
+                        async_answer_0(callid, rc);
+                        async_transaction_destroy(trans);
+                        return;
+                }
+        }
+        const errno_t rc = hc_iface->write(
+            fun, target, setup, trans->buffer, size, callback_out, trans);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_transaction_destroy(trans);
+        }
+}
+        errno_t err = EPARTY;
+        ipc_callid_t data_callid;
+        size_t len;
+        if (!async_data_write_receive(&data_callid, &len)
+            || len != sizeof(trans->request)) {
+                async_answer_0(data_callid, EINVAL);
+                goto err;
+        }
+        if ((err = async_data_write_finalize(data_callid,
+                            &trans->request, sizeof(trans->request))))
+                goto err;
+        if (trans->request.size > 0) {
+                if ((err = receive_memory_buffer(trans)))
+                        goto err;
+        } else {
+                /* The value was valid on the other side, for us, its garbage. */
+                trans->request.buffer.virt = NULL;
+        }
+        if ((err = usbhc_iface->transfer(fun, &trans->request,
+            &transfer_finished, trans)))
+                goto err;
+        /* The call will be answered asynchronously by the callback. */
+        return;
+err:
+        async_answer_0(callid, err);
+        async_transaction_destroy(trans);
+}
 /**
  * @}

uspace/lib/drv/include/usb_iface.h

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty, Michal Staruch
  * All rights reserved.
+ *
 …
  */
 /** @file
  * @brief USB interface definition.
+ * @brief USB device interface definition.
  */
 …
 #include "ddf/driver.h"
 #include <async.h>
+#include <usbhc_iface.h>
 typedef async_sess_t usb_dev_session_t;
+/** USB speeds. */
+typedef enum {
+        /** USB 1.1 low speed (1.5Mbits/s). */
+        USB_SPEED_LOW,
+        /** USB 1.1 full speed (12Mbits/s). */
+        USB_SPEED_FULL,
+        /** USB 2.0 high speed (480Mbits/s). */
+        USB_SPEED_HIGH,
+        /** Psuedo-speed serving as a boundary. */
+        USB_SPEED_MAX
+} usb_speed_t;
+/** USB endpoint number type.
+ * Negative values could be used to indicate error.
+ */
+typedef int16_t usb_endpoint_t;
+/** USB address type.
+ * Negative values could be used to indicate error.
+ */
+typedef int16_t usb_address_t;
+/** USB transfer type. */
+typedef enum {
+        USB_TRANSFER_CONTROL = 0,
+        USB_TRANSFER_ISOCHRONOUS = 1,
+        USB_TRANSFER_BULK = 2,
+        USB_TRANSFER_INTERRUPT = 3
+} usb_transfer_type_t;
+/** USB data transfer direction. */
+typedef enum {
+        USB_DIRECTION_IN,
+        USB_DIRECTION_OUT,
+        USB_DIRECTION_BOTH
+} usb_direction_t;
+/** USB complete address type.
+ * Pair address + endpoint is identification of transaction recipient.
+ */
+typedef union {
+        struct {
+                usb_address_t address;
+                usb_endpoint_t endpoint;
+        } __attribute__((packed));
+        uint32_t packed;
+} usb_target_t;
+typedef struct {
+        usb_address_t address;  /**< Current USB address */
+        uint8_t depth;          /**< Depth in the hub hiearchy */
+        usb_speed_t speed;      /**< Speed of the device */
+        devman_handle_t handle; /**< Handle to DDF function of the HC driver */
+        /** Interface set by multi interface driver,  -1 if none */
+        int iface;
+} usb_device_desc_t;
 extern usb_dev_session_t *usb_dev_connect(devman_handle_t);
 …
 extern void usb_dev_disconnect(usb_dev_session_t *);
+extern errno_t usb_get_my_interface(async_exch_t *, int *);
+extern errno_t usb_get_my_device_handle(async_exch_t *, devman_handle_t *);
+extern errno_t usb_reserve_default_address(async_exch_t *, usb_speed_t);
+extern errno_t usb_release_default_address(async_exch_t *);
+extern errno_t usb_device_enumerate(async_exch_t *, unsigned port);
+extern errno_t usb_device_remove(async_exch_t *, unsigned port);
+extern errno_t usb_register_endpoint(async_exch_t *, usb_endpoint_t,
+    usb_transfer_type_t, usb_direction_t, size_t, unsigned, unsigned);
+extern errno_t usb_unregister_endpoint(async_exch_t *, usb_endpoint_t,
+    usb_direction_t);
+extern errno_t usb_read(async_exch_t *, usb_endpoint_t, uint64_t, void *, size_t,
+    size_t *);
+extern errno_t 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)(errno_t, void *);
+/** Callback for incoming transfer. */
+typedef void (*usb_iface_transfer_in_callback_t)(errno_t, size_t, void *);
+extern errno_t usb_get_my_description(async_exch_t *, usb_device_desc_t *);
 /** USB device communication interface. */
 typedef struct {
+        errno_t (*get_my_interface)(ddf_fun_t *, int *);
+        errno_t (*get_my_device_handle)(ddf_fun_t *, devman_handle_t *);
+        errno_t (*reserve_default_address)(ddf_fun_t *, usb_speed_t);
+        errno_t (*release_default_address)(ddf_fun_t *);
+        errno_t (*device_enumerate)(ddf_fun_t *, unsigned);
+        errno_t (*device_remove)(ddf_fun_t *, unsigned);
+        errno_t (*register_endpoint)(ddf_fun_t *, usb_endpoint_t,
+            usb_transfer_type_t, usb_direction_t, size_t, unsigned, unsigned);
+        errno_t (*unregister_endpoint)(ddf_fun_t *, usb_endpoint_t,
+            usb_direction_t);
+        errno_t (*read)(ddf_fun_t *, usb_endpoint_t, uint64_t, uint8_t *, size_t,
+            usb_iface_transfer_in_callback_t, void *);
+        errno_t (*write)(ddf_fun_t *, usb_endpoint_t, uint64_t, const uint8_t *,
+            size_t, usb_iface_transfer_out_callback_t, void *);
+        errno_t (*get_my_description)(ddf_fun_t *, usb_device_desc_t *);
 } usb_iface_t;

uspace/lib/drv/include/usbhc_iface.h

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2010 Vojtech Horky
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2017 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
  * @{
  */
 /** @file
+ * @brief USB host controller interface definition.
+ * @brief USB host controler interface definition. This is the interface of
+ * USB host controller function, which can be used by usb device drivers.
  */
 …
 #include "ddf/driver.h"
+#include <usb_iface.h>
+#include <stdbool.h>
+extern errno_t usbhc_read(async_exch_t *, usb_address_t, usb_endpoint_t,
+    uint64_t, void *, size_t, size_t *);
+extern errno_t usbhc_write(async_exch_t *, usb_address_t, usb_endpoint_t,
+    uint64_t, const void *, size_t);
+/** Callback for outgoing transfer. */
+typedef void (*usbhc_iface_transfer_out_callback_t)(errno_t, void *);
+/** Callback for incoming transfer. */
+typedef void (*usbhc_iface_transfer_in_callback_t)(errno_t, size_t, void *);
+/** USB host controller communication interface. */
+#include <async.h>
+/** USB speeds. */
+typedef enum {
+        /** USB 1.1 low speed (1.5Mbits/s). */
+        USB_SPEED_LOW,
+        /** USB 1.1 full speed (12Mbits/s). */
+        USB_SPEED_FULL,
+        /** USB 2.0 high speed (480Mbits/s). */
+        USB_SPEED_HIGH,
+        /** USB 3.0 super speed (5Gbits/s). */
+        USB_SPEED_SUPER,
+        /** Psuedo-speed serving as a boundary. */
+        USB_SPEED_MAX
+} usb_speed_t;
+/** USB endpoint number type.
+ * Negative values could be used to indicate error.
+ */
+typedef uint16_t usb_endpoint_t;
+/** USB address type.
+ * Negative values could be used to indicate error.
+ */
+typedef uint16_t usb_address_t;
+/**
+ * USB Stream ID type.
+ */
+typedef uint16_t usb_stream_t;
+/** USB transfer type. */
+typedef enum {
+        USB_TRANSFER_CONTROL = 0,
+        USB_TRANSFER_ISOCHRONOUS = 1,
+        USB_TRANSFER_BULK = 2,
+        USB_TRANSFER_INTERRUPT = 3,
+} usb_transfer_type_t;
+#define USB_TRANSFER_COUNT  (USB_TRANSFER_INTERRUPT + 1)
+/** USB data transfer direction. */
+typedef enum {
+        USB_DIRECTION_IN,
+        USB_DIRECTION_OUT,
+        USB_DIRECTION_BOTH,
+} usb_direction_t;
+#define USB_DIRECTION_COUNT  (USB_DIRECTION_BOTH + 1)
+/** USB complete address type.
+ * Pair address + endpoint is identification of transaction recipient.
+ */
+typedef union {
+        struct {
+                usb_address_t address;
+                usb_endpoint_t endpoint;
+                usb_stream_t stream;
+        } __attribute__((packed));
+        uint64_t packed;
+} usb_target_t;
+// FIXME: DMA buffers shall be part of libdrv anyway.
+typedef uintptr_t dma_policy_t;
+typedef struct dma_buffer {
+        void *virt;
+        dma_policy_t policy;
+} dma_buffer_t;
+typedef struct usb_pipe_desc {
+        /** Endpoint number. */
+        usb_endpoint_t endpoint_no;
+        /** Endpoint transfer type. */
+        usb_transfer_type_t transfer_type;
+        /** Endpoint direction. */
+        usb_direction_t direction;
+        /**
+         * Maximum size of one transfer. Non-periodic endpoints may handle
+         * bigger transfers, but those can be split into multiple USB transfers.
+         */
+        size_t max_transfer_size;
+        /** Constraints on buffers to be transferred without copying */
+        dma_policy_t transfer_buffer_policy;
+} usb_pipe_desc_t;
+typedef struct usb_pipe_transfer_request {
+        usb_direction_t dir;
+        usb_endpoint_t endpoint;
+        usb_stream_t stream;
+        uint64_t setup;                 /**< Valid iff the transfer is of control type */
+        /**
+         * The DMA buffer to share. Must be at least offset + size large. Is
+         * patched after being transmitted over IPC, so the pointer is still
+         * valid.
+         */
+        dma_buffer_t buffer;
+        size_t offset;                  /**< Offset to the buffer */
+        size_t size;                    /**< Requested size. */
+} usbhc_iface_transfer_request_t;
+/** This structure follows standard endpoint descriptor + superspeed companion
+ * descriptor, and exists to avoid dependency of libdrv on libusb. Keep the
+ * internal fields named exactly like their source (because we want to use the
+ * same macros to access them).
+ * Callers shall fill it with bare contents of respective descriptors (in usb endianity).
+ */
+typedef struct usb_endpoint_descriptors {
+        struct {
+                uint8_t endpoint_address;
+                uint8_t attributes;
+                uint16_t max_packet_size;
+                uint8_t poll_interval;
+        } endpoint;
+        /* Superspeed companion descriptor */
+        struct companion_desc_t {
+                uint8_t max_burst;
+                uint8_t attributes;
+                uint16_t bytes_per_interval;
+        } companion;
+} usb_endpoint_descriptors_t;
+extern errno_t usbhc_reserve_default_address(async_exch_t *);
+extern errno_t usbhc_release_default_address(async_exch_t *);
+extern errno_t usbhc_device_enumerate(async_exch_t *, unsigned, usb_speed_t);
+extern errno_t usbhc_device_remove(async_exch_t *, unsigned);
+extern errno_t usbhc_register_endpoint(async_exch_t *, usb_pipe_desc_t *, const usb_endpoint_descriptors_t *);
+extern errno_t usbhc_unregister_endpoint(async_exch_t *, const usb_pipe_desc_t *);
+extern errno_t usbhc_transfer(async_exch_t *, const usbhc_iface_transfer_request_t *, size_t *);
+/** Callback for outgoing transfer */
+typedef errno_t (*usbhc_iface_transfer_callback_t)(void *, int, size_t);
+/** USB device communication interface. */
 typedef struct {
+        errno_t (*read)(ddf_fun_t *, usb_target_t, uint64_t, uint8_t *, size_t,
+            usbhc_iface_transfer_in_callback_t, void *);
+        errno_t (*write)(ddf_fun_t *, usb_target_t, uint64_t, const uint8_t *,
+            size_t, usbhc_iface_transfer_out_callback_t, void *);
+        errno_t (*default_address_reservation)(ddf_fun_t *, bool);
+        errno_t (*device_enumerate)(ddf_fun_t *, unsigned, usb_speed_t);
+        errno_t (*device_remove)(ddf_fun_t *, unsigned);
+        errno_t (*register_endpoint)(ddf_fun_t *, usb_pipe_desc_t *, const usb_endpoint_descriptors_t *);
+        errno_t (*unregister_endpoint)(ddf_fun_t *, const usb_pipe_desc_t *);
+        errno_t (*transfer)(ddf_fun_t *, const usbhc_iface_transfer_request_t *,
+            usbhc_iface_transfer_callback_t, void *);
 } usbhc_iface_t;
 #endif

uspace/lib/pcm/src/format.c

-              rf5e5f73
+              rdf6ded8
 #include "format.h"
-#define uint8_t_le2host(x) (x)
-#define host2uint8_t_le(x) (x)
-#define uint8_t_be2host(x) (x)
-#define host2uint8_t_be(x) (x)
-#define int8_t_le2host(x) (x)
-#define host2int8_t_le(x) (x)
-#define int16_t_le2host(x) uint16_t_le2host(x)
-#define host2int16_t_le(x) host2uint16_t_le(x)
-#define int32_t_le2host(x) uint32_t_le2host(x)
-#define host2int32_t_le(x) host2uint32_t_le(x)
-#define int8_t_be2host(x) (x)
-#define host2int8_t_be(x) (x)
-#define int16_t_be2host(x) uint16_t_be2host(x)
-#define host2int16_t_be(x) host2uint16_t_be(x)
-#define int32_t_be2host(x) uint32_t_be2host(x)
-#define host2int32_t_be(x) host2uint32_t_be(x)
 // TODO float endian?

uspace/lib/usb/Makefile

-              rf5e5f73
+              rdf6ded8
         src/dev.c \
         src/debug.c \
+        src/dma_buffer.c \
         src/dump.c \
+        src/port.c \
         src/usb.c

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2010 Matus Dekanek
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
         USB_HUB_FEATURE_HUB_OVER_CURRENT = 1,
         USB_HUB_FEATURE_PORT_CONNECTION = 0,
         USB_HUB_FEATURE_PORT_ENABLE = 1,
         USB_HUB_FEATURE_PORT_SUSPEND = 2,
+        USB2_HUB_FEATURE_PORT_ENABLE = 1,
+        USB2_HUB_FEATURE_PORT_SUSPEND = 2,
         USB_HUB_FEATURE_PORT_OVER_CURRENT = 3,
         USB_HUB_FEATURE_PORT_RESET = 4,
+        USB3_HUB_FEATURE_PORT_LINK_STATE = 5,
         USB_HUB_FEATURE_PORT_POWER = 8,
+        USB_HUB_FEATURE_PORT_LOW_SPEED = 9,
+        USB_HUB_FEATURE_PORT_HIGH_SPEED = 10,
+        USB2_HUB_FEATURE_PORT_LOW_SPEED = 9,
         USB_HUB_FEATURE_C_PORT_CONNECTION = 16,
         USB_HUB_FEATURE_C_PORT_ENABLE = 17,
         USB_HUB_FEATURE_C_PORT_SUSPEND = 18,
+        USB2_HUB_FEATURE_C_PORT_ENABLE = 17,
+        USB2_HUB_FEATURE_C_PORT_SUSPEND = 18,
         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
+        USB2_HUB_FEATURE_PORT_TEST = 21,
+        USB2_HUB_FEATURE_PORT_INDICATOR = 22,
+        USB3_HUB_FEATURE_C_PORT_LINK_STATE = 25,
+        USB3_HUB_FEATURE_BH_PORT_RESET = 28,
+        USB3_HUB_FEATURE_C_BH_PORT_RESET = 29,
         /* USB_HUB_FEATURE_ = , */
 } usb_hub_class_feature_t;
+/**
+ * Dword holding port status and changes flags.
+ *
+ * For more information refer to tables 11-15 and 11-16 in
+ * "Universal Serial Bus Specification Revision 1.1" pages 274 and 277
+ * (290 and 293 in pdf)
+ *
+ * Beware that definition of bits changed between USB 2 and 3,
+ * so some fields are prefixed with USB2 or USB3 instead.
+ */
+typedef uint32_t usb_port_status_t;
+#define USB_HUB_PORT_STATUS_BIT(bit)  (uint32_usb2host(1 << (bit)))
+#define USB_HUB_PORT_STATUS_CONNECTION          USB_HUB_PORT_STATUS_BIT(0)
+#define USB_HUB_PORT_STATUS_ENABLE              USB_HUB_PORT_STATUS_BIT(1)
+#define USB2_HUB_PORT_STATUS_SUSPEND            USB_HUB_PORT_STATUS_BIT(2)
+#define USB_HUB_PORT_STATUS_OC                  USB_HUB_PORT_STATUS_BIT(3)
+#define USB_HUB_PORT_STATUS_RESET               USB_HUB_PORT_STATUS_BIT(4)
+#define USB2_HUB_PORT_STATUS_POWER              USB_HUB_PORT_STATUS_BIT(8)
+#define USB2_HUB_PORT_STATUS_LOW_SPEED          USB_HUB_PORT_STATUS_BIT(9)
+#define USB3_HUB_PORT_STATUS_POWER              USB_HUB_PORT_STATUS_BIT(9)
+#define USB2_HUB_PORT_STATUS_HIGH_SPEED         USB_HUB_PORT_STATUS_BIT(10)
+#define USB2_HUB_PORT_STATUS_TEST               USB_HUB_PORT_STATUS_BIT(11)
+#define USB2_HUB_PORT_STATUS_INDICATOR          USB_HUB_PORT_STATUS_BIT(12)
+#define USB_HUB_PORT_STATUS_C_CONNECTION        USB_HUB_PORT_STATUS_BIT(16)
+#define USB2_HUB_PORT_STATUS_C_ENABLE           USB_HUB_PORT_STATUS_BIT(17)
+#define USB2_HUB_PORT_STATUS_C_SUSPEND          USB_HUB_PORT_STATUS_BIT(18)
+#define USB_HUB_PORT_STATUS_C_OC                USB_HUB_PORT_STATUS_BIT(19)
+#define USB_HUB_PORT_STATUS_C_RESET             USB_HUB_PORT_STATUS_BIT(20)
+#define USB3_HUB_PORT_STATUS_C_BH_RESET         USB_HUB_PORT_STATUS_BIT(21)
+#define USB3_HUB_PORT_STATUS_C_LINK_STATE       USB_HUB_PORT_STATUS_BIT(22)
+#define USB3_HUB_PORT_STATUS_C_CONFIG_ERROR     USB_HUB_PORT_STATUS_BIT(23)
 /** Header of standard hub descriptor without the "variadic" part. */
 …
         uint8_t length;
         /** Descriptor type (0x29). */
+        /** Descriptor type (0x29 or 0x2a for superspeed hub). */
         uint8_t descriptor_type;
 …
 #define HUB_CHAR_OC_PER_PORT_FLAG       (1 << 3)
 #define HUB_CHAR_NO_OC_FLAG             (1 << 4)
+/* These are invalid for superspeed hub */
 #define HUB_CHAR_TT_THINK_16            (1 << 5)
 #define HUB_CHAR_TT_THINK_8             (1 << 6)
 …
          */
         uint8_t max_current;
 } __attribute__ ((packed)) usb_hub_descriptor_header_t;
+} __attribute__((packed)) usb_hub_descriptor_header_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.
+ *
+ *      For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2
+/**
+ * @brief usb hub specific request types.
  */
 typedef enum {
+    /** This request resets a value reported in the hub status. */
+    USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE = 0x20,
+    /** This request resets a value reported in the port status. */
+    USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE = 0x23,
+    /** This is an optional per-port diagnostic request that returns the bus state value, as sampled at the last EOF2 point. */
+    USB_HUB_REQ_TYPE_GET_STATE = 0xA3,
+    /** This request returns the hub descriptor. */
+    USB_HUB_REQ_TYPE_GET_DESCRIPTOR = 0xA0,
+    /** This request returns the current hub status and the states that have changed since the previous acknowledgment. */
+    USB_HUB_REQ_TYPE_GET_HUB_STATUS = 0xA0,
+    /** This request returns the current port status and the current value of the port status change bits. */
+    USB_HUB_REQ_TYPE_GET_PORT_STATUS = 0xA3,
+    /** This request overwrites the hub descriptor. */
+    USB_HUB_REQ_TYPE_SET_DESCRIPTOR = 0x20,
+    /** This request sets a value reported in the hub status. */
+    USB_HUB_REQ_TYPE_SET_HUB_FEATURE = 0x20,
+    /** This request sets a value reported in the port status. */
+    USB_HUB_REQ_TYPE_SET_PORT_FEATURE = 0x23
+        /** This request resets a value reported in the hub status. */
+        USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE = 0x20,
+        /** This request resets a value reported in the port status. */
+        USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE = 0x23,
+        /**
+         * This is an optional per-port diagnostic request that returns the bus
+         * state value, as sampled at the last EOF2 point.
+         */
+        USB_HUB_REQ_TYPE_GET_STATE = 0xA3,
+        /** This request returns the hub descriptor. */
+        USB_HUB_REQ_TYPE_GET_DESCRIPTOR = 0xA0,
+        /**
+         * This request returns the current hub status and the states that have
+         * changed since the previous acknowledgment.
+         */
+        USB_HUB_REQ_TYPE_GET_HUB_STATUS = 0xA0,
+        /**
+         * This request returns the current port status and the current value of the
+         * port status change bits.
+         */
+        USB_HUB_REQ_TYPE_GET_PORT_STATUS = 0xA3,
+        /** This request overwrites the hub descriptor. */
+        USB_HUB_REQ_TYPE_SET_DESCRIPTOR = 0x20,
+        /** This request sets a value reported in the hub status. */
+        USB_HUB_REQ_TYPE_SET_HUB_FEATURE = 0x20,
+        /**
+         * This request sets the value that the hub uses to determine the index
+         * into the Route String Index for the hub.
+         */
+        USB_HUB_REQ_TYPE_SET_HUB_DEPTH = 0x20,
+        /** This request sets a value reported in the port status. */
+        USB_HUB_REQ_TYPE_SET_PORT_FEATURE = 0x23,
 } usb_hub_bm_request_type_t;
+/** @brief hub class request codes*/
+/// \TODO these are duplicit to standart descriptors
+/**
+ * @brief hub class request codes
+ */
 typedef enum {
+    /**  */
+    USB_HUB_REQUEST_GET_STATUS = 0,
+    /** */
+    USB_HUB_REQUEST_CLEAR_FEATURE = 1,
+    /** USB 1.0 only */
+    USB_HUB_REQUEST_GET_STATE = 2,
+    /** */
+    USB_HUB_REQUEST_SET_FEATURE = 3,
+    /** */
+    USB_HUB_REQUEST_GET_DESCRIPTOR = 6,
+    /** */
+    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_GET_STATUS = 0,
+        USB_HUB_REQUEST_CLEAR_FEATURE = 1,
+        /** USB 1.0 only */
+        USB_HUB_REQUEST_GET_STATE = 2,
+        USB_HUB_REQUEST_SET_FEATURE = 3,
+        USB_HUB_REQUEST_GET_DESCRIPTOR = 6,
+        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 3+ only */
+        USB_HUB_REQUEST_SET_HUB_DEPTH = 12,
 } usb_hub_request_t;
 /**
  *      Maximum size of usb hub descriptor in bytes
+ * Maximum size of usb hub descriptor in bytes
  */
 /* 7 (basic size) + 2*32 (port bitmasks) */

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2018 Michal Staruch, Ondrej Hlavaty
  * All rights reserved.
+ *
 …
         USB_DESCTYPE_OTHER_SPEED_CONFIGURATION = 7,
         USB_DESCTYPE_INTERFACE_POWER = 8,
+        /* USB 3.0 types */
+        USB_DESCTYPE_OTG = 9,
+        USB_DESCTYPE_DEBUG = 0xa,
+        USB_DESCTYPE_IFACE_ASSOC = 0xb,
+        USB_DESCTYPE_BOS = 0xf,
+        USB_DESCTYPE_DEVICE_CAP = 0x10,
         /* Class specific */
         USB_DESCTYPE_HID = 0x21,
 …
         USB_DESCTYPE_HID_PHYSICAL = 0x23,
         USB_DESCTYPE_HUB = 0x29,
+        USB_DESCTYPE_SSPEED_HUB = 0x2a,
+        USB_DESCTYPE_SSPEED_EP_COMPANION = 0x30
         /* USB_DESCTYPE_ = */
 } usb_descriptor_type_t;
 …
         /** Number of possible configurations. */
         uint8_t configuration_count;
 } __attribute__ ((packed)) usb_standard_device_descriptor_t;
+} __attribute__((packed)) usb_standard_device_descriptor_t;
 /** USB device qualifier decriptor is basically a cut down version of the device
 …
         uint8_t configuration_count;
         uint8_t reserved;
 } __attribute__ ((packed)) usb_standard_device_qualifier_descriptor_t;
+} __attribute__((packed)) usb_standard_device_qualifier_descriptor_t;
 /** Standard USB configuration descriptor.
 …
          */
         uint8_t max_power;
 } __attribute__ ((packed)) usb_standard_configuration_descriptor_t;
+} __attribute__((packed)) usb_standard_configuration_descriptor_t;
 /** USB Other Speed Configuration descriptor shows values that would change
 …
         /** String descriptor describing this interface. */
         uint8_t str_interface;
 } __attribute__ ((packed)) usb_standard_interface_descriptor_t;
+} __attribute__((packed)) usb_standard_interface_descriptor_t;
 /** Standard USB endpoint descriptor.
 …
         /** Endpoint address together with data flow direction. */
         uint8_t endpoint_address;
+#define USB_ED_GET_EP(ed)       ((ed).endpoint_address & 0xf)
+#define USB_ED_GET_DIR(ed)      (!(((ed).endpoint_address >> 7) & 0x1))
         /** Endpoint attributes.
          * Includes transfer type (usb_transfer_type_t).
          */
         uint8_t attributes;
+#define USB_ED_GET_TRANSFER_TYPE(ed)    ((ed).attributes & 0x3)
         /** Maximum packet size.
          * Lower 10 bits represent the actuall size
 …
          * 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.
+         * Isochronous endpoints must use value 1.
+         * Interrupt endpoints any value from 1 to 255.
+#define USB_ED_GET_MPS(ed) \
+        (uint16_usb2host((ed).max_packet_size) & 0x7ff)
+#define USB_ED_GET_ADD_OPPS(ed) \
+        ((uint16_usb2host((ed).max_packet_size) >> 11) & 0x3)
+        /** Polling interval. Different semantics for various (speed, type)
+         * pairs.
          */
         uint8_t poll_interval;
+} __attribute__ ((packed)) usb_standard_endpoint_descriptor_t;
+} __attribute__((packed)) usb_standard_endpoint_descriptor_t;
+/** Superspeed USB endpoint companion descriptor.
+ * See USB 3 specification, section 9.6.7.
+ */
+typedef struct {
+        /** Size of this descriptor in bytes */
+        uint8_t length;
+        /** Descriptor type (USB_DESCTYPE_SSPEED_EP_COMPANION). */
+        uint8_t descriptor_type;
+        /** The maximum number of packets the endpoint can send
+         * or receive as part of a burst. Valid values are from 0 to 15.
+         * The endpoint can only burst max_burst + 1 packets at a time.
+         */
+        uint8_t max_burst;
+        /** Valid only for bulk and isochronous endpoints.
+         * For bulk endpoints, this field contains the amount of streams
+         * supported by the endpoint.
+         * For isochronous endpoints, this field contains maximum
+         * number of packets supported within a service interval.
+         * Warning: the values returned by macros may not make any sense
+         * for specific endpoint types.
+         */
+        uint8_t attributes;
+#define USB_SSC_MAX_STREAMS(sscd) ((sscd).attributes & 0x1f)
+#define USB_SSC_MULT(sscd) ((sscd).attributes & 0x3)
+        /** The total number of bytes this endpoint will transfer
+         * every service interval (SI).
+         * This field is only valid for periodic endpoints.
+         */
+        uint16_t bytes_per_interval;
+} __attribute__((packed)) usb_superspeed_endpoint_companion_descriptor_t;
 /** Part of standard USB HID descriptor specifying one class descriptor.
 …
         /** Length of class-specific descriptor in bytes. */
         uint16_t length;
 } __attribute__ ((packed)) usb_standard_hid_class_descriptor_info_t;
+} __attribute__((packed)) usb_standard_hid_class_descriptor_info_t;
 /** Standard USB HID descriptor.
 …
         /** First mandatory class descriptor (Report) info. */
         usb_standard_hid_class_descriptor_info_t report_desc_info;
 } __attribute__ ((packed)) usb_standard_hid_descriptor_t;
+} __attribute__((packed)) usb_standard_hid_descriptor_t;
 #endif

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2012 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 #define USB_ENDPOINT_STATUS_HALTED ((uint16_t)(1 << 0))
+/** Size of the USB setup packet */
+#define USB_SETUP_PACKET_SIZE 8
 /** Device request setup packet.
  * The setup packet describes the request.
 …
 #define SETUP_REQUEST_TYPE_DEVICE_TO_HOST (1 << 7)
 #define SETUP_REQUEST_TYPE_HOST_TO_DEVICE (0 << 7)
+#define SETUP_REQUEST_TYPE_IS_DEVICE_TO_HOST(rt) ((rt) & (1 << 7))
 #define SETUP_REQUEST_TYPE_GET_TYPE(rt) ((rt >> 5) & 0x3)
 #define SETUP_REQUEST_TYPE_GET_RECIPIENT(rec) (rec & 0x1f)
 …
 } __attribute__ ((packed)) usb_device_request_setup_packet_t;
 static_assert(sizeof(usb_device_request_setup_packet_t) == 8);
+static_assert(sizeof(usb_device_request_setup_packet_t) == USB_SETUP_PACKET_SIZE);
+int usb_request_needs_toggle_reset(
+    const usb_device_request_setup_packet_t *request);
+#define GET_DEVICE_DESC(size) \
+{ \
+        .request_type = SETUP_REQUEST_TYPE_DEVICE_TO_HOST \
+            | (USB_REQUEST_TYPE_STANDARD << 5) \
+            | USB_REQUEST_RECIPIENT_DEVICE, \
+        .request = USB_DEVREQ_GET_DESCRIPTOR, \
+        .value = uint16_host2usb(USB_DESCTYPE_DEVICE << 8), \
+        .index = uint16_host2usb(0), \
+        .length = uint16_host2usb(size), \
+};
+#define SET_ADDRESS(address) \
+{ \
+        .request_type = SETUP_REQUEST_TYPE_HOST_TO_DEVICE \
+            | (USB_REQUEST_TYPE_STANDARD << 5) \
+            | USB_REQUEST_RECIPIENT_DEVICE, \
+        .request = USB_DEVREQ_SET_ADDRESS, \
+        .value = uint16_host2usb(address), \
+        .index = uint16_host2usb(0), \
+        .length = uint16_host2usb(0), \
+};
+#define CTRL_PIPE_MIN_PACKET_SIZE 8
 #endif

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2010 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty, Michal Staruch
  * All rights reserved.
+ *
 …
 #include <stdint.h>
 #include <types/common.h>
 #include <usb_iface.h>
+#include <usbhc_iface.h>
 /** Convert 16bit value from native (host) endianness to USB endianness. */
 …
 #define uint32_usb2host(n) uint32_t_le2host((n))
 const char * usb_str_transfer_type(usb_transfer_type_t t);
 const char * usb_str_transfer_type_short(usb_transfer_type_t t);
+const char *usb_str_transfer_type(usb_transfer_type_t);
+const char *usb_str_transfer_type_short(usb_transfer_type_t);
 const char *usb_str_direction(usb_direction_t);
 …
+{
         return (s == USB_SPEED_FULL) || (s == USB_SPEED_LOW);
+}
+static inline bool usb_speed_is_valid(const usb_speed_t s)
+{
+        return (s >= USB_SPEED_LOW) && (s < USB_SPEED_MAX);
+}
 …
 static inline bool usb_address_is_valid(usb_address_t a)
+{
         return (a >= USB_ADDRESS_DEFAULT) && (a <= USB11_ADDRESS_MAX);
+        return a <= USB11_ADDRESS_MAX;
+}
 …
 #define USB_ENDPOINT_DEFAULT_CONTROL 0
+/** Maximum endpoint number in USB 1.1. */
+#define USB11_ENDPOINT_MAX 16
+/** Maximum endpoint number in USB */
+#define USB_ENDPOINT_MAX 16
+/** There might be two directions for every endpoint number (except 0) */
+#define USB_ENDPOINT_COUNT (2 * USB_ENDPOINT_MAX)
 /** Check USB endpoint for allowed values.
 …
 static inline bool usb_endpoint_is_valid(usb_endpoint_t ep)
+{
+        return (ep >= USB_ENDPOINT_DEFAULT_CONTROL) &&
+            (ep < USB11_ENDPOINT_MAX);
+        return ep < USB_ENDPOINT_MAX;
+}
+/** Check USB target for allowed values (address and endpoint).
+/**
+ * Check USB target for allowed values (address, endpoint, stream).
+ *
  * @param target.
  * @return True, if values are wihtin limits, false otherwise.
  */
 static inline bool usb_target_is_valid(usb_target_t target)
+static inline bool usb_target_is_valid(const usb_target_t *target)
+{
+        return usb_address_is_valid(target.address) &&
+            usb_endpoint_is_valid(target.endpoint);
+        return usb_address_is_valid(target->address) &&
+            usb_endpoint_is_valid(target->endpoint);
+        // A 16-bit Stream ID is always valid.
+}
 …
  * @return Whether @p a and @p b points to the same pipe on the same device.
  */
 static inline int usb_target_same(usb_target_t a, usb_target_t b)
+static inline bool usb_target_same(usb_target_t a, usb_target_t b)
+{
+        return (a.address == b.address)
+            && (a.endpoint == b.endpoint);
+        return (a.address == b.address) && (a.endpoint == b.endpoint);
+}
-/** General handle type.
- * Used by various USB functions as opaque handle.
- */
-typedef sysarg_t usb_handle_t;
 /** USB packet identifier. */
 …
         USB_PID_SETUP = _MAKE_PID(3, 1),
         USB_PID_DATA0 = _MAKE_PID(0 ,3),
         USB_PID_DATA1 = _MAKE_PID(2 ,3),
+        USB_PID_DATA0 = _MAKE_PID(0, 3),
+        USB_PID_DATA1 = _MAKE_PID(2, 3),
         USB_PID_ACK = _MAKE_PID(0 ,2),
         USB_PID_NAK = _MAKE_PID(2 ,2),
         USB_PID_STALL = _MAKE_PID(3 ,2),
+        USB_PID_ACK = _MAKE_PID(0, 2),
+        USB_PID_NAK = _MAKE_PID(2, 2),
+        USB_PID_STALL = _MAKE_PID(3, 2),
         USB_PID_PRE = _MAKE_PID(3 ,0),
+        USB_PID_PRE = _MAKE_PID(3, 0),
         /* USB_PID_ = _MAKE_PID( ,), */
 #undef _MAKE_PID

uspace/lib/usb/src/dump.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 static void usb_dump_descriptor_endpoint(FILE *, const char *, const char *,
     const uint8_t *, size_t);
+static void usb_dump_descriptor_superspeed_endpoint_companion(FILE *, const char *, const char *,
+    const uint8_t *, size_t);
 static void usb_dump_descriptor_hid(FILE *, const char *, const char *,
     const uint8_t *, size_t);
 …
         { USB_DESCTYPE_INTERFACE, usb_dump_descriptor_interface },
         { USB_DESCTYPE_ENDPOINT, usb_dump_descriptor_endpoint },
+        { USB_DESCTYPE_SSPEED_EP_COMPANION, usb_dump_descriptor_superspeed_endpoint_companion },
         { USB_DESCTYPE_HID, usb_dump_descriptor_hid },
         { USB_DESCTYPE_HUB, usb_dump_descriptor_hub },
 …
         PRINTLINE("wMaxPacketSize = %d", d->max_packet_size);
         PRINTLINE("bInterval = %dms", d->poll_interval);
+}
+static void usb_dump_descriptor_superspeed_endpoint_companion(FILE *output,
+    const char *line_prefix, const char *line_suffix,
+    const uint8_t *descriptor, size_t descriptor_length)
+{
+        usb_superspeed_endpoint_companion_descriptor_t *d
+           = (usb_superspeed_endpoint_companion_descriptor_t *) descriptor;
+        if (descriptor_length < sizeof(*d)) {
+                return;
+        }
+        PRINTLINE("bLength = %u", d->length);
+        PRINTLINE("bDescriptorType = 0x%02X", d->descriptor_type);
+        PRINTLINE("bMaxBurst = %u", d->max_burst);
+        PRINTLINE("bmAttributes = %d", d->attributes);
+        PRINTLINE("wBytesPerInterval = %u", d->bytes_per_interval);
+}

uspace/lib/usb/src/usb.c

-              rf5e5f73
+              rdf6ded8
         [USB_SPEED_FULL] = "full",
         [USB_SPEED_HIGH] = "high",
+        [USB_SPEED_SUPER] = "super",
 };
 …
+}
-/** 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/include/usb/dev/device.h

-              rf5e5f73
+              rdf6ded8
 #include <usb/dev/alternate_ifaces.h>
 #include <usb/dev/pipes.h>
+#include <usbhc_iface.h>
 #include <assert.h>
 …
 /* DDF parts */
+errno_t usb_device_create_ddf(ddf_dev_t *, const usb_endpoint_description_t **, const char **);
+errno_t usb_device_create_ddf(ddf_dev_t *,
+    const usb_endpoint_description_t **, const char **);
 void usb_device_destroy_ddf(ddf_dev_t *);
 …
+}
 usb_device_t * usb_device_create(devman_handle_t);
+usb_device_t *usb_device_create(devman_handle_t);
 void usb_device_destroy(usb_device_t *);
 const char * usb_device_get_name(usb_device_t *);
+const char *usb_device_get_name(usb_device_t *);
 ddf_fun_t *usb_device_ddf_fun_create(usb_device_t *, fun_type_t, const char *);
 async_exch_t * usb_device_bus_exchange_begin(usb_device_t *);
+async_exch_t *usb_device_bus_exchange_begin(usb_device_t *);
 void usb_device_bus_exchange_end(async_exch_t *);
 …
 usb_endpoint_mapping_t * usb_device_get_mapped_ep_desc(usb_device_t *,
     const usb_endpoint_description_t *);
+usb_endpoint_mapping_t * usb_device_get_mapped_ep(usb_device_t *,
+    usb_endpoint_t);
+int usb_device_unmap_ep(usb_endpoint_mapping_t *);
+int usb_device_get_iface_number(usb_device_t *);
+devman_handle_t usb_device_get_devman_handle(usb_device_t *);
+usb_address_t usb_device_get_address(const usb_device_t *);
+usb_speed_t usb_device_get_depth(const usb_device_t *);
+usb_speed_t usb_device_get_speed(const usb_device_t *);
+int usb_device_get_iface_number(const usb_device_t *);
+devman_handle_t usb_device_get_devman_handle(const usb_device_t *);
 const usb_device_descriptors_t * usb_device_descriptors(usb_device_t *);
+const usb_device_descriptors_t *usb_device_descriptors(usb_device_t *);
 const usb_alternate_interfaces_t * usb_device_get_alternative_ifaces(
+const usb_alternate_interfaces_t *usb_device_get_alternative_ifaces(
     usb_device_t *);
 void * usb_device_data_alloc(usb_device_t *, size_t);
 void * usb_device_data_get(usb_device_t *);
+void *usb_device_data_alloc(usb_device_t *, size_t);
+void *usb_device_data_get(usb_device_t *);
 #endif

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

-              rf5e5f73
+              rdf6ded8
         errno_t (*device_add)(usb_device_t *);
         /** Callback when a device is about to be removed from the system. */
         errno_t (*device_rem)(usb_device_t *);
+        errno_t (*device_remove)(usb_device_t *);
         /** Callback when a device was removed from the system. */
         errno_t (*device_gone)(usb_device_t *);
+        /** Callback asking the driver to online a specific function. */
+        errno_t (*function_online)(ddf_fun_t *);
+        /** Callback asking the driver to offline a specific function. */
+        errno_t (*function_offline)(ddf_fun_t *);
 } usb_driver_ops_t;

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 #define CTRL_PIPE_MIN_PACKET_SIZE 8
 /** Abstraction of a logical connection to USB device endpoint.
  * It encapsulates endpoint attributes (transfer type etc.).
+ * It contains some vital information about the pipe.
  * This endpoint must be bound with existing usb_device_connection_t
  * (i.e. the wire to send data over).
  */
 typedef struct {
+        /** Endpoint number. */
+        usb_endpoint_t endpoint_no;
+        /** Endpoint transfer type. */
+        usb_transfer_type_t transfer_type;
+        /** Endpoint direction. */
+        usb_direction_t direction;
+        /** Maximum packet size for the endpoint. */
+        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;
+        /** Pipe description received from HC */
+        usb_pipe_desc_t desc;
         /** Whether to automatically reset halt on the endpoint.
 …
          */
         bool auto_reset_halt;
         /** The connection used for sending the data. */
         usb_dev_session_t *bus_session;
 …
         /** Found descriptor fitting the description. */
         const usb_standard_endpoint_descriptor_t *descriptor;
+        /** Relevant superspeed companion descriptor. */
+        const usb_superspeed_endpoint_companion_descriptor_t
+            *companion_descriptor;
         /** Interface descriptor the endpoint belongs to. */
         const usb_standard_interface_descriptor_t *interface;
 …
 } usb_endpoint_mapping_t;
+errno_t usb_pipe_initialize(usb_pipe_t *, usb_endpoint_t, usb_transfer_type_t,
+    size_t, usb_direction_t, unsigned, usb_dev_session_t *);
+errno_t usb_pipe_initialize(usb_pipe_t *, usb_dev_session_t *);
 errno_t usb_pipe_initialize_default_control(usb_pipe_t *, usb_dev_session_t *);
-errno_t usb_pipe_probe_default_control(usb_pipe_t *);
 errno_t usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     size_t, const uint8_t *, size_t, usb_dev_session_t *);
+errno_t usb_pipe_register(usb_pipe_t *, unsigned);
+errno_t usb_pipe_register(usb_pipe_t *,
+    const usb_standard_endpoint_descriptor_t *,
+    const usb_superspeed_endpoint_companion_descriptor_t *);
 errno_t usb_pipe_unregister(usb_pipe_t *);
 errno_t usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
 errno_t usb_pipe_write(usb_pipe_t *, const void *, size_t);
+errno_t usb_pipe_read_dma(usb_pipe_t *, void *, void *, size_t, size_t *);
+errno_t usb_pipe_write_dma(usb_pipe_t *, void *, void *, size_t);
 errno_t usb_pipe_control_read(usb_pipe_t *, const void *, size_t,
 …
     const void *, size_t);
+void *usb_pipe_alloc_buffer(usb_pipe_t *, size_t);
+void usb_pipe_free_buffer(usb_pipe_t *, void *);
 #endif
 /**

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2017 Petr Manek
  * All rights reserved.
+ *
 …
 #include <stddef.h>
 #include <stdint.h>
+#include <fibril_synch.h>
+/** Parameters and callbacks for automated polling. */
+typedef struct {
+        /** Level of debugging messages from auto polling.
+         * 0 - nothing
+         * 1 - inform about errors and polling start/end
+         * 2 - also dump every retrieved buffer
+/** USB automated polling. */
+typedef struct usb_polling {
+        /** Mandatory parameters - user is expected to configure these. */
+        /** USB device to poll. */
+        usb_device_t *device;
+        /** Device enpoint mapping to use for polling. */
+        usb_endpoint_mapping_t *ep_mapping;
+        /** Size of the recieved data. */
+        size_t request_size;
+        /**
+         * Data buffer of at least `request_size`. User is responsible for its
+         * allocation.
          */
+        int debug;
+        /** Maximum number of consecutive errors before polling termination. */
+        size_t max_failures;
+        /** Delay between poll requests in milliseconds.
+         * Set to negative value to use value from endpoint descriptor.
+         */
+        int delay;
+        /** Whether to automatically try to clear the HALT feature after
+         * the endpoint stalls.
+         */
+        bool auto_clear_halt;
+        uint8_t *buffer;
         /** Callback when data arrives.
+         *
 …
         bool (*on_data)(usb_device_t *dev, uint8_t *data, size_t data_size,
             void *arg);
+        /**
+         * Optional parameters - user can customize them, but they are
+         * defaulted to  some reasonable values.
+         */
+        /** Level of debugging messages from auto polling.
+         * 0 - nothing (default)
+         * 1 - inform about errors and polling start/end
+         * 2 - also dump every retrieved buffer
+         */
+        int debug;
+        /**
+         * Maximum number of consecutive errors before polling termination
+         * (default 3).
+         */
+        size_t max_failures;
+        /** Delay between poll requests in milliseconds.
+         * By default, value from endpoint descriptor used.
+         */
+        int delay;
+        /** Whether to automatically try to clear the HALT feature after
+         * the endpoint stalls (true by default).
+         */
+        bool auto_clear_halt;
+        /** Argument to pass to callbacks (default NULL). */
+        void *arg;
         /** Callback when polling is terminated.
+         *
 …
         void (*on_polling_end)(usb_device_t *dev, bool due_to_errors,
             void *arg);
         /** Callback when error occurs.
+         *
 …
          */
         bool (*on_error)(usb_device_t *dev, errno_t err_code, void *arg);
-        /** Argument to pass to callbacks. */
-        void *arg;
-} usb_device_auto_polling_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 *);
+extern errno_t usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
+    const usb_device_auto_polling_t *, size_t);
+        /**
+         * Internal parameters - user is not expected to set them. Messing with
+         * them can result in unexpected behavior if you do not know what you
+         * are doing.
+         */
+extern errno_t usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
     usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
+        /** Fibril used for polling. */
+        fid_t fibril;
+extern errno_t usb_device_auto_polling_desc(usb_device_t *,
+    const usb_endpoint_description_t *, const usb_device_auto_polling_t *,
+    size_t);
+        /** True if polling is currently in operation. */
+        volatile bool running;
+extern errno_t 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 *);
+        /** True if polling should terminate as soon as possible. */
+        volatile bool joining;
+        /** Synchronization primitives for joining polling end. */
+        fibril_mutex_t guard;
+        fibril_condvar_t cv;
+} usb_polling_t;
+errno_t usb_polling_init(usb_polling_t *);
+void usb_polling_fini(usb_polling_t *);
+errno_t usb_polling_start(usb_polling_t *);
+errno_t usb_polling_join(usb_polling_t *);
 #endif

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

rf5e5f73	rdf6ded8
85	85	char **);
86	86
87		~~errno_t usb_request_clear_endpoint_halt(usb_pipe_t *, uint16_t);~~
88	87	errno_t usb_pipe_clear_halt(usb_pipe_t , usb_pipe_t );
89	88	errno_t usb_request_get_endpoint_status(usb_pipe_t , usb_pipe_t , uint16_t *);

uspace/lib/usbdev/src/devdrv.c

-              rf5e5f73
+              rdf6ded8
  * Copyright (c) 2011 Vojtech Horky
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Petr Manek, Michal Staruch
  * All rights reserved.
+ *
 …
 #include <devman.h>
 #include <errno.h>
+#include <str_error.h>
 #include <stdlib.h>
 …
         /** 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.
+         *
 …
          */
         usb_endpoint_mapping_t *pipes;
         /** Number of other endpoint pipes. */
         size_t pipes_count;
+        /** USB address of this device */
+        usb_address_t address;
+        /** Depth in the USB hub hiearchy */
+        unsigned depth;
+        /** USB speed of this device */
+        usb_speed_t speed;
         /** Current interface.
+         *
 …
          */
         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.
+         *
 …
                 return rc;
+        }
         /* Change current alternative */
         usb_dev->alternate_interfaces.current = alternate_setting;
 …
         /* Register created pipes. */
+        unsigned pipes_registered = 0;
         for (size_t i = 0; i < pipe_count; i++) {
                 if (pipes[i].present) {
+                        rc = usb_pipe_register(&pipes[i].pipe,
+                            pipes[i].descriptor->poll_interval);
+                        rc = usb_pipe_register(&pipes[i].pipe, pipes[i].descriptor, pipes[i].companion_descriptor);
                         if (rc != EOK) {
                                 goto rollback_unregister_endpoints;
+                        }
+                }
+                pipes_registered++;
+        }
 …
          */
 rollback_unregister_endpoints:
         for (size_t i = 0; i < pipe_count; i++) {
+        for (size_t i = 0; i < pipes_registered; i++) {
                 if (pipes[i].present) {
                         usb_pipe_unregister(&pipes[i].pipe);
 …
         assert(usb_dev);
         assert(usb_dev->pipes || usb_dev->pipes_count == 0);
         /* Destroy the pipes. */
+        int rc;
         for (size_t i = 0; i < usb_dev->pipes_count; ++i) {
                 usb_log_debug2("Unregistering pipe %zu: %spresent.\n",
+                usb_log_debug2("Unregistering pipe %zu: %spresent.",
                     i, usb_dev->pipes[i].present ? "" : "not ");
+                if (usb_dev->pipes[i].present)
+                        usb_pipe_unregister(&usb_dev->pipes[i].pipe);
+        }
+                rc = usb_device_unmap_ep(usb_dev->pipes + i);
+                if (rc != EOK && rc != ENOENT)
+                        usb_log_warning("Unregistering pipe %zu failed: %s", i, str_error(rc));
+        }
         free(usb_dev->pipes);
         usb_dev->pipes = 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)
+int usb_device_unmap_ep(usb_endpoint_mapping_t *epm)
+{
+        assert(epm);
+        if (!epm->present)
+                return ENOENT;
+        const int rc = usb_pipe_unregister(&epm->pipe);
+        if (rc != EOK)
+                return rc;
+        epm->present = false;
+        return EOK;
+}
+usb_address_t usb_device_get_address(const usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return usb_dev->depth;
+}
+unsigned usb_device_get_depth(const usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return usb_dev->depth;
+}
+usb_speed_t usb_device_get_speed(const usb_device_t *usb_dev)
+{
+        assert(usb_dev);
+        return usb_dev->speed;
+}
+int usb_device_get_iface_number(const usb_device_t *usb_dev)
+{
         assert(usb_dev);
 …
+}
 devman_handle_t usb_device_get_devman_handle(usb_device_t *usb_dev)
+devman_handle_t usb_device_get_devman_handle(const usb_device_t *usb_dev)
+{
         assert(usb_dev);
 …
  */
 static errno_t 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)
+    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
+{
         assert(usb_dev != 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.full_config = NULL;
 …
         usb_dev->pipes = NULL;
         usb_dev->bus_session = usb_dev_connect(handle);
+        usb_dev->bus_session = usb_dev_connect(usb_dev->handle);
         if (!usb_dev->bus_session) {
 …
         /* This pipe was registered by the hub driver,
          * during device initialization. */
+        errno_t rc = usb_pipe_initialize_default_control(
+            &usb_dev->ctrl_pipe, usb_dev->bus_session);
+        errno_t rc = usb_pipe_initialize_default_control(&usb_dev->ctrl_pipe, usb_dev->bus_session);
         if (rc != EOK) {
                 usb_dev_disconnect(usb_dev->bus_session);
 …
          * it makes no sense to speak about alternate interfaces when
          * controlling a device. */
         rc = usb_alternate_interfaces_init(&usb_dev->alternate_interfaces,
+        usb_alternate_interfaces_init(&usb_dev->alternate_interfaces,
             usb_dev->descriptors.full_config,
             usb_dev->descriptors.full_config_size, usb_dev->interface_no);
 …
+}
+static errno_t usb_device_get_info(async_sess_t *sess, devman_handle_t *handle,
+        int *iface_no)
+{
+        assert(handle);
+        assert(iface_no);
+static errno_t usb_device_get_info(async_sess_t *sess, usb_device_t *dev)
+{
+        assert(dev);
         async_exch_t *exch = async_exchange_begin(sess);
         if (!exch)
                 return EPARTY;
+        errno_t ret = usb_get_my_device_handle(exch, handle);
+        usb_device_desc_t dev_desc;
+        const errno_t ret = usb_get_my_description(exch, &dev_desc);
         if (ret == EOK) {
                 ret = usb_get_my_interface(exch, iface_no);
                 if (ret == ENOTSUP) {
                         *iface_no = -1;
                         ret = EOK;
+                }
+        }
+                dev->address = dev_desc.address;
+                dev->depth = dev_desc.depth;
+                dev->speed = dev_desc.speed;
+                dev->handle = dev_desc.handle;
+                dev->interface_no = dev_desc.iface;
+        }
         async_exchange_end(exch);
         return ret;
 …
         assert(ddf_dev);
         assert(err);
-        devman_handle_t h = 0;
-        int iface_no = -1;
         async_sess_t *sess = ddf_dev_parent_sess_get(ddf_dev);
         if (sess == NULL)
                 return ENOMEM;
-        const errno_t ret = usb_device_get_info(sess, &h, &iface_no);
-        if (ret != EOK)
-                return ret;
         usb_device_t *usb_dev =
 …
                 return ENOMEM;
+        }
+        return usb_device_init(usb_dev, ddf_dev, desc, err, h, iface_no);
+        const errno_t ret = usb_device_get_info(sess, usb_dev);
+        if (ret != EOK)
+                return ret;
+        return usb_device_init(usb_dev, ddf_dev, desc, err);
+}
 …
 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);
-        errno_t 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;
+        async_sess_t *sess = devman_device_connect(handle, IPC_FLAG_BLOCKING);
+        errno_t ret = usb_device_get_info(sess, usb_dev);
+        if (sess)
+                async_hangup(sess);
+        if (ret != EOK) {
+                free(usb_dev);
+                return NULL;
+        }
         const char* dummy = NULL;
         ret = usb_device_init(usb_dev, NULL, NULL, &dummy, handle, iface_no);
+        ret = usb_device_init(usb_dev, NULL, NULL, &dummy);
         if (ret != EOK) {
                 free(usb_dev);

uspace/lib/usbdev/src/devpoll.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2017 Petr Manek
  * All rights reserved.
+ *
 …
 #include <errno.h>
 #include <fibril.h>
+#include <fibril_synch.h>
 #include <stdbool.h>
 #include <stdlib.h>
 …
 #include <stdint.h>
+/** Maximum number of failed consecutive requests before announcing failure. */
+#define MAX_FAILED_ATTEMPTS 3
+/** Data needed for polling. */
+typedef struct {
+        /** Parameters for automated polling. */
+        usb_device_auto_polling_t auto_polling;
+        /** USB device to poll. */
+        usb_device_t *dev;
+        /** Device enpoint mapping to use for polling. */
+        usb_endpoint_mapping_t *polling_mapping;
+        /** Size of the recieved data. */
+        size_t request_size;
+        /** Data buffer. */
+        uint8_t *buffer;
+} polling_data_t;
+/** Initialize the polling data structure, its internals and configuration
+ *  with default values.
+ *
+ * @param polling Valid polling data structure.
+ * @return Error code.
+ * @retval EOK Polling data structure is ready to be used.
+ */
+int usb_polling_init(usb_polling_t *polling)
+{
+        if (!polling)
+                return EBADMEM;
+        /* Zero out everything */
+        memset(polling, 0, sizeof(usb_polling_t));
+        /* Internal initializers. */
+        fibril_mutex_initialize(&polling->guard);
+        fibril_condvar_initialize(&polling->cv);
+        /* Default configuration. */
+        polling->auto_clear_halt = true;
+        polling->delay = -1;
+        polling->max_failures = 3;
+        return EOK;
+}
+/** Destroy the polling data structure.
+ *  This function does nothing but a safety check whether the polling
+ *  was joined successfully.
+ *
+ * @param polling Polling data structure.
+ */
+void usb_polling_fini(usb_polling_t *polling)
+{
+        /* Nothing done at the moment. */
+        assert(polling);
+        assert(!polling->running);
+}
 /** Polling fibril.
+ *
  * @param arg Pointer to polling_data_t.
+ * @param arg Pointer to usb_polling_t.
  * @return Always EOK.
  */
 …
+{
         assert(arg);
+        polling_data_t *data = arg;
+        /* Helper to reduce typing. */
+        const usb_device_auto_polling_t *params = &data->auto_polling;
+        usb_pipe_t *pipe = &data->polling_mapping->pipe;
+        if (params->debug > 0) {
+        usb_polling_t *polling = arg;
+        fibril_mutex_lock(&polling->guard);
+        polling->running = true;
+        fibril_mutex_unlock(&polling->guard);
+        usb_pipe_t *pipe = &polling->ep_mapping->pipe;
+        if (polling->debug > 0) {
                 const usb_endpoint_mapping_t *mapping =
                     data->polling_mapping;
+                    polling->ep_mapping;
                 usb_log_debug("Poll (%p): started polling of `%s' - " \
                     "interface %d (%s,%d,%d), %zuB/%zu.\n",
                     data, usb_device_get_name(data->dev),
+                    polling, usb_device_get_name(polling->device),
                     (int) mapping->interface->interface_number,
                     usb_str_class(mapping->interface->interface_class),
                     (int) mapping->interface->interface_subclass,
                     (int) mapping->interface->interface_protocol,
                     data->request_size, pipe->max_packet_size);
+                    polling->request_size, pipe->desc.max_transfer_size);
+        }
         size_t failed_attempts = 0;
         while (failed_attempts <= params->max_failures) {
+        while (failed_attempts <= polling->max_failures) {
                 size_t actual_size;
                 const errno_t rc = usb_pipe_read(pipe, data->buffer,
                     data->request_size, &actual_size);
+                const errno_t rc = usb_pipe_read(pipe, polling->buffer,
+                    polling->request_size, &actual_size);
                 if (rc == EOK) {
                         if (params->debug > 1) {
+                        if (polling->debug > 1) {
                                 usb_log_debug(
                                     "Poll%p: received: '%s' (%zuB).\n",
                                     data,
                                     usb_debug_str_buffer(data->buffer,
+                                    polling,
+                                    usb_debug_str_buffer(polling->buffer,
                                         actual_size, 16),
                                     actual_size);
 …
                                 usb_log_debug(
                                     "Poll%p: polling failed: %s.\n",
                                     data, str_error(rc));
+                                    polling, str_error(rc));
+                }
                 /* If the pipe stalled, we can try to reset the stall. */
                 if ((rc == ESTALL) && (params->auto_clear_halt)) {
+                if (rc == ESTALL && polling->auto_clear_halt) {
                         /*
                          * We ignore error here as this is usually a futile
                          * attempt anyway.
                          */
+                        usb_request_clear_endpoint_halt(
+                            usb_device_get_default_pipe(data->dev),
+                            pipe->endpoint_no);
+                        usb_pipe_clear_halt(
+                            usb_device_get_default_pipe(polling->device), pipe);
+                }
                 if (rc != EOK) {
                         ++failed_attempts;
+                        const bool cont = (params->on_error == NULL) ? true :
+                            params->on_error(data->dev, rc, params->arg);
+                        if (!cont) {
+                                failed_attempts = params->max_failures;
+                        const bool carry_on = !polling->on_error ? true :
+                            polling->on_error(polling->device, rc, polling->arg);
+                        if (!carry_on || polling->joining) {
+                                /* This is user requested abort, erases failures. */
+                                failed_attempts = 0;
+                                break;
+                        }
                         continue;
 …
                 /* We have the data, execute the callback now. */
                 assert(params->on_data);
                 const bool carry_on = params->on_data(
                     data->dev, data->buffer, actual_size, params->arg);
+                assert(polling->on_data);
+                const bool carry_on = polling->on_data(polling->device,
+                    polling->buffer, actual_size, polling->arg);
                 if (!carry_on) {
 …
                 /* Take a rest before next request. */
                 // FIXME 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 delay should be implemented in HC schedule
                 async_usleep(params->delay);
+                async_usleep(polling->delay);
+        }
         const bool failed = failed_attempts > 0;
+        if (params->on_polling_end != NULL) {
+                params->on_polling_end(data->dev, failed, params->arg);
+        }
+        if (params->debug > 0) {
+        if (polling->on_polling_end)
+                polling->on_polling_end(polling->device, failed, polling->arg);
+        if (polling->debug > 0) {
                 if (failed) {
                         usb_log_error("Polling of device `%s' terminated: "
                             "recurring failures.\n",
                             usb_device_get_name(data->dev));
+                            usb_device_get_name(polling->device));
                 } else {
                         usb_log_debug("Polling of device `%s' terminated: "
                             "driver request.\n",
                             usb_device_get_name(data->dev));
+                            usb_device_get_name(polling->device));
+                }
+        }
+        /* Free the allocated memory. */
+        free(data->buffer);
+        free(data);
+        fibril_mutex_lock(&polling->guard);
+        polling->running = false;
+        fibril_mutex_unlock(&polling->guard);
+        /* Notify joiners, if any. */
+        fibril_condvar_broadcast(&polling->cv);
         return EOK;
+}
 …
  * first request would be executed prior to return from this function).
+ *
+ * @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).
+ * @param polling Polling data structure.
  * @return Error code.
  * @retval EOK New fibril polling the device was already started.
  */
+static errno_t 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)) {
+errno_t usb_polling_start(usb_polling_t *polling)
+{
+        if (!polling || !polling->device || !polling->ep_mapping || !polling->on_data)
                 return EBADMEM;
+        }
+        if (request_size == 0)
+        if (!polling->request_size)
                 return EINVAL;
         if (!epm || (epm->pipe.transfer_type != USB_TRANSFER_INTERRUPT) ||
             (epm->pipe.direction != USB_DIRECTION_IN))
+        if (!polling->ep_mapping || (polling->ep_mapping->pipe.desc.transfer_type != USB_TRANSFER_INTERRUPT)
+            || (polling->ep_mapping->pipe.desc.direction != USB_DIRECTION_IN))
                 return EINVAL;
+        polling_data_t *polling_data = malloc(sizeof(polling_data_t));
+        if (polling_data == NULL) {
+        /* Negative value means use descriptor provided value. */
+        if (polling->delay < 0)
+                polling->delay = polling->ep_mapping->descriptor->poll_interval;
+        polling->fibril = fibril_create(polling_fibril, polling);
+        if (!polling->fibril)
                 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_add_ready(polling->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.
+ */
+errno_t 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).
+ * @return Error code.
+ * @retval EOK New fibril polling the device was already started.
+ */
+errno_t 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)
+{
+        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(dev, ep);
+        return usb_device_auto_polling_internal(
+            dev, epm, &auto_polling, request_size);
+}
+errno_t 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);
+}
+errno_t 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);
+/** Close the polling pipe permanently and synchronously wait
+ *  until the automatic polling fibril terminates.
+ *
+ *  It is safe to deallocate the polling data structure (and its
+ *  data buffer) only after a successful call to this function.
+ *
+ *  @warning Call to this function will trigger execution of the
+ *  on_error() callback with EINTR error code.
+ *
+ *  @parram polling Polling data structure.
+ *  @return Error code.
+ *  @retval EOK Polling fibril has been successfully terminated.
+ */
+errno_t usb_polling_join(usb_polling_t *polling)
+{
+        errno_t rc;
+        if (!polling)
+                return EBADMEM;
+        /* Check if the fibril already terminated. */
+        if (!polling->running)
+                return EOK;
+        /* Set the flag */
+        polling->joining = true;
+        /* Unregister the pipe. */
+        rc = usb_device_unmap_ep(polling->ep_mapping);
+        if (rc != EOK && rc != ENOENT && rc != EHANGUP)
+                return rc;
+        /* Wait for the fibril to terminate. */
+        fibril_mutex_lock(&polling->guard);
+        while (polling->running)
+                fibril_condvar_wait(&polling->cv, &polling->guard);
+        fibril_mutex_unlock(&polling->guard);
+        return EOK;
+}

uspace/lib/usbdev/src/dp.c

-              rf5e5f73
+              rdf6ded8
         NESTING(CONFIGURATION, INTERFACE),
         NESTING(INTERFACE, ENDPOINT),
+        NESTING(ENDPOINT, SSPEED_EP_COMPANION),
         NESTING(INTERFACE, HUB),
         NESTING(INTERFACE, HID),
 …
  * @retval -1 Invalid input.
  */
+static int get_descriptor_type(const usb_dp_parser_data_t *data, const uint8_t *start)
+static int get_descriptor_type(const usb_dp_parser_data_t *data,
+    const uint8_t *start)
+{
         if (start == NULL) {
 …
         int parent_type = get_descriptor_type(data, parent);
         int possible_sibling_type = get_descriptor_type(data, possible_sibling);
+        if (is_nested_descriptor_type(parser, possible_sibling_type, parent_type)) {
+        if (is_nested_descriptor_type(parser,
+                    possible_sibling_type, parent_type)) {
                 return possible_sibling;
         } else {

uspace/lib/usbdev/src/driver.c

-              rf5e5f73
+              rdf6ded8
  * Copyright (c) 2011 Vojtech Horky
  * Copyright (c) 2013 Jan Vesely
+ * Copyright (c) 2018 Petr Manek
  * All rights reserved.
+ *
 …
         errno_t rc = usb_device_create_ddf(gen_dev, driver->endpoints, &err_msg);
         if (rc != EOK) {
                 usb_log_error("USB device `%s' init failed (%s): %s.\n",
+                usb_log_error("USB device `%s' init failed (%s): %s.",
                     ddf_dev_get_name(gen_dev), err_msg, str_error(rc));
                 return rc;
 …
         assert(driver);
         assert(driver->ops);
         if (driver->ops->device_rem == NULL)
+        if (driver->ops->device_remove == 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 errno_t ret = driver->ops->device_rem(usb_dev);
+        const errno_t ret = driver->ops->device_remove(usb_dev);
         if (ret != EOK)
                 return ret;
         usb_device_destroy_ddf(gen_dev);
         return EOK;
 …
+}
+/** Callback when the driver is asked to online a specific function.
+ *
+ * This callback is a wrapper for USB specific version of @c fun_online.
+ *
+ * @param gen_dev Device function structure as prepared by DDF.
+ * @return Error code.
+ */
+static int generic_function_online(ddf_fun_t *fun)
+{
+        assert(driver);
+        assert(driver->ops);
+        if (driver->ops->function_online == NULL)
+                return ENOTSUP;
+        return driver->ops->function_online(fun);
+}
+/** Callback when the driver is asked to offline a specific function.
+ *
+ * This callback is a wrapper for USB specific version of @c fun_offline.
+ *
+ * @param gen_dev Device function structure as prepared by DDF.
+ * @return Error code.
+ */
+static int generic_function_offline(ddf_fun_t *fun)
+{
+        assert(driver);
+        assert(driver->ops);
+        if (driver->ops->function_offline == NULL)
+                return ENOTSUP;
+        return driver->ops->function_offline(fun);
+}
 static driver_ops_t generic_driver_ops = {
         .dev_add = generic_device_add,
         .dev_remove = generic_device_remove,
         .dev_gone = generic_device_gone,
+        .fun_online = generic_function_online,
+        .fun_offline = generic_function_offline,
 };
 static driver_t generic_driver = {

uspace/lib/usbdev/src/pipes.c

-              rf5e5f73
+              rdf6ded8
  * Copyright (c) 2011 Vojtech Horky
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Michal Staruch
  * All rights reserved.
+ *
 …
 #include <usb/dev/request.h>
 #include <usb/usb.h>
 #include <usb_iface.h>
+#include <usb/dma_buffer.h>
 #include <assert.h>
+#include <bitops.h>
 #include <async.h>
+#include <as.h>
 #include <errno.h>
 #include <mem.h>
 …
         assert(pipe != NULL);
         if (!pipe->auto_reset_halt || (pipe->endpoint_no != 0)) {
+        if (!pipe->auto_reset_halt || (pipe->desc.endpoint_no != 0)) {
                 return;
+        }
 …
         /* Prevent infinite recursion. */
         pipe->auto_reset_halt = false;
         usb_request_clear_endpoint_halt(pipe, 0);
+        usb_pipe_clear_halt(pipe, pipe);
         pipe->auto_reset_halt = true;
+}
+/* Helper structure to avoid passing loads of arguments through */
+typedef struct {
+        usb_pipe_t *pipe;
+        usb_direction_t dir;
+        bool is_control;        // Only for checking purposes
+        usbhc_iface_transfer_request_t req;
+        size_t transferred_size;
+} transfer_t;
+/**
+ * Issue a transfer in a separate exchange.
+ */
+static errno_t transfer_common(transfer_t *t)
+{
+        if (!t->pipe)
+                return EBADMEM;
+        /* Only control writes make sense without buffer */
+        if ((t->dir != USB_DIRECTION_OUT || !t->is_control) && t->req.size == 0)
+                return EINVAL;
+        /* Nonzero size requires buffer */
+        if (!dma_buffer_is_set(&t->req.buffer) && t->req.size != 0)
+                return EINVAL;
+        /* Check expected direction */
+        if (t->pipe->desc.direction != USB_DIRECTION_BOTH &&
+            t->pipe->desc.direction != t->dir)
+                return EBADF;
+        /* Check expected transfer type */
+        if ((t->pipe->desc.transfer_type == USB_TRANSFER_CONTROL) != t->is_control)
+                return EBADF;
+        async_exch_t *exch = async_exchange_begin(t->pipe->bus_session);
+        if (!exch)
+                return ENOMEM;
+        t->req.dir = t->dir;
+        t->req.endpoint = t->pipe->desc.endpoint_no;
+        const errno_t rc = usbhc_transfer(exch, &t->req, &t->transferred_size);
+        async_exchange_end(exch);
+        if (rc == ESTALL)
+                clear_self_endpoint_halt(t->pipe);
+        return rc;
+}
+/**
+ * Setup the transfer request inside transfer according to dma buffer provided.
+ *
+ * TODO: The buffer could have been allocated as a more strict one. Currently,
+ * we assume that the policy is just the requested one.
+ */
+static void setup_dma_buffer(transfer_t *t, void *base, void *ptr, size_t size)
+{
+        t->req.buffer.virt = base;
+        t->req.buffer.policy = t->pipe->desc.transfer_buffer_policy;
+        t->req.offset = ptr - base;
+        t->req.size = size;
+}
+/**
+ * Compatibility wrapper for reads/writes without preallocated buffer.
+ */
+static errno_t transfer_wrap_dma(transfer_t *t, void *buf, size_t size)
+{
+        if (size == 0) {
+                setup_dma_buffer(t, NULL, NULL, 0);
+                return transfer_common(t);
+        }
+        void *dma_buf = usb_pipe_alloc_buffer(t->pipe, size);
+        setup_dma_buffer(t, dma_buf, dma_buf, size);
+        if (t->dir == USB_DIRECTION_OUT)
+                memcpy(dma_buf, buf, size);
+        const errno_t err = transfer_common(t);
+        if (!err && t->dir == USB_DIRECTION_IN)
+                memcpy(buf, dma_buf, t->transferred_size);
+        usb_pipe_free_buffer(t->pipe, dma_buf);
+        return err;
+}
+static errno_t prepare_control(transfer_t *t, const void *setup, size_t setup_size)
+{
+        if ((setup == NULL) || (setup_size != 8))
+                return EINVAL;
+        memcpy(&t->req.setup, setup, 8);
+        return EOK;
+}
 …
  * @param[out] data_buffer Buffer for incoming data.
  * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
  * @param[out] data_transfered_size Number of bytes that were actually
  *                                  transfered during the DATA stage.
+ * @param[out] data_transferred_size Number of bytes that were actually
+ *                                  transferred during the DATA stage.
  * @return Error code.
  */
 errno_t usb_pipe_control_read(usb_pipe_t *pipe,
     const void *setup_buffer, size_t setup_buffer_size,
+    void *buffer, size_t buffer_size, size_t *transfered_size)
+{
+        assert(pipe);
+        if ((setup_buffer == NULL) || (setup_buffer_size != 8)) {
+                return EINVAL;
+        }
+        if ((buffer == NULL) || (buffer_size == 0)) {
+                return EINVAL;
+        }
+        if ((pipe->direction != USB_DIRECTION_BOTH)
+            || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
+                return EBADF;
+        }
+        uint64_t setup_packet;
+        memcpy(&setup_packet, setup_buffer, 8);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        size_t act_size = 0;
+        const errno_t rc = usb_read(exch, pipe->endpoint_no, setup_packet, buffer,
+            buffer_size, &act_size);
+        async_exchange_end(exch);
+        if (rc == ESTALL) {
+                clear_self_endpoint_halt(pipe);
+        }
+        if (rc == EOK && transfered_size != NULL) {
+                *transfered_size = act_size;
+        }
+        return rc;
+    void *buffer, size_t buffer_size, size_t *transferred_size)
+{
+        errno_t err;
+        transfer_t transfer = {
+                .pipe = pipe,
+                .dir = USB_DIRECTION_IN,
+                .is_control = true,
+        };
+        if ((err = prepare_control(&transfer, setup_buffer, setup_buffer_size)))
+                return err;
+        if ((err = transfer_wrap_dma(&transfer, buffer, buffer_size)))
+                return err;
+        if (transferred_size)
+                *transferred_size = transfer.transferred_size;
+        return EOK;
+}
 …
+{
         assert(pipe);
+        if ((setup_buffer == NULL) || (setup_buffer_size != 8)) {
+                return EINVAL;
+        }
+        if ((buffer == NULL) && (buffer_size > 0)) {
+                return EINVAL;
+        }
+        if ((buffer != NULL) && (buffer_size == 0)) {
+                return EINVAL;
+        }
+        if ((pipe->direction != USB_DIRECTION_BOTH)
+            || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
+                return EBADF;
+        }
+        uint64_t setup_packet;
+        memcpy(&setup_packet, setup_buffer, 8);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        const errno_t rc = usb_write(exch,
+            pipe->endpoint_no, setup_packet, buffer, buffer_size);
+        async_exchange_end(exch);
+        if (rc == ESTALL) {
+                clear_self_endpoint_halt(pipe);
+        }
+        return rc;
+        errno_t err;
+        transfer_t transfer = {
+                .pipe = pipe,
+                .dir = USB_DIRECTION_OUT,
+                .is_control = true,
+        };
+        if ((err = prepare_control(&transfer, setup_buffer, setup_buffer_size)))
+                return err;
+        return transfer_wrap_dma(&transfer, (void *) buffer, buffer_size);
+}
+/**
+ * Allocate a buffer for data transmission, that satisfies the constraints
+ * imposed by the host controller.
+ *
+ * @param[in] pipe Pipe for which the buffer is allocated
+ * @param[in] size Size of the required buffer
+ */
+void *usb_pipe_alloc_buffer(usb_pipe_t *pipe, size_t size)
+{
+        dma_buffer_t buf;
+        if (dma_buffer_alloc_policy(&buf, size, pipe->desc.transfer_buffer_policy))
+                return NULL;
+        return buf.virt;
+}
+void usb_pipe_free_buffer(usb_pipe_t *pipe, void *buffer)
+{
+        dma_buffer_t buf;
+        buf.virt = buffer;
+        dma_buffer_free(&buf);
+}
 …
  * @param[out] buffer Buffer where to store the data.
  * @param[in] size Size of the buffer (in bytes).
  * @param[out] size_transfered Number of bytes that were actually transfered.
+ * @param[out] size_transferred Number of bytes that were actually transferred.
  * @return Error code.
  */
 errno_t usb_pipe_read(usb_pipe_t *pipe,
+    void *buffer, size_t size, size_t *size_transfered)
+{
+        assert(pipe);
+        if (buffer == NULL) {
+                return EINVAL;
+        }
+        if (size == 0) {
+                return EINVAL;
+        }
+        if (pipe->direction != USB_DIRECTION_IN) {
+                return EBADF;
+        }
+        if (pipe->transfer_type == USB_TRANSFER_CONTROL) {
+                return EBADF;
+        }
+        /* Isochronous transfer are not supported (yet) */
+        if (pipe->transfer_type != USB_TRANSFER_INTERRUPT &&
+            pipe->transfer_type != USB_TRANSFER_BULK)
+            return ENOTSUP;
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        size_t act_size = 0;
+        const errno_t rc =
+            usb_read(exch, pipe->endpoint_no, 0, buffer, size, &act_size);
+        async_exchange_end(exch);
+        if (rc == EOK && size_transfered != NULL) {
+                *size_transfered = act_size;
+        }
+        return rc;
+    void *buffer, size_t size, size_t *size_transferred)
+{
+        assert(pipe);
+        errno_t err;
+        transfer_t transfer = {
+                .pipe = pipe,
+                .dir = USB_DIRECTION_IN,
+        };
+        if ((err = transfer_wrap_dma(&transfer, buffer, size)))
+                return err;
+        if (size_transferred)
+                *size_transferred = transfer.transferred_size;
+        return EOK;
+}
 …
+{
         assert(pipe);
+        if (buffer == NULL || size == 0) {
+                return EINVAL;
+        }
+        if (pipe->direction != USB_DIRECTION_OUT) {
+                return EBADF;
+        }
+        if (pipe->transfer_type == USB_TRANSFER_CONTROL) {
+                return EBADF;
+        }
+        /* Isochronous transfer are not supported (yet) */
+        if (pipe->transfer_type != USB_TRANSFER_INTERRUPT &&
+            pipe->transfer_type != USB_TRANSFER_BULK)
+            return ENOTSUP;
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        const errno_t rc = usb_write(exch, pipe->endpoint_no, 0, buffer, size);
+        async_exchange_end(exch);
+        return rc;
+        transfer_t transfer = {
+                .pipe = pipe,
+                .dir = USB_DIRECTION_OUT,
+        };
+        return transfer_wrap_dma(&transfer, (void *) buffer, size);
+}
+/**
+ * Request a read (in) transfer on an endpoint pipe, declaring that buffer
+ * is pointing to a memory area previously allocated by usb_pipe_alloc_buffer.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] buffer Buffer, previously allocated with usb_pipe_alloc_buffer.
+ * @param[in] size Size of the buffer (in bytes).
+ * @param[out] size_transferred Number of bytes that were actually transferred.
+ * @return Error code.
+ */
+errno_t usb_pipe_read_dma(usb_pipe_t *pipe, void *base, void *ptr, size_t size,
+    size_t *size_transferred)
+{
+        assert(pipe);
+        errno_t err;
+        transfer_t transfer = {
+                .pipe = pipe,
+                .dir = USB_DIRECTION_IN,
+        };
+        setup_dma_buffer(&transfer, base, ptr, size);
+        if ((err = transfer_common(&transfer)))
+                return err;
+        if (size_transferred)
+                *size_transferred = transfer.transferred_size;
+        return EOK;
+}
+/**
+ * Request a write (out) transfer on an endpoint pipe, declaring that buffer
+ * is pointing to a memory area previously allocated by usb_pipe_alloc_buffer.
+ *
+ * @param[in] pipe Pipe used for the transfer.
+ * @param[in] buffer Buffer, previously allocated with usb_pipe_alloc_buffer.
+ * @param[in] size Size of the buffer (in bytes).
+ * @return Error code.
+ */
+errno_t usb_pipe_write_dma(usb_pipe_t *pipe, void *base, void *ptr, size_t size)
+{
+        assert(pipe);
+        transfer_t transfer = {
+                .pipe = pipe,
+                .dir = USB_DIRECTION_OUT,
+        };
+        setup_dma_buffer(&transfer, base, ptr, size);
+        return transfer_common(&transfer);
+}
 …
+ *
  * @param pipe Endpoint pipe to be initialized.
+ * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
+ * @param transfer_type Transfer type (e.g. interrupt or bulk).
+ * @param max_packet_size Maximum packet size in bytes.
+ * @param direction Endpoint direction (in/out).
+ * @return Error code.
+ */
+errno_t 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, 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;
+ * @param bus_session Endpoint pipe to be initialized.
+ * @return Error code.
+ */
+errno_t usb_pipe_initialize(usb_pipe_t *pipe, usb_dev_session_t *bus_session)
+{
+        assert(pipe);
         pipe->auto_reset_halt = false;
         pipe->bus_session = bus_session;
 …
+}
+/** Initialize USB endpoint pipe as the default zero control pipe.
+static const usb_pipe_desc_t default_control_pipe = {
+        .endpoint_no = 0,
+        .transfer_type = USB_TRANSFER_CONTROL,
+        .direction = USB_DIRECTION_BOTH,
+        .max_transfer_size = CTRL_PIPE_MIN_PACKET_SIZE,
+        .transfer_buffer_policy = DMA_POLICY_STRICT,
+};
+/** Initialize USB default control pipe.
+ *
+ * This one is special because it must not be registered, it is registered
+ * automatically.
+ *
  * @param pipe Endpoint pipe to be initialized.
+ * @param bus_session Endpoint pipe to be initialized.
  * @return Error code.
  */
 …
     usb_dev_session_t *bus_session)
+{
         assert(pipe);
         const errno_t rc = usb_pipe_initialize(pipe, 0, USB_TRANSFER_CONTROL,
+            CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH, 1, bus_session);
+        const errno_t ret = usb_pipe_initialize(pipe, bus_session);
+        if (ret)
+                return ret;
+        pipe->desc = default_control_pipe;
         pipe->auto_reset_halt = true;
         return rc;
+        return EOK;
+}
 …
+ *
  * @param pipe Pipe to be registered.
+ * @param interval Polling interval.
+ * @return Error code.
+ */
+errno_t usb_pipe_register(usb_pipe_t *pipe, unsigned interval)
+ * @param ep_desc Matched endpoint descriptor
+ * @param comp_desc Matched superspeed companion descriptro, if any
+ * @return Error code.
+ */
+errno_t usb_pipe_register(usb_pipe_t *pipe,
+    const usb_standard_endpoint_descriptor_t *ep_desc,
+    const usb_superspeed_endpoint_companion_descriptor_t *comp_desc)
+{
+        assert(pipe);
+        assert(pipe->bus_session);
+        assert(ep_desc);
+        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
+        if (!exch)
+                return ENOMEM;
+        usb_endpoint_descriptors_t descriptors = { 0 };
+#define COPY(field) descriptors.endpoint.field = ep_desc->field
+        COPY(endpoint_address);
+        COPY(attributes);
+        COPY(max_packet_size);
+        COPY(poll_interval);
+#undef COPY
+#define COPY(field) descriptors.companion.field = comp_desc->field
+        if (comp_desc) {
+                COPY(max_burst);
+                COPY(attributes);
+                COPY(bytes_per_interval);
+        }
+#undef COPY
+        const errno_t ret = usbhc_register_endpoint(exch,
+            &pipe->desc, &descriptors);
+        async_exchange_end(exch);
+        return ret;
+}
+/** Revert endpoint registration with the host controller.
+ *
+ * @param pipe Pipe to be unregistered.
+ * @return Error code.
+ */
+errno_t usb_pipe_unregister(usb_pipe_t *pipe)
+{
         assert(pipe);
 …
         if (!exch)
                 return ENOMEM;
+        const errno_t ret = usb_register_endpoint(exch, pipe->endpoint_no,
             pipe->transfer_type, pipe->direction, pipe->max_packet_size,
+            pipe->packets, interval);
+        const errno_t ret = usbhc_unregister_endpoint(exch, &pipe->desc);
         async_exchange_end(exch);
         return ret;
+}
-/** Revert endpoint registration with the host controller.
+ *
- * @param pipe Pipe to be unregistered.
- * @return Error code.
- */
-errno_t usb_pipe_unregister(usb_pipe_t *pipe)
+{
-        assert(pipe);
-        assert(pipe->bus_session);
-        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
-        if (!exch)
-                return ENOMEM;
-        const errno_t ret = usb_unregister_endpoint(exch, pipe->endpoint_no,
-            pipe->direction);
-        async_exchange_end(exch);
-        return ret;
+}
 /**
  * @}

uspace/lib/usbdev/src/pipesinit.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty, Michal Staruch
  * All rights reserved.
+ *
 …
 #include <usb/dev/request.h>
 #include <usb/usb.h>
+#include <usb/debug.h>
 #include <usb/descriptor.h>
 …
         NESTING(INTERFACE, HID),
         NESTING(HID, HID_REPORT),
+        NESTING(ENDPOINT, SSPEED_EP_COMPANION),
         LAST_NESTING
 };
 …
+{
         return descriptor[1] == USB_DESCTYPE_ENDPOINT;
+}
+/** Tells whether given descriptor is of superspeed companion type.
+ *
+ * @param descriptor Descriptor in question.
+ * @return Whether the given descriptor is superspeed companion descriptor.
+ */
+static inline bool is_superspeed_companion_descriptor(const uint8_t *descriptor)
+{
+        return descriptor[1] == USB_DESCTYPE_SSPEED_EP_COMPANION;
+}
 …
                 if (interface_number_fits
                     && interface_setting_fits
+                    && endpoint_descriptions_fits) {
+                    && endpoint_descriptions_fits
+                    && !mapping->present) {
                         return mapping;
+                }
 …
                 mapping_count--;
+        }
         return NULL;
+}
 …
  * @param interface Interface descriptor under which belongs the @p endpoint.
  * @param endpoint Endpoint descriptor.
+ * @param companion Superspeed companion descriptor.
  * @return Error code.
  */
 …
     usb_standard_interface_descriptor_t *interface,
     usb_standard_endpoint_descriptor_t *endpoint_desc,
+    usb_superspeed_endpoint_companion_descriptor_t *companion_desc,
     usb_dev_session_t *bus_session)
+{
 …
          * Get endpoint characteristics.
          */
-        /* Actual endpoint number is in bits 0..3 */
-        const usb_endpoint_t ep_no = endpoint_desc->endpoint_address & 0x0F;
         const usb_endpoint_description_t description = {
+                /* Endpoint direction is set by bit 7 */
+                .direction = (endpoint_desc->endpoint_address & 128)
+                    ? USB_DIRECTION_IN : USB_DIRECTION_OUT,
+                /* Transfer type is in bits 0..2 and
+                 * the enum values corresponds 1:1 */
+                .transfer_type = endpoint_desc->attributes & 3,
+                .transfer_type = USB_ED_GET_TRANSFER_TYPE(*endpoint_desc),
+                .direction = USB_ED_GET_DIR(*endpoint_desc),
                 /* Get interface characteristics. */
 …
+        }
+        errno_t rc = usb_pipe_initialize(&ep_mapping->pipe,
+            ep_no, description.transfer_type,
+            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;
+        }
+        errno_t err = usb_pipe_initialize(&ep_mapping->pipe, bus_session);
+        if (err)
+                return err;
         ep_mapping->present = true;
         ep_mapping->descriptor = endpoint_desc;
+        ep_mapping->companion_descriptor = companion_desc;
         ep_mapping->interface = interface;
 …
         do {
                 if (is_endpoint_descriptor(descriptor)) {
+                        /* Check if companion descriptor is present too, it should immediatelly follow. */
+                        const uint8_t *companion_desc = usb_dp_get_nested_descriptor(parser,
+                                parser_data, descriptor);
+                        if (companion_desc && !is_superspeed_companion_descriptor(companion_desc)) {
+                                /* Not what we wanted, don't pass it further. */
+                                companion_desc = NULL;
+                        }
                         (void) process_endpoint(mapping, mapping_count,
                             (usb_standard_interface_descriptor_t *)
 …
                             (usb_standard_endpoint_descriptor_t *)
                                 descriptor,
+                            (usb_superspeed_endpoint_companion_descriptor_t *)
+                                companion_desc,
                             bus_session);
+                }
 …
         if (config_descriptor == NULL)
                 return EBADMEM;
         if (config_descriptor_size <
             sizeof(usb_standard_configuration_descriptor_t)) {
 …
+}
-/** Probe default control pipe for max packet size.
+ *
- * The function tries to get the correct value of max packet size several
- * time before giving up.
+ *
- * The session on the pipe shall not be started.
+ *
- * @param pipe Default control pipe.
- * @return Error code.
- */
-errno_t usb_pipe_probe_default_control(usb_pipe_t *pipe)
+{
-        assert(pipe);
-        static_assert(DEV_DESCR_MAX_PACKET_SIZE_OFFSET < CTRL_PIPE_MIN_PACKET_SIZE);
-        if ((pipe->direction != USB_DIRECTION_BOTH) ||
-            (pipe->transfer_type != USB_TRANSFER_CONTROL) ||
-            (pipe->endpoint_no != 0)) {
-                return EINVAL;
+        }
-        uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE];
-        size_t transferred_size;
-        errno_t rc;
-        for (size_t attempt_var = 0; attempt_var < 3; ++attempt_var) {
-                rc = usb_request_get_descriptor(pipe, USB_REQUEST_TYPE_STANDARD,
-                    USB_REQUEST_RECIPIENT_DEVICE, USB_DESCTYPE_DEVICE,
-, 0, dev_descr_start, CTRL_PIPE_MIN_PACKET_SIZE,
-                    &transferred_size);
-                if (rc == EOK) {
-                        if (transferred_size != CTRL_PIPE_MIN_PACKET_SIZE) {
-                                rc = ELIMIT;
-                                continue;
+                        }
-                        break;
+                }
+        }
-        if (rc != EOK) {
-                return rc;
+        }
-        pipe->max_packet_size
-            = dev_descr_start[DEV_DESCR_MAX_PACKET_SIZE_OFFSET];
-        return EOK;
+}
 /**
  * @}

uspace/lib/usbdev/src/request.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
  * @param data_size        Size of the @p data buffer
  *                         (in native endianness).
  * @param actual_data_size Actual size of transfered data
+ * @param actual_data_size Actual size of transferred data
  *                         (in native endianness).
+ *
 …
         uint16_t status_usb_endianess;
         size_t data_transfered_size;
+        size_t data_transferred_size;
         errno_t rc = usb_control_request_get(pipe, USB_REQUEST_TYPE_STANDARD,
             recipient, USB_DEVREQ_GET_STATUS, 0, uint16_host2usb(index),
             &status_usb_endianess, 2, &data_transfered_size);
         if (rc != EOK) {
                 return rc;
+        }
         if (data_transfered_size != 2) {
+            &status_usb_endianess, 2, &data_transferred_size);
+        if (rc != EOK) {
+                return rc;
+        }
+        if (data_transferred_size != 2) {
                 return ELIMIT;
+        }
 …
          */
         uint8_t tmp_buffer;
         size_t bytes_transfered;
+        size_t bytes_transferred;
         rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             &tmp_buffer, sizeof(tmp_buffer), &bytes_transfered);
         if (rc != EOK) {
                 return rc;
+        }
         if (bytes_transfered != 1) {
+            &tmp_buffer, sizeof(tmp_buffer), &bytes_transferred);
+        if (rc != EOK) {
+                return rc;
+        }
+        if (bytes_transferred != 1) {
                 return ELIMIT;
+        }
 …
         rc = usb_request_get_descriptor(pipe, request_type, recipient,
             descriptor_type, descriptor_index, language,
             buffer, size, &bytes_transfered);
+            buffer, size, &bytes_transferred);
         if (rc != EOK) {
                 free(buffer);
                 return rc;
+        }
         if (bytes_transfered != size) {
+        if (bytes_transferred != size) {
                 free(buffer);
                 return ELIMIT;
 …
  * @return Error code.
  */
 errno_t usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index)
+static errno_t usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index)
+{
         return usb_request_clear_feature(pipe,
 …
                 return EINVAL;
+        }
+        return usb_request_clear_endpoint_halt(ctrl_pipe,
+            target_pipe->endpoint_no);
+        uint16_t index = target_pipe->desc.endpoint_no;
+        index |= (target_pipe->desc.direction == USB_DIRECTION_IN) << 7;
+        return usb_request_clear_endpoint_halt(ctrl_pipe, index);
+}
 …
+{
         uint16_t status_tmp;
         uint16_t pipe_index = (uint16_t) pipe->endpoint_no;
+        uint16_t pipe_index = (uint16_t) pipe->desc.endpoint_no;
         errno_t rc = usb_request_get_status(ctrl_pipe,
             USB_REQUEST_RECIPIENT_ENDPOINT, uint16_host2usb(pipe_index),

uspace/lib/usbhid/src/hiddescriptor.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Matej Klonfar
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
         if(report_item->usages_count > 0){
                 usages = malloc(sizeof(int32_t) * report_item->usages_count);
+                usages = malloc(sizeof(uint32_t) * report_item->usages_count);
                 memcpy(usages, report_item->usages, sizeof(int32_t) *
                                 report_item->usages_count);
 …
                 field->size = report_item->size;
+                if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
+                        int offset = report_item->offset + report_item->size * i;
+                        int field_offset = (offset/8)*8 + (offset/8 + 1) * 8 -
+                                offset - report_item->size;
+                        if(field_offset < 0) {
+                                field->offset = 0;
+                        }
+                        else {
+                                field->offset = field_offset;
+                        }
+                }
+                else {
+                        field->offset = report_item->offset + (i * report_item->size);
+                }
+                field->offset = report_item->offset + (i * report_item->size);
                 if(report->use_report_ids != 0) {
 …
+{
         if(list == NULL || list_empty(list)) {
             usb_log_debug("\tempty\n");
+            usb_log_debug("\tempty");
             return;
+        }
 …
         list_foreach(*list, ritems_link, usb_hid_report_field_t,
             report_item) {
                 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
                 usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
                 usb_log_debug("\t\tLOGMIN: %d\n",
+                usb_log_debug("\t\tOFFSET: %u", report_item->offset);
+                usb_log_debug("\t\tSIZE: %zu", report_item->size);
+                usb_log_debug("\t\tLOGMIN: %d",
                         report_item->logical_minimum);
                 usb_log_debug("\t\tLOGMAX: %d\n",
+                usb_log_debug("\t\tLOGMAX: %d",
                         report_item->logical_maximum);
                 usb_log_debug("\t\tPHYMIN: %d\n",
+                usb_log_debug("\t\tPHYMIN: %d",
                         report_item->physical_minimum);
                 usb_log_debug("\t\tPHYMAX: %d\n",
+                usb_log_debug("\t\tPHYMAX: %d",
                         report_item->physical_maximum);
                 usb_log_debug("\t\ttUSAGEMIN: %X\n",
+                usb_log_debug("\t\ttUSAGEMIN: %X",
                         report_item->usage_minimum);
                 usb_log_debug("\t\tUSAGEMAX: %X\n",
+                usb_log_debug("\t\tUSAGEMAX: %X",
                                report_item->usage_maximum);
                 usb_log_debug("\t\tUSAGES COUNT: %zu\n",
+                usb_log_debug("\t\tUSAGES COUNT: %zu",
                         report_item->usages_count);
                 usb_log_debug("\t\tVALUE: %X\n", report_item->value);
                 usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
                 usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
+                usb_log_debug("\t\tVALUE: %X", report_item->value);
+                usb_log_debug("\t\ttUSAGE: %X", report_item->usage);
+                usb_log_debug("\t\tUSAGE PAGE: %X", report_item->usage_page);
                 usb_hid_print_usage_path(report_item->collection_path);
-                usb_log_debug("\n");
+        }
+}
 …
         list_foreach(report->reports, reports_link,
             usb_hid_report_description_t, report_des) {
                 usb_log_debug("Report ID: %d\n", report_des->report_id);
                 usb_log_debug("\tType: %d\n", report_des->type);
                 usb_log_debug("\tLength: %zu\n", report_des->bit_length);
                 usb_log_debug("\tB Size: %zu\n",
+                usb_log_debug("Report ID: %d", report_des->report_id);
+                usb_log_debug("\tType: %d", report_des->type);
+                usb_log_debug("\tLength: %zu", report_des->bit_length);
+                usb_log_debug("\tB Size: %zu",
                         usb_hid_report_byte_size(report,
                                 report_des->report_id,
                                 report_des->type));
                 usb_log_debug("\tItems: %zu\n", report_des->item_length);
+                usb_log_debug("\tItems: %zu", report_des->item_length);
                 usb_hid_descriptor_print_list(&report_des->report_items);

uspace/lib/usbhid/src/hidparser.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Matej Klonfar
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 #include <usb/debug.h>
 #include <assert.h>
+#include <bitops.h>
+#include <macros.h>
 …
 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
         int32_t value);
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
+    int32_t value);
 …
+ *
  * @param parser Opaque report parser structure
  * @param report_id
+ * @param report_id
  * @param type
  * @return Number of items in specified report
  */
 size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
+size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
     usb_hid_report_type_t type)
+{
 …
+ *
  * @param parser Opaque report parser structure
  * @param report_id
+ * @param report_id
  * @param type
  * @return Number of items in specified report
  */
 size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
+size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
     usb_hid_report_type_t type)
+{
 …
                 return 0;
         } else {
                 return ((report_des->bit_length + 7) / 8) ;
+                return ((report_des->bit_length + 7) / 8);
+        }
+}
 …
  * @param data Data for the report.
  * @return Error code.
  */
 errno_t usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
+ */
+errno_t usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
     size_t size, uint8_t *report_id)
+{
         usb_hid_report_description_t *report_des;
         usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
         if (report == NULL) {
                 return EINVAL;
 …
+        }
         report_des = usb_hid_report_find_description(report, *report_id,
+        report_des = usb_hid_report_find_description(report, *report_id,
             type);
 …
                 if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
                         if (USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
                                 /* array */
                                 item->value =
                                         usb_hid_translate_data(item, data);
+                                item->value =
+                                    usb_hid_translate_data(item, data);
                                 item->usage = USB_HID_EXTENDED_USAGE(
                                     item->usages[item->value -
                                     item->physical_minimum]);
                                 item->usage_page =
+                                item->usage_page =
                                     USB_HID_EXTENDED_USAGE_PAGE(
                                     item->usages[item->value -
 …
                                 usb_hid_report_set_last_item(
                                     item->collection_path,
                                     USB_HID_TAG_CLASS_GLOBAL,
+                                    item->collection_path,
+                                    USB_HID_TAG_CLASS_GLOBAL,
                                     item->usage_page);
                                 usb_hid_report_set_last_item(
                                     item->collection_path,
+                                    item->collection_path,
                                     USB_HID_TAG_CLASS_LOCAL, item->usage);
                         } else {
                                 /* variable item */
                                 item->value = usb_hid_translate_data(item,
+                                item->value = usb_hid_translate_data(item,
                                     data);
+                        }
+                }
+        }
         return EOK;
+}
 …
 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data)
+{
-        int resolution;
-        int offset;
-        int part_size;
-        int32_t value = 0;
-        int32_t mask = 0;
-        const uint8_t *foo = 0;
         /* now only short tags are allowed */
         if (item->size > 32) {
 …
         if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
                 item->physical_minimum = item->logical_minimum;
                 item->physical_maximum = item->logical_maximum;
+        }
+                item->physical_maximum = item->logical_maximum;
+        }
+        int resolution;
         if (item->physical_maximum == item->physical_minimum) {
+            resolution = 1;
+        } else {
+            resolution = (item->logical_maximum - item->logical_minimum) /
+                ((item->physical_maximum - item->physical_minimum) *
+                (usb_pow(10, (item->unit_exponent))));
+        }
+        offset = item->offset;
+        // FIXME
+        if ((size_t) (offset / 8) != (size_t) ((offset+item->size - 1) / 8)) {
+                part_size = 0;
+                size_t i = 0;
+                for (i = (size_t) (offset / 8);
+                    i <= (size_t) (offset + item->size - 1) / 8; i++) {
+                        if (i == (size_t) (offset / 8)) {
+                                /* the higher one */
+                                part_size = 8 - (offset % 8);
+                                foo = data + i;
+                                mask =  ((1 << (item->size - part_size)) - 1);
+                                value = (*foo & mask);
+                        } else if (i == ((offset + item->size - 1) / 8)) {
+                                /* the lower one */
+                                foo = data + i;
+                                mask = ((1 << (item->size - part_size)) - 1) <<
+                                    (8 - (item->size - part_size));
+                                value = (((*foo & mask) >> (8 -
+                                    (item->size - part_size))) << part_size) +
+                                    value;
+                        } else {
+                                value = (*(data + 1) << (part_size + 8)) +
+                                    value;
+                                part_size += 8;
+                        }
+                }
+        } else {
+                foo = data + (offset / 8);
+                mask = ((1 << item->size) - 1) <<
+                    (8 - ((offset % 8) + item->size));
+                value = (*foo & mask) >> (8 - ((offset % 8) + item->size));
+                resolution = 1;
+        } else {
+                resolution = (item->logical_maximum - item->logical_minimum) /
+                    ((item->physical_maximum - item->physical_minimum) *
+                    (usb_pow(10, (item->unit_exponent))));
+        }
+        int32_t value = 0;
+        /* First, skip all bytes we don't care */
+        data += item->offset / 8;
+        int bits = item->size;
+        int taken = 0;
+        /* Than we take the higher bits from the LSB */
+        const unsigned bit_offset = item->offset % 8;
+        const int lsb_bits = min(bits, 8);
+        value |= (*data >> bit_offset) & BIT_RRANGE(uint8_t, lsb_bits);
+        bits -= lsb_bits;
+        taken += lsb_bits;
+        data++;
+        /* Then there may be bytes, which we take as a whole. */
+        while (bits > 8) {
+                value |= *data << taken;
+                taken += 8;
+                bits -= 8;
+                data++;
+        }
+        /* And, finally, lower bits from HSB. */
+        if (bits > 0) {
+                value |= (*data & BIT_RRANGE(uint8_t, bits)) << taken;
+        }
 …
+        }
         return (int) (((value - item->logical_minimum) / resolution) +
+        return (int) (((value - item->logical_minimum) / resolution) +
             item->physical_minimum);
+}
 …
 /* OUTPUT API */
 /**
+/**
  * Allocates output report buffer for output report
+ *
 …
  * @return Returns allocated output buffer for specified output
  */
 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
+uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
     uint8_t report_id)
+{
 …
  * @return Error code
  */
 errno_t usb_hid_report_output_translate(usb_hid_report_t *report,
+errno_t usb_hid_report_output_translate(usb_hid_report_t *report,
     uint8_t report_id, uint8_t *buffer, size_t size)
+{
 …
         int length;
         int32_t tmp_value;
         if (report == NULL) {
                 return EINVAL;
 …
         usb_hid_report_description_t *report_des;
         report_des = usb_hid_report_find_description(report, report_id,
+        report_des = usb_hid_report_find_description(report, report_id,
             USB_HID_REPORT_TYPE_OUTPUT);
         if (report_des == NULL) {
                 return EINVAL;
 …
         list_foreach(report_des->report_items, ritems_link,
             usb_hid_report_field_t, report_item) {
                 value = usb_hid_translate_data_reverse(report_item,
+                value = usb_hid_translate_data_reverse(report_item,
                     report_item->value);
                 offset = report_des->bit_length - report_item->offset - 1;
                 length = report_item->size;
                 usb_log_debug("\ttranslated value: %x\n", value);
+                usb_log_debug("\ttranslated value: %x", value);
                 if ((offset / 8) == ((offset + length - 1) / 8)) {
                         if (((size_t) (offset / 8) >= size) ||
+                        if (((size_t) (offset / 8) >= size) ||
                             ((size_t) (offset + length - 1) / 8) >= size) {
                                 break; // TODO ErrorCode
 …
                         value = value << shift;
                         value = value & (((1 << length) - 1) << shift);
                         uint8_t mask = 0;
                         mask = 0xff - (((1 << length) - 1) << shift);
 …
                                 if (i == (offset / 8)) {
                                         tmp_value = value;
                                         tmp_value = tmp_value &
+                                        tmp_value = tmp_value &
                                             ((1 << (8 - (offset % 8))) - 1);
                                         tmp_value = tmp_value << (offset % 8);
                                         mask = ~(((1 << (8 - (offset % 8))) - 1)
                                             << (offset % 8));
                                         buffer[i] = (buffer[i] & mask) |
+                                        buffer[i] = (buffer[i] & mask) |
                                             tmp_value;
                                 } else if (i == ((offset + length - 1) / 8)) {
                                         value = value >> (length -
+                                        value = value >> (length -
                                             ((offset + length) % 8));
                                         value = value & ((1 << (length -
+                                        value = value & ((1 << (length -
                                             ((offset + length) % 8))) - 1);
                                         mask = (1 << (length -
+                                        mask = (1 << (length -
                                             ((offset + length) % 8))) - 1;
 …
                 report_item->value = 0;
+        }
         return EOK;
+}
 …
  * @return ranslated value
  */
 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
     int value)
+{
 …
         if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
                 ret = item->logical_minimum;
+                return item->logical_minimum;
+        }
         if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
                 item->physical_minimum = item->logical_minimum;
                 item->physical_maximum = item->logical_maximum;
+        }
+                item->physical_maximum = item->logical_maximum;
+        }
         /* variable item */
         if (item->physical_maximum == item->physical_minimum) {
             resolution = 1;
         } else {
             resolution = (item->logical_maximum - item->logical_minimum) /
                 ((item->physical_maximum - item->physical_minimum) *
                 (usb_pow(10, (item->unit_exponent))));
+        }
         ret = ((value - item->physical_minimum) * resolution) +
+                resolution = 1;
+        } else {
+                resolution = (item->logical_maximum - item->logical_minimum) /
+                    ((item->physical_maximum - item->physical_minimum) *
+                    (usb_pow(10, (item->unit_exponent))));
+        }
+        ret = ((value - item->physical_minimum) * resolution) +
             item->logical_minimum;
         usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), "
             "ret(%x)\n", value, resolution, item->physical_minimum,
+            "ret(%x)\n", value, resolution, item->physical_minimum,
             item->logical_minimum, ret);
         if ((item->logical_minimum < 0) || (item->logical_maximum < 0)) {
                 return USB_HID_INT32_TO_UINT32(ret, item->size);
 …
+{
         usb_hid_report_item_t *new_report_item;
         if (!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
                 return NULL;
+        }
+        }
         memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
         link_initialize(&(new_report_item->link));
 …
  * @param field Current field. If NULL is given, the first one in the report
  * is returned. Otherwise the next one i nthe list is returned.
  * @param path Usage path specifying which fields wa are interested in.
+ * @param path Usage path specifying which fields wa are interested in.
  * @param flags Flags defining mode of usage paths comparison
  * @param type Type of report we search.
 …
  * @retval Pointer to the founded report structure when founded
  */
 usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
     usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
+usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
+    usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
     usb_hid_report_type_t type)
+{
         usb_hid_report_description_t *report_des =
+        usb_hid_report_description_t *report_des =
             usb_hid_report_find_description(report, path->report_id, type);
         link_t *field_it;
         if (report_des == NULL) {
                 return NULL;
 …
         while (field_it != &report_des->report_items.head) {
                 field = list_get_instance(field_it, usb_hid_report_field_t,
+                field = list_get_instance(field_it, usb_hid_report_field_t,
                     ritems_link);
 …
         usb_hid_report_description_t *report_des;
         link_t *report_it;
         if (report_id > 0) {
                 report_des = usb_hid_report_find_description(report, report_id,
+                report_des = usb_hid_report_find_description(report, report_id,
                     type);
                 if (report_des == NULL) {
 …
                 } else {
                         report_it = report_des->reports_link.next;
+                }
+                }
         } else {
                 report_it = report->reports.head.next;
 …
         while (report_it != &report->reports.head) {
                 report_des = list_get_instance(report_it,
+                report_des = list_get_instance(report_it,
                     usb_hid_report_description_t, reports_link);
 …
                 return;
+        }
         report_item->usages_count = 0;
         memset(report_item->usages, 0, USB_HID_MAX_USAGES);
         report_item->extended_usage_page = 0;
         report_item->usage_minimum = 0;

uspace/lib/usbhid/src/hidpath.c

-              rf5e5f73
+              rdf6ded8
  * @return Error code
  */
 errno_t usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
                                     int32_t usage_page, int32_t usage)
+{
         usb_hid_report_usage_path_t *item
                 = malloc(sizeof(usb_hid_report_usage_path_t));
+errno_t usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
+    int32_t usage_page, int32_t usage)
+{
+        usb_hid_report_usage_path_t *item =
+            malloc(sizeof(usb_hid_report_usage_path_t));
         if (item == NULL) {
 …
         item->usage_page = usage_page;
         item->flags = 0;
         list_append (&item->rpath_items_link, &usage_path->items);
         usage_path->depth++;
 …
 /**
  * Removes last item from the usage path structure
  * @param usage_path
+ * @param usage_path
  * @return void
  */
 …
         link_t *item_link;
         usb_hid_report_usage_path_t *item;
         if(!list_empty(&usage_path->items)){
+        if (!list_empty(&usage_path->items)) {
                 item_link = list_last(&usage_path->items);
                 item = list_get_instance(item_link,
 …
+{
         usb_hid_report_usage_path_t *item;
         if(!list_empty(&usage_path->items)){
+        if (!list_empty(&usage_path->items)) {
                 item = list_get_instance(list_last(&usage_path->items),
                         usb_hid_report_usage_path_t, rpath_items_link);
+                    usb_hid_report_usage_path_t, rpath_items_link);
                 memset(item, 0, sizeof(usb_hid_report_usage_path_t));
 …
  * @return void
  */
 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path,
                                   int32_t tag, int32_t data)
+void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path,
+    int32_t tag, int32_t data)
+{
         usb_hid_report_usage_path_t *item;
         if(!list_empty(&usage_path->items)){
+        if (!list_empty(&usage_path->items)) {
                 item = list_get_instance(list_last(&usage_path->items),
                      usb_hid_report_usage_path_t, rpath_items_link);
+                switch(tag) {
+                        case USB_HID_TAG_CLASS_GLOBAL:
+                                item->usage_page = data;
+                                break;
+                        case USB_HID_TAG_CLASS_LOCAL:
+                                item->usage = data;
+                                break;
+                }
+        }
+}
+/**
+ *
+ *
+ *
+ *
+ */
+                switch (tag) {
+                case USB_HID_TAG_CLASS_GLOBAL:
+                        item->usage_page = data;
+                        break;
+                case USB_HID_TAG_CLASS_LOCAL:
+                        item->usage = data;
+                        break;
+                }
+        }
+}
 void usb_hid_print_usage_path(usb_hid_report_path_t *path)
+{
         usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id);
         usb_log_debug("\tLENGTH: %d\n", path->depth);
+        usb_log_debug("USAGE_PATH FOR RId(%d):", path->report_id);
+        usb_log_debug("\tLENGTH: %d", path->depth);
         list_foreach(path->items, rpath_items_link,
             usb_hid_report_usage_path_t, path_item) {
                 usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
                 usb_log_debug("\tUSAGE: %X\n", path_item->usage);
                 usb_log_debug("\tFLAGS: %d\n", path_item->flags);
+                usb_log_debug("\tUSAGE_PAGE: %X", path_item->usage_page);
+                usb_log_debug("\tUSAGE: %X", path_item->usage);
+                usb_log_debug("\tFLAGS: %d", path_item->flags);
+        }
+}
 …
         usb_hid_report_usage_path_t *report_item;
         usb_hid_report_usage_path_t *path_item;
         link_t *report_link;
         link_t *path_link;
         int only_page;
         if (report_path->report_id != path->report_id) {
                 if (path->report_id != 0) {
 …
+                }
+        }
         // Empty path match all others
         if (path->depth == 0) {
                 return 0;
+        }
         if ((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0) {
                 flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY;
+        }
         switch (flags) {
         /* Path is somewhere in report_path */
 …
                         return 1;
+                }
                 path_link = list_first(&path->items);
                 path_item = list_get_instance(path_link,
                     usb_hid_report_usage_path_t, rpath_items_link);
                 list_foreach(report_path->items, rpath_items_link,
                     usb_hid_report_usage_path_t, report_item) {
                         if (USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
                             path_item->usage_page)) {
                                 if (only_page == 0) {
                                         if (USB_HID_SAME_USAGE(report_item->usage,
 …
+                        }
+                }
                 return 1;
                 break;
         /* The paths must be identical */
         case USB_HID_PATH_COMPARE_STRICT:
 …
+                }
                 /* Fallthrough */
         /* Path is prefix of the report_path */
         case USB_HID_PATH_COMPARE_BEGIN:
                 report_link = report_path->items.head.next;
                 path_link = path->items.head.next;
                 while ((report_link != &report_path->items.head) &&
                     (path_link != &path->items.head)) {
                         report_item = list_get_instance(report_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
                         path_item = list_get_instance(path_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
                         if (!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
                             path_item->usage_page) || ((only_page == 0) &&
 …
+                        }
+                }
                 if ((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
                     (path_link == &path->items.head)) ||
 …
+                }
                 break;
         /* Path is suffix of report_path */
         case USB_HID_PATH_COMPARE_END:
                 report_link = report_path->items.head.prev;
                 path_link = path->items.head.prev;
                 if (list_empty(&path->items)) {
                         return 0;
+                }
                 while ((report_link != &report_path->items.head) &&
                       (path_link != &path->items.head)) {
                         report_item = list_get_instance(report_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
                         path_item = list_get_instance(path_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
                         if (!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
                             path_item->usage_page) || ((only_page == 0) &&
 …
+                        }
+                }
                 if (path_link == &path->items.head) {
                         return 0;
 …
+                }
                 break;
         default:
                 return -1;
 …
         usb_hid_report_path_t *path;
         path = malloc(sizeof(usb_hid_report_path_t));
         if(path == NULL){
+        if (path == NULL) {
                 return NULL;
+        }
 …
         if (path == NULL)
                 return;
         while(!list_empty(&path->items)){
+        while (!list_empty(&path->items)) {
                 usb_hid_report_remove_last_item(path);
+        }
 …
  */
 usb_hid_report_path_t *usb_hid_report_path_clone(
         usb_hid_report_path_t *usage_path)
+    usb_hid_report_path_t *usage_path)
+{
         usb_hid_report_usage_path_t *new_path_item;
         usb_hid_report_path_t *new_usage_path = usb_hid_report_path ();
         if(new_usage_path == NULL){
+        if (new_usage_path == NULL) {
                 return NULL;
+        }
         new_usage_path->report_id = usage_path->report_id;
         if(list_empty(&usage_path->items)){
+        if (list_empty(&usage_path->items)) {
                 return new_usage_path;
+        }
 …
                 new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
                 if(new_path_item == NULL) {
+                if (new_path_item == NULL) {
                         return NULL;
+                }
                 link_initialize(&new_path_item->rpath_items_link);
                 new_path_item->usage_page = path_item->usage_page;
                 new_path_item->usage = path_item->usage;
                 new_path_item->flags = path_item->flags;
+                new_path_item->usage = path_item->usage;
+                new_path_item->flags = path_item->flags;
                 list_append(&new_path_item->rpath_items_link,
                     &new_usage_path->items);
 …
  * @return Error code
  */
 errno_t usb_hid_report_path_set_report_id(usb_hid_report_path_t *path,
         uint8_t report_id)
+{
         if(path == NULL){
+errno_t usb_hid_report_path_set_report_id(usb_hid_report_path_t *path,
+    uint8_t report_id)
+{
+        if (path == NULL) {
                 return EINVAL;
+        }

uspace/lib/usbhid/src/hidreport.c

-              rf5e5f73
+              rdf6ded8
         const uint8_t *d =
             usb_dp_get_nested_descriptor(&parser, &parser_data,
                 usb_device_descriptors(dev)->full_config);
+            usb_device_descriptors(dev)->full_config);
         /*
 …
         if (d == NULL) {
                 usb_log_error("The %d. interface descriptor not found!\n",
+                usb_log_error("The %d. interface descriptor not found!",
                     usb_device_get_iface_number(dev));
                 return ENOENT;
 …
         if (d == NULL) {
                 usb_log_fatal("No HID descriptor found!\n");
+                usb_log_fatal("No HID descriptor found!");
                 return ENOENT;
+        }
 …
+        }
         usb_log_debug("Getting Report descriptor, expected size: %u\n", length);
+        usb_log_debug("Getting Report descriptor, expected size: %u", length);
         /*
 …
         *size = length;
         usb_log_debug("Done.\n");
+        usb_log_debug("Done.");
         return EOK;
 …
 errno_t usb_hid_process_report_descriptor(usb_device_t *dev,
+errno_t usb_hid_process_report_descriptor(usb_device_t *dev,
     usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size)
+{
 …
         if (rc != EOK) {
                 usb_log_error("Problem with getting Report descriptor: %s.\n",
+                usb_log_error("Problem with getting Report descriptor: %s.",
                     str_error(rc));
                 if (*report_desc != NULL) {
 …
         rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size);
         if (rc != EOK) {
                 usb_log_error("Problem parsing Report descriptor: %s.\n",
+                usb_log_error("Problem parsing Report descriptor: %s.",
                     str_error(rc));
                 free(*report_desc);

uspace/lib/usbhid/src/hidreq.c

-              rf5e5f73
+              rdf6ded8
+{
         if (ctrl_pipe == NULL) {
                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
                 return EINVAL;
+        }
         if (iface_no < 0) {
                 usb_log_warning("usbhid_req_set_report(): no interface given."
                     "\n");
                 return EINVAL;
+        }
         /*
          * No need for checking other parameters, as they are checked in
          * the called function (usb_control_request_set()).
          */
         errno_t rc;
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        errno_t rc;
         uint16_t value = 0;
         value |= (type << 8);
         usb_log_debug("Sending Set Report request to the device.\n");
+        usb_log_debug("Sending Set Report request to the device.");
         rc = usb_control_request_set(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
 …
                 return rc;
+        }
         return EOK;
+}
 …
+{
         if (ctrl_pipe == NULL) {
                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
                 return EINVAL;
+        }
         if (iface_no < 0) {
                 usb_log_warning("usbhid_req_set_report(): no interface given."
                     "\n");
                 return EINVAL;
+        }
         /*
          * No need for checking other parameters, as they are checked in
          * the called function (usb_control_request_set()).
          */
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
         errno_t rc;
         usb_log_debug("Sending Set Protocol request to the device ("
             "protocol: %d, iface: %d).\n", protocol, iface_no);
         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_PROTOCOL, protocol, iface_no, NULL, 0);
 …
                 return rc;
+        }
         return EOK;
+}
 …
+{
         if (ctrl_pipe == NULL) {
                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
                 return EINVAL;
+        }
         if (iface_no < 0) {
                 usb_log_warning("usbhid_req_set_report(): no interface given."
                     "\n");
                 return EINVAL;
+        }
         /*
          * No need for checking other parameters, as they are checked in
          * the called function (usb_control_request_set()).
          */
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
         errno_t rc;
         usb_log_debug("Sending Set Idle request to the device ("
             "duration: %u, iface: %d).\n", duration, iface_no);
         uint16_t value = duration << 8;
         rc = usb_control_request_set(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
 …
                 return rc;
+        }
         return EOK;
+}
 …
  * @param[in][out] buffer Buffer for the report data.
  * @param[in] buf_size Size of the buffer (in bytes).
  * @param[out] actual_size Actual size of report received from the device
+ * @param[out] actual_size Actual size of report received from the device
  *                         (in bytes).
+ *
 …
  * @return Other value inherited from function usb_control_request_set().
  */
 errno_t usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no,
     usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size,
+errno_t usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no,
+    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size,
     size_t *actual_size)
+{
         if (ctrl_pipe == NULL) {
                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
                 return EINVAL;
+        }
         if (iface_no < 0) {
                 usb_log_warning("usbhid_req_set_report(): no interface given."
                     "\n");
                 return EINVAL;
+        }
         /*
          * No need for checking other parameters, as they are checked in
          * the called function (usb_control_request_set()).
          */
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
         errno_t rc;
         uint16_t value = 0;
         value |= (type << 8);
         usb_log_debug("Sending Get Report request to the device.\n");
         rc = usb_control_request_get(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+        usb_log_debug("Sending Get Report request to the device.");
+        rc = usb_control_request_get(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_GET_REPORT, value, iface_no, buffer, buf_size,
             actual_size);
 …
                 return rc;
+        }
         return EOK;
+}
 …
  * @return Other value inherited from function usb_control_request_set().
  */
 errno_t usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no,
+errno_t usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no,
     usb_hid_protocol_t *protocol)
+{
         if (ctrl_pipe == NULL) {
                 usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
                 return EINVAL;
+        }
         if (iface_no < 0) {
                 usb_log_warning("usbhid_req_set_report(): no interface given."
                     "\n");
                 return EINVAL;
+        }
         /*
          * No need for checking other parameters, as they are checked in
          * the called function (usb_control_request_set()).
          */
         errno_t rc;
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+        errno_t rc;
         usb_log_debug("Sending Get Protocol request to the device ("
             "iface: %d).\n", iface_no);
         uint8_t buffer[1];
         size_t actual_size = 0;
         rc = usb_control_request_get(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+        rc = usb_control_request_get(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size);
 …
                 return rc;
+        }
         if (actual_size != 1) {
                 usb_log_warning("Wrong data size: %zu, expected: 1.\n",
                         actual_size);
+                usb_log_warning("Wrong data size: %zu, expected: 1.",
+                    actual_size);
                 return ELIMIT;
+        }
         *protocol = buffer[0];
         return EOK;
+}
 …
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
  * @return Other value inherited from one of functions
+ * @return Other value inherited from one of functions
  *         usb_pipe_start_session(), usb_pipe_end_session(),
  *         usb_control_request_set().
  */
+errno_t usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+errno_t usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no,
+    uint8_t *duration)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
         errno_t rc;
         usb_log_debug("Sending Get Idle request to the device ("
             "iface: %d).\n", iface_no);
         uint16_t value = 0;
         uint8_t buffer[1];
         size_t actual_size = 0;
         rc = usb_control_request_get(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1,
+        rc = usb_control_request_get(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+            USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1,
             &actual_size);
 …
                 return rc;
+        }
         if (actual_size != 1) {
                 usb_log_warning("Wrong data size: %zu, expected: 1.\n",
                         actual_size);
+                usb_log_warning("Wrong data size: %zu, expected: 1.",
+                    actual_size);
                 return ELIMIT;
+        }
         *duration = buffer[0];
         return EOK;
+}

uspace/lib/usbhost/Makefile

-              rf5e5f73
+              rdf6ded8
         src/endpoint.c \
         src/hcd.c \
+        src/usb_bus.c \
+        src/bus.c \
+        src/usb2_bus.c \
+        src/bandwidth.c \
+        src/utility.c \
         src/usb_transfer_batch.c

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2012 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 #define LIBUSBHOST_HOST_DDF_HELPERS_H
 #include <usb/host/hcd.h>
 #include <usb/host/usb_bus.h>
+#include <ddf/driver.h>
+#include <ddf/interrupt.h>
 #include <usb/usb.h>
+#include <ddf/driver.h>
+#include <ddf/interrupt.h>
+#include <device/hw_res_parsed.h>
+#include <usb/host/hcd.h>
+#include <usb/descriptor.h>
-typedef errno_t (*driver_init_t)(hcd_t *, const hw_res_list_parsed_t *, bool);
-typedef void (*driver_fini_t)(hcd_t *);
-typedef errno_t (*claim_t)(ddf_dev_t *);
-typedef errno_t (*irq_code_gen_t)(irq_code_t *, const hw_res_list_parsed_t *, int *);
+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;
+errno_t hcd_ddf_setup_hc(ddf_dev_t *, size_t);
+void hcd_ddf_clean_hc(hc_device_t *);
-errno_t hcd_ddf_add_hc(ddf_dev_t *device, const ddf_hc_driver_t *driver);
+errno_t 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);
+errno_t hcd_ddf_setup_root_hub(ddf_dev_t *device);
+device_t *hcd_ddf_fun_create(hc_device_t *, usb_speed_t);
+void hcd_ddf_fun_destroy(device_t *);
 hcd_t *dev_to_hcd(ddf_dev_t *dev);
+errno_t hcd_ddf_setup_match_ids(device_t *, usb_standard_device_descriptor_t *);
+errno_t hcd_ddf_enable_interrupt(ddf_dev_t *device, int);
+errno_t hcd_ddf_get_registers(ddf_dev_t *device, hw_res_list_parsed_t *hw_res);
+errno_t hcd_ddf_setup_interrupts(ddf_dev_t *device,
+    const hw_res_list_parsed_t *hw_res,
+    interrupt_handler_t handler,
+    errno_t (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *, int *),
+    cap_handle_t *handle);
+void ddf_hcd_gen_irq_handler(ipc_call_t *call, ddf_dev_t *dev);
+errno_t hcd_ddf_enable_interrupt(hc_device_t *hcd, int);
+errno_t hcd_ddf_get_registers(hc_device_t *hcd, hw_res_list_parsed_t *hw_res);
+void hcd_ddf_gen_irq_handler(ipc_callid_t iid, ipc_call_t *call, ddf_dev_t *dev);
 #endif

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 /** @file
+ *
+ * Endpoint structure is tightly coupled to the bus. The bus controls the
+ * life-cycle of endpoint. In order to keep endpoints lightweight, operations
+ * on endpoints are part of the bus structure.
+ *
  */
 #ifndef LIBUSBHOST_HOST_ENDPOINT_H
 #define LIBUSBHOST_HOST_ENDPOINT_H
+#include <adt/list.h>
+#include <atomic.h>
+#include <fibril_synch.h>
 #include <stdbool.h>
+#include <adt/list.h>
+#include <fibril_synch.h>
+#include <sys/time.h>
 #include <usb/usb.h>
+#include <atomic.h>
+#include <usb/host/bus.h>
+#include <usbhc_iface.h>
+/** Host controller side endpoint structure. */
+typedef struct bus bus_t;
+typedef struct device device_t;
+typedef struct transfer_request transfer_request_t;
+typedef struct usb_transfer_batch usb_transfer_batch_t;
+/**
+ * Host controller side endpoint structure.
+ *
+ * This structure, though reference-counted, is very fragile. It is responsible
+ * for synchronizing transfer batch scheduling and completion.
+ *
+ * To avoid situations, in which two locks must be obtained to schedule/finish
+ * a transfer, the endpoint inherits a lock from the outside. Because the
+ * concrete instance of mutex can be unknown at the time of initialization,
+ * the HC shall pass the right lock at the time of onlining the endpoint.
+ *
+ * The fields used for scheduling (online, active_batch) are to be used only
+ * under that guard and by functions designed for this purpose. The driver can
+ * also completely avoid using this mechanism, in which case it is on its own in
+ * question of transfer aborting.
+ *
+ * Relevant information can be found in the documentation of HelenOS xHCI
+ * project.
+ */
 typedef struct endpoint {
+        /** USB device */
+        device_t *device;
         /** Reference count. */
+        atomic_t refcnt;
+        /** Part of linked list. */
+        link_t link;
+        /** USB address. */
+        usb_address_t address;
+        /** USB endpoint number. */
+        atomic_t refcnt;
+        /** An inherited guard */
+        fibril_mutex_t *guard;
+        /** Whether it's allowed to schedule on this endpoint */
+        bool online;
+        /** The currently active transfer batch. */
+        usb_transfer_batch_t *active_batch;
+        /** Signals change of active status. */
+        fibril_condvar_t avail;
+        /** Endpoint number */
         usb_endpoint_t endpoint;
         /** Communication direction. */
 …
         /** USB transfer type. */
         usb_transfer_type_t transfer_type;
+        /** Communication speed. */
+        usb_speed_t speed;
+        /** Maximum size of data packets. */
+        /** Maximum size of one packet */
         size_t max_packet_size;
+        /** Additional opportunities per uframe */
+        unsigned packets;
+        /** Necessary bandwidth. */
+        size_t bandwidth;
+        /** Value of the toggle bit. */
+        unsigned toggle:1;
+        /** True if there is a batch using this scheduled for this endpoint. */
+        volatile bool active;
+        /** Protects resources and active status changes. */
+        fibril_mutex_t guard;
+        /** 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 {
+                /** Device specific data. */
+                void *data;
+                /** Callback to get the value of toggle bit. */
+                int (*toggle_get)(void *);
+                /** Callback to set the value of toggle bit. */
+                void (*toggle_set)(void *, int);
+        } hc_data;
+        /** Maximum size of one transfer */
+        size_t max_transfer_size;
+        /* Policies for transfer buffers */
+        /** A hint for optimal performance. */
+        dma_policy_t transfer_buffer_policy;
+        /** Enforced by the library. */
+        dma_policy_t required_transfer_buffer_policy;
+        /**
+         * Number of packets that can be sent in one service interval
+         * (not necessarily uframe, despite its name)
+         */
+        unsigned packets_per_uframe;
+        /* This structure is meant to be extended by overriding. */
 } endpoint_t;
+extern endpoint_t *endpoint_create(usb_address_t, usb_endpoint_t,
+    usb_direction_t, usb_transfer_type_t, usb_speed_t, size_t, unsigned int,
+    size_t, usb_address_t, unsigned int);
+extern void endpoint_destroy(endpoint_t *);
+extern void endpoint_init(endpoint_t *, device_t *,
+    const usb_endpoint_descriptors_t *);
 extern void endpoint_add_ref(endpoint_t *);
 extern void endpoint_del_ref(endpoint_t *);
+extern void endpoint_set_hc_data(endpoint_t *, void *, int (*)(void *),
+    void (*)(void *, int));
+extern void endpoint_clear_hc_data(endpoint_t *);
+extern void endpoint_set_online(endpoint_t *, fibril_mutex_t *);
+extern void endpoint_set_offline_locked(endpoint_t *);
+extern void endpoint_use(endpoint_t *);
+extern void endpoint_release(endpoint_t *);
+extern void endpoint_wait_timeout_locked(endpoint_t *ep, suseconds_t);
+extern int endpoint_activate_locked(endpoint_t *, usb_transfer_batch_t *);
+extern void endpoint_deactivate_locked(endpoint_t *);
+extern int endpoint_toggle_get(endpoint_t *);
+extern void endpoint_toggle_set(endpoint_t *, int);
+int endpoint_send_batch(endpoint_t *, const transfer_request_t *);
+/** list_get_instance wrapper.
+ *
+ * @param item Pointer to link member.
+ *
+ * @return Pointer to endpoint_t structure.
+ *
+ */
+static inline endpoint_t * endpoint_get_instance(link_t *item)
+static inline bus_t *endpoint_get_bus(endpoint_t *ep)
+{
+        return item ? list_get_instance(item, endpoint_t, link) : NULL;
+        device_t * const device = ep->device;
+        return device ? device->bus : NULL;
+}
 #endif

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 #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 <ddf/driver.h>
+#include <usb/request.h>
+#include <assert.h>
+#include <usbhc_iface.h>
+#include <stddef.h>
+#include <stdint.h>
+typedef struct hw_resource_list_parsed hw_res_list_parsed_t;
+typedef struct bus bus_t;
+typedef struct device device_t;
+typedef struct hcd hcd_t;
+/* Treat this header as read-only in driver code.
+ * It could be opaque, but why to complicate matters.
+ */
+typedef struct hc_device {
+        /* Bus instance */
+        bus_t *bus;
+typedef errno_t (*schedule_hook_t)(hcd_t *, usb_transfer_batch_t *);
+typedef errno_t (*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 errno_t (*status_hook_t)(hcd_t *, uint32_t *);
+        /* Managed DDF device */
+        ddf_dev_t *ddf_dev;
+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;
+        /* Control function */
+        ddf_fun_t *ctl_fun;
+/** Generic host controller driver structure. */
+struct hcd {
+        /** Endpoint manager. */
+        usb_bus_t bus;
+        /* Result of enabling HW IRQs */
+        int irq_cap;
         /** Interrupt replacement fibril */
         fid_t polling_fibril;
+        /** Driver implementation */
+        hcd_ops_t ops;
+        /** Device specific driver data. */
+        void * driver_data;
+};
+        /* This structure is meant to be extended by driver code. */
+} hc_device_t;
+extern void hcd_init(hcd_t *, usb_speed_t, size_t, bw_count_func_t);
+typedef struct hc_driver {
+        const char *name;
+static inline void hcd_set_implementation(hcd_t *hcd, void *data,
+    const hcd_ops_t *ops)
+        /** Size of the device data to be allocated, and passed as the
+         * hc_device_t. */
+        size_t hc_device_size;
+        /** Initialize device structures. */
+        int (*hc_add)(hc_device_t *, const hw_res_list_parsed_t *);
+        /** Generate IRQ code to handle interrupts. */
+        int (*irq_code_gen)(irq_code_t *, hc_device_t *,
+            const hw_res_list_parsed_t *, int *);
+        /** Claim device from BIOS. */
+        int (*claim)(hc_device_t *);
+        /** Start the host controller. */
+        int (*start)(hc_device_t *);
+        /** Setup the virtual roothub. */
+        int (*setup_root_hub)(hc_device_t *);
+        /** Stop the host controller (after start has been called) */
+        int (*stop)(hc_device_t *);
+        /** HC was asked to be removed (after hc_add has been called) */
+        int (*hc_remove)(hc_device_t *);
+        /** HC is gone. */
+        int (*hc_gone)(hc_device_t *);
+} hc_driver_t;
+/* Drivers should call this before leaving hc_add */
+static inline void hc_device_setup(hc_device_t *hcd, bus_t *bus)
+{
+        assert(hcd);
+        if (ops) {
+                hcd->driver_data = data;
+                hcd->ops = *ops;
+        } else {
+                memset(&hcd->ops, 0, sizeof(hcd->ops));
+        }
+        hcd->bus = bus;
+}
 static inline void * hcd_get_driver_data(hcd_t *hcd)
+static inline hc_device_t *dev_to_hcd(ddf_dev_t *dev)
+{
+        assert(hcd);
+        return hcd->driver_data;
+        return ddf_dev_data_get(dev);
+}
+extern errno_t hcd_request_address(hcd_t *, usb_speed_t, usb_address_t *);
+extern errno_t hcd_release_address(hcd_t *, usb_address_t);
+extern errno_t hcd_reserve_default_address(hcd_t *, usb_speed_t);
+static inline errno_t hcd_release_default_address(hcd_t *hcd)
+{
+        return hcd_release_address(hcd, USB_ADDRESS_DEFAULT);
+}
+extern errno_t hcd_add_ep(hcd_t *, usb_target_t, usb_direction_t,
+    usb_transfer_type_t, size_t, unsigned int, size_t, usb_address_t,
+    unsigned int);
+extern errno_t hcd_remove_ep(hcd_t *, usb_target_t, usb_direction_t);
+extern errno_t hcd_send_batch(hcd_t *, usb_target_t, usb_direction_t, void *,
+    size_t, uint64_t, usbhc_iface_transfer_in_callback_t,
+    usbhc_iface_transfer_out_callback_t, void *, const char *);
+extern errno_t hcd_send_batch_sync(hcd_t *, usb_target_t, usb_direction_t,
+    void *, size_t, uint64_t, const char *, size_t *);
+extern errno_t hc_driver_main(const hc_driver_t *);
 #endif

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

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 #define LIBUSBHOST_HOST_USB_TRANSFER_BATCH_H
+#include <usb/host/endpoint.h>
+#include <usb/usb.h>
+#include <assert.h>
+#include <atomic.h>
+#include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <usb/dma_buffer.h>
+#include <usb/request.h>
+#include <usb/usb.h>
 #include <usbhc_iface.h>
+#define USB_SETUP_PACKET_SIZE 8
+#include <usb/host/hcd.h>
+#include <usb/host/endpoint.h>
+#include <usb/host/bus.h>
+typedef struct endpoint endpoint_t;
+typedef struct bus bus_t;
 /** Structure stores additional data needed for communication with EP */
 typedef struct usb_transfer_batch {
+        /** Target for communication */
+        usb_target_t target;
+        /** Direction of the transfer */
+        usb_direction_t dir;
         /** Endpoint used for communication */
         endpoint_t *ep;
+        /** Function called on completion (IN version) */
+        usbhc_iface_transfer_in_callback_t callback_in;
+        /** Function called on completion (OUT version) */
+        usbhc_iface_transfer_out_callback_t callback_out;
+        /** Argument to pass to the completion function */
+        void *arg;
+        /** Place for data to send/receive */
+        char *buffer;
+        /** Size of memory pointed to by buffer member */
+        size_t buffer_size;
         /** Place to store SETUP data needed by control transfers */
+        char setup_buffer[USB_SETUP_PACKET_SIZE];
+        /** Used portion of setup_buffer member
+         *
+         * SETUP buffer must be 8 bytes for control transfers and is left
+         * unused for all other transfers. Thus, this field is either 0 or 8.
+        union {
+                char buffer [USB_SETUP_PACKET_SIZE];
+                usb_device_request_setup_packet_t packet;
+                uint64_t packed;
+        } setup;
+        /** DMA buffer with enforced policy */
+        dma_buffer_t dma_buffer;
+        /** Size of memory buffer */
+        size_t offset, size;
+        /**
+         * In case a bounce buffer is allocated, the original buffer must to be
+         * stored to be filled after the IN transaction is finished.
          */
+        size_t setup_size;
+        char *original_buffer;
+        bool is_bounced;
+        /** Actually used portion of the buffer
+         * This member is never accessed by functions provided in this header,
+         * with the exception of usb_transfer_batch_finish. For external use.
+         */
+        size_t transfered_size;
+        /** Indicates success/failure of the communication
+         * This member is never accessed by functions provided in this header,
+         * with the exception of usb_transfer_batch_finish. For external use.
+         */
+        /** Indicates success/failure of the communication */
         errno_t error;
+        /** Actually used portion of the buffer */
+        size_t transferred_size;
+        /** Function called on completion */
+        usbhc_iface_transfer_callback_t on_complete;
+        /** Arbitrary data for the handler */
+        void *on_complete_data;
 } usb_transfer_batch_t;
+/** Printf formatting string for dumping usb_transfer_batch_t. */
+/**
+ * Printf formatting string for dumping usb_transfer_batch_t.
+ *  [address:endpoint speed transfer_type-direction buffer_sizeB/max_packet_size]
+ * */
 #define USB_TRANSFER_BATCH_FMT "[%d:%d %s %s-%s %zuB/%zu]"
 …
  */
 #define USB_TRANSFER_BATCH_ARGS(batch) \
         (batch).ep->address, (batch).ep->endpoint, \
         usb_str_speed((batch).ep->speed), \
+        ((batch).ep->device->address), ((batch).ep->endpoint), \
+        usb_str_speed((batch).ep->device->speed), \
         usb_str_transfer_type_short((batch).ep->transfer_type), \
         usb_str_direction((batch).ep->direction), \
         (batch).buffer_size, (batch).ep->max_packet_size
+        usb_str_direction((batch).dir), \
+        (batch).size, (batch).ep->max_packet_size
+/** Wrapper for bus operation. */
+usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *);
+usb_transfer_batch_t * usb_transfer_batch_create(
+    endpoint_t *ep,
+    char *buffer,
+    size_t buffer_size,
+    uint64_t setup_buffer,
+    usbhc_iface_transfer_in_callback_t func_in,
+    usbhc_iface_transfer_out_callback_t func_out,
+    void *arg
+);
+void usb_transfer_batch_destroy(usb_transfer_batch_t *instance);
+/** Batch initializer. */
+void usb_transfer_batch_init(usb_transfer_batch_t *, endpoint_t *);
+void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance,
+    const void* data, size_t size, errno_t error);
+/** Buffer handling */
+bool usb_transfer_batch_bounce_required(usb_transfer_batch_t *);
+errno_t usb_transfer_batch_bounce(usb_transfer_batch_t *);
+/** Finish batch using stored error value and transferred size.
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] data Data to copy to the output buffer.
+/** Batch finalization. */
+void usb_transfer_batch_finish(usb_transfer_batch_t *);
+/** To be called from outside only when the transfer is not going to be finished
+ * (i.o.w. until successfuly scheduling)
  */
+static inline void usb_transfer_batch_finish(
+    const usb_transfer_batch_t *instance, const void* data)
+{
+        assert(instance);
+        usb_transfer_batch_finish_error(
+            instance, data, instance->transfered_size, instance->error);
+}
+/** Determine batch direction based on the callbacks present
+ * @param[in] instance Batch structure to use, non-null.
+ * @return USB_DIRECTION_IN, or USB_DIRECTION_OUT.
+ */
+static inline usb_direction_t usb_transfer_batch_direction(
+    const usb_transfer_batch_t *instance)
+{
+        assert(instance);
+        if (instance->callback_in) {
+                assert(instance->callback_out == NULL);
+                assert(instance->ep == NULL
+                    || instance->ep->transfer_type == USB_TRANSFER_CONTROL
+                    || instance->ep->direction == USB_DIRECTION_IN);
+                return USB_DIRECTION_IN;
+        }
+        if (instance->callback_out) {
+                assert(instance->callback_in == NULL);
+                assert(instance->ep == NULL
+                    || instance->ep->transfer_type == USB_TRANSFER_CONTROL
+                    || instance->ep->direction == USB_DIRECTION_OUT);
+                return USB_DIRECTION_OUT;
+        }
+        assert(false);
+}
+void usb_transfer_batch_destroy(usb_transfer_batch_t *);
 #endif

uspace/lib/usbhost/src/ddf_helpers.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2013 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty, Michal Staruch, Petr Manek
  * All rights reserved.
+ *
 …
  */
 /** @file
+ *
+ */
+#include <usb/classes/classes.h>
+#include <usb/debug.h>
+#include <usb/descriptor.h>
+#include <usb/request.h>
+#include <usb/usb.h>
+ * Helpers to work with the DDF interface.
+ */
 #include <adt/list.h>
 …
 #include <device/hw_res_parsed.h>
 #include <errno.h>
-#include <fibril_synch.h>
-#include <macros.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <str_error.h>
+#include <usb/classes/classes.h>
+#include <usb/debug.h>
+#include <usb/descriptor.h>
+#include <usb/usb.h>
+#include <usb/dma_buffer.h>
 #include <usb_iface.h>
+#include <usbhc_iface.h>
+#include "bus.h"
+#include "endpoint.h"
 #include "ddf_helpers.h"
+#define CTRL_PIPE_MIN_PACKET_SIZE 8
+typedef struct usb_dev {
+        link_t link;
+        list_t devices;
+        fibril_mutex_t guard;
+        ddf_fun_t *fun;
+        usb_address_t address;
+        usb_speed_t speed;
+        usb_address_t tt_address;
+        unsigned port;
+} usb_dev_t;
+typedef struct hc_dev {
+        ddf_fun_t *ctl_fun;
+        hcd_t hcd;
+        usb_dev_t *root_hub;
+} hc_dev_t;
+static hc_dev_t *dev_to_hc_dev(ddf_dev_t *dev)
+{
+        return ddf_dev_data_get(dev);
+}
+hcd_t *dev_to_hcd(ddf_dev_t *dev)
+{
+        hc_dev_t *hc_dev = dev_to_hc_dev(dev);
+        if (!hc_dev) {
+                usb_log_error("Invalid HCD device.\n");
+                return NULL;
+        }
+        return &hc_dev->hcd;
+}
+static errno_t hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
+static errno_t hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port);
+/* DDF INTERFACE */
+/** Register endpoint interface function.
+ * @param fun DDF function.
+ * @param address USB address of the device.
+ * @param endpoint USB endpoint number to be registered.
+ * @param transfer_type Endpoint's transfer type.
+ * @param direction USB communication direction the endpoint is capable of.
+ * @param max_packet_size Maximu size of packets the endpoint accepts.
+ * @param interval Preferred timeout between communication.
+/**
+ * DDF usbhc_iface callback. Passes the endpoint descriptors, fills the pipe
+ * descriptor according to the contents of the endpoint.
+ *
+ * @param[in] fun DDF function of the device in question.
+ * @param[out] pipe_desc The pipe descriptor to be filled.
+ * @param[in] endpoint_desc Endpoint descriptors from the device.
  * @return Error code.
  */
+static errno_t register_endpoint(
+    ddf_fun_t *fun, usb_endpoint_t endpoint,
+    usb_transfer_type_t transfer_type, usb_direction_t direction,
+    size_t max_packet_size, unsigned packets, unsigned interval)
+{
+        assert(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+static errno_t register_endpoint(ddf_fun_t *fun, usb_pipe_desc_t *pipe_desc,
+     const usb_endpoint_descriptors_t *ep_desc)
+{
+        assert(fun);
+        hc_device_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
         assert(hcd);
+        assert(hcd->bus);
         assert(dev);
+        const size_t size = max_packet_size;
+        const usb_target_t target =
+            {{.address = dev->address, .endpoint = endpoint}};
+        usb_log_debug("Register endpoint %d:%d %s-%s %zuB %ums.\n",
+            dev->address, endpoint, usb_str_transfer_type(transfer_type),
+            usb_str_direction(direction), max_packet_size, interval);
+        return hcd_add_ep(hcd, target, direction, transfer_type,
+            max_packet_size, packets, size, dev->tt_address, dev->port);
+}
+/** Unregister endpoint interface function.
+ * @param fun DDF function.
+ * @param address USB address of the endpoint.
+ * @param endpoint USB endpoint number.
+ * @param direction Communication direction of the enpdoint to unregister.
+        endpoint_t *ep;
+        const int err = bus_endpoint_add(dev, ep_desc, &ep);
+        if (err)
+                return err;
+        if (pipe_desc) {
+                pipe_desc->endpoint_no = ep->endpoint;
+                pipe_desc->direction = ep->direction;
+                pipe_desc->transfer_type = ep->transfer_type;
+                pipe_desc->max_transfer_size = ep->max_transfer_size;
+                pipe_desc->transfer_buffer_policy = ep->transfer_buffer_policy;
+        }
+        endpoint_del_ref(ep);
+        return EOK;
+}
+ /**
+  * DDF usbhc_iface callback. Unregister endpoint that makes the other end of
+  * the pipe described.
+  *
+  * @param fun DDF function of the device in question.
+  * @param pipe_desc Pipe description.
+  * @return Error code.
+  */
+static errno_t unregister_endpoint(ddf_fun_t *fun, const usb_pipe_desc_t *pipe_desc)
+{
+        assert(fun);
+        hc_device_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(hcd);
+        assert(hcd->bus);
+        assert(dev);
+        endpoint_t *ep = bus_find_endpoint(dev, pipe_desc->endpoint_no, pipe_desc->direction);
+        if (!ep)
+                return ENOENT;
+        const errno_t err = bus_endpoint_remove(ep);
+        endpoint_del_ref(ep);
+        return err;
+}
+/**
+ * DDF usbhc_iface callback. Calls the respective bus operation directly.
+ *
+ * @param fun DDF function of the device (hub) requesting the address.
+ */
+static errno_t default_address_reservation(ddf_fun_t *fun, bool reserve)
+{
+        assert(fun);
+        hc_device_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(hcd);
+        assert(hcd->bus);
+        assert(dev);
+        usb_log_debug("Device %d %s default address", dev->address, reserve ? "requested" : "releasing");
+        if (reserve) {
+                return bus_reserve_default_address(hcd->bus, dev);
+        } else {
+                bus_release_default_address(hcd->bus, dev);
+                return EOK;
+        }
+}
+/**
+ * DDF usbhc_iface callback. Calls the bus operation directly.
+ *
+ * @param fun DDF function of the device (hub) requesting the address.
+ * @param speed USB speed of the new device
+ */
+static errno_t device_enumerate(ddf_fun_t *fun, unsigned port, usb_speed_t speed)
+{
+        assert(fun);
+        ddf_dev_t *hc = ddf_fun_get_dev(fun);
+        assert(hc);
+        hc_device_t *hcd = dev_to_hcd(hc);
+        assert(hcd);
+        device_t *hub = ddf_fun_data_get(fun);
+        assert(hub);
+        errno_t err;
+        if (!usb_speed_is_valid(speed))
+                return EINVAL;
+        usb_log_debug("Hub %d reported a new %s speed device on port: %u",
+            hub->address, usb_str_speed(speed), port);
+        device_t *dev = hcd_ddf_fun_create(hcd, speed);
+        if (!dev) {
+                usb_log_error("Failed to create USB device function.");
+                return ENOMEM;
+        }
+        dev->hub = hub;
+        dev->tier = hub->tier + 1;
+        dev->port = port;
+        dev->speed = speed;
+        if ((err = bus_device_enumerate(dev))) {
+                usb_log_error("Failed to initialize USB dev memory structures.");
+                goto err_usb_dev;
+        }
+        /* If the driver didn't name the dev when enumerating,
+         * do it in some generic way.
+         */
+        if (!ddf_fun_get_name(dev->fun)) {
+                bus_device_set_default_name(dev);
+        }
+        if ((err = ddf_fun_bind(dev->fun))) {
+                usb_log_error("Device(%d): Failed to register: %s.", dev->address, str_error(err));
+                goto err_usb_dev;
+        }
+        return EOK;
+err_usb_dev:
+        hcd_ddf_fun_destroy(dev);
+        return err;
+}
+static errno_t device_remove(ddf_fun_t *fun, unsigned port)
+{
+        assert(fun);
+        device_t *hub = ddf_fun_data_get(fun);
+        assert(hub);
+        usb_log_debug("Hub `%s' reported removal of device on port %u",
+            ddf_fun_get_name(fun), port);
+        device_t *victim = NULL;
+        fibril_mutex_lock(&hub->guard);
+        list_foreach(hub->devices, link, device_t, it) {
+                if (it->port == port) {
+                        victim = it;
+                        break;
+                }
+        }
+        fibril_mutex_unlock(&hub->guard);
+        if (!victim) {
+                usb_log_warning("Hub '%s' tried to remove non-existent"
+                    " device.", ddf_fun_get_name(fun));
+                return ENOENT;
+        }
+        assert(victim->fun);
+        assert(victim->port == port);
+        assert(victim->hub == hub);
+        bus_device_gone(victim);
+        return EOK;
+}
+/**
+ * Gets description of the device that is calling.
+ *
+ * @param[in] fun Device function.
+ * @param[out] desc Device descriptor to be filled.
  * @return Error code.
  */
+static errno_t unregister_endpoint(
+    ddf_fun_t *fun, usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(hcd);
+static errno_t get_device_description(ddf_fun_t *fun, usb_device_desc_t *desc)
+{
+        assert(fun);
+        device_t *dev = ddf_fun_data_get(fun);
         assert(dev);
+        const usb_target_t target =
+            {{.address = dev->address, .endpoint = endpoint}};
+        usb_log_debug("Unregister endpoint %d:%d %s.\n",
+            dev->address, endpoint, usb_str_direction(direction));
+        return hcd_remove_ep(hcd, target, direction);
+}
+static errno_t reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
+{
+        assert(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(hcd);
+        assert(dev);
+        usb_log_debug("Device %d requested default address at %s speed\n",
+            dev->address, usb_str_speed(speed));
+        return hcd_reserve_default_address(hcd, speed);
+}
+static errno_t release_default_address(ddf_fun_t *fun)
+{
+        assert(fun);
+        hcd_t *hcd = dev_to_hcd(ddf_fun_get_dev(fun));
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(hcd);
+        assert(dev);
+        usb_log_debug("Device %d released default address\n", dev->address);
+        return hcd_release_default_address(hcd);
+}
+static errno_t device_enumerate(ddf_fun_t *fun, unsigned port)
+{
+        assert(fun);
+        ddf_dev_t *ddf_dev = ddf_fun_get_dev(fun);
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(ddf_dev);
+        assert(dev);
+        usb_log_debug("Hub %d reported a new USB device on port: %u\n",
+            dev->address, port);
+        return hcd_ddf_new_device(ddf_dev, dev, port);
+}
+static errno_t device_remove(ddf_fun_t *fun, unsigned port)
+{
+        assert(fun);
+        ddf_dev_t *ddf_dev = ddf_fun_get_dev(fun);
+        usb_dev_t *dev = ddf_fun_data_get(fun);
+        assert(ddf_dev);
+        assert(dev);
+        usb_log_debug("Hub `%s' reported removal of device on port %u\n",
+            ddf_fun_get_name(fun), port);
+        return hcd_ddf_remove_device(ddf_dev, dev, port);
+}
+/** Gets handle of the respective device.
+ *
+ * @param[in] fun Device function.
+ * @param[out] handle Place to write the handle.
+ * @return Error code.
+ */
+static errno_t get_my_device_handle(ddf_fun_t *fun, devman_handle_t *handle)
+{
+        assert(fun);
+        if (handle)
+                *handle = ddf_fun_get_handle(fun);
+        return EOK;
+}
+/** Inbound communication interface function.
+        if (!desc)
+                return EOK;
+        *desc = (usb_device_desc_t) {
+                .address = dev->address,
+                .depth = dev->tier,
+                .speed = dev->speed,
+                .handle = ddf_fun_get_handle(fun),
+                .iface = -1,
+        };
+        return EOK;
+}
+/**
+ * Transfer issuing interface function.
+ *
  * @param fun DDF function.
  * @param target Communication target.
+ * @param dir Communication direction.
  * @param setup_data Data to use in setup stage (control transfers).
  * @param data Pointer to data buffer.
 …
  * @return Error code.
  */
+static errno_t dev_read(ddf_fun_t *fun, usb_endpoint_t endpoint,
+    uint64_t setup_data, uint8_t *data, size_t size,
+    usbhc_iface_transfer_in_callback_t callback, void *arg)
+{
+        assert(fun);
+        usb_dev_t *usb_dev = ddf_fun_data_get(fun);
+        assert(usb_dev);
+static errno_t transfer(ddf_fun_t *fun,
+    const usbhc_iface_transfer_request_t *ifreq,
+    usbhc_iface_transfer_callback_t callback, void *arg)
+{
+        assert(fun);
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
         const usb_target_t target = {{
+            .address =  usb_dev->address,
+            .endpoint = endpoint,
+                .address = dev->address,
+                .endpoint = ifreq->endpoint,
+                .stream = ifreq->stream,
         }};
+        return hcd_send_batch(dev_to_hcd(ddf_fun_get_dev(fun)), target,
+            USB_DIRECTION_IN, data, size, setup_data, callback, NULL, arg,
+            "READ");
+}
+/** Outbound communication interface function.
+ * @param fun DDF function.
+ * @param target Communication target.
+ * @param setup_data Data to use in setup stage (control transfers).
+ * @param data Pointer to data buffer.
+ * @param size Size of the data buffer.
+ * @param callback Function to call on communication end.
+ * @param arg Argument passed to the callback function.
+ * @return Error code.
+ */
+static errno_t dev_write(ddf_fun_t *fun, usb_endpoint_t endpoint,
+    uint64_t setup_data, const uint8_t *data, size_t size,
+    usbhc_iface_transfer_out_callback_t callback, void *arg)
+{
+        assert(fun);
+        usb_dev_t *usb_dev = ddf_fun_data_get(fun);
+        assert(usb_dev);
+        const usb_target_t target = {{
+            .address =  usb_dev->address,
+            .endpoint = endpoint,
+        }};
+        return hcd_send_batch(dev_to_hcd(ddf_fun_get_dev(fun)),
+            target, USB_DIRECTION_OUT, (uint8_t*)data, size, setup_data, NULL,
+            callback, arg, "WRITE");
+        if (!usb_target_is_valid(&target))
+                return EINVAL;
+        if (ifreq->offset > 0 && ifreq->size == 0)
+                return EINVAL;
+        if (ifreq->size > 0 && !dma_buffer_is_set(&ifreq->buffer))
+                return EBADMEM;
+        if (!callback && arg)
+                return EBADMEM;
+        const transfer_request_t request = {
+                .target = target,
+                .dir = ifreq->dir,
+                .buffer = ifreq->buffer,
+                .offset = ifreq->offset,
+                .size = ifreq->size,
+                .setup = ifreq->setup,
+                .on_complete = callback,
+                .arg = arg,
+                .name = (ifreq->dir == USB_DIRECTION_IN) ? "READ" : "WRITE",
+        };
+        return bus_issue_transfer(dev, &request);
+}
 /** USB device interface */
 static usb_iface_t usb_iface = {
+        .get_my_device_handle = get_my_device_handle,
+        .reserve_default_address = reserve_default_address,
+        .release_default_address = release_default_address,
+        .get_my_description = get_device_description,
+};
+/** USB host controller interface */
+static usbhc_iface_t usbhc_iface = {
+        .default_address_reservation = default_address_reservation,
         .device_enumerate = device_enumerate,
 …
         .unregister_endpoint = unregister_endpoint,
+        .read = dev_read,
+        .write = dev_write,
+        .transfer = transfer,
 };
 …
 static ddf_dev_ops_t usb_ops = {
         .interfaces[USB_DEV_IFACE] = &usb_iface,
+        .interfaces[USBHC_DEV_IFACE] = &usbhc_iface,
 };
 /* DDF HELPERS */
-#define GET_DEVICE_DESC(size) \
-{ \
-        .request_type = SETUP_REQUEST_TYPE_DEVICE_TO_HOST \
-            | (USB_REQUEST_TYPE_STANDARD << 5) \
-            | USB_REQUEST_RECIPIENT_DEVICE, \
-        .request = USB_DEVREQ_GET_DESCRIPTOR, \
-        .value = uint16_host2usb(USB_DESCTYPE_DEVICE << 8), \
-        .index = uint16_host2usb(0), \
-        .length = uint16_host2usb(size), \
-};
-#define SET_ADDRESS(address) \
-{ \
-        .request_type = SETUP_REQUEST_TYPE_HOST_TO_DEVICE \
-            | (USB_REQUEST_TYPE_STANDARD << 5) \
-            | USB_REQUEST_RECIPIENT_DEVICE, \
-        .request = USB_DEVREQ_SET_ADDRESS, \
-        .value = uint16_host2usb(address), \
-        .index = uint16_host2usb(0), \
-        .length = uint16_host2usb(0), \
-};
-static errno_t hcd_ddf_add_device(ddf_dev_t *parent, usb_dev_t *hub_dev,
-    unsigned port, usb_address_t address, usb_speed_t speed, const char *name,
-    const match_id_list_t *mids)
+{
-        assert(parent);
-        char default_name[10] = { 0 }; /* usbxyz-ss */
-        if (!name) {
-                snprintf(default_name, sizeof(default_name) - 1,
-                    "usb%u-%cs", address, usb_str_speed(speed)[0]);
-                name = default_name;
+        }
-        ddf_fun_t *fun = ddf_fun_create(parent, fun_inner, name);
-        if (!fun)
-                return ENOMEM;
-        usb_dev_t *info = ddf_fun_data_alloc(fun, sizeof(usb_dev_t));
-        if (!info) {
-                ddf_fun_destroy(fun);
-                return ENOMEM;
+        }
-        info->address = address;
-        info->speed = speed;
-        info->fun = fun;
-        info->port = port;
-        info->tt_address = hub_dev ? hub_dev->tt_address : -1;
-        link_initialize(&info->link);
-        list_initialize(&info->devices);
-        fibril_mutex_initialize(&info->guard);
-        if (hub_dev && hub_dev->speed == USB_SPEED_HIGH && usb_speed_is_11(speed))
-                info->tt_address = hub_dev->address;
-        ddf_fun_set_ops(fun, &usb_ops);
-        list_foreach(mids->ids, link, const match_id_t, mid) {
-                ddf_fun_add_match_id(fun, mid->id, mid->score);
+        }
-        errno_t ret = ddf_fun_bind(fun);
-        if (ret != EOK) {
-                ddf_fun_destroy(fun);
-                return ret;
+        }
-        if (hub_dev) {
-                fibril_mutex_lock(&hub_dev->guard);
-                list_append(&info->link, &hub_dev->devices);
-                fibril_mutex_unlock(&hub_dev->guard);
-        } else {
-                hc_dev_t *hc_dev = dev_to_hc_dev(parent);
-                assert(hc_dev->root_hub == NULL);
-                hc_dev->root_hub = info;
+        }
-        return EOK;
+}
 #define ADD_MATCHID_OR_RETURN(list, sc, str, ...) \
 …
         assert(l);
         assert(d);
         if (d->vendor_id != 0) {
                 /* First, with release number. */
 …
                     d->vendor_id, d->product_id, (d->device_version >> 8),
                     (d->device_version & 0xff));
                 /* Next, without release number. */
                 ADD_MATCHID_OR_RETURN(l, 90, "usb&vendor=%#04x&product=%#04x",
 …
         return EOK;
+}
+static errno_t hcd_ddf_remove_device(ddf_dev_t *device, usb_dev_t *hub,
+    unsigned port)
+{
+        assert(device);
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+        hc_dev_t *hc_dev = dev_to_hc_dev(device);
+        assert(hc_dev);
+        fibril_mutex_lock(&hub->guard);
+        usb_dev_t *victim = NULL;
+        list_foreach(hub->devices, link, usb_dev_t, it) {
+                if (it->port == port) {
+                        victim = it;
+                        break;
+                }
+        }
+        if (victim) {
+                assert(victim->port == port);
+                list_remove(&victim->link);
+                fibril_mutex_unlock(&hub->guard);
+                const errno_t ret = ddf_fun_unbind(victim->fun);
+                if (ret == EOK) {
+                        usb_address_t address = victim->address;
+                        ddf_fun_destroy(victim->fun);
+                        hcd_release_address(hcd, address);
+                } else {
+                        usb_log_warning("Failed to unbind device `%s': %s\n",
+                            ddf_fun_get_name(victim->fun), str_error(ret));
+                }
+                return EOK;
+        }
+        fibril_mutex_unlock(&hub->guard);
+        return ENOENT;
+}
+static errno_t hcd_ddf_new_device(ddf_dev_t *device, usb_dev_t *hub, unsigned port)
+{
+        assert(device);
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+        usb_speed_t speed = USB_SPEED_MAX;
+        /* This checks whether the default address is reserved and gets speed */
+        errno_t ret = usb_bus_get_speed(&hcd->bus, USB_ADDRESS_DEFAULT, &speed);
+        if (ret != EOK) {
+                usb_log_error("Failed to verify speed: %s.", str_error(ret));
+                return ret;
+        }
+        usb_log_debug("Found new %s speed USB device.", usb_str_speed(speed));
+        static const usb_target_t default_target = {{
+                .address = USB_ADDRESS_DEFAULT,
+                .endpoint = 0,
+        }};
+        usb_address_t address;
+        ret = hcd_request_address(hcd, speed, &address);
+        if (ret != EOK) {
+                usb_log_error("Failed to reserve new address: %s.",
+                    str_error(ret));
+                return ret;
+        }
+        usb_log_debug("Reserved new address: %d\n", address);
+        const usb_target_t target = {{
+                .address = address,
+                .endpoint = 0,
+        }};
+        const usb_address_t tt_address = hub ? hub->tt_address : -1;
+        /* Add default pipe on default address */
+        usb_log_debug("Device(%d): Adding default target(0:0)\n", address);
+        ret = hcd_add_ep(hcd,
+            default_target, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            CTRL_PIPE_MIN_PACKET_SIZE, CTRL_PIPE_MIN_PACKET_SIZE, 1,
+            tt_address, port);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to add default target: %s.",
+                    address, str_error(ret));
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+        /* Get max packet size for default pipe */
+        usb_standard_device_descriptor_t desc = { 0 };
+        const usb_device_request_setup_packet_t get_device_desc_8 =
+            GET_DEVICE_DESC(CTRL_PIPE_MIN_PACKET_SIZE);
+        // TODO CALLBACKS
+        usb_log_debug("Device(%d): Requesting first 8B of device descriptor.",
+            address);
+        size_t got;
+        ret = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_IN,
+            &desc, CTRL_PIPE_MIN_PACKET_SIZE, *(uint64_t *)&get_device_desc_8,
+            "read first 8 bytes of dev descriptor", &got);
+        if (ret == EOK && got != CTRL_PIPE_MIN_PACKET_SIZE) {
+                ret = EOVERFLOW;
+        }
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to get 8B of dev descr: %s.",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+        /* Register EP on the new address */
+        usb_log_debug("Device(%d): Registering control EP.", address);
+        ret = hcd_add_ep(hcd, target, USB_DIRECTION_BOTH, USB_TRANSFER_CONTROL,
+            ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)),
+            ED_MPS_TRANS_OPPORTUNITIES_GET(uint16_usb2host(desc.max_packet_size)),
+            ED_MPS_PACKET_SIZE_GET(uint16_usb2host(desc.max_packet_size)),
+            tt_address, port);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to register EP0: %s",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+        /* Set new address */
+        const usb_device_request_setup_packet_t set_address =
+            SET_ADDRESS(target.address);
+        usb_log_debug("Device(%d): Setting USB address.", address);
+        ret = hcd_send_batch_sync(hcd, default_target, USB_DIRECTION_OUT,
+            NULL, 0, *(uint64_t *)&set_address, "set address", &got);
+        usb_log_debug("Device(%d): Removing default (0:0) EP.", address);
+        hcd_remove_ep(hcd, default_target, USB_DIRECTION_BOTH);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to set new address: %s.",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, address);
+                return ret;
+        }
+        /* Get std device descriptor */
+        const usb_device_request_setup_packet_t get_device_desc =
+            GET_DEVICE_DESC(sizeof(desc));
+        usb_log_debug("Device(%d): Requesting full device descriptor.",
+            address);
+        ret = hcd_send_batch_sync(hcd, target, USB_DIRECTION_IN,
+            &desc, sizeof(desc), *(uint64_t *)&get_device_desc,
+            "read device descriptor", &got);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to set get dev descriptor: %s",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return ret;
+        }
+}
+device_t *hcd_ddf_fun_create(hc_device_t *hc, usb_speed_t speed)
+{
+        /* Create DDF function for the new device */
+        ddf_fun_t *fun = ddf_fun_create(hc->ddf_dev, fun_inner, NULL);
+        if (!fun)
+                return NULL;
+        ddf_fun_set_ops(fun, &usb_ops);
+        /* Create USB device node for the new device */
+        device_t *dev = ddf_fun_data_alloc(fun, hc->bus->device_size);
+        if (!dev) {
+                ddf_fun_destroy(fun);
+                return NULL;
+        }
+        bus_device_init(dev, hc->bus);
+        dev->fun = fun;
+        dev->speed = speed;
+        return dev;
+}
+void hcd_ddf_fun_destroy(device_t *dev)
+{
+        assert(dev);
+        assert(dev->fun);
+        ddf_fun_destroy(dev->fun);
+}
+errno_t hcd_ddf_setup_match_ids(device_t *device, usb_standard_device_descriptor_t *desc)
+{
+        errno_t err;
+        match_id_list_t mids;
+        init_match_ids(&mids);
         /* Create match ids from the device descriptor */
+        match_id_list_t mids;
+        init_match_ids(&mids);
+        usb_log_debug("Device(%d): Creating match IDs.", address);
+        ret = create_match_ids(&mids, &desc);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to create match ids: %s",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+                return ret;
+        }
+        /* Register device */
+        usb_log_debug("Device(%d): Registering DDF device.", address);
+        ret = hcd_ddf_add_device(device, hub, port, address, speed, NULL, &mids);
+        clean_match_ids(&mids);
+        if (ret != EOK) {
+                usb_log_error("Device(%d): Failed to register: %s.",
+                    address, str_error(ret));
+                hcd_remove_ep(hcd, target, USB_DIRECTION_BOTH);
+                hcd_release_address(hcd, target.address);
+        }
+        return ret;
+}
+/** Announce root hub to the DDF
+ *
+ * @param[in] device Host controller ddf device
+ * @return Error code
+ */
+errno_t hcd_ddf_setup_root_hub(ddf_dev_t *device)
+{
+        assert(device);
+        hcd_t *hcd = dev_to_hcd(device);
+        assert(hcd);
+        hcd_reserve_default_address(hcd, hcd->bus.max_speed);
+        const errno_t ret = hcd_ddf_new_device(device, NULL, 0);
+        hcd_release_default_address(hcd);
+        return ret;
+        usb_log_debug("Device(%d): Creating match IDs.", device->address);
+        if ((err = create_match_ids(&mids, desc))) {
+                return err;
+        }
+        list_foreach(mids.ids, link, const match_id_t, mid) {
+                ddf_fun_add_match_id(device->fun, mid->id, mid->score);
+        }
+        return EOK;
+}
 …
  * This function does all the ddf work for hc driver.
  */
+errno_t hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed,
+    size_t bw, bw_count_func_t bw_count)
+errno_t hcd_ddf_setup_hc(ddf_dev_t *device, size_t size)
+{
         assert(device);
         hc_dev_t *instance = ddf_dev_data_alloc(device, sizeof(hc_dev_t));
+        hc_device_t *instance = ddf_dev_data_alloc(device, size);
         if (instance == NULL) {
                 usb_log_error("Failed to allocate HCD ddf structure.\n");
+                usb_log_error("Failed to allocate HCD ddf structure.");
                 return ENOMEM;
+        }
+        instance->root_hub = NULL;
+        hcd_init(&instance->hcd, max_speed, bw, bw_count);
+        instance->ddf_dev = device;
         errno_t ret = ENOMEM;
         instance->ctl_fun = ddf_fun_create(device, fun_exposed, "ctl");
         if (!instance->ctl_fun) {
                 usb_log_error("Failed to create HCD ddf fun.\n");
+                usb_log_error("Failed to create HCD ddf fun.");
                 goto err_destroy_fun;
+        }
 …
         ret = ddf_fun_bind(instance->ctl_fun);
         if (ret != EOK) {
                 usb_log_error("Failed to bind ctl_fun: %s.\n", str_error(ret));
+                usb_log_error("Failed to bind ctl_fun: %s.", str_error(ret));
                 goto err_destroy_fun;
+        }
 …
         ret = ddf_fun_add_to_category(instance->ctl_fun, USB_HC_CATEGORY);
         if (ret != EOK) {
                 usb_log_error("Failed to add fun to category: %s.\n",
+                usb_log_error("Failed to add fun to category: %s.",
                     str_error(ret));
                 ddf_fun_unbind(instance->ctl_fun);
 …
+}
+void hcd_ddf_clean_hc(ddf_dev_t *device)
+{
+        assert(device);
+        hc_dev_t *hc = dev_to_hc_dev(device);
+        assert(hc);
+        const errno_t ret = ddf_fun_unbind(hc->ctl_fun);
+        if (ret == EOK)
+                ddf_fun_destroy(hc->ctl_fun);
+}
+//TODO: Cache parent session in HCD
+void hcd_ddf_clean_hc(hc_device_t *hcd)
+{
+        if (ddf_fun_unbind(hcd->ctl_fun) == EOK)
+                ddf_fun_destroy(hcd->ctl_fun);
+}
 /** Call the parent driver with a request to enable interrupt
+ *
 …
  * @return Error code.
  */
 errno_t hcd_ddf_enable_interrupt(ddf_dev_t *device, int inum)
+{
         async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
+errno_t hcd_ddf_enable_interrupt(hc_device_t *hcd, int inum)
+{
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
         if (parent_sess == NULL)
                 return EIO;
 …
+}
+//TODO: Cache parent session in HCD
+errno_t hcd_ddf_get_registers(ddf_dev_t *device, hw_res_list_parsed_t *hw_res)
+{
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(device);
+errno_t hcd_ddf_get_registers(hc_device_t *hcd, hw_res_list_parsed_t *hw_res)
+{
+        async_sess_t *parent_sess = ddf_dev_parent_sess_get(hcd->ddf_dev);
         if (parent_sess == NULL)
                 return EIO;
 …
+}
-// TODO: move this someplace else
-static inline void irq_code_clean(irq_code_t *code)
+{
-        if (code) {
-                free(code->ranges);
-                free(code->cmds);
-                code->ranges = NULL;
-                code->cmds = NULL;
-                code->rangecount = 0;
-                code->cmdcount = 0;
+        }
+}
-/** Register interrupt handler
+ *
- * @param[in] device Host controller DDF device
- * @param[in] regs Register range
- * @param[in] irq Interrupt number
- * @paran[in] handler Interrupt handler
- * @param[in] gen_irq_code IRQ code generator.
+ *
- * @param[out] handle  IRQ capability handle on success.
+ *
- * @return Error code.
- */
-errno_t hcd_ddf_setup_interrupts(ddf_dev_t *device,
-    const hw_res_list_parsed_t *hw_res,
-    interrupt_handler_t handler,
-    errno_t (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *, int *),
-    cap_handle_t *handle)
+{
-        assert(device);
-        if (!handler || !gen_irq_code)
-                return ENOTSUP;
-        irq_code_t irq_code = {0};
-        int irq;
-        errno_t ret = gen_irq_code(&irq_code, hw_res, &irq);
-        if (ret != EOK) {
-                usb_log_error("Failed to generate IRQ code: %s.\n",
-                    str_error(ret));
-                return ret;
+        }
-        /* Register handler to avoid interrupt lockup */
-        ret = register_interrupt_handler(device, irq, handler,
-            &irq_code, handle);
-        irq_code_clean(&irq_code);
-        if (ret != EOK) {
-                usb_log_error("Failed to register interrupt handler: %s.\n",
-                    str_error(ret));
-                return ret;
+        }
-        /* Enable interrupts */
-        ret = hcd_ddf_enable_interrupt(device, irq);
-        if (ret != EOK) {
-                usb_log_error("Failed to register interrupt handler: %s.\n",
-                    str_error(ret));
-                unregister_interrupt_handler(device, *handle);
+        }
-        return ret;
+}
-/** IRQ handling callback, forward status from call to diver structure.
+ *
- * @param[in] dev DDF instance of the device to use.
- * @param[in] call Pointer to the call from kernel.
- */
-void ddf_hcd_gen_irq_handler(ipc_call_t *call, ddf_dev_t *dev)
+{
-        assert(dev);
-        hcd_t *hcd = dev_to_hcd(dev);
-        if (!hcd || !hcd->ops.irq_hook) {
-                usb_log_error("Interrupt on not yet initialized device.\n");
-                return;
+        }
-        const uint32_t status = IPC_GET_ARG1(*call);
-        hcd->ops.irq_hook(hcd, status);
+}
-static errno_t interrupt_polling(void *arg)
+{
-        hcd_t *hcd = arg;
-        assert(hcd);
-        if (!hcd->ops.status_hook || !hcd->ops.irq_hook)
-                return ENOTSUP;
-        uint32_t status = 0;
-        while (hcd->ops.status_hook(hcd, &status) == EOK) {
-                hcd->ops.irq_hook(hcd, status);
-                status = 0;
-                /* We should wait 1 frame - 1ms here, but this polling is a
-                 * lame crutch anyway so don't hog the system. 10ms is still
-                 * good enough for emergency mode */
-                async_usleep(10000);
+        }
-        return EOK;
+}
-/** Initialize hc and rh DDF structures and their respective drivers.
+ *
- * @param device DDF instance of the device to use
- * @param speed Maximum supported speed
- * @param bw Available bandwidth (arbitrary units)
- * @param bw_count Bandwidth computing function
- * @param irq_handler IRQ handling function
- * @param gen_irq_code Function to generate IRQ pseudocode
- *                     (it needs to return used irq number)
- * @param driver_init Function to initialize HC driver
- * @param driver_fini Function to cleanup HC driver
- * @return Error code
+ *
- * This function does all the preparatory work for hc and rh drivers:
- *  - gets device's hw resources
- *  - attempts to enable interrupts
- *  - registers interrupt handler
- *  - calls driver specific initialization
- *  - registers root hub
- */
-errno_t hcd_ddf_add_hc(ddf_dev_t *device, const ddf_hc_driver_t *driver)
+{
-        assert(driver);
-        static const struct { size_t bw; bw_count_func_t bw_count; }bw[] = {
-            [USB_SPEED_FULL] = { .bw = BANDWIDTH_AVAILABLE_USB11,
-                                 .bw_count = bandwidth_count_usb11 },
-            [USB_SPEED_HIGH] = { .bw = BANDWIDTH_AVAILABLE_USB11,
-                                 .bw_count = bandwidth_count_usb11 },
-        };
-        errno_t ret = EOK;
-        const usb_speed_t speed = driver->hc_speed;
-        if (speed >= ARRAY_SIZE(bw) || bw[speed].bw == 0) {
-                usb_log_error("Driver `%s' reported unsupported speed: %s",
-                    driver->name, usb_str_speed(speed));
-                return ENOTSUP;
+        }
-        hw_res_list_parsed_t hw_res;
-        ret = hcd_ddf_get_registers(device, &hw_res);
-        if (ret != EOK) {
-                usb_log_error("Failed to get register memory addresses "
-                    "for `%s': %s.\n", ddf_dev_get_name(device),
-                    str_error(ret));
-                return ret;
+        }
-        ret = hcd_ddf_setup_hc(device, speed, bw[speed].bw, bw[speed].bw_count);
-        if (ret != EOK) {
-                usb_log_error("Failed to setup generic HCD.\n");
-                hw_res_list_parsed_clean(&hw_res);
-                return ret;
+        }
-        interrupt_handler_t *irq_handler =
-            driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
-        int irq_cap;
-        errno_t irq_ret = hcd_ddf_setup_interrupts(device, &hw_res,
-            irq_handler, driver->irq_code_gen, &irq_cap);
-        bool irqs_enabled = (irq_ret == EOK);
-        if (irqs_enabled) {
-                usb_log_debug("Hw interrupts enabled.\n");
+        }
-        if (driver->claim) {
-                ret = driver->claim(device);
-                if (ret != EOK) {
-                        usb_log_error("Failed to claim `%s' for driver `%s'",
-                            ddf_dev_get_name(device), driver->name);
-                        return ret;
+                }
+        }
-        /* Init hw driver */
-        hcd_t *hcd = dev_to_hcd(device);
-        ret = driver->init(hcd, &hw_res, irqs_enabled);
-        hw_res_list_parsed_clean(&hw_res);
-        if (ret != EOK) {
-                usb_log_error("Failed to init HCD: %s.\n", str_error(ret));
-                goto irq_unregister;
+        }
-        /* Need working irq replacement to setup root hub */
-        if (!irqs_enabled && hcd->ops.status_hook) {
-                hcd->polling_fibril = fibril_create(interrupt_polling, hcd);
-                if (hcd->polling_fibril == 0) {
-                        usb_log_error("Failed to create polling fibril\n");
-                        ret = ENOMEM;
-                        goto irq_unregister;
+                }
-                fibril_add_ready(hcd->polling_fibril);
-                usb_log_warning("Failed to enable interrupts: %s."
-                    " Falling back to polling.\n", str_error(irq_ret));
+        }
-        /*
-         * Creating root hub registers a new USB device so HC
-         * needs to be ready at this time.
-         */
-        ret = hcd_ddf_setup_root_hub(device);
-        if (ret != EOK) {
-                usb_log_error("Failed to setup HC root hub: %s.\n",
-                    str_error(ret));
-                driver->fini(dev_to_hcd(device));
-irq_unregister:
-                /* Unregistering non-existent should be ok */
-                unregister_interrupt_handler(device, irq_cap);
-                hcd_ddf_clean_hc(device);
-                return ret;
+        }
-        usb_log_info("Controlling new `%s' device `%s'.\n",
-            driver->name, ddf_dev_get_name(device));
-        return EOK;
+}
 /**
  * @}

uspace/lib/usbhost/src/endpoint.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
  */
-#include <usb/host/endpoint.h>
 #include <assert.h>
+#include <atomic.h>
+#include <mem.h>
 #include <stdlib.h>
+#include <atomic.h>
+/** Allocate ad initialize endpoint_t structure.
+ * @param address USB address.
+ * @param endpoint USB endpoint number.
+ * @param direction Communication direction.
+ * @param type USB transfer type.
+ * @param speed Communication speed.
+ * @param max_packet_size Maximum size of data packets.
+ * @param bw Required bandwidth.
+ * @return Pointer to initialized endpoint_t structure, NULL on failure.
+ */
+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, unsigned packets, size_t bw,
+    usb_address_t tt_address, unsigned tt_p)
+{
+        endpoint_t *instance = malloc(sizeof(endpoint_t));
+        if (instance) {
+                atomic_set(&instance->refcnt, 0);
+                instance->address = address;
+                instance->endpoint = endpoint;
+                instance->direction = direction;
+                instance->transfer_type = type;
+                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;
+                instance->hc_data.toggle_set = NULL;
+                link_initialize(&instance->link);
+                fibril_mutex_initialize(&instance->guard);
+                fibril_condvar_initialize(&instance->avail);
+        }
+        return instance;
+}
+/** Properly dispose of endpoint_t structure.
+ * @param instance endpoint_t structure.
+ */
+void endpoint_destroy(endpoint_t *instance)
+{
+        assert(instance);
+        assert(!instance->active);
+        assert(instance->hc_data.data == NULL);
+        free(instance);
+}
+void endpoint_add_ref(endpoint_t *instance)
+{
+        atomic_inc(&instance->refcnt);
+}
+void endpoint_del_ref(endpoint_t *instance)
+{
+        if (atomic_predec(&instance->refcnt) == 0)
+                endpoint_destroy(instance);
+}
+/** Set device specific data and hooks.
+ * @param instance endpoint_t structure.
+ * @param data device specific data.
+ * @param toggle_get Hook to call when retrieving value of toggle bit.
+ * @param toggle_set Hook to call when setting the value of toggle bit.
+ */
+void endpoint_set_hc_data(endpoint_t *instance,
+    void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int))
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->hc_data.data = data;
+        instance->hc_data.toggle_get = toggle_get;
+        instance->hc_data.toggle_set = toggle_set;
+        fibril_mutex_unlock(&instance->guard);
+}
+/** Clear device specific data and hooks.
+ * @param instance endpoint_t structure.
+ * @note This function does not free memory pointed to by data pointer.
+ */
+void endpoint_clear_hc_data(endpoint_t *instance)
+{
+        assert(instance);
+        endpoint_set_hc_data(instance, NULL, NULL, NULL);
+}
+/** Mark the endpoint as active and block access for further fibrils.
+ * @param instance endpoint_t structure.
+ */
+void endpoint_use(endpoint_t *instance)
+{
+        assert(instance);
+        /* Add reference for active endpoint. */
+        endpoint_add_ref(instance);
+        fibril_mutex_lock(&instance->guard);
+        while (instance->active)
+                fibril_condvar_wait(&instance->avail, &instance->guard);
+        instance->active = true;
+        fibril_mutex_unlock(&instance->guard);
+}
+/** Mark the endpoint as inactive and allow access for further fibrils.
+ * @param instance endpoint_t structure.
+ */
+void endpoint_release(endpoint_t *instance)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->active = false;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->avail);
+        /* Drop reference for active endpoint. */
+        endpoint_del_ref(instance);
+}
+/** Get the value of toggle bit.
+ * @param instance endpoint_t structure.
+ * @note Will use provided hook.
+ */
+int endpoint_toggle_get(endpoint_t *instance)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        if (instance->hc_data.toggle_get)
+                instance->toggle =
+                    instance->hc_data.toggle_get(instance->hc_data.data);
+        const int ret = instance->toggle;
+        fibril_mutex_unlock(&instance->guard);
+#include <str_error.h>
+#include <usb/debug.h>
+#include <usb/descriptor.h>
+#include <usb/host/hcd.h>
+#include <usb/host/utility.h>
+#include "usb_transfer_batch.h"
+#include "bus.h"
+#include "endpoint.h"
+/**
+ * Initialize provided endpoint structure.
+ */
+void endpoint_init(endpoint_t *ep, device_t *dev, const usb_endpoint_descriptors_t *desc)
+{
+        memset(ep, 0, sizeof(endpoint_t));
+        assert(dev);
+        ep->device = dev;
+        atomic_set(&ep->refcnt, 0);
+        fibril_condvar_initialize(&ep->avail);
+        ep->endpoint = USB_ED_GET_EP(desc->endpoint);
+        ep->direction = USB_ED_GET_DIR(desc->endpoint);
+        ep->transfer_type = USB_ED_GET_TRANSFER_TYPE(desc->endpoint);
+        ep->max_packet_size = USB_ED_GET_MPS(desc->endpoint);
+        ep->packets_per_uframe = USB_ED_GET_ADD_OPPS(desc->endpoint) + 1;
+        /** Direction both is our construct never present in descriptors */
+        if (ep->transfer_type == USB_TRANSFER_CONTROL)
+                ep->direction = USB_DIRECTION_BOTH;
+        ep->max_transfer_size = ep->max_packet_size * ep->packets_per_uframe;
+        ep->transfer_buffer_policy = DMA_POLICY_STRICT;
+        ep->required_transfer_buffer_policy = DMA_POLICY_STRICT;
+}
+/**
+ * Get the bus endpoint belongs to.
+ */
+static inline const bus_ops_t *get_bus_ops(endpoint_t *ep)
+{
+        return ep->device->bus->ops;
+}
+/**
+ * Increase the reference count on endpoint.
+ */
+void endpoint_add_ref(endpoint_t *ep)
+{
+        atomic_inc(&ep->refcnt);
+}
+/**
+ * Call the desctruction callback. Default behavior is to free the memory directly.
+ */
+static inline void endpoint_destroy(endpoint_t *ep)
+{
+        const bus_ops_t *ops = get_bus_ops(ep);
+        if (ops->endpoint_destroy) {
+                ops->endpoint_destroy(ep);
+        } else {
+                assert(ep->active_batch == NULL);
+                /* Assume mostly the eps will be allocated by malloc. */
+                free(ep);
+        }
+}
+/**
+ * Decrease the reference count.
+ */
+void endpoint_del_ref(endpoint_t *ep)
+{
+        if (atomic_predec(&ep->refcnt) == 0) {
+                endpoint_destroy(ep);
+        }
+}
+/**
+ * Mark the endpoint as online. Supply a guard to be used for this endpoint
+ * synchronization.
+ */
+void endpoint_set_online(endpoint_t *ep, fibril_mutex_t *guard)
+{
+        ep->guard = guard;
+        ep->online = true;
+}
+/**
+ * Mark the endpoint as offline. All other fibrils waiting to activate this
+ * endpoint will be interrupted.
+ */
+void endpoint_set_offline_locked(endpoint_t *ep)
+{
+        assert(ep);
+        assert(fibril_mutex_is_locked(ep->guard));
+        ep->online = false;
+        fibril_condvar_broadcast(&ep->avail);
+}
+/**
+ * Wait until a transfer finishes. Can be used even when the endpoint is
+ * offline (and is interrupted by the endpoint going offline).
+ */
+void endpoint_wait_timeout_locked(endpoint_t *ep, suseconds_t timeout)
+{
+        assert(ep);
+        assert(fibril_mutex_is_locked(ep->guard));
+        if (ep->active_batch == NULL)
+                return;
+        fibril_condvar_wait_timeout(&ep->avail, ep->guard, timeout);
+}
+/**
+ * Mark the endpoint as active and block access for further fibrils. If the
+ * endpoint is already active, it will block on ep->avail condvar.
+ *
+ * Call only under endpoint guard. After you activate the endpoint and release
+ * the guard, you must assume that particular transfer is already
+ * finished/aborted.
+ *
+ * Activation and deactivation is not done by the library to maximize
+ * performance. The HC might want to prepare some memory buffers prior to
+ * interfering with other world.
+ *
+ * @param batch Transfer batch this endpoint is blocked by.
+ */
+int endpoint_activate_locked(endpoint_t *ep, usb_transfer_batch_t *batch)
+{
+        assert(ep);
+        assert(batch);
+        assert(batch->ep == ep);
+        assert(ep->guard);
+        assert(fibril_mutex_is_locked(ep->guard));
+        while (ep->online && ep->active_batch != NULL)
+                fibril_condvar_wait(&ep->avail, ep->guard);
+        if (!ep->online)
+                return EINTR;
+        assert(ep->active_batch == NULL);
+        ep->active_batch = batch;
+        return EOK;
+}
+/**
+ * Mark the endpoint as inactive and allow access for further fibrils.
+ */
+void endpoint_deactivate_locked(endpoint_t *ep)
+{
+        assert(ep);
+        assert(fibril_mutex_is_locked(ep->guard));
+        ep->active_batch = NULL;
+        fibril_condvar_signal(&ep->avail);
+}
+/**
+ * Initiate a transfer on an endpoint. Creates a transfer batch, checks the
+ * bandwidth requirements and schedules the batch.
+ *
+ * @param endpoint Endpoint for which to send the batch
+ */
+errno_t endpoint_send_batch(endpoint_t *ep, const transfer_request_t *req)
+{
+        assert(ep);
+        assert(req);
+        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
+                usb_log_debug("%s %d:%d %zu/%zuB, setup %#016" PRIx64, req->name,
+                    req->target.address, req->target.endpoint,
+                    req->size, ep->max_packet_size,
+                    req->setup);
+        } else {
+                usb_log_debug("%s %d:%d %zu/%zuB", req->name,
+                    req->target.address, req->target.endpoint,
+                    req->size, ep->max_packet_size);
+        }
+        device_t * const device = ep->device;
+        if (!device) {
+                usb_log_warning("Endpoint detached");
+                return EAGAIN;
+        }
+        const bus_ops_t *ops = device->bus->ops;
+        if (!ops->batch_schedule) {
+                usb_log_error("HCD does not implement scheduler.");
+                return ENOTSUP;
+        }
+        size_t size = req->size;
+        /*
+         * Limit transfers with reserved bandwidth to the amount reserved.
+         * OUT transfers are rejected, IN can be just trimmed in advance.
+         */
+        if (size > ep->max_transfer_size &&
+            (ep->transfer_type == USB_TRANSFER_INTERRUPT
+             || ep->transfer_type == USB_TRANSFER_ISOCHRONOUS)) {
+                if (req->dir == USB_DIRECTION_OUT)
+                        return ENOSPC;
+                else
+                        size = ep->max_transfer_size;
+        }
+        /* Offline devices don't schedule transfers other than on EP0. */
+        if (!device->online && ep->endpoint > 0)
+                return EAGAIN;
+        usb_transfer_batch_t *batch = usb_transfer_batch_create(ep);
+        if (!batch) {
+                usb_log_error("Failed to create transfer batch.");
+                return ENOMEM;
+        }
+        batch->target = req->target;
+        batch->setup.packed = req->setup;
+        batch->dir = req->dir;
+        batch->size = size;
+        batch->offset = req->offset;
+        batch->dma_buffer = req->buffer;
+        dma_buffer_acquire(&batch->dma_buffer);
+        if (batch->offset != 0) {
+                usb_log_debug("A transfer with nonzero offset requested.");
+                usb_transfer_batch_bounce(batch);
+        }
+        if (usb_transfer_batch_bounce_required(batch))
+                usb_transfer_batch_bounce(batch);
+        batch->on_complete = req->on_complete;
+        batch->on_complete_data = req->arg;
+        const int ret = ops->batch_schedule(batch);
+        if (ret != EOK) {
+                usb_log_warning("Batch %p failed to schedule: %s", batch, str_error(ret));
+                usb_transfer_batch_destroy(batch);
+        }
         return ret;
+}
-/** Set the value of toggle bit.
- * @param instance endpoint_t structure.
- * @note Will use provided hook.
- */
-void endpoint_toggle_set(endpoint_t *instance, int toggle)
+{
-        assert(instance);
-        assert(toggle == 0 || toggle == 1);
-        fibril_mutex_lock(&instance->guard);
-        instance->toggle = toggle;
-        if (instance->hc_data.toggle_set)
-                instance->hc_data.toggle_set(instance->hc_data.data, toggle);
-        fibril_mutex_unlock(&instance->guard);
+}
 /**
  * @}

uspace/lib/usbhost/src/hcd.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
 /** @file
+ *
+ */
+#include <usb/debug.h>
+#include <usb/request.h>
+ * Host controller driver framework. Encapsulates DDF device of HC to an
+ * hc_device_t, which is passed to driver implementing hc_driver_t.
+ */
 #include <assert.h>
 #include <async.h>
+#include <ddf/interrupt.h>
 #include <errno.h>
+#include <macros.h>
+#include <str_error.h>
+#include <usb/debug.h>
+#include <usb/descriptor.h>
+#include <usb/request.h>
 #include <usb_iface.h>
+#include "bus.h"
+#include "ddf_helpers.h"
+#include "endpoint.h"
+#include "usb_transfer_batch.h"
 #include "hcd.h"
+/** Calls ep_add_hook upon endpoint registration.
+ * @param ep Endpoint to be registered.
+ * @param arg hcd_t in disguise.
+ * @return Error code.
+ */
+static errno_t register_helper(endpoint_t *ep, void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(ep);
+int hc_dev_add(ddf_dev_t *);
+int hc_dev_remove(ddf_dev_t *);
+int hc_dev_gone(ddf_dev_t *);
+int hc_fun_online(ddf_fun_t *);
+int hc_fun_offline(ddf_fun_t *);
+static driver_ops_t hc_driver_ops = {
+        .dev_add = hc_dev_add,
+        .dev_remove = hc_dev_remove,
+        .dev_gone = hc_dev_gone,
+        .fun_online = hc_fun_online,
+        .fun_offline = hc_fun_offline,
+};
+static const hc_driver_t *hc_driver;
+/**
+ * The main HC driver routine.
+ */
+int hc_driver_main(const hc_driver_t *driver)
+{
+        driver_t ddf_driver = {
+                .name = driver->name,
+                .driver_ops = &hc_driver_ops,
+        };
+        /* Remember ops to call. */
+        hc_driver = driver;
+        return ddf_driver_main(&ddf_driver);
+}
+/**
+ * IRQ handling callback. Call the bus operation.
+ *
+ * Currently, there is a bus ops lookup to find the interrupt handler. So far,
+ * the mechanism is too flexible, as it allows different instances of HC to
+ * have different IRQ handlers, disallowing us to optimize the lookup here.
+ * TODO: Make the bus mechanism less flexible in irq handling and remove the
+ * lookup.
+ */
+static void irq_handler(ipc_call_t *call, ddf_dev_t *dev)
+{
+        assert(dev);
+        hc_device_t *hcd = dev_to_hcd(dev);
+        const uint32_t status = IPC_GET_ARG1(*call);
+        hcd->bus->ops->interrupt(hcd->bus, status);
+}
+/**
+ * Worker for the HW interrupt replacement fibril.
+ */
+static errno_t interrupt_polling(void *arg)
+{
+        bus_t *bus = arg;
+        assert(bus);
+        if (!bus->ops->interrupt || !bus->ops->status)
+                return ENOTSUP;
+        uint32_t status = 0;
+        while (bus->ops->status(bus, &status) == EOK) {
+                bus->ops->interrupt(bus, status);
+                status = 0;
+                /* We should wait 1 frame - 1ms here, but this polling is a
+                 * lame crutch anyway so don't hog the system. 10ms is still
+                 * good enough for emergency mode */
+                async_usleep(10000);
+        }
+        return EOK;
+}
+/**
+ * Clean the IRQ code bottom-half.
+ */
+static inline void irq_code_clean(irq_code_t *code)
+{
+        if (code) {
+                free(code->ranges);
+                free(code->cmds);
+                code->ranges = NULL;
+                code->cmds = NULL;
+                code->rangecount = 0;
+                code->cmdcount = 0;
+        }
+}
+/**
+ * Register an interrupt handler. If there is a callback to setup the bottom half,
+ * invoke it and register it. Register for notifications.
+ *
+ * If this method fails, a polling fibril is started instead.
+ *
+ * @param[in] hcd Host controller device.
+ * @param[in] hw_res Resources to be used.
+ *
+ * @return IRQ capability handle on success.
+ * @return Negative error code.
+ */
+static errno_t hcd_ddf_setup_interrupts(hc_device_t *hcd,
+    const hw_res_list_parsed_t *hw_res)
+{
         assert(hcd);
+        if (hcd->ops.ep_add_hook)
+                return hcd->ops.ep_add_hook(hcd, ep);
+        irq_code_t irq_code = { 0 };
+        if (!hc_driver->irq_code_gen)
+                return ENOTSUP;
+        int irq;
+        errno_t ret;
+        ret = hc_driver->irq_code_gen(&irq_code, hcd, hw_res, &irq);
+        if (ret != EOK) {
+                usb_log_error("Failed to generate IRQ code: %s.",
+                    str_error(irq));
+                return irq;
+        }
+        /* Register handler to avoid interrupt lockup */
+        int irq_cap;
+        ret = register_interrupt_handler(hcd->ddf_dev, irq, irq_handler,
+            &irq_code, &irq_cap);
+        irq_code_clean(&irq_code);
+        if (ret != EOK) {
+                usb_log_error("Failed to register interrupt handler: %s.",
+                    str_error(irq_cap));
+                return irq_cap;
+        }
+        /* Enable interrupts */
+        ret = hcd_ddf_enable_interrupt(hcd, irq);
+        if (ret != EOK) {
+                usb_log_error("Failed to enable interrupts: %s.",
+                    str_error(ret));
+                unregister_interrupt_handler(hcd->ddf_dev, irq_cap);
+                return ret;
+        }
+        return irq_cap;
+}
+/**
+ * Initialize HC in memory of the driver.
+ *
+ * This function does all the preparatory work for hc and rh drivers:
+ *  - gets device's hw resources
+ *  - attempts to enable interrupts
+ *  - registers interrupt handler
+ *  - calls driver specific initialization
+ *  - registers root hub
+ *
+ * @param device DDF instance of the device to use
+ * @return Error code
+ */
+errno_t hc_dev_add(ddf_dev_t *device)
+{
+        errno_t ret = EOK;
+        assert(device);
+        if (!hc_driver->hc_add) {
+                usb_log_error("Driver '%s' does not support adding devices.",
+                    hc_driver->name);
+                return ENOTSUP;
+        }
+        ret = hcd_ddf_setup_hc(device, hc_driver->hc_device_size);
+        if (ret != EOK) {
+                usb_log_error("Failed to setup HC device.");
+                return ret;
+        }
+        hc_device_t *hcd = dev_to_hcd(device);
+        hw_res_list_parsed_t hw_res;
+        ret = hcd_ddf_get_registers(hcd, &hw_res);
+        if (ret != EOK) {
+                usb_log_error("Failed to get register memory addresses "
+                    "for `%s': %s.", ddf_dev_get_name(device),
+                    str_error(ret));
+                goto err_hcd;
+        }
+        ret = hc_driver->hc_add(hcd, &hw_res);
+        if (ret != EOK) {
+                usb_log_error("Failed to init HCD.");
+                goto err_hw_res;
+        }
+        assert(hcd->bus);
+        /* Setup interrupts  */
+        hcd->irq_cap = hcd_ddf_setup_interrupts(hcd, &hw_res);
+        if (hcd->irq_cap >= 0) {
+                usb_log_debug("Hw interrupts enabled.");
+        }
+        /* Claim the device from BIOS */
+        if (hc_driver->claim)
+                ret = hc_driver->claim(hcd);
+        if (ret != EOK) {
+                usb_log_error("Failed to claim `%s' for `%s': %s",
+                    ddf_dev_get_name(device), hc_driver->name, str_error(ret));
+                goto err_irq;
+        }
+        /* Start hw */
+        if (hc_driver->start)
+                ret = hc_driver->start(hcd);
+        if (ret != EOK) {
+                usb_log_error("Failed to start HCD: %s.", str_error(ret));
+                goto err_irq;
+        }
+        const bus_ops_t *ops = hcd->bus->ops;
+        /* Need working irq replacement to setup root hub */
+        if (hcd->irq_cap < 0 && ops->status) {
+                hcd->polling_fibril = fibril_create(interrupt_polling, hcd->bus);
+                if (!hcd->polling_fibril) {
+                        usb_log_error("Failed to create polling fibril");
+                        ret = ENOMEM;
+                        goto err_started;
+                }
+                fibril_add_ready(hcd->polling_fibril);
+                usb_log_warning("Failed to enable interrupts: %s."
+                    " Falling back to polling.", str_error(hcd->irq_cap));
+        }
+        /*
+         * Creating root hub registers a new USB device so HC
+         * needs to be ready at this time.
+         */
+        if (hc_driver->setup_root_hub)
+                ret = hc_driver->setup_root_hub(hcd);
+        if (ret != EOK) {
+                usb_log_error("Failed to setup HC root hub: %s.",
+                    str_error(ret));
+                goto err_polling;
+        }
+        usb_log_info("Controlling new `%s' device `%s'.",
+            hc_driver->name, ddf_dev_get_name(device));
         return EOK;
+}
+/** Calls ep_remove_hook upon endpoint removal.
+ * @param ep Endpoint to be unregistered.
+ * @param arg hcd_t in disguise.
+ */
+static void unregister_helper(endpoint_t *ep, void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(ep);
+        assert(hcd);
+        if (hcd->ops.ep_remove_hook)
+                hcd->ops.ep_remove_hook(hcd, ep);
+}
+/** Calls ep_remove_hook upon endpoint removal. Prints warning.
+ *  * @param ep Endpoint to be unregistered.
+ *   * @param arg hcd_t in disguise.
+ *    */
+static void unregister_helper_warn(endpoint_t *ep, void *arg)
+{
+        assert(ep);
+        usb_log_warning("Endpoint %d:%d %s was left behind, removing.\n",
+            ep->address, ep->endpoint, usb_str_direction(ep->direction));
+        unregister_helper(ep, arg);
+}
+/** 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 max_speed Maximum supported USB speed (full, high).
+ * @param bandwidth Available bandwidth, passed to endpoint manager.
+ * @param bw_count Bandwidth compute function, passed to endpoint manager.
+ */
+void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth,
+    bw_count_func_t bw_count)
+{
+        assert(hcd);
+        usb_bus_init(&hcd->bus, bandwidth, bw_count, max_speed);
+        hcd_set_implementation(hcd, NULL, NULL);
+}
+errno_t hcd_request_address(hcd_t *hcd, usb_speed_t speed, usb_address_t *address)
+{
+        assert(hcd);
+        return usb_bus_request_address(&hcd->bus, address, false, speed);
+}
+errno_t hcd_release_address(hcd_t *hcd, usb_address_t address)
+{
+        assert(hcd);
+        return usb_bus_remove_address(&hcd->bus, address,
+            unregister_helper_warn, hcd);
+}
+errno_t hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed)
+{
+        assert(hcd);
+        usb_address_t address = 0;
+        return usb_bus_request_address(&hcd->bus, &address, true, speed);
+}
+errno_t 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)
+{
+        assert(hcd);
+        return usb_bus_add_ep(&hcd->bus, target.address,
+            target.endpoint, dir, type, max_packet_size, packets, size,
+            register_helper, hcd, tt_address, tt_port);
+}
+errno_t hcd_remove_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir)
+{
+        assert(hcd);
+        return usb_bus_remove_ep(&hcd->bus, target.address,
+            target.endpoint, dir, unregister_helper, hcd);
+}
+typedef struct {
+        void *original_data;
+        usbhc_iface_transfer_out_callback_t original_callback;
+        usb_target_t target;
+        hcd_t *hcd;
+} toggle_t;
+static void toggle_reset_callback(errno_t retval, void *arg)
+{
+        assert(arg);
+        toggle_t *toggle = arg;
+        if (retval == EOK) {
+                usb_log_debug2("Reseting toggle on %d:%d.\n",
+                    toggle->target.address, toggle->target.endpoint);
+                usb_bus_reset_toggle(&toggle->hcd->bus,
+                    toggle->target, toggle->target.endpoint == 0);
+        }
+        toggle->original_callback(retval, toggle->original_data);
+}
+/** Prepare generic usb_transfer_batch and schedule it.
+ * @param hcd Host controller driver.
+ * @param fun DDF fun
+ * @param target address and endpoint number.
+ * @param setup_data Data to use in setup stage (Control communication type)
+ * @param in Callback for device to host communication.
+ * @param out Callback for host to device communication.
+ * @param arg Callback parameter.
+ * @param name Communication identifier (for nicer output).
+ * @return Error code.
+ */
+errno_t 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)
+{
+        assert(hcd);
+        endpoint_t *ep = usb_bus_find_ep(&hcd->bus,
+            target.address, target.endpoint, direction);
+        if (ep == NULL) {
+                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
+                    target.address, target.endpoint, name);
+                return ENOENT;
+        }
+        usb_log_debug2("%s %d:%d %zu(%zu).\n",
+            name, target.address, target.endpoint, size, ep->max_packet_size);
+        const size_t bw = bandwidth_count_usb11(
+            ep->speed, ep->transfer_type, size, ep->max_packet_size);
+        /* Check if we have enough bandwidth reserved */
+        if (ep->bandwidth < bw) {
+                usb_log_error("Endpoint(%d:%d) %s needs %zu bw "
+                    "but only %zu is reserved.\n",
+                    ep->address, ep->endpoint, name, bw, ep->bandwidth);
+                return ENOSPC;
+        }
+        if (!hcd->ops.schedule) {
+                usb_log_error("HCD does not implement scheduler.\n");
+                return ENOTSUP;
+        }
+        /* Check for commands that reset toggle bit */
+        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
+                const int reset_toggle = usb_request_needs_toggle_reset(
+                    (usb_device_request_setup_packet_t *) &setup_data);
+                if (reset_toggle >= 0) {
+                        assert(out);
+                        toggle_t *toggle = malloc(sizeof(toggle_t));
+                        if (!toggle)
+                                return ENOMEM;
+                        toggle->target.address = target.address;
+                        toggle->target.endpoint = reset_toggle;
+                        toggle->original_callback = out;
+                        toggle->original_data = arg;
+                        toggle->hcd = hcd;
+                        arg = toggle;
+                        out = toggle_reset_callback;
+                }
+        }
+        usb_transfer_batch_t *batch = usb_transfer_batch_create(
+            ep, data, size, setup_data, in, out, arg);
+        if (!batch) {
+                usb_log_error("Failed to create transfer batch.\n");
+                return ENOMEM;
+        }
+        const errno_t ret = hcd->ops.schedule(hcd, batch);
+        if (ret != EOK)
+                usb_transfer_batch_destroy(batch);
+        /* Drop our own reference to ep. */
+        endpoint_del_ref(ep);
+err_polling:
+        // TODO: Stop the polling fibril (refactor the interrupt_polling func)
+        //
+err_started:
+        if (hc_driver->stop)
+                hc_driver->stop(hcd);
+err_irq:
+        unregister_interrupt_handler(device, hcd->irq_cap);
+        if (hc_driver->hc_remove)
+                hc_driver->hc_remove(hcd);
+err_hw_res:
+        hw_res_list_parsed_clean(&hw_res);
+err_hcd:
+        hcd_ddf_clean_hc(hcd);
         return ret;
+}
+typedef struct {
+        volatile unsigned done;
+        errno_t ret;
+        size_t size;
+} sync_data_t;
+static void transfer_in_cb(errno_t ret, size_t size, void* data)
+{
+        sync_data_t *d = data;
+        assert(d);
+        d->ret = ret;
+        d->done = 1;
+        d->size = size;
+}
+static void transfer_out_cb(errno_t ret, void* data)
+{
+        sync_data_t *d = data;
+        assert(data);
+        d->ret = ret;
+        d->done = 1;
+}
+/** this is really ugly version of sync usb communication */
+errno_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, size_t *out_size)
+{
+        assert(hcd);
+        sync_data_t sd = { .done = 0, .ret = EBUSY, .size = size };
+        const errno_t ret = hcd_send_batch(hcd, target, dir, data, size, setup_data,
+            dir == USB_DIRECTION_IN ? transfer_in_cb : NULL,
+            dir == USB_DIRECTION_OUT ? transfer_out_cb : NULL, &sd, name);
+        if (ret != EOK)
+                return ret;
+        while (!sd.done) {
+                async_usleep(1000);
+        }
+        if (sd.ret == EOK)
+                *out_size = sd.size;
+        return sd.ret;
+errno_t hc_dev_remove(ddf_dev_t *dev)
+{
+        errno_t err;
+        hc_device_t *hcd = dev_to_hcd(dev);
+        if (hc_driver->stop)
+                if ((err = hc_driver->stop(hcd)))
+                        return err;
+        unregister_interrupt_handler(dev, hcd->irq_cap);
+        if (hc_driver->hc_remove)
+                if ((err = hc_driver->hc_remove(hcd)))
+                        return err;
+        hcd_ddf_clean_hc(hcd);
+        // TODO probably not complete
+        return EOK;
+}
+errno_t hc_dev_gone(ddf_dev_t *dev)
+{
+        errno_t err = ENOTSUP;
+        hc_device_t *hcd = dev_to_hcd(dev);
+        if (hc_driver->hc_gone)
+                err = hc_driver->hc_gone(hcd);
+        hcd_ddf_clean_hc(hcd);
+        return err;
+}
+errno_t hc_fun_online(ddf_fun_t *fun)
+{
+        assert(fun);
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
+        usb_log_info("Device(%d): Requested to be brought online.", dev->address);
+        return bus_device_online(dev);
+}
+int hc_fun_offline(ddf_fun_t *fun)
+{
+        assert(fun);
+        device_t *dev = ddf_fun_data_get(fun);
+        assert(dev);
+        usb_log_info("Device(%d): Requested to be taken offline.", dev->address);
+        return bus_device_offline(dev);
+}

uspace/lib/usbhost/src/usb_transfer_batch.c

-              rf5e5f73
+              rdf6ded8
 /*
  * Copyright (c) 2011 Jan Vesely
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
+ *
 …
  */
-#include <usb/host/usb_transfer_batch.h>
-#include <usb/debug.h>
 #include <assert.h>
 #include <errno.h>
-#include <macros.h>
-#include <mem.h>
 #include <stdlib.h>
+#include <usbhc_iface.h>
+/** Allocate and initialize usb_transfer_batch structure.
+ * @param ep endpoint used by the transfer batch.
+ * @param buffer data to send/recieve.
+ * @param buffer_size Size of data buffer.
+ * @param setup_buffer Data to send in SETUP stage of control transfer.
+ * @param func_in callback on IN transfer completion.
+ * @param func_out callback on OUT transfer completion.
+ * @param fun DDF function (passed to callback function).
+ * @param arg Argument to pass to the callback function.
+ * @param private_data driver specific per batch data.
+ * @param private_data_dtor Function to properly destroy private_data.
+ * @return Pointer to valid usb_transfer_batch_t structure, NULL on failure.
+ */
+usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *ep, char *buffer,
+    size_t buffer_size,
+    uint64_t setup_buffer,
+    usbhc_iface_transfer_in_callback_t func_in,
+    usbhc_iface_transfer_out_callback_t func_out,
+    void *arg)
+{
+        if (func_in == NULL && func_out == NULL)
+                return NULL;
+        if (func_in != NULL && func_out != NULL)
+                return NULL;
+        usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
+        if (instance) {
+                instance->ep = ep;
+                instance->callback_in = func_in;
+                instance->callback_out = func_out;
+                instance->arg = arg;
+                instance->buffer = buffer;
+                instance->buffer_size = buffer_size;
+                instance->setup_size = 0;
+                instance->transfered_size = 0;
+                instance->error = EOK;
+                if (ep && ep->transfer_type == USB_TRANSFER_CONTROL) {
+                        memcpy(instance->setup_buffer, &setup_buffer,
+                            USB_SETUP_PACKET_SIZE);
+                        instance->setup_size = USB_SETUP_PACKET_SIZE;
+#include <str_error.h>
+#include <usb/debug.h>
+#include "endpoint.h"
+#include "bus.h"
+#include "usb_transfer_batch.h"
+/**
+ * Create a batch on a given endpoint.
+ *
+ * If the bus callback is not defined, it just creates a default batch.
+ */
+usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *ep)
+{
+        assert(ep);
+        bus_t *bus = endpoint_get_bus(ep);
+        if (!bus->ops->batch_create) {
+                usb_transfer_batch_t *batch = calloc(1, sizeof(usb_transfer_batch_t));
+                if (!batch)
+                        return NULL;
+                usb_transfer_batch_init(batch, ep);
+                return batch;
+        }
+        return bus->ops->batch_create(ep);
+}
+/**
+ * Initialize given batch structure.
+ */
+void usb_transfer_batch_init(usb_transfer_batch_t *batch, endpoint_t *ep)
+{
+        assert(ep);
+        /* Batch reference */
+        endpoint_add_ref(ep);
+        batch->ep = ep;
+}
+/**
+ * Destroy the batch. If there's no bus callback, just free it.
+ */
+void usb_transfer_batch_destroy(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(batch->ep);
+        bus_t *bus = endpoint_get_bus(batch->ep);
+        endpoint_t *ep = batch->ep;
+        if (bus->ops) {
+                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " destroying.",
+                    batch, USB_TRANSFER_BATCH_ARGS(*batch));
+                bus->ops->batch_destroy(batch);
+        }
+        else {
+                usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.",
+                    batch, USB_TRANSFER_BATCH_ARGS(*batch));
+                free(batch);
+        }
+        /* Batch reference */
+        endpoint_del_ref(ep);
+}
+bool usb_transfer_batch_bounce_required(usb_transfer_batch_t *batch)
+{
+        if (!batch->size)
+                return false;
+        unsigned flags = batch->dma_buffer.policy & DMA_POLICY_FLAGS_MASK;
+        unsigned required_flags =
+            batch->ep->required_transfer_buffer_policy & DMA_POLICY_FLAGS_MASK;
+        if (required_flags & ~flags)
+                return true;
+        size_t chunk_mask = dma_policy_chunk_mask(batch->dma_buffer.policy);
+        size_t required_chunk_mask =
+             dma_policy_chunk_mask(batch->ep->required_transfer_buffer_policy);
+        /* If the chunks are at least as large as required, we're good */
+        if ((required_chunk_mask & ~chunk_mask) == 0)
+                return false;
+        size_t start_chunk = batch->offset & ~chunk_mask;
+        size_t end_chunk = (batch->offset + batch->size - 1) & ~chunk_mask;
+        /* The requested area crosses a chunk boundary */
+        if (start_chunk != end_chunk)
+                return true;
+        return false;
+}
+errno_t usb_transfer_batch_bounce(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(!batch->is_bounced);
+        dma_buffer_release(&batch->dma_buffer);
+        batch->original_buffer = batch->dma_buffer.virt + batch->offset;
+        usb_log_debug("Batch(%p): Buffer cannot be used directly, "
+            "falling back to bounce buffer!", batch);
+        const errno_t err = dma_buffer_alloc_policy(&batch->dma_buffer,
+            batch->size, batch->ep->transfer_buffer_policy);
+        if (err)
+                return err;
+        /* Copy the data out */
+        if (batch->dir == USB_DIRECTION_OUT)
+                memcpy(batch->dma_buffer.virt,
+                    batch->original_buffer,
+                    batch->size);
+        batch->is_bounced = true;
+        batch->offset = 0;
+        return err;
+}
+/**
+ * Finish a transfer batch: call handler, destroy batch, release endpoint.
+ *
+ * Call only after the batch have been scheduled && completed!
+ */
+void usb_transfer_batch_finish(usb_transfer_batch_t *batch)
+{
+        assert(batch);
+        assert(batch->ep);
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.",
+            batch, USB_TRANSFER_BATCH_ARGS(*batch));
+        if (batch->error == EOK && batch->size > 0) {
+                if (batch->is_bounced) {
+                        /* We we're forced to use bounce buffer, copy it back */
+                        if (batch->dir == USB_DIRECTION_IN)
+                        memcpy(batch->original_buffer,
+                            batch->dma_buffer.virt,
+                            batch->transferred_size);
+                        dma_buffer_free(&batch->dma_buffer);
+                }
+                if (instance->ep)
+                        endpoint_use(instance->ep);
+        }
+        return instance;
+}
+/** Correctly dispose all used data structures.
+ *
+ * @param[in] instance Batch structure to use.
+ */
+void usb_transfer_batch_destroy(usb_transfer_batch_t *instance)
+{
+        if (!instance)
+                return;
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " disposing.\n",
+            instance, USB_TRANSFER_BATCH_ARGS(*instance));
+        if (instance->ep) {
+                endpoint_release(instance->ep);
+        }
+        free(instance);
+}
+/** Prepare data and call the right callback.
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] data Data to copy to the output buffer.
+ * @param[in] size Size of @p data.
+ * @param[in] error Error value to use.
+ */
+void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance,
+    const void *data, size_t size, errno_t error)
+{
+        assert(instance);
+        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " finishing.\n",
+            instance, USB_TRANSFER_BATCH_ARGS(*instance));
+        /* NOTE: Only one of these pointers should be set. */
+        if (instance->callback_out) {
+                instance->callback_out(error, instance->arg);
+        }
+        if (instance->callback_in) {
+                /* We care about the data and there are some to copy */
+                const size_t safe_size = min(size, instance->buffer_size);
+                if (data) {
+                        memcpy(instance->buffer, data, safe_size);
+                else {
+                        dma_buffer_release(&batch->dma_buffer);
+                }
+                instance->callback_in(error, safe_size, instance->arg);
+        }
+}
+        }
+        if (batch->on_complete) {
+                const int err = batch->on_complete(batch->on_complete_data, batch->error, batch->transferred_size);
+                if (err)
+                        usb_log_warning("Batch %p failed to complete: %s",
+                            batch, str_error(err));
+        }
+        usb_transfer_batch_destroy(batch);
+}
 /**
  * @}

uspace/lib/usbvirt/src/ctrltransfer.c

rf5e5f73	rdf6ded8
68	68	}
69	69
70		usb_log_debug("Control transfer: %s(%s)\n", handler->name,
	70	usb_log_debug("Control transfer: %s(%s)", handler->name,
71	71	usb_debug_str_buffer((uint8_t) setup, sizeof(setup), 0));
72	72	errno_t rc = handler->callback(dev, setup, data, data_sent_size);

uspace/lib/usbvirt/src/ipc_hc.c

-              rf5e5f73
+              rdf6ded8
  * @param data_buffer Data buffer (DATA stage of control transfer).
  * @param data_buffer_size Size of data buffer in bytes.
  * @param data_transfered_size Number of actually transferred bytes.
+ * @param data_transferred_size Number of actually transferred bytes.
+ *
  * @return Error code.
 …
 errno_t usbvirt_ipc_send_control_read(async_sess_t *sess, void *setup_buffer,
     size_t setup_buffer_size, void *data_buffer, size_t data_buffer_size,
     size_t *data_transfered_size)
+    size_t *data_transferred_size)
+{
         if (!sess)
 …
+        }
+        errno_t rc = async_data_write_start(exch, setup_buffer, setup_buffer_size);
+        errno_t rc = async_data_write_start(exch, setup_buffer,
+            setup_buffer_size);
         if (rc != EOK) {
                 async_exchange_end(exch);
 …
         ipc_call_t data_request_call;
         aid_t data_request = async_data_read(exch, data_buffer, data_buffer_size,
             &data_request_call);
+        aid_t data_request = async_data_read(exch, data_buffer,
+            data_buffer_size, &data_request_call);
         async_exchange_end(exch);
 …
                 return (errno_t) opening_request_rc;
         if (data_transfered_size != NULL)
                 *data_transfered_size = IPC_GET_ARG2(data_request_call);
+        if (data_transferred_size != NULL)
+                *data_transferred_size = IPC_GET_ARG2(data_request_call);
         return EOK;
 …
+        }
+        errno_t rc = async_data_write_start(exch, setup_buffer, setup_buffer_size);
+        errno_t rc = async_data_write_start(exch, setup_buffer,
+            setup_buffer_size);
         if (rc != EOK) {
                 async_exchange_end(exch);
 …
         if (data_buffer_size > 0) {
+                rc = async_data_write_start(exch, data_buffer, data_buffer_size);
+                rc = async_data_write_start(exch, data_buffer,
+                    data_buffer_size);
                 if (rc != EOK) {
                         async_exchange_end(exch);

uspace/lib/usbvirt/src/transfer.c

-              rf5e5f73
+              rdf6ded8
         if (rc == EFORWARD) {
                 usb_log_warning("Control transfer {%s (%s)} not handled.\n",
+                usb_log_warning("Control transfer {%s (%s)} not handled.",
                     usb_debug_str_buffer(setup, setup_size, 10),
                     setup_packet->request_type & 0x80
 …
  * @return Error code.
  */
+errno_t usbvirt_control_read(usbvirt_device_t *dev, const void *setup, size_t setup_size,
+errno_t 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)
+{

Context Navigation

Changeset df6ded8 in mainline for uspace/lib

Legend:

Download in other formats: