Changeset e56b8a3 in mainline


Ignore:
Timestamp:
2011-05-27T13:27:22Z (13 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0c904a3
Parents:
8242dd86 (diff), 567a3e2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Development changes

Location:
uspace
Files:
2 added
29 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/mkbd/Makefile

    r8242dd86 re56b8a3  
    3131
    3232LIBS = \
     33        $(LIBUSBHID_PREFIX)/libusbhid.a \
    3334        $(LIBUSBDEV_PREFIX)/libusbdev.a \
    3435        $(LIBUSB_PREFIX)/libusb.a \
    35         $(LIBDRV_PREFIX)/libdrv.a
     36        $(LIBDRV_PREFIX)/libdrv.a 
    3637EXTRA_CFLAGS = \
    3738        -I$(LIBUSB_PREFIX)/include \
    3839        -I$(LIBUSBDEV_PREFIX)/include \
    39         -I$(LIBDRV_PREFIX)/include
     40        -I$(LIBDRV_PREFIX)/include \
     41        -I$(LIBUSBHID_PREFIX)/include
    4042
    4143SOURCES = \

  • uspace/app/mkbd/main.c

    r8242dd86 re56b8a3  
    4545#include <devmap.h>
    4646#include <usb/dev/hub.h>
    47 #include <usb/hc.h>
     47//#include <usb/host.h>
     48//#include <usb/driver.h>
     49#include <usb/hid/iface.h>
    4850#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>
    4957
    5058#define NAME "mkbd"
    … …  
    5260static int dev_phone = -1;
    5361
    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;
     62static 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) {
     66                return ENOMEM;
     67        }
     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
     137static 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//      printf("Calling usb_hid_parse_report() with size %zu and "
     143//          "buffer: \n", size);
     144//      for (size_t i = 0; i < size; ++i) {
     145//              printf(" %X ", buffer[i]);
    76146//      }
    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 
    94 static 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;
     147//      printf("\n");
     148       
     149        uint8_t report_id;
     150        int rc = usb_hid_parse_report(report, buffer, size, &report_id);
     151        if (rc != EOK) {
     152//              printf("Error parsing report: %s\n", str_error(rc));
     153                return;
     154        }
     155       
     156        usb_hid_report_path_t *path = usb_hid_report_path();
     157        if (path == NULL) {
     158                return;
     159        }
     160       
     161        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
     162       
     163        usb_hid_report_path_set_report_id(path, report_id);
     164
     165        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
     166            report, NULL, path, USB_HID_PATH_COMPARE_END
     167            | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     168            USB_HID_REPORT_TYPE_INPUT);
     169       
     170//      printf("Field: %p\n", field);
     171       
     172        while (field != NULL) {
     173//              printf("Field usage: %u, field value: %d\n", field->usage,
     174//                  field->value);
     175                if (field->value != 0) {
     176                        const char *key_str =
     177                            usbhid_multimedia_usage_to_str(field->usage);
     178                        printf("Pressed key: %s\n", key_str);
     179                }
     180               
     181                field = usb_hid_report_get_sibling(
     182                    report, field, path, USB_HID_PATH_COMPARE_END
     183                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     184                    USB_HID_REPORT_TYPE_INPUT);
     185//              printf("Next field: %p\n", field);
     186        }
     187       
     188        usb_hid_report_path_free(path);
    123189}
    124190
    125 static 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) {
    147                 return ENOMEM;
    148         }
    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 }
     191#define MAX_PATH_LENGTH 1024
    206192
    207193static void print_usage(char *app_name)
    … …  
    209195#define _INDENT "      "
    210196
    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");
     197       printf(NAME ": Print out what multimedia keys were pressed.\n\n");
     198       printf("Usage: %s device\n", app_name);
     199       printf(_INDENT "The device is a devman path to the device.\n");
    214200
    215201#undef _OPTION
    … …  
    219205int main(int argc, char *argv[])
    220206{
     207        int act_event = -1;
    221208       
    222209        if (argc <= 1) {
    … …  
    226213       
    227214        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         }
     215        //const char *devpath = "/hw/pci0/00:06.0/ohci-rh/usb00_a2/HID1/hid";
    239216       
    240217        int rc;
    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",
     218       
     219        devman_handle_t dev_handle = 0;
     220        rc = devman_device_get_handle(devpath, &dev_handle, 0);
     221        if (rc != EOK) {
     222                printf("Failed to get handle from devman: %s.\n",
    247223                    str_error(rc));
    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);
     224                return rc;
     225        }
    261226       
    262227        rc = devman_device_connect(dev_handle, 0);
    263228        if (rc < 0) {
    264                 printf(NAME ": failed to connect to the device: %s.\n",
    265                        str_error(rc));
    266                 return -1;
     229                printf(NAME ": failed to connect to the device (handle %"
     230                       PRIun "): %s.\n", dev_handle, str_error(rc));
     231                return rc;
    267232        }
    268233       
    269234        dev_phone = rc;
    270         printf("Got phone to the device: %d\n", dev_phone);
    271        
    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 //      }
     235//      printf("Got phone to the device: %d\n", dev_phone);
     236       
     237        char path[MAX_PATH_LENGTH];
     238        rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
     239        if (rc != EOK) {
     240                return ENOMEM;
     241        }
     242       
     243        printf("Device path: %s\n", path);
     244       
     245       
     246        usb_hid_report_t *report = NULL;
     247        rc = initialize_report_parser(dev_phone, &report);
     248        if (rc != EOK) {
     249                printf("Failed to initialize report parser: %s\n",
     250                    str_error(rc));
     251                return rc;
     252        }
     253       
     254        assert(report != NULL);
     255       
     256        size_t size;
     257        rc = usbhid_dev_get_event_length(dev_phone, &size);
     258        if (rc != EOK) {
     259                printf("Failed to get event length: %s.\n", str_error(rc));
     260                return rc;
     261        }
     262       
     263//      printf("Event length: %zu\n", size);
     264        uint8_t *event = (uint8_t *)malloc(size);
     265        if (event == NULL) {
     266                // hangup phone?
     267                return ENOMEM;
     268        }
     269       
     270//      printf("Event length: %zu\n", size);
     271       
     272        size_t actual_size;
     273        int event_nr;
     274       
     275        while (1) {
     276                // get event from the driver
     277//              printf("Getting event from the driver.\n");
     278               
     279                /** @todo Try blocking call. */
     280                rc = usbhid_dev_get_event(dev_phone, event, size, &actual_size,
     281                    &event_nr, 0);
     282                if (rc != EOK) {
     283                        // hangup phone?
     284                        printf("Error in getting event from the HID driver:"
     285                            "%s.\n", str_error(rc));
     286                        break;
     287                }
     288               
     289//              printf("Got buffer: %p, size: %zu, max size: %zu\n", event,
     290//                  actual_size, size);
     291               
     292//              printf("Event number: %d, my actual event: %d\n", event_nr,
     293//                  act_event);
     294                if (event_nr > act_event) {
     295                        print_key(event, size, report);
     296                        act_event = event_nr;
     297                }
     298               
     299                async_usleep(10000);
     300        }
    292301       
    293302        return 0;

  • uspace/drv/ohci/hc.c

    r8242dd86 re56b8a3  
    343343{
    344344        assert(instance);
    345         usb_log_debug("OHCI(%p) interrupt: %x.\n", instance, status);
    346345        if ((status & ~I_SF) == 0) /* ignore sof status */
    347346                return;
     347        usb_log_debug2("OHCI(%p) interrupt: %x.\n", instance, status);
    348348        if (status & I_RHSC)
    349349                rh_interrupt(&instance->rh);

  • uspace/drv/ohci/root_hub.c

    r8242dd86 re56b8a3  
    6161        .vendor_id = 0x16db,
    6262        .product_id = 0x0001,
    63         /// \TODO these values migt be different
    6463        .str_serial_number = 0,
    6564        .usb_spec_version = 0x110,
    … …  
    119118static const uint32_t hub_clear_feature_by_writing_one_mask =
    120119   RHS_CLEAR_PORT_POWER;
    121    // 1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
    122120
    123121/**
    … …  
    127125    RHS_LPSC_FLAG |
    128126    RHS_OCIC_FLAG;
    129     //(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
    130     //(1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    131127
    132128/**
    … …  
    135131static const uint32_t hub_set_feature_direct_mask =
    136132    RHS_SET_PORT_POWER;
    137     //(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    138133
    139134/**
    … …  
    160155    RHPS_PRSC_FLAG;
    161156
    162 /*
    163 
    164     (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
    165     (1 << USB_HUB_FEATURE_PORT_SUSPEND) |
    166     (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) |
    167     (1 << USB_HUB_FEATURE_PORT_POWER) |
    168     (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
    169     (1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
    170     (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) |
    171     (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
    172     (1 << USB_HUB_FEATURE_C_PORT_RESET);
    173  */
    174157//note that USB_HUB_FEATURE_PORT_POWER bit is translated into
    175158//USB_HUB_FEATURE_PORT_LOW_SPEED for port set feature request
    … …  
    179162 */
    180163static const uint32_t port_status_change_mask = RHPS_CHANGE_WC_MASK;
    181 /*    (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
    182     (1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
    183     (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
    184     (1 << USB_HUB_FEATURE_C_PORT_RESET) |
    185     (1 << USB_HUB_FEATURE_C_PORT_SUSPEND);
    186 */
    187164
    188165static int create_serialized_hub_descriptor(rh_t *instance);
    … …  
    420397 * create answer to port status_request
    421398 *
    422  * Copy content of corresponding port status register to answer buffer.
     399 * Copy content of corresponding port status register to answer buffer. The
     400 * format of the port status register and port status data is the same (
     401 * see OHCI root hub and USB hub documentation).
    423402 *
    424403 * @param instance root hub instance
    … …  
    431410        if (port < 1 || port > instance->port_count)
    432411                return EINVAL;
    433         uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
    434412        request->transfered_size = 4;
    435         uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
     413        uint32_t data = instance->registers->rh_port_status[port - 1];
     414        memcpy(request->data_buffer,&data,4);
    436415#if 0
    437416        int i;
    … …  
    450429 * create answer to port status_request
    451430 *
    452  * Copy content of hub status register to answer buffer.
     431 * This copies flags in hub status register into the buffer. The format of the
     432 * status register and status message is the same, according to USB hub
     433 * specification and OHCI root hub specification.
    453434 *
    454435 * @param instance root hub instance
    … …  
    458439static int process_get_hub_status_request(rh_t *instance,
    459440    usb_transfer_batch_t * request) {
    460         uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
     441        //uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
    461442        request->transfered_size = 4;
    462443        //bits, 0,1,16,17
    463444        uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
    464         uint32_buffer[0] = mask & instance->registers->rh_status;
     445        uint32_t data = mask & instance->registers->rh_status;
     446        //uint32_buffer[0] = mask & instance->registers->rh_status;
     447        memcpy(request->data_buffer,&data,4);
    465448
    466449        return EOK;
    … …  
    516499            | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
    517500        bzero(bitmap, instance->interrupt_mask_size);
    518         if (instance->registers->rh_status & mask) {
     501        if ((instance->registers->rh_status & mask) !=0 ) {
    519502                bitmap[0] = 1;
    520503        }
    … …  
    522505        mask = port_status_change_mask;
    523506        for (port = 1; port <= instance->port_count; ++port) {
    524                 if (mask & instance->registers->rh_port_status[port - 1]) {
     507                if ((mask & instance->registers->rh_port_status[port - 1]) != 0) {
    525508
    526509                        bitmap[(port) / 8] += 1 << (port % 8);

  • uspace/drv/uhci-hcd/uhci.c

    r8242dd86 re56b8a3  
    6161} uhci_t;
    6262
    63 static inline uhci_t * dev_to_uhci(ddf_dev_t *dev)
     63static inline uhci_t * dev_to_uhci(const ddf_dev_t *dev)
    6464{
    6565        assert(dev);
    … …  
    7777{
    7878        assert(dev);
    79         uhci_t *uhci = dev->driver_data;
    80         assert(uhci);
     79        uhci_t *uhci = dev_to_uhci(dev);
    8180        hc_t *hc = &uhci->hc;
    82         uint16_t status = IPC_GET_ARG1(*call);
     81        const uint16_t status = IPC_GET_ARG1(*call);
    8382        assert(hc);
    8483        hc_interrupt(hc, status);
    8584}
     85/*----------------------------------------------------------------------------*/
     86/** Operations supported by the HC driver */
     87static ddf_dev_ops_t hc_ops = {
     88        .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
     89};
    8690/*----------------------------------------------------------------------------*/
    8791/** Get address of the device identified by handle.
    … …  
    115119 * @return Error code.
    116120 */
    117 static int usb_iface_get_hc_handle(
    118     ddf_fun_t *fun, devman_handle_t *handle)
     121static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
    119122{
    120123        assert(fun);
    … …  
    131134        .get_hc_handle = usb_iface_get_hc_handle,
    132135        .get_address = usb_iface_get_address
    133 };
    134 /*----------------------------------------------------------------------------*/
    135 /** Operations supported by the HC driver */
    136 static ddf_dev_ops_t hc_ops = {
    137         .interfaces[USBHC_DEV_IFACE] = &hc_iface, /* see iface.h/c */
    138136};
    139137/*----------------------------------------------------------------------------*/

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

    r8242dd86 re56b8a3  
    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, int32_t *buffer,
    65     size_t size, size_t *act_size, unsigned int flags);
     64static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     65    size_t size, size_t *act_size, int *event_nr, unsigned int flags);
    6666
    6767static int usb_generic_hid_client_connected(ddf_fun_t *fun);
     68
     69static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun);
     70
     71static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
     72    size_t size, size_t *actual_size);
    6873
    6974/*----------------------------------------------------------------------------*/
    … …  
    7176static usbhid_iface_t usb_generic_iface = {
    7277        .get_event = usb_generic_hid_get_event,
    73         .get_event_length = usb_generic_hid_get_event_length
     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
    7481};
    7582
    … …  
    8390static size_t usb_generic_hid_get_event_length(ddf_fun_t *fun)
    8491{
    85         if (fun == NULL || fun->driver_data) {
     92        usb_log_debug2("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) {
    8696                return 0;
    8797        }
    … …  
    8999        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    90100       
    91         return hid_dev->input_report_size;
    92 }
    93 
    94 /*----------------------------------------------------------------------------*/
    95 
    96 static int usb_generic_hid_get_event(ddf_fun_t *fun, int32_t *buffer,
    97     size_t size, size_t *act_size, unsigned int flags)
    98 {
    99         if (fun == NULL || fun->driver_data) {
     101        usb_log_debug2("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;
     105}
     106
     107/*----------------------------------------------------------------------------*/
     108
     109static int usb_generic_hid_get_event(ddf_fun_t *fun, uint8_t *buffer,
     110    size_t size, size_t *act_size, int *event_nr, unsigned int flags)
     111{
     112        usb_log_debug2("Generic HID: Get event.\n");
     113       
     114        if (fun == NULL || fun->driver_data == NULL || buffer == NULL
     115            || act_size == NULL || event_nr == NULL) {
     116                usb_log_debug("No function");
    100117                return EINVAL;
    101118        }
    … …  
    104121       
    105122        if (hid_dev->input_report_size > size) {
     123                usb_log_debug("input_report_size > size (%zu, %zu)\n",
     124                    hid_dev->input_report_size, size);
    106125                return EINVAL;  // TODO: other error code
    107126        }
    108127       
    109128        /*! @todo This should probably be atomic. */
    110         if (usb_hid_report_ready()) {
    111                 memcpy(buffer, hid_dev->input_report,
    112                     hid_dev->input_report_size);
    113                 *act_size = hid_dev->input_report_size;
    114                 usb_hid_report_received();
    115         }
     129//      if (usb_hid_report_ready()) {
     130//              usb_log_debug2("Report ready, size: %zu\n",
     131//                  hid_dev->input_report_size);
     132               
     133//              usb_hid_report_received();
     134//      } else {
     135//              memset(buffer, 0, hid_dev->input_report_size);
     136//      }
     137        memcpy(buffer, hid_dev->input_report,
     138            hid_dev->input_report_size);
     139        *act_size = hid_dev->input_report_size;
     140        *event_nr = usb_hid_report_number(hid_dev);
    116141       
    117142        // clear the buffer so that it will not be received twice
    … …  
    120145        // note that we already received this report
    121146//      report_received = true;
     147        usb_log_debug2("OK\n");
     148       
     149        return EOK;
     150}
     151
     152/*----------------------------------------------------------------------------*/
     153
     154static size_t usb_generic_get_report_descriptor_length(ddf_fun_t *fun)
     155{
     156        usb_log_debug("Generic HID: Get report descriptor length.\n");
     157       
     158        if (fun == NULL || fun->driver_data == NULL) {
     159                usb_log_debug("No function");
     160                return EINVAL;
     161        }
     162       
     163        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
     164       
     165        usb_log_debug2("hid_dev->report_desc_size = %zu\n",
     166            hid_dev->report_desc_size);
     167       
     168        return hid_dev->report_desc_size;
     169}
     170
     171/*----------------------------------------------------------------------------*/
     172
     173static int usb_generic_get_report_descriptor(ddf_fun_t *fun, uint8_t *desc,
     174    size_t size, size_t *actual_size)
     175{
     176        usb_log_debug2("Generic HID: Get report descriptor.\n");
     177       
     178        if (fun == NULL || fun->driver_data == NULL) {
     179                usb_log_debug("No function");
     180                return EINVAL;
     181        }
     182       
     183        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
     184       
     185        if (hid_dev->report_desc_size > size) {
     186                return EINVAL;  // TODO: other error code
     187        }
     188       
     189        memcpy(desc, hid_dev->report_desc, hid_dev->report_desc_size);
     190        *actual_size = hid_dev->report_desc_size;
    122191       
    123192        return EOK;
    … …  
    128197static int usb_generic_hid_client_connected(ddf_fun_t *fun)
    129198{
    130         usb_hid_report_received();
     199        usb_log_debug("Generic HID: Client connected.\n");
    131200        return EOK;
    132201}
    … …  
    145214                return ENOMEM;
    146215        }
     216       
     217        fun->ops = &usb_generic_hid_ops;
     218        fun->driver_data = hid_dev;
    147219
    148220        int rc = ddf_fun_bind(fun);
    … …  
    154226        }
    155227       
    156         fun->ops = &usb_generic_hid_ops;
    157         fun->driver_data = hid_dev;
     228        usb_log_debug("HID function created. Handle: %d\n", fun->handle);
    158229       
    159230        return EOK;
    … …  
    176247    uint8_t *buffer, size_t buffer_size)
    177248{
    178         usb_log_debug("usb_hid_polling_callback(%p, %p, %zu)\n",
     249        usb_log_debug2("usb_hid_polling_callback(%p, %p, %zu)\n",
    179250            hid_dev, buffer, buffer_size);
    180251        usb_debug_str_buffer(buffer, buffer_size, 0);

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

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

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

    r8242dd86 re56b8a3  
    234234       
    235235        if (mouse_dev->mouse_phone < 0) {
    236                 usb_log_error(NAME " No console phone.\n");
    237                 return false;   // ??
     236                usb_log_warning(NAME " No console phone.\n");
     237                return true;
    238238        }
    239239

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

    r8242dd86 re56b8a3  
    4848 */
    4949static int usb_hid_keymap_consumer[0x29c] = {
    50         [0xf] = KC_F1, /* Just for testing purposes */
    51         [0x5] = KC_F2, /* Just for testing purposes */
    52         [0x8] = KC_F3, /* Just for testing purposes */
    53         [0x6] = KC_F4, /* Just for testing purposes */
    54         [0x7] = KC_F5, /* Just for testing purposes */
    55         [0xc] = KC_F6, /* Just for testing purposes */
    56        
    5750        [0xb5] = 0,       /* Scan Next Track */
    5851        [0xb6] = 0,       /* Scan Previous Track */
    5952        [0xb7] = 0,       /* Stop */
    6053        [0xb8] = 0,       /* Eject */
    61         [0xcd] = KC_F2,   /* Play/Pause */
    62         [0xe2] = KC_F3,   /* Mute */
    63         [0xe9] = KC_F5,   /* Volume Increment */
    64         [0xea] = KC_F4,   /* Volume Decrement */
    65         [0x183] = 0,      /* AL Consumer Control Configuration */
     54        [0xcd] = 0/*KC_F2*/,   /* Play/Pause */
     55        [0xe2] = 0/*KC_F3*/,   /* Mute */
     56        [0xe9] = 0/*KC_F5*/,   /* Volume Increment */
     57        [0xea] = 0/*KC_F4*/,   /* Volume Decrement */
     58        [0x183] = 0/*KC_F1*/,      /* AL Consumer Control Configuration */
    6659        [0x18a] = 0,      /* AL Email Reader */
    6760        [0x192] = 0,      /* AL Calculator */
    6861        [0x221] = 0,      /* AC Search */
    69         [0x223] = 0,      /* AC Home */
     62        [0x223] = 0/*KC_F6*/,      /* AC Home */
    7063        [0x224] = 0,      /* AC Back */
    7164        [0x225] = 0,      /* AC Forward */
    7265        [0x226] = 0,      /* AC Stop */
    73         [0x227] = KC_F1,  /* AC Refresh */
    74         [0x22a] = KC_F6   /* AC Bookmarks */
    75 };
    76 
    77 static 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"
     66        [0x227] = 0,  /* AC Refresh */
     67        [0x22a] = 0   /* AC Bookmarks */
    74668};
    74769
    … …  
    76991
    77092/**
    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  */
    778 const 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 /**
    79093 * @}
    79194 */

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

    r8242dd86 re56b8a3  
    3939unsigned int usb_multimedia_map_usage(int usage);
    4040
    41 const char *usb_multimedia_usage_to_str(int usage);
    42 
    4341#endif /* USB_HID_MULTIMEDIA_KEYMAP_H_ */
    4442

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

    r8242dd86 re56b8a3  
    4343#include <usb/debug.h>
    4444#include <usb/hid/usages/core.h>
     45#include <usb/hid/usages/consumer.h>
    4546
    4647#include <errno.h>
    … …  
    5859typedef struct usb_multimedia_t {
    5960        /** Previously pressed keys (not translated to key codes). */
    60         int32_t *keys_old;
     61        //int32_t *keys_old;
    6162        /** Currently pressed keys (not translated to key codes). */
    62         int32_t *keys;
     63        //int32_t *keys;
    6364        /** Count of stored keys (i.e. number of keys in the report). */
    64         size_t key_count;       
     65        //size_t key_count;     
    6566        /** IPC phone to the console device (for sending key events). */
    6667        int console_phone;
    … …  
    174175       
    175176        // free all buffers
    176         if ((*multim_dev)->keys != NULL) {
    177                 free((*multim_dev)->keys);
    178         }
    179         if ((*multim_dev)->keys_old != NULL) {
    180                 free((*multim_dev)->keys_old);
    181         }
     177//      if ((*multim_dev)->keys != NULL) {
     178//              free((*multim_dev)->keys);
     179//      }
     180//      if ((*multim_dev)->keys_old != NULL) {
     181//              free((*multim_dev)->keys_old);
     182//      }
    182183
    183184        free(*multim_dev);
    … …  
    209210                return rc;
    210211        }
     212       
     213        usb_log_debug("%s function created. Handle: %d\n", NAME, fun->handle);
    211214       
    212215        rc = ddf_fun_add_to_class(fun, "keyboard");
    … …  
    241244        multim_dev->console_phone = -1;
    242245       
    243         usb_hid_report_path_t *path = usb_hid_report_path();
    244         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
    245        
    246         usb_hid_report_path_set_report_id(path, 1);
    247        
    248         multim_dev->key_count = usb_hid_report_size(
    249             hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
    250 
    251         usb_hid_report_path_free(path);
    252        
    253         usb_log_debug(NAME " Size of the input report: %zu\n",
    254             multim_dev->key_count);
    255        
    256         multim_dev->keys = (int32_t *)calloc(multim_dev->key_count,
    257             sizeof(int32_t));
    258        
    259         if (multim_dev->keys == NULL) {
    260                 usb_log_fatal("No memory!\n");
    261                 free(multim_dev);
    262                 return ENOMEM;
    263         }
    264        
    265         multim_dev->keys_old =
    266                 (int32_t *)calloc(multim_dev->key_count, sizeof(int32_t));
    267        
    268         if (multim_dev->keys_old == NULL) {
    269                 usb_log_fatal("No memory!\n");
    270                 free(multim_dev->keys);
    271                 free(multim_dev);
    272                 return ENOMEM;
    273         }
     246//      usb_hid_report_path_t *path = usb_hid_report_path();
     247//      usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
     248       
     249//      usb_hid_report_path_set_report_id(path, 1);
     250       
     251//      multim_dev->key_count = usb_hid_report_size(
     252//          hid_dev->report, 1, USB_HID_REPORT_TYPE_INPUT);
     253
     254//      usb_hid_report_path_free(path);
     255       
     256//      usb_log_debug(NAME " Size of the input report: %zu\n",
     257//          multim_dev->key_count);
     258       
     259//      multim_dev->keys = (int32_t *)calloc(multim_dev->key_count,
     260//          sizeof(int32_t));
     261       
     262//      if (multim_dev->keys == NULL) {
     263//              usb_log_fatal("No memory!\n");
     264//              free(multim_dev);
     265//              return ENOMEM;
     266//      }
     267       
     268//      multim_dev->keys_old =
     269//              (int32_t *)calloc(multim_dev->key_count, sizeof(int32_t));
     270       
     271//      if (multim_dev->keys_old == NULL) {
     272//              usb_log_fatal("No memory!\n");
     273//              free(multim_dev->keys);
     274//              free(multim_dev);
     275//              return ENOMEM;
     276//      }
    274277       
    275278        /*! @todo Autorepeat */
    … …  
    357360                            usb_multimedia_map_usage(field->usage);
    358361                        const char *key_str =
    359                             usb_multimedia_usage_to_str(field->usage);
     362                            usbhid_multimedia_usage_to_str(field->usage);
    360363                        usb_log_info("Pressed key: %s\n", key_str);
    361364                        usb_multimedia_push_ev(hid_dev, multim_dev, KEY_PRESS,

  • uspace/drv/usbhid/subdrivers.c

    r8242dd86 re56b8a3  
    3838#include <usb/hid/hidpath.h>
    3939
    40 //#include "lgtch-ultrax/lgtch-ultrax.h"
    4140#include "multimedia/multimedia.h"
    4241#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
    6064const usb_hid_subdriver_mapping_t usb_hid_subdrivers[] = {
    6165        {
    6266                path_kbd,
    63                 -1,
     67                0,
    6468                USB_HID_PATH_COMPARE_BEGIN,
    6569                -1,
    … …  
    8892        {
    8993                path_mouse,
    90                 -1,
     94                0,
    9195                USB_HID_PATH_COMPARE_BEGIN,
    9296                -1,
    … …  
    99103                }
    100104        },
     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//      },
    101118        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
    102119};

  • uspace/drv/usbhid/usbhid.c

    r8242dd86 re56b8a3  
    6363static const int USB_HID_MAX_SUBDRIVERS = 10;
    6464
    65 static fibril_local bool report_received;
     65/** @todo What happens if this is not fibril local? */
     66//static fibril_local bool report_number;
    6667
    6768/*----------------------------------------------------------------------------*/
    … …  
    234235        }
    235236       
    236         hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc(count *
     237        // add one generic HID subdriver per device
     238       
     239        hid_dev->subdrivers = (usb_hid_subdriver_t *)malloc((count + 1) *
    237240            sizeof(usb_hid_subdriver_t));
    238241        if (hid_dev->subdrivers == NULL) {
    … …  
    247250        }
    248251       
    249         hid_dev->subdriver_count = count;
     252        hid_dev->subdrivers[count].init = usb_generic_hid_init;
     253        hid_dev->subdrivers[count].poll = usb_generic_hid_polling_callback;
     254        hid_dev->subdrivers[count].deinit = NULL;
     255        hid_dev->subdrivers[count].poll_end = NULL;
     256       
     257        hid_dev->subdriver_count = count + 1;
    250258       
    251259        return EOK;
    … …  
    307315               
    308316                if (matched) {
     317                        usb_log_debug("Subdriver matched.\n");
    309318                        subdrivers[count++] = &mapping->subdriver;
    310319                }
    … …  
    348357/*----------------------------------------------------------------------------*/
    349358
     359static int usb_hid_init_report(usb_hid_dev_t *hid_dev)
     360{
     361        assert(hid_dev != NULL && hid_dev->report != NULL);
     362       
     363        uint8_t report_id = 0;
     364        size_t size;/* = usb_hid_report_byte_size(hid_dev->report, report_id,
     365            USB_HID_REPORT_TYPE_INPUT);*/
     366       
     367        size_t max_size = 0;
     368       
     369        do {
     370                size = usb_hid_report_byte_size(hid_dev->report, report_id,
     371                    USB_HID_REPORT_TYPE_INPUT);
     372                usb_log_debug("Report ID: %u, size: %zu\n", report_id, size);
     373                max_size = (size > max_size) ? size : max_size;
     374                report_id = usb_hid_get_next_report_id(hid_dev->report,
     375                    report_id, USB_HID_REPORT_TYPE_INPUT);
     376        } while (report_id != 0);
     377       
     378        usb_log_debug("Max size of input report: %zu\n", max_size);
     379       
     380        hid_dev->max_input_report_size = max_size;
     381        assert(hid_dev->input_report == NULL);
     382       
     383        hid_dev->input_report = malloc(max_size);
     384        if (hid_dev->input_report == NULL) {
     385                return ENOMEM;
     386        }
     387        memset(hid_dev->input_report, 0, max_size);
     388       
     389        return EOK;
     390}
     391
     392/*----------------------------------------------------------------------------*/
     393
    350394usb_hid_dev_t *usb_hid_new(void)
    351395{
    … …  
    402446        /* Get the report descriptor and parse it. */
    403447        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    404             hid_dev->report);
     448            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    405449       
    406450        bool fallback = false;
    … …  
    483527        }
    484528       
     529        // save max input report size and allocate space for the report
     530        rc = usb_hid_init_report(hid_dev);
     531        if (rc != EOK) {
     532                usb_log_error("Failed to initialize input report buffer.\n");
     533        }
     534       
    485535        return rc;
    486536}
    … …  
    500550        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    501551       
    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         }
     552//      int allocated = (hid_dev->input_report != NULL);
     553        assert(hid_dev->input_report != NULL);
     554        usb_log_debug("Max input report size: %zu, buffer size: %zu\n",
     555            hid_dev->max_input_report_size, buffer_size);
     556        assert(hid_dev->max_input_report_size >= buffer_size);
     557       
     558//      if (/*!allocated*/
     559//          /*|| *//*hid_dev->input_report_size < buffer_size*/) {
     560//              uint8_t *input_old = hid_dev->input_report;
     561//              uint8_t *input_new = (uint8_t *)malloc(buffer_size);
     562               
     563//              if (input_new == NULL) {
     564//                      usb_log_error("Failed to allocate space for input "
     565//                          "buffer. This event may not be reported\n");
     566//                      memset(hid_dev->input_report, 0,
     567//                          hid_dev->input_report_size);
     568//              } else {
     569//                      memcpy(input_new, input_old,
     570//                          hid_dev->input_report_size);
     571//                      hid_dev->input_report = input_new;
     572//                      if (allocated) {
     573//                              free(input_old);
     574//                      }
     575//                      usb_hid_new_report();
     576//              }
     577//      }
    524578       
    525579        /*! @todo This should probably be atomic. */
    526580        memcpy(hid_dev->input_report, buffer, buffer_size);
    527581        hid_dev->input_report_size = buffer_size;
     582        usb_hid_new_report(hid_dev);
    528583       
    529584        bool cont = false;
    … …  
    601656/*----------------------------------------------------------------------------*/
    602657
    603 void usb_hid_new_report(void)
    604 {
    605         report_received = false;
    606 }
    607 
    608 /*----------------------------------------------------------------------------*/
    609 
    610 void usb_hid_report_received(void)
    611 {
    612         report_received = true;
    613 }
    614 
    615 /*----------------------------------------------------------------------------*/
    616 
    617 bool usb_hid_report_ready(void)
    618 {
    619         return !report_received;
    620 }
     658void usb_hid_new_report(usb_hid_dev_t *hid_dev)
     659{
     660        ++hid_dev->report_nr;
     661}
     662
     663/*----------------------------------------------------------------------------*/
     664
     665int usb_hid_report_number(usb_hid_dev_t *hid_dev)
     666{
     667        return hid_dev->report_nr;
     668}
     669
     670/*----------------------------------------------------------------------------*/
     671
     672//void usb_hid_report_received(void)
     673//{
     674//      ++report_number;
     675//}
     676
     677/*----------------------------------------------------------------------------*/
     678
     679//bool usb_hid_report_ready(void)
     680//{
     681//      return !report_received;
     682//}
    621683
    622684/*----------------------------------------------------------------------------*/

  • uspace/drv/usbhid/usbhid.h

    r8242dd86 re56b8a3  
    9898       
    9999        size_t input_report_size;
     100        size_t max_input_report_size;
     101       
     102        int report_nr;
    100103} usb_hid_dev_t;
    101104
    … …  
    127130//const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev);
    128131
    129 void usb_hid_new_report(void);
     132void usb_hid_new_report(usb_hid_dev_t *hid_dev);
    130133
    131 void usb_hid_report_received(void);
     134int usb_hid_report_number(usb_hid_dev_t *hid_dev);
    132135
    133 bool usb_hid_report_ready(void);
     136//void usb_hid_report_received(void);
     137
     138//bool usb_hid_report_ready(void);
    134139
    135140void usb_hid_free(usb_hid_dev_t **hid_dev);

  • uspace/drv/usbhub/usbhub.c

    r8242dd86 re56b8a3  
    6767    usb_hub_status_t status);
    6868
    69 static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
     69static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
    7070    usb_hub_status_t status);
    7171
    … …  
    386386        int opResult;
    387387        if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
    388                 opResult = usb_hub_clear_feature(hub_info->control_pipe,
    389                     USB_HUB_FEATURE_HUB_LOCAL_POWER);
    390                 if (opResult != EOK) {
    391                         usb_log_error("cannot power off hub: %d\n",
    392                             opResult);
     388                //poweroff all ports
     389                unsigned int port;
     390                for(port = 1;port <= hub_info->port_count;++port){
     391                        opResult = usb_hub_clear_port_feature(
     392                            hub_info->control_pipe,port,
     393                            USB_HUB_FEATURE_PORT_POWER);
     394                        if (opResult != EOK) {
     395                                usb_log_warning(
     396                                    "cannot power off port %d;  %d\n",
     397                                    port, opResult);
     398                        }
    393399                }
    394400        } else {
    395                 opResult = usb_hub_set_feature(hub_info->control_pipe,
    396                     USB_HUB_FEATURE_HUB_LOCAL_POWER);
    397                 if (opResult != EOK) {
    398                         usb_log_error("cannot power on hub: %d\n",
    399                             opResult);
     401                //power all ports
     402                unsigned int port;
     403                for(port = 1;port <= hub_info->port_count;++port){
     404                        opResult = usb_hub_set_port_feature(
     405                            hub_info->control_pipe,port,
     406                            USB_HUB_FEATURE_PORT_POWER);
     407                        if (opResult != EOK) {
     408                                usb_log_warning(
     409                                    "cannot power off port %d;  %d\n",
     410                                    port, opResult);
     411                        }
    400412                }
    401413        }
    … …  
    404416
    405417/**
    406  * process hub power change
    407  *
    408  * If the power has been lost, reestablish it.
    409  * If it was reestablished, re-power all ports.
     418 * process hub local power change
     419 *
     420 * This change is ignored.
    410421 * @param hub_info hub instance
    411422 * @param status hub status bitmask
    412423 * @return error code
    413424 */
    414 static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
     425static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
    415426    usb_hub_status_t status) {
    416427        int opResult = EOK;
    417         if (!usb_hub_is_status(status,USB_HUB_FEATURE_HUB_LOCAL_POWER)) {
    418                 //restart power on hub
    419                 opResult = usb_hub_set_feature(hub_info->control_pipe,
    420                     USB_HUB_FEATURE_HUB_LOCAL_POWER);
    421                 if (opResult != EOK) {
    422                         usb_log_error("cannot power on hub: %d\n",
    423                             opResult);
    424                 }
    425         } else {//power reestablished on hub- restart ports
    426                 size_t port;
    427                 for (port = 1; port <= hub_info->port_count; ++port) {
    428                         opResult = usb_hub_set_port_feature(
    429                             hub_info->control_pipe,
    430                             port, USB_HUB_FEATURE_PORT_POWER);
    431                         if (opResult != EOK) {
    432                                 usb_log_error("Cannot power on port %zu: %s.\n",
    433                                     port, str_error(opResult));
    434                         }
    435                 }
    436         }
    437         if(opResult!=EOK){
    438                 return opResult;//no feature clearing
    439         }
    440428        opResult = usb_hub_clear_feature(hub_info->control_pipe,
    441429            USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    … …  
    452440 *
    453441 * The change can be either in the over-current condition or
    454  * local-power lost condition.
     442 * local-power change.
    455443 * @param hub_info hub instance
    456444 */
    … …  
    487475        if (
    488476            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
    489                 usb_process_hub_power_change(hub_info, status);
     477                usb_process_hub_local_power_change(hub_info, status);
    490478        }
    491479}

  • uspace/lib/drv/Makefile

    r8242dd86 re56b8a3  
    4040        generic/remote_usb.c \
    4141        generic/remote_pci.c \
    42         generic/remote_usbhc.c
     42        generic/remote_usbhc.c \
     43        generic/remote_usbhid.c
    4344
    4445include $(USPACE_PREFIX)/Makefile.common

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

    r8242dd86 re56b8a3  
    4646#include "remote_pci.h"
    4747
     48#include <stdio.h>
     49
    4850static iface_dipatch_table_t remote_ifaces = {
    4951        .ifaces = {
    … …  
    6062{
    6163        assert(is_valid_iface_idx(idx));
     64       
    6265        return remote_ifaces.ifaces[idx];
    6366}

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

    r8242dd86 re56b8a3  
    405405                                /* The interface has not such method */
    406406                                printf("%s: driver_connection_gen error - "
    407                                     "invalid interface method.", driver->name);
     407                                    "invalid interface method (%d).\n",
     408                                    driver->name, iface_method_idx);
    408409                                async_answer_0(callid, ENOTSUP);
    409410                                break;

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

    r8242dd86 re56b8a3  
    3636#include <errno.h>
    3737#include <assert.h>
     38#include <stdio.h>
    3839
    3940#include "usbhid_iface.h"
    … …  
    4243static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4344static void remote_usbhid_get_event(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     45static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     46static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4447// static void remote_usbhid_(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4548
    … …  
    4750static remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
    4851        remote_usbhid_get_event_length,
    49         remote_usbhid_get_event
     52        remote_usbhid_get_event,
     53        remote_usbhid_get_report_descriptor_length,
     54        remote_usbhid_get_report_descriptor
    5055};
    5156
    … …  
    5863};
    5964
    60 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     65//usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    6166
    6267
    … …  
    6469    ipc_callid_t callid, ipc_call_t *call)
    6570{
     71        printf("remote_usbhid_get_event_length()\n");
     72       
    6673        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
    6774
    6875        if (!hid_iface->get_event_length) {
    69                 async_answer_0(callid, ENOTSUP);
    70                 return;
    71         }
    72 
    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         }
     76                printf("Get event length not set!\n");
     77                async_answer_0(callid, ENOTSUP);
     78                return;
     79        }
     80
     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//      }
    8292}
    8393
    … …  
    100110                return;
    101111        }
    102         /* Check that length is even number. Truncate otherwise. */
    103         if ((len % 2) == 1) {
    104                 len--;
    105         }
     112//      /* Check that length is even number. Truncate otherwise. */
     113//      if ((len % 2) == 1) {
     114//              len--;
     115//      }
    106116        if (len == 0) {
    107117                async_answer_0(data_callid, EINVAL);
    108118                async_answer_0(callid, EINVAL);
     119                return;
    109120        }
    110121
    111122        int rc;
    112123
    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) {
     124        uint8_t *data = malloc(len);
     125        if (data == NULL) {
    116126                async_answer_0(data_callid, ENOMEM);
    117127                async_answer_0(callid, ENOMEM);
    118         }
    119 
    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);
     128                return;
     129        }
     130
     131        size_t act_length;
     132        int event_nr;
     133        rc = hid_iface->get_event(fun, data, len, &act_length, &event_nr, flags);
    123134        if (rc != EOK) {
    124                 free(usage_pages_and_usages);
     135                free(data);
    125136                async_answer_0(data_callid, rc);
    126137                async_answer_0(callid, rc);
    127         }
    128         if (act_items >= items) {
     138                return;
     139        }
     140        if (act_length >= len) {
    129141                /* This shall not happen. */
    130142                // FIXME: how about an assert here?
    131                 act_items = items;
    132         }
    133 
    134         async_data_read_finalize(data_callid, usage_pages_and_usages,
    135             act_items * 2 * sizeof(uint16_t));
    136 
    137         free(usage_pages_and_usages);
    138 
     143                act_length = len;
     144        }
     145
     146        async_data_read_finalize(data_callid, data, act_length);
     147
     148        free(data);
     149
     150        async_answer_1(callid, EOK, event_nr);
     151}
     152
     153void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
     154    ipc_callid_t callid, ipc_call_t *call)
     155{
     156        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
     157
     158        if (!hid_iface->get_report_descriptor_length) {
     159                async_answer_0(callid, ENOTSUP);
     160                return;
     161        }
     162
     163        size_t len = hid_iface->get_report_descriptor_length(fun);
     164        async_answer_1(callid, EOK, (sysarg_t) len);
     165}
     166
     167void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
     168    ipc_callid_t callid, ipc_call_t *call)
     169{
     170        usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
     171
     172        if (!hid_iface->get_report_descriptor) {
     173                async_answer_0(callid, ENOTSUP);
     174                return;
     175        }
     176
     177        size_t len;
     178        ipc_callid_t data_callid;
     179        if (!async_data_read_receive(&data_callid, &len)) {
     180                async_answer_0(callid, EINVAL);
     181                return;
     182        }
     183
     184        if (len == 0) {
     185                async_answer_0(data_callid, EINVAL);
     186                async_answer_0(callid, EINVAL);
     187                return;
     188        }
     189
     190        uint8_t *descriptor = malloc(len);
     191        if (descriptor == NULL) {
     192                async_answer_0(data_callid, ENOMEM);
     193                async_answer_0(callid, ENOMEM);
     194                return;
     195        }
     196
     197        size_t act_len = 0;
     198        int rc = hid_iface->get_report_descriptor(fun, descriptor, len,
     199            &act_len);
     200        if (act_len > len) {
     201                rc = ELIMIT;
     202        }
     203        if (rc != EOK) {
     204                free(descriptor);
     205                async_answer_0(data_callid, rc);
     206                async_answer_0(callid, rc);
     207                return;
     208        }
     209
     210        async_data_read_finalize(data_callid, descriptor, act_len);
    139211        async_answer_0(callid, EOK);
    140 }
     212
     213        free(descriptor);
     214}
     215
     216
    141217
    142218/**

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

    r8242dd86 re56b8a3  
    3636#define LIBDRV_REMOTE_PCI_H_
    3737
    38 remote_iface_t remote_pci_iface;
     38extern remote_iface_t remote_pci_iface;
    3939
    4040#endif

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

    r8242dd86 re56b8a3  
    3636#define LIBDRV_REMOTE_USB_H_
    3737
    38 remote_iface_t remote_usb_iface;
     38extern remote_iface_t remote_usb_iface;
    3939
    4040#endif

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

    r8242dd86 re56b8a3  
    3636#define LIBDRV_REMOTE_USBHC_H_
    3737
    38 remote_iface_t remote_usbhc_iface;
     38extern remote_iface_t remote_usbhc_iface;
    3939
    4040#endif

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

    r8242dd86 re56b8a3  
    3636#define LIBDRV_REMOTE_USBHID_H_
    3737
    38 remote_iface_t remote_usbhid_iface;
     38extern remote_iface_t remote_usbhid_iface;
    3939
    4040#endif

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

    r8242dd86 re56b8a3  
    4545         * Parameters: none
    4646         * Answer:
    47          * - EOK (expected always as long as device support USB HID interface)
    48          * Parameters of the answer:
    49          * - number of items
     47         * - Size of one report in bytes.
    5048         */
    5149        IPC_M_USBHID_GET_EVENT_LENGTH,
    … …  
    6361         * It is okay if the client requests less data. Extra data must
    6462         * be truncated by the driver.
     63         *
     64         * @todo Change this comment.
    6565         */
    66         IPC_M_USBHID_GET_EVENT
     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
    6788} usbhid_iface_funcs_t;
    6889
    … …  
    7596         *
    7697         * @param[in] fun DDF function answering the request.
    77          * @return Number of events or error code.
     98         * @return Size of the event in bytes.
    7899         */
    79100        size_t (*get_event_length)(ddf_fun_t *fun);
    … …  
    87108         * @return Error code.
    88109         */
    89         int (*get_event)(ddf_fun_t *fun, int32_t *buffer, size_t size,
    90             size_t *act_size, unsigned int flags);
     110        int (*get_event)(ddf_fun_t *fun, uint8_t *buffer, size_t size,
     111            size_t *act_size, int *event_nr, 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);
    91130} usbhid_iface_t;
    92131

  • uspace/lib/usbhid/Makefile

    r8242dd86 re56b8a3  
    4141        src/hidpath.c \
    4242        src/hidreport.c \
     43        src/consumer.c \
    4344        src/hidreq.c
    4445

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

    r8242dd86 re56b8a3  
    4444 * report parser.
    4545 *
    46  * \param dev USB device representing a HID device.
    47  * \param parser HID Report parser.
     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
    4850 *
    4951 * \retval EOK if successful.
    … …  
    5759 */
    5860int usb_hid_process_report_descriptor(usb_device_t *dev,
    59     usb_hid_report_t *report);
     61    usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size);
    6062
    6163#endif /* LIBUSB_HIDREPORT_H_ */

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

    r8242dd86 re56b8a3  
    3838#include <sys/types.h>
    3939
    40 int usbhid_dev_get_event_length(int);
    41 int usbhid_dev_get_event(int, uint16_t *, uint16_t *, size_t, size_t *,
     40int usbhid_dev_get_event_length(int, size_t *);
     41int usbhid_dev_get_event(int, uint8_t *, size_t, size_t *, int *,
    4242    unsigned int);
     43int usbhid_dev_get_report_descriptor_length(int, size_t *);
     44int usbhid_dev_get_report_descriptor(int, uint8_t *, size_t, size_t *);
    4345
    4446#endif

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

    r8242dd86 re56b8a3  
    4646 * @return Number of usages returned or negative error code.
    4747 */
    48 int usbhid_dev_get_event_length(int dev_phone)
     48int usbhid_dev_get_event_length(int dev_phone, size_t *size)
    4949{
    5050        if (dev_phone < 0) {
    … …  
    5656            IPC_M_USBHID_GET_EVENT_LENGTH, &len);
    5757        if (rc == EOK) {
    58                 return (int) len;
    59         } else {
    60                 return rc;
    61         }
     58                if (size != NULL) {
     59                        *size = (size_t) len;
     60                }
     61        }
     62       
     63        return rc;
    6264}
    6365
    … …  
    7476 * @return Error code.
    7577 */
    76 int 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)
    78 {
    79         if (dev_phone < 0) {
    80                 return EINVAL;
    81         }
    82         if ((usage_pages == NULL) || (usages == NULL)) {
    83                 return ENOMEM;
    84         }
    85         if (usage_count == 0) {
    86                 return EINVAL;
    87         }
    88 
    89         size_t buffer_size = sizeof(uint16_t) * usage_count * 2;
    90         uint16_t *buffer = malloc(buffer_size);
     78int usbhid_dev_get_event(int dev_phone, uint8_t *buf,
     79    size_t size, size_t *actual_size, int *event_nr, unsigned int flags)
     80{
     81        if (dev_phone < 0) {
     82                return EINVAL;
     83        }
     84        if ((buf == NULL)) {
     85                return ENOMEM;
     86        }
     87        if (size == 0) {
     88                return EINVAL;
     89        }
     90       
     91//      if (size == 0) {
     92//              return EOK;
     93//      }
     94
     95        size_t buffer_size =  size;
     96        uint8_t *buffer = malloc(buffer_size);
    9197        if (buffer == NULL) {
    9298                return ENOMEM;
    9399        }
    94100
     101        ipc_call_t opening_request_call;
    95102        aid_t opening_request = async_send_2(dev_phone,
    96103            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT,
    97             flags, NULL);
     104            flags, &opening_request_call);
    98105        if (opening_request == 0) {
    99106                free(buffer);
    … …  
    128135        }
    129136
    130         size_t actual_size = IPC_GET_ARG2(data_request_call);
    131         size_t items = actual_size / 2;
     137        size_t act_size = IPC_GET_ARG2(data_request_call);
    132138
    133139        /* Copy the individual items. */
    134         memcpy(usage_pages, buffer, items * sizeof(uint16_t));
    135         memcpy(usages, buffer + items, items * sizeof(uint16_t));
    136 
    137         if (actual_usage_count != NULL) {
    138                 *actual_usage_count = items;
     140        memcpy(buf, buffer, act_size);
     141//      memcpy(usages, buffer + items, items * sizeof(int32_t));
     142
     143        if (actual_size != NULL) {
     144                *actual_size = act_size;
     145        }
     146       
     147        if (event_nr != NULL) {
     148                *event_nr = IPC_GET_ARG1(opening_request_call);
     149        }
     150
     151        return EOK;
     152}
     153
     154
     155int usbhid_dev_get_report_descriptor_length(int dev_phone, size_t *size)
     156{
     157        if (dev_phone < 0) {
     158                return EINVAL;
     159        }
     160
     161        sysarg_t arg_size;
     162        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE),
     163            IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
     164        if (rc == EOK) {
     165                if (size != NULL) {
     166                        *size = (size_t) arg_size;
     167                }
     168        }
     169        return rc;
     170}
     171
     172int usbhid_dev_get_report_descriptor(int dev_phone, uint8_t *buf, size_t size,
     173    size_t *actual_size)
     174{
     175        if (dev_phone < 0) {
     176                return EINVAL;
     177        }
     178        if ((buf == NULL)) {
     179                return ENOMEM;
     180        }
     181        if (size == 0) {
     182                return EINVAL;
     183        }
     184
     185        aid_t opening_request = async_send_1(dev_phone,
     186            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
     187            NULL);
     188        if (opening_request == 0) {
     189                return ENOMEM;
     190        }
     191
     192        ipc_call_t data_request_call;
     193        aid_t data_request = async_data_read(dev_phone, buf, size,
     194            &data_request_call);
     195        if (data_request == 0) {
     196                async_wait_for(opening_request, NULL);
     197                return ENOMEM;
     198        }
     199
     200        sysarg_t data_request_rc;
     201        sysarg_t opening_request_rc;
     202        async_wait_for(data_request, &data_request_rc);
     203        async_wait_for(opening_request, &opening_request_rc);
     204
     205        if (data_request_rc != EOK) {
     206                /* Prefer return code of the opening request. */
     207                if (opening_request_rc != EOK) {
     208                        return (int) opening_request_rc;
     209                } else {
     210                        return (int) data_request_rc;
     211                }
     212        }
     213
     214        if (opening_request_rc != EOK) {
     215                return (int) opening_request_rc;
     216        }
     217
     218        size_t act_size = IPC_GET_ARG2(data_request_call);
     219
     220        if (actual_size != NULL) {
     221                *actual_size = act_size;
    139222        }
    140223

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

    r8242dd86 re56b8a3  
    164164
    165165int usb_hid_process_report_descriptor(usb_device_t *dev,
    166     usb_hid_report_t *report)
     166    usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size)
    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,
    178             &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, report_size);
    179178       
    180179        if (rc != EOK) {
    181180                usb_log_error("Problem with getting Report descriptor: %s.\n",
    182181                    str_error(rc));
    183                 if (report_desc != NULL) {
    184                         free(report_desc);
     182                if (*report_desc != NULL) {
     183                        free(*report_desc);
     184                        *report_desc = NULL;
    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);
     195                free(*report_desc);
     196                *report_desc = NULL;
    196197                return rc;
    197198        }
    198199       
    199200        usb_hid_descriptor_print(report);
    200         free(report_desc);
    201201       
    202202        return EOK;
Note: See TracChangeset for help on using the changeset viewer.