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                                 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 (UsageStackSize)
 232                                         {
 233                                                 NewReportItem.Attributes.Usage.Usage = UsageStack[0];
 234
 235                                                 for (uint8_t i = 0; i < UsageStackSize; i++)
 236                                                   UsageStack[i] = UsageStack[i + 1];
 237
 238                                                 UsageStackSize--;
 239                                         }
 240                                         else
 241                                         {
 242                                                 NewReportItem.Attributes.Usage.Usage = 0;
 243                                         }
 244
 245                                         switch (HIDReportItem & TAG_MASK)
 246                                         {
 247                                                 case TAG_MAIN_INPUT:
 248                                                         NewReportItem.ItemType  = REPORT_ITEM_TYPE_In;
 249                                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_In];
 250
 251                                                         CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_In] += CurrStateTable->Attributes.BitSize;
 252                                                         break;
 253                                                 case TAG_MAIN_OUTPUT:
 254                                                         NewReportItem.ItemType  = REPORT_ITEM_TYPE_Out;
 255                                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_Out];
 256
 257                                                         CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_Out] += CurrStateTable->Attributes.BitSize;
 258                                                         break;
 259                                                 case TAG_MAIN_FEATURE:
 260                                                         NewReportItem.ItemType  = REPORT_ITEM_TYPE_Feature;
 261                                                         NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_Feature];
 262
 263                                                         CurrReportIDInfo->ReportSizeBits[REPORT_ITEM_TYPE_Feature] += CurrStateTable->Attributes.BitSize;
 264                                                         break;
 265                                         }
 266
 267                                         if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&CurrStateTable->Attributes))
 268                                         {
 269                                                 if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)
 270                                                   return HID_PARSE_InsufficientReportItems;
 271
 272                                                 memcpy(&ParserData->ReportItems[ParserData->TotalReportItems],
 273                                                        &NewReportItem, sizeof(HID_ReportItem_t));
 274
 275                                                 ParserData->TotalReportItems++;
 276                                         }
 277                                 }
 278
 279                                 UsageStackSize = 0;
 280
 281                                 break;
 282                 }
 283
 284                 if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)
 285                 {
 286                         CurrStateTable->Attributes.Usage.MinMax.Minimum = 0;
 287                         CurrStateTable->Attributes.Usage.MinMax.Maximum = 0;
 288                         UsageStackSize = 0;
 289                 }
 290         }
 291
 292         return HID_PARSE_Successful;
 293 }
 294
 295 bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem)
 296 {
 297         uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
 298         uint16_t CurrentBit   = ReportItem->BitOffset;
 299         uint32_t BitMask      = (1 << 0);
 300
 301         ReportItem->Value = 0;
 302
 303         if (ReportItem->ReportID)
 304         {
 305                 if (ReportItem->ReportID != ReportData[0])
 306                   return false;
 307
 308                 ReportData++;
 309         }
 310
 311         while (DataBitsRem--)
 312         {
 313                 if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
 314                   ReportItem->Value |= BitMask;
 315
 316                 CurrentBit++;
 317                 BitMask <<= 1;
 318         }
 319
 320         return true;
 321 }
 322
 323 void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)
 324 {
 325         uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
 326         uint16_t CurrentBit   = ReportItem->BitOffset;
 327         uint32_t BitMask      = (1 << 0);
 328
 329         if (ReportItem->ReportID)
 330         {
 331                 ReportData[0] = ReportItem->ReportID;
 332                 ReportData++;
 333         }
 334
 335         while (DataBitsRem--)
 336         {
 337                 if (ReportItem->Value & (1 << (CurrentBit % 8)))
 338                   ReportData[CurrentBit / 8] |= BitMask;
 339
 340                 CurrentBit++;
 341                 BitMask <<= 1;
 342         }
 343 }
 344
 345 uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, uint8_t ReportID, uint8_t ReportType)
 346 {
 347         for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)
 348         {
 349                 if (ParserData->ReportIDSizes[i].ReportID == ReportID)
 350                   return ParserData->ReportIDSizes[i].ReportSizeBits[ReportType];
 351         }
 352
 353         return 0;
 354 }
 355
 356 #endif