Oops - fix broken SPI driver due to missing bit inversion on a port mask.

[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 7116ed8..43f703a 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/HIDParser.c
+++ b/LUFA/Drivers/USB/Class/Host/HIDParser.c
@@ -1,7 +1,7 @@
 /*
              LUFA Library
      Copyright (C) Dean Camera, 2010.
 /*
              LUFA Library
      Copyright (C) Dean Camera, 2010.

-              
+

   dean [at] fourwalledcubicle [dot] com
       www.fourwalledcubicle.com
 */
   dean [at] fourwalledcubicle [dot] com
       www.fourwalledcubicle.com
 */


@@ -9,13 +9,13 @@
 /*
   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


@@ -34,12 +34,14 @@
 
 #include "HIDParser.h"
 
 
 #include "HIDParser.h"
 

-uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)
+uint8_t USB_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];
        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};


@@ -48,16 +50,16 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
        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:


@@ -82,7 +84,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                        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));


@@ -92,7 +94,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                        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):


@@ -137,25 +139,25 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                                                        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):


@@ -172,42 +174,42 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                                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):


@@ -216,7 +218,7 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
                                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));


@@ -231,68 +233,66 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
 
                                                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;
                        UsageMinMax.Maximum = 0;
                if ((HIDReportItem & TYPE_MASK) == TYPE_MAIN)
                {
                        UsageMinMax.Minimum = 0;
                        UsageMinMax.Maximum = 0;

-                       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;
 }
 

-bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem)
+bool USB_GetHIDReportItemInfo(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);
 
 {
        uint16_t DataBitsRem  = ReportItem->Attributes.BitSize;
        uint16_t CurrentBit   = ReportItem->BitOffset;
        uint32_t BitMask      = (1 << 0);
 

-       ReportItem->PreviousValue = ReportItem->Value;
-       ReportItem->Value = 0;
-       

        if (ReportItem->ReportID)
        {
                if (ReportItem->ReportID != ReportData[0])
        if (ReportItem->ReportID)
        {
                if (ReportItem->ReportID != ReportData[0])


@@ -301,19 +301,23 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const
                ReportData++;
        }
 
                ReportData++;
        }
 

+       ReportItem->PreviousValue = ReportItem->Value;
+       ReportItem->Value = 0;
+

        while (DataBitsRem--)
        {
                if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
                  ReportItem->Value |= BitMask;
        while (DataBitsRem--)
        {
                if (ReportData[CurrentBit / 8] & (1 << (CurrentBit % 8)))
                  ReportItem->Value |= BitMask;

-               
+

                CurrentBit++;
                BitMask <<= 1;
        }
                CurrentBit++;
                BitMask <<= 1;
        }

-       
+

        return true;
 }
 
        return true;
 }
 

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

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


@@ -337,12 +341,14 @@ void USB_SetHIDReportItemInfo(uint8_t* ReportData, HID_ReportItem_t* const Repor
        }
 }
 
        }
 }
 

-uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t ReportID, const uint8_t ReportType)
+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++)
        {
                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));
        }


@@ -351,3 +357,4 @@ uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t
 }
 
 #endif
 }
 
 #endif

+