LUFA/Drivers/USB/Class/Host/HIDParser.h

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *  \brief USB Human Interface Device (HID) Class report descriptor parser.
  33  *
  34  *  This file allows for the easy parsing of complex HID report descriptors, which describes the data that
  35  *  a HID device transmits to the host. It also provides an easy API for extracting and processing the data
  36  *  elements inside a HID report sent from an attached HID device.
  37  */
  38
  39 /** \ingroup Group_USB
  40  *  @defgroup Group_HIDParser HID Report Parser
  41  *
  42  *  \section Sec_Dependencies Module Source Dependencies
  43  *  The following files must be built with any user project that uses this module:
  44  *    - LUFA/Drivers/USB/Class/Host/HIDParser.c <i>(Makefile source module name: LUFA_SRC_USB)</i>
  45  *
  46  *  \section Module Description
  47  *  Functions, macros, variables, enums and types related to the parsing of HID class device report descriptors.
  48  *
  49  *  The processed HID report is presented back to the user application as a flat structure containing each report
  50  *  item's IN, OUT and FEATURE items along with each item's attributes.
  51  *
  52  *  This library portion also allows for easy setting and retrieval of data from a HID report, including devices
  53  *  with multiple reports on the one HID interface.
  54  *
  55  *  @{
  56  */
  57
  58 #ifndef __HIDPARSER_H__
  59 #define __HIDPARSER_H__
  60
  61         /* Macros: */
  62                 #define __INCLUDE_FROM_USB_DRIVER
  63                 #define __INCLUDE_FROM_HID_DRIVER
  64
  65         /* Includes: */
  66                 #include <string.h>
  67                 #include <stdbool.h>
  68
  69                 #include "HIDReportData.h"
  70                 #include "../Common/HID.h"
  71
  72                 #include "../../../../Common/Common.h"
  73
  74         /* Enable C linkage for C++ Compilers: */
  75                 #if defined(__cplusplus)
  76                         extern "C" {
  77                 #endif
  78
  79         /* Macros: */
  80                 #if !defined(HID_STATETABLE_STACK_DEPTH) || defined(__DOXYGEN__)
  81                         /** Constant indicating the maximum stack depth of the state table. A larger state table
  82                          *  allows for more PUSH/POP report items to be nested, but consumes more memory. By default
  83                          *  this is set to 2 levels (allowing non-nested PUSH items) but this can be overridden by
  84                          *  defining HID_STATETABLE_STACK_DEPTH to another value in the user project makefile, passing the
  85                          *  define to the compiler using the -D compiler switch.
  86                          */
  87                         #define HID_STATETABLE_STACK_DEPTH    2
  88                 #endif
  89
  90                 #if !defined(HID_USAGE_STACK_DEPTH) || defined(__DOXYGEN__)
  91                         /** Constant indicating the maximum stack depth of the usage table. A larger usage table
  92                          *  allows for more USAGE items to be indicated sequentially for REPORT COUNT entries of more than
  93                          *  one, but requires more stack space. By default this is set to 8 levels (allowing for a report
  94                          *  item with a count of 8) but this can be overridden by defining HID_USAGE_STACK_DEPTH to another
  95                          *  value in the user project makefile, passing the define to the compiler using the -D compiler
  96                          *  switch.
  97                          */
  98                         #define HID_USAGE_STACK_DEPTH         8
  99                 #endif
 100
 101                 #if !defined(HID_MAX_COLLECTIONS) || defined(__DOXYGEN__)
 102                         /** Constant indicating the maximum number of COLLECTION items (nested or unnested) that can be
 103                          *  processed in the report item descriptor. A large value allows for more COLLECTION items to be
 104                          *  processed, but consumes more memory. By default this is set to 10 collections, but this can be
 105                          *  overridden by defining HID_MAX_COLLECTIONS to another value in the user project makefile, passing
 106                          *  the define to the compiler using the -D compiler switch.
 107                          */
 108                         #define HID_MAX_COLLECTIONS           10
 109                 #endif
 110
 111                 #if !defined(HID_MAX_REPORTITEMS) || defined(__DOXYGEN__)
 112                         /** Constant indicating the maximum number of report items (IN, OUT or FEATURE) that can be processed
 113                          *  in the report item descriptor and stored in the user HID Report Info structure. A large value allows
 114                          *  for more report items to be stored, but consumes more memory. By default this is set to 20 items,
 115                          *  but this can be overridden by defining HID_MAX_REPORTITEMS to another value in the user project
 116                          *  makefile, and passing the define to the compiler using the -D compiler switch.
 117                          */
 118                         #define HID_MAX_REPORTITEMS           20
 119                 #endif
 120
 121                 #if !defined(HID_MAX_REPORT_IDS) || defined(__DOXYGEN__)
 122                         /** Constant indicating the maximum number of unique report IDs that can be processed in the report item
 123                          *  descriptor for the report size information array in the user HID Report Info structure. A large value
 124                          *  allows for more report ID report sizes to be stored, but consumes more memory. By default this is set
 125                          *  to 10 items, but this can be overridden by defining HID_MAX_REPORT_IDS to another value in the user project
 126                          *  makefile, and passing the define to the compiler using the -D compiler switch. Note that IN, OUT and FEATURE
 127                          *  items sharing the same report ID consume only one size item in the array.
 128                          */
 129                         #define HID_MAX_REPORT_IDS            10
 130                 #endif
 131
 132                 /** Returns the value a given HID report item (once its value has been fetched via \ref USB_GetHIDReportItemInfo())
 133                  *  left-aligned to the given data type. This allows for signed data to be interpreted correctly, by shifting the data
 134                  *  leftwards until the data's sign bit is in the correct position.
 135                  *
 136                  *  \param[in] ReportItem  HID Report Item whose retrieved value is to be aligned.
 137                  *  \param[in] Type        Data type to align the HID report item's value to.
 138                  *
 139                  *  \return Left-aligned data of the given report item's pre-retrieved value for the given datatype.
 140                  */
 141                 #define HID_ALIGN_DATA(ReportItem, Type) ((Type)(ReportItem->Value << ((8 * sizeof(Type)) - ReportItem->Attributes.BitSize)))
 142
 143         /* Public Interface - May be used in end-application: */
 144                 /* Enums: */
 145                         /** Enum for the possible error codes in the return value of the \ref USB_ProcessHIDReport() function. */
 146                         enum HID_Parse_ErrorCodes_t
 147                         {
 148                                 HID_PARSE_Successful                  = 0, /**< Successful parse of the HID report descriptor, no error. */
 149                                 HID_PARSE_HIDStackOverflow            = 1, /**< More than \ref HID_STATETABLE_STACK_DEPTH nested PUSHes in the report. */
 150                                 HID_PARSE_HIDStackUnderflow           = 2, /**< A POP was found when the state table stack was empty. */
 151                                 HID_PARSE_InsufficientReportItems     = 3, /**< More than \ref HID_MAX_REPORTITEMS report items in the report. */
 152                                 HID_PARSE_UnexpectedEndCollection     = 4, /**< An END COLLECTION item found without matching COLLECTION item. */
 153                                 HID_PARSE_InsufficientCollectionPaths = 5, /**< More than \ref HID_MAX_COLLECTIONS collections in the report. */
 154                                 HID_PARSE_UsageListOverflow           = 6, /**< More than \ref HID_USAGE_STACK_DEPTH usages listed in a row. */
 155                                 HID_PARSE_InsufficientReportIDItems   = 7, /**< More than \ref HID_MAX_REPORT_IDS report IDs in the device. */
 156                                 HID_PARSE_NoUnfilteredReportItems     = 8, /**< All report items from the device were filtered by the filtering callback routine. */
 157                         };
 158
 159                 /* Type Defines: */
 160                         /** \brief HID Parser Report Item Min/Max Structure.
 161                          *
 162                          *  Type define for an attribute with both minimum and maximum values (e.g. Logical Min/Max).
 163                          */
 164                         typedef struct
 165                         {
 166                                 uint32_t                     Minimum; /**< Minimum value for the attribute. */
 167                                 uint32_t                     Maximum; /**< Maximum value for the attribute. */
 168                         } HID_MinMax_t;
 169
 170                         /** \brief HID Parser Report Item Unit Structure.
 171                          *
 172                          *  Type define for the Unit attributes of a report item.
 173                          */
 174                         typedef struct
 175                         {
 176                                 uint32_t                     Type;     /**< Unit type (refer to HID specifications for details). */
 177                                 uint8_t                      Exponent; /**< Unit exponent (refer to HID specifications for details). */
 178                         } HID_Unit_t;
 179
 180                         /** \brief HID Parser Report Item Usage Structure.
 181                          *
 182                          *  Type define for the Usage attributes of a report item.
 183                          */
 184                         typedef struct
 185                         {
 186                                 uint16_t                     Page;   /**< Usage page of the report item. */
 187                                 uint16_t                     Usage;  /**< Usage of the report item. */
 188                         } HID_Usage_t;
 189
 190                         /** \brief HID Parser Report Item Collection Path Structure.
 191                          *
 192                          *  Type define for a COLLECTION object. Contains the collection attributes and a reference to the
 193                          *  parent collection if any.
 194                          */
 195                         typedef struct CollectionPath
 196                         {
 197                                 uint8_t                      Type;   /**< Collection type (e.g. "Generic Desktop"). */
 198                                 HID_Usage_t                  Usage;  /**< Collection usage. */
 199                                 struct CollectionPath*       Parent; /**< Reference to parent collection, or NULL if root collection. */
 200                         } HID_CollectionPath_t;
 201
 202                         /** \brief HID Parser Report Item Attributes Structure.
 203                          *
 204                          *  Type define for all the data attributes of a report item, except flags.
 205                          */
 206                         typedef struct
 207                         {
 208                                 uint8_t                      BitSize;  /**< Size in bits of the report item's data. */
 209
 210                                 HID_Usage_t                  Usage;    /**< Usage of the report item. */
 211                                 HID_Unit_t                   Unit;     /**< Unit type and exponent of the report item. */
 212                                 HID_MinMax_t                 Logical;  /**< Logical minimum and maximum of the report item. */
 213                                 HID_MinMax_t                 Physical; /**< Physical minimum and maximum of the report item. */
 214                         } HID_ReportItem_Attributes_t;
 215
 216                         /** \brief HID Parser Report Item Details Structure.
 217                          *
 218                          *  Type define for a report item (IN, OUT or FEATURE) layout attributes and other details.
 219                          */
 220                         typedef struct
 221                         {
 222                                 uint16_t                     BitOffset;      /**< Bit offset in the IN, OUT or FEATURE report of the item. */
 223                                 uint8_t                      ItemType;       /**< Report item type, a value in HID_ReportItemTypes_t. */
 224                                 uint16_t                     ItemFlags;      /**< Item data flags, such as constant/variable, etc. */
 225                                 uint8_t                      ReportID;       /**< Report ID this item belongs to, or 0x00 if device has only one report */
 226                                 HID_CollectionPath_t*        CollectionPath; /**< Collection path of the item. */
 227
 228                                 HID_ReportItem_Attributes_t  Attributes;     /**< Report item attributes. */
 229
 230                                 uint32_t                     Value;          /**< Current value of the report item - use \ref HID_ALIGN_DATA() when processing
 231                                                                               *   a retrieved value so that it is aligned to a specific type.
 232                                                                               */
 233                                 uint32_t                     PreviousValue;  /**< Previous value of the report item. */
 234                         } HID_ReportItem_t;
 235
 236                         /** \brief HID Parser Report Size Structure.
 237                          *
 238                          *  Type define for a report item size information structure, to retain the size of a device's reports by ID.
 239                          */
 240                         typedef struct
 241                         {
 242                                 uint8_t                      ReportID; /**< Report ID of the report within the HID interface. */
 243                                 uint16_t                     ReportSizeBits[3]; /**< Total number of bits in each report type for the given Report ID,
 244                                                                                  *   indexed by the \ref HID_ReportItemTypes_t enum.
 245                                                                                                                                  */
 246                         } HID_ReportSizeInfo_t;
 247
 248                         /** \brief HID Parser State Structure.
 249                          *
 250                          *  Type define for a complete processed HID report, including all report item data and collections.
 251                          */
 252                         typedef struct
 253                         {
 254                                 uint8_t                      TotalReportItems; /**< Total number of report items stored in the
 255                                                                                 *   ReportItems array.
 256                                                                                 */
 257                                 HID_ReportItem_t             ReportItems[HID_MAX_REPORTITEMS]; /**< Report items array, including
 258                                                                                             *   all IN, OUT and FEATURE items.
 259                                                                                                 */
 260                                 HID_CollectionPath_t         CollectionPaths[HID_MAX_COLLECTIONS]; /**< All collection items, referenced
 261                                                                                                     *   by the report items.
 262                                                                                                     */
 263                                 uint8_t                      TotalDeviceReports; /**< Number of reports within the HID interface */
 264                                 HID_ReportSizeInfo_t         ReportIDSizes[HID_MAX_REPORT_IDS]; /**< Report sizes for each report in the interface */
 265                                 uint16_t                     LargestReportSizeBits; /**< Largest report that the attached device will generate, in bits */
 266                                 bool                         UsingReportIDs; /**< Indicates if the device has at least one REPORT ID
 267                                                                               *   element in its HID report descriptor.
 268                                                                               */
 269                         } HID_ReportInfo_t;
 270
 271                 /* Function Prototypes: */
 272                         /** Function to process a given HID report returned from an attached device, and store it into a given
 273                          *  \ref HID_ReportInfo_t structure.
 274                          *
 275                          *  \param[in]  ReportData  Buffer containing the device's HID report table.
 276                          *  \param[in]  ReportSize  Size in bytes of the HID report table.
 277                          *  \param[out] ParserData  Pointer to a \ref HID_ReportInfo_t instance for the parser output.
 278                          *
 279                          *  \return A value in the \ref HID_Parse_ErrorCodes_t enum.
 280                          */
 281                         uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
 282                                                      uint16_t ReportSize,
 283                                                      HID_ReportInfo_t* const ParserData) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
 284
 285                         /** Extracts the given report item's value out of the given HID report and places it into the Value
 286                          *  member of the report item's \ref HID_ReportItem_t structure.
 287                          *
 288                          *  When called on a report with an item that exists in that report, this copies the report item's Value
 289                          *  to it's PreviousValue element for easy checking to see if an item's value has changed before processing
 290                          *  a report. If the given item does not exist in the report, the function does not modify the report item's
 291                          *  data.
 292                          *
 293                          *  \param[in]     ReportData  Buffer containing an IN or FEATURE report from an attached device.
 294                          *  \param[in,out] ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array.
 295                          *
 296                          *  \returns Boolean true if the item to retrieve was located in the given report, false otherwise.
 297                          */
 298                         bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
 299                                                       HID_ReportItem_t* const ReportItem) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
 300
 301                         /** Retrieves the given report item's value out of the Value member of the report item's
 302                          *  \ref HID_ReportItem_t structure and places it into the correct position in the HID report
 303                          *  buffer. The report buffer is assumed to have the appropriate bits cleared before calling
 304                          *  this function (i.e., the buffer should be explicitly cleared before report values are added).
 305                          *
 306                          *  When called, this copies the report item's Value element to it's PreviousValue element for easy
 307                          *  checking to see if an item's value has changed before sending a report.
 308                          *
 309                          *  If the device has multiple HID reports, the first byte in the report is set to the report ID of the given item.
 310                          *
 311                          *  \param[out] ReportData  Buffer holding the current OUT or FEATURE report data.
 312                          *  \param[in]  ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array.
 313                          */
 314                         void USB_SetHIDReportItemInfo(uint8_t* ReportData,
 315                                                       HID_ReportItem_t* const ReportItem) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
 316
 317                         /** Retrieves the size of a given HID report in bytes from it's Report ID.
 318                          *
 319                          *  \param[in] ParserData  Pointer to a \ref HID_ReportInfo_t instance containing the parser output.
 320                          *  \param[in] ReportID    Report ID of the report whose size is to be retrieved.
 321                          *  \param[in] ReportType  Type of the report whose size is to be determined, a valued from the
 322                          *                         \ref HID_ReportItemTypes_t enum.
 323                          *
 324                          *  \return Size of the report in bytes, or 0 if the report does not exist.
 325                          */
 326                         uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
 327                                                       const uint8_t ReportID,
 328                                                       const uint8_t ReportType) ATTR_CONST ATTR_NON_NULL_PTR_ARG(1);
 329
 330                         /** Callback routine for the HID Report Parser. This callback <b>must</b> be implemented by the user code when
 331                          *  the parser is used, to determine what report IN, OUT and FEATURE item's information is stored into the user
 332                          *  HID_ReportInfo_t structure. This can be used to filter only those items the application will be using, so that
 333                          *  no RAM is wasted storing the attributes for report items which will never be referenced by the application.
 334                          *
 335                          *  \param[in] CurrentItem  Pointer to the current report item for user checking.
 336                          *
 337                          *  \return Boolean true if the item should be stored into the HID_ReportInfo_t structure, false if it should be ignored.
 338                          */
 339                         bool CALLBACK_HIDParser_FilterHIDReportItem(HID_ReportItem_t* const CurrentItem);
 340
 341         /* Private Interface - For use in library only: */
 342         #if !defined(__DOXYGEN__)
 343                 /* Type Defines: */
 344                         typedef struct
 345                         {
 346                                  HID_ReportItem_Attributes_t Attributes;
 347                                  uint8_t                     ReportCount;
 348                                  uint8_t                     ReportID;
 349                         } HID_StateTable_t;
 350         #endif
 351
 352         /* Disable C linkage for C++ Compilers: */
 353                 #if defined(__cplusplus)
 354                         }
 355                 #endif
 356
 357 #endif
 358
 359 /** @} */