projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Clean up excessive whitespace at the end of each line using the wspurify tool made...
[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 c5d5f94..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
@@ -41,7 +41,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 +50,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 +84,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 +94,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 +139,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 +174,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];
                                        CurrCollectionPath = &ParserData->CollectionPaths[1];
-                                       
+
                                        while (CurrCollectionPath->Parent != NULL)
                                        {
                                                if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])
                                                  return HID_PARSE_InsufficientCollectionPaths;
                                        while (CurrCollectionPath->Parent != NULL)
                                        {
                                                if (CurrCollectionPath == &ParserData->CollectionPaths[HID_MAX_COLLECTIONS - 1])
                                                  return HID_PARSE_InsufficientCollectionPaths;
-                                       
+
                                                CurrCollectionPath++;
                                        }
                                                CurrCollectionPath++;
                                        }
-                                       
+
                                        CurrCollectionPath->Parent = ParentCollectionPath;
                                }
                                        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,60 +218,60 @@ 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));
-                                                  
+
                                        NewReportItem.ItemFlags      = ReportItemData;
                                        NewReportItem.CollectionPath = CurrCollectionPath;
                                        NewReportItem.ReportID       = CurrStateTable->ReportID;
                                        NewReportItem.ItemFlags      = ReportItemData;
                                        NewReportItem.CollectionPath = CurrCollectionPath;
                                        NewReportItem.ReportID       = CurrStateTable->ReportID;
-                                       
+
                                        if (UsageListSize)
                                        {
                                                NewReportItem.Attributes.Usage.Usage = UsageList[0];
                                        if (UsageListSize)
                                        {
                                                NewReportItem.Attributes.Usage.Usage = UsageList[0];
-                                               
+
                                                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);
                                        uint8_t ItemTag = (HIDReportItem & TAG_MASK);
-                                       
+
                                        if (ItemTag == TAG_MAIN_INPUT)
                                          NewReportItem.ItemType = HID_REPORT_ITEM_In;
                                        else if (ItemTag == TAG_MAIN_OUTPUT)
                                          NewReportItem.ItemType = HID_REPORT_ITEM_Out;
                                        else
                                          NewReportItem.ItemType = HID_REPORT_ITEM_Feature;
                                        if (ItemTag == TAG_MAIN_INPUT)
                                          NewReportItem.ItemType = HID_REPORT_ITEM_In;
                                        else if (ItemTag == TAG_MAIN_OUTPUT)
                                          NewReportItem.ItemType = HID_REPORT_ITEM_Out;
                                        else
                                          NewReportItem.ItemType = HID_REPORT_ITEM_Feature;
-                                       
+
                                        NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType];
                                        NewReportItem.BitOffset = CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType];
-                                       
+
                                        CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize;
                                        CurrReportIDInfo->ReportSizeBits[NewReportItem.ItemType] += CurrStateTable->Attributes.BitSize;
-                                       
+
                                        if (ParserData->LargestReportSizeBits < NewReportItem.BitOffset)
                                          ParserData->LargestReportSizeBits = NewReportItem.BitOffset;
                                        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;
                                        if (!(ReportItemData & IOF_CONSTANT) && CALLBACK_HIDParser_FilterHIDReportItem(&NewReportItem))
                                        {
                                                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 +279,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,27 +292,27 @@ 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])
                  return false;
        if (ReportItem->ReportID)
        {
                if (ReportItem->ReportID != ReportData[0])
                  return false;
-                 
+
                ReportData++;
        }
                ReportData++;
        }
-       
+
        ReportItem->PreviousValue = ReportItem->Value;
        ReportItem->Value = 0;
        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;
 }
 
@@ -322,20 +322,20 @@ void USB_SetHIDReportItemInfo(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)
        {
                ReportData[0] = ReportItem->ReportID;
                ReportData++;
        }
        if (ReportItem->ReportID)
        {
                ReportData[0] = ReportItem->ReportID;
                ReportData++;
        }
-       
+
        ReportItem->PreviousValue = ReportItem->Value;
        ReportItem->PreviousValue = ReportItem->Value;
-       
+
        while (DataBitsRem--)
        {
                if (ReportItem->Value & (1 << (CurrentBit % 8)))
                  ReportData[CurrentBit / 8] |= BitMask;
        while (DataBitsRem--)
        {
                if (ReportItem->Value & (1 << (CurrentBit % 8)))
                  ReportData[CurrentBit / 8] |= BitMask;
-                 
+
                CurrentBit++;
                BitMask <<= 1;
        }
                CurrentBit++;
                BitMask <<= 1;
        }
@@ -348,7 +348,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 +357,4 @@ uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
 }
 
 #endif
 }
 
 #endif
+
USB isp AVR programmer