Changeset eb393ad in mainline for uspace/lib/usb/src/hidparser.c

Timestamp:

2011-04-21T20:57:21Z (13 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

6513110

Parents:

36f737a (diff), c7c0984a (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:

Merged fixes from maklf

File:

• uspace/lib/usb/src/hidparser.c (modified) (22 diffs)

uspace/lib/usb/src/hidparser.c

@@ -81 +81 @@
 int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size);
 inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
-int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data, size_t j);
+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);
 int usb_pow(int a, int b);
@@ -151 +151 @@
                 list_initialize(&field->link);
 
-                /* fill the attributes */
+                /* fill the attributes */               
                 field->collection_path = path;
                 field->logical_minimum = report_item->logical_minimum;
@@ -157 +157 @@
                 field->physical_minimum = report_item->physical_minimum;
                 field->physical_maximum = report_item->physical_maximum;
+
                 field->usage_minimum = report_item->usage_minimum;
                 field->usage_maximum = report_item->usage_maximum;
@@ -165 +166 @@
                         field->usage_page = report_item->usage_page;
                 }
-                
-                if(report_item->usages_count > 0 && ((report_item->usage_minimum = 0) && (report_item->usage_maximum = 0))) {
+
+                if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
                         if(i < report_item->usages_count){
-                                if((report_item->usages[i] & 0xFF00) > 0){
+                                if((report_item->usages[i] & 0xFF00) != 0){
                                         field->usage_page = (report_item->usages[i] >> 16);                                     
                                         field->usage = (report_item->usages[i] & 0xFF);
@@ -179 +180 @@
                                 field->usage = report_item->usages[report_item->usages_count - 1];
                         }
-                }               
+                }       
+
+                if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
+                        if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
+                                field->usage = report_item->usage_maximum - i;
+                        }
+                        else {
+                                field->usage = report_item->usage_minimum + i;                                  
+                        }
+
+                }
                 
                 field->size = report_item->size;
@@ -351 +362 @@
                                         offset_output = 0;
                                         offset_feature = 0;
+                                        usb_hid_report_path_set_report_id (usage_path, report_item->id);
                                         break;
 
@@ -788 +800 @@
  */ 
 int usb_hid_parse_report(const usb_hid_report_t *report,  
-    const uint8_t *data, size_t size)
+    const uint8_t *data, size_t size, uint8_t *report_id)
 {
         link_t *list_item;
         usb_hid_report_field_t *item;
 
-        uint8_t report_id = 0;
         usb_hid_report_description_t *report_des;
         usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
@@ -802 +813 @@
 
         if(report->use_report_ids != 0) {
-                report_id = data[0];
-        }
-
-        report_des = usb_hid_report_find_description(report, report_id, type);
+                *report_id = data[0];
+        }       
+        else {
+                *report_id = 0;
+        }
+
+
+        report_des = usb_hid_report_find_description(report, *report_id, type);
 
         /* read data */
@@ -813 +828 @@
                 item = list_get_instance(list_item, usb_hid_report_field_t, link);
 
-                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) {
+                if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
                         
-                        if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) ||
-                           ((item->usage_minimum == 0) && (item->usage_maximum == 0))) {
-
+                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
+
+                                // array
+                                item->value = usb_hid_translate_data(item, data);
+                            item->usage = (item->value - item->physical_minimum) + item->usage_minimum;
+                        }
+                        else {
                                 // variable item
-                                item->value = usb_hid_translate_data(item, data,0);
-
-                                // array item ???
-                                if(!((item->usage_minimum == 0) && (item->usage_maximum == 0))) {
-                                        item->usage = item->value + item->usage_minimum;
-                                }
-                        }
-                        else {
-                                // bitmapa
-                                // TODO: overit jestli vraci hodnoty podle phy min/max 
-                                item->value = usb_hid_translate_data(item, data, 0);
-                        }                       
+                                item->value = usb_hid_translate_data(item, data);                               
+                        }                               
                 }
                 list_item = list_item->next;
@@ -847 +856 @@
  * @return Translated data
  */
-int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data, size_t j)
+int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data)
 {
         int resolution;
@@ -862 +871 @@
         }
 
-        if((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
+        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;                 
+        }
+        
 
         if(item->physical_maximum == item->physical_minimum){
@@ -876 +886 @@
         }
 
-        offset = item->offset + (j * item->size);
+        offset = item->offset;
         // FIXME
         if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
@@ -914 +924 @@
                 value = (uint32_t)value;
         }
-
 
         return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
@@ -1242 +1251 @@
                 return NULL;
         }
+
+        new_usage_path->report_id = usage_path->report_id;
         
         if(list_empty(&usage_path->head)){
@@ -1393 +1404 @@
 
         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
-
+        
         usb_hid_report_description_t *report_des;
         report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT);
@@ -1405 +1416 @@
                 report_item = list_get_instance(item, usb_hid_report_field_t, link);
 
-                        if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) ||
-                                ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
+                        if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
                                         
-                                // variable item
+                                // array
                                 value = usb_hid_translate_data_reverse(report_item, report_item->value);
                                 offset = report_item->offset;
@@ -1414 +1424 @@
                         }
                         else {
-                                //bitmap
-                                value += usb_hid_translate_data_reverse(report_item, report_item->value);
+                                // variable item
+                                value  = usb_hid_translate_data_reverse(report_item, report_item->value);
                                 offset = report_item->offset;
                                 length = report_item->size;
@@ -1462 +1472 @@
 
 
+                // reset value
+                report_item->value = 0;
+                
                 item = item->next;
         }
-
+        
         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
 
@@ -1485 +1498 @@
         }
 
+        if((item->physical_minimum == 0) && (item->physical_maximum == 0)){
+                item->physical_minimum = item->logical_minimum;
+                item->physical_maximum = item->logical_maximum;                 
+        }
+        
+
         if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) {
 
                 // variable item
-                if((item->physical_minimum == 0) && (item->physical_maximum == 0)) {
-                        item->physical_minimum = item->logical_minimum;
-                        item->physical_maximum = item->logical_maximum;
-                }
-
                 if(item->physical_maximum == item->physical_minimum){
                     resolution = 1;
@@ -1568 +1582 @@
                         if(usb_hid_report_compare_usage_path (field->collection_path, path, 
                                                       flags) == EOK) {
-
                                 if(data_idx < data_size) {
-                                        field->value = data[data_idx++];
+                                        if((data[data_idx] >= field->physical_minimum) && (data[data_idx] >= field->physical_minimum)) {
+                                                field->value = data[data_idx];
+                                        }
+                                        else {
+                                                return ERANGE;
+                                        }
+
+                                        data_idx++;
                                 }
                                 else {
@@ -1622 +1642 @@
         while(field_it != &report_des->report_items) {
                 field = list_get_instance(field_it, usb_hid_report_field_t, link);
-                        
-                usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
-                if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){
+
+                if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
+                        usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
+                        if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){
+                                usb_hid_report_remove_last_item (field->collection_path);
+                                return field;
+                        }
                         usb_hid_report_remove_last_item (field->collection_path);
-                        usb_log_debug("....OK\n");
-                        return field;
-                }
-                usb_hid_report_remove_last_item (field->collection_path);
-
+                }
                 field_it = field_it->next;
         }
@@ -1636 +1656 @@
         return NULL;
 }
+
+uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
+{
+        if(report == NULL){
+                return 0;
+        }
+
+        usb_hid_report_description_t *report_des;
+        link_t *report_it;
+        
+        if(report_id == 0) {
+                report_it = usb_hid_report_find_description (report, report_id, type)->link.next;               
+        }
+        else {
+                report_it = report->reports.next;
+        }
+
+        while(report_it != &report->reports) {
+                report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
+                if(report_des->type == type){
+                        return report_des->report_id;
+                }
+        }
+
+        return 0;
+}
+
+
 /**
  * @}