-/*\r
- LUFA Library\r
- Copyright (C) Dean Camera, 2009.\r
- \r
- dean [at] fourwalledcubicle [dot] com\r
- www.fourwalledcubicle.com\r
-*/\r
-\r
-/*\r
- Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
-\r
- Permission to use, copy, modify, and distribute this software\r
- and its documentation for any purpose and without fee is hereby\r
- granted, provided that the above copyright notice appear in all\r
- copies and that both that the copyright notice and this\r
- permission notice and warranty disclaimer appear in supporting\r
- documentation, and that the name of the author not be used in\r
- advertising or publicity pertaining to distribution of the\r
- software without specific, written prior permission.\r
-\r
- The author disclaim all warranties with regard to this\r
- software, including all implied warranties of merchantability\r
- and fitness. In no event shall the author be liable for any\r
- special, indirect or consequential damages or any damages\r
- whatsoever resulting from loss of use, data or profits, whether\r
- in an action of contract, negligence or other tortious action,\r
- arising out of or in connection with the use or performance of\r
- this software.\r
-*/\r
-\r
-/** \file\r
- *\r
- * RNDIS Device commands, to issue RNDIS commands to the device for\r
- * the control and data transfer between the host and RNDIS device.\r
- */\r
-\r
-#include "RNDISCommands.h"\r
-\r
-/** Current RNDIS Request ID, for associating sent commands with received data */\r
-uint32_t RequestID = 0;\r
-\r
-\r
-/** Function to send the given encapsulated RNDIS command to the device.\r
- *\r
- * \param[in] Buffer Source command data buffer to send to the device\r
- * \param[in] Length Number of bytes to send\r
- *\r
- * \return A value from the USB_Host_SendControlErrorCodes_t enum\r
- */\r
-uint8_t RNDIS_SendEncapsulatedCommand(void* Buffer, uint16_t Length)\r
-{\r
- USB_ControlRequest = (USB_Request_Header_t)\r
- {\r
- .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),\r
- .bRequest = REQ_SendEncapsulatedCommand,\r
- .wValue = 0,\r
- .wIndex = 0,\r
- .wLength = Length,\r
- };\r
-\r
- /* Select the control pipe for the request transfer */\r
- Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
-\r
- return USB_Host_SendControlRequest(Buffer);\r
-}\r
-\r
-/** Function to receive the given encapsulated RNDIS response from the device.\r
- *\r
- * \param[out] Buffer Destination command data buffer to write read data from the device to\r
- * \param[in] Length Number of bytes to read\r
- *\r
- * \return A value from the USB_Host_SendControlErrorCodes_t enum\r
- */\r
-uint8_t RNDIS_GetEncapsulatedResponse(void* Buffer, uint16_t Length)\r
-{\r
- USB_ControlRequest = (USB_Request_Header_t)\r
- {\r
- .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),\r
- .bRequest = REQ_GetEncapsulatedResponse,\r
- .wValue = 0,\r
- .wIndex = 0,\r
- .wLength = Length,\r
- };\r
- \r
- /* Select the control pipe for the request transfer */\r
- Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
-\r
- return USB_Host_SendControlRequest(Buffer);\r
-}\r
-\r
-/** Sends a RNDIS KEEPALIVE command to the device, to ensure that it does not enter standby mode after periods\r
- * of long inactivity.\r
- *\r
- * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a\r
- * logical command failure\r
- */\r
-uint8_t RNDIS_SendKeepAlive(void)\r
-{\r
- uint8_t ErrorCode;\r
-\r
- RNDIS_KeepAlive_Message_t KeepAliveMessage;\r
- RNDIS_KeepAlive_Complete_t KeepAliveMessageResponse;\r
- \r
- KeepAliveMessage.MessageType = REMOTE_NDIS_KEEPALIVE_MSG;\r
- KeepAliveMessage.MessageLength = sizeof(RNDIS_KeepAlive_Message_t);\r
- KeepAliveMessage.RequestId = RequestID++;\r
-\r
- if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&KeepAliveMessage,\r
- sizeof(RNDIS_KeepAlive_Message_t))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
- \r
- if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&KeepAliveMessageResponse,\r
- sizeof(RNDIS_KeepAlive_Complete_t))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
- \r
- return HOST_SENDCONTROL_Successful;\r
-}\r
-\r
-/** Initializes the attached RNDIS device's RNDIS interface.\r
- *\r
- * \param[in] HostMaxPacketSize Size of the packet buffer on the host\r
- * \param[out] DeviceMaxPacketSize Pointer to where the packet buffer size of the device is to be stored\r
- *\r
- * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a\r
- * logical command failure\r
- */\r
-uint8_t RNDIS_InitializeDevice(uint16_t HostMaxPacketSize, uint16_t* DeviceMaxPacketSize)\r
-{\r
- uint8_t ErrorCode;\r
-\r
- RNDIS_Initialize_Message_t InitMessage;\r
- RNDIS_Initialize_Complete_t InitMessageResponse;\r
-\r
- InitMessage.MessageType = REMOTE_NDIS_INITIALIZE_MSG;\r
- InitMessage.MessageLength = sizeof(RNDIS_Initialize_Message_t);\r
- InitMessage.RequestId = RequestID++;\r
-\r
- InitMessage.MajorVersion = REMOTE_NDIS_VERSION_MAJOR;\r
- InitMessage.MinorVersion = REMOTE_NDIS_VERSION_MINOR;\r
- InitMessage.MaxTransferSize = HostMaxPacketSize;\r
- \r
- if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&InitMessage,\r
- sizeof(RNDIS_Initialize_Message_t))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
- \r
- if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&InitMessageResponse,\r
- sizeof(RNDIS_Initialize_Complete_t))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
-\r
- if (InitMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)\r
- return RNDIS_COMMAND_FAILED;\r
- \r
- *DeviceMaxPacketSize = InitMessageResponse.MaxTransferSize;\r
- \r
- return HOST_SENDCONTROL_Successful;\r
-}\r
-\r
-/** Sets a given RNDIS property of an attached RNDIS device.\r
- *\r
- * \param[in] Oid OID number of the parameter to set\r
- * \param[in] Buffer Pointer to where the property data is to be sourced from\r
- * \param[in] Length Length in bytes of the property data to sent to the device\r
- *\r
- * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a\r
- * logical command failure\r
- */\r
-uint8_t RNDIS_SetRNDISProperty(uint32_t Oid, void* Buffer, uint16_t Length)\r
-{\r
- uint8_t ErrorCode;\r
-\r
- struct\r
- {\r
- RNDIS_Set_Message_t SetMessage;\r
- uint8_t ContigiousBuffer[Length];\r
- } SetMessageData;\r
- \r
- RNDIS_Set_Complete_t SetMessageResponse;\r
- \r
- SetMessageData.SetMessage.MessageType = REMOTE_NDIS_SET_MSG;\r
- SetMessageData.SetMessage.MessageLength = sizeof(RNDIS_Set_Message_t) + Length;\r
- SetMessageData.SetMessage.RequestId = RequestID++;\r
- \r
- SetMessageData.SetMessage.Oid = Oid;\r
- SetMessageData.SetMessage.InformationBufferLength = Length;\r
- SetMessageData.SetMessage.InformationBufferOffset = (sizeof(RNDIS_Set_Message_t) - sizeof(RNDIS_Message_Header_t));\r
- SetMessageData.SetMessage.DeviceVcHandle = 0;\r
- \r
- memcpy(&SetMessageData.ContigiousBuffer, Buffer, Length);\r
-\r
- if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&SetMessageData,\r
- SetMessageData.SetMessage.MessageLength)) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
- \r
- if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&SetMessageResponse,\r
- sizeof(RNDIS_Set_Complete_t))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
-\r
- if (SetMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)\r
- return RNDIS_COMMAND_FAILED;\r
- \r
- return HOST_SENDCONTROL_Successful;\r
-}\r
-\r
-/** Gets a given RNDIS property of an attached RNDIS device.\r
- *\r
- * \param[in] Oid OID number of the parameter to get\r
- * \param[in] Buffer Pointer to where the property data is to be written to\r
- * \param[in] MaxLength Length in bytes of the destination buffer size\r
- *\r
- * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a\r
- * logical command failure\r
- */\r
-uint8_t RNDIS_QueryRNDISProperty(uint32_t Oid, void* Buffer, uint16_t MaxLength)\r
-{\r
- uint8_t ErrorCode;\r
-\r
- RNDIS_Query_Message_t QueryMessage;\r
-\r
- struct\r
- {\r
- RNDIS_Query_Complete_t QueryMessageResponse;\r
- uint8_t ContigiousBuffer[MaxLength];\r
- } QueryMessageResponseData;\r
-\r
- QueryMessage.MessageType = REMOTE_NDIS_QUERY_MSG;\r
- QueryMessage.MessageLength = sizeof(RNDIS_Query_Message_t);\r
- QueryMessage.RequestId = RequestID++;\r
- \r
- QueryMessage.Oid = Oid;\r
- QueryMessage.InformationBufferLength = 0;\r
- QueryMessage.InformationBufferOffset = 0;\r
- QueryMessage.DeviceVcHandle = 0;\r
-\r
- if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&QueryMessage,\r
- sizeof(RNDIS_Query_Message_t))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
- \r
- if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&QueryMessageResponseData,\r
- sizeof(QueryMessageResponseData))) != HOST_SENDCONTROL_Successful)\r
- {\r
- return ErrorCode;\r
- }\r
-\r
- if (QueryMessageResponseData.QueryMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)\r
- return RNDIS_COMMAND_FAILED;\r
-\r
- memcpy(Buffer, &QueryMessageResponseData.ContigiousBuffer, MaxLength);\r
-\r
- return HOST_SENDCONTROL_Successful;\r
-}\r
-\r
-/** Retrieves the size of a received packet, discarding the remainder of the RNDIS packet header to leave only the\r
- * packet contents for processing by the host.\r
- *\r
- * \param[out] PacketLength Size of the packet currently in the pipe\r
- *\r
- * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
- */\r
-uint8_t RNDIS_GetPacketLength(uint16_t* PacketLength)\r
-{\r
- uint8_t ErrorCode;\r
-\r
- Pipe_SelectPipe(RNDIS_DATAPIPE_IN);\r
- Pipe_SetPipeToken(PIPE_TOKEN_IN);\r
- Pipe_Unfreeze();\r
- \r
- if (!(Pipe_IsReadWriteAllowed()))\r
- {\r
- *PacketLength = 0;\r
- Pipe_Freeze();\r
- return PIPE_RWSTREAM_NoError;\r
- }\r
-\r
- RNDIS_Packet_Message_t DeviceMessage;\r
- \r
- if ((ErrorCode = Pipe_Read_Stream_LE(&DeviceMessage, sizeof(RNDIS_Packet_Message_t))) != PIPE_RWSTREAM_NoError)\r
- {\r
- return ErrorCode;\r
- }\r
-\r
- *PacketLength = (uint16_t)DeviceMessage.DataLength;\r
- \r
- Pipe_Discard_Stream(DeviceMessage.DataOffset - (sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t)));\r
- \r
- Pipe_Freeze();\r
- \r
- return PIPE_RWSTREAM_NoError;\r
-}\r
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2011.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2011 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 disclaim 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.
+*/
+
+/** \file
+ *
+ * RNDIS Device commands, to issue RNDIS commands to the device for
+ * the control and data transfer between the host and RNDIS device.
+ */
+
+#include "RNDISCommands.h"
+
+/** Current RNDIS Request ID, for associating sent commands with received data */
+uint32_t RequestID = 0;
+
+
+/** Function to send the given encapsulated RNDIS command to the device.
+ *
+ * \param[in] Buffer Source command data buffer to send to the device
+ * \param[in] Length Number of bytes to send
+ *
+ * \return A value from the USB_Host_SendControlErrorCodes_t enum
+ */
+uint8_t RNDIS_SendEncapsulatedCommand(void* const Buffer,
+ const uint16_t Length)
+{
+ USB_ControlRequest = (USB_Request_Header_t)
+ {
+ .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
+ .bRequest = RNDIS_REQ_SendEncapsulatedCommand,
+ .wValue = 0,
+ .wIndex = 0,
+ .wLength = Length,
+ };
+
+ /* Select the control pipe for the request transfer */
+ Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+ return USB_Host_SendControlRequest(Buffer);
+}
+
+/** Function to receive the given encapsulated RNDIS response from the device.
+ *
+ * \param[out] Buffer Destination command data buffer to write read data from the device to
+ * \param[in] Length Number of bytes to read
+ *
+ * \return A value from the USB_Host_SendControlErrorCodes_t enum
+ */
+uint8_t RNDIS_GetEncapsulatedResponse(void* const Buffer,
+ const uint16_t Length)
+{
+ USB_ControlRequest = (USB_Request_Header_t)
+ {
+ .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
+ .bRequest = RNDIS_REQ_GetEncapsulatedResponse,
+ .wValue = 0,
+ .wIndex = 0,
+ .wLength = Length,
+ };
+
+ /* Select the control pipe for the request transfer */
+ Pipe_SelectPipe(PIPE_CONTROLPIPE);
+
+ return USB_Host_SendControlRequest(Buffer);
+}
+
+/** Sends a RNDIS KEEPALIVE command to the device, to ensure that it does not enter standby mode after periods
+ * of long inactivity.
+ *
+ * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a
+ * logical command failure
+ */
+uint8_t RNDIS_SendKeepAlive(void)
+{
+ uint8_t ErrorCode;
+
+ RNDIS_KeepAlive_Message_t KeepAliveMessage;
+ RNDIS_KeepAlive_Complete_t KeepAliveMessageResponse;
+
+ KeepAliveMessage.MessageType = REMOTE_NDIS_KEEPALIVE_MSG;
+ KeepAliveMessage.MessageLength = sizeof(RNDIS_KeepAlive_Message_t);
+ KeepAliveMessage.RequestId = RequestID++;
+
+ if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&KeepAliveMessage,
+ sizeof(RNDIS_KeepAlive_Message_t))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&KeepAliveMessageResponse,
+ sizeof(RNDIS_KeepAlive_Complete_t))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ return HOST_SENDCONTROL_Successful;
+}
+
+/** Initializes the attached RNDIS device's RNDIS interface.
+ *
+ * \param[in] HostMaxPacketSize Size of the packet buffer on the host
+ * \param[out] DeviceMaxPacketSize Pointer to where the packet buffer size of the device is to be stored
+ *
+ * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a
+ * logical command failure
+ */
+uint8_t RNDIS_InitializeDevice(const uint16_t HostMaxPacketSize,
+ uint16_t* const DeviceMaxPacketSize)
+{
+ uint8_t ErrorCode;
+
+ RNDIS_Initialize_Message_t InitMessage;
+ RNDIS_Initialize_Complete_t InitMessageResponse;
+
+ InitMessage.MessageType = REMOTE_NDIS_INITIALIZE_MSG;
+ InitMessage.MessageLength = sizeof(RNDIS_Initialize_Message_t);
+ InitMessage.RequestId = RequestID++;
+
+ InitMessage.MajorVersion = REMOTE_NDIS_VERSION_MAJOR;
+ InitMessage.MinorVersion = REMOTE_NDIS_VERSION_MINOR;
+ InitMessage.MaxTransferSize = HostMaxPacketSize;
+
+ if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&InitMessage,
+ sizeof(RNDIS_Initialize_Message_t))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&InitMessageResponse,
+ sizeof(RNDIS_Initialize_Complete_t))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if (InitMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
+ return RNDIS_COMMAND_FAILED;
+
+ *DeviceMaxPacketSize = InitMessageResponse.MaxTransferSize;
+
+ return HOST_SENDCONTROL_Successful;
+}
+
+/** Sets a given RNDIS property of an attached RNDIS device.
+ *
+ * \param[in] Oid OID number of the parameter to set
+ * \param[in] Buffer Pointer to where the property data is to be sourced from
+ * \param[in] Length Length in bytes of the property data to sent to the device
+ *
+ * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a
+ * logical command failure
+ */
+uint8_t RNDIS_SetRNDISProperty(const uint32_t Oid,
+ void* Buffer,
+ const uint16_t Length)
+{
+ uint8_t ErrorCode;
+
+ struct
+ {
+ RNDIS_Set_Message_t SetMessage;
+ uint8_t ContiguousBuffer[Length];
+ } SetMessageData;
+
+ RNDIS_Set_Complete_t SetMessageResponse;
+
+ SetMessageData.SetMessage.MessageType = REMOTE_NDIS_SET_MSG;
+ SetMessageData.SetMessage.MessageLength = sizeof(RNDIS_Set_Message_t) + Length;
+ SetMessageData.SetMessage.RequestId = RequestID++;
+
+ SetMessageData.SetMessage.Oid = Oid;
+ SetMessageData.SetMessage.InformationBufferLength = Length;
+ SetMessageData.SetMessage.InformationBufferOffset = (sizeof(RNDIS_Set_Message_t) - sizeof(RNDIS_Message_Header_t));
+ SetMessageData.SetMessage.DeviceVcHandle = 0;
+
+ memcpy(&SetMessageData.ContiguousBuffer, Buffer, Length);
+
+ if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&SetMessageData,
+ SetMessageData.SetMessage.MessageLength)) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&SetMessageResponse,
+ sizeof(RNDIS_Set_Complete_t))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if (SetMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
+ return RNDIS_COMMAND_FAILED;
+
+ return HOST_SENDCONTROL_Successful;
+}
+
+/** Gets a given RNDIS property of an attached RNDIS device.
+ *
+ * \param[in] Oid OID number of the parameter to get
+ * \param[in] Buffer Pointer to where the property data is to be written to
+ * \param[in] MaxLength Length in bytes of the destination buffer size
+ *
+ * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a
+ * logical command failure
+ */
+uint8_t RNDIS_QueryRNDISProperty(const uint32_t Oid,
+ void* Buffer,
+ const uint16_t MaxLength)
+{
+ uint8_t ErrorCode;
+
+ RNDIS_Query_Message_t QueryMessage;
+
+ struct
+ {
+ RNDIS_Query_Complete_t QueryMessageResponse;
+ uint8_t ContiguousBuffer[MaxLength];
+ } QueryMessageResponseData;
+
+ QueryMessage.MessageType = REMOTE_NDIS_QUERY_MSG;
+ QueryMessage.MessageLength = sizeof(RNDIS_Query_Message_t);
+ QueryMessage.RequestId = RequestID++;
+
+ QueryMessage.Oid = Oid;
+ QueryMessage.InformationBufferLength = 0;
+ QueryMessage.InformationBufferOffset = 0;
+ QueryMessage.DeviceVcHandle = 0;
+
+ if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&QueryMessage,
+ sizeof(RNDIS_Query_Message_t))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if ((ErrorCode = RNDIS_GetEncapsulatedResponse(&QueryMessageResponseData,
+ sizeof(QueryMessageResponseData))) != HOST_SENDCONTROL_Successful)
+ {
+ return ErrorCode;
+ }
+
+ if (QueryMessageResponseData.QueryMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
+ return RNDIS_COMMAND_FAILED;
+
+ memcpy(Buffer, &QueryMessageResponseData.ContiguousBuffer, MaxLength);
+
+ return HOST_SENDCONTROL_Successful;
+}
+
+/** Retrieves the size of a received packet, discarding the remainder of the RNDIS packet header to leave only the
+ * packet contents for processing by the host.
+ *
+ * \param[out] PacketLength Size of the packet currently in the pipe
+ *
+ * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
+ */
+uint8_t RNDIS_GetPacketLength(uint16_t* const PacketLength)
+{
+ uint8_t ErrorCode;
+
+ Pipe_SelectPipe(RNDIS_DATA_IN_PIPE);
+ Pipe_SetPipeToken(PIPE_TOKEN_IN);
+ Pipe_Unfreeze();
+
+ if (!(Pipe_IsReadWriteAllowed()))
+ {
+ *PacketLength = 0;
+ Pipe_Freeze();
+ return PIPE_RWSTREAM_NoError;
+ }
+
+ RNDIS_Packet_Message_t DeviceMessage;
+
+ if ((ErrorCode = Pipe_Read_Stream_LE(&DeviceMessage, sizeof(RNDIS_Packet_Message_t), NULL)) != PIPE_RWSTREAM_NoError)
+ {
+ return ErrorCode;
+ }
+
+ *PacketLength = (uint16_t)DeviceMessage.DataLength;
+
+ Pipe_Discard_Stream(DeviceMessage.DataOffset - (sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t)),
+ NULL);
+
+ Pipe_Freeze();
+
+ return PIPE_RWSTREAM_NoError;
+}
+
projects / pub / USBasp.git / blobdiff