Changeset 20a3465 in mainline for uspace/lib

Timestamp:

2011-10-30T19:50:54Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

3ce78580, 48902fa

Parents:

4c3ad56 (diff), 45bf63c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

uspace/lib

Files:

• c/generic/str.c (modified) (1 diff)
• c/include/str.h (modified) (1 diff)
• usbdev/include/usb/dev/dp.h (modified) (3 diffs)
• usbdev/include/usb/dev/driver.h (modified) (3 diffs)
• usbdev/include/usb/dev/pipes.h (modified) (1 diff)
• usbdev/src/altiface.c (modified) (10 diffs)
• usbdev/src/devdrv.c (modified) (15 diffs)
• usbdev/src/dp.c (modified) (15 diffs)
• usbdev/src/pipesinit.c (modified) (11 diffs)
• usbdev/src/request.c (modified) (2 diffs)
• usbhid/include/usb/hid/hiddescriptor.h (modified) (2 diffs)
• usbhid/src/hiddescriptor.c (modified) (2 diffs)
• usbhid/src/hidparser.c (modified) (23 diffs)
• usbhid/src/hidreport.c (modified) (2 diffs)
• usbhost/include/usb/host/endpoint.h (modified) (1 diff)
• usbhost/include/usb/host/hcd.h (modified) (1 diff)
• usbhost/include/usb/host/usb_device_manager.h (modified) (2 diffs)
• usbhost/include/usb/host/usb_endpoint_manager.h (modified) (2 diffs)
• usbhost/include/usb/host/usb_transfer_batch.h (modified) (5 diffs)
• usbhost/src/endpoint.c (modified) (5 diffs)
• usbhost/src/iface.c (modified) (10 diffs)
• usbhost/src/usb_device_manager.c (modified) (9 diffs)
• usbhost/src/usb_endpoint_manager.c (modified) (7 diffs)
• usbhost/src/usb_transfer_batch.c (modified) (4 diffs)

uspace/lib/c/generic/str.c

@@ -839 +839 @@
         
         return NULL;
+}
+
+/** Removes specified trailing characters from a string.
+ *
+ * @param str String to remove from.
+ * @param ch  Character to remove.
+ */
+void str_rtrim(char *str, wchar_t ch)
+{
+        size_t off = 0;
+        size_t pos = 0;
+        wchar_t c;
+        bool update_last_chunk = true;
+        char *last_chunk = NULL;
+
+        while ((c = str_decode(str, &off, STR_NO_LIMIT))) {
+                if (c != ch) {
+                        update_last_chunk = true;
+                        last_chunk = NULL;
+                } else if (update_last_chunk) {
+                        update_last_chunk = false;
+                        last_chunk = (str + pos);
+                }
+                pos = off;
+        }
+
+        if (last_chunk)
+                *last_chunk = '\0';
+}
+
+/** Removes specified leading characters from a string.
+ *
+ * @param str String to remove from.
+ * @param ch  Character to remove.
+ */
+void str_ltrim(char *str, wchar_t ch)
+{
+        wchar_t acc;
+        size_t off = 0;
+        size_t pos = 0;
+        size_t str_sz = str_size(str);
+
+        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
+                if (acc != ch)
+                        break;
+                else
+                        pos = off;
+        }
+
+        if (pos > 0) {
+                memmove(str, &str[pos], str_sz - pos);
+                pos = str_sz - pos;
+                str[str_sz - pos] = '\0';
+        }
 }
 

uspace/lib/c/include/str.h

@@ -91 +91 @@
 extern char *str_rchr(const char *str, wchar_t ch);
 
+extern void str_rtrim(char *str, wchar_t ch);
+extern void str_ltrim(char *str, wchar_t ch);
+
 extern bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos);
 extern bool wstr_remove(wchar_t *str, size_t pos);

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

@@ -59 +59 @@
 typedef struct {
         /** Used descriptor nesting. */
-        usb_dp_descriptor_nesting_t *nesting;
+        const usb_dp_descriptor_nesting_t *nesting;
 } usb_dp_parser_t;
 
@@ -65 +65 @@
 typedef struct {
         /** Data to be parsed. */
-        uint8_t *data;
+        const uint8_t *data;
         /** Size of input data in bytes. */
         size_t size;
@@ -72 +72 @@
 } usb_dp_parser_data_t;
 
-uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *,
-    usb_dp_parser_data_t *, uint8_t *);
-uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *,
-    usb_dp_parser_data_t *, uint8_t *, uint8_t *);
+typedef void (*walk_callback_t)(const uint8_t *, size_t, void *);
 
-void usb_dp_walk_simple(uint8_t *, size_t, usb_dp_descriptor_nesting_t *,
-    void (*)(uint8_t *, size_t, void *), void *);
+const uint8_t *usb_dp_get_nested_descriptor(const usb_dp_parser_t *,
+    const usb_dp_parser_data_t *, const uint8_t *);
+const uint8_t *usb_dp_get_sibling_descriptor(const usb_dp_parser_t *,
+    const usb_dp_parser_data_t *, const uint8_t *, const uint8_t *);
+
+void usb_dp_walk_simple(uint8_t *, size_t, const usb_dp_descriptor_nesting_t *,
+    walk_callback_t, void *);
 
 #endif

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

@@ -43 +43 @@
         usb_standard_device_descriptor_t device;
         /** Full configuration descriptor of current configuration. */
-        uint8_t *configuration;
+        const uint8_t *configuration;
         size_t configuration_size;
 } usb_device_descriptors_t;
@@ -53 +53 @@
 typedef struct {
         /** Interface descriptor. */
-        usb_standard_interface_descriptor_t *interface;
+        const usb_standard_interface_descriptor_t *interface;
         /** Pointer to start of descriptor tree bound with this interface. */
-        uint8_t *nested_descriptors;
+        const uint8_t *nested_descriptors;
         /** Size of data pointed by nested_descriptors in bytes. */
         size_t nested_descriptors_size;
@@ -156 +156 @@
 \endcode
          */
-        usb_endpoint_description_t **endpoints;
+        const usb_endpoint_description_t **endpoints;
         /** Driver ops. */
-        usb_driver_ops_t *ops;
+        const usb_driver_ops_t *ops;
 } usb_driver_t;
 
-int usb_driver_main(usb_driver_t *);
+int usb_driver_main(const usb_driver_t *);
 
 int usb_device_select_interface(usb_device_t *, uint8_t,
-    usb_endpoint_description_t **);
+    const usb_endpoint_description_t **);
 
 int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *);
 int usb_device_create_pipes(const ddf_dev_t *, usb_device_connection_t *,
-    usb_endpoint_description_t **, uint8_t *, size_t, int, int,
+    const usb_endpoint_description_t **, const uint8_t *, size_t, int, int,
     usb_endpoint_mapping_t **, size_t *);
 int usb_device_destroy_pipes(const ddf_dev_t *, usb_endpoint_mapping_t *, size_t);
-int usb_device_create(ddf_dev_t *, usb_endpoint_description_t **, usb_device_t **, const char **);
-void usb_device_destroy(usb_device_t *);
+int usb_device_init(usb_device_t *, ddf_dev_t *,
+    const usb_endpoint_description_t **, const char **);
+void usb_device_deinit(usb_device_t *);
 
-size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);
-int usb_alternate_interfaces_create(uint8_t *, size_t, int,
+void * usb_device_data_alloc(usb_device_t *, size_t);
+
+size_t usb_interface_count_alternates(const uint8_t *, size_t, uint8_t);
+int usb_alternate_interfaces_create(const uint8_t *, size_t, int,
     usb_alternate_interfaces_t **);
-
+void usb_alternate_interfaces_destroy(usb_alternate_interfaces_t *);
 #endif
 /**

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

@@ -171 +171 @@
 int usb_pipe_probe_default_control(usb_pipe_t *);
 int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
-    size_t, uint8_t *, size_t, usb_device_connection_t *);
+    size_t, const uint8_t *, size_t, usb_device_connection_t *);
 int usb_pipe_register_with_speed(usb_pipe_t *, usb_speed_t,
     unsigned int, usb_hc_connection_t *);

uspace/lib/usbdev/src/altiface.c

@@ -48 +48 @@
  * @return Number of alternate interfaces for @p interface_no interface.
  */
-size_t usb_interface_count_alternates(uint8_t *config_descr,
+size_t usb_interface_count_alternates(const uint8_t *config_descr,
     size_t config_descr_size, uint8_t interface_no)
 {
@@ -54 +54 @@
         assert(config_descr_size > 0);
 
-        usb_dp_parser_t dp_parser = {
+        const usb_dp_parser_t dp_parser = {
                 .nesting = usb_dp_standard_descriptor_nesting
         };
-        usb_dp_parser_data_t dp_data = {
+        const usb_dp_parser_data_t dp_data = {
                 .data = config_descr,
                 .size = config_descr_size,
@@ -65 +65 @@
         size_t alternate_count = 0;
 
-        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
+        const uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
             &dp_data, config_descr);
         while (iface_ptr != NULL) {
@@ -90 +90 @@
  * @return Error code.
  */
-int usb_alternate_interfaces_create(uint8_t *config_descr,
+int usb_alternate_interfaces_create(const uint8_t *config_descr,
     size_t config_descr_size, int interface_number,
     usb_alternate_interfaces_t **alternates_ptr)
@@ -98 +98 @@
         assert(config_descr_size > 0);
 
+        *alternates_ptr = NULL;
         if (interface_number < 0) {
-                alternates_ptr = NULL;
                 return EOK;
         }
@@ -105 +105 @@
         usb_alternate_interfaces_t *alternates
             = malloc(sizeof(usb_alternate_interfaces_t));
-
         if (alternates == NULL) {
                 return ENOMEM;
@@ -119 +118 @@
         }
 
-        alternates->alternatives = malloc(alternates->alternative_count
-            * sizeof(usb_alternate_interface_descriptors_t));
+        alternates->alternatives = calloc(alternates->alternative_count,
+            sizeof(usb_alternate_interface_descriptors_t));
         if (alternates->alternatives == NULL) {
                 free(alternates);
@@ -140 +139 @@
             = &alternates->alternatives[0];
 
-        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
+        const uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
             &dp_data, dp_data.data);
         while (iface_ptr != NULL) {
@@ -160 +159 @@
                     dp_data.data, iface_ptr);
                 if (iface_ptr == NULL) {
-                        uint8_t *next = dp_data.data + dp_data.size;
+                        const uint8_t *next = dp_data.data + dp_data.size;
                         cur_alt_iface->nested_descriptors_size
                             = next - cur_alt_iface->nested_descriptors;
@@ -176 +175 @@
 }
 
-
+void usb_alternate_interfaces_destroy(usb_alternate_interfaces_t *alternate)
+{
+        if (!alternate)
+                return;
+        free(alternate->alternatives);
+        free(alternate);
+}
 /**
  * @}

uspace/lib/usbdev/src/devdrv.c

@@ -54 +54 @@
 };
 
-static usb_driver_t *driver = NULL;
+static const usb_driver_t *driver = NULL;
 
 
@@ -64 +64 @@
  * @return Task exit status.
  */
-int usb_driver_main(usb_driver_t *drv)
+int usb_driver_main(const usb_driver_t *drv)
 {
         assert(drv != NULL);
@@ -81 +81 @@
  * @return Number of pipes (excluding default control pipe).
  */
-static size_t count_other_pipes(usb_endpoint_description_t **endpoints)
+static size_t count_other_pipes(const usb_endpoint_description_t **endpoints)
 {
         size_t count = 0;
@@ -101 +101 @@
  * @return Error code.
  */
-static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
+static int initialize_other_pipes(const usb_endpoint_description_t **endpoints,
     usb_device_t *dev, int alternate_setting)
 {
@@ -115 +115 @@
         int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints,
             dev->descriptors.configuration, dev->descriptors.configuration_size,
-            dev->interface_no, alternate_setting,
-            &pipes, &pipes_count);
+            dev->interface_no, alternate_setting, &pipes, &pipes_count);
 
         if (rc != EOK) {
@@ -141 +140 @@
         assert(driver->ops->device_add);
 
-        int rc;
-
-        usb_device_t *dev = NULL;
+        usb_device_t *dev = ddf_dev_data_alloc(gen_dev, sizeof(usb_device_t));
+        if (dev == NULL) {
+                usb_log_error("USB device `%s' structure allocation failed.\n",
+                    gen_dev->name);
+                return ENOMEM;
+        }
         const char *err_msg = NULL;
-        rc = usb_device_create(gen_dev, driver->endpoints, &dev, &err_msg);
-        if (rc != EOK) {
-                usb_log_error("USB device `%s' creation failed (%s): %s.\n",
+        int rc = usb_device_init(dev, gen_dev, driver->endpoints, &err_msg);
+        if (rc != EOK) {
+                usb_log_error("USB device `%s' init failed (%s): %s.\n",
                     gen_dev->name, err_msg, str_error(rc));
                 return rc;
         }
-        gen_dev->driver_data = dev;
-
-        return driver->ops->device_add(dev);
+
+        rc = driver->ops->device_add(dev);
+        if (rc != EOK)
+                usb_device_deinit(dev);
+        return rc;
 }
 /*----------------------------------------------------------------------------*/
@@ -186 +190 @@
         if (driver->ops->device_gone == NULL)
                 return ENOTSUP;
-        const int ret = driver->ops->device_gone(gen_dev->driver_data);
+        usb_device_t *usb_dev = gen_dev->driver_data;
+        const int ret = driver->ops->device_gone(usb_dev);
         if (ret == EOK)
-                usb_device_destroy(gen_dev->driver_data);
+                usb_device_deinit(usb_dev);
 
         return ret;
@@ -235 +240 @@
  */
 int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
-    usb_endpoint_description_t **endpoints)
+    const usb_endpoint_description_t **endpoints)
 {
         if (dev->interface_no < 0) {
@@ -318 +323 @@
  */
 int usb_device_create_pipes(const ddf_dev_t *dev, usb_device_connection_t *wire,
-    usb_endpoint_description_t **endpoints,
-    uint8_t *config_descr, size_t config_descr_size,
+    const usb_endpoint_description_t **endpoints,
+    const uint8_t *config_descr, size_t config_descr_size,
     int interface_no, int interface_setting,
     usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr)
@@ -333 +338 @@
         int rc;
 
-        size_t pipe_count = count_other_pipes(endpoints);
+        const size_t pipe_count = count_other_pipes(endpoints);
         if (pipe_count == 0) {
+                *pipes_count_ptr = pipe_count;
                 *pipes_ptr = NULL;
                 return EOK;
@@ -445 +451 @@
 {
         assert(dev != NULL);
-        assert(((pipes != NULL) && (pipes_count > 0))
-            || ((pipes == NULL) && (pipes_count == 0)));
 
         if (pipes_count == 0) {
+                assert(pipes == NULL);
                 return EOK;
         }
+        assert(pipes != NULL);
 
         int rc;
@@ -468 +474 @@
         size_t i;
         for (i = 0; i < pipes_count; i++) {
-                usb_pipe_unregister(pipes[i].pipe, &hc_conn);
+                usb_log_debug2("Unregistering pipe %zu (%spresent).\n",
+                    i, pipes[i].present ? "" : "not ");
+                if (pipes[i].present)
+                        usb_pipe_unregister(pipes[i].pipe, &hc_conn);
                 free(pipes[i].pipe);
         }
@@ -509 +518 @@
 
 
-/** Create new instance of USB device.
- *
+/** Initialize new instance of USB device.
+ *
+ * @param[in] usb_dev Pointer to the new device.
  * @param[in] ddf_dev Generic DDF device backing the USB one.
  * @param[in] endpoints NULL terminated array of endpoints (NULL for none).
- * @param[out] dev_ptr Where to store pointer to the new device.
  * @param[out] errstr_ptr Where to store description of context
  *      (in case error occurs).
  * @return Error code.
  */
-int usb_device_create(ddf_dev_t *ddf_dev,
-    usb_endpoint_description_t **endpoints,
-    usb_device_t **dev_ptr, const char **errstr_ptr)
-{
-        assert(dev_ptr != NULL);
+int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
+    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
+{
+        assert(usb_dev != NULL);
         assert(ddf_dev != NULL);
 
-        int rc;
-
-        usb_device_t *dev = malloc(sizeof(usb_device_t));
-        if (dev == NULL) {
-                *errstr_ptr = "structure allocation";
-                return ENOMEM;
-        }
-
-        // FIXME: proper deallocation in case of errors
-
-        dev->ddf_dev = ddf_dev;
-        dev->driver_data = NULL;
-        dev->descriptors.configuration = NULL;
-        dev->alternate_interfaces = NULL;
-
-        dev->pipes_count = 0;
-        dev->pipes = NULL;
+        usb_dev->ddf_dev = ddf_dev;
+        usb_dev->driver_data = NULL;
+        usb_dev->descriptors.configuration = NULL;
+        usb_dev->alternate_interfaces = NULL;
+        usb_dev->pipes_count = 0;
+        usb_dev->pipes = NULL;
 
         /* Initialize backing wire and control pipe. */
-        rc = init_wire_and_ctrl_pipe(dev, errstr_ptr);
+        int rc = init_wire_and_ctrl_pipe(usb_dev, errstr_ptr);
         if (rc != EOK) {
                 return rc;
@@ -550 +547 @@
 
         /* Get our interface. */
-        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
+        usb_dev->interface_no = usb_device_get_assigned_interface(ddf_dev);
 
         /* Retrieve standard descriptors. */
-        rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
-            &dev->descriptors);
-        if (rc != EOK) {
+        rc = usb_device_retrieve_descriptors(&usb_dev->ctrl_pipe,
+            &usb_dev->descriptors);
+        if (rc != EOK) {
+                /* Nothing allocated, nothing to free. */
                 *errstr_ptr = "descriptor retrieval";
                 return rc;
         }
 
-        /* Create alternate interfaces. */
-        rc = usb_alternate_interfaces_create(dev->descriptors.configuration,
-            dev->descriptors.configuration_size, dev->interface_no,
-            &dev->alternate_interfaces);
-        if (rc != EOK) {
-                /* We will try to silently ignore this. */
-                dev->alternate_interfaces = NULL;
-        }
-
-        rc = initialize_other_pipes(endpoints, dev, 0);
-        if (rc != EOK) {
+        /* Create alternate interfaces. We will silently ignore failure. */
+        //TODO Why ignore?
+        usb_alternate_interfaces_create(usb_dev->descriptors.configuration,
+            usb_dev->descriptors.configuration_size, usb_dev->interface_no,
+            &usb_dev->alternate_interfaces);
+
+        rc = initialize_other_pipes(endpoints, usb_dev, 0);
+        if (rc != EOK) {
+                /* Full configuration descriptor is allocated. */
+                free(usb_dev->descriptors.configuration);
+                /* Alternate interfaces may be allocated */
+                usb_alternate_interfaces_destroy(usb_dev->alternate_interfaces);
                 *errstr_ptr = "pipes initialization";
                 return rc;
@@ -576 +575 @@
 
         *errstr_ptr = NULL;
-        *dev_ptr = dev;
 
         return EOK;
 }
 
-/** Destroy instance of a USB device.
- *
- * @param dev Device to be destroyed.
- */
-void usb_device_destroy(usb_device_t *dev)
-{
-        if (dev == NULL) {
-                return;
-        }
-
-        /* Ignore errors and hope for the best. */
-        usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count);
-        free(dev->descriptors.configuration);
-
-        if (dev->alternate_interfaces != NULL) {
-                free(dev->alternate_interfaces->alternatives);
-        }
-        free(dev->alternate_interfaces);
-
-        free(dev);
+/** Clean instance of a USB device.
+ *
+ * @param dev Device to be de-initialized.
+ *
+ * Does not free/destroy supplied pointer.
+ */
+void usb_device_deinit(usb_device_t *dev)
+{
+        if (dev) {
+                /* Ignore errors and hope for the best. */
+                destroy_current_pipes(dev);
+
+                usb_alternate_interfaces_destroy(dev->alternate_interfaces);
+                free(dev->descriptors.configuration);
+                free(dev->driver_data);
+        }
+}
+
+void * usb_device_data_alloc(usb_device_t *usb_dev, size_t size)
+{
+        assert(usb_dev);
+        assert(usb_dev->driver_data == NULL);
+        return usb_dev->driver_data = calloc(1, size);
+
 }
 

uspace/lib/usbdev/src/dp.c

@@ -75 +75 @@
  * @return Whether @p ptr points inside <code>data->data</code> field.
  */
-static bool is_valid_descriptor_pointer(usb_dp_parser_data_t *data,
-    uint8_t *ptr)
+static bool is_valid_descriptor_pointer(const usb_dp_parser_data_t *data,
+    const uint8_t *ptr)
 {
         if (ptr == NULL) {
@@ -100 +100 @@
  * @retval NULL Invalid input or no next descriptor.
  */
-static uint8_t *get_next_descriptor(usb_dp_parser_data_t *data,
-    uint8_t *current)
+static const uint8_t *get_next_descriptor(const usb_dp_parser_data_t *data,
+    const uint8_t *current)
 {
         assert(is_valid_descriptor_pointer(data, current));
 
-        uint8_t current_length = *current;
-        uint8_t *next = current + current_length;
+        const uint8_t current_length = *current;
+        const uint8_t *next = current + current_length;
 
         if (!is_valid_descriptor_pointer(data, next)) {
@@ -124 +124 @@
  * @retval -1 Invalid input.
  */
-static int get_descriptor_type(usb_dp_parser_data_t *data, uint8_t *start)
+static int get_descriptor_type(const usb_dp_parser_data_t *data, const uint8_t *start)
 {
         if (start == NULL) {
@@ -145 +145 @@
  * @return Whether @p child could be child of @p parent.
  */
-static bool is_nested_descriptor_type(usb_dp_parser_t *parser,
+static bool is_nested_descriptor_type(const usb_dp_parser_t *parser,
     int child, int parent)
 {
-        usb_dp_descriptor_nesting_t *nesting = parser->nesting;
+        const usb_dp_descriptor_nesting_t *nesting = parser->nesting;
         while ((nesting->child > 0) && (nesting->parent > 0)) {
                 if ((nesting->child == child) && (nesting->parent == parent)) {
@@ -166 +166 @@
  * @return Whether @p child could be child of @p parent.
  */
-static bool is_nested_descriptor(usb_dp_parser_t *parser,
-    usb_dp_parser_data_t *data, uint8_t *child, uint8_t *parent)
+static bool is_nested_descriptor(const usb_dp_parser_t *parser,
+    const usb_dp_parser_data_t *data, const uint8_t *child, const uint8_t *parent)
 {
         return is_nested_descriptor_type(parser,
@@ -183 +183 @@
  * @retval NULL Invalid input.
  */
-uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *parser,
-    usb_dp_parser_data_t *data, uint8_t *parent)
+const uint8_t *usb_dp_get_nested_descriptor(const usb_dp_parser_t *parser,
+    const usb_dp_parser_data_t *data, const uint8_t *parent)
 {
         if (!is_valid_descriptor_pointer(data, parent)) {
@@ -190 +190 @@
         }
 
-        uint8_t *next = get_next_descriptor(data, parent);
+        const uint8_t *next = get_next_descriptor(data, parent);
         if (next == NULL) {
                 return NULL;
@@ -211 +211 @@
  * @retval NULL Invalid input.
  */
-static uint8_t *skip_nested_descriptors(usb_dp_parser_t *parser,
-    usb_dp_parser_data_t *data, uint8_t *parent)
-{
-        uint8_t *child = usb_dp_get_nested_descriptor(parser, data, parent);
+static const uint8_t *skip_nested_descriptors(const usb_dp_parser_t *parser,
+    const usb_dp_parser_data_t *data, const uint8_t *parent)
+{
+        const uint8_t *child =
+            usb_dp_get_nested_descriptor(parser, data, parent);
         if (child == NULL) {
                 return get_next_descriptor(data, parent);
         }
-        uint8_t *next_child = skip_nested_descriptors(parser, data, child);
+        const uint8_t *next_child =
+            skip_nested_descriptors(parser, data, child);
         while (is_nested_descriptor(parser, data, next_child, parent)) {
                 next_child = skip_nested_descriptors(parser, data, next_child);
@@ -236 +238 @@
  * @retval NULL Invalid input.
  */
-uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *parser,
-    usb_dp_parser_data_t *data, uint8_t *parent, uint8_t *sibling)
+const uint8_t *usb_dp_get_sibling_descriptor(
+    const usb_dp_parser_t *parser, const usb_dp_parser_data_t *data,
+    const uint8_t *parent, const uint8_t *sibling)
 {
         if (!is_valid_descriptor_pointer(data, parent)
@@ -244 +247 @@
         }
 
-        uint8_t *possible_sibling = skip_nested_descriptors(parser, data, sibling);
+        const uint8_t *possible_sibling =
+            skip_nested_descriptors(parser, data, sibling);
         if (possible_sibling == NULL) {
                 return NULL;
@@ -269 +273 @@
  * @param arg Custom (user) argument.
  */
-static void usb_dp_browse_simple_internal(usb_dp_parser_t *parser,
-    usb_dp_parser_data_t *data, uint8_t *root, size_t depth,
-    void (*callback)(uint8_t *, size_t, void *), void *arg)
+static void usb_dp_browse_simple_internal(const usb_dp_parser_t *parser,
+    const usb_dp_parser_data_t *data, const uint8_t *root, size_t depth,
+    void (*callback)(const uint8_t *, size_t, void *), void *arg)
 {
         if (root == NULL) {
@@ -277 +281 @@
         }
         callback(root, depth, arg);
-        uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root);
+        const uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root);
         do {
                 usb_dp_browse_simple_internal(parser, data, child, depth + 1,
@@ -301 +305 @@
  */
 void usb_dp_walk_simple(uint8_t *descriptors, size_t descriptors_size,
-    usb_dp_descriptor_nesting_t *descriptor_nesting,
-    void (*callback)(uint8_t *, size_t, void *), void *arg)
+    const usb_dp_descriptor_nesting_t *descriptor_nesting,
+    walk_callback_t callback, void *arg)
 {
         if ((descriptors == NULL) || (descriptors_size == 0)
@@ -309 +313 @@
         }
 
-        usb_dp_parser_data_t data = {
+        const usb_dp_parser_data_t data = {
                 .data = descriptors,
                 .size = descriptors_size,
@@ -315 +319 @@
         };
 
-        usb_dp_parser_t parser = {
+        const usb_dp_parser_t parser = {
                 .nesting = descriptor_nesting
         };

uspace/lib/usbdev/src/pipesinit.c

@@ -68 +68 @@
  * @return Whether the given descriptor is endpoint descriptor.
  */
-static inline bool is_endpoint_descriptor(uint8_t *descriptor)
+static inline bool is_endpoint_descriptor(const uint8_t *descriptor)
 {
         return descriptor[1] == USB_DESCTYPE_ENDPOINT;
@@ -80 +80 @@
  */
 static bool endpoint_fits_description(const usb_endpoint_description_t *wanted,
-    usb_endpoint_description_t *found)
+    const usb_endpoint_description_t *found)
 {
 #define _SAME(fieldname) ((wanted->fieldname) == (found->fieldname))
@@ -120 +120 @@
 static usb_endpoint_mapping_t *find_endpoint_mapping(
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
-    usb_endpoint_description_t *found_endpoint,
+    const usb_endpoint_description_t *found_endpoint,
     int interface_number, int interface_setting)
 {
@@ -160 +160 @@
     usb_device_connection_t *wire)
 {
-        usb_endpoint_description_t description;
 
         /*
@@ -167 +166 @@
 
         /* Actual endpoint number is in bits 0..3 */
-        usb_endpoint_t ep_no = endpoint->endpoint_address & 0x0F;
-
-        /* Endpoint direction is set by bit 7 */
-        description.direction = (endpoint->endpoint_address & 128)
-            ? USB_DIRECTION_IN : USB_DIRECTION_OUT;
-        /* Transfer type is in bits 0..2 and the enum values corresponds 1:1 */
-        description.transfer_type = endpoint->attributes & 3;
-
-        /*
-         * Get interface characteristics.
-         */
-        description.interface_class = interface->interface_class;
-        description.interface_subclass = interface->interface_subclass;
-        description.interface_protocol = interface->interface_protocol;
+        const usb_endpoint_t ep_no = endpoint->endpoint_address & 0x0F;
+
+        const usb_endpoint_description_t description = {
+                /* Endpoint direction is set by bit 7 */
+                .direction = (endpoint->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->attributes & 3,
+
+                /* Get interface characteristics. */
+                .interface_class = interface->interface_class,
+                .interface_subclass = interface->interface_subclass,
+                .interface_protocol = interface->interface_protocol,
+        };
 
         /*
@@ -224 +224 @@
 static int process_interface(
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
-    usb_dp_parser_t *parser, usb_dp_parser_data_t *parser_data,
-    uint8_t *interface_descriptor)
-{
-        uint8_t *descriptor = usb_dp_get_nested_descriptor(parser,
+    const usb_dp_parser_t *parser, const usb_dp_parser_data_t *parser_data,
+    const uint8_t *interface_descriptor)
+{
+        const uint8_t *descriptor = usb_dp_get_nested_descriptor(parser,
             parser_data, interface_descriptor);
 
@@ -284 +284 @@
 int usb_pipe_initialize_from_configuration(
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
-    uint8_t *configuration_descriptor, size_t configuration_descriptor_size,
+    const uint8_t *config_descriptor, size_t config_descriptor_size,
     usb_device_connection_t *connection)
 {
         assert(connection);
 
-        if (configuration_descriptor == NULL) {
+        if (config_descriptor == NULL) {
                 return EBADMEM;
         }
-        if (configuration_descriptor_size
+        if (config_descriptor_size
             < sizeof(usb_standard_configuration_descriptor_t)) {
                 return ERANGE;
@@ -310 +310 @@
          * Prepare the descriptor parser.
          */
-        usb_dp_parser_t dp_parser = {
+        const usb_dp_parser_t dp_parser = {
                 .nesting = descriptor_nesting
         };
-        usb_dp_parser_data_t dp_data = {
-                .data = configuration_descriptor,
-                .size = configuration_descriptor_size,
+        const usb_dp_parser_data_t dp_data = {
+                .data = config_descriptor,
+                .size = config_descriptor_size,
                 .arg = connection
         };
@@ -322 +322 @@
          * Iterate through all interfaces.
          */
-        uint8_t *interface = usb_dp_get_nested_descriptor(&dp_parser,
-            &dp_data, configuration_descriptor);
+        const uint8_t *interface = usb_dp_get_nested_descriptor(&dp_parser,
+            &dp_data, config_descriptor);
         if (interface == NULL) {
                 return ENOENT;
@@ -329 +329 @@
         do {
                 (void) process_interface(mapping, mapping_count,
-                    &dp_parser, &dp_data,
-                    interface);
+                    &dp_parser, &dp_data, interface);
                 interface = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
-                    configuration_descriptor, interface);
+                    config_descriptor, interface);
         } while (interface != NULL);
 
@@ -514 +513 @@
 {
         assert(pipe);
+        assert(pipe->wire);
         assert(hc_connection);
         

uspace/lib/usbdev/src/request.c

@@ -425 +425 @@
 
         /* Everything is okay, copy the descriptor. */
-        memcpy(descriptor, &descriptor_tmp,
-            sizeof(descriptor_tmp));
+        memcpy(descriptor, &descriptor_tmp, sizeof(descriptor_tmp));
 
         return EOK;
@@ -470 +469 @@
 
         /* Everything is okay, copy the descriptor. */
-        memcpy(descriptor, &descriptor_tmp,
-            sizeof(descriptor_tmp));
+        memcpy(descriptor, &descriptor_tmp, sizeof(descriptor_tmp));
 
         return EOK;

uspace/lib/usbhid/include/usb/hid/hiddescriptor.h

@@ -42 +42 @@
 #include <usb/hid/hidtypes.h>
 
-int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 
+int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
                 const uint8_t *data, size_t size);
-
-void usb_hid_free_report(usb_hid_report_t *report);
 
 void usb_hid_descriptor_print(usb_hid_report_t *report);
 
 int usb_hid_report_init(usb_hid_report_t *report);
+
+void usb_hid_report_deinit(usb_hid_report_t *report);
 
 int usb_hid_report_append_fields(usb_hid_report_t *report,
@@ -78 +78 @@
 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
 
-void usb_hid_free_report_list(list_t *list);
-
 usb_hid_report_item_t *usb_hid_report_item_clone(
                 const usb_hid_report_item_t *item);

uspace/lib/usbhid/src/hiddescriptor.c

@@ -974 +974 @@
 /*---------------------------------------------------------------------------*/
 
-/**
- * Releases whole linked list of report items
- *
- * @param list List of report descriptor items (usb_hid_report_item_t)
- * @return void
- */
-void usb_hid_free_report_list(list_t *list)
-{
-        return; /* XXX What's this? */
-        
-/*      usb_hid_report_item_t *report_item;
-        link_t *next;
-        
-        if(list == NULL || list_empty(list)) {
-            return;
-        }
-        
-        next = list->head.next;
-        while (next != &list->head) {
-                report_item = list_get_instance(next, usb_hid_report_item_t,
-                    rpath_items_link);
-
-                while(!list_empty(&report_item->usage_path->link)) {
-                        usb_hid_report_remove_last_item(report_item->usage_path);
-                }
-
-                
-            next = next->next;
-            
-            free(report_item);
-        }
-        
-        return;
-        */
-}
-/*---------------------------------------------------------------------------*/
 
 /** Frees the HID report descriptor parser structure 
@@ -1016 +980 @@
  * @return void
  */
-void usb_hid_free_report(usb_hid_report_t *report)
+void usb_hid_report_deinit(usb_hid_report_t *report)
 {
         if(report == NULL){

uspace/lib/usbhid/src/hidparser.c

@@ -52 +52 @@
         int32_t value);
 
-int usb_pow(int a, int b);
-
-/*---------------------------------------------------------------------------*/
-
-// TODO: tohle ma bejt asi jinde
-int usb_pow(int a, int b)
-{
-        switch(b) {
+/*---------------------------------------------------------------------------*/
+
+static int usb_pow(int a, int b)
+{
+        switch (b) {
         case 0:
                 return 1;
@@ -67 +64 @@
                 break;
         default:
-                return a * usb_pow(a, b-1);
+                return a * usb_pow(a, b - 1);
                 break;
         }
@@ -81 +78 @@
  */
 size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id, 
-                           usb_hid_report_type_t type)
+    usb_hid_report_type_t type)
 {
         usb_hid_report_description_t *report_des;
 
-        if(report == NULL) {
+        if (report == NULL) {
                 return 0;
         }
 
-        report_des = usb_hid_report_find_description (report, report_id, type);
-        if(report_des == NULL){
+        report_des = usb_hid_report_find_description(report, report_id, type);
+        if (report_des == NULL) {
                 return 0;
-        }
-        else {
+        } else {
                 return report_des->item_length;
         }
@@ -106 +102 @@
  */
 size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, 
-                           usb_hid_report_type_t type)
+    usb_hid_report_type_t type)
 {
         usb_hid_report_description_t *report_des;
 
-        if(report == NULL) {
+        if (report == NULL) {
                 return 0;
         }
 
-        report_des = usb_hid_report_find_description (report, report_id, type);
-        if(report_des == NULL){
+        report_des = usb_hid_report_find_description(report, report_id, type);
+        if (report_des == NULL) {
                 return 0;
-        }
-        else {
+        } else {
                 return ((report_des->bit_length + 7) / 8) ;
         }
@@ -133 +128 @@
  */ 
 int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, 
-        size_t size, uint8_t *report_id)
+    size_t size, uint8_t *report_id)
 {
         usb_hid_report_field_t *item;
@@ -140 +135 @@
         usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
         
-        if(report == NULL) {
+        if (report == NULL) {
                 return EINVAL;
         }
 
-        if(report->use_report_ids != 0) {
+        if (report->use_report_ids != 0) {
                 *report_id = data[0];
-        }       
-        else {
+        } else {
                 *report_id = 0;
         }
 
-
         report_des = usb_hid_report_find_description(report, *report_id, 
-                type);
-
-        if(report_des == NULL) {
+            type);
+
+        if (report_des == NULL) {
                 return EINVAL;
         }
@@ -162 +155 @@
         list_foreach(report_des->report_items, list_item) {
                 item = list_get_instance(list_item, usb_hid_report_field_t, 
-                                ritems_link);
-
-                if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
+                    ritems_link);
+
+                if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
                         
-                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0){
-
-                                // array
+                        if (USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
+                                /* array */
                                 item->value = 
                                         usb_hid_translate_data(item, data);
                 
                                 item->usage = USB_HID_EXTENDED_USAGE(
-                                    item->usages[
-                                    item->value - item->physical_minimum]);
+                                    item->usages[item->value -
+                                    item->physical_minimum]);
 
                                 item->usage_page = 
                                     USB_HID_EXTENDED_USAGE_PAGE(
-                                    item->usages[
-                                    item->value - item->physical_minimum]);
-
-                                usb_hid_report_set_last_item (
+                                    item->usages[item->value -
+                                    item->physical_minimum]);
+
+                                usb_hid_report_set_last_item(
                                     item->collection_path, 
                                     USB_HID_TAG_CLASS_GLOBAL, 
                                     item->usage_page);
 
-                                usb_hid_report_set_last_item (
+                                usb_hid_report_set_last_item(
                                     item->collection_path, 
                                     USB_HID_TAG_CLASS_LOCAL, item->usage);
-                                
-                        }
-                        else {
-                                // variable item
+                        } else {
+                                /* variable item */
                                 item->value = usb_hid_translate_data(item, 
                                     data);                              
@@ -200 +190 @@
         
         return EOK;
-        
 }
 
@@ -217 +206 @@
         int part_size;
         
-        int32_t value=0;
-        int32_t mask=0;
-        const uint8_t *foo=0;
-
-        // now only shot tags are allowed
-        if(item->size > 32) {
+        int32_t value = 0;
+        int32_t mask = 0;
+        const uint8_t *foo = 0;
+
+        /* now only short tags are allowed */
+        if (item->size > 32) {
                 return 0;
         }
 
-        if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
+        if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
                 item->physical_minimum = item->logical_minimum;
                 item->physical_maximum = item->logical_maximum;                 
@@ -232 +221 @@
         
 
-        if(item->physical_maximum == item->physical_minimum){
+        if (item->physical_maximum == item->physical_minimum) {
             resolution = 1;
-        }
-        else {
+        } else {
             resolution = (item->logical_maximum - item->logical_minimum) / 
                 ((item->physical_maximum - item->physical_minimum) * 
-                (usb_pow(10,(item->unit_exponent))));
+                (usb_pow(10, (item->unit_exponent))));
         }
 
         offset = item->offset;
         // FIXME
-        if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
+        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
+                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);
+                                mask =  ((1 << (item->size - part_size)) - 1);
                                 value = (*foo & mask);
-                        }
-                        else if(i == ((offset+item->size-1)/8)){
-                                // the lower one
+                        } 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));
+                                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;
+                                    (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));
-        }
-
-        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
+        } else {                
+                foo = data + (offset / 8);
+                mask = ((1 << item->size) - 1) <<
+                    (8 - ((offset % 8) + item->size));
+                value = (*foo & mask) >> (8 - ((offset % 8) + item->size));
+        }
+
+        if ((item->logical_minimum < 0) || (item->logical_maximum < 0)) {
                 value = USB_HID_UINT32_TO_INT32(value, item->size);
         }
 
-        return (int)(((value - item->logical_minimum) / resolution) + 
-                item->physical_minimum);
-        
+        return (int) (((value - item->logical_minimum) / resolution) + 
+            item->physical_minimum);
 }
 
@@ -299 +286 @@
  */
 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, 
-        uint8_t report_id)
-{
-        if(report == NULL) {
+    uint8_t report_id)
+{
+        if (report == NULL) {
                 *size = 0;
                 return NULL;
@@ -310 +297 @@
         list_foreach(report->reports, report_it) {
                 report_des = list_get_instance(report_it,
-                        usb_hid_report_description_t, reports_link);
+                    usb_hid_report_description_t, reports_link);
                 
-                if((report_des->report_id == report_id) &&
-                        (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
+                if ((report_des->report_id == report_id) &&
+                    (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)) {
                         break;
                 }
         }
 
-        if(report_des == NULL){
+        if (report_des == NULL) {
                 *size = 0;
                 return NULL;
-        }
-        else {
-                *size = (report_des->bit_length + (8 - 1))/8;
+        } else {
+                *size = (report_des->bit_length + (8 - 1)) / 8;
                 uint8_t *ret = malloc((*size) * sizeof(uint8_t));
                 memset(ret, 0, (*size) * sizeof(uint8_t));
@@ -337 +323 @@
  */
 void usb_hid_report_output_free(uint8_t *output)
-
-{
-        if(output != NULL) {
-                free (output);
+{
+        if (output != NULL) {
+                free(output);
         }
 }
@@ -354 +339 @@
  */
 int usb_hid_report_output_translate(usb_hid_report_t *report, 
-        uint8_t report_id, uint8_t *buffer, size_t size)
-{
-        int32_t value=0;
+    uint8_t report_id, uint8_t *buffer, size_t size)
+{
+        int32_t value = 0;
         int offset;
         int length;
         int32_t tmp_value;
         
-        if(report == NULL) {
+        if (report == NULL) {
                 return EINVAL;
         }
 
-        if(report->use_report_ids != 0) {
+        if (report->use_report_ids != 0) {
                 buffer[0] = report_id;          
         }
 
         usb_hid_report_description_t *report_des;
-        report_des = usb_hid_report_find_description (report, report_id, 
-                USB_HID_REPORT_TYPE_OUTPUT);
-        
-        if(report_des == NULL){
+        report_des = usb_hid_report_find_description(report, report_id, 
+            USB_HID_REPORT_TYPE_OUTPUT);
+        
+        if (report_des == NULL) {
                 return EINVAL;
         }
@@ -384 +369 @@
 
                 value = usb_hid_translate_data_reverse(report_item, 
-                        report_item->value);
+                    report_item->value);
 
                 offset = report_des->bit_length - report_item->offset - 1;
@@ -391 +376 @@
                 usb_log_debug("\ttranslated value: %x\n", value);
 
-                if((offset/8) == ((offset+length-1)/8)) {
-                        // je to v jednom bytu
-                        if(((size_t)(offset/8) >= size) || 
-                                ((size_t)(offset+length-1)/8) >= size) {
+                if ((offset / 8) == ((offset + length - 1) / 8)) {
+                        if (((size_t) (offset / 8) >= size) || 
+                            ((size_t) (offset + length - 1) / 8) >= size) {
                                 break; // TODO ErrorCode
                         }
-                        size_t shift = 8 - offset%8 - length;
+                        size_t shift = 8 - offset % 8 - length;
                         value = value << shift;                                                 
-                        value = value & (((1 << length)-1) << shift);
+                        value = value & (((1 << length) - 1) << shift);
                                 
                         uint8_t mask = 0;
                         mask = 0xff - (((1 << length) - 1) << shift);
-                        buffer[offset/8] = (buffer[offset/8] & mask) | value;
-                }
-                else {
+                        buffer[offset / 8] = (buffer[offset / 8] & mask) |
+                            value;
+                } else {
                         int i = 0;
                         uint8_t mask = 0;
-                        for(i = (offset/8); i <= ((offset+length-1)/8); i++) {
-                                if(i == (offset/8)) {
+                        for (i = (offset / 8);
+                            i <= ((offset + length - 1) / 8); i++) {
+                                if (i == (offset / 8)) {
                                         tmp_value = value;
                                         tmp_value = tmp_value & 
-                                                ((1 << (8-(offset%8)))-1);
-
-                                        tmp_value = tmp_value << (offset%8);
-        
-                                        mask = ~(((1 << (8-(offset%8)))-1) << 
-                                                        (offset%8));
+                                            ((1 << (8 - (offset % 8))) - 1);
+
+                                        tmp_value = tmp_value << (offset % 8);
+        
+                                        mask = ~(((1 << (8 - (offset % 8))) - 1)
+                                            << (offset % 8));
 
                                         buffer[i] = (buffer[i] & mask) | 
-                                                tmp_value;
-                                }
-                                else if (i == ((offset + length -1)/8)) {
+                                            tmp_value;
+                                } else if (i == ((offset + length - 1) / 8)) {
                                         
                                         value = value >> (length - 
-                                                ((offset + length) % 8));
+                                            ((offset + length) % 8));
 
                                         value = value & ((1 << (length - 
-                                                ((offset + length) % 8))) - 1);
+                                            ((offset + length) % 8))) - 1);
                                 
                                         mask = (1 << (length - 
-                                                ((offset + length) % 8))) - 1;
+                                            ((offset + length) % 8))) - 1;
 
                                         buffer[i] = (buffer[i] & mask) | value;
-                                }
-                                else {
-                                        buffer[i] = value & (0xFF << i);
+                                } else {
+                                        buffer[i] = value & (0xff << i);
                                 }
                         }
                 }
 
-                // reset value
+                /* reset value */
                 report_item->value = 0;
         }
@@ -456 +439 @@
  */
 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 
-        int value)
-{
-        int ret=0;
+    int value)
+{
+        int ret = 0;
         int resolution;
 
-        if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
+        if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
                 ret = item->logical_minimum;
         }
 
-        if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
+        if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
                 item->physical_minimum = item->logical_minimum;
                 item->physical_maximum = item->logical_maximum;                 
         }
         
-        // variable item
-        if(item->physical_maximum == item->physical_minimum){
+        /* variable item */
+        if (item->physical_maximum == item->physical_minimum) {
             resolution = 1;
-        }
-        else {
+        } else {
             resolution = (item->logical_maximum - item->logical_minimum) /
                 ((item->physical_maximum - item->physical_minimum) *
-                (usb_pow(10,(item->unit_exponent))));
+                (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, 
-                item->logical_minimum, ret);
-        
-        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
+            item->logical_minimum;
+
+        usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), "
+            "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);
         }
-        return (int32_t)0 + ret;
+
+        return (int32_t) 0 + ret;
 }
 
@@ -501 +484 @@
  */
 usb_hid_report_item_t *usb_hid_report_item_clone(
-        const usb_hid_report_item_t *item)
+    const usb_hid_report_item_t *item)
 {
         usb_hid_report_item_t *new_report_item;
         
-        if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
+        if (!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
                 return NULL;
         }                                       
@@ -529 +512 @@
  */
 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_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_find_description(report, path->report_id, type);
+            usb_hid_report_find_description(report, path->report_id, type);
 
         link_t *field_it;
         
-        if(report_des == NULL){
+        if (report_des == NULL) {
                 return NULL;
         }
 
-        if(field == NULL){
+        if (field == NULL) {
                 field_it = report_des->report_items.head.next;
-        }
-        else {
+        } else {
                 field_it = field->ritems_link.next;
         }
 
-        while(field_it != &report_des->report_items.head) {
+        while (field_it != &report_des->report_items.head) {
                 field = list_get_instance(field_it, usb_hid_report_field_t, 
-                        ritems_link);
-
-                if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
-                        usb_hid_report_path_append_item (
-                                field->collection_path, field->usage_page, 
-                                field->usage);
-
-                        if(usb_hid_report_compare_usage_path(
-                                field->collection_path, path, flags) == EOK){
-
+                    ritems_link);
+
+                if (USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
+                        usb_hid_report_path_append_item(field->collection_path,
+                            field->usage_page, field->usage);
+
+                        if (usb_hid_report_compare_usage_path(
+                            field->collection_path, path, flags) == EOK) {
                                 usb_hid_report_remove_last_item(
-                                        field->collection_path);
-
+                                    field->collection_path);
                                 return field;
                         }
-                        usb_hid_report_remove_last_item (
-                                field->collection_path);
+                        usb_hid_report_remove_last_item(field->collection_path);
                 }
                 field_it = field_it->next;
@@ -586 +564 @@
  * @retval report_id otherwise
  */
-uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, 
-        uint8_t report_id, usb_hid_report_type_t type)
-{
-        if(report == NULL){
+uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, uint8_t report_id,
+    usb_hid_report_type_t type)
+{
+        if (report == NULL) {
                 return 0;
         }
@@ -596 +574 @@
         link_t *report_it;
         
-        if(report_id > 0) {
+        if (report_id > 0) {
                 report_des = usb_hid_report_find_description(report, report_id, 
-                        type);
-                if(report_des == NULL) {
+                    type);
+                if (report_des == NULL) {
                         return 0;
-                }
-                else {
+                } else {
                         report_it = report_des->reports_link.next;
                 }       
-        }
-        else {
+        } else {
                 report_it = report->reports.head.next;
         }
 
-        while(report_it != &report->reports.head) {
+        while (report_it != &report->reports.head) {
                 report_des = list_get_instance(report_it, 
-                        usb_hid_report_description_t, reports_link);
-
-                if(report_des->type == type){
+                    usb_hid_report_description_t, reports_link);
+
+                if (report_des->type == type) {
                         return report_des->report_id;
                 }
@@ -635 +611 @@
 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
 {
-        if(report_item == NULL) {
+        if (report_item == NULL) {
                 return;
         }
@@ -651 +627 @@
         report_item->string_minimum = 0;
         report_item->string_maximum = 0;
-
-        return;
-}
+}
+
 /**
  * @}

uspace/lib/usbhid/src/hidreport.c

@@ -69 +69 @@
          * First nested descriptor of the configuration descriptor.
          */
-        uint8_t *d = 
+        const uint8_t *d = 
             usb_dp_get_nested_descriptor(&parser, &parser_data, 
             dev->descriptors.configuration);
@@ -92 +92 @@
          * First nested descriptor of the interface descriptor.
          */
-        uint8_t *iface_desc = d;
+        const uint8_t *iface_desc = d;
         d = usb_dp_get_nested_descriptor(&parser, &parser_data, iface_desc);
         

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

@@ -36 +36 @@
 #define LIBUSBHOST_HOST_ENDPOINT_H
 
-#include <assert.h>
 #include <bool.h>
 #include <adt/list.h>
 #include <fibril_synch.h>
-
 #include <usb/usb.h>
 
+/** Host controller side endpoint structure. */
 typedef struct endpoint {
+        /** Part of linked list. */
+        link_t link;
+        /** USB address. */
         usb_address_t address;
+        /** USB endpoint number. */
         usb_endpoint_t endpoint;
+        /** Communication direction. */
         usb_direction_t direction;
+        /** USB transfer type. */
         usb_transfer_type_t transfer_type;
+        /** Communication speed. */
         usb_speed_t speed;
+        /** Maximum size of data packets. */
         size_t max_packet_size;
+        /** 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;
-        volatile bool active;
-        void (*destroy_hook)(struct endpoint *);
+        /** 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;
 } endpoint_t;
 
-endpoint_t * endpoint_get(usb_address_t address, usb_endpoint_t endpoint,
+endpoint_t * endpoint_create(usb_address_t address, usb_endpoint_t endpoint,
     usb_direction_t direction, usb_transfer_type_t type, usb_speed_t speed,
-    size_t max_packet_size);
-
+    size_t max_packet_size, size_t bw);
 void endpoint_destroy(endpoint_t *instance);
 
 void endpoint_set_hc_data(endpoint_t *instance,
-    void *data, void (*destroy_hook)(endpoint_t *),
-    int (*toggle_get)(void *), void (*toggle_set)(void *, int));
-
+    void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int));
 void endpoint_clear_hc_data(endpoint_t *instance);
 
 void endpoint_use(endpoint_t *instance);
-
 void endpoint_release(endpoint_t *instance);
 
 int endpoint_toggle_get(endpoint_t *instance);
-
 void endpoint_toggle_set(endpoint_t *instance, int toggle);
 
-void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target);
+/** list_get_instance wrapper.
+ * @param item Pointer to link member.
+ * @return Pointer to enpoint_t structure.
+ */
+static inline endpoint_t * endpoint_get_instance(link_t *item)
+{
+        return list_get_instance(item, endpoint_t, link);
+}
 #endif
 /**

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

@@ -37 +37 @@
 
 #include <assert.h>
+#include <usbhc_iface.h>
+
 #include <usb/host/usb_device_manager.h>
 #include <usb/host/usb_endpoint_manager.h>
 #include <usb/host/usb_transfer_batch.h>
-#include <usbhc_iface.h>
 
 typedef struct hcd hcd_t;
 
+/** Generic host controller driver structure. */
 struct hcd {
+        /** Device manager storing handles and addresses. */
         usb_device_manager_t dev_manager;
+        /** Endpoint manager. */
         usb_endpoint_manager_t ep_manager;
+
+        /** Device specific driver data. */
         void *private_data;
-
+        /** Transfer scheduling, implement in device driver. */
         int (*schedule)(hcd_t *, usb_transfer_batch_t *);
+        /** Hook called upon registering new endpoint. */
         int (*ep_add_hook)(hcd_t *, endpoint_t *);
+        /** Hook called upon removing of an endpoint. */
+        void (*ep_remove_hook)(hcd_t *, endpoint_t *);
 };
 /*----------------------------------------------------------------------------*/
-static inline int hcd_init(hcd_t *hcd, size_t bandwidth,
+/** Initialize hcd_t structure.
+ * Initializes device and endpoint managers. Sets data nd hook pointer to NULL.
+ * @param hcd hcd_t structure to initialize, non-null.
+ * @param bandwidth Available bandwidth, passed to endpoint manager.
+ * @param bw_count Bandwidth compute function, passed to endpoint manager.
+ */
+static inline void hcd_init(hcd_t *hcd, size_t bandwidth,
     size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t))
 {
         assert(hcd);
         usb_device_manager_init(&hcd->dev_manager);
-        return usb_endpoint_manager_init(&hcd->ep_manager, bandwidth, bw_count);
+        usb_endpoint_manager_init(&hcd->ep_manager, bandwidth, bw_count);
+        hcd->private_data = NULL;
+        hcd->schedule = NULL;
+        hcd->ep_add_hook = NULL;
+        hcd->ep_remove_hook = NULL;
 }
 /*----------------------------------------------------------------------------*/
-static inline void hcd_destroy(hcd_t *hcd)
-{
-        usb_endpoint_manager_destroy(&hcd->ep_manager);
-}
-/*----------------------------------------------------------------------------*/
-static inline void reset_ep_if_need(
-    hcd_t *hcd, usb_target_t target, const char* setup_data)
+/** Check registered endpoints and reset toggle bit if necessary.
+ * @param hcd hcd_t structure, non-null.
+ * @param target Control communication target.
+ * @param setup_data Setup packet of the control communication.
+ */
+static inline void reset_ep_if_need(hcd_t *hcd, usb_target_t target,
+    const char setup_data[8])
 {
         assert(hcd);
-        usb_endpoint_manager_reset_if_need(
+        usb_endpoint_manager_reset_eps_if_need(
             &hcd->ep_manager, target, (const uint8_t *)setup_data);
 }
 /*----------------------------------------------------------------------------*/
-static inline hcd_t * fun_to_hcd(ddf_fun_t *fun)
+/** Data retrieve wrapper.
+ * @param fun ddf function, non-null.
+ * @return pointer cast to hcd_t*.
+ */
+static inline hcd_t * fun_to_hcd(const ddf_fun_t *fun)
 {
         assert(fun);

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

@@ -49 +49 @@
 #define USB_ADDRESS_COUNT (USB11_ADDRESS_MAX + 1)
 
-/** Information about attached USB device. */
-struct usb_device_info {
-        usb_speed_t speed;
-        bool occupied;
-        devman_handle_t handle;
-};
-
 /** Host controller device manager.
- * You shall not access members directly but only using functions below.
+ * You shall not access members directly.
  */
 typedef struct {
-        struct usb_device_info devices[USB_ADDRESS_COUNT];
+        /** Information about attached USB devices. */
+        struct {
+                usb_speed_t speed;      /**< Device speed */
+                bool occupied;          /**< The address is in use. */
+                devman_handle_t handle; /**< Devman handle of the device. */
+        } devices[USB_ADDRESS_COUNT];
         fibril_mutex_t guard;
+        /** The last reserved address */
         usb_address_t last_address;
 } usb_device_manager_t;
@@ -70 +69 @@
     usb_device_manager_t *instance, usb_speed_t speed);
 
-void usb_device_manager_bind(usb_device_manager_t *instance,
+int usb_device_manager_bind(usb_device_manager_t *instance,
     usb_address_t address, devman_handle_t handle);
 
-void usb_device_manager_release(usb_device_manager_t *instance,
+int usb_device_manager_release(usb_device_manager_t *instance,
     usb_address_t address);
 
-usb_address_t usb_device_manager_find(usb_device_manager_t *instance,
+usb_address_t usb_device_manager_find_address(usb_device_manager_t *instance,
     devman_handle_t handle);
 
-bool usb_device_manager_find_by_address(usb_device_manager_t *instance,
-    usb_address_t address, devman_handle_t *handle);
-
-usb_speed_t usb_device_manager_get_speed(usb_device_manager_t *instance,
-    usb_address_t address);
+int usb_device_manager_get_info_by_address(usb_device_manager_t *instance,
+    usb_address_t address, devman_handle_t *handle, usb_speed_t *speed);
 #endif
 /**

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

@@ -40 +40 @@
 #define LIBUSBHOST_HOST_USB_ENDPOINT_MANAGER_H
 
-#include <stdlib.h>
-#include <adt/hash_table.h>
+#include <adt/list.h>
 #include <fibril_synch.h>
 #include <usb/usb.h>
+
 #include <usb/host/endpoint.h>
 
-#define BANDWIDTH_TOTAL_USB11 12000000
+/** Bytes per second in FULL SPEED */
+#define BANDWIDTH_TOTAL_USB11 (12000000 / 8)
+/** 90% of total bandwidth is available for periodic transfers */
 #define BANDWIDTH_AVAILABLE_USB11 ((BANDWIDTH_TOTAL_USB11 / 10) * 9)
+/** 16 addresses per list */
+#define ENDPOINT_LIST_COUNT 8
 
+/** Endpoint management structure */
 typedef struct usb_endpoint_manager {
-        hash_table_t ep_table;
+        /** Store endpoint_t instances */
+        list_t endpoint_lists[ENDPOINT_LIST_COUNT];
+        /** Prevents races accessing lists */
         fibril_mutex_t guard;
+        /** Size of the bandwidth pool */
         size_t free_bw;
+        /** Use this function to count bw required by EP */
         size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t);
 } usb_endpoint_manager_t;
@@ -63 +72 @@
     size_t (*bw_count)(usb_speed_t, usb_transfer_type_t, size_t, size_t));
 
-void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance);
+void usb_endpoint_manager_reset_eps_if_need(usb_endpoint_manager_t *instance,
+    usb_target_t target, const uint8_t data[8]);
 
-int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
-    endpoint_t *ep, size_t data_size);
-
-int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance,
+int usb_endpoint_manager_register_ep(
+    usb_endpoint_manager_t *instance, endpoint_t *ep, size_t data_size);
+int usb_endpoint_manager_unregister_ep(
+    usb_endpoint_manager_t *instance, endpoint_t *ep);
+endpoint_t * usb_endpoint_manager_find_ep(usb_endpoint_manager_t *instance,
     usb_address_t address, usb_endpoint_t ep, usb_direction_t direction);
 
-endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance,
-    usb_address_t address, usb_endpoint_t ep, usb_direction_t direction,
-    size_t *bw);
-
-void usb_endpoint_manager_reset_if_need(
-    usb_endpoint_manager_t *instance, usb_target_t target, const uint8_t *data);
-
-/** Wrapper combining allocation and insertion */
-static inline int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance,
+int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance,
     usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
     usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size,
-    size_t data_size)
-{
-        endpoint_t *ep = endpoint_get(
-            address, endpoint, direction, type, speed, max_packet_size);
-        if (!ep)
-                return ENOMEM;
+    size_t data_size, int (*callback)(endpoint_t *, void *), void *arg);
 
-        const int ret =
-            usb_endpoint_manager_register_ep(instance, ep, data_size);
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        }
-        return ret;
-}
+int usb_endpoint_manager_remove_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    void (*callback)(endpoint_t *, void *), void *arg);
 #endif
 /**
  * @}
  */
-

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

@@ -43 +43 @@
 #define USB_SETUP_PACKET_SIZE 8
 
-typedef struct usb_transfer_batch usb_transfer_batch_t;
 /** Structure stores additional data needed for communication with EP */
-struct usb_transfer_batch {
+typedef struct usb_transfer_batch {
         /** Endpoint used for communication */
         endpoint_t *ep;
@@ -77 +76 @@
         /** Callback to properly remove driver data during destruction */
         void (*private_data_dtor)(void *p_data);
-};
+} usb_transfer_batch_t;
 
 /** Printf formatting string for dumping usb_transfer_batch_t. */
@@ -93 +92 @@
 
 
-usb_transfer_batch_t * usb_transfer_batch_get(
+usb_transfer_batch_t * usb_transfer_batch_create(
     endpoint_t *ep,
     char *buffer,
@@ -105 +104 @@
     void (*private_data_dtor)(void *p_data)
 );
+void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance);
 
-void usb_transfer_batch_finish(usb_transfer_batch_t *instance,
+void usb_transfer_batch_finish(const usb_transfer_batch_t *instance,
     const void* data, size_t size);
-void usb_transfer_batch_call_in(usb_transfer_batch_t *instance);
-void usb_transfer_batch_call_out(usb_transfer_batch_t *instance);
-void usb_transfer_batch_dispose(usb_transfer_batch_t *instance);
-
-/** Helper function, calls callback and correctly destroys batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-static inline void usb_transfer_batch_call_in_and_dispose(
-    usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_in(instance);
-        usb_transfer_batch_dispose(instance);
-}
 /*----------------------------------------------------------------------------*/
-/** Helper function calls callback and correctly destroys batch structure.
- *
- * @param[in] instance Batch structure to use.
- */
-static inline void usb_transfer_batch_call_out_and_dispose(
-    usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        usb_transfer_batch_call_out(instance);
-        usb_transfer_batch_dispose(instance);
-}
-/*----------------------------------------------------------------------------*/
-/** Helper function, sets error value and finishes transfer.
+/** Override error value and finishes transfer.
  *
  * @param[in] instance Batch structure to use.
@@ -151 +124 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Helper function, determines batch direction absed on the present callbacks
- * @param[in] instance Batch structure to use.
+/** 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.
  */

uspace/lib/usbhost/src/endpoint.c

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-/** @addtogroup drvusbuhcihc
+/** @addtogroup libusbhost
  * @{
  */
@@ -39 +38 @@
 #include <usb/host/endpoint.h>
 
-endpoint_t * endpoint_get(usb_address_t address, usb_endpoint_t endpoint,
+/** 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)
+    size_t max_packet_size, size_t bw)
 {
         endpoint_t *instance = malloc(sizeof(endpoint_t));
@@ -51 +60 @@
                 instance->speed = speed;
                 instance->max_packet_size = max_packet_size;
+                instance->bandwidth = bw;
                 instance->toggle = 0;
                 instance->active = false;
-                instance->destroy_hook = NULL;
                 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);
-                endpoint_clear_hc_data(instance);
         }
         return instance;
 }
 /*----------------------------------------------------------------------------*/
+/** Properly dispose of endpoint_t structure.
+ * @param instance endpoint_t structure.
+ */
 void endpoint_destroy(endpoint_t *instance)
 {
         assert(instance);
+        //TODO: Do something about waiting fibrils.
         assert(!instance->active);
-        if (instance->hc_data.data) {
-                assert(instance->destroy_hook);
-                instance->destroy_hook(instance);
-        }
+        assert(instance->hc_data.data == NULL);
         free(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, void (*destroy_hook)(endpoint_t *),
-    int (*toggle_get)(void *), void (*toggle_set)(void *, int))
+    void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int))
 {
         assert(instance);
-        instance->destroy_hook = destroy_hook;
+        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);
-        instance->destroy_hook = NULL;
+        fibril_mutex_lock(&instance->guard);
         instance->hc_data.data = NULL;
         instance->hc_data.toggle_get = NULL;
         instance->hc_data.toggle_set = NULL;
+        fibril_mutex_unlock(&instance->guard);
 }
 /*----------------------------------------------------------------------------*/
+/** Mark the endpoint as active and block access for further fibrils.
+ * @param instance endpoint_t structure.
+ */
 void endpoint_use(endpoint_t *instance)
 {
@@ -105 +129 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Mark the endpoint as inactive and allow access for further fibrils.
+ * @param instance endpoint_t structure.
+ */
 void endpoint_release(endpoint_t *instance)
 {
@@ -114 +141 @@
 }
 /*----------------------------------------------------------------------------*/
+/** 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);
-        return (int)instance->toggle;
+        const int ret = instance->toggle;
+        fibril_mutex_unlock(&instance->guard);
+        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);
-        instance->toggle = toggle;
-}
-/*----------------------------------------------------------------------------*/
-void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target)
-{
-        assert(instance);
-        if (instance->address == target.address &&
-            (instance->endpoint == target.endpoint || target.endpoint == 0))
-                endpoint_toggle_set(instance, 0);
+        fibril_mutex_unlock(&instance->guard);
 }
 /**

uspace/lib/usbhost/src/iface.c

@@ -49 +49 @@
         assert(hcd);
 
-        int ret;
-
-        size_t res_bw;
-        endpoint_t *ep = usb_endpoint_manager_get_ep(&hcd->ep_manager,
-            target.address, target.endpoint, direction, &res_bw);
+        endpoint_t *ep = usb_endpoint_manager_find_ep(&hcd->ep_manager,
+            target.address, target.endpoint, direction);
         if (ep == NULL) {
                 usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
@@ -65 +62 @@
         const size_t bw = bandwidth_count_usb11(
             ep->speed, ep->transfer_type, size, ep->max_packet_size);
-        if (res_bw < bw) {
+        /* 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",
-                    target.address, target.endpoint, name, bw, res_bw);
+                    ep->address, ep->endpoint, name, bw, ep->bandwidth);
                 return ENOSPC;
         }
@@ -78 +76 @@
         /* No private data and no private data dtor */
         usb_transfer_batch_t *batch =
-            usb_transfer_batch_get(ep, data, size, setup_data,
+            usb_transfer_batch_create(ep, data, size, setup_data,
             in, out, arg, fun, NULL, NULL);
         if (!batch) {
@@ -84 +82 @@
         }
 
-        ret = hcd->schedule(hcd, batch);
+        const int ret = hcd->schedule(hcd, batch);
         if (ret != EOK)
-                usb_transfer_batch_dispose(batch);
+                usb_transfer_batch_destroy(batch);
 
         return ret;
@@ -130 +128 @@
 
         usb_log_debug("Address bind %d-%" PRIun ".\n", address, handle);
-        usb_device_manager_bind(&hcd->dev_manager, address, handle);
-        return EOK;
+        return usb_device_manager_bind(&hcd->dev_manager, address, handle);
 }
 /*----------------------------------------------------------------------------*/
@@ -147 +144 @@
         hcd_t *hcd = fun_to_hcd(fun);
         assert(hcd);
-        const bool found =
-            usb_device_manager_find_by_address(&hcd->dev_manager, address, handle);
-        return found ? EOK : ENOENT;
+        return usb_device_manager_get_info_by_address(
+            &hcd->dev_manager, address, handle, NULL);
 }
 /*----------------------------------------------------------------------------*/
@@ -166 +162 @@
         usb_device_manager_release(&hcd->dev_manager, address);
         return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static int register_helper(endpoint_t *ep, void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(ep);
+        assert(hcd);
+        if (hcd->ep_add_hook)
+                return hcd->ep_add_hook(hcd, ep);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+static void unregister_helper(endpoint_t *ep, void *arg)
+{
+        hcd_t *hcd = arg;
+        assert(ep);
+        assert(hcd);
+        if (hcd->ep_remove_hook)
+                hcd->ep_remove_hook(hcd, ep);
 }
 /*----------------------------------------------------------------------------*/
@@ -180 +195 @@
         /* Default address is not bound or registered,
          * thus it does not provide speed info. */
-        const usb_speed_t speed = (address == 0) ? ep_speed :
-            usb_device_manager_get_speed(&hcd->dev_manager, address);
+        usb_speed_t speed = ep_speed;
+        /* NOTE The function will return EINVAL and won't
+         * touch speed variable for default address */
+        usb_device_manager_get_info_by_address(
+            &hcd->dev_manager, address, NULL, &speed);
 
         usb_log_debug("Register endpoint %d:%d %s-%s %s %zuB %ums.\n",
@@ -188 +206 @@
             max_packet_size, interval);
 
-        endpoint_t *ep = endpoint_get(
-            address, endpoint, direction, transfer_type, speed, max_packet_size);
-        if (!ep)
-                return ENOMEM;
-        int ret = EOK;
-
-        if (hcd->ep_add_hook) {
-                ret = hcd->ep_add_hook(hcd, ep);
-        }
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-                return ret;
-        }
-
-        ret = usb_endpoint_manager_register_ep(&hcd->ep_manager, ep, size);
-        if (ret != EOK) {
-                endpoint_destroy(ep);
-        }
-        return ret;
+        return usb_endpoint_manager_add_ep(&hcd->ep_manager, address, endpoint,
+            direction, transfer_type, speed, max_packet_size, size,
+            register_helper, hcd);
 }
 /*----------------------------------------------------------------------------*/
@@ -218 +220 @@
         usb_log_debug("Unregister endpoint %d:%d %s.\n",
             address, endpoint, usb_str_direction(direction));
-        return usb_endpoint_manager_unregister_ep(&hcd->ep_manager, address,
-            endpoint, direction);
+        return usb_endpoint_manager_remove_ep(&hcd->ep_manager, address,
+            endpoint, direction, unregister_helper, hcd);
 }
 /*----------------------------------------------------------------------------*/

uspace/lib/usbhost/src/usb_device_manager.c

@@ -38 +38 @@
 #include <usb/host/usb_device_manager.h>
 
-/*----------------------------------------------------------------------------*/
 /** Initialize device manager structure.
  *
@@ -48 +47 @@
 {
         assert(instance);
-        unsigned i = 0;
-        for (; i < USB_ADDRESS_COUNT; ++i) {
+        for (unsigned i = 0; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
                 instance->devices[i].handle = 0;
@@ -77 +75 @@
                 ++new_address;
                 if (new_address > USB11_ADDRESS_MAX)
-                        new_address = 1;
+                        new_address = 1; // NOTE it should be safe to put 0 here
+                                         // TODO Use mod
                 if (new_address == instance->last_address) {
                         fibril_mutex_unlock(&instance->guard);
@@ -86 +85 @@
         assert(new_address != USB_ADDRESS_DEFAULT);
         assert(instance->devices[new_address].occupied == false);
+        assert(instance->devices[new_address].handle == 0);
 
         instance->devices[new_address].occupied = true;
@@ -100 +100 @@
  * @param[in] address Device address
  * @param[in] handle Devman handle of the device.
- */
-void usb_device_manager_bind(usb_device_manager_t *instance,
+ * @return Error code.
+ */
+int usb_device_manager_bind(usb_device_manager_t *instance,
     usb_address_t address, devman_handle_t handle)
 {
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-
-        assert(address > 0);
-        assert(address <= USB11_ADDRESS_MAX);
-        assert(instance->devices[address].occupied);
-
+        if ((address <= 0) || (address >= USB_ADDRESS_COUNT)) {
+                return EINVAL;
+        }
+        assert(instance);
+
+        fibril_mutex_lock(&instance->guard);
+        /* Not reserved */
+        if (!instance->devices[address].occupied) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOENT;
+        }
+        /* Already bound */
+        if (instance->devices[address].handle != 0) {
+                fibril_mutex_unlock(&instance->guard);
+                return EEXISTS;
+        }
         instance->devices[address].handle = handle;
         fibril_mutex_unlock(&instance->guard);
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -119 +130 @@
  * @param[in] instance Device manager structure to use.
  * @param[in] address Device address
- */
-void usb_device_manager_release(
+ * @return Error code.
+ */
+int usb_device_manager_release(
     usb_device_manager_t *instance, usb_address_t address)
 {
-        assert(instance);
-        assert(address > 0);
-        assert(address <= USB11_ADDRESS_MAX);
-
-        fibril_mutex_lock(&instance->guard);
-        assert(instance->devices[address].occupied);
+        if ((address <= 0) || (address >= USB_ADDRESS_COUNT)) {
+                return EINVAL;
+        }
+        assert(instance);
+
+        fibril_mutex_lock(&instance->guard);
+        if (!instance->devices[address].occupied) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOENT;
+        }
 
         instance->devices[address].occupied = false;
-        fibril_mutex_unlock(&instance->guard);
+        instance->devices[address].handle = 0;
+        fibril_mutex_unlock(&instance->guard);
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -140 +158 @@
  * @return USB Address, or error code.
  */
-usb_address_t usb_device_manager_find(
+usb_address_t usb_device_manager_find_address(
     usb_device_manager_t *instance, devman_handle_t handle)
 {
         assert(instance);
         fibril_mutex_lock(&instance->guard);
-        usb_address_t address = 1;
-        while (address <= USB11_ADDRESS_MAX) {
+        for (usb_address_t address = 1; address <= USB11_ADDRESS_MAX; ++address)
+        {
                 if (instance->devices[address].handle == handle) {
                         assert(instance->devices[address].occupied);
@@ -152 +170 @@
                         return address;
                 }
-                ++address;
         }
         fibril_mutex_unlock(&instance->guard);
         return ENOENT;
 }
-
-/** Find devman handle assigned to USB address.
- * Intentionally refuse to find handle of default address.
+/*----------------------------------------------------------------------------*/
+/** Find devman handle and speed assigned to USB address.
+ * Intentionally refuse to work on default address.
  *
  * @param[in] instance Device manager structure to use.
  * @param[in] address Address the caller wants to find.
  * @param[out] handle Where to store found handle.
- * @return Whether such address is currently occupied.
- */
-bool usb_device_manager_find_by_address(usb_device_manager_t *instance,
-    usb_address_t address, devman_handle_t *handle)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
+ * @param[out] speed Assigned speed.
+ * @return Error code.
+ */
+int usb_device_manager_get_info_by_address(usb_device_manager_t *instance,
+    usb_address_t address, devman_handle_t *handle, usb_speed_t *speed)
+{
+        assert(instance);
         if ((address <= 0) || (address >= USB_ADDRESS_COUNT)) {
-                fibril_mutex_unlock(&instance->guard);
-                return false;
-        }
+                return EINVAL;
+        }
+
+        fibril_mutex_lock(&instance->guard);
         if (!instance->devices[address].occupied) {
                 fibril_mutex_unlock(&instance->guard);
-                return false;
+                return ENOENT;
         }
 
@@ -183 +201 @@
                 *handle = instance->devices[address].handle;
         }
-
-        fibril_mutex_unlock(&instance->guard);
-        return true;
-}
-
-/*----------------------------------------------------------------------------*/
-/** Get speed associated with the address
- *
- * @param[in] instance Device manager structure to use.
- * @param[in] address Address of the device.
- * @return USB speed.
- */
-usb_speed_t usb_device_manager_get_speed(
-    usb_device_manager_t *instance, usb_address_t address)
-{
-        assert(instance);
-        assert(address >= 0);
-        assert(address <= USB11_ADDRESS_MAX);
-
-        return instance->devices[address].speed;
+        if (speed != NULL) {
+                *speed = instance->devices[address].speed;
+        }
+
+        fibril_mutex_unlock(&instance->guard);
+        return EOK;
 }
 /**

uspace/lib/usbhost/src/usb_endpoint_manager.c

@@ -34 +34 @@
 #include <usb/host/usb_endpoint_manager.h>
 
-#define BUCKET_COUNT 7
-
-#define MAX_KEYS (3)
-typedef struct {
-        link_t link;
-        size_t bw;
-        endpoint_t *ep;
-} node_t;
-/*----------------------------------------------------------------------------*/
-static hash_index_t node_hash(unsigned long key[])
-{
-        /* USB endpoints use 4 bits, thus ((key[0] << 4) | key[1])
-         * produces unique value for every address.endpoint pair */
-        return ((key[0] << 4) | key[1]) % BUCKET_COUNT;
-}
-/*----------------------------------------------------------------------------*/
-static int node_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        assert(item);
-        node_t *node = hash_table_get_instance(item, node_t, link);
-        assert(node);
-        assert(node->ep);
-        bool match = true;
-        switch (keys) {
-        case 3:
-                match = match &&
-                    ((key[2] == node->ep->direction)
-                    || (node->ep->direction == USB_DIRECTION_BOTH));
-        case 2:
-                match = match && (key[1] == (unsigned long)node->ep->endpoint);
-        case 1:
-                match = match && (key[0] == (unsigned long)node->ep->address);
-                break;
-        default:
-                match = false;
-        }
-        return match;
-}
-/*----------------------------------------------------------------------------*/
-static void node_remove(link_t *item)
-{
-        assert(item);
-        node_t *node = hash_table_get_instance(item, node_t, link);
-        endpoint_destroy(node->ep);
-        free(node);
-}
-/*----------------------------------------------------------------------------*/
-static void node_toggle_reset_filtered(link_t *item, void *arg)
-{
-        assert(item);
-        node_t *node = hash_table_get_instance(item, node_t, link);
-        usb_target_t *target = arg;
-        endpoint_toggle_reset_filtered(node->ep, *target);
-}
-/*----------------------------------------------------------------------------*/
-static hash_table_operations_t op = {
-        .hash = node_hash,
-        .compare = node_compare,
-        .remove_callback = node_remove,
-};
-/*----------------------------------------------------------------------------*/
+/** Endpoint compare helper function.
+ *
+ * USB_DIRECTION_BOTH matches both IN and OUT.
+ * @param ep Endpoint to compare, non-null.
+ * @param address Tested address.
+ * @param endpoint Tested endpoint number.
+ * @param direction Tested direction.
+ * @return True if ep can be used to communicate with given device,
+ * false otherwise.
+ */
+static inline bool ep_match(const endpoint_t *ep,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(ep);
+        return
+            ((direction == ep->direction)
+                || (ep->direction == USB_DIRECTION_BOTH)
+                || (direction == USB_DIRECTION_BOTH))
+            && (endpoint == ep->endpoint)
+            && (address == ep->address);
+}
+/*----------------------------------------------------------------------------*/
+/** Get list that holds endpints for given address.
+ * @param instance usb_endpoint_manager structure, non-null.
+ * @param addr USB address, must be >= 0.
+ * @return Pointer to the appropriate list.
+ */
+static list_t * get_list(usb_endpoint_manager_t *instance, usb_address_t addr)
+{
+        assert(instance);
+        assert(addr >= 0);
+        return &instance->endpoint_lists[addr % ENDPOINT_LIST_COUNT];
+}
+/*----------------------------------------------------------------------------*/
+/** Internal search function, works on locked structure.
+ * @param instance usb_endpoint_manager structure, non-null.
+ * @param address USB address, must be valid.
+ * @param endpoint USB endpoint number.
+ * @param direction Communication direction.
+ * @return Pointer to endpoint_t structure representing given communication
+ * target, NULL if there is no such endpoint registered.
+ */
+static endpoint_t * find_locked(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(instance);
+        assert(fibril_mutex_is_locked(&instance->guard));
+        if (address < 0)
+                return NULL;
+        list_foreach(*get_list(instance, address), iterator) {
+                endpoint_t *ep = endpoint_get_instance(iterator);
+                if (ep_match(ep, address, endpoint, direction))
+                        return ep;
+        }
+        return NULL;
+}
+/*----------------------------------------------------------------------------*/
+/** Calculate bandwidth that needs to be reserved for communication with EP.
+ * Calculation follows USB 1.1 specification.
+ * @param speed Device's speed.
+ * @param type Type of the transfer.
+ * @param size Number of byte to transfer.
+ * @param max_packet_size Maximum bytes in one packet.
+ */
 size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type,
     size_t size, size_t max_packet_size)
@@ -106 +109 @@
         const unsigned packet_count =
             (size + max_packet_size - 1) / max_packet_size;
-        /* TODO: It may be that ISO and INT transfers use only one data packet
-         * per transaction, but I did not find text in UB spec that confirms
-         * this */
+        /* TODO: It may be that ISO and INT transfers use only one packet per
+         * transaction, but I did not find text in USB spec to confirm this */
         /* NOTE: All data packets will be considered to be max_packet_size */
         switch (speed)
@@ -137 +139 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Initialize to default state.
+ * You need to provide valid bw_count function if you plan to use
+ * add_endpoint/remove_endpoint pair.
+ *
+ * @param instance usb_endpoint_manager structure, non-null.
+ * @param available_bandwidth Size of the bandwidth pool.
+ * @param bw_count function to use to calculate endpoint bw requirements.
+ * @return Error code.
+ */
 int usb_endpoint_manager_init(usb_endpoint_manager_t *instance,
     size_t available_bandwidth,
@@ -145 +156 @@
         instance->free_bw = available_bandwidth;
         instance->bw_count = bw_count;
-        const bool ht =
-            hash_table_create(&instance->ep_table, BUCKET_COUNT, MAX_KEYS, &op);
-        return ht ? EOK : ENOMEM;
-}
-/*----------------------------------------------------------------------------*/
-void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance)
-{
-        hash_table_destroy(&instance->ep_table);
-}
-/*----------------------------------------------------------------------------*/
-int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
-    endpoint_t *ep, size_t data_size)
-{
-        assert(instance);
-        assert(instance->bw_count);
-        assert(ep);
-        const size_t bw = instance->bw_count(ep->speed, ep->transfer_type,
-            data_size, ep->max_packet_size);
-
-        fibril_mutex_lock(&instance->guard);
-
-        if (bw > instance->free_bw) {
-                fibril_mutex_unlock(&instance->guard);
-                return ENOSPC;
-        }
-
-        unsigned long key[MAX_KEYS] =
-            {ep->address, ep->endpoint, ep->direction};
-
-        const link_t *item =
-            hash_table_find(&instance->ep_table, key);
-        if (item != NULL) {
-                fibril_mutex_unlock(&instance->guard);
-                return EEXISTS;
-        }
-
-        node_t *node = malloc(sizeof(node_t));
-        if (node == NULL) {
-                fibril_mutex_unlock(&instance->guard);
-                return ENOMEM;
-        }
-
-        node->bw = bw;
-        node->ep = ep;
-        link_initialize(&node->link);
-
-        hash_table_insert(&instance->ep_table, key, &node->link);
-        instance->free_bw -= bw;
-        fibril_mutex_unlock(&instance->guard);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance,
-    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
-{
-        assert(instance);
-        unsigned long key[MAX_KEYS] = {address, endpoint, direction};
-
-        fibril_mutex_lock(&instance->guard);
-        link_t *item = hash_table_find(&instance->ep_table, key);
-        if (item == NULL) {
-                fibril_mutex_unlock(&instance->guard);
-                return EINVAL;
-        }
-
-        node_t *node = hash_table_get_instance(item, node_t, link);
-        if (node->ep->active) {
-                fibril_mutex_unlock(&instance->guard);
-                return EBUSY;
-        }
-
-        instance->free_bw += node->bw;
-        hash_table_remove(&instance->ep_table, key, MAX_KEYS);
-
-        fibril_mutex_unlock(&instance->guard);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance,
-    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
-    size_t *bw)
-{
-        assert(instance);
-        unsigned long key[MAX_KEYS] = {address, endpoint, direction};
-
-        fibril_mutex_lock(&instance->guard);
-        const link_t *item = hash_table_find(&instance->ep_table, key);
-        if (item == NULL) {
-                fibril_mutex_unlock(&instance->guard);
-                return NULL;
-        }
-        const node_t *node = hash_table_get_instance(item, node_t, link);
-        if (bw)
-                *bw = node->bw;
-
-        fibril_mutex_unlock(&instance->guard);
-        return node->ep;
+        for (unsigned i = 0; i < ENDPOINT_LIST_COUNT; ++i) {
+                list_initialize(&instance->endpoint_lists[i]);
+        }
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
 /** Check setup packet data for signs of toggle reset.
  *
- * @param[in] instance Device keeper structure to use.
+ * @param[in] instance usb_endpoint_manager structure, non-null.
  * @param[in] target Device to receive setup packet.
  * @param[in] data Setup packet data.
  *
- * Really ugly one.
- */
-void usb_endpoint_manager_reset_if_need(
-    usb_endpoint_manager_t *instance, usb_target_t target, const uint8_t *data)
+ * Really ugly one. Resets toggle bit on all endpoints that need it.
+ */
+void usb_endpoint_manager_reset_eps_if_need(usb_endpoint_manager_t *instance,
+    usb_target_t target, const uint8_t data[8])
 {
         assert(instance);
@@ -267 +185 @@
                 /* Recipient is endpoint, value is zero (ENDPOINT_STALL) */
                 if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
+                        fibril_mutex_lock(&instance->guard);
                         /* endpoint number is < 16, thus first byte is enough */
-                        usb_target_t reset_target =
-                            { .address = target.address, data[4] };
-                        fibril_mutex_lock(&instance->guard);
-                        hash_table_apply(&instance->ep_table,
-                            node_toggle_reset_filtered, &reset_target);
+                        list_foreach(*get_list(instance, target.address), it) {
+                                endpoint_t *ep = endpoint_get_instance(it);
+                                if ((ep->address == target.address)
+                                    && (ep->endpoint = data[4])) {
+                                        endpoint_toggle_set(ep,0);
+                                }
+                        }
                         fibril_mutex_unlock(&instance->guard);
                 }
@@ -279 +200 @@
         case 0x9: /* Set Configuration */
         case 0x11: /* Set Interface */
-                /* Recipient must be device */
+                /* 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. */
                 if ((data[0] & 0xf) == 0) {
-                        usb_target_t reset_target =
-                            { .address = target.address, 0 };
                         fibril_mutex_lock(&instance->guard);
-                        hash_table_apply(&instance->ep_table,
-                            node_toggle_reset_filtered, &reset_target);
+                        list_foreach(*get_list(instance, target.address), it) {
+                                endpoint_t *ep = endpoint_get_instance(it);
+                                if (ep->address == target.address) {
+                                        endpoint_toggle_set(ep,0);
+                                }
+                        }
                         fibril_mutex_unlock(&instance->guard);
                 }
@@ -291 +216 @@
         }
 }
+/*----------------------------------------------------------------------------*/
+/** Register endpoint structure.
+ * Checks for duplicates.
+ * @param instance usb_endpoint_manager, non-null.
+ * @param ep endpoint_t to register.
+ * @param data_size Size of data to transfer.
+ * @return Error code.
+ */
+int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
+    endpoint_t *ep, size_t data_size)
+{
+        assert(instance);
+        if (ep == NULL || ep->address < 0)
+                return EINVAL;
+
+        fibril_mutex_lock(&instance->guard);
+        /* Check for available bandwidth */
+        if (ep->bandwidth > instance->free_bw) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOSPC;
+        }
+
+        /* Check for existence */
+        const endpoint_t *endpoint =
+            find_locked(instance, ep->address, ep->endpoint, ep->direction);
+        if (endpoint != NULL) {
+                fibril_mutex_unlock(&instance->guard);
+                return EEXISTS;
+        }
+        list_append(&ep->link, get_list(instance, ep->address));
+
+        instance->free_bw -= ep->bandwidth;
+        fibril_mutex_unlock(&instance->guard);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Unregister endpoint structure.
+ * Checks for duplicates.
+ * @param instance usb_endpoint_manager, non-null.
+ * @param ep endpoint_t to unregister.
+ * @return Error code.
+ */
+int usb_endpoint_manager_unregister_ep(
+    usb_endpoint_manager_t *instance, endpoint_t *ep)
+{
+        assert(instance);
+        if (ep == NULL || ep->address < 0)
+                return EINVAL;
+
+        fibril_mutex_lock(&instance->guard);
+        if (!list_member(&ep->link, get_list(instance, ep->address))) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOENT;
+        }
+        list_remove(&ep->link);
+        instance->free_bw += ep->bandwidth;
+        fibril_mutex_unlock(&instance->guard);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Find endpoint_t representing the given communication route.
+ * @param instance usb_endpoint_manager, non-null.
+ * @param address
+ */
+endpoint_t * usb_endpoint_manager_find_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
+{
+        assert(instance);
+
+        fibril_mutex_lock(&instance->guard);
+        endpoint_t *ep = find_locked(instance, address, endpoint, direction);
+        fibril_mutex_unlock(&instance->guard);
+        return ep;
+}
+/*----------------------------------------------------------------------------*/
+/** Create and register new endpoint_t structure.
+ * @param instance usb_endpoint_manager structure, non-null.
+ * @param address USB address.
+ * @param endpoint USB endpoint number.
+ * @param direction Communication direction.
+ * @param type USB transfer type.
+ * @param speed USB Communication speed.
+ * @param max_packet_size Maximum size of data packets.
+ * @param data_size Expected communication size.
+ * @param callback function to call just after registering.
+ * @param arg Argument to pass to the callback function.
+ * @return Error code.
+ */
+int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size,
+    size_t data_size, int (*callback)(endpoint_t *, void *), void *arg)
+{
+        assert(instance);
+        if (instance->bw_count == NULL)
+                return ENOTSUP;
+        if (address < 0)
+                return EINVAL;
+
+        const size_t bw =
+            instance->bw_count(speed, type, data_size, max_packet_size);
+
+        fibril_mutex_lock(&instance->guard);
+        /* Check for available bandwidth */
+        if (bw > instance->free_bw) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOSPC;
+        }
+
+        /* Check for existence */
+        endpoint_t *ep = find_locked(instance, address, endpoint, direction);
+        if (ep != NULL) {
+                fibril_mutex_unlock(&instance->guard);
+                return EEXISTS;
+        }
+
+        ep = endpoint_create(
+            address, endpoint, direction, type, speed, max_packet_size, bw);
+        if (!ep) {
+                fibril_mutex_unlock(&instance->guard);
+                return ENOMEM;
+        }
+
+        if (callback) {
+                const int ret = callback(ep, arg);
+                if (ret != EOK) {
+                        fibril_mutex_unlock(&instance->guard);
+                        endpoint_destroy(ep);
+                        return ret;
+                }
+        }
+        list_append(&ep->link, get_list(instance, ep->address));
+
+        instance->free_bw -= ep->bandwidth;
+        fibril_mutex_unlock(&instance->guard);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Unregister and destroy endpoint_t structure representing given route.
+ * @param instance usb_endpoint_manager structure, non-null.
+ * @param address USB address.
+ * @param endpoint USB endpoint number.
+ * @param direction Communication direction.
+ * @param callback Function to call after unregister, before destruction.
+ * @arg Argument to pass to the callback function.
+ * @return Error code.
+ */
+int usb_endpoint_manager_remove_ep(usb_endpoint_manager_t *instance,
+    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
+    void (*callback)(endpoint_t *, void *), void *arg)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        endpoint_t *ep = find_locked(instance, address, endpoint, direction);
+        if (ep != NULL) {
+                list_remove(&ep->link);
+                instance->free_bw += ep->bandwidth;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        if (ep == NULL)
+                return ENOENT;
+
+        if (callback) {
+                callback(ep, arg);
+        }
+        endpoint_destroy(ep);
+        return EOK;
+}

uspace/lib/usbhost/src/usb_transfer_batch.c

@@ -37 +37 @@
 #include <usb/usb.h>
 #include <usb/debug.h>
+
 #include <usb/host/usb_transfer_batch.h>
 #include <usb/host/hcd.h>
 
-usb_transfer_batch_t * usb_transfer_batch_get(
+/** 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 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,
@@ -53 +66 @@
     )
 {
+        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) {
@@ -78 +96 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Mark batch as finished and run 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.
- */
-void usb_transfer_batch_finish(
-    usb_transfer_batch_t *instance, const void *data, size_t size)
-{
-        assert(instance);
-        assert(instance->ep);
-        /* we care about the data and there are some to copy */
-        if (instance->ep->direction != USB_DIRECTION_OUT
-            && data) {
-                const size_t min_size =
-                    size < instance->buffer_size ? size : instance->buffer_size;
-                memcpy(instance->buffer, data, min_size);
-        }
-        if (instance->callback_out)
-                usb_transfer_batch_call_out(instance);
-        if (instance->callback_in)
-                usb_transfer_batch_call_in(instance);
-
-}
-/*----------------------------------------------------------------------------*/
-/** Prepare data, get error status and call callback in.
- *
- * @param[in] instance Batch structure to use.
- * Copies data from transport buffer, and calls callback with appropriate
- * parameters.
- */
-void usb_transfer_batch_call_in(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        assert(instance->callback_in);
-
-        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " completed (%zuB): %s.\n",
-            instance, USB_TRANSFER_BATCH_ARGS(*instance),
-            instance->transfered_size, str_error(instance->error));
-
-        instance->callback_in(instance->fun, instance->error,
-            instance->transfered_size, instance->arg);
-}
-/*----------------------------------------------------------------------------*/
-/** Get error status and call callback out.
- *
- * @param[in] instance Batch structure to use.
- */
-void usb_transfer_batch_call_out(usb_transfer_batch_t *instance)
-{
-        assert(instance);
-        assert(instance->callback_out);
-
-        usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " completed: %s.\n",
-            instance, USB_TRANSFER_BATCH_ARGS(*instance),
-            str_error(instance->error));
-
-        if (instance->ep->transfer_type == USB_TRANSFER_CONTROL
-            && instance->error == EOK) {
-                const usb_target_t target =
-                    {{ instance->ep->address, instance->ep->endpoint }};
-                reset_ep_if_need(
-                    fun_to_hcd(instance->fun), target, instance->setup_buffer);
-        }
-
-        instance->callback_out(instance->fun,
-            instance->error, instance->arg);
-}
-/*----------------------------------------------------------------------------*/
 /** Correctly dispose all used data structures.
  *
  * @param[in] instance Batch structure to use.
  */
-void usb_transfer_batch_dispose(usb_transfer_batch_t *instance)
+void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance)
 {
         if (!instance)
@@ -166 +115 @@
         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.
+ */
+void usb_transfer_batch_finish(
+    const usb_transfer_batch_t *instance, const void *data, size_t size)
+{
+        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) {
+                /* Check for commands that reset toggle bit */
+                if (instance->ep->transfer_type == USB_TRANSFER_CONTROL
+                    && instance->error == EOK) {
+                        const usb_target_t target =
+                            {{ instance->ep->address, instance->ep->endpoint }};
+                        reset_ep_if_need(fun_to_hcd(instance->fun), target,
+                            instance->setup_buffer);
+                }
+                instance->callback_out(instance->fun,
+                    instance->error, instance->arg);
+        }
+
+        if (instance->callback_in) {
+                /* We care about the data and there are some to copy */
+                if (data) {
+                        const size_t min_size = size < instance->buffer_size
+                            ? size : instance->buffer_size;
+                        memcpy(instance->buffer, data, min_size);
+                }
+                instance->callback_in(instance->fun, instance->error,
+                    instance->transfered_size, instance->arg);
+        }
+}
 /**
  * @}