projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed PDI/TPI programming speed of ~250KHz in the AVRISP-MKII Clone project, instead...
[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 49f9452..8a59f5a 100644 (file)
--- 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, 2010.
 /*
              LUFA Library
      Copyright (C) Dean Camera, 2010.
-              
+
   dean [at] fourwalledcubicle [dot] com
   dean [at] fourwalledcubicle [dot] com
-      www.fourwalledcubicle.com
+           www.lufa-lib.org
 */
 
 /*
   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
 */
 
 /*
   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
-  Permission to use, copy, modify, distribute, and sell this 
+  Permission to use, copy, modify, distribute, and sell this
   software and its documentation for any purpose is hereby granted
   software and its documentation for any purpose is hereby granted
-  without fee, provided that the above copyright notice appear in 
+  without fee, provided that the above copyright notice appear in
   all copies and that both that the copyright notice and this
   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 
+  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 without specific, written prior permission.
 
   The author disclaim all warranties with regard to this
@@ -32,6 +32,7 @@
 #include "../../HighLevel/USBMode.h"
 #if defined(USB_CAN_BE_HOST)
 
 #include "../../HighLevel/USBMode.h"
 #if defined(USB_CAN_BE_HOST)
 
+#define  __INCLUDE_FROM_HID_DRIVER
 #include "HIDParser.h"
 
 uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
 #include "HIDParser.h"
 
 uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
@@ -41,7 +42,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
        HID_StateTable_t      StateTable[HID_STATETABLE_STACK_DEPTH];
        HID_StateTable_t*     CurrStateTable          = &StateTable[0];
        HID_CollectionPath_t* CurrCollectionPath      = NULL;
        HID_StateTable_t      StateTable[HID_STATETABLE_STACK_DEPTH];
        HID_StateTable_t*     CurrStateTable          = &StateTable[0];
        HID_CollectionPath_t* CurrCollectionPath      = NULL;
-       HID_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];                  
+       HID_ReportSizeInfo_t* CurrReportIDInfo        = &ParserData->ReportIDSizes[0];
        uint16_t              UsageList[HID_USAGE_STACK_DEPTH];
        uint8_t               UsageListSize           = 0;
        HID_MinMax_t          UsageMinMax             = {0, 0};
        uint16_t              UsageList[HID_USAGE_STACK_DEPTH];
        uint8_t               UsageListSize           = 0;
        HID_MinMax_t          UsageMinMax             = {0, 0};
@@ -50,16 +51,16 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
        memset(CurrStateTable,   0x00, sizeof(HID_StateTable_t));
        memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
 
        memset(CurrStateTable,   0x00, sizeof(HID_StateTable_t));
        memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
 
-       ParserData->TotalDeviceReports = 1;     
+       ParserData->TotalDeviceReports = 1;
 
        while (ReportSize)
        {
                uint8_t  HIDReportItem  = *ReportData;
                uint32_t ReportItemData = 0;
 
        while (ReportSize)
        {
                uint8_t  HIDReportItem  = *ReportData;
                uint32_t ReportItemData = 0;
-               
+
                ReportData++;
                ReportSize--;
                ReportData++;
                ReportSize--;
-               
+
                switch (HIDReportItem & DATA_SIZE_MASK)
                {
                        case DATA_SIZE_4:
                switch (HIDReportItem & DATA_SIZE_MASK)
                {
                        case DATA_SIZE_4:
@@ -84,7 +85,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
                        case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
                                if (CurrStateTable == &StateTable[HID_STATETABLE_STACK_DEPTH - 1])
                                  return HID_PARSE_HIDStackOverflow;
                        case (TYPE_GLOBAL | TAG_GLOBAL_PUSH):
                                if (CurrStateTable == &StateTable[HID_STATETABLE_STACK_DEPTH - 1])
                                  return HID_PARSE_HIDStackOverflow;
-       
+
                                memcpy((CurrStateTable + 1),
                                       CurrStateTable,
                                       sizeof(HID_ReportItem_t));
                                memcpy((CurrStateTable + 1),
                                       CurrStateTable,
                                       sizeof(HID_ReportItem_t));
@@ -94,7 +95,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
                        case (TYPE_GLOBAL | TAG_GLOBAL_POP):
                                if (CurrStateTable == &StateTable[0])
                                  return HID_PARSE_HIDStackUnderflow;
                        case (TYPE_GLOBAL | TAG_GLOBAL_POP):
                                if (CurrStateTable == &StateTable[0])
                                  return HID_PARSE_HIDStackUnderflow;
-                                 
+
                                CurrStateTable--;
                                break;
                        case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
                                CurrStateTable--;
                                break;
                        case (TYPE_GLOBAL | TAG_GLOBAL_USAGEPAGE):
@@ -139,25 +140,25 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
                                                        break;
                                                }
                                        }
                                                        break;
                                                }
                                        }
-                                       
+
                                        if (CurrReportIDInfo == NULL)
                                        {
                                                if (ParserData->TotalDeviceReports == HID_MAX_REPORT_IDS)
                                                  return HID_PARSE_InsufficientReportIDItems;
                                        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));
                                        }
                                }
 
                                                CurrReportIDInfo = &ParserData->ReportIDSizes[ParserData->TotalDeviceReports++];
                                                memset(CurrReportIDInfo, 0x00, sizeof(HID_ReportSizeInfo_t));
                                        }
                                }
 
-                               ParserData->UsingReportIDs = true;                              
+                               ParserData->UsingReportIDs = true;
 
                                CurrReportIDInfo->ReportID = CurrStateTable->ReportID;
                                break;
                        case (TYPE_LOCAL | TAG_LOCAL_USAGE):
                                if (UsageListSize == HID_USAGE_STACK_DEPTH)
                                  return HID_PARSE_UsageListOverflow;
 
                                CurrReportIDInfo->ReportID = CurrStateTable->ReportID;
                                break;
                        case (TYPE_LOCAL | TAG_LOCAL_USAGE):
                                if (UsageListSize == HID_USAGE_STACK_DEPTH)
                                  return HID_PARSE_UsageListOverflow;
-                       
+
                                UsageList[UsageListSize++] = ReportItemData;
                                break;
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
                                UsageList[UsageListSize++] = ReportItemData;
                                break;
                        case (TYPE_LOCAL | TAG_LOCAL_USAGEMIN):
@@ -174,42 +175,42 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
                                else
                                {
                                        HID_CollectionPath_t* ParentCollectionPath = CurrCollectionPath;
                                else
                                {
                                        HID_CollectionPath_t* ParentCollectionPath = CurrCollectionPath;
-                       
+
                                        CurrCollectionPath = &ParserData->CollectionPaths[1];
 
                                        while (CurrCollectionPath->Parent != NULL)
                                        {
                                                if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])
                                                  return HID_PARSE_InsufficientCollectionPaths;
                                        CurrCollectionPath = &ParserData->CollectionPaths[1];
 
                                        while (CurrCollectionPath->Parent != NULL)
                                        {
                                                if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])
                                                  return HID_PARSE_InsufficientCollectionPaths;
-                                       
+
                                                CurrCollectionPath++;
                                        }
 
                                        CurrCollectionPath->Parent = ParentCollectionPath;
                                }
                                                CurrCollectionPath++;
                                        }
 
                                        CurrCollectionPath->Parent = ParentCollectionPath;
                                }
-                               
+
                                CurrCollectionPath->Type = ReportItemData;
                                CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page;
                                CurrCollectionPath->Type = ReportItemData;
                                CurrCollectionPath->Usage.Page = CurrStateTable->Attributes.Usage.Page;
-                               
+
                                if (UsageListSize)
                                {
                                        CurrCollectionPath->Usage.Usage = UsageList[0];
 
                                        for (uint8_t i = 0; i < UsageListSize; i++)
                                          UsageList[i] = UsageList[i + 1];
                                if (UsageListSize)
                                {
                                        CurrCollectionPath->Usage.Usage = UsageList[0];
 
                                        for (uint8_t i = 0; i < UsageListSize; i++)
                                          UsageList[i] = UsageList[i + 1];
-                                       
+
                                        UsageListSize--;
                                }
                                else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)
                                {
                                        CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++;
                                }
                                        UsageListSize--;
                                }
                                else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)
                                {
                                        CurrCollectionPath->Usage.Usage = UsageMinMax.Minimum++;
                                }
-                               
+
                                break;
                        case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
                                if (CurrCollectionPath == NULL)
                                  return HID_PARSE_UnexpectedEndCollection;
                                break;
                        case (TYPE_MAIN | TAG_MAIN_ENDCOLLECTION):
                                if (CurrCollectionPath == NULL)
                                  return HID_PARSE_UnexpectedEndCollection;
-               
+
                                CurrCollectionPath = CurrCollectionPath->Parent;
                                break;
                        case (TYPE_MAIN | TAG_MAIN_INPUT):
                                CurrCollectionPath = CurrCollectionPath->Parent;
                                break;
                        case (TYPE_MAIN | TAG_MAIN_INPUT):
@@ -218,7 +219,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
                                for (uint8_t ReportItemNum = 0; ReportItemNum < CurrStateTable->ReportCount; ReportItemNum++)
                                {
                                        HID_ReportItem_t NewReportItem;
                                for (uint8_t ReportItemNum = 0; ReportItemNum < CurrStateTable->ReportCount; ReportItemNum++)
                                {
                                        HID_ReportItem_t NewReportItem;
-                                 
+
                                        memcpy(&NewReportItem.Attributes,
                                               &CurrStateTable->Attributes,
                                               sizeof(HID_ReportItem_Attributes_t));
                                        memcpy(&NewReportItem.Attributes,
                                               &CurrStateTable->Attributes,
                                               sizeof(HID_ReportItem_Attributes_t));
@@ -233,45 +234,45 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
 
                                                for (uint8_t i = 0; i < UsageListSize; i++)
                                                  UsageList[i] = UsageList[i + 1];
 
                                                for (uint8_t i = 0; i < UsageListSize; i++)
                                                  UsageList[i] = UsageList[i + 1];
-                                                 
+
                                                UsageListSize--;
                                        }
                                        else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)
                                        {
                                                NewReportItem.Attributes.Usage.Usage = UsageMinMax.Minimum++;
                                        }
                                                UsageListSize--;
                                        }
                                        else if (UsageMinMax.Minimum <= UsageMinMax.Maximum)
                                        {
                                                NewReportItem.Attributes.Usage.Usage = UsageMinMax.Minimum++;
                                        }
-                                       
+
                                        uint8_t ItemTag = (HIDReportItem & TAG_MASK);
 
                                        if (ItemTag == TAG_MAIN_INPUT)
                                        uint8_t ItemTag = (HIDReportItem & TAG_MASK);
 
                                        if (ItemTag == TAG_MAIN_INPUT)
-                                         NewReportItem.ItemType = REPORT_ITEM_TYPE_In;
+                                         NewReportItem.ItemType = HID_REPORT_ITEM_In;
                                        else if (ItemTag == TAG_MAIN_OUTPUT)
                                        else if (ItemTag == TAG_MAIN_OUTPUT)
-                                         NewReportItem.ItemType = REPORT_ITEM_TYPE_Out;
+                                         NewReportItem.ItemType = HID_REPORT_ITEM_Out;
                                        else
                                        else
-                                         NewReportItem.ItemType = REPORT_ITEM_TYPE_Feature;
-                                       
+                                         NewReportItem.ItemType = HID_REPORT_ITEM_Feature;
+
                                        NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType];
 
                                        CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize;
 
                                        if (ParserData->LargestReportSizeBits < NewReportItem.BitOffset)
                                          ParserData->LargestReportSizeBits = NewReportItem.BitOffset;
                                        NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType];
 
                                        CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize;
 
                                        if (ParserData->LargestReportSizeBits < NewReportItem.BitOffset)
                                          ParserData->LargestReportSizeBits = NewReportItem.BitOffset;
-                                       
+
                                        if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&NewReportItem))
                                        if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&NewReportItem))
-                                       {                                       
+                                       {
                                                if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)
                                                  return HID_PARSE_InsufficientReportItems;
                                                if (ParserData->TotalReportItems == HID_MAX_REPORTITEMS)
                                                  return HID_PARSE_InsufficientReportItems;
-                                       
+
                                                memcpy(&ParserData->ReportItems[ParserData->TotalReportItems],
                                                       &NewReportItem, sizeof(HID_ReportItem_t));
                                                memcpy(&ParserData->ReportItems[ParserData->TotalReportItems],
                                                       &NewReportItem, sizeof(HID_ReportItem_t));
-                                       
+
                                                ParserData->TotalReportItems++;
                                        }
                                }
                                                ParserData->TotalReportItems++;
                                        }
                                }
-                               
+
                                break;
                }
                                break;
                }
-         
+
                if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)
                {
                        UsageMinMax.Minimum = 0;
                if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)
                {
                        UsageMinMax.Minimum = 0;
@@ -279,10 +280,10 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
                        UsageListSize       = 0;
                }
        }
                        UsageListSize       = 0;
                }
        }
-       
+
        if (!(ParserData->TotalReportItems))
          return HID_PARSE_NoUnfilteredReportItems;
        if (!(ParserData->TotalReportItems))
          return HID_PARSE_NoUnfilteredReportItems;
-       
+
        return HID_PARSE_Successful;
 }
 
        return HID_PARSE_Successful;
 }
 
@@ -292,7 +293,7 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
        uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
        uint16_t CurrentBit   = ReportItem->BitOffset;
        uint32_t BitMask      = (1 << 0);
        uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
        uint16_t CurrentBit   = ReportItem->BitOffset;
        uint32_t BitMask      = (1 << 0);
-       
+
        if (ReportItem->ReportID)
        {
                if (ReportItem->ReportID != ReportData[0])
        if (ReportItem->ReportID)
        {
                if (ReportItem->ReportID != ReportData[0])
@@ -308,11 +309,11 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
        {
                if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
                  ReportItem->Value |= BitMask;
        {
                if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
                  ReportItem->Value |= BitMask;
-               
+
                CurrentBit++;
                BitMask <<= 1;
        }
                CurrentBit++;
                BitMask <<= 1;
        }
-       
+
        return true;
 }
 
        return true;
 }
 
@@ -348,7 +349,7 @@ uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
        for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)
        {
                uint16_t ReportSizeBits = ParserData->ReportIDSizes[i].ReportSizeBits[ReportType];
        for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)
        {
                uint16_t ReportSizeBits = ParserData->ReportIDSizes[i].ReportSizeBits[ReportType];
-       
+
                if (ParserData->ReportIDSizes[i].ReportID == ReportID)
                  return ((ReportSizeBits >> 3) + ((ReportSizeBits & 0x07) ? 1 : 0));
        }
                if (ParserData->ReportIDSizes[i].ReportID == ReportID)
                  return ((ReportSizeBits >> 3) + ((ReportSizeBits & 0x07) ? 1 : 0));
        }
@@ -357,3 +358,4 @@ uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
 }
 
 #endif
 }
 
 #endif
+
USB isp AVR programmer