Changes in / [fcbcaae9:563ead9] in mainline


Ignore:
Files:
6 added
3 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    rfcbcaae9 r563ead9  
    77*.map
    88*.disasm
    9 *.lo
    10 *.la
    11 *.so.*
    12 *.so0
    139_link.ld
    1410./*.iso

  • uspace/Makefile.common

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

  • uspace/app/lsusb/main.c

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

  • uspace/app/mkbd/main.c

    rfcbcaae9 r563ead9  
    4545#include <devmap.h>
    4646#include <usb/dev/hub.h>
    47 #include <usb/hc.h>
     47#include <usb/host.h>
     48#include <usb/driver.h>
    4849#include <usb/dev/pipes.h>
    4950
    … …  
    172173                /* Try to get its address. */
    173174                if (!addr_found) {
    174                         addr = usb_hc_get_address_by_handle(dev_handle);
     175                        addr = usb_device_get_assigned_address(dev_handle);
    175176                        if (addr >= 0) {
    176177                                addr_found = true;

  • uspace/app/usbinfo/main.c

    rfcbcaae9 r563ead9  
    4343#include <devman.h>
    4444#include <devmap.h>
    45 #include <usb/hc.h>
     45#include <usb/dev/hc.h>
    4646#include <usb/dev/pipes.h>
     47#include <usb/host.h>
     48#include <usb/driver.h>
    4749#include "usbinfo.h"
     50
     51static 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
     82static 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}
    48163
    49164static void print_usage(char *app_name)
    … …  
    185300                devman_handle_t hc_handle = 0;
    186301                usb_address_t dev_addr = 0;
    187                 int rc = usb_resolve_device_handle(devpath,
    188                     &hc_handle, &dev_addr, NULL);
    189                 if (rc != EOK) {
     302                bool found = resolve_hc_handle_and_dev_addr(devpath,
     303                    &hc_handle, &dev_addr);
     304                if (!found) {
    190305                        fprintf(stderr, NAME ": device `%s' not found "
    191306                            "or not of USB kind, skipping.\n",

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

    rfcbcaae9 r563ead9  
    3838#include <fibril.h>
    3939#include <ddf/driver.h>
    40 #include <usb/hc.h> /* usb_hc_connection_t */
     40#include <usb/dev/hc.h> /* usb_hc_connection_t */
    4141
    4242typedef uint16_t port_status_t;

  • uspace/lib/usb/Makefile

    rfcbcaae9 r563ead9  
    3737        src/ddfiface.c \
    3838        src/debug.c \
     39        src/driver.c \
    3940        src/dump.c \
    40         src/hc.c \
    41         src/resolve.c \
     41        src/host.c \
    4242        src/usb.c
    4343

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

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

  • uspace/lib/usbdev/Makefile

    rfcbcaae9 r563ead9  
    4646        src/pipesio.c \
    4747        src/recognise.c \
    48         src/request.c
     48        src/request.c \
     49        src/usbdevice.c
    4950
    5051include $(USPACE_PREFIX)/Makefile.common

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

    rfcbcaae9 r563ead9  
    3939
    4040#include <sys/types.h>
    41 #include <usb/hc.h>
     41#include <usb/dev/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);
     65int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t,
     66    devman_handle_t *);
    6567
    6668#endif

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

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

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

    rfcbcaae9 r563ead9  
    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 */
     129int 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}
    122145
    123146static void unregister_control_endpoint_on_default_address(

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

    rfcbcaae9 r563ead9  
    3636#include <usb/dev/pipes.h>
    3737#include <usb/debug.h>
    38 #include <usb/hc.h>
     38#include <usb/driver.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 */
     106usb_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;
    99127}
    100128

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

    rfcbcaae9 r563ead9  
    2727 */
    2828
    29 /** @addtogroup libusb
     29/** @addtogroup libusbhid
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief USB HID Report descriptor item tags.
     33 * @brief USB HID parser.
    3434 */
    35 #ifndef LIBUSB_HID_REPORT_ITEMS_H_
    36 #define LIBUSB_HID_REPORT_ITEMS_H_
     35#ifndef LIBUSBHID_HID_REPORT_ITEMS_H_
     36#define LIBUSBHID_HID_REPORT_ITEMS_H_
    3737
    3838#include <stdint.h>
    3939
    40 /*---------------------------------------------------------------------------*/
    41 /*
     40/**
    4241 * Item prefix
    4342 */
    44 
    45 /** Returns size of item data in bytes */
    4643#define USB_HID_ITEM_SIZE(data)         ((uint8_t)(data & 0x3))
    47 
    48 /** Returns item tag */
    4944#define USB_HID_ITEM_TAG(data)          ((uint8_t)((data & 0xF0) >> 4))
    50 
    51 /** Returns class of item tag */
    5245#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. */
    5646#define USB_HID_ITEM_IS_LONG(data)      (data == 0xFE)
    5747
    58 /*---------------------------------------------------------------------------*/
    59 /*
     48
     49/**
    6050 * Extended usage macros
    6151 */
    62 
    63 /** Recognizes if the given usage is extended (contains also usage page).  */
    6452#define USB_HID_IS_EXTENDED_USAGE(usage)        ((usage & 0xFFFF0000) != 0)
    65 
    66 /** Cuts usage page of the extended usage. */
    6753#define USB_HID_EXTENDED_USAGE_PAGE(usage)      ((usage & 0xFFFF0000) >> 16)
    68 
    69 /** Cuts usage of the extended usage */
    7054#define USB_HID_EXTENDED_USAGE(usage)           (usage & 0xFFFF)
    7155
    72 /*---------------------------------------------------------------------------*/
    73 /*
     56/**
    7457 * Input/Output/Feature Item flags
    7558 */
    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  */
     59/** Constant (1) / Variable (0) */
    8260#define USB_HID_ITEM_FLAG_CONSTANT(flags)       ((flags & 0x1) == 0x1)
    83 
    84 /**
    85  * Indicates whether the item creates variable (1) or array (0) data fields in
    86  * reports.
    87  */
     61/** Variable (1) / Array (0) */
    8862#define USB_HID_ITEM_FLAG_VARIABLE(flags)       ((flags & 0x2) == 0x2)
    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  */
     63/** Absolute / Relative*/
    9664#define USB_HID_ITEM_FLAG_RELATIVE(flags)       ((flags & 0x4) == 0x4)
    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  */
     65/** Wrap / No Wrap */
    10566#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  */
    11267#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  */
    11968#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  */
    12769#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  */
    13570#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  */
    14371#define USB_HID_ITEM_FLAG_BUFFERED(flags)       ((flags & 0x100) == 0x100)
    14472
    145 /*---------------------------------------------------------------------------*/
    146 
    14773/* MAIN ITEMS */
    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  */
     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
    18078#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  */
    18679#define USB_HID_REPORT_TAG_END_COLLECTION       0xC
    18780
    188 /*---------------------------------------------------------------------------*/
     81/* GLOBAL ITEMS */
     82#define USB_HID_TAG_CLASS_GLOBAL                        0x1
     83#define USB_HID_REPORT_TAG_USAGE_PAGE           0x0
     84#define USB_HID_REPORT_TAG_LOGICAL_MINIMUM      0x1
     85#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
     88#define USB_HID_REPORT_TAG_UNIT_EXPONENT        0x5
     89#define USB_HID_REPORT_TAG_UNIT                         0x6
     90#define USB_HID_REPORT_TAG_REPORT_SIZE          0x7
     91#define USB_HID_REPORT_TAG_REPORT_ID            0x8
     92#define USB_HID_REPORT_TAG_REPORT_COUNT         0x9
     93#define USB_HID_REPORT_TAG_PUSH                         0xA
     94#define USB_HID_REPORT_TAG_POP                          0xB
    18995
    190 /* GLOBAL ITEMS */
    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  */
    204 #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  */
    212 #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  */
    218 #define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM      0x2
    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  */
    235 #define USB_HID_REPORT_TAG_UNIT_EXPONENT        0x5
    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  */
    246 #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  */
    256 #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  */
    263 #define USB_HID_REPORT_TAG_REPORT_COUNT         0x9
    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 /*---------------------------------------------------------------------------*/
    27696
    27797/* LOCAL ITEMS */
    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  */
     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
    315103#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  */
    321104#define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM   0x5
    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 /*---------------------------------------------------------------------------*/
     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
    351109
    352110#endif

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

    rfcbcaae9 r563ead9  
    2727 */
    2828
    29 /** @addtogroup libusb
     29/** @addtogroup libusbhid
    3030 * @{
    3131 */
    … …  
    3333 * USB HID report descriptor and report data parser
    3434 */
    35 #ifndef LIBUSB_HIDDESCRIPTOR_H_
    36 #define LIBUSB_HIDDESCRIPTOR_H_
     35#ifndef LIBUSBHID_HIDDESCRIPTOR_H_
     36#define LIBUSBHID_HIDDESCRIPTOR_H_
    3737
    3838#include <stdint.h>
    … …  
    4242#include <usb/hid/hidtypes.h>
    4343
     44
     45/*
     46 * Descriptor parser functions
     47 */
     48
     49/** */
    4450int usb_hid_parse_report_descriptor(usb_hid_report_t *report,
    4551                                    const uint8_t *data, size_t size);
    4652
     53/** */
    4754void usb_hid_free_report(usb_hid_report_t *report);
    4855
     56/** */
    4957void usb_hid_descriptor_print(usb_hid_report_t *report);
    5058
     59
    5160int usb_hid_report_init(usb_hid_report_t *report);
    52 
    5361int usb_hid_report_append_fields(usb_hid_report_t *report,
    5462                                 usb_hid_report_item_t *report_item);
    5563
    5664usb_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 
    5865int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
    5966                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    60 
    6167int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    6268                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    63 
    6469int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    6570                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    66 
    6771int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    6872                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
    6973
    7074void usb_hid_descriptor_print_list(link_t *head);
    71 
    7275void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item);
    73 
    7476void usb_hid_free_report_list(link_t *head);
    75 
    7677usb_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 
    8381#endif
    8482/**

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

    rfcbcaae9 r563ead9  
    2727 */
    2828
    29 /** @addtogroup libusb
     29/** @addtogroup libusbhid
    3030 * @{
    3131 */
    … …  
    3333 * USB HID report descriptor and report data parser
    3434 */
    35 #ifndef LIBUSB_HIDPATH_H_
    36 #define LIBUSB_HIDPATH_H_
     35#ifndef LIBUSBHID_HIDPATH_H_
     36#define LIBUSBHID_HIDPATH_H_
    3737
    3838#include <usb/hid/hidparser.h>
    … …  
    4040#include <adt/list.h>
    4141
    42 
    43 /*---------------------------------------------------------------------------*/
    4442/**
    45  * Flags of usage paths comparison modes.
    46  *
     43 * Description of path of usage pages and usages in report descriptor
    4744 */
    48 /** Wanted usage path must be exactly the same as the searched one.
    49  * This option cannot be combined with the others.
    50  */
     45/** Wanted usage path must be exactly the same as the searched one */
    5146#define USB_HID_PATH_COMPARE_STRICT             0
    52 
    53 /**
    54  * Wanted usage path must be the suffix in the searched one.
    55  */
     47/** Wanted usage path must be the suffix in the searched one */
    5648#define USB_HID_PATH_COMPARE_END                1
    57 
    58 /**
    59  * Only usage page are compared along the usage path.
    60  * This option can be combined with others.
    61  */
     49/** */
    6250#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    2
    63 
    64 /**
    65  * Searched usage page must be prefix of the other one.
    66  */
     51/** Searched usage page must be prefix of the other one */
    6752#define USB_HID_PATH_COMPARE_BEGIN              4
    68 
    69 /**
    70  * Searched couple of usage page and usage can be anywhere in usage path.
    71  * This option is deprecated.
    72  */
     53/** Searched couple of usage page and usage can be anywhere in usage path */
    7354#define USB_HID_PATH_COMPARE_ANYWHERE           8
    7455
    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  */
     56
     57/** Collection usage path structure */
    8158typedef struct {
    82         /** Usage page of report item. Zero when usage page can be changed. */
     59        /** */
    8360        uint32_t usage_page;
    84         /** Usage of report item. Zero when usage can be changed. */   
     61        /** */ 
    8562        uint32_t usage;
    8663
    87         /** Attribute of Collection tag in report descriptor*/
    8864        uint8_t flags;
    89 
    90         /** Linked list structure*/
     65        /** */
    9166        link_t link;
    9267} usb_hid_report_usage_path_t;
    9368
    94 
    95 /*---------------------------------------------------------------------------*/
    96 /**
    97  * USB HID usage path structure.
    98  * */
     69/** */
    9970typedef struct {
    100         /** Length of usage path */     
     71        /** */ 
    10172        int depth;     
    102 
    103         /** Report id. Zero is reserved and means that report id is not used. */
    10473        uint8_t report_id;
    10574       
    106         /** Linked list structure. */   
     75        /** */ 
    10776        link_t link; /* list */
    10877
    109         /** Head of the list of usage path items. */
    110         link_t head;
     78        link_t head; /* head of list of usage paths */
    11179
    11280} usb_hid_report_path_t;
    11381
    114 /*---------------------------------------------------------------------------*/
     82/** */
    11583usb_hid_report_path_t *usb_hid_report_path(void);
    11684
     85/** */
    11786void usb_hid_report_path_free(usb_hid_report_path_t *path);
    11887
     88/** */
    11989int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path,
    12090                                      uint8_t report_id);
    12191
     92/** */
    12293int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
    12394                                    int32_t usage_page, int32_t usage);
    12495
     96/** */
    12597void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
    12698
     99/** */
    127100void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
    128101
     102/** */
    129103void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path,
    130104                                  int32_t tag, int32_t data);
    131105
     106/** */
    132107int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path,
    133108                                      usb_hid_report_path_t *path, int flags);
    134109
     110/** */
    135111usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path);
    136112

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

    rfcbcaae9 r563ead9  
    2727 */
    2828
    29 /** @addtogroup libusb
     29/** @addtogroup libusbhid
    3030 * @{
    3131 */
    3232/** @file
    33  * Basic data structures for USB HID Report descriptor and report parser.
    34  */
    35 #ifndef LIBUSB_HIDTYPES_H_
    36 #define LIBUSB_HIDTYPES_H_
     33 * USB HID report descriptor and report data parser
     34 */
     35#ifndef LIBUSBHID_HIDTYPES_H_
     36#define LIBUSBHID_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  */
    4641#define USB_HID_MAX_USAGES      0xffff
    4742
    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  */
     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
    7647typedef enum {
    7748        USB_HID_REPORT_TYPE_INPUT = 1,
    … …  
    8051} usb_hid_report_type_t;
    8152
    82 /*---------------------------------------------------------------------------*/
    83 
    84 /**
    85  * Description of all reports described in one report descriptor.
    86  */
    87 typedef struct {
    88         /** Count of available reports. */
     53
     54typedef struct {
     55        /** */
    8956        int report_count;
    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. */
     57        link_t reports;         /** list of usb_hid_report_description_t */
     58
    9559        link_t collection_paths;
    96 
    97         /** Length of list of usage paths. */
    9860        int collection_paths_count;
    9961
    100         /** Flag whether report ids are used. */
    10162        int use_report_ids;
    102 
    103         /** Report id of last parsed report. */
    10463        uint8_t last_report_id;
    10564       
    10665} usb_hid_report_t;
    107 /*---------------------------------------------------------------------------*/
    108 
    109 /**
    110  * Description of one concrete report
    111  */
    112 typedef struct {
    113         /** Report id. Zero when no report id is used. */
     66
     67typedef struct {
    11468        uint8_t report_id;
    115 
    116         /** Type of report */
    11769        usb_hid_report_type_t type;
    11870
    119         /** Bit length of the report */
    12071        size_t bit_length;
    121 
    122         /** Number of items in report */
    12372        size_t item_length;
    12473       
    125         /** Linked list of report items in report */
    126         link_t report_items;
    127 
    128         /** Linked list of descriptions. */
     74        link_t report_items;    /** list of report items (fields) */
     75
    12976        link_t link;
    13077} usb_hid_report_description_t;
    131 /*---------------------------------------------------------------------------*/
    132 
    133 /**
    134  * Description of one field/item in report
    135  */
    136 typedef struct {
    137         /** Bit offset of the field */
     78
     79typedef struct {
     80
    13881        int offset;
    139 
    140         /** Bit size of the field */
    14182        size_t size;
    14283
    143         /** Usage page. Zero when usage page can be changed. */
    14484        uint16_t usage_page;
    145 
    146         /** Usage. Zero when usage can be changed. */
    14785        uint16_t usage;
    14886
    149         /** Item's attributes */
    15087        uint8_t item_flags;
    151 
    152         /** Usage/Collection path of the field. */
    15388        usb_hid_report_path_t *collection_path;
    15489
    155         /**
    156          * The lowest valid logical value (value with the device operates)
    157          */
    15890        int32_t logical_minimum;
    159 
    160         /**
    161          * The greatest valid logical value
    162          */
    16391        int32_t logical_maximum;
    164 
    165         /**
    166          * The lowest valid physical value (value with the system operates)
    167          */
    16892        int32_t physical_minimum;
    169 
    170         /** The greatest valid physical value */
    17193        int32_t physical_maximum;
    172 
    173         /** The lowest valid usage index */
    17494        int32_t usage_minimum;
    175 
    176         /** The greatest valid usage index */
    17795        int32_t usage_maximum;
    178        
    179         /** Unit of the value */
    18096        uint32_t unit;
    181 
    182         /** Unit exponent */
    18397        uint32_t unit_exponent;
    18498
    185         /** Array of possible usages */
    18699        uint32_t *usages;
    187 
    188         /** Size of the array of usages */
    189100        size_t usages_count;
    190101
    191         /** Parsed value */
    192102        int32_t value;
    193103
    194         /** List to another report items */
    195104        link_t link;
    196105} usb_hid_report_field_t;
    197106
    198 /*---------------------------------------------------------------------------*/
     107
    199108
    200109/**
    201  * State table for report descriptor parsing
     110 * state table
    202111 */
    203112typedef struct {
    … …  
    205114        int32_t id;
    206115       
    207         /** Extended usage page */
     116        /** */
    208117        uint16_t extended_usage_page;
    209 
    210         /** Array of usages specified for this item */
    211118        uint32_t usages[USB_HID_MAX_USAGES];
    212        
    213         /** Length of usages array */
    214119        int usages_count;
    215120
    216         /** Usage page*/
     121        /** */
    217122        uint32_t usage_page;
    218123
    219         /** Minimum valid usage index */       
     124        /** */ 
    220125        int32_t usage_minimum;
    221        
    222         /** Maximum valid usage index */       
     126        /** */ 
    223127        int32_t usage_maximum;
    224        
    225         /** Minimum valid logical value */     
     128        /** */ 
    226129        int32_t logical_minimum;
    227        
    228         /** Maximum valid logical value */     
     130        /** */ 
    229131        int32_t logical_maximum;
    230 
    231         /** Length of the items in bits*/       
     132        /** */ 
    232133        int32_t size;
    233 
    234         /** COunt of items*/   
     134        /** */ 
    235135        int32_t count;
    236 
    237         /**  Bit offset of the item in report */       
     136        /** */ 
    238137        size_t offset;
    239 
    240         /** Unit exponent */   
     138        /** */ 
    241139        int32_t unit_exponent;
    242         /** Unit of the value */       
     140        /** */ 
    243141        int32_t unit;
    244142
    245         /** String index */
     143        /** */
    246144        uint32_t string_index;
    247 
    248         /** Minimum valid string index */       
     145        /** */ 
    249146        uint32_t string_minimum;
    250 
    251         /** Maximum valid string index */       
     147        /** */ 
    252148        uint32_t string_maximum;
    253 
    254         /** The designator index */     
     149        /** */ 
    255150        uint32_t designator_index;
    256 
    257         /** Minimum valid designator value*/   
     151        /** */ 
    258152        uint32_t designator_minimum;
    259 
    260         /** Maximum valid designator value*/   
     153        /** */ 
    261154        uint32_t designator_maximum;
    262 
    263         /** Minimal valid physical value*/     
     155        /** */ 
    264156        int32_t physical_minimum;
    265 
    266         /** Maximal valid physical value */     
     157        /** */ 
    267158        int32_t physical_maximum;
    268159
    269         /** Items attributes*/ 
     160        /** */ 
    270161        uint8_t item_flags;
    271162
    272         /** Report type */
    273163        usb_hid_report_type_t type;
    274164
    275165        /** current collection path*/   
    276166        usb_hid_report_path_t *usage_path;
    277 
    278         /** Unused*/   
     167        /** */ 
    279168        link_t link;
    280169
    281170        int in_delimiter;
    282171} usb_hid_report_item_t;
    283 /*---------------------------------------------------------------------------*/
    284 /**
    285  * Enum of the keyboard modifiers
    286  */
     172
     173/** HID parser callbacks for IN items. */
     174typedef 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
    287185typedef enum {
    288186        USB_HID_MOD_LCTRL = 0x01,
    … …  
    308206        USB_HID_MOD_RGUI
    309207};
    310 /*---------------------------------------------------------------------------*/
    311 
    312208
    313209#endif
Note: See TracChangeset for help on using the changeset viewer.