Changes in uspace/lib/usbdev/src/altiface.c [6e3c005:160b75e] in mainline

File:

• uspace/lib/usbdev/src/altiface.c (modified) (5 diffs)

uspace/lib/usbdev/src/altiface.c

@@ -48 +48 @@
  * @return Number of alternate interfaces for @p interface_no interface.
  */
-size_t usb_interface_count_alternates(const uint8_t *config_descr,
+size_t usb_interface_count_alternates(uint8_t *config_descr,
     size_t config_descr_size, uint8_t interface_no)
 {
@@ -54 +54 @@
         assert(config_descr_size > 0);
 
-        const usb_dp_parser_t dp_parser = {
+        usb_dp_parser_t dp_parser = {
                 .nesting = usb_dp_standard_descriptor_nesting
         };
-        const usb_dp_parser_data_t dp_data = {
+        usb_dp_parser_data_t dp_data = {
                 .data = config_descr,
                 .size = config_descr_size,
@@ -65 +65 @@
         size_t alternate_count = 0;
 
-        const void *iface_ptr =
-            usb_dp_get_nested_descriptor(&dp_parser, &dp_data, config_descr);
+        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
+            &dp_data, config_descr);
         while (iface_ptr != NULL) {
-                const usb_standard_interface_descriptor_t *iface = iface_ptr;
-                if (iface->descriptor_type == USB_DESCTYPE_INTERFACE
-                    && iface->interface_number == interface_no) {
-                        ++alternate_count;
+                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,
@@ -80 +82 @@
 }
 
-/** Initialize alternate interface representation structure.
+/** Create alternate interface representation structure.
  *
- * @param[in] alternates Pointer to allocated structure.
  * @param[in] config_descr Configuration descriptor.
  * @param[in] config_descr_size Size of configuration descriptor.
  * @param[in] interface_number Interface number.
+ * @param[out] alternates_ptr Where to store pointer to allocated structure.
  * @return Error code.
  */
-int usb_alternate_interfaces_init(usb_alternate_interfaces_t *alternates,
-    const uint8_t *config_descr, size_t config_descr_size, int interface_number)
+int usb_alternate_interfaces_create(uint8_t *config_descr,
+    size_t config_descr_size, int interface_number,
+    usb_alternate_interfaces_t **alternates_ptr)
 {
-        assert(alternates != NULL);
+        assert(alternates_ptr != NULL);
         assert(config_descr != NULL);
         assert(config_descr_size > 0);
 
-        alternates->alternatives = NULL;
-        alternates->alternative_count = 0;
-        alternates->current = 0;
+        if (interface_number < 0) {
+                alternates_ptr = NULL;
+                return EOK;
+        }
 
-        /* No interfaces. */
-        if (interface_number < 0) {
-                return EOK;
+        usb_alternate_interfaces_t *alternates
+            = malloc(sizeof(usb_alternate_interfaces_t));
+
+        if (alternates == NULL) {
+                return ENOMEM;
         }
 
         alternates->alternative_count
             = usb_interface_count_alternates(config_descr, config_descr_size,
-                interface_number);
+            interface_number);
 
         if (alternates->alternative_count == 0) {
+                free(alternates);
                 return ENOENT;
         }
 
-        alternates->alternatives = calloc(alternates->alternative_count,
-            sizeof(usb_alternate_interface_descriptors_t));
+        alternates->alternatives = malloc(alternates->alternative_count
+            * sizeof(usb_alternate_interface_descriptors_t));
         if (alternates->alternatives == NULL) {
+                free(alternates);
                 return ENOMEM;
         }
 
-        const usb_dp_parser_t dp_parser = {
+        alternates->current = 0;
+
+        usb_dp_parser_t dp_parser = {
                 .nesting = usb_dp_standard_descriptor_nesting
         };
-        const usb_dp_parser_data_t dp_data = {
+        usb_dp_parser_data_t dp_data = {
                 .data = config_descr,
                 .size = config_descr_size,
@@ -127 +137 @@
         };
 
-        usb_alternate_interface_descriptors_t *iterator
+        usb_alternate_interface_descriptors_t *cur_alt_iface
             = &alternates->alternatives[0];
 
-        const usb_alternate_interface_descriptors_t *end
-            = &alternates->alternatives[alternates->alternative_count];
-
-        const void *iface_ptr =
-            usb_dp_get_nested_descriptor(&dp_parser, &dp_data, dp_data.data);
-
-        while (iface_ptr != NULL && iterator < end) {
-                const usb_standard_interface_descriptor_t *iface = iface_ptr;
-
+        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 != interface_number)) {
-                        /* This is not a valid alternate interface descriptor
-                         * for interface with number == interface_number. */
                         iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser,
-                            &dp_data, dp_data.data, iface_ptr);
+                            &dp_data,
+                            dp_data.data, iface_ptr);
                         continue;
                 }
 
-                iterator->interface = iface;
-                iterator->nested_descriptors = iface_ptr + sizeof(*iface);
+                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;
+                }
 
-                const uint8_t *next = (iface_ptr == NULL) ?
-                    dp_data.data + dp_data.size : iface_ptr;
+                cur_alt_iface++;
+        }
 
-                iterator->nested_descriptors_size
-                    = next - iterator->nested_descriptors;
-
-                ++iterator;
-        }
+        *alternates_ptr = alternates;
 
         return EOK;
 }
 
-/** Clean initialized structure.
- * @param instance structure do deinitialize.
- */
-void usb_alternate_interfaces_deinit(usb_alternate_interfaces_t *instance)
-{
-        if (!instance)
-                return;
-        free(instance->alternatives);
-        instance->alternatives = NULL;
-}
+
 /**
  * @}