Changeset df6ded8 in mainline for uspace/lib/usbhid/src

Timestamp:

2018-02-28T16:37:50Z (8 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

1b20da0

Parents:

f5e5f73 (diff), b2dca8de (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.

git-author:

Jakub Jermar <jakub@…> (2018-02-28 16:06:42)

git-committer:

Jakub Jermar <jakub@…> (2018-02-28 16:37:50)

Message:

Merge github.com:helenos-xhci-team/helenos

This commit merges support for USB 3 and generally refactors, fixes,
extends and cleans up the existing USB framework.

Notable additions and features:

• new host controller driver has been implemented to control various xHC models (among others, NEC Renesas uPD720200)
• isochronous data transfer mode
• support for explicit USB device removal
• USB tablet driver

Location:

uspace/lib/usbhid/src

Files:

• hiddescriptor.c (modified) (6 diffs)
• hidparser.c (modified) (32 diffs)
• hidpath.c (modified) (20 diffs)
• hidreport.c (modified) (8 diffs)
• hidreq.c (modified) (13 diffs)

uspace/lib/usbhid/src/hiddescriptor.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Matej Klonfar
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -176 +177 @@
 
         if(report_item->usages_count > 0){
-                usages = malloc(sizeof(int32_t) * report_item->usages_count);
+                usages = malloc(sizeof(uint32_t) * report_item->usages_count);
                 memcpy(usages, report_item->usages, sizeof(int32_t) *
                                 report_item->usages_count); 
@@ -247 +248 @@
                 field->size = report_item->size;
 
-                if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
-                        int offset = report_item->offset + report_item->size * i;
-                        int field_offset = (offset/8)*8 + (offset/8 + 1) * 8 - 
-                                offset - report_item->size;
-                        if(field_offset < 0) {
-                                field->offset = 0;
-                        }
-                        else {
-                                field->offset = field_offset;
-                        }
-                }
-                else {
-                        field->offset = report_item->offset + (i * report_item->size);
-                }
-
+                field->offset = report_item->offset + (i * report_item->size);
 
                 if(report->use_report_ids != 0) {
@@ -896 +883 @@
 {
         if(list == NULL || list_empty(list)) {
-            usb_log_debug("\tempty\n");
+            usb_log_debug("\tempty");
             return;
         }
@@ -902 +889 @@
         list_foreach(*list, ritems_link, usb_hid_report_field_t,
             report_item) {
-                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
-                usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
-                usb_log_debug("\t\tLOGMIN: %d\n",
+                usb_log_debug("\t\tOFFSET: %u", report_item->offset);
+                usb_log_debug("\t\tSIZE: %zu", report_item->size);
+                usb_log_debug("\t\tLOGMIN: %d",
                         report_item->logical_minimum);
-                usb_log_debug("\t\tLOGMAX: %d\n",
+                usb_log_debug("\t\tLOGMAX: %d",
                         report_item->logical_maximum);
-                usb_log_debug("\t\tPHYMIN: %d\n",
+                usb_log_debug("\t\tPHYMIN: %d",
                         report_item->physical_minimum);
-                usb_log_debug("\t\tPHYMAX: %d\n",
+                usb_log_debug("\t\tPHYMAX: %d",
                         report_item->physical_maximum);
-                usb_log_debug("\t\ttUSAGEMIN: %X\n",
+                usb_log_debug("\t\ttUSAGEMIN: %X",
                         report_item->usage_minimum);
-                usb_log_debug("\t\tUSAGEMAX: %X\n",
+                usb_log_debug("\t\tUSAGEMAX: %X",
                                report_item->usage_maximum);
-                usb_log_debug("\t\tUSAGES COUNT: %zu\n",
+                usb_log_debug("\t\tUSAGES COUNT: %zu",
                         report_item->usages_count);
 
-                usb_log_debug("\t\tVALUE: %X\n", report_item->value);
-                usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
-                usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
+                usb_log_debug("\t\tVALUE: %X", report_item->value);
+                usb_log_debug("\t\ttUSAGE: %X", report_item->usage);
+                usb_log_debug("\t\tUSAGE PAGE: %X", report_item->usage_page);
 
                 usb_hid_print_usage_path(report_item->collection_path);
-
-                usb_log_debug("\n");
         }
 }
@@ -943 +928 @@
         list_foreach(report->reports, reports_link,
             usb_hid_report_description_t, report_des) {
-                usb_log_debug("Report ID: %d\n", report_des->report_id);
-                usb_log_debug("\tType: %d\n", report_des->type);
-                usb_log_debug("\tLength: %zu\n", report_des->bit_length);
-                usb_log_debug("\tB Size: %zu\n",
+                usb_log_debug("Report ID: %d", report_des->report_id);
+                usb_log_debug("\tType: %d", report_des->type);
+                usb_log_debug("\tLength: %zu", report_des->bit_length);
+                usb_log_debug("\tB Size: %zu",
                         usb_hid_report_byte_size(report,
                                 report_des->report_id,
                                 report_des->type));
-                usb_log_debug("\tItems: %zu\n", report_des->item_length);
+                usb_log_debug("\tItems: %zu", report_des->item_length);
 
                 usb_hid_descriptor_print_list(&report_des->report_items);

uspace/lib/usbhid/src/hidparser.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2011 Matej Klonfar
+ * Copyright (c) 2018 Ondrej Hlavaty
  * All rights reserved.
  *
@@ -40 +41 @@
 #include <usb/debug.h>
 #include <assert.h>
+#include <bitops.h>
+#include <macros.h>
 
 
@@ -49 +52 @@
 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
 
-uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 
-        int32_t value);
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
+    int32_t value);
 
 
@@ -73 +76 @@
  *
  * @param parser Opaque report parser structure
- * @param report_id 
+ * @param report_id
  * @param type
  * @return Number of items in specified report
  */
-size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id, 
+size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
     usb_hid_report_type_t type)
 {
@@ -97 +100 @@
  *
  * @param parser Opaque report parser structure
- * @param report_id 
+ * @param report_id
  * @param type
  * @return Number of items in specified report
  */
-size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, 
+size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
     usb_hid_report_type_t type)
 {
@@ -114 +117 @@
                 return 0;
         } else {
-                return ((report_des->bit_length + 7) / 8) ;
+                return ((report_des->bit_length + 7) / 8);
         }
 }
@@ -126 +129 @@
  * @param data Data for the report.
  * @return Error code.
- */ 
-errno_t usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, 
+ */
+errno_t usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
     size_t size, uint8_t *report_id)
 {
         usb_hid_report_description_t *report_des;
         usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
-        
+
         if (report == NULL) {
                 return EINVAL;
@@ -143 +146 @@
         }
 
-        report_des = usb_hid_report_find_description(report, *report_id, 
+        report_des = usb_hid_report_find_description(report, *report_id,
             type);
 
@@ -155 +158 @@
 
                 if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
-                        
+
                         if (USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
                                 /* array */
-                                item->value = 
-                                        usb_hid_translate_data(item, data);
-                                
+                                item->value =
+                                    usb_hid_translate_data(item, data);
+
                                 item->usage = USB_HID_EXTENDED_USAGE(
                                     item->usages[item->value -
                                     item->physical_minimum]);
 
-                                item->usage_page = 
+                                item->usage_page =
                                     USB_HID_EXTENDED_USAGE_PAGE(
                                     item->usages[item->value -
@@ -171 +174 @@
 
                                 usb_hid_report_set_last_item(
-                                    item->collection_path, 
-                                    USB_HID_TAG_CLASS_GLOBAL, 
+                                    item->collection_path,
+                                    USB_HID_TAG_CLASS_GLOBAL,
                                     item->usage_page);
 
                                 usb_hid_report_set_last_item(
-                                    item->collection_path, 
+                                    item->collection_path,
                                     USB_HID_TAG_CLASS_LOCAL, item->usage);
                         } else {
                                 /* variable item */
-                                item->value = usb_hid_translate_data(item, 
+                                item->value = usb_hid_translate_data(item,
                                     data);
                         }
                 }
         }
-        
+
         return EOK;
 }
@@ -199 +202 @@
 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data)
 {
-        int resolution;
-        int offset;
-        int part_size;
-        
-        int32_t value = 0;
-        int32_t mask = 0;
-        const uint8_t *foo = 0;
-
         /* now only short tags are allowed */
         if (item->size > 32) {
@@ -214 +209 @@
         if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
                 item->physical_minimum = item->logical_minimum;
-                item->physical_maximum = item->logical_maximum;                 
-        }
-        
-
+                item->physical_maximum = item->logical_maximum;
+        }
+
+        int resolution;
         if (item->physical_maximum == item->physical_minimum) {
-            resolution = 1;
-        } else {
-            resolution = (item->logical_maximum - item->logical_minimum) / 
-                ((item->physical_maximum - item->physical_minimum) * 
-                (usb_pow(10, (item->unit_exponent))));
-        }
-
-        offset = item->offset;
-        // FIXME
-        if ((size_t) (offset / 8) != (size_t) ((offset+item->size - 1) / 8)) {
-                
-                part_size = 0;
-
-                size_t i = 0;
-                for (i = (size_t) (offset / 8);
-                    i <= (size_t) (offset + item->size - 1) / 8; i++) {
-                        if (i == (size_t) (offset / 8)) {
-                                /* the higher one */
-                                part_size = 8 - (offset % 8);
-                                foo = data + i;
-                                mask =  ((1 << (item->size - part_size)) - 1);
-                                value = (*foo & mask);
-                        } else if (i == ((offset + item->size - 1) / 8)) {
-                                /* the lower one */
-                                foo = data + i;
-                                mask = ((1 << (item->size - part_size)) - 1) <<
-                                    (8 - (item->size - part_size));
-
-                                value = (((*foo & mask) >> (8 - 
-                                    (item->size - part_size))) << part_size) + 
-                                    value;
-                        } else {
-                                value = (*(data + 1) << (part_size + 8)) +
-                                    value;
-                                part_size += 8;
-                        }
-                }
-        } else {                
-                foo = data + (offset / 8);
-                mask = ((1 << item->size) - 1) <<
-                    (8 - ((offset % 8) + item->size));
-                value = (*foo & mask) >> (8 - ((offset % 8) + item->size));
+                resolution = 1;
+        } else {
+                resolution = (item->logical_maximum - item->logical_minimum) /
+                    ((item->physical_maximum - item->physical_minimum) *
+                    (usb_pow(10, (item->unit_exponent))));
+        }
+
+        int32_t value = 0;
+
+        /* First, skip all bytes we don't care */
+        data += item->offset / 8;
+
+        int bits = item->size;
+        int taken = 0;
+
+        /* Than we take the higher bits from the LSB */
+        const unsigned bit_offset = item->offset % 8;
+        const int lsb_bits = min(bits, 8);
+
+        value |= (*data >> bit_offset) & BIT_RRANGE(uint8_t, lsb_bits);
+        bits -= lsb_bits;
+        taken += lsb_bits;
+        data++;
+
+        /* Then there may be bytes, which we take as a whole. */
+        while (bits > 8) {
+                value |= *data << taken;
+                taken += 8;
+                bits -= 8;
+                data++;
+        }
+
+        /* And, finally, lower bits from HSB. */
+        if (bits > 0) {
+                value |= (*data & BIT_RRANGE(uint8_t, bits)) << taken;
         }
 
@@ -267 +255 @@
         }
 
-        return (int) (((value - item->logical_minimum) / resolution) + 
+        return (int) (((value - item->logical_minimum) / resolution) +
             item->physical_minimum);
 }
@@ -274 +262 @@
 /* OUTPUT API */
 
-/** 
+/**
  * Allocates output report buffer for output report
  *
@@ -282 +270 @@
  * @return Returns allocated output buffer for specified output
  */
-uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, 
+uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
     uint8_t report_id)
 {
@@ -334 +322 @@
  * @return Error code
  */
-errno_t usb_hid_report_output_translate(usb_hid_report_t *report, 
+errno_t usb_hid_report_output_translate(usb_hid_report_t *report,
     uint8_t report_id, uint8_t *buffer, size_t size)
 {
@@ -341 +329 @@
         int length;
         int32_t tmp_value;
-        
+
         if (report == NULL) {
                 return EINVAL;
@@ -351 +339 @@
 
         usb_hid_report_description_t *report_des;
-        report_des = usb_hid_report_find_description(report, report_id, 
+        report_des = usb_hid_report_find_description(report, report_id,
             USB_HID_REPORT_TYPE_OUTPUT);
-        
+
         if (report_des == NULL) {
                 return EINVAL;
@@ -360 +348 @@
         list_foreach(report_des->report_items, ritems_link,
             usb_hid_report_field_t, report_item) {
-                value = usb_hid_translate_data_reverse(report_item, 
+                value = usb_hid_translate_data_reverse(report_item,
                     report_item->value);
 
                 offset = report_des->bit_length - report_item->offset - 1;
                 length = report_item->size;
-                
-                usb_log_debug("\ttranslated value: %x\n", value);
+
+                usb_log_debug("\ttranslated value: %x", value);
 
                 if ((offset / 8) == ((offset + length - 1) / 8)) {
-                        if (((size_t) (offset / 8) >= size) || 
+                        if (((size_t) (offset / 8) >= size) ||
                             ((size_t) (offset + length - 1) / 8) >= size) {
                                 break; // TODO ErrorCode
@@ -376 +364 @@
                         value = value << shift;
                         value = value & (((1 << length) - 1) << shift);
-                        
+
                         uint8_t mask = 0;
                         mask = 0xff - (((1 << length) - 1) << shift);
@@ -388 +376 @@
                                 if (i == (offset / 8)) {
                                         tmp_value = value;
-                                        tmp_value = tmp_value & 
+                                        tmp_value = tmp_value &
                                             ((1 << (8 - (offset % 8))) - 1);
 
                                         tmp_value = tmp_value << (offset % 8);
-                                        
+
                                         mask = ~(((1 << (8 - (offset % 8))) - 1)
                                             << (offset % 8));
 
-                                        buffer[i] = (buffer[i] & mask) | 
+                                        buffer[i] = (buffer[i] & mask) |
                                             tmp_value;
                                 } else if (i == ((offset + length - 1) / 8)) {
-                                        
-                                        value = value >> (length - 
+
+                                        value = value >> (length -
                                             ((offset + length) % 8));
 
-                                        value = value & ((1 << (length - 
+                                        value = value & ((1 << (length -
                                             ((offset + length) % 8))) - 1);
-                                        
-                                        mask = (1 << (length - 
+
+                                        mask = (1 << (length -
                                             ((offset + length) % 8))) - 1;
 
@@ -419 +407 @@
                 report_item->value = 0;
         }
-        
+
         return EOK;
 }
@@ -430 +418 @@
  * @return ranslated value
  */
-uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 
+uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
     int value)
 {
@@ -437 +425 @@
 
         if (USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
-                ret = item->logical_minimum;
+                return item->logical_minimum;
         }
 
         if ((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
                 item->physical_minimum = item->logical_minimum;
-                item->physical_maximum = item->logical_maximum;                 
-        }
-        
+                item->physical_maximum = item->logical_maximum;
+        }
+
         /* variable item */
         if (item->physical_maximum == item->physical_minimum) {
-            resolution = 1;
-        } else {
-            resolution = (item->logical_maximum - item->logical_minimum) /
-                ((item->physical_maximum - item->physical_minimum) *
-                (usb_pow(10, (item->unit_exponent))));
-        }
-
-        ret = ((value - item->physical_minimum) * resolution) + 
+                resolution = 1;
+        } else {
+                resolution = (item->logical_maximum - item->logical_minimum) /
+                    ((item->physical_maximum - item->physical_minimum) *
+                    (usb_pow(10, (item->unit_exponent))));
+        }
+
+        ret = ((value - item->physical_minimum) * resolution) +
             item->logical_minimum;
 
         usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), "
-            "ret(%x)\n", value, resolution, item->physical_minimum, 
+            "ret(%x)\n", value, resolution, item->physical_minimum,
             item->logical_minimum, ret);
-        
+
         if ((item->logical_minimum < 0) || (item->logical_maximum < 0)) {
                 return USB_HID_INT32_TO_UINT32(ret, item->size);
@@ -479 +467 @@
 {
         usb_hid_report_item_t *new_report_item;
-        
+
         if (!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
                 return NULL;
-        }                                       
+        }
         memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
         link_initialize(&(new_report_item->link));
@@ -497 +485 @@
  * @param field Current field. If NULL is given, the first one in the report
  * is returned. Otherwise the next one i nthe list is returned.
- * @param path Usage path specifying which fields wa are interested in. 
+ * @param path Usage path specifying which fields wa are interested in.
  * @param flags Flags defining mode of usage paths comparison
  * @param type Type of report we search.
@@ -503 +491 @@
  * @retval Pointer to the founded report structure when founded
  */
-usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, 
-    usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags, 
+usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
+    usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
     usb_hid_report_type_t type)
 {
-        usb_hid_report_description_t *report_des = 
+        usb_hid_report_description_t *report_des =
             usb_hid_report_find_description(report, path->report_id, type);
 
         link_t *field_it;
-        
+
         if (report_des == NULL) {
                 return NULL;
@@ -523 +511 @@
 
         while (field_it != &report_des->report_items.head) {
-                field = list_get_instance(field_it, usb_hid_report_field_t, 
+                field = list_get_instance(field_it, usb_hid_report_field_t,
                     ritems_link);
 
@@ -565 +553 @@
         usb_hid_report_description_t *report_des;
         link_t *report_it;
-        
+
         if (report_id > 0) {
-                report_des = usb_hid_report_find_description(report, report_id, 
+                report_des = usb_hid_report_find_description(report, report_id,
                     type);
                 if (report_des == NULL) {
@@ -573 +561 @@
                 } else {
                         report_it = report_des->reports_link.next;
-                }       
+                }
         } else {
                 report_it = report->reports.head.next;
@@ -579 +567 @@
 
         while (report_it != &report->reports.head) {
-                report_des = list_get_instance(report_it, 
+                report_des = list_get_instance(report_it,
                     usb_hid_report_description_t, reports_link);
 
@@ -606 +594 @@
                 return;
         }
-        
+
         report_item->usages_count = 0;
         memset(report_item->usages, 0, USB_HID_MAX_USAGES);
-        
+
         report_item->extended_usage_page = 0;
         report_item->usage_minimum = 0;

uspace/lib/usbhid/src/hidpath.c

@@ -73 +73 @@
  * @return Error code
  */
-errno_t usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 
-                                    int32_t usage_page, int32_t usage)
-{       
-        usb_hid_report_usage_path_t *item
-                = malloc(sizeof(usb_hid_report_usage_path_t));
+errno_t usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
+    int32_t usage_page, int32_t usage)
+{
+        usb_hid_report_usage_path_t *item =
+            malloc(sizeof(usb_hid_report_usage_path_t));
 
         if (item == NULL) {
@@ -87 +87 @@
         item->usage_page = usage_page;
         item->flags = 0;
-        
+
         list_append (&item->rpath_items_link, &usage_path->items);
         usage_path->depth++;
@@ -96 +96 @@
 /**
  * Removes last item from the usage path structure
- * @param usage_path 
+ * @param usage_path
  * @return void
  */
@@ -103 +103 @@
         link_t *item_link;
         usb_hid_report_usage_path_t *item;
-        
-        if(!list_empty(&usage_path->items)){
+
+        if (!list_empty(&usage_path->items)) {
                 item_link = list_last(&usage_path->items);
                 item = list_get_instance(item_link,
@@ -124 +124 @@
 {
         usb_hid_report_usage_path_t *item;
-        
-        if(!list_empty(&usage_path->items)){
+
+        if (!list_empty(&usage_path->items)) {
                 item = list_get_instance(list_last(&usage_path->items),
-                        usb_hid_report_usage_path_t, rpath_items_link);
+                    usb_hid_report_usage_path_t, rpath_items_link);
 
                 memset(item, 0, sizeof(usb_hid_report_usage_path_t));
@@ -143 +143 @@
  * @return void
  */
-void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, 
-                                  int32_t tag, int32_t data)
+void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path,
+    int32_t tag, int32_t data)
 {
         usb_hid_report_usage_path_t *item;
-        
-        if(!list_empty(&usage_path->items)){
+
+        if (!list_empty(&usage_path->items)) {
                 item = list_get_instance(list_last(&usage_path->items),
                      usb_hid_report_usage_path_t, rpath_items_link);
 
-                switch(tag) {
-                        case USB_HID_TAG_CLASS_GLOBAL:
-                                item->usage_page = data;
-                                break;
-                        case USB_HID_TAG_CLASS_LOCAL:
-                                item->usage = data;
-                                break;
-                }
-        }
-        
-}
-
-
-/**
- *
- *
- *
- *
- */
+                switch (tag) {
+                case USB_HID_TAG_CLASS_GLOBAL:
+                        item->usage_page = data;
+                        break;
+                case USB_HID_TAG_CLASS_LOCAL:
+                        item->usage = data;
+                        break;
+                }
+        }
+}
+
 void usb_hid_print_usage_path(usb_hid_report_path_t *path)
 {
-        usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id);
-        usb_log_debug("\tLENGTH: %d\n", path->depth);
+        usb_log_debug("USAGE_PATH FOR RId(%d):", path->report_id);
+        usb_log_debug("\tLENGTH: %d", path->depth);
 
         list_foreach(path->items, rpath_items_link,
             usb_hid_report_usage_path_t, path_item) {
 
-                usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
-                usb_log_debug("\tUSAGE: %X\n", path_item->usage);
-                usb_log_debug("\tFLAGS: %d\n", path_item->flags);
+                usb_log_debug("\tUSAGE_PAGE: %X", path_item->usage_page);
+                usb_log_debug("\tUSAGE: %X", path_item->usage);
+                usb_log_debug("\tFLAGS: %d", path_item->flags);
         }
 }
@@ -199 +191 @@
         usb_hid_report_usage_path_t *report_item;
         usb_hid_report_usage_path_t *path_item;
-        
+
         link_t *report_link;
         link_t *path_link;
-        
+
         int only_page;
-        
+
         if (report_path->report_id != path->report_id) {
                 if (path->report_id != 0) {
@@ -210 +202 @@
                 }
         }
-        
+
         // Empty path match all others
         if (path->depth == 0) {
                 return 0;
         }
-        
+
         if ((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0) {
                 flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY;
         }
-        
+
         switch (flags) {
         /* Path is somewhere in report_path */
@@ -226 +218 @@
                         return 1;
                 }
-                
+
                 path_link = list_first(&path->items);
                 path_item = list_get_instance(path_link,
                     usb_hid_report_usage_path_t, rpath_items_link);
-                
+
                 list_foreach(report_path->items, rpath_items_link,
                     usb_hid_report_usage_path_t, report_item) {
                         if (USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
                             path_item->usage_page)) {
-                                
+
                                 if (only_page == 0) {
                                         if (USB_HID_SAME_USAGE(report_item->usage,
@@ -245 +237 @@
                         }
                 }
-                
+
                 return 1;
                 break;
-        
+
         /* The paths must be identical */
         case USB_HID_PATH_COMPARE_STRICT:
@@ -255 +247 @@
                 }
                 /* Fallthrough */
-        
+
         /* Path is prefix of the report_path */
         case USB_HID_PATH_COMPARE_BEGIN:
                 report_link = report_path->items.head.next;
                 path_link = path->items.head.next;
-                
+
                 while ((report_link != &report_path->items.head) &&
                     (path_link != &path->items.head)) {
-                        
+
                         report_item = list_get_instance(report_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
-                        
+
                         path_item = list_get_instance(path_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
-                        
+
                         if (!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
                             path_item->usage_page) || ((only_page == 0) &&
@@ -280 +272 @@
                         }
                 }
-                
+
                 if ((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
                     (path_link == &path->items.head)) ||
@@ -290 +282 @@
                 }
                 break;
-        
+
         /* Path is suffix of report_path */
         case USB_HID_PATH_COMPARE_END:
                 report_link = report_path->items.head.prev;
                 path_link = path->items.head.prev;
-                
+
                 if (list_empty(&path->items)) {
                         return 0;
                 }
-                
+
                 while ((report_link != &report_path->items.head) &&
                       (path_link != &path->items.head)) {
                         report_item = list_get_instance(report_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
-                        
+
                         path_item = list_get_instance(path_link,
                             usb_hid_report_usage_path_t, rpath_items_link);
-                        
+
                         if (!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
                             path_item->usage_page) || ((only_page == 0) &&
@@ -318 +310 @@
                         }
                 }
-                
+
                 if (path_link == &path->items.head) {
                         return 0;
@@ -325 +317 @@
                 }
                 break;
-        
+
         default:
                 return -1;
@@ -340 +332 @@
         usb_hid_report_path_t *path;
         path = malloc(sizeof(usb_hid_report_path_t));
-        if(path == NULL){
+        if (path == NULL) {
                 return NULL;
         }
@@ -363 +355 @@
         if (path == NULL)
                 return;
-        while(!list_empty(&path->items)){
+        while (!list_empty(&path->items)) {
                 usb_hid_report_remove_last_item(path);
         }
@@ -379 +371 @@
  */
 usb_hid_report_path_t *usb_hid_report_path_clone(
-        usb_hid_report_path_t *usage_path)
+    usb_hid_report_path_t *usage_path)
 {
         usb_hid_report_usage_path_t *new_path_item;
         usb_hid_report_path_t *new_usage_path = usb_hid_report_path ();
 
-        if(new_usage_path == NULL){
+        if (new_usage_path == NULL) {
                 return NULL;
         }
 
         new_usage_path->report_id = usage_path->report_id;
-        
-        if(list_empty(&usage_path->items)){
+
+        if (list_empty(&usage_path->items)) {
                 return new_usage_path;
         }
@@ -398 +390 @@
 
                 new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
-                if(new_path_item == NULL) {
+                if (new_path_item == NULL) {
                         return NULL;
                 }
-                
+
                 link_initialize(&new_path_item->rpath_items_link);
                 new_path_item->usage_page = path_item->usage_page;
-                new_path_item->usage = path_item->usage;                
-                new_path_item->flags = path_item->flags;                
-                
+                new_path_item->usage = path_item->usage;
+                new_path_item->flags = path_item->flags;
+
                 list_append(&new_path_item->rpath_items_link,
                     &new_usage_path->items);
@@ -423 +415 @@
  * @return Error code
  */
-errno_t usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, 
-        uint8_t report_id)
-{
-        if(path == NULL){
+errno_t usb_hid_report_path_set_report_id(usb_hid_report_path_t *path,
+    uint8_t report_id)
+{
+        if (path == NULL) {
                 return EINVAL;
         }

uspace/lib/usbhid/src/hidreport.c

@@ -71 +71 @@
         const uint8_t *d =
             usb_dp_get_nested_descriptor(&parser, &parser_data,
-                usb_device_descriptors(dev)->full_config);
+            usb_device_descriptors(dev)->full_config);
         
         /*
@@ -84 +84 @@
         
         if (d == NULL) {
-                usb_log_error("The %d. interface descriptor not found!\n",
+                usb_log_error("The %d. interface descriptor not found!",
                     usb_device_get_iface_number(dev));
                 return ENOENT;
@@ -104 +104 @@
         
         if (d == NULL) {
-                usb_log_fatal("No HID descriptor found!\n");
+                usb_log_fatal("No HID descriptor found!");
                 return ENOENT;
         }
@@ -130 +130 @@
         }
         
-        usb_log_debug("Getting Report descriptor, expected size: %u\n", length);
+        usb_log_debug("Getting Report descriptor, expected size: %u", length);
         
         /*
@@ -156 +156 @@
         *size = length;
         
-        usb_log_debug("Done.\n");
+        usb_log_debug("Done.");
         
         return EOK;
@@ -163 +163 @@
 
 
-errno_t usb_hid_process_report_descriptor(usb_device_t *dev, 
+errno_t usb_hid_process_report_descriptor(usb_device_t *dev,
     usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size)
 {
@@ -178 +178 @@
         
         if (rc != EOK) {
-                usb_log_error("Problem with getting Report descriptor: %s.\n",
+                usb_log_error("Problem with getting Report descriptor: %s.",
                     str_error(rc));
                 if (*report_desc != NULL) {
@@ -191 +191 @@
         rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size);
         if (rc != EOK) {
-                usb_log_error("Problem parsing Report descriptor: %s.\n",
+                usb_log_error("Problem parsing Report descriptor: %s.",
                     str_error(rc));
                 free(*report_desc);

uspace/lib/usbhid/src/hidreq.c

@@ -62 +62 @@
 {
         if (ctrl_pipe == NULL) {
-                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
-                return EINVAL;
-        }
-        
-        if (iface_no < 0) {
-                usb_log_warning("usbhid_req_set_report(): no interface given."
-                    "\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        errno_t rc;
-        
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+
+        errno_t rc;
+
         uint16_t value = 0;
         value |= (type << 8);
 
-        usb_log_debug("Sending Set Report request to the device.\n");
-        
+        usb_log_debug("Sending Set Report request to the device.");
+
         rc = usb_control_request_set(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
@@ -93 +93 @@
                 return rc;
         }
-        
+
         return EOK;
 }
@@ -112 +112 @@
 {
         if (ctrl_pipe == NULL) {
-                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
-                return EINVAL;
-        }
-        
-        if (iface_no < 0) {
-                usb_log_warning("usbhid_req_set_report(): no interface given."
-                    "\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+
         errno_t rc;
 
         usb_log_debug("Sending Set Protocol request to the device ("
             "protocol: %d, iface: %d).\n", protocol, iface_no);
-        
-        rc = usb_control_request_set(ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+
+        rc = usb_control_request_set(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_SET_PROTOCOL, protocol, iface_no, NULL, 0);
 
@@ -141 +141 @@
                 return rc;
         }
-        
+
         return EOK;
 }
@@ -160 +160 @@
 {
         if (ctrl_pipe == NULL) {
-                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
-                return EINVAL;
-        }
-        
-        if (iface_no < 0) {
-                usb_log_warning("usbhid_req_set_report(): no interface given."
-                    "\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+
         errno_t rc;
 
         usb_log_debug("Sending Set Idle request to the device ("
             "duration: %u, iface: %d).\n", duration, iface_no);
-        
+
         uint16_t value = duration << 8;
-        
+
         rc = usb_control_request_set(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
@@ -191 +191 @@
                 return rc;
         }
-        
+
         return EOK;
 }
@@ -203 +203 @@
  * @param[in][out] buffer Buffer for the report data.
  * @param[in] buf_size Size of the buffer (in bytes).
- * @param[out] actual_size Actual size of report received from the device 
+ * @param[out] actual_size Actual size of report received from the device
  *                         (in bytes).
  *
@@ -210 +210 @@
  * @return Other value inherited from function usb_control_request_set().
  */
-errno_t usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, 
-    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size, 
+errno_t usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no,
+    usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size,
     size_t *actual_size)
 {
         if (ctrl_pipe == NULL) {
-                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
-                return EINVAL;
-        }
-        
-        if (iface_no < 0) {
-                usb_log_warning("usbhid_req_set_report(): no interface given."
-                    "\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+
         errno_t rc;
 
         uint16_t value = 0;
         value |= (type << 8);
-        
-        usb_log_debug("Sending Get Report request to the device.\n");
-        
-        rc = usb_control_request_get(ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+
+        usb_log_debug("Sending Get Report request to the device.");
+
+        rc = usb_control_request_get(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_GET_REPORT, value, iface_no, buffer, buf_size,
             actual_size);
@@ -247 +247 @@
                 return rc;
         }
-        
+
         return EOK;
 }
@@ -262 +262 @@
  * @return Other value inherited from function usb_control_request_set().
  */
-errno_t usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, 
+errno_t usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no,
     usb_hid_protocol_t *protocol)
 {
         if (ctrl_pipe == NULL) {
-                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
-                return EINVAL;
-        }
-        
-        if (iface_no < 0) {
-                usb_log_warning("usbhid_req_set_report(): no interface given."
-                    "\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
-        errno_t rc;     
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+
+        errno_t rc;
 
         usb_log_debug("Sending Get Protocol request to the device ("
             "iface: %d).\n", iface_no);
-        
+
         uint8_t buffer[1];
         size_t actual_size = 0;
-        
-        rc = usb_control_request_get(ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
+
+        rc = usb_control_request_get(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
             USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size);
 
@@ -298 +298 @@
                 return rc;
         }
-        
+
         if (actual_size != 1) {
-                usb_log_warning("Wrong data size: %zu, expected: 1.\n",
-                        actual_size);
+                usb_log_warning("Wrong data size: %zu, expected: 1.",
+                    actual_size);
                 return ELIMIT;
         }
-        
+
         *protocol = buffer[0];
-        
+
         return EOK;
 }
@@ -320 +320 @@
  * @retval EOK if successful.
  * @retval EINVAL if no HID device is given.
- * @return Other value inherited from one of functions 
+ * @return Other value inherited from one of functions
  *         usb_pipe_start_session(), usb_pipe_end_session(),
  *         usb_control_request_set().
  */
-errno_t usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration)
-{
-        if (ctrl_pipe == NULL) {
-                usb_log_warning("usbhid_req_set_report(): no pipe given.\n");
-                return EINVAL;
-        }
-        
-        if (iface_no < 0) {
-                usb_log_warning("usbhid_req_set_report(): no interface given."
-                    "\n");
-                return EINVAL;
-        }
-        
-        /*
-         * No need for checking other parameters, as they are checked in
-         * the called function (usb_control_request_set()).
-         */
-        
+errno_t usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no,
+    uint8_t *duration)
+{
+        if (ctrl_pipe == NULL) {
+                usb_log_warning("usbhid_req_set_report(): no pipe given.");
+                return EINVAL;
+        }
+
+        if (iface_no < 0) {
+                usb_log_warning("usbhid_req_set_report(): no interface given."
+                    "\n");
+                return EINVAL;
+        }
+
+        /*
+         * No need for checking other parameters, as they are checked in
+         * the called function (usb_control_request_set()).
+         */
+
         errno_t rc;
 
         usb_log_debug("Sending Get Idle request to the device ("
             "iface: %d).\n", iface_no);
-        
+
         uint16_t value = 0;
         uint8_t buffer[1];
         size_t actual_size = 0;
-        
-        rc = usb_control_request_get(ctrl_pipe, 
-            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 
-            USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1, 
+
+        rc = usb_control_request_get(ctrl_pipe,
+            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
+            USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1,
             &actual_size);
 
@@ -361 +362 @@
                 return rc;
         }
-        
+
         if (actual_size != 1) {
-                usb_log_warning("Wrong data size: %zu, expected: 1.\n",
-                        actual_size);
+                usb_log_warning("Wrong data size: %zu, expected: 1.",
+                    actual_size);
                 return ELIMIT;
         }
-        
+
         *duration = buffer[0];
-        
+
         return EOK;
 }