From 74298f8ca11dc8d3b0359d1d4e124d6494c3eeac Mon Sep 17 00:00:00 2001 From: Nicolas Schodet Date: Fri, 10 Apr 2009 01:15:42 +0200 Subject: * digital/avr/modules/usb: - imported LUFA. --- .../usb/lufa/LUFA/Drivers/USB/Class/HIDParser.c | 326 +++++++++++++++++++++ 1 file changed, 326 insertions(+) create mode 100644 digital/avr/modules/usb/lufa/LUFA/Drivers/USB/Class/HIDParser.c (limited to 'digital/avr/modules/usb/lufa/LUFA/Drivers/USB/Class/HIDParser.c') diff --git a/digital/avr/modules/usb/lufa/LUFA/Drivers/USB/Class/HIDParser.c b/digital/avr/modules/usb/lufa/LUFA/Drivers/USB/Class/HIDParser.c new file mode 100644 index 00000000..35b280b5 --- /dev/null +++ b/digital/avr/modules/usb/lufa/LUFA/Drivers/USB/Class/HIDParser.c @@ -0,0 +1,326 @@ +/* + LUFA Library + Copyright (C) Dean Camera, 2009. + + dean [at] fourwalledcubicle [dot] com + www.fourwalledcubicle.com +*/ + +/* + Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com) + + Permission to use, copy, modify, and distribute this software + and its documentation for any purpose and without fee is hereby + granted, provided that the above copyright notice appear in all + copies and that both that the copyright notice and this + permission notice and warranty disclaimer appear in supporting + documentation, and that the name of the author not be used in + advertising or publicity pertaining to distribution of the + software without specific, written prior permission. + + The author disclaim all warranties with regard to this + software, including all implied warranties of merchantability + and fitness. In no event shall the author be liable for any + special, indirect or consequential damages or any damages + whatsoever resulting from loss of use, data or profits, whether + in an action of contract, negligence or other tortious action, + arising out of or in connection with the use or performance of + this software. +*/ + +#include "HIDParser.h" + +uint8_t ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData) +{ + HID_StateTable_t StateTable[HID_STATETABLE_STACK_DEPTH]; + HID_StateTable_t* CurrStateTable = &StateTable[0]; + uint16_t UsageStack[HID_USAGE_STACK_DEPTH]; + uint8_t UsageStackSize = 0; + uint16_t BitOffsetIn = 0; + uint16_t BitOffsetOut = 0; +#if defined(HID_ENABLE_FEATURE_PROCESSING) + uint16_t BitOffsetFeature = 0; +#endif + HID_CollectionPath_t* CurrCollectionPath = NULL; + + memset((void*)ParserData, 0x00, sizeof(HID_ReportInfo_t)); + memset((void*)StateTable, 0x00, sizeof(StateTable)); + + while (ReportSize) + { + uint32_t ReportItemData = 0; + + switch (*ReportData & DATA_SIZE_MASK) + { + case DATA_SIZE_4: + ReportItemData = *((uint32_t*)(ReportData + 1)); + break; + case DATA_SIZE_2: + ReportItemData = *((uint16_t*)(ReportData + 1)); + break; + case DATA_SIZE_1: + ReportItemData = *((uint8_t*)(ReportData + 1)); + break; + } + + switch (*ReportData & (TYPE_MASK | TAG_MASK)) + { + case (TYPE_GLOBAL | TAG_GLOBAL_PUSH): + if (CurrStateTable == &StateTable[HID_STATETABLE_STACK_DEPTH]) + return HID_PARSE_HIDStackOverflow; + + memcpy((CurrStateTable - 1), + CurrStateTable, + sizeof(HID_ReportItem_t)); + + CurrStateTable++; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_POP): + if (CurrStateTable == &StateTable[0]) + return HID_PARSE_HIDStackUnderflow; + + CurrStateTable--; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE): + CurrStateTable->Attributes.Usage.Page = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMIN): + CurrStateTable->Attributes.Logical.Minimum = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_LOGICALMAX): + CurrStateTable->Attributes.Logical.Maximum = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMIN): + CurrStateTable->Attributes.Physical.Minimum = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_PHYSMAX): + CurrStateTable->Attributes.Physical.Maximum = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_UNITEXP): + CurrStateTable->Attributes.Unit.Exponent = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_UNIT): + CurrStateTable->Attributes.Unit.Type = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_REPORTSIZE): + CurrStateTable->Attributes.BitSize = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_REPORTCOUNT): + CurrStateTable->ReportCount = ReportItemData; + break; + case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID): + CurrStateTable->ReportID = ReportItemData; + break; + case (TYPE_LOCAL | TAG_LOCAL_USAGE): + if (UsageStackSize == HID_USAGE_STACK_DEPTH) + return HID_PARSE_UsageStackOverflow; + + UsageStack[UsageStackSize++] = ReportItemData; + break; + case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN): + CurrStateTable->Attributes.Usage.MinMax.Minimum = ReportItemData; + break; + case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX): + CurrStateTable->Attributes.Usage.MinMax.Maximum = ReportItemData; + break; + case (TYPE_MAIN | TAG_MAIN_COLLECTION): + if (CurrCollectionPath == NULL) + { + CurrCollectionPath = &ParserData->CollectionPaths[0]; + } + else + { + HID_CollectionPath_t* ParentCollectionPath = CurrCollectionPath; + + CurrCollectionPath = &ParserData->CollectionPaths[1]; + + while (CurrCollectionPath->Parent != NULL); + { + if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS]) + return HID_PARSE_InsufficientCollectionPaths; + + CurrCollectionPath++; + } + + CurrCollectionPath->Parent = ParentCollectionPath; + } + + CurrCollectionPath->Type = ReportItemData; + CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page; + + if (UsageStackSize) + { + CurrCollectionPath->Usage.Usage = UsageStack[0]; + + for (uint8_t i = 0; i < UsageStackSize; i++) + UsageStack[i] = UsageStack[i + 1]; + + UsageStackSize--; + } + else + { + CurrCollectionPath->Usage.Usage = 0; + } + + break; + case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION): + if (CurrCollectionPath == NULL) + return HID_PARSE_UnexpectedEndCollection; + + CurrCollectionPath = CurrCollectionPath->Parent; + + break; + case (TYPE_MAIN | TAG_MAIN_INPUT): + case (TYPE_MAIN | TAG_MAIN_OUTPUT): +#if defined(HID_ENABLE_FEATURE_PROCESSING) + case (TYPE_MAIN | TAG_MAIN_FEATURE): +#endif + for (uint8_t ReportItemNum = 0; ReportItemNum < CurrStateTable->ReportCount; ReportItemNum++) + { + HID_ReportItem_t* CurrReportItem = &ParserData->ReportItems[ParserData->TotalReportItems]; + + if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS) + return HID_PARSE_InsufficientReportItems; + + memcpy(&CurrReportItem->Attributes, + &CurrStateTable->Attributes, + sizeof(HID_ReportItem_Attributes_t)); + + CurrReportItem->ItemFlags = ReportItemData; + CurrReportItem->CollectionPath = CurrCollectionPath; + CurrReportItem->ReportID = CurrStateTable->ReportID; + + if (UsageStackSize) + { + CurrReportItem->Attributes.Usage.Usage = UsageStack[0]; + + for (uint8_t i = 0; i < UsageStackSize; i++) + UsageStack[i] = UsageStack[i + 1]; + + UsageStackSize--; + } + else + { + CurrReportItem->Attributes.Usage.Usage = 0; + } + + switch (*ReportData & TAG_MASK) + { + case TAG_MAIN_INPUT: + CurrReportItem->ItemType = REPORT_ITEM_TYPE_In; + CurrReportItem->BitOffset = BitOffsetIn; + + BitOffsetIn += CurrStateTable->Attributes.BitSize; + + break; + case TAG_MAIN_OUTPUT: + CurrReportItem->ItemType = REPORT_ITEM_TYPE_Out; + CurrReportItem->BitOffset = BitOffsetOut; + + BitOffsetOut += CurrStateTable->Attributes.BitSize; + + break; +#if defined(HID_ENABLE_FEATURE_PROCESSING) + case TAG_MAIN_FEATURE: + CurrReportItem->ItemType = REPORT_ITEM_TYPE_Feature; + CurrReportItem->BitOffset = BitOffsetFeature; + + BitOffsetFeature += CurrStateTable->Attributes.BitSize; + + break; +#endif + } + +#if !defined(HID_INCLUDE_CONSTANT_DATA_ITEMS) + if (!(ReportItemData & IOF_CONSTANT)) + ParserData->TotalReportItems++; +#else + ParserData->TotalReportItems++; +#endif + } + + UsageStackSize = 0; + + break; + } + + if ((*ReportData & TYPE_MASK) == TYPE_MAIN) + { + CurrStateTable->Attributes.Usage.MinMax.Minimum = 0; + CurrStateTable->Attributes.Usage.MinMax.Maximum = 0; + UsageStackSize = 0; + } + + switch (*ReportData & DATA_SIZE_MASK) + { + case DATA_SIZE_4: + ReportSize -= 5; + ReportData += 5; + break; + case DATA_SIZE_2: + ReportSize -= 3; + ReportData += 3; + break; + case DATA_SIZE_1: + ReportSize -= 2; + ReportData += 2; + break; + case DATA_SIZE_0: + ReportSize -= 1; + ReportData += 1; + break; + } + } + + return HID_PARSE_Successful; +} + +bool GetReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem) +{ + uint16_t DataBitsRem = ReportItem->Attributes.BitSize; + uint16_t CurrentBit = ReportItem->BitOffset; + uint32_t BitMask = (1 << 0); + + ReportItem->Value = 0; + + if (ReportItem->ReportID) + { + if (ReportItem->ReportID != ReportData[0]) + return false; + + ReportData++; + } + + while (DataBitsRem--) + { + if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8))) + ReportItem->Value |= BitMask; + + CurrentBit++; + BitMask <<= 1; + } + + return true; +} + +void SetReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem) +{ + uint16_t DataBitsRem = ReportItem->Attributes.BitSize; + uint16_t CurrentBit = ReportItem->BitOffset; + uint32_t BitMask = (1 << 0); + + if (ReportItem->ReportID) + { + ReportData[0] = ReportItem->ReportID; + ReportData++; + } + + while (DataBitsRem--) + { + if (ReportItem->Value & (1 << (CurrentBit % 8))) + ReportData[CurrentBit / 8] |= BitMask; + + CurrentBit++; + BitMask <<= 1; + } +} -- cgit v1.2.3