X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/d2068d878c2ef6c4a68e85215d9d4a3b376089c2..5930f47bf4b9b4490daf80d44595ff14ee7ce165:/LUFA/Drivers/USB/Class/Host/HIDParser.c?ds=inline

diff --git a/LUFA/Drivers/USB/Class/Host/HIDParser.c b/LUFA/Drivers/USB/Class/Host/HIDParser.c
index 5174b59f9..81062b1c8 100644
--- a/LUFA/Drivers/USB/Class/Host/HIDParser.c
+++ b/LUFA/Drivers/USB/Class/Host/HIDParser.c
@@ -38,19 +38,15 @@ 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_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];			
+	uint16_t              UsageList[HID_USAGE_STACK_DEPTH];
+	uint8_t               UsageListSize          = 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,16 +122,39 @@ 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;
@@ -154,7 +173,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 +187,14 @@ 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];
+					for (uint8_t i = 0; i < UsageListSize; i++)
+					  UsageList[i] = UsageList[i + 1];
 					  
-					UsageStackSize--;
-				}
-				else
-				{
-					CurrCollectionPath->Usage.Usage = 0;
+					UsageListSize--;
 				}
 				
 				break;
@@ -188,7 +203,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 +219,33 @@ 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--;
+						UsageListSize--;
 					}
+
+					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.Attributes.Usage.Usage = 0;
-					}
-											
-					switch (HIDReportItem & TAG_MASK)
-					{
-						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.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,8 +257,6 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
 					}
 				}
 				
-				UsageStackSize = 0;
-				
 				break;
 		}
 	  
@@ -262,10 +264,13 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
 		{
 			CurrStateTable->Attributes.Usage.MinMax.Minimum = 0;
 			CurrStateTable->Attributes.Usage.MinMax.Maximum = 0;
-			UsageStackSize = 0;
+			UsageListSize = 0;
 		}
 	}
 	
+	if (!(ParserData->TotalReportItems))
+	  return HID_PARSE_NoUnfilteredReportItems;
+	
 	return HID_PARSE_Successful;
 }
 
@@ -319,4 +324,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