Fix errors uncovered by the new build test compile warnings; fix UC3 pipe configurati...

[pub/USBasp.git] / LUFA / Drivers / USB / Core / HostStandardReq.c

diff --git a/LUFA/Drivers/USB/Core/HostStandardReq.c b/LUFA/Drivers/USB/Core/HostStandardReq.c
index d2523fd..649ad5e 100644 (file)
--- a/LUFA/Drivers/USB/Core/HostStandardReq.c
+++ b/LUFA/Drivers/USB/Core/HostStandardReq.c
@@ -1,13 +1,13 @@
 /*
              LUFA Library
-     Copyright (C) Dean Camera, 2011.
+     Copyright (C) Dean Camera, 2012.
 
   dean [at] fourwalledcubicle [dot] com
            www.lufa-lib.org
 */
 
 /*
-  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+  Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
   Permission to use, copy, modify, distribute, and sell this
   software and its documentation for any purpose is hereby granted
@@ -36,9 +36,10 @@
 #define  __INCLUDE_FROM_HOSTSTDREQ_C
 #include "HostStandardReq.h"
 
+uint8_t USB_Host_ConfigurationNumber;
+
 uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
 {
-       uint8_t* HeaderStream = (uint8_t*)&USB_ControlRequest;
        uint8_t* DataStream   = (uint8_t*)BufferPtr;
        bool     BusSuspended = USB_Host_IsBusSuspended();
        uint8_t  ReturnStatus = HOST_SENDCONTROL_Successful;
@@ -54,11 +55,18 @@ uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
 
        Pipe_Unfreeze();
 
-       Pipe_Write_Byte(USB_ControlRequest.bmRequestType);
-       Pipe_Write_Byte(USB_ControlRequest.bRequest);
-       Pipe_Write_Word_LE(USB_ControlRequest.wValue);
-       Pipe_Write_Word_LE(USB_ControlRequest.wIndex);
-       Pipe_Write_Word_LE(USB_ControlRequest.wLength);
+       #if defined(ARCH_BIG_ENDIAN)
+       Pipe_Write_8(USB_ControlRequest.bmRequestType);
+       Pipe_Write_8(USB_ControlRequest.bRequest);
+       Pipe_Write_16_LE(USB_ControlRequest.wValue);
+       Pipe_Write_16_LE(USB_ControlRequest.wIndex);
+       Pipe_Write_16_LE(USB_ControlRequest.wLength);
+       #else
+       uint8_t* HeaderStream = (uint8_t*)&USB_ControlRequest;
+
+       for (uint8_t HeaderByte = 0; HeaderByte < sizeof(USB_Request_Header_t); HeaderByte++)
+         Pipe_Write_8(*(HeaderStream++));
+       #endif
 
        Pipe_ClearSETUP();
 
@@ -88,7 +96,7 @@ uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
 
                                while (Pipe_BytesInPipe() && DataLen)
                                {
-                                       *(DataStream++) = Pipe_Read_Byte();
+                                       *(DataStream++) = Pipe_Read_8();
                                        DataLen--;
                                }
 
@@ -120,9 +128,9 @@ uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
                                if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)
                                  goto End_Of_Control_Send;
 
-                               while (DataLen && (Pipe_BytesInPipe() < USB_ControlPipeSize))
+                               while (DataLen && (Pipe_BytesInPipe() < USB_Host_ControlPipeSize))
                                {
-                                       Pipe_Write_Byte(*(DataStream++));
+                                       Pipe_Write_8(*(DataStream++));
                                        DataLen--;
                                }
 
@@ -179,5 +187,130 @@ static uint8_t USB_Host_WaitForIOS(const uint8_t WaitType)
        return HOST_SENDCONTROL_Successful;
 }
 
+uint8_t USB_Host_SetDeviceConfiguration(const uint8_t ConfigNumber)
+{
+       uint8_t ErrorCode;
+
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),
+                       .bRequest      = REQ_SetConfiguration,
+                       .wValue        = ConfigNumber,
+                       .wIndex        = 0,
+                       .wLength       = 0,
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       if ((ErrorCode = USB_Host_SendControlRequest(NULL)) == HOST_SENDCONTROL_Successful)
+       {
+               USB_Host_ConfigurationNumber = ConfigNumber;
+               USB_HostState                = (ConfigNumber) ? HOST_STATE_Configured : HOST_STATE_Addressed;
+       }
+
+       return ErrorCode;
+}
+
+uint8_t USB_Host_GetDeviceConfiguration(uint8_t* const ConfigNumber)
+{
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
+                       .bRequest      = REQ_GetConfiguration,
+                       .wValue        = 0,
+                       .wIndex        = 0,
+                       .wLength       = sizeof(uint8_t),
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       return USB_Host_SendControlRequest(ConfigNumber);
+}
+
+uint8_t USB_Host_GetDescriptor(const uint8_t Type,
+                               const uint8_t Index,
+                               void* const Buffer,
+                               const uint8_t BufferLength)
+{
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
+                       .bRequest      = REQ_GetDescriptor,
+                       .wValue        = (((uint16_t)Type << 8) | Index),
+                       .wIndex        = 0,
+                       .wLength       = BufferLength,
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       return USB_Host_SendControlRequest(Buffer);
+}
+
+uint8_t USB_Host_GetDeviceStatus(uint8_t* const FeatureStatus)
+{
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
+                       .bRequest      = REQ_GetStatus,
+                       .wValue        = 0,
+                       .wIndex        = 0,
+                       .wLength       = 0,
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       return USB_Host_SendControlRequest(FeatureStatus);
+}
+
+uint8_t USB_Host_ClearEndpointStall(const uint8_t EndpointAddress)
+{
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT),
+                       .bRequest      = REQ_ClearFeature,
+                       .wValue        = FEATURE_SEL_EndpointHalt,
+                       .wIndex        = EndpointAddress,
+                       .wLength       = 0,
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       return USB_Host_SendControlRequest(NULL);
+}
+
+uint8_t USB_Host_SetInterfaceAltSetting(const uint8_t InterfaceIndex,
+                                        const uint8_t AltSetting)
+{
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
+                       .bRequest      = REQ_SetInterface,
+                       .wValue        = AltSetting,
+                       .wIndex        = InterfaceIndex,
+                       .wLength       = 0,
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       return USB_Host_SendControlRequest(NULL);
+}
+
+uint8_t USB_Host_GetInterfaceAltSetting(const uint8_t InterfaceIndex,
+                                        uint8_t* const AltSetting)
+{
+       USB_ControlRequest = (USB_Request_Header_t)
+               {
+                       .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),
+                       .bRequest      = REQ_GetInterface,
+                       .wValue        = 0,
+                       .wIndex        = InterfaceIndex,
+                       .wLength       = sizeof(uint8_t),
+               };
+
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+       return USB_Host_SendControlRequest(AltSetting);
+}
+
 #endif