Changes in / [fa8d346:8d3f198] in mainline


Ignore:
Files:
3 added
8 deleted
36 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    rfa8d346 r8d3f198  
    77*.map
    88*.disasm
     9*.lo
     10*.la
     11*.so.*
     12*.so0
    913_link.ld
    1014./*.iso

  • uspace/Makefile.common

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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/hc.c

    rfa8d346 r8d3f198  
    565565        bzero(&instance->rh, sizeof(instance->rh));
    566566        /* Init queues */
    567         hc_init_transfer_lists(instance);
     567        const int ret = hc_init_transfer_lists(instance);
     568        if (ret != EOK) {
     569                return ret;
     570        }
    568571
    569572        /*Init HCCA */

  • uspace/drv/uhci-hcd/Makefile

    rfa8d346 r8d3f198  
    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.h

    rfa8d346 r8d3f198  
    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

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

    rfa8d346 r8d3f198  
    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"
    … …  
    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

    rfa8d346 r8d3f198  
    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
    … …  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    3636#include <arch/barrier.h>
    3737
     38
    3839#include "transfer_list.h"
     40#include "batch.h"
    3941
    4042static void transfer_list_remove_batch(
    … …  
    5860                return ENOMEM;
    5961        }
    60         uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
     62        const uint32_t queue_head_pa = addr_to_phys(instance->queue_head);
    6163        usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n",
    6264            name, instance->queue_head, queue_head_pa);
    … …  
    9092{
    9193        assert(instance);
     94        assert(instance->queue_head);
    9295        assert(next);
    93         if (!instance->queue_head)
    94                 return;
    9596        /* Set queue_head.next to point to the follower */
    9697        qh_set_next_qh(instance->queue_head, next->queue_head);
    … …  
    137138        write_barrier();
    138139
    139         /* Add to the driver list */
     140        /* Add to the driver's list */
    140141        list_append(&batch->link, &instance->batch_list);
    141142
    … …  
    160161        link_t *current = instance->batch_list.next;
    161162        while (current != &instance->batch_list) {
    162                 link_t *next = current->next;
     163                link_t * const next = current->next;
    163164                usb_transfer_batch_t *batch =
    164165                    usb_transfer_batch_from_link(current);
    … …  
    182183        fibril_mutex_lock(&instance->guard);
    183184        while (!list_empty(&instance->batch_list)) {
    184                 link_t *current = instance->batch_list.next;
     185                link_t * const current = instance->batch_list.next;
    185186                usb_transfer_batch_t *batch =
    186187                    usb_transfer_batch_from_link(current);

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

    rfa8d346 r8d3f198  
    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

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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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         usb_log_warning("Requested %zu bytes, current allocator can't handle "
    77             "that amount, pray that the standard malloc will suffice.", size);
    78         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);
    7983}
    8084/*----------------------------------------------------------------------------*/
    … …  
    8690        if (!addr)
    8791                return;
    88         if (slab_in_range_g(addr))
    89                 return slab_free_g(addr);
    9092        free(addr);
    9193}
    … …  
    98100{
    99101        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
    100         assert(free_address); /* TODO: remove this assert */
    101102        if (free_address == 0)
    102103                return NULL;

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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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);
    … …  
    283289        usb_log_error("%s: Don't know how to remove device %" PRIun ".\n",
    284290            port->id_string, port->attached_device);
     291        port->attached_device = 0;
    285292        return ENOTSUP;
    286293}

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

    rfa8d346 r8d3f198  
    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/lib/usb/Makefile

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    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

    rfa8d346 r8d3f198  
    120120}
    121121
    122 /** Get handle of USB device with given address.
    123  *
    124  * @param[in] connection Opened connection to host controller.
    125  * @param[in] address Address of device in question.
    126  * @param[out] handle Where to write the device handle.
    127  * @return Error code.
    128  */
    129 int usb_hc_get_handle_by_address(usb_hc_connection_t *connection,
    130     usb_address_t address, devman_handle_t *handle)
    131 {
    132         CHECK_CONNECTION(connection);
    133 
    134         sysarg_t tmp;
    135         int rc = async_req_2_1(connection->hc_phone,
    136             DEV_IFACE_ID(USBHC_DEV_IFACE),
    137             IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
    138             address, &tmp);
    139         if ((rc == EOK) && (handle != NULL)) {
    140                 *handle = tmp;
    141         }
    142 
    143         return rc;
    144 }
    145122
    146123static void unregister_control_endpoint_on_default_address(

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

    rfa8d346 r8d3f198  
    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/include/usb/hid/hid_report_items.h

    rfa8d346 r8d3f198  
    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/*
    5060 * Extended usage macros
    5161 */
     62
     63/** Recognizes if the given usage is extended (contains also usage page).  */
    5264#define USB_HID_IS_EXTENDED_USAGE(usage)        ((usage & 0xFFFF0000) != 0)
     65
     66/** Cuts usage page of the extended usage. */
    5367#define USB_HID_EXTENDED_USAGE_PAGE(usage)      ((usage & 0xFFFF0000) >> 16)
     68
     69/** Cuts usage of the extended usage */
    5470#define USB_HID_EXTENDED_USAGE(usage)           (usage & 0xFFFF)
    5571
    56 /**
     72/*---------------------------------------------------------------------------*/
     73/*
    5774 * Input/Output/Feature Item flags
    5875 */
    59 /** 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 */
    6082#define USB_HID_ITEM_FLAG_CONSTANT(flags)       ((flags & 0x1) == 0x1)
    61 /** Variable (1) / Array (0) */
     83
     84/**
     85 * Indicates whether the item creates variable (1) or array (0) data fields in
     86 * reports.
     87 */
    6288#define USB_HID_ITEM_FLAG_VARIABLE(flags)       ((flags & 0x2) == 0x2)
    63 /** 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 */
    6496#define USB_HID_ITEM_FLAG_RELATIVE(flags)       ((flags & 0x4) == 0x4)
    65 /** Wrap / No Wrap */
     97
     98/**
     99 * Indicates whether the data “rolls over” when reaching either the extreme
     100 * high or low value. For example, a dial that can spin freely 360 degrees
     101 * might output values from 0 to 10. If Wrap is indicated, the next value
     102 * reported after passing the 10 position in the increasing direction would be
     103 * 0.
     104 */
    66105#define USB_HID_ITEM_FLAG_WRAP(flags)           ((flags & 0x8) == 0x8)
     106
     107/**
     108 * Indicates whether the raw data from the device has been processed in some
     109 * way, and no longer represents a linear relationship between what is
     110 * measured and the data that is reported.
     111 */
    67112#define USB_HID_ITEM_FLAG_LINEAR(flags)         ((flags & 0x10) == 0x10)
     113
     114/**
     115 * Indicates whether the control has a preferred state to which it will return
     116 * when the user is not physically interacting with the control. Push buttons
     117 * (as opposed to toggle buttons) and self- centering joysticks are examples.
     118 */
    68119#define USB_HID_ITEM_FLAG_PREFERRED(flags)      ((flags & 0x20) == 0x20)
     120
     121/**
     122 * Indicates whether the control has a state in which it is not sending
     123 * meaningful data. One possible use of the null state is for controls that
     124 * require the user to physically interact with the control in order for it to
     125 * report useful data.
     126 */
    69127#define USB_HID_ITEM_FLAG_POSITION(flags)       ((flags & 0x40) == 0x40)
     128
     129/**
     130 * Indicates whether the Feature or Output control's value should be changed
     131 * by the host or not.  Volatile output can change with or without host
     132 * interaction. To avoid synchronization problems, volatile controls should be
     133 * relative whenever possible.
     134 */
    70135#define USB_HID_ITEM_FLAG_VOLATILE(flags)       ((flags & 0x80) == 0x80)
     136
     137/**
     138 * Indicates that the control emits a fixed-size stream of bytes. The contents
     139 * of the data field are determined by the application. The contents of the
     140 * buffer are not interpreted as a single numeric quantity. Report data
     141 * defined by a Buffered Bytes item must be aligned on an 8-bit boundary.
     142 */
    71143#define USB_HID_ITEM_FLAG_BUFFERED(flags)       ((flags & 0x100) == 0x100)
    72144
     145/*---------------------------------------------------------------------------*/
     146
    73147/* MAIN ITEMS */
    74 #define USB_HID_TAG_CLASS_MAIN                          0x0
    75 #define USB_HID_REPORT_TAG_INPUT                        0x8
    76 #define USB_HID_REPORT_TAG_OUTPUT                       0x9
    77 #define USB_HID_REPORT_TAG_FEATURE                      0xB
     148
     149/**
     150 * Main items are used to either define or group certain types of data fields
     151 * within a Report descriptor.
     152 */
     153#define USB_HID_TAG_CLASS_MAIN                  0x0
     154
     155/**
     156 * An Input item describes information about the data provided by one or more
     157 * physical controls. An application can use this information to interpret the
     158 * data provided by the device. All data fields defined in a single item share
     159 * an identical data format.
     160 */
     161#define USB_HID_REPORT_TAG_INPUT                0x8
     162
     163/**
     164 * The Output item is used to define an output data field in a report. This
     165 * item is similar to an Input item except it describes data sent to the
     166 * device—for example, LED states.
     167 */
     168#define USB_HID_REPORT_TAG_OUTPUT               0x9
     169
     170/**
     171 * Feature items describe device configuration information that can be sent to
     172 * the device.
     173 */
     174#define USB_HID_REPORT_TAG_FEATURE              0xB
     175
     176/**
     177 * A Collection item identifies a relationship between two or more data
     178 * (Input, Output, or Feature.)
     179 */
    78180#define USB_HID_REPORT_TAG_COLLECTION           0xA
     181
     182/**
     183 * While the Collection item opens a collection of data, the End Collection
     184 * item closes a collection.
     185 */
    79186#define USB_HID_REPORT_TAG_END_COLLECTION       0xC
    80187
     188/*---------------------------------------------------------------------------*/
     189
    81190/* GLOBAL ITEMS */
    82 #define USB_HID_TAG_CLASS_GLOBAL                        0x1
     191
     192/**
     193 * Global items describe rather than define data from a control.
     194 */
     195#define USB_HID_TAG_CLASS_GLOBAL                0x1
     196
     197/**
     198 * Unsigned integer specifying the current Usage Page. Since a usage are 32
     199 * bit values, Usage Page items can be used to conserve space in a report
     200 * descriptor by setting the high order 16 bits of a subsequent usages. Any
     201 * usage that follows which is defines 16 bits or less is interpreted as a
     202 * Usage ID and concatenated with the Usage Page to form a 32 bit Usage.
     203 */
    83204#define USB_HID_REPORT_TAG_USAGE_PAGE           0x0
     205
     206/**
     207 * Extent value in logical units. This is the minimum value that a variable
     208 * or array item will report. For example, a mouse reporting x position values
     209 * from 0 to 128 would have a Logical Minimum of 0 and a Logical Maximum of
     210 * 128.
     211 */
    84212#define USB_HID_REPORT_TAG_LOGICAL_MINIMUM      0x1
     213
     214/**
     215 * Extent value in logical units. This is the maximum value that a variable
     216 * or array item will report.
     217 */
    85218#define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM      0x2
    86 #define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3
    87 #define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4
     219
     220/**
     221 * Minimum value for the physical extent of a variable item. This represents
     222 * the Logical Minimum with units applied to it.
     223 */
     224#define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM     0x3
     225
     226/**
     227 * Maximum value for the physical extent of a variable item.
     228 */
     229#define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM     0x4
     230
     231/**
     232 * Value of the unit exponent in base 10. See the table later in this section
     233 * for more information.
     234 */
    88235#define USB_HID_REPORT_TAG_UNIT_EXPONENT        0x5
    89 #define USB_HID_REPORT_TAG_UNIT                         0x6
     236
     237/**
     238 * Unit values.
     239 */
     240#define USB_HID_REPORT_TAG_UNIT                 0x6
     241
     242/**
     243 * Unsigned integer specifying the size of the report fields in bits. This
     244 * allows the parser to build an item map for the report handler to use.
     245 */
    90246#define USB_HID_REPORT_TAG_REPORT_SIZE          0x7
     247
     248/**
     249 * Unsigned value that specifies the Report ID. If a Report ID tag is used
     250 * anywhere in Report descriptor, all data reports for the device are preceded
     251 * by a single byte ID field. All items succeeding the first Report ID tag but
     252 * preceding a second Report ID tag are included in a report prefixed by a
     253 * 1-byte ID. All items succeeding the second but preceding a third Report ID
     254 * tag are included in a second report prefixed by a second ID, and so on.
     255 */
    91256#define USB_HID_REPORT_TAG_REPORT_ID            0x8
     257
     258/**
     259 * Unsigned integer specifying the number of data fields for the item;
     260 * determines how many fields are included in the report for this particular
     261 * item (and consequently how many bits are added to the report).
     262 */
    92263#define USB_HID_REPORT_TAG_REPORT_COUNT         0x9
    93 #define USB_HID_REPORT_TAG_PUSH                         0xA
    94 #define USB_HID_REPORT_TAG_POP                          0xB
    95 
     264
     265/**
     266 * Places a copy of the global item state table on the stack.
     267 */
     268#define USB_HID_REPORT_TAG_PUSH                 0xA
     269
     270/**
     271 * Replaces the item state table with the top structure from the stack.
     272 */
     273#define USB_HID_REPORT_TAG_POP                  0xB
     274
     275/*---------------------------------------------------------------------------*/
    96276
    97277/* LOCAL ITEMS */
    98 #define USB_HID_TAG_CLASS_LOCAL                                 0x2
    99 #define USB_HID_REPORT_TAG_USAGE                                0x0
    100 #define USB_HID_REPORT_TAG_USAGE_MINIMUM                0x1
    101 #define USB_HID_REPORT_TAG_USAGE_MAXIMUM                0x2
    102 #define USB_HID_REPORT_TAG_DESIGNATOR_INDEX             0x3
     278
     279/**
     280 * Local item tags define characteristics of controls. These items do not
     281 * carry over to the next Main item. If a Main item defines more than one
     282 * control, it may be preceded by several similar Local item tags. For
     283 * example, an Input item may have several Usage tags associated with it, one
     284 * for each control.
     285 */
     286#define USB_HID_TAG_CLASS_LOCAL                 0x2
     287
     288/**
     289 * Usage index for an item usage; represents a suggested usage for the item or
     290 * collection. In the case where an item represents multiple controls, a Usage
     291 * tag may suggest a usage for every variable or element in an array.
     292 */
     293#define USB_HID_REPORT_TAG_USAGE                0x0
     294
     295/**
     296 * Defines the starting usage associated with an array or bitmap.
     297 */
     298#define USB_HID_REPORT_TAG_USAGE_MINIMUM        0x1
     299
     300/**
     301 * Defines the ending usage associated with an array or bitmap.
     302 */
     303#define USB_HID_REPORT_TAG_USAGE_MAXIMUM        0x2
     304
     305/**
     306 * Determines the body part used for a control. Index points to a designator
     307 * in the Physical descriptor.
     308 */
     309#define USB_HID_REPORT_TAG_DESIGNATOR_INDEX     0x3
     310
     311/**
     312 * Defines the index of the starting designator associated with an array or
     313 * bitmap.
     314 */
    103315#define USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM   0x4
     316
     317/**
     318 * Defines the index of the ending designator associated with an array or
     319 * bitmap.
     320 */
    104321#define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM   0x5
    105 #define USB_HID_REPORT_TAG_STRING_INDEX                 0x7
    106 #define USB_HID_REPORT_TAG_STRING_MINIMUM               0x8
    107 #define USB_HID_REPORT_TAG_STRING_MAXIMUM               0x9
    108 #define USB_HID_REPORT_TAG_DELIMITER                    0xA
     322
     323/**
     324 * String index for a String descriptor; allows a string to be associated with
     325 * a particular item or control.
     326 */
     327#define USB_HID_REPORT_TAG_STRING_INDEX         0x7
     328
     329/**
     330 * Specifies the first string index when assigning a group of sequential
     331 * strings to controls in an array or bitmap.
     332 */
     333#define USB_HID_REPORT_TAG_STRING_MINIMUM       0x8
     334
     335/**
     336 * Specifies the last string index when assigning a group of sequential
     337 * strings to controls in an array or bitmap.
     338 */
     339#define USB_HID_REPORT_TAG_STRING_MAXIMUM       0x9
     340
     341/**
     342 * Defines the beginning or end of a set of local items (1 = open set, 0 =
     343 * close set).
     344 *
     345 * Usages other than the first (most preferred) usage defined are not
     346 * accessible by system software.
     347 */
     348#define USB_HID_REPORT_TAG_DELIMITER            0xA
     349
     350/*---------------------------------------------------------------------------*/
    109351
    110352#endif

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

    rfa8d346 r8d3f198  
    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
    44 
    45 /*
    46  * Descriptor parser functions
    47  */
    48 
    49 /** */
    5044int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
    5145                                    const uint8_t *data, size_t size);
    5246
    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);
    6153int usb_hid_report_append_fields(usb_hid_report_t *report,
    6254                                 usb_hid_report_item_t *report_item);
    6355
    6456usb_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);
     57
    6558int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
    6659                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     60
    6761int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    6862                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     63
    6964int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    7065                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     66
    7167int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    7268                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    7369
    7470void usb_hid_descriptor_print_list(link_t *head);
     71
    7572void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
     73
    7674void usb_hid_free_report_list(link_t *head);
     75
    7776usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
     77
    7878uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
    7979
    8080usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path);
     81
     82
    8183#endif
    8284/**

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

    rfa8d346 r8d3f198  
    6565                           usb_hid_report_type_t type);
    6666
     67size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id,
     68                           usb_hid_report_type_t type);
     69
     70
    6771/** Makes the output report buffer by translated given data */
    6872int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
    6973                                    uint8_t *buffer, size_t size);
     74
    7075
    7176/** */
    … …  
    7782
    7883/** */
    79 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report,
     84uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report,
    8085                                     uint8_t report_id,
    8186                                     usb_hid_report_type_t type);

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

    rfa8d346 r8d3f198  
    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/*---------------------------------------------------------------------------*/
    4244/**
    43  * Description of path of usage pages and usages in report descriptor
     45 * Flags of usage paths comparison modes.
     46 *
    4447 */
    45 /** Wanted usage path must be exactly the same as the searched one */
     48/** Wanted usage path must be exactly the same as the searched one.
     49 * This option cannot be combined with the others.
     50 */
    4651#define USB_HID_PATH_COMPARE_STRICT             0
    47 /** Wanted usage path must be the suffix in the searched one */
     52
     53/**
     54 * Wanted usage path must be the suffix in the searched one.
     55 */
    4856#define USB_HID_PATH_COMPARE_END                1
    49 /** */
     57
     58/**
     59 * Only usage page are compared along the usage path.
     60 * This option can be 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. */
    73104        uint8_t report_id;
    74105       
    75         /** */ 
     106        /** Linked list structure. */   
    76107        link_t link; /* list */
    77108
    78         link_t head; /* head of list of usage paths */
     109        /** Head of the list of usage path items. */
     110        link_t head;
    79111
    80112} usb_hid_report_path_t;
    81113
    82 /** */
     114/*---------------------------------------------------------------------------*/
    83115usb_hid_report_path_t *usb_hid_report_path(void);
    84116
    85 /** */
    86117void usb_hid_report_path_free(usb_hid_report_path_t *path);
    87118
    88 /** */
    89119int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path,
    90120                                      uint8_t report_id);
    91121
    92 /** */
    93122int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
    94123                                    int32_t usage_page, int32_t usage);
    95124
    96 /** */
    97125void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
    98126
    99 /** */
    100127void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
    101128
    102 /** */
    103129void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path,
    104130                                  int32_t tag, int32_t data);
    105131
    106 /** */
    107132int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path,
    108133                                      usb_hid_report_path_t *path, int flags);
    109134
    110 /** */
    111135usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path);
    112136

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

    rfa8d346 r8d3f198  
    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/*---------------------------------------------------------------------------*/
     42
     43/**
     44 * Maximum amount of specified usages for one report item
     45 */
    4146#define USB_HID_MAX_USAGES      0xffff
    4247
    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 
     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 * Report type
     75 */
    4776typedef enum {
    4877        USB_HID_REPORT_TYPE_INPUT = 1,
    … …  
    5180} usb_hid_report_type_t;
    5281
    53 
     82/*---------------------------------------------------------------------------*/
     83
     84/**
     85 * Description of all reports described in one report descriptor.
     86 */
    5487typedef struct {
    55         /** */
     88        /** Count of available reports. */
    5689        int report_count;
    57         link_t reports;         /** list of usb_hid_report_description_t */
    58 
     90
     91        /** Head of linked list of description of reports. */
     92        link_t reports;
     93
     94        /** Head of linked list of all used usage/collection paths. */
    5995        link_t collection_paths;
     96
     97        /** Length of list of usage paths. */
    6098        int collection_paths_count;
    6199
     100        /** Flag whether report ids are used. */
    62101        int use_report_ids;
     102
     103        /** Report id of last parsed report. */
    63104        uint8_t last_report_id;
    64105       
    65106} usb_hid_report_t;
    66 
     107/*---------------------------------------------------------------------------*/
     108
     109/**
     110 * Description of one concrete report
     111 */
    67112typedef struct {
     113        /** Report id. Zero when no report id is used. */
    68114        uint8_t report_id;
     115
     116        /** Type of report */
    69117        usb_hid_report_type_t type;
    70118
     119        /** Bit length of the report */
    71120        size_t bit_length;
     121
     122        /** Number of items in report */
    72123        size_t item_length;
    73124       
    74         link_t report_items;    /** list of report items (fields) */
    75 
     125        /** Linked list of report items in report */
     126        link_t report_items;
     127
     128        /** Linked list of descriptions. */
    76129        link_t link;
    77130} usb_hid_report_description_t;
    78 
     131/*---------------------------------------------------------------------------*/
     132
     133/**
     134 * Description of one field/item in report
     135 */
    79136typedef struct {
    80 
     137        /** Bit offset of the field */
    81138        int offset;
     139
     140        /** Bit size of the field */
    82141        size_t size;
    83142
     143        /** Usage page. Zero when usage page can be changed. */
    84144        uint16_t usage_page;
     145
     146        /** Usage. Zero when usage can be changed. */
    85147        uint16_t usage;
    86148
     149        /** Item's attributes */
    87150        uint8_t item_flags;
     151
     152        /** Usage/Collection path of the field. */
    88153        usb_hid_report_path_t *collection_path;
    89154
     155        /**
     156         * The lowest valid logical value (value with the device operates)
     157         */
    90158        int32_t logical_minimum;
     159
     160        /**
     161         * The greatest valid logical value
     162         */
    91163        int32_t logical_maximum;
     164
     165        /**
     166         * The lowest valid physical value (value with the system operates)
     167         */
    92168        int32_t physical_minimum;
     169
     170        /** The greatest valid physical value */
    93171        int32_t physical_maximum;
     172
     173        /** The lowest valid usage index */
    94174        int32_t usage_minimum;
     175
     176        /** The greatest valid usage index */
    95177        int32_t usage_maximum;
     178       
     179        /** Unit of the value */
    96180        uint32_t unit;
     181
     182        /** Unit exponent */
    97183        uint32_t unit_exponent;
    98184
     185        /** Array of possible usages */
    99186        uint32_t *usages;
     187
     188        /** Size of the array of usages */
    100189        size_t usages_count;
    101190
     191        /** Parsed value */
    102192        int32_t value;
    103193
     194        /** List to another report items */
    104195        link_t link;
    105196} usb_hid_report_field_t;
    106197
    107 
    108 
    109 /**
    110  * state table
     198/*---------------------------------------------------------------------------*/
     199
     200/**
     201 * State table for report descriptor parsing
    111202 */
    112203typedef struct {
    … …  
    114205        int32_t id;
    115206       
    116         /** */
     207        /** Extended usage page */
    117208        uint16_t extended_usage_page;
     209
     210        /** Array of usages specified for this item */
    118211        uint32_t usages[USB_HID_MAX_USAGES];
     212       
     213        /** Length of usages array */
    119214        int usages_count;
    120215
    121         /** */
     216        /** Usage page*/
    122217        uint32_t usage_page;
    123218
    124         /** */ 
     219        /** Minimum valid usage index */       
    125220        int32_t usage_minimum;
    126         /** */ 
     221       
     222        /** Maximum valid usage index */       
    127223        int32_t usage_maximum;
    128         /** */ 
     224       
     225        /** Minimum valid logical value */     
    129226        int32_t logical_minimum;
    130         /** */ 
     227       
     228        /** Maximum valid logical value */     
    131229        int32_t logical_maximum;
    132         /** */ 
     230
     231        /** Length of the items in bits*/       
    133232        int32_t size;
    134         /** */ 
     233
     234        /** COunt of items*/   
    135235        int32_t count;
    136         /** */ 
     236
     237        /**  Bit offset of the item in report */       
    137238        size_t offset;
    138         /** */ 
     239
     240        /** Unit exponent */   
    139241        int32_t unit_exponent;
    140         /** */ 
     242        /** Unit of the value */       
    141243        int32_t unit;
    142244
    143         /** */
     245        /** String index */
    144246        uint32_t string_index;
    145         /** */ 
     247
     248        /** Minimum valid string index */       
    146249        uint32_t string_minimum;
    147         /** */ 
     250
     251        /** Maximum valid string index */       
    148252        uint32_t string_maximum;
    149         /** */ 
     253
     254        /** The designator index */     
    150255        uint32_t designator_index;
    151         /** */ 
     256
     257        /** Minimum valid designator value*/   
    152258        uint32_t designator_minimum;
    153         /** */ 
     259
     260        /** Maximum valid designator value*/   
    154261        uint32_t designator_maximum;
    155         /** */ 
     262
     263        /** Minimal valid physical value*/     
    156264        int32_t physical_minimum;
    157         /** */ 
     265
     266        /** Maximal valid physical value */     
    158267        int32_t physical_maximum;
    159268
    160         /** */ 
     269        /** Items attributes*/ 
    161270        uint8_t item_flags;
    162271
     272        /** Report type */
    163273        usb_hid_report_type_t type;
    164274
    165275        /** current collection path*/   
    166276        usb_hid_report_path_t *usage_path;
    167         /** */ 
     277
     278        /** Unused*/   
    168279        link_t link;
    169280
    170281        int in_delimiter;
    171282} usb_hid_report_item_t;
    172 
    173 /** HID parser callbacks for IN items. */
    174 typedef struct {
    175         /** Callback for keyboard.
    176          *
    177          * @param key_codes Array of pressed key (including modifiers).
    178          * @param count Length of @p key_codes.
    179          * @param arg Custom argument.
    180          */
    181         void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg);
    182 } usb_hid_report_in_callbacks_t;
    183 
    184 
     283/*---------------------------------------------------------------------------*/
     284/**
     285 * Enum of the keyboard modifiers
     286 */
    185287typedef enum {
    186288        USB_HID_MOD_LCTRL = 0x01,
    … …  
    206308        USB_HID_MOD_RGUI
    207309};
     310/*---------------------------------------------------------------------------*/
     311
    208312
    209313#endif

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

    rfa8d346 r8d3f198  
    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 
     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/*---------------------------------------------------------------------------*/
    7074
    7175/** Returns size of report of specified report id and type in items
    … …  
    9498}
    9599
     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/*---------------------------------------------------------------------------*/
    96125
    97126/** Parse and act upon a HID report.
    … …  
    103132 * @return Error code.
    104133 */
    105 int usb_hid_parse_report(const usb_hid_report_t *report,
    106     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)
    107136{
    108137        link_t *list_item;
    … …  
    139168                                item->value = usb_hid_translate_data(item, data);
    140169               
    141                                 item->usage = USB_HID_EXTENDED_USAGE(item->usages[item->value - item->physical_minimum]);
    142                                 item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(item->usages[item->value - item->physical_minimum]);                             
     170                                item->usage = USB_HID_EXTENDED_USAGE(
     171                                        item->usages[item->value - item->physical_minimum]);
     172                                item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(
     173                                        item->usages[item->value - item->physical_minimum]);                           
    143174
    144175                                usb_hid_report_set_last_item (item->collection_path,
    145                                                               USB_HID_TAG_CLASS_GLOBAL,
    146                                                               item->usage_page);
     176                                        USB_HID_TAG_CLASS_GLOBAL, item->usage_page);
    147177                                usb_hid_report_set_last_item (item->collection_path,
    148                                                               USB_HID_TAG_CLASS_LOCAL,
    149                                                               item->usage);
     178                                    USB_HID_TAG_CLASS_LOCAL, item->usage);
    150179                               
    151180                        }
    … …  
    162191}
    163192
     193/*---------------------------------------------------------------------------*/
    164194/**
    165195 * Translate data from the report as specified in report descriptor item
    … …  
    167197 * @param item Report descriptor item with definition of translation
    168198 * @param data Data to translate
    169  * @param j Index of processed field in report descriptor item
    170199 * @return Translated data
    171200 */
    … …  
    240269}
    241270
    242 /*** OUTPUT API **/
     271/*---------------------------------------------------------------------------*/
     272/* OUTPUT API */
    243273
    244274/**
    … …  
    250280 * @return Returns allocated output buffer for specified output
    251281 */
    252 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id)
     282uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size,
     283        uint8_t report_id)
    253284{
    254285        if(report == NULL) {
    … …  
    260291        usb_hid_report_description_t *report_des = NULL;
    261292        while(report_it != &report->reports) {
    262                 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
    263                 if((report_des->report_id == report_id) && (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
     293                report_des = list_get_instance(report_it,
     294                        usb_hid_report_description_t, link);
     295               
     296                if((report_des->report_id == report_id) &&
     297                        (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){
    264298                        break;
    265299                }
    … …  
    303337 * @return Error code
    304338 */
    305 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,
    306                                     uint8_t *buffer, size_t size)
     339int usb_hid_report_output_translate(usb_hid_report_t *report,
     340        uint8_t report_id, uint8_t *buffer, size_t size)
    307341{
    308342        link_t *item;   
    … …  
    320354        }
    321355
    322         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
    323        
    324356        usb_hid_report_description_t *report_des;
    325         report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT);
     357        report_des = usb_hid_report_find_description (report, report_id,
     358                USB_HID_REPORT_TYPE_OUTPUT);
     359       
    326360        if(report_des == NULL){
    327361                return EINVAL;
    … …  
    333367                report_item = list_get_instance(item, usb_hid_report_field_t, link);
    334368
    335                 usb_log_debug("OUTPUT ITEM usage(%x), value(%x)\n", report_item->usage, report_item->value);
    336                
    337369                if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
    338370                                       
    339371                        // array
    340                         value = usb_hid_translate_data_reverse(report_item, report_item->value);
     372                        value = usb_hid_translate_data_reverse(report_item,
     373                                report_item->value);
     374
    341375                        offset = report_item->offset;
    342376                        length = report_item->size;
    … …  
    344378                else {
    345379                        // variable item
    346                         value  = usb_hid_translate_data_reverse(report_item, report_item->value);
     380                        value  = usb_hid_translate_data_reverse(report_item,
     381                                report_item->value);
     382
    347383                        offset = report_item->offset;
    348384                        length = report_item->size;
    … …  
    353389                if((offset/8) == ((offset+length-1)/8)) {
    354390                        // je to v jednom bytu
    355                         if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) {
     391                        if(((size_t)(offset/8) >= size) ||
     392                                ((size_t)(offset+length-1)/8) >= size) {
    356393                                break; // TODO ErrorCode
    357394                        }
    … …  
    379416                                       
    380417                                        value = value >> (length - ((offset + length) % 8));
    381                                         value = value & ((1 << (length - ((offset + length) % 8))) - 1);
     418                                        value = value &
     419                                                ((1 << (length - ((offset + length) % 8))) - 1);
    382420                               
    383421                                        mask = (1 << (length - ((offset + length) % 8))) - 1;
    … …  
    396434        }
    397435       
    398         usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));
    399 
    400436        return EOK;
    401437}
    402438
     439/*---------------------------------------------------------------------------*/
    403440/**
    404441 * Translate given data for putting them into the outoput report
    … …  
    407444 * @return ranslated value
    408445 */
    409 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value)
     446uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item,
     447        int value)
    410448{
    411449        int ret=0;
    … …  
    431469        }
    432470
    433         ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum;
    434         usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), ret(%x)\n", value, resolution, item->physical_minimum, item->logical_minimum, ret);
     471        ret = ((value - item->physical_minimum) * resolution) +
     472                item->logical_minimum;
     473
     474        usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \
     475                ret(%x)\n", value, resolution, item->physical_minimum,
     476                item->logical_minimum, ret);
    435477       
    436478        if((item->logical_minimum < 0) || (item->logical_maximum < 0)){
    … …  
    440482}
    441483
    442 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
     484/*---------------------------------------------------------------------------*/
     485/**
     486 * Clones given state table
     487 *
     488 * @param item State table to clone
     489 * @return Pointer to the cloned item
     490 */
     491usb_hid_report_item_t *usb_hid_report_item_clone(
     492        const usb_hid_report_item_t *item)
    443493{
    444494        usb_hid_report_item_t *new_report_item;
    … …  
    453503}
    454504
    455 
     505/*---------------------------------------------------------------------------*/
     506/**
     507 * Function for sequence walking through the report. Returns next field in the
     508 * report or the first one when no field is given.
     509 *
     510 * @param report Searched report structure
     511 * @param field Current field. If NULL is given, the first one in the report
     512 * is returned. Otherwise the next one i nthe list is returned.
     513 * @param path Usage path specifying which fields wa are interested in.
     514 * @param flags Flags defining mode of usage paths comparison
     515 * @param type Type of report we search.
     516 * @retval NULL if no field is founded
     517 * @retval Pointer to the founded report structure when founded
     518 */
    456519usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report,
    457                                                         usb_hid_report_field_t *field,
    458                             usb_hid_report_path_t *path, int flags,
    459                             usb_hid_report_type_t type)
    460 {
    461         usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type);
     520        usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags,
     521        usb_hid_report_type_t type)
     522{
     523        usb_hid_report_description_t *report_des = usb_hid_report_find_description(
     524                report, path->report_id, type);
     525
    462526        link_t *field_it;
    463527       
    … …  
    467531
    468532        if(field == NULL){
    469                 // vezmu prvni co mathuje podle path!!
    470533                field_it = report_des->report_items.next;
    471534        }
    … …  
    478541
    479542                if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) {
    480                         usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage);
    481                         if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){
    482                                 usb_hid_report_remove_last_item (field->collection_path);
     543                        usb_hid_report_path_append_item (field->collection_path,
     544                                field->usage_page, field->usage);
     545
     546                        if(usb_hid_report_compare_usage_path(field->collection_path, path,
     547                                flags) == EOK){
     548
     549                                usb_hid_report_remove_last_item(field->collection_path);
    483550                                return field;
    484551                        }
    … …  
    491558}
    492559
    493 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type)
     560/*---------------------------------------------------------------------------*/
     561/**
     562 * Returns next report_id of report of specified type. If zero is given than
     563 * first report_id of specified type is returned (0 is not legal value for
     564 * repotr_id)
     565 *
     566 * @param report_id Current report_id, 0 if there is no current report_id
     567 * @param type Type of searched report
     568 * @param report Report structure inwhich we search
     569 * @retval 0 if report structure is null or there is no specified report
     570 * @retval report_id otherwise
     571 */
     572uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report,
     573        uint8_t report_id, usb_hid_report_type_t type)
    494574{
    495575        if(report == NULL){
    … …  
    500580        link_t *report_it;
    501581       
    502         if(report_id == 0) {
    503                 report_it = usb_hid_report_find_description (report, report_id, type)->link.next;               
     582        if(report_id > 0) {
     583                report_it = usb_hid_report_find_description(report, report_id,
     584                        type)->link.next;               
    504585        }
    505586        else {
    … …  
    508589
    509590        while(report_it != &report->reports) {
    510                 report_des = list_get_instance(report_it, usb_hid_report_description_t, link);
     591                report_des = list_get_instance(report_it,
     592                        usb_hid_report_description_t, link);
     593
    511594                if(report_des->type == type){
    512595                        return report_des->report_id;
    … …  
    517600}
    518601
     602/*---------------------------------------------------------------------------*/
     603/**
     604 * Reset all local items in given state table
     605 *
     606 * @param report_item State table containing current state of report
     607 * descriptor parsing
     608 *
     609 * @return void
     610 */
    519611void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item)
    520612{

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

    rfa8d346 r8d3f198  
    4141#include <assert.h>
    4242
    43 
    44 #define USB_HID_SAME_USAGE(usage1, usage2)      ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0))
    45 #define USB_HID_SAME_USAGE_PAGE(page1, page2)   ((page1 == page2) || (page1 == 0) || (page2 == 0))
    46 
     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/*---------------------------------------------------------------------------*/
    4766/**
    4867 * Appends one item (couple of usage_path and usage) into the usage path
    … …  
    7392}
    7493
     94/*---------------------------------------------------------------------------*/
    7595/**
    7696 * Removes last item from the usage path structure
    … …  
    91111}
    92112
     113/*---------------------------------------------------------------------------*/
    93114/**
    94115 * Nulls last item of the usage path structure.
    … …  
    102123       
    103124        if(!list_empty(&usage_path->head)){     
    104                 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
    105128                memset(item, 0, sizeof(usb_hid_report_usage_path_t));
    106129        }
    107130}
    108131
     132/*---------------------------------------------------------------------------*/
    109133/**
    110134 * Modifies last item of usage path structure by given usage page or usage
    … …  
    137161}
    138162
    139 
     163/*---------------------------------------------------------------------------*/
     164/**
     165 *
     166 *
     167 *
     168 *
     169 */
    140170void usb_hid_print_usage_path(usb_hid_report_path_t *path)
    141171{
    … …  
    147177        while(item != &path->head) {
    148178
    149                 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
    150182                usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
    151183                usb_log_debug("\tUSAGE: %X\n", path_item->usage);
    152184                usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
    153185               
    154                 item = item->next;
    155         }
    156 }
    157 
     186        item = item->next;
     187        }
     188}
     189
     190/*---------------------------------------------------------------------------*/
    158191/**
    159192 * Compares two usage paths structures
    … …  
    198231                        }
    199232
    200                         // projit skrz cestu a kdyz nekde sedi tak vratim EOK
    201                         // dojduli az za konec tak nnesedi
    202233                        report_link = report_path->head.next;
    203234                        path_link = path->head.next;
    204                         path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
     235                        path_item = list_get_instance(path_link,
     236                                usb_hid_report_usage_path_t, link);
    205237
    206238                        while(report_link != &report_path->head) {
    207                                 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
    208                                 if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page)){
     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                                       
    209245                                        if(only_page == 0){
    210                                                 if(USB_HID_SAME_USAGE(report_item->usage, path_item->usage)) {
     246                                                if(USB_HID_SAME_USAGE(report_item->usage,
     247                                                        path_item->usage)) {
     248                                                       
    211249                                                        return EOK;
    212250                                                }
    … …  
    238276                                                 
    239277                                        report_item = list_get_instance(report_link,
    240                                                                         usb_hid_report_usage_path_t,
    241                                                                         link);
     278                        usb_hid_report_usage_path_t, link);
    242279                                                 
    243280                                        path_item = list_get_instance(path_link,
    244                                                                       usb_hid_report_usage_path_t,
    245                                                                       link);           
    246 
    247                                         if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page) ||
    248                                            ((only_page == 0) &&
    249                                             !USB_HID_SAME_USAGE(report_item->usage, path_item->usage))) {
     281                        usb_hid_report_usage_path_t, link);             
     282
     283                                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
     284                                                path_item->usage_page) || ((only_page == 0) &&
     285                                            !USB_HID_SAME_USAGE(report_item->usage,
     286                                                path_item->usage))) {
    250287                                                       
    251288                                                   return 1;
    … …  
    257294                                }
    258295
    259                                 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) ||
    260                                    ((report_link == &report_path->head) && (path_link == &path->head))) {
     296                                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
     297                                        (path_link == &path->head)) ||
     298                                   ((report_link == &report_path->head) &&
     299                                        (path_link == &path->head))) {
     300                                       
    261301                                        return EOK;
    262302                                }
    … …  
    280320                                                 
    281321                                        report_item = list_get_instance(report_link,
    282                                                                         usb_hid_report_usage_path_t,
    283                                                                         link);
     322                                                usb_hid_report_usage_path_t, link);
     323
    284324                                        path_item = list_get_instance(path_link,
    285                                                                       usb_hid_report_usage_path_t,
    286                                                                       link);           
     325                                                usb_hid_report_usage_path_t, link);             
    287326                                                 
    288                                         if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page) ||
    289                                            ((only_page == 0) &&
    290                                             !USB_HID_SAME_USAGE(report_item->usage, path_item->usage))) {
     327                                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
     328                                                path_item->usage_page) || ((only_page == 0) &&
     329                                            !USB_HID_SAME_USAGE(report_item->usage,
     330                                                path_item->usage))) {
     331                                               
    291332                                                        return 1;
    292333                                        } else {
    … …  
    311352}
    312353
     354/*---------------------------------------------------------------------------*/
    313355/**
    314356 * Allocates and initializes new usage path structure.
    … …  
    332374}
    333375
     376/*---------------------------------------------------------------------------*/
    334377/**
    335378 * Releases given usage path structure.
    … …  
    348391}
    349392
    350 
     393/*---------------------------------------------------------------------------*/
    351394/**
    352395 * Clone content of given usage path to the new one
    … …  
    355398 * @return New copy of given usage path structure
    356399 */
    357 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path)
     400usb_hid_report_path_t *usb_hid_report_path_clone(
     401        usb_hid_report_path_t *usage_path)
    358402{
    359403        link_t *path_link;
    … …  
    374418        path_link = usage_path->head.next;
    375419        while(path_link != &usage_path->head) {
    376                 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, 
     420                path_item = list_get_instance(path_link, usb_hid_report_usage_path_t,
    377421                                              link);
    378422                new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
    … …  
    395439}
    396440
    397 
     441/*---------------------------------------------------------------------------*/
    398442/**
    399443 * Sets report id in usage path structure
    … …  
    403447 * @return Error code
    404448 */
    405 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
     449int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path,
     450        uint8_t report_id)
    406451{
    407452        if(path == NULL){
Note: See TracChangeset for help on using the changeset viewer.