Changeset cc5908e in mainline for uspace/lib/usb/src


Ignore:
Timestamp:
2011-05-07T14:28:51Z (14 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
252cf2a, 68b614e
Parents:
bd2394b (diff), 7205209 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Development changes merged

Location:
uspace/lib/usb/src
Files:
2 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/usb/src/hiddescriptor.c

    rbd2394b rcc5908e  
    116116        int i;
    117117
    118         for(i=0; i<report_item->usages_count; i++){
    119                 usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);
    120         }
    121 
     118        usb_log_debug("usages_count  - %zu\n", report_item->usages_count);
     119
     120        uint32_t *usages;
     121        int usages_used=0;
     122        if(report_item->usages_count > 0){
     123                usages = malloc(sizeof(int32_t) * report_item->usages_count);
     124                memcpy(usages, report_item->usages, sizeof(int32_t) * report_item->usages_count);
     125        }
     126        else {
     127                usages = NULL;
     128        }
     129       
    122130        usb_hid_report_path_t *path = report_item->usage_path; 
    123131        for(i=0; i<report_item->count; i++){
    … …  
    133141                field->physical_maximum = report_item->physical_maximum;
    134142
    135                 field->usage_minimum = report_item->usage_minimum;
    136                 field->usage_maximum = report_item->usage_maximum;
    137                 if(report_item->extended_usage_page != 0){
    138                         field->usage_page = report_item->extended_usage_page;
     143                if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){
     144                        /*
     145                                Store usage array. The Correct Usage Page and Usage is depending
     146                                on data in report and will be filled later
     147                        */
     148                        field->usage = 0;
     149                        field->usage_page = report_item->usage_page;
     150
     151                        field->usages_count = report_item->usages_count;
     152                        field->usages = usages;
     153                        usages_used = 1;
    139154                }
    140155                else {
    141                         field->usage_page = report_item->usage_page;
    142                 }
    143 
    144                 if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
    145                         uint32_t usage;
    146                         if(i < report_item->usages_count){
     156                        /* Fill the correct Usage and Usage Page */
     157                        int32_t usage;
     158                        if(i < report_item->usages_count) {
    147159                                usage = report_item->usages[i];
    148160                        }
    … …  
    151163                        }
    152164
    153                                                
    154                         if((usage & 0xFFFF0000) != 0){
    155                                 field->usage_page = (usage >> 16);                                     
    156                                 field->usage = (usage & 0xFFFF);
     165                        if(USB_HID_IS_EXTENDED_USAGE(usage)){
     166                                field->usage = USB_HID_EXTENDED_USAGE(usage);
     167                                field->usage_page = USB_HID_EXTENDED_USAGE_PAGE(usage);
    157168                        }
    158169                        else {
    159170                                field->usage = usage;
    160                         }
    161 
    162                        
    163                 }       
    164 
    165                 if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
    166                         field->usage = report_item->usage_minimum + i;                                 
     171                                field->usage_page = report_item->usage_page;
     172                        }
    167173                }
    168174               
    … …  
    209215        }
    210216
     217        // free only when not used!!!
     218        if(usages && usages_used == 0) {
     219                free(usages);
     220        }
    211221
    212222        return EOK;
    … …  
    565575                        }
    566576                        break;
    567                 case USB_HID_REPORT_TAG_USAGE_MINIMUM:
    568 
    569                         usb_log_debug("USAGE_MINIMUM (SIZE: %d), data[0](%x), data[1](%x), data[2](%x) data[3](%x)\n",
    570                                       item_size, *data, *(data+1), *(data+2), *(data+3));
    571                        
     577                case USB_HID_REPORT_TAG_USAGE_MINIMUM:                 
    572578                        if (item_size == 3) {
    573579                                // usage extended usages
    … …  
    581587                case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
    582588                        if (item_size == 3) {
     589
     590                                if(report_item->extended_usage_page != ((usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16)) {
     591                                        return EINVAL;
     592                                }
     593                               
    583594                                // usage extended usages
    584595                                report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16;
    … …  
    588599                                report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    589600                        }
     601
     602                        // vlozit zaznamy do pole usages
     603                        int32_t i;
     604                        for(i=report_item->usage_minimum; i<=report_item->usage_maximum; i++) {
     605                                if(report_item->extended_usage_page) {
     606                                        report_item->usages[report_item->usages_count++] = (report_item->extended_usage_page << 16) + i;
     607                                }
     608                                else {
     609                                        report_item->usages[report_item->usages_count++] = i;
     610                                }
     611                        }
     612                        report_item->extended_usage_page = 0;
     613                       
    590614                        break;
    591615                case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
    … …  
    660684
    661685                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
    662                 usb_log_debug("\t\tSIZE: %X\n", report_item->size);                             
     686                usb_log_debug("\t\tSIZE: %zu\n", report_item->size);                           
    663687                usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum);
    664688                usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum);               
    … …  
    699723                usb_log_debug("Report ID: %d\n", report_des->report_id);
    700724                usb_log_debug("\tType: %d\n", report_des->type);
    701                 usb_log_debug("\tLength: %d\n", report_des->bit_length);               
    702                 usb_log_debug("\tItems: %d\n", report_des->item_length);               
     725                usb_log_debug("\tLength: %zu\n", report_des->bit_length);               
     726                usb_log_debug("\tItems: %zu\n", report_des->item_length);               
    703727
    704728                usb_hid_descriptor_print_list(&report_des->report_items);

  • uspace/lib/usb/src/hidparser.c

    rbd2394b rcc5908e  
    138138                                // array
    139139                                item->value = usb_hid_translate_data(item, data);
    140                             item->usage = (item->value - item->physical_minimum) + item->usage_minimum;
     140               
     141                                item->usage = USB_HID_EXTENDED_USAGE(item->usages[item->value - item->physical_minimum]);
     142                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(item->usages[item->value - item->physical_minimum]);
     143
    141144                        }
    142145                        else {

  • uspace/lib/usb/src/host.c

    rbd2394b rcc5908e  
    11/*
    2  * Copyright (c) 2010 Vojtech Horky
     2 * Copyright (c) 2011 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup usbvirtkbd
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    32 /** @file
    33  * @brief USB keyboard configuration.
     32/**
     33 * @file
     34 * Host controller common functions (implementation).
    3435 */
    35 #ifndef VUK_KBDCONFIG_H_
    36 #define VUK_KBDCONFIG_H_
     36#include <stdio.h>
     37#include <str_error.h>
     38#include <errno.h>
     39#include <assert.h>
     40#include <bool.h>
     41#include <usb/host.h>
     42#include <usb/descriptor.h>
     43#include <devman.h>
    3744
    38 #include <usb/descriptor.h>
    39 #include "report.h"
    40 #include "descriptor.h"
     45/** Get host controller handle by its class index.
     46 *
     47 * @param class_index Class index for the host controller.
     48 * @param hc_handle Where to store the HC handle
     49 *      (can be NULL for existence test only).
     50 * @return Error code.
     51 */
     52int usb_ddf_get_hc_handle_by_class(size_t class_index,
     53    devman_handle_t *hc_handle)
     54{
     55        char *class_index_str;
     56        devman_handle_t hc_handle_tmp;
     57        int rc;
    4158
    42 extern usb_standard_device_descriptor_t std_device_descriptor;
     59        rc = asprintf(&class_index_str, "%zu", class_index);
     60        if (rc < 0) {
     61                return ENOMEM;
     62        }
     63        rc = devman_device_get_handle_by_class("usbhc", class_index_str,
     64            &hc_handle_tmp, 0);
     65        free(class_index_str);
     66        if (rc != EOK) {
     67                return rc;
     68        }
    4369
    44 extern usb_standard_configuration_descriptor_t std_configuration_descriptor;
     70        if (hc_handle != NULL) {
     71                *hc_handle = hc_handle_tmp;
     72        }
    4573
    46 extern usb_standard_interface_descriptor_t std_interface_descriptor;
     74        return EOK;
     75}
    4776
    48 extern usb_standard_endpoint_descriptor_t endpoint_descriptor;
    49 
    50 
    51 extern hid_descriptor_t hid_descriptor;
    52 
    53 extern report_descriptor_data_t report_descriptor;
    54 extern size_t report_descriptor_size;
    55 
    56 
    57 #endif
    58 /**
    59  * @}
     77/** @}
    6078 */
Note: See TracChangeset for help on using the changeset viewer.