Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 9b78020 in mainline


Ignore:
Timestamp:
2011-04-22T10:21:56Z (11 years ago)
Author:
Lubos Slovak <lubos.slovak@…>
Branches:
lfn, master
Children:
308a5d5
Parents:
1775ebc (diff), 7304663 (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

Location:
uspace
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbhid/kbd/kbddev.c

    r1775ebc r9b78020  
    694694        while (field != NULL) {
    695695                usb_log_debug2("FIELD (%p) - VALUE(%d) USAGE(%u)\n",
    696                     field, field->value, field->value);
     696                    field, field->value, field->usage);
    697697               
    698698                assert(i < kbd_dev->key_count);
     
    709709                 *       two parts of the Report somehow.
    710710                 */
    711                 kbd_dev->keys[i] = field->value;
     711                if( field->value != 0 ) {
     712                        kbd_dev->keys[i] = field->usage;
     713                }
     714                else {
     715                        kbd_dev->keys[i] = 0;
     716                }
    712717                usb_log_debug2("Saved %u. key usage %d\n", i, kbd_dev->keys[i]);
    713718               
  • uspace/lib/usb/src/hidparser.c

    r1775ebc r9b78020  
    7373void usb_hid_print_usage_path(usb_hid_report_path_t *path);
    7474void usb_hid_descriptor_print_list(link_t *head);
    75 int usb_hid_report_reset_local_items();
     75void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
    7676void usb_hid_free_report_list(link_t *head);
    7777usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
     
    7979 * Data translation private functions
    8080 */
    81 int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size);
     81uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
    8282inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
    8383int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
     
    8585int usb_pow(int a, int b);
    8686
     87#define USB_HID_UINT32_TO_INT32(x, size)        ((((x) & (1 << ((size) - 1))) != 0) ? -(~(x - 1) & ((1 << size) - 1)) : (x)) //(-(~((x) - 1)))
     88#define USB_HID_INT32_TO_UINT32(x, size)        (((x) < 0 ) ? ((1 << (size)) + (x)) : (x))
    8789// TODO: tohle ma bejt asi jinde
    8890int usb_pow(int a, int b)
     
    144146        }
    145147
     148        for(i=0; i<report_item->usages_count; i++){
     149                usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);
     150        }
     151
    146152       
    147153        for(i=0; i<report_item->count; i++){
     
    168174
    169175                if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
    170                         if(i < report_item->usages_count){
    171                                 if((report_item->usages[i] & 0xFF00) != 0){
    172                                         field->usage_page = (report_item->usages[i] >> 16);                                     
    173                                         field->usage = (report_item->usages[i] & 0xFF);
     176                        uint32_t usage;
     177                        if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
     178                                if(i < report_item->usages_count){
     179                                        usage = report_item->usages[i];
    174180                                }
    175181                                else {
    176                                         field->usage = report_item->usages[i];
     182                                        usage = report_item->usages[report_item->usages_count - 1];
    177183                                }
    178184                        }
    179185                        else {
    180                                 field->usage = report_item->usages[report_item->usages_count - 1];
    181                         }
     186                                if((report_item->count - i - 1) < report_item->usages_count){
     187                                        usage = report_item->usages[(report_item->count - i - 1)];
     188                                }
     189                                else {
     190                                        usage = report_item->usages[report_item->usages_count - 1];
     191                                }
     192                        }
     193
     194                                               
     195                        if((usage & 0xFF00) != 0){
     196                                field->usage_page = (usage >> 16);                                     
     197                                field->usage = (usage & 0xFF);
     198                        }
     199                        else {
     200                                field->usage = usage;
     201                        }
     202
     203                       
    182204                }       
    183205
     
    342364
    343365                                        /* reset local items */
    344                                         while(report_item->usages_count > 0){
    345                                                 report_item->usages[--(report_item->usages_count)] = 0;
    346                                         }
    347 
    348                                         report_item->extended_usage_page = 0;
    349                                         report_item->usage_minimum = 0;
    350                                         report_item->usage_maximum = 0;
    351                                         report_item->designator_index = 0;
    352                                         report_item->designator_minimum = 0;
    353                                         report_item->designator_maximum = 0;
    354                                         report_item->string_index = 0;
    355                                         report_item->string_minimum = 0;
    356                                         report_item->string_maximum = 0;
     366                                        usb_hid_report_reset_local_items (report_item);
    357367
    358368                                        break;
     
    476486                        // TODO usage_path->flags = *data;
    477487                        usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);                                         
     488                        usb_hid_report_reset_local_items (report_item);
    478489                        return USB_HID_NO_ACTION;
    479490                        break;
     
    506517        {
    507518                case USB_HID_REPORT_TAG_USAGE_PAGE:
    508                         report_item->usage_page = usb_hid_report_tag_data_int32(data, item_size);
     519                        report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size);
    509520                        break;
    510521                case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
    511                         report_item->logical_minimum = usb_hid_report_tag_data_int32(data,item_size);
     522                        report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    512523                        break;
    513524                case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
    514                         report_item->logical_maximum = usb_hid_report_tag_data_int32(data,item_size);
     525                        report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    515526                        break;
    516527                case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
    517                         report_item->physical_minimum = usb_hid_report_tag_data_int32(data,item_size);
     528                        report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    518529                        break;                 
    519530                case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
    520                         report_item->physical_maximum = usb_hid_report_tag_data_int32(data,item_size);
     531                        report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
     532
    521533                        break;
    522534                case USB_HID_REPORT_TAG_UNIT_EXPONENT:
    523                         report_item->unit_exponent = usb_hid_report_tag_data_int32(data,item_size);
     535                        report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size);
    524536                        break;
    525537                case USB_HID_REPORT_TAG_UNIT:
    526                         report_item->unit = usb_hid_report_tag_data_int32(data,item_size);
     538                        report_item->unit = usb_hid_report_tag_data_uint32(data,item_size);
    527539                        break;
    528540                case USB_HID_REPORT_TAG_REPORT_SIZE:
    529                         report_item->size = usb_hid_report_tag_data_int32(data,item_size);
     541                        report_item->size = usb_hid_report_tag_data_uint32(data,item_size);
    530542                        break;
    531543                case USB_HID_REPORT_TAG_REPORT_COUNT:
    532                         report_item->count = usb_hid_report_tag_data_int32(data,item_size);
     544                        report_item->count = usb_hid_report_tag_data_uint32(data,item_size);
    533545                        break;
    534546                case USB_HID_REPORT_TAG_REPORT_ID:
    535                         report_item->id = usb_hid_report_tag_data_int32(data,item_size);
     547                        report_item->id = usb_hid_report_tag_data_uint32(data,item_size);
    536548                        return USB_HID_RESET_OFFSET;
    537549                        break;
     
    548560                        return USB_HID_NO_ACTION;
    549561        }
    550        
     562
    551563        return EOK;
    552564}
     
    567579        {
    568580                case USB_HID_REPORT_TAG_USAGE:
    569                         report_item->usages[report_item->usages_count++] = usb_hid_report_tag_data_int32(data,item_size);
     581                        report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
     582                        report_item->usages_count++;
    570583                        break;
    571584                case USB_HID_REPORT_TAG_USAGE_MINIMUM:
    572585                        if (item_size == 3) {
    573586                                // usage extended usages
    574                                 report_item->extended_usage_page = (usb_hid_report_tag_data_int32(data,item_size) & 0xFF00) >> 16;
    575                                 report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size) & 0xFF;
     587                                report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16;
     588                                report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
    576589                        }
    577590                        else {
    578                                 report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size);
     591                                report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size);
    579592                        }
    580593                        break;
     
    582595                        if (item_size == 3) {
    583596                                // usage extended usages
    584                                 report_item->extended_usage_page = (usb_hid_report_tag_data_int32(data,item_size) & 0xFF00) >> 16;
    585                                 report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size) & 0xFF;
     597                                report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16;
     598                                report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
    586599                        }
    587600                        else {
    588                                 report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size);
     601                                report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    589602                        }
    590603                        break;
    591604                case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
    592                         report_item->designator_index = usb_hid_report_tag_data_int32(data,item_size);
     605                        report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size);
    593606                        break;
    594607                case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
    595                         report_item->designator_minimum = usb_hid_report_tag_data_int32(data,item_size);
     608                        report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size);
    596609                        break;
    597610                case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
    598                         report_item->designator_maximum = usb_hid_report_tag_data_int32(data,item_size);
     611                        report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    599612                        break;
    600613                case USB_HID_REPORT_TAG_STRING_INDEX:
    601                         report_item->string_index = usb_hid_report_tag_data_int32(data,item_size);
     614                        report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size);
    602615                        break;
    603616                case USB_HID_REPORT_TAG_STRING_MINIMUM:
    604                         report_item->string_minimum = usb_hid_report_tag_data_int32(data,item_size);
     617                        report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size);
    605618                        break;
    606619                case USB_HID_REPORT_TAG_STRING_MAXIMUM:
    607                         report_item->string_maximum = usb_hid_report_tag_data_int32(data,item_size);
     620                        report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    608621                        break;                 
    609622                case USB_HID_REPORT_TAG_DELIMITER:
    610                         //report_item->delimiter = usb_hid_report_tag_data_int32(data,item_size);
     623                        //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size);
    611624                        //TODO:
    612625                        //      DELIMITER STUFF
     
    621634
    622635/**
    623  * Converts raw data to int32 (thats the maximum length of short item data)
     636 * Converts raw data to uint32 (thats the maximum length of short item data)
    624637 *
    625638 * @param Data buffer
     
    627640 * @return Converted int32 number
    628641 */
    629 int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size)
     642uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size)
    630643{
    631644        unsigned int i;
    632         int32_t result;
     645        uint32_t result;
    633646
    634647        result = 0;
     
    639652        return result;
    640653}
    641 
    642 
    643654
    644655/**
     
    665676                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
    666677                usb_log_debug("\t\tSIZE: %X\n", report_item->size);                             
    667                 usb_log_debug("\t\tLOGMIN: %X\n", report_item->logical_minimum);
    668                 usb_log_debug("\t\tLOGMAX: %X\n", report_item->logical_maximum);               
    669                 usb_log_debug("\t\tPHYMIN: %X\n", report_item->physical_minimum);               
    670                 usb_log_debug("\t\tPHYMAX: %X\n", report_item->physical_maximum);                               
     678                usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum);
     679                usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum);               
     680                usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum);               
     681                usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum);                               
    671682                usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum);
    672683                usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum);
     
    918929        }
    919930
    920         if(!(item->logical_minimum >= 0 && item->logical_maximum >= 0)){
    921                 value = (int32_t)value;
    922         }
    923         else {
    924                 value = (uint32_t)value;
     931        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
     932                value = USB_HID_UINT32_TO_INT32(value, item->size);
    925933        }
    926934
     
    15291537        }
    15301538
    1531 
    1532         return (uint32_t)ret;
     1539        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
     1540                return USB_HID_INT32_TO_UINT32(ret, item->size);
     1541        }
     1542        return (int32_t)ret;
    15331543}
    15341544
     
    16831693}
    16841694
    1685 
     1695void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
     1696{
     1697        if(report_item == NULL) {
     1698                return;
     1699        }
     1700       
     1701        report_item->usages_count = 0;
     1702        memset(report_item->usages, 0, USB_HID_MAX_USAGES);
     1703       
     1704        report_item->extended_usage_page = 0;
     1705        report_item->usage_minimum = 0;
     1706        report_item->usage_maximum = 0;
     1707        report_item->designator_index = 0;
     1708        report_item->designator_minimum = 0;
     1709        report_item->designator_maximum = 0;
     1710        report_item->string_index = 0;
     1711        report_item->string_minimum = 0;
     1712        report_item->string_maximum = 0;
     1713
     1714        return;
     1715}
    16861716/**
    16871717 * @}
Note: See TracChangeset for help on using the changeset viewer.