Changeset bb70637 in mainline

Timestamp:

2013-01-26T23:35:12Z (11 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

35bc430

Parents:

3e23316

Message:

usb: Rework polling to accept either ep numbers or descriptions.

Switch usbhub and usbhid to new polling.

Location:

uspace

Files:

• drv/bus/usb/usbhid/main.c (modified) (1 diff)
• drv/bus/usb/usbhid/usbhid.c (modified) (7 diffs)
• drv/bus/usb/usbhid/usbhid.h (modified) (2 diffs)
• drv/bus/usb/usbhub/main.c (modified) (1 diff)
• drv/bus/usb/usbhub/usbhub.c (modified) (2 diffs)
• drv/bus/usb/usbhub/usbhub.h (modified) (1 diff)
• lib/usbdev/include/usb/dev/poll.h (modified) (1 diff)
• lib/usbdev/src/devpoll.c (modified) (7 diffs)

uspace/drv/bus/usb/usbhid/main.c

@@ -89 +89 @@
          * This will create a separate fibril that will query the device
          * for the data continuously. */
-       rc = usb_device_auto_poll(dev,
+        rc = usb_device_auto_poll_desc(dev,
            /* Index of the polling pipe. */
-           hid_dev->poll_pipe_index,
+           hid_dev->poll_pipe_mapping->description,
            /* Callback when data arrives. */
            usb_hid_polling_callback,
            /* How much data to request. */
-           dev->pipes[hid_dev->poll_pipe_index].pipe.max_packet_size,
+           hid_dev->poll_pipe_mapping->pipe.max_packet_size,
            /* Delay */
-           0,
+           -1,
            /* Callback when the polling ends. */
            usb_hid_polling_ended_callback,

uspace/drv/bus/usb/usbhid/usbhid.c

@@ -41 +41 @@
 #include <usb/hid/hidreport.h>
 #include <usb/hid/request.h>
+
 #include <errno.h>
+#include <macros.h>
 #include <str_error.h>
 
@@ -265 +267 @@
 }
 
-static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, const usb_device_t *dev)
+static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
 {
         assert(hid_dev);
@@ -271 +273 @@
 
         static const struct {
-                unsigned ep_number;
+                const usb_endpoint_description_t *desc;
                 const char* description;
         } endpoints[] = {
-                {USB_HID_KBD_POLL_EP_NO, "Keyboard endpoint"},
-                {USB_HID_MOUSE_POLL_EP_NO, "Mouse endpoint"},
-                {USB_HID_GENERIC_POLL_EP_NO, "Generic HID endpoint"},
+                {&usb_hid_kbd_poll_endpoint_description, "Keyboard endpoint"},
+                {&usb_hid_mouse_poll_endpoint_description, "Mouse endpoint"},
+                {&usb_hid_generic_poll_endpoint_description, "Generic HID endpoint"},
         };
 
-        for (unsigned i = 0; i < sizeof(endpoints)/sizeof(endpoints[0]); ++i) {
-                if (endpoints[i].ep_number >= dev->pipes_count) {
-                        return EINVAL;
-                }
-                if (dev->pipes[endpoints[i].ep_number].present) {
+        for (unsigned i = 0; i < ARRAY_SIZE(endpoints); ++i) {
+                usb_endpoint_mapping_t *epm =
+                    usb_device_get_mapped_ep_desc(dev, endpoints[i].desc);
+                if (epm && epm->present) {
                         usb_log_debug("Found: %s.\n", endpoints[i].description);
-                        hid_dev->poll_pipe_index = endpoints[i].ep_number;
+                        hid_dev->poll_pipe_mapping = epm;
                         return EOK;
                 }
@@ -352 +353 @@
         /* The USB device should already be initialized, save it in structure */
         hid_dev->usb_dev = dev;
-        hid_dev->poll_pipe_index = -1;
+        hid_dev->poll_pipe_mapping = NULL;
 
         int rc = usb_hid_check_pipes(hid_dev, dev);
@@ -382 +383 @@
                     "boot protocol.\n");
 
-                switch (hid_dev->poll_pipe_index) {
-                case USB_HID_KBD_POLL_EP_NO:
+                switch (hid_dev->poll_pipe_mapping->interface->interface_protocol) {
+                case USB_HID_PROTOCOL_KEYBOARD:
                         usb_log_info("Falling back to kbd boot protocol.\n");
                         rc = usb_kbd_set_boot_protocol(hid_dev);
@@ -390 +391 @@
                         }
                         break;
-                case USB_HID_MOUSE_POLL_EP_NO:
+                case USB_HID_PROTOCOL_MOUSE:
                         usb_log_info("Falling back to mouse boot protocol.\n");
                         rc = usb_mouse_set_boot_protocol(hid_dev);
@@ -398 +399 @@
                         break;
                 default:
-                        assert(hid_dev->poll_pipe_index
-                            == USB_HID_GENERIC_POLL_EP_NO);
                         usb_log_info("Falling back to generic HID driver.\n");
                         usb_hid_set_generic_hid_subdriver(hid_dev);

uspace/drv/bus/usb/usbhid/usbhid.h

@@ -103 +103 @@
         usb_device_t *usb_dev;
 
-        /** Index of the polling pipe in usb_hid_endpoints array. */
-        unsigned poll_pipe_index;
+        /** Endpont mapping of the polling pipe. */
+        usb_endpoint_mapping_t *poll_pipe_mapping;
 
         /** Subdrivers. */
@@ -132 +132 @@
 };
 
-
-
-enum {
-        USB_HID_KBD_POLL_EP_NO = 0,
-        USB_HID_MOUSE_POLL_EP_NO = 1,
-        USB_HID_GENERIC_POLL_EP_NO = 2,
-        USB_HID_POLL_EP_COUNT = 3
-};
-
 extern const usb_endpoint_description_t *usb_hid_endpoints[];
-
-
 
 int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev);

uspace/drv/bus/usb/usbhub/main.c

@@ -43 +43 @@
 #include "usbhub.h"
 
-/** Hub status-change endpoint description.
- *
- * For more information see section 11.15.1 of USB 1.1 specification.
- */
-static const usb_endpoint_description_t hub_status_change_endpoint_description =
-{
-        .transfer_type = USB_TRANSFER_INTERRUPT,
-        .direction = USB_DIRECTION_IN,
-        .interface_class = USB_CLASS_HUB,
-        .interface_subclass = 0,
-        .interface_protocol = 0,
-        .flags = 0
-};
 
 /** USB hub driver operations. */

uspace/drv/bus/usb/usbhub/usbhub.c

@@ -57 +57 @@
 
 #define HUB_FNC_NAME "hub"
+/** Hub status-change endpoint description.
+ *
+ * For more information see section 11.15.1 of USB 1.1 specification.
+ */
+const usb_endpoint_description_t hub_status_change_endpoint_description =
+{
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HUB,
+        .interface_subclass = 0,
+        .interface_protocol = 0,
+        .flags = 0
+};
 
 /** Standard get hub global status request */
@@ -147 +160 @@
 
         /* Start hub operation. */
-        opResult = usb_device_auto_poll(hub_dev->usb_device, 0,
+        opResult = usb_device_auto_poll_desc(hub_dev->usb_device,
+            &hub_status_change_endpoint_description,
             hub_port_changes_callback, ((hub_dev->port_count + 1 + 7) / 8),
-            255000,
-            usb_hub_polling_terminated_callback, hub_dev);
+            -1, usb_hub_polling_terminated_callback, hub_dev);
         if (opResult != EOK) {
                 usb_pipe_end_long_transfer(control_pipe);

uspace/drv/bus/usb/usbhub/usbhub.h

@@ -80 +80 @@
 };
 
+extern const usb_endpoint_description_t hub_status_change_endpoint_description;
+
 int usb_hub_device_add(usb_device_t *usb_dev);
 int usb_hub_device_remove(usb_device_t *usb_dev);

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

@@ -87 +87 @@
 } usb_device_auto_polling_t;
 
-int usb_device_auto_polling(usb_device_t *, size_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_polling(usb_device_t *, usb_endpoint_t,
     const usb_device_auto_polling_t *, size_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 *, usb_endpoint_t,
+    usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
 
-int usb_device_auto_poll(usb_device_t *, size_t,
-    usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
+int usb_device_auto_polling_desc(usb_device_t *,
+    const usb_endpoint_description_t *, const usb_device_auto_polling_t *,
+    size_t);
+
+int usb_device_auto_poll_desc(usb_device_t *,
+    const usb_endpoint_description_t *, usb_polling_callback_t, size_t, int,
+    usb_polling_terminted_callback_t, void *);
 
 #endif

uspace/lib/usbdev/src/devpoll.c

@@ -51 +51 @@
         /** USB device to poll. */
         usb_device_t *dev;
-        /** Device pipe to use for polling. */
-        size_t pipe_index;
+        /** Device enpoint mapping to use for polling. */
+        usb_endpoint_mapping_t *polling_mapping;
         /** Size of the recieved data. */
         size_t request_size;
@@ -72 +72 @@
         const usb_device_auto_polling_t *params = &data->auto_polling;
 
-        usb_pipe_t *pipe
-            = &data->dev->pipes[data->pipe_index].pipe;
+        usb_pipe_t *pipe = &data->polling_mapping->pipe;
 
         if (params->debug > 0) {
                 const usb_endpoint_mapping_t *mapping
-                    = &data->dev->pipes[data->pipe_index];
+                    = data->polling_mapping;
                 usb_log_debug("Poll%p: started polling of `%s' - " \
                     "interface %d (%s,%d,%d), %zuB/%zu.\n",
@@ -117 +116 @@
                          */
                         usb_request_clear_endpoint_halt(
-                            &data->dev->ctrl_pipe, pipe->endpoint_no);
+                            usb_device_get_default_pipe(data->dev),
+                            pipe->endpoint_no);
                 }
 
@@ -175 +175 @@
 }
 
+
 /** Start automatic device polling over interrupt in pipe.
  *
- * @warning It is up to the callback to produce delays between individual
- * requests.
+ * 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
@@ -185 +186 @@
  *
  * @param dev Device to be periodically polled.
+ * @param epm Endpoint mapping to use.
+ * @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.
+ */
+static int usb_device_auto_polling_internal(usb_device_t *dev,
+    usb_endpoint_mapping_t *epm, const usb_device_auto_polling_t *polling,
+    size_t request_size)
+{
+        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
+                return EBADMEM;
+        }
+
+        if (request_size == 0)
+                return EINVAL;
+
+        if (!epm || (epm->pipe.transfer_type != USB_TRANSFER_INTERRUPT) ||
+            (epm->pipe.direction != USB_DIRECTION_IN))
+                return EINVAL;
+
+
+        polling_data_t *polling_data = malloc(sizeof(polling_data_t));
+        if (polling_data == NULL) {
+                return ENOMEM;
+        }
+
+        /* 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->polling_mapping = epm;
+
+        /* Copy provided settings. */
+        polling_data->auto_polling = *polling;
+
+        /* Negative value means use descriptor provided value. */
+        if (polling->delay < 0) {
+                polling_data->auto_polling.delay =
+                    epm->descriptor->poll_interval;
+        }
+
+        fid_t fibril = fibril_create(polling_fibril, polling_data);
+        if (fibril == 0) {
+                free(polling_data->buffer);
+                free(polling_data);
+                return ENOMEM;
+        }
+        fibril_add_ready(fibril);
+
+        /* Fibril launched. That fibril will free the allocated data. */
+
+        return EOK;
+}
+/** 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 req_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 *usb_dev, usb_endpoint_t ep,
+    const usb_device_auto_polling_t *polling, size_t req_size)
+{
+        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(usb_dev, ep);
+        return usb_device_auto_polling_internal(usb_dev, epm, polling, req_size);
+}
+
+/** Start automatic device polling over interrupt in pipe.
+ *
+ * @warning It is up to the callback to produce delays between individual
+ * requests.
+ *
+ * @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 ep Endpoint  used for polling.
  * @param callback Callback when data are available.
  * @param request_size How many bytes to ask for in each request.
+ * @param delay NUmber of ms to wait between queries, -1 to use descriptor val.
  * @param terminated_callback Callback when polling is terminated.
  * @param arg Custom argument (passed as is to the callbacks).
@@ -193 +288 @@
  * @retval EOK New fibril polling the device was already started.
  */
-int usb_device_auto_poll(usb_device_t *dev, size_t pipe_index,
+int usb_device_auto_poll(usb_device_t *dev, usb_endpoint_t ep,
     usb_polling_callback_t callback, size_t request_size, int delay,
     usb_polling_terminted_callback_t terminated_callback, void *arg)
@@ -208 +303 @@
         };
 
-        return usb_device_auto_polling(dev, pipe_index, &auto_polling,
-           request_size);
-}
-
-/** 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,
-    const usb_device_auto_polling_t *polling,
-    size_t request_size)
-{
-        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
-                return EBADMEM;
-        }
-
-        if (pipe_index >= dev->pipes_count || request_size == 0) {
-                return EINVAL;
-        }
-        if ((dev->pipes[pipe_index].pipe.transfer_type != USB_TRANSFER_INTERRUPT)
-            || (dev->pipes[pipe_index].pipe.direction != USB_DIRECTION_IN)) {
-                return EINVAL;
-        }
-
-        polling_data_t *polling_data = malloc(sizeof(polling_data_t));
-        if (polling_data == NULL) {
-                return ENOMEM;
-        }
-
-        /* 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;
-
-        /* Copy provided settings. */
-        polling_data->auto_polling = *polling;
-
-        /* Negative value means use descriptor provided value. */
-        if (polling->delay < 0) {
-                polling_data->auto_polling.delay =
-                    (int) dev->pipes[pipe_index].descriptor->poll_interval;
-        }
-
-        fid_t fibril = fibril_create(polling_fibril, polling_data);
-        if (fibril == 0) {
-                free(polling_data->buffer);
-                free(polling_data);
-                return ENOMEM;
-        }
-        fibril_add_ready(fibril);
-
-        /* Fibril launched. That fibril will free the allocated data. */
-
-        return EOK;
+        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev, ep);
+        return usb_device_auto_polling_internal(
+            dev, epm, &auto_polling, request_size);
+}
+
+int usb_device_auto_polling_desc(usb_device_t *usb_dev,
+    const usb_endpoint_description_t *desc,
+    const usb_device_auto_polling_t *polling, size_t req_size)
+{
+        usb_endpoint_mapping_t *epm =
+            usb_device_get_mapped_ep_desc(usb_dev, desc);
+        return usb_device_auto_polling_internal(usb_dev, epm, polling, req_size);
+}
+
+int usb_device_auto_poll_desc(usb_device_t * usb_dev,
+    const usb_endpoint_description_t *desc, usb_polling_callback_t callback,
+    size_t req_size, int delay,
+    usb_polling_terminted_callback_t terminated_callback, void *arg)
+{
+        const usb_device_auto_polling_t auto_polling = {
+                .debug = 1,
+                .auto_clear_halt = true,
+                .delay = delay,
+                .max_failures = MAX_FAILED_ATTEMPTS,
+                .on_data = callback,
+                .on_polling_end = terminated_callback,
+                .on_error = NULL,
+                .arg = arg,
+        };
+
+        usb_endpoint_mapping_t *epm =
+            usb_device_get_mapped_ep_desc(usb_dev, desc);
+        return usb_device_auto_polling_internal(
+            usb_dev, epm, &auto_polling, req_size);
 }