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


Ignore:
Timestamp:
2011-10-14T12:40:31Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e5024111
Parents:
3002434
Message:

usbhid: Remove tabs on empty lines. diff -w shows no changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3002434 rcc29622  
    6868{
    6969        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    70        
     70
    7171        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    7272            sizeof(usb_hid_subdriver_t));
    … …  
    7474                return ENOMEM;
    7575        }
    76        
     76
    7777        assert(hid_dev->subdriver_count >= 0);
    78        
     78
    7979        // set the init callback
    8080        hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_kbd_init;
    81        
     81
    8282        // set the polling callback
    8383        hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    8484            usb_kbd_polling_callback;
    85        
     85
    8686        // set the polling ended callback
    8787        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    88        
     88
    8989        // set the deinit callback
    9090        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_kbd_deinit;
    91        
     91
    9292        // set subdriver count
    9393        ++hid_dev->subdriver_count;
    94        
     94
    9595        return EOK;
    9696}
    … …  
    101101{
    102102        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    103        
     103
    104104        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    105105            sizeof(usb_hid_subdriver_t));
    … …  
    107107                return ENOMEM;
    108108        }
    109        
     109
    110110        assert(hid_dev->subdriver_count >= 0);
    111        
     111
    112112        // set the init callback
    113113        hid_dev->subdrivers[hid_dev->subdriver_count].init = usb_mouse_init;
    114        
     114
    115115        // set the polling callback
    116116        hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    117117            usb_mouse_polling_callback;
    118        
     118
    119119        // set the polling ended callback
    120120        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    121        
     121
    122122        // set the deinit callback
    123123        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = usb_mouse_deinit;
    124        
     124
    125125        // set subdriver count
    126126        ++hid_dev->subdriver_count;
    127        
     127
    128128        return EOK;
    129129}
    … …  
    134134{
    135135        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    136        
     136
    137137        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    138138            sizeof(usb_hid_subdriver_t));
    … …  
    140140                return ENOMEM;
    141141        }
    142        
     142
    143143        assert(hid_dev->subdriver_count >= 0);
    144        
     144
    145145        // set the init callback
    146146        hid_dev->subdrivers[hid_dev->subdriver_count].init =
    147147            usb_generic_hid_init;
    148        
     148
    149149        // set the polling callback
    150150        hid_dev->subdrivers[hid_dev->subdriver_count].poll =
    151151            usb_generic_hid_polling_callback;
    152        
     152
    153153        // set the polling ended callback
    154154        hid_dev->subdrivers[hid_dev->subdriver_count].poll_end = NULL;
    155        
     155
    156156        // set the deinit callback
    157157        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = NULL;
    158        
     158
    159159        // set subdriver count
    160160        ++hid_dev->subdriver_count;
    161        
     161
    162162        return EOK;
    163163}
    … …  
    170170        assert(hid_dev != NULL);
    171171        assert(hid_dev->usb_dev != NULL);
    172        
     172
    173173        return (hid_dev->usb_dev->descriptors.device.vendor_id
    174174            == mapping->vendor_id
    … …  
    184184        assert(hid_dev != NULL);
    185185        assert(mapping != NULL);
    186        
     186
    187187        usb_hid_report_path_t *usage_path = usb_hid_report_path();
    188188        if (usage_path == NULL) {
    … …  
    202202                ++i;
    203203        }
    204        
     204
    205205        assert(hid_dev->report != NULL);
    206        
     206
    207207        usb_log_debug("Compare flags: %d\n", mapping->compare);
    208        
     208
    209209        bool matches = false;
    210210        uint8_t report_id = mapping->report_id;
    … …  
    234234                    USB_HID_REPORT_TYPE_INPUT);
    235235        } while (!matches && report_id != 0);
    236        
     236
    237237        usb_hid_report_path_free(usage_path);
    238        
     238
    239239        return matches;
    240240}
    … …  
    246246{
    247247        int i;
    248        
     248
    249249        if (count <= 0) {
    250250                hid_dev->subdriver_count = 0;
    … …  
    252252                return EOK;
    253253        }
    254        
     254
    255255        // add one generic HID subdriver per device
    256        
     256
    257257        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
    258258            sizeof(usb_hid_subdriver_t));
    … …  
    260260                return ENOMEM;
    261261        }
    262        
     262
    263263        for (i = 0; i < count; ++i) {
    264264                hid_dev->subdrivers[i].init = subdrivers[i]->init;
    … …  
    267267                hid_dev->subdrivers[i].poll_end = subdrivers[i]->poll_end;
    268268        }
    269        
     269
    270270        hid_dev->subdrivers[count].init = usb_generic_hid_init;
    271271        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
    272272        hid_dev->subdrivers[count].deinit = NULL;
    273273        hid_dev->subdrivers[count].poll_end = NULL;
    274        
     274
    275275        hid_dev->subdriver_count = count + 1;
    276        
     276
    277277        return EOK;
    278278}
    … …  
    283283{
    284284        assert(hid_dev != NULL);
    285        
     285
    286286        const usb_hid_subdriver_t *subdrivers[USB_HID_MAX_SUBDRIVERS];
    287        
     287
    288288        int i = 0, count = 0;
    289289        const usb_hid_subdriver_mapping_t *mapping = &usb_hid_subdrivers[i];
    … …  
    291291        bool ids_matched;
    292292        bool matched;
    293        
     293
    294294        while (count < USB_HID_MAX_SUBDRIVERS &&
    295295            (mapping->usage_path != NULL
    … …  
    339339                mapping = &usb_hid_subdrivers[++i];
    340340        }
    341        
     341
    342342        // we have all subdrivers determined, save them into the hid device
    343343        return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
    … …  
    349349{
    350350        assert(hid_dev != NULL && dev != NULL);
    351        
     351
    352352        int rc = EOK;
    353        
     353
    354354        if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
    355355                usb_log_debug("Found keyboard endpoint.\n");
    … …  
    369369                rc = ENOTSUP;
    370370        }
    371        
     371
    372372        return rc;
    373373}
    … …  
    378378{
    379379        assert(hid_dev != NULL && hid_dev->report != NULL);
    380        
     380
    381381        uint8_t report_id = 0;
    382382        size_t size;
    383        
     383
    384384        size_t max_size = 0;
    385        
     385
    386386        do {
    387387                usb_log_debug("Getting size of the report.\n");
    … …  
    394394                    report_id, USB_HID_REPORT_TYPE_INPUT);
    395395        } while (report_id != 0);
    396        
     396
    397397        usb_log_debug("Max size of input report: %zu\n", max_size);
    398        
     398
    399399        hid_dev->max_input_report_size = max_size;
    400400        assert(hid_dev->input_report == NULL);
    401        
     401
    402402        hid_dev->input_report = malloc(max_size);
    403403        if (hid_dev->input_report == NULL) {
    … …  
    405405        }
    406406        memset(hid_dev->input_report, 0, max_size);
    407        
     407
    408408        return EOK;
    409409}
    … …  
    415415        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)calloc(1,
    416416            sizeof(usb_hid_dev_t));
    417        
     417
    418418        if (hid_dev == NULL) {
    419419                usb_log_fatal("No memory!\n");
    420420                return NULL;
    421421        }
    422        
     422
    423423        hid_dev->report = (usb_hid_report_t *)(malloc(sizeof(
    424424            usb_hid_report_t)));
    … …  
    428428                return NULL;
    429429        }
    430        
     430
    431431        hid_dev->poll_pipe_index = -1;
    432        
     432
    433433        return hid_dev;
    434434}
    … …  
    439439{
    440440        int rc, i;
    441        
     441
    442442        usb_log_debug("Initializing HID structure...\n");
    443        
     443
    444444        if (hid_dev == NULL) {
    445445                usb_log_error("Failed to init HID structure: no structure given"
    … …  
    447447                return EINVAL;
    448448        }
    449        
     449
    450450        if (dev == NULL) {
    451451                usb_log_error("Failed to init HID structure: no USB device"
    … …  
    453453                return EINVAL;
    454454        }
    455        
     455
    456456        /* The USB device should already be initialized, save it in structure */
    457457        hid_dev->usb_dev = dev;
    458        
     458
    459459        rc = usb_hid_check_pipes(hid_dev, dev);
    460460        if (rc != EOK) {
    … …  
    465465        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    466466            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    467        
     467
    468468        bool fallback = false;
    469        
     469
    470470        if (rc == EOK) {
    471471                // try to find subdrivers that may want to handle this device
    … …  
    484484                fallback = true;
    485485        }
    486        
     486
    487487        if (fallback) {
    488488                // fall back to boot protocol
    … …  
    510510                }
    511511        }
    512        
     512
    513513        if (rc != EOK) {
    514514                usb_log_error("No subdriver for handling this device could be"
    … …  
    542542                rc = (ok) ? EOK : -1;   // what error to report
    543543        }
    544        
    545        
     544
     545
    546546        if (rc == EOK) {
    547547                // save max input report size and allocate space for the report
    … …  
    552552                }
    553553        }
    554        
    555        
     554
     555
    556556        return rc;
    557557}
    … …  
    563563{
    564564        int i;
    565        
     565
    566566        if (dev == NULL || arg == NULL || buffer == NULL) {
    567567                usb_log_error("Missing arguments to polling callback.\n");
    568568                return false;
    569569        }
    570        
     570
    571571        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    572        
     572
    573573        assert(hid_dev->input_report != NULL);
    574574        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
    … …  
    582582                usb_hid_new_report(hid_dev);
    583583        }
    584        
     584
    585585        // parse the input report
    586        
     586
    587587        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
    588588            &hid_dev->report_id);
    589        
     589
    590590        if (rc != EOK) {
    591591                usb_log_warning("Error in usb_hid_parse_report():"
    592592                    "%s\n", str_error(rc));
    593593        }       
    594        
     594
    595595        bool cont = false;
    596        
     596
    597597        // continue if at least one of the subdrivers want to continue
    598598        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    … …  
    603603                }
    604604        }
    605        
     605
    606606        return cont;
    607607}
    … …  
    613613{
    614614        int i;
    615        
     615
    616616        if (dev == NULL || arg == NULL) {
    617617                return;
    618618        }
    619        
     619
    620620        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    621        
     621
    622622        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    623623                if (hid_dev->subdrivers[i].poll_end != NULL) {
    … …  
    626626                }
    627627        }
    628        
     628
    629629        usb_hid_destroy(hid_dev);
    630630}
    … …  
    649649{
    650650        int i;
    651        
     651
    652652        if (hid_dev == NULL) {
    653653                return;
    654654        }
    655        
     655
    656656        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
    657657            hid_dev->subdrivers, hid_dev->subdriver_count);
    658        
     658
    659659        assert(hid_dev->subdrivers != NULL
    660660            || hid_dev->subdriver_count == 0);
    661        
     661
    662662        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    663663                if (hid_dev->subdrivers[i].deinit != NULL) {
    … …  
    666666                }
    667667        }
    668        
     668
    669669        // free the subdrivers info
    670670        if (hid_dev->subdrivers != NULL) {
Note: See TracChangeset for help on using the changeset viewer.