X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/205b35d131a1cc8196786de4370cb90fec17835e..d11ed10c5314c44dc01c06954d1d73d4894cbff8:/LUFA/Drivers/USB/Class/Host/HIDParser.c diff --git a/LUFA/Drivers/USB/Class/Host/HIDParser.c b/LUFA/Drivers/USB/Class/Host/HIDParser.c index accb8f36b..3ef9c7812 100644 --- a/LUFA/Drivers/USB/Class/Host/HIDParser.c +++ b/LUFA/Drivers/USB/Class/Host/HIDParser.c @@ -1,21 +1,21 @@ /* LUFA Library - Copyright (C) Dean Camera, 2009. + Copyright (C) Dean Camera, 2010. 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 + Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com) + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, 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 @@ -37,20 +37,17 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID { HID_StateTable_t StateTable[HID_STATETABLE_STACK_DEPTH]; HID_StateTable_t* CurrStateTable = &StateTable[0]; - HID_CollectionPath_t* CurrCollectionPath = NULL; - uint16_t UsageStack[HID_USAGE_STACK_DEPTH]; - uint8_t UsageStackSize = 0; - uint16_t BitOffsetIn = 0; - uint16_t BitOffsetOut = 0; - uint16_t BitOffsetFeature = 0; - - ParserData->TotalReportItems = 0; - ParserData->UsingMultipleReports = false; - - for (uint8_t CurrCollection = 0; CurrCollection < HID_MAX_COLLECTIONS; CurrCollection++) - ParserData->CollectionPaths[CurrCollection].Parent = NULL; + HID_CollectionPath_t* CurrCollectionPath = NULL; + HID_ReportSizeInfo_t* CurrReportIDInfo = &ParserData->ReportIDSizes[0]; + uint16_t UsageList[HID_USAGE_STACK_DEPTH]; + uint8_t UsageListSize = 0; + HID_MinMax_t UsageMinMax = {0, 0}; + + memset(ParserData, 0x00, sizeof(HID_ReportInfo_t)); + memset(CurrStateTable, 0x00, sizeof(HID_StateTable_t)); + memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t)); - memset(&StateTable[0], 0x00, sizeof(HID_StateTable_t)); + ParserData->TotalDeviceReports = 1; while (ReportSize) { @@ -126,22 +123,45 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID break; case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID): CurrStateTable->ReportID = ReportItemData; - ParserData->UsingMultipleReports = true; - BitOffsetIn = 0; - BitOffsetOut = 0; - BitOffsetFeature = 0; + + if (ParserData->UsingReportIDs) + { + CurrReportIDInfo = NULL; + + for (uint8_t i = 0; i < ParserData->TotalDeviceReports; i++) + { + if (ParserData->ReportIDSizes[i].ReportID == CurrStateTable->ReportID) + { + CurrReportIDInfo = &ParserData->ReportIDSizes[i]; + break; + } + } + + if (CurrReportIDInfo == NULL) + { + if (ParserData->TotalDeviceReports == HID_MAX_REPORT_IDS) + return HID_PARSE_InsufficientReportIDItems; + + CurrReportIDInfo = &ParserData->ReportIDSizes[ParserData->TotalDeviceReports++]; + memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t)); + } + } + + ParserData->UsingReportIDs = true; + + CurrReportIDInfo->ReportID = CurrStateTable->ReportID; break; case (TYPE_LOCAL | TAG_LOCAL_USAGE): - if (UsageStackSize == HID_USAGE_STACK_DEPTH) - return HID_PARSE_UsageStackOverflow; + if (UsageListSize == HID_USAGE_STACK_DEPTH) + return HID_PARSE_UsageListOverflow; - UsageStack[UsageStackSize++] = ReportItemData; + UsageList[UsageListSize++] = ReportItemData; break; case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN): - CurrStateTable->Attributes.Usage.MinMax.Minimum = ReportItemData; + UsageMinMax.Minimum = ReportItemData; break; case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX): - CurrStateTable->Attributes.Usage.MinMax.Maximum = ReportItemData; + UsageMinMax.Maximum = ReportItemData; break; case (TYPE_MAIN | TAG_MAIN_COLLECTION): if (CurrCollectionPath == NULL) @@ -154,7 +174,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID CurrCollectionPath = &ParserData->CollectionPaths[1]; - while (CurrCollectionPath->Parent != NULL); + while (CurrCollectionPath->Parent != NULL) { if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1]) return HID_PARSE_InsufficientCollectionPaths; @@ -168,18 +188,18 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID CurrCollectionPath->Type = ReportItemData; CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page; - if (UsageStackSize) + if (UsageListSize) { - CurrCollectionPath->Usage.Usage = UsageStack[0]; + CurrCollectionPath->Usage.Usage = UsageList[0]; - for (uint8_t i = 0; i < UsageStackSize; i++) - UsageStack[i] = UsageStack[i + 1]; - - UsageStackSize--; + for (uint8_t i = 0; i < UsageListSize; i++) + UsageList[i] = UsageList[i + 1]; + + UsageListSize--; } - else + else if (UsageMinMax.Minimum <= UsageMinMax.Maximum) { - CurrCollectionPath->Usage.Usage = 0; + CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++; } break; @@ -188,7 +208,6 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID return HID_PARSE_UnexpectedEndCollection; CurrCollectionPath = CurrCollectionPath->Parent; - break; case (TYPE_MAIN | TAG_MAIN_INPUT): case (TYPE_MAIN | TAG_MAIN_OUTPUT): @@ -205,43 +224,37 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID NewReportItem.CollectionPath = CurrCollectionPath; NewReportItem.ReportID = CurrStateTable->ReportID; - if (UsageStackSize) + if (UsageListSize) { - NewReportItem.Attributes.Usage.Usage = UsageStack[0]; + NewReportItem.Attributes.Usage.Usage = UsageList[0]; - for (uint8_t i = 0; i < UsageStackSize; i++) - UsageStack[i] = UsageStack[i + 1]; + for (uint8_t i = 0; i < UsageListSize; i++) + UsageList[i] = UsageList[i + 1]; - UsageStackSize--; - } - else - { - NewReportItem.Attributes.Usage.Usage = 0; + UsageListSize--; } - - switch (HIDReportItem & TAG_MASK) + else if (UsageMinMax.Minimum <= UsageMinMax.Maximum) { - case TAG_MAIN_INPUT: - NewReportItem.ItemType = REPORT_ITEM_TYPE_In; - NewReportItem.BitOffset = BitOffsetIn; - - BitOffsetIn += CurrStateTable->Attributes.BitSize; - break; - case TAG_MAIN_OUTPUT: - NewReportItem.ItemType = REPORT_ITEM_TYPE_Out; - NewReportItem.BitOffset = BitOffsetOut; - - BitOffsetOut += CurrStateTable->Attributes.BitSize; - break; - case TAG_MAIN_FEATURE: - NewReportItem.ItemType = REPORT_ITEM_TYPE_Feature; - NewReportItem.BitOffset = BitOffsetFeature; - - BitOffsetFeature += CurrStateTable->Attributes.BitSize; - break; + NewReportItem.Attributes.Usage.Usage = UsageMinMax.Minimum++; } + + uint8_t ItemTag = (HIDReportItem & TAG_MASK); + + if (ItemTag == TAG_MAIN_INPUT) + NewReportItem.ItemType = REPORT_ITEM_TYPE_In; + else if (ItemTag == TAG_MAIN_OUTPUT) + NewReportItem.ItemType = REPORT_ITEM_TYPE_Out; + else + NewReportItem.ItemType = REPORT_ITEM_TYPE_Feature; + + NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType]; + + CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize; - if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&CurrStateTable->Attributes)) + if (ParserData->LargestReportSizeBits < NewReportItem.BitOffset) + ParserData->LargestReportSizeBits = NewReportItem.BitOffset; + + if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&NewReportItem)) { if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS) return HID_PARSE_InsufficientReportItems; @@ -253,19 +266,20 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID } } - UsageStackSize = 0; - break; } if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN) { - CurrStateTable->Attributes.Usage.MinMax.Minimum = 0; - CurrStateTable->Attributes.Usage.MinMax.Maximum = 0; - UsageStackSize = 0; + UsageMinMax.Minimum = 0; + UsageMinMax.Maximum = 0; + UsageListSize = 0; } } + if (!(ParserData->TotalReportItems)) + return HID_PARSE_NoUnfilteredReportItems; + return HID_PARSE_Successful; } @@ -275,6 +289,7 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const uint16_t CurrentBit = ReportItem->BitOffset; uint32_t BitMask = (1 << 0); + ReportItem->PreviousValue = ReportItem->Value; ReportItem->Value = 0; if (ReportItem->ReportID) @@ -297,7 +312,7 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const return true; } -void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem) +void USB_SetHIDReportItemInfo(uint8_t* ReportData, HID_ReportItem_t* const ReportItem) { uint16_t DataBitsRem = ReportItem->Attributes.BitSize; uint16_t CurrentBit = ReportItem->BitOffset; @@ -309,6 +324,8 @@ void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* Repor ReportData++; } + ReportItem->PreviousValue = ReportItem->Value; + while (DataBitsRem--) { if (ReportItem->Value & (1 << (CurrentBit % 8))) @@ -319,4 +336,15 @@ void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* Repor } } +uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t ReportID, const uint8_t ReportType) +{ + for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++) + { + if (ParserData->ReportIDSizes[i].ReportID == ReportID) + return ParserData->ReportIDSizes[i].ReportSizeBits[ReportType]; + } + + return 0; +} + #endif