Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r065064e6 r5f6e25e  
    5454
    5555/* Array of endpoints expected on the device, NULL terminated. */
    56 usb_endpoint_description_t *usb_hid_endpoints[] = {
     56usb_endpoint_description_t *usb_hid_endpoints[USB_HID_POLL_EP_COUNT + 1] = {
    5757        &usb_hid_kbd_poll_endpoint_description,
    5858        &usb_hid_mouse_poll_endpoint_description,
    … …  
    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
    157         hid_dev->subdrivers[hid_dev->subdriver_count].deinit =
    158             usb_generic_hid_deinit;
    159 
     157        hid_dev->subdrivers[hid_dev->subdriver_count].deinit = NULL;
     158       
    160159        // set subdriver count
    161160        ++hid_dev->subdriver_count;
    162 
     161       
    163162        return EOK;
    164163}
    … …  
    171170        assert(hid_dev != NULL);
    172171        assert(hid_dev->usb_dev != NULL);
    173 
     172       
    174173        return (hid_dev->usb_dev->descriptors.device.vendor_id
    175174            == mapping->vendor_id
    … …  
    185184        assert(hid_dev != NULL);
    186185        assert(mapping != NULL);
    187 
     186       
    188187        usb_hid_report_path_t *usage_path = usb_hid_report_path();
    189188        if (usage_path == NULL) {
    … …  
    203202                ++i;
    204203        }
    205 
     204       
    206205        assert(hid_dev->report != NULL);
    207 
     206       
    208207        usb_log_debug("Compare flags: %d\n", mapping->compare);
    209 
     208       
    210209        bool matches = false;
    211210        uint8_t report_id = mapping->report_id;
    … …  
    235234                    USB_HID_REPORT_TYPE_INPUT);
    236235        } while (!matches && report_id != 0);
    237 
     236       
    238237        usb_hid_report_path_free(usage_path);
    239 
     238       
    240239        return matches;
    241240}
    … …  
    247246{
    248247        int i;
    249 
     248       
    250249        if (count <= 0) {
    251250                hid_dev->subdriver_count = 0;
    … …  
    253252                return EOK;
    254253        }
    255 
     254       
    256255        // add one generic HID subdriver per device
    257 
     256       
    258257        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
    259258            sizeof(usb_hid_subdriver_t));
    … …  
    261260                return ENOMEM;
    262261        }
    263 
     262       
    264263        for (i = 0; i < count; ++i) {
    265264                hid_dev->subdrivers[i].init = subdrivers[i]->init;
    … …  
    268267                hid_dev->subdrivers[i].poll_end = subdrivers[i]->poll_end;
    269268        }
    270 
     269       
    271270        hid_dev->subdrivers[count].init = usb_generic_hid_init;
    272271        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
    273         hid_dev->subdrivers[count].deinit = usb_generic_hid_deinit;
     272        hid_dev->subdrivers[count].deinit = NULL;
    274273        hid_dev->subdrivers[count].poll_end = NULL;
    275 
     274       
    276275        hid_dev->subdriver_count = count + 1;
    277 
     276       
    278277        return EOK;
    279278}
    … …  
    284283{
    285284        assert(hid_dev != NULL);
    286 
     285       
    287286        const usb_hid_subdriver_t *subdrivers[USB_HID_MAX_SUBDRIVERS];
    288 
     287       
    289288        int i = 0, count = 0;
    290289        const usb_hid_subdriver_mapping_t *mapping = &usb_hid_subdrivers[i];
    … …  
    292291        bool ids_matched;
    293292        bool matched;
    294 
     293       
    295294        while (count < USB_HID_MAX_SUBDRIVERS &&
    296295            (mapping->usage_path != NULL
    … …  
    340339                mapping = &usb_hid_subdrivers[++i];
    341340        }
    342 
     341       
    343342        // we have all subdrivers determined, save them into the hid device
    344343        return usb_hid_save_subdrivers(hid_dev, subdrivers, count);
    … …  
    350349{
    351350        assert(hid_dev != NULL && dev != NULL);
    352 
     351       
    353352        int rc = EOK;
    354 
     353       
    355354        if (dev->pipes[USB_HID_KBD_POLL_EP_NO].present) {
    356355                usb_log_debug("Found keyboard endpoint.\n");
    … …  
    370369                rc = ENOTSUP;
    371370        }
    372 
     371       
    373372        return rc;
    374373}
    … …  
    379378{
    380379        assert(hid_dev != NULL && hid_dev->report != NULL);
    381 
     380       
    382381        uint8_t report_id = 0;
    383382        size_t size;
    384 
     383       
    385384        size_t max_size = 0;
    386 
     385       
    387386        do {
    388387                usb_log_debug("Getting size of the report.\n");
    … …  
    395394                    report_id, USB_HID_REPORT_TYPE_INPUT);
    396395        } while (report_id != 0);
    397 
     396       
    398397        usb_log_debug("Max size of input report: %zu\n", max_size);
    399 
     398       
    400399        hid_dev->max_input_report_size = max_size;
    401400        assert(hid_dev->input_report == NULL);
    402 
     401       
    403402        hid_dev->input_report = malloc(max_size);
    404403        if (hid_dev->input_report == NULL) {
    … …  
    406405        }
    407406        memset(hid_dev->input_report, 0, max_size);
    408 
     407       
    409408        return EOK;
    410409}
    … …  
    412411/*----------------------------------------------------------------------------*/
    413412
     413usb_hid_dev_t *usb_hid_new(void)
     414{
     415        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)calloc(1,
     416            sizeof(usb_hid_dev_t));
     417       
     418        if (hid_dev == NULL) {
     419                usb_log_fatal("No memory!\n");
     420                return NULL;
     421        }
     422       
     423        hid_dev->report = (usb_hid_report_t *)(malloc(sizeof(
     424            usb_hid_report_t)));
     425        if (hid_dev->report == NULL) {
     426                usb_log_fatal("No memory!\n");
     427                free(hid_dev);
     428                return NULL;
     429        }
     430       
     431        hid_dev->poll_pipe_index = -1;
     432       
     433        return hid_dev;
     434}
     435
     436/*----------------------------------------------------------------------------*/
     437
    414438int usb_hid_init(usb_hid_dev_t *hid_dev, usb_device_t *dev)
    415439{
    416440        int rc, i;
    417 
     441       
    418442        usb_log_debug("Initializing HID structure...\n");
    419 
     443       
    420444        if (hid_dev == NULL) {
    421445                usb_log_error("Failed to init HID structure: no structure given"
    … …  
    423447                return EINVAL;
    424448        }
    425 
     449       
    426450        if (dev == NULL) {
    427451                usb_log_error("Failed to init HID structure: no USB device"
    … …  
    429453                return EINVAL;
    430454        }
    431 
    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);
    439 
     455       
    440456        /* The USB device should already be initialized, save it in structure */
    441457        hid_dev->usb_dev = dev;
    442         hid_dev->poll_pipe_index = -1;
    443 
     458       
    444459        rc = usb_hid_check_pipes(hid_dev, dev);
    445460        if (rc != EOK) {
    … …  
    450465        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    451466            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    452 
     467       
    453468        bool fallback = false;
    454 
     469       
    455470        if (rc == EOK) {
    456471                // try to find subdrivers that may want to handle this device
    … …  
    469484                fallback = true;
    470485        }
    471 
     486       
    472487        if (fallback) {
    473488                // fall back to boot protocol
    … …  
    495510                }
    496511        }
    497 
     512       
    498513        if (rc != EOK) {
    499514                usb_log_error("No subdriver for handling this device could be"
    … …  
    527542                rc = (ok) ? EOK : -1;   // what error to report
    528543        }
    529 
    530 
     544       
     545       
    531546        if (rc == EOK) {
    532547                // save max input report size and allocate space for the report
    … …  
    537552                }
    538553        }
    539 
    540 
     554       
     555       
    541556        return rc;
    542557}
    … …  
    548563{
    549564        int i;
    550 
     565       
    551566        if (dev == NULL || arg == NULL || buffer == NULL) {
    552567                usb_log_error("Missing arguments to polling callback.\n");
    553568                return false;
    554569        }
    555 
     570       
    556571        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    557 
     572       
    558573        assert(hid_dev->input_report != NULL);
    559574        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
    … …  
    567582                usb_hid_new_report(hid_dev);
    568583        }
    569 
     584       
    570585        // parse the input report
    571 
     586       
    572587        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
    573588            &hid_dev->report_id);
    574 
     589       
    575590        if (rc != EOK) {
    576591                usb_log_warning("Error in usb_hid_parse_report():"
    577592                    "%s\n", str_error(rc));
    578593        }       
    579 
     594       
    580595        bool cont = false;
    581 
     596       
    582597        // continue if at least one of the subdrivers want to continue
    583598        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    … …  
    588603                }
    589604        }
    590 
     605       
    591606        return cont;
    592607}
    … …  
    598613{
    599614        int i;
    600 
     615       
    601616        if (dev == NULL || arg == NULL) {
    602617                return;
    603618        }
    604 
     619       
    605620        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    606 
     621       
    607622        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    608623                if (hid_dev->subdrivers[i].poll_end != NULL) {
    … …  
    611626                }
    612627        }
    613 
    614         hid_dev->running = false;
     628       
     629        usb_hid_destroy(hid_dev);
    615630}
    616631
    … …  
    634649{
    635650        int i;
    636 
     651       
    637652        if (hid_dev == NULL) {
    638653                return;
    639654        }
    640 
     655       
    641656        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
    642657            hid_dev->subdrivers, hid_dev->subdriver_count);
    643 
     658       
    644659        assert(hid_dev->subdrivers != NULL
    645660            || hid_dev->subdriver_count == 0);
    646 
     661       
    647662        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    648663                if (hid_dev->subdrivers[i].deinit != NULL) {
    … …  
    651666                }
    652667        }
    653 
    654         /* Free allocated structures */
    655         free(hid_dev->subdrivers);
    656         free(hid_dev->report_desc);
    657 
    658         /* Destroy the parser */
     668       
     669        // free the subdrivers info
     670        if (hid_dev->subdrivers != NULL) {
     671                free(hid_dev->subdrivers);
     672        }
     673
     674        // destroy the parser
    659675        if (hid_dev->report != NULL) {
    660676                usb_hid_free_report(hid_dev->report);
    661677        }
    662678
     679        if (hid_dev->report_desc != NULL) {
     680                free(hid_dev->report_desc);
     681        }
    663682}
    664683
Note: See TracChangeset for help on using the changeset viewer.