Changes in / [b9e3aa3:8357fc9] in mainline


Ignore:
Location:
uspace
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/mkbd/main.c

    rb9e3aa3 r8357fc9  
    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        }

  • uspace/drv/usbhid/usbhid.c

    rb9e3aa3 r8357fc9  
    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;
    … …  
    259249        }
    260250       
    261         usb_log_debug("Size of the input report: %zu\n", size);
     251        usb_log_debug("Size of the input report: %zuB\n", size);
    262252        usb_hid_report_path_free(usage_path);
    263253       
    … …  
    411401       
    412402        do {
    413                 usb_log_debug("Getting size of the report.\n");
    414403                size = usb_hid_report_byte_size(hid_dev->report, report_id,
    415404                    USB_HID_REPORT_TYPE_INPUT);
    416405                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
    417406                max_size = (size > max_size) ? size : max_size;
    418                 usb_log_debug("Getting next report ID\n");
    419407                report_id = usb_hid_get_next_report_id(hid_dev->report,
    420408                    report_id, USB_HID_REPORT_TYPE_INPUT);
    … …  
    546534                    hid_dev->subdriver_count);
    547535                //usb_hid_free(&hid_dev);
    548                
    549536        } else {
    550537                bool ok = false;
    … …  
    573560        }
    574561       
    575        
    576         if (rc == EOK) {
    577                 // save max input report size and allocate space for the report
    578                 rc = usb_hid_init_report(hid_dev);
    579                 if (rc != EOK) {
    580                         usb_log_error("Failed to initialize input report buffer"
    581                             ".\n");
    582                 }
    583         }
    584        
     562        // save max input report size and allocate space for the report
     563        rc = usb_hid_init_report(hid_dev);
     564        if (rc != EOK) {
     565                usb_log_error("Failed to initialize input report buffer.\n");
     566        }
    585567       
    586568        return rc;
    … …  
    605587        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
    606588            hid_dev->max_input_report_size, buffer_size);
    607         //assert(hid_dev->max_input_report_size >= buffer_size);
    608         if (hid_dev->max_input_report_size >= buffer_size) {
    609                 /*! @todo This should probably be atomic. */
    610                 memcpy(hid_dev->input_report, buffer, buffer_size);
    611                 hid_dev->input_report_size = buffer_size;
    612                 usb_hid_new_report(hid_dev);
    613         }
     589        assert(hid_dev->max_input_report_size >= buffer_size);
     590       
     591//      if (/*!allocated*/
     592//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
     593//              uint8_t *input_old = hid_dev->input_report;
     594//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
     595               
     596//              if (input_new == NULL) {
     597//                      usb_log_error("Failed to allocate space for input "
     598//                          "buffer. This event may not be reported\n");
     599//                      memset(hid_dev->input_report, 0,
     600//                          hid_dev->input_report_size);
     601//              } else {
     602//                      memcpy(input_new, input_old,
     603//                          hid_dev->input_report_size);
     604//                      hid_dev->input_report = input_new;
     605//                      if (allocated) {
     606//                              free(input_old);
     607//                      }
     608//                      usb_hid_new_report();
     609//              }
     610//      }
     611       
     612        /*! @todo This should probably be atomic. */
     613        memcpy(hid_dev->input_report, buffer, buffer_size);
     614        hid_dev->input_report_size = buffer_size;
     615        usb_hid_new_report(hid_dev);
    614616       
    615617        bool cont = false;
Note: See TracChangeset for help on using the changeset viewer.