Changeset ae3a941 in mainline for uspace/lib/usbhid

Timestamp:

2018-02-26T16:51:40Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

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

Children:

e773f58

Parents:

3692678

Message:

usb: cstyle

Location:

uspace/lib/usbhid/src

Files:

• hidparser.c (modified) (29 diffs)
• hidpath.c (modified) (20 diffs)
• hidreport.c (modified) (2 diffs)
• hidreq.c (modified) (15 diffs)

uspace/lib/usbhid/src/hidparser.c

@@ -52 +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);
 
 
@@ -76 +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)
 {
@@ -100 +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)
 {
@@ -117 +117 @@
                 return 0;
         } else {
-                return ((report_des->bit_length + 7) / 8) ;
+                return ((report_des->bit_length + 7) / 8);
         }
 }
@@ -129 +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;
@@ -146 +146 @@
         }
 
-        report_des = usb_hid_report_find_description(report, *report_id, 
+        report_des = usb_hid_report_find_description(report, *report_id,
             type);
 
@@ -158 +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 -
@@ -174 +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;
 }
@@ -214 +214 @@
         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))));
+                resolution = 1;
+        } else {
+                resolution = (item->logical_maximum - item->logical_minimum) /
+                    ((item->physical_maximum - item->physical_minimum) *
+                    (usb_pow(10, (item->unit_exponent))));
         }
 
@@ -255 +255 @@
         }
 
-        return (int) (((value - item->logical_minimum) / resolution) + 
+        return (int) (((value - item->logical_minimum) / resolution) +
             item->physical_minimum);
 }
@@ -262 +262 @@
 /* OUTPUT API */
 
-/** 
+/**
  * Allocates output report buffer for output report
  *
@@ -270 +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)
 {
@@ -322 +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)
 {
@@ -329 +329 @@
         int length;
         int32_t tmp_value;
-        
+
         if (report == NULL) {
                 return EINVAL;
@@ -339 +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;
@@ -348 +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", 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
@@ -364 +364 @@
                         value = value << shift;
                         value = value & (((1 << length) - 1) << shift);
-                        
+
                         uint8_t mask = 0;
                         mask = 0xff - (((1 << length) - 1) << shift);
@@ -376 +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;
 
@@ -407 +407 @@
                 report_item->value = 0;
         }
-        
+
         return EOK;
 }
@@ -418 +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)
 {
@@ -430 +430 @@
         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);
@@ -467 +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));
@@ -485 +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.
@@ -491 +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;
@@ -511 +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);
 
@@ -553 +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) {
@@ -561 +561 @@
                 } else {
                         report_it = report_des->reports_link.next;
-                }       
+                }
         } else {
                 report_it = report->reports.head.next;
@@ -567 +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);
 
@@ -594 +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)
 {
@@ -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);
         
         /*
@@ -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)
 {

uspace/lib/usbhid/src/hidreq.c

@@ -65 +65 @@
                 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;
-        
+
+        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.");
-        
+
         rc = usb_control_request_set(ctrl_pipe,
             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
@@ -93 +93 @@
                 return rc;
         }
-        
+
         return EOK;
 }
@@ -115 +115 @@
                 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()).
-         */
-        
+
+        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;
 }
@@ -163 +163 @@
                 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()).
-         */
-        
+
+        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)
 {
@@ -218 +218 @@
                 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()).
-         */
-        
+
+        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.");
-        
-        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_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)
 {
@@ -269 +269 @@
                 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;     
+
+        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.",
-                        actual_size);
+                    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.");
-                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.",
-                        actual_size);
+                    actual_size);
                 return ELIMIT;
         }
-        
+
         *duration = buffer[0];
-        
+
         return EOK;
 }