Fix newly renamed VirtualSerial demos' include filename references so that they compile.

[pub/USBasp.git] / 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 241e17a..5b295ed 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/HIDParser.c
+++ b/LUFA/Drivers/USB/Class/Host/HIDParser.c
@@ -35,24 +35,19 @@
 \r
 uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)\r
 {\r
 \r
 uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)\r
 {\r

-       HID_StateTable_t  StateTable[HID_STATETABLE_STACK_DEPTH];\r
-       HID_StateTable_t* CurrStateTable          = &StateTable[0];\r
-       uint16_t          UsageStack[HID_USAGE_STACK_DEPTH];\r
-       uint8_t           UsageStackSize          = 0;\r
-       uint16_t          BitOffsetIn             = 0;\r
-       uint16_t          BitOffsetOut            = 0;\r
-#if defined(HID_ENABLE_FEATURE_PROCESSING)\r
-       uint16_t          BitOffsetFeature        = 0;\r
-#endif\r
-       HID_CollectionPath_t* CurrCollectionPath  = NULL;\r
+       HID_StateTable_t      StateTable[HID_STATETABLE_STACK_DEPTH];\r
+       HID_StateTable_t*     CurrStateTable          = &StateTable[0];\r
+       HID_CollectionPath_t* CurrCollectionPath      = NULL;\r
+       HID_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];                  \r
+       uint16_t              UsageList[HID_USAGE_STACK_DEPTH];\r
+       uint8_t               UsageListSize           = 0;\r
+       HID_MinMax_t          UsageMinMax             = {0, 0};\r

 \r
 \r

-       ParserData->TotalReportItems     = 0;\r
-       ParserData->UsingMultipleReports = false;\r
-       \r
-       for (uint8_t CurrCollection = 0; CurrCollection < HID_MAX_COLLECTIONS; CurrCollection++)\r
-         ParserData->CollectionPaths[CurrCollection].Parent = NULL;\r
+       memset(ParserData,       0x00, sizeof(HID_ReportInfo_t));\r
+       memset(CurrStateTable,   0x00, sizeof(HID_StateTable_t));\r
+       memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));\r

 \r
 \r

-       memset(&StateTable[0], 0x00, sizeof(HID_StateTable_t));\r
+       ParserData->TotalDeviceReports = 1;     \r

 \r
        while (ReportSize)\r
        {\r
 \r
        while (ReportSize)\r
        {\r


@@ -128,25 +123,45 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                                break;\r
                        case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):\r
                                CurrStateTable->ReportID                    = ReportItemData;\r
                                break;\r
                        case (TYPE_GLOBAL | TAG_GLOBAL_REPORTID):\r
                                CurrStateTable->ReportID                    = ReportItemData;\r

-                               ParserData->UsingMultipleReports = true;\r
-                               BitOffsetIn      = 0;\r
-                               BitOffsetOut     = 0;\r

 \r
 \r

-                               #if defined(HID_ENABLE_FEATURE_PROCESSING)\r
-                               BitOffsetFeature = 0;\r
-                               #endif\r
+                               if (ParserData->UsingReportIDs)\r
+                               {\r
+                                       CurrReportIDInfo = NULL;\r
+\r
+                                       for (uint8_t i = 0; i < ParserData->TotalDeviceReports; i++)\r
+                                       {\r
+                                               if (ParserData->ReportIDSizes[i].ReportID == CurrStateTable->ReportID)\r
+                                               {\r
+                                                       CurrReportIDInfo = &ParserData->ReportIDSizes[i];\r
+                                                       break;\r
+                                               }\r
+                                       }\r
+                                       \r
+                                       if (CurrReportIDInfo == NULL)\r
+                                       {\r
+                                               if (ParserData->TotalDeviceReports == HID_MAX_REPORT_IDS)\r
+                                                 return HID_PARSE_InsufficientReportIDItems;\r
+                                       \r
+                                               CurrReportIDInfo = &ParserData->ReportIDSizes[ParserData->TotalDeviceReports++];\r
+                                               memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));\r
+                                       }\r
+                               }\r
+\r
+                               ParserData->UsingReportIDs = true;                              \r
+\r
+                               CurrReportIDInfo->ReportID = CurrStateTable->ReportID;\r

                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGE):\r
                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGE):\r

-                               if (UsageStackSize == HID_USAGE_STACK_DEPTH)\r
-                                 return HID_PARSE_UsageStackOverflow;\r
+                               if (UsageListSize == HID_USAGE_STACK_DEPTH)\r
+                                 return HID_PARSE_UsageListOverflow;\r

                        \r
                        \r

-                               UsageStack[UsageStackSize++] = ReportItemData;\r
+                               UsageList[UsageListSize++] = ReportItemData;\r

                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):\r
                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):\r

-                               CurrStateTable->Attributes.Usage.MinMax.Minimum = ReportItemData;\r
+                               UsageMinMax.Minimum = ReportItemData;\r

                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):\r
                                break;\r
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMAX):\r

-                               CurrStateTable->Attributes.Usage.MinMax.Maximum = ReportItemData;\r
+                               UsageMinMax.Maximum = ReportItemData;\r

                                break;\r
                        case (TYPE_MAIN | TAG_MAIN_COLLECTION):\r
                                if (CurrCollectionPath == NULL)\r
                                break;\r
                        case (TYPE_MAIN | TAG_MAIN_COLLECTION):\r
                                if (CurrCollectionPath == NULL)\r


@@ -159,7 +174,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                        \r
                                        CurrCollectionPath = &ParserData->CollectionPaths[1];\r
 \r
                        \r
                                        CurrCollectionPath = &ParserData->CollectionPaths[1];\r
 \r

-                                       while (CurrCollectionPath->Parent != NULL);\r
+                                       while (CurrCollectionPath->Parent != NULL)\r

                                        {\r
                                                if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])\r
                                                  return HID_PARSE_InsufficientCollectionPaths;\r
                                        {\r
                                                if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])\r
                                                  return HID_PARSE_InsufficientCollectionPaths;\r


@@ -173,18 +188,18 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                                CurrCollectionPath->Type = ReportItemData;\r
                                CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page;\r
                                \r
                                CurrCollectionPath->Type = ReportItemData;\r
                                CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page;\r
                                \r

-                               if (UsageStackSize)\r
+                               if (UsageListSize)\r

                                {\r
                                {\r

-                                       CurrCollectionPath->Usage.Usage = UsageStack[0];\r
+                                       CurrCollectionPath->Usage.Usage = UsageList[0];\r

 \r
 \r

-                                       for (uint8_t i = 0; i < UsageStackSize; i++)\r
-                                         UsageStack[i] = UsageStack[i + 1];\r
-                                         \r
-                                       UsageStackSize--;\r
+                                       for (uint8_t i = 0; i < UsageListSize; i++)\r
+                                         UsageList[i] = UsageList[i + 1];\r
+                                       \r
+                                       UsageListSize--;\r

                                }\r
                                }\r

-                               else\r
+                               else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)\r

                                {\r
                                {\r

-                                       CurrCollectionPath->Usage.Usage = 0;\r
+                                       CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++;\r

                                }\r
                                \r
                                break;\r
                                }\r
                                \r
                                break;\r


@@ -193,90 +208,78 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                                  return HID_PARSE_UnexpectedEndCollection;\r
                \r
                                CurrCollectionPath = CurrCollectionPath->Parent;\r
                                  return HID_PARSE_UnexpectedEndCollection;\r
                \r
                                CurrCollectionPath = CurrCollectionPath->Parent;\r

-\r

                                break;\r
                        case (TYPE_MAIN | TAG_MAIN_INPUT):\r
                        case (TYPE_MAIN | TAG_MAIN_OUTPUT):\r
                                break;\r
                        case (TYPE_MAIN | TAG_MAIN_INPUT):\r
                        case (TYPE_MAIN | TAG_MAIN_OUTPUT):\r

-#if defined(HID_ENABLE_FEATURE_PROCESSING)\r

                        case (TYPE_MAIN | TAG_MAIN_FEATURE):\r
                        case (TYPE_MAIN | TAG_MAIN_FEATURE):\r

-#endif\r

                                for (uint8_t ReportItemNum = 0; ReportItemNum < CurrStateTable->ReportCount; ReportItemNum++)\r
                                {\r
                                for (uint8_t ReportItemNum = 0; ReportItemNum < CurrStateTable->ReportCount; ReportItemNum++)\r
                                {\r

-                                       HID_ReportItem_t* CurrReportItem = &ParserData->ReportItems[ParserData->TotalReportItems];\r
-                               \r
-                                       if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)\r
-                                         return HID_PARSE_InsufficientReportItems;\r
+                                       HID_ReportItem_t NewReportItem;\r

                                  \r
                                  \r

-                                       memcpy(&CurrReportItem->Attributes,\r
+                                       memcpy(&NewReportItem.Attributes,\r

                                               &CurrStateTable->Attributes,\r
                                               sizeof(HID_ReportItem_Attributes_t));\r
 \r
                                               &CurrStateTable->Attributes,\r
                                               sizeof(HID_ReportItem_Attributes_t));\r
 \r

-                                       CurrReportItem->ItemFlags      = ReportItemData;\r
-                                       CurrReportItem->CollectionPath = CurrCollectionPath;\r
-                                       CurrReportItem->ReportID       = CurrStateTable->ReportID;\r
+                                       NewReportItem.ItemFlags      = ReportItemData;\r
+                                       NewReportItem.CollectionPath = CurrCollectionPath;\r
+                                       NewReportItem.ReportID       = CurrStateTable->ReportID;\r

 \r
 \r

-                                       if (UsageStackSize)\r
+                                       if (UsageListSize)\r

                                        {\r
                                        {\r

-                                               CurrReportItem->Attributes.Usage.Usage = UsageStack[0];\r
+                                               NewReportItem.Attributes.Usage.Usage = UsageList[0];\r

 \r
 \r

-                                               for (uint8_t i = 0; i < UsageStackSize; i++)\r
-                                                 UsageStack[i] = UsageStack[i + 1];\r
+                                               for (uint8_t i = 0; i < UsageListSize; i++)\r
+                                                 UsageList[i] = UsageList[i + 1];\r

                                                  \r
                                                  \r

-                                               UsageStackSize--;\r
+                                               UsageListSize--;\r

                                        }\r
                                        }\r

-                                       else\r
+                                       else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)\r

                                        {\r
                                        {\r

-                                               CurrReportItem->Attributes.Usage.Usage = 0;\r
+                                               NewReportItem.Attributes.Usage.Usage = UsageMinMax.Minimum++;\r

                                        }\r
                                        }\r

-                                                                                       \r
-                                       switch (HIDReportItem & TAG_MASK)\r
-                                       {\r
-                                               case TAG_MAIN_INPUT:\r
-                                                       CurrReportItem->ItemType  = REPORT_ITEM_TYPE_In;\r
-                                                       CurrReportItem->BitOffset = BitOffsetIn;\r
-                                                               \r
-                                                       BitOffsetIn += CurrStateTable->Attributes.BitSize;\r
-                                                       \r
-                                                       break;\r
-                                               case TAG_MAIN_OUTPUT:\r
-                                                       CurrReportItem->ItemType  = REPORT_ITEM_TYPE_Out;\r
-                                                       CurrReportItem->BitOffset = BitOffsetOut;\r
-                                                               \r
-                                                       BitOffsetOut += CurrStateTable->Attributes.BitSize;\r
-                                                       \r
-                                                       break;\r
-#if defined(HID_ENABLE_FEATURE_PROCESSING)\r
-                                               case TAG_MAIN_FEATURE:\r
-                                                       CurrReportItem->ItemType  = REPORT_ITEM_TYPE_Feature;                                           \r
-                                                       CurrReportItem->BitOffset = BitOffsetFeature;\r
-                                                               \r
-                                                       BitOffsetFeature += CurrStateTable->Attributes.BitSize;         \r
+                                       \r
+                                       uint8_t ItemTag = (HIDReportItem & TAG_MASK);\r

 \r
 \r

-                                                       break;\r
-#endif\r
-                                       }\r
+                                       if (ItemTag == TAG_MAIN_INPUT)\r
+                                         NewReportItem.ItemType = REPORT_ITEM_TYPE_In;\r
+                                       else if (ItemTag == TAG_MAIN_OUTPUT)\r
+                                         NewReportItem.ItemType = REPORT_ITEM_TYPE_Out;\r
+                                       else\r
+                                         NewReportItem.ItemType = REPORT_ITEM_TYPE_Feature;\r

                                        \r
                                        \r

-#if defined(HID_INCLUDE_CONSTANT_DATA_ITEMS)\r
-                                       ParserData->TotalReportItems++;\r
-#else\r
-                                       if (!(ReportItemData & IOF_CONSTANT))\r
-                                         ParserData->TotalReportItems++;\r
-#endif\r
+                                       NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType];\r
+\r
+                                       CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize;\r
+\r
+                                       if (ParserData->LargestReportSizeBits < NewReportItem.BitOffset)\r
+                                         ParserData->LargestReportSizeBits = NewReportItem.BitOffset;\r
+                                       \r
+                                       if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&NewReportItem))\r
+                                       {                                       \r
+                                               if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)\r
+                                                 return HID_PARSE_InsufficientReportItems;\r
+                                       \r
+                                               memcpy(&ParserData->ReportItems[ParserData->TotalReportItems],\r
+                                                      &NewReportItem, sizeof(HID_ReportItem_t));\r
+                                       \r
+                                               ParserData->TotalReportItems++;\r
+                                       }\r

                                }\r
                                \r
                                }\r
                                \r

-                               UsageStackSize = 0;\r
-                               \r

                                break;\r
                }\r
          \r
                if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)\r
                {\r
                                break;\r
                }\r
          \r
                if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)\r
                {\r

-                       CurrStateTable->Attributes.Usage.MinMax.Minimum = 0;\r
-                       CurrStateTable->Attributes.Usage.MinMax.Maximum = 0;\r
-                       UsageStackSize = 0;\r
+                       UsageMinMax.Minimum = 0;\r
+                       UsageMinMax.Maximum = 0;\r
+                       UsageListSize   = 0;\r

                }\r
        }\r
        \r
                }\r
        }\r
        \r

+       if (!(ParserData->TotalReportItems))\r
+         return HID_PARSE_NoUnfilteredReportItems;\r
+       \r

        return HID_PARSE_Successful;\r
 }\r
 \r
        return HID_PARSE_Successful;\r
 }\r
 \r


@@ -286,6 +289,7 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const
        uint16_t CurrentBit   = ReportItem->BitOffset;\r
        uint32_t BitMask      = (1 << 0);\r
 \r
        uint16_t CurrentBit   = ReportItem->BitOffset;\r
        uint32_t BitMask      = (1 << 0);\r
 \r

+       ReportItem->PreviousValue = ReportItem->Value;\r

        ReportItem->Value = 0;\r
        \r
        if (ReportItem->ReportID)\r
        ReportItem->Value = 0;\r
        \r
        if (ReportItem->ReportID)\r


@@ -308,7 +312,7 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const
        return true;\r
 }\r
 \r
        return true;\r
 }\r
 \r

-void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)\r
+void USB_SetHIDReportItemInfo(uint8_t* ReportData, HID_ReportItem_t* const ReportItem)\r

 {\r
        uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;\r
        uint16_t CurrentBit   = ReportItem->BitOffset;\r
 {\r
        uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;\r
        uint16_t CurrentBit   = ReportItem->BitOffset;\r


@@ -320,6 +324,8 @@ void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* Repor
                ReportData++;\r
        }\r
 \r
                ReportData++;\r
        }\r
 \r

+       ReportItem->PreviousValue = ReportItem->Value;\r
+\r

        while (DataBitsRem--)\r
        {\r
                if (ReportItem->Value & (1 << (CurrentBit % 8)))\r
        while (DataBitsRem--)\r
        {\r
                if (ReportItem->Value & (1 << (CurrentBit % 8)))\r


@@ -330,4 +336,15 @@ void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* Repor
        }\r
 }\r
 \r
        }\r
 }\r
 \r

+uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t ReportID, const uint8_t ReportType)\r
+{\r
+       for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)\r
+       {\r
+               if (ParserData->ReportIDSizes[i].ReportID == ReportID)\r
+                 return ParserData->ReportIDSizes[i].ReportSizeBits[ReportType];\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r

 #endif\r
 #endif\r