Move RNDISConstants.h into the RNDIS class driver common definition header.
[pub/USBasp.git] / LUFA / Drivers / USB / Class / Host / HID.c
index b0593f0..4ba7558 100644 (file)
@@ -1,21 +1,21 @@
 /*
              LUFA Library
      Copyright (C) Dean Camera, 2010.
-              
+
   dean [at] fourwalledcubicle [dot] com
-      www.fourwalledcubicle.com
+           www.lufa-lib.org
 */
 
 /*
   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
-  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
-  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
 #include "../../HighLevel/USBMode.h"
 #if defined(USB_CAN_BE_HOST)
 
-#define  __INCLUDE_FROM_HID_CLASS_HOST_C
 #define  __INCLUDE_FROM_HID_DRIVER
+#define  __INCLUDE_FROM_HID_HOST_C
 #include "HID.h"
 
 uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
                                 uint16_t ConfigDescriptorSize,
                                 void* ConfigDescriptorData)
 {
-       USB_Descriptor_Interface_t* CurrentHIDInterface;
-
        USB_Descriptor_Endpoint_t*  DataINEndpoint  = NULL;
        USB_Descriptor_Endpoint_t*  DataOUTEndpoint = NULL;
-       
+       USB_Descriptor_Interface_t* HIDInterface    = NULL;
+       USB_HID_Descriptor_HID_t*   HIDDescriptor   = NULL;
+
        memset(&HIDInterfaceInfo->State, 0x00, sizeof(HIDInterfaceInfo->State));
-       
+
        if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
          return HID_ENUMERROR_InvalidConfigDescriptor;
-       
-       do
-       {
-               if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
-                                                                         DCOMP_HID_Host_NextHIDInterface) != DESCRIPTOR_SEARCH_COMP_Found)
-               {
-                       return HID_ENUMERROR_NoCompatibleInterfaceFound;
-               }
-               
-               CurrentHIDInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
-       } while (HIDInterfaceInfo->Config.HIDInterfaceProtocol &&
-                (CurrentHIDInterface->Protocol != HIDInterfaceInfo->Config.HIDInterfaceProtocol));
-
-       HIDInterfaceInfo->State.InterfaceNumber      = CurrentHIDInterface->InterfaceNumber;
-       HIDInterfaceInfo->State.SupportsBootProtocol = (CurrentHIDInterface->SubClass != HID_BOOTP_NonBootProtocol);
-
-       if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
-                                     DCOMP_HID_Host_NextHID) != DESCRIPTOR_SEARCH_COMP_Found)
-       {
-               return HID_ENUMERROR_NoCompatibleInterfaceFound;
-       }
-       
-       HIDInterfaceInfo->State.HIDReportSize = DESCRIPTOR_PCAST(ConfigDescriptorData,
-                                                                USB_HID_Descriptor_HID_t)->HIDReportLength;
 
        while (!(DataINEndpoint) || !(DataOUTEndpoint))
        {
-               if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
+               if (!(HIDInterface) ||
+                   USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
                                              DCOMP_HID_Host_NextHIDInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
                {
                        if (DataINEndpoint || DataOUTEndpoint)
                          break;
-       
+
                        do
                        {
                                if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
-                                                                                         DCOMP_HID_Host_NextHIDInterface) != DESCRIPTOR_SEARCH_COMP_Found)
+                                                             DCOMP_HID_Host_NextHIDInterface) != DESCRIPTOR_SEARCH_COMP_Found)
                                {
                                        return HID_ENUMERROR_NoCompatibleInterfaceFound;
                                }
-                               
-                               CurrentHIDInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
+
+                               HIDInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
                        } while (HIDInterfaceInfo->Config.HIDInterfaceProtocol &&
-                                        (CurrentHIDInterface->Protocol != HIDInterfaceInfo->Config.HIDInterfaceProtocol));
-                       
-                       HIDInterfaceInfo->State.InterfaceNumber      = CurrentHIDInterface->InterfaceNumber;
-                       HIDInterfaceInfo->State.SupportsBootProtocol = (CurrentHIDInterface->SubClass != HID_BOOTP_NonBootProtocol);
+                                        (HIDInterface->Protocol != HIDInterfaceInfo->Config.HIDInterfaceProtocol));
 
                        if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
                                                      DCOMP_HID_Host_NextHID) != DESCRIPTOR_SEARCH_COMP_Found)
@@ -103,49 +77,51 @@ uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo
                                return HID_ENUMERROR_NoCompatibleInterfaceFound;
                        }
 
-                       HIDInterfaceInfo->State.HIDReportSize = DESCRIPTOR_PCAST(ConfigDescriptorData,
-                                                                                USB_HID_Descriptor_HID_t)->HIDReportLength;
+                       HIDDescriptor = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_HID_Descriptor_HID_t);
 
                        DataINEndpoint  = NULL;
                        DataOUTEndpoint = NULL;
 
                        continue;
                }
-               
+
                USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
 
                if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
                  DataINEndpoint = EndpointData;
                else
-                 DataOUTEndpoint = EndpointData;                 
+                 DataOUTEndpoint = EndpointData;
        }
-       
+
        for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
        {
                if (PipeNum == HIDInterfaceInfo->Config.DataINPipeNumber)
                {
                        Pipe_ConfigurePipe(PipeNum, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
-                                                          DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
-                                                          HIDInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+                                          DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
+                                          HIDInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
                        Pipe_SetInterruptPeriod(DataINEndpoint->PollingIntervalMS);
-                       
-                       HIDInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;                  
+
+                       HIDInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
                }
                else if (PipeNum == HIDInterfaceInfo->Config.DataOUTPipeNumber)
                {
                        Pipe_ConfigurePipe(PipeNum, EP_TYPE_INTERRUPT, PIPE_TOKEN_OUT,
-                                                          DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
-                                                          HIDInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
+                                          DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
+                                          HIDInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
                        Pipe_SetInterruptPeriod(DataOUTEndpoint->PollingIntervalMS);
 
                        HIDInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
                        HIDInterfaceInfo->State.DeviceUsesOUTPipe = true;
                }
        }
-       
-       HIDInterfaceInfo->State.LargestReportSize = 8;
+
+       HIDInterfaceInfo->State.InterfaceNumber = HIDInterface->InterfaceNumber;
+       HIDInterfaceInfo->State.HIDReportSize   = HIDDescriptor->HIDReportLength;
+       HIDInterfaceInfo->State.SupportsBootProtocol = (HIDInterface->SubClass != HID_CSCP_NonBootProtocol);
+       HIDInterfaceInfo->State.LargestReportSize    = 8;
        HIDInterfaceInfo->State.IsActive = true;
-       
+
        return HID_ENUMERROR_NoError;
 }
 
@@ -155,11 +131,11 @@ static uint8_t DCOMP_HID_Host_NextHIDInterface(void* const CurrentDescriptor)
        {
                USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
                                                                                USB_Descriptor_Interface_t);
-       
-               if (CurrentInterface->Class == HID_INTERFACE_CLASS)
+
+               if (CurrentInterface->Class == HID_CSCP_HIDClass)
                  return DESCRIPTOR_SEARCH_Found;
        }
-       
+
        return DESCRIPTOR_SEARCH_NotFound;
 }
 
@@ -170,7 +146,7 @@ static uint8_t DCOMP_HID_Host_NextHID(void* const CurrentDescriptor)
        else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
          return DESCRIPTOR_SEARCH_Fail;
        else
-         return DESCRIPTOR_SEARCH_NotFound;      
+         return DESCRIPTOR_SEARCH_NotFound;
 }
 
 static uint8_t DCOMP_HID_Host_NextHIDInterfaceEndpoint(void* const CurrentDescriptor)
@@ -178,7 +154,7 @@ static uint8_t DCOMP_HID_Host_NextHIDInterfaceEndpoint(void* const CurrentDescri
        if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
        {
                USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
-                                                                             USB_Descriptor_Endpoint_t);       
+                                                                             USB_Descriptor_Endpoint_t);
 
                if (!(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress)))
                  return DESCRIPTOR_SEARCH_Found;
@@ -206,11 +182,11 @@ uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceI
        };
 
        Pipe_SelectPipe(PIPE_CONTROLPIPE);
-       
+
        return USB_Host_SendControlRequest(Buffer);
-}                                                                                         
+}
 #endif
-                                                                                  
+
 uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
                                void* Buffer)
 {
@@ -221,7 +197,7 @@ uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 
        Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
        Pipe_Unfreeze();
-       
+
        uint16_t ReportSize;
        uint8_t* BufferPos = Buffer;
 
@@ -229,13 +205,13 @@ uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
        if (!(HIDInterfaceInfo->State.UsingBootProtocol))
        {
                uint8_t ReportID = 0;
-       
+
                if (HIDInterfaceInfo->Config.HIDParserData->UsingReportIDs)
                {
                        ReportID = Pipe_Read_Byte();
                        *(BufferPos++) = ReportID;
                }
-               
+
                ReportSize = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, ReportID, HID_REPORT_ITEM_In);
        }
        else
@@ -246,10 +222,10 @@ uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 
        if ((ErrorCode = Pipe_Read_Stream_LE(BufferPos, ReportSize, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
-        
-       Pipe_ClearIN();         
+
+       Pipe_ClearIN();
        Pipe_Freeze();
-       
+
        return PIPE_RWSTREAM_NoError;
 }
 
@@ -268,19 +244,19 @@ uint8_t HID_Host_SendReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo
        if (HIDInterfaceInfo->State.DeviceUsesOUTPipe && (ReportType == HID_REPORT_ITEM_Out))
        {
                uint8_t ErrorCode;
-       
+
                Pipe_SelectPipe(HIDInterfaceInfo->Config.DataOUTPipeNumber);
                Pipe_Unfreeze();
-               
+
                if (ReportID)
                  Pipe_Write_Stream_LE(&ReportID, sizeof(ReportID), NO_STREAM_CALLBACK);
-               
+
                if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, ReportSize, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
                  return ErrorCode;
-               
+
                Pipe_ClearOUT();
                Pipe_Freeze();
-               
+
                return PIPE_RWSTREAM_NoError;
        }
        else
@@ -300,7 +276,7 @@ uint8_t HID_Host_SendReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo
                };
 
                Pipe_SelectPipe(PIPE_CONTROLPIPE);
-               
+
                return USB_Host_SendControlRequest(Buffer);
        }
 }
@@ -314,11 +290,11 @@ bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 
        Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
        Pipe_Unfreeze();
-       
+
        ReportReceived = Pipe_IsINReceived();
-       
+
        Pipe_Freeze();
-       
+
        return ReportReceived;
 }
 
@@ -336,7 +312,7 @@ uint8_t HID_Host_SetBootProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInf
                };
 
        Pipe_SelectPipe(PIPE_CONTROLPIPE);
-       
+
        if (!(HIDInterfaceInfo->State.SupportsBootProtocol))
          return HID_ERROR_LOGICAL;
 
@@ -345,7 +321,7 @@ uint8_t HID_Host_SetBootProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInf
 
        HIDInterfaceInfo->State.LargestReportSize = 8;
        HIDInterfaceInfo->State.UsingBootProtocol = true;
-       
+
        return HOST_SENDCONTROL_Successful;
 }
 
@@ -355,7 +331,7 @@ uint8_t HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceI
        uint8_t ErrorCode;
 
        uint8_t HIDReportData[HIDInterfaceInfo->State.HIDReportSize];
-       
+
        USB_ControlRequest = (USB_Request_Header_t)
                {
                        .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),
@@ -369,7 +345,7 @@ uint8_t HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceI
 
        if ((ErrorCode = USB_Host_SendControlRequest(HIDReportData)) != HOST_SENDCONTROL_Successful)
          return ErrorCode;
-         
+
        if (HIDInterfaceInfo->State.UsingBootProtocol)
        {
                USB_ControlRequest = (USB_Request_Header_t)
@@ -386,10 +362,10 @@ uint8_t HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceI
 
                HIDInterfaceInfo->State.UsingBootProtocol = false;
        }
-       
+
        if (HIDInterfaceInfo->Config.HIDParserData == NULL)
          return HID_ERROR_LOGICAL;
-               
+
        if ((ErrorCode = USB_ProcessHIDReport(HIDReportData, HIDInterfaceInfo->State.HIDReportSize,
                                              HIDInterfaceInfo->Config.HIDParserData)) != HID_PARSE_Successful)
        {
@@ -404,3 +380,4 @@ uint8_t HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceI
 #endif
 
 #endif
+