LUFA/Drivers/USB/Class/Common/HIDParser.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  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 #define  __INCLUDE_FROM_USB_DRIVER
  32 #define  __INCLUDE_FROM_HID_DRIVER
  33 #include "HIDParser.h"
  34
  35 uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
  36                              uint16_t ReportSize,
  37                              HID_ReportInfo_t* const ParserData)
  38 {
  39         HID_StateTable_t      StateTable[HID_STATETABLE_STACK_DEPTH];
  40         HID_StateTable_t*     CurrStateTable          = &StateTable[0];
  41         HID_CollectionPath_t* CurrCollectionPath      = NULL;
  42         HID_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];
  43         uint16_t              UsageList[HID_USAGE_STACK_DEPTH];
  44         uint8_t               UsageListSize           = 0;
  45         HID_MinMax_t          UsageMinMax             = {0, 0};
  46
  47         memset(ParserData,       0x00, sizeof(HID_ReportInfo_t));
  48         memset(CurrStateTable,   0x00, sizeof(HID_StateTable_t));
  49         memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
  50
  51         ParserData->TotalDeviceReports = 1;
  52
  53         while (ReportSize)
  54         {
  55                 uint8_t  HIDReportItem  = *ReportData;
  56                 uint32_t ReportItemData = 0;
  57
  58                 ReportData++;
  59                 ReportSize--;
  60
  61                 switch (HIDReportItem & HID_RI_DATA_SIZE_MASK)
  62                 {
  63                         case HID_RI_DATA_BITS_32:
  64                                 ReportItemData  = le32_to_cpu(*((uint32_t*)ReportData));
  65                                 ReportSize     -= 4;
  66                                 ReportData     += 4;
  67                                 break;
  68                         case HID_RI_DATA_BITS_16:
  69                                 ReportItemData  = le16_to_cpu(*((uint16_t*)ReportData));
  70                                 ReportSize     -= 2;
  71                                 ReportData     += 2;
  72                                 break;
  73                         case HID_RI_DATA_BITS_8:
  74                                 ReportItemData  = *((uint8_t*)ReportData);
  75                                 ReportSize     -= 1;
  76                                 ReportData     += 1;
  77                                 break;
  78                 }
  79
  80                 switch (HIDReportItem & (HID_RI_TYPE_MASK | HID_RI_TAG_MASK))
  81                 {
  82                         case HID_RI_PUSH(0):
  83                                 if (CurrStateTable == &StateTable[HID_STATETABLE_STACK_DEPTH - 1])
  84                                   return HID_PARSE_HIDStackOverflow;
  85
  86                                 memcpy((CurrStateTable + 1),
  87                                        CurrStateTable,
  88                                        sizeof(HID_ReportItem_t));
  89
  90                                 CurrStateTable++;
  91                                 break;
  92                         case HID_RI_POP(0):
  93                                 if (CurrStateTable == &StateTable[0])
  94                                   return HID_PARSE_HIDStackUnderflow;
  95
  96                                 CurrStateTable--;
  97                                 break;
  98                         case HID_RI_USAGE_PAGE(0):
  99                                 if ((HIDReportItem & HID_RI_DATA_SIZE_MASK) == HID_RI_DATA_BITS_32)
 100                                   CurrStateTable->Attributes.Usage.Page = (ReportItemData >> 16);
 101
 102                                 CurrStateTable->Attributes.Usage.Page       = ReportItemData;
 103                                 break;
 104                         case HID_RI_LOGICAL_MINIMUM(0):
 105                                 CurrStateTable->Attributes.Logical.Minimum  = ReportItemData;
 106                                 break;
 107                         case HID_RI_LOGICAL_MAXIMUM(0):
 108                                 CurrStateTable->Attributes.Logical.Maximum  = ReportItemData;
 109                                 break;
 110                         case HID_RI_PHYSICAL_MINIMUM(0):
 111                                 CurrStateTable->Attributes.Physical.Minimum = ReportItemData;
 112                                 break;
 113                         case HID_RI_PHYSICAL_MAXIMUM(0):
 114                                 CurrStateTable->Attributes.Physical.Maximum = ReportItemData;
 115                                 break;
 116                         case HID_RI_UNIT_EXPONENT(0):
 117                                 CurrStateTable->Attributes.Unit.Exponent    = ReportItemData;
 118                                 break;
 119                         case HID_RI_UNIT(0):
 120                                 CurrStateTable->Attributes.Unit.Type        = ReportItemData;
 121                                 break;
 122                         case HID_RI_REPORT_SIZE(0):
 123                                 CurrStateTable->Attributes.BitSize          = ReportItemData;
 124                                 break;
 125                         case HID_RI_REPORT_COUNT(0):
 126                                 CurrStateTable->ReportCount                 = ReportItemData;
 127                                 break;
 128                         case HID_RI_REPORT_ID(0):
 129                                 CurrStateTable->ReportID                    = ReportItemData;
 130
 131                                 if (ParserData->UsingReportIDs)
 132                                 {
 133                                         CurrReportIDInfo = NULL;
 134
 135                                         for (uint8_t i = 0; i < ParserData->TotalDeviceReports; i++)
 136                                         {
 137                                                 if (ParserData->ReportIDSizes[i].ReportID == CurrStateTable->ReportID)
 138                                                 {
 139                                                         CurrReportIDInfo = &ParserData->ReportIDSizes[i];
 140                                                         break;
 141                                                 }
 142                                         }
 143
 144                                         if (CurrReportIDInfo == NULL)
 145                                         {
 146                                                 if (ParserData->TotalDeviceReports == HID_MAX_REPORT_IDS)
 147                                                   return HID_PARSE_InsufficientReportIDItems;
 148
 149                                                 CurrReportIDInfo = &ParserData->ReportIDSizes[ParserData->TotalDeviceReports++];
 150                                                 memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
 151                                         }
 152                                 }
 153
 154                                 ParserData->UsingReportIDs = true;
 155
 156                                 CurrReportIDInfo->ReportID = CurrStateTable->ReportID;
 157                                 break;
 158                         case HID_RI_USAGE(0):
 159                                 if (UsageListSize == HID_USAGE_STACK_DEPTH)
 160                                   return HID_PARSE_UsageListOverflow;
 161
 162                                 UsageList[UsageListSize++] = ReportItemData;
 163                                 break;
 164                         case HID_RI_USAGE_MINIMUM(0):
 165                                 UsageMinMax.Minimum = ReportItemData;
 166                                 break;
 167                         case HID_RI_USAGE_MAXIMUM(0):
 168                                 UsageMinMax.Maximum = ReportItemData;
 169                                 break;
 170                         case HID_RI_COLLECTION(0):
 171                                 if (CurrCollectionPath == NULL)
 172                                 {
 173                                         CurrCollectionPath = &ParserData->CollectionPaths[0];
 174                                 }
 175                                 else
 176                                 {
 177                                         HID_CollectionPath_t* ParentCollectionPath = CurrCollectionPath;
 178
 179                                         CurrCollectionPath = &ParserData->CollectionPaths[1];
 180
 181                                         while (CurrCollectionPath->Parent != NULL)
 182                                         {
 183                                                 if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])
 184                                                   return HID_PARSE_InsufficientCollectionPaths;
 185
 186                                                 CurrCollectionPath++;
 187                                         }
 188
 189                                         CurrCollectionPath->Parent = ParentCollectionPath;
 190                                 }
 191
 192                                 CurrCollectionPath->Type       = ReportItemData;
 193                                 CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page;
 194
 195                                 if (UsageListSize)
 196                                 {
 197                                         CurrCollectionPath->Usage.Usage = UsageList[0];
 198
 199                                         for (uint8_t i = 0; i < UsageListSize; i++)
 200                                           UsageList[i] = UsageList[i + 1];
 201
 202                                         UsageListSize--;
 203                                 }
 204                                 else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)
 205                                 {
 206                                         CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++;
 207                                 }
 208
 209                                 break;
 210                         case HID_RI_END_COLLECTION(0):
 211                                 if (CurrCollectionPath == NULL)
 212                                   return HID_PARSE_UnexpectedEndCollection;
 213
 214                                 CurrCollectionPath = CurrCollectionPath->Parent;
 215                                 break;
 216                         case HID_RI_INPUT(0):
 217                         case HID_RI_OUTPUT(0):
 218                         case HID_RI_FEATURE(0):
 219                                 for (uint8_t ReportItemNum = 0; ReportItemNum < CurrStateTable->ReportCount; ReportItemNum++)
 220                                 {
 221                                         HID_ReportItem_t NewReportItem;
 222
 223                                         memcpy(&NewReportItem.Attributes,
 224                                                &CurrStateTable->Attributes,
 225                                                sizeof(HID_ReportItem_Attributes_t));
 226
 227                                         NewReportItem.ItemFlags      = ReportItemData;
 228                                         NewReportItem.CollectionPath = CurrCollectionPath;
 229                                         NewReportItem.ReportID       = CurrStateTable->ReportID;
 230
 231                                         if (UsageListSize)
 232                                         {
 233                                                 NewReportItem.Attributes.Usage.Usage = UsageList[0];
 234
 235                                                 for (uint8_t i = 0; i < UsageListSize; i++)
 236                                                   UsageList[i] = UsageList[i + 1];
 237
 238                                                 UsageListSize--;
 239                                         }
 240                                         else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)
 241                                         {
 242                                                 NewReportItem.Attributes.Usage.Usage = UsageMinMax.Minimum++;
 243                                         }
 244
 245                                         uint8_t ItemTypeTag = (HIDReportItem & (HID_RI_TYPE_MASK | HID_RI_TAG_MASK));
 246
 247                                         if (ItemTypeTag == HID_RI_INPUT(0))
 248                                           NewReportItem.ItemType = HID_REPORT_ITEM_In;
 249                                         else if (ItemTypeTag == HID_RI_OUTPUT(0))
 250                                           NewReportItem.ItemType = HID_REPORT_ITEM_Out;
 251                                         else
 252                                           NewReportItem.ItemType = HID_REPORT_ITEM_Feature;
 253
 254                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType];
 255
 256                                         CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize;
 257
 258                                         if (ParserData->LargestReportSizeBits < NewReportItem.BitOffset)
 259                                           ParserData->LargestReportSizeBits = NewReportItem.BitOffset;
 260
 261                                         if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)
 262                                           return HID_PARSE_InsufficientReportItems;
 263
 264                                         memcpy(&ParserData->ReportItems[ParserData->TotalReportItems],
 265                                                &NewReportItem, sizeof(HID_ReportItem_t));
 266
 267                                         if (!(ReportItemData & HID_IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&NewReportItem))
 268                                           ParserData->TotalReportItems++;
 269                                 }
 270
 271                                 break;
 272                 }
 273
 274                 if ((HIDReportItem & HID_RI_TYPE_MASK) == HID_RI_TYPE_MAIN)
 275                 {
 276                         UsageMinMax.Minimum = 0;
 277                         UsageMinMax.Maximum = 0;
 278                         UsageListSize       = 0;
 279                 }
 280         }
 281
 282         if (!(ParserData->TotalReportItems))
 283           return HID_PARSE_NoUnfilteredReportItems;
 284
 285         return HID_PARSE_Successful;
 286 }
 287
 288 bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
 289                               HID_ReportItem_t* const ReportItem)
 290 {
 291         if (ReportItem == NULL)
 292           return false;
 293
 294         uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
 295         uint16_t CurrentBit   = ReportItem->BitOffset;
 296         uint32_t BitMask      = (1 << 0);
 297
 298         if (ReportItem->ReportID)
 299         {
 300                 if (ReportItem->ReportID != ReportData[0])
 301                   return false;
 302
 303                 ReportData++;
 304         }
 305
 306         ReportItem->PreviousValue = ReportItem->Value;
 307         ReportItem->Value = 0;
 308
 309         while (DataBitsRem--)
 310         {
 311                 if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
 312                   ReportItem->Value |= BitMask;
 313
 314                 CurrentBit++;
 315                 BitMask <<= 1;
 316         }
 317
 318         return true;
 319 }
 320
 321 void USB_SetHIDReportItemInfo(uint8_t* ReportData,
 322                               HID_ReportItem_t* const ReportItem)
 323 {
 324         if (ReportItem == NULL)
 325           return;
 326
 327         uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
 328         uint16_t CurrentBit   = ReportItem->BitOffset;
 329         uint32_t BitMask      = (1 << 0);
 330
 331         if (ReportItem->ReportID)
 332         {
 333                 ReportData[0] = ReportItem->ReportID;
 334                 ReportData++;
 335         }
 336
 337         ReportItem->PreviousValue = ReportItem->Value;
 338
 339         while (DataBitsRem--)
 340         {
 341                 if (ReportItem->Value & (1 << (CurrentBit % 8)))
 342                   ReportData[CurrentBit / 8] |= BitMask;
 343
 344                 CurrentBit++;
 345                 BitMask <<= 1;
 346         }
 347 }
 348
 349 uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
 350                               const uint8_t ReportID,
 351                               const uint8_t ReportType)
 352 {
 353         for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)
 354         {
 355                 uint16_t ReportSizeBits = ParserData->ReportIDSizes[i].ReportSizeBits[ReportType];
 356
 357                 if (ParserData->ReportIDSizes[i].ReportID == ReportID)
 358                   return (ReportSizeBits / 8) + ((ReportSizeBits % 8) ? 1 : 0);
 359         }
 360
 361         return 0;
 362 }