Changeset e56b8a3 in mainline for uspace/lib

Timestamp:

2011-05-27T13:27:22Z (14 years ago)

Author:

Matej Klonfar <maklf@…>

Branches:

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

Children:

0c904a3

Parents:

8242dd86 (diff), 567a3e2 (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:

Development changes

Location:

uspace/lib

Files:

• drv/Makefile (modified) (1 diff)
• drv/generic/dev_iface.c (modified) (2 diffs)
• drv/generic/driver.c (modified) (1 diff)
• drv/generic/remote_usbhid.c (modified) (6 diffs)
• drv/include/remote_pci.h (modified) (1 diff)
• drv/include/remote_usb.h (modified) (1 diff)
• drv/include/remote_usbhc.h (modified) (1 diff)
• drv/include/remote_usbhid.h (modified) (1 diff)
• drv/include/usbhid_iface.h (modified) (4 diffs)
• usbhid/Makefile (modified) (1 diff)
• usbhid/include/usb/hid/hidreport.h (modified) (2 diffs)
• usbhid/include/usb/hid/iface.h (modified) (1 diff)
• usbhid/include/usb/hid/usages/consumer.h (added)
• usbhid/src/consumer.c (added)
• usbhid/src/hidiface.c (modified) (4 diffs)
• usbhid/src/hidreport.c (modified) (2 diffs)

uspace/lib/drv/Makefile

@@ -40 +40 @@
         generic/remote_usb.c \
         generic/remote_pci.c \
-        generic/remote_usbhc.c
+        generic/remote_usbhc.c \
+        generic/remote_usbhid.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/drv/generic/dev_iface.c

@@ -46 +46 @@
 #include "remote_pci.h"
 
+#include <stdio.h>
+
 static iface_dipatch_table_t remote_ifaces = {
         .ifaces = {
@@ -60 +62 @@
 {
         assert(is_valid_iface_idx(idx));
+        
         return remote_ifaces.ifaces[idx];
 }

uspace/lib/drv/generic/driver.c

@@ -405 +405 @@
                                 /* The interface has not such method */
                                 printf("%s: driver_connection_gen error - "
-                                    "invalid interface method.", driver->name);
+                                    "invalid interface method (%d).\n",
+                                    driver->name, iface_method_idx);
                                 async_answer_0(callid, ENOTSUP);
                                 break;

uspace/lib/drv/generic/remote_usbhid.c

@@ -36 +36 @@
 #include <errno.h>
 #include <assert.h>
+#include <stdio.h>
 
 #include "usbhid_iface.h"
@@ -42 +43 @@
 static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhid_get_event(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 // static void remote_usbhid_(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 
@@ -47 +50 @@
 static remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
         remote_usbhid_get_event_length,
-        remote_usbhid_get_event
+        remote_usbhid_get_event,
+        remote_usbhid_get_report_descriptor_length,
+        remote_usbhid_get_report_descriptor
 };
 
@@ -58 +63 @@
 };
 
-usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+//usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
 
 
@@ -64 +69 @@
     ipc_callid_t callid, ipc_call_t *call)
 {
+        printf("remote_usbhid_get_event_length()\n");
+        
         usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
 
         if (!hid_iface->get_event_length) {
-                async_answer_0(callid, ENOTSUP);
-                return;
-        }
-
-        int len = hid_iface->get_event_length(fun);
-        if (len == 0) {
-                len = EEMPTY;
-        }
-        if (len < 0) {
-                async_answer_0(callid, len);
-        } else {
-                async_answer_1(callid, EOK, len);
-        }
+                printf("Get event length not set!\n");
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t len = hid_iface->get_event_length(fun);
+//      if (len == 0) {
+//              len = EEMPTY;
+//      }
+        async_answer_1(callid, EOK, len);
+        
+//      if (len < 0) {
+//              async_answer_0(callid, len);
+//      } else {
+//              async_answer_1(callid, EOK, len);
+//      }
 }
 
@@ -100 +110 @@
                 return;
         }
-        /* Check that length is even number. Truncate otherwise. */
-        if ((len % 2) == 1) {
-                len--;
-        }
+//      /* Check that length is even number. Truncate otherwise. */
+//      if ((len % 2) == 1) {
+//              len--;
+//      }
         if (len == 0) {
                 async_answer_0(data_callid, EINVAL);
                 async_answer_0(callid, EINVAL);
+                return;
         }
 
         int rc;
 
-        size_t items = len / 2;
-        uint16_t *usage_pages_and_usages = malloc(sizeof(uint16_t) * len);
-        if (usage_pages_and_usages == NULL) {
+        uint8_t *data = malloc(len);
+        if (data == NULL) {
                 async_answer_0(data_callid, ENOMEM);
                 async_answer_0(callid, ENOMEM);
-        }
-
-        size_t act_items;
-        int rc = hid_iface->get_event(fun, usage_pages_and_usages,
-            usage_pages_and_usages + items, items, &act_items, flags);
+                return;
+        }
+
+        size_t act_length;
+        int event_nr;
+        rc = hid_iface->get_event(fun, data, len, &act_length, &event_nr, flags);
         if (rc != EOK) {
-                free(usage_pages_and_usages);
+                free(data);
                 async_answer_0(data_callid, rc);
                 async_answer_0(callid, rc);
-        }
-        if (act_items >= items) {
+                return;
+        }
+        if (act_length >= len) {
                 /* This shall not happen. */
                 // FIXME: how about an assert here?
-                act_items = items;
-        }
-
-        async_data_read_finalize(data_callid, usage_pages_and_usages,
-            act_items * 2 * sizeof(uint16_t));
-
-        free(usage_pages_and_usages);
-
+                act_length = len;
+        }
+
+        async_data_read_finalize(data_callid, data, act_length);
+
+        free(data);
+
+        async_answer_1(callid, EOK, event_nr);
+}
+
+void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
+
+        if (!hid_iface->get_report_descriptor_length) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t len = hid_iface->get_report_descriptor_length(fun);
+        async_answer_1(callid, EOK, (sysarg_t) len);
+}
+
+void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
+
+        if (!hid_iface->get_report_descriptor) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+
+        size_t len;
+        ipc_callid_t data_callid;
+        if (!async_data_read_receive(&data_callid, &len)) {
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+
+        if (len == 0) {
+                async_answer_0(data_callid, EINVAL);
+                async_answer_0(callid, EINVAL);
+                return;
+        }
+
+        uint8_t *descriptor = malloc(len);
+        if (descriptor == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        size_t act_len = 0;
+        int rc = hid_iface->get_report_descriptor(fun, descriptor, len,
+            &act_len);
+        if (act_len > len) {
+                rc = ELIMIT;
+        }
+        if (rc != EOK) {
+                free(descriptor);
+                async_answer_0(data_callid, rc);
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        async_data_read_finalize(data_callid, descriptor, act_len);
         async_answer_0(callid, EOK);
-}
+
+        free(descriptor);
+}
+
+
 
 /**

uspace/lib/drv/include/remote_pci.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_PCI_H_
 
-remote_iface_t remote_pci_iface;
+extern remote_iface_t remote_pci_iface;
 
 #endif

uspace/lib/drv/include/remote_usb.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_USB_H_
 
-remote_iface_t remote_usb_iface;
+extern remote_iface_t remote_usb_iface;
 
 #endif

uspace/lib/drv/include/remote_usbhc.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_USBHC_H_
 
-remote_iface_t remote_usbhc_iface;
+extern remote_iface_t remote_usbhc_iface;
 
 #endif

uspace/lib/drv/include/remote_usbhid.h

@@ -36 +36 @@
 #define LIBDRV_REMOTE_USBHID_H_
 
-remote_iface_t remote_usbhid_iface;
+extern remote_iface_t remote_usbhid_iface;
 
 #endif

uspace/lib/drv/include/usbhid_iface.h

@@ -45 +45 @@
          * Parameters: none
          * Answer:
-         * - EOK (expected always as long as device support USB HID interface)
-         * Parameters of the answer:
-         * - number of items
+         * - Size of one report in bytes.
          */
         IPC_M_USBHID_GET_EVENT_LENGTH,
@@ -63 +61 @@
          * 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
+        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;
 
@@ -75 +96 @@
          *
          * @param[in] fun DDF function answering the request.
-         * @return Number of events or error code.
+         * @return Size of the event in bytes.
          */
         size_t (*get_event_length)(ddf_fun_t *fun);
@@ -87 +108 @@
          * @return Error code.
          */
-        int (*get_event)(ddf_fun_t *fun, int32_t *buffer, size_t size,
-            size_t *act_size, unsigned int flags);
+        int (*get_event)(ddf_fun_t *fun, uint8_t *buffer, size_t size,
+            size_t *act_size, int *event_nr, unsigned int flags);
+        
+        /** Get size of the report descriptor in bytes.
+         *
+         * @param[in] fun DDF function answering the request.
+         * @return Size of the report descriptor in bytes.
+         */
+        size_t (*get_report_descriptor_length)(ddf_fun_t *fun);
+        
+        /** Get the report descriptor from the HID device.
+         *
+         * @param[in] fun DDF function answering the request.
+         * @param[out] desc Buffer with the report descriptor.
+         * @param[in] size Size of the allocated @p desc buffer.
+         * @param[out] act_size Actual size of the report descriptor returned.
+         * @return Error code.
+         */
+        int (*get_report_descriptor)(ddf_fun_t *fun, uint8_t *desc, 
+            size_t size, size_t *act_size);
 } usbhid_iface_t;
 

uspace/lib/usbhid/Makefile

@@ -41 +41 @@
         src/hidpath.c \
         src/hidreport.c \
+        src/consumer.c \
         src/hidreq.c
 

uspace/lib/usbhid/include/usb/hid/hidreport.h

@@ -44 +44 @@
  * report parser.
  *
- * \param dev USB device representing a HID device.
- * \param parser HID Report parser.
+ * \param[in] dev USB device representing a HID device.
+ * \param[in/out] parser HID Report parser.
+ * \param[out] report_desc Place to save report descriptor into.
+ * \param[out] report_size
  *
  * \retval EOK if successful.
@@ -57 +59 @@
  */
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_t *report);
+    usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size);
 
 #endif /* LIBUSB_HIDREPORT_H_ */

uspace/lib/usbhid/include/usb/hid/iface.h

@@ -38 +38 @@
 #include <sys/types.h>
 
-int usbhid_dev_get_event_length(int);
-int usbhid_dev_get_event(int, uint16_t *, uint16_t *, size_t, size_t *,
+int usbhid_dev_get_event_length(int, size_t *);
+int usbhid_dev_get_event(int, uint8_t *, size_t, size_t *, int *,
     unsigned int);
+int usbhid_dev_get_report_descriptor_length(int, size_t *);
+int usbhid_dev_get_report_descriptor(int, uint8_t *, size_t, size_t *);
 
 #endif

uspace/lib/usbhid/src/hidiface.c

@@ -46 +46 @@
  * @return Number of usages returned or negative error code.
  */
-int usbhid_dev_get_event_length(int dev_phone)
+int usbhid_dev_get_event_length(int dev_phone, size_t *size)
 {
         if (dev_phone < 0) {
@@ -56 +56 @@
             IPC_M_USBHID_GET_EVENT_LENGTH, &len);
         if (rc == EOK) {
-                return (int) len;
-        } else {
-                return rc;
-        }
+                if (size != NULL) {
+                        *size = (size_t) len;
+                }
+        }
+        
+        return rc;
 }
 
@@ -74 +76 @@
  * @return Error code.
  */
-int usbhid_dev_get_event(int dev_phone, uint16_t *usage_pages, uint16_t *usages,
-    size_t usage_count, size_t *actual_usage_count, unsigned int flags)
-{
-        if (dev_phone < 0) {
-                return EINVAL;
-        }
-        if ((usage_pages == NULL) || (usages == NULL)) {
-                return ENOMEM;
-        }
-        if (usage_count == 0) {
-                return EINVAL;
-        }
-
-        size_t buffer_size = sizeof(uint16_t) * usage_count * 2;
-        uint16_t *buffer = malloc(buffer_size);
+int usbhid_dev_get_event(int dev_phone, uint8_t *buf, 
+    size_t size, size_t *actual_size, int *event_nr, unsigned int flags)
+{
+        if (dev_phone < 0) {
+                return EINVAL;
+        }
+        if ((buf == NULL)) {
+                return ENOMEM;
+        }
+        if (size == 0) {
+                return EINVAL;
+        }
+        
+//      if (size == 0) {
+//              return EOK;
+//      }
+
+        size_t buffer_size =  size;
+        uint8_t *buffer = malloc(buffer_size);
         if (buffer == NULL) {
                 return ENOMEM;
         }
 
+        ipc_call_t opening_request_call;
         aid_t opening_request = async_send_2(dev_phone,
             DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT,
-            flags, NULL);
+            flags, &opening_request_call);
         if (opening_request == 0) {
                 free(buffer);
@@ -128 +135 @@
         }
 
-        size_t actual_size = IPC_GET_ARG2(data_request_call);
-        size_t items = actual_size / 2;
+        size_t act_size = IPC_GET_ARG2(data_request_call);
 
         /* Copy the individual items. */
-        memcpy(usage_pages, buffer, items * sizeof(uint16_t));
-        memcpy(usages, buffer + items, items * sizeof(uint16_t));
-
-        if (actual_usage_count != NULL) {
-                *actual_usage_count = items;
+        memcpy(buf, buffer, act_size);
+//      memcpy(usages, buffer + items, items * sizeof(int32_t));
+
+        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(int dev_phone, size_t *size)
+{
+        if (dev_phone < 0) {
+                return EINVAL;
+        }
+
+        sysarg_t arg_size;
+        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE),
+            IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
+        if (rc == EOK) {
+                if (size != NULL) {
+                        *size = (size_t) arg_size;
+                }
+        }
+        return rc;
+}
+
+int usbhid_dev_get_report_descriptor(int dev_phone, uint8_t *buf, size_t size, 
+    size_t *actual_size)
+{
+        if (dev_phone < 0) {
+                return EINVAL;
+        }
+        if ((buf == NULL)) {
+                return ENOMEM;
+        }
+        if (size == 0) {
+                return EINVAL;
+        }
+
+        aid_t opening_request = async_send_1(dev_phone,
+            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
+            NULL);
+        if (opening_request == 0) {
+                return ENOMEM;
+        }
+
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(dev_phone, buf, size,
+            &data_request_call);
+        if (data_request == 0) {
+                async_wait_for(opening_request, NULL);
+                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;
         }
 

uspace/lib/usbhid/src/hidreport.c

@@ -164 +164 @@
 
 int usb_hid_process_report_descriptor(usb_device_t *dev, 
-    usb_hid_report_t *report)
+    usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size)
 {
         if (dev == NULL || report == NULL) {
@@ -172 +172 @@
         }
         
-        uint8_t *report_desc = NULL;
-        size_t report_size;
-        
-        int rc = usb_hid_get_report_descriptor(dev, &report_desc, 
-            &report_size);
+//      uint8_t *report_desc = NULL;
+//      size_t report_size;
+        
+        int rc = usb_hid_get_report_descriptor(dev, report_desc, report_size);
         
         if (rc != EOK) {
                 usb_log_error("Problem with getting Report descriptor: %s.\n",
                     str_error(rc));
-                if (report_desc != NULL) {
-                        free(report_desc);
+                if (*report_desc != NULL) {
+                        free(*report_desc);
+                        *report_desc = NULL;
                 }
                 return rc;
         }
         
-        assert(report_desc != NULL);
-        
-        rc = usb_hid_parse_report_descriptor(report, report_desc, report_size);
+        assert(*report_desc != NULL);
+        
+        rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size);
         if (rc != EOK) {
                 usb_log_error("Problem parsing Report descriptor: %s.\n",
                     str_error(rc));
-                free(report_desc);
+                free(*report_desc);
+                *report_desc = NULL;
                 return rc;
         }
         
         usb_hid_descriptor_print(report);
-        free(report_desc);
         
         return EOK;