Changes in uspace/lib/usbdev/src/devpoll.c [b77931d:a0487a2] in mainline

File:

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

uspace/lib/usbdev/src/devpoll.c

@@ -46 +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 *);
-
+        /** Parameters for automated polling. */
+        usb_device_auto_polling_t auto_polling;
+
+        /** USB device to poll. */
         usb_device_t *dev;
+        /** Device pipe to use for polling. */
         size_t pipe_index;
+        /** Size of the recieved data. */
         size_t request_size;
+        /** Data buffer. */
         uint8_t *buffer;
-        void *custom_arg;
 } polling_data_t;
 
@@ -69 +67 @@
 static int polling_fibril(void *arg)
 {
-        polling_data_t *polling_data = (polling_data_t *) arg;
-        assert(polling_data);
+        assert(arg);
+        const polling_data_t *data = arg;
+        /* Helper to reduce typing. */
+        const usb_device_auto_polling_t *params = &data->auto_polling;
 
         usb_pipe_t *pipe
-            = &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];
+            = &data->dev->pipes[data->pipe_index].pipe;
+
+        if (params->debug > 0) {
+                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",
-                    polling_data,
-                    polling_data->dev->ddf_dev->name,
+                    data, 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);
-        }
-
+                    data->request_size, pipe->max_packet_size);
+        }
+
+        usb_pipe_start_long_transfer(pipe);
         size_t failed_attempts = 0;
-        while (failed_attempts <= polling_data->max_failures) {
-                int rc;
-
+        while (failed_attempts <= params->max_failures) {
                 size_t actual_size;
-                rc = usb_pipe_read(pipe, polling_data->buffer,
-                    polling_data->request_size, &actual_size);
-
-                if (polling_data->debug > 1) {
+                const int rc = usb_pipe_read(pipe, data->buffer,
+                    data->request_size, &actual_size);
+
+                if (params->debug > 1) {
                         if (rc == EOK) {
                                 usb_log_debug(
                                     "Poll%p: received: '%s' (%zuB).\n",
-                                    polling_data,
-                                    usb_debug_str_buffer(polling_data->buffer,
+                                    data,
+                                    usb_debug_str_buffer(data->buffer,
                                         actual_size, 16),
                                     actual_size);
@@ -108 +106 @@
                                 usb_log_debug(
                                     "Poll%p: polling failed: %s.\n",
-                                    polling_data, str_error(rc));
+                                    data, str_error(rc));
                         }
                 }
 
                 /* If the pipe stalled, we can try to reset the stall. */
-                if ((rc == ESTALL) && (polling_data->auto_clear_halt)) {
+                if ((rc == ESTALL) && (params->auto_clear_halt)) {
                         /*
                          * We ignore error here as this is usually a futile
@@ -119 +117 @@
                          */
                         usb_request_clear_endpoint_halt(
-                            &polling_data->dev->ctrl_pipe,
-                            pipe->endpoint_no);
+                            &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;
+                        const bool cont = (params->on_error == NULL) ? true :
+                            params->on_error(data->dev, rc, params->arg);
+                        if (!cont) {
+                                failed_attempts = params->max_failures;
                         }
-                        failed_attempts++;
                         continue;
                 }
 
                 /* We have the data, execute the callback now. */
-                bool carry_on = polling_data->on_data(polling_data->dev,
-                    polling_data->buffer, actual_size,
-                    polling_data->custom_arg);
+                assert(params->on_data);
+                const bool carry_on = params->on_data(
+                    data->dev, data->buffer, actual_size, params->arg);
 
                 if (!carry_on) {
+                        /* This is user requested abort, erases failures. */
                         failed_attempts = 0;
                         break;
@@ -151 +145 @@
 
                 /* 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");
+                async_usleep(params->delay);
+        }
+
+        usb_pipe_end_long_transfer(pipe);
+
+        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 (failed) {
+                        usb_log_error("Polling of device `%s' terminated: "
+                            "recurring failures.\n", data->dev->ddf_dev->name);
                 } else {
-                        usb_log_debug(
-                            "Polling of device `%s' terminated by user.\n",
-                            polling_data->dev->ddf_dev->name
-                        );
+                        usb_log_debug("Polling of device `%s' terminated: "
+                            "driver request.\n", data->dev->ddf_dev->name);
                 }
         }
 
         /* Free the allocated memory. */
-        free(polling_data->buffer);
-        free(polling_data);
+        free(data->buffer);
+        free(data);
 
         return EOK;
@@ -202 +195 @@
     usb_polling_terminted_callback_t terminated_callback, void *arg)
 {
-        if ((dev == NULL) || (callback == NULL)) {
-                return EBADMEM;
-        }
-        if (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;
-        }
-
         const usb_device_auto_polling_t auto_polling = {
                 .debug = 1,
@@ -221 +203 @@
                 .on_polling_end = terminated_callback,
                 .on_error = NULL,
+                .arg = arg,
         };
 
         return usb_device_auto_polling(dev, pipe_index, &auto_polling,
-           request_size, arg);
+           request_size);
 }
 
@@ -246 +229 @@
 int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index,
     const usb_device_auto_polling_t *polling,
-    size_t request_size, void *arg)
+    size_t request_size)
 {
-        if (dev == NULL) {
+        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
                 return EBADMEM;
         }
-        if (pipe_index >= dev->pipes_count) {
+
+        if (pipe_index >= dev->pipes_count || request_size == 0) {
                 return EINVAL;
         }
@@ -257 +241 @@
             || (dev->pipes[pipe_index].pipe.direction != USB_DIRECTION_IN)) {
                 return EINVAL;
-        }
-        if ((polling == NULL) || (polling->on_data == NULL)) {
-                return EBADMEM;
         }
 
@@ -276 +257 @@
         polling_data->dev = dev;
         polling_data->pipe_index = pipe_index;
-        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;
+
+        /* 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);