Changeset c7dd69d in mainline for uspace/lib/usb/src

Timestamp:

2011-04-15T13:19:59Z (14 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

da1dd48

Parents:

e3b5129 (diff), 8fd4ba0 (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:

Development changes

Location:

uspace/lib/usb/src

Files:

• altiface.c (added)
• devdrv.c (modified) (10 diffs)
• devpoll.c (modified) (10 diffs)
• hidreport.c (modified) (2 diffs)
• hidreq.c (modified) (17 diffs)
• host/batch.c (modified) (5 diffs)
• host/device_keeper.c (modified) (7 diffs)
• host/endpoint.c (modified) (5 diffs)
• host/usb_endpoint_manager.c (modified) (1 diff)
• pipesinit.c (modified) (2 diffs)
• pipesio.c (modified) (4 diffs)
• request.c (modified) (1 diff)

uspace/lib/usb/src/devdrv.c

@@ -100 +100 @@
     usb_device_t *dev, int alternate_setting)
 {
+        if (endpoints == NULL) {
+                dev->pipes = NULL;
+                dev->pipes_count = 0;
+                return EOK;
+        }
+
         usb_endpoint_mapping_t *pipes;
         size_t pipes_count;
@@ -109 +115 @@
 
         if (rc != EOK) {
-                usb_log_error(
-                    "Failed to create endpoint pipes for `%s': %s.\n",
-                    dev->ddf_dev->name, str_error(rc));
                 return rc;
         }
@@ -117 +120 @@
         dev->pipes = pipes;
         dev->pipes_count = pipes_count;
-
-        return EOK;
-}
-
-/** Initialize all endpoint pipes.
- *
- * @param drv The driver.
- * @param dev The device to be initialized.
- * @return Error code.
- */
-static int initialize_pipes(usb_device_t *dev)
-{
-        int rc;
-
-        rc = usb_device_connection_initialize_from_device(&dev->wire,
-            dev->ddf_dev);
-        if (rc != EOK) {
-                usb_log_error(
-                    "Failed initializing connection on device `%s'. %s.\n",
-                    dev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe,
-            &dev->wire);
-        if (rc != EOK) {
-                usb_log_error("Failed to initialize default control pipe " \
-                    "on device `%s': %s.\n",
-                    dev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
-        if (rc != EOK) {
-                usb_log_error(
-                    "Probing default control pipe on device `%s' failed: %s.\n",
-                    dev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        /* Get our interface. */
-        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
-
-        /*
-         * We will do some querying of the device, it is worth to prepare
-         * the long transfer.
-         */
-        rc = usb_pipe_start_long_transfer(&dev->ctrl_pipe);
-        if (rc != EOK) {
-                usb_log_error("Failed to start transfer: %s.\n",
-                    str_error(rc));
-                return rc;
-        }
-
-        /* Retrieve the descriptors. */
-        rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
-            &dev->descriptors);
-        if (rc != EOK) {
-                usb_log_error("Failed to retrieve standard device " \
-                    "descriptors of %s: %s.\n",
-                    dev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-
-        if (driver->endpoints != NULL) {
-                rc = initialize_other_pipes(driver->endpoints, dev, 0);
-        }
-
-        usb_pipe_end_long_transfer(&dev->ctrl_pipe);
-
-        /* Rollback actions. */
-        if (rc != EOK) {
-                if (dev->descriptors.configuration != NULL) {
-                        free(dev->descriptors.configuration);
-                }
-        }
-
-        return rc;
-}
-
-/** Count number of alternate settings of a interface.
- *
- * @param config_descr Full configuration descriptor.
- * @param config_descr_size Size of @p config_descr in bytes.
- * @param interface_no Interface number.
- * @return Number of alternate interfaces for @p interface_no interface.
- */
-size_t usb_interface_count_alternates(uint8_t *config_descr,
-    size_t config_descr_size, uint8_t interface_no)
-{
-        assert(config_descr != NULL);
-        assert(config_descr_size > 0);
-
-        usb_dp_parser_t dp_parser = {
-                .nesting = usb_dp_standard_descriptor_nesting
-        };
-        usb_dp_parser_data_t dp_data = {
-                .data = config_descr,
-                .size = config_descr_size,
-                .arg = NULL
-        };
-
-        size_t alternate_count = 0;
-
-        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
-            &dp_data, config_descr);
-        while (iface_ptr != NULL) {
-                usb_standard_interface_descriptor_t *iface
-                    = (usb_standard_interface_descriptor_t *) iface_ptr;
-                if (iface->descriptor_type == USB_DESCTYPE_INTERFACE) {
-                        if (iface->interface_number == interface_no) {
-                                alternate_count++;
-                        }
-                }
-                iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
-                    config_descr, iface_ptr);
-        }
-
-        return alternate_count;
-}
-
-/** Initialize structures related to alternate interfaces.
- *
- * @param dev Device where alternate settings shall be initialized.
- * @return Error code.
- */
-static int initialize_alternate_interfaces(usb_device_t *dev)
-{
-        if (dev->interface_no < 0) {
-                dev->alternate_interfaces = NULL;
-                return EOK;
-        }
-
-        usb_alternate_interfaces_t *alternates
-            = malloc(sizeof(usb_alternate_interfaces_t));
-
-        if (alternates == NULL) {
-                return ENOMEM;
-        }
-
-        alternates->alternative_count
-            = usb_interface_count_alternates(dev->descriptors.configuration,
-            dev->descriptors.configuration_size, dev->interface_no);
-
-        if (alternates->alternative_count == 0) {
-                free(alternates);
-                return ENOENT;
-        }
-
-        alternates->alternatives = malloc(alternates->alternative_count
-            * sizeof(usb_alternate_interface_descriptors_t));
-        if (alternates->alternatives == NULL) {
-                free(alternates);
-                return ENOMEM;
-        }
-
-        alternates->current = 0;
-
-        usb_dp_parser_t dp_parser = {
-                .nesting = usb_dp_standard_descriptor_nesting
-        };
-        usb_dp_parser_data_t dp_data = {
-                .data = dev->descriptors.configuration,
-                .size = dev->descriptors.configuration_size,
-                .arg = NULL
-        };
-
-        usb_alternate_interface_descriptors_t *cur_alt_iface
-            = &alternates->alternatives[0];
-
-        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
-            &dp_data, dp_data.data);
-        while (iface_ptr != NULL) {
-                usb_standard_interface_descriptor_t *iface
-                    = (usb_standard_interface_descriptor_t *) iface_ptr;
-                if ((iface->descriptor_type != USB_DESCTYPE_INTERFACE)
-                    || (iface->interface_number != dev->interface_no)) {
-                        iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser,
-                            &dp_data,
-                            dp_data.data, iface_ptr);
-                        continue;
-                }
-
-                cur_alt_iface->interface = iface;
-                cur_alt_iface->nested_descriptors = iface_ptr + sizeof(*iface);
-
-                /* Find next interface to count size of nested descriptors. */
-                iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
-                    dp_data.data, iface_ptr);
-                if (iface_ptr == NULL) {
-                        uint8_t *next = dp_data.data + dp_data.size;
-                        cur_alt_iface->nested_descriptors_size
-                            = next - cur_alt_iface->nested_descriptors;
-                } else {
-                        cur_alt_iface->nested_descriptors_size
-                            = iface_ptr - cur_alt_iface->nested_descriptors;
-                }
-
-                cur_alt_iface++;
-        }
-
-        dev->alternate_interfaces = alternates;
 
         return EOK;
@@ -339 +139 @@
         int rc;
 
-        usb_device_t *dev = malloc(sizeof(usb_device_t));
-        if (dev == NULL) {
-                usb_log_error("Out of memory when adding device `%s'.\n",
-                    gen_dev->name);
-                return ENOMEM;
-        }
-
-
-        dev->ddf_dev = gen_dev;
-        dev->ddf_dev->driver_data = dev;
-        dev->driver_data = NULL;
-        dev->descriptors.configuration = NULL;
-
-        dev->pipes_count = 0;
-        dev->pipes = NULL;
-
-        rc = initialize_pipes(dev);
-        if (rc != EOK) {
-                free(dev);
-                return rc;
-        }
-
-        (void) initialize_alternate_interfaces(dev);
+        usb_device_t *dev = NULL;
+        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",
+                    gen_dev->name, err_msg, str_error(rc));
+                return rc;
+        }
 
         return driver->ops->add_device(dev);
@@ -395 +180 @@
  * with usb_pipe_initialize_from_configuration().
  *
+ * @warning This is a wrapper function that does several operations that
+ * can fail and that cannot be rollbacked easily. That means that a failure
+ * during the SET_INTERFACE request would result in having a device with
+ * no pipes at all (except the default control one). That is because the old
+ * pipes needs to be unregistered at HC first and the new ones could not
+ * be created.
+ *
  * @param dev USB device.
  * @param alternate_setting Alternate setting to choose.
@@ -409 +201 @@
         int rc;
 
-        /* TODO: more transactional behavior. */
-
         /* Destroy existing pipes. */
         rc = destroy_current_pipes(dev);
@@ -432 +222 @@
 /** Retrieve basic descriptors from the device.
  *
- * @param[in] ctrl_pipe Control pipe with opened session.
+ * @param[in] ctrl_pipe Control endpoint pipe.
  * @param[out] descriptors Where to store the descriptors.
  * @return Error code.
@@ -440 +230 @@
 {
         assert(descriptors != NULL);
-        assert(usb_pipe_is_session_started(ctrl_pipe));
 
         descriptors->configuration = NULL;
 
         int rc;
+
+        /* It is worth to start a long transfer. */
+        rc = usb_pipe_start_long_transfer(ctrl_pipe);
+        if (rc != EOK) {
+                return rc;
+        }
 
         /* Get the device descriptor. */
         rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device);
         if (rc != EOK) {
-                return rc;
+                goto leave;
         }
 
@@ -456 +251 @@
             ctrl_pipe, 0, (void **) &descriptors->configuration,
             &descriptors->configuration_size);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        return EOK;
+
+leave:
+        usb_pipe_end_long_transfer(ctrl_pipe);
+
+        return rc;
 }
 
@@ -641 +436 @@
 }
 
+/** Initialize control pipe in a device.
+ *
+ * @param dev USB device in question.
+ * @param errmsg Where to store error context.
+ * @return
+ */
+static int init_wire_and_ctrl_pipe(usb_device_t *dev, const char **errmsg)
+{
+        int rc;
+
+        rc = usb_device_connection_initialize_from_device(&dev->wire,
+            dev->ddf_dev);
+        if (rc != EOK) {
+                *errmsg = "device connection initialization";
+                return rc;
+        }
+
+        rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe,
+            &dev->wire);
+        if (rc != EOK) {
+                *errmsg = "default control pipe initialization";
+                return rc;
+        }
+
+        return EOK;
+}
+
+
+/** Create new instance of USB 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);
+        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;
+
+        /* Initialize backing wire and control pipe. */
+        rc = init_wire_and_ctrl_pipe(dev, errstr_ptr);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Get our interface. */
+        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
+
+        /* Retrieve standard descriptors. */
+        rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
+            &dev->descriptors);
+        if (rc != EOK) {
+                *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) {
+                *errstr_ptr = "pipes initialization";
+                return rc;
+        }
+
+        *errstr_ptr = NULL;
+        *dev_ptr = dev;
+
+        return EOK;
+}
+
 /**
  * @}

uspace/lib/usb/src/devpoll.c

@@ -33 +33 @@
  * USB device driver framework - automatic interrupt polling.
  */
-#include <usb/devdrv.h>
+#include <usb/devpoll.h>
 #include <usb/request.h>
 #include <usb/debug.h>
+#include <usb/classes/classes.h>
 #include <errno.h>
 #include <str_error.h>
@@ -45 +46 @@
 /** Data needed for polling. */
 typedef struct {
+        int debug;
+        size_t max_failures;
+        useconds_t delay;
+        bool auto_clear_halt;
+        bool (*on_data)(usb_device_t *, uint8_t *, size_t, void *);
+        void (*on_polling_end)(usb_device_t *, bool, void *);
+        bool (*on_error)(usb_device_t *, int, void *);
+
         usb_device_t *dev;
         size_t pipe_index;
-        usb_polling_callback_t callback;
-        usb_polling_terminted_callback_t terminated_callback;
         size_t request_size;
         uint8_t *buffer;
@@ -54 +61 @@
 } polling_data_t;
 
+
 /** Polling fibril.
  *
@@ -67 +75 @@
             = polling_data->dev->pipes[polling_data->pipe_index].pipe;
         
-        usb_log_debug("Pipe interface number: %d, protocol: %d, subclass: %d, max packet size: %d\n", 
-            polling_data->dev->pipes[polling_data->pipe_index].interface_no,
-            polling_data->dev->pipes[polling_data->pipe_index].description->interface_protocol,
-            polling_data->dev->pipes[polling_data->pipe_index].description->interface_subclass,
-            pipe->max_packet_size);
+        if (polling_data->debug > 0) {
+                usb_endpoint_mapping_t *mapping
+                    = &polling_data->dev->pipes[polling_data->pipe_index];
+                usb_log_debug("Poll0x%x: started polling of `%s' - " \
+                    "interface %d (%s,%d,%d), %zuB/%zu.\n",
+                    polling_data,
+                    polling_data->dev->ddf_dev->name,
+                    (int) mapping->interface->interface_number,
+                    usb_str_class(mapping->interface->interface_class),
+                    (int) mapping->interface->interface_subclass,
+                    (int) mapping->interface->interface_protocol,
+                    polling_data->request_size, pipe->max_packet_size);
+        }
 
         size_t failed_attempts = 0;
-        while (failed_attempts < MAX_FAILED_ATTEMPTS) {
+        while (failed_attempts <= polling_data->max_failures) {
                 int rc;
 
@@ -81 +97 @@
                     polling_data->request_size, &actual_size);
 
-                
-//              if (rc == ESTALL) {
-//                      usb_log_debug("Seding clear feature...\n");
-//                      usb_request_clear_feature(pipe, USB_REQUEST_TYPE_STANDARD,
-//                        USB_REQUEST_RECIPIENT_ENDPOINT, 0, pipe->endpoint_no);
-//                      continue;
-//              }
+                if (polling_data->debug > 1) {
+                        if (rc == EOK) {
+                                usb_log_debug(
+                                    "Poll0x%x: received: '%s' (%zuB).\n",
+                                    polling_data,
+                                    usb_debug_str_buffer(polling_data->buffer,
+                                        actual_size, 16),
+                                    actual_size);
+                        } else {
+                                usb_log_debug(
+                                    "Poll0x%x: polling failed: %s.\n",
+                                    polling_data, str_error(rc));
+                        }
+                }
+
+                /* If the pipe stalled, we can try to reset the stall. */
+                if ((rc == ESTALL) && (polling_data->auto_clear_halt)) {
+                        /*
+                         * We ignore error here as this is usually a futile
+                         * attempt anyway.
+                         */
+                        usb_request_clear_endpoint_halt(
+                            &polling_data->dev->ctrl_pipe,
+                            pipe->endpoint_no);
+                }
 
                 if (rc != EOK) {
+                        if (polling_data->on_error != NULL) {
+                                bool cont = polling_data->on_error(
+                                    polling_data->dev, rc,
+                                    polling_data->custom_arg);
+                                if (!cont) {
+                                        failed_attempts
+                                            = polling_data->max_failures;
+                                }
+                        }
                         failed_attempts++;
                         continue;
@@ -95 +138 @@
 
                 /* We have the data, execute the callback now. */
-                bool carry_on = polling_data->callback(polling_data->dev,
+                bool carry_on = polling_data->on_data(polling_data->dev,
                     polling_data->buffer, actual_size,
                     polling_data->custom_arg);
@@ -106 +149 @@
                 /* Reset as something might be only a temporary problem. */
                 failed_attempts = 0;
-        }
-
-        if (failed_attempts > 0) {
-                usb_log_error(
-                    "Polling of device `%s' terminated: recurring failures.\n",
-                    polling_data->dev->ddf_dev->name);
-        }
-
-        if (polling_data->terminated_callback != NULL) {
-                polling_data->terminated_callback(polling_data->dev,
+
+                /* Take a rest before next request. */
+                async_usleep(polling_data->delay);
+        }
+
+        if (polling_data->on_polling_end != NULL) {
+                polling_data->on_polling_end(polling_data->dev,
                     failed_attempts > 0, polling_data->custom_arg);
+        }
+
+        if (polling_data->debug > 0) {
+                if (failed_attempts > 0) {
+                        usb_log_error(
+                            "Polling of device `%s' terminated: %s.\n",
+                            polling_data->dev->ddf_dev->name,
+                            "recurring failures");
+                } else {
+                        usb_log_debug(
+                            "Polling of device `%s' terminated by user.\n",
+                            polling_data->dev->ddf_dev->name
+                        );
+                }
         }
 
@@ -159 +213 @@
         }
 
+        usb_device_auto_polling_t *auto_polling
+            = malloc(sizeof(usb_device_auto_polling_t));
+        if (auto_polling == NULL) {
+                return ENOMEM;
+        }
+
+        auto_polling->debug = 1;
+        auto_polling->auto_clear_halt = true;
+        auto_polling->delay = 0;
+        auto_polling->max_failures = MAX_FAILED_ATTEMPTS;
+        auto_polling->on_data = callback;
+        auto_polling->on_polling_end = terminated_callback;
+        auto_polling->on_error = NULL;
+
+        int rc = usb_device_auto_polling(dev, pipe_index, auto_polling,
+           request_size, arg);
+
+        free(auto_polling);
+
+        return rc;
+}
+
+/** Start automatic device polling over interrupt in pipe.
+ *
+ * The polling settings is copied thus it is okay to destroy the structure
+ * after this function returns.
+ *
+ * @warning There is no guarantee when the request to the device
+ * will be sent for the first time (it is possible that this
+ * first request would be executed prior to return from this function).
+ *
+ * @param dev Device to be periodically polled.
+ * @param pipe_index Index of the endpoint pipe used for polling.
+ * @param polling Polling settings.
+ * @param request_size How many bytes to ask for in each request.
+ * @param arg Custom argument (passed as is to the callbacks).
+ * @return Error code.
+ * @retval EOK New fibril polling the device was already started.
+ */
+int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index,
+    usb_device_auto_polling_t *polling,
+    size_t request_size, void *arg)
+{
+        if (dev == NULL) {
+                return EBADMEM;
+        }
+        if (pipe_index >= dev->pipes_count) {
+                return EINVAL;
+        }
+        if ((dev->pipes[pipe_index].pipe->transfer_type != USB_TRANSFER_INTERRUPT)
+            || (dev->pipes[pipe_index].pipe->direction != USB_DIRECTION_IN)) {
+                return EINVAL;
+        }
+        if ((polling == NULL) || (polling->on_data == NULL)) {
+                return EBADMEM;
+        }
+
         polling_data_t *polling_data = malloc(sizeof(polling_data_t));
         if (polling_data == NULL) {
@@ -164 +275 @@
         }
 
-        /* Allocate now to prevent immediate failure in the polling fibril. */
-        polling_data->buffer = malloc(request_size);
+        /* Fill-in the data. */
+        polling_data->buffer = malloc(sizeof(request_size));
         if (polling_data->buffer == NULL) {
                 free(polling_data);
                 return ENOMEM;
         }
+        polling_data->request_size = request_size;
         polling_data->dev = dev;
         polling_data->pipe_index = pipe_index;
-        polling_data->callback = callback;
-        polling_data->terminated_callback = terminated_callback;
-        polling_data->request_size = request_size;
         polling_data->custom_arg = arg;
+
+        polling_data->debug = polling->debug;
+        polling_data->max_failures = polling->max_failures;
+        if (polling->delay >= 0) {
+                polling_data->delay = (useconds_t) polling->delay;
+        } else {
+                polling_data->delay = (useconds_t) dev->pipes[pipe_index]
+                    .descriptor->poll_interval;
+        }
+        polling_data->auto_clear_halt = polling->auto_clear_halt;
+
+        polling_data->on_data = polling->on_data;
+        polling_data->on_polling_end = polling->on_polling_end;
+        polling_data->on_error = polling->on_error;
 
         fid_t fibril = fibril_create(polling_fibril, polling_data);
@@ -181 +304 @@
                 free(polling_data->buffer);
                 free(polling_data);
-                /* FIXME: better error code. */
                 return ENOMEM;
         }
         fibril_add_ready(fibril);
 
-        /* The allocated buffer etc. will be freed by the fibril. */
+        /* Fibril launched. That fibril will free the allocated data. */
 
         return EOK;

uspace/lib/usb/src/hidreport.c

@@ -119 +119 @@
         uint16_t length =  hid_desc->report_desc_info.length;
         size_t actual_size = 0;
-        
-        /*
-         * Start session for the control transfer.
-         */
-        int sess_rc = usb_pipe_start_session(&dev->ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
 
         /*
@@ -162 +152 @@
                     "%u)\n", actual_size, length);
                 return EINVAL;
-        }
-        
-        /*
-         * End session for the control transfer.
-         */
-        sess_rc = usb_pipe_end_session(&dev->ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to end a session: %s.\n",
-                    str_error(sess_rc));
-                free(*report_desc);
-                *report_desc = NULL;
-                return sess_rc;
         }
         

uspace/lib/usb/src/hidreq.c

@@ -56 +56 @@
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
- * @return Other value inherited from one of functions 
- *         usb_pipe_start_session(), usb_pipe_end_session(),
- *         usb_control_request_set().
+ * @return Other value inherited from function usb_control_request_set().
  */
 int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no,
@@ -79 +77 @@
          */
         
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
+        int rc;
         
         uint16_t value = 0;
@@ -97 +88 @@
             USB_HIDREQ_SET_REPORT, value, iface_no, buffer, buf_size);
 
-        sess_rc = usb_pipe_end_session(ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return rc;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
         }
         
@@ -123 +106 @@
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
- * @return Other value inherited from one of functions 
- *         usb_pipe_start_session(), usb_pipe_end_session(),
- *         usb_control_request_set().
+ * @return Other value inherited from function usb_control_request_set().
  */
 int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no,
@@ -146 +127 @@
          */
         
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
+        int rc;
 
         usb_log_debug("Sending Set_Protocol request to the device ("
@@ -162 +136 @@
             USB_HIDREQ_SET_PROTOCOL, protocol, iface_no, NULL, 0);
 
-        sess_rc = usb_pipe_end_session(ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return rc;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
         }
         
@@ -189 +155 @@
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
- * @return Other value inherited from one of functions 
- *         usb_pipe_start_session(), usb_pipe_end_session(),
- *         usb_control_request_set().
+ * @return Other value inherited from function usb_control_request_set().
  */
 int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration)
@@ -211 +175 @@
          */
         
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
+        int rc;
 
         usb_log_debug("Sending Set_Idle request to the device ("
@@ -229 +186 @@
             USB_HIDREQ_SET_IDLE, value, iface_no, NULL, 0);
 
-        sess_rc = usb_pipe_end_session(ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return rc;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
         }
         
@@ -259 +208 @@
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
- * @return Other value inherited from one of functions 
- *         usb_pipe_start_session(), usb_pipe_end_session(),
- *         usb_control_request_set().
+ * @return Other value inherited from function usb_control_request_set().
  */
 int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, 
@@ -283 +230 @@
          */
         
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
+        int rc;
 
         uint16_t value = 0;
@@ -302 +242 @@
             actual_size);
 
-        sess_rc = usb_pipe_end_session(ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return rc;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
         }
         
@@ -328 +260 @@
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
- * @return Other value inherited from one of functions 
- *         usb_pipe_start_session(), usb_pipe_end_session(),
- *         usb_control_request_set().
+ * @return Other value inherited from function usb_control_request_set().
  */
 int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 
@@ -351 +281 @@
          */
         
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
+        int rc; 
 
         usb_log_debug("Sending Get_Protocol request to the device ("
@@ -370 +293 @@
             USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size);
 
-        sess_rc = usb_pipe_end_session(ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return rc;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
         }
         
@@ -427 +342 @@
          */
         
-        int rc, sess_rc;
-        
-        sess_rc = usb_pipe_start_session(ctrl_pipe);
-        if (sess_rc != EOK) {
-                usb_log_warning("Failed to start a session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
-        }
+        int rc;
 
         usb_log_debug("Sending Get_Idle request to the device ("
@@ -448 +356 @@
             &actual_size);
 
-        sess_rc = usb_pipe_end_session(ctrl_pipe);
-
-        if (rc != EOK) {
-                usb_log_warning("Error sending output report to the keyboard: "
-                    "%s.\n", str_error(rc));
-                return rc;
-        }
-
-        if (sess_rc != EOK) {
-                usb_log_warning("Error closing session: %s.\n",
-                    str_error(sess_rc));
-                return sess_rc;
+        if (rc != EOK) {
+                usb_log_warning("Error sending output report to the keyboard: "
+                    "%s.\n", str_error(rc));
+                return rc;
         }
         

uspace/lib/usb/src/host/batch.c

@@ -39 +39 @@
 #include <usb/host/batch.h>
 
+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_init(
     usb_transfer_batch_t *instance,
-    usb_target_t target,
-    usb_transfer_type_t transfer_type,
-    usb_speed_t speed,
-    size_t max_packet_size,
+    endpoint_t *ep,
     char *buffer,
-    char *transport_buffer,
+    char *data_buffer,
     size_t buffer_size,
     char *setup_buffer,
@@ -54 +54 @@
     void *arg,
     ddf_fun_t *fun,
-                endpoint_t *ep,
-    void *private_data
+    void *private_data,
+    void (*private_data_dtor)(void *p_data)
     )
 {
         assert(instance);
         link_initialize(&instance->link);
-        instance->target = target;
-        instance->transfer_type = transfer_type;
-        instance->speed = speed;
-        instance->direction = ep->direction;
+        instance->ep = ep;
         instance->callback_in = func_in;
         instance->callback_out = func_out;
         instance->arg = arg;
         instance->buffer = buffer;
-        instance->transport_buffer = transport_buffer;
+        instance->data_buffer = data_buffer;
         instance->buffer_size = buffer_size;
         instance->setup_buffer = setup_buffer;
         instance->setup_size = setup_size;
-        instance->max_packet_size = max_packet_size;
         instance->fun = fun;
         instance->private_data = private_data;
+        instance->private_data_dtor = private_data_dtor;
         instance->transfered_size = 0;
         instance->next_step = NULL;
         instance->error = EOK;
-        instance->ep = ep;
         endpoint_use(instance->ep);
+}
+/*----------------------------------------------------------------------------*/
+/** Helper function, calls callback and correctly destroys batch structure.
+ *
+ * @param[in] instance Batch structure to use.
+ */
+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.
+ */
+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);
 }
 /*----------------------------------------------------------------------------*/
@@ -105 +123 @@
         assert(instance);
         assert(instance->callback_in);
+        assert(instance->ep);
 
         /* We are data in, we need data */
-        memcpy(instance->buffer, instance->transport_buffer,
-            instance->buffer_size);
+        memcpy(instance->buffer, instance->data_buffer, instance->buffer_size);
 
         usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
-            instance,
-            instance->target.address, instance->target.endpoint,
-            usb_str_speed(instance->speed),
-            usb_str_transfer_type_short(instance->transfer_type),
-            instance->transfered_size,
-            str_error(instance->error), instance->error);
+            instance, instance->ep->address, instance->ep->endpoint,
+            usb_str_speed(instance->ep->speed),
+            usb_str_transfer_type_short(instance->ep->transfer_type),
+            instance->transfered_size, str_error(instance->error), instance->error);
 
         instance->callback_in(instance->fun, instance->error,
@@ -132 +148 @@
 
         usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n",
-            instance,
-            instance->target.address, instance->target.endpoint,
-            usb_str_speed(instance->speed),
-            usb_str_transfer_type_short(instance->transfer_type),
+            instance, instance->ep->address, instance->ep->endpoint,
+            usb_str_speed(instance->ep->speed),
+            usb_str_transfer_type_short(instance->ep->transfer_type),
             str_error(instance->error), instance->error);
 
@@ -141 +156 @@
             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)
+{
+        assert(instance);
+        usb_log_debug("Batch(%p) disposing.\n", instance);
+        if (instance->private_data) {
+                assert(instance->private_data_dtor);
+                instance->private_data_dtor(instance->private_data);
+        }
+        free(instance);
+}
 /**
  * @}

uspace/lib/usb/src/host/device_keeper.c

@@ -48 +48 @@
 {
         assert(instance);
-        fibril_mutex_initialize(&instance->guard);
-        fibril_condvar_initialize(&instance->change);
-        instance->last_address = 0;
         unsigned i = 0;
         for (; i < USB_ADDRESS_COUNT; ++i) {
@@ -60 +57 @@
         // (it is needed to allow smooth registration at default address)
         instance->devices[0].occupied = true;
+        instance->last_address = 0;
+        fibril_mutex_initialize(&instance->guard);
 }
-/*----------------------------------------------------------------------------*/
-/** Attempt to obtain address 0, blocks.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] speed Speed of the device requesting default address.
- */
-void usb_device_keeper_reserve_default_address(
-    usb_device_keeper_t *instance, usb_speed_t speed)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
-                fibril_condvar_wait(&instance->change, &instance->guard);
-        }
-        instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
-        instance->devices[USB_ADDRESS_DEFAULT].speed = speed;
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-/** Attempt to obtain address 0, blocks.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] speed Speed of the device requesting default address.
- */
-void usb_device_keeper_release_default_address(usb_device_keeper_t *instance)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
-        fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->change);
-}
-/*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 /** Get a free USB address
@@ -120 +86 @@
         assert(new_address != USB_ADDRESS_DEFAULT);
         assert(instance->devices[new_address].occupied == false);
+
         instance->devices[new_address].occupied = true;
         instance->devices[new_address].speed = speed;
         instance->last_address = new_address;
+
         fibril_mutex_unlock(&instance->guard);
         return new_address;
@@ -138 +106 @@
         assert(instance);
         fibril_mutex_lock(&instance->guard);
+
         assert(address > 0);
         assert(address <= USB11_ADDRESS_MAX);
         assert(instance->devices[address].occupied);
+
         instance->devices[address].handle = handle;
         fibril_mutex_unlock(&instance->guard);
@@ -159 +129 @@
         fibril_mutex_lock(&instance->guard);
         assert(instance->devices[address].occupied);
+
         instance->devices[address].occupied = false;
         fibril_mutex_unlock(&instance->guard);
@@ -177 +148 @@
         while (address <= USB11_ADDRESS_MAX) {
                 if (instance->devices[address].handle == handle) {
+                        assert(instance->devices[address].occupied);
                         fibril_mutex_unlock(&instance->guard);
                         return address;
@@ -198 +170 @@
         assert(address >= 0);
         assert(address <= USB11_ADDRESS_MAX);
+
         return instance->devices[address].speed;
 }

uspace/lib/usb/src/host/endpoint.c

@@ -53 +53 @@
         fibril_mutex_initialize(&instance->guard);
         fibril_condvar_initialize(&instance->avail);
+        endpoint_clear_hc_data(instance);
         return EOK;
 }
@@ -61 +62 @@
         assert(!instance->active);
         free(instance);
+}
+/*----------------------------------------------------------------------------*/
+void endpoint_set_hc_data(endpoint_t *instance,
+    void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int))
+{
+        assert(instance);
+        instance->hc_data.data = data;
+        instance->hc_data.toggle_get = toggle_get;
+        instance->hc_data.toggle_set = toggle_set;
+}
+/*----------------------------------------------------------------------------*/
+void endpoint_clear_hc_data(endpoint_t *instance)
+{
+        assert(instance);
+        instance->hc_data.data = NULL;
+        instance->hc_data.toggle_get = NULL;
+        instance->hc_data.toggle_set = NULL;
 }
 /*----------------------------------------------------------------------------*/
@@ -85 +103 @@
 {
         assert(instance);
+        if (instance->hc_data.toggle_get)
+                instance->toggle =
+                    instance->hc_data.toggle_get(instance->hc_data.data);
         return (int)instance->toggle;
 }
@@ -92 +113 @@
         assert(instance);
         assert(toggle == 0 || toggle == 1);
+        if (instance->hc_data.toggle_set)
+                instance->hc_data.toggle_set(instance->hc_data.data, toggle);
         instance->toggle = toggle;
 }
@@ -100 +123 @@
         if (instance->address == target.address &&
             (instance->endpoint == target.endpoint || target.endpoint == 0))
-                instance->toggle = 0;
+                endpoint_toggle_set(instance, 0);
 }
 /**

uspace/lib/usb/src/host/usb_endpoint_manager.c

@@ -211 +211 @@
 
         node_t *node = hash_table_get_instance(item, node_t, link);
+        if (node->ep->active)
+                return EBUSY;
+
         instance->free_bw += node->bw;
         hash_table_remove(&instance->ep_table, key, MAX_KEYS);

uspace/lib/usb/src/pipesinit.c

@@ -365 +365 @@
         pipe->direction = direction;
         pipe->refcount = 0;
+        pipe->auto_reset_halt = false;
 
         return EOK;
@@ -385 +386 @@
             0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE,
             USB_DIRECTION_BOTH);
+
+        pipe->auto_reset_halt = true;
 
         return rc;

uspace/lib/usb/src/pipesio.c

@@ -49 +49 @@
 #include <assert.h>
 #include <usbhc_iface.h>
+#include <usb/request.h>
 #include "pipepriv.h"
 
@@ -307 +308 @@
 }
 
+/** Try to clear endpoint halt of default control pipe.
+ *
+ * @param pipe Pipe for control endpoint zero.
+ */
+static void clear_self_endpoint_halt(usb_pipe_t *pipe)
+{
+        assert(pipe != NULL);
+
+        if (!pipe->auto_reset_halt || (pipe->endpoint_no != 0)) {
+                return;
+        }
+
+
+        /* Prevent indefinite recursion. */
+        pipe->auto_reset_halt = false;
+        usb_request_clear_endpoint_halt(pipe, 0);
+        pipe->auto_reset_halt = true;
+}
+
 
 /** Request a control read transfer, no checking of input parameters.
@@ -436 +456 @@
             setup_buffer, setup_buffer_size,
             data_buffer, data_buffer_size, &act_size);
+
+        if (rc == ESTALL) {
+                clear_self_endpoint_halt(pipe);
+        }
 
         pipe_drop_ref(pipe);
@@ -563 +587 @@
             setup_buffer, setup_buffer_size, data_buffer, data_buffer_size);
 
+        if (rc == ESTALL) {
+                clear_self_endpoint_halt(pipe);
+        }
+
         pipe_drop_ref(pipe);
 

uspace/lib/usb/src/request.c

@@ -871 +871 @@
 }
 
+/** Clear halt bit of an endpoint pipe (after pipe stall).
+ *
+ * @param pipe Control pipe.
+ * @param ep_index Endpoint index (in native endianness).
+ * @return Error code.
+ */
+int usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index)
+{
+        return usb_request_clear_feature(pipe,
+            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT,
+            uint16_host2usb(USB_FEATURE_SELECTOR_ENDPOINT_HALT),
+            uint16_host2usb(ep_index));
+}
+
 /**
  * @}