Changeset e50cd7f for uspace/lib/usb – HelenOS

uspace/lib/usb/Makefile

-              ref354b6
+              re50cd7f
 SOURCES = \
         src/addrkeep.c \
+        src/altiface.c \
         src/class.c \
         src/ddfiface.c \
 …
         src/dp.c \
         src/dump.c \
+        src/hidiface.c \
         src/hidparser.c \
         src/hub.c \
+        src/pipepriv.c \
         src/pipes.c \
         src/pipesinit.c \

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

ref354b6	re50cd7f
317	317	usb_hid_report_path_t usb_hid_report_path_clone(usb_hid_report_path_t usage_path);
318	318
	319	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);
319	320
320	321	/*

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

-              ref354b6
+              re50cd7f
  */
 typedef enum {
+        USB_HUB_FEATURE_HUB_LOCAL_POWER = 0,
+        USB_HUB_FEATURE_HUB_OVER_CURRENT = 1,
         USB_HUB_FEATURE_C_HUB_LOCAL_POWER = 0,
         USB_HUB_FEATURE_C_HUB_OVER_CURRENT = 1,
 …
         /* USB_HUB_FEATURE_ = , */
 } usb_hub_class_feature_t;
 /** Header of standard hub descriptor without the "variadic" part. */
 …
             maximum of 255 ports).
      */
     uint8_t * devices_removable;
+    uint8_t devices_removable[32];
     /**

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

-              ref354b6
+              re50cd7f
     usb_endpoint_description_t **);
+typedef bool (*usb_polling_callback_t)(usb_device_t *,
+    uint8_t *, size_t, void *);
+typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
+int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *);
+int usb_device_create_pipes(ddf_dev_t *, usb_device_connection_t *,
+    usb_endpoint_description_t **, uint8_t *, size_t, int, int,
+    usb_endpoint_mapping_t **, size_t *);
+int usb_device_destroy_pipes(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 **);
+int usb_device_auto_poll(usb_device_t *, size_t,
+    usb_polling_callback_t, size_t, usb_polling_terminted_callback_t, void *);
+size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);
+int usb_alternate_interfaces_create(uint8_t *, size_t, int,
+    usb_alternate_interfaces_t **);
 #endif

uspace/lib/usb/include/usb/host/batch.h

-              ref354b6
+              re50cd7f
 typedef struct usb_transfer_batch usb_transfer_batch_t;
 struct usb_transfer_batch {
+        endpoint_t *ep;
         link_t link;
-        usb_target_t target;
-        usb_transfer_type_t transfer_type;
-        usb_speed_t speed;
-        usb_direction_t direction;
         usbhc_iface_transfer_in_callback_t callback_in;
         usbhc_iface_transfer_out_callback_t callback_out;
+        void *arg;
         char *buffer;
         char *transport_buffer;
+        char *data_buffer;
         size_t buffer_size;
         char *setup_buffer;
         size_t setup_size;
-        size_t max_packet_size;
         size_t transfered_size;
         void (*next_step)(usb_transfer_batch_t *);
         int error;
         ddf_fun_t *fun;
-        void *arg;
-        endpoint_t *ep;
         void *private_data;
+        void (*private_data_dtor)(void *p_data);
 };
 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,
 …
     void *arg,
     ddf_fun_t *fun,
                 endpoint_t *ep,
     void *private_data
+    void *private_data,
+    void (*private_data_dtor)(void *p_data)
 );
+void usb_transfer_batch_call_in_and_dispose(usb_transfer_batch_t *instance);
+void usb_transfer_batch_call_out_and_dispose(usb_transfer_batch_t *instance);
+void usb_transfer_batch_finish(usb_transfer_batch_t *instance);
+void usb_transfer_batch_dispose(usb_transfer_batch_t *instance);
+static inline void usb_transfer_batch_finish_error(
+    usb_transfer_batch_t *instance, int error)
+{
+        assert(instance);
+        instance->error = error;
+        usb_transfer_batch_finish(instance);
+}
 static inline usb_transfer_batch_t *usb_transfer_batch_from_link(link_t *l)
 …
+}
-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_finish(usb_transfer_batch_t *instance, int error);
 #endif
 /**

uspace/lib/usb/include/usb/host/device_keeper.h

-              ref354b6
+              re50cd7f
         usb_speed_t speed;
         bool occupied;
-        link_t endpoints;
-        uint16_t control_used;
         devman_handle_t handle;
 };
 …
         struct usb_device_info devices[USB_ADDRESS_COUNT];
         fibril_mutex_t guard;
-        fibril_condvar_t change;
         usb_address_t last_address;
 } usb_device_keeper_t;
 void usb_device_keeper_init(usb_device_keeper_t *instance);
-void usb_device_keeper_add_ep(
-    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
-void usb_device_keeper_reserve_default_address(
-    usb_device_keeper_t *instance, usb_speed_t speed);
-void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
-void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
-    usb_target_t target, const uint8_t *setup_data);
 usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
 …
 usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     usb_address_t address);
-void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_target_t target);
-void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_target_t target);
 #endif
 /**

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

-              ref354b6
+              re50cd7f
 #include <bool.h>
 #include <adt/list.h>
+#include <fibril_synch.h>
 #include <usb/usb.h>
 …
         usb_speed_t speed;
         size_t max_packet_size;
-        bool active;
         unsigned toggle:1;
+        link_t same_device_eps;
+        fibril_mutex_t guard;
+        fibril_condvar_t avail;
+        volatile bool active;
+        struct {
+                void *data;
+                int (*toggle_get)(void *);
+                void (*toggle_set)(void *, int);
+        } hc_data;
 } endpoint_t;
 …
 void endpoint_destroy(endpoint_t *instance);
+void endpoint_set_hc_data(endpoint_t *instance,
+    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(link_t *ep);
+void endpoint_toggle_reset_filtered(link_t *ep, usb_endpoint_t epn);
+void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target);
 #endif
 /**

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

-              ref354b6
+              re50cd7f
     endpoint_t *ep, size_t data_size);
-int usb_endpoint_manager_register_ep_wait(usb_endpoint_manager_t *instance,
-    usb_address_t address, usb_endpoint_t ep, usb_direction_t direction,
-    void *data, void (*data_remove_callback)(void* data, void* arg), void *arg,
-    size_t bw);
 int usb_endpoint_manager_unregister_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);
+static inline 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 = malloc(sizeof(endpoint_t));
+        if (ep == NULL)
+                return ENOMEM;
+        int ret = endpoint_init(ep, address, endpoint, direction, type, speed,
+            max_packet_size);
+        if (ret != EOK) {
+                free(ep);
+                return ret;
+        }
+        ret = usb_endpoint_manager_register_ep(instance, ep, data_size);
+        if (ret != EOK) {
+                endpoint_destroy(ep);
+                return ret;
+        }
+        return EOK;
+}
 #endif
 /**

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

-              ref354b6
+              re50cd7f
 } usb_hc_attached_device_t;
-int usb_hc_reserve_default_address(usb_hc_connection_t *, usb_speed_t);
-int usb_hc_release_default_address(usb_hc_connection_t *);
 usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_speed_t);
 int usb_hc_register_device(usb_hc_connection_t *,

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

-              ref354b6
+              re50cd7f
 #include <ipc/devman.h>
 #include <ddf/driver.h>
+#include <fibril_synch.h>
 /** Abstraction of a physical connection to the device.
 …
  * This endpoint must be bound with existing usb_device_connection_t
  * (i.e. the wire to send data over).
+ *
+ * Locking order: if you want to lock both mutexes
+ * (@c guard and @c hc_phone_mutex), lock @c guard first.
+ * It is not necessary to lock @c guard if you want to lock @c hc_phone_mutex
+ * only.
  */
 typedef struct {
+        /** Guard of the whole pipe. */
+        fibril_mutex_t guard;
         /** The connection used for sending the data. */
         usb_device_connection_t *wire;
 …
         /** Phone to the host controller.
          * Negative when no session is active.
+         * It is an error to access this member without @c hc_phone_mutex
+         * being locked.
+         * If call over the phone is to be made, it must be preceeded by
+         * call to pipe_add_ref() [internal libusb function].
          */
         int hc_phone;
+        /** Guard for serialization of requests over the phone. */
+        fibril_mutex_t hc_phone_mutex;
+        /** Number of active transfers over the pipe. */
+        int refcount;
+        /** Whether to automatically reset halt on the endpoint.
+         * Valid only for control endpoint zero.
+         */
+        bool auto_reset_halt;
 } usb_pipe_t;
 …
 int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     size_t, 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 *);
 int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *);
 int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *);
 …
 int usb_pipe_end_session(usb_pipe_t *);
 bool usb_pipe_is_session_started(usb_pipe_t *);
+int usb_pipe_start_long_transfer(usb_pipe_t *);
+void usb_pipe_end_long_transfer(usb_pipe_t *);
 int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);

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

-              ref354b6
+              re50cd7f
 /** USB endpoint status - endpoint is halted (stalled). */
 #define USB_ENDPOINT_STATUS_HALTED ((uint16_t)(1 << 0))
+/** USB feature selector - endpoint halt (stall). */
+#define USB_FEATURE_SELECTOR_ENDPOINT_HALT (0)
+/** USB feature selector - device remote wake-up. */
+#define USB_FEATURE_SELECTOR_REMOTE_WAKEUP (1)
 /** Standard device request. */
 …
     char **);
+int usb_request_clear_endpoint_halt(usb_pipe_t *, uint16_t);
 #endif
 /**

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

-              ref354b6
+              re50cd7f
         USB_SPEED_FULL,
         /** USB 2.0 high speed (480Mbits/s). */
+        USB_SPEED_HIGH
+        USB_SPEED_HIGH,
+        /** Psuedo-speed serving as a boundary. */
+        USB_SPEED_MAX
 } usb_speed_t;

uspace/lib/usb/src/devdrv.c

-              ref354b6
+              re50cd7f
+}
-/** Log out of memory error on given device.
+ *
- * @param dev Device causing the trouble.
- */
-static void usb_log_oom(ddf_dev_t *dev)
+{
-        usb_log_error("Out of memory when adding device `%s'.\n",
-            dev->name);
+}
 /** Count number of pipes the driver expects.
+ *
 …
  */
 static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
+    usb_device_t *dev)
+{
+        int rc;
+        size_t pipe_count = count_other_pipes(endpoints);
+        if (pipe_count == 0) {
+    usb_device_t *dev, int alternate_setting)
+{
+        if (endpoints == NULL) {
+                dev->pipes = NULL;
+                dev->pipes_count = 0;
                 return EOK;
+        }
+        dev->pipes = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count);
+        if (dev->pipes == NULL) {
+                usb_log_oom(dev->ddf_dev);
+                return ENOMEM;
+        }
+        size_t i;
+        /* Initialize to NULL first for rollback purposes. */
+        for (i = 0; i < pipe_count; i++) {
+                dev->pipes[i].pipe = NULL;
+        }
+        for (i = 0; i < pipe_count; i++) {
+                dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t));
+                if (dev->pipes[i].pipe == NULL) {
+                        usb_log_oom(dev->ddf_dev);
+                        rc = ENOMEM;
+                        goto rollback;
+                }
+                dev->pipes[i].description = endpoints[i];
+                dev->pipes[i].interface_no = dev->interface_no;
+                dev->pipes[i].interface_setting = 0;
+        }
+        rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count,
+        usb_endpoint_mapping_t *pipes;
+        size_t pipes_count;
+        int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints,
             dev->descriptors.configuration, dev->descriptors.configuration_size,
+            &dev->wire);
+        if (rc != EOK) {
+                usb_log_error("Failed initializing USB endpoints: %s.\n",
+                    str_error(rc));
+                goto rollback;
+        }
+        /* Register the endpoints. */
+        usb_hc_connection_t hc_conn;
+        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev);
+        if (rc != EOK) {
+                usb_log_error(
+                    "Failed initializing connection to host controller: %s.\n",
+                    str_error(rc));
+                goto rollback;
+        }
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                usb_log_error("Failed to connect to host controller: %s.\n",
+                    str_error(rc));
+                goto rollback;
+        }
+        for (i = 0; i < pipe_count; i++) {
+                if (dev->pipes[i].present) {
+                        rc = usb_pipe_register(dev->pipes[i].pipe,
+                            dev->pipes[i].descriptor->poll_interval,
+                            &hc_conn);
+                        /* Ignore error when operation not supported by HC. */
+                        if ((rc != EOK) && (rc != ENOTSUP)) {
+                                /* FIXME: what shall we do? */
+                                dev->pipes[i].present = false;
+                                free(dev->pipes[i].pipe);
+                                dev->pipes[i].pipe = NULL;
+                        }
+                }
+        }
+        /* Ignoring errors here. */
+        usb_hc_connection_close(&hc_conn);
+        dev->pipes_count = pipe_count;
+        return EOK;
+rollback:
+        for (i = 0; i < pipe_count; i++) {
+                if (dev->pipes[i].pipe != NULL) {
+                        free(dev->pipes[i].pipe);
+                }
+        }
+        free(dev->pipes);
+        return rc;
+}
+/** 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);
+        /*
+         * For further actions, we need open session on default control pipe.
+         */
+        rc = usb_pipe_start_session(&dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_error("Failed to start an IPC session: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
+        /* Get the device descriptor. */
+        rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
+            &dev->descriptors.device);
+        if (rc != EOK) {
+                usb_log_error("Failed to retrieve device descriptor: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
+        /* Get the full configuration descriptor. */
+        rc = usb_request_get_full_configuration_descriptor_alloc(
+            &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration,
+            &dev->descriptors.configuration_size);
+        if (rc != EOK) {
+                usb_log_error("Failed retrieving configuration descriptor: %s. %s\n",
+                    dev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+        if (driver->endpoints != NULL) {
+                rc = initialize_other_pipes(driver->endpoints, dev);
+        }
+        /* No checking here. */
+        usb_pipe_end_session(&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.
+ */
+static size_t count_alternate_interfaces(uint8_t *config_descr,
+    size_t config_descr_size, int interface_no)
+{
+        assert(config_descr != NULL);
+        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
+            = count_alternate_interfaces(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;
+            dev->interface_no, alternate_setting,
+            &pipes, &pipes_count);
+        if (rc != EOK) {
+                return rc;
+        }
+        dev->pipes = pipes;
+        dev->pipes_count = pipes_count;
         return EOK;
 …
         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);
 …
 static int destroy_current_pipes(usb_device_t *dev)
+{
+        size_t i;
+        int rc;
+        /* TODO: this shall be done under some device mutex. */
+        /* First check that no session is opened. */
+        for (i = 0; i < dev->pipes_count; i++) {
+                if (usb_pipe_is_session_started(dev->pipes[i].pipe)) {
+                        return EBUSY;
+                }
+        }
+        /* Prepare connection to HC. */
+        usb_hc_connection_t hc_conn;
+        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev);
+        if (rc != EOK) {
+                return rc;
+        }
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                return rc;
+        }
+        /* Destroy the pipes. */
+        for (i = 0; i < dev->pipes_count; i++) {
+                usb_pipe_unregister(dev->pipes[i].pipe, &hc_conn);
+                free(dev->pipes[i].pipe);
+        }
+        usb_hc_connection_close(&hc_conn);
+        free(dev->pipes);
+        int rc = usb_device_destroy_pipes(dev->ddf_dev,
+            dev->pipes, dev->pipes_count);
+        if (rc != EOK) {
+                return rc;
+        }
         dev->pipes = NULL;
         dev->pipes_count = 0;
 …
  * 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.
 …
         int rc;
-        /* TODO: more transactional behavior. */
         /* Destroy existing pipes. */
         rc = destroy_current_pipes(dev);
 …
         /* Create new pipes. */
         rc = initialize_other_pipes(endpoints, dev);
+        rc = initialize_other_pipes(endpoints, dev, (int) alternate_setting);
         return rc;
+}
+/** Retrieve basic descriptors from the device.
+ *
+ * @param[in] ctrl_pipe Control endpoint pipe.
+ * @param[out] descriptors Where to store the descriptors.
+ * @return Error code.
+ */
+int usb_device_retrieve_descriptors(usb_pipe_t *ctrl_pipe,
+    usb_device_descriptors_t *descriptors)
+{
+        assert(descriptors != NULL);
+        descriptors->configuration = NULL;
+        int rc;
+        /* It is worth to start a long transfer. */
+        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) {
+                goto leave;
+        }
+        /* Get the full configuration descriptor. */
+        rc = usb_request_get_full_configuration_descriptor_alloc(
+            ctrl_pipe, 0, (void **) &descriptors->configuration,
+            &descriptors->configuration_size);
+leave:
+        usb_pipe_end_long_transfer(ctrl_pipe);
+        return rc;
+}
+/** Create pipes for a device.
+ *
+ * This is more or less a wrapper that does following actions:
+ * - allocate and initialize pipes
+ * - map endpoints to the pipes based on the descriptions
+ * - registers endpoints with the host controller
+ *
+ * @param[in] dev Generic DDF device backing the USB one.
+ * @param[in] wire Initialized backing connection to the host controller.
+ * @param[in] endpoints Endpoints description, NULL terminated.
+ * @param[in] config_descr Configuration descriptor of active configuration.
+ * @param[in] config_descr_size Size of @p config_descr in bytes.
+ * @param[in] interface_no Interface to map from.
+ * @param[in] interface_setting Interface setting (default is usually 0).
+ * @param[out] pipes_ptr Where to store array of created pipes
+ *      (not NULL terminated).
+ * @param[out] pipes_count_ptr Where to store number of pipes
+ *      (set to if you wish to ignore the count).
+ * @return Error code.
+ */
+int usb_device_create_pipes(ddf_dev_t *dev, usb_device_connection_t *wire,
+    usb_endpoint_description_t **endpoints,
+    uint8_t *config_descr, size_t config_descr_size,
+    int interface_no, int interface_setting,
+    usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr)
+{
+        assert(dev != NULL);
+        assert(wire != NULL);
+        assert(endpoints != NULL);
+        assert(config_descr != NULL);
+        assert(config_descr_size > 0);
+        assert(pipes_ptr != NULL);
+        size_t i;
+        int rc;
+        size_t pipe_count = count_other_pipes(endpoints);
+        if (pipe_count == 0) {
+                *pipes_ptr = NULL;
+                return EOK;
+        }
+        usb_endpoint_mapping_t *pipes
+            = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count);
+        if (pipes == NULL) {
+                return ENOMEM;
+        }
+        /* Initialize to NULL to allow smooth rollback. */
+        for (i = 0; i < pipe_count; i++) {
+                pipes[i].pipe = NULL;
+        }
+        /* Now allocate and fully initialize. */
+        for (i = 0; i < pipe_count; i++) {
+                pipes[i].pipe = malloc(sizeof(usb_pipe_t));
+                if (pipes[i].pipe == NULL) {
+                        rc = ENOMEM;
+                        goto rollback_free_only;
+                }
+                pipes[i].description = endpoints[i];
+                pipes[i].interface_no = interface_no;
+                pipes[i].interface_setting = interface_setting;
+        }
+        /* Find the mapping from configuration descriptor. */
+        rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
+            config_descr, config_descr_size, wire);
+        if (rc != EOK) {
+                goto rollback_free_only;
+        }
+        /* Register the endpoints with HC. */
+        usb_hc_connection_t hc_conn;
+        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev);
+        if (rc != EOK) {
+                goto rollback_free_only;
+        }
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                goto rollback_free_only;
+        }
+        for (i = 0; i < pipe_count; i++) {
+                if (pipes[i].present) {
+                        rc = usb_pipe_register(pipes[i].pipe,
+                            pipes[i].descriptor->poll_interval, &hc_conn);
+                        if (rc != EOK) {
+                                goto rollback_unregister_endpoints;
+                        }
+                }
+        }
+        usb_hc_connection_close(&hc_conn);
+        *pipes_ptr = pipes;
+        if (pipes_count_ptr != NULL) {
+                *pipes_count_ptr = pipe_count;
+        }
+        return EOK;
+        /*
+         * Jump here if something went wrong after endpoints have
+         * been registered.
+         * This is also the target when the registration of
+         * endpoints fails.
+         */
+rollback_unregister_endpoints:
+        for (i = 0; i < pipe_count; i++) {
+                if (pipes[i].present) {
+                        usb_pipe_unregister(pipes[i].pipe, &hc_conn);
+                }
+        }
+        usb_hc_connection_close(&hc_conn);
+        /*
+         * Jump here if something went wrong before some actual communication
+         * with HC. Then the only thing that needs to be done is to free
+         * allocated memory.
+         */
+rollback_free_only:
+        for (i = 0; i < pipe_count; i++) {
+                if (pipes[i].pipe != NULL) {
+                        free(pipes[i].pipe);
+                }
+        }
+        free(pipes);
+        return rc;
+}
+/** Destroy pipes previously created by usb_device_create_pipes.
+ *
+ * @param[in] dev Generic DDF device backing the USB one.
+ * @param[in] pipes Endpoint mapping to be destroyed.
+ * @param[in] pipes_count Number of endpoints.
+ */
+int usb_device_destroy_pipes(ddf_dev_t *dev,
+    usb_endpoint_mapping_t *pipes, size_t pipes_count)
+{
+        assert(dev != NULL);
+        assert(((pipes != NULL) && (pipes_count > 0))
+            || ((pipes == NULL) && (pipes_count == 0)));
+        if (pipes_count == 0) {
+                return EOK;
+        }
+        int rc;
+        /* Prepare connection to HC to allow endpoint unregistering. */
+        usb_hc_connection_t hc_conn;
+        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev);
+        if (rc != EOK) {
+                return rc;
+        }
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                return rc;
+        }
+        /* Destroy the pipes. */
+        size_t i;
+        for (i = 0; i < pipes_count; i++) {
+                usb_pipe_unregister(pipes[i].pipe, &hc_conn);
+                free(pipes[i].pipe);
+        }
+        usb_hc_connection_close(&hc_conn);
+        free(pipes);
+        return EOK;
+}
+/** 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

-              ref354b6
+              re50cd7f
  * 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>
 …
 /** 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;
 …
 } polling_data_t;
 /** Polling fibril.
+ *
 …
         usb_pipe_t *pipe
             = polling_data->dev->pipes[polling_data->pipe_index].pipe;
+        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;
-                rc = usb_pipe_start_session(pipe);
-                if (rc != EOK) {
-                        failed_attempts++;
-                        continue;
+                }
                 size_t actual_size;
 …
                     polling_data->request_size, &actual_size);
+                /* Quit the session regardless of errors. */
+                usb_pipe_end_session(pipe);
+                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;
 …
                 /* 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);
 …
                 /* 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
+                        );
+                }
+        }
 …
+        }
+        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) {
 …
+        }
         /* 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);
 …
                 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/hidparser.c

-              ref354b6
+              re50cd7f
         offset = item->offset + (j * item->size);
         // FIXME
         if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
 …
                 field = list_get_instance(field_it, usb_hid_report_field_t, link);
+                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) {
+                        ret++;
+                }
+                usb_hid_report_remove_last_item (field->collection_path);
+                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) {
+                                ret++;
+                        }
+                        usb_hid_report_remove_last_item (field->collection_path);
+                }
                 field_it = field_it->next;
 …
 /**
- * Clones given report item structure and returns the new one
+ *
- * @param item Report item structure to clone
- * @return Clonned item
- */
-usb_hid_report_item_t *usb_hid_report_item_clone(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)))) {
-                return NULL;
+        }
-        memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
-        link_initialize(&(new_report_item->link));
-        return new_report_item;
+}
-/**
+ *
+ *
 …
+}
+usb_hid_report_item_t *usb_hid_report_item_clone(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)))) {
+                return NULL;
+        }
+        memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
+        link_initialize(&(new_report_item->link));
+        return new_report_item;
+}
+usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
+                                                        usb_hid_report_field_t *field,
+                            usb_hid_report_path_t *path, int flags,
+                            usb_hid_report_type_t type)
+{
+        usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type);
+        link_t *field_it;
+        if(report_des == NULL){
+                return NULL;
+        }
+        if(field == NULL){
+                // vezmu prvni co mathuje podle path!!
+                field_it = report_des->report_items.next;
+        }
+        else {
+                field_it = field->link.next;
+        }
+        while(field_it != &report_des->report_items) {
+                field = list_get_instance(field_it, usb_hid_report_field_t, link);
+                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);
+                        usb_log_debug("....OK\n");
+                        return field;
+                }
+                usb_hid_report_remove_last_item (field->collection_path);
+                field_it = field_it->next;
+        }
+        return NULL;
+}
 /**
  * @}

uspace/lib/usb/src/hidreport.c

-              ref354b6
+              re50cd7f
                 d = usb_dp_get_sibling_descriptor(&parser, &parser_data,
                     dev->descriptors.configuration, d);
+                ++i;
+        }
 …
         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;
+        }
         /*
 …
                     "%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

-              ref354b6
+              re50cd7f
  * @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,
 …
          */
+        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;
 …
             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;
+        }
 …
  * @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,
 …
          */
+        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 ("
 …
             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;
+        }
 …
  * @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)
 …
          */
+        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 ("
 …
             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;
+        }
 …
  * @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,
 …
          */
+        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;
 …
             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;
+        }
 …
  * @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,
 …
          */
+        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 ("
 …
             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;
+        }
 …
          */
+        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 ("
 …
             &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

-              ref354b6
+              re50cd7f
 #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,
 …
     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 = USB_DIRECTION_BOTH;
+        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);
+}
 /*----------------------------------------------------------------------------*/
 …
+ *
  */
 void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error)
+void usb_transfer_batch_finish(usb_transfer_batch_t *instance)
+{
         assert(instance);
+        instance->error = error;
+        assert(instance->ep);
+        endpoint_release(instance->ep);
         instance->next_step(instance);
+}
 …
         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,
 …
         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);
 …
             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

-              ref354b6
+              re50cd7f
+{
         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) {
                 instance->devices[i].occupied = false;
-                instance->devices[i].control_used = 0;
                 instance->devices[i].handle = 0;
                 list_initialize(&instance->devices[i].endpoints);
+                instance->devices[i].speed = USB_SPEED_MAX;
+        }
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_add_ep(
+    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        assert(instance->devices[address].occupied);
+        list_append(&ep->same_device_eps, &instance->devices[address].endpoints);
+        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_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);
+}
+/*----------------------------------------------------------------------------*/
+/** Check setup packet data for signs of toggle reset.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] target Device to receive setup packet.
+ * @param[in] data Setup packet data.
+ *
+ * Really ugly one.
+ */
+void usb_device_keeper_reset_if_need(
+    usb_device_keeper_t *instance, usb_target_t target, const uint8_t *data)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB_ADDRESS_COUNT || target.address < 0
+            || !instance->devices[target.address].occupied) {
+                fibril_mutex_unlock(&instance->guard);
+                usb_log_error("Invalid data when checking for toggle reset.\n");
+                return;
+        }
+        switch (data[1])
+        {
+        case 0x01: /*clear feature*/
+                /* recipient is endpoint, value is zero (ENDPOINT_STALL) */
+                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
+                        link_t *current =
+                            instance->devices[target.address].endpoints.next;
+                        while (current !=
+                           &instance->devices[target.address].endpoints)
+                        {
+                        /* endpoint number is < 16, thus first byte is enough */
+                                endpoint_toggle_reset_filtered(
+                                    current, data[4]);
+                                current = current->next;
+                        }
+                }
+        break;
+        case 0x9: /* set configuration */
+        case 0x11: /* set interface */
+                /* target must be device */
+                if ((data[0] & 0xf) == 0) {
+                        link_t *current =
+                            instance->devices[target.address].endpoints.next;
+                        while (current !=
+                           &instance->devices[target.address].endpoints)
+                        {
+                                endpoint_toggle_reset(current);
+                                current = current->next;
+                        }
+                }
+        break;
+        }
+        fibril_mutex_unlock(&instance->guard);
+        // TODO: is this hack enough?
+        // (it is needed to allow smooth registration at default address)
+        instance->devices[0].occupied = true;
+        instance->last_address = 0;
+        fibril_mutex_initialize(&instance->guard);
+}
 /*----------------------------------------------------------------------------*/
 …
         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;
 …
         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);
 …
         fibril_mutex_lock(&instance->guard);
         assert(instance->devices[address].occupied);
         instance->devices[address].occupied = false;
         fibril_mutex_unlock(&instance->guard);
 …
         while (address <= USB11_ADDRESS_MAX) {
                 if (instance->devices[address].handle == handle) {
+                        assert(instance->devices[address].occupied);
                         fibril_mutex_unlock(&instance->guard);
                         return address;
 …
         assert(address >= 0);
         assert(address <= USB11_ADDRESS_MAX);
         return instance->devices[address].speed;
+}
-/*----------------------------------------------------------------------------*/
-void usb_device_keeper_use_control(
-    usb_device_keeper_t *instance, usb_target_t target)
+{
-        assert(instance);
-        const uint16_t ep = 1 << target.endpoint;
-        fibril_mutex_lock(&instance->guard);
-        while (instance->devices[target.address].control_used & ep) {
-                fibril_condvar_wait(&instance->change, &instance->guard);
+        }
-        instance->devices[target.address].control_used |= ep;
-        fibril_mutex_unlock(&instance->guard);
+}
-/*----------------------------------------------------------------------------*/
-void usb_device_keeper_release_control(
-    usb_device_keeper_t *instance, usb_target_t target)
+{
-        assert(instance);
-        const uint16_t ep = 1 << target.endpoint;
-        fibril_mutex_lock(&instance->guard);
-        assert((instance->devices[target.address].control_used & ep) != 0);
-        instance->devices[target.address].control_used &= ~ep;
-        fibril_mutex_unlock(&instance->guard);
-        fibril_condvar_signal(&instance->change);
+}
 /**

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

-              ref354b6
+              re50cd7f
  */
+#include <assert.h>
 #include <errno.h>
 #include <usb/host/endpoint.h>
 …
         instance->max_packet_size = max_packet_size;
         instance->toggle = 0;
+        link_initialize(&instance->same_device_eps);
+        instance->active = false;
+        fibril_mutex_initialize(&instance->guard);
+        fibril_condvar_initialize(&instance->avail);
+        endpoint_clear_hc_data(instance);
         return EOK;
+}
 …
+{
         assert(instance);
         list_remove(&instance->same_device_eps);
+        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;
+}
+/*----------------------------------------------------------------------------*/
+void endpoint_use(endpoint_t *instance)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        while (instance->active)
+                fibril_condvar_wait(&instance->avail, &instance->guard);
+        instance->active = true;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void endpoint_release(endpoint_t *instance)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        instance->active = false;
+        fibril_mutex_unlock(&instance->guard);
+        fibril_condvar_signal(&instance->avail);
+}
 /*----------------------------------------------------------------------------*/
 …
+{
         assert(instance);
+        if (instance->hc_data.toggle_get)
+                instance->toggle =
+                    instance->hc_data.toggle_get(instance->hc_data.data);
         return (int)instance->toggle;
+}
 …
         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;
+}
 /*----------------------------------------------------------------------------*/
 void endpoint_toggle_reset(link_t *ep)
+void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target)
+{
-        endpoint_t *instance =
-            list_get_instance(ep, endpoint_t, same_device_eps);
         assert(instance);
+        instance->toggle = 0;
+}
+/*----------------------------------------------------------------------------*/
+void endpoint_toggle_reset_filtered(link_t *ep, usb_endpoint_t epn)
+{
+        endpoint_t *instance =
+            list_get_instance(ep, endpoint_t, same_device_eps);
+        assert(instance);
+        if (instance->endpoint == epn)
+                instance->toggle = 0;
+        if (instance->address == target.address &&
+            (instance->endpoint == target.endpoint || target.endpoint == 0))
+                endpoint_toggle_set(instance, 0);
+}
 /**

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

-              ref354b6
+              re50cd7f
 #include <errno.h>
+#include <usb/debug.h>
 #include <usb/host/usb_endpoint_manager.h>
 …
         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);
+}
 /*----------------------------------------------------------------------------*/
 …
         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);
 …
         return node->ep;
+}
+/*----------------------------------------------------------------------------*/
+/** Check setup packet data for signs of toggle reset.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @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)
+{
+        assert(instance);
+        if (target.endpoint > 15 || target.endpoint < 0
+            || target.address >= USB11_ADDRESS_MAX || target.address < 0) {
+                usb_log_error("Invalid data when checking for toggle reset.\n");
+                return;
+        }
+        switch (data[1])
+        {
+        case 0x01: /*clear feature*/
+                /* recipient is endpoint, value is zero (ENDPOINT_STALL) */
+                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
+                        /* 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);
+                        fibril_mutex_unlock(&instance->guard);
+                }
+        break;
+        case 0x9: /* set configuration */
+        case 0x11: /* set interface */
+                /* target must be device */
+                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);
+                        fibril_mutex_unlock(&instance->guard);
+                }
+        break;
+        }
+}

uspace/lib/usb/src/hub.c

-              ref354b6
+              re50cd7f
 #include <errno.h>
 #include <assert.h>
+#include <usb/debug.h>
+/** How much time to wait between attempts to register endpoint 0:0.
+ * The value is based on typical value for port reset + some overhead.
+ */
+#define ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC (1000 * (10 + 2))
 /** Check that HC connection is alright.
 …
         } while (false)
-/** Tell host controller to reserve default address.
+ *
- * @param connection Opened connection to host controller.
- * @param speed Speed of the device that will respond on the default address.
- * @return Error code.
- */
-int usb_hc_reserve_default_address(usb_hc_connection_t *connection,
-    usb_speed_t speed)
+{
-        CHECK_CONNECTION(connection);
-        return async_req_2_0(connection->hc_phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, speed);
+}
-/** Tell host controller to release default address.
+ *
- * @param connection Opened connection to host controller.
- * @return Error code.
- */
-int usb_hc_release_default_address(usb_hc_connection_t *connection)
+{
-        CHECK_CONNECTION(connection);
-        return async_req_1_0(connection->hc_phone,
-            DEV_IFACE_ID(USBHC_DEV_IFACE),
-            IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
+}
 /** Ask host controller for free address assignment.
+ *
 …
  * error codes than those listed as return codes by this function itself).
+ *
+ * The @p connection representing connection with host controller does not
+ * need to be started.
+ * This function duplicates the connection to allow simultaneous calls of
+ * this function (i.e. from different fibrils).
+ *
  * @param[in] parent Parent device (i.e. the hub device).
  * @param[in] connection Opened connection to host controller.
+ * @param[in] connection Connection to host controller.
  * @param[in] dev_speed New device speed.
  * @param[in] enable_port Function for enabling signaling through the port the
 …
     ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
+{
+        CHECK_CONNECTION(connection);
+        assert(connection != NULL);
+        // FIXME: this is awful, we are accessing directly the structure.
+        usb_hc_connection_t hc_conn = {
+                .hc_handle = connection->hc_handle,
+                .hc_phone = -1
+        };
+        int rc;
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                return rc;
+        }
         /*
          * Request new address.
          */
         usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed);
+        usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed);
         if (dev_addr < 0) {
+                usb_hc_connection_close(&hc_conn);
                 return EADDRNOTAVAIL;
+        }
+        int rc;
+        /*
+         * Reserve the default address.
+         */
+        rc = usb_hc_reserve_default_address(connection, dev_speed);
+        if (rc != EOK) {
+                rc = EBUSY;
+                goto leave_release_free_address;
+        }
+        /*
+         * Enable the port (i.e. allow signaling through this port).
+         */
+        rc = enable_port(port_no, arg);
+        if (rc != EOK) {
+                goto leave_release_default_address;
+        }
+        /*
+         * Change the address from default to the free one.
+         * We need to create a new control pipe for that.
+        /*
+         * We will not register control pipe on default address.
+         * The registration might fail. That means that someone else already
+         * registered that endpoint. We will simply wait and try again.
+         * (Someone else already wants to add a new device.)
          */
         usb_device_connection_t dev_conn;
         rc = usb_device_connection_initialize_on_default_address(&dev_conn,
             connection);
+            &hc_conn);
         if (rc != EOK) {
                 rc = ENOTCONN;
                 goto leave_release_default_address;
+                goto leave_release_free_address;
+        }
 …
         if (rc != EOK) {
                 rc = ENOTCONN;
+                goto leave_release_free_address;
+        }
+        do {
+                rc = usb_pipe_register_with_speed(&ctrl_pipe, dev_speed, 0,
+                    &hc_conn);
+                if (rc != EOK) {
+                        /* Do not overheat the CPU ;-). */
+                        async_usleep(ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC);
+                }
+        } while (rc != EOK);
+        /*
+         * Endpoint is registered. We can enable the port and change
+         * device address.
+         */
+        rc = enable_port(port_no, arg);
+        if (rc != EOK) {
                 goto leave_release_default_address;
+        }
+        /* Before sending any traffic, we need to register this
+         * endpoint.
+         */
+        rc = usb_pipe_register(&ctrl_pipe, 0, connection);
+        if (rc != EOK) {
+                rc = EREFUSED;
+        rc = usb_pipe_probe_default_control(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ESTALL;
                 goto leave_release_default_address;
+        }
+        rc = usb_pipe_probe_default_control(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+        rc = usb_request_set_address(&ctrl_pipe, dev_addr);
+        if (rc != EOK) {
+                rc = ESTALL;
                 goto leave_release_default_address;
+        }
+        rc = usb_pipe_start_session(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_unregister_endpoint;
+        }
+        rc = usb_request_set_address(&ctrl_pipe, dev_addr);
+        if (rc != EOK) {
+                rc = ESTALL;
+                goto leave_stop_session;
+        }
+        usb_pipe_end_session(&ctrl_pipe);
+        /*
+         * Register the control endpoint for the new device.
+         */
+        rc = usb_pipe_register(&ctrl_pipe, 0, connection);
+        if (rc != EOK) {
+                rc = EREFUSED;
+                goto leave_unregister_endpoint;
+        }
+        /*
+         * Release the original endpoint.
+         */
+        unregister_control_endpoint_on_default_address(connection);
+        /*
+         * Once the address is changed, we can return the default address.
+         */
+        usb_hc_release_default_address(connection);
+        /*
+         * Address changed. We can release the original endpoint, thus
+         * allowing other to access the default address.
+         */
+        unregister_control_endpoint_on_default_address(&hc_conn);
+        /*
+         * Time to register the new endpoint.
+         */
+        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
+        if (rc != EOK) {
+                goto leave_release_free_address;
+        }
         /*
 …
+        }
         /*
          * And now inform the host controller about the handle.
 …
                 .handle = child_handle
         };
         rc = usb_hc_register_device(connection, &new_device);
+        rc = usb_hc_register_device(&hc_conn, &new_device);
         if (rc != EOK) {
                 rc = EDESTADDRREQ;
 …
          * Completely ignoring errors here.
          */
-leave_stop_session:
-        usb_pipe_end_session(&ctrl_pipe);
-leave_unregister_endpoint:
-        usb_pipe_unregister(&ctrl_pipe, connection);
 leave_release_default_address:
         usb_hc_release_default_address(connection);
+        usb_pipe_unregister(&ctrl_pipe, &hc_conn);
 leave_release_free_address:
+        usb_hc_unregister_device(connection, dev_addr);
+        usb_hc_unregister_device(&hc_conn, dev_addr);
+        usb_hc_connection_close(&hc_conn);
         return rc;

uspace/lib/usb/src/pipes.c

-              ref354b6
+              re50cd7f
 #include <errno.h>
 #include <assert.h>
+#include "pipepriv.h"
 #define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */
 …
  * necessary.
+ *
+ * @deprecated
+ * Obsoleted with introduction of usb_pipe_start_long_transfer
+ *
  * @param pipe Endpoint pipe to start the session on.
  * @return Error code.
 …
 int usb_pipe_start_session(usb_pipe_t *pipe)
+{
+        assert(pipe);
+        if (usb_pipe_is_session_started(pipe)) {
+                return EBUSY;
+        }
+        int phone = devman_device_connect(pipe->wire->hc_handle, 0);
+        if (phone < 0) {
+                return phone;
+        }
+        pipe->hc_phone = phone;
+        usb_log_warning("usb_pipe_start_session() was deprecated.\n");
         return EOK;
+}
 …
 /** Ends a session on the endpoint pipe.
+ *
+ * @deprecated
+ * Obsoleted with introduction of usb_pipe_end_long_transfer
+ *
  * @see usb_pipe_start_session
+ *
 …
 int usb_pipe_end_session(usb_pipe_t *pipe)
+{
+        assert(pipe);
+        if (!usb_pipe_is_session_started(pipe)) {
+                return ENOENT;
+        }
+        int rc = async_hangup(pipe->hc_phone);
+        if (rc != EOK) {
+                return rc;
+        }
+        pipe->hc_phone = -1;
+        usb_log_warning("usb_pipe_end_session() was deprecated.\n");
         return EOK;
+}
 …
 bool usb_pipe_is_session_started(usb_pipe_t *pipe)
+{
+        return (pipe->hc_phone >= 0);
+        pipe_acquire(pipe);
+        bool started = pipe->refcount > 0;
+        pipe_release(pipe);
+        return started;
+}
+/** Prepare pipe for a long transfer.
+ *
+ * By a long transfer is mean transfer consisting of several
+ * requests to the HC.
+ * Calling such function is optional and it has positive effect of
+ * improved performance because IPC session is initiated only once.
+ *
+ * @param pipe Pipe over which the transfer will happen.
+ * @return Error code.
+ */
+int usb_pipe_start_long_transfer(usb_pipe_t *pipe)
+{
+        return pipe_add_ref(pipe);
+}
+/** Terminate a long transfer on a pipe.
+ *
+ * @see usb_pipe_start_long_transfer
+ *
+ * @param pipe Pipe where to end the long transfer.
+ */
+void usb_pipe_end_long_transfer(usb_pipe_t *pipe)
+{
+        pipe_drop_ref(pipe);
+}

uspace/lib/usb/src/pipesinit.c

-              ref354b6
+              re50cd7f
         assert(connection);
+        fibril_mutex_initialize(&pipe->guard);
         pipe->wire = connection;
         pipe->hc_phone = -1;
+        fibril_mutex_initialize(&pipe->hc_phone_mutex);
         pipe->endpoint_no = endpoint_no;
         pipe->transfer_type = transfer_type;
         pipe->max_packet_size = max_packet_size;
         pipe->direction = direction;
+        pipe->refcount = 0;
+        pipe->auto_reset_halt = false;
         return EOK;
 …
 , USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE,
             USB_DIRECTION_BOTH);
+        pipe->auto_reset_halt = true;
         return rc;
 …
         int rc;
+        TRY_LOOP(failed_attempts) {
+                rc = usb_pipe_start_session(pipe);
+                if (rc == EOK) {
+                        break;
+                }
+        }
+        rc = usb_pipe_start_long_transfer(pipe);
         if (rc != EOK) {
                 return rc;
 …
+                }
+        }
         usb_pipe_end_session(pipe);
+        usb_pipe_end_long_transfer(pipe);
         if (rc != EOK) {
                 return rc;
 …
     usb_hc_connection_t *hc_connection)
+{
+        return usb_pipe_register_with_speed(pipe, USB_SPEED_MAX + 1,
+            interval, hc_connection);
+}
+/** Register endpoint with a speed at the host controller.
+ *
+ * You will rarely need to use this function because it is needed only
+ * if the registered endpoint is of address 0 and there is no other way
+ * to tell speed of the device at address 0.
+ *
+ * @param pipe Pipe to be registered.
+ * @param speed Speed of the device
+ *      (invalid speed means use previously specified one).
+ * @param interval Polling interval.
+ * @param hc_connection Connection to the host controller (must be opened).
+ * @return Error code.
+ */
+int usb_pipe_register_with_speed(usb_pipe_t *pipe, usb_speed_t speed,
+    unsigned int interval,
+    usb_hc_connection_t *hc_connection)
+{
         assert(pipe);
         assert(hc_connection);
 …
+        }
+#define _PACK(high, low) ((high) * 256 + (low))
+        return async_req_5_0(hc_connection->hc_phone,
+#define _PACK2(high, low) (((high) << 16) + (low))
+#define _PACK3(high, middle, low) (((((high) << 8) + (middle)) << 8) + (low))
+        return async_req_4_0(hc_connection->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_REGISTER_ENDPOINT,
+            _PACK(pipe->wire->address, pipe->endpoint_no),
+            _PACK(pipe->transfer_type, pipe->direction),
+            pipe->max_packet_size, interval);
+#undef _PACK
+            _PACK2(pipe->wire->address, pipe->endpoint_no),
+            _PACK3(speed, pipe->transfer_type, pipe->direction),
+            _PACK2(pipe->max_packet_size, interval));
+#undef _PACK2
+#undef _PACK3
+}

uspace/lib/usb/src/pipesio.c

-              ref354b6
+              re50cd7f
 #include <assert.h>
 #include <usbhc_iface.h>
+#include <usb/request.h>
+#include "pipepriv.h"
 /** Request an in transfer, no checking of input parameters.
 …
+        }
+        /* Ensure serialization over the phone. */
+        pipe_start_transaction(pipe);
         /*
          * Make call identifying target USB device and type of transfer.
          */
         aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_3(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
             pipe->wire->address, pipe->endpoint_no,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
+                pipe_end_transaction(pipe);
                 return ENOMEM;
+        }
 …
         aid_t data_request = async_data_read(pipe->hc_phone, buffer, size,
             &data_request_call);
+        /*
+         * Since now on, someone else might access the backing phone
+         * without breaking the transfer IPC protocol.
+         */
+        pipe_end_transaction(pipe);
         if (data_request == 0) {
 …
         if (buffer == NULL) {
                         return EINVAL;
+                return EINVAL;
+        }
         if (size == 0) {
                 return EINVAL;
+        }
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
+        }
 …
+        }
+        int rc;
+        rc = pipe_add_ref(pipe);
+        if (rc != EOK) {
+                return rc;
+        }
         size_t act_size = 0;
-        int rc;
         rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size);
+        pipe_drop_ref(pipe);
         if (rc != EOK) {
                 return rc;
 …
+        }
+        /* Ensure serialization over the phone. */
+        pipe_start_transaction(pipe);
         /*
          * Make call identifying target USB device and type of transfer.
          */
         aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_3(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
             pipe->wire->address, pipe->endpoint_no,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
+                pipe_end_transaction(pipe);
                 return ENOMEM;
+        }
 …
          */
         int rc = async_data_write_start(pipe->hc_phone, buffer, size);
+        /*
+         * Since now on, someone else might access the backing phone
+         * without breaking the transfer IPC protocol.
+         */
+        pipe_end_transaction(pipe);
         if (rc != EOK) {
                 async_wait_for(opening_request, NULL);
 …
+        }
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
+        }
         if (pipe->direction != USB_DIRECTION_OUT) {
                 return EBADF;
 …
+        }
+        int rc = usb_pipe_write_no_check(pipe, buffer, size);
+        int rc;
+        rc = pipe_add_ref(pipe);
+        if (rc != EOK) {
+                return rc;
+        }
+        rc = usb_pipe_write_no_check(pipe, buffer, size);
+        pipe_drop_ref(pipe);
         return rc;
+}
+/** 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;
+}
 …
     void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
+{
+        /* Ensure serialization over the phone. */
+        pipe_start_transaction(pipe);
         /*
          * Make call identifying target USB device and control transfer type.
          */
         aid_t opening_request = async_send_4(pipe->hc_phone,
+        aid_t opening_request = async_send_3(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_READ,
             pipe->wire->address, pipe->endpoint_no,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
 …
             setup_buffer, setup_buffer_size);
         if (rc != EOK) {
+                pipe_end_transaction(pipe);
                 async_wait_for(opening_request, NULL);
                 return rc;
 …
             data_buffer, data_buffer_size,
             &data_request_call);
+        /*
+         * Since now on, someone else might access the backing phone
+         * without breaking the transfer IPC protocol.
+         */
+        pipe_end_transaction(pipe);
         if (data_request == 0) {
                 async_wait_for(opening_request, NULL);
 …
+        }
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
+        }
         if ((pipe->direction != USB_DIRECTION_BOTH)
             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
 …
+        }
+        int rc;
+        rc = pipe_add_ref(pipe);
+        if (rc != EOK) {
+                return rc;
+        }
         size_t act_size = 0;
         int rc = usb_pipe_control_read_no_check(pipe,
+        rc = usb_pipe_control_read_no_check(pipe,
             setup_buffer, setup_buffer_size,
             data_buffer, data_buffer_size, &act_size);
+        if (rc == ESTALL) {
+                clear_self_endpoint_halt(pipe);
+        }
+        pipe_drop_ref(pipe);
         if (rc != EOK) {
 …
     void *data_buffer, size_t data_buffer_size)
+{
+        /* Ensure serialization over the phone. */
+        pipe_start_transaction(pipe);
         /*
          * Make call identifying target USB device and control transfer type.
          */
         aid_t opening_request = async_send_5(pipe->hc_phone,
+        aid_t opening_request = async_send_4(pipe->hc_phone,
             DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_WRITE,
             pipe->wire->address, pipe->endpoint_no,
             data_buffer_size,
-            pipe->max_packet_size,
             NULL);
         if (opening_request == 0) {
+                pipe_end_transaction(pipe);
                 return ENOMEM;
+        }
 …
             setup_buffer, setup_buffer_size);
         if (rc != EOK) {
+                pipe_end_transaction(pipe);
                 async_wait_for(opening_request, NULL);
                 return rc;
 …
                 rc = async_data_write_start(pipe->hc_phone,
                     data_buffer, data_buffer_size);
+                /* All data sent, pipe can be released. */
+                pipe_end_transaction(pipe);
                 if (rc != EOK) {
                         async_wait_for(opening_request, NULL);
                         return rc;
+                }
+        } else {
+                /* No data to send, we can release the pipe for others. */
+                pipe_end_transaction(pipe);
+        }
 …
+        }
-        if (!usb_pipe_is_session_started(pipe)) {
-                return EBADF;
+        }
         if ((pipe->direction != USB_DIRECTION_BOTH)
             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
 …
+        }
+        int rc = usb_pipe_control_write_no_check(pipe,
+        int rc;
+        rc = pipe_add_ref(pipe);
+        if (rc != EOK) {
+                return rc;
+        }
+        rc = usb_pipe_control_write_no_check(pipe,
             setup_buffer, setup_buffer_size, data_buffer, data_buffer_size);
+        if (rc == ESTALL) {
+                clear_self_endpoint_halt(pipe);
+        }
+        pipe_drop_ref(pipe);
         return rc;

uspace/lib/usb/src/recognise.c

-              ref354b6
+              re50cd7f
         child->driver_data = dev_data;
-        rc = usb_pipe_start_session(&ctrl_pipe);
-        if (rc != EOK) {
-                goto failure;
+        }
         rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids);
-        if (rc != EOK) {
-                goto failure;
+        }
-        rc = usb_pipe_end_session(&ctrl_pipe);
         if (rc != EOK) {
                 goto failure;

uspace/lib/usb/src/request.c

-              ref354b6
+              re50cd7f
+}
+/** 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));
+}
 /**
  * @}

Context Navigation

Changeset e50cd7f in mainline for uspace/lib/usb

Legend:

uspace/lib/usb/Makefile

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

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

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

uspace/lib/usb/include/usb/host/batch.h

uspace/lib/usb/include/usb/host/device_keeper.h

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

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

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

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

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

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

uspace/lib/usb/src/devdrv.c

uspace/lib/usb/src/devpoll.c

uspace/lib/usb/src/hidparser.c

uspace/lib/usb/src/hidreport.c

uspace/lib/usb/src/hidreq.c

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

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

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

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

uspace/lib/usb/src/hub.c

uspace/lib/usb/src/pipes.c

uspace/lib/usb/src/pipesinit.c

uspace/lib/usb/src/pipesio.c

uspace/lib/usb/src/recognise.c

uspace/lib/usb/src/request.c

Download in other formats: