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

   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 #include "../../HighLevel/USBMode.h"
  32 #if defined(USB_CAN_BE_HOST)
  33
  34 #include "HIDParser.h"
  35
  36 uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)
  37 {
  38         HID_StateTable_t      StateTable[HID_STATETABLE_STACK_DEPTH];
  39         HID_StateTable_t*     CurrStateTable          = &StateTable[0];
  40         HID_CollectionPath_t* CurrCollectionPath      = NULL;
  41         HID_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];
  42         uint16_t              UsageStack[HID_USAGE_STACK_DEPTH];
  43         uint8_t               UsageStackSize          = 0;
  44
  45         ParserData->TotalReportItems   = 0;
  46         ParserData->TotalDeviceReports = 1;
  47         ParserData->UsingReportIDs     = false;
  48
  49         for (uint8_t CurrCollection = 0; CurrCollection < HID_MAX_COLLECTIONS; CurrCollection++)
  50           ParserData->CollectionPaths[CurrCollection].Parent = NULL;
  51
  52         memset(CurrStateTable,   0x00, sizeof(HID_StateTable_t));
  53         memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
  54
  55         while (ReportSize)
  56         {
  57                 uint8_t  HIDReportItem  = *ReportData;
  58                 uint32_t ReportItemData = 0;
  59
  60                 ReportData++;
  61                 ReportSize--;
  62
  63                 switch (HIDReportItem & DATA_SIZE_MASK)
  64                 {
  65                         case DATA_SIZE_4:
  66                                 ReportItemData  = *((uint32_t*)ReportData);
  67                                 ReportSize     -= 4;
  68                                 ReportData     += 4;
  69                                 break;
  70                         case DATA_SIZE_2:
  71                                 ReportItemData  = *((uint16_t*)ReportData);
  72                                 ReportSize     -= 2;
  73                                 ReportData     += 2;
  74                                 break;
  75                         case DATA_SIZE_1:
  76                                 ReportItemData  = *((uint8_t*)ReportData);
  77                                 ReportSize     -= 1;
  78                                 ReportData     += 1;
  79                                 break;
  80                 }
  81
  82                 switch (HIDReportItem & (TYPE_MASK | TAG_MASK))
  83                 {
  84                         case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
  85                                 if (CurrStateTable == &StateTable[HID_STATETABLE_STACK_DEPTH - 1])
  86                                   return HID_PARSE_HIDStackOverflow;
  87
  88                                 memcpy((CurrStateTable + 1),
  89                                        CurrStateTable,
  90                                        sizeof(HID_ReportItem_t));
  91
  92                                 CurrStateTable++;
  93                                 break;
  94                         case (TYPE_GLOBAL | TAG_GLOBAL_POP):
  95                                 if (CurrStateTable == &StateTable[0])
  96                                   return HID_PARSE_HIDStackUnderflow;
  97
  98                                 CurrStateTable--;
  99                                 break;
 100                         case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
 101                                 CurrStateTable->Attributes.Usage.Page       = ReportItemData;
 102                                 break;
 103                         case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN):
 104                                 CurrStateTable->Attributes.Logical.Minimum  = ReportItemData;
 105                                 break;
 106                         case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX):
 107                                 CurrStateTable->Attributes.Logical.Maximum  = ReportItemData;
 108                                 break;
 109                         case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN):
 110                                 CurrStateTable->Attributes.Physical.Minimum = ReportItemData;
 111                                 break;
 112                         case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX):
 113                                 CurrStateTable->Attributes.Physical.Maximum = ReportItemData;
 114                                 break;
 115                         case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP):
 116                                 CurrStateTable->Attributes.Unit.Exponent    = ReportItemData;
 117                                 break;
 118                         case (TYPE_GLOBAL | TAG_GLOBAL_UNIT):
 119                                 CurrStateTable->Attributes.Unit.Type        = ReportItemData;
 120                                 break;
 121                         case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE):
 122                                 CurrStateTable->Attributes.BitSize          = ReportItemData;
 123                                 break;
 124                         case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT):
 125                                 CurrStateTable->ReportCount                 = ReportItemData;
 126                                 break;
 127                         case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):
 128                                 CurrStateTable->ReportID                    = ReportItemData;
 129
 130                                 if (ParserData->UsingReportIDs)
 131                                 {
 132                                         CurrReportIDInfo = NULL;
 133
 134                                         for (uint8_t i = 0; i < ParserData->TotalDeviceReports; i++)
 135                                         {
 136                                                 if (ParserData->ReportIDSizes[i].ReportID == CurrStateTable->ReportID)
 137                                                 {
 138                                                         CurrReportIDInfo = &ParserData->ReportIDSizes[i];
 139                                                         break;
 140                                                 }
 141                                         }
 142
 143                                         if (CurrReportIDInfo == NULL)
 144                                         {
 145                                                 if (ParserData->TotalDeviceReports++ > HID_MAX_REPORT_IDS)
 146                                                   return HID_PARSE_InsufficientReportIDItems;
 147
 148                                                 CurrReportIDInfo = &ParserData->ReportIDSizes[ParserData->TotalDeviceReports - 1];
 149                                                 memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
 150                                         }
 151                                 }
 152
 153                                 ParserData->UsingReportIDs = true;
 154
 155                                 CurrReportIDInfo->ReportID     = CurrStateTable->ReportID;
 156                                 break;
 157                         case (TYPE_LOCAL | TAG_LOCAL_USAGE):
 158                                 if (UsageStackSize == HID_USAGE_STACK_DEPTH)
 159                                   return HID_PARSE_UsageStackOverflow;
 160
 161                                 UsageStack[UsageStackSize++] = ReportItemData;
 162                                 break;
 163                         case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
 164                                 CurrStateTable->Attributes.Usage.MinMax.Minimum = ReportItemData;
 165                                 break;
 166                         case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):
 167                                 CurrStateTable->Attributes.Usage.MinMax.Maximum = ReportItemData;
 168                                 break;
 169                         case (TYPE_MAIN | TAG_MAIN_COLLECTION):
 170                                 if (CurrCollectionPath == NULL)
 171                                 {
 172                                         CurrCollectionPath = &ParserData->CollectionPaths[0];
 173                                 }
 174                                 else
 175                                 {
 176                                         HID_CollectionPath_t* ParentCollectionPath = CurrCollectionPath;
 177
 178                                         CurrCollectionPath = &ParserData->CollectionPaths[1];
 179
 180                                         while (CurrCollectionPath->Parent != NULL);
 181                                         {
 182                                                 if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])
 183                                                   return HID_PARSE_InsufficientCollectionPaths;
 184
 185                                                 CurrCollectionPath++;
 186                                         }
 187
 188                                         CurrCollectionPath->Parent = ParentCollectionPath;
 189                                 }
 190
 191                                 CurrCollectionPath->Type = ReportItemData;
 192                                 CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page;
 193
 194                                 if (UsageStackSize)
 195                                 {
 196                                         CurrCollectionPath->Usage.Usage = UsageStack[0];
 197
 198                                         for (uint8_t i = 0; i < UsageStackSize; i++)
 199                                           UsageStack[i] = UsageStack[i + 1];
 200
 201                                         UsageStackSize--;
 202                                 }
 203                                 else
 204                                 {
 205                                         CurrCollectionPath->Usage.Usage = 0;
 206                                 }
 207
 208                                 break;
 209                         case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
 210                                 if (CurrCollectionPath == NULL)
 211                                   return HID_PARSE_UnexpectedEndCollection;
 212
 213                                 CurrCollectionPath = CurrCollectionPath->Parent;
 214
 215                                 break;
 216                         case (TYPE_MAIN | TAG_MAIN_INPUT):
 217                         case (TYPE_MAIN | TAG_MAIN_OUTPUT):
 218                         case (TYPE_MAIN | TAG_MAIN_FEATURE):
 219                                 uint8_t Count = CurrStateTable->ReportCount;
 220                                 for (uint8_t ReportItemNum = 0; ReportItemNum < Count; ReportItemNum++)
 221                                 {
 222                                         HID_ReportItem_t NewReportItem;
 223
 224                                         memcpy(&NewReportItem.Attributes,
 225                                                &CurrStateTable->Attributes,
 226                                                sizeof(HID_ReportItem_Attributes_t));
 227
 228                                         NewReportItem.ItemFlags      = ReportItemData;
 229                                         NewReportItem.CollectionPath = CurrCollectionPath;
 230                                         NewReportItem.ReportID       = CurrStateTable->ReportID;
 231
 232                                         if (UsageStackSize)
 233                                         {
 234                                                 NewReportItem.Attributes.Usage.Usage = UsageStack[0];
 235
 236                                                 for (uint8_t i = 0; i < UsageStackSize; i++)
 237                                                   UsageStack[i] = UsageStack[i + 1];
 238
 239                                                 UsageStackSize--;
 240                                         }
 241                                         else
 242                                         {
 243                                                 NewReportItem.Attributes.Usage.Usage = 0;
 244                                         }
 245
 246                                         uint8_t ReportSizeIndex = 0;
 247
 248                                         switch (HIDReportItem & TAG_MASK)
 249                                         {
 250                                                 case TAG_MAIN_INPUT:
 251                                                         NewReportItem.ItemType  = REPORT_ITEM_TYPE_In;
 252                                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_In];
 253
 254                                                         ReportSizeIndex = REPORT_ITEM_TYPE_In;
 255                                                         break;
 256                                                 case TAG_MAIN_OUTPUT:
 257                                                         NewReportItem.ItemType  = REPORT_ITEM_TYPE_Out;
 258                                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_Out];
 259
 260                                                         ReportSizeIndex = REPORT_ITEM_TYPE_Out;
 261                                                         break;
 262                                                 case TAG_MAIN_FEATURE:
 263                                                         NewReportItem.ItemType  = REPORT_ITEM_TYPE_Feature;
 264                                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_Feature];
 265
 266                                                         ReportSizeIndex = REPORT_ITEM_TYPE_Feature;
 267                                                         break;
 268                                         }
 269
 270                                         CurrReportIDInfo->ReportSizeBits[ReportSizeIndex] += CurrStateTable->Attributes.BitSize;
 271
 272                                         if (ParserData->LargestReportSizeBits < CurrReportIDInfo->ReportSizeBits[ReportSizeIndex])
 273                                           ParserData->LargestReportSizeBits = CurrReportIDInfo->ReportSizeBits[ReportSizeIndex];
 274
 275                                         if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&CurrStateTable->Attributes))
 276                                         {
 277                                                 if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)
 278                                                   return HID_PARSE_InsufficientReportItems;
 279
 280                                                 memcpy(&ParserData->ReportItems[ParserData->TotalReportItems],
 281                                                        &NewReportItem, sizeof(HID_ReportItem_t));
 282
 283                                                 ParserData->TotalReportItems++;
 284                                         }
 285                                 }
 286
 287                                 UsageStackSize = 0;
 288
 289                                 break;
 290                 }
 291
 292                 if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)
 293                 {
 294                         CurrStateTable->Attributes.Usage.MinMax.Minimum = 0;
 295                         CurrStateTable->Attributes.Usage.MinMax.Maximum = 0;
 296                         UsageStackSize = 0;
 297                 }
 298         }
 299
 300         if (!(ParserData->TotalReportItems))
 301           return HID_PARSE_NoUnfilteredReportItems;
 302
 303         return HID_PARSE_Successful;
 304 }
 305
 306 bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem)
 307 {
 308         uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
 309         uint16_t CurrentBit   = ReportItem->BitOffset;
 310         uint32_t BitMask      = (1 << 0);
 311
 312         ReportItem->Value = 0;
 313
 314         if (ReportItem->ReportID)
 315         {
 316                 if (ReportItem->ReportID != ReportData[0])
 317                   return false;
 318
 319                 ReportData++;
 320         }
 321
 322         while (DataBitsRem--)
 323         {
 324                 if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
 325                   ReportItem->Value |= BitMask;
 326
 327                 CurrentBit++;
 328                 BitMask <<= 1;
 329         }
 330
 331         return true;
 332 }
 333
 334 void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)
 335 {
 336         uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
 337         uint16_t CurrentBit   = ReportItem->BitOffset;
 338         uint32_t BitMask      = (1 << 0);
 339
 340         if (ReportItem->ReportID)
 341         {
 342                 ReportData[0] = ReportItem->ReportID;
 343                 ReportData++;
 344         }
 345
 346         while (DataBitsRem--)
 347         {
 348                 if (ReportItem->Value & (1 << (CurrentBit % 8)))
 349                   ReportData[CurrentBit / 8] |= BitMask;
 350
 351                 CurrentBit++;
 352                 BitMask <<= 1;
 353         }
 354 }
 355
 356 uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t ReportID, const uint8_t ReportType)
 357 {
 358         for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)
 359         {
 360                 if (ParserData->ReportIDSizes[i].ReportID == ReportID)
 361                   return ParserData->ReportIDSizes[i].ReportSizeBits[ReportType];
 362         }
 363
 364         return 0;
 365 }
 366
 367 #endif