Changes in uspace/lib/usbdev/src/devpoll.c [a0487a2:b77931d] 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 {
-        /** Parameters for automated polling. */
-        usb_device_auto_polling_t auto_polling;
-
-        /** USB device to poll. */
+        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;
-        /** 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;
 
@@ -67 +69 @@
 static int polling_fibril(void *arg)
 {
-        assert(arg);
-        const polling_data_t *data = arg;
-        /* Helper to reduce typing. */
-        const usb_device_auto_polling_t *params = &data->auto_polling;
+        polling_data_t *polling_data = (polling_data_t *) arg;
+        assert(polling_data);
 
         usb_pipe_t *pipe
-            = &data->dev->pipes[data->pipe_index].pipe;
-
-        if (params->debug > 0) {
-                const usb_endpoint_mapping_t *mapping
-                    = &data->dev->pipes[data->pipe_index];
+            = &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",
-                    data, data->dev->ddf_dev->name,
+                    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,
-                    data->request_size, pipe->max_packet_size);
-        }
-
-        usb_pipe_start_long_transfer(pipe);
+                    polling_data->request_size, pipe->max_packet_size);
+        }
+
         size_t failed_attempts = 0;
-        while (failed_attempts <= params->max_failures) {
+        while (failed_attempts <= polling_data->max_failures) {
+                int rc;
+
                 size_t actual_size;
-                const int rc = usb_pipe_read(pipe, data->buffer,
-                    data->request_size, &actual_size);
-
-                if (params->debug > 1) {
+                rc = usb_pipe_read(pipe, polling_data->buffer,
+                    polling_data->request_size, &actual_size);
+
+                if (polling_data->debug > 1) {
                         if (rc == EOK) {
                                 usb_log_debug(
                                     "Poll%p: received: '%s' (%zuB).\n",
-                                    data,
-                                    usb_debug_str_buffer(data->buffer,
+                                    polling_data,
+                                    usb_debug_str_buffer(polling_data->buffer,
                                         actual_size, 16),
                                     actual_size);
@@ -106 +108 @@
                                 usb_log_debug(
                                     "Poll%p: polling failed: %s.\n",
-                                    data, str_error(rc));
+                                    polling_data, 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_data->auto_clear_halt)) {
                         /*
                          * We ignore error here as this is usually a futile
@@ -117 +119 @@
                          */
                         usb_request_clear_endpoint_halt(
-                            &data->dev->ctrl_pipe, pipe->endpoint_no);
+                            &polling_data->dev->ctrl_pipe,
+                            pipe->endpoint_no);
                 }
 
                 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;
+                        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;
                 }
 
                 /* 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);
+                bool carry_on = polling_data->on_data(polling_data->dev,
+                    polling_data->buffer, actual_size,
+                    polling_data->custom_arg);
 
                 if (!carry_on) {
-                        /* This is user requested abort, erases failures. */
                         failed_attempts = 0;
                         break;
@@ -145 +151 @@
 
                 /* Take a rest before next request. */
-                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);
+                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: "
-                            "driver request.\n", data->dev->ddf_dev->name);
+                        usb_log_debug(
+                            "Polling of device `%s' terminated by user.\n",
+                            polling_data->dev->ddf_dev->name
+                        );
                 }
         }
 
         /* Free the allocated memory. */
-        free(data->buffer);
-        free(data);
+        free(polling_data->buffer);
+        free(polling_data);
 
         return EOK;
@@ -195 +202 @@
     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,
@@ -203 +221 @@
                 .on_polling_end = terminated_callback,
                 .on_error = NULL,
-                .arg = arg,
         };
 
         return usb_device_auto_polling(dev, pipe_index, &auto_polling,
-           request_size);
+           request_size, arg);
 }
 
@@ -229 +246 @@
 int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index,
     const usb_device_auto_polling_t *polling,
-    size_t request_size)
+    size_t request_size, void *arg)
 {
-        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
+        if (dev == NULL) {
                 return EBADMEM;
         }
-
-        if (pipe_index >= dev->pipes_count || request_size == 0) {
+        if (pipe_index >= dev->pipes_count) {
                 return EINVAL;
         }
@@ -241 +257 @@
             || (dev->pipes[pipe_index].pipe.direction != USB_DIRECTION_IN)) {
                 return EINVAL;
+        }
+        if ((polling == NULL) || (polling->on_data == NULL)) {
+                return EBADMEM;
         }
 
@@ -257 +276 @@
         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;
-        }
+        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);