Changes in / [cbdb6457:11d2e96a] in mainline


Ignore:
Location:
uspace/drv/usbhid
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/usbhid/Makefile

    rcbdb6457 r11d2e96a  
    4646        generic/hiddev.c \
    4747        mouse/mousedev.c \
     48        lgtch-ultrax/lgtch-ultrax.c \
    4849        $(STOLEN_LAYOUT_SOURCES)
    4950

  • uspace/drv/usbhid/kbd/kbddev.c

    rcbdb6457 r11d2e96a  
    176176
    177177/*----------------------------------------------------------------------------*/
     178
     179static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
     180    uint8_t report_id, void *arg);
     181
     182static const usb_hid_report_in_callbacks_t usb_kbd_parser_callbacks = {
     183        .keyboard = usb_kbd_process_keycodes
     184};
     185
     186/*----------------------------------------------------------------------------*/
    178187/* Keyboard layouts                                                           */
    179188/*----------------------------------------------------------------------------*/
    … …  
    630639{
    631640        assert(hid_dev->parser != NULL);
    632        
    633         usb_hid_report_in_callbacks_t *callbacks =
    634             (usb_hid_report_in_callbacks_t *)malloc(
    635                 sizeof(usb_hid_report_in_callbacks_t));
    636        
    637         callbacks->keyboard = usb_kbd_process_keycodes;
    638641
    639642        usb_log_debug("Calling usb_hid_parse_report() with "
    … …  
    644647        usb_hid_report_path_t *path = usb_hid_report_path();
    645648        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    646         usb_hid_report_path_set_report_id(path, 0);
     649        //usb_hid_report_path_set_report_id(path, 0);
    647650       
    648651        int rc = usb_hid_parse_report(hid_dev->parser, buffer,
    649652            actual_size, path,
    650653            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    651             callbacks, hid_dev);
     654            &usb_kbd_parser_callbacks, hid_dev);
    652655
    653656        usb_hid_report_path_free(path);

  • uspace/drv/usbhid/main.c

    rcbdb6457 r11d2e96a  
    7575static int usb_hid_try_add_device(usb_device_t *dev)
    7676{
     77        assert(dev != NULL);
     78       
    7779        /*
    7880         * Initialize device (get and process descriptors, get address, etc.)
    … …  
    178180        usb_log_debug("usb_hid_add_device()\n");
    179181       
     182        if (dev == NULL) {
     183                usb_log_warning("Wrong parameter given for add_device().\n");
     184                return EINVAL;
     185        }
     186       
    180187        if (dev->interface_no < 0) {
    181188                usb_log_warning("Device is not a supported HID device.\n");

  • uspace/drv/usbhid/mouse/mousedev.c

    rcbdb6457 r11d2e96a  
    157157static void usb_mouse_free(usb_mouse_t **mouse_dev)
    158158{
    159         if (mouse_dev == NULL || *mouse_dev == NULL) {
    160                 return;
    161         }
     159        assert(mouse_dev != NULL && *mouse_dev != NULL);
    162160       
    163161        // hangup phone to the console
    164         async_hangup((*mouse_dev)->console_phone);
     162        if ((*mouse_dev)->console_phone >= 0) {
     163                async_hangup((*mouse_dev)->console_phone);
     164        }
    165165       
    166166        free(*mouse_dev);

  • uspace/drv/usbhid/subdrivers.c

    rcbdb6457 r11d2e96a  
    3737#include "usb/classes/hidut.h"
    3838
    39 static usb_hid_subdriver_usage_t path_kbd[] = {{USB_HIDUT_PAGE_KEYBOARD, 0}};
     39#include "lgtch-ultrax/lgtch-ultrax.h"
     40
     41static usb_hid_subdriver_usage_t path_kbd[] = {
     42        {USB_HIDUT_PAGE_KEYBOARD, 0},
     43        {0, 0}
     44};
     45
     46static usb_hid_subdriver_usage_t lgtch_path[] = {
     47        {0xc, 0},
     48        {0, 0}
     49};
    4050
    4151const usb_hid_subdriver_mapping_t usb_hid_subdrivers[] = {
    4252        {
    4353                path_kbd,
     54                -1,
     55                USB_HID_PATH_COMPARE_END
     56                | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     57                0,
     58                0,
     59                {
     60                        .init = usb_kbd_init,
     61                        .deinit = usb_kbd_deinit,
     62                        .poll = usb_kbd_polling_callback,
     63                        .poll_end = NULL
     64                },
     65               
     66        },
     67        {
     68                lgtch_path,
    4469                1,
    4570                USB_HID_PATH_COMPARE_END
    4671                | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    47                 NULL,
    48                 NULL,
     72                0x046d,
     73                0xc30e,
    4974                {
    50                         usb_kbd_init,
    51                         usb_kbd_deinit,
    52                         usb_kbd_polling_callback,
    53                         NULL
    54                 },
    55                
     75                        .init = NULL,
     76                        .deinit = NULL,
     77                        .poll = usb_lgtch_polling_callback,
     78                        .poll_end = NULL
     79                }
    5680        },
    57         {NULL, 0, 0, NULL, NULL, {NULL, NULL, NULL, NULL}}
     81        {NULL, -1, 0, 0, 0, {NULL, NULL, NULL, NULL}}
    5882};
    5983

  • uspace/drv/usbhid/subdrivers.h

    rcbdb6457 r11d2e96a  
    5454typedef struct usb_hid_subdriver_mapping {
    5555        const usb_hid_subdriver_usage_t *usage_path;
    56         int path_size;
     56        int report_id;
    5757        int compare;
    58         const char *vendor_id;
    59         const char *product_id;
     58        uint16_t vendor_id;
     59        uint16_t product_id;
    6060        usb_hid_subdriver_t subdriver;
    6161} usb_hid_subdriver_mapping_t;

  • uspace/drv/usbhid/usbhid.c

    rcbdb6457 r11d2e96a  
    6767static int usb_hid_set_boot_kbd_subdriver(usb_hid_dev_t *hid_dev)
    6868{
    69         assert(hid_dev->subdriver_count == 0);
     69        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    7070       
    7171        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    … …  
    9797static int usb_hid_set_boot_mouse_subdriver(usb_hid_dev_t *hid_dev)
    9898{
    99         assert(hid_dev->subdriver_count == 0);
     99        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    100100       
    101101        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    … …  
    127127static int usb_hid_set_generic_hid_subdriver(usb_hid_dev_t *hid_dev)
    128128{
    129         assert(hid_dev->subdriver_count == 0);
     129        assert(hid_dev != NULL && hid_dev->subdriver_count == 0);
    130130       
    131131        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(
    … …  
    164164
    165165static bool usb_hid_path_matches(usb_hid_dev_t *hid_dev,
    166     const usb_hid_subdriver_usage_t *path, int path_size, int compare)
     166    const usb_hid_subdriver_mapping_t *mapping)
    167167{
    168168        assert(hid_dev != NULL);
    169         assert(path != NULL);
     169        assert(mapping != NULL);
    170170       
    171171        usb_hid_report_path_t *usage_path = usb_hid_report_path();
    … …  
    174174                return false;
    175175        }
    176         int i;
    177         for (i = 0; i < path_size; ++i) {
     176        int i = 0;
     177        while (mapping->usage_path[i].usage != 0
     178            || mapping->usage_path[i].usage_page != 0) {
    178179                if (usb_hid_report_path_append_item(usage_path,
    179                     path[i].usage_page, path[i].usage) != EOK) {
     180                    mapping->usage_path[i].usage_page,
     181                    mapping->usage_path[i].usage) != EOK) {
    180182                        usb_log_debug("Failed to append to usage path.\n");
    181183                        usb_hid_report_path_free(usage_path);
    182184                        return false;
    183185                }
     186                ++i;
     187        }
     188       
     189        if (mapping->report_id >= 0) {
     190                usb_hid_report_path_set_report_id(usage_path,
     191                    mapping->report_id);
    184192        }
    185193       
    186194        assert(hid_dev->parser != NULL);
    187195       
    188         usb_log_debug("Compare flags: %d\n", compare);
     196        usb_log_debug("Compare flags: %d\n", mapping->compare);
    189197        size_t size = usb_hid_report_input_length(hid_dev->parser, usage_path,
    190             compare);
     198            mapping->compare);
    191199        usb_log_debug("Size of the input report: %d\n", size);
    192200       
    … …  
    231239static int usb_hid_find_subdrivers(usb_hid_dev_t *hid_dev)
    232240{
     241        assert(hid_dev != NULL);
     242       
    233243        const usb_hid_subdriver_t *subdrivers[USB_HID_MAX_SUBDRIVERS];
    234244       
    235245        int i = 0, count = 0;
    236246        const usb_hid_subdriver_mapping_t *mapping = &usb_hid_subdrivers[i];
     247
     248        bool ids_matched;
     249        bool matched;
    237250       
    238251        while (count < USB_HID_MAX_SUBDRIVERS &&
    239252            (mapping->usage_path != NULL
    240             || mapping->vendor_id != NULL
    241             || mapping->product_id != NULL)) {
     253            || mapping->vendor_id != 0 || mapping->product_id != 0)) {
    242254                // check the vendor & product ID
    243                 if (mapping->vendor_id != NULL && mapping->product_id == NULL) {
    244                         usb_log_warning("Missing Product ID for Vendor ID %s\n",
     255                if (mapping->vendor_id != 0 && mapping->product_id == 0) {
     256                        usb_log_warning("Missing Product ID for Vendor ID %u\n",
    245257                            mapping->vendor_id);
    246258                        return EINVAL;
    247259                }
    248                 if (mapping->product_id != NULL && mapping->vendor_id == NULL) {
    249                         usb_log_warning("Missing Vendor ID for Product ID %s\n",
     260                if (mapping->product_id != 0 && mapping->vendor_id == 0) {
     261                        usb_log_warning("Missing Vendor ID for Product ID %u\n",
    250262                            mapping->product_id);
    251263                        return EINVAL;
    252264                }
    253265               
    254                 if (mapping->vendor_id != NULL) {
    255                         assert(mapping->product_id != NULL);
    256                         usb_log_debug("Comparing device against vendor ID %s"
    257                             " and product ID %s.\n", mapping->vendor_id,
     266                ids_matched = false;
     267                matched = false;
     268               
     269                if (mapping->vendor_id != 0) {
     270                        assert(mapping->product_id != 0);
     271                        usb_log_debug("Comparing device against vendor ID %u"
     272                            " and product ID %u.\n", mapping->vendor_id,
    258273                            mapping->product_id);
    259274                        if (usb_hid_ids_match(hid_dev, mapping)) {
    260                                 usb_log_debug("Matched.\n");
    261                                 subdrivers[count++] = &mapping->subdriver;
    262                                 // skip the checking of usage path
    263                                 goto next;
     275                                usb_log_debug("IDs matched.\n");
     276                                ids_matched = true;
    264277                        }
    265278                }
    … …  
    267280                if (mapping->usage_path != NULL) {
    268281                        usb_log_debug("Comparing device against usage path.\n");
    269                         if (usb_hid_path_matches(hid_dev,
    270                             mapping->usage_path, mapping->path_size,
    271                             mapping->compare)) {
    272                                 subdrivers[count++] = &mapping->subdriver;
    273                         } else {
    274                                 usb_log_debug("Not matched.\n");
     282                        if (usb_hid_path_matches(hid_dev, mapping)) {
     283                                // does not matter if IDs were matched
     284                                matched = true;
    275285                        }
    276                 }
    277         next:
     286                } else {
     287                        // matched only if IDs were matched and there is no path
     288                        matched = ids_matched;
     289                }
     290               
     291                if (matched) {
     292                        subdrivers[count++] = &mapping->subdriver;
     293                }
     294               
    278295                mapping = &usb_hid_subdrivers[++i];
    279296        }
    … …  
    287304static int usb_hid_check_pipes(usb_hid_dev_t *hid_dev, usb_device_t *dev)
    288305{
     306        assert(hid_dev != NULL && dev != NULL);
     307       
    289308        int rc = EOK;
    290309       
Note: See TracChangeset for help on using the changeset viewer.