Changeset 2471aaf in mainline

Timestamp:

2011-04-14T20:09:01Z (14 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

545764b

Parents:

5f7c846 (diff), 0146d41 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Development branch changes

Location:

uspace

Files:

• drv/usbhid/main.c (modified) (1 diff)
• drv/usbhub/usbhub.c (modified) (1 diff)
• drv/usbkbd/main.c (modified) (1 diff)
• drv/usbmouse/main.c (modified) (1 diff)
• lib/usb/include/usb/devdrv.h (modified) (1 diff)
• lib/usb/include/usb/devpoll.h (added)
• lib/usb/include/usb/pipes.h (modified) (1 diff)
• lib/usb/src/devpoll.c (modified) (10 diffs)
• lib/usb/src/pipesinit.c (modified) (2 diffs)
• lib/usb/src/pipesio.c (modified) (4 diffs)

uspace/drv/usbhid/main.c

@@ -42 +42 @@
 
 #include <usb/devdrv.h>
+#include <usb/devpoll.h>
 
 #include "usbhid.h"

uspace/drv/usbhub/usbhub.c

@@ -45 +45 @@
 #include <usb/request.h>
 #include <usb/classes/hub.h>
+#include <usb/devpoll.h>
 #include <stdio.h>
 

uspace/drv/usbkbd/main.c

@@ -42 +42 @@
 
 #include <usb/devdrv.h>
+#include <usb/devpoll.h>
 
 #include "kbddev.h"

uspace/drv/usbmouse/main.c

@@ -36 +36 @@
 #include "mouse.h"
 #include <usb/debug.h>
+#include <usb/devpoll.h>
 #include <errno.h>
 #include <str_error.h>

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

@@ -162 +162 @@
     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,
-    usb_polling_callback_t, size_t, usb_polling_terminted_callback_t, 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 *,

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

@@ -99 +99 @@
         /** 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;
 

uspace/lib/usb/src/devpoll.c

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

uspace/lib/usb/src/pipesinit.c

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

uspace/lib/usb/src/pipesio.c

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