Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 74b1e40 in mainline


Ignore:
Timestamp:
2011-05-20T12:49:13Z (11 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master
Children:
5499a8b, c9256c5
Parents:
7941bd6
Message:

hid parser header's doxygen doc

Location:
uspace/lib/usbhid/include/usb/hid
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usbhid/include/usb/hid/hid_report_items.h

    r7941bd6 r74b1e40  
    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

    r7941bd6 r74b1e40  
    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/hidpath.h

    r7941bd6 r74b1e40  
    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

    r7941bd6 r74b1e40  
    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
Note: See TracChangeset for help on using the changeset viewer.