X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/df5500e81cc40633eb5edee59410030f0aa77c2d..6bbd2a99c216bd47aeeaa53ab3687cb045a37e5a:/LUFA/Drivers/USB/Class/Host/HID.c

diff --git a/LUFA/Drivers/USB/Class/Host/HID.c b/LUFA/Drivers/USB/Class/Host/HID.c
index 793523866..741f56a18 100644
--- a/LUFA/Drivers/USB/Class/Host/HID.c
+++ b/LUFA/Drivers/USB/Class/Host/HID.c
@@ -36,7 +36,7 @@
 
 #warning The HID Host mode Class driver is currently incomplete and is for preview purposes only.
 
-uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint16_t ConfigDescriptorSize,
+uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, uint16_t ConfigDescriptorSize,
                                 uint8_t* ConfigDescriptorData)
 {
 	uint8_t FoundEndpoints = 0;
@@ -60,20 +60,22 @@ uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint
 	} while (HIDInterfaceInfo->Config.HIDInterfaceProtocol &&
 	         (CurrentHIDInterface->Protocol != HIDInterfaceInfo->Config.HIDInterfaceProtocol));
 
-	HIDInterfaceInfo->State.InterfaceNumber	     =
-	#if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)
-	                     CurrentHIDInterface->InterfaceNumber;
-	#else
-	                     CurrentHIDInterface->bInterfaceNumber;
-	#endif
-	HIDInterfaceInfo->State.SupportsBootSubClass = (CurrentHIDInterface->SubClass != 0);
+	HIDInterfaceInfo->State.InterfaceNumber      = CurrentHIDInterface->InterfaceNumber;
+	HIDInterfaceInfo->State.SupportsBootProtocol = (CurrentHIDInterface->SubClass != HID_NON_BOOT_PROTOCOL);
+
+	if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData, DComp_NextHID) != DESCRIPTOR_SEARCH_COMP_Found)
+	{
+		return HID_ENUMERROR_NoHIDDescriptorFound;
+	}
+
+	HIDInterfaceInfo->State.HIDReportSize = DESCRIPTOR_CAST(ConfigDescriptorData, USB_HID_Descriptor_t).HIDReportLength;
 
 	while (FoundEndpoints != (HID_FOUND_DATAPIPE_IN | HID_FOUND_DATAPIPE_OUT))
 	{
 		if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
-		                              DComp_HID_Host_NextInterfaceHIDDataEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
+		                              DComp_HID_Host_NextHIDInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
 		{
-			if (FoundEndpoints == (1 << HID_FOUND_DATAPIPE_IN))
+			if (FoundEndpoints & HID_FOUND_DATAPIPE_IN)
 			  break;
 				
 			return HID_ENUMERROR_EndpointsNotFound;
@@ -95,11 +97,13 @@ uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint
 							   EndpointData->EndpointAddress, EndpointData->EndpointSize, PIPE_BANK_SINGLE);
 			HIDInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
 			
+			HIDInterfaceInfo->State.DeviceUsesOUTPipe = true;
+			
 			FoundEndpoints |= HID_FOUND_DATAPIPE_OUT;		
 		}
 	}
 
-	HIDInterfaceInfo->State.Active = true;
+	HIDInterfaceInfo->State.IsActive = true;
 	return HID_ENUMERROR_NoError;
 }
 
@@ -117,7 +121,17 @@ static uint8_t DComp_HID_Host_NextHIDInterface(void* CurrentDescriptor)
 	return DESCRIPTOR_SEARCH_NotFound;
 }
 
-static uint8_t DComp_HID_Host_NextInterfaceHIDDataEndpoint(void* CurrentDescriptor)
+static uint8_t DComp_NextHID(void* CurrentDescriptor)
+{
+	if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_HID)
+	  return DESCRIPTOR_SEARCH_Found;
+	else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
+	  return DESCRIPTOR_SEARCH_Fail;
+	else
+	  return DESCRIPTOR_SEARCH_NotFound;	  
+}
+
+static uint8_t DComp_HID_Host_NextHIDInterfaceEndpoint(void* CurrentDescriptor)
 {
 	if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 	{
@@ -135,42 +149,193 @@ static uint8_t DComp_HID_Host_NextInterfaceHIDDataEndpoint(void* CurrentDescript
 	return DESCRIPTOR_SEARCH_NotFound;
 }
 
-void HID_Host_USBTask(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo)
+void HID_Host_USBTask(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 {
 
 }
 
-bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo)
+uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, const bool ControlRequest,
+                               uint8_t* ReportID, void* Buffer)
 {
-	bool ReportReceived;
+	if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
+	  return false;
+
+	if (ControlRequest)
+	{
+		USB_ControlRequest = (USB_Request_Header_t)
+		{
+			.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
+			.bRequest      = REQ_SetReport,
+			.wValue        = *ReportID,
+			.wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
+			.wLength       = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, *ReportID, REPORT_ITEM_TYPE_In),
+		};
+
+		Pipe_SelectPipe(PIPE_CONTROLPIPE);
+		
+		return USB_Host_SendControlRequest(Buffer);
+	}
+	else
+	{
+		uint8_t ErrorCode;
+	
+		Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
+		Pipe_Unfreeze();
+		
+		uint16_t ReportSize;
+
+		if (HIDInterfaceInfo->State.UsingBootProtocol)
+		{
+			ReportSize = Pipe_BytesInPipe();
+		}
+		else
+		{
+			if (HIDInterfaceInfo->Config.HIDParserData->UsingReportIDs)
+				*ReportID = Pipe_Read_Byte();
+			else
+				*ReportID = 0;
+			
+			ReportSize = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, *ReportID, REPORT_ITEM_TYPE_In);
+		}
+
+		if ((ErrorCode = Pipe_Read_Stream_LE(Buffer, ReportSize, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
+		  return ErrorCode;
+		 
+		Pipe_ClearIN();		
+		Pipe_Freeze();
+		
+		return PIPE_RWSTREAM_NoError;		
+	}
+}
 
-	if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.Active))
+uint8_t HID_Host_SendReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, uint8_t ReportID, void* Buffer,
+                            const uint16_t ReportSize)
+{
+	if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 	  return false;
+	  
+	if (HIDInterfaceInfo->State.DeviceUsesOUTPipe)
+	{
+		USB_ControlRequest = (USB_Request_Header_t)
+		{
+			.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
+			.bRequest      = REQ_SetReport,
+			.wValue        = ReportID,
+			.wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
+			.wLength       = ReportSize,
+		};
+
+		Pipe_SelectPipe(PIPE_CONTROLPIPE);
+		
+		return USB_Host_SendControlRequest(Buffer);
+	}
+	else
+	{
+		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;
+	}
+}
+
+bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
+{
+	if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
+	  return false;
+
+	bool ReportReceived;
 
 	Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
 	Pipe_Unfreeze();
 	
-	ReportReceived = Pipe_IsReadWriteAllowed();
+	ReportReceived = Pipe_IsINReceived();
 	
 	Pipe_Freeze();
-
+	
 	return ReportReceived;
 }
 
-uint8_t USB_HID_Host_SetProtocol(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, bool UseReportProtocol)
+uint8_t USB_HID_Host_SetBootProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 {
+	uint8_t ErrorCode;
+
 	USB_ControlRequest = (USB_Request_Header_t)
 		{
 			.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 			.bRequest      = REQ_SetProtocol,
-			.wValue        = UseReportProtocol,
+			.wValue        = 0,
 			.wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 			.wLength       = 0,
 		};
 
 	Pipe_SelectPipe(PIPE_CONTROLPIPE);
 	
-	return USB_Host_SendControlRequest(NULL);
+	if (!(HIDInterfaceInfo->State.SupportsBootProtocol))
+	  return HID_ERROR_LOGICAL;
+
+	if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
+	  return ErrorCode;
+
+	HIDInterfaceInfo->State.UsingBootProtocol = true;
+	
+	return HOST_SENDCONTROL_Successful;
+}
+
+uint8_t USB_HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
+{
+	uint8_t ErrorCode;
+
+	uint8_t HIDReportData[HIDInterfaceInfo->State.HIDReportSize];
+	
+	USB_ControlRequest = (USB_Request_Header_t)
+		{
+			.bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),
+			.bRequest      = REQ_GetDescriptor,
+			.wValue        = (DTYPE_Report << 8),
+			.wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
+			.wLength       = HIDInterfaceInfo->State.HIDReportSize,
+		};
+
+	Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+	if ((ErrorCode = USB_Host_SendControlRequest(HIDReportData)) != HOST_SENDCONTROL_Successful)
+	  return ErrorCode;
+	  
+	USB_ControlRequest = (USB_Request_Header_t)
+		{
+			.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
+			.bRequest      = REQ_SetProtocol,
+			.wValue        = 1,
+			.wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
+			.wLength       = 0,
+		};
+
+	if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
+	  return ErrorCode;
+
+	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)
+	{
+		return HID_ERROR_LOGICAL | ErrorCode;
+	}
+
+	return 0;
 }
 
 #endif