Changes in uspace/lib/usbdev/src/devpoll.c [33b8d024:5a6cc679] in mainline

File:

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

uspace/lib/usbdev/src/devpoll.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2017 Petr Manek
  * All rights reserved.
  *
@@ -47 +48 @@
 #include <errno.h>
 #include <fibril.h>
+#include <fibril_synch.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -53 +55 @@
 #include <stdint.h>
 
-/** Maximum number of failed consecutive requests before announcing failure. */
-#define MAX_FAILED_ATTEMPTS 3
-
-/** Data needed for polling. */
-typedef struct {
-        /** Parameters for automated polling. */
-        usb_device_auto_polling_t auto_polling;
-
-        /** USB device to poll. */
-        usb_device_t *dev;
-        /** Device enpoint mapping to use for polling. */
-        usb_endpoint_mapping_t *polling_mapping;
-        /** Size of the recieved data. */
-        size_t request_size;
-        /** Data buffer. */
-        uint8_t *buffer;
-} polling_data_t;
+
+/** Initialize the polling data structure, its internals and configuration
+ *  with default values.
+ *
+ * @param polling Valid polling data structure.
+ * @return Error code.
+ * @retval EOK Polling data structure is ready to be used.
+ */
+int usb_polling_init(usb_polling_t *polling)
+{
+        if (!polling)
+                return EBADMEM;
+
+        /* Zero out everything */
+        memset(polling, 0, sizeof(usb_polling_t));
+
+        /* Internal initializers. */
+        fibril_mutex_initialize(&polling->guard);
+        fibril_condvar_initialize(&polling->cv);
+
+        /* Default configuration. */
+        polling->auto_clear_halt = true;
+        polling->delay = -1;
+        polling->max_failures = 3;
+
+        return EOK;
+}
+
+
+/** Destroy the polling data structure.
+ *  This function does nothing but a safety check whether the polling
+ *  was joined successfully.
+ *
+ * @param polling Polling data structure.
+ */
+void usb_polling_fini(usb_polling_t *polling)
+{
+        /* Nothing done at the moment. */
+        assert(polling);
+        assert(!polling->running);
+}
 
 
 /** Polling fibril.
  *
- * @param arg Pointer to polling_data_t.
+ * @param arg Pointer to usb_polling_t.
  * @return Always EOK.
  */
@@ -80 +106 @@
 {
         assert(arg);
-        polling_data_t *data = arg;
-        /* Helper to reduce typing. */
-        const usb_device_auto_polling_t *params = &data->auto_polling;
-
-        usb_pipe_t *pipe = &data->polling_mapping->pipe;
-
-        if (params->debug > 0) {
+        usb_polling_t *polling = arg;
+
+        fibril_mutex_lock(&polling->guard);
+        polling->running = true;
+        fibril_mutex_unlock(&polling->guard);
+
+        usb_pipe_t *pipe = &polling->ep_mapping->pipe;
+
+        if (polling->debug > 0) {
                 const usb_endpoint_mapping_t *mapping =
-                    data->polling_mapping;
+                    polling->ep_mapping;
                 usb_log_debug("Poll (%p): started polling of `%s' - " \
                     "interface %d (%s,%d,%d), %zuB/%zu.\n",
-                    data, usb_device_get_name(data->dev),
+                    polling, usb_device_get_name(polling->device),
                     (int) mapping->interface->interface_number,
                     usb_str_class(mapping->interface->interface_class),
                     (int) mapping->interface->interface_subclass,
                     (int) mapping->interface->interface_protocol,
-                    data->request_size, pipe->max_packet_size);
+                    polling->request_size, pipe->desc.max_transfer_size);
         }
 
         size_t failed_attempts = 0;
-        while (failed_attempts <= params->max_failures) {
+        while (failed_attempts <= polling->max_failures) {
                 size_t actual_size;
-                const errno_t rc = usb_pipe_read(pipe, data->buffer,
-                    data->request_size, &actual_size);
+                const errno_t rc = usb_pipe_read(pipe, polling->buffer,
+                    polling->request_size, &actual_size);
 
                 if (rc == EOK) {
-                        if (params->debug > 1) {
+                        if (polling->debug > 1) {
                                 usb_log_debug(
                                     "Poll%p: received: '%s' (%zuB).\n",
-                                    data,
-                                    usb_debug_str_buffer(data->buffer,
+                                    polling,
+                                    usb_debug_str_buffer(polling->buffer,
                                         actual_size, 16),
                                     actual_size);
@@ -117 +145 @@
                                 usb_log_debug(
                                     "Poll%p: polling failed: %s.\n",
-                                    data, str_error(rc));
+                                    polling, str_error(rc));
                 }
 
                 /* If the pipe stalled, we can try to reset the stall. */
-                if ((rc == ESTALL) && (params->auto_clear_halt)) {
+                if (rc == ESTALL && polling->auto_clear_halt) {
                         /*
                          * We ignore error here as this is usually a futile
                          * attempt anyway.
                          */
-                        usb_request_clear_endpoint_halt(
-                            usb_device_get_default_pipe(data->dev),
-                            pipe->endpoint_no);
+                        usb_pipe_clear_halt(
+                            usb_device_get_default_pipe(polling->device), pipe);
                 }
 
                 if (rc != EOK) {
                         ++failed_attempts;
-                        const bool cont = (params->on_error == NULL) ? true :
-                            params->on_error(data->dev, rc, params->arg);
-                        if (!cont) {
-                                failed_attempts = params->max_failures;
+                        const bool carry_on = !polling->on_error ? true :
+                            polling->on_error(polling->device, rc, polling->arg);
+
+                        if (!carry_on || polling->joining) {
+                                /* This is user requested abort, erases failures. */
+                                failed_attempts = 0;
+                                break;
                         }
                         continue;
@@ -142 +172 @@
 
                 /* We have the data, execute the callback now. */
-                assert(params->on_data);
-                const bool carry_on = params->on_data(
-                    data->dev, data->buffer, actual_size, params->arg);
+                assert(polling->on_data);
+                const bool carry_on = polling->on_data(polling->device,
+                    polling->buffer, actual_size, polling->arg);
 
                 if (!carry_on) {
@@ -156 +186 @@
 
                 /* 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);
+                async_usleep(polling->delay);
         }
 
         const bool failed = failed_attempts > 0;
 
-        if (params->on_polling_end != NULL) {
-                params->on_polling_end(data->dev, failed, params->arg);
-        }
-
-        if (params->debug > 0) {
+        if (polling->on_polling_end)
+                polling->on_polling_end(polling->device, failed, polling->arg);
+
+        if (polling->debug > 0) {
                 if (failed) {
                         usb_log_error("Polling of device `%s' terminated: "
                             "recurring failures.\n",
-                            usb_device_get_name(data->dev));
+                            usb_device_get_name(polling->device));
                 } else {
                         usb_log_debug("Polling of device `%s' terminated: "
                             "driver request.\n",
-                            usb_device_get_name(data->dev));
+                            usb_device_get_name(polling->device));
                 }
         }
 
-        /* Free the allocated memory. */
-        free(data->buffer);
-        free(data);
-
+        fibril_mutex_lock(&polling->guard);
+        polling->running = false;
+        fibril_mutex_unlock(&polling->guard);
+
+        /* Notify joiners, if any. */
+        fibril_condvar_broadcast(&polling->cv);
         return EOK;
 }
@@ -198 +229 @@
  * first request would be executed prior to return from this function).
  *
- * @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).
+ * @param polling Polling data structure.
  * @return Error code.
  * @retval EOK New fibril polling the device was already started.
  */
-static errno_t 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)) {
+errno_t usb_polling_start(usb_polling_t *polling)
+{
+        if (!polling || !polling->device || !polling->ep_mapping || !polling->on_data)
                 return EBADMEM;
-        }
-
-        if (request_size == 0)
+
+        if (!polling->request_size)
                 return EINVAL;
-        
-        if (!epm || (epm->pipe.transfer_type != USB_TRANSFER_INTERRUPT) ||
-            (epm->pipe.direction != USB_DIRECTION_IN))
+
+        if (!polling->ep_mapping || (polling->ep_mapping->pipe.desc.transfer_type != USB_TRANSFER_INTERRUPT)
+            || (polling->ep_mapping->pipe.desc.direction != USB_DIRECTION_IN))
                 return EINVAL;
-        
-
-        polling_data_t *polling_data = malloc(sizeof(polling_data_t));
-        if (polling_data == NULL) {
+
+        /* Negative value means use descriptor provided value. */
+        if (polling->delay < 0)
+                polling->delay = polling->ep_mapping->descriptor->poll_interval;
+
+        polling->fibril = fibril_create(polling_fibril, polling);
+        if (!polling->fibril)
                 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_add_ready(polling->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.
- */
-errno_t 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).
- * @return Error code.
- * @retval EOK New fibril polling the device was already started.
- */
-errno_t 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)
-{
-        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(dev, ep);
-        return usb_device_auto_polling_internal(
-            dev, epm, &auto_polling, request_size);
-}
-
-errno_t 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);
-}
-
-errno_t 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);
+
+/** Close the polling pipe permanently and synchronously wait
+ *  until the automatic polling fibril terminates.
+ *
+ *  It is safe to deallocate the polling data structure (and its
+ *  data buffer) only after a successful call to this function.
+ *
+ *  @warning Call to this function will trigger execution of the
+ *  on_error() callback with EINTR error code.
+ *
+ *  @parram polling Polling data structure.
+ *  @return Error code.
+ *  @retval EOK Polling fibril has been successfully terminated.
+ */
+errno_t usb_polling_join(usb_polling_t *polling)
+{
+        errno_t rc;
+        if (!polling)
+                return EBADMEM;
+
+        /* Check if the fibril already terminated. */
+        if (!polling->running)
+                return EOK;
+
+        /* Set the flag */
+        polling->joining = true;
+
+        /* Unregister the pipe. */
+        rc = usb_device_unmap_ep(polling->ep_mapping);
+        if (rc != EOK && rc != ENOENT && rc != EHANGUP)
+                return rc;
+
+        /* Wait for the fibril to terminate. */
+        fibril_mutex_lock(&polling->guard);
+        while (polling->running)
+                fibril_condvar_wait(&polling->cv, &polling->guard);
+        fibril_mutex_unlock(&polling->guard);
+
+        return EOK;
 }