Changeset 0cec844d in mainline for uspace/lib

Timestamp:

2011-04-03T17:39:48Z (15 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

3094804b, baa9d5d, c593b21

Parents:

b8f7a0d2 (diff), 0b4e7ca (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Add base support for alternate interfaces

Location:

uspace/lib/usb

Files:

• include/usb/devdrv.h (modified) (5 diffs)
• include/usb/pipes.h (modified) (1 diff)
• src/devdrv.c (modified) (10 diffs)
• src/pipesinit.c (modified) (3 diffs)

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

@@ -47 +47 @@
 } usb_device_descriptors_t;
 
+/** Wrapper for data related to alternate interface setting.
+ * The pointers will typically point inside configuration descriptor and
+ * thus you shall not deallocate them.
+ */
+typedef struct {
+        /** Interface descriptor. */
+        usb_standard_interface_descriptor_t *interface;
+        /** Pointer to start of descriptor tree bound with this interface. */
+        uint8_t *nested_descriptors;
+        /** Size of data pointed by nested_descriptors in bytes. */
+        size_t nested_descriptors_size;
+} usb_alternate_interface_descriptors_t;
+
+/** Alternate interface settings. */
+typedef struct {
+        /** Array of alternate interfaces descriptions. */
+        usb_alternate_interface_descriptors_t *alternatives;
+        /** Size of @c alternatives array. */
+        size_t alternative_count;
+        /** Index of currently selected one. */
+        size_t current;
+} usb_alternate_interfaces_t;
+
 /** USB device structure. */
 typedef struct {
@@ -56 +79 @@
          */
         usb_endpoint_mapping_t *pipes;
+        /** Number of other endpoint pipes. */
+        size_t pipes_count;
         /** Current interface.
          * Usually, drivers operate on single interface only.
@@ -61 +86 @@
          */
         int interface_no;
+
+        /** Alternative interfaces.
+         * Set to NULL when the driver controls whole device
+         * (i.e. more (or any) interfaces).
+         */
+        usb_alternate_interfaces_t *alternate_interfaces;
 
         /** Some useful descriptors. */
@@ -92 +123 @@
          */
         const char *name;
-        /** Expected endpoints description, excluding default control endpoint.
+        /** Expected endpoints description.
+         * This description shall exclude default control endpoint (pipe zero)
+         * and must be NULL terminated.
+         * When only control endpoint is expected, you may set NULL directly
+         * without creating one item array containing NULL.
          *
-         * It MUST be of size expected_enpoints_count(excluding default ctrl) + 1
-         * where the last record MUST BE NULL, otherwise catastrophic things may
-         * happen.
+         * When the driver expect single interrupt in endpoint,
+         * the initialization may look like this:
+\code
+static usb_endpoint_description_t poll_endpoint_description = {
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HUB,
+        .interface_subclass = 0,
+        .interface_protocol = 0,
+        .flags = 0
+};
+
+static usb_endpoint_description_t *hub_endpoints[] = {
+        &poll_endpoint_description,
+        NULL
+};
+
+static usb_driver_t hub_driver = {
+        .endpoints = hub_endpoints,
+        ...
+};
+\endcode
          */
         usb_endpoint_description_t **endpoints;
@@ -105 +159 @@
 int usb_driver_main(usb_driver_t *);
 
+int usb_device_select_interface(usb_device_t *, uint8_t,
+    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_auto_poll(usb_device_t *, size_t,

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

@@ -107 +107 @@
         /** Interface number the endpoint must belong to (-1 for any). */
         int interface_no;
+        /** Alternate interface setting to choose. */
+        int interface_setting;
         /** Found descriptor fitting the description. */
         usb_standard_endpoint_descriptor_t *descriptor;

uspace/lib/usb/src/devdrv.c

@@ -36 +36 @@
 #include <usb/request.h>
 #include <usb/debug.h>
+#include <usb/dp.h>
 #include <errno.h>
 #include <str_error.h>
@@ -86 +87 @@
  * @return Number of pipes (excluding default control pipe).
  */
-static size_t count_other_pipes(usb_driver_t *drv)
+static size_t count_other_pipes(usb_endpoint_description_t **endpoints)
 {
         size_t count = 0;
-        if (drv->endpoints == NULL) {
+        if (endpoints == NULL) {
                 return 0;
         }
 
-        while (drv->endpoints[count] != NULL) {
+        while (endpoints[count] != NULL) {
                 count++;
         }
@@ -106 +107 @@
  * @return Error code.
  */
-static int initialize_other_pipes(usb_driver_t *drv, usb_device_t *dev)
+static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
+    usb_device_t *dev)
 {
         int rc;
-        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
-
-        size_t pipe_count = count_other_pipes(drv);
+
+        size_t pipe_count = count_other_pipes(endpoints);
+        if (pipe_count == 0) {
+                return EOK;
+        }
+
         dev->pipes = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count);
         if (dev->pipes == NULL) {
@@ -133 +138 @@
                 }
 
-                dev->pipes[i].description = drv->endpoints[i];
+                dev->pipes[i].description = endpoints[i];
                 dev->pipes[i].interface_no = dev->interface_no;
+                dev->pipes[i].interface_setting = 0;
         }
 
@@ -178 +184 @@
         usb_hc_connection_close(&hc_conn);
 
+        dev->pipes_count = pipe_count;
+
         return EOK;
 
@@ -227 +235 @@
         }
 
+        /* 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.
@@ -257 +268 @@
 
         if (driver->endpoints != NULL) {
-                rc = initialize_other_pipes(driver, dev);
+                rc = initialize_other_pipes(driver->endpoints, dev);
         }
 
@@ -271 +282 @@
 
         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;
+
+        return EOK;
 }
 
@@ -301 +436 @@
         dev->descriptors.configuration = NULL;
 
+        dev->pipes_count = 0;
+        dev->pipes = NULL;
+
         rc = initialize_pipes(dev);
         if (rc != EOK) {
@@ -307 +445 @@
         }
 
+        (void) initialize_alternate_interfaces(dev);
+
         return driver->ops->add_device(dev);
+}
+
+/** Destroy existing pipes of a USB device.
+ *
+ * @param dev Device where to destroy the pipes.
+ * @return Error code.
+ */
+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);
+        dev->pipes = NULL;
+        dev->pipes_count = 0;
+
+        return EOK;
+}
+
+/** Change interface setting of a device.
+ * This function selects new alternate setting of an interface by issuing
+ * proper USB command to the device and also creates new USB pipes
+ * under @c dev->pipes.
+ *
+ * @warning This function is intended for drivers working at interface level.
+ * For drivers controlling the whole device, you need to change interface
+ * manually using usb_request_set_interface() and creating new pipes
+ * with usb_pipe_initialize_from_configuration().
+ *
+ * @param dev USB device.
+ * @param alternate_setting Alternate setting to choose.
+ * @param endpoints New endpoint descriptions.
+ * @return Error code.
+ */
+int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
+    usb_endpoint_description_t **endpoints)
+{
+        if (dev->interface_no < 0) {
+                return EINVAL;
+        }
+
+        int rc;
+
+        /* TODO: more transactional behavior. */
+
+        /* Destroy existing pipes. */
+        rc = destroy_current_pipes(dev);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Change the interface itself. */
+        rc = usb_request_set_interface(&dev->ctrl_pipe, dev->interface_no,
+            alternate_setting);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Create new pipes. */
+        rc = initialize_other_pipes(endpoints, dev);
+
+        return rc;
 }
 

uspace/lib/usb/src/pipesinit.c

@@ -121 +121 @@
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
     usb_endpoint_description_t *found_endpoint,
-    int interface_number)
+    int interface_number, int interface_setting)
 {
         while (mapping_count > 0) {
@@ -127 +127 @@
                     || (mapping->interface_no == interface_number);
 
+                bool interface_setting_fits = (mapping->interface_setting < 0)
+                    || (mapping->interface_setting == interface_setting);
+
                 bool endpoint_descriptions_fits = endpoint_fits_description(
                     mapping->description, found_endpoint);
 
-                if (interface_number_fits && endpoint_descriptions_fits) {
+                if (interface_number_fits
+                    && interface_setting_fits
+                    && endpoint_descriptions_fits) {
                         return mapping;
                 }
@@ -181 +186 @@
          */
         usb_endpoint_mapping_t *ep_mapping = find_endpoint_mapping(mapping,
-            mapping_count, &description, interface->interface_number);
+            mapping_count, &description,
+            interface->interface_number, interface->alternate_setting);
         if (ep_mapping == NULL) {
                 return ENOENT;