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

Changeset 1553cbf in mainline


Ignore:
Timestamp:
2011-04-22T09:15:43Z (11 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master
Children:
cf2ccd4
Parents:
2020927
Message:

negative numbers fix

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usb/src/hidparser.c

    r2020927 r1553cbf  
    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)
     
    173175                if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
    174176                        uint32_t usage;
    175                         if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
     177                        if(report_item->type != USB_HID_REPORT_TYPE_INPUT) {
    176178                                if(i < report_item->usages_count){
    177179                                        usage = report_item->usages[i];
     
    515517        {
    516518                case USB_HID_REPORT_TAG_USAGE_PAGE:
    517                         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);
    518520                        break;
    519521                case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
    520                         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);
    521523                        break;
    522524                case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
    523                         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);
    524526                        break;
    525527                case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
    526                         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);
    527529                        break;                 
    528530                case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
    529                         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
    530533                        break;
    531534                case USB_HID_REPORT_TAG_UNIT_EXPONENT:
    532                         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);
    533536                        break;
    534537                case USB_HID_REPORT_TAG_UNIT:
    535                         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);
    536539                        break;
    537540                case USB_HID_REPORT_TAG_REPORT_SIZE:
    538                         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);
    539542                        break;
    540543                case USB_HID_REPORT_TAG_REPORT_COUNT:
    541                         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);
    542545                        break;
    543546                case USB_HID_REPORT_TAG_REPORT_ID:
    544                         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);
    545548                        return USB_HID_RESET_OFFSET;
    546549                        break;
     
    557560                        return USB_HID_NO_ACTION;
    558561        }
    559        
     562
    560563        return EOK;
    561564}
     
    576579        {
    577580                case USB_HID_REPORT_TAG_USAGE:
    578                         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);
    579582                        report_item->usages_count++;
    580583                        break;
     
    582585                        if (item_size == 3) {
    583586                                // usage extended usages
    584                                 report_item->extended_usage_page = (usb_hid_report_tag_data_int32(data,item_size) & 0xFF00) >> 16;
    585                                 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;
    586589                        }
    587590                        else {
    588                                 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);
    589592                        }
    590593                        break;
     
    592595                        if (item_size == 3) {
    593596                                // usage extended usages
    594                                 report_item->extended_usage_page = (usb_hid_report_tag_data_int32(data,item_size) & 0xFF00) >> 16;
    595                                 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;
    596599                        }
    597600                        else {
    598                                 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);
    599602                        }
    600603                        break;
    601604                case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
    602                         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);
    603606                        break;
    604607                case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
    605                         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);
    606609                        break;
    607610                case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
    608                         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);
    609612                        break;
    610613                case USB_HID_REPORT_TAG_STRING_INDEX:
    611                         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);
    612615                        break;
    613616                case USB_HID_REPORT_TAG_STRING_MINIMUM:
    614                         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);
    615618                        break;
    616619                case USB_HID_REPORT_TAG_STRING_MAXIMUM:
    617                         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);
    618621                        break;                 
    619622                case USB_HID_REPORT_TAG_DELIMITER:
    620                         //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);
    621624                        //TODO:
    622625                        //      DELIMITER STUFF
     
    631634
    632635/**
    633  * 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)
    634637 *
    635638 * @param Data buffer
     
    637640 * @return Converted int32 number
    638641 */
    639 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)
    640643{
    641644        unsigned int i;
    642         int32_t result;
     645        uint32_t result;
    643646
    644647        result = 0;
     
    649652        return result;
    650653}
    651 
    652 
    653654
    654655/**
     
    675676                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
    676677                usb_log_debug("\t\tSIZE: %X\n", report_item->size);                             
    677                 usb_log_debug("\t\tLOGMIN: %X\n", report_item->logical_minimum);
    678                 usb_log_debug("\t\tLOGMAX: %X\n", report_item->logical_maximum);               
    679                 usb_log_debug("\t\tPHYMIN: %X\n", report_item->physical_minimum);               
    680                 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);                               
    681682                usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum);
    682683                usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum);
     
    928929        }
    929930
    930         if(!(item->logical_minimum >= 0 && item->logical_maximum >= 0)){
    931                 value = (int32_t)value;
    932         }
    933         else {
    934                 value = (uint32_t)value;
     931        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
     932                value = USB_HID_UINT32_TO_INT32(value, item->size);
    935933        }
    936934
     
    15391537        }
    15401538
    1541 
    1542         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;
    15431543}
    15441544
Note: See TracChangeset for help on using the changeset viewer.