Changes in / [88be3a0b:6bfaab5] in mainline


Ignore:
Files:
11 added
23 deleted
75 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    r88be3a0b r6bfaab5  
    77*.map
    88*.disasm
     9*.lo
     10*.la
     11*.so.*
     12*.so0
    913_link.ld
    1014./*.iso
    … …  
    5357./uspace/app/klog/klog
    5458./uspace/app/lsusb/lsusb
     59./uspace/app/mkbd/mkbd
    5560./uspace/app/mkfat/mkfat
    5661./uspace/app/netstart/netstart

  • boot/Makefile.common

    r88be3a0b r6bfaab5  
    157157        $(USPACE_PATH)/app/usbinfo/usbinfo \
    158158        $(USPACE_PATH)/app/vuhid/vuh \
     159        $(USPACE_PATH)/app/mkbd/mkbd \
    159160        $(USPACE_PATH)/app/websrv/websrv
    160161

  • boot/arch/amd64/Makefile.inc

    r88be3a0b r6bfaab5  
    4949        usbflbk \
    5050        usbhub \
    51         usbkbd \
    5251        usbhid \
    5352        usbmast \

  • kernel/generic/src/ipc/irq.c

    r88be3a0b r6bfaab5  
    370370        if (AS != irq->driver_as) \
    371371                as_switch(AS, irq->driver_as); \
    372         printf("Copying data from address: %p.\n", va); \
    373372        memcpy_from_uspace(&target, va, (sizeof(target))); \
    374373        if (dstarg) \
    … …  
    381380        if (AS != irq->driver_as) \
    382381                as_switch(AS, irq->driver_as); \
    383         printf("Writing data to address: %p.\n", va); \
    384382        memcpy_to_uspace(va, &val, sizeof(val)); \
    385383} while (0)
    … …  
    457455                        uint32_t val;
    458456                        CMD_MEM_READ(val);
    459                         printf("mem READ value: %x.\n", val);
    460457                        break;
    461458                        }

  • uspace/Makefile

    r88be3a0b r6bfaab5  
    5959        app/websrv \
    6060        app/sysinfo \
     61        app/mkbd \
    6162        srv/clip \
    6263        srv/devmap \
    … …  
    122123                drv/uhci-rhd \
    123124                drv/usbflbk \
    124                 drv/usbkbd \
    125125                drv/usbhid \
    126126                drv/usbhub \
    … …  
    144144                drv/uhci-rhd \
    145145                drv/usbflbk \
    146                 drv/usbkbd \
    147146                drv/usbhid \
    148147                drv/usbhub \

  • uspace/Makefile.common

    r88be3a0b r6bfaab5  
    131131        endif
    132132endif
     133# Build static whenever we use libusb because that library uses
     134# thread local variables
     135ifneq ($(findstring usb, $(LIBS)),)
     136        STATIC_BUILD = y
     137endif
    133138
    134139ifeq ($(STATIC_BUILD), y)

  • uspace/app/lsusb/main.c

    r88be3a0b r6bfaab5  
    4545#include <devmap.h>
    4646#include <usb/dev/hub.h>
    47 #include <usb/host.h>
     47#include <usb/hc.h>
    4848
    4949#define NAME "lsusb"

  • uspace/app/usbinfo/main.c

    r88be3a0b r6bfaab5  
    4343#include <devman.h>
    4444#include <devmap.h>
    45 #include <usb/dev/hc.h>
     45#include <usb/hc.h>
    4646#include <usb/dev/pipes.h>
    47 #include <usb/host.h>
    48 #include <usb/driver.h>
    4947#include "usbinfo.h"
    50 
    51 static bool try_parse_class_and_address(const char *path,
    52     devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
    53 {
    54         size_t class_index;
    55         size_t address;
    56         int rc;
    57         char *ptr;
    58 
    59         rc = str_size_t(path, &ptr, 10, false, &class_index);
    60         if (rc != EOK) {
    61                 return false;
    62         }
    63         if ((*ptr == ':') || (*ptr == '.')) {
    64                 ptr++;
    65         } else {
    66                 return false;
    67         }
    68         rc = str_size_t(ptr, NULL, 10, true, &address);
    69         if (rc != EOK) {
    70                 return false;
    71         }
    72         rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle);
    73         if (rc != EOK) {
    74                 return false;
    75         }
    76         if (out_device_address != NULL) {
    77                 *out_device_address = (usb_address_t) address;
    78         }
    79         return true;
    80 }
    81 
    82 static bool resolve_hc_handle_and_dev_addr(const char *devpath,
    83     devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
    84 {
    85         int rc;
    86 
    87         /* Hack for QEMU to save-up on typing ;-). */
    88         if (str_cmp(devpath, "qemu") == 0) {
    89                 devpath = "/hw/pci0/00:01.2/uhci-rh/usb00_a1";
    90         }
    91 
    92         /* Hack for virtual keyboard. */
    93         if (str_cmp(devpath, "virt") == 0) {
    94                 devpath = "/virt/usbhc/usb00_a1/usb00_a2";
    95         }
    96 
    97         if (try_parse_class_and_address(devpath,
    98             out_hc_handle, out_device_address)) {
    99                 return true;
    100         }
    101 
    102         char *path = str_dup(devpath);
    103         if (path == NULL) {
    104                 return ENOMEM;
    105         }
    106 
    107         devman_handle_t hc = 0;
    108         bool hc_found = false;
    109         usb_address_t addr = 0;
    110         bool addr_found = false;
    111 
    112         /* Remove suffixes and hope that we will encounter device node. */
    113         while (str_length(path) > 0) {
    114                 /* Get device handle first. */
    115                 devman_handle_t dev_handle;
    116                 rc = devman_device_get_handle(path, &dev_handle, 0);
    117                 if (rc != EOK) {
    118                         free(path);
    119                         return false;
    120                 }
    121 
    122                 /* Try to find its host controller. */
    123                 if (!hc_found) {
    124                         rc = usb_hc_find(dev_handle, &hc);
    125                         if (rc == EOK) {
    126                                 hc_found = true;
    127                         }
    128                 }
    129                 /* Try to get its address. */
    130                 if (!addr_found) {
    131                         addr = usb_device_get_assigned_address(dev_handle);
    132                         if (addr >= 0) {
    133                                 addr_found = true;
    134                         }
    135                 }
    136 
    137                 /* Speed-up. */
    138                 if (hc_found && addr_found) {
    139                         break;
    140                 }
    141 
    142                 /* Remove the last suffix. */
    143                 char *slash_pos = str_rchr(path, '/');
    144                 if (slash_pos != NULL) {
    145                         *slash_pos = 0;
    146                 }
    147         }
    148 
    149         free(path);
    150 
    151         if (hc_found && addr_found) {
    152                 if (out_hc_handle != NULL) {
    153                         *out_hc_handle = hc;
    154                 }
    155                 if (out_device_address != NULL) {
    156                         *out_device_address = addr;
    157                 }
    158                 return true;
    159         } else {
    160                 return false;
    161         }
    162 }
    16348
    16449static void print_usage(char *app_name)
    … …  
    300185                devman_handle_t hc_handle = 0;
    301186                usb_address_t dev_addr = 0;
    302                 bool found = resolve_hc_handle_and_dev_addr(devpath,
    303                     &hc_handle, &dev_addr);
    304                 if (!found) {
     187                int rc = usb_resolve_device_handle(devpath,
     188                    &hc_handle, &dev_addr, NULL);
     189                if (rc != EOK) {
    305190                        fprintf(stderr, NAME ": device `%s' not found "
    306191                            "or not of USB kind, skipping.\n",

  • uspace/drv/ohci/batch.c

    r88be3a0b r6bfaab5  
    4444#include "hw_struct/transfer_descriptor.h"
    4545
     46/** OHCI specific data required for USB transfer */
    4647typedef struct ohci_transfer_batch {
     48        /** Endpoint descriptor of the target endpoint. */
    4749        ed_t *ed;
     50        /** List of TDs needed for the transfer */
    4851        td_t **tds;
     52        /** Number of TDs used by the transfer */
    4953        size_t td_count;
     54        /** Dummy TD to be left at the ED and used by the next transfer */
    5055        size_t leave_td;
    51         char *device_buffer;
     56        /** Data buffer, must be accessible byb the OHCI hw. */
     57        void *device_buffer;
    5258} ohci_transfer_batch_t;
    53 
     59/*----------------------------------------------------------------------------*/
     60static void batch_control(usb_transfer_batch_t *instance,
     61    usb_direction_t data_dir, usb_direction_t status_dir);
     62static void batch_data(usb_transfer_batch_t *instance);
     63/*----------------------------------------------------------------------------*/
     64/** Safely destructs ohci_transfer_batch_t structure
     65 *
     66 * @param[in] ohci_batch Instance to destroy.
     67 */
    5468static void ohci_transfer_batch_dispose(void *ohci_batch)
    5569{
    … …  
    6983}
    7084/*----------------------------------------------------------------------------*/
    71 static void batch_control(usb_transfer_batch_t *instance,
    72     usb_direction_t data_dir, usb_direction_t status_dir);
    73 static void batch_data(usb_transfer_batch_t *instance);
    74 /*----------------------------------------------------------------------------*/
     85/** Allocate memory initialize internal structures
     86 *
     87 * @param[in] fun DDF function to pass to callback.
     88 * @param[in] ep Communication target
     89 * @param[in] buffer Data source/destination.
     90 * @param[in] buffer_size Size of the buffer.
     91 * @param[in] setup_buffer Setup data source (if not NULL)
     92 * @param[in] setup_size Size of setup_buffer (should be always 8)
     93 * @param[in] func_in function to call on inbound transfer completion
     94 * @param[in] func_out function to call on outbound transfer completion
     95 * @param[in] arg additional parameter to func_in or func_out
     96 * @return Valid pointer if all structures were successfully created,
     97 * NULL otherwise.
     98 *
     99 * Allocates and initializes structures needed by the OHCI hw for the transfer.
     100 */
    75101usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    76     char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
     102    char *buffer, size_t buffer_size,
     103    const char *setup_buffer, size_t setup_size,
    77104    usbhc_iface_transfer_in_callback_t func_in,
    78105    usbhc_iface_transfer_out_callback_t func_out, void *arg)
    … …  
    94121            ohci_transfer_batch_dispose);
    95122
    96         hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
     123        const hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
    97124        assert(hcd_ep);
    98125
    … …  
    103130        data->td_count =
    104131            ((buffer_size + OHCI_TD_MAX_TRANSFER - 1) / OHCI_TD_MAX_TRANSFER);
     132        /* Control transfer need Setup and Status stage */
    105133        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
    106134                data->td_count += 2;
    107135        }
    108136
    109         /* we need one extra place for td that is currently assigned to hcd_ep*/
     137        /* We need an extra place for TD that is currently assigned to hcd_ep*/
    110138        data->tds = calloc(sizeof(td_t*), data->td_count + 1);
    111139        CHECK_NULL_DISPOSE_RETURN(data->tds,
    112140            "Failed to allocate transfer descriptors.\n");
    113141
     142        /* Add TD left over by the previous transfer */
    114143        data->tds[0] = hcd_ep->td;
    115144        data->leave_td = 0;
    … …  
    123152        data->ed = hcd_ep->ed;
    124153
     154        /* NOTE: OHCI is capable of handling buffer that crosses page boundaries
     155         * it is, however, not capable of handling buffer that occupies more
     156         * than two pages (the first page is computed using start pointer, the
     157         * other using the end pointer) */
    125158        if (setup_size + buffer_size > 0) {
    126159                data->device_buffer = malloc32(setup_size + buffer_size);
    … …  
    135168}
    136169/*----------------------------------------------------------------------------*/
     170/** Check batch TDs' status.
     171 *
     172 * @param[in] instance Batch structure to use.
     173 * @return False, if there is an active TD, true otherwise.
     174 *
     175 * Walk all TDs (usually there is just one). Stop with false if there is an
     176 * active TD. Stop with true if an error is found. Return true if the walk
     177 * completes with the last TD.
     178 */
    137179bool batch_is_complete(usb_transfer_batch_t *instance)
    138180{
    … …  
    140182        ohci_transfer_batch_t *data = instance->private_data;
    141183        assert(data);
    142         size_t tds = data->td_count;
    143184        usb_log_debug("Batch(%p) checking %zu td(s) for completion.\n",
    144             instance, tds);
     185            instance, data->td_count);
    145186        usb_log_debug("ED: %x:%x:%x:%x.\n",
    146187            data->ed->status, data->ed->td_head, data->ed->td_tail,
    … …  
    148189        size_t i = 0;
    149190        instance->transfered_size = instance->buffer_size;
    150         for (; i < tds; ++i) {
     191        for (; i < data->td_count; ++i) {
    151192                assert(data->tds[i] != NULL);
    152193                usb_log_debug("TD %zu: %x:%x:%x:%x.\n", i,
    … …  
    173214        assert(hcd_ep);
    174215        hcd_ep->td = data->tds[i];
    175         if (i > 0)
    176                 instance->transfered_size -= td_remain_size(data->tds[i - 1]);
     216        assert(i > 0);
     217        for (--i;i < data->td_count; ++i)
     218                instance->transfered_size -= td_remain_size(data->tds[i]);
    177219
    178220        /* Clear possible ED HALT */
    179221        data->ed->td_head &= ~ED_TDHEAD_HALTED_FLAG;
    180         uint32_t pa = addr_to_phys(hcd_ep->td);
     222        const uint32_t pa = addr_to_phys(hcd_ep->td);
    181223        assert(pa == (data->ed->td_head & ED_TDHEAD_PTR_MASK));
    182224        assert(pa == (data->ed->td_tail & ED_TDTAIL_PTR_MASK));
    … …  
    185227}
    186228/*----------------------------------------------------------------------------*/
     229/** Starts execution of the TD list
     230 *
     231 * @param[in] instance Batch structure to use
     232 */
    187233void batch_commit(usb_transfer_batch_t *instance)
    188234{
    … …  
    193239}
    194240/*----------------------------------------------------------------------------*/
     241/** Prepares control write transfer.
     242 *
     243 * @param[in] instance Batch structure to use.
     244 *
     245 * Uses generic control transfer using direction OUT(data stage) and
     246 * IN(status stage).
     247 */
    195248void batch_control_write(usb_transfer_batch_t *instance)
    196249{
    … …  
    203256}
    204257/*----------------------------------------------------------------------------*/
     258/** Prepares control read transfer.
     259 *
     260 * @param[in] instance Batch structure to use.
     261 *
     262 * Uses generic control transfer using direction IN(data stage) and
     263 * OUT(status stage).
     264 */
    205265void batch_control_read(usb_transfer_batch_t *instance)
    206266{
    … …  
    211271}
    212272/*----------------------------------------------------------------------------*/
     273/** Prepare interrupt in transfer.
     274 *
     275 * @param[in] instance Batch structure to use.
     276 *
     277 * Data transfer.
     278 */
    213279void batch_interrupt_in(usb_transfer_batch_t *instance)
    214280{
    … …  
    219285}
    220286/*----------------------------------------------------------------------------*/
     287/** Prepare interrupt out transfer.
     288 *
     289 * @param[in] instance Batch structure to use.
     290 *
     291 * Data transfer.
     292 */
    221293void batch_interrupt_out(usb_transfer_batch_t *instance)
    222294{
    … …  
    229301}
    230302/*----------------------------------------------------------------------------*/
     303/** Prepare bulk in transfer.
     304 *
     305 * @param[in] instance Batch structure to use.
     306 *
     307 * Data transfer.
     308 */
    231309void batch_bulk_in(usb_transfer_batch_t *instance)
    232310{
    … …  
    237315}
    238316/*----------------------------------------------------------------------------*/
     317/** Prepare bulk out transfer.
     318 *
     319 * @param[in] instance Batch structure to use.
     320 *
     321 * Data transfer.
     322 */
    239323void batch_bulk_out(usb_transfer_batch_t *instance)
    240324{
    … …  
    247331}
    248332/*----------------------------------------------------------------------------*/
    249 ed_t * batch_ed(usb_transfer_batch_t *instance)
    250 {
    251         assert(instance);
    252         ohci_transfer_batch_t *data = instance->private_data;
    253         assert(data);
    254         return data->ed;
    255 }
    256 /*----------------------------------------------------------------------------*/
     333/** Prepare generic control transfer
     334 *
     335 * @param[in] instance Batch structure to use.
     336 * @param[in] data_dir Direction to use for data stage.
     337 * @param[in] status_dir Direction to use for status stage.
     338 *
     339 * Setup stage with toggle 0 and direction BOTH(SETUP_PID)
     340 * Data stage with alternating toggle and direction supplied by parameter.
     341 * Status stage with toggle 1 and direction supplied by parameter.
     342 */
    257343void batch_control(usb_transfer_batch_t *instance,
    258344    usb_direction_t data_dir, usb_direction_t status_dir)
    … …  
    303389}
    304390/*----------------------------------------------------------------------------*/
     391/** Prepare generic data transfer
     392 *
     393 * @param[in] instance Batch structure to use.
     394 *
     395 * Direction is supplied by the associated ep and toggle is maintained by the
     396 * OHCI hw in ED.
     397 */
    305398void batch_data(usb_transfer_batch_t *instance)
    306399{
    … …  
    316409        char *buffer = instance->data_buffer;
    317410        while (remain_size > 0) {
    318                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
    319                     OHCI_TD_MAX_TRANSFER : remain_size;
     411                const size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER
     412                    ? OHCI_TD_MAX_TRANSFER : remain_size;
    320413
    321414                td_init(data->tds[td_current], instance->ep->direction,

  • uspace/drv/ohci/batch.h

    r88be3a0b r6bfaab5  
    4141#include <usb/host/batch.h>
    4242
    43 #include "hw_struct/endpoint_descriptor.h"
    44 
    4543usb_transfer_batch_t * batch_get(
    4644    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    47     char *setup_buffer, size_t setup_size,
     45    const char *setup_buffer, size_t setup_size,
    4846    usbhc_iface_transfer_in_callback_t func_in,
    4947    usbhc_iface_transfer_out_callback_t func_out,
    … …  
    6563
    6664void batch_bulk_out(usb_transfer_batch_t *instance);
    67 
    68 ed_t * batch_ed(usb_transfer_batch_t *instance);
    6965#endif
    7066/**

  • uspace/drv/ohci/endpoint_list.c

    r88be3a0b r6bfaab5  
    3434#include <errno.h>
    3535#include <usb/debug.h>
     36#include <arch/barrier.h>
    3637
    3738#include "endpoint_list.h"
    … …  
    4344 * @return Error code
    4445 *
    45  * Allocates memory for internal qh_t structure.
     46 * Allocates memory for internal ed_t structure.
    4647 */
    4748int endpoint_list_init(endpoint_list_t *instance, const char *name)
    … …  
    6869 * @param[in] instance List to lead.
    6970 * @param[in] next List to append.
    70  * @return Error code
    7171 *
    72  * Does not check whether this replaces an existing list .
     72 * Does not check whether this replaces an existing list.
    7373 */
    7474void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next)
    … …  
    7979}
    8080/*----------------------------------------------------------------------------*/
    81 /** Submit transfer endpoint to the list and queue.
     81/** Add endpoint to the list and queue.
    8282 *
    8383 * @param[in] instance List to use.
    84  * @param[in] endpoint Transfer endpoint to submit.
    85  * @return Error code
     84 * @param[in] endpoint Endpoint to add.
    8685 *
    8786 * The endpoint is added to the end of the list and queue.
    … …  
    9998        /* Add to the hardware queue. */
    10099        if (list_empty(&instance->endpoint_list)) {
    101                 /* There is nothing scheduled */
     100                /* There are no active EDs */
    102101                last_ed = instance->list_head;
    103102        } else {
    104                 /* There is something scheduled */
     103                /* There are active EDs, get the last one */
    105104                hcd_endpoint_t *last = list_get_instance(
    106105                    instance->endpoint_list.prev, hcd_endpoint_t, link);
     106                assert(last);
    107107                last_ed = last->ed;
    108108        }
    109         /* keep link */
     109        /* Keep link */
    110110        hcd_ep->ed->next = last_ed->next;
     111        /* Make sure ED is written to the memory */
     112        write_barrier();
     113
     114        /* Add ed to the hw queue */
    111115        ed_append_ed(last_ed, hcd_ep->ed);
     116        /* Make sure ED is updated */
     117        write_barrier();
    112118
    113         asm volatile ("": : :"memory");
    114 
    115         /* Add to the driver list */
     119        /* Add to the sw list */
    116120        list_append(&hcd_ep->link, &instance->endpoint_list);
    117121
    … …  
    129133}
    130134/*----------------------------------------------------------------------------*/
    131 #if 0
    132 /** Create list for finished endpoints.
     135/** Remove endpoint from the list and queue.
    133136 *
    134137 * @param[in] instance List to use.
    135  * @param[in] done list to fill
    136  */
    137 void endpoint_list_remove_finished(endpoint_list_t *instance, link_t *done)
    138 {
    139         assert(instance);
    140         assert(done);
    141 
    142         fibril_mutex_lock(&instance->guard);
    143         usb_log_debug2("Checking list %s for completed endpointes(%d).\n",
    144             instance->name, list_count(&instance->endpoint_list));
    145         link_t *current = instance->endpoint_list.next;
    146         while (current != &instance->endpoint_list) {
    147                 link_t *next = current->next;
    148                 hcd_endpoint_t *endpoint =
    149                     list_get_instance(current, hcd_endpoint_t, link);
    150 
    151                 if (endpoint_is_complete(endpoint)) {
    152                         /* Save for post-processing */
    153                         endpoint_list_remove_endpoint(instance, endpoint);
    154                         list_append(current, done);
    155                 }
    156                 current = next;
    157         }
    158         fibril_mutex_unlock(&instance->guard);
    159 }
    160 /*----------------------------------------------------------------------------*/
    161 /** Walk the list and abort all endpointes.
    162  *
    163  * @param[in] instance List to use.
    164  */
    165 void endpoint_list_abort_all(endpoint_list_t *instance)
    166 {
    167         fibril_mutex_lock(&instance->guard);
    168         while (!list_empty(&instance->endpoint_list)) {
    169                 link_t *current = instance->endpoint_list.next;
    170                 hcd_endpoint_t *endpoint =
    171                     list_get_instance(current, hcd_endpoint_t, link);
    172                 endpoint_list_remove_endpoint(instance, endpoint);
    173                 hcd_endpoint_finish_error(endpoint, EIO);
    174         }
    175         fibril_mutex_unlock(&instance->guard);
    176 }
    177 #endif
    178 /*----------------------------------------------------------------------------*/
    179 /** Remove a transfer endpoint from the list and queue.
    180  *
    181  * @param[in] instance List to use.
    182  * @param[in] endpoint Transfer endpoint to remove.
    183  * @return Error code
    184  *
    185  * Does not lock the transfer list, caller is responsible for that.
     138 * @param[in] endpoint Endpoint to remove.
    186139 */
    187140void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep)
    … …  
    212165        assert((prev_ed->next & ED_NEXT_PTR_MASK) == addr_to_phys(hcd_ep->ed));
    213166        prev_ed->next = hcd_ep->ed->next;
     167        /* Make sure ED is updated */
     168        write_barrier();
    214169
    215         asm volatile ("": : :"memory");
    216170        usb_log_debug("HCD EP(%p) removed (%s) from %s, next %x.\n",
    217171            hcd_ep, qpos, instance->name, hcd_ep->ed->next);

  • uspace/drv/ohci/endpoint_list.h

    r88be3a0b r6bfaab5  
    4141#include "utils/malloc32.h"
    4242
     43/** Structure maintains both OHCI queue and software list of active endpoints.*/
    4344typedef struct endpoint_list {
     45        /** Guard against add/remove races */
    4446        fibril_mutex_t guard;
     47        /** OHCI hw structure at the beginning of the queue */
    4548        ed_t *list_head;
     49        /** Physical address of the first(dummy) ED */
    4650        uint32_t list_head_pa;
     51        /** Assigned name, provides nicer debug output */
    4752        const char *name;
     53        /** Sw list of all active EDs */
    4854        link_t endpoint_list;
    4955} endpoint_list_t;
    … …  
    5359 * @param[in] instance Memory place to use.
    5460 *
    55  * Frees memory for internal qh_t structure.
     61 * Frees memory of the internal ed_t structure.
    5662 */
    5763static inline void endpoint_list_fini(endpoint_list_t *instance)
    … …  
    6268
    6369int endpoint_list_init(endpoint_list_t *instance, const char *name);
    64 
    6570void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next);
    66 
    6771void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
    68 
    6972void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
    70 #if 0
    71 void endpoint_list_remove_finished(endpoint_list_t *instance, link_t *done);
    72 
    73 void endpoint_list_abort_all(endpoint_list_t *instance);
    74 #endif
    7573#endif
    7674/**

  • uspace/drv/ohci/hc.c

    r88be3a0b r6bfaab5  
    5151static int hc_init_memory(hc_t *instance);
    5252/*----------------------------------------------------------------------------*/
     53/** Announce OHCI root hub to the DDF
     54 *
     55 * @param[in] instance OHCI driver intance
     56 * @param[in] hub_fun DDF fuction representing OHCI root hub
     57 * @return Error code
     58 */
    5359int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
    5460{
    … …  
    5662        assert(hub_fun);
    5763
    58         int ret;
    59 
    60         usb_address_t hub_address =
     64        const usb_address_t hub_address =
    6165            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
    6266        if (hub_address <= 0) {
    63                 usb_log_error("Failed to get OHCI root hub address.\n");
     67                usb_log_error("Failed(%d) to get OHCI root hub address.\n",
     68                    hub_address);
    6469                return hub_address;
    6570        }
    … …  
    6873            &instance->manager, hub_address, hub_fun->handle);
    6974
    70         ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
     75#define CHECK_RET_RELEASE(ret, message...) \
     76if (ret != EOK) { \
     77        usb_log_error(message); \
     78        hc_remove_endpoint(instance, hub_address, 0, USB_DIRECTION_BOTH); \
     79        usb_device_keeper_release(&instance->manager, hub_address); \
     80        return ret; \
     81} else (void)0
     82
     83        int ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
    7184            USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH, 64, 0, 0);
    72         if (ret != EOK) {
    73                 usb_log_error("Failed to add OHCI rh endpoint 0.\n");
    74                 usb_device_keeper_release(&instance->manager, hub_address);
    75                 return ret;
    76         }
     85        CHECK_RET_RELEASE(ret, "Failed(%d) to add OHCI rh endpoint 0.\n", ret);
    7786
    7887        char *match_str = NULL;
    7988        /* DDF needs heap allocated string */
    8089        ret = asprintf(&match_str, "usb&class=hub");
    81         if (ret < 0) {
    82                 usb_log_error(
    83                     "Failed(%d) to create root hub match-id string.\n", ret);
    84                 usb_device_keeper_release(&instance->manager, hub_address);
    85                 return ret;
    86         }
     90        ret = ret > 0 ? 0 : ret;
     91        CHECK_RET_RELEASE(ret, "Failed(%d) to create match-id string.\n", ret);
    8792
    8893        ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
    89         if (ret != EOK) {
    90                 usb_log_error("Failed add root hub match-id.\n");
    91         }
     94        CHECK_RET_RELEASE(ret, "Failed(%d) add root hub match-id.\n", ret);
     95
    9296        ret = ddf_fun_bind(hub_fun);
    93         return ret;
    94 }
    95 /*----------------------------------------------------------------------------*/
     97        CHECK_RET_RELEASE(ret, "Failed(%d) to bind root hub function.\n", ret);
     98
     99        return EOK;
     100#undef CHECK_RET_RELEASE
     101}
     102/*----------------------------------------------------------------------------*/
     103/** Initialize OHCI hc driver structure
     104 *
     105 * @param[in] instance Memory place for the structure.
     106 * @param[in] regs Address of the memory mapped I/O registers.
     107 * @param[in] reg_size Size of the memory mapped area.
     108 * @param[in] interrupts True if w interrupts should be used
     109 * @return Error code
     110 */
    96111int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
    97112{
    … …  
    121136#undef CHECK_RET_RETURN
    122137
    123 
    124 //      hc_init_hw(instance);
     138        fibril_mutex_initialize(&instance->guard);
    125139        hc_gain_control(instance);
    126         fibril_mutex_initialize(&instance->guard);
    127140
    128141        rh_init(&instance->rh, instance->registers);
    … …  
    137150}
    138151/*----------------------------------------------------------------------------*/
     152/** Create end register endpoint structures
     153 *
     154 * @param[in] instance OHCI driver structure.
     155 * @param[in] address USB address of the device.
     156 * @param[in] endpoint USB endpoint number.
     157 * @param[in] speed Communication speeed of the device.
     158 * @param[in] type Endpoint's transfer type.
     159 * @param[in] direction Endpoint's direction.
     160 * @param[in] mps Maximum packet size the endpoint accepts.
     161 * @param[in] size Maximum allowed buffer size.
     162 * @param[in] interval Time between transfers(interrupt transfers only).
     163 * @return Error code
     164 */
    139165int hc_add_endpoint(
    140166    hc_t *instance, usb_address_t address, usb_endpoint_t endpoint,
    … …  
    194220}
    195221/*----------------------------------------------------------------------------*/
     222/** Dequeue and delete endpoint structures
     223 *
     224 * @param[in] instance OHCI hc driver structure.
     225 * @param[in] address USB address of the device.
     226 * @param[in] endpoint USB endpoint number.
     227 * @param[in] direction Direction of the endpoint.
     228 * @return Error code
     229 */
    196230int hc_remove_endpoint(hc_t *instance, usb_address_t address,
    197231    usb_endpoint_t endpoint, usb_direction_t direction)
    … …  
    244278}
    245279/*----------------------------------------------------------------------------*/
     280/** Get access to endpoint structures
     281 *
     282 * @param[in] instance OHCI hc driver structure.
     283 * @param[in] address USB address of the device.
     284 * @param[in] endpoint USB endpoint number.
     285 * @param[in] direction Direction of the endpoint.
     286 * @param[out] bw Reserved bandwidth.
     287 * @return Error code
     288 */
    246289endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
    247290    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw)
    … …  
    255298}
    256299/*----------------------------------------------------------------------------*/
     300/** Add USB transfer to the schedule.
     301 *
     302 * @param[in] instance OHCI hc driver structure.
     303 * @param[in] batch Batch representing the transfer.
     304 * @return Error code.
     305 */
    257306int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
    258307{
    … …  
    261310        assert(batch->ep);
    262311
    263         /* check for root hub communication */
     312        /* Check for root hub communication */
    264313        if (batch->ep->address == instance->rh.address) {
    265314                return rh_request(&instance->rh, batch);
    … …  
    269318        list_append(&batch->link, &instance->pending_batches);
    270319        batch_commit(batch);
    271         switch (batch->ep->transfer_type) {
     320
     321        /* Control and bulk schedules need a kick to start working */
     322        switch (batch->ep->transfer_type)
     323        {
    272324        case USB_TRANSFER_CONTROL:
    273325                instance->registers->command_status |= CS_CLF;
    … …  
    279331                break;
    280332        }
    281 
    282333        fibril_mutex_unlock(&instance->guard);
    283334        return EOK;
    284335}
    285336/*----------------------------------------------------------------------------*/
     337/** Interrupt handling routine
     338 *
     339 * @param[in] instance OHCI hc driver structure.
     340 * @param[in] status Value of the status register at the time of interrupt.
     341 */
    286342void hc_interrupt(hc_t *instance, uint32_t status)
    287343{
    … …  
    292348        if (status & I_RHSC)
    293349                rh_interrupt(&instance->rh);
    294 
    295350
    296351        if (status & I_WDH) {
    … …  
    316371                fibril_mutex_unlock(&instance->guard);
    317372        }
    318 }
    319 /*----------------------------------------------------------------------------*/
     373
     374        if (status & I_UE) {
     375                hc_start_hw(instance);
     376        }
     377
     378}
     379/*----------------------------------------------------------------------------*/
     380/** Check status register regularly
     381 *
     382 * @param[in] instance OHCI hc driver structure.
     383 * @return Error code
     384 */
    320385int interrupt_emulator(hc_t *instance)
    321386{
    … …  
    326391                instance->registers->interrupt_status = status;
    327392                hc_interrupt(instance, status);
    328                 async_usleep(50000);
     393                async_usleep(10000);
    329394        }
    330395        return EOK;
    331396}
    332397/*----------------------------------------------------------------------------*/
     398/** Turn off any (BIOS)driver that might be in control of the device.
     399 *
     400 * @param[in] instance OHCI hc driver structure.
     401 */
    333402void hc_gain_control(hc_t *instance)
    334403{
    … …  
    380449}
    381450/*----------------------------------------------------------------------------*/
     451/** OHCI hw initialization routine.
     452 *
     453 * @param[in] instance OHCI hc driver structure.
     454 */
    382455void hc_start_hw(hc_t *instance)
    383456{
    … …  
    447520}
    448521/*----------------------------------------------------------------------------*/
     522/** Initialize schedule queues
     523 *
     524 * @param[in] instance OHCI hc driver structure
     525 * @return Error code
     526 */
    449527int hc_init_transfer_lists(hc_t *instance)
    450528{
    451529        assert(instance);
    452 
    453530#define SETUP_ENDPOINT_LIST(type) \
    454531do { \
    … …  
    458535                usb_log_error("Failed(%d) to setup %s endpoint list.\n", \
    459536                    ret, name); \
    460                 endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]); \
     537                endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]);\
    461538                endpoint_list_fini(&instance->lists[USB_TRANSFER_INTERRUPT]); \
    462539                endpoint_list_fini(&instance->lists[USB_TRANSFER_CONTROL]); \
    463540                endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
     541                return ret; \
    464542        } \
    465543} while (0)
    … …  
    476554}
    477555/*----------------------------------------------------------------------------*/
     556/** Initialize memory structures used by the OHCI hcd.
     557 *
     558 * @param[in] instance OHCI hc driver structure.
     559 * @return Error code.
     560 */
    478561int hc_init_memory(hc_t *instance)
    479562{
    … …  
    482565        bzero(&instance->rh, sizeof(instance->rh));
    483566        /* Init queues */
    484         hc_init_transfer_lists(instance);
     567        const int ret = hc_init_transfer_lists(instance);
     568        if (ret != EOK) {
     569                return ret;
     570        }
    485571
    486572        /*Init HCCA */
    … …  
    502588        /* Init interrupt code */
    503589        instance->interrupt_code.cmds = instance->interrupt_commands;
     590        instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    504591        {
    505592                /* Read status register */
    … …  
    521608                instance->interrupt_commands[2].srcarg = 2;
    522609
    523                 /* Write clean status register */
     610                /* Write-clean status register */
    524611                instance->interrupt_commands[3].cmd = CMD_MEM_WRITE_A_32;
    525612                instance->interrupt_commands[3].srcarg = 1;
    … …  
    529616                /* Accept interrupt */
    530617                instance->interrupt_commands[4].cmd = CMD_ACCEPT;
    531 
    532                 instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    533618        }
    534619

  • uspace/drv/ohci/hc.h

    r88be3a0b r6bfaab5  
    5353#define OHCI_NEEDED_IRQ_COMMANDS 5
    5454
     55/** Main OHCI drier structure */
    5556typedef struct hc {
     57        /** USB bus driver, devices and addresses */
     58        usb_device_keeper_t manager;
     59        /** USB bus driver, endpoints */
     60        usb_endpoint_manager_t ep_manager;
     61
     62        /** Memory mapped I/O registers area */
    5663        ohci_regs_t *registers;
     64        /** Host controller communication area structure */
    5765        hcca_t *hcca;
    5866
    59         usb_address_t rh_address;
    60         rh_t rh;
    61 
     67        /** Transfer schedules */
    6268        endpoint_list_t lists[4];
     69        /** List of active transfers */
    6370        link_t pending_batches;
    6471
    65         usb_device_keeper_t manager;
    66         usb_endpoint_manager_t ep_manager;
     72        /** Fibril for periodic checks if interrupts can't be used */
    6773        fid_t interrupt_emulator;
     74
     75        /** Guards schedule and endpoint manipulation */
    6876        fibril_mutex_t guard;
    6977
    … …  
    7381        /** Commands that form interrupt code */
    7482        irq_cmd_t interrupt_commands[OHCI_NEEDED_IRQ_COMMANDS];
     83
     84        /** USB hub emulation structure */
     85        rh_t rh;
    7586} hc_t;
    7687
    7788int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
    78 
    7989int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
    80 
    8190void hc_start_hw(hc_t *instance);
    8291
    … …  
    8594 * @param[in] instance Host controller structure to use.
    8695 */
    87 static inline void hc_fini(hc_t *instance) { /* TODO: implement*/ };
     96static inline void hc_fini(hc_t *instance)
     97        { /* TODO: implement*/ };
    8898
    8999int hc_add_endpoint(hc_t *instance, usb_address_t address, usb_endpoint_t ep,
    90100    usb_speed_t speed, usb_transfer_type_t type, usb_direction_t direction,
    91101    size_t max_packet_size, size_t size, unsigned interval);
    92 
    93102int hc_remove_endpoint(hc_t *instance, usb_address_t address,
    94103    usb_endpoint_t endpoint, usb_direction_t direction);
    95 
    96104endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
    97105    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw);
    98106
    99107int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
    100 
    101108void hc_interrupt(hc_t *instance, uint32_t status);
    102109
    … …  
    107114 */
    108115static inline hc_t * fun_to_hc(ddf_fun_t *fun)
    109         { return (hc_t*)fun->driver_data; }
     116        { return fun->driver_data; }
    110117#endif
    111118/**

  • uspace/drv/ohci/hcd_endpoint.c

    r88be3a0b r6bfaab5  
    3535#include "hcd_endpoint.h"
    3636
     37/** Callback to set toggle on ED.
     38 *
     39 * @param[in] hcd_ep hcd endpoint structure
     40 * @param[in] toggle new value of toggle bit
     41 */
    3742static void hcd_ep_toggle_set(void *hcd_ep, int toggle)
    3843{
    … …  
    4247        ed_toggle_set(instance->ed, toggle);
    4348}
     49/*----------------------------------------------------------------------------*/
     50/** Callback to get value of toggle bit.
     51 *
     52 * @param[in] hcd_ep hcd endpoint structure
     53 * @return Current value of toggle bit.
     54 */
    4455static int hcd_ep_toggle_get(void *hcd_ep)
    4556{
    … …  
    4960        return ed_toggle_get(instance->ed);
    5061}
    51 
    52 
     62/*----------------------------------------------------------------------------*/
     63/** Creates new hcd endpoint representation.
     64 *
     65 * @param[in] ep USBD endpoint structure
     66 * @return pointer to a new hcd endpoint structure, NULL on failure.
     67 */
    5368hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep)
    5469{
    … …  
    7893}
    7994/*----------------------------------------------------------------------------*/
    80 hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
    81 {
    82         assert(ep);
    83         return ep->hc_data.data;
    84 }
    85 /*----------------------------------------------------------------------------*/
     95/** Disposes assigned hcd endpoint structure
     96 *
     97 * @param[in] ep USBD endpoint structure
     98 */
    8699void hcd_endpoint_clear(endpoint_t *ep)
    87100{

  • uspace/drv/ohci/hcd_endpoint.h

    r88be3a0b r6bfaab5  
    3737#include <assert.h>
    3838#include <adt/list.h>
    39 
    4039#include <usb/host/endpoint.h>
    4140
    … …  
    4342#include "hw_struct/transfer_descriptor.h"
    4443
     44/** Connector structure linking ED to to prepared TD. */
    4545typedef struct hcd_endpoint {
     46        /** OHCI endpoint descriptor */
    4647        ed_t *ed;
     48        /** Currently enqueued transfer descriptor */
    4749        td_t *td;
     50        /** Linked list used by driver software */
    4851        link_t link;
    4952} hcd_endpoint_t;
    5053
    5154hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep);
     55void hcd_endpoint_clear(endpoint_t *ep);
    5256
    53 hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep);
     57/** Get and convert assigned hcd_endpoint_t structure
     58 * @param[in] ep USBD endpoint structure.
     59 * @return Pointer to assigned hcd endpoint structure
     60 */
     61static inline hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
     62{
     63        assert(ep);
     64        return ep->hc_data.data;
     65}
    5466
    55 void hcd_endpoint_clear(endpoint_t *ep);
    5667#endif
    5768/**

  • uspace/drv/ohci/hw_struct/transfer_descriptor.c

    r88be3a0b r6bfaab5  
    4444        assert(instance);
    4545        bzero(instance, sizeof(td_t));
    46         instance-> status = 0
     46        instance->status = 0
    4747            | ((dp[dir] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT)
    4848            | ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT);

  • uspace/drv/ohci/hw_struct/transfer_descriptor.h

    r88be3a0b r6bfaab5  
    4141#include "completion_codes.h"
    4242
    43 /* OHCI TDs can handle up to 8KB buffers */
    44 #define OHCI_TD_MAX_TRANSFER (8 * 1024)
     43/* OHCI TDs can handle up to 8KB buffers, however, it can use max 2 pages.
     44 * Using 4KB buffers guarantees the page count condition.
     45 * (OHCI assumes 4KB pages) */
     46#define OHCI_TD_MAX_TRANSFER (4 * 1024)
    4547
    4648typedef struct td {

  • uspace/drv/ohci/ohci_regs.h

    r88be3a0b r6bfaab5  
    3636#include <stdint.h>
    3737
    38 typedef struct ohci_regs
    39 {
     38/** OHCI memory mapped registers structure */
     39typedef struct ohci_regs {
    4040        const volatile uint32_t revision;
    4141        volatile uint32_t control;

  • uspace/drv/uhci-hcd/Makefile

    r88be3a0b r6bfaab5  
    4848        root_hub.c \
    4949        hw_struct/transfer_descriptor.c \
    50         utils/slab.c \
    5150        pci.c \
    5251        batch.c

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

    r88be3a0b r6bfaab5  
    4545#define DEFAULT_ERROR_COUNT 3
    4646
     47/** UHCI specific data required for USB transfer */
    4748typedef struct uhci_transfer_batch {
     49        /** Queue head
     50         * This QH is used to maintain UHCI schedule structure and the element
     51         * pointer points to the first TD of this batch.
     52         */
    4853        qh_t *qh;
     54        /** List of TDs needed for the transfer */
    4955        td_t *tds;
     56        /** Number of TDs used by the transfer */
     57        size_t td_count;
     58        /** Data buffer, must be accessible by the UHCI hw */
    5059        void *device_buffer;
    51         size_t td_count;
    5260} uhci_transfer_batch_t;
    5361/*----------------------------------------------------------------------------*/
    54 static void uhci_transfer_batch_dispose(void *uhci_batch)
    55 {
    56         uhci_transfer_batch_t *instance = uhci_batch;
    57         assert(instance);
    58         free32(instance->device_buffer);
    59         free(instance);
    60 }
    61 /*----------------------------------------------------------------------------*/
    62 
    6362static void batch_control(usb_transfer_batch_t *instance,
    6463    usb_packet_id data_stage, usb_packet_id status_stage);
    6564static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid);
    66 
     65/*----------------------------------------------------------------------------*/
     66/** Safely destructs uhci_transfer_batch_t structure
     67 *
     68 * @param[in] uhci_batch Instance to destroy.
     69 */
     70static void uhci_transfer_batch_dispose(void *uhci_batch)
     71{
     72        uhci_transfer_batch_t *instance = uhci_batch;
     73        assert(instance);
     74        free32(instance->device_buffer);
     75        free(instance);
     76}
     77/*----------------------------------------------------------------------------*/
    6778/** Allocate memory and initialize internal data structure.
    6879 *
    … …  
    8495 */
    8596usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    86     char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
     97    char *buffer, size_t buffer_size,
     98    const char* setup_buffer, size_t setup_size,
    8799    usbhc_iface_transfer_in_callback_t func_in,
    88100    usbhc_iface_transfer_out_callback_t func_out, void *arg)
    … …  
    173185                instance->error = td_status(&data->tds[i]);
    174186                if (instance->error != EOK) {
    175                         usb_log_debug("Batch(%p) found error TD(%zu):%" PRIx32 ".\n",
    176                             instance, i, data->tds[i].status);
     187                        usb_log_debug("Batch(%p) found error TD(%zu):%"
     188                            PRIx32 ".\n", instance, i, data->tds[i].status);
    177189                        td_print_status(&data->tds[i]);
    178190
    … …  
    397409/*----------------------------------------------------------------------------*/
    398410/** Provides access to QH data structure.
     411 *
    399412 * @param[in] instance Batch pointer to use.
    400413 * @return Pointer to the QH used by the batch.

  • uspace/drv/uhci-hcd/batch.h

    r88be3a0b r6bfaab5  
    3535#define DRV_UHCI_BATCH_H
    3636
    37 #include <usbhc_iface.h>
    38 #include <usb/usb.h>
    39 #include <usb/host/device_keeper.h>
    40 #include <usb/host/endpoint.h>
    4137#include <usb/host/batch.h>
    4238
    … …  
    4541usb_transfer_batch_t * batch_get(
    4642    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    47     char *setup_buffer, size_t setup_size,
     43    const char *setup_buffer, size_t setup_size,
    4844    usbhc_iface_transfer_in_callback_t func_in,
    4945    usbhc_iface_transfer_out_callback_t func_out,
    … …  
    5551
    5652void batch_control_write(usb_transfer_batch_t *instance);
    57 
    5853void batch_control_read(usb_transfer_batch_t *instance);
    5954
    6055void batch_interrupt_in(usb_transfer_batch_t *instance);
    61 
    6256void batch_interrupt_out(usb_transfer_batch_t *instance);
    6357
    6458void batch_bulk_in(usb_transfer_batch_t *instance);
    65 
    6659void batch_bulk_out(usb_transfer_batch_t *instance);
    6760

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

    r88be3a0b r6bfaab5  
    3939#include <usb/debug.h>
    4040#include <usb/usb.h>
    41 #include <usb/ddfiface.h>
    42 #include <usb_iface.h>
    4341
    4442#include "hc.h"
    … …  
    5755static int hc_debug_checker(void *arg);
    5856/*----------------------------------------------------------------------------*/
    59 /** Initialize UHCI hcd driver structure
     57/** Initialize UHCI hc driver structure
    6058 *
    6159 * @param[in] instance Memory place to initialize.
    … …  
    8583        /* allow access to hc control registers */
    8684        regs_t *io;
    87         ret = pio_enable(regs, reg_size, (void**)&io);
     85        ret = pio_enable(regs, reg_size, (void **)&io);
    8886        CHECK_RET_RETURN(ret,
    8987            "Failed(%d) to gain access to registers at %p: %s.\n",
    … …  
    143141        }
    144142
    145         uint16_t status = pio_read_16(&registers->usbcmd);
     143        const uint16_t status = pio_read_16(&registers->usbcmd);
    146144        if (status != 0)
    147145                usb_log_warning("Previous command value: %x.\n", status);
    … …  
    212210        /* Init USB frame list page*/
    213211        instance->frame_list = get_page();
    214         ret = instance ? EOK : ENOMEM;
     212        ret = instance->frame_list ? EOK : ENOMEM;
    215213        CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
    216214        usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
    … …  
    277275                &instance->transfers_control_slow);
    278276
    279         /*FSBR*/
     277        /*FSBR, This feature is not needed (adds no benefit) and is supposedly
     278         * buggy on certain hw, enable at your own risk. */
    280279#ifdef FSBR
    281280        transfer_list_set_next(&instance->transfers_bulk_full,
    … …  
    428427                }
    429428
    430                 uintptr_t frame_list =
     429                const uintptr_t frame_list =
    431430                    pio_read_32(&instance->registers->flbaseadd) & ~0xfff;
    432431                if (frame_list != addr_to_phys(instance->frame_list)) {

  • uspace/drv/uhci-hcd/hc.h

    r88be3a0b r6bfaab5  
    3737
    3838#include <fibril.h>
    39 #include <fibril_synch.h>
    40 #include <adt/list.h>
    4139#include <ddi.h>
    4240
    43 #include <usbhc_iface.h>
    4441#include <usb/host/device_keeper.h>
    4542#include <usb/host/usb_endpoint_manager.h>
     43#include <usb/host/batch.h>
    4644
    47 #include "batch.h"
    4845#include "transfer_list.h"
    4946
    … …  
    9592#define UHCI_NEEDED_IRQ_COMMANDS 5
    9693
    97 /* Main HC driver structure */
     94/** Main UHCI driver structure */
    9895typedef struct hc {
    9996        /** USB bus driver, devices and addresses */
    … …  
    154151 */
    155152static inline hc_t * fun_to_hc(ddf_fun_t *fun)
    156         { return (hc_t*)fun->driver_data; }
     153{
     154        assert(fun);
     155        return fun->driver_data;
     156}
    157157#endif
    158158/**

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

    r88be3a0b r6bfaab5  
    3939
    4040#include "iface.h"
     41#include "batch.h"
    4142#include "hc.h"
    4243
    … …  
    122123        return EOK;
    123124}
    124 
     125/*----------------------------------------------------------------------------*/
    125126/** Find device handle by address interface function.
    126127 *
    … …  
    136137        hc_t *hc = fun_to_hc(fun);
    137138        assert(hc);
    138         bool found =
     139        const bool found =
    139140            usb_device_keeper_find_by_address(&hc->manager, address, handle);
    140141        return found ? EOK : ENOENT;
    141142}
    142 
    143143/*----------------------------------------------------------------------------*/
    144144/** Release address interface function
    … …  
    164164    size_t max_packet_size, unsigned int interval)
    165165{
     166        assert(fun);
    166167        hc_t *hc = fun_to_hc(fun);
    167168        assert(hc);
    … …  
    183184    usb_endpoint_t endpoint, usb_direction_t direction)
    184185{
     186        assert(fun);
    185187        hc_t *hc = fun_to_hc(fun);
    186188        assert(hc);
    … …  
    211213        if (ret != EOK)
    212214                return ret;
     215        assert(batch);
     216        assert(hc);
    213217        batch_interrupt_out(batch);
    214218        ret = hc_schedule(hc, batch);
    … …  
    239243        if (ret != EOK)
    240244                return ret;
     245        assert(batch);
     246        assert(hc);
    241247        batch_interrupt_in(batch);
    242248        ret = hc_schedule(hc, batch);
    … …  
    267273        if (ret != EOK)
    268274                return ret;
     275        assert(batch);
     276        assert(hc);
    269277        batch_bulk_out(batch);
    270278        ret = hc_schedule(hc, batch);
    … …  
    295303        if (ret != EOK)
    296304                return ret;
     305        assert(batch);
     306        assert(hc);
    297307        batch_bulk_in(batch);
    298308        ret = hc_schedule(hc, batch);
    … …  
    327337        if (ret != EOK)
    328338                return ret;
     339        assert(batch);
     340        assert(hc);
    329341        usb_endpoint_manager_reset_if_need(&hc->ep_manager, target, setup_data);
    330342        batch_control_write(batch);
    … …  
    360372        if (ret != EOK)
    361373                return ret;
     374        assert(batch);
     375        assert(hc);
    362376        batch_control_read(batch);
    363377        ret = hc_schedule(hc, batch);

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

    r88be3a0b r6bfaab5  
    5252 * @return Error code.
    5353 */
    54 int pci_get_my_registers(ddf_dev_t *dev,
     54int pci_get_my_registers(const ddf_dev_t *dev,
    5555    uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
    5656{
    57         assert(dev != NULL);
     57        assert(dev);
     58        assert(io_reg_address);
     59        assert(io_reg_size);
     60        assert(irq_no);
    5861
    5962        int parent_phone =
    … …  
    6669        int rc = hw_res_get_resource_list(parent_phone, &hw_resources);
    6770        if (rc != EOK) {
    68                 goto leave;
     71                async_hangup(parent_phone);
     72                return rc;
    6973        }
    7074
    … …  
    7882        size_t i;
    7983        for (i = 0; i < hw_resources.count; i++) {
    80                 hw_resource_t *res = &hw_resources.resources[i];
     84                const hw_resource_t *res = &hw_resources.resources[i];
    8185                switch (res->type)
    8286                {
    … …  
    99103                }
    100104        }
     105        async_hangup(parent_phone);
    101106
    102         if (!io_found || !irq_found) {
    103                 rc = ENOENT;
    104                 goto leave;
    105         }
     107        if (!io_found || !irq_found)
     108                return ENOENT;
    106109
    107110        *io_reg_address = io_address;
    … …  
    109112        *irq_no = irq;
    110113
    111         rc = EOK;
    112 leave:
    113         async_hangup(parent_phone);
    114         return rc;
     114        return EOK;
    115115}
    116116/*----------------------------------------------------------------------------*/
    … …  
    120120 * @return Error code.
    121121 */
    122 int pci_enable_interrupts(ddf_dev_t *device)
     122int pci_enable_interrupts(const ddf_dev_t *device)
    123123{
    124         int parent_phone = devman_parent_device_connect(device->handle,
    125             IPC_FLAG_BLOCKING);
    126         bool enabled = hw_res_enable_interrupt(parent_phone);
     124        const int parent_phone =
     125            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
     126        if (parent_phone < 0) {
     127                return parent_phone;
     128        }
     129        const bool enabled = hw_res_enable_interrupt(parent_phone);
    127130        async_hangup(parent_phone);
    128131        return enabled ? EOK : EIO;
    … …  
    134137 * @return Error code.
    135138 */
    136 int pci_disable_legacy(ddf_dev_t *device)
     139int pci_disable_legacy(const ddf_dev_t *device)
    137140{
    138141        assert(device);
    139         int parent_phone =
     142        const int parent_phone =
    140143            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
    141144        if (parent_phone < 0) {
    … …  
    145148        /* See UHCI design guide for these values p.45,
    146149         * write all WC bits in USB legacy register */
    147         sysarg_t address = 0xc0;
    148         sysarg_t value = 0xaf00;
     150        const sysarg_t address = 0xc0;
     151        const sysarg_t value = 0xaf00;
    149152
    150         int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
     153        const int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
    151154            IPC_M_CONFIG_SPACE_WRITE_16, address, value);
    152155        async_hangup(parent_phone);

  • uspace/drv/uhci-hcd/pci.h

    r88be3a0b r6bfaab5  
    3838#include <ddf/driver.h>
    3939
    40 int pci_get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
    41 int pci_enable_interrupts(ddf_dev_t *);
    42 int pci_disable_legacy(ddf_dev_t *);
     40int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *);
     41int pci_enable_interrupts(const ddf_dev_t *);
     42int pci_disable_legacy(const ddf_dev_t *);
    4343
    4444#endif

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

    r88be3a0b r6bfaab5  
    6060                return ret;
    6161        }
     62        assert(match_str);
    6263
    6364        ret = ddf_fun_add_match_id(fun, match_str, 100);

  • uspace/drv/uhci-hcd/root_hub.h

    r88be3a0b r6bfaab5  
    4343        /** List of resources available to the root hub. */
    4444        hw_resource_list_t resource_list;
    45         /** The only resource in the above list */
     45        /** The only resource in the RH resource list */
    4646        hw_resource_t io_regs;
    4747} rh_t;

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

    r88be3a0b r6bfaab5  
    3434#include <errno.h>
    3535#include <usb/debug.h>
     36#include <arch/barrier.h>
     37
    3638
    3739#include "transfer_list.h"
     40#include "batch.h"
    3841
    3942static void transfer_list_remove_batch(
    … …  
    5760                return ENOMEM;
    5861        }
    59         uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
     62        const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
    6063        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n",
    6164            name, instance->queue_head, queue_head_pa);
    … …  
    7174 * @param[in] instance Memory place to use.
    7275 *
    73  * Frees memory for internal qh_t structure.
     76 * Frees memory of the internal qh_t structure.
    7477 */
    7578void transfer_list_fini(transfer_list_t *instance)
    … …  
    8992{
    9093        assert(instance);
     94        assert(instance->queue_head);
    9195        assert(next);
    92         if (!instance->queue_head)
    93                 return;
    9496        /* Set queue_head.next to point to the follower */
    9597        qh_set_next_qh(instance->queue_head, next->queue_head);
    … …  
    126128        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
    127129
     130        /* Make sure all data in the batch are written */
     131        write_barrier();
     132
    128133        /* keep link */
    129134        batch_qh(batch)->next = last_qh->next;
    130135        qh_set_next_qh(last_qh, batch_qh(batch));
    131136
    132         asm volatile ("": : :"memory");
    133 
    134         /* Add to the driver list */
     137        /* Make sure the pointer is updated */
     138        write_barrier();
     139
     140        /* Add to the driver's list */
    135141        list_append(&batch->link, &instance->batch_list);
    136142
    … …  
    155161        link_t *current = instance->batch_list.next;
    156162        while (current != &instance->batch_list) {
    157                 link_t *next = current->next;
     163                link_t * const next = current->next;
    158164                usb_transfer_batch_t *batch =
    159165                    usb_transfer_batch_from_link(current);
    … …  
    177183        fibril_mutex_lock(&instance->guard);
    178184        while (!list_empty(&instance->batch_list)) {
    179                 link_t *current = instance->batch_list.next;
     185                link_t * const current = instance->batch_list.next;
    180186                usb_transfer_batch_t *batch =
    181187                    usb_transfer_batch_from_link(current);
    … …  
    222228            == addr_to_phys(batch_qh(batch)));
    223229        prev_qh->next = batch_qh(batch)->next;
    224         asm volatile ("": : :"memory");
     230
     231        /* Make sure the pointer is updated */
     232        write_barrier();
     233
    225234        /* Remove from the batch list */
    226235        list_remove(&batch->link);

  • uspace/drv/uhci-hcd/transfer_list.h

    r88be3a0b r6bfaab5  
    3636
    3737#include <fibril_synch.h>
     38#include <usb/host/batch.h>
    3839
    39 #include "batch.h"
    4040#include "hw_struct/queue_head.h"
    4141
    … …  
    4343 * of currently executed transfers
    4444 */
    45 typedef struct transfer_list
    46 {
     45typedef struct transfer_list {
    4746        /** Guard against multiple add/remove races */
    4847        fibril_mutex_t guard;

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

    r88be3a0b r6bfaab5  
    7777{
    7878        assert(dev);
    79         hc_t *hc = &((uhci_t*)dev->driver_data)->hc;
     79        uhci_t *uhci = dev->driver_data;
     80        assert(uhci);
     81        hc_t *hc = &uhci->hc;
    8082        uint16_t status = IPC_GET_ARG1(*call);
    8183        assert(hc);
    … …  
    144146{
    145147        assert(fun);
    146         return &((rh_t*)fun->driver_data)->resource_list;
     148        rh_t *rh = fun->driver_data;
     149        assert(rh);
     150        return &rh->resource_list;
    147151}
    148152/*----------------------------------------------------------------------------*/

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

    r88be3a0b r6bfaab5  
    3535#ifndef DRV_UHCI_UHCI_H
    3636#define DRV_UHCI_UHCI_H
    37 #include <ddi.h>
    3837#include <ddf/driver.h>
    3938

  • uspace/drv/uhci-hcd/utils/malloc32.h

    r88be3a0b r6bfaab5  
    4141#include <as.h>
    4242
    43 #include "slab.h"
    44 
    4543#define UHCI_STRCUTURES_ALIGNMENT 16
    4644#define UHCI_REQUIRED_PAGE_SIZE 4096
    … …  
    5957        uintptr_t result;
    6058        const int ret = as_get_physical_mapping(addr, &result);
    61         assert(ret == EOK);
    62 
    6359        if (ret != EOK)
    6460                return 0;
    … …  
    7268 */
    7369static inline void * malloc32(size_t size) {
    74         if (size <= SLAB_ELEMENT_SIZE)
    75                 return slab_malloc_g();
    76         assert(false);
    77         return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
     70        /* This works only when the host has less than 4GB of memory as
     71         * physical address needs to fit into 32 bits */
     72
     73        /* If we need more than one page there is no guarantee that the
     74         * memory will be continuous */
     75        if (size > PAGE_SIZE)
     76                return NULL;
     77        /* Calculate alignment to make sure the block won't cross page
     78         * boundary */
     79        size_t alignment = UHCI_STRCUTURES_ALIGNMENT;
     80        while (alignment < size)
     81                alignment *= 2;
     82        return memalign(alignment, size);
    7883}
    7984/*----------------------------------------------------------------------------*/
    … …  
    8590        if (!addr)
    8691                return;
    87         if (slab_in_range_g(addr))
    88                 return slab_free_g(addr);
    8992        free(addr);
    9093}
    … …  
    97100{
    98101        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
    99         assert(free_address); /* TODO: remove this assert */
    100102        if (free_address == 0)
    101103                return NULL;

  • uspace/drv/uhci-rhd/main.c

    r88be3a0b r6bfaab5  
    3737#include <errno.h>
    3838#include <str_error.h>
     39
    3940#include <usb_iface.h>
    4041#include <usb/ddfiface.h>
    … …  
    4546#define NAME "uhci-rhd"
    4647
    47 static int hc_get_my_registers(ddf_dev_t *dev,
     48static int hc_get_my_registers(const ddf_dev_t *dev,
    4849    uintptr_t *io_reg_address, size_t *io_reg_size);
    4950/*----------------------------------------------------------------------------*/
    … …  
    130131 */
    131132int hc_get_my_registers(
    132     ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
     133    const ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
    133134{
    134         assert(dev != NULL);
     135        assert(dev);
    135136
    136         int parent_phone = devman_parent_device_connect(dev->handle,
     137        const int parent_phone = devman_parent_device_connect(dev->handle,
    137138            IPC_FLAG_BLOCKING);
    138139        if (parent_phone < 0) {
    … …  
    141142
    142143        hw_resource_list_t hw_resources;
    143         int ret = hw_res_get_resource_list(parent_phone, &hw_resources);
     144        const int ret = hw_res_get_resource_list(parent_phone, &hw_resources);
    144145        if (ret != EOK) {
    145146                async_hangup(parent_phone);

  • uspace/drv/uhci-rhd/port.c

    r88be3a0b r6bfaab5  
    3636#include <errno.h>
    3737#include <str_error.h>
    38 #include <time.h>
    3938#include <async.h>
    4039
    … …  
    8281 * @param[in] number Port number.
    8382 * @param[in] usec Polling interval.
    84  * @param[in] rh Pointer to ddf instance fo the root hub driver.
     83 * @param[in] rh Pointer to ddf instance of the root hub driver.
    8584 * @return Error code.
    8685 *
    … …  
    9190{
    9291        assert(port);
    93         asprintf(&port->id_string, "Port (%p - %u)", port, number);
    94         if (port->id_string == NULL) {
     92        char *id_string;
     93        asprintf(&id_string, "Port (%p - %u)", port, number);
     94        if (id_string == NULL) {
    9595                return ENOMEM;
    9696        }
    9797
     98        port->id_string = id_string;
    9899        port->address = address;
    99100        port->number = number;
    … …  
    105106            usb_hc_connection_initialize_from_device(&port->hc_connection, rh);
    106107        if (ret != EOK) {
    107                 usb_log_error("Failed to initialize connection to HC.");
     108                usb_log_error("%s: failed to initialize connection to HC.",
     109                    port->id_string);
     110                free(id_string);
    108111                return ret;
    109112        }
    … …  
    113116                usb_log_error("%s: failed to create polling fibril.",
    114117                    port->id_string);
     118                free(id_string);
    115119                return ENOMEM;
    116120        }
    … …  
    132136        assert(port);
    133137        free(port->id_string);
    134         /* TODO: Kill fibril here */
     138        // TODO: Kill fibril here
    135139        return;
    136140}
    … …  
    150154
    151155                /* Read register value */
    152                 port_status_t port_status = uhci_port_read_status(instance);
     156                const port_status_t port_status =
     157                    uhci_port_read_status(instance);
    153158
    154159                /* Print the value if it's interesting */
    … …  
    161166                usb_log_debug("%s: Connected change detected: %x.\n",
    162167                    instance->id_string, port_status);
    163 
    164                 int rc =
    165                     usb_hc_connection_open(&instance->hc_connection);
    166                 if (rc != EOK) {
    167                         usb_log_error("%s: Failed to connect to HC.",
    168                             instance->id_string);
    169                         continue;
    170                 }
    171168
    172169                /* Remove any old device */
    … …  
    175172                            instance->id_string);
    176173                        uhci_port_remove_device(instance);
     174                }
     175
     176                int ret =
     177                    usb_hc_connection_open(&instance->hc_connection);
     178                if (ret != EOK) {
     179                        usb_log_error("%s: Failed to connect to HC.",
     180                            instance->id_string);
     181                        continue;
    177182                }
    178183
    … …  
    190195                }
    191196
    192                 rc = usb_hc_connection_close(&instance->hc_connection);
    193                 if (rc != EOK) {
     197                ret = usb_hc_connection_close(&instance->hc_connection);
     198                if (ret != EOK) {
    194199                        usb_log_error("%s: Failed to disconnect.",
    195200                            instance->id_string);
    … …  
    209214int uhci_port_reset_enable(int portno, void *arg)
    210215{
    211         uhci_port_t *port = (uhci_port_t *) arg;
     216        uhci_port_t *port = arg;
     217        assert(port);
    212218
    213219        usb_log_debug2("%s: new_device_enable_port.\n", port->id_string);
    … …  
    227233                while (uhci_port_read_status(port) & STATUS_IN_RESET);
    228234        }
     235        /* PIO delay, should not be longer than 3ms as the device might
     236         * enter suspend state. */
    229237        udelay(10);
    230238        /* Enable the port. */
    231239        uhci_port_set_enabled(port, true);
    232 
    233         /* Reset recovery period,
    234          * devices do not have to respond during this period
    235          */
    236         async_usleep(10000);
    237240        return EOK;
    238241}
    … …  
    286289        usb_log_error("%s: Don't know how to remove device %" PRIun ".\n",
    287290            port->id_string, port->attached_device);
     291        port->attached_device = 0;
    288292        return ENOTSUP;
    289293}

  • uspace/drv/uhci-rhd/port.h

    r88be3a0b r6bfaab5  
    3838#include <fibril.h>
    3939#include <ddf/driver.h>
    40 #include <usb/dev/hc.h> /* usb_hc_connection_t */
     40#include <usb/hc.h> /* usb_hc_connection_t */
    4141
    4242typedef uint16_t port_status_t;
    … …  
    5757typedef struct uhci_port
    5858{
    59         char *id_string;
     59        const char *id_string;
    6060        port_status_t *address;
    6161        unsigned number;

  • uspace/drv/usbhid/Makefile

    r88be3a0b r6bfaab5  
    5757        generic/hiddev.c \
    5858        mouse/mousedev.c \
    59         lgtch-ultrax/lgtch-ultrax.c \
    60         lgtch-ultrax/keymap.c \
     59        multimedia/multimedia.c \
     60        multimedia/keymap.c \
    6161        $(STOLEN_LAYOUT_SOURCES)
    6262

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

    r88be3a0b r6bfaab5  
    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;
    158        
    159         return EOK;
    160 }
    161 
    162 /*----------------------------------------------------------------------------*/
    163 
    164 int usb_generic_hid_init(usb_hid_dev_t *hid_dev)
     228        usb_log_debug("HID function created. Handle: %d\n", fun->handle);
     229       
     230        return EOK;
     231}
     232
     233/*----------------------------------------------------------------------------*/
     234
     235int usb_generic_hid_init(usb_hid_dev_t *hid_dev, void **data)
    165236{
    166237        if (hid_dev == NULL) {
    … …  
    173244/*----------------------------------------------------------------------------*/
    174245
    175 bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev,
     246bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data,
    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/generic/hiddev.h

    r88be3a0b r6bfaab5  
    4848/*----------------------------------------------------------------------------*/
    4949
    50 int usb_generic_hid_init(struct usb_hid_dev *hid_dev);
     50int usb_generic_hid_init(struct usb_hid_dev *hid_dev, void **data);
    5151
    52 bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev,
     52bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    5353    uint8_t *buffer, size_t buffer_size);
    5454

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

    r88be3a0b r6bfaab5  
    252252        sysarg_t method = IPC_GET_IMETHOD(*icall);
    253253       
    254         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    255        
    256         if (hid_dev == NULL || hid_dev->data == NULL) {
     254        usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
     255        if (kbd_dev == NULL) {
    257256                usb_log_debug("default_connection_handler: "
    258257                    "Missing parameter.\n");
    … …  
    260259                return;
    261260        }
    262        
    263         assert(hid_dev != NULL);
    264         assert(hid_dev->data != NULL);
    265         usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
    266261
    267262        if (method == IPC_M_CONNECT_TO_ME) {
    … …  
    313308        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    314309            hid_dev->report, NULL, kbd_dev->led_path,
    315             USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY | USB_HID_PATH_COMPARE_END,
     310            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    316311            USB_HID_REPORT_TYPE_OUTPUT);
    317312       
    318         while (field != NULL) {
    319 
     313        while (field != NULL) {         
     314               
    320315                if ((field->usage == USB_HID_LED_NUM_LOCK)
    321316                    && (kbd_dev->mods & KM_NUM_LOCK)){
    … …  
    334329               
    335330                field = usb_hid_report_get_sibling(hid_dev->report, field,
    336                     kbd_dev->led_path, USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY
    337                     | USB_HID_PATH_COMPARE_END, USB_HID_REPORT_TYPE_OUTPUT);
     331                    kbd_dev->led_path, 
     332                USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     333                        USB_HID_REPORT_TYPE_OUTPUT);
    338334        }
    339335       
    … …  
    662658 *     usb_hid_parse_report().
    663659 */
    664 static void usb_kbd_process_data(usb_hid_dev_t *hid_dev,
     660static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev,
    665661                                 uint8_t *buffer, size_t actual_size)
    666662{
    667663        assert(hid_dev->report != NULL);
    668664        assert(hid_dev != NULL);
    669         assert(hid_dev->data != NULL);
    670        
    671         usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
     665        assert(kbd_dev != NULL);
    672666
    673667        usb_log_debug("Calling usb_hid_parse_report() with "
    … …  
    774768/*----------------------------------------------------------------------------*/
    775769
    776 static int usb_kbd_create_function(usb_hid_dev_t *hid_dev)
     770static int usb_kbd_create_function(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
    777771{
    778772        assert(hid_dev != NULL);
    779773        assert(hid_dev->usb_dev != NULL);
     774        assert(kbd_dev != NULL);
    780775       
    781776        /* Create the function exposed under /dev/devices. */
    … …  
    792787         * to the DDF function.
    793788         */
    794         fun->ops = &hid_dev->ops;
    795         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
     789        fun->ops = &kbd_dev->ops;
     790        fun->driver_data = kbd_dev;
    796791
    797792        int rc = ddf_fun_bind(fun);
    … …  
    802797                return rc;
    803798        }
     799       
     800        usb_log_debug("%s function created. Handle: %d\n", HID_KBD_FUN_NAME,
     801            fun->handle);
    804802       
    805803        usb_log_debug("Adding DDF function to class %s...\n",
    … …  
    840838 * @return Other value inherited from function usbhid_dev_init().
    841839 */
    842 int usb_kbd_init(usb_hid_dev_t *hid_dev)
     840int usb_kbd_init(usb_hid_dev_t *hid_dev, void **data)
    843841{
    844842        usb_log_debug("Initializing HID/KBD structure...\n");
    … …  
    865863        usb_hid_report_path_set_report_id(path, 0);
    866864       
    867         kbd_dev->key_count = usb_hid_report_input_length(
    868             hid_dev->report, path,
    869             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
     865        kbd_dev->key_count = usb_hid_report_size(
     866            hid_dev->report, 0, USB_HID_REPORT_TYPE_INPUT);
    870867        usb_hid_report_path_free(path);
    871868       
    … …  
    908905            kbd_dev->led_path, USB_HIDUT_PAGE_LED, 0);
    909906       
    910         kbd_dev->led_output_size = usb_hid_report_output_size(hid_dev->report,
    911             kbd_dev->led_path,
    912             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
     907        kbd_dev->led_output_size = usb_hid_report_size(hid_dev->report,
     908            0, USB_HID_REPORT_TYPE_OUTPUT);
    913909       
    914910        usb_log_debug("Output report size (in items): %zu\n",
    … …  
    955951       
    956952        // save the KBD device structure into the HID device structure
    957         hid_dev->data = kbd_dev;
     953        //hid_dev->data = kbd_dev;
     954        *data = kbd_dev;
    958955       
    959956        // set handler for incoming calls
    960         hid_dev->ops.default_handler = default_connection_handler;
     957        kbd_dev->ops.default_handler = default_connection_handler;
    961958       
    962959        /*
    … …  
    983980       
    984981        usb_log_debug("Creating KBD function...\n");
    985         int rc = usb_kbd_create_function(hid_dev);
     982        int rc = usb_kbd_create_function(hid_dev, kbd_dev);
    986983        if (rc != EOK) {
    987984                usb_kbd_free(&kbd_dev);
    … …  
    994991/*----------------------------------------------------------------------------*/
    995992
    996 bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    997      size_t buffer_size)
    998 {
    999         if (hid_dev == NULL || buffer == NULL) {
     993bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data,
     994     uint8_t *buffer, size_t buffer_size)
     995{
     996        if (hid_dev == NULL || buffer == NULL || data == NULL) {
    1000997                // do not continue polling (???)
    1001998                return false;
    1002999        }
    10031000       
     1001        usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
     1002        assert(kbd_dev != NULL);
     1003       
    10041004        // TODO: add return value from this function
    1005         usb_kbd_process_data(hid_dev, buffer, buffer_size);
     1005        usb_kbd_process_data(hid_dev, kbd_dev, buffer, buffer_size);
    10061006       
    10071007        return true;
    … …  
    10661066/*----------------------------------------------------------------------------*/
    10671067
    1068 void usb_kbd_deinit(usb_hid_dev_t *hid_dev)
     1068void usb_kbd_deinit(usb_hid_dev_t *hid_dev, void *data)
    10691069{
    10701070        if (hid_dev == NULL) {
    … …  
    10721072        }
    10731073       
    1074         if (hid_dev->data != NULL) {
    1075                 usb_kbd_t *kbd_dev = (usb_kbd_t *)hid_dev->data;
     1074        if (data != NULL) {
     1075                usb_kbd_t *kbd_dev = (usb_kbd_t *)data;
    10761076                if (usb_kbd_is_initialized(kbd_dev)) {
    10771077                        usb_kbd_mark_unusable(kbd_dev);
    10781078                } else {
    10791079                        usb_kbd_free(&kbd_dev);
    1080                         hid_dev->data = NULL;
    10811080                }
    10821081        }

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

    r88be3a0b r6bfaab5  
    8383        int console_phone;
    8484       
     85        /** @todo What is this actually? */
     86        ddf_dev_ops_t ops;
     87       
    8588        /** Information for auto-repeat of keys. */
    8689        usb_kbd_repeat_t repeat;
    … …  
    117120/*----------------------------------------------------------------------------*/
    118121
    119 int usb_kbd_init(struct usb_hid_dev *hid_dev);
     122int usb_kbd_init(struct usb_hid_dev *hid_dev, void **data);
    120123
    121 bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
    122     size_t buffer_size);
     124bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     125                              uint8_t *buffer, size_t buffer_size);
    123126
    124127int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);
    … …  
    131134    int type, unsigned int key);
    132135
    133 void usb_kbd_deinit(struct usb_hid_dev *hid_dev);
     136void usb_kbd_deinit(struct usb_hid_dev *hid_dev, void *data);
    134137
    135138int usb_kbd_set_boot_protocol(struct usb_hid_dev *hid_dev);

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

    r88be3a0b r6bfaab5  
    122122        sysarg_t method = IPC_GET_IMETHOD(*icall);
    123123       
    124         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    125        
    126         if (hid_dev == NULL || hid_dev->data == NULL) {
     124        usb_mouse_t *mouse_dev = (usb_mouse_t *)fun->driver_data;
     125       
     126        if (mouse_dev == NULL) {
    127127                usb_log_debug("default_connection_handler: Missing "
    128128                    "parameters.\n");
    … …  
    131131        }
    132132       
    133         assert(hid_dev != NULL);
    134         assert(hid_dev->data != NULL);
    135         usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
     133        usb_log_debug("default_connection_handler: fun->name: %s\n",
     134                      fun->name);
     135        usb_log_debug("default_connection_handler: mouse_phone: %d, wheel "
     136            "phone: %d\n", mouse_dev->mouse_phone, mouse_dev->wheel_phone);
    136137       
    137138        int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0)
    … …  
    145146                            "phone to mouse already set.\n");
    146147                        async_answer_0(icallid, ELIMIT);
    147                         //async_answer_0(icallid, EOK);
    148148                        return;
    149149                }
    150150
    151151                *phone = callback;
    152                 usb_log_debug("Console phone to mouse set ok (%d).\n", callback);
     152                usb_log_debug("Console phone to mouse set ok (%d).\n", *phone);
    153153                async_answer_0(icallid, EOK);
    154154                return;
    … …  
    224224/*----------------------------------------------------------------------------*/
    225225
    226 static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    227     size_t buffer_size)
    228 {
    229         usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
     226static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev,
     227                                     usb_mouse_t *mouse_dev, uint8_t *buffer,
     228                                     size_t buffer_size)
     229{
     230        assert(mouse_dev != NULL);
    230231       
    231232        usb_log_debug2("got buffer: %s.\n",
    … …  
    233234       
    234235        if (mouse_dev->mouse_phone < 0) {
    235                 usb_log_error(NAME " No console phone.\n");
    236                 return false;   // ??
     236                usb_log_warning(NAME " No console phone.\n");
     237                return true;
    237238        }
    238239
    … …  
    378379/*----------------------------------------------------------------------------*/
    379380
    380 static int usb_mouse_create_function(usb_hid_dev_t *hid_dev)
    381 {
     381static int usb_mouse_create_function(usb_hid_dev_t *hid_dev, usb_mouse_t *mouse)
     382{
     383        assert(hid_dev != NULL);
     384        assert(mouse != NULL);
     385       
    382386        /* Create the function exposed under /dev/devices. */
    383387        usb_log_debug("Creating DDF function %s...\n", HID_MOUSE_FUN_NAME);
    … …  
    389393        }
    390394       
    391         /*
    392          * Store the initialized HID device and HID ops
    393          * to the DDF function.
    394          */
    395         fun->ops = &hid_dev->ops;
    396         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
     395        fun->ops = &mouse->ops;
     396        fun->driver_data = mouse;   // TODO: maybe change to hid_dev->data
    397397
    398398        int rc = ddf_fun_bind(fun);
    … …  
    431431         * to the DDF function.
    432432         */
    433         fun->ops = &hid_dev->ops;
    434         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
     433        fun->ops = &mouse->ops;
     434        fun->driver_data = mouse;   // TODO: maybe change to hid_dev->data
    435435
    436436        rc = ddf_fun_bind(fun);
    … …  
    458458/*----------------------------------------------------------------------------*/
    459459
    460 int usb_mouse_init(usb_hid_dev_t *hid_dev)
     460int usb_mouse_init(usb_hid_dev_t *hid_dev, void **data)
    461461{
    462462        usb_log_debug("Initializing HID/Mouse structure...\n");
    … …  
    485485       
    486486        // save the Mouse device structure into the HID device structure
    487         hid_dev->data = mouse_dev;
     487        *data = mouse_dev;
    488488       
    489489        // set handler for incoming calls
    490         hid_dev->ops.default_handler = default_connection_handler;
     490        // TODO: must be one for each subdriver!!
     491        mouse_dev->ops.default_handler = default_connection_handler;
    491492       
    492493        // TODO: how to know if the device supports the request???
    … …  
    494495//          hid_dev->usb_dev->interface_no, IDLE_RATE);
    495496       
    496         int rc = usb_mouse_create_function(hid_dev);
     497        int rc = usb_mouse_create_function(hid_dev, mouse_dev);
    497498        if (rc != EOK) {
    498499                usb_mouse_free(&mouse_dev);
    … …  
    505506/*----------------------------------------------------------------------------*/
    506507
    507 bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    508      size_t buffer_size)
     508bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data,
     509     uint8_t *buffer, size_t buffer_size)
    509510{
    510511        usb_log_debug("usb_mouse_polling_callback()\n");
    511512        usb_debug_str_buffer(buffer, buffer_size, 0);
    512513       
    513         if (hid_dev == NULL) {
     514        if (hid_dev == NULL || data == NULL) {
    514515                usb_log_error("Missing argument to the mouse polling callback."
    515516                    "\n");
    … …  
    517518        }
    518519       
    519         if (hid_dev->data == NULL) {
    520                 usb_log_error("Wrong argument to the mouse polling callback."
    521                     "\n");
    522                 return false;
    523         }
    524        
    525         return usb_mouse_process_report(hid_dev, buffer, buffer_size);
    526 }
    527 
    528 /*----------------------------------------------------------------------------*/
    529 
    530 void usb_mouse_deinit(usb_hid_dev_t *hid_dev)
    531 {
    532         usb_mouse_free((usb_mouse_t **)&hid_dev->data);
     520        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
     521               
     522        return usb_mouse_process_report(hid_dev, mouse_dev, buffer,
     523                                        buffer_size);
     524}
     525
     526/*----------------------------------------------------------------------------*/
     527
     528void usb_mouse_deinit(usb_hid_dev_t *hid_dev, void *data)
     529{
     530        if (data != NULL) {
     531                usb_mouse_free((usb_mouse_t **)&data);
     532        }
    533533}
    534534

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

    r88be3a0b r6bfaab5  
    5252       
    5353        int32_t *buttons;
     54       
     55        ddf_dev_ops_t ops;
    5456} usb_mouse_t;
    5557
    … …  
    6365/*----------------------------------------------------------------------------*/
    6466
    65 int usb_mouse_init(struct usb_hid_dev *hid_dev);
     67int usb_mouse_init(struct usb_hid_dev *hid_dev, void **data);
    6668
    67 bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, uint8_t *buffer,
    68     size_t buffer_size);
     69bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     70    uint8_t *buffer, size_t buffer_size);
    6971
    70 void usb_mouse_deinit(struct usb_hid_dev *hid_dev);
     72void usb_mouse_deinit(struct usb_hid_dev *hid_dev, void *data);
    7173
    7274int usb_mouse_set_boot_protocol(struct usb_hid_dev *hid_dev);

  • uspace/drv/usbhid/subdrivers.c

    r88be3a0b r6bfaab5  
    3838#include <usb/hid/hidpath.h>
    3939
    40 #include "lgtch-ultrax/lgtch-ultrax.h"
     40#include "multimedia/multimedia.h"
    4141#include "mouse/mousedev.h"
     42#include "generic/hiddev.h"
    4243
    4344static usb_hid_subdriver_usage_t path_kbd[] = {
    44         {USB_HIDUT_PAGE_KEYBOARD, 0},
     45        {USB_HIDUT_PAGE_GENERIC_DESKTOP,
     46         USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD},
    4547        {0, 0}
    4648};
    4749
    48 static usb_hid_subdriver_usage_t path_mouse2[] = {
    49         {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_X},
     50static usb_hid_subdriver_usage_t path_mouse[] = {
     51        {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE},
    5052        {0, 0}
    5153};
    5254
    53 static usb_hid_subdriver_usage_t lgtch_path[] = {
    54         {0xc, 0},
     55static usb_hid_subdriver_usage_t multim_key_path[] = {
     56        {USB_HIDUT_PAGE_CONSUMER, USB_HIDUT_USAGE_CONSUMER_CONSUMER_CONTROL},
    5557        {0, 0}
    5658};
     59
     60//static usb_hid_subdriver_usage_t generic_hid_key_path[] = {
     61//      {0, 0}
     62//};
    5763
    5864const usb_hid_subdriver_mapping_t usb_hid_subdrivers[] = {
    5965        {
    6066                path_kbd,
    61                 -1,
    62                 USB_HID_PATH_COMPARE_END
    63                 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     67                0,
     68                USB_HID_PATH_COMPARE_BEGIN,
    6469                -1,
    6570                -1,
    … …  
    7378        },
    7479        {
    75                 lgtch_path,
     80                multim_key_path,
    7681                1,
    77                 USB_HID_PATH_COMPARE_END
    78                 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    79                 0x046d,
    80                 0xc30e,
     82                USB_HID_PATH_COMPARE_BEGIN,
     83                -1,
     84                -1,
    8185                {
    82                         .init = usb_lgtch_init,
    83                         .deinit = usb_lgtch_deinit,
    84                         .poll = usb_lgtch_polling_callback,
     86                        .init = usb_multimedia_init,
     87                        .deinit = usb_multimedia_deinit,
     88                        .poll = usb_multimedia_polling_callback,
    8589                        .poll_end = NULL
    8690                }
    8791        },
    8892        {
    89                 path_mouse2,
    90                 -1,
    91                 USB_HID_PATH_COMPARE_END
    92                 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     93                path_mouse,
     94                0,
     95                USB_HID_PATH_COMPARE_BEGIN,
    9396                -1,
    9497                -1,
    … …  
    100103                }
    101104        },
    102         {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
     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//      },
     118        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL, NULL}}
    103119};
    104120

  • uspace/drv/usbhid/usbhid.c

    r88be3a0b r6bfaab5  
    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/*----------------------------------------------------------------------------*/
    … …  
    203204       
    204205        usb_log_debug("Compare flags: %d\n", mapping->compare);
    205         size_t size = usb_hid_report_input_length(hid_dev->report, usage_path,
    206             mapping->compare);
     206//      size_t size = usb_hid_report_size(hid_dev->report, 0,
     207//          USB_HID_REPORT_TYPE_INPUT);
     208        size_t size = 0;
     209        usb_hid_report_field_t *field = usb_hid_report_get_sibling (hid_dev->report,
     210                NULL, usage_path, mapping->compare, USB_HID_REPORT_TYPE_INPUT);
     211        while(field != NULL) {
     212                size++;
     213                field = usb_hid_report_get_sibling (hid_dev->report,
     214                                        field, usage_path, mapping->compare,
     215                            USB_HID_REPORT_TYPE_INPUT);
     216        }
     217       
    207218        usb_log_debug("Size of the input report: %zuB\n", size);
    208        
    209219        usb_hid_report_path_free(usage_path);
    210220       
    … …  
    225235        }
    226236       
    227         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) *
    228240            sizeof(usb_hid_subdriver_t));
    229241        if (hid_dev->subdrivers == NULL) {
    … …  
    238250        }
    239251       
    240         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;
    241258       
    242259        return EOK;
    … …  
    298315               
    299316                if (matched) {
     317                        usb_log_debug("Subdriver matched.\n");
    300318                        subdrivers[count++] = &mapping->subdriver;
    301319                }
    … …  
    339357/*----------------------------------------------------------------------------*/
    340358
     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
    341394usb_hid_dev_t *usb_hid_new(void)
    342395{
    … …  
    393446        /* Get the report descriptor and parse it. */
    394447        rc = usb_hid_process_report_descriptor(hid_dev->usb_dev,
    395             hid_dev->report);
     448            hid_dev->report, &hid_dev->report_desc, &hid_dev->report_desc_size);
    396449       
    397450        bool fallback = false;
    … …  
    457510                        if (hid_dev->subdrivers[i].init != NULL) {
    458511                                usb_log_debug("Initializing subdriver %d.\n",i);
    459                                 rc = hid_dev->subdrivers[i].init(hid_dev);
     512                                rc = hid_dev->subdrivers[i].init(hid_dev,
     513                                    &hid_dev->subdrivers[i].data);
    460514                                if (rc != EOK) {
    461515                                        usb_log_warning("Failed to initialize"
    … …  
    473527        }
    474528       
     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       
    475535        return rc;
    476536}
    … …  
    490550        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)arg;
    491551       
    492         int allocated = (hid_dev->input_report != NULL);
    493        
    494         if (!allocated
    495             || hid_dev->input_report_size < buffer_size) {
    496                 uint8_t *input_old = hid_dev->input_report;
    497                 uint8_t *input_new = (uint8_t *)malloc(buffer_size);
    498                
    499                 if (input_new == NULL) {
    500                         usb_log_error("Failed to allocate space for input "
    501                             "buffer. This event may not be reported\n");
    502                         memset(hid_dev->input_report, 0,
    503                             hid_dev->input_report_size);
    504                 } else {
    505                         memcpy(input_new, input_old,
    506                             hid_dev->input_report_size);
    507                         hid_dev->input_report = input_new;
    508                         if (allocated) {
    509                                 free(input_old);
    510                         }
    511                         usb_hid_new_report();
    512                 }
    513         }
     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//      }
    514578       
    515579        /*! @todo This should probably be atomic. */
    516580        memcpy(hid_dev->input_report, buffer, buffer_size);
    517581        hid_dev->input_report_size = buffer_size;
     582        usb_hid_new_report(hid_dev);
    518583       
    519584        bool cont = false;
    … …  
    522587        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    523588                if (hid_dev->subdrivers[i].poll != NULL
    524                     && hid_dev->subdrivers[i].poll(hid_dev, buffer,
    525                     buffer_size)) {
     589                    && hid_dev->subdrivers[i].poll(hid_dev,
     590                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
    526591                        cont = true;
    527592                }
    … …  
    546611        for (i = 0; i < hid_dev->subdriver_count; ++i) {
    547612                if (hid_dev->subdrivers[i].poll_end != NULL) {
    548                         hid_dev->subdrivers[i].poll_end(hid_dev, reason);
     613                        hid_dev->subdrivers[i].poll_end(hid_dev,
     614                            hid_dev->subdrivers[i].data, reason);
    549615                }
    550616        }
    … …  
    590656/*----------------------------------------------------------------------------*/
    591657
    592 void usb_hid_new_report(void)
    593 {
    594         report_received = false;
    595 }
    596 
    597 /*----------------------------------------------------------------------------*/
    598 
    599 void usb_hid_report_received(void)
    600 {
    601         report_received = true;
    602 }
    603 
    604 /*----------------------------------------------------------------------------*/
    605 
    606 bool usb_hid_report_ready(void)
    607 {
    608         return !report_received;
    609 }
     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//}
    610683
    611684/*----------------------------------------------------------------------------*/
    … …  
    627700        for (i = 0; i < (*hid_dev)->subdriver_count; ++i) {
    628701                if ((*hid_dev)->subdrivers[i].deinit != NULL) {
    629                         (*hid_dev)->subdrivers[i].deinit(*hid_dev);
     702                        (*hid_dev)->subdrivers[i].deinit(*hid_dev,
     703                            (*hid_dev)->subdrivers[i].data);
    630704                }
    631705        }

  • uspace/drv/usbhid/usbhid.h

    r88be3a0b r6bfaab5  
    4848struct usb_hid_dev;
    4949
    50 typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *);
    51 typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *);
    52 typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, uint8_t *, size_t);
    53 typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, bool reason);
     50typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *, void **data);
     51typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *, void *data);
     52typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, void *data, uint8_t *,
     53                                    size_t);
     54typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, void *data,
     55                                         bool reason);
    5456
    5557// TODO: add function and class name??
    … …  
    6365        /** Function to be called when polling ends. */
    6466        usb_hid_driver_poll_ended poll_end;
     67        /** Arbitrary data needed by the subdriver. */
     68        void *data;
    6569} usb_hid_subdriver_t;
    6670
    … …  
    7276        /** Structure holding generic USB device information. */
    7377        usb_device_t *usb_dev;
    74        
    75         /** @todo What is this actually? */
    76         ddf_dev_ops_t ops;
    7778       
    7879        /** Index of the polling pipe in usb_hid_endpoints array. */
    … …  
    9798       
    9899        size_t input_report_size;
     100        size_t max_input_report_size;
    99101       
    100         /** Arbitrary data (e.g. a special structure for handling keyboard). */
    101         void *data;
     102        int report_nr;
    102103} usb_hid_dev_t;
    103104
    … …  
    129130//const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev);
    130131
    131 void usb_hid_new_report(void);
     132void usb_hid_new_report(usb_hid_dev_t *hid_dev);
    132133
    133 void usb_hid_report_received(void);
     134int usb_hid_report_number(usb_hid_dev_t *hid_dev);
    134135
    135 bool usb_hid_report_ready(void);
     136//void usb_hid_report_received(void);
     137
     138//bool usb_hid_report_ready(void);
    136139
    137140void usb_hid_free(usb_hid_dev_t **hid_dev);

  • uspace/lib/drv/Makefile

    r88be3a0b r6bfaab5  
    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

    r88be3a0b r6bfaab5  
    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

    r88be3a0b r6bfaab5  
    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

    r88be3a0b r6bfaab5  
    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_usbhid.h

    r88be3a0b r6bfaab5  
    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

    r88be3a0b r6bfaab5  
    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/usb/Makefile

    r88be3a0b r6bfaab5  
    3737        src/ddfiface.c \
    3838        src/debug.c \
    39         src/driver.c \
    4039        src/dump.c \
    41         src/host.c \
     40        src/hc.c \
     41        src/resolve.c \
    4242        src/usb.c
    4343

  • uspace/lib/usb/src/ddfiface.c

    r88be3a0b r6bfaab5  
    3737#include <async.h>
    3838#include <usb/ddfiface.h>
    39 #include <usb/driver.h>
     39#include <usb/hc.h>
    4040#include <usb/debug.h>
    4141#include <errno.h>

  • uspace/lib/usbdev/Makefile

    r88be3a0b r6bfaab5  
    4646        src/pipesio.c \
    4747        src/recognise.c \
    48         src/request.c \
    49         src/usbdevice.c
     48        src/request.c
    5049
    5150include $(USPACE_PREFIX)/Makefile.common

  • uspace/lib/usbdev/include/usb/dev/hub.h

    r88be3a0b r6bfaab5  
    3939
    4040#include <sys/types.h>
    41 #include <usb/dev/hc.h>
     41#include <usb/hc.h>
    4242
    4343int usb_hc_new_device_wrapper(ddf_dev_t *, usb_hc_connection_t *, usb_speed_t,
    … …  
    6363    const usb_hc_attached_device_t *);
    6464int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t);
    65 int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t,
    66     devman_handle_t *);
    6765
    6866#endif

  • uspace/lib/usbdev/include/usb/dev/pipes.h

    r88be3a0b r6bfaab5  
    3838#include <sys/types.h>
    3939#include <usb/usb.h>
    40 #include <usb/dev/hc.h>
     40#include <usb/hc.h>
    4141#include <usb/descriptor.h>
    4242#include <ipc/devman.h>
    … …  
    163163
    164164int usb_device_get_assigned_interface(ddf_dev_t *);
    165 usb_address_t usb_device_get_assigned_address(devman_handle_t);
    166165
    167166int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *,

  • uspace/lib/usbdev/src/hub.c

    r88be3a0b r6bfaab5  
    4141#include <assert.h>
    4242#include <usb/debug.h>
     43#include <time.h>
    4344
    4445/** How much time to wait between attempts to register endpoint 0:0.
    … …  
    119120}
    120121
    121 /** Get handle of USB device with given address.
    122  *
    123  * @param[in] connection Opened connection to host controller.
    124  * @param[in] address Address of device in question.
    125  * @param[out] handle Where to write the device handle.
    126  * @return Error code.
    127  */
    128 int usb_hc_get_handle_by_address(usb_hc_connection_t *connection,
    129     usb_address_t address, devman_handle_t *handle)
    130 {
    131         CHECK_CONNECTION(connection);
    132 
    133         sysarg_t tmp;
    134         int rc = async_req_2_1(connection->hc_phone,
    135             DEV_IFACE_ID(USBHC_DEV_IFACE),
    136             IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
    137             address, &tmp);
    138         if ((rc == EOK) && (handle != NULL)) {
    139                 *handle = tmp;
    140         }
    141 
    142         return rc;
    143 }
    144122
    145123static void unregister_control_endpoint_on_default_address(
    … …  
    218196
    219197        int rc;
     198        struct timeval start_time;
     199
     200        rc = gettimeofday(&start_time, NULL);
     201        if (rc != EOK) {
     202                return rc;
     203        }
    220204
    221205        rc = usb_hc_connection_open(&hc_conn);
    … …  
    264248                }
    265249        } while (rc != EOK);
     250        struct timeval end_time;
     251
     252        rc = gettimeofday(&end_time, NULL);
     253        if (rc != EOK) {
     254                goto leave_release_default_address;
     255        }
     256
     257        /* According to the USB spec part 9.1.2 host allows 100ms time for
     258         * the insertion process to complete. According to 7.1.7.1 this is the
     259         * time between attach detected and port reset. However, the setup done
     260         * above might use much of this time so we should only wait to fill
     261         * up the 100ms quota*/
     262        suseconds_t elapsed = tv_sub(&end_time, &start_time);
     263        if (elapsed < 100000) {
     264                async_usleep(100000 - elapsed);
     265        }
    266266
    267267        /*
    … …  
    273273                goto leave_release_default_address;
    274274        }
     275        /* USB spec 7.1.7.1: The USB System Software guarantees a minimum of
     276         * 10ms for reset recovery. Device response to any bus transactions
     277         * addressed to the default device address during the reset recovery
     278         * time is undefined.
     279         */
     280        async_usleep(10000);
    275281
    276282        rc = usb_pipe_probe_default_control(&ctrl_pipe);

  • uspace/lib/usbdev/src/pipes.c

    r88be3a0b r6bfaab5  
    3636#include <usb/dev/pipes.h>
    3737#include <usb/debug.h>
    38 #include <usb/driver.h>
     38#include <usb/hc.h>
    3939#include <usbhc_iface.h>
    4040#include <usb_iface.h>
    … …  
    9797
    9898        return (int) iface_no;
    99 }
    100 
    101 /** Tell USB address assigned to given device.
    102  *
    103  * @param dev_handle Devman handle of the USB device in question.
    104  * @return USB address or negative error code.
    105  */
    106 usb_address_t usb_device_get_assigned_address(devman_handle_t dev_handle)
    107 {
    108         int parent_phone = devman_parent_device_connect(dev_handle,
    109             IPC_FLAG_BLOCKING);
    110         if (parent_phone < 0) {
    111                 return parent_phone;
    112         }
    113 
    114         sysarg_t address;
    115 
    116         int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),
    117             IPC_M_USB_GET_ADDRESS,
    118             dev_handle, &address);
    119 
    120         if (rc != EOK) {
    121                 return rc;
    122         }
    123 
    124         async_hangup(parent_phone);
    125 
    126         return (usb_address_t) address;
    12799}
    128100

  • uspace/lib/usbhid/Makefile

    r88be3a0b r6bfaab5  
    4141        src/hidpath.c \
    4242        src/hidreport.c \
     43        src/consumer.c \
    4344        src/hidreq.c
    4445

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

    r88be3a0b r6bfaab5  
    2727 */
    2828
    29 /** @addtogroup libusbhid
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief USB HID parser.
    34  */
    35 #ifndef LIBUSBHID_HID_REPORT_ITEMS_H_
    36 #define LIBUSBHID_HID_REPORT_ITEMS_H_
     33 * @brief USB HID Report descriptor item tags.
     34 */
     35#ifndef LIBUSB_HID_REPORT_ITEMS_H_
     36#define LIBUSB_HID_REPORT_ITEMS_H_
    3737
    3838#include <stdint.h>
    3939
    40 /**
     40/*---------------------------------------------------------------------------*/
     41/*
    4142 * Item prefix
    4243 */
     44
     45/** Returns size of item data in bytes */
    4346#define USB_HID_ITEM_SIZE(data)         ((uint8_t)(data & 0x3))
     47
     48/** Returns item tag */
    4449#define USB_HID_ITEM_TAG(data)          ((uint8_t)((data & 0xF0) >> 4))
     50
     51/** Returns class of item tag */
    4552#define USB_HID_ITEM_TAG_CLASS(data)    ((uint8_t)((data & 0xC) >> 2))
     53
     54/** Returns if the item is the short item or long item. Long items are not
     55 * supported. */
    4656#define USB_HID_ITEM_IS_LONG(data)      (data == 0xFE)
    4757
    48 
    49 /**
     58/*---------------------------------------------------------------------------*/
     59/*
     60 * Extended usage macros
     61 */
     62
     63/** Recognizes if the given usage is extended (contains also usage page).  */
     64#define USB_HID_IS_EXTENDED_USAGE(usage)        ((usage & 0xFFFF0000) != 0)
     65
     66/** Cuts usage page of the extended usage. */
     67#define USB_HID_EXTENDED_USAGE_PAGE(usage)      ((usage & 0xFFFF0000) >> 16)
     68
     69/** Cuts usage of the extended usage */
     70#define USB_HID_EXTENDED_USAGE(usage)           (usage & 0xFFFF)
     71
     72/*---------------------------------------------------------------------------*/
     73/*
    5074 * Input/Output/Feature Item flags
    5175 */
    52 /** Constant (1) / Variable (0) */
     76/**
     77 * Indicates whether the item is data (0) or a constant (1) value. Data
     78 * indicates the item is defining report fields that contain modifiable device
     79 * data. Constant indicates the item is a static read-only field in a report
     80 * and cannot be modified (written) by the host.
     81 */
    5382#define USB_HID_ITEM_FLAG_CONSTANT(flags)       ((flags & 0x1) == 0x1)
    54 /** Variable (1) / Array (0) */
     83
     84/**
     85 * Indicates whether the item creates variable (1) or array (0) data fields in
     86 * reports.
     87 */
    5588#define USB_HID_ITEM_FLAG_VARIABLE(flags)       ((flags & 0x2) == 0x2)
    56 /** Absolute / Relative*/
     89
     90/**
     91 * Indicates whether the data is absolute (0) (based on a fixed origin) or
     92 * relative (1) (indicating the change in value from the last report). Mouse
     93 * devices usually provide relative data, while tablets usually provide
     94 * absolute data.
     95 */
    5796#define USB_HID_ITEM_FLAG_RELATIVE(flags)       ((flags & 0x4) == 0x4)
    58 /** Wrap / No Wrap */
     97
     98/** Indicates whether the data “rolls over” when reaching either the extreme
     99 * high or low value. For example, a dial that can spin freely 360 degrees
     100 * might output values from 0 to 10. If Wrap is indicated, the next value
     101 * reported after passing the 10 position in the increasing direction would be
     102 * 0.
     103 */
    59104#define USB_HID_ITEM_FLAG_WRAP(flags)           ((flags & 0x8) == 0x8)
     105
     106/**
     107 * Indicates whether the raw data from the device has been processed in some
     108 * way, and no longer represents a linear relationship between what is
     109 * measured and the data that is reported.
     110 */
    60111#define USB_HID_ITEM_FLAG_LINEAR(flags)         ((flags & 0x10) == 0x10)
     112
     113/**
     114 * Indicates whether the control has a preferred state to which it will return
     115 * when the user is not physically interacting with the control. Push buttons
     116 * (as opposed to toggle buttons) and self- centering joysticks are examples.
     117 */
    61118#define USB_HID_ITEM_FLAG_PREFERRED(flags)      ((flags & 0x20) == 0x20)
     119
     120/**
     121 * Indicates whether the control has a state in which it is not sending
     122 * meaningful data. One possible use of the null state is for controls that
     123 * require the user to physically interact with the control in order for it to
     124 * report useful data.
     125 */
    62126#define USB_HID_ITEM_FLAG_POSITION(flags)       ((flags & 0x40) == 0x40)
     127
     128/**
     129 * Indicates whether the Feature or Output control's value should be changed
     130 * by the host or not.  Volatile output can change with or without host
     131 * interaction. To avoid synchronization problems, volatile controls should be
     132 * relative whenever possible.
     133 */
    63134#define USB_HID_ITEM_FLAG_VOLATILE(flags)       ((flags & 0x80) == 0x80)
     135
     136/**
     137 * Indicates that the control emits a fixed-size stream of bytes. The contents
     138 * of the data field are determined by the application. The contents of the
     139 * buffer are not interpreted as a single numeric quantity. Report data
     140 * defined by a Buffered Bytes item must be aligned on an 8-bit boundary.
     141 */
    64142#define USB_HID_ITEM_FLAG_BUFFERED(flags)       ((flags & 0x100) == 0x100)
    65143
     144/*---------------------------------------------------------------------------*/
     145
    66146/* MAIN ITEMS */
    67 #define USB_HID_TAG_CLASS_MAIN                          0x0
    68 #define USB_HID_REPORT_TAG_INPUT                        0x8
    69 #define USB_HID_REPORT_TAG_OUTPUT                       0x9
    70 #define USB_HID_REPORT_TAG_FEATURE                      0xB
     147
     148/**
     149 * Main items are used to either define or group certain types of data fields
     150 * within a Report descriptor.
     151 */
     152#define USB_HID_TAG_CLASS_MAIN                  0x0
     153
     154/**
     155 * An Input item describes information about the data provided by one or more
     156 * physical controls. An application can use this information to interpret the
     157 * data provided by the device. All data fields defined in a single item share
     158 * an identical data format.
     159 */
     160#define USB_HID_REPORT_TAG_INPUT                0x8
     161
     162/**
     163 * The Output item is used to define an output data field in a report. This
     164 * item is similar to an Input item except it describes data sent to the
     165 * device—for example, LED states.
     166 */
     167#define USB_HID_REPORT_TAG_OUTPUT               0x9
     168
     169/**
     170 * Feature items describe device configuration information that can be sent to
     171 * the device.
     172 */
     173#define USB_HID_REPORT_TAG_FEATURE              0xB
     174
     175/**
     176 * A Collection item identifies a relationship between two or more data
     177 * (Input, Output, or Feature.)
     178 */
    71179#define USB_HID_REPORT_TAG_COLLECTION           0xA
     180
     181/**
     182 * While the Collection item opens a collection of data, the End Collection
     183 * item closes a collection.
     184 */
    72185#define USB_HID_REPORT_TAG_END_COLLECTION       0xC
    73186
     187/*---------------------------------------------------------------------------*/
     188
    74189/* GLOBAL ITEMS */
    75 #define USB_HID_TAG_CLASS_GLOBAL                        0x1
     190
     191/**
     192 * Global items describe rather than define data from a control.
     193 */
     194#define USB_HID_TAG_CLASS_GLOBAL                0x1
     195
     196/**
     197 * Unsigned integer specifying the current Usage Page. Since a usage are 32
     198 * bit values, Usage Page items can be used to conserve space in a report
     199 * descriptor by setting the high order 16 bits of a subsequent usages. Any
     200 * usage that follows which is defines 16 bits or less is interpreted as a
     201 * Usage ID and concatenated with the Usage Page to form a 32 bit Usage.
     202 */
    76203#define USB_HID_REPORT_TAG_USAGE_PAGE           0x0
     204
     205/**
     206 * Extent value in logical units. This is the minimum value that a variable
     207 * or array item will report. For example, a mouse reporting x position values
     208 * from 0 to 128 would have a Logical Minimum of 0 and a Logical Maximum of
     209 * 128.
     210 */
    77211#define USB_HID_REPORT_TAG_LOGICAL_MINIMUM      0x1
     212
     213/**
     214 * Extent value in logical units. This is the maximum value that a variable
     215 * or array item will report.
     216 */
    78217#define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM      0x2
    79 #define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3
    80 #define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4
     218
     219/**
     220 * Minimum value for the physical extent of a variable item. This represents
     221 * the Logical Minimum with units applied to it.
     222 */
     223#define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM     0x3
     224
     225/**
     226 * Maximum value for the physical extent of a variable item.
     227 */
     228#define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM     0x4
     229
     230/**
     231 * Value of the unit exponent in base 10. See the table later in this section
     232 * for more information.
     233 */
    81234#define USB_HID_REPORT_TAG_UNIT_EXPONENT        0x5
    82 #define USB_HID_REPORT_TAG_UNIT                         0x6
     235
     236/**
     237 * Unit values.
     238 */
     239#define USB_HID_REPORT_TAG_UNIT                 0x6
     240
     241/**
     242 * Unsigned integer specifying the size of the report fields in bits. This
     243 * allows the parser to build an item map for the report handler to use.
     244 */
    83245#define USB_HID_REPORT_TAG_REPORT_SIZE          0x7
     246
     247/**
     248 * Unsigned value that specifies the Report ID. If a Report ID tag is used
     249 * anywhere in Report descriptor, all data reports for the device are preceded
     250 * by a single byte ID field. All items succeeding the first Report ID tag but
     251 * preceding a second Report ID tag are included in a report prefixed by a
     252 * 1-byte ID. All items succeeding the second but preceding a third Report ID
     253 * tag are included in a second report prefixed by a second ID, and so on.
     254 */
    84255#define USB_HID_REPORT_TAG_REPORT_ID            0x8
     256
     257/**
     258 * Unsigned integer specifying the number of data fields for the item;
     259 * determines how many fields are included in the report for this particular
     260 * item (and consequently how many bits are added to the report).
     261 */
    85262#define USB_HID_REPORT_TAG_REPORT_COUNT         0x9
    86 #define USB_HID_REPORT_TAG_PUSH                         0xA
    87 #define USB_HID_REPORT_TAG_POP                          0xB
    88 
     263
     264/**
     265 * Places a copy of the global item state table on the stack.
     266 */
     267#define USB_HID_REPORT_TAG_PUSH                 0xA
     268
     269/**
     270 * Replaces the item state table with the top structure from the stack.
     271 */
     272#define USB_HID_REPORT_TAG_POP                  0xB
     273
     274/*---------------------------------------------------------------------------*/
    89275
    90276/* LOCAL ITEMS */
    91 #define USB_HID_TAG_CLASS_LOCAL                                 0x2
    92 #define USB_HID_REPORT_TAG_USAGE                                0x0
    93 #define USB_HID_REPORT_TAG_USAGE_MINIMUM                0x1
    94 #define USB_HID_REPORT_TAG_USAGE_MAXIMUM                0x2
    95 #define USB_HID_REPORT_TAG_DESIGNATOR_INDEX             0x3
     277
     278/**
     279 * Local item tags define characteristics of controls. These items do not
     280 * carry over to the next Main item. If a Main item defines more than one
     281 * control, it may be preceded by several similar Local item tags. For
     282 * example, an Input item may have several Usage tags associated with it, one
     283 * for each control.
     284 */
     285#define USB_HID_TAG_CLASS_LOCAL                 0x2
     286
     287/**
     288 * Usage index for an item usage; represents a suggested usage for the item or
     289 * collection. In the case where an item represents multiple controls, a Usage
     290 * tag may suggest a usage for every variable or element in an array.
     291 */
     292#define USB_HID_REPORT_TAG_USAGE                0x0
     293
     294/**
     295 * Defines the starting usage associated with an array or bitmap.
     296 */
     297#define USB_HID_REPORT_TAG_USAGE_MINIMUM        0x1
     298
     299/**
     300 * Defines the ending usage associated with an array or bitmap.
     301 */
     302#define USB_HID_REPORT_TAG_USAGE_MAXIMUM        0x2
     303
     304/**
     305 * Determines the body part used for a control. Index points to a designator
     306 * in the Physical descriptor.
     307 */
     308#define USB_HID_REPORT_TAG_DESIGNATOR_INDEX     0x3
     309
     310/**
     311 * Defines the index of the starting designator associated with an array or
     312 * bitmap.
     313 */
    96314#define USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM   0x4
     315
     316/**
     317 * Defines the index of the ending designator associated with an array or
     318 * bitmap.
     319 */
    97320#define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM   0x5
    98 #define USB_HID_REPORT_TAG_STRING_INDEX                 0x7
    99 #define USB_HID_REPORT_TAG_STRING_MINIMUM               0x8
    100 #define USB_HID_REPORT_TAG_STRING_MAXIMUM               0x9
    101 #define USB_HID_REPORT_TAG_DELIMITER                    0xA
     321
     322/**
     323 * String index for a String descriptor; allows a string to be associated with
     324 * a particular item or control.
     325 */
     326#define USB_HID_REPORT_TAG_STRING_INDEX         0x7
     327
     328/**
     329 * Specifies the first string index when assigning a group of sequential
     330 * strings to controls in an array or bitmap.
     331 */
     332#define USB_HID_REPORT_TAG_STRING_MINIMUM       0x8
     333
     334/**
     335 * Specifies the last string index when assigning a group of sequential
     336 * strings to controls in an array or bitmap.
     337 */
     338#define USB_HID_REPORT_TAG_STRING_MAXIMUM       0x9
     339
     340/**
     341 * Defines the beginning or end of a set of local items (1 = open set, 0 =
     342 * close set).
     343 *
     344 * Usages other than the first (most preferred) usage defined are not
     345 * accessible by system software.
     346 */
     347#define USB_HID_REPORT_TAG_DELIMITER            0xA
     348
     349/*---------------------------------------------------------------------------*/
    102350
    103351#endif

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

    r88be3a0b r6bfaab5  
    2727 */
    2828
    29 /** @addtogroup libusbhid
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    … …  
    3333 * USB HID report descriptor and report data parser
    3434 */
    35 #ifndef LIBUSBHID_HIDDESCRIPTOR_H_
    36 #define LIBUSBHID_HIDDESCRIPTOR_H_
     35#ifndef LIBUSB_HIDDESCRIPTOR_H_
     36#define LIBUSB_HIDDESCRIPTOR_H_
    3737
    3838#include <stdint.h>
    … …  
    4242#include <usb/hid/hidtypes.h>
    4343
     44int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
     45                const uint8_t *data, size_t size);
    4446
    45 /*
    46  * Descriptor parser functions
    47  */
    48 
    49 /** */
    50 int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
    51                                     const uint8_t *data, size_t size);
    52 
    53 /** */
    5447void usb_hid_free_report(usb_hid_report_t *report);
    5548
    56 /** */
    5749void usb_hid_descriptor_print(usb_hid_report_t *report);
    5850
     51int usb_hid_report_init(usb_hid_report_t *report);
    5952
    60 int usb_hid_report_init(usb_hid_report_t *report);
    61 int usb_hid_report_append_fields(usb_hid_report_t *report,
    62                                  usb_hid_report_item_t *report_item);
     53int usb_hid_report_append_fields(usb_hid_report_t *report,
     54                usb_hid_report_item_t *report_item);
    6355
    64 usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type);
    65 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
    66                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    67 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    68                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    69 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    70                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    71 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    72                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     56usb_hid_report_description_t * usb_hid_report_find_description(
     57                const usb_hid_report_t *report, uint8_t report_id,
     58                usb_hid_report_type_t type);
     59
     60int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
     61                size_t item_size, usb_hid_report_item_t *report_item,
     62                usb_hid_report_path_t *usage_path);
     63
     64int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data,
     65                size_t item_size, usb_hid_report_item_t *report_item,
     66                usb_hid_report_path_t *usage_path);
     67
     68int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data,
     69                size_t item_size, usb_hid_report_item_t *report_item,
     70                usb_hid_report_path_t *usage_path);
     71
     72int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data,
     73                size_t item_size, usb_hid_report_item_t *report_item,
     74                usb_hid_report_path_t *usage_path);
    7375
    7476void usb_hid_descriptor_print_list(link_t *head);
     77
    7578void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
     79
    7680void usb_hid_free_report_list(link_t *head);
    77 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
     81
     82usb_hid_report_item_t *usb_hid_report_item_clone(
     83                const usb_hid_report_item_t *item);
     84
    7885uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
    7986
    80 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path);
     87usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t*report,
     88                usb_hid_report_path_t *cmp_path);
     89
     90
    8191#endif
    8292/**

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

    r88be3a0b r6bfaab5  
    4747 * Input report parser functions
    4848 */
    49 /** */
    50 int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
    51                          size_t size, uint8_t *report_id);
    52 
    53 /** */
    54 size_t usb_hid_report_input_length(const usb_hid_report_t *report,
    55         usb_hid_report_path_t *path, int flags);
     49int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
     50                size_t size, uint8_t *report_id);
    5651
    5752/*
    5853 * Output report parser functions
    5954 */
    60 /** Allocates output report buffer*/
    6155uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
    62                                uint8_t report_id);
     56                uint8_t report_id);
    6357
    64 /** Frees output report buffer*/
    6558void usb_hid_report_output_free(uint8_t *output);
    6659
    67 /** Returns size of output for given usage path */
    68 size_t usb_hid_report_output_size(usb_hid_report_t *report,
    69                                   usb_hid_report_path_t *path, int flags);
     60size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
     61                usb_hid_report_type_t type);
    7062
    71 /** Makes the output report buffer by translated given data */
    72 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
    73                                     uint8_t *buffer, size_t size);
     63size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
     64                usb_hid_report_type_t type);
    7465
    75 /** */
    76 usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
    77                                                    usb_hid_report_field_t *field,
    78                                                    usb_hid_report_path_t *path,
    79                                                    int flags,
    80                                                    usb_hid_report_type_t type);
    8166
    82 /** */
    83 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report,
    84                                      uint8_t report_id,
    85                                      usb_hid_report_type_t type);
     67int usb_hid_report_output_translate(usb_hid_report_t *report,
     68                uint8_t report_id, uint8_t *buffer, size_t size);
     69
     70
     71/*
     72 * Report descriptor structure observing functions
     73 */
     74usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
     75                usb_hid_report_field_t *field, usb_hid_report_path_t *path,
     76                int flags, usb_hid_report_type_t type);
     77
     78uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report,
     79                uint8_t report_id, usb_hid_report_type_t type);
    8680
    8781#endif

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

    r88be3a0b r6bfaab5  
    2727 */
    2828
    29 /** @addtogroup libusbhid
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    … …  
    3333 * USB HID report descriptor and report data parser
    3434 */
    35 #ifndef LIBUSBHID_HIDPATH_H_
    36 #define LIBUSBHID_HIDPATH_H_
     35#ifndef LIBUSB_HIDPATH_H_
     36#define LIBUSB_HIDPATH_H_
    3737
    3838#include <usb/hid/hidparser.h>
    … …  
    4040#include <adt/list.h>
    4141
     42
     43/*---------------------------------------------------------------------------*/
     44/*
     45 * Flags of usage paths comparison modes.
     46 *
     47 */
     48/** Wanted usage path must be exactly the same as the searched one.  This
     49 * option cannot be combined with the others.
     50 */
     51#define USB_HID_PATH_COMPARE_STRICT             0
     52
    4253/**
    43  * Description of path of usage pages and usages in report descriptor
     54 * Wanted usage path must be the suffix in the searched one.
    4455 */
    45 /** Wanted usage path must be exactly the same as the searched one */
    46 #define USB_HID_PATH_COMPARE_STRICT             0
    47 /** Wanted usage path must be the suffix in the searched one */
    4856#define USB_HID_PATH_COMPARE_END                1
    49 /** */
     57
     58/**
     59 * Only usage page are compared along the usage path.  This option can be
     60 * combined with others.
     61 */
    5062#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    2
    51 /** Searched usage page must be prefix of the other one */
     63
     64/**
     65 * Searched usage page must be prefix of the other one.
     66 */
    5267#define USB_HID_PATH_COMPARE_BEGIN              4
    53 /** Searched couple of usage page and usage can be anywhere in usage path */
     68
     69/**
     70 * Searched couple of usage page and usage can be anywhere in usage path.
     71 * This option is deprecated.
     72 */
    5473#define USB_HID_PATH_COMPARE_ANYWHERE           8
    5574
    56 
    57 /** Collection usage path structure */
     75/*----------------------------------------------------------------------------*/
     76/**
     77 * Item of usage path structure. Last item of linked list describes one item
     78 * in report, the others describe superior Collection tags. Usage and Usage
     79 * page of report item can be changed due to data in report.
     80 */
    5881typedef struct {
    59         /** */
     82        /** Usage page of report item. Zero when usage page can be changed. */
    6083        uint32_t usage_page;
    61         /** */ 
     84        /** Usage of report item. Zero when usage can be changed. */   
    6285        uint32_t usage;
    6386
     87        /** Attribute of Collection tag in report descriptor*/
    6488        uint8_t flags;
    65         /** */
     89
     90        /** Linked list structure*/
    6691        link_t link;
    6792} usb_hid_report_usage_path_t;
    6893
    69 /** */
     94
     95/*---------------------------------------------------------------------------*/
     96/**
     97 * USB HID usage path structure.
     98 * */
    7099typedef struct {
    71         /** */ 
     100        /** Length of usage path */     
    72101        int depth;     
     102
     103        /** Report id. Zero is reserved and means that report id is not used.
     104         * */
    73105        uint8_t report_id;
    74106       
    75         /** */ 
     107        /** Linked list structure. */   
    76108        link_t link; /* list */
    77109
    78         link_t head; /* head of list of usage paths */
     110        /** Head of the list of usage path items. */
     111        link_t head;
    79112
    80113} usb_hid_report_path_t;
    81114
    82 /** */
     115/*---------------------------------------------------------------------------*/
    83116usb_hid_report_path_t *usb_hid_report_path(void);
    84117
    85 /** */
    86118void usb_hid_report_path_free(usb_hid_report_path_t *path);
    87119
    88 /** */
    89 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path,
    90                                       uint8_t report_id);
     120int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path,
     121                uint8_t report_id);
    91122
    92 /** */
    93123int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
    94                                     int32_t usage_page, int32_t usage);
     124                int32_t usage_page, int32_t usage);
    95125
    96 /** */
    97126void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
    98127
    99 /** */
    100128void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
    101129
    102 /** */
    103130void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path,
    104                                   int32_t tag, int32_t data);
     131                int32_t tag, int32_t data);
    105132
    106 /** */
    107 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path,
    108                                       usb_hid_report_path_t *path, int flags);
     133int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path,
     134                usb_hid_report_path_t *path, int flags);
    109135
    110 /** */
    111 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path);
     136usb_hid_report_path_t *usb_hid_report_path_clone(
     137                usb_hid_report_path_t *usage_path);
    112138
    113139void usb_hid_print_usage_path(usb_hid_report_path_t *path);

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

    r88be3a0b r6bfaab5  
    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/hidtypes.h

    r88be3a0b r6bfaab5  
    2727 */
    2828
    29 /** @addtogroup libusbhid
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    3232/** @file
    33  * USB HID report descriptor and report data parser
    34  */
    35 #ifndef LIBUSBHID_HIDTYPES_H_
    36 #define LIBUSBHID_HIDTYPES_H_
     33 * Basic data structures for USB HID Report descriptor and report parser.
     34 */
     35#ifndef LIBUSB_HIDTYPES_H_
     36#define LIBUSB_HIDTYPES_H_
    3737
    3838#include <stdint.h>
    3939#include <adt/list.h>
    4040
    41 #define USB_HID_MAX_USAGES      20
    42 
    43 #define USB_HID_UINT32_TO_INT32(x, size)        ((((x) & (1 << ((size) - 1))) != 0) ? -(~(x - 1) & ((1 << size) - 1)) : (x)) //(-(~((x) - 1)))
    44 #define USB_HID_INT32_TO_UINT32(x, size)        (((x) < 0 ) ? ((1 << (size)) + (x)) : (x))
    45 
    46 
     41/*---------------------------------------------------------------------------*/
     42
     43/**
     44 * Maximum amount of specified usages for one report item
     45 */
     46#define USB_HID_MAX_USAGES      0xffff
     47
     48/**
     49 * Converts integer from unsigned two's complement format format to signed
     50 * one.
     51 *
     52 * @param x Number to convert
     53 * @param size Length of the unsigned number in bites
     54 * @return signed int
     55 */
     56#define USB_HID_UINT32_TO_INT32(x, size)        \
     57        ((((x) & (1 << ((size) - 1))) != 0) ?   \
     58         -(~((x) - 1) & ((1 << size) - 1)) : (x))
     59
     60/**
     61 * Convert integer from signed format to unsigned. If number is negative the
     62 * two's complement format is used.
     63 *
     64 * @param x Number to convert
     65 * @param size Length of result number in bites
     66 * @return unsigned int
     67 */
     68#define USB_HID_INT32_TO_UINT32(x, size)        \
     69        (((x) < 0 ) ? ((1 << (size)) + (x)) : (x))
     70
     71/*---------------------------------------------------------------------------*/
     72
     73/**
     74 * Enum of report types
     75 */
    4776typedef enum {
     77        /** Input report. Data are sent from device to system */
    4878        USB_HID_REPORT_TYPE_INPUT = 1,
     79
     80        /** Output report. Data are sent from system to device */
    4981        USB_HID_REPORT_TYPE_OUTPUT = 2,
     82
     83        /** Feature report. Describes device configuration information that
     84         * can be sent to the device */
    5085        USB_HID_REPORT_TYPE_FEATURE = 3
    5186} usb_hid_report_type_t;
    5287
    53 
     88/*---------------------------------------------------------------------------*/
     89
     90/**
     91 * Description of all reports described in one report descriptor.
     92 */
    5493typedef struct {
    55         /** */
     94        /** Count of available reports. */
    5695        int report_count;
    57         link_t reports;         /** list of usb_hid_report_description_t */
    58 
     96
     97        /** Head of linked list of description of reports. */
     98        link_t reports;
     99
     100        /** Head of linked list of all used usage/collection paths. */
    59101        link_t collection_paths;
     102
     103        /** Length of list of usage paths. */
    60104        int collection_paths_count;
    61105
     106        /** Flag whether report ids are used. */
    62107        int use_report_ids;
     108
     109        /** Report id of last parsed report. */
    63110        uint8_t last_report_id;
    64111       
    65112} usb_hid_report_t;
    66 
     113/*---------------------------------------------------------------------------*/
     114
     115/**
     116 * Description of one concrete report
     117 */
    67118typedef struct {
     119        /** Report id. Zero when no report id is used. */
    68120        uint8_t report_id;
     121
     122        /** Type of report */
    69123        usb_hid_report_type_t type;
    70124
     125        /** Bit length of the report */
    71126        size_t bit_length;
     127
     128        /** Number of items in report */
    72129        size_t item_length;
    73130       
    74         link_t report_items;    /** list of report items (fields) */
    75 
     131        /** Linked list of report items in report */
     132        link_t report_items;
     133
     134        /** Linked list of descriptions. */
    76135        link_t link;
    77136} usb_hid_report_description_t;
    78 
     137/*---------------------------------------------------------------------------*/
     138
     139/**
     140 * Description of one field/item in report
     141 */
    79142typedef struct {
    80 
     143        /** Bit offset of the field */
    81144        int offset;
     145
     146        /** Bit size of the field */
    82147        size_t size;
    83148
     149        /** Usage page. Zero when usage page can be changed. */
    84150        uint16_t usage_page;
     151
     152        /** Usage. Zero when usage can be changed. */
    85153        uint16_t usage;
    86154
     155        /** Item's attributes */
    87156        uint8_t item_flags;
     157
     158        /** Usage/Collection path of the field. */
    88159        usb_hid_report_path_t *collection_path;
    89160
     161        /**
     162         * The lowest valid logical value (value with the device operates)
     163         */
    90164        int32_t logical_minimum;
     165
     166        /**
     167         * The greatest valid logical value
     168         */
    91169        int32_t logical_maximum;
     170
     171        /**
     172         * The lowest valid physical value (value with the system operates)
     173         */
    92174        int32_t physical_minimum;
     175
     176        /** The greatest valid physical value */
    93177        int32_t physical_maximum;
    94         uint32_t usage_minimum;
    95         uint32_t usage_maximum;
     178
     179        /** The lowest valid usage index */
     180        int32_t usage_minimum;
     181
     182        /** The greatest valid usage index */
     183        int32_t usage_maximum;
     184       
     185        /** Unit of the value */
    96186        uint32_t unit;
     187
     188        /** Unit exponent */
    97189        uint32_t unit_exponent;
    98        
    99 
     190
     191        /** Array of possible usages */
     192        uint32_t *usages;
     193
     194        /** Size of the array of usages */
     195        size_t usages_count;
     196
     197        /** Parsed value */
    100198        int32_t value;
    101199
     200        /** List to another report items */
    102201        link_t link;
    103202} usb_hid_report_field_t;
    104203
    105 
    106 
    107 /**
    108  * state table
     204/*---------------------------------------------------------------------------*/
     205
     206/**
     207 * State table for report descriptor parsing
    109208 */
    110209typedef struct {
    … …  
    112211        int32_t id;
    113212       
    114         /** */
     213        /** Extended usage page */
    115214        uint16_t extended_usage_page;
     215
     216        /** Array of usages specified for this item */
    116217        uint32_t usages[USB_HID_MAX_USAGES];
     218       
     219        /** Length of usages array */
    117220        int usages_count;
    118221
    119         /** */
     222        /** Usage page*/
    120223        uint32_t usage_page;
    121224
    122         /** */ 
    123         uint32_t usage_minimum;
    124         /** */ 
    125         uint32_t usage_maximum;
    126         /** */ 
     225        /** Minimum valid usage index */       
     226        int32_t usage_minimum;
     227       
     228        /** Maximum valid usage index */       
     229        int32_t usage_maximum;
     230       
     231        /** Minimum valid logical value */     
    127232        int32_t logical_minimum;
    128         /** */ 
     233       
     234        /** Maximum valid logical value */     
    129235        int32_t logical_maximum;
    130         /** */ 
     236
     237        /** Length of the items in bits*/       
    131238        int32_t size;
    132         /** */ 
     239
     240        /** COunt of items*/   
    133241        int32_t count;
    134         /** */ 
     242
     243        /**  Bit offset of the item in report */       
    135244        size_t offset;
    136         /** */ 
     245
     246        /** Unit exponent */   
    137247        int32_t unit_exponent;
    138         /** */ 
     248        /** Unit of the value */       
    139249        int32_t unit;
    140250
    141         /** */
     251        /** String index */
    142252        uint32_t string_index;
    143         /** */ 
     253
     254        /** Minimum valid string index */       
    144255        uint32_t string_minimum;
    145         /** */ 
     256
     257        /** Maximum valid string index */       
    146258        uint32_t string_maximum;
    147         /** */ 
     259
     260        /** The designator index */     
    148261        uint32_t designator_index;
    149         /** */ 
     262
     263        /** Minimum valid designator value*/   
    150264        uint32_t designator_minimum;
    151         /** */ 
     265
     266        /** Maximum valid designator value*/   
    152267        uint32_t designator_maximum;
    153         /** */ 
     268
     269        /** Minimal valid physical value*/     
    154270        int32_t physical_minimum;
    155         /** */ 
     271
     272        /** Maximal valid physical value */     
    156273        int32_t physical_maximum;
    157274
    158         /** */ 
     275        /** Items attributes*/ 
    159276        uint8_t item_flags;
    160277
     278        /** Report type */
    161279        usb_hid_report_type_t type;
    162280
    163281        /** current collection path*/   
    164282        usb_hid_report_path_t *usage_path;
    165         /** */ 
     283
     284        /** Unused*/   
    166285        link_t link;
    167286
    168287        int in_delimiter;
    169288} usb_hid_report_item_t;
    170 
    171 /** HID parser callbacks for IN items. */
    172 typedef struct {
    173         /** Callback for keyboard.
    174          *
    175          * @param key_codes Array of pressed key (including modifiers).
    176          * @param count Length of @p key_codes.
    177          * @param arg Custom argument.
    178          */
    179         void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg);
    180 } usb_hid_report_in_callbacks_t;
    181 
    182 
     289/*---------------------------------------------------------------------------*/
     290/**
     291 * Enum of the keyboard modifiers
     292 */
    183293typedef enum {
    184294        USB_HID_MOD_LCTRL = 0x01,
    … …  
    204314        USB_HID_MOD_RGUI
    205315};
     316/*---------------------------------------------------------------------------*/
     317
    206318
    207319#endif

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

    r88be3a0b r6bfaab5  
    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/include/usb/hid/usages/core.h

    r88be3a0b r6bfaab5  
    6767} usb_hidut_usage_generic_desktop_t;
    6868
     69typedef enum {
     70        USB_HIDUT_USAGE_CONSUMER_CONSUMER_CONTROL = 1
     71} usb_hidut_usage_consumer_t;
     72
    6973
    7074#endif

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

    r88be3a0b r6bfaab5  
    4141#include <assert.h>
    4242
    43 
     43/*---------------------------------------------------------------------------*/
     44/*
     45 * Constants defining current parsing mode for correct parsing of the set of
     46 * local tags (usage) enclosed in delimter tags.
     47 */
     48/**
     49 * Second delimiter tag was read. The set of local items (usage) ended.
     50 */
    4451#define OUTSIDE_DELIMITER_SET   0
     52
     53/**
     54 * First delimiter tag was read. The set of local items (usage) started.
     55 */
    4556#define START_DELIMITER_SET     1
     57
     58/**
     59 * Parser is in the set of local items.
     60 */
    4661#define INSIDE_DELIMITER_SET    2
     62
     63/*---------------------------------------------------------------------------*/
    4764       
    4865/** The new report item flag. Used to determine when the item is completly
    … …  
    6178#define USB_HID_UNKNOWN_TAG             -99
    6279
    63 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path)
    64 {
    65         /* find or append current collection path to the list */
    66         link_t *path_it = report->collection_paths.next;
     80/*---------------------------------------------------------------------------*/
     81/**
     82 * Checks if given collection path is already present in report structure and
     83 * inserts it if not.
     84 *
     85 * @param report Report structure
     86 * @param cmp_path The collection path
     87 * @return Pointer to the result collection path in report structure.
     88 * @retval NULL If some error occurs
     89 */
     90usb_hid_report_path_t *usb_hid_report_path_try_insert(
     91                usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) {
     92       
     93        link_t *path_it = report->collection_paths.prev->next;
    6794        usb_hid_report_path_t *path = NULL;
     95       
     96        if((report == NULL) || (cmp_path == NULL)) {
     97                return NULL;
     98        }
     99       
    68100        while(path_it != &report->collection_paths) {
    69                 path = list_get_instance(path_it, usb_hid_report_path_t, link);
    70                
    71                 if(usb_hid_report_compare_usage_path(path, cmp_path, USB_HID_PATH_COMPARE_STRICT) == EOK){
     101                path = list_get_instance(path_it, usb_hid_report_path_t,
     102                                link);
     103               
     104                if(usb_hid_report_compare_usage_path(path, cmp_path,
     105                                        USB_HID_PATH_COMPARE_STRICT) == EOK){
    72106                        break;
    73107                }                       
    … …  
    75109        }
    76110        if(path_it == &report->collection_paths) {
    77                 path = usb_hid_report_path_clone(cmp_path);                     
     111                path = usb_hid_report_path_clone(cmp_path);
     112                if(path == NULL) {
     113                        return NULL;
     114                }
    78115                list_append(&path->link, &report->collection_paths);                                   
    79116                report->collection_paths_count++;
    … …  
    82119        }
    83120        else {
    84                 return list_get_instance(path_it, usb_hid_report_path_t, link);
    85         }
    86 }
    87 
     121                return list_get_instance(path_it, usb_hid_report_path_t,
     122                                link);
     123        }
     124}
     125
     126/*---------------------------------------------------------------------------*/
    88127/**
    89128 * Initialize the report descriptor parser structure
    … …  
    91130 * @param parser Report descriptor parser structure
    92131 * @return Error code
     132 * @retval EINVAL If no report structure was given
     133 * @retval EOK If report structure was successfully initialized
    93134 */
    94135int usb_hid_report_init(usb_hid_report_t *report)
    … …  
    106147}
    107148
    108 
    109 /*
    110  *
    111  *
    112  */
    113 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)
    114 {
     149/*---------------------------------------------------------------------------*/
     150
     151/**
     152 *
     153 *
     154 * @param report Report structure in which the new report items should be
     155 *               stored
     156 * @param report_item Current report descriptor's parsing state table
     157 * @return Error code
     158 * @retval EOK If all fields were successfully append to report
     159 * @retval EINVAL If invalid parameters (NULL) was given
     160 * @retval ENOMEM If there is no memmory to store new report description
     161 *
     162 */
     163int usb_hid_report_append_fields(usb_hid_report_t *report,
     164                usb_hid_report_item_t *report_item) {
     165
    115166        usb_hid_report_field_t *field;
    116167        int i;
    117168
    118         for(i=0; i<report_item->usages_count; i++){
    119                 usb_log_debug("usages (%d) - %x\n", i, report_item->usages[i]);
    120         }
    121 
     169        uint32_t *usages;
     170        int usages_used=0;
     171
     172        if((report == NULL) || (report_item == NULL)) {
     173                return EINVAL;
     174        }
     175
     176        if(report_item->usages_count > 0){
     177                usages = malloc(sizeof(int32_t) * report_item->usages_count);
     178                memcpy(usages, report_item->usages, sizeof(int32_t) *
     179                                report_item->usages_count);
     180        }
     181        else {
     182                usages = NULL;
     183        }
     184       
    122185        usb_hid_report_path_t *path = report_item->usage_path; 
    123186        for(i=0; i<report_item->count; i++){
    … …  
    133196                field->physical_maximum = report_item->physical_maximum;
    134197
    135                 field->usage_minimum = report_item->usage_minimum;
    136                 field->usage_maximum = report_item->usage_maximum;
    137                 if(report_item->extended_usage_page != 0){
    138                         field->usage_page = report_item->extended_usage_page;
     198                if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){
     199                        /*
     200                        Store usage array. The Correct Usage Page and Usage is
     201                        depending on data in report and will be filled later
     202                        */
     203                        field->usage = 0;
     204                        field->usage_page = 0; //report_item->usage_page;
     205
     206                        field->usages_count = report_item->usages_count;
     207                        field->usages = usages;
     208                        usages_used = 1;
    139209                }
    140210                else {
    141                         field->usage_page = report_item->usage_page;
    142                 }
    143 
    144                 if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
    145                         uint32_t usage;
    146                         if(i < report_item->usages_count){
     211
     212                        /* Fill the correct Usage and Usage Page */
     213                        int32_t usage;
     214                        if(i < report_item->usages_count) {
    147215                                usage = report_item->usages[i];
    148216                        }
    149217                        else {
    150                                 usage = report_item->usages[report_item->usages_count - 1];
     218                                usage = report_item->usages[
     219                                        report_item->usages_count- 1];
    151220                        }
    152221
    153                                                
    154                         if((usage & 0xFFFF0000) != 0){
    155                                 field->usage_page = (usage >> 16);                                     
    156                                 field->usage = (usage & 0xFFFF);
     222                        if(USB_HID_IS_EXTENDED_USAGE(usage)){
     223                                field->usage = USB_HID_EXTENDED_USAGE(usage);
     224                                field->usage_page =
     225                                        USB_HID_EXTENDED_USAGE_PAGE(usage);
    157226                        }
    158227                        else {
     228                                // should not occur
    159229                                field->usage = usage;
     230                                field->usage_page = report_item->usage_page;
    160231                        }
    161 
    162                        
    163                 }       
    164 
    165                 if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
    166                         field->usage = report_item->usage_minimum + i;                                 
    167                 }
    168                
    169                 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, field->usage_page);
    170                 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, field->usage);
    171 
    172                 field->collection_path = usb_hid_report_path_try_insert(report, path);
     232                }
     233               
     234                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL,
     235                                field->usage_page);
     236                usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL,
     237                                field->usage);
     238
     239                field->collection_path =
     240                        usb_hid_report_path_try_insert(report, path);
    173241
    174242                field->size = report_item->size;
    175243               
    176                 size_t offset_byte = (report_item->offset + (i * report_item->size)) / 8;
    177                 size_t offset_bit = 8 - ((report_item->offset + (i * report_item->size)) % 8) - report_item->size;
     244                size_t offset_byte = (report_item->offset + (i *
     245                        report_item->size)) / 8;
     246
     247                size_t offset_bit = 8 - ((report_item->offset + (i *
     248                        report_item->size)) % 8) - report_item->size;
    178249
    179250                field->offset = 8 * offset_byte + offset_bit;
    … …  
    186257                /* find the right report list*/
    187258                usb_hid_report_description_t *report_des;
    188                 report_des = usb_hid_report_find_description(report, report_item->id, report_item->type);
     259                report_des = usb_hid_report_find_description(report,
     260                        report_item->id, report_item->type);
     261               
    189262                if(report_des == NULL){
    190                         report_des = malloc(sizeof(usb_hid_report_description_t));
    191                         memset(report_des, 0, sizeof(usb_hid_report_description_t));
     263                        report_des = malloc(
     264                                sizeof(usb_hid_report_description_t));
     265                        if(report_des == NULL) {
     266                                return ENOMEM;
     267                        }
     268
     269                        memset(report_des, 0,
     270                                sizeof(usb_hid_report_description_t));
    192271
    193272                        report_des->type = report_item->type;
    194273                        report_des->report_id = report_item->id;
     274                        if(report_des->report_id != 0) {
     275                                /* set up the bit length by report_id field */
     276                                report_des->bit_length = 8;
     277                        }
     278
    195279                        list_initialize (&report_des->link);
    196280                        list_initialize (&report_des->report_items);
    … …  
    209293        }
    210294
     295        // free only when not used!!!
     296        if(usages && usages_used == 0) {
     297                free(usages);
     298        }
    211299
    212300        return EOK;
    213301}
    214 
    215 usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
    216 {
     302/*---------------------------------------------------------------------------*/
     303/**
     304 * Finds description of report with given report_id and of given type in
     305 * opaque report structure.
     306 *
     307 * @param report Opaque structure containing the parsed report descriptor
     308 * @param report_id ReportId of report we are searching
     309 * @param type Type of report we are searching
     310 * @return Pointer to the particular report description
     311 * @retval NULL If no description is founded
     312 */
     313usb_hid_report_description_t * usb_hid_report_find_description(
     314                const usb_hid_report_t *report, uint8_t report_id,
     315                usb_hid_report_type_t type) {
     316
    217317        link_t *report_it = report->reports.next;
    218318        usb_hid_report_description_t *report_des = NULL;
    219319       
    220320        while(report_it != &report->reports) {
    221                 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
    222 
    223                 if((report_des->report_id == report_id) && (report_des->type == type)){
     321                report_des = list_get_instance(report_it,
     322                                usb_hid_report_description_t, link);
     323
     324                if((report_des->report_id == report_id) &&
     325                   (report_des->type == type)) {
    224326                        return report_des;
    225327                }
    … …  
    230332        return NULL;
    231333}
     334/*---------------------------------------------------------------------------*/
    232335
    233336/** Parse HID report descriptor.
    … …  
    236339 * @param data Data describing the report.
    237340 * @return Error code.
     341 * @retval ENOMEM If no more memmory is available
     342 * @retval EINVAL If invalid data are founded
     343 * @retval EOK If report descriptor is successfully parsed
    238344 */
    239345int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
    … …  
    286392                       
    287393                        ret = usb_hid_report_parse_tag(tag,class,data+i+1,
    288                                                        item_size,report_item, usage_path);
     394                                item_size,report_item, usage_path);
     395
    289396                        switch(ret){
    290                                 case USB_HID_NEW_REPORT_ITEM:
    291                                         // store report item to report and create the new one
    292                                         // store current collection path
    293                                         report_item->usage_path = usage_path;
     397                        case USB_HID_NEW_REPORT_ITEM:
     398                                /* store report item to report and create the
     399                                 * new one store current collection path
     400                                 */
     401                                report_item->usage_path = usage_path;
    294402                                       
    295                                         usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);   
    296                                         if(report_item->id != 0){
    297                                                 report->use_report_ids = 1;
    298                                         }
     403                                usb_hid_report_path_set_report_id(
     404                                     report_item->usage_path, report_item->id);
     405                               
     406                                if(report_item->id != 0){
     407                                        report->use_report_ids = 1;
     408                                }
    299409                                       
    300                                         switch(tag) {
    301                                                 case USB_HID_REPORT_TAG_INPUT:
    302                                                         report_item->type = USB_HID_REPORT_TYPE_INPUT;
    303                                                         report_item->offset = offset_input;
    304                                                         offset_input += report_item->count * report_item->size;
    305                                                         break;
    306                                                 case USB_HID_REPORT_TAG_OUTPUT:
    307                                                         report_item->type = USB_HID_REPORT_TYPE_OUTPUT;
    308                                                         report_item->offset = offset_output;
    309                                                         offset_output += report_item->count * report_item->size;
    310 
    311                                                         break;
    312                                                 case USB_HID_REPORT_TAG_FEATURE:
    313                                                         report_item->type = USB_HID_REPORT_TYPE_FEATURE;
    314                                                         report_item->offset = offset_feature;
    315                                                         offset_feature += report_item->count * report_item->size;
    316                                                         break;
    317                                                 default:
    318                                                     usb_log_debug("\tjump over - tag %X\n", tag);
    319                                                     break;
    320                                         }
     410                                switch(tag) {
     411                                case USB_HID_REPORT_TAG_INPUT:
     412                                        report_item->type =
     413                                            USB_HID_REPORT_TYPE_INPUT;
     414
     415                                        report_item->offset = offset_input;
     416                                        offset_input += report_item->count *
     417                                            report_item->size;
     418                                        break;
     419       
     420                                case USB_HID_REPORT_TAG_OUTPUT:
     421                                        report_item->type =
     422                                            USB_HID_REPORT_TYPE_OUTPUT;
    321423                                       
    322                                         /*
    323                                          * append new fields to the report
    324                                          * structure                                     
    325                                          */
    326                                         usb_hid_report_append_fields(report, report_item);
    327 
    328                                         /* reset local items */
    329                                         usb_hid_report_reset_local_items (report_item);
    330 
     424                                        report_item->offset = offset_output;
     425                                        offset_output += report_item->count *
     426                                            report_item->size;
    331427                                        break;
    332 
    333                                 case USB_HID_RESET_OFFSET:
    334                                         offset_input = 0;
    335                                         offset_output = 0;
    336                                         offset_feature = 0;
    337                                         usb_hid_report_path_set_report_id (usage_path, report_item->id);
     428       
     429                                case USB_HID_REPORT_TAG_FEATURE:
     430                                        report_item->type =
     431                                            USB_HID_REPORT_TYPE_FEATURE;
     432
     433                                        report_item->offset = offset_feature;
     434                                        offset_feature += report_item->count *
     435                                                report_item->size;
    338436                                        break;
    339 
    340                                 case USB_HID_REPORT_TAG_PUSH:
    341                                         // push current state to stack
    342                                         new_report_item = usb_hid_report_item_clone(report_item);
    343                                         usb_hid_report_path_t *tmp_path = usb_hid_report_path_clone(usage_path);
    344                                         new_report_item->usage_path = tmp_path;
    345 
    346                                         list_prepend (&new_report_item->link, &stack);
    347                                         break;
    348                                 case USB_HID_REPORT_TAG_POP:
    349                                         // restore current state from stack
    350                                         if(list_empty (&stack)) {
    351                                                 return EINVAL;
    352                                         }
    353                                         free(report_item);
     437       
     438                                default:
     439                                        usb_log_debug2(
     440                                            "\tjump over - tag %X\n", tag);
     441                                        break;
     442                                }
     443                                       
     444                                /*
     445                                 * append new fields to the report structure                                     
     446                                 */
     447                                usb_hid_report_append_fields(report,
     448                                    report_item);
     449
     450                                /* reset local items */
     451                                usb_hid_report_reset_local_items (report_item);
     452                                break;
     453
     454                        case USB_HID_RESET_OFFSET:
     455                                offset_input = 0;
     456                                offset_output = 0;
     457                                offset_feature = 0;
     458                                usb_hid_report_path_set_report_id (usage_path,
     459                                    report_item->id);
     460                                break;
     461
     462                        case USB_HID_REPORT_TAG_PUSH:
     463                                // push current state to stack
     464                                new_report_item = usb_hid_report_item_clone(
     465                                    report_item);
     466                               
     467                                usb_hid_report_path_t *tmp_path =
     468                                    usb_hid_report_path_clone(usage_path);
     469
     470                                new_report_item->usage_path = tmp_path;
     471
     472                                list_prepend (&new_report_item->link, &stack);
     473                                break;
     474                        case USB_HID_REPORT_TAG_POP:
     475                                // restore current state from stack
     476                                if(list_empty (&stack)) {
     477                                        return EINVAL;
     478                                }
     479                                free(report_item);
    354480                                               
    355                                         report_item = list_get_instance(stack.next, usb_hid_report_item_t, link);
     481                                report_item = list_get_instance(stack.next,
     482                                    usb_hid_report_item_t, link);
    356483                                       
    357                                         usb_hid_report_usage_path_t *tmp_usage_path;
    358                                         tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link);
     484                                usb_hid_report_usage_path_t *tmp_usage_path;
     485                                tmp_usage_path = list_get_instance(
     486                                    report_item->usage_path->link.prev,
     487                                    usb_hid_report_usage_path_t, link);
    359488                                       
    360                                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
    361                                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
    362 
    363                                         usb_hid_report_path_free(report_item->usage_path);
    364                                         list_initialize(&report_item->usage_path->link);
    365                                         list_remove (stack.next);
     489                                usb_hid_report_set_last_item(usage_path,
     490                                    USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
     491                               
     492                                usb_hid_report_set_last_item(usage_path,
     493                                    USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
     494
     495                                usb_hid_report_path_free(report_item->usage_path);
     496                                list_initialize(&report_item->usage_path->link);
     497                                list_remove (stack.next);
    366498                                       
    367                                         break;
     499                                break;
    368500                                       
    369                                 default:
    370                                         // nothing special to do                                       
    371                                         break;
     501                        default:
     502                                // nothing special to do                                       
     503                                break;
    372504                        }
    373505
    … …  
    386518}
    387519
     520/*---------------------------------------------------------------------------*/
    388521
    389522/**
    … …  
    396529 * @return Code of action to be done next
    397530 */
    398 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
    399                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    400 {       
     531int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data,
     532        size_t item_size, usb_hid_report_item_t *report_item,
     533        usb_hid_report_path_t *usage_path) {   
     534       
    401535        int ret;
    402536       
    403537        switch(class){
    404                 case USB_HID_TAG_CLASS_MAIN:
    405 
    406                         if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) {
    407                                 return USB_HID_NEW_REPORT_ITEM;
    408                         }
    409                         else {
    410                                 /*TODO process the error */
    411                                 return ret;
    412                            }
    413                         break;
    414 
    415                 case USB_HID_TAG_CLASS_GLOBAL: 
    416                         return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path);
    417                         break;
    418 
    419                 case USB_HID_TAG_CLASS_LOCAL:                   
    420                         return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path);
    421                         break;
    422                 default:
    423                         return USB_HID_NO_ACTION;
     538        case USB_HID_TAG_CLASS_MAIN:
     539
     540                if((ret=usb_hid_report_parse_main_tag(tag, data, item_size,
     541                        report_item, usage_path)) == EOK) {
     542
     543                        return USB_HID_NEW_REPORT_ITEM;
     544                }
     545                else {
     546                        return ret;
     547                }
     548                break;
     549
     550        case USB_HID_TAG_CLASS_GLOBAL: 
     551                return usb_hid_report_parse_global_tag(tag, data, item_size,
     552                        report_item, usage_path);
     553                break;
     554
     555        case USB_HID_TAG_CLASS_LOCAL:                   
     556                return usb_hid_report_parse_local_tag(tag, data, item_size,
     557                        report_item, usage_path);
     558                break;
     559       
     560        default:
     561                return USB_HID_NO_ACTION;
    424562        }
    425563}
    … …  
    435573 */
    436574
    437 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    438                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
     575int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data,
     576        size_t item_size, usb_hid_report_item_t *report_item,
     577        usb_hid_report_path_t *usage_path)
    439578{
    440579        usb_hid_report_usage_path_t *path_item;
    … …  
    442581        switch(tag)
    443582        {
    444                 case USB_HID_REPORT_TAG_INPUT:
    445                 case USB_HID_REPORT_TAG_OUTPUT:
    446                 case USB_HID_REPORT_TAG_FEATURE:
    447                         report_item->item_flags = *data;                       
    448                         return EOK;                     
    449                         break;
     583        case USB_HID_REPORT_TAG_INPUT:
     584        case USB_HID_REPORT_TAG_OUTPUT:
     585        case USB_HID_REPORT_TAG_FEATURE:
     586                report_item->item_flags = *data;                       
     587                return EOK;                     
     588                break;
    450589                       
    451                 case USB_HID_REPORT_TAG_COLLECTION:
    452                         // store collection atributes
    453                         path_item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
    454                         path_item->flags = *data;       
     590        case USB_HID_REPORT_TAG_COLLECTION:
     591
     592                /* store collection atributes */
     593                path_item = list_get_instance(usage_path->head.prev,
     594                        usb_hid_report_usage_path_t, link);
     595                path_item->flags = *data;       
    455596                       
    456                         // set last item
    457                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, report_item->usage_page);
    458                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, report_item->usages[report_item->usages_count-1]);
     597                /* set last item */
     598                usb_hid_report_set_last_item(usage_path,
     599                        USB_HID_TAG_CLASS_GLOBAL,
     600                        USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[
     601                                report_item->usages_count-1]));
     602
     603                usb_hid_report_set_last_item(usage_path,
     604                        USB_HID_TAG_CLASS_LOCAL,
     605                        USB_HID_EXTENDED_USAGE(report_item->usages[
     606                                report_item->usages_count-1]));
    459607                       
    460                         // append the new one which will be set by common
    461                         // usage/usage page
    462                         usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);
    463                         usb_hid_report_reset_local_items (report_item);
    464                         return USB_HID_NO_ACTION;
    465                         break;
     608                /* append the new one which will be set by common usage/usage
     609                 * page */
     610                usb_hid_report_path_append_item(usage_path,
     611                        report_item->usage_page,
     612                        report_item->usages[report_item->usages_count-1]);
     613
     614                usb_hid_report_reset_local_items (report_item);
     615                return USB_HID_NO_ACTION;
     616                break;
    466617                       
    467                 case USB_HID_REPORT_TAG_END_COLLECTION:
    468                         usb_hid_report_remove_last_item(usage_path);
    469                         return USB_HID_NO_ACTION;
    470                         break;
    471                 default:
    472                         return USB_HID_NO_ACTION;
     618        case USB_HID_REPORT_TAG_END_COLLECTION:
     619                usb_hid_report_remove_last_item(usage_path);
     620                return USB_HID_NO_ACTION;
     621                break;
     622
     623        default:
     624                return USB_HID_NO_ACTION;
    473625        }
    474626
    … …  
    485637 * @return Error code
    486638 */
    487 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    488                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    489 {
    490         // TODO take care about the bit length of data
     639int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data,
     640        size_t item_size, usb_hid_report_item_t *report_item,
     641        usb_hid_report_path_t *usage_path) {
     642       
    491643        switch(tag)
    492644        {
    493                 case USB_HID_REPORT_TAG_USAGE_PAGE:
    494                         report_item->usage_page = usb_hid_report_tag_data_uint32(data, item_size);
    495                         break;
    496                 case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
    497                         report_item->logical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    498                         break;
    499                 case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
    500                         report_item->logical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    501                         break;
    502                 case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
    503                         report_item->physical_minimum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    504                         break;                 
    505                 case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
    506                         report_item->physical_maximum = USB_HID_UINT32_TO_INT32(usb_hid_report_tag_data_uint32(data,item_size), item_size * 8);
    507 
    508                         break;
    509                 case USB_HID_REPORT_TAG_UNIT_EXPONENT:
    510                         report_item->unit_exponent = usb_hid_report_tag_data_uint32(data,item_size);
    511                         break;
    512                 case USB_HID_REPORT_TAG_UNIT:
    513                         report_item->unit = usb_hid_report_tag_data_uint32(data,item_size);
    514                         break;
    515                 case USB_HID_REPORT_TAG_REPORT_SIZE:
    516                         report_item->size = usb_hid_report_tag_data_uint32(data,item_size);
    517                         break;
    518                 case USB_HID_REPORT_TAG_REPORT_COUNT:
    519                         report_item->count = usb_hid_report_tag_data_uint32(data,item_size);
    520                         break;
    521                 case USB_HID_REPORT_TAG_REPORT_ID:
    522                         report_item->id = usb_hid_report_tag_data_uint32(data,item_size);
    523                         return USB_HID_RESET_OFFSET;
    524                         break;
    525                 case USB_HID_REPORT_TAG_PUSH:
    526                 case USB_HID_REPORT_TAG_POP:
    527                         /*
    528                          * stack operations are done in top level parsing
    529                          * function
    530                          */
    531                         return tag;
    532                         break;
     645        case USB_HID_REPORT_TAG_USAGE_PAGE:
     646                report_item->usage_page =
     647                        usb_hid_report_tag_data_uint32(data, item_size);
     648                break;
     649
     650        case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
     651                report_item->logical_minimum = USB_HID_UINT32_TO_INT32(
     652                        usb_hid_report_tag_data_uint32(data,item_size),
     653                        item_size * 8);
     654                break;
     655
     656        case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM:
     657                report_item->logical_maximum = USB_HID_UINT32_TO_INT32(
     658                        usb_hid_report_tag_data_uint32(data,item_size),
     659                        item_size * 8);
     660                break;
     661
     662        case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM:
     663                report_item->physical_minimum = USB_HID_UINT32_TO_INT32(
     664                        usb_hid_report_tag_data_uint32(data,item_size),
     665                        item_size * 8);
     666                break;                 
     667
     668        case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM:
     669                report_item->physical_maximum = USB_HID_UINT32_TO_INT32(
     670                        usb_hid_report_tag_data_uint32(data,item_size),
     671                        item_size * 8);
     672                break;
     673
     674        case USB_HID_REPORT_TAG_UNIT_EXPONENT:
     675                report_item->unit_exponent = usb_hid_report_tag_data_uint32(
     676                        data,item_size);
     677                break;
     678
     679        case USB_HID_REPORT_TAG_UNIT:
     680                report_item->unit = usb_hid_report_tag_data_uint32(
     681                        data,item_size);
     682                break;
     683
     684        case USB_HID_REPORT_TAG_REPORT_SIZE:
     685                report_item->size = usb_hid_report_tag_data_uint32(
     686                        data,item_size);
     687                break;
     688
     689        case USB_HID_REPORT_TAG_REPORT_COUNT:
     690                report_item->count = usb_hid_report_tag_data_uint32(
     691                        data,item_size);
     692                break;
     693
     694        case USB_HID_REPORT_TAG_REPORT_ID:
     695                report_item->id = usb_hid_report_tag_data_uint32(data,
     696                        item_size);
     697                return USB_HID_RESET_OFFSET;
     698                break;
     699       
     700        case USB_HID_REPORT_TAG_PUSH:
     701        case USB_HID_REPORT_TAG_POP:
     702                /*
     703                 * stack operations are done in top level parsing
     704                 * function
     705                 */
     706                return tag;
     707                break;
    533708                       
    534                 default:
    535                         return USB_HID_NO_ACTION;
     709        default:
     710                return USB_HID_NO_ACTION;
    536711        }
    537712
    … …  
    548723 * @return Error code
    549724 */
    550 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    551                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
     725int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data,
     726        size_t item_size, usb_hid_report_item_t *report_item,
     727        usb_hid_report_path_t *usage_path)
    552728{
     729        int32_t extended_usage;
     730       
    553731        switch(tag) {
    554                 case USB_HID_REPORT_TAG_USAGE:
    555                         switch(report_item->in_delimiter) {
    556                                 case INSIDE_DELIMITER_SET:
    557                                         // nothing to do
    558                                         break;
    559                                 case START_DELIMITER_SET:
    560                                         report_item->in_delimiter = INSIDE_DELIMITER_SET;
    561                                 case OUTSIDE_DELIMITER_SET:
    562                                         report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
    563                                         report_item->usages_count++;
    564                                         break;
     732        case USB_HID_REPORT_TAG_USAGE:
     733                switch(report_item->in_delimiter) {
     734                case INSIDE_DELIMITER_SET:
     735                        /* nothing to do
     736                         * we catch only the first one
     737                         */
     738                        break;
     739       
     740                case START_DELIMITER_SET:
     741                        report_item->in_delimiter = INSIDE_DELIMITER_SET;
     742                case OUTSIDE_DELIMITER_SET:
     743                        extended_usage = ((report_item->usage_page) << 16);
     744                        extended_usage += usb_hid_report_tag_data_uint32(
     745                                data,item_size);
     746
     747                        report_item->usages[report_item->usages_count] =
     748                                extended_usage;
     749
     750                        report_item->usages_count++;
     751                        break;
     752                }
     753                break;
     754               
     755        case USB_HID_REPORT_TAG_USAGE_MINIMUM:                 
     756                if (item_size == 3) {
     757                        // usage extended usages
     758                        report_item->extended_usage_page =
     759                            USB_HID_EXTENDED_USAGE_PAGE(
     760                            usb_hid_report_tag_data_uint32(data,item_size));
     761                           
     762
     763                        report_item->usage_minimum =
     764                            USB_HID_EXTENDED_USAGE(
     765                            usb_hid_report_tag_data_uint32(data,item_size));
     766                }
     767                else {
     768                        report_item->usage_minimum =
     769                            usb_hid_report_tag_data_uint32(data,item_size);
     770                }
     771                break;
     772       
     773        case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
     774                if (item_size == 3) {
     775                        if(report_item->extended_usage_page !=
     776                            USB_HID_EXTENDED_USAGE_PAGE(       
     777                            usb_hid_report_tag_data_uint32(data,item_size))) {
     778                               
     779                                return EINVAL;
    565780                        }
    566                         break;
    567                 case USB_HID_REPORT_TAG_USAGE_MINIMUM:
    568                         if (item_size == 3) {
    569                                 // usage extended usages
    570                                 report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16;
    571                                 report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
     781                               
     782                        // usage extended usages
     783                        report_item->extended_usage_page =
     784                                USB_HID_EXTENDED_USAGE_PAGE(
     785                                usb_hid_report_tag_data_uint32(data,item_size));
     786
     787                        report_item->usage_maximum =
     788                                USB_HID_EXTENDED_USAGE(
     789                                usb_hid_report_tag_data_uint32(data,item_size));
     790                }
     791                else {
     792                        report_item->usage_maximum =
     793                                usb_hid_report_tag_data_uint32(data,item_size);
     794                }
     795
     796                // vlozit zaznamy do pole usages
     797                int32_t i;
     798                for(i = report_item->usage_minimum;
     799                    i <= report_item->usage_maximum; i++) {
     800
     801                        if(report_item->extended_usage_page) {
     802                            report_item->usages[report_item->usages_count++] =
     803                                (report_item->extended_usage_page << 16) + i;
    572804                        }
    573                         else {
    574                                 report_item->usage_minimum = usb_hid_report_tag_data_uint32(data,item_size);
     805                        else {                 
     806                            report_item->usages[report_item->usages_count++] =
     807                                (report_item->usage_page << 16) + i;
    575808                        }
    576                         break;
    577                 case USB_HID_REPORT_TAG_USAGE_MAXIMUM:
    578                         if (item_size == 3) {
    579                                 // usage extended usages
    580                                 report_item->extended_usage_page = (usb_hid_report_tag_data_uint32(data,item_size) & 0xFF00) >> 16;
    581                                 report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size) & 0xFF;
    582                         }
    583                         else {
    584                                 report_item->usage_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    585                         }
    586                         break;
    587                 case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
    588                         report_item->designator_index = usb_hid_report_tag_data_uint32(data,item_size);
    589                         break;
    590                 case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
    591                         report_item->designator_minimum = usb_hid_report_tag_data_uint32(data,item_size);
    592                         break;
    593                 case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
    594                         report_item->designator_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    595                         break;
    596                 case USB_HID_REPORT_TAG_STRING_INDEX:
    597                         report_item->string_index = usb_hid_report_tag_data_uint32(data,item_size);
    598                         break;
    599                 case USB_HID_REPORT_TAG_STRING_MINIMUM:
    600                         report_item->string_minimum = usb_hid_report_tag_data_uint32(data,item_size);
    601                         break;
    602                 case USB_HID_REPORT_TAG_STRING_MAXIMUM:
    603                         report_item->string_maximum = usb_hid_report_tag_data_uint32(data,item_size);
    604                         break;                 
    605                 case USB_HID_REPORT_TAG_DELIMITER:
    606                         report_item->in_delimiter = usb_hid_report_tag_data_uint32(data,item_size);
    607                         break;
    608 
    609                 default:
    610                         return USB_HID_NO_ACTION;
     809                }
     810                report_item->extended_usage_page = 0;
     811                       
     812                break;
     813               
     814        case USB_HID_REPORT_TAG_DESIGNATOR_INDEX:
     815                report_item->designator_index =
     816                        usb_hid_report_tag_data_uint32(data,item_size);
     817                break;
     818       
     819        case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM:
     820                report_item->designator_minimum =
     821                        usb_hid_report_tag_data_uint32(data,item_size);
     822                break;
     823
     824        case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM:
     825                report_item->designator_maximum =
     826                        usb_hid_report_tag_data_uint32(data,item_size);
     827                break;
     828
     829        case USB_HID_REPORT_TAG_STRING_INDEX:
     830                report_item->string_index =
     831                        usb_hid_report_tag_data_uint32(data,item_size);
     832                break;
     833
     834        case USB_HID_REPORT_TAG_STRING_MINIMUM:
     835                report_item->string_minimum =
     836                        usb_hid_report_tag_data_uint32(data,item_size);
     837                break;
     838
     839        case USB_HID_REPORT_TAG_STRING_MAXIMUM:
     840                report_item->string_maximum =
     841                        usb_hid_report_tag_data_uint32(data,item_size);
     842                break;                 
     843
     844        case USB_HID_REPORT_TAG_DELIMITER:
     845                report_item->in_delimiter =
     846                        usb_hid_report_tag_data_uint32(data,item_size);
     847                break;
     848
     849        default:
     850                return USB_HID_NO_ACTION;
    611851        }
    612852
    613853        return EOK;
    614854}
     855/*---------------------------------------------------------------------------*/
    615856
    616857/**
    … …  
    633874        return result;
    634875}
     876/*---------------------------------------------------------------------------*/
    635877
    636878/**
    … …  
    653895        for(item = head->next; item != head; item = item->next) {
    654896               
    655                 report_item = list_get_instance(item, usb_hid_report_field_t, link);
     897                report_item = list_get_instance(item, usb_hid_report_field_t,
     898                                link);
    656899
    657900                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
    658                 usb_log_debug("\t\tSIZE: %zu\n", report_item->size);                           
    659                 usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum);
    660                 usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum);               
    661                 usb_log_debug("\t\tPHYMIN: %d\n", report_item->physical_minimum);               
    662                 usb_log_debug("\t\tPHYMAX: %d\n", report_item->physical_maximum);                               
    663                 usb_log_debug("\t\ttUSAGEMIN: %X\n", report_item->usage_minimum);
    664                 usb_log_debug("\t\tUSAGEMAX: %X\n", report_item->usage_maximum);
     901                usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
     902                usb_log_debug("\t\tLOGMIN: %d\n",
     903                        report_item->logical_minimum);
     904                usb_log_debug("\t\tLOGMAX: %d\n",
     905                        report_item->logical_maximum);         
     906                usb_log_debug("\t\tPHYMIN: %d\n",
     907                        report_item->physical_minimum);         
     908                usb_log_debug("\t\tPHYMAX: %d\n",
     909                        report_item->physical_maximum);                         
     910                usb_log_debug("\t\ttUSAGEMIN: %X\n",
     911                        report_item->usage_minimum);
     912                usb_log_debug("\t\tUSAGEMAX: %X\n",
     913                               report_item->usage_maximum);
     914                usb_log_debug("\t\tUSAGES COUNT: %zu\n",
     915                        report_item->usages_count);
    665916
    666917                usb_log_debug("\t\tVALUE: %X\n", report_item->value);
    … …  
    668919                usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
    669920               
    670                 //usb_hid_print_usage_path(report_item->collection_path);
     921                usb_hid_print_usage_path(report_item->collection_path);
    671922
    672923                usb_log_debug("\n");           
    … …  
    674925        }
    675926
    676 
    677 }
     927}
     928/*---------------------------------------------------------------------------*/
     929
    678930/**
    679931 * Prints content of given report descriptor in human readable format.
    … …  
    692944
    693945        while(report_it != &report->reports) {
    694                 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
     946                report_des = list_get_instance(report_it,
     947                        usb_hid_report_description_t, link);
    695948                usb_log_debug("Report ID: %d\n", report_des->report_id);
    696949                usb_log_debug("\tType: %d\n", report_des->type);
    697950                usb_log_debug("\tLength: %zu\n", report_des->bit_length);               
     951                usb_log_debug("\tB Size: %zu\n",
     952                        usb_hid_report_byte_size(report,
     953                                report_des->report_id,
     954                                report_des->type));
    698955                usb_log_debug("\tItems: %zu\n", report_des->item_length);               
    699956
    700957                usb_hid_descriptor_print_list(&report_des->report_items);
    701958
    702 
    703                 link_t *path_it = report->collection_paths.next;
    704                 while(path_it != &report->collection_paths) {
    705                         usb_hid_print_usage_path (list_get_instance(path_it, usb_hid_report_path_t, link));
    706                         path_it = path_it->next;
    707                 }
    708                
    709959                report_it = report_it->next;
    710960        }
    711961}
     962/*---------------------------------------------------------------------------*/
    712963
    713964/**
    … …  
    734985
    735986                while(!list_empty(&report_item->usage_path->link)) {
    736                         usb_hid_report_remove_last_item(report_item->usage_path);
     987                    usb_hid_report_remove_last_item(report_item->usage_path);
    737988                }
    738989
    … …  
    746997       
    747998}
     999/*---------------------------------------------------------------------------*/
    7481000
    7491001/** Frees the HID report descriptor parser structure
    … …  
    7611013        usb_hid_report_path_t *path;
    7621014        while(!list_empty(&report->collection_paths)) {
    763                 path = list_get_instance(report->collection_paths.next, usb_hid_report_path_t, link);
     1015                path = list_get_instance(report->collection_paths.next,
     1016                                usb_hid_report_path_t, link);
     1017
    7641018                usb_hid_report_path_free(path);         
    7651019        }
    … …  
    7691023        usb_hid_report_field_t *field;
    7701024        while(!list_empty(&report->reports)) {
    771                 report_des = list_get_instance(report->reports.next, usb_hid_report_description_t, link);
     1025                report_des = list_get_instance(report->reports.next,
     1026                                usb_hid_report_description_t, link);
     1027
    7721028                list_remove(&report_des->link);
    7731029               
    7741030                while(!list_empty(&report_des->report_items)) {
    775                         field = list_get_instance(report_des->report_items.next, usb_hid_report_field_t, link);
     1031                        field = list_get_instance(
     1032                                report_des->report_items.next,
     1033                                usb_hid_report_field_t, link);
     1034
    7761035                        list_remove(&field->link);
    7771036
    … …  
    7841043        return;
    7851044}
     1045/*---------------------------------------------------------------------------*/
    7861046
    7871047/**

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

    r88be3a0b r6bfaab5  
    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/hidparser.c

    r88be3a0b r6bfaab5  
    3131 */
    3232/** @file
    33  * HID report descriptor and report data parser implementation.
     33 * USB HID report data parser implementation.
    3434 */
    3535#include <usb/hid/hidparser.h>
    … …  
    4141#include <assert.h>
    4242
    43 
     43/*---------------------------------------------------------------------------*/
    4444/*
    4545 * Data translation private functions
    4646 */
    4747uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
    48 //inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset);
     48
    4949int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data);
    50 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value);
     50
     51uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
     52        int32_t value);
     53
    5154int usb_pow(int a, int b);
    5255
     56/*---------------------------------------------------------------------------*/
    5357
    5458// TODO: tohle ma bejt asi jinde
    … …  
    5660{
    5761        switch(b) {
    58                 case 0:
    59                         return 1;
    60                         break;
    61                 case 1:
    62                         return a;
    63                         break;
    64                 default:
    65                         return a * usb_pow(a, b-1);
    66                         break;
    67         }
    68 }
    69 
    70 
    71 
     62        case 0:
     63                return 1;
     64                break;
     65        case 1:
     66                return a;
     67                break;
     68        default:
     69                return a * usb_pow(a, b-1);
     70                break;
     71        }
     72}
     73/*---------------------------------------------------------------------------*/
     74
     75/** Returns size of report of specified report id and type in items
     76 *
     77 * @param parser Opaque report parser structure
     78 * @param report_id
     79 * @param type
     80 * @return Number of items in specified report
     81 */
     82size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id,
     83                           usb_hid_report_type_t type)
     84{
     85        usb_hid_report_description_t *report_des;
     86
     87        if(report == NULL) {
     88                return 0;
     89        }
     90
     91        report_des = usb_hid_report_find_description (report, report_id, type);
     92        if(report_des == NULL){
     93                return 0;
     94        }
     95        else {
     96                return report_des->item_length;
     97        }
     98}
     99
     100/** Returns size of report of specified report id and type in bytes
     101 *
     102 * @param parser Opaque report parser structure
     103 * @param report_id
     104 * @param type
     105 * @return Number of items in specified report
     106 */
     107size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
     108                           usb_hid_report_type_t type)
     109{
     110        usb_hid_report_description_t *report_des;
     111
     112        if(report == NULL) {
     113                return 0;
     114        }
     115
     116        report_des = usb_hid_report_find_description (report, report_id, type);
     117        if(report_des == NULL){
     118                return 0;
     119        }
     120        else {
     121                return ((report_des->bit_length + 7) / 8) ;
     122        }
     123}
     124/*---------------------------------------------------------------------------*/
    72125
    73126/** Parse and act upon a HID report.
    … …  
    79132 * @return Error code.
    80133 */
    81 int usb_hid_parse_report(const usb_hid_report_t *report,
    82     const uint8_t *data, size_t size, uint8_t *report_id)
     134int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data,
     135        size_t size, uint8_t *report_id)
    83136{
    84137        link_t *list_item;
    … …  
    87140        usb_hid_report_description_t *report_des;
    88141        usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT;
    89 
     142       
    90143        if(report == NULL) {
    91144                return EINVAL;
    … …  
    101154
    102155        report_des = usb_hid_report_find_description(report, *report_id, type);
     156        if(report_des == NULL) {
     157                return EINVAL;
     158        }
    103159
    104160        /* read data */
    … …  
    106162        while(list_item != &(report_des->report_items)) {
    107163
    108                 item = list_get_instance(list_item, usb_hid_report_field_t, link);
     164                item = list_get_instance(list_item, usb_hid_report_field_t,
     165                                link);
    109166
    110167                if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
    … …  
    113170
    114171                                // array
    115                                 item->value = usb_hid_translate_data(item, data);
    116                             item->usage = (item->value - item->physical_minimum) + item->usage_minimum;
     172                                item->value =
     173                                        usb_hid_translate_data(item, data);
     174               
     175                                item->usage = USB_HID_EXTENDED_USAGE(
     176                                    item->usages[item->value - item->physical_minimum]);
     177
     178                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(
     179                                    item->usages[item->value - item->physical_minimum]);
     180
     181                                usb_hid_report_set_last_item (item->collection_path,
     182                                    USB_HID_TAG_CLASS_GLOBAL, item->usage_page);
     183
     184                                usb_hid_report_set_last_item (item->collection_path,
     185                                    USB_HID_TAG_CLASS_LOCAL, item->usage);
     186                               
    117187                        }
    118188                        else {
    … …  
    123193                list_item = list_item->next;
    124194        }
    125            
     195       
    126196        return EOK;
    127197       
    128198}
    129199
     200/*---------------------------------------------------------------------------*/
    130201/**
    131202 * Translate data from the report as specified in report descriptor item
    … …  
    133204 * @param item Report descriptor item with definition of translation
    134205 * @param data Data to translate
    135  * @param j Index of processed field in report descriptor item
    136206 * @return Translated data
    137207 */
    … …  
    202272        }
    203273
    204         return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum);
    205        
    206 }
    207 
    208 /**
    209  * Returns number of items in input report which are accessible by given usage path
    210  *
    211  * @param parser Opaque report descriptor structure
    212  * @param path Usage path specification
    213  * @param flags Usage path comparison flags
    214  * @return Number of items in input report
    215  */
    216 size_t usb_hid_report_input_length(const usb_hid_report_t *report,
    217         usb_hid_report_path_t *path, int flags)
    218 {       
    219        
    220         size_t ret = 0;
    221 
    222         if(report == NULL) {
    223                 return 0;
    224         }
    225 
    226         usb_hid_report_description_t *report_des;
    227         report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_INPUT);
    228         if(report_des == NULL) {
    229                 return 0;
    230         }
    231 
    232         link_t *field_it = report_des->report_items.next;
    233         usb_hid_report_field_t *field;
    234         while(field_it != &report_des->report_items) {
    235 
    236                 field = list_get_instance(field_it, usb_hid_report_field_t, link);
    237                 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
    238                        
    239                         usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
    240                         if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) {
    241                                 ret++;
    242                         }
    243                         usb_hid_report_remove_last_item (field->collection_path);
    244                 }
    245                
    246                 field_it = field_it->next;
    247         }
    248 
    249         return ret;
    250         }
    251 
    252 /*** OUTPUT API **/
     274        return (int)(((value - item->logical_minimum) / resolution) +
     275                item->physical_minimum);
     276       
     277}
     278
     279/*---------------------------------------------------------------------------*/
     280/* OUTPUT API */
    253281
    254282/**
    … …  
    260288 * @return Returns allocated output buffer for specified output
    261289 */
    262 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id)
     290uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
     291        uint8_t report_id)
    263292{
    264293        if(report == NULL) {
    … …  
    270299        usb_hid_report_description_t *report_des = NULL;
    271300        while(report_it != &report->reports) {
    272                 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
    273                 if((report_des->report_id == report_id) && (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
     301                report_des = list_get_instance(report_it,
     302                        usb_hid_report_description_t, link);
     303               
     304                if((report_des->report_id == report_id) &&
     305                        (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
    274306                        break;
    275307                }
    … …  
    302334                free (output);
    303335        }
    304 }
    305 
    306 /** Returns size of output for given usage path
    307  *
    308  * @param parser Opaque report parser structure
    309  * @param path Usage path specified which items will be thought for the output
    310  * @param flags Flags of usage path structure comparison
    311  * @return Number of items matching the given usage path
    312  */
    313 size_t usb_hid_report_output_size(usb_hid_report_t *report,
    314                                   usb_hid_report_path_t *path, int flags)
    315 {
    316         size_t ret = 0;
    317         usb_hid_report_description_t *report_des;
    318 
    319         if(report == NULL) {
    320                 return 0;
    321         }
    322 
    323         report_des = usb_hid_report_find_description (report, path->report_id, USB_HID_REPORT_TYPE_OUTPUT);
    324         if(report_des == NULL){
    325                 return 0;
    326         }
    327        
    328         link_t *field_it = report_des->report_items.next;
    329         usb_hid_report_field_t *field;
    330         while(field_it != &report_des->report_items) {
    331 
    332                 field = list_get_instance(field_it, usb_hid_report_field_t, link);
    333                 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0){
    334                         usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
    335                         if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK) {
    336                                 ret++;
    337                         }
    338                         usb_hid_report_remove_last_item (field->collection_path);
    339                 }
    340                
    341                 field_it = field_it->next;
    342         }
    343 
    344         return ret;
    345        
    346336}
    347337
    … …  
    355345 * @return Error code
    356346 */
    357 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
    358                                     uint8_t *buffer, size_t size)
     347int usb_hid_report_output_translate(usb_hid_report_t *report,
     348        uint8_t report_id, uint8_t *buffer, size_t size)
    359349{
    360350        link_t *item;   
    … …  
    372362        }
    373363
    374         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
    375        
    376364        usb_hid_report_description_t *report_des;
    377         report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT);
     365        report_des = usb_hid_report_find_description (report, report_id,
     366                USB_HID_REPORT_TYPE_OUTPUT);
     367       
    378368        if(report_des == NULL){
    379369                return EINVAL;
    … …  
    385375                report_item = list_get_instance(item, usb_hid_report_field_t, link);
    386376
    387                         if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
     377                if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
    388378                                       
    389                                 // array
    390                                 value = usb_hid_translate_data_reverse(report_item, report_item->value);
    391                                 offset = report_item->offset;
    392                                 length = report_item->size;
     379                        // array
     380                        value = usb_hid_translate_data_reverse(report_item,
     381                                report_item->value);
     382
     383                        offset = report_item->offset;
     384                        length = report_item->size;
     385                }
     386                else {
     387                        // variable item
     388                        value  = usb_hid_translate_data_reverse(report_item,
     389                                report_item->value);
     390
     391                        offset = report_item->offset;
     392                        length = report_item->size;
     393                }
     394
     395                usb_log_debug("\ttranslated value: %x\n", value);
     396
     397                if((offset/8) == ((offset+length-1)/8)) {
     398                        // je to v jednom bytu
     399                        if(((size_t)(offset/8) >= size) ||
     400                                ((size_t)(offset+length-1)/8) >= size) {
     401                                break; // TODO ErrorCode
    393402                        }
    394                         else {
    395                                 // variable item
    396                                 value  = usb_hid_translate_data_reverse(report_item, report_item->value);
    397                                 offset = report_item->offset;
    398                                 length = report_item->size;
    399                         }
    400 
    401                         if((offset/8) == ((offset+length-1)/8)) {
    402                                 // je to v jednom bytu
    403                                 if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) {
    404                                         break; // TODO ErrorCode
     403                        size_t shift = 8 - offset%8 - length;
     404                        value = value << shift;                                                 
     405                        value = value & (((1 << length)-1) << shift);
     406                               
     407                        uint8_t mask = 0;
     408                        mask = 0xff - (((1 << length) - 1) << shift);
     409                        buffer[offset/8] = (buffer[offset/8] & mask) | value;
     410                }
     411                else {
     412                        int i = 0;
     413                        uint8_t mask = 0;
     414                        for(i = (offset/8); i <= ((offset+length-1)/8); i++) {
     415                                if(i == (offset/8)) {
     416                                        tmp_value = value;
     417                                        tmp_value = tmp_value &
     418                                                ((1 << (8-(offset%8)))-1);
     419
     420                                        tmp_value = tmp_value << (offset%8);
     421       
     422                                        mask = ~(((1 << (8-(offset%8)))-1) <<
     423                                                        (offset%8));
     424
     425                                        buffer[i] = (buffer[i] & mask) |
     426                                                tmp_value;
    405427                                }
    406 
    407                                 size_t shift = 8 - offset%8 - length;
    408 
    409                                 value = value << shift;                                                 
    410                                 value = value & (((1 << length)-1) << shift);
     428                                else if (i == ((offset + length -1)/8)) {
     429                                       
     430                                        value = value >> (length -
     431                                                ((offset + length) % 8));
     432
     433                                        value = value & ((1 << (length -
     434                                                ((offset + length) % 8))) - 1);
    411435                               
    412                                 uint8_t mask = 0;
    413                                 mask = 0xff - (((1 << length) - 1) << shift);
    414                                 buffer[offset/8] = (buffer[offset/8] & mask) | value;
    415                         }
    416                         else {
    417                                 int i = 0;
    418                                 uint8_t mask = 0;
    419                                 for(i = (offset/8); i <= ((offset+length-1)/8); i++) {
    420                                         if(i == (offset/8)) {
    421                                                 tmp_value = value;
    422                                                 tmp_value = tmp_value & ((1 << (8-(offset%8)))-1);                             
    423                                                 tmp_value = tmp_value << (offset%8);
    424        
    425                                                 mask = ~(((1 << (8-(offset%8)))-1) << (offset%8));
    426                                                 buffer[i] = (buffer[i] & mask) | tmp_value;                     
    427                                         }
    428                                         else if (i == ((offset + length -1)/8)) {
    429                                                
    430                                                 value = value >> (length - ((offset + length) % 8));
    431                                                 value = value & ((1 << (length - ((offset + length) % 8))) - 1);
    432                                
    433                                                 mask = (1 << (length - ((offset + length) % 8))) - 1;
    434                                                 buffer[i] = (buffer[i] & mask) | value;
    435                                         }
    436                                         else {
    437                                                 buffer[i] = value & (0xFF << i);
    438                                         }
     436                                        mask = (1 << (length -
     437                                                ((offset + length) % 8))) - 1;
     438
     439                                        buffer[i] = (buffer[i] & mask) | value;
     440                                }
     441                                else {
     442                                        buffer[i] = value & (0xFF << i);
    439443                                }
    440444                        }
    441 
     445                }
    442446
    443447                // reset value
    … …  
    447451        }
    448452       
    449         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
    450 
    451453        return EOK;
    452454}
    453455
     456/*---------------------------------------------------------------------------*/
    454457/**
    455458 * Translate given data for putting them into the outoput report
    … …  
    458461 * @return ranslated value
    459462 */
    460 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)
     463uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
     464        int value)
    461465{
    462466        int ret=0;
    … …  
    472476        }
    473477       
    474 
    475         if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) {
    476 
    477                 // variable item
    478                 if(item->physical_maximum == item->physical_minimum){
    479                     resolution = 1;
    480                 }
    481                 else {
    482                     resolution = (item->logical_maximum - item->logical_minimum) /
    483                         ((item->physical_maximum - item->physical_minimum) *
    484                         (usb_pow(10,(item->unit_exponent))));
    485                 }
    486 
    487                 ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum;
    488         }
    489         else {
    490                 // bitmapa
    491                 if(value == 0) {
    492                         ret = 0;
    493                 }
    494                 else {
    495                         size_t bitmap_idx = (value - item->usage_minimum);
    496                         ret = 1 << bitmap_idx;
    497                 }
    498         }
    499 
     478        // variable item
     479        if(item->physical_maximum == item->physical_minimum){
     480            resolution = 1;
     481        }
     482        else {
     483            resolution = (item->logical_maximum - item->logical_minimum) /
     484                ((item->physical_maximum - item->physical_minimum) *
     485                (usb_pow(10,(item->unit_exponent))));
     486        }
     487
     488        ret = ((value - item->physical_minimum) * resolution) +
     489                item->logical_minimum;
     490
     491        usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \
     492                ret(%x)\n", value, resolution, item->physical_minimum,
     493                item->logical_minimum, ret);
     494       
    500495        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
    501496                return USB_HID_INT32_TO_UINT32(ret, item->size);
    502497        }
    503         return (int32_t)ret;
    504 }
    505 
    506 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
     498        return (int32_t)0 + ret;
     499}
     500
     501/*---------------------------------------------------------------------------*/
     502/**
     503 * Clones given state table
     504 *
     505 * @param item State table to clone
     506 * @return Pointer to the cloned item
     507 */
     508usb_hid_report_item_t *usb_hid_report_item_clone(
     509        const usb_hid_report_item_t *item)
    507510{
    508511        usb_hid_report_item_t *new_report_item;
    … …  
    517520}
    518521
    519 
     522/*---------------------------------------------------------------------------*/
     523/**
     524 * Function for sequence walking through the report. Returns next field in the
     525 * report or the first one when no field is given.
     526 *
     527 * @param report Searched report structure
     528 * @param field Current field. If NULL is given, the first one in the report
     529 * is returned. Otherwise the next one i nthe list is returned.
     530 * @param path Usage path specifying which fields wa are interested in.
     531 * @param flags Flags defining mode of usage paths comparison
     532 * @param type Type of report we search.
     533 * @retval NULL if no field is founded
     534 * @retval Pointer to the founded report structure when founded
     535 */
    520536usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
    521                                                         usb_hid_report_field_t *field,
    522                             usb_hid_report_path_t *path, int flags,
    523                             usb_hid_report_type_t type)
    524 {
    525         usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type);
     537        usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
     538        usb_hid_report_type_t type)
     539{
     540        usb_hid_report_description_t *report_des =
     541                usb_hid_report_find_description(report, path->report_id, type);
     542
    526543        link_t *field_it;
    527544       
    … …  
    531548
    532549        if(field == NULL){
    533                 // vezmu prvni co mathuje podle path!!
    534550                field_it = report_des->report_items.next;
    535551        }
    … …  
    539555
    540556        while(field_it != &report_des->report_items) {
    541                 field = list_get_instance(field_it, usb_hid_report_field_t, link);
     557                field = list_get_instance(field_it, usb_hid_report_field_t,
     558                        link);
    542559
    543560                if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
    544                         usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
    545                         if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){
    546                                 usb_hid_report_remove_last_item (field->collection_path);
     561                        usb_hid_report_path_append_item (
     562                                field->collection_path, field->usage_page,
     563                                field->usage);
     564
     565                        if(usb_hid_report_compare_usage_path(
     566                                field->collection_path, path, flags) == EOK){
     567
     568                                usb_hid_report_remove_last_item(
     569                                        field->collection_path);
     570
    547571                                return field;
    548572                        }
    549                         usb_hid_report_remove_last_item (field->collection_path);
     573                        usb_hid_report_remove_last_item (
     574                                field->collection_path);
    550575                }
    551576                field_it = field_it->next;
    … …  
    555580}
    556581
    557 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
     582/*---------------------------------------------------------------------------*/
     583/**
     584 * Returns next report_id of report of specified type. If zero is given than
     585 * first report_id of specified type is returned (0 is not legal value for
     586 * repotr_id)
     587 *
     588 * @param report_id Current report_id, 0 if there is no current report_id
     589 * @param type Type of searched report
     590 * @param report Report structure inwhich we search
     591 * @retval 0 if report structure is null or there is no specified report
     592 * @retval report_id otherwise
     593 */
     594uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report,
     595        uint8_t report_id, usb_hid_report_type_t type)
    558596{
    559597        if(report == NULL){
    … …  
    564602        link_t *report_it;
    565603       
    566         if(report_id == 0) {
    567                 report_it = usb_hid_report_find_description (report, report_id, type)->link.next;               
     604        if(report_id > 0) {
     605                report_it = usb_hid_report_find_description(report, report_id,
     606                        type)->link.next;               
    568607        }
    569608        else {
    … …  
    572611
    573612        while(report_it != &report->reports) {
    574                 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
     613                report_des = list_get_instance(report_it,
     614                        usb_hid_report_description_t, link);
     615
    575616                if(report_des->type == type){
    576617                        return report_des->report_id;
    … …  
    581622}
    582623
     624/*---------------------------------------------------------------------------*/
     625/**
     626 * Reset all local items in given state table
     627 *
     628 * @param report_item State table containing current state of report
     629 * descriptor parsing
     630 *
     631 * @return void
     632 */
    583633void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
    584634{

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

    r88be3a0b r6bfaab5  
    4141#include <assert.h>
    4242
    43 
     43/*---------------------------------------------------------------------------*/
     44/**
     45 * Compares two usages if they are same or not or one of the usages is not
     46 * set.
     47 *
     48 * @param usage1
     49 * @param usage2
     50 * @return boolean
     51 */
     52#define USB_HID_SAME_USAGE(usage1, usage2)              \
     53        ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0))
     54
     55/**
     56 * Compares two usage pages if they are same or not or one of them is not set.
     57 *
     58 * @param page1
     59 * @param page2
     60 * @return boolean
     61 */
     62#define USB_HID_SAME_USAGE_PAGE(page1, page2)   \
     63        ((page1 == page2) || (page1 == 0) || (page2 == 0))
     64
     65/*---------------------------------------------------------------------------*/
    4466/**
    4567 * Appends one item (couple of usage_path and usage) into the usage path
    … …  
    7092}
    7193
     94/*---------------------------------------------------------------------------*/
    7295/**
    7396 * Removes last item from the usage path structure
    … …  
    88111}
    89112
     113/*---------------------------------------------------------------------------*/
    90114/**
    91115 * Nulls last item of the usage path structure.
    … …  
    99123       
    100124        if(!list_empty(&usage_path->head)){     
    101                 item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
     125                item = list_get_instance(usage_path->head.prev,
     126                        usb_hid_report_usage_path_t, link);
     127
    102128                memset(item, 0, sizeof(usb_hid_report_usage_path_t));
    103129        }
    104130}
    105131
     132/*---------------------------------------------------------------------------*/
    106133/**
    107134 * Modifies last item of usage path structure by given usage page or usage
    … …  
    134161}
    135162
    136 
     163/*---------------------------------------------------------------------------*/
     164/**
     165 *
     166 *
     167 *
     168 *
     169 */
    137170void usb_hid_print_usage_path(usb_hid_report_path_t *path)
    138171{
    … …  
    144177        while(item != &path->head) {
    145178
    146                 path_item = list_get_instance(item, usb_hid_report_usage_path_t, link);
     179                path_item = list_get_instance(item, usb_hid_report_usage_path_t,
     180                        link);
     181
    147182                usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
    148183                usb_log_debug("\tUSAGE: %X\n", path_item->usage);
    149184                usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
    150185               
    151                 item = item->next;
    152         }
    153 }
    154 
     186        item = item->next;
     187        }
     188}
     189
     190/*---------------------------------------------------------------------------*/
    155191/**
    156192 * Compares two usage paths structures
    … …  
    189225       
    190226        switch(flags){
    191                 /* path is somewhere in report_path */
    192                 case USB_HID_PATH_COMPARE_ANYWHERE:
    193                         if(path->depth != 1){
    194                                 return 1;
    195                         }
    196 
    197                         // projit skrz cestu a kdyz nekde sedi tak vratim EOK
    198                         // dojduli az za konec tak nnesedi
    199                         report_link = report_path->head.next;
    200                         path_link = path->head.next;
    201                         path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
    202 
    203                         while(report_link != &report_path->head) {
    204                                 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
    205                                 if(report_item->usage_page == path_item->usage_page){
    206                                         if(only_page == 0){
    207                                                 if(report_item->usage == path_item->usage) {
    208                                                         return EOK;
    209                                                 }
    210                                         }
    211                                         else {
     227        /* path is somewhere in report_path */
     228        case USB_HID_PATH_COMPARE_ANYWHERE:
     229                if(path->depth != 1){
     230                        return 1;
     231                }
     232
     233                report_link = report_path->head.next;
     234                path_link = path->head.next;
     235                path_item = list_get_instance(path_link,
     236                        usb_hid_report_usage_path_t, link);
     237
     238                while(report_link != &report_path->head) {
     239                        report_item = list_get_instance(report_link,
     240                                usb_hid_report_usage_path_t, link);
     241                               
     242                        if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
     243                                path_item->usage_page)){
     244                                       
     245                                if(only_page == 0){
     246                                        if(USB_HID_SAME_USAGE(
     247                                                report_item->usage,
     248                                                path_item->usage)) {
     249                                                       
    212250                                                return EOK;
    213251                                        }
    214252                                }
    215 
     253                                else {
     254                                        return EOK;
     255                                }
     256                        }
     257
     258                        report_link = report_link->next;
     259                }
     260
     261                return 1;
     262                break;
     263
     264        /* the paths must be identical */
     265        case USB_HID_PATH_COMPARE_STRICT:
     266                if(report_path->depth != path->depth){
     267                        return 1;
     268                }
     269               
     270        /* path is prefix of the report_path */
     271        case USB_HID_PATH_COMPARE_BEGIN:
     272       
     273                report_link = report_path->head.next;
     274                path_link = path->head.next;
     275                       
     276                while((report_link != &report_path->head) &&
     277                      (path_link != &path->head)) {
     278                                         
     279                        report_item = list_get_instance(report_link,
     280                                usb_hid_report_usage_path_t, link);
     281                                         
     282                        path_item = list_get_instance(path_link,
     283                                usb_hid_report_usage_path_t, link);
     284
     285                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
     286                                path_item->usage_page) || ((only_page == 0) &&
     287                            !USB_HID_SAME_USAGE(report_item->usage,
     288                                path_item->usage))) {
     289                       
     290                                return 1;
     291                        }
     292                        else {
    216293                                report_link = report_link->next;
     294                                path_link = path_link->next;                   
    217295                        }
    218 
    219                         return 1;
    220                         break;
    221                 /* the paths must be identical */
    222                 case USB_HID_PATH_COMPARE_STRICT:
    223                                 if(report_path->depth != path->depth){
    224                                         return 1;
    225                                 }
    226                
    227                 /* path is prefix of the report_path */
    228                 case USB_HID_PATH_COMPARE_BEGIN:
    229        
    230                                 report_link = report_path->head.next;
    231                                 path_link = path->head.next;
    232                        
    233                                 while((report_link != &report_path->head) &&
    234                                       (path_link != &path->head)) {
    235                                                  
    236                                         report_item = list_get_instance(report_link,
    237                                                                         usb_hid_report_usage_path_t,
    238                                                                         link);
    239                                                  
    240                                         path_item = list_get_instance(path_link,
    241                                                                       usb_hid_report_usage_path_t,
    242                                                                       link);           
    243 
    244                                         if((report_item->usage_page != path_item->usage_page) ||
    245                                            ((only_page == 0) &&
    246                                             (report_item->usage != path_item->usage))) {
    247                                                        
    248                                                    return 1;
    249                                         } else {
    250                                                 report_link = report_link->next;
    251                                                 path_link = path_link->next;                   
    252                                         }
    253296                       
    254297                                }
    255298
    256                                 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) ||
    257                                    ((report_link == &report_path->head) && (path_link == &path->head))) {
    258                                         return EOK;
    259                                 }
    260                                 else {
     299                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
     300                        (path_link == &path->head)) ||
     301                   ((report_link == &report_path->head) &&
     302                        (path_link == &path->head))) {
     303                               
     304                        return EOK;
     305                }
     306                else {
     307                        return 1;
     308                }                                               
     309                break;
     310
     311        /* path is suffix of report_path */
     312        case USB_HID_PATH_COMPARE_END:
     313
     314                report_link = report_path->head.prev;
     315                path_link = path->head.prev;
     316
     317                if(list_empty(&path->head)){
     318                        return EOK;
     319                }
     320                       
     321                while((report_link != &report_path->head) &&
     322                      (path_link != &path->head)) {
     323                                                 
     324                        report_item = list_get_instance(report_link,
     325                                usb_hid_report_usage_path_t, link);
     326
     327                        path_item = list_get_instance(path_link,
     328                                usb_hid_report_usage_path_t, link);             
     329                                                 
     330                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
     331                                path_item->usage_page) || ((only_page == 0) &&
     332                            !USB_HID_SAME_USAGE(report_item->usage,
     333                                path_item->usage))) {
     334                                               
    261335                                        return 1;
    262                                 }                                               
    263                         break;
    264 
    265                 /* path is suffix of report_path */
    266                 case USB_HID_PATH_COMPARE_END:
    267 
    268                                 report_link = report_path->head.prev;
    269                                 path_link = path->head.prev;
    270 
    271                                 if(list_empty(&path->head)){
    272                                         return EOK;
    273                                 }
     336                        } else {
     337                                report_link = report_link->prev;
     338                                path_link = path_link->prev;                   
     339                        }
     340
     341                }
     342
     343                if(path_link == &path->head) {
     344                        return EOK;
     345                }
     346                else {
     347                        return 1;
     348                }                                               
    274349                       
    275                                 while((report_link != &report_path->head) &&
    276                                       (path_link != &path->head)) {
    277                                                  
    278                                         report_item = list_get_instance(report_link,
    279                                                                         usb_hid_report_usage_path_t,
    280                                                                         link);
    281                                         path_item = list_get_instance(path_link,
    282                                                                       usb_hid_report_usage_path_t,
    283                                                                       link);           
    284 
    285                                         if((report_item->usage_page != path_item->usage_page) ||
    286                                            ((only_page == 0) &&
    287                                             (report_item->usage != path_item->usage))) {
    288                                                    return 1;
    289                                         } else {
    290                                                 report_link = report_link->prev;
    291                                                 path_link = path_link->prev;                   
    292                                         }
    293                        
    294                                 }
    295 
    296                                 if(path_link == &path->head) {
    297                                         return EOK;
    298                                 }
    299                                 else {
    300                                         return 1;
    301                                 }                                               
    302                        
    303                         break;
    304 
    305                 default:
    306                         return EINVAL;
    307         }
    308 }
    309 
     350                break;
     351
     352        default:
     353                return EINVAL;
     354        }
     355}
     356
     357/*---------------------------------------------------------------------------*/
    310358/**
    311359 * Allocates and initializes new usage path structure.
    … …  
    329377}
    330378
     379/*---------------------------------------------------------------------------*/
    331380/**
    332381 * Releases given usage path structure.
    … …  
    345394}
    346395
    347 
     396/*---------------------------------------------------------------------------*/
    348397/**
    349398 * Clone content of given usage path to the new one
    … …  
    352401 * @return New copy of given usage path structure
    353402 */
    354 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
     403usb_hid_report_path_t *usb_hid_report_path_clone(
     404        usb_hid_report_path_t *usage_path)
    355405{
    356406        link_t *path_link;
    … …  
    371421        path_link = usage_path->head.next;
    372422        while(path_link != &usage_path->head) {
    373                 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t,
    374                                               link);
     423                path_item = list_get_instance(path_link,
     424                        usb_hid_report_usage_path_t, link);
     425
    375426                new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
    376427                if(new_path_item == NULL) {
    … …  
    392443}
    393444
    394 
     445/*---------------------------------------------------------------------------*/
    395446/**
    396447 * Sets report id in usage path structure
    … …  
    400451 * @return Error code
    401452 */
    402 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
     453int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path,
     454        uint8_t report_id)
    403455{
    404456        if(path == NULL){

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

    r88be3a0b r6bfaab5  
    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;

  • uspace/lib/usbhost/src/device_keeper.c

    r88be3a0b r6bfaab5  
    158158}
    159159
    160 /** Find devman handled assigned to USB address.
     160/** Find devman handle assigned to USB address.
     161 * Intentionally refuse to find handle of default address.
    161162 *
    162163 * @param[in] instance Device keeper structure to use.
    … …  
    170171        assert(instance);
    171172        fibril_mutex_lock(&instance->guard);
    172         if ((address < 0) || (address >= USB_ADDRESS_COUNT)) {
     173        if ((address <= 0) || (address >= USB_ADDRESS_COUNT)) {
    173174                fibril_mutex_unlock(&instance->guard);
    174175                return false;
Note: See TracChangeset for help on using the changeset viewer.