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

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