Changes in uspace/lib/usbdev/src/devpoll.c [58563585:56fd7cf] in mainline

File:

• uspace/lib/usbdev/src/devpoll.c (modified) (14 diffs)

uspace/lib/usbdev/src/devpoll.c

@@ -33 +33 @@
  * USB device driver framework - automatic interrupt polling.
  */
-
-#include <usb/dev/device.h>
-#include <usb/dev/pipes.h>
 #include <usb/dev/poll.h>
 #include <usb/dev/request.h>
+#include <usb/debug.h>
 #include <usb/classes/classes.h>
-#include <usb/debug.h>
-#include <usb/descriptor.h>
-#include <usb/usb.h>
-
+#include <errno.h>
+#include <str_error.h>
 #include <assert.h>
-#include <async.h>
-#include <errno.h>
-#include <fibril.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <str_error.h>
-#include <sys/types.h>
 
 /** Maximum number of failed consecutive requests before announcing failure. */
@@ -62 +51 @@
         /** USB device to poll. */
         usb_device_t *dev;
-        /** Device enpoint mapping to use for polling. */
-        usb_endpoint_mapping_t *polling_mapping;
+        /** Device pipe to use for polling. */
+        size_t pipe_index;
         /** Size of the recieved data. */
         size_t request_size;
@@ -83 +72 @@
         const usb_device_auto_polling_t *params = &data->auto_polling;
 
-        usb_pipe_t *pipe = &data->polling_mapping->pipe;
+        usb_pipe_t *pipe
+            = &data->dev->pipes[data->pipe_index].pipe;
 
         if (params->debug > 0) {
-                const usb_endpoint_mapping_t *mapping =
-                    data->polling_mapping;
-                usb_log_debug("Poll (%p): started polling of `%s' - " \
+                const usb_endpoint_mapping_t *mapping
+                    = &data->dev->pipes[data->pipe_index];
+                usb_log_debug("Poll%p: started polling of `%s' - " \
                     "interface %d (%s,%d,%d), %zuB/%zu.\n",
-                    data, usb_device_get_name(data->dev),
+                    data, ddf_dev_get_name(data->dev->ddf_dev),
                     (int) mapping->interface->interface_number,
                     usb_str_class(mapping->interface->interface_class),
@@ -98 +88 @@
         }
 
+        usb_pipe_start_long_transfer(pipe);
         size_t failed_attempts = 0;
         while (failed_attempts <= params->max_failures) {
@@ -104 +95 @@
                     data->request_size, &actual_size);
 
-                if (rc == EOK) {
-                        if (params->debug > 1) {
+                if (params->debug > 1) {
+                        if (rc == EOK) {
                                 usb_log_debug(
                                     "Poll%p: received: '%s' (%zuB).\n",
@@ -112 +103 @@
                                         actual_size, 16),
                                     actual_size);
-                        }
-                } else {
+                        } else {
                                 usb_log_debug(
                                     "Poll%p: polling failed: %s.\n",
                                     data, str_error(rc));
+                        }
                 }
 
@@ -126 +117 @@
                          */
                         usb_request_clear_endpoint_halt(
-                            usb_device_get_default_pipe(data->dev),
-                            pipe->endpoint_no);
+                            &data->dev->ctrl_pipe, pipe->endpoint_no);
                 }
 
@@ -155 +145 @@
 
                 /* Take a rest before next request. */
-                
-                // FIXME TODO: This is broken, the time is in ms not us.
-                // but first we need to fix drivers to actually stop using this,
-                // since polling delay should be implemented in HC schedule
                 async_usleep(params->delay);
         }
+
+        usb_pipe_end_long_transfer(pipe);
 
         const bool failed = failed_attempts > 0;
@@ -171 +159 @@
                 if (failed) {
                         usb_log_error("Polling of device `%s' terminated: "
-                            "recurring failures.\n",
-                            usb_device_get_name(data->dev));
+                            "recurring failures.\n", ddf_dev_get_name(
+                            data->dev->ddf_dev));
                 } else {
                         usb_log_debug("Polling of device `%s' terminated: "
-                            "driver request.\n",
-                            usb_device_get_name(data->dev));
+                            "driver request.\n", ddf_dev_get_name(
+                            data->dev->ddf_dev));
                 }
         }
@@ -187 +175 @@
 }
 
-
 /** 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 It is up to the callback to produce delays between individual
+ * requests.
  *
  * @warning There is no guarantee when the request to the device
@@ -198 +185 @@
  *
  * @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).
@@ -300 +193 @@
  * @retval EOK New fibril polling the device was already started.
  */
-int usb_device_auto_poll(usb_device_t *dev, usb_endpoint_t ep,
-    usb_polling_callback_t callback, size_t request_size, int delay,
+int usb_device_auto_poll(usb_device_t *dev, size_t pipe_index,
+    usb_polling_callback_t callback, size_t request_size,
     usb_polling_terminted_callback_t terminated_callback, void *arg)
 {
@@ -307 +200 @@
                 .debug = 1,
                 .auto_clear_halt = true,
-                .delay = delay,
+                .delay = 0,
                 .max_failures = MAX_FAILED_ATTEMPTS,
                 .on_data = callback,
@@ -315 +208 @@
         };
 
-        usb_endpoint_mapping_t *epm = usb_device_get_mapped_ep(dev, ep);
-        return usb_device_auto_polling_internal(
-            dev, epm, &auto_polling, request_size);
+        return usb_device_auto_polling(dev, pipe_index, &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)
+/** 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)
 {
-        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);
+        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;
 }