Changes in / [8d3f198:5f9b81af] in mainline


Ignore:
Location:
uspace
Files:
2 deleted
21 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/mkbd/Makefile

    r8d3f198 r5f9b81af  
    3131
    3232LIBS = \
    33         $(LIBUSBHID_PREFIX)/libusbhid.a \
    3433        $(LIBUSBDEV_PREFIX)/libusbdev.a \
    3534        $(LIBUSB_PREFIX)/libusb.a \
    36         $(LIBDRV_PREFIX)/libdrv.a 
     35        $(LIBDRV_PREFIX)/libdrv.a
    3736EXTRA_CFLAGS = \
    3837        -I$(LIBUSB_PREFIX)/include \
    3938        -I$(LIBUSBDEV_PREFIX)/include \
    40         -I$(LIBDRV_PREFIX)/include \
    41         -I$(LIBUSBHID_PREFIX)/include
     39        -I$(LIBDRV_PREFIX)/include
    4240
    4341SOURCES = \

  • uspace/app/mkbd/main.c

    r8d3f198 r5f9b81af  
    4545#include <devmap.h>
    4646#include <usb/dev/hub.h>
    47 #include <usb/host.h>
    48 #include <usb/driver.h>
    49 #include <usb/hid/iface.h>
     47#include <usb/hc.h>
    5048#include <usb/dev/pipes.h>
    51 #include <async.h>
    52 #include <usb/hid/usages/core.h>
    53 #include <usb/hid/hidparser.h>
    54 #include <usb/hid/hiddescriptor.h>
    55 #include <usb/hid/usages/consumer.h>
    56 #include <assert.h>
    5749
    5850#define NAME "mkbd"
    … …  
    6052static int dev_phone = -1;
    6153
    62 static int initialize_report_parser(int dev_phone, usb_hid_report_t **report)
    63 {
    64         *report = (usb_hid_report_t *)malloc(sizeof(usb_hid_report_t));
    65         if (*report == NULL) {
     54//static void print_found_hc(size_t class_index, const char *path)
     55//{
     56//      // printf(NAME ": host controller %zu is `%s'.\n", class_index, path);
     57//      printf("Bus %02zu: %s\n", class_index, path);
     58//}
     59//static void print_found_dev(usb_address_t addr, const char *path)
     60//{
     61//      // printf(NAME ":     device with address %d is `%s'.\n", addr, path);
     62//      printf("  Device %02d: %s\n", addr, path);
     63//}
     64
     65//static void print_hc_devices(devman_handle_t hc_handle)
     66//{
     67//      int rc;
     68//      usb_hc_connection_t conn;
     69
     70//      usb_hc_connection_initialize(&conn, hc_handle);
     71//      rc = usb_hc_connection_open(&conn);
     72//      if (rc != EOK) {
     73//              printf(NAME ": failed to connect to HC: %s.\n",
     74//                  str_error(rc));
     75//              return;
     76//      }
     77//      usb_address_t addr;
     78//      for (addr = 1; addr < 5; addr++) {
     79//              devman_handle_t dev_handle;
     80//              rc = usb_hc_get_handle_by_address(&conn, addr, &dev_handle);
     81//              if (rc != EOK) {
     82//                      continue;
     83//              }
     84//              char path[MAX_PATH_LENGTH];
     85//              rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
     86//              if (rc != EOK) {
     87//                      continue;
     88//              }
     89//              print_found_dev(addr, path);
     90//      }
     91//      usb_hc_connection_close(&conn);
     92//}
     93
     94static bool try_parse_class_and_address(const char *path,
     95    devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
     96{
     97        size_t class_index;
     98        size_t address;
     99        int rc;
     100        char *ptr;
     101
     102        rc = str_size_t(path, &ptr, 10, false, &class_index);
     103        if (rc != EOK) {
     104                return false;
     105        }
     106        if ((*ptr == ':') || (*ptr == '.')) {
     107                ptr++;
     108        } else {
     109                return false;
     110        }
     111        rc = str_size_t(ptr, NULL, 10, true, &address);
     112        if (rc != EOK) {
     113                return false;
     114        }
     115        rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle);
     116        if (rc != EOK) {
     117                return false;
     118        }
     119        if (out_device_address != NULL) {
     120                *out_device_address = (usb_address_t) address;
     121        }
     122        return true;
     123}
     124
     125static bool resolve_hc_handle_and_dev_addr(const char *devpath,
     126    devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
     127{
     128        int rc;
     129
     130        /* Hack for QEMU to save-up on typing ;-). */
     131        if (str_cmp(devpath, "qemu") == 0) {
     132                devpath = "/hw/pci0/00:01.2/uhci-rh/usb00_a1";
     133        }
     134
     135        /* Hack for virtual keyboard. */
     136        if (str_cmp(devpath, "virt") == 0) {
     137                devpath = "/virt/usbhc/usb00_a1/usb00_a2";
     138        }
     139
     140        if (try_parse_class_and_address(devpath,
     141            out_hc_handle, out_device_address)) {
     142                return true;
     143        }
     144
     145        char *path = str_dup(devpath);
     146        if (path == NULL) {
    66147                return ENOMEM;
    67148        }
    68        
    69         int rc = usb_hid_report_init(*report);
    70         if (rc != EOK) {
    71                 usb_hid_free_report(*report);
    72                 *report = NULL;
    73                 printf("usb_hid_report_init() failed.\n");
    74                 return rc;
    75         }
    76        
    77         // get the report descriptor length from the device
    78         size_t report_desc_size;
    79         rc = usbhid_dev_get_report_descriptor_length(
    80             dev_phone, &report_desc_size);
    81         if (rc != EOK) {
    82                 usb_hid_free_report(*report);
    83                 *report = NULL;
    84                 printf("usbhid_dev_get_report_descriptor_length() failed.\n");
    85                 return rc;
    86         }
    87        
    88         if (report_desc_size == 0) {
    89                 usb_hid_free_report(*report);
    90                 *report = NULL;
    91                 printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
    92                 return EINVAL;  // TODO: other error code?
    93         }
    94        
    95         uint8_t *desc = (uint8_t *)malloc(report_desc_size);
    96         if (desc == NULL) {
    97                 usb_hid_free_report(*report);
    98                 *report = NULL;
    99                 return ENOMEM;
    100         }
    101        
    102         // get the report descriptor from the device
    103         size_t actual_size;
    104         rc = usbhid_dev_get_report_descriptor(dev_phone, desc, report_desc_size,
    105             &actual_size);
    106         if (rc != EOK) {
    107                 usb_hid_free_report(*report);
    108                 *report = NULL;
    109                 free(desc);
    110                 printf("usbhid_dev_get_report_descriptor() failed.\n");
    111                 return rc;
    112         }
    113        
    114         if (actual_size != report_desc_size) {
    115                 usb_hid_free_report(*report);
    116                 *report = NULL;
    117                 free(desc);
    118                 printf("usbhid_dev_get_report_descriptor() returned wrong size:"
    119                     " %zu, expected: %zu.\n", actual_size, report_desc_size);
    120                 return EINVAL;  // TODO: other error code?
    121         }
    122        
    123         // initialize the report parser
    124        
    125         rc = usb_hid_parse_report_descriptor(*report, desc, report_desc_size);
    126         free(desc);
    127        
    128         if (rc != EOK) {
    129                 free(desc);
    130                 printf("usb_hid_parse_report_descriptor() failed.\n");
    131                 return rc;
    132         }
    133        
    134         return EOK;
    135 }
    136 
    137 static void print_key(uint8_t *buffer, size_t size, usb_hid_report_t *report)
    138 {
    139         assert(buffer != NULL);
    140         assert(report != NULL);
    141        
    142         uint8_t report_id;
    143         usb_hid_parse_report(report, buffer, size, &report_id);
    144        
    145         usb_hid_report_path_t *path = usb_hid_report_path();
    146         if (path == NULL) {
    147                 return;
    148         }
    149        
    150         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
    151        
    152         usb_hid_report_path_set_report_id(path, report_id);
    153 
    154         usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    155             report, NULL, path, USB_HID_PATH_COMPARE_END
    156             | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    157             USB_HID_REPORT_TYPE_INPUT);
    158        
    159         while (field != NULL) {
    160                 if (field->value != 0) {
    161                         const char *key_str =
    162                             usbhid_multimedia_usage_to_str(field->usage);
    163                         printf("Pressed key: %s\n", key_str);
    164                 }
    165                
    166                 field = usb_hid_report_get_sibling(
    167                     report, field, path, USB_HID_PATH_COMPARE_END
    168                     | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    169                     USB_HID_REPORT_TYPE_INPUT);
    170         }
    171        
    172         usb_hid_report_path_free(path);
    173 }
    174 
    175 #define MAX_PATH_LENGTH 1024
     149
     150        devman_handle_t hc = 0;
     151        bool hc_found = false;
     152        usb_address_t addr = 0;
     153        bool addr_found = false;
     154
     155        /* Remove suffixes and hope that we will encounter device node. */
     156        while (str_length(path) > 0) {
     157                /* Get device handle first. */
     158                devman_handle_t dev_handle;
     159                rc = devman_device_get_handle(path, &dev_handle, 0);
     160                if (rc != EOK) {
     161                        free(path);
     162                        return false;
     163                }
     164
     165                /* Try to find its host controller. */
     166                if (!hc_found) {
     167                        rc = usb_hc_find(dev_handle, &hc);
     168                        if (rc == EOK) {
     169                                hc_found = true;
     170                        }
     171                }
     172                /* Try to get its address. */
     173                if (!addr_found) {
     174                        addr = usb_hc_get_address_by_handle(dev_handle);
     175                        if (addr >= 0) {
     176                                addr_found = true;
     177                        }
     178                }
     179
     180                /* Speed-up. */
     181                if (hc_found && addr_found) {
     182                        break;
     183                }
     184
     185                /* Remove the last suffix. */
     186                char *slash_pos = str_rchr(path, '/');
     187                if (slash_pos != NULL) {
     188                        *slash_pos = 0;
     189                }
     190        }
     191
     192        free(path);
     193
     194        if (hc_found && addr_found) {
     195                if (out_hc_handle != NULL) {
     196                        *out_hc_handle = hc;
     197                }
     198                if (out_device_address != NULL) {
     199                        *out_device_address = addr;
     200                }
     201                return true;
     202        } else {
     203                return false;
     204        }
     205}
    176206
    177207static void print_usage(char *app_name)
    … …  
    179209#define _INDENT "      "
    180210
    181        printf(NAME ": Print out what multimedia keys were pressed.\n\n");
    182        printf("Usage: %s device\n", app_name);
    183        printf(_INDENT "The device is a devman path to the device.\n");
     211        printf(NAME ": Print out what multimedia keys were pressed.\n\n");
     212        printf("Usage: %s device\n", app_name);
     213        printf(_INDENT "The device is a devman path to the device.\n");
    184214
    185215#undef _OPTION
    … …  
    195225        }
    196226       
    197         //char *devpath = argv[1];
    198         const char *devpath = "/hw/pci0/00:06.0/ohci-rh/usb00_a2/HID0/hid";
     227        char *devpath = argv[1];
     228
     229        /* The initialization is here only to make compiler happy. */
     230        devman_handle_t hc_handle = 0;
     231        usb_address_t dev_addr = 0;
     232        bool found = resolve_hc_handle_and_dev_addr(devpath,
     233            &hc_handle, &dev_addr);
     234        if (!found) {
     235                fprintf(stderr, NAME ": device `%s' not found "
     236                    "or not of USB kind. Exiting.\n", devpath);
     237                return -1;
     238        }
    199239       
    200240        int rc;
    201        
    202         devman_handle_t dev_handle = 0;
    203         rc = devman_device_get_handle(devpath, &dev_handle, 0);
    204         if (rc != EOK) {
    205                 printf("Failed to get handle from devman: %s.\n",
     241        usb_hc_connection_t conn;
     242
     243        usb_hc_connection_initialize(&conn, hc_handle);
     244        rc = usb_hc_connection_open(&conn);
     245        if (rc != EOK) {
     246                printf(NAME ": failed to connect to HC: %s.\n",
    206247                    str_error(rc));
    207                 return rc;
    208         }
     248                return -1;
     249        }
     250        usb_address_t addr = 0;
     251
     252        devman_handle_t dev_handle;
     253        rc = usb_hc_get_handle_by_address(&conn, addr, &dev_handle);
     254        if (rc != EOK) {
     255                printf(NAME ": failed getting handle to the device: %s.\n",
     256                       str_error(rc));
     257                return -1;
     258        }
     259
     260        usb_hc_connection_close(&conn);
    209261       
    210262        rc = devman_device_connect(dev_handle, 0);
    211263        if (rc < 0) {
    212                 printf(NAME ": failed to connect to the device (handle %"
    213                        PRIun "): %s.\n", dev_handle, str_error(rc));
    214                 return rc;
     264                printf(NAME ": failed to connect to the device: %s.\n",
     265                       str_error(rc));
     266                return -1;
    215267        }
    216268       
    … …  
    218270        printf("Got phone to the device: %d\n", dev_phone);
    219271       
    220         char path[MAX_PATH_LENGTH];
    221         rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
    222         if (rc != EOK) {
    223                 return ENOMEM;
    224         }
    225        
    226         printf("Device path: %s\n", path);
    227        
    228        
    229         usb_hid_report_t *report = NULL;
    230         rc = initialize_report_parser(dev_phone, &report);
    231         if (rc != EOK) {
    232                 printf("Failed to initialize report parser: %s\n",
    233                     str_error(rc));
    234                 return rc;
    235         }
    236        
    237         assert(report != NULL);
    238        
    239         size_t size;
    240         rc = usbhid_dev_get_event_length(dev_phone, &size);
    241         if (rc != EOK) {
    242                 printf("Failed to get event length: %s.\n", str_error(rc));
    243                 return rc;
    244         }
    245        
    246         printf("Event length: %zu\n", size);
    247         uint8_t *event = (uint8_t *)malloc(size);
    248         if (event == NULL) {
    249                 // hangup phone?
    250                 return ENOMEM;
    251         }
    252        
    253         printf("Event length: %zu\n", size);
    254        
    255         size_t actual_size;
    256        
    257         while (1) {
    258                 // get event from the driver
    259                 printf("Getting event from the driver.\n");
    260                
    261                 /** @todo Try blocking call. */
    262                 rc = usbhid_dev_get_event(dev_phone, event, size, &actual_size,
    263                     0);
    264                 if (rc != EOK) {
    265                         // hangup phone?
    266                         printf("Error in getting event from the HID driver:"
    267                             "%s.\n", str_error(rc));
    268                         break;
    269                 }
    270                
    271                 printf("Got buffer: %p, size: %zu\n", event, actual_size);
    272                
    273                 print_key(event, size, report);
    274                
    275                 async_usleep(10000);
    276         }
     272       
     273//      size_t class_index = 0;
     274//      size_t failed_attempts = 0;
     275
     276//      while (failed_attempts < MAX_FAILED_ATTEMPTS) {
     277//              class_index++;
     278//              devman_handle_t hc_handle = 0;
     279//              int rc = usb_ddf_get_hc_handle_by_class(class_index, &hc_handle);
     280//              if (rc != EOK) {
     281//                      failed_attempts++;
     282//                      continue;
     283//              }
     284//              char path[MAX_PATH_LENGTH];
     285//              rc = devman_get_device_path(hc_handle, path, MAX_PATH_LENGTH);
     286//              if (rc != EOK) {
     287//                      continue;
     288//              }
     289//              print_found_hc(class_index, path);
     290//              print_hc_devices(hc_handle);
     291//      }
    277292       
    278293        return 0;

  • uspace/drv/usbhid/generic/hiddev.c

    r8d3f198 r5f9b81af  
    6262static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun);
    6363
    64 static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     64static int usb_generic_hid_get_event(ddf_fun_t *fun, int32_t *buffer,
    6565    size_t size, size_t *act_size, unsigned int flags);
    6666
    6767static int usb_generic_hid_client_connected(ddf_fun_t *fun);
    68 
    69 static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun);
    70 
    71 static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
    72     size_t size, size_t *actual_size);
    7368
    7469/*----------------------------------------------------------------------------*/
    … …  
    7671static usbhid_iface_t usb_generic_iface = {
    7772        .get_event = usb_generic_hid_get_event,
    78         .get_event_length = usb_generic_hid_get_event_length,
    79         .get_report_descriptor_length = usb_generic_get_report_descriptor_length,
    80         .get_report_descriptor = usb_generic_get_report_descriptor
     73        .get_event_length = usb_generic_hid_get_event_length
    8174};
    8275
    … …  
    9083static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun)
    9184{
    92         usb_log_debug("Generic HID: Get event length (fun: %p, "
    93             "fun->driver_data: %p.\n", fun, fun->driver_data);
    94        
    95         if (fun == NULL || fun->driver_data == NULL) {
     85        if (fun == NULL || fun->driver_data) {
    9686                return 0;
    9787        }
    … …  
    9989        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    10090       
    101         usb_log_debug("hid_dev: %p, Max input report size (%d).\n",
    102             hid_dev, hid_dev->max_input_report_size);
    103        
    104         return hid_dev->max_input_report_size;
     91        return hid_dev->input_report_size;
    10592}
    10693
    10794/*----------------------------------------------------------------------------*/
    10895
    109 static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     96static int usb_generic_hid_get_event(ddf_fun_t *fun, int32_t *buffer,
    11097    size_t size, size_t *act_size, unsigned int flags)
    11198{
    112         usb_log_debug("Generic HID: Get event.\n");
    113        
    114         if (fun == NULL || fun->driver_data == NULL) {
    115                 usb_log_debug("No function");
     99        if (fun == NULL || fun->driver_data) {
    116100                return EINVAL;
    117101        }
    … …  
    142126/*----------------------------------------------------------------------------*/
    143127
    144 static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
    145 {
    146         usb_log_debug("Generic HID: Get report descriptor length.\n");
    147        
    148         if (fun == NULL || fun->driver_data == NULL) {
    149                 usb_log_debug("No function");
    150                 return EINVAL;
    151         }
    152        
    153         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    154        
    155         printf("hid_dev->report_desc_size = %zu\n", hid_dev->report_desc_size);
    156        
    157         return hid_dev->report_desc_size;
    158 }
    159 
    160 /*----------------------------------------------------------------------------*/
    161 
    162 static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
    163     size_t size, size_t *actual_size)
    164 {
    165         usb_log_debug("Generic HID: Get report descriptor.\n");
    166        
    167         if (fun == NULL || fun->driver_data == NULL) {
    168                 usb_log_debug("No function");
    169                 return EINVAL;
    170         }
    171        
    172         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    173        
    174         if (hid_dev->report_desc_size > size) {
    175                 return EINVAL;  // TODO: other error code
    176         }
    177        
    178         memcpy(desc, hid_dev->report_desc, hid_dev->report_desc_size);
    179         *actual_size = hid_dev->report_desc_size;
    180        
    181         return EOK;
    182 }
    183 
    184 /*----------------------------------------------------------------------------*/
    185 
    186128static int usb_generic_hid_client_connected(ddf_fun_t *fun)
    187129{
    188         usb_log_debug("Generic HID: Client connected.\n");
    189130        usb_hid_report_received();
    190131        return EOK;
    … …  
    204145                return ENOMEM;
    205146        }
    206        
    207         fun->ops = &usb_generic_hid_ops;
    208         fun->driver_data = hid_dev;
    209147
    210148        int rc = ddf_fun_bind(fun);
    … …  
    216154        }
    217155       
    218         usb_log_debug("HID function created. Handle: %d\n", fun->handle);
     156        fun->ops = &usb_generic_hid_ops;
     157        fun->driver_data = hid_dev;
    219158       
    220159        return EOK;

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

    r8d3f198 r5f9b81af  
    798798        }
    799799       
    800         usb_log_debug("%s function created. Handle: %d\n", HID_KBD_FUN_NAME,
    801             fun->handle);
    802        
    803800        usb_log_debug("Adding DDF function to class %s...\n",
    804801            HID_KBD_CLASS_NAME);

  • uspace/drv/usbhid/multimedia/keymap.c

    r8d3f198 r5f9b81af  
    7575};
    7676
     77static const char *usb_hid_consumer_usage_str[0x29d] = {
     78        [0x01] = "Consumer Control",
     79        [0x02] = "Numeric Key Pad",
     80        [0x03] = "Programmable Buttons",
     81        [0x04] = "Microphone",
     82        [0x05] = "Headphone",
     83        [0x06] = "Graphic Equalizer",
     84        [0x07] = "Reserved",
     85        [0x08] = "Reserved",
     86        [0x09] = "Reserved",
     87        [0x0a] = "Reserved",
     88        [0x0b] = "Reserved",
     89        [0x0c] = "Reserved",
     90        [0x0d] = "Reserved",
     91        [0x0e] = "Reserved",
     92        [0x0f] = "Reserved",
     93        [0x10] = "Reserved",
     94        [0x11] = "Reserved",
     95        [0x12] = "Reserved",
     96        [0x13] = "Reserved",
     97        [0x14] = "Reserved",
     98        [0x15] = "Reserved",
     99        [0x16] = "Reserved",
     100        [0x17] = "Reserved",
     101        [0x18] = "Reserved",
     102        [0x19] = "Reserved",
     103        [0x1a] = "Reserved",
     104        [0x1b] = "Reserved",
     105        [0x1c] = "Reserved",
     106        [0x1d] = "Reserved",
     107        [0x1e] = "Reserved",
     108        [0x1f] = "Reserved",
     109        [0x20] = "+10",
     110        [0x21] = "+100",
     111        [0x22] = "AM/PM",
     112        [0x23] = "Reserved",
     113        [0x24] = "Reserved",
     114        [0x25] = "Reserved",
     115        [0x26] = "Reserved",
     116        [0x27] = "Reserved",
     117        [0x28] = "Reserved",
     118        [0x29] = "Reserved",
     119        [0x2a] = "Reserved",
     120        [0x2b] = "Reserved",
     121        [0x2c] = "Reserved",
     122        [0x2d] = "Reserved",
     123        [0x2e] = "Reserved",
     124        [0x2f] = "Reserved",
     125        [0x30] = "Reserved",
     126        [0x31] = "Reserved",
     127        [0x32] = "Reserved",
     128        [0x33] = "Reserved",
     129        [0x34] = "Reserved",
     130        [0x35] = "Reserved",
     131        [0x36] = "Reserved",
     132        [0x37] = "Reserved",
     133        [0x38] = "Reserved",
     134        [0x39] = "Reserved",
     135        [0x3a] = "Reserved",
     136        [0x3b] = "Reserved",
     137        [0x3c] = "Reserved",
     138        [0x3d] = "Reserved",
     139        [0x3e] = "Reserved",
     140        [0x3f] = "Reserved",
     141        [0x40] = "Menu",
     142        [0x41] = "Menu Pick",
     143        [0x42] = "Menu Up",
     144        [0x43] = "Menu Down",
     145        [0x44] = "Menu Left",
     146        [0x45] = "Menu Right",
     147        [0x46] = "Menu Escape",
     148        [0x47] = "Menu Value Increase",
     149        [0x48] = "Menu Value Decrease",
     150        [0x49] = "Reserved",
     151        [0x4a] = "Reserved",
     152        [0x4b] = "Reserved",
     153        [0x4c] = "Reserved",
     154        [0x4d] = "Reserved",
     155        [0x4e] = "Reserved",
     156        [0x4f] = "Reserved",
     157        [0x50] = "Reserved",
     158        [0x51] = "Reserved",
     159        [0x52] = "Reserved",
     160        [0x53] = "Reserved",
     161        [0x54] = "Reserved",
     162        [0x55] = "Reserved",
     163        [0x56] = "Reserved",
     164        [0x57] = "Reserved",
     165        [0x58] = "Reserved",
     166        [0x59] = "Reserved",
     167        [0x5a] = "Reserved",
     168        [0x5b] = "Reserved",
     169        [0x5c] = "Reserved",
     170        [0x5d] = "Reserved",
     171        [0x5e] = "Reserved",
     172        [0x5f] = "Reserved",
     173        [0x60] = "Data On Screen",
     174        [0x61] = "Closed Caption",
     175        [0x62] = "Closed Caption Select",
     176        [0x63] = "VCR/TV",
     177        [0x64] = "Broadcast Mode",
     178        [0x65] = "Snapshot",
     179        [0x66] = "Still",
     180        [0x67] = "Reserved",
     181        [0x68] = "Reserved",
     182        [0x69] = "Reserved",
     183        [0x6a] = "Reserved",
     184        [0x6b] = "Reserved",
     185        [0x6c] = "Reserved",
     186        [0x6d] = "Reserved",
     187        [0x6e] = "Reserved",
     188        [0x6f] = "Reserved",
     189        [0x70] = "Reserved",
     190        [0x71] = "Reserved",
     191        [0x72] = "Reserved",
     192        [0x73] = "Reserved",
     193        [0x74] = "Reserved",
     194        [0x75] = "Reserved",
     195        [0x76] = "Reserved",
     196        [0x77] = "Reserved",
     197        [0x78] = "Reserved",
     198        [0x79] = "Reserved",
     199        [0x7a] = "Reserved",
     200        [0x7b] = "Reserved",
     201        [0x7c] = "Reserved",
     202        [0x7d] = "Reserved",
     203        [0x7e] = "Reserved",
     204        [0x7f] = "Reserved",
     205        [0x80] = "Selection",
     206        [0x81] = "Assign Selection",
     207        [0x82] = "Mode Step",
     208        [0x83] = "Recall Last",
     209        [0x84] = "Enter Channel",
     210        [0x85] = "Order Movie",
     211        [0x86] = "Channel",
     212        [0x87] = "Media Selection",
     213        [0x88] = "Media Select Computer",
     214        [0x89] = "Media Select TV",
     215        [0x8a] = "Media Select WWW",
     216        [0x8b] = "Media Select DVD",
     217        [0x8c] = "Media Select Telephone",
     218        [0x8d] = "Media Select Program Guide",
     219        [0x8e] = "Media Select Video Phone",
     220        [0x8f] = "Media Select Games",
     221        [0x90] = "Media Select Messages",
     222        [0x91] = "Media Select CD",
     223        [0x92] = "Media Select VCR",
     224        [0x93] = "Media Select Tuner",
     225        [0x94] = "Quit",
     226        [0x95] = "Help",
     227        [0x96] = "Media Select Tape",
     228        [0x97] = "Media Select Cable",
     229        [0x98] = "Media Select Satellite",
     230        [0x99] = "Media Select Security",
     231        [0x9a] = "Media Select Home",
     232        [0x9b] = "Media Select Call",
     233        [0x9c] = "Channel Increment",
     234        [0x9d] = "Channel Decrement",
     235        [0x9e] = "Media Select SAP",
     236        [0x9f] = "Reserved",
     237        [0xa0] = "VCR Plus",
     238        [0xa1] = "Once",
     239        [0xa2] = "Daily",
     240        [0xa3] = "Weekly",
     241        [0xa4] = "Monthly",
     242        [0xa5] = "Reserved",
     243        [0xa6] = "Reserved",
     244        [0xa7] = "Reserved",
     245        [0xa8] = "Reserved",
     246        [0xa9] = "Reserved",
     247        [0xaa] = "Reserved",
     248        [0xab] = "Reserved",
     249        [0xac] = "Reserved",
     250        [0xad] = "Reserved",
     251        [0xae] = "Reserved",
     252        [0xaf] = "Reserved",
     253        [0xb0] = "Play",
     254        [0xb1] = "Pause",
     255        [0xb2] = "Record",
     256        [0xb3] = "Fast Forward",
     257        [0xb4] = "Rewind",
     258        [0xb5] = "Scan Next Track",
     259        [0xb6] = "Scan Previous Trac",
     260        [0xb7] = "Stop",
     261        [0xb8] = "Eject",
     262        [0xb9] = "Random Play",
     263        [0xba] = "Select Disc",
     264        [0xbb] = "Enter Disc",
     265        [0xbc] = "Repeat",
     266        [0xbd] = "Tracking",
     267        [0xbe] = "Track Normal",
     268        [0xbf] = "Slow Tracking",
     269        [0xc0] = "Frame Forward",
     270        [0xc1] = "Frame Back",
     271        [0xc2] = "Mark",
     272        [0xc3] = "Clear Mark",
     273        [0xc4] = "Repeat From Mark",
     274        [0xc5] = "Return to Mark",
     275        [0xc6] = "Search Mark Forward",
     276        [0xc7] = "Search Mark Backwards",
     277        [0xc8] = "Counter Reset",
     278        [0xc9] = "Show Counter",
     279        [0xca] = "Tracking Increment",
     280        [0xcb] = "Tracking Decrement",
     281        [0xcc] = "Stop/Eject",
     282        [0xcd] = "Play/Pause",
     283        [0xce] = "Play/Skip",
     284        [0xcf] = "Reserved",
     285        [0xd0] = "Reserved",
     286        [0xd1] = "Reserved",
     287        [0xd2] = "Reserved",
     288        [0xd3] = "Reserved",
     289        [0xd4] = "Reserved",
     290        [0xd5] = "Reserved",
     291        [0xd6] = "Reserved",
     292        [0xd7] = "Reserved",
     293        [0xd8] = "Reserved",
     294        [0xd9] = "Reserved",
     295        [0xda] = "Reserved",
     296        [0xdb] = "Reserved",
     297        [0xdc] = "Reserved",
     298        [0xdd] = "Reserved",
     299        [0xde] = "Reserved",
     300        [0xdf] = "Reserved",
     301        [0xe0] = "Volume",
     302        [0xe1] = "Balance",
     303        [0xe2] = "Mute",
     304        [0xe3] = "Bass",
     305        [0xe4] = "Treble",
     306        [0xe5] = "Bass Boost",
     307        [0xe6] = "Surround Mode",
     308        [0xe7] = "Loudness",
     309        [0xe8] = "MPX",
     310        [0xe9] = "Volume Increment",
     311        [0xea] = "Volume Decrement",
     312        [0xeb] = "Reserved",
     313        [0xec] = "Reserved",
     314        [0xed] = "Reserved",
     315        [0xee] = "Reserved",
     316        [0xef] = "Reserved",
     317        [0xf0] = "Speed Select",
     318        [0xf1] = "Playback Speed",
     319        [0xf2] = "Standard Play",
     320        [0xf3] = "Long Play",
     321        [0xf4] = "Extended Play",
     322        [0xf5] = "Slow",
     323        [0xf6] = "Reserved",
     324        [0xf7] = "Reserved",
     325        [0xf8] = "Reserved",
     326        [0xf9] = "Reserved",
     327        [0xfa] = "Reserved",
     328        [0xfb] = "Reserved",
     329        [0xfc] = "Reserved",
     330        [0xfd] = "Reserved",
     331        [0xfe] = "Reserved",
     332        [0xff] = "Reserved",
     333        [0x100] = "Fan Enable",
     334        [0x101] = "Fan Speed",
     335        [0x102] = "Light Enable",
     336        [0x103] = "Light Illumination Level",
     337        [0x104] = "Climate Control Enable",
     338        [0x105] = "Room Temperature",
     339        [0x106] = "Security Enable",
     340        [0x107] = "Fire Alarm",
     341        [0x108] = "Police Alarm",
     342        [0x109] = "Proximity",
     343        [0x10a] = "Motion",
     344        [0x10b] = "Duress Alarm",
     345        [0x10c] = "Holdup Alarm",
     346        [0x10d] = "Medical Alarm",
     347        [0x10e] = "Reserved",
     348        [0x10f] = "Reserved",
     349        [0x110] = "Reserved",
     350        [0x111] = "Reserved",
     351        [0x112] = "Reserved",
     352        [0x113] = "Reserved",
     353        [0x114] = "Reserved",
     354        [0x115] = "Reserved",
     355        [0x116] = "Reserved",
     356        [0x117] = "Reserved",
     357        [0x118] = "Reserved",
     358        [0x119] = "Reserved",
     359        [0x11a] = "Reserved",
     360        [0x11b] = "Reserved",
     361        [0x11c] = "Reserved",
     362        [0x11d] = "Reserved",
     363        [0x11e] = "Reserved",
     364        [0x11f] = "Reserved",
     365        [0x120] = "Reserved",
     366        [0x121] = "Reserved",
     367        [0x122] = "Reserved",
     368        [0x123] = "Reserved",
     369        [0x124] = "Reserved",
     370        [0x125] = "Reserved",
     371        [0x126] = "Reserved",
     372        [0x127] = "Reserved",
     373        [0x128] = "Reserved",
     374        [0x129] = "Reserved",
     375        [0x12a] = "Reserved",
     376        [0x12b] = "Reserved",
     377        [0x12c] = "Reserved",
     378        [0x12d] = "Reserved",
     379        [0x12e] = "Reserved",
     380        [0x12f] = "Reserved",
     381        [0x130] = "Reserved",
     382        [0x131] = "Reserved",
     383        [0x132] = "Reserved",
     384        [0x133] = "Reserved",
     385        [0x134] = "Reserved",
     386        [0x135] = "Reserved",
     387        [0x136] = "Reserved",
     388        [0x137] = "Reserved",
     389        [0x138] = "Reserved",
     390        [0x139] = "Reserved",
     391        [0x13a] = "Reserved",
     392        [0x13b] = "Reserved",
     393        [0x13c] = "Reserved",
     394        [0x13d] = "Reserved",
     395        [0x13e] = "Reserved",
     396        [0x13f] = "Reserved",
     397        [0x140] = "Reserved",
     398        [0x141] = "Reserved",
     399        [0x142] = "Reserved",
     400        [0x143] = "Reserved",
     401        [0x144] = "Reserved",
     402        [0x145] = "Reserved",
     403        [0x146] = "Reserved",
     404        [0x147] = "Reserved",
     405        [0x148] = "Reserved",
     406        [0x149] = "Reserved",
     407        [0x14a] = "Reserved",
     408        [0x14b] = "Reserved",
     409        [0x14c] = "Reserved",
     410        [0x14d] = "Reserved",
     411        [0x14e] = "Reserved",
     412        [0x14f] = "Reserved",
     413        [0x150] = "Balance Right",
     414        [0x151] = "Balance Left",
     415        [0x152] = "Bass Increment",
     416        [0x153] = "Bass Decrement",
     417        [0x154] = "Treble Increment",
     418        [0x155] = "Treble Decrement",
     419        [0x156] = "Reserved",
     420        [0x157] = "Reserved",
     421        [0x158] = "Reserved",
     422        [0x159] = "Reserved",
     423        [0x15a] = "Reserved",
     424        [0x15b] = "Reserved",
     425        [0x15c] = "Reserved",
     426        [0x15d] = "Reserved",
     427        [0x15e] = "Reserved",
     428        [0x15f] = "Reserved",
     429        [0x160] = "Speaker System",
     430        [0x161] = "Channel Left",
     431        [0x162] = "Channel Right",
     432        [0x163] = "Channel Center",
     433        [0x164] = "Channel Front",
     434        [0x165] = "Channel Center Front",
     435        [0x166] = "Channel Side",
     436        [0x167] = "Channel Surround",
     437        [0x168] = "Channel Low Frequency Enhancement",
     438        [0x169] = "Channel Top",
     439        [0x16a] = "Channel Unknown",
     440        [0x16b] = "Reserved",
     441        [0x16c] = "Reserved",
     442        [0x16d] = "Reserved",
     443        [0x16e] = "Reserved",
     444        [0x16f] = "Reserved",
     445        [0x170] = "Sub-channel",
     446        [0x171] = "Sub-channel Increment",
     447        [0x172] = "Sub-channel Decrement",
     448        [0x173] = "Alternate Audio Increment",
     449        [0x174] = "Alternate Audio Decrement",
     450        [0x175] = "Reserved",
     451        [0x176] = "Reserved",
     452        [0x177] = "Reserved",
     453        [0x178] = "Reserved",
     454        [0x179] = "Reserved",
     455        [0x17a] = "Reserved",
     456        [0x17b] = "Reserved",
     457        [0x17c] = "Reserved",
     458        [0x17d] = "Reserved",
     459        [0x17e] = "Reserved",
     460        [0x17f] = "Reserved",
     461        [0x180] = "Application Launch Buttons",
     462        [0x181] = "AL Launch Buttion Configuration Tool",
     463        [0x182] = "AL Programmable Button Configuration",
     464        [0x183] = "AL Consumer Control Configuration",
     465        [0x184] = "AL Word Processor",
     466        [0x185] = "AL Text Editor",
     467        [0x186] = "AL Spreadsheet",
     468        [0x187] = "AL Graphics Editor",
     469        [0x188] = "AL Presentation App",
     470        [0x189] = "AL Database App",
     471        [0x18a] = "AL Email Reader",
     472        [0x18b] = "AL Newsreader",
     473        [0x18c] = "AL Voicemail",
     474        [0x18d] = "AL Contacts/Address Book",
     475        [0x18e] = "AL Calendar/Schedule",
     476        [0x18f] = "AL Task/Project Manager",
     477        [0x190] = "AL Log/Journal/Timecard",
     478        [0x191] = "AL Checkbook/Finance",
     479        [0x192] = "AL Calculator",
     480        [0x193] = "AL A/V Capture/Playback",
     481        [0x194] = "AL Local Machine Browser",
     482        [0x195] = "AL LAN/WAN Browser",
     483        [0x196] = "AL Internet Browser",
     484        [0x197] = "AL Remote Networking/ISP Connect",
     485        [0x198] = "AL Network Conference",
     486        [0x199] = "AL Network Chat",
     487        [0x19a] = "AL Telephony/Dialer",
     488        [0x19b] = "AL Logon",
     489        [0x19c] = "AL Logoff",
     490        [0x19d] = "AL Logon/Logoff",
     491        [0x19e] = "AL Terminal Lock/Screensaver",
     492        [0x19f] = "AL Control Panel",
     493        [0x1a0] = "AL Command Line Processor/Run",
     494        [0x1a1] = "AL Process/Task Manager",
     495        [0x1a2] = "AL Select Task/Application",
     496        [0x1a3] = "AL Next Task/Application",
     497        [0x1a4] = "AL Previous Task/Application",
     498        [0x1a5] = "AL Preemptive Halt Task/Application",
     499        [0x1a6] = "AL Integrated Help Center",
     500        [0x1a7] = "AL Documents",
     501        [0x1a8] = "AL Thesaurus",
     502        [0x1a9] = "AL Dictionary",
     503        [0x1aa] = "AL Desktop",
     504        [0x1ab] = "AL Spell Check",
     505        [0x1ac] = "AL Grammar Check",
     506        [0x1ad] = "AL Wireless Status",
     507        [0x1ae] = "AL Keyboard Layout",
     508        [0x1af] = "AL Virus Protection",
     509        [0x1b0] = "AL Encryption",
     510        [0x1b1] = "AL Screen Saver",
     511        [0x1b2] = "AL Alarms",
     512        [0x1b3] = "AL Clock",
     513        [0x1b4] = "AL File Browser",
     514        [0x1b5] = "AL Power Status",
     515        [0x1b6] = "AL Image Browser",
     516        [0x1b7] = "AL Audio Browser",
     517        [0x1b8] = "AL Movie Browser",
     518        [0x1b9] = "AL Digital Rights Manager",
     519        [0x1ba] = "AL Digital Wallet",
     520        [0x1bb] = "Reserved",
     521        [0x1bc] = "AL Instant Messaging",
     522        [0x1bd] = "AL OEM Features Tips/Tutorial Browser",
     523        [0x1be] = "AL OEM Help",
     524        [0x1bf] = "AL Online Community",
     525        [0x1c0] = "AL Entertainment Content Browser",
     526        [0x1c1] = "AL Online Shopping Browser",
     527        [0x1c2] = "AL SmartCard Information/Help",
     528        [0x1c3] = "AL Market Monitor/Finance Browser",
     529        [0x1c4] = "AL Customized Corporate News Browser",
     530        [0x1c5] = "AL Online Activity Browser",
     531        [0x1c6] = "AL Research/Search Browser",
     532        [0x1c7] = "AL Audio Player",
     533        [0x1c8] = "Reserved",
     534        [0x1c9] = "Reserved",
     535        [0x1ca] = "Reserved",
     536        [0x1cb] = "Reserved",
     537        [0x1cc] = "Reserved",
     538        [0x1cd] = "Reserved",
     539        [0x1ce] = "Reserved",
     540        [0x1cf] = "Reserved",
     541        [0x1d0] = "Reserved",
     542        [0x1d1] = "Reserved",
     543        [0x1d2] = "Reserved",
     544        [0x1d3] = "Reserved",
     545        [0x1d4] = "Reserved",
     546        [0x1d5] = "Reserved",
     547        [0x1d6] = "Reserved",
     548        [0x1d7] = "Reserved",
     549        [0x1d8] = "Reserved",
     550        [0x1d9] = "Reserved",
     551        [0x1da] = "Reserved",
     552        [0x1db] = "Reserved",
     553        [0x1dc] = "Reserved",
     554        [0x1dd] = "Reserved",
     555        [0x1de] = "Reserved",
     556        [0x1df] = "Reserved",
     557        [0x1e0] = "Reserved",
     558        [0x1e1] = "Reserved",
     559        [0x1e2] = "Reserved",
     560        [0x1e3] = "Reserved",
     561        [0x1e4] = "Reserved",
     562        [0x1e5] = "Reserved",
     563        [0x1e6] = "Reserved",
     564        [0x1e7] = "Reserved",
     565        [0x1e8] = "Reserved",
     566        [0x1e9] = "Reserved",
     567        [0x1ea] = "Reserved",
     568        [0x1eb] = "Reserved",
     569        [0x1ec] = "Reserved",
     570        [0x1ed] = "Reserved",
     571        [0x1ee] = "Reserved",
     572        [0x1ef] = "Reserved",
     573        [0x1f0] = "Reserved",
     574        [0x1f1] = "Reserved",
     575        [0x1f2] = "Reserved",
     576        [0x1f3] = "Reserved",
     577        [0x1f4] = "Reserved",
     578        [0x1f5] = "Reserved",
     579        [0x1f6] = "Reserved",
     580        [0x1f7] = "Reserved",
     581        [0x1f8] = "Reserved",
     582        [0x1f9] = "Reserved",
     583        [0x1fa] = "Reserved",
     584        [0x1fb] = "Reserved",
     585        [0x1fc] = "Reserved",
     586        [0x1fd] = "Reserved",
     587        [0x1fe] = "Reserved",
     588        [0x1ff] = "Reserved",
     589        [0x200] = "Generic GUI Application Controls",
     590        [0x201] = "AC New",
     591        [0x202] = "AC Open",
     592        [0x203] = "AC Close",
     593        [0x204] = "AC Exit",
     594        [0x205] = "AC Maximize",
     595        [0x206] = "AC Minimize",
     596        [0x207] = "AC Save",
     597        [0x208] = "AC Print",
     598        [0x209] = "AC Properties",
     599        [0x20a] = "",
     600        [0x20b] = "",
     601        [0x20c] = "",
     602        [0x20d] = "",
     603        [0x20e] = "",
     604        [0x20f] = "",
     605        [0x210] = "",
     606        [0x211] = "",
     607        [0x212] = "",
     608        [0x213] = "",
     609        [0x214] = "",
     610        [0x215] = "",
     611        [0x216] = "",
     612        [0x217] = "",
     613        [0x218] = "",
     614        [0x219] = "",
     615        [0x21a] = "AC Undo",
     616        [0x21b] = "AC Copy",
     617        [0x21c] = "AC Cut",
     618        [0x21d] = "AC Paste",
     619        [0x21e] = "AC Select All",
     620        [0x21f] = "AC Find",
     621        [0x220] = "AC Find and Replace",
     622        [0x221] = "AC Search",
     623        [0x222] = "AC Go To",
     624        [0x223] = "AC Home",
     625        [0x224] = "AC Back",
     626        [0x225] = "AC Forward",
     627        [0x226] = "AC Stop",
     628        [0x227] = "AC Refresh",
     629        [0x228] = "AC Previous Link",
     630        [0x229] = "AC Next Link",
     631        [0x22a] = "AC Bookmarks",
     632        [0x22b] = "AC History",
     633        [0x22c] = "AC Subscriptions",
     634        [0x22d] = "AC Zoom In",
     635        [0x22e] = "AC Zoom Out",
     636        [0x22f] = "AC Zoom",
     637        [0x230] = "AC Full Screen View",
     638        [0x231] = "AC Normal View",
     639        [0x232] = "AC View Toggle",
     640        [0x233] = "AC Scroll Up",
     641        [0x234] = "AC Scroll Down",
     642        [0x235] = "AC Scroll",
     643        [0x236] = "AC Pan Left",
     644        [0x237] = "AC Pan Right",
     645        [0x238] = "AC Pan",
     646        [0x239] = "AC New Window",
     647        [0x23a] = "AC Tile Horizontally",
     648        [0x23b] = "AC Tile Vertically",
     649        [0x23c] = "AC Format",
     650        [0x23d] = "AC Edit",
     651        [0x23e] = "AC Bold",
     652        [0x23f] = "AC Italics",
     653        [0x240] = "AC Undeline",
     654        [0x241] = "AC Strikethrough",
     655        [0x242] = "AC Subscript",
     656        [0x243] = "AC Superscript",
     657        [0x244] = "AC All Caps",
     658        [0x245] = "AC Rotate",
     659        [0x246] = "AC Resize",
     660        [0x247] = "AC Flip Horizontal",
     661        [0x248] = "AC Flip Vertical",
     662        [0x249] = "AC Mirror Horizontal",
     663        [0x24a] = "AC Mirror Vertical",
     664        [0x24b] = "AC Font Select",
     665        [0x24c] = "AC Font Color",
     666        [0x24d] = "AC Font Size",
     667        [0x24e] = "AC Justify Left",
     668        [0x24f] = "AC Justify Center H",
     669        [0x250] = "AC Justify Right",
     670        [0x251] = "AC Justify Block H",
     671        [0x252] = "AC Justify Top",
     672        [0x253] = "AC Justify Center V",
     673        [0x254] = "AC Justify Bottom",
     674        [0x255] = "AC Justify Block V",
     675        [0x256] = "AC Indent Decrease",
     676        [0x257] = "AC Indent Increase",
     677        [0x258] = "AC Numbered List",
     678        [0x259] = "AC Restart Numbering",
     679        [0x25a] = "AC Bulleted List",
     680        [0x25b] = "AC Promote",
     681        [0x25c] = "AC Demote",
     682        [0x25d] = "AC Yes",
     683        [0x25e] = "AC No",
     684        [0x25f] = "AC Cancel",
     685        [0x260] = "AC Catalog",
     686        [0x261] = "AC Buy/Checkout",
     687        [0x262] = "AC Add to Cart",
     688        [0x263] = "AC Expand",
     689        [0x264] = "AC Expand All",
     690        [0x265] = "AC Collapse",
     691        [0x266] = "AC Collapse All",
     692        [0x267] = "AC Print Preview",
     693        [0x268] = "AC Paste Special",
     694        [0x269] = "AC Insert Mode",
     695        [0x26a] = "AC Delete",
     696        [0x26b] = "AC Lock",
     697        [0x26c] = "AC Unlock",
     698        [0x26d] = "AC Protect",
     699        [0x26e] = "AC Unprotect",
     700        [0x26f] = "AC Attach Comment",
     701        [0x270] = "AC Delete Comment",
     702        [0x271] = "AC View Comment",
     703        [0x272] = "AC Select Word",
     704        [0x273] = "AC Select Sentence",
     705        [0x274] = "AC Select Paragraph",
     706        [0x275] = "AC Select Column",
     707        [0x276] = "AC Select Row",
     708        [0x277] = "AC Select Table",
     709        [0x278] = "AC Select Object",
     710        [0x279] = "AC Redo/Repeat",
     711        [0x27a] = "AC Sort",
     712        [0x27b] = "AC Sort Ascending",
     713        [0x27c] = "AC Sort Descending",
     714        [0x27d] = "AC Filter",
     715        [0x27e] = "AC Set Clock",
     716        [0x27f] = "AC View Clock",
     717        [0x280] = "AC Select Time Zone",
     718        [0x281] = "AC Edit Time Zones",
     719        [0x282] = "AC Set Alarm",
     720        [0x283] = "AC Clear Alarm",
     721        [0x284] = "AC Snooze Alarm",
     722        [0x285] = "AC Reset Alarm",
     723        [0x286] = "AC Synchronize",
     724        [0x287] = "AC Send/Receive",
     725        [0x288] = "AC Send To",
     726        [0x289] = "AC Reply",
     727        [0x28a] = "AC Reply All",
     728        [0x28b] = "AC Forward Msg",
     729        [0x28c] = "AC Send",
     730        [0x28d] = "AC Attach File",
     731        [0x28e] = "AC Upload",
     732        [0x28f] = "AC Download (Save Target As)",
     733        [0x290] = "AC Set Borders",
     734        [0x291] = "AC Insert Row",
     735        [0x292] = "AC Insert Column",
     736        [0x293] = "AC Insert File",
     737        [0x294] = "AC Insert Picture",
     738        [0x295] = "AC Insert Object",
     739        [0x296] = "AC Insert Symbol",
     740        [0x297] = "AC Save and Close",
     741        [0x298] = "AC Rename",
     742        [0x299] = "AC Merge",
     743        [0x29a] = "AC Split",
     744        [0x29b] = "AC Distrubute Horizontally",
     745        [0x29c] = "AC Distrubute Vertically"
     746};
     747
    77748/**
    78749 * Translates USB HID Usages from the Consumer Page into HelenOS keycodes.
    … …  
    98769
    99770/**
     771 * Translates USB HID Usages from the Consumer Page into their string
     772 * representation.
     773 *
     774 * @param usage USB HID Consumer Page Usage number.
     775 *
     776 * @retval HelenOS key code corresponding to the given USB Consumer Page Usage.
     777 */
     778const char *usb_multimedia_usage_to_str(int usage)
     779{
     780        size_t map_length = sizeof(usb_hid_consumer_usage_str) / sizeof(char *);
     781
     782        if ((usage < 0) || ((size_t)usage >= map_length))
     783                return "Unknown usage";
     784
     785        /*! @todo What if the usage is not in the table? */
     786        return usb_hid_consumer_usage_str[usage];
     787}
     788
     789/**
    100790 * @}
    101791 */

  • uspace/drv/usbhid/multimedia/keymap.h

    r8d3f198 r5f9b81af  
    3939unsigned int usb_multimedia_map_usage(int usage);
    4040
     41const char *usb_multimedia_usage_to_str(int usage);
     42
    4143#endif /* USB_HID_MULTIMEDIA_KEYMAP_H_ */
    4244

  • uspace/drv/usbhid/multimedia/multimedia.c

    r8d3f198 r5f9b81af  
    4343#include <usb/debug.h>
    4444#include <usb/hid/usages/core.h>
    45 #include <usb/hid/usages/consumer.h>
    4645
    4746#include <errno.h>
    … …  
    211210        }
    212211       
    213         usb_log_debug("%s function created. Handle: %d\n", NAME, fun->handle);
    214        
    215212        rc = ddf_fun_add_to_class(fun, "keyboard");
    216213        if (rc != EOK) {
    … …  
    360357                            usb_multimedia_map_usage(field->usage);
    361358                        const char *key_str =
    362                             usbhid_multimedia_usage_to_str(field->usage);
     359                            usb_multimedia_usage_to_str(field->usage);
    363360                        usb_log_info("Pressed key: %s\n", key_str);
    364361                        usb_multimedia_push_ev(hid_dev, multim_dev, KEY_PRESS,

  • uspace/drv/usbhid/subdrivers.c

    r8d3f198 r5f9b81af  
    3838#include <usb/hid/hidpath.h>
    3939
     40//#include "lgtch-ultrax/lgtch-ultrax.h"
    4041#include "multimedia/multimedia.h"
    4142#include "mouse/mousedev.h"
    42 #include "generic/hiddev.h"
    4343
    4444static usb_hid_subdriver_usage_t path_kbd[] = {
    … …  
    5858};
    5959
    60 //static usb_hid_subdriver_usage_t generic_hid_key_path[] = {
    61 //      {0, 0}
    62 //};
    63 
    6460const usb_hid_subdriver_mapping_t usb_hid_subdrivers[] = {
    6561        {
    6662                path_kbd,
    67                 0,
     63                -1,
    6864                USB_HID_PATH_COMPARE_BEGIN,
    6965                -1,
    … …  
    9288        {
    9389                path_mouse,
    94                 0,
     90                -1,
    9591                USB_HID_PATH_COMPARE_BEGIN,
    9692                -1,
    … …  
    10399                }
    104100        },
    105 //      {
    106 //              generic_hid_key_path,
    107 //              0,
    108 //              USB_HID_PATH_COMPARE_ANYWHERE,
    109 //              -1,
    110 //              -1,
    111 //              {
    112 //                      .init = usb_generic_hid_init,
    113 //                      .deinit = NULL,
    114 //                      .poll = usb_generic_hid_polling_callback,
    115 //                      .poll_end = NULL
    116 //              }
    117 //      },
    118101        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
    119102};

  • uspace/drv/usbhid/usbhid.c

    r8d3f198 r5f9b81af  
    234234        }
    235235       
    236         // add one generic HID subdriver per device
    237        
    238         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
     236        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(count *
    239237            sizeof(usb_hid_subdriver_t));
    240238        if (hid_dev->subdrivers == NULL) {
    … …  
    249247        }
    250248       
    251         hid_dev->subdrivers[count].init = usb_generic_hid_init;
    252         hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
    253         hid_dev->subdrivers[count].deinit = NULL;
    254         hid_dev->subdrivers[count].poll_end = NULL;
    255        
    256         hid_dev->subdriver_count = count + 1;
     249        hid_dev->subdriver_count = count;
    257250       
    258251        return EOK;
    … …  
    314307               
    315308                if (matched) {
    316                         usb_log_debug("Subdriver matched.\n");
    317309                        subdrivers[count++] = &mapping->subdriver;
    318310                }
    … …  
    356348/*----------------------------------------------------------------------------*/
    357349
    358 static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
    359 {
    360         assert(hid_dev != NULL && hid_dev->report != NULL);
    361        
    362         uint8_t report_id = 0;
    363         size_t size = usb_hid_report_size(hid_dev->report, report_id,
    364             USB_HID_REPORT_TYPE_INPUT);
    365        
    366         size_t max_size = 0;
    367        
    368         while (size > 0) {
    369                 max_size = (size > max_size) ? size : max_size;
    370                 size = usb_hid_report_size(hid_dev->report, report_id,
    371                     USB_HID_REPORT_TYPE_INPUT);
    372                 ++report_id;
    373         }
    374        
    375         usb_log_debug("Max size of input report: %zu\n", max_size);
    376        
    377         hid_dev->max_input_report_size = max_size;
    378         assert(hid_dev->input_report == NULL);
    379        
    380         hid_dev->input_report = malloc(max_size);
    381         if (hid_dev->input_report == NULL) {
    382                 return ENOMEM;
    383         }
    384         memset(hid_dev->input_report, 0, max_size);
    385        
    386         return EOK;
    387 }
    388 
    389 /*----------------------------------------------------------------------------*/
    390 
    391350usb_hid_dev_t *usb_hid_new(void)
    392351{
    … …  
    443402        /* Get the report descriptor and parse it. */
    444403        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    445             hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
     404            hid_dev->report);
    446405       
    447406        bool fallback = false;
    … …  
    524483        }
    525484       
    526         // save max input report size and allocate space for the report
    527         rc = usb_hid_init_report(hid_dev);
    528         if (rc != EOK) {
    529                 usb_log_error("Failed to initialize input report buffer.\n");
    530         }
    531        
    532485        return rc;
    533486}
    … …  
    547500        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    548501       
    549 //      int allocated = (hid_dev->input_report != NULL);
    550         assert(hid_dev->input_report != NULL);
    551         assert(hid_dev->max_input_report_size >= buffer_size);
    552        
    553 //      if (/*!allocated*/
    554 //          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
    555 //              uint8_t *input_old = hid_dev->input_report;
    556 //              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
    557                
    558 //              if (input_new == NULL) {
    559 //                      usb_log_error("Failed to allocate space for input "
    560 //                          "buffer. This event may not be reported\n");
    561 //                      memset(hid_dev->input_report, 0,
    562 //                          hid_dev->input_report_size);
    563 //              } else {
    564 //                      memcpy(input_new, input_old,
    565 //                          hid_dev->input_report_size);
    566 //                      hid_dev->input_report = input_new;
    567 //                      if (allocated) {
    568 //                              free(input_old);
    569 //                      }
    570 //                      usb_hid_new_report();
    571 //              }
    572 //      }
     502        int allocated = (hid_dev->input_report != NULL);
     503       
     504        if (!allocated
     505            || hid_dev->input_report_size < buffer_size) {
     506                uint8_t *input_old = hid_dev->input_report;
     507                uint8_t *input_new = (uint8_t *)malloc(buffer_size);
     508               
     509                if (input_new == NULL) {
     510                        usb_log_error("Failed to allocate space for input "
     511                            "buffer. This event may not be reported\n");
     512                        memset(hid_dev->input_report, 0,
     513                            hid_dev->input_report_size);
     514                } else {
     515                        memcpy(input_new, input_old,
     516                            hid_dev->input_report_size);
     517                        hid_dev->input_report = input_new;
     518                        if (allocated) {
     519                                free(input_old);
     520                        }
     521                        usb_hid_new_report();
     522                }
     523        }
    573524       
    574525        /*! @todo This should probably be atomic. */
    575526        memcpy(hid_dev->input_report, buffer, buffer_size);
    576527        hid_dev->input_report_size = buffer_size;
    577         usb_hid_new_report();
    578528       
    579529        bool cont = false;

  • uspace/drv/usbhid/usbhid.h

    r8d3f198 r5f9b81af  
    9898       
    9999        size_t input_report_size;
    100         size_t max_input_report_size;
    101100} usb_hid_dev_t;
    102101

  • uspace/lib/drv/Makefile

    r8d3f198 r5f9b81af  
    4040        generic/remote_usb.c \
    4141        generic/remote_pci.c \
    42         generic/remote_usbhc.c \
    43         generic/remote_usbhid.c
     42        generic/remote_usbhc.c
    4443
    4544include $(USPACE_PREFIX)/Makefile.common

  • uspace/lib/drv/generic/dev_iface.c

    r8d3f198 r5f9b81af  
    4646#include "remote_pci.h"
    4747
    48 #include <stdio.h>
    49 
    5048static iface_dipatch_table_t remote_ifaces = {
    5149        .ifaces = {
    … …  
    6260{
    6361        assert(is_valid_iface_idx(idx));
    64        
    6562        return remote_ifaces.ifaces[idx];
    6663}

  • uspace/lib/drv/generic/driver.c

    r8d3f198 r5f9b81af  
    346346                sysarg_t method = IPC_GET_IMETHOD(call);
    347347                int iface_idx;
    348                
    349                 printf("driver_connection_gen(): method: %d\n", method);
    350348               
    351349                switch  (method) {
    … …  
    397395                         * handling ("remote interface").
    398396                         */
    399                         printf("iface_idx: %d\n", iface_idx);
    400397                        remote_iface_t *rem_iface = get_remote_iface(iface_idx);
    401398                        assert(rem_iface != NULL);
    … …  
    408405                                /* The interface has not such method */
    409406                                printf("%s: driver_connection_gen error - "
    410                                     "invalid interface method (%d).\n",
    411                                     driver->name, iface_method_idx);
     407                                    "invalid interface method.", driver->name);
    412408                                async_answer_0(callid, ENOTSUP);
    413409                                break;

  • uspace/lib/drv/generic/remote_usbhid.c

    r8d3f198 r5f9b81af  
    3636#include <errno.h>
    3737#include <assert.h>
    38 #include <stdio.h>
    3938
    4039#include "usbhid_iface.h"
    … …  
    4342static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4443static void remote_usbhid_get_event(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    45 static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    46 static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4744// static void remote_usbhid_(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4845
    … …  
    5047static remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
    5148        remote_usbhid_get_event_length,
    52         remote_usbhid_get_event,
    53         remote_usbhid_get_report_descriptor_length,
    54         remote_usbhid_get_report_descriptor
     49        remote_usbhid_get_event
    5550};
    5651
    … …  
    6358};
    6459
    65 //usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     60usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    6661
    6762
    … …  
    6964    ipc_callid_t callid, ipc_call_t *call)
    7065{
    71         printf("remote_usbhid_get_event_length()\n");
    72        
    7366        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    7467
    7568        if (!hid_iface->get_event_length) {
    76                 printf("Get event length not set!\n");
    7769                async_answer_0(callid, ENOTSUP);
    7870                return;
    7971        }
    8072
    81         size_t len = hid_iface->get_event_length(fun);
    82 //      if (len == 0) {
    83 //              len = EEMPTY;
    84 //      }
    85         async_answer_1(callid, EOK, len);
    86        
    87 //      if (len < 0) {
    88 //              async_answer_0(callid, len);
    89 //      } else {
    90 //              async_answer_1(callid, EOK, len);
    91 //      }
     73        int len = hid_iface->get_event_length(fun);
     74        if (len == 0) {
     75                len = EEMPTY;
     76        }
     77        if (len < 0) {
     78                async_answer_0(callid, len);
     79        } else {
     80                async_answer_1(callid, EOK, len);
     81        }
    9282}
    9383
    … …  
    110100                return;
    111101        }
    112 //      /* Check that length is even number. Truncate otherwise. */
    113 //      if ((len % 2) == 1) {
    114 //              len--;
    115 //      }
     102        /* Check that length is even number. Truncate otherwise. */
     103        if ((len % 2) == 1) {
     104                len--;
     105        }
    116106        if (len == 0) {
    117107                async_answer_0(data_callid, EINVAL);
    118108                async_answer_0(callid, EINVAL);
    119                 return;
    120109        }
    121110
    122111        int rc;
    123112
    124         uint8_t *data = malloc(len);
    125         if (data == NULL) {
     113        size_t items = len / 2;
     114        uint16_t *usage_pages_and_usages = malloc(sizeof(uint16_t) * len);
     115        if (usage_pages_and_usages == NULL) {
    126116                async_answer_0(data_callid, ENOMEM);
    127117                async_answer_0(callid, ENOMEM);
    128                 return;
    129118        }
    130119
    131         size_t act_length;
    132         rc = hid_iface->get_event(fun, data, len, &act_length, flags);
     120        size_t act_items;
     121        int rc = hid_iface->get_event(fun, usage_pages_and_usages,
     122            usage_pages_and_usages + items, items, &act_items, flags);
    133123        if (rc != EOK) {
    134                 free(data);
     124                free(usage_pages_and_usages);
    135125                async_answer_0(data_callid, rc);
    136126                async_answer_0(callid, rc);
    137                 return;
    138127        }
    139         if (act_length >= len) {
     128        if (act_items >= items) {
    140129                /* This shall not happen. */
    141130                // FIXME: how about an assert here?
    142                 act_length = len;
     131                act_items = items;
    143132        }
    144133
    145         async_data_read_finalize(data_callid, data, act_length);
     134        async_data_read_finalize(data_callid, usage_pages_and_usages,
     135            act_items * 2 * sizeof(uint16_t));
    146136
    147         free(data);
     137        free(usage_pages_and_usages);
    148138
    149139        async_answer_0(callid, EOK);
    150140}
    151141
    152 void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
    153     ipc_callid_t callid, ipc_call_t *call)
    154 {
    155         usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    156 
    157         if (!hid_iface->get_report_descriptor_length) {
    158                 async_answer_0(callid, ENOTSUP);
    159                 return;
    160         }
    161 
    162         size_t len = hid_iface->get_report_descriptor_length(fun);
    163         async_answer_1(callid, EOK, (sysarg_t) len);
    164 }
    165 
    166 void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
    167     ipc_callid_t callid, ipc_call_t *call)
    168 {
    169         usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    170 
    171         if (!hid_iface->get_report_descriptor) {
    172                 async_answer_0(callid, ENOTSUP);
    173                 return;
    174         }
    175 
    176         size_t len;
    177         ipc_callid_t data_callid;
    178         if (!async_data_read_receive(&data_callid, &len)) {
    179                 async_answer_0(callid, EINVAL);
    180                 return;
    181         }
    182 
    183         if (len == 0) {
    184                 async_answer_0(data_callid, EINVAL);
    185                 async_answer_0(callid, EINVAL);
    186                 return;
    187         }
    188 
    189         uint8_t *descriptor = malloc(len);
    190         if (descriptor == NULL) {
    191                 async_answer_0(data_callid, ENOMEM);
    192                 async_answer_0(callid, ENOMEM);
    193                 return;
    194         }
    195 
    196         size_t act_len = 0;
    197         int rc = hid_iface->get_report_descriptor(fun, descriptor, len,
    198             &act_len);
    199         if (act_len > len) {
    200                 rc = ELIMIT;
    201         }
    202         if (rc != EOK) {
    203                 free(descriptor);
    204                 async_answer_0(data_callid, rc);
    205                 async_answer_0(callid, rc);
    206                 return;
    207         }
    208 
    209         async_data_read_finalize(data_callid, descriptor, act_len);
    210         async_answer_0(callid, EOK);
    211 
    212         free(descriptor);
    213 }
    214 
    215 
    216 
    217142/**
    218143 * @}

  • uspace/lib/drv/include/remote_usbhid.h

    r8d3f198 r5f9b81af  
    3636#define LIBDRV_REMOTE_USBHID_H_
    3737
    38 extern remote_iface_t remote_usbhid_iface;
     38remote_iface_t remote_usbhid_iface;
    3939
    4040#endif

  • uspace/lib/drv/include/usbhid_iface.h

    r8d3f198 r5f9b81af  
    4545         * Parameters: none
    4646         * Answer:
    47          * - Size of one report in bytes.
     47         * - EOK (expected always as long as device support USB HID interface)
     48         * Parameters of the answer:
     49         * - number of items
    4850         */
    4951        IPC_M_USBHID_GET_EVENT_LENGTH,
    … …  
    6163         * It is okay if the client requests less data. Extra data must
    6264         * be truncated by the driver.
    63          *
    64          * @todo Change this comment.
    6565         */
    66         IPC_M_USBHID_GET_EVENT,
    67        
    68         /** Get the size of the report descriptor from the HID device.
    69          *
    70          * Parameters:
    71          * - none
    72          * Answer:
    73          * - EOK - method is implemented (expected always)
    74          * Parameters of the answer:
    75          * - Size of the report in bytes.
    76          */
    77         IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH,
    78        
    79         /** Get the report descriptor from the HID device.
    80          *
    81          * Parameters:
    82          * - none
    83          * The call is followed by data read expecting the descriptor itself.
    84          * Answer:
    85          * - EOK - report descriptor returned.
    86          */
    87         IPC_M_USBHID_GET_REPORT_DESCRIPTOR
     66        IPC_M_USBHID_GET_EVENT
    8867} usbhid_iface_funcs_t;
    8968
    … …  
    9675         *
    9776         * @param[in] fun DDF function answering the request.
    98          * @return Size of the event in bytes.
     77         * @return Number of events or error code.
    9978         */
    10079        size_t (*get_event_length)(ddf_fun_t *fun);
    … …  
    10887         * @return Error code.
    10988         */
    110         int (*get_event)(ddf_fun_t *fun, uint8_t *buffer, size_t size,
     89        int (*get_event)(ddf_fun_t *fun, int32_t *buffer, size_t size,
    11190            size_t *act_size, unsigned int flags);
    112        
    113         /** Get size of the report descriptor in bytes.
    114          *
    115          * @param[in] fun DDF function answering the request.
    116          * @return Size of the report descriptor in bytes.
    117          */
    118         size_t (*get_report_descriptor_length)(ddf_fun_t *fun);
    119        
    120         /** Get the report descriptor from the HID device.
    121          *
    122          * @param[in] fun DDF function answering the request.
    123          * @param[out] desc Buffer with the report descriptor.
    124          * @param[in] size Size of the allocated @p desc buffer.
    125          * @param[out] act_size Actual size of the report descriptor returned.
    126          * @return Error code.
    127          */
    128         int (*get_report_descriptor)(ddf_fun_t *fun, uint8_t *desc,
    129             size_t size, size_t *act_size);
    13091} usbhid_iface_t;
    13192

  • uspace/lib/usbhid/Makefile

    r8d3f198 r5f9b81af  
    4141        src/hidpath.c \
    4242        src/hidreport.c \
    43         src/consumer.c \
    4443        src/hidreq.c
    4544

  • uspace/lib/usbhid/include/usb/hid/hidreport.h

    r8d3f198 r5f9b81af  
    4444 * report parser.
    4545 *
    46  * \param[in] dev USB device representing a HID device.
    47  * \param[in/out] parser HID Report parser.
    48  * \param[out] report_desc Place to save report descriptor into.
    49  * \param[out] report_size
     46 * \param dev USB device representing a HID device.
     47 * \param parser HID Report parser.
    5048 *
    5149 * \retval EOK if successful.
    … …  
    5957 */
    6058int usb_hid_process_report_descriptor(usb_device_t *dev,
    61     usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size);
     59    usb_hid_report_t *report);
    6260
    6361#endif /* LIBUSB_HIDREPORT_H_ */

  • uspace/lib/usbhid/include/usb/hid/iface.h

    r8d3f198 r5f9b81af  
    3838#include <sys/types.h>
    3939
    40 int usbhid_dev_get_event_length(int, size_t *);
    41 int usbhid_dev_get_event(int, uint8_t *, size_t, size_t *,
     40int usbhid_dev_get_event_length(int);
     41int usbhid_dev_get_event(int, uint16_t *, uint16_t *, size_t, size_t *,
    4242    unsigned int);
    43 int usbhid_dev_get_report_descriptor_length(int, size_t *);
    44 int usbhid_dev_get_report_descriptor(int, uint8_t *, size_t, size_t *);
    4543
    4644#endif

  • uspace/lib/usbhid/src/hidiface.c

    r8d3f198 r5f9b81af  
    4646 * @return Number of usages returned or negative error code.
    4747 */
    48 int usbhid_dev_get_event_length(int dev_phone, size_t *size)
     48int usbhid_dev_get_event_length(int dev_phone)
    4949{
    5050        if (dev_phone < 0) {
    … …  
    5656            IPC_M_USBHID_GET_EVENT_LENGTH, &len);
    5757        if (rc == EOK) {
    58                 if (size != NULL) {
    59                         *size = (size_t) len;
    60                 }
     58                return (int) len;
     59        } else {
     60                return rc;
    6161        }
    62        
    63         return rc;
    6462}
    6563
    … …  
    7674 * @return Error code.
    7775 */
    78 int usbhid_dev_get_event(int dev_phone, uint8_t *buf,
    79     size_t size, size_t *actual_size, unsigned int flags)
     76int usbhid_dev_get_event(int dev_phone, uint16_t *usage_pages, uint16_t *usages,
     77    size_t usage_count, size_t *actual_usage_count, unsigned int flags)
    8078{
    8179        if (dev_phone < 0) {
    8280                return EINVAL;
    8381        }
    84         if ((buf == NULL)) {
     82        if ((usage_pages == NULL) || (usages == NULL)) {
    8583                return ENOMEM;
    8684        }
    87         if (size == 0) {
     85        if (usage_count == 0) {
    8886                return EINVAL;
    8987        }
    90        
    91 //      if (size == 0) {
    92 //              return EOK;
    93 //      }
    9488
    95         size_t buffer_size =  size;
    96         uint8_t *buffer = malloc(buffer_size);
     89        size_t buffer_size = sizeof(uint16_t) * usage_count * 2;
     90        uint16_t *buffer = malloc(buffer_size);
    9791        if (buffer == NULL) {
    9892                return ENOMEM;
    … …  
    134128        }
    135129
    136         size_t act_size = IPC_GET_ARG2(data_request_call);
     130        size_t actual_size = IPC_GET_ARG2(data_request_call);
     131        size_t items = actual_size / 2;
    137132
    138133        /* Copy the individual items. */
    139         memcpy(buf, buffer, act_size);
    140 //      memcpy(usages, buffer + items, items * sizeof(int32_t));
     134        memcpy(usage_pages, buffer, items * sizeof(uint16_t));
     135        memcpy(usages, buffer + items, items * sizeof(uint16_t));
    141136
    142         if (actual_size != NULL) {
    143                 *actual_size = act_size;
    144         }
    145 
    146         return EOK;
    147 }
    148 
    149 
    150 int usbhid_dev_get_report_descriptor_length(int dev_phone, size_t *size)
    151 {
    152         if (dev_phone < 0) {
    153                 return EINVAL;
    154         }
    155 
    156         sysarg_t arg_size;
    157         int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE),
    158             IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
    159         if (rc == EOK) {
    160                 if (size != NULL) {
    161                         *size = (size_t) arg_size;
    162                 }
    163         }
    164         return rc;
    165 }
    166 
    167 int usbhid_dev_get_report_descriptor(int dev_phone, uint8_t *buf, size_t size,
    168     size_t *actual_size)
    169 {
    170         if (dev_phone < 0) {
    171                 return EINVAL;
    172         }
    173         if ((buf == NULL)) {
    174                 return ENOMEM;
    175         }
    176         if (size == 0) {
    177                 return EINVAL;
    178         }
    179 
    180         aid_t opening_request = async_send_1(dev_phone,
    181             DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
    182             NULL);
    183         if (opening_request == 0) {
    184                 return ENOMEM;
    185         }
    186 
    187         ipc_call_t data_request_call;
    188         aid_t data_request = async_data_read(dev_phone, buf, size,
    189             &data_request_call);
    190         if (data_request == 0) {
    191                 async_wait_for(opening_request, NULL);
    192                 return ENOMEM;
    193         }
    194 
    195         sysarg_t data_request_rc;
    196         sysarg_t opening_request_rc;
    197         async_wait_for(data_request, &data_request_rc);
    198         async_wait_for(opening_request, &opening_request_rc);
    199 
    200         if (data_request_rc != EOK) {
    201                 /* Prefer return code of the opening request. */
    202                 if (opening_request_rc != EOK) {
    203                         return (int) opening_request_rc;
    204                 } else {
    205                         return (int) data_request_rc;
    206                 }
    207         }
    208 
    209         if (opening_request_rc != EOK) {
    210                 return (int) opening_request_rc;
    211         }
    212 
    213         size_t act_size = IPC_GET_ARG2(data_request_call);
    214 
    215         if (actual_size != NULL) {
    216                 *actual_size = act_size;
     137        if (actual_usage_count != NULL) {
     138                *actual_usage_count = items;
    217139        }
    218140

  • uspace/lib/usbhid/src/hidreport.c

    r8d3f198 r5f9b81af  
    164164
    165165int usb_hid_process_report_descriptor(usb_device_t *dev,
    166     usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size)
     166    usb_hid_report_t *report)
    167167{
    168168        if (dev == NULL || report == NULL) {
    … …  
    172172        }
    173173       
    174 //      uint8_t *report_desc = NULL;
    175 //      size_t report_size;
    176        
    177         int rc = usb_hid_get_report_descriptor(dev, report_desc, report_size);
     174        uint8_t *report_desc = NULL;
     175        size_t report_size;
     176       
     177        int rc = usb_hid_get_report_descriptor(dev, &report_desc,
     178            &report_size);
    178179       
    179180        if (rc != EOK) {
    180181                usb_log_error("Problem with getting Report descriptor: %s.\n",
    181182                    str_error(rc));
    182                 if (*report_desc != NULL) {
    183                         free(*report_desc);
    184                         *report_desc = NULL;
     183                if (report_desc != NULL) {
     184                        free(report_desc);
    185185                }
    186186                return rc;
    187187        }
    188188       
    189         assert(*report_desc != NULL);
    190        
    191         rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size);
     189        assert(report_desc != NULL);
     190       
     191        rc = usb_hid_parse_report_descriptor(report, report_desc, report_size);
    192192        if (rc != EOK) {
    193193                usb_log_error("Problem parsing Report descriptor: %s.\n",
    194194                    str_error(rc));
    195                 free(*report_desc);
    196                 *report_desc = NULL;
     195                free(report_desc);
    197196                return rc;
    198197        }
    199198       
    200199        usb_hid_descriptor_print(report);
     200        free(report_desc);
    201201       
    202202        return EOK;
Note: See TracChangeset for help on using the changeset viewer.