Changeset 7dddd7b in mainline

Timestamp:

2018-01-13T20:47:58Z (7 years ago)

Author:

Petr Manek <petr.manek@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

71f211f

Parents:

2489353

git-author:

Petr Manek <petr.manek@…> (2018-01-13 19:20:41)

git-committer:

Petr Manek <petr.manek@…> (2018-01-13 20:47:58)

Message:

usbdev: refactor polling

Until now, device polling had to be executed by calling one of four
proxy functions, which served as a syntax sugar and had no clear
distinction between each other (not to mention misleading names and high
number of arguments).

In this commit, the four mentioned functions are discarded in favor of
one main function, which was proxied by them either way. The number of
arguments have decreased in favor of named struct fields in the auto
polling config structure.

Drivers, which make use of polling, such as usbhid and usbhub were
updated to the latest API design.

Location:

uspace

Files:

• drv/bus/usb/usbhub/usbhub.c (modified) (1 diff)
• drv/hid/usbhid/main.c (modified) (1 diff)
• lib/usbdev/include/usb/dev/poll.h (modified) (1 diff)
• lib/usbdev/src/devpoll.c (modified) (3 diffs)

uspace/drv/bus/usb/usbhub/usbhub.c

@@ -164 +164 @@
 
         /* Start hub operation. */
-        opResult = usb_device_auto_poll_desc(hub_dev->usb_device,
-            &hub_status_change_endpoint_description,
-            hub_port_changes_callback, ((hub_dev->port_count + 1 + 7) / 8),
-            -1, usb_hub_polling_error_callback,
-            usb_hub_polling_terminated_callback, hub_dev);
+        const usb_device_auto_polling_t auto_polling = {
+                .debug = 1,
+                .auto_clear_halt = true,
+                .delay = -1,
+                .max_failures = 3,
+                .on_data = hub_port_changes_callback,
+                .on_polling_end = usb_hub_polling_terminated_callback,
+                .on_error = usb_hub_polling_error_callback,
+                .arg = hub_dev,
+        };
+
+        usb_endpoint_mapping_t *epm =
+            usb_device_get_mapped_ep_desc(hub_dev->usb_device,
+            &hub_status_change_endpoint_description);
+        opResult = usb_device_auto_polling(hub_dev->usb_device, epm,
+            &auto_polling, ((hub_dev->port_count + 1 + 7) / 8));
+        
         if (opResult != EOK) {
                 /* Function is already bound */

uspace/drv/hid/usbhid/main.c

@@ -90 +90 @@
          * This will create a separate fibril that will query the device
          * for the data continuously. */
-        rc = usb_device_auto_poll_desc(dev,
-           /* Index of the polling pipe. */
-           hid_dev->poll_pipe_mapping->description,
-           /* Callback when data arrives. */
-           usb_hid_polling_callback,
-           /* How much data to request. */
-           hid_dev->poll_pipe_mapping->pipe.desc.max_transfer_size,
-           /* Delay */
-           -1,
-           /* Callback when the polling fails. */
-           usb_hid_polling_error_callback,
-           /* Callback when the polling ends. */
-           usb_hid_polling_ended_callback,
-           /* Custom argument. */
-           hid_dev);
+        const usb_device_auto_polling_t auto_polling = {
+                .debug = 1,
+                .auto_clear_halt = true,
+                .delay = -1,
+                .max_failures = 3,
+                .on_data = usb_hid_polling_callback,
+                .on_polling_end = usb_hid_polling_ended_callback,
+                .on_error = usb_hid_polling_error_callback,
+                .arg = hid_dev,
+        };
+
+        rc = usb_device_auto_polling(dev, hid_dev->poll_pipe_mapping,
+            &auto_polling, hid_dev->poll_pipe_mapping->pipe.desc.max_transfer_size);
 
         if (rc != EOK) {

uspace/lib/usbdev/include/usb/dev/poll.h

@@ -96 +96 @@
 typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
 
-extern int usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
+extern int usb_device_auto_polling(usb_device_t *, usb_endpoint_mapping_t *,
     const usb_device_auto_polling_t *, size_t);
-
-extern int usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
-    usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
-
-extern int usb_device_auto_polling_desc(usb_device_t *,
-    const usb_endpoint_description_t *, const usb_device_auto_polling_t *,
-    size_t);
-
-extern int usb_device_auto_poll_desc(usb_device_t *,
-    const usb_endpoint_description_t *, usb_polling_callback_t, size_t, int,
-    usb_polling_error_callback_t, usb_polling_terminted_callback_t, void *);
 
 #endif

uspace/lib/usbdev/src/devpoll.c

@@ -203 +203 @@
  * @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 req_size How many bytes to ask for in each request.
  * @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)
+int usb_device_auto_polling(usb_device_t *dev, usb_endpoint_mapping_t *epm,
+    const usb_device_auto_polling_t *polling, size_t req_size)
 {
-        if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
+        int rc;
+        if (!dev || !polling || !polling->on_data)
                 return EBADMEM;
-        }
-
-        if (request_size == 0)
+
+        if (!req_size)
                 return EINVAL;
 
@@ -223 +221 @@
                 return EINVAL;
 
-
         polling_data_t *polling_data = malloc(sizeof(polling_data_t));
-        if (polling_data == NULL) {
+        if (!polling_data)
                 return ENOMEM;
-        }
 
         /* Fill-in the data. */
-        polling_data->buffer = malloc(request_size);
+        polling_data->buffer = malloc(req_size);
         if (polling_data->buffer == NULL) {
-                free(polling_data);
-                return ENOMEM;
-        }
-        polling_data->request_size = request_size;
+                rc = ENOMEM;
+                goto err_polling_data;
+        }
+        polling_data->request_size = req_size;
         polling_data->dev = dev;
         polling_data->polling_mapping = epm;
@@ -249 +245 @@
 
         fid_t fibril = fibril_create(polling_fibril, polling_data);
-        if (fibril == 0) {
-                free(polling_data->buffer);
-                free(polling_data);
-                return ENOMEM;
+        if (!fibril) {
+                rc = ENOMEM;
+                goto err_buffer;
         }
         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).
- * @return Error code.
- * @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,
-    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);
-}
-
-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)
-{
-        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_error_callback_t error_callback,
-    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 = error_callback,
-                .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);
+
+err_buffer:
+        free(polling_data->buffer);
+err_polling_data:
+        free(polling_data);
+        return rc;
 }