Fix the LUFA lib to use a submodule instead of just files (#6245)

* Remove LUFA files

* Update descriptions for newer version of LUFA

* Create PR6245.md

* Fix CDC(Serial) type errors

* Fix missed merge conflict for AUDIO_DTYPE_CSInterface

1 files changed, 0 insertions, 508 deletions

diff --git a/lib/lufa/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c b/lib/lufa/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c
deleted file mode 100644
index 45293b12f..000000000
--- a/lib/lufa/LUFA/Drivers/USB/Class/Device/RNDISClassDevice.c
+++ /dev/null
@@ -1,508 +0,0 @@
-/*
-             LUFA Library
-     Copyright (C) Dean Camera, 2017.
-
-  dean [at] fourwalledcubicle [dot] com
-           www.lufa-lib.org
-*/
-
-/*
-  Copyright 2017  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
-  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
-  software without specific, written prior permission.
-
-  The author disclaims all warranties with regard to this
-  software, including all implied warranties of merchantability
-  and fitness.  In no event shall the author be liable for any
-  special, indirect or consequential damages or any damages
-  whatsoever resulting from loss of use, data or profits, whether
-  in an action of contract, negligence or other tortious action,
-  arising out of or in connection with the use or performance of
-  this software.
-*/
-
-#define  __INCLUDE_FROM_USB_DRIVER
-#include "../../Core/USBMode.h"
-
-#if defined(USB_CAN_BE_DEVICE)
-
-#define  __INCLUDE_FROM_RNDIS_DRIVER
-#define  __INCLUDE_FROM_RNDIS_DEVICE_C
-#include "RNDISClassDevice.h"
-
-static const uint32_t PROGMEM AdapterSupportedOIDList[]  =
-	{
-		CPU_TO_LE32(OID_GEN_SUPPORTED_LIST),
-		CPU_TO_LE32(OID_GEN_PHYSICAL_MEDIUM),
-		CPU_TO_LE32(OID_GEN_HARDWARE_STATUS),
-		CPU_TO_LE32(OID_GEN_MEDIA_SUPPORTED),
-		CPU_TO_LE32(OID_GEN_MEDIA_IN_USE),
-		CPU_TO_LE32(OID_GEN_MAXIMUM_FRAME_SIZE),
-		CPU_TO_LE32(OID_GEN_MAXIMUM_TOTAL_SIZE),
-		CPU_TO_LE32(OID_GEN_LINK_SPEED),
-		CPU_TO_LE32(OID_GEN_TRANSMIT_BLOCK_SIZE),
-		CPU_TO_LE32(OID_GEN_RECEIVE_BLOCK_SIZE),
-		CPU_TO_LE32(OID_GEN_VENDOR_ID),
-		CPU_TO_LE32(OID_GEN_VENDOR_DESCRIPTION),
-		CPU_TO_LE32(OID_GEN_CURRENT_PACKET_FILTER),
-		CPU_TO_LE32(OID_GEN_MAXIMUM_TOTAL_SIZE),
-		CPU_TO_LE32(OID_GEN_MEDIA_CONNECT_STATUS),
-		CPU_TO_LE32(OID_GEN_XMIT_OK),
-		CPU_TO_LE32(OID_GEN_RCV_OK),
-		CPU_TO_LE32(OID_GEN_XMIT_ERROR),
-		CPU_TO_LE32(OID_GEN_RCV_ERROR),
-		CPU_TO_LE32(OID_GEN_RCV_NO_BUFFER),
-		CPU_TO_LE32(OID_802_3_PERMANENT_ADDRESS),
-		CPU_TO_LE32(OID_802_3_CURRENT_ADDRESS),
-		CPU_TO_LE32(OID_802_3_MULTICAST_LIST),
-		CPU_TO_LE32(OID_802_3_MAXIMUM_LIST_SIZE),
-		CPU_TO_LE32(OID_802_3_RCV_ERROR_ALIGNMENT),
-		CPU_TO_LE32(OID_802_3_XMIT_ONE_COLLISION),
-		CPU_TO_LE32(OID_802_3_XMIT_MORE_COLLISIONS),
-	};
-
-void RNDIS_Device_ProcessControlRequest(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
-{
-	if (!(Endpoint_IsSETUPReceived()))
-	  return;
-
-	if (USB_ControlRequest.wIndex != RNDISInterfaceInfo->Config.ControlInterfaceNumber)
-	  return;
-
-	switch (USB_ControlRequest.bRequest)
-	{
-		case RNDIS_REQ_SendEncapsulatedCommand:
-			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
-			{
-				Endpoint_ClearSETUP();
-				Endpoint_Read_Control_Stream_LE(RNDISInterfaceInfo->Config.MessageBuffer, USB_ControlRequest.wLength);
-				Endpoint_ClearIN();
-
-				RNDIS_Device_ProcessRNDISControlMessage(RNDISInterfaceInfo);
-			}
-
-			break;
-		case RNDIS_REQ_GetEncapsulatedResponse:
-			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
-			{
-				RNDIS_Message_Header_t* MessageHeader = (RNDIS_Message_Header_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-
-				if (!(MessageHeader->MessageLength))
-				{
-					RNDISInterfaceInfo->Config.MessageBuffer[0] = 0;
-					MessageHeader->MessageLength                = CPU_TO_LE32(1);
-				}
-
-				Endpoint_ClearSETUP();
-				Endpoint_Write_Control_Stream_LE(RNDISInterfaceInfo->Config.MessageBuffer, le32_to_cpu(MessageHeader->MessageLength));
-				Endpoint_ClearOUT();
-
-				MessageHeader->MessageLength = CPU_TO_LE32(0);
-			}
-
-			break;
-	}
-}
-
-bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
-{
-	memset(&RNDISInterfaceInfo->State, 0x00, sizeof(RNDISInterfaceInfo->State));
-
-	RNDISInterfaceInfo->Config.DataINEndpoint.Type       = EP_TYPE_BULK;
-	RNDISInterfaceInfo->Config.DataOUTEndpoint.Type      = EP_TYPE_BULK;
-	RNDISInterfaceInfo->Config.NotificationEndpoint.Type = EP_TYPE_INTERRUPT;
-
-	if (RNDISInterfaceInfo->Config.MessageBuffer == NULL)
-	  return false;
-
-	if (RNDISInterfaceInfo->Config.MessageBufferLength < RNDIS_DEVICE_MIN_MESSAGE_BUFFER_LENGTH)
-	  return false;
-
-	if (!(Endpoint_ConfigureEndpointTable(&RNDISInterfaceInfo->Config.DataINEndpoint, 1)))
-	  return false;
-
-	if (!(Endpoint_ConfigureEndpointTable(&RNDISInterfaceInfo->Config.DataOUTEndpoint, 1)))
-	  return false;
-
-	if (!(Endpoint_ConfigureEndpointTable(&RNDISInterfaceInfo->Config.NotificationEndpoint, 1)))
-	  return false;
-
-	return true;
-}
-
-void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
-{
-	if (USB_DeviceState != DEVICE_STATE_Configured)
-	  return;
-
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.NotificationEndpoint.Address);
-
-	if (Endpoint_IsINReady() && RNDISInterfaceInfo->State.ResponseReady)
-	{
-		USB_Request_Header_t Notification = (USB_Request_Header_t)
-			{
-				.bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
-				.bRequest      = RNDIS_NOTIF_ResponseAvailable,
-				.wValue        = CPU_TO_LE16(0),
-				.wIndex        = CPU_TO_LE16(0),
-				.wLength       = CPU_TO_LE16(0),
-			};
-
-		Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NULL);
-
-		Endpoint_ClearIN();
-
-		RNDISInterfaceInfo->State.ResponseReady = false;
-	}
-}
-
-void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
-{
-	/* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of
-	         this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */
-
-	RNDIS_Message_Header_t* MessageHeader = (RNDIS_Message_Header_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-
-	switch (le32_to_cpu(MessageHeader->MessageType))
-	{
-		case REMOTE_NDIS_INITIALIZE_MSG:
-			RNDISInterfaceInfo->State.ResponseReady     = true;
-
-			RNDIS_Initialize_Message_t*  INITIALIZE_Message  =
-			               (RNDIS_Initialize_Message_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-			RNDIS_Initialize_Complete_t* INITIALIZE_Response =
-			               (RNDIS_Initialize_Complete_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-
-			INITIALIZE_Response->MessageType            = CPU_TO_LE32(REMOTE_NDIS_INITIALIZE_CMPLT);
-			INITIALIZE_Response->MessageLength          = CPU_TO_LE32(sizeof(RNDIS_Initialize_Complete_t));
-			INITIALIZE_Response->RequestId              = INITIALIZE_Message->RequestId;
-			INITIALIZE_Response->Status                 = CPU_TO_LE32(REMOTE_NDIS_STATUS_SUCCESS);
-
-			INITIALIZE_Response->MajorVersion           = CPU_TO_LE32(REMOTE_NDIS_VERSION_MAJOR);
-			INITIALIZE_Response->MinorVersion           = CPU_TO_LE32(REMOTE_NDIS_VERSION_MINOR);
-			INITIALIZE_Response->DeviceFlags            = CPU_TO_LE32(REMOTE_NDIS_DF_CONNECTIONLESS);
-			INITIALIZE_Response->Medium                 = CPU_TO_LE32(REMOTE_NDIS_MEDIUM_802_3);
-			INITIALIZE_Response->MaxPacketsPerTransfer  = CPU_TO_LE32(1);
-			INITIALIZE_Response->MaxTransferSize        = CPU_TO_LE32(sizeof(RNDIS_Packet_Message_t) + ETHERNET_FRAME_SIZE_MAX);
-			INITIALIZE_Response->PacketAlignmentFactor  = CPU_TO_LE32(0);
-			INITIALIZE_Response->AFListOffset           = CPU_TO_LE32(0);
-			INITIALIZE_Response->AFListSize             = CPU_TO_LE32(0);
-
-			RNDISInterfaceInfo->State.CurrRNDISState    = RNDIS_Initialized;
-			break;
-		case REMOTE_NDIS_HALT_MSG:
-			RNDISInterfaceInfo->State.ResponseReady     = false;
-
-			MessageHeader->MessageLength                = CPU_TO_LE32(0);
-
-			RNDISInterfaceInfo->State.CurrRNDISState    = RNDIS_Uninitialized;
-			break;
-		case REMOTE_NDIS_QUERY_MSG:
-			RNDISInterfaceInfo->State.ResponseReady     = true;
-
-			RNDIS_Query_Message_t*  QUERY_Message       = (RNDIS_Query_Message_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-			RNDIS_Query_Complete_t* QUERY_Response      = (RNDIS_Query_Complete_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-			uint32_t                Query_Oid           = CPU_TO_LE32(QUERY_Message->Oid);
-
-			void*    QueryData    = &RNDISInterfaceInfo->Config.MessageBuffer[sizeof(RNDIS_Message_Header_t) +
-			                                                                  le32_to_cpu(QUERY_Message->InformationBufferOffset)];
-			void*    ResponseData = &RNDISInterfaceInfo->Config.MessageBuffer[sizeof(RNDIS_Query_Complete_t)];
-			uint16_t ResponseSize;
-
-			QUERY_Response->MessageType                 = CPU_TO_LE32(REMOTE_NDIS_QUERY_CMPLT);
-
-			if (RNDIS_Device_ProcessNDISQuery(RNDISInterfaceInfo, Query_Oid, QueryData, le32_to_cpu(QUERY_Message->InformationBufferLength),
-			                                  ResponseData, &ResponseSize))
-			{
-				QUERY_Response->Status                  = CPU_TO_LE32(REMOTE_NDIS_STATUS_SUCCESS);
-				QUERY_Response->MessageLength           = cpu_to_le32(sizeof(RNDIS_Query_Complete_t) + ResponseSize);
-
-				QUERY_Response->InformationBufferLength = CPU_TO_LE32(ResponseSize);
-				QUERY_Response->InformationBufferOffset = CPU_TO_LE32(sizeof(RNDIS_Query_Complete_t) - sizeof(RNDIS_Message_Header_t));
-			}
-			else
-			{
-				QUERY_Response->Status                  = CPU_TO_LE32(REMOTE_NDIS_STATUS_NOT_SUPPORTED);
-				QUERY_Response->MessageLength           = CPU_TO_LE32(sizeof(RNDIS_Query_Complete_t));
-
-				QUERY_Response->InformationBufferLength = CPU_TO_LE32(0);
-				QUERY_Response->InformationBufferOffset = CPU_TO_LE32(0);
-			}
-
-			break;
-		case REMOTE_NDIS_SET_MSG:
-			RNDISInterfaceInfo->State.ResponseReady     = true;
-
-			RNDIS_Set_Message_t*  SET_Message           = (RNDIS_Set_Message_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-			RNDIS_Set_Complete_t* SET_Response          = (RNDIS_Set_Complete_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-			uint32_t              SET_Oid               = le32_to_cpu(SET_Message->Oid);
-
-			SET_Response->MessageType                   = CPU_TO_LE32(REMOTE_NDIS_SET_CMPLT);
-			SET_Response->MessageLength                 = CPU_TO_LE32(sizeof(RNDIS_Set_Complete_t));
-			SET_Response->RequestId                     = SET_Message->RequestId;
-
-			void* SetData = &RNDISInterfaceInfo->Config.MessageBuffer[sizeof(RNDIS_Message_Header_t) +
-			                                                              le32_to_cpu(SET_Message->InformationBufferOffset)];
-
-			SET_Response->Status = RNDIS_Device_ProcessNDISSet(RNDISInterfaceInfo, SET_Oid, SetData,
-			                                                   le32_to_cpu(SET_Message->InformationBufferLength)) ?
-			                                                   REMOTE_NDIS_STATUS_SUCCESS : REMOTE_NDIS_STATUS_NOT_SUPPORTED;
-			break;
-		case REMOTE_NDIS_RESET_MSG:
-			RNDISInterfaceInfo->State.ResponseReady     = true;
-
-			RNDIS_Reset_Complete_t* RESET_Response      = (RNDIS_Reset_Complete_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-
-			RESET_Response->MessageType                 = CPU_TO_LE32(REMOTE_NDIS_RESET_CMPLT);
-			RESET_Response->MessageLength               = CPU_TO_LE32(sizeof(RNDIS_Reset_Complete_t));
-			RESET_Response->Status                      = CPU_TO_LE32(REMOTE_NDIS_STATUS_SUCCESS);
-			RESET_Response->AddressingReset             = CPU_TO_LE32(0);
-
-			break;
-		case REMOTE_NDIS_KEEPALIVE_MSG:
-			RNDISInterfaceInfo->State.ResponseReady     = true;
-
-			RNDIS_KeepAlive_Message_t*  KEEPALIVE_Message  =
-			                (RNDIS_KeepAlive_Message_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-			RNDIS_KeepAlive_Complete_t* KEEPALIVE_Response =
-			                (RNDIS_KeepAlive_Complete_t*)RNDISInterfaceInfo->Config.MessageBuffer;
-
-			KEEPALIVE_Response->MessageType             = CPU_TO_LE32(REMOTE_NDIS_KEEPALIVE_CMPLT);
-			KEEPALIVE_Response->MessageLength           = CPU_TO_LE32(sizeof(RNDIS_KeepAlive_Complete_t));
-			KEEPALIVE_Response->RequestId               = KEEPALIVE_Message->RequestId;
-			KEEPALIVE_Response->Status                  = CPU_TO_LE32(REMOTE_NDIS_STATUS_SUCCESS);
-
-			break;
-	}
-}
-
-static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
-                                          const uint32_t OId,
-                                          void* const QueryData,
-                                          const uint16_t QuerySize,
-                                          void* ResponseData,
-                                          uint16_t* const ResponseSize)
-{
-	(void)QueryData;
-	(void)QuerySize;
-
-	switch (OId)
-	{
-		case OID_GEN_SUPPORTED_LIST:
-			*ResponseSize = sizeof(AdapterSupportedOIDList);
-
-			memcpy_P(ResponseData, AdapterSupportedOIDList, sizeof(AdapterSupportedOIDList));
-
-			return true;
-		case OID_GEN_PHYSICAL_MEDIUM:
-			*ResponseSize = sizeof(uint32_t);
-
-			/* Indicate that the device is a true ethernet link */
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(0);
-
-			return true;
-		case OID_GEN_HARDWARE_STATUS:
-			*ResponseSize = sizeof(uint32_t);
-
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(NDIS_HardwareStatus_Ready);
-
-			return true;
-		case OID_GEN_MEDIA_SUPPORTED:
-		case OID_GEN_MEDIA_IN_USE:
-			*ResponseSize = sizeof(uint32_t);
-
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(REMOTE_NDIS_MEDIUM_802_3);
-
-			return true;
-		case OID_GEN_VENDOR_ID:
-			*ResponseSize = sizeof(uint32_t);
-
-			/* Vendor ID 0x0xFFFFFF is reserved for vendors who have not purchased a NDIS VID */
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(0x00FFFFFF);
-
-			return true;
-		case OID_GEN_MAXIMUM_FRAME_SIZE:
-		case OID_GEN_TRANSMIT_BLOCK_SIZE:
-		case OID_GEN_RECEIVE_BLOCK_SIZE:
-			*ResponseSize = sizeof(uint32_t);
-
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(ETHERNET_FRAME_SIZE_MAX);
-
-			return true;
-		case OID_GEN_VENDOR_DESCRIPTION:
-			*ResponseSize = (strlen(RNDISInterfaceInfo->Config.AdapterVendorDescription) + 1);
-
-			memcpy(ResponseData, RNDISInterfaceInfo->Config.AdapterVendorDescription, *ResponseSize);
-
-			return true;
-		case OID_GEN_MEDIA_CONNECT_STATUS:
-			*ResponseSize = sizeof(uint32_t);
-
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(REMOTE_NDIS_MEDIA_STATE_CONNECTED);
-
-			return true;
-		case OID_GEN_LINK_SPEED:
-			*ResponseSize = sizeof(uint32_t);
-
-			/* Indicate 10Mb/s link speed */
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(100000);
-
-			return true;
-		case OID_802_3_PERMANENT_ADDRESS:
-		case OID_802_3_CURRENT_ADDRESS:
-			*ResponseSize = sizeof(MAC_Address_t);
-
-			memcpy(ResponseData, &RNDISInterfaceInfo->Config.AdapterMACAddress, sizeof(MAC_Address_t));
-
-			return true;
-		case OID_802_3_MAXIMUM_LIST_SIZE:
-			*ResponseSize = sizeof(uint32_t);
-
-			/* Indicate only one multicast address supported */
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(1);
-
-			return true;
-		case OID_GEN_CURRENT_PACKET_FILTER:
-			*ResponseSize = sizeof(uint32_t);
-
-			*((uint32_t*)ResponseData) = cpu_to_le32(RNDISInterfaceInfo->State.CurrPacketFilter);
-
-			return true;
-		case OID_GEN_XMIT_OK:
-		case OID_GEN_RCV_OK:
-		case OID_GEN_XMIT_ERROR:
-		case OID_GEN_RCV_ERROR:
-		case OID_GEN_RCV_NO_BUFFER:
-		case OID_802_3_RCV_ERROR_ALIGNMENT:
-		case OID_802_3_XMIT_ONE_COLLISION:
-		case OID_802_3_XMIT_MORE_COLLISIONS:
-			*ResponseSize = sizeof(uint32_t);
-
-			/* Unused statistic OIDs - always return 0 for each */
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(0);
-
-			return true;
-		case OID_GEN_MAXIMUM_TOTAL_SIZE:
-			*ResponseSize = sizeof(uint32_t);
-
-			/* Indicate maximum overall buffer (Ethernet frame and RNDIS header) the adapter can handle */
-			*((uint32_t*)ResponseData) = CPU_TO_LE32(RNDISInterfaceInfo->Config.MessageBufferLength + ETHERNET_FRAME_SIZE_MAX);
-
-			return true;
-		default:
-			return false;
-	}
-}
-
-static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
-                                        const uint32_t OId,
-                                        const void* SetData,
-                                        const uint16_t SetSize)
-{
-	(void)SetSize;
-
-	switch (OId)
-	{
-		case OID_GEN_CURRENT_PACKET_FILTER:
-			RNDISInterfaceInfo->State.CurrPacketFilter = le32_to_cpu(*((uint32_t*)SetData));
-			RNDISInterfaceInfo->State.CurrRNDISState   = (RNDISInterfaceInfo->State.CurrPacketFilter) ? RNDIS_Data_Initialized : RNDIS_Initialized;
-
-			return true;
-		case OID_802_3_MULTICAST_LIST:
-			/* Do nothing - throw away the value from the host as it is unused */
-
-			return true;
-		default:
-			return false;
-	}
-}
-
-bool RNDIS_Device_IsPacketReceived(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
-{
-	if ((USB_DeviceState != DEVICE_STATE_Configured) ||
-	    (RNDISInterfaceInfo->State.CurrRNDISState != RNDIS_Data_Initialized))
-	{
-		return false;
-	}
-
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpoint.Address);
-	return Endpoint_IsOUTReceived();
-}
-
-uint8_t RNDIS_Device_ReadPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
-                                void* Buffer,
-                                uint16_t* const PacketLength)
-{
-	if ((USB_DeviceState != DEVICE_STATE_Configured) ||
-	    (RNDISInterfaceInfo->State.CurrRNDISState != RNDIS_Data_Initialized))
-	{
-		return ENDPOINT_RWSTREAM_DeviceDisconnected;
-	}
-
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpoint.Address);
-
-	*PacketLength = 0;
-
-	if (!(Endpoint_IsOUTReceived()))
-		return ENDPOINT_RWSTREAM_NoError;
-
-	RNDIS_Packet_Message_t RNDISPacketHeader;
-	Endpoint_Read_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t), NULL);
-
-	if (le32_to_cpu(RNDISPacketHeader.DataLength) > ETHERNET_FRAME_SIZE_MAX)
-	{
-		Endpoint_StallTransaction();
-
-		return RNDIS_ERROR_LOGICAL_CMD_FAILED;
-	}
-
-	*PacketLength = (uint16_t)le32_to_cpu(RNDISPacketHeader.DataLength);
-
-	Endpoint_Read_Stream_LE(Buffer, *PacketLength, NULL);
-	Endpoint_ClearOUT();
-
-	return ENDPOINT_RWSTREAM_NoError;
-}
-
-uint8_t RNDIS_Device_SendPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
-                                void* Buffer,
-                                const uint16_t PacketLength)
-{
-	uint8_t ErrorCode;
-
-	if ((USB_DeviceState != DEVICE_STATE_Configured) ||
-	    (RNDISInterfaceInfo->State.CurrRNDISState != RNDIS_Data_Initialized))
-	{
-		return ENDPOINT_RWSTREAM_DeviceDisconnected;
-	}
-
-	Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataINEndpoint.Address);
-
-	if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
-	  return ErrorCode;
-
-	RNDIS_Packet_Message_t RNDISPacketHeader;
-
-	memset(&RNDISPacketHeader, 0, sizeof(RNDIS_Packet_Message_t));
-
-	RNDISPacketHeader.MessageType   = CPU_TO_LE32(REMOTE_NDIS_PACKET_MSG);
-	RNDISPacketHeader.MessageLength = cpu_to_le32(sizeof(RNDIS_Packet_Message_t) + PacketLength);
-	RNDISPacketHeader.DataOffset    = CPU_TO_LE32(sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t));
-	RNDISPacketHeader.DataLength    = cpu_to_le32(PacketLength);
-
-	Endpoint_Write_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t), NULL);
-	Endpoint_Write_Stream_LE(Buffer, PacketLength, NULL);
-	Endpoint_ClearIN();
-
-	return ENDPOINT_RWSTREAM_NoError;
-}
-
-#endif
-