Changeset 1f131fb9 in mainline for uspace/drv/bus/usb/usbhid/usbhid.c


Ignore:
Timestamp:
2011-10-16T19:38:53Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
22ceff3a, e5291e0
Parents:
98fb010 (diff), 93d2684 (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:

Minor USB changes.

Add more const qualifiers where possible.
Do not limit the number possible usbhid subdrivers.
This should not break anything. If it does feel free to revert this merge.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r98fb010 r1f131fb9  
    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.