Changeset 22ceff3a in mainline for uspace/drv/bus/usb/usbhid/usbhid.c


Ignore:
Timestamp:
2011-10-17T07:29:44Z (13 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
12f55220
Parents:
25696fea (diff), 1f131fb9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge with mainline

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/usbhid/usbhid.c

    r25696fea r22ceff3a  
    5454
    5555/* Array of endpoints expected on the device, NULL terminated. */
    56 usb_endpoint_description_t *usb_hid_endpoints[] = {
     56const usb_endpoint_description_t *usb_hid_endpoints[] = {
    5757        &usb_hid_kbd_poll_endpoint_description,
    5858        &usb_hid_mouse_poll_endpoint_description,
    … …  
    6161};
    6262
    63 static const int USB_HID_MAX_SUBDRIVERS = 10;
    64 
    6563/*----------------------------------------------------------------------------*/
    6664
    6765static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
    6866{
    69         assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    70 
    71         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    72             sizeof(usb_hid_subdriver_t));
     67        assert(hid_dev != NULL);
     68        assert(hid_dev->subdriver_count == 0);
     69
     70        hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
    7371        if (hid_dev->subdrivers == NULL) {
    7472                return ENOMEM;
    7573        }
    76 
    77         assert(hid_dev->subdriver_count >= 0);
    78 
    79         // set the init callback
    80         hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_kbd_init;
    81 
    82         // set the polling callback
    83         hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    84             usb_kbd_polling_callback;
    85 
    86         // set the polling ended callback
    87         hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    88 
    89         // set the deinit callback
    90         hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_kbd_deinit;
    91 
    92         // set subdriver count
    93         ++hid_dev->subdriver_count;
     74        hid_dev->subdriver_count = 1;
     75        // TODO 0 should be keyboard, but find a better way
     76        hid_dev->subdrivers[0] = usb_hid_subdrivers[0].subdriver;
    9477
    9578        return EOK;
    … …  
    10083static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
    10184{
    102         assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    103 
    104         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    105             sizeof(usb_hid_subdriver_t));
     85        assert(hid_dev != NULL);
     86        assert(hid_dev->subdriver_count == 0);
     87
     88        hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
    10689        if (hid_dev->subdrivers == NULL) {
    10790                return ENOMEM;
    10891        }
    109 
    110         assert(hid_dev->subdriver_count >= 0);
    111 
    112         // set the init callback
    113         hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_mouse_init;
    114 
    115         // set the polling callback
    116         hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    117             usb_mouse_polling_callback;
    118 
    119         // set the polling ended callback
    120         hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    121 
    122         // set the deinit callback
    123         hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_mouse_deinit;
    124 
    125         // set subdriver count
    126         ++hid_dev->subdriver_count;
     92        hid_dev->subdriver_count = 1;
     93        // TODO 2 should be mouse, but find a better way
     94        hid_dev->subdrivers[2] = usb_hid_subdrivers[0].subdriver;
    12795
    12896        return EOK;
    … …  
    135103        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    136104
    137         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    138             sizeof(usb_hid_subdriver_t));
     105        hid_dev->subdrivers = malloc(sizeof(usb_hid_subdriver_t));
    139106        if (hid_dev->subdrivers == NULL) {
    140107                return ENOMEM;
    141108        }
    142 
    143         assert(hid_dev->subdriver_count >= 0);
    144 
    145         // set the init callback
    146         hid_dev->subdrivers[hid_dev->subdriver_count].init =
    147             usb_generic_hid_init;
    148 
    149         // set the polling callback
    150         hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    151             usb_generic_hid_polling_callback;
    152 
    153         // set the polling ended callback
    154         hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    155 
    156         // set the deinit callback
    157         hid_dev->subdrivers[hid_dev->subdriver_count].deinit =
    158             usb_generic_hid_deinit;
    159 
    160         // set subdriver count
    161         ++hid_dev->subdriver_count;
     109        hid_dev->subdriver_count = 1;
     110
     111        /* Set generic hid subdriver routines */
     112        hid_dev->subdrivers[0].init = usb_generic_hid_init;
     113        hid_dev->subdrivers[0].poll = usb_generic_hid_polling_callback;
     114        hid_dev->subdrivers[0].poll_end = NULL;
     115        hid_dev->subdrivers[0].deinit = usb_generic_hid_deinit;
    162116
    163117        return EOK;
    … …  
    166120/*----------------------------------------------------------------------------*/
    167121
    168 static bool usb_hid_ids_match(usb_hid_dev_t *hid_dev,
     122static bool usb_hid_ids_match(const usb_hid_dev_t *hid_dev,
    169123    const usb_hid_subdriver_mapping_t *mapping)
    170124{
    … …  
    172126        assert(hid_dev->usb_dev != NULL);
    173127
    174         return (hid_dev->usb_dev->descriptors.device.vendor_id 
     128        return (hid_dev->usb_dev->descriptors.device.vendor_id
    175129            == mapping->vendor_id
    176130            && hid_dev->usb_dev->descriptors.device.product_id
    … …  
    180134/*----------------------------------------------------------------------------*/
    181135
    182 static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev, 
     136static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev,
    183137    const usb_hid_subdriver_mapping_t *mapping)
    184138{
    … …  
    192146        }
    193147        int i = 0;
    194         while (mapping->usage_path[i].usage != 0 
     148        while (mapping->usage_path[i].usage != 0
    195149            || mapping->usage_path[i].usage_page != 0) {
    196                 if (usb_hid_report_path_append_item(usage_path, 
    197                     mapping->usage_path[i].usage_page, 
     150                if (usb_hid_report_path_append_item(usage_path,
     151                    mapping->usage_path[i].usage_page,
    198152                    mapping->usage_path[i].usage) != EOK) {
    199153                        usb_log_debug("Failed to append to usage path.\n");
    … …  
    204158        }
    205159
    206         assert(hid_dev->report != NULL);
    207 
    208160        usb_log_debug("Compare flags: %d\n", mapping->compare);
    209161
    … …  
    213165        do {
    214166                usb_log_debug("Trying report id %u\n", report_id);
    215                
     167
    216168                if (report_id != 0) {
    217169                        usb_hid_report_path_set_report_id(usage_path,
    … …  
    220172
    221173                usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    222                     hid_dev->report,
    223                     NULL, usage_path, mapping->compare,
     174                    &hid_dev->report, NULL, usage_path, mapping->compare,
    224175                    USB_HID_REPORT_TYPE_INPUT);
    225                
     176
    226177                usb_log_debug("Field: %p\n", field);
    227178
    … …  
    230181                        break;
    231182                }
    232                
     183
    233184                report_id = usb_hid_get_next_report_id(
    234                     hid_dev->report, report_id,
    235                     USB_HID_REPORT_TYPE_INPUT);
     185                    &hid_dev->report, report_id, USB_HID_REPORT_TYPE_INPUT);
    236186        } while (!matches && report_id != 0);
    237187
    … …  
    243193/*----------------------------------------------------------------------------*/
    244194
    245 static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev, 
     195static int usb_hid_save_subdrivers(usb_hid_dev_t *hid_dev,
    246196    const usb_hid_subdriver_t **subdrivers, int count)
    247197{
    … …  
    254204        }
    255205
    256         // add one generic HID subdriver per device
    257 
    258         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
    259             sizeof(usb_hid_subdriver_t));
     206        /* +1 for generic hid subdriver */
     207        hid_dev->subdrivers = calloc((count + 1), sizeof(usb_hid_subdriver_t));
    260208        if (hid_dev->subdrivers == NULL) {
    261209                return ENOMEM;
    … …  
    269217        }
    270218
     219        /* Add one generic HID subdriver per device */
    271220        hid_dev->subdrivers[count].init = usb_generic_hid_init;
    272221        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
    … …  
    307256                        return EINVAL;
    308257                }
    309                
     258
    310259                ids_matched = false;
    311260                matched = false;
    312                
     261
    313262                if (mapping->vendor_id >= 0) {
    314263                        assert(mapping->product_id >= 0);
    … …  
    321270                        }
    322271                }
    323                
     272
    324273                if (mapping->usage_path != NULL) {
    325274                        usb_log_debug("Comparing device against usage path.\n");
    … …  
    332281                        matched = ids_matched;
    333282                }
    334                
     283
    335284                if (matched) {
    336285                        usb_log_debug("Subdriver matched.\n");
    337286                        subdrivers[count++] = &mapping->subdriver;
    338287                }
    339                
     288
    340289                mapping = &usb_hid_subdrivers[++i];
    341290        }
    342291
    343         // we have all subdrivers determined, save them into the hid device
     292        /* We have all subdrivers determined, save them into the hid device */
     293        // TODO Dowe really need this complicated stuff if there is
     294        // max_subdrivers limitation?
    344295        return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
    345296}
    … …  
    347298/*----------------------------------------------------------------------------*/
    348299
    349 static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
    350 {
    351         assert(hid_dev != NULL && dev != NULL);
    352 
    353         int rc = EOK;
     300static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, const usb_device_t *dev)
     301{
     302        assert(hid_dev);
     303        assert(dev);
    354304
    355305        if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
    … …  
    368318                usb_log_error("None of supported endpoints found - probably"
    369319                    " not a supported device.\n");
    370                 rc = ENOTSUP;
    371         }
    372 
    373         return rc;
     320                return ENOTSUP;
     321        }
     322
     323        return EOK;
    374324}
    375325
    … …  
    378328static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
    379329{
    380         assert(hid_dev != NULL && hid_dev->report != NULL);
     330        assert(hid_dev != NULL);
    381331
    382332        uint8_t report_id = 0;
    383         size_t size;
    384 
    385333        size_t max_size = 0;
    386334
    387335        do {
    388336                usb_log_debug("Getting size of the report.\n");
    389                 size = usb_hid_report_byte_size(hid_dev->report, report_id,
    390                     USB_HID_REPORT_TYPE_INPUT);
     337                const size_t size =
     338                    usb_hid_report_byte_size(&hid_dev->report, report_id,
     339                        USB_HID_REPORT_TYPE_INPUT);
    391340                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
    392341                max_size = (size > max_size) ? size : max_size;
    393342                usb_log_debug("Getting next report ID\n");
    394                 report_id = usb_hid_get_next_report_id(hid_dev->report,
     343                report_id = usb_hid_get_next_report_id(&hid_dev->report,
    395344                    report_id, USB_HID_REPORT_TYPE_INPUT);
    396345        } while (report_id != 0);
    … …  
    398347        usb_log_debug("Max size of input report: %zu\n", max_size);
    399348
    400         hid_dev->max_input_report_size = max_size;
    401349        assert(hid_dev->input_report == NULL);
    402350
    403         hid_dev->input_report = malloc(max_size);
     351        hid_dev->input_report = calloc(1, max_size);
    404352        if (hid_dev->input_report == NULL) {
    405353                return ENOMEM;
    406354        }
    407         memset(hid_dev->input_report, 0, max_size);
     355        hid_dev->max_input_report_size = max_size;
    408356
    409357        return EOK;
    … …  
    430378        }
    431379
    432         hid_dev->report = (usb_hid_report_t *)(malloc(sizeof(
    433             usb_hid_report_t)));
    434         if (hid_dev->report == NULL) {
    435                 usb_log_error("No memory!\n");
    436                 return ENOMEM;
    437         }
    438         usb_hid_report_init(hid_dev->report);
     380        usb_hid_report_init(&hid_dev->report);
    439381
    440382        /* The USB device should already be initialized, save it in structure */
    … …  
    446388                return rc;
    447389        }
    448                
     390
    449391        /* Get the report descriptor and parse it. */
    450         rc = usb_hid_process_report_descriptor(hid_dev->usb_dev, 
    451             hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
     392        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
     393            &hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    452394
    453395        bool fallback = false;
    … …  
    488430                        break;
    489431                default:
    490                         assert(hid_dev->poll_pipe_index 
     432                        assert(hid_dev->poll_pipe_index
    491433                            == USB_HID_GENERIC_POLL_EP_NO);
    492                        
     434
    493435                        usb_log_info("Falling back to generic HID driver.\n");
    494436                        rc = usb_hid_set_generic_hid_subdriver(hid_dev);
    … …  
    499441                usb_log_error("No subdriver for handling this device could be"
    500442                    " initialized: %s.\n", str_error(rc));
    501                 usb_log_debug("Subdriver count: %d\n", 
     443                usb_log_debug("Subdriver count: %d\n",
    502444                    hid_dev->subdriver_count);
    503                
    504445        } else {
    505446                bool ok = false;
    506                
    507                 usb_log_debug("Subdriver count: %d\n", 
     447
     448                usb_log_debug("Subdriver count: %d\n",
    508449                    hid_dev->subdriver_count);
    509                
     450
    510451                for (i = 0; i < hid_dev->subdriver_count; ++i) {
    511452                        if (hid_dev->subdrivers[i].init != NULL) {
    … …  
    524465                        }
    525466                }
    526                
     467
    527468                rc = (ok) ? EOK : -1;   // what error to report
    528469        }
    … …  
    538479        }
    539480
    540 
    541481        return rc;
    542482}
    … …  
    544484/*----------------------------------------------------------------------------*/
    545485
    546 bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer, 
     486bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
    547487    size_t buffer_size, void *arg)
    548488{
    549         int i;
    550 
    551489        if (dev == NULL || arg == NULL || buffer == NULL) {
    552490                usb_log_error("Missing arguments to polling callback.\n");
    553491                return false;
    554492        }
    555 
    556         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
     493        usb_hid_dev_t *hid_dev = arg;
    557494
    558495        assert(hid_dev->input_report != NULL);
     496
    559497        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
    560498            hid_dev->max_input_report_size,
    … …  
    568506        }
    569507
    570         // parse the input report
    571 
    572         int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
    573             &hid_dev->report_id);
    574 
     508        /* Parse the input report */
     509        const int rc = usb_hid_parse_report(
     510            &hid_dev->report, buffer, buffer_size, &hid_dev->report_id);
    575511        if (rc != EOK) {
    576512                usb_log_warning("Error in usb_hid_parse_report():"
    577513                    "%s\n", str_error(rc));
    578         }       
     514        }
    579515
    580516        bool cont = false;
    581 
    582         // continue if at least one of the subdrivers want to continue
    583         for (i = 0; i < hid_dev->subdriver_count; ++i) {
    584                 if (hid_dev->subdrivers[i].poll != NULL
    585                     && hid_dev->subdrivers[i].poll(hid_dev,
    586                         hid_dev->subdrivers[i].data)) {
    587                         cont = true;
     517        /* Continue if at least one of the subdrivers want to continue */
     518        for (int i = 0; i < hid_dev->subdriver_count; ++i) {
     519                if (hid_dev->subdrivers[i].poll != NULL) {
     520                        cont = cont || hid_dev->subdrivers[i].poll(
     521                            hid_dev, hid_dev->subdrivers[i].data);
    588522                }
    589523        }
    … …  
    594528/*----------------------------------------------------------------------------*/
    595529
    596 void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason,
    597      void *arg)
    598 {
    599         int i;
    600 
    601         if (dev == NULL || arg == NULL) {
    602                 return;
    603         }
    604 
    605         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    606 
    607         for (i = 0; i < hid_dev->subdriver_count; ++i) {
     530void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg)
     531{
     532        assert(dev);
     533        assert(arg);
     534
     535        usb_hid_dev_t *hid_dev = arg;
     536
     537        for (int i = 0; i < hid_dev->subdriver_count; ++i) {
    608538                if (hid_dev->subdrivers[i].poll_end != NULL) {
    609                         hid_dev->subdrivers[i].poll_end(hid_dev,
    610                             hid_dev->subdrivers[i].data, reason);
     539                        hid_dev->subdrivers[i].poll_end(
     540                            hid_dev, hid_dev->subdrivers[i].data, reason);
    611541                }
    612542        }
    … …  
    624554/*----------------------------------------------------------------------------*/
    625555
    626 int usb_hid_report_number(usb_hid_dev_t *hid_dev)
     556int usb_hid_report_number(const usb_hid_dev_t *hid_dev)
    627557{
    628558        return hid_dev->report_nr;
    … …  
    631561/*----------------------------------------------------------------------------*/
    632562
    633 void usb_hid_destroy(usb_hid_dev_t *hid_dev)
    634 {
    635         int i;
    636 
    637         if (hid_dev == NULL) {
    638                 return;
    639         }
     563void usb_hid_deinit(usb_hid_dev_t *hid_dev)
     564{
     565        assert(hid_dev);
     566        assert(hid_dev->subdrivers != NULL || hid_dev->subdriver_count == 0);
     567
    640568
    641569        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
    642570            hid_dev->subdrivers, hid_dev->subdriver_count);
    643571
    644         assert(hid_dev->subdrivers != NULL
    645             || hid_dev->subdriver_count == 0);
    646 
    647         for (i = 0; i < hid_dev->subdriver_count; ++i) {
     572        for (int i = 0; i < hid_dev->subdriver_count; ++i) {
    648573                if (hid_dev->subdrivers[i].deinit != NULL) {
    649574                        hid_dev->subdrivers[i].deinit(hid_dev,
    … …  
    657582
    658583        /* Destroy the parser */
    659         if (hid_dev->report != NULL) {
    660                 usb_hid_free_report(hid_dev->report);
    661         }
     584        usb_hid_report_deinit(&hid_dev->report);
    662585
    663586}
Note: See TracChangeset for help on using the changeset viewer.