Changes in uspace/drv/usbhid/usbhid.c [faa44e58:8fb45e08] in mainline

File:

• uspace/drv/usbhid/usbhid.c (modified) (14 diffs)

uspace/drv/usbhid/usbhid.c

@@ -63 +63 @@
 static const int USB_HID_MAX_SUBDRIVERS = 10;
 
-static fibril_local bool report_received;
+/** @todo What happens if this is not fibril local? */
+//static fibril_local bool report_number;
 
 /*----------------------------------------------------------------------------*/
@@ -203 +204 @@
         
         usb_log_debug("Compare flags: %d\n", mapping->compare);
-        size_t size = usb_hid_report_input_length(hid_dev->report, usage_path, 
-            mapping->compare);
+//      size_t size = usb_hid_report_size(hid_dev->report, 0, 
+//          USB_HID_REPORT_TYPE_INPUT);
+        size_t size = 0;
+        usb_hid_report_field_t *field = usb_hid_report_get_sibling (hid_dev->report,
+                NULL, usage_path, mapping->compare, USB_HID_REPORT_TYPE_INPUT);
+        while(field != NULL) {
+                size++;
+                field = usb_hid_report_get_sibling (hid_dev->report,
+                                        field, usage_path, mapping->compare, 
+                            USB_HID_REPORT_TYPE_INPUT);
+        }
+        
         usb_log_debug("Size of the input report: %zuB\n", size);
-        
         usb_hid_report_path_free(usage_path);
         
@@ -225 +235 @@
         }
         
-        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(count * 
+        // add one generic HID subdriver per device
+        
+        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) * 
             sizeof(usb_hid_subdriver_t));
         if (hid_dev->subdrivers == NULL) {
@@ -238 +250 @@
         }
         
-        hid_dev->subdriver_count = count;
+        hid_dev->subdrivers[count].init = usb_generic_hid_init;
+        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
+        hid_dev->subdrivers[count].deinit = NULL;
+        hid_dev->subdrivers[count].poll_end = NULL;
+        
+        hid_dev->subdriver_count = count + 1;
         
         return EOK;
@@ -298 +315 @@
                 
                 if (matched) {
+                        usb_log_debug("Subdriver matched.\n");
                         subdrivers[count++] = &mapping->subdriver;
                 }
@@ -339 +357 @@
 /*----------------------------------------------------------------------------*/
 
+static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
+{
+        assert(hid_dev != NULL && hid_dev->report != NULL);
+        
+        uint8_t report_id = 0;
+        size_t size;/* = usb_hid_report_byte_size(hid_dev->report, report_id, 
+            USB_HID_REPORT_TYPE_INPUT);*/
+        
+        size_t max_size = 0;
+        
+        do {
+                size = usb_hid_report_byte_size(hid_dev->report, report_id, 
+                    USB_HID_REPORT_TYPE_INPUT);
+                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
+                max_size = (size > max_size) ? size : max_size;
+                report_id = usb_hid_get_next_report_id(hid_dev->report, 
+                    report_id, USB_HID_REPORT_TYPE_INPUT);
+        } while (report_id != 0);
+        
+        usb_log_debug("Max size of input report: %zu\n", max_size);
+        
+        hid_dev->max_input_report_size = max_size;
+        assert(hid_dev->input_report == NULL);
+        
+        hid_dev->input_report = malloc(max_size);
+        if (hid_dev->input_report == NULL) {
+                return ENOMEM;
+        }
+        memset(hid_dev->input_report, 0, max_size);
+        
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
 usb_hid_dev_t *usb_hid_new(void)
 {
@@ -393 +446 @@
         /* Get the report descriptor and parse it. */
         rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, 
-            hid_dev->report);
+            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
         
         bool fallback = false;
@@ -457 +510 @@
                         if (hid_dev->subdrivers[i].init != NULL) {
                                 usb_log_debug("Initializing subdriver %d.\n",i);
-                                rc = hid_dev->subdrivers[i].init(hid_dev);
+                                rc = hid_dev->subdrivers[i].init(hid_dev,
+                                    &hid_dev->subdrivers[i].data);
                                 if (rc != EOK) {
                                         usb_log_warning("Failed to initialize"
@@ -473 +527 @@
         }
         
+        // save max input report size and allocate space for the report
+        rc = usb_hid_init_report(hid_dev);
+        if (rc != EOK) {
+                usb_log_error("Failed to initialize input report buffer.\n");
+        }
+        
         return rc;
 }
@@ -490 +550 @@
         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
         
-        int allocated = (hid_dev->input_report != NULL);
-        
-        if (!allocated
-            || hid_dev->input_report_size < buffer_size) {
-                uint8_t *input_old = hid_dev->input_report;
-                uint8_t *input_new = (uint8_t *)malloc(buffer_size);
-                
-                if (input_new == NULL) {
-                        usb_log_error("Failed to allocate space for input "
-                            "buffer. This event may not be reported\n");
-                        memset(hid_dev->input_report, 0, 
-                            hid_dev->input_report_size);
-                } else {
-                        memcpy(input_new, input_old, 
-                            hid_dev->input_report_size);
-                        hid_dev->input_report = input_new;
-                        if (allocated) {
-                                free(input_old);
-                        }
-                        usb_hid_new_report();
-                }
-        }
+//      int allocated = (hid_dev->input_report != NULL);
+        assert(hid_dev->input_report != NULL);
+        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
+            hid_dev->max_input_report_size, buffer_size);
+        assert(hid_dev->max_input_report_size >= buffer_size);
+        
+//      if (/*!allocated*/
+//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
+//              uint8_t *input_old = hid_dev->input_report;
+//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
+                
+//              if (input_new == NULL) {
+//                      usb_log_error("Failed to allocate space for input "
+//                          "buffer. This event may not be reported\n");
+//                      memset(hid_dev->input_report, 0, 
+//                          hid_dev->input_report_size);
+//              } else {
+//                      memcpy(input_new, input_old, 
+//                          hid_dev->input_report_size);
+//                      hid_dev->input_report = input_new;
+//                      if (allocated) {
+//                              free(input_old);
+//                      }
+//                      usb_hid_new_report();
+//              }
+//      }
         
         /*! @todo This should probably be atomic. */
         memcpy(hid_dev->input_report, buffer, buffer_size);
         hid_dev->input_report_size = buffer_size;
+        usb_hid_new_report(hid_dev);
         
         bool cont = false;
@@ -522 +587 @@
         for (i = 0; i < hid_dev->subdriver_count; ++i) {
                 if (hid_dev->subdrivers[i].poll != NULL
-                    && hid_dev->subdrivers[i].poll(hid_dev, buffer, 
-                    buffer_size)) {
+                    && hid_dev->subdrivers[i].poll(hid_dev, 
+                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
                         cont = true;
                 }
@@ -546 +611 @@
         for (i = 0; i < hid_dev->subdriver_count; ++i) {
                 if (hid_dev->subdrivers[i].poll_end != NULL) {
-                        hid_dev->subdrivers[i].poll_end(hid_dev, reason);
+                        hid_dev->subdrivers[i].poll_end(hid_dev,
+                            hid_dev->subdrivers[i].data, reason);
                 }
         }
@@ -590 +656 @@
 /*----------------------------------------------------------------------------*/
 
-void usb_hid_new_report(void)
-{
-        report_received = false;
-}
-
-/*----------------------------------------------------------------------------*/
-
-void usb_hid_report_received(void)
-{
-        report_received = true;
-}
-
-/*----------------------------------------------------------------------------*/
-
-bool usb_hid_report_ready(void)
-{
-        return !report_received;
-}
+void usb_hid_new_report(usb_hid_dev_t *hid_dev)
+{
+        ++hid_dev->report_nr;
+}
+
+/*----------------------------------------------------------------------------*/
+
+int usb_hid_report_number(usb_hid_dev_t *hid_dev)
+{
+        return hid_dev->report_nr;
+}
+
+/*----------------------------------------------------------------------------*/
+
+//void usb_hid_report_received(void)
+//{
+//      ++report_number;
+//}
+
+/*----------------------------------------------------------------------------*/
+
+//bool usb_hid_report_ready(void)
+//{
+//      return !report_received;
+//}
 
 /*----------------------------------------------------------------------------*/
@@ -627 +700 @@
         for (i = 0; i < (*hid_dev)->subdriver_count; ++i) {
                 if ((*hid_dev)->subdrivers[i].deinit != NULL) {
-                        (*hid_dev)->subdrivers[i].deinit(*hid_dev);
+                        (*hid_dev)->subdrivers[i].deinit(*hid_dev,
+                            (*hid_dev)->subdrivers[i].data);
                 }
         }