Ignore:
File:
1 edited

Legend:

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

    r64dbc83 r70a71e5  
    6464int usb_hid_report_reset_local_items();
    6565void usb_hid_free_report_list(link_t *head);
    66 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
     66
    6767/*
    6868 * Data translation private functions
     
    106106    list_initialize(&(parser->feature));
    107107
    108         list_initialize(&(parser->stack));
    109 
    110         parser->use_report_id = 0;
    111108    return EOK;   
    112109}
     
    189186                                        tmp_usage_path = NULL;
    190187
    191                                         usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);   
    192                                         if(report_item->id != 0){
    193                                                 parser->use_report_id = 1;
    194                                         }
    195188                                       
    196189                                        switch(tag) {
     
    222215                                        if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
    223216                                                return ENOMEM;
    224                                         }                                       
     217                                        }
    225218                                        memcpy(new_report_item,report_item, sizeof(usb_hid_report_item_t));
    226                                         link_initialize(&(new_report_item->link));
    227                                        
    228219                                        /* reset local items */
    229220                                        new_report_item->usage_minimum = 0;
    230221                                        new_report_item->usage_maximum = 0;
    231                                         new_report_item->designator_index = 0;
    232                                         new_report_item->designator_minimum = 0;
    233                                         new_report_item->designator_maximum = 0;
    234                                         new_report_item->string_index = 0;
    235                                         new_report_item->string_minimum = 0;
    236                                         new_report_item->string_maximum = 0;
    237 
    238                                         /* reset usage from current usage path */
    239                                         usb_hid_report_usage_path_t *path = list_get_instance(&usage_path->link, usb_hid_report_usage_path_t, link);
    240                                         path->usage = 0;
    241222                                       
     223                                        link_initialize(&(new_report_item->link));
    242224                                        report_item = new_report_item;
    243225                                                                               
     
    245227                                case USB_HID_REPORT_TAG_PUSH:
    246228                                        // push current state to stack
    247                                         new_report_item = usb_hid_report_item_clone(report_item);
    248                                         list_prepend (&parser->stack, &new_report_item->link);
    249                                        
     229                                        // not yet implemented
    250230                                        break;
    251231                                case USB_HID_REPORT_TAG_POP:
    252232                                        // restore current state from stack
    253                                         if(list_empty (&parser->stack)) {
    254                                                 return EINVAL;
    255                                         }
    256                                        
    257                                         report_item = list_get_instance(&parser->stack, usb_hid_report_item_t, link);
    258                                         list_remove (parser->stack.next);
    259                                        
     233                                        // not yet implemented                                             
    260234                                        break;
    261235                                       
     
    673647        }
    674648
    675         parser->use_report_id = 0;
    676 
    677649        usb_hid_free_report_list(&parser->input);
    678650        usb_hid_free_report_list(&parser->output);
     
    704676        size_t i=0;
    705677        size_t j=0;
    706         uint8_t report_id = 0;
    707678
    708679        if(parser == NULL) {
     
    715686        if(!(keys = malloc(sizeof(uint8_t) * key_count))){
    716687                return ENOMEM;
    717         }
    718 
    719         if(parser->use_report_id != 0) {
    720                 report_id = data[0];
    721                 usb_hid_report_path_set_report_id(path, report_id);
    722688        }
    723689
     
    727693
    728694                item = list_get_instance(list_item, usb_hid_report_item_t, link);
    729 
    730695                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) &&
    731696                   (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
     
    750715        }
    751716
    752         callbacks->keyboard(keys, key_count, report_id, arg);
     717        callbacks->keyboard(keys, key_count, 0, arg);
    753718           
    754719        free(keys);     
     
    774739        int32_t mask;
    775740        const uint8_t *foo;
    776 
     741       
    777742        // now only common numbers llowed
    778743        if(item->size > 32) {
     
    793758                (usb_pow(10,(item->unit_exponent))));
    794759        }
    795 
    796760        offset = item->offset + (j * item->size);
    797         if(item->id != 0) {
    798                 offset += 8;
    799                 usb_log_debug("MOVED OFFSET BY 1Byte, REPORT_ID(%d)\n", item->id);
    800         }
    801761       
    802762        // FIXME
     
    982942
    983943        int only_page;
    984 
    985         if(report_path->report_id != path->report_id) {
    986                 return 1;
    987         }
    988944
    989945        if(path->depth == 0){
     
    10821038        else {
    10831039                path->depth = 0;
    1084                 path->report_id = 0;
    10851040                list_initialize(&path->link);
    10861041                return path;
     
    12001155                return 0;
    12011156        }
    1202 
     1157       
    12031158        item = parser->output.next;
    12041159        while(&parser->output != item) {
     
    12401195        int length;
    12411196        int32_t tmp_value;
    1242         size_t offset_prefix = 0;
    12431197       
    12441198        if(parser == NULL) {
    12451199                return EINVAL;
    1246         }
    1247 
    1248         if(parser->use_report_id != 0) {
    1249                 buffer[0] = path->report_id;
    1250                 offset_prefix = 8;
    12511200        }
    12521201
     
    12691218//                              // variable item
    12701219                                value = usb_hid_translate_data_reverse(report_item, data[idx++]);
    1271                                 offset = report_item->offset + (i * report_item->size) + offset_prefix;
     1220                                offset = report_item->offset + (i * report_item->size);
    12721221                                length = report_item->size;
    12731222                        }
     
    12751224                                //bitmap
    12761225                                value += usb_hid_translate_data_reverse(report_item, data[idx++]);
    1277                                 offset = report_item->offset + offset_prefix;
     1226                                offset = report_item->offset;
    12781227                                length = report_item->size * report_item->count;
    12791228                        }
     
    13741323
    13751324
    1376 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
    1377 {
    1378         if(path == NULL){
    1379                 return EINVAL;
    1380         }
    1381 
    1382         path->report_id = report_id;
    1383         return EOK;
    1384 }
    1385 
    1386 
    1387 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
    1388 {
    1389         usb_hid_report_item_t *new_report_item;
    1390        
    1391         if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
    1392                 return NULL;
    1393         }                                       
    1394         memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
    1395         link_initialize(&(new_report_item->link));
    1396 
    1397         return new_report_item;
    1398 }
    1399 
    14001325/**
    14011326 * @}
Note: See TracChangeset for help on using the changeset viewer.