Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/hid/usbhid/usbhid.c

    re0a5d4c rb7fd2a0  
    11/*
    22 * Copyright (c) 2011 Lubos Slovak
    3  * Copyright (c) 2018 Petr Manek, Ondrej Hlavaty
    43 * All rights reserved.
    54 *
    … …  
    135134        usb_hid_report_path_t *usage_path = usb_hid_report_path();
    136135        if (usage_path == NULL) {
    137                 usb_log_debug("Failed to create usage path.");
     136                usb_log_debug("Failed to create usage path.\n");
    138137                return false;
    139138        }
    … …  
    144143                    mapping->usage_path[i].usage_page,
    145144                    mapping->usage_path[i].usage) != EOK) {
    146                         usb_log_debug("Failed to append to usage path.");
     145                        usb_log_debug("Failed to append to usage path.\n");
    147146                        usb_hid_report_path_free(usage_path);
    148147                        return false;
    … …  
    150149        }
    151150
    152         usb_log_debug("Compare flags: %d", mapping->compare);
     151        usb_log_debug("Compare flags: %d\n", mapping->compare);
    153152
    154153        bool matches = false;
    … …  
    156155
    157156        do {
    158                 usb_log_debug("Trying report id %u", report_id);
     157                usb_log_debug("Trying report id %u\n", report_id);
    159158                if (report_id != 0) {
    160159                        usb_hid_report_path_set_report_id(usage_path,
    … …  
    167166                        USB_HID_REPORT_TYPE_INPUT);
    168167
    169                 usb_log_debug("Field: %p", field);
     168                usb_log_debug("Field: %p\n", field);
    170169
    171170                if (field != NULL) {
    … …  
    244243                            mapping->product_id);
    245244                        if (usb_hid_ids_match(hid_dev, mapping)) {
    246                                 usb_log_debug("IDs matched.");
     245                                usb_log_debug("IDs matched.\n");
    247246                                matched = true;
    248247                        }
    … …  
    251250                /* Check usage match. */
    252251                if (mapping->usage_path != NULL) {
    253                         usb_log_debug("Comparing device against usage path.");
     252                        usb_log_debug("Comparing device against usage path.\n");
    254253                        if (usb_hid_path_matches(hid_dev, mapping)) {
    255254                                /* Does not matter if IDs were matched. */
    … …  
    259258
    260259                if (matched) {
    261                         usb_log_debug("Subdriver matched.");
     260                        usb_log_debug("Subdriver matched.\n");
    262261                        subdrivers[count++] = &mapping->subdriver;
    263262                }
    … …  
    286285                    usb_device_get_mapped_ep_desc(dev, endpoints[i].desc);
    287286                if (epm && epm->present) {
    288                         usb_log_debug("Found: %s.", endpoints[i].description);
     287                        usb_log_debug("Found: %s.\n", endpoints[i].description);
    289288                        hid_dev->poll_pipe_mapping = epm;
    290289                        return EOK;
    … …  
    302301
    303302        do {
    304                 usb_log_debug("Getting size of the report.");
     303                usb_log_debug("Getting size of the report.\n");
    305304                const size_t size =
    306305                    usb_hid_report_byte_size(&hid_dev->report, report_id,
    307306                        USB_HID_REPORT_TYPE_INPUT);
    308                 usb_log_debug("Report ID: %u, size: %zu", report_id, size);
     307                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
    309308                max_size = (size > max_size) ? size : max_size;
    310                 usb_log_debug("Getting next report ID");
     309                usb_log_debug("Getting next report ID\n");
    311310                report_id = usb_hid_get_next_report_id(&hid_dev->report,
    312311                    report_id, USB_HID_REPORT_TYPE_INPUT);
    313312        } while (report_id != 0);
    314313
    315         usb_log_debug("Max size of input report: %zu", max_size);
     314        usb_log_debug("Max size of input report: %zu\n", max_size);
    316315
    317316        assert(hid_dev->input_report == NULL);
    … …  
    324323
    325324        return EOK;
    326 }
    327 
    328 static bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
    329     size_t buffer_size, void *arg)
    330 {
    331         if (dev == NULL || arg == NULL || buffer == NULL) {
    332                 usb_log_error("Missing arguments to polling callback.");
    333                 return false;
    334         }
    335         usb_hid_dev_t *hid_dev = arg;
    336 
    337         assert(hid_dev->input_report != NULL);
    338 
    339         usb_log_debug("New data [%zu/%zu]: %s", buffer_size,
    340             hid_dev->max_input_report_size,
    341             usb_debug_str_buffer(buffer, buffer_size, 0));
    342 
    343         if (hid_dev->max_input_report_size >= buffer_size) {
    344                 /*! @todo This should probably be atomic. */
    345                 memcpy(hid_dev->input_report, buffer, buffer_size);
    346                 hid_dev->input_report_size = buffer_size;
    347                 usb_hid_new_report(hid_dev);
    348         }
    349 
    350         /* Parse the input report */
    351         const errno_t rc = usb_hid_parse_report(
    352             &hid_dev->report, buffer, buffer_size, &hid_dev->report_id);
    353         if (rc != EOK) {
    354                 usb_log_warning("Failure in usb_hid_parse_report():"
    355                     "%s\n", str_error(rc));
    356         }
    357 
    358         bool cont = false;
    359         /* Continue if at least one of the subdrivers want to continue */
    360         for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
    361                 if (hid_dev->subdrivers[i].poll != NULL) {
    362                         cont = cont || hid_dev->subdrivers[i].poll(
    363                             hid_dev, hid_dev->subdrivers[i].data);
    364                 }
    365         }
    366 
    367         return cont;
    368 }
    369 
    370 static bool usb_hid_polling_error_callback(usb_device_t *dev, errno_t err_code, void *arg)
    371 {
    372         assert(dev);
    373         assert(arg);
    374         usb_hid_dev_t *hid_dev = arg;
    375 
    376         usb_log_error("Device %s polling error: %s", usb_device_get_name(dev),
    377             str_error(err_code));
    378 
    379         /* Continue polling until the device is about to be removed. */
    380         return hid_dev->running;
    381 }
    382 
    383 static void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg)
    384 {
    385         assert(dev);
    386         assert(arg);
    387 
    388         usb_hid_dev_t *hid_dev = arg;
    389 
    390         for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
    391                 if (hid_dev->subdrivers[i].poll_end != NULL) {
    392                         hid_dev->subdrivers[i].poll_end(
    393                             hid_dev, hid_dev->subdrivers[i].data, reason);
    394                 }
    395         }
    396 
    397         hid_dev->running = false;
    398325}
    399326
    … …  
    405332 * During initialization, the keyboard is switched into boot protocol, the idle
    406333 * rate is set to 0 (infinity), resulting in the keyboard only reporting event
    407  * when a key is pressed or released. Finally, the LED lights are turned on
     334 * when a key is pressed or released. Finally, the LED lights are turned on 
    408335 * according to the default setup of lock keys.
    409336 *
    410  * @note By default, the keyboards is initialized with Num Lock turned on and
     337 * @note By default, the keyboards is initialized with Num Lock turned on and 
    411338 *       other locks turned off.
    412339 *
    … …  
    420347        assert(dev);
    421348
    422         usb_log_debug("Initializing HID structure...");
     349        usb_log_debug("Initializing HID structure...\n");
    423350
    424351        usb_hid_report_init(&hid_dev->report);
    … …  
    442369                usb_hid_find_subdrivers(hid_dev);
    443370        } else {
    444                 usb_log_error("Failed to parse report descriptor: fallback.");
     371                usb_log_error("Failed to parse report descriptor: fallback.\n");
    445372                hid_dev->subdrivers = NULL;
    446373                hid_dev->subdriver_count = 0;
    447374        }
    448375
    449         usb_log_debug("Subdriver count(before trying boot protocol): %d",
     376        usb_log_debug("Subdriver count(before trying boot protocol): %d\n",
    450377            hid_dev->subdriver_count);
    451378
    … …  
    458385                switch (hid_dev->poll_pipe_mapping->interface->interface_protocol) {
    459386                case USB_HID_PROTOCOL_KEYBOARD:
    460                         usb_log_info("Falling back to kbd boot protocol.");
     387                        usb_log_info("Falling back to kbd boot protocol.\n");
    461388                        rc = usb_kbd_set_boot_protocol(hid_dev);
    462389                        if (rc == EOK) {
    … …  
    465392                        break;
    466393                case USB_HID_PROTOCOL_MOUSE:
    467                         usb_log_info("Falling back to mouse boot protocol.");
     394                        usb_log_info("Falling back to mouse boot protocol.\n");
    468395                        rc = usb_mouse_set_boot_protocol(hid_dev);
    469396                        if (rc == EOK) {
    … …  
    472399                        break;
    473400                default:
    474                         usb_log_info("Falling back to generic HID driver.");
     401                        usb_log_info("Falling back to generic HID driver.\n");
    475402                        usb_hid_set_generic_hid_subdriver(hid_dev);
    476403                }
    477404        }
    478405
    479         usb_log_debug("Subdriver count(after trying boot protocol): %d",
     406        usb_log_debug("Subdriver count(after trying boot protocol): %d\n",
    480407            hid_dev->subdriver_count);
    481408
    … …  
    492419        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
    493420                if (hid_dev->subdrivers[i].init != NULL) {
    494                         usb_log_debug("Initializing subdriver %d.",i);
     421                        usb_log_debug("Initializing subdriver %d.\n",i);
    495422                        const errno_t pret = hid_dev->subdrivers[i].init(hid_dev,
    496423                            &hid_dev->subdrivers[i].data);
    … …  
    515442                rc = usb_hid_init_report(hid_dev);
    516443                if (rc != EOK) {
    517                         usb_log_error("Failed to initialize input report buffer: %s", str_error(rc));
    518                         // FIXME: What happens now?
    519                 }
    520 
    521                 usb_polling_t *polling = &hid_dev->polling;
    522                 if ((rc = usb_polling_init(polling))) {
    523                         usb_log_error("Failed to initialize polling: %s", str_error(rc));
    524                         // FIXME: What happens now?
    525                 }
    526 
    527                 polling->device = hid_dev->usb_dev;
    528                 polling->ep_mapping = hid_dev->poll_pipe_mapping;
    529                 polling->request_size = hid_dev->poll_pipe_mapping->pipe.desc.max_transfer_size;
    530                 polling->buffer = malloc(polling->request_size);
    531                 polling->on_data = usb_hid_polling_callback;
    532                 polling->on_polling_end = usb_hid_polling_ended_callback;
    533                 polling->on_error = usb_hid_polling_error_callback;
    534                 polling->arg = hid_dev;
     444                        usb_log_error("Failed to initialize input report buffer"
     445                            ".\n");
     446                }
    535447        }
    536448
    537449        return rc;
     450}
     451
     452bool usb_hid_polling_callback(usb_device_t *dev, uint8_t *buffer,
     453    size_t buffer_size, void *arg)
     454{
     455        if (dev == NULL || arg == NULL || buffer == NULL) {
     456                usb_log_error("Missing arguments to polling callback.\n");
     457                return false;
     458        }
     459        usb_hid_dev_t *hid_dev = arg;
     460
     461        assert(hid_dev->input_report != NULL);
     462
     463        usb_log_debug("New data [%zu/%zu]: %s\n", buffer_size,
     464            hid_dev->max_input_report_size,
     465            usb_debug_str_buffer(buffer, buffer_size, 0));
     466
     467        if (hid_dev->max_input_report_size >= buffer_size) {
     468                /*! @todo This should probably be atomic. */
     469                memcpy(hid_dev->input_report, buffer, buffer_size);
     470                hid_dev->input_report_size = buffer_size;
     471                usb_hid_new_report(hid_dev);
     472        }
     473
     474        /* Parse the input report */
     475        const errno_t rc = usb_hid_parse_report(
     476            &hid_dev->report, buffer, buffer_size, &hid_dev->report_id);
     477        if (rc != EOK) {
     478                usb_log_warning("Failure in usb_hid_parse_report():"
     479                    "%s\n", str_error(rc));
     480        }
     481
     482        bool cont = false;
     483        /* Continue if at least one of the subdrivers want to continue */
     484        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
     485                if (hid_dev->subdrivers[i].poll != NULL) {
     486                        cont = cont || hid_dev->subdrivers[i].poll(
     487                            hid_dev, hid_dev->subdrivers[i].data);
     488                }
     489        }
     490
     491        return cont;
     492}
     493
     494void usb_hid_polling_ended_callback(usb_device_t *dev, bool reason, void *arg)
     495{
     496        assert(dev);
     497        assert(arg);
     498
     499        usb_hid_dev_t *hid_dev = arg;
     500
     501        for (unsigned i = 0; i < hid_dev->subdriver_count; ++i) {
     502                if (hid_dev->subdrivers[i].poll_end != NULL) {
     503                        hid_dev->subdrivers[i].poll_end(
     504                            hid_dev, hid_dev->subdrivers[i].data, reason);
     505                }
     506        }
     507
     508        hid_dev->running = false;
    538509}
    539510
    … …  
    553524        assert(hid_dev->subdrivers != NULL || hid_dev->subdriver_count == 0);
    554525
    555         free(hid_dev->polling.buffer);
    556         usb_polling_fini(&hid_dev->polling);
    557 
    558         usb_log_debug("Subdrivers: %p, subdriver count: %d",
     526
     527        usb_log_debug("Subdrivers: %p, subdriver count: %d\n",
    559528            hid_dev->subdrivers, hid_dev->subdriver_count);
    560529
    … …  
    572541        /* Destroy the parser */
    573542        usb_hid_report_deinit(&hid_dev->report);
     543
    574544}
    575545
Note: See TracChangeset for help on using the changeset viewer.