Changes in / [3ae26a8:17d1542] in mainline


Ignore:
Location:
uspace
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/mkbd/main.c

    r3ae26a8 r17d1542  
    7171                usb_hid_free_report(*report);
    7272                *report = NULL;
    73                 //printf("usb_hid_report_init() failed.\n");
     73                printf("usb_hid_report_init() failed.\n");
    7474                return rc;
    7575        }
    … …  
    8282                usb_hid_free_report(*report);
    8383                *report = NULL;
    84                 //printf("usbhid_dev_get_report_descriptor_length() failed.\n");
     84                printf("usbhid_dev_get_report_descriptor_length() failed.\n");
    8585                return rc;
    8686        }
    … …  
    8989                usb_hid_free_report(*report);
    9090                *report = NULL;
    91                 //printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
     91                printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
    9292                return EINVAL;  // TODO: other error code?
    9393        }
    … …  
    108108                *report = NULL;
    109109                free(desc);
    110                 //printf("usbhid_dev_get_report_descriptor() failed.\n");
     110                printf("usbhid_dev_get_report_descriptor() failed.\n");
    111111                return rc;
    112112        }
    … …  
    116116                *report = NULL;
    117117                free(desc);
    118 //              printf("usbhid_dev_get_report_descriptor() returned wrong size:"
    119 //                  " %zu, expected: %zu.\n", actual_size, report_desc_size);
     118                printf("usbhid_dev_get_report_descriptor() returned wrong size:"
     119                    " %zu, expected: %zu.\n", actual_size, report_desc_size);
    120120                return EINVAL;  // TODO: other error code?
    121121        }
    … …  
    128128        if (rc != EOK) {
    129129                free(desc);
    130 //              printf("usb_hid_parse_report_descriptor() failed.\n");
     130                printf("usb_hid_parse_report_descriptor() failed.\n");
    131131                return rc;
    132132        }
    … …  
    213213       
    214214        char *devpath = argv[1];
     215        //const char *devpath = "/hw/pci0/00:06.0/ohci-rh/usb00_a2/HID1/hid";
     216       
     217        int rc;
    215218       
    216219        devman_handle_t dev_handle = 0;
    217        
    218         int rc = usb_resolve_device_handle(devpath, NULL, NULL, &dev_handle);
    219         if (rc != EOK) {
    220                 printf("Device not found or not of USB kind: %s.\n",
     220        rc = devman_device_get_handle(devpath, &dev_handle, 0);
     221        if (rc != EOK) {
     222                printf("Failed to get handle from devman: %s.\n",
    221223                    str_error(rc));
    222224                return rc;

  • uspace/drv/usbhid/usbhid.c

    r3ae26a8 r17d1542  
    7878        }
    7979       
    80         assert(hid_dev->subdriver_count >= 0);
    81        
    8280        // set the init callback
    83         hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_kbd_init;
     81        hid_dev->subdrivers[0].init = usb_kbd_init;
    8482       
    8583        // set the polling callback
    86         hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    87             usb_kbd_polling_callback;
     84        hid_dev->subdrivers[0].poll = usb_kbd_polling_callback;
    8885       
    8986        // set the polling ended callback
    90         hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
     87        hid_dev->subdrivers[0].poll_end = NULL;
    9188       
    9289        // set the deinit callback
    93         hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_kbd_deinit;
     90        hid_dev->subdrivers[0].deinit = usb_kbd_deinit;
    9491       
    9592        // set subdriver count
    96         ++hid_dev->subdriver_count;
     93        hid_dev->subdriver_count = 1;
    9794       
    9895        return EOK;
    … …  
    111108        }
    112109       
    113         assert(hid_dev->subdriver_count >= 0);
    114        
    115110        // set the init callback
    116         hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_mouse_init;
     111        hid_dev->subdrivers[0].init = usb_mouse_init;
    117112       
    118113        // set the polling callback
    119         hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    120             usb_mouse_polling_callback;
     114        hid_dev->subdrivers[0].poll = usb_mouse_polling_callback;
    121115       
    122116        // set the polling ended callback
    123         hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
     117        hid_dev->subdrivers[0].poll_end = NULL;
    124118       
    125119        // set the deinit callback
    126         hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_mouse_deinit;
     120        hid_dev->subdrivers[0].deinit = usb_mouse_deinit;
    127121       
    128122        // set subdriver count
    129         ++hid_dev->subdriver_count;
     123        hid_dev->subdriver_count = 1;
    130124       
    131125        return EOK;
    … …  
    144138        }
    145139       
    146         assert(hid_dev->subdriver_count >= 0);
    147        
    148140        // set the init callback
    149         hid_dev->subdrivers[hid_dev->subdriver_count].init =
    150             usb_generic_hid_init;
     141        hid_dev->subdrivers[0].init = usb_generic_hid_init;
    151142       
    152143        // set the polling callback
    153         hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    154             usb_generic_hid_polling_callback;
     144        hid_dev->subdrivers[0].poll = usb_generic_hid_polling_callback;
    155145       
    156146        // set the polling ended callback
    157         hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
     147        hid_dev->subdrivers[0].poll_end = NULL;
    158148       
    159149        // set the deinit callback
    160         hid_dev->subdrivers[hid_dev->subdriver_count].deinit = NULL;
     150        hid_dev->subdrivers[0].deinit = NULL;
    161151       
    162152        // set subdriver count
    163         ++hid_dev->subdriver_count;
     153        hid_dev->subdriver_count = 1;
    164154       
    165155        return EOK;
    … …  
    206196        }
    207197       
    208 //      if (mapping->report_id >= 0) {
    209 //              usb_hid_report_path_set_report_id(usage_path,
    210 //                  mapping->report_id);
    211 //      }
     198        if (mapping->report_id >= 0) {
     199                usb_hid_report_path_set_report_id(usage_path,
     200                    mapping->report_id);
     201        }
    212202       
    213203        assert(hid_dev->report != NULL);
    … …  
    216206//      size_t size = usb_hid_report_size(hid_dev->report, 0,
    217207//          USB_HID_REPORT_TYPE_INPUT);
    218 //      size_t size = 0;
    219        
    220         bool matches = false;
    221 
    222 //      usb_hid_report_description_t *report_des =
    223 //              usb_hid_report_find_description(hid_dev->report,
    224 //              mapping->report_id, USB_HID_REPORT_TYPE_INPUT);
    225         uint8_t report_id = mapping->report_id;
    226 
    227         /*while(report_des != NULL)*/do {
    228 
    229 //              if((mapping->report_id) == 0 && (report_des->report_id != 0)) {
    230 //                      usb_hid_report_path_set_report_id(usage_path,
    231 //                              report_des->report_id);
    232 //              }
    233                                              
    234                 usb_log_debug("Trying report id %u\n", report_id);
    235                
    236                 if (report_id != 0) {
    237                         usb_hid_report_path_set_report_id(usage_path,
    238                                 report_id);
    239                 }
    240 
    241                 usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    242                     hid_dev->report,
    243                     NULL, usage_path, mapping->compare,
    244                     USB_HID_REPORT_TYPE_INPUT);
    245                
    246                 usb_log_debug("Field: %p\n", field);
    247 
    248                 if (field != NULL) {
    249 //                      size++;
    250 //                      field = usb_hid_report_get_sibling(hid_dev->report,
    251 //                          field, usage_path, mapping->compare,
    252 //                          USB_HID_REPORT_TYPE_INPUT);
    253                         matches = true;
    254                         break;
    255                 }
    256                
    257                 report_id = usb_hid_get_next_report_id(
    258                     hid_dev->report, report_id,
    259                     USB_HID_REPORT_TYPE_INPUT);
    260 
    261 //              if((mapping->report_id == 0) && (report_des->report_id != 0)) {
    262 //                      uint8_t report_id = usb_hid_get_next_report_id(
    263 //                              hid_dev->report, report_des->report_id,
    264 //                              USB_HID_REPORT_TYPE_INPUT);
    265 
    266 //                      if(report_id == 0) {
    267 //                              break;
    268 //                      }
    269 
    270 //                      report_des = usb_hid_report_find_description(
    271 //                              hid_dev->report, report_id,
    272 //                              USB_HID_REPORT_TYPE_INPUT);
    273 //              }
    274 //              else {
    275 //                      break;
    276 //              }
    277         } while (!matches && report_id != 0);
    278        
    279 //      usb_log_debug("Size of the input report: %zu\n", size);
     208        size_t size = 0;
     209        usb_hid_report_field_t *field = usb_hid_report_get_sibling (hid_dev->report,
     210                NULL, usage_path, mapping->compare, USB_HID_REPORT_TYPE_INPUT);
     211        while(field != NULL) {
     212                size++;
     213                field = usb_hid_report_get_sibling (hid_dev->report,
     214                                        field, usage_path, mapping->compare,
     215                            USB_HID_REPORT_TYPE_INPUT);
     216        }
     217       
     218        usb_log_debug("Size of the input report: %zuB\n", size);
    280219        usb_hid_report_path_free(usage_path);
    281220       
    282         return matches;
     221        return (size > 0);
    283222}
    284223
    … …  
    429368       
    430369        do {
    431                 usb_log_debug("Getting size of the report.\n");
    432370                size = usb_hid_report_byte_size(hid_dev->report, report_id,
    433371                    USB_HID_REPORT_TYPE_INPUT);
    434372                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
    435373                max_size = (size > max_size) ? size : max_size;
    436                 usb_log_debug("Getting next report ID\n");
    437374                report_id = usb_hid_get_next_report_id(hid_dev->report,
    438375                    report_id, USB_HID_REPORT_TYPE_INPUT);
    … …  
    564501                    hid_dev->subdriver_count);
    565502                //usb_hid_free(&hid_dev);
    566                
    567503        } else {
    568504                bool ok = false;
    … …  
    591527        }
    592528       
    593        
    594         if (rc == EOK) {
    595                 // save max input report size and allocate space for the report
    596                 rc = usb_hid_init_report(hid_dev);
    597                 if (rc != EOK) {
    598                         usb_log_error("Failed to initialize input report buffer"
    599                             ".\n");
    600                 }
    601         }
    602        
     529        // save max input report size and allocate space for the report
     530        rc = usb_hid_init_report(hid_dev);
     531        if (rc != EOK) {
     532                usb_log_error("Failed to initialize input report buffer.\n");
     533        }
    603534       
    604535        return rc;
    … …  
    623554        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
    624555            hid_dev->max_input_report_size, buffer_size);
    625         //assert(hid_dev->max_input_report_size >= buffer_size);
    626         if (hid_dev->max_input_report_size >= buffer_size) {
    627                 /*! @todo This should probably be atomic. */
    628                 memcpy(hid_dev->input_report, buffer, buffer_size);
    629                 hid_dev->input_report_size = buffer_size;
    630                 usb_hid_new_report(hid_dev);
    631         }
     556        assert(hid_dev->max_input_report_size >= buffer_size);
     557       
     558//      if (/*!allocated*/
     559//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
     560//              uint8_t *input_old = hid_dev->input_report;
     561//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
     562               
     563//              if (input_new == NULL) {
     564//                      usb_log_error("Failed to allocate space for input "
     565//                          "buffer. This event may not be reported\n");
     566//                      memset(hid_dev->input_report, 0,
     567//                          hid_dev->input_report_size);
     568//              } else {
     569//                      memcpy(input_new, input_old,
     570//                          hid_dev->input_report_size);
     571//                      hid_dev->input_report = input_new;
     572//                      if (allocated) {
     573//                              free(input_old);
     574//                      }
     575//                      usb_hid_new_report();
     576//              }
     577//      }
     578       
     579        /*! @todo This should probably be atomic. */
     580        memcpy(hid_dev->input_report, buffer, buffer_size);
     581        hid_dev->input_report_size = buffer_size;
     582        usb_hid_new_report(hid_dev);
    632583       
    633584        bool cont = false;

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

    r3ae26a8 r17d1542  
    329329                usb_hid_report_type_t type) {
    330330
    331         if(report == NULL) {
    332                 return NULL;
    333         }
    334 
    335331        link_t *report_it = report->reports.next;
    336332        usb_hid_report_description_t *report_des = NULL;
    … …  
    340336                                usb_hid_report_description_t, link);
    341337
    342                 // if report id not set, return the first of the type
    343                 if(((report_des->report_id == report_id) || (report_id == 0)) &&
     338                if((report_des->report_id == report_id) &&
    344339                   (report_des->type == type)) {
    345340                        return report_des;

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

    r3ae26a8 r17d1542  
    605605       
    606606        if(report_id > 0) {
    607                 report_des = usb_hid_report_find_description(report, report_id,
    608                         type);
    609                 if(report_des == NULL) {
    610                         return 0;
    611                 }
    612                 else {
    613                         report_it = report_des->link.next;
    614                 }       
     607                report_it = usb_hid_report_find_description(report, report_id,
     608                        type)->link.next;               
    615609        }
    616610        else {

  • uspace/lib/usbhid/src/hidpath.c

    r3ae26a8 r17d1542  
    211211
    212212        if(report_path->report_id != path->report_id) {
    213                 if(path->report_id != 0) {
    214                         return 1;
    215                 }
     213                return 1;
    216214        }
    217215
Note: See TracChangeset for help on using the changeset viewer.