Changes in uspace/lib/usb/src/devpoll.c [4125b7d:4ede178] in mainline

File:

• uspace/lib/usb/src/devpoll.c (modified) (9 diffs)

uspace/lib/usb/src/devpoll.c

@@ -33 +33 @@
  * USB device driver framework - automatic interrupt polling.
  */
-#include <usb/devpoll.h>
+#include <usb/devdrv.h>
 #include <usb/request.h>
 #include <usb/debug.h>
-#include <usb/classes/classes.h>
 #include <errno.h>
 #include <str_error.h>
@@ -46 +45 @@
 /** 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;
         void *custom_arg;
 } polling_data_t;
-
 
 /** Polling fibril.
@@ -75 +67 @@
             = 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("Poll%p: 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);
-        }
+        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);
 
         size_t failed_attempts = 0;
-        while (failed_attempts <= polling_data->max_failures) {
+        while (failed_attempts < MAX_FAILED_ATTEMPTS) {
                 int rc;
 
@@ -97 +81 @@
                     polling_data->request_size, &actual_size);
 
-                if (polling_data->debug > 1) {
-                        if (rc == EOK) {
-                                usb_log_debug(
-                                    "Poll%p: received: '%s' (%zuB).\n",
-                                    polling_data,
-                                    usb_debug_str_buffer(polling_data->buffer,
-                                        actual_size, 16),
-                                    actual_size);
-                        } else {
-                                usb_log_debug(
-                                    "Poll%p: 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 == 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 (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;
@@ -138 +95 @@
 
                 /* We have the data, execute the callback now. */
-                bool carry_on = polling_data->on_data(polling_data->dev,
+                bool carry_on = polling_data->callback(polling_data->dev,
                     polling_data->buffer, actual_size,
                     polling_data->custom_arg);
@@ -149 +106 @@
                 /* Reset as something might be only a temporary problem. */
                 failed_attempts = 0;
-
-                /* 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 (failed_attempts > 0) {
+                usb_log_error(
+                    "Polling of device `%s' terminated: recurring failures.\n",
+                    polling_data->dev->ddf_dev->name);
         }
 
-        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
-                        );
-                }
+        if (polling_data->terminated_callback != NULL) {
+                polling_data->terminated_callback(polling_data->dev,
+                    failed_attempts > 0, polling_data->custom_arg);
         }
 
@@ -213 +159 @@
         }
 
-        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) {
@@ -275 +164 @@
         }
 
-        /* Fill-in the data. */
-        polling_data->buffer = malloc(sizeof(request_size));
+        /* Allocate now to prevent immediate failure in the polling fibril. */
+        polling_data->buffer = malloc(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);
@@ -304 +181 @@
                 free(polling_data->buffer);
                 free(polling_data);
+                /* FIXME: better error code. */
                 return ENOMEM;
         }
         fibril_add_ready(fibril);
 
-        /* Fibril launched. That fibril will free the allocated data. */
+        /* The allocated buffer etc. will be freed by the fibril. */
 
         return EOK;