Changeset 476f62c in mainline for uspace/lib/drv/generic/remote_usbhid.c

Timestamp:

2014-01-17T17:26:48Z (10 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

5828554, cf982ff

Parents:

61b5b73d (diff), 66be0288 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge libdrv cleanup.

• move 'client side' device iface to libdrv (from libc)
• hide remote_* libdrv headers
• add a bunch of const qualifiers and change static data to const
• cleanup: index initialized arrays, array size macro, removes duplicit enums, …

TODO:

move hw_res, pio_window and co to libdrv. (too entangled with libc to move right now)
move clock_dev iface to libdrv. (also tied to libc, we need a time provider solution)

File:

• uspace/lib/drv/generic/remote_usbhid.c (modified) (2 diffs)

uspace/lib/drv/generic/remote_usbhid.c

@@ -37 +37 @@
 #include <assert.h>
 #include <stdio.h>
+#include <macros.h>
 
 #include "usbhid_iface.h"
 #include "ddf/driver.h"
+
+/** IPC methods for USB HID device interface. */
+typedef enum {
+        /** Get number of events reported in single burst.
+         * Parameters: none
+         * Answer:
+         * - Size of one report in bytes.
+         */
+        IPC_M_USBHID_GET_EVENT_LENGTH,
+        /** Get single event from the HID device.
+         * The word single refers to set of individual events that were
+         * available at particular point in time.
+         * Parameters:
+         * - flags
+         * The call is followed by data read expecting two concatenated
+         * arrays.
+         * Answer:
+         * - EOK - events returned
+         * - EAGAIN - no event ready (only in non-blocking mode)
+         *
+         * It is okay if the client requests less data. Extra data must
+         * be truncated by the driver.
+         *
+         * @todo Change this comment.
+         */
+        IPC_M_USBHID_GET_EVENT,
+        
+        /** Get the size of the report descriptor from the HID device.
+         *
+         * Parameters:
+         * - none
+         * Answer:
+         * - EOK - method is implemented (expected always)
+         * Parameters of the answer:
+         * - Size of the report in bytes.
+         */
+        IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH,
+        
+        /** Get the report descriptor from the HID device.
+         *
+         * Parameters:
+         * - none
+         * The call is followed by data read expecting the descriptor itself.
+         * Answer:
+         * - EOK - report descriptor returned.
+         */
+        IPC_M_USBHID_GET_REPORT_DESCRIPTOR
+} usbhid_iface_funcs_t;
+
+/** Ask for event array length.
+ *
+ * @param dev_sess Session to DDF device providing USB HID interface.
+ *
+ * @return Number of usages returned or negative error code.
+ *
+ */
+int usbhid_dev_get_event_length(async_sess_t *dev_sess, size_t *size)
+{
+        if (!dev_sess)
+                return EINVAL;
+        
+        async_exch_t *exch = async_exchange_begin(dev_sess);
+        
+        sysarg_t len;
+        int rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE),
+            IPC_M_USBHID_GET_EVENT_LENGTH, &len);
+        
+        async_exchange_end(exch);
+        
+        if (rc == EOK) {
+                if (size != NULL)
+                        *size = (size_t) len;
+        }
+        
+        return rc;
+}
+
+/** Request for next event from HID device.
+ *
+ * @param[in]  dev_sess    Session to DDF device providing USB HID interface.
+ * @param[out] usage_pages Where to store usage pages.
+ * @param[out] usages      Where to store usages (actual data).
+ * @param[in]  usage_count Length of @p usage_pages and @p usages buffer
+ *                         (in items, not bytes).
+ * @param[out] actual_usage_count Number of usages actually returned by the
+ *                                device driver.
+ * @param[in] flags        Flags (see USBHID_IFACE_FLAG_*).
+ *
+ * @return Error code.
+ *
+ */
+int usbhid_dev_get_event(async_sess_t *dev_sess, uint8_t *buf,
+    size_t size, size_t *actual_size, int *event_nr, unsigned int flags)
+{
+        if (!dev_sess)
+                return EINVAL;
+        
+        if (buf == NULL)
+                return ENOMEM;
+        
+        if (size == 0)
+                return EINVAL;
+        
+        size_t buffer_size =  size;
+        uint8_t *buffer = malloc(buffer_size);
+        if (buffer == NULL)
+                return ENOMEM;
+        
+        async_exch_t *exch = async_exchange_begin(dev_sess);
+        
+        ipc_call_t opening_request_call;
+        aid_t opening_request = async_send_2(exch,
+            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT,
+            flags, &opening_request_call);
+        
+        if (opening_request == 0) {
+                async_exchange_end(exch);
+                free(buffer);
+                return ENOMEM;
+        }
+        
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(exch, buffer, buffer_size,
+            &data_request_call);
+        
+        async_exchange_end(exch);
+        
+        if (data_request == 0) {
+                async_forget(opening_request);
+                free(buffer);
+                return ENOMEM;
+        }
+        
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(opening_request, &opening_request_rc);
+        
+        if (data_request_rc != EOK) {
+                /* Prefer return code of the opening request. */
+                if (opening_request_rc != EOK)
+                        return (int) opening_request_rc;
+                else
+                        return (int) data_request_rc;
+        }
+        
+        if (opening_request_rc != EOK)
+                return (int) opening_request_rc;
+        
+        size_t act_size = IPC_GET_ARG2(data_request_call);
+        
+        /* Copy the individual items. */
+        memcpy(buf, buffer, act_size);
+        
+        if (actual_size != NULL)
+                *actual_size = act_size;
+        
+        if (event_nr != NULL)
+                *event_nr = IPC_GET_ARG1(opening_request_call);
+        
+        return EOK;
+}
+
+int usbhid_dev_get_report_descriptor_length(async_sess_t *dev_sess,
+    size_t *size)
+{
+        if (!dev_sess)
+                return EINVAL;
+        
+        async_exch_t *exch = async_exchange_begin(dev_sess);
+        
+        sysarg_t arg_size;
+        int rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE),
+            IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
+        
+        async_exchange_end(exch);
+        
+        if (rc == EOK) {
+                if (size != NULL)
+                        *size = (size_t) arg_size;
+        }
+        
+        return rc;
+}
+
+int usbhid_dev_get_report_descriptor(async_sess_t *dev_sess, uint8_t *buf,
+    size_t size, size_t *actual_size)
+{
+        if (!dev_sess)
+                return EINVAL;
+        
+        if (buf == NULL)
+                return ENOMEM;
+        
+        if (size == 0)
+                return EINVAL;
+        
+        async_exch_t *exch = async_exchange_begin(dev_sess);
+        
+        aid_t opening_request = async_send_1(exch,
+            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
+            NULL);
+        if (opening_request == 0) {
+                async_exchange_end(exch);
+                return ENOMEM;
+        }
+        
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(exch, buf, size,
+            &data_request_call);
+        
+        async_exchange_end(exch);
+        
+        if (data_request == 0) {
+                async_forget(opening_request);
+                return ENOMEM;
+        }
+        
+        sysarg_t data_request_rc;
+        sysarg_t opening_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        async_wait_for(opening_request, &opening_request_rc);
+        
+        if (data_request_rc != EOK) {
+                /* Prefer return code of the opening request. */
+                if (opening_request_rc != EOK)
+                        return (int) opening_request_rc;
+                else
+                        return (int) data_request_rc;
+        }
+        
+        if (opening_request_rc != EOK)
+                return (int) opening_request_rc;
+        
+        size_t act_size = IPC_GET_ARG2(data_request_call);
+        
+        if (actual_size != NULL)
+                *actual_size = act_size;
+        
+        return EOK;
+}
 
 static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
@@ -48 +290 @@
 
 /** Remote USB HID interface operations. */
-static remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
-        remote_usbhid_get_event_length,
-        remote_usbhid_get_event,
-        remote_usbhid_get_report_descriptor_length,
-        remote_usbhid_get_report_descriptor
+static const remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
+        [IPC_M_USBHID_GET_EVENT_LENGTH] = remote_usbhid_get_event_length,
+        [IPC_M_USBHID_GET_EVENT] = remote_usbhid_get_event,
+        [IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH] =
+            remote_usbhid_get_report_descriptor_length,
+        [IPC_M_USBHID_GET_REPORT_DESCRIPTOR] = remote_usbhid_get_report_descriptor
 };
 
 /** Remote USB HID interface structure.
  */
-remote_iface_t remote_usbhid_iface = {
-        .method_count = sizeof(remote_usbhid_iface_ops) /
-            sizeof(remote_usbhid_iface_ops[0]),
+const remote_iface_t remote_usbhid_iface = {
+        .method_count = ARRAY_SIZE(remote_usbhid_iface_ops),
         .methods = remote_usbhid_iface_ops
 };