Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/usbhid/usbhid.c

    rfaa44e58 ra9cdca0  
    203203       
    204204        usb_log_debug("Compare flags: %d\n", mapping->compare);
    205         size_t size = usb_hid_report_input_length(hid_dev->report, usage_path,
    206             mapping->compare);
     205//      size_t size = usb_hid_report_size(hid_dev->report, 0,
     206//          USB_HID_REPORT_TYPE_INPUT);
     207        size_t size = 0;
     208        usb_hid_report_field_t *field = usb_hid_report_get_sibling (hid_dev->report,
     209                NULL, usage_path, mapping->compare, USB_HID_REPORT_TYPE_INPUT);
     210        while(field != NULL) {
     211                size++;
     212                field = usb_hid_report_get_sibling (hid_dev->report,
     213                                        field, usage_path, mapping->compare,
     214                            USB_HID_REPORT_TYPE_INPUT);
     215        }
     216       
    207217        usb_log_debug("Size of the input report: %zuB\n", size);
    208        
    209218        usb_hid_report_path_free(usage_path);
    210219       
    … …  
    225234        }
    226235       
    227         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(count *
     236        // add one generic HID subdriver per device
     237       
     238        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
    228239            sizeof(usb_hid_subdriver_t));
    229240        if (hid_dev->subdrivers == NULL) {
    … …  
    238249        }
    239250       
    240         hid_dev->subdriver_count = count;
     251        hid_dev->subdrivers[count].init = usb_generic_hid_init;
     252        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
     253        hid_dev->subdrivers[count].deinit = NULL;
     254        hid_dev->subdrivers[count].poll_end = NULL;
     255       
     256        hid_dev->subdriver_count = count + 1;
    241257       
    242258        return EOK;
    … …  
    298314               
    299315                if (matched) {
     316                        usb_log_debug("Subdriver matched.\n");
    300317                        subdrivers[count++] = &mapping->subdriver;
    301318                }
    … …  
    339356/*----------------------------------------------------------------------------*/
    340357
     358static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
     359{
     360        assert(hid_dev != NULL && hid_dev->report != NULL);
     361       
     362        uint8_t report_id = 0;
     363        size_t size = usb_hid_report_byte_size(hid_dev->report, report_id,
     364            USB_HID_REPORT_TYPE_INPUT);
     365       
     366        size_t max_size = 0;
     367       
     368        do {
     369                max_size = (size > max_size) ? size : max_size;
     370                size = usb_hid_report_byte_size(hid_dev->report, report_id,
     371                    USB_HID_REPORT_TYPE_INPUT);
     372                report_id = usb_hid_get_next_report_id(hid_dev->report,
     373                    report_id, USB_HID_REPORT_TYPE_INPUT);
     374        } while (report_id != 0);
     375       
     376        usb_log_debug("Max size of input report: %zu\n", max_size);
     377       
     378        hid_dev->max_input_report_size = max_size;
     379        assert(hid_dev->input_report == NULL);
     380       
     381        hid_dev->input_report = malloc(max_size);
     382        if (hid_dev->input_report == NULL) {
     383                return ENOMEM;
     384        }
     385        memset(hid_dev->input_report, 0, max_size);
     386       
     387        return EOK;
     388}
     389
     390/*----------------------------------------------------------------------------*/
     391
    341392usb_hid_dev_t *usb_hid_new(void)
    342393{
    … …  
    393444        /* Get the report descriptor and parse it. */
    394445        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    395             hid_dev->report);
     446            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    396447       
    397448        bool fallback = false;
    … …  
    457508                        if (hid_dev->subdrivers[i].init != NULL) {
    458509                                usb_log_debug("Initializing subdriver %d.\n",i);
    459                                 rc = hid_dev->subdrivers[i].init(hid_dev);
     510                                rc = hid_dev->subdrivers[i].init(hid_dev,
     511                                    &hid_dev->subdrivers[i].data);
    460512                                if (rc != EOK) {
    461513                                        usb_log_warning("Failed to initialize"
    … …  
    473525        }
    474526       
     527        // save max input report size and allocate space for the report
     528        rc = usb_hid_init_report(hid_dev);
     529        if (rc != EOK) {
     530                usb_log_error("Failed to initialize input report buffer.\n");
     531        }
     532       
    475533        return rc;
    476534}
    … …  
    490548        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    491549       
    492         int allocated = (hid_dev->input_report != NULL);
    493        
    494         if (!allocated
    495             || hid_dev->input_report_size < buffer_size) {
    496                 uint8_t *input_old = hid_dev->input_report;
    497                 uint8_t *input_new = (uint8_t *)malloc(buffer_size);
    498                
    499                 if (input_new == NULL) {
    500                         usb_log_error("Failed to allocate space for input "
    501                             "buffer. This event may not be reported\n");
    502                         memset(hid_dev->input_report, 0,
    503                             hid_dev->input_report_size);
    504                 } else {
    505                         memcpy(input_new, input_old,
    506                             hid_dev->input_report_size);
    507                         hid_dev->input_report = input_new;
    508                         if (allocated) {
    509                                 free(input_old);
    510                         }
    511                         usb_hid_new_report();
    512                 }
    513         }
     550//      int allocated = (hid_dev->input_report != NULL);
     551        assert(hid_dev->input_report != NULL);
     552        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
     553            hid_dev->max_input_report_size, buffer_size);
     554        assert(hid_dev->max_input_report_size >= buffer_size);
     555       
     556//      if (/*!allocated*/
     557//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
     558//              uint8_t *input_old = hid_dev->input_report;
     559//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
     560               
     561//              if (input_new == NULL) {
     562//                      usb_log_error("Failed to allocate space for input "
     563//                          "buffer. This event may not be reported\n");
     564//                      memset(hid_dev->input_report, 0,
     565//                          hid_dev->input_report_size);
     566//              } else {
     567//                      memcpy(input_new, input_old,
     568//                          hid_dev->input_report_size);
     569//                      hid_dev->input_report = input_new;
     570//                      if (allocated) {
     571//                              free(input_old);
     572//                      }
     573//                      usb_hid_new_report();
     574//              }
     575//      }
    514576       
    515577        /*! @todo This should probably be atomic. */
    516578        memcpy(hid_dev->input_report, buffer, buffer_size);
    517579        hid_dev->input_report_size = buffer_size;
     580        usb_hid_new_report();
    518581       
    519582        bool cont = false;
    … …  
    522585        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    523586                if (hid_dev->subdrivers[i].poll != NULL
    524                     && hid_dev->subdrivers[i].poll(hid_dev, buffer,
    525                     buffer_size)) {
     587                    && hid_dev->subdrivers[i].poll(hid_dev,
     588                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
    526589                        cont = true;
    527590                }
    … …  
    546609        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    547610                if (hid_dev->subdrivers[i].poll_end != NULL) {
    548                         hid_dev->subdrivers[i].poll_end(hid_dev, reason);
     611                        hid_dev->subdrivers[i].poll_end(hid_dev,
     612                            hid_dev->subdrivers[i].data, reason);
    549613                }
    550614        }
    … …  
    627691        for (i = 0; i < (*hid_dev)->subdriver_count; ++i) {
    628692                if ((*hid_dev)->subdrivers[i].deinit != NULL) {
    629                         (*hid_dev)->subdrivers[i].deinit(*hid_dev);
     693                        (*hid_dev)->subdrivers[i].deinit(*hid_dev,
     694                            (*hid_dev)->subdrivers[i].data);
    630695                }
    631696        }
Note: See TracChangeset for help on using the changeset viewer.