Added const modifiers to device mode class drivers.
Added parameter directions to function parameter documentation. Added new experimental FAST_STREAM_FUNCTIONS compile time option to speed up stream transfers at the expense of a higher FLASH consumption (needs testing to verify improved throughput).
This commit is contained in:
Dean Camera
parent
3cbdcd3686
commit
f1076ac4d6
115 changed files with 1031 additions and 633 deletions
|
|
@ -201,7 +201,7 @@
|
|||
|
||||
/** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.
|
||||
*
|
||||
* \param freq Required audio sampling frequency in HZ
|
||||
* \param[in] freq Required audio sampling frequency in HZ
|
||||
*/
|
||||
#define AUDIO_SAMPLE_FREQ(freq) {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}
|
||||
|
||||
|
|
|
|||
|
|
@ -111,7 +111,7 @@
|
|||
* a single typedef struct. A macro is used instead so that functional descriptors can be created
|
||||
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
|
||||
*
|
||||
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
|
||||
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
|
||||
*/
|
||||
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
|
||||
struct \
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@
|
|||
/** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel
|
||||
* addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.
|
||||
*
|
||||
* \param channel MIDI channel number to address
|
||||
* \param[in] channel MIDI channel number to address
|
||||
*/
|
||||
#define MIDI_CHANNEL(channel) (channel - 1)
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
|
||||
#include "Audio.h"
|
||||
|
||||
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
|
||||
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
|
||||
{
|
||||
if (!(Endpoint_IsSETUPReceived()))
|
||||
return;
|
||||
|
|
@ -83,7 +83,7 @@ bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfac
|
|||
return true;
|
||||
}
|
||||
|
||||
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
|
||||
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -124,7 +124,7 @@ int32_t Audio_Device_ReadSample24(void)
|
|||
return Sample;
|
||||
}
|
||||
|
||||
void Audio_Device_WriteSample8(int8_t Sample)
|
||||
void Audio_Device_WriteSample8(const int8_t Sample)
|
||||
{
|
||||
Endpoint_Write_Byte(Sample);
|
||||
|
||||
|
|
@ -132,7 +132,7 @@ void Audio_Device_WriteSample8(int8_t Sample)
|
|||
Endpoint_ClearIN();
|
||||
}
|
||||
|
||||
void Audio_Device_WriteSample16(int16_t Sample)
|
||||
void Audio_Device_WriteSample16(const int16_t Sample)
|
||||
{
|
||||
Endpoint_Write_Word_LE(Sample);
|
||||
|
||||
|
|
@ -140,7 +140,7 @@ void Audio_Device_WriteSample16(int16_t Sample)
|
|||
Endpoint_ClearIN();
|
||||
}
|
||||
|
||||
void Audio_Device_WriteSample24(int32_t Sample)
|
||||
void Audio_Device_WriteSample24(const int32_t Sample)
|
||||
{
|
||||
Endpoint_Write_Byte(Sample >> 16);
|
||||
Endpoint_Write_Word_LE(Sample);
|
||||
|
|
@ -149,13 +149,13 @@ void Audio_Device_WriteSample24(int32_t Sample)
|
|||
Endpoint_ClearIN();
|
||||
}
|
||||
|
||||
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
|
||||
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
|
||||
{
|
||||
Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpointNumber);
|
||||
return Endpoint_IsOUTReceived();
|
||||
}
|
||||
|
||||
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
|
||||
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
|
||||
{
|
||||
Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpointNumber);
|
||||
return Endpoint_IsINReady();
|
||||
|
|
|
|||
|
|
@ -97,25 +97,25 @@
|
|||
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the
|
||||
* given Audio interface is selected.
|
||||
*
|
||||
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
|
||||
*/
|
||||
bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
|
||||
bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
|
||||
|
||||
/** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be
|
||||
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
|
||||
*
|
||||
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
*/
|
||||
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
|
||||
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
|
||||
|
||||
/** General management task for a given Audio class interface, required for the correct operation of the interface. This should
|
||||
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
|
||||
*
|
||||
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
*/
|
||||
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
|
||||
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
|
||||
|
||||
/** Reads the next 8-bit audio sample from the current audio interface.
|
||||
*
|
||||
|
|
@ -149,43 +149,43 @@
|
|||
* \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that
|
||||
* the correct endpoint is selected and ready for data.
|
||||
*
|
||||
* \param Sample Signed 8-bit audio sample
|
||||
* \param[in] Sample Signed 8-bit audio sample
|
||||
*/
|
||||
void Audio_Device_WriteSample8(int8_t Sample);
|
||||
void Audio_Device_WriteSample8(const int8_t Sample);
|
||||
|
||||
/** Writes the next 16-bit audio sample to the current audio interface.
|
||||
*
|
||||
* \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that
|
||||
* the correct endpoint is selected and ready for data.
|
||||
*
|
||||
* \param Sample Signed 16-bit audio sample
|
||||
* \param[in] Sample Signed 16-bit audio sample
|
||||
*/
|
||||
void Audio_Device_WriteSample16(int16_t Sample);
|
||||
void Audio_Device_WriteSample16(const int16_t Sample);
|
||||
|
||||
/** Writes the next 24-bit audio sample to the current audio interface.
|
||||
*
|
||||
* \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that
|
||||
* the correct endpoint is selected and ready for data.
|
||||
*
|
||||
* \param Sample Signed 24-bit audio sample
|
||||
* \param[in] Sample Signed 24-bit audio sample
|
||||
*/
|
||||
void Audio_Device_WriteSample24(int32_t Sample);
|
||||
void Audio_Device_WriteSample24(const int32_t Sample);
|
||||
|
||||
/** Determines if the given audio interface is ready for a sample to be read from it.
|
||||
*
|
||||
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the given Audio interface has a sample to be read, false otherwise
|
||||
*/
|
||||
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
|
||||
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
|
||||
|
||||
/** Determines if the given audio interface is ready to accept the next sample to be written to it.
|
||||
*
|
||||
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise
|
||||
*/
|
||||
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
|
||||
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
|
||||
|
||||
/* Disable C linkage for C++ Compilers: */
|
||||
#if defined(__cplusplus)
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
|
|||
Endpoint_ClearIN();
|
||||
}
|
||||
|
||||
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length)
|
||||
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
@ -140,7 +140,7 @@ void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* D
|
|||
Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
|
||||
}
|
||||
|
||||
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data)
|
||||
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
@ -156,7 +156,7 @@ void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t D
|
|||
Endpoint_Write_Byte(Data);
|
||||
}
|
||||
|
||||
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
|
||||
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
|
||||
{
|
||||
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
|
||||
|
||||
|
|
@ -178,7 +178,7 @@ uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
|
|||
return DataByte;
|
||||
}
|
||||
|
||||
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
|
||||
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -108,34 +108,34 @@
|
|||
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the
|
||||
* given CDC interface is selected.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
|
||||
*/
|
||||
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be
|
||||
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*/
|
||||
void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** General management task for a given CDC class interface, required for the correct operation of the interface. This should
|
||||
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*/
|
||||
void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a
|
||||
* line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the
|
||||
* user program by declaring a handler function with the same name and parameters listed here. The new line encoding
|
||||
* settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*/
|
||||
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a
|
||||
* control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the
|
||||
|
|
@ -143,62 +143,62 @@
|
|||
* are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as
|
||||
* a mask of CDC_CONTROL_LINE_OUT_* masks.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*/
|
||||
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the
|
||||
* string is discarded.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param Data Pointer to the string to send to the host
|
||||
* \param Length Size in bytes of the string to send to the host
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in] Data Pointer to the string to send to the host
|
||||
* \param[in] Length Size in bytes of the string to send to the host
|
||||
*/
|
||||
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length);
|
||||
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length);
|
||||
|
||||
/** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the
|
||||
* byte is discarded.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param Data Byte of data to send to the host
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in] Data Byte of data to send to the host
|
||||
*/
|
||||
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data);
|
||||
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data);
|
||||
|
||||
/** Determines the number of bytes received by the CDC interface from the host, waiting to be read.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*
|
||||
* \return Total number of buffered bytes received from the host
|
||||
*/
|
||||
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** Reads a byte of data from the host. If no data is waiting to be read of if a USB host is not connected, the function
|
||||
* returns 0. The USB_CDC_BytesReceived() function should be queried before data is recieved to ensure that no data
|
||||
* underflow occurs.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*
|
||||
* \return Next received byte from the host, or 0 if no data received
|
||||
*/
|
||||
uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial
|
||||
* control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist
|
||||
* until they are cleared via a second notification. This should be called each time the CDC class driver's
|
||||
* ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.
|
||||
*
|
||||
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
|
||||
*/
|
||||
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
|
||||
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
|
||||
|
||||
/* Private Interface - For use in library only: */
|
||||
#if !defined(__DOXYGEN__)
|
||||
/* Function Prototypes: */
|
||||
#if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)
|
||||
void CDC_Device_Event_Stub(void);
|
||||
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
|
||||
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
|
||||
ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);
|
||||
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
|
||||
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
|
||||
ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
|
||||
#include "HID.h"
|
||||
|
||||
void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
|
||||
void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
|
||||
{
|
||||
if (!(Endpoint_IsSETUPReceived()))
|
||||
return;
|
||||
|
|
@ -130,7 +130,7 @@ void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInf
|
|||
}
|
||||
}
|
||||
|
||||
bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
|
||||
bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
|
||||
{
|
||||
HIDInterfaceInfo->State.UsingReportProtocol = true;
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
|
|||
return true;
|
||||
}
|
||||
|
||||
void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
|
||||
void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@
|
|||
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
|
||||
* containing the given HID interface is selected.
|
||||
*
|
||||
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
|
||||
*/
|
||||
|
|
@ -98,14 +98,14 @@
|
|||
/** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be
|
||||
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
|
||||
*
|
||||
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
*/
|
||||
void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);
|
||||
|
||||
/** General management task for a given HID class interface, required for the correct operation of the interface. This should
|
||||
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
|
||||
*
|
||||
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
*/
|
||||
void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);
|
||||
|
||||
|
|
@ -113,11 +113,11 @@
|
|||
* HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the
|
||||
* user is responsible for the creation of the next HID input report to be sent to the host.
|
||||
*
|
||||
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param ReportID If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should
|
||||
* be set to the report ID of the generated HID input report. If multiple reports are not sent via the
|
||||
* given HID interface, this parameter should be ignored.
|
||||
* \param ReportData Pointer to a buffer where the generated HID report should be stored.
|
||||
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param[in,out] ReportID If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should
|
||||
* be set to the report ID of the generated HID input report. If multiple reports are not sent via the
|
||||
* given HID interface, this parameter should be ignored.
|
||||
* \param[out] ReportData Pointer to a buffer where the generated HID report should be stored.
|
||||
*
|
||||
* \return Number of bytes in the generated input report, or zero if no report is to be sent
|
||||
*/
|
||||
|
|
@ -127,14 +127,14 @@
|
|||
* either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback
|
||||
* the user is responsible for the processing of the received HID output report from the host.
|
||||
*
|
||||
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param ReportID Report ID of the received output report. If multiple reports are not received via the given HID
|
||||
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
|
||||
* \param[in] ReportID Report ID of the received output report. If multiple reports are not received via the given HID
|
||||
* interface, this parameter should be ignored.
|
||||
* \param ReportData Pointer to a buffer where the received HID report is stored.
|
||||
* \param ReportSize Size in bytes of the received report from the host.
|
||||
* \param[in] ReportData Pointer to a buffer where the received HID report is stored.
|
||||
* \param[in] ReportSize Size in bytes of the received report from the host.
|
||||
*/
|
||||
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, void* ReportData,
|
||||
uint16_t ReportSize);
|
||||
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
|
||||
const void* ReportData, const uint16_t ReportSize);
|
||||
|
||||
/* Disable C linkage for C++ Compilers: */
|
||||
#if defined(__cplusplus)
|
||||
|
|
|
|||
|
|
@ -33,12 +33,12 @@
|
|||
|
||||
#include "MIDI.h"
|
||||
|
||||
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)
|
||||
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)
|
||||
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
|
||||
{
|
||||
if (MIDIInterfaceInfo->Config.DataINEndpointNumber)
|
||||
{
|
||||
|
|
@ -63,12 +63,12 @@ bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceIn
|
|||
return true;
|
||||
}
|
||||
|
||||
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)
|
||||
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)
|
||||
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
@ -82,7 +82,7 @@ void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo,
|
|||
}
|
||||
}
|
||||
|
||||
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)
|
||||
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -54,12 +54,6 @@
|
|||
|
||||
/* Public Interface - May be used in end-application: */
|
||||
/* Type Define: */
|
||||
/** Configuration information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */
|
||||
typedef USB_ClassInfo_MIDI_Device_Config_t;
|
||||
|
||||
/** Current State information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */
|
||||
typedef USB_ClassInfo_MIDI_Device_State_t;
|
||||
|
||||
/** Class state structure. An instance of this structure should be made for each MIDI interface
|
||||
* within the user application, and passed to each of the MIDI class driver functions as the
|
||||
* MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.
|
||||
|
|
@ -92,41 +86,41 @@
|
|||
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
|
||||
* containing the given MIDI interface is selected.
|
||||
*
|
||||
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
|
||||
*/
|
||||
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);
|
||||
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);
|
||||
|
||||
/** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be
|
||||
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
|
||||
*
|
||||
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
*/
|
||||
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);
|
||||
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);
|
||||
|
||||
/** General management task for a given MIDI class interface, required for the correct operation of the interface. This should
|
||||
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
|
||||
*
|
||||
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
*/
|
||||
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);
|
||||
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);
|
||||
|
||||
/** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.
|
||||
*
|
||||
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param Event Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send
|
||||
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param[in] Event Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send
|
||||
*/
|
||||
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);
|
||||
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);
|
||||
|
||||
/** Receives a MIDI event packet from the host.
|
||||
*
|
||||
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param Event Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed
|
||||
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
|
||||
* \param[out] Event Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed
|
||||
*
|
||||
* \return Boolean true if a MIDI event packet was received, false otherwise
|
||||
*/
|
||||
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);
|
||||
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);
|
||||
|
||||
/* Disable C linkage for C++ Compilers: */
|
||||
#if defined(__cplusplus)
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@
|
|||
|
||||
static USB_ClassInfo_MS_Device_t* CallbackMSInterfaceInfo;
|
||||
|
||||
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
||||
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
|
||||
{
|
||||
if (!(Endpoint_IsSETUPReceived()))
|
||||
return;
|
||||
|
|
@ -75,7 +75,7 @@ void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
|||
}
|
||||
}
|
||||
|
||||
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
||||
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
|
||||
{
|
||||
if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
|
||||
ENDPOINT_DIR_IN, MSInterfaceInfo->Config.DataINEndpointSize,
|
||||
|
|
@ -94,7 +94,7 @@ bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
|||
return true;
|
||||
}
|
||||
|
||||
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
||||
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
@ -138,7 +138,7 @@ void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
|||
MSInterfaceInfo->State.IsMassStoreReset = false;
|
||||
}
|
||||
|
||||
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
||||
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
|
||||
{
|
||||
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
|
||||
|
||||
|
|
@ -171,7 +171,7 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceI
|
|||
return true;
|
||||
}
|
||||
|
||||
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
|
||||
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
|
||||
{
|
||||
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
|
||||
|
||||
|
|
|
|||
|
|
@ -95,43 +95,43 @@
|
|||
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
|
||||
* containing the given Mass Storage interface is selected.
|
||||
*
|
||||
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
|
||||
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
|
||||
*/
|
||||
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
|
||||
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
|
||||
|
||||
/** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be
|
||||
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
|
||||
*
|
||||
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
|
||||
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
|
||||
*/
|
||||
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
|
||||
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
|
||||
|
||||
/** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should
|
||||
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
|
||||
*
|
||||
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage configuration and state.
|
||||
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage configuration and state.
|
||||
*/
|
||||
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
|
||||
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
|
||||
|
||||
/** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the
|
||||
* host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible
|
||||
* for the processing of the received SCSI command from the host. The SCSI command is available in the CommandBlock structure
|
||||
* inside the Mass Storage class state structure passed as a parameter to the callback function.
|
||||
*
|
||||
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
|
||||
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the SCSI command was successfully processed, false otherwise
|
||||
*/
|
||||
bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
|
||||
bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
|
||||
|
||||
/* Private Interface - For use in library only: */
|
||||
#if !defined(__DOXYGEN__)
|
||||
/* Function Prototypes: */
|
||||
#if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)
|
||||
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
|
||||
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
|
||||
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
|
||||
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
|
||||
static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ static const uint32_t PROGMEM AdapterSupportedOIDList[] =
|
|||
OID_802_3_XMIT_MORE_COLLISIONS,
|
||||
};
|
||||
|
||||
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
|
||||
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
|
||||
{
|
||||
if (!(Endpoint_IsSETUPReceived()))
|
||||
return;
|
||||
|
|
@ -110,7 +110,7 @@ void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterf
|
|||
}
|
||||
}
|
||||
|
||||
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
|
||||
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
|
||||
{
|
||||
if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
|
||||
ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.DataINEndpointSize,
|
||||
|
|
@ -136,7 +136,7 @@ bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfac
|
|||
return true;
|
||||
}
|
||||
|
||||
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
|
||||
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
|
||||
{
|
||||
if (!(USB_IsConnected))
|
||||
return;
|
||||
|
|
@ -208,7 +208,7 @@ void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
|
|||
}
|
||||
}
|
||||
|
||||
void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
|
||||
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. */
|
||||
|
|
@ -331,9 +331,9 @@ void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDIS
|
|||
}
|
||||
}
|
||||
|
||||
static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo,
|
||||
uint32_t OId, void* QueryData, uint16_t QuerySize,
|
||||
void* ResponseData, uint16_t* ResponseSize)
|
||||
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)
|
||||
{
|
||||
switch (OId)
|
||||
{
|
||||
|
|
@ -443,8 +443,8 @@ static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInt
|
|||
}
|
||||
}
|
||||
|
||||
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId, void* SetData,
|
||||
uint16_t SetSize)
|
||||
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId, void* SetData,
|
||||
const uint16_t SetSize)
|
||||
{
|
||||
switch (OId)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -103,36 +103,36 @@
|
|||
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
|
||||
* containing the given HID interface is selected.
|
||||
*
|
||||
* \param RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
|
||||
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
|
||||
*
|
||||
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
|
||||
*/
|
||||
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
|
||||
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
|
||||
|
||||
/** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be
|
||||
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
|
||||
*
|
||||
* \param RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
|
||||
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
|
||||
*/
|
||||
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
|
||||
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
|
||||
|
||||
/** General management task for a given HID class interface, required for the correct operation of the interface. This should
|
||||
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
|
||||
*
|
||||
* \param RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
|
||||
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
|
||||
*/
|
||||
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
|
||||
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
|
||||
|
||||
/* Private Interface - For use in library only: */
|
||||
#if !defined(__DOXYGEN__)
|
||||
/* Function Prototypes: */
|
||||
#if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)
|
||||
static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
|
||||
static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo,
|
||||
uint32_t OId, void* QueryData, uint16_t QuerySize,
|
||||
void* ResponseData, uint16_t* ResponseSize);
|
||||
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId,
|
||||
void* SetData, uint16_t SetSize);
|
||||
static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
|
||||
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);
|
||||
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,
|
||||
void* SetData, const uint16_t SetSize);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -209,9 +209,9 @@
|
|||
/** Function to process a given HID report returned from an attached device, and store it into a given
|
||||
* \ref HID_ReportInfo_t structure.
|
||||
*
|
||||
* \param ReportData Buffer containing the device's HID report table
|
||||
* \param ReportSize Size in bytes of the HID report table
|
||||
* \param ParserData Pointer to a \ref HID_ReportInfo_t instance for the parser output
|
||||
* \param[in] ReportData Buffer containing the device's HID report table
|
||||
* \param[in] ReportSize Size in bytes of the HID report table
|
||||
* \param[out] ParserData Pointer to a \ref HID_ReportInfo_t instance for the parser output
|
||||
*
|
||||
* \return A value in the \ref HID_Parse_ErrorCodes_t enum
|
||||
*/
|
||||
|
|
@ -221,8 +221,8 @@
|
|||
/** Extracts the given report item's value out of the given HID report and places it into the Value
|
||||
* member of the report item's \ref HID_ReportItem_t structure.
|
||||
*
|
||||
* \param ReportData Buffer containing an IN or FEATURE report from an attached device
|
||||
* \param ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
|
||||
* \param[in] ReportData Buffer containing an IN or FEATURE report from an attached device
|
||||
* \param[in,out] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
|
||||
*
|
||||
* \returns Boolean true if the item to retrieve was located in the given report, false otherwise
|
||||
*/
|
||||
|
|
@ -236,8 +236,8 @@
|
|||
*
|
||||
* If the device has multiple HID reports, the report ID is set to the report ID of the given item.
|
||||
*
|
||||
* \param ReportData Buffer holding the current OUT report data
|
||||
* \param ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
|
||||
* \param[out] ReportData Buffer holding the current OUT report data
|
||||
* \param[in] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
|
||||
*/
|
||||
void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)
|
||||
ATTR_NON_NULL_PTR_ARG(1, 2);
|
||||
|
|
|
|||
|
|
@ -133,9 +133,9 @@
|
|||
*
|
||||
* \note This function is available in USB Host mode only.
|
||||
*
|
||||
* \param BytesRem Pointer to an int storing the remaining bytes in the configuration descriptor
|
||||
* \param CurrConfigLoc Pointer to the current position in the configuration descriptor
|
||||
* \param ComparatorRoutine Name of the comparator search function to use on the configuration descriptor
|
||||
* \param[in,out] BytesRem Pointer to an int storing the remaining bytes in the configuration descriptor
|
||||
* \param[in,out] CurrConfigLoc Pointer to the current position in the configuration descriptor
|
||||
* \param[in] ComparatorRoutine Name of the comparator search function to use on the configuration descriptor
|
||||
*
|
||||
* \return Value of one of the members of the \ref DSearch_Comp_Return_ErrorCodes_t enum
|
||||
*
|
||||
|
|
@ -183,17 +183,17 @@
|
|||
/* Function Prototypes: */
|
||||
/** Retrieves the configuration descriptor data or size from an attached device via a standard request.
|
||||
*
|
||||
* \param ConfigNumber Device configuration descriptor number to fetch from the device (usually set to 1 for
|
||||
* single configuration devices)
|
||||
* \param[in] ConfigNumber Device configuration descriptor number to fetch from the device (usually set to 1 for
|
||||
* single configuration devices)
|
||||
*
|
||||
* \param ConfigSizePtr Pointer to a uint16_t for either storing or retrieving the configuration
|
||||
* descriptor size
|
||||
* \param[in,out] ConfigSizePtr Pointer to a uint16_t for either storing or retrieving the configuration
|
||||
* descriptor size
|
||||
*
|
||||
* \param BufferPtr Pointer to the buffer for storing the configuration descriptor data. If this is
|
||||
* NULL, the size of the configuration descriptor will be retrieved instead and
|
||||
* placed in the variable pointed to by ConfigSizePtr. If this is non-NULL, the number
|
||||
* of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded
|
||||
* into the buffer
|
||||
* \param[out] BufferPtr Pointer to the buffer for storing the configuration descriptor data. If this is
|
||||
* NULL, the size of the configuration descriptor will be retrieved instead and
|
||||
* placed in the variable pointed to by ConfigSizePtr. If this is non-NULL, the number
|
||||
* of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded
|
||||
* into the buffer
|
||||
*/
|
||||
uint8_t USB_GetDeviceConfigDescriptor(uint8_t ConfigNumber, uint16_t* const ConfigSizePtr, void* BufferPtr)
|
||||
ATTR_NON_NULL_PTR_ARG(2);
|
||||
|
|
@ -201,9 +201,9 @@
|
|||
/** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value.
|
||||
* The bytes remaining value is automatically decremented.
|
||||
*
|
||||
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param Type Descriptor type value to search for
|
||||
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param[in] Type Descriptor type value to search for
|
||||
*/
|
||||
void USB_GetNextDescriptorOfType(uint16_t* const BytesRem,
|
||||
uint8_t** const CurrConfigLoc,
|
||||
|
|
@ -215,10 +215,10 @@
|
|||
* descriptor is reached first, the number of bytes remaining to process is set to zero and the
|
||||
* function exits. The bytes remaining value is automatically decremented.
|
||||
*
|
||||
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param Type Descriptor type value to search for
|
||||
* \param BeforeType Descriptor type value which must not be reached before the given Type descriptor
|
||||
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param[in] Type Descriptor type value to search for
|
||||
* \param[in] BeforeType Descriptor type value which must not be reached before the given Type descriptor
|
||||
*/
|
||||
void USB_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,
|
||||
uint8_t** const CurrConfigLoc,
|
||||
|
|
@ -230,10 +230,10 @@
|
|||
* which must come after a descriptor of the second given type value. The bytes remaining value is
|
||||
* automatically decremented.
|
||||
*
|
||||
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param Type Descriptor type value to search for
|
||||
* \param AfterType Descriptor type value which must be reached before the given Type descriptor
|
||||
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param[in] Type Descriptor type value to search for
|
||||
* \param[in] AfterType Descriptor type value which must be reached before the given Type descriptor
|
||||
*/
|
||||
void USB_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,
|
||||
uint8_t** const CurrConfigLoc,
|
||||
|
|
@ -245,8 +245,8 @@
|
|||
/** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then
|
||||
points to the next sub-descriptor. The bytes remaining value is automatically decremented.
|
||||
*
|
||||
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
|
||||
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
|
||||
*/
|
||||
static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,
|
||||
uint8_t** const CurrConfigLoc)
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@
|
|||
*
|
||||
* \note This event only exists on USB AVR models which support dual role modes.
|
||||
*
|
||||
* \param ErrorCode Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t
|
||||
* \param[in] ErrorCode Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t
|
||||
*/
|
||||
void EVENT_USB_InitFailure(const uint8_t ErrorCode);
|
||||
|
||||
|
|
@ -146,7 +146,7 @@
|
|||
/** Event for USB host error. This event fires when a hardware fault has occurred whilst the USB
|
||||
* interface is in host mode.
|
||||
*
|
||||
* \param ErrorCode Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t
|
||||
* \param[in] ErrorCode Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t
|
||||
*
|
||||
* \note This event only exists on USB AVR models which supports host mode.
|
||||
*
|
||||
|
|
@ -185,12 +185,12 @@
|
|||
/** Event for USB device enumeration failure. This event fires when a the USB interface is
|
||||
* in host mode, and an attached USB device has failed to enumerate completely.
|
||||
*
|
||||
* \param ErrorCode Error code indicating the failure reason, a value in
|
||||
* \ref USB_Host_EnumerationErrorCodes_t
|
||||
* \param[in] ErrorCode Error code indicating the failure reason, a value in
|
||||
* \ref USB_Host_EnumerationErrorCodes_t
|
||||
*
|
||||
* \param SubErrorCode Sub error code indicating the reason for failure - for example, if the
|
||||
* ErrorCode parameter indicates a control error, this will give the error
|
||||
* code returned by the \ref USB_Host_SendControlRequest() function.
|
||||
* \param[in] SubErrorCode Sub error code indicating the reason for failure - for example, if the
|
||||
* ErrorCode parameter indicates a control error, this will give the error
|
||||
* code returned by the \ref USB_Host_SendControlRequest() function.
|
||||
*
|
||||
* \note This event only exists on USB AVR models which supports host mode.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -124,15 +124,15 @@
|
|||
* index and language ID. This function MUST be overridden in the user application (added with full, identical
|
||||
* prototype and name so that the library can call it to retrieve descriptor data.
|
||||
*
|
||||
* \param wValue The type of the descriptor to retrieve in the upper byte, and the index in the
|
||||
* lower byte (when more than one descriptor of the given type exists, such as the
|
||||
* case of string descriptors). The type may be one of the standard types defined
|
||||
* in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.
|
||||
* \param wIndex The language ID of the string to return if the wValue type indicates DTYPE_String,
|
||||
* otherwise zero for standard descriptors, or as defined in a class-specific
|
||||
* standards.
|
||||
* \param DescriptorAddress Pointer to the descriptor in memory. This should be set by the routine to
|
||||
* the address of the descriptor.
|
||||
* \param[in] wValue The type of the descriptor to retrieve in the upper byte, and the index in the
|
||||
* lower byte (when more than one descriptor of the given type exists, such as the
|
||||
* case of string descriptors). The type may be one of the standard types defined
|
||||
* in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.
|
||||
* \param[in] wIndex The language ID of the string to return if the wValue type indicates DTYPE_String,
|
||||
* otherwise zero for standard descriptors, or as defined in a class-specific
|
||||
* standards.
|
||||
* \param[out] DescriptorAddress Pointer to the descriptor in memory. This should be set by the routine to
|
||||
* the address of the descriptor.
|
||||
*
|
||||
* \note By default, the library expects all descriptors to be located in flash memory via the PROGMEM attribute.
|
||||
* If descriptors should be located in RAM or EEPROM instead (to speed up access in the case of RAM, or to
|
||||
|
|
|
|||
|
|
@ -119,6 +119,46 @@ uint8_t Endpoint_Discard_Stream(uint16_t Length
|
|||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
{
|
||||
Endpoint_ClearOUT();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return ENDPOINT_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
Endpoint_Discard_Byte();
|
||||
case 7: Endpoint_Discard_Byte();
|
||||
case 6: Endpoint_Discard_Byte();
|
||||
case 5: Endpoint_Discard_Byte();
|
||||
case 4: Endpoint_Discard_Byte();
|
||||
case 3: Endpoint_Discard_Byte();
|
||||
case 2: Endpoint_Discard_Byte();
|
||||
case 1: Endpoint_Discard_Byte();
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
|
|
@ -155,6 +195,46 @@ uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length
|
|||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
{
|
||||
Endpoint_ClearIN();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return ENDPOINT_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
Endpoint_Write_Byte(*(DataStream++));
|
||||
case 7: Endpoint_Write_Byte(*(DataStream++));
|
||||
case 6: Endpoint_Write_Byte(*(DataStream++));
|
||||
case 5: Endpoint_Write_Byte(*(DataStream++));
|
||||
case 4: Endpoint_Write_Byte(*(DataStream++));
|
||||
case 3: Endpoint_Write_Byte(*(DataStream++));
|
||||
case 2: Endpoint_Write_Byte(*(DataStream++));
|
||||
case 1: Endpoint_Write_Byte(*(DataStream++));
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
|
|
@ -175,7 +255,7 @@ uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length
|
|||
Length--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return ENDPOINT_RWSTREAM_NoError;
|
||||
}
|
||||
|
||||
|
|
@ -191,6 +271,46 @@ uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length
|
|||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
{
|
||||
Endpoint_ClearIN();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return ENDPOINT_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
Endpoint_Write_Byte(*(DataStream--));
|
||||
case 7: Endpoint_Write_Byte(*(DataStream--));
|
||||
case 6: Endpoint_Write_Byte(*(DataStream--));
|
||||
case 5: Endpoint_Write_Byte(*(DataStream--));
|
||||
case 4: Endpoint_Write_Byte(*(DataStream--));
|
||||
case 3: Endpoint_Write_Byte(*(DataStream--));
|
||||
case 2: Endpoint_Write_Byte(*(DataStream--));
|
||||
case 1: Endpoint_Write_Byte(*(DataStream--));
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
|
|
@ -211,7 +331,7 @@ uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length
|
|||
Length--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return ENDPOINT_RWSTREAM_NoError;
|
||||
}
|
||||
|
||||
|
|
@ -227,6 +347,46 @@ uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length
|
|||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
{
|
||||
Endpoint_ClearOUT();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return ENDPOINT_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
*(DataStream++) = Endpoint_Read_Byte();
|
||||
case 7: *(DataStream++) = Endpoint_Read_Byte();
|
||||
case 6: *(DataStream++) = Endpoint_Read_Byte();
|
||||
case 5: *(DataStream++) = Endpoint_Read_Byte();
|
||||
case 4: *(DataStream++) = Endpoint_Read_Byte();
|
||||
case 3: *(DataStream++) = Endpoint_Read_Byte();
|
||||
case 2: *(DataStream++) = Endpoint_Read_Byte();
|
||||
case 1: *(DataStream++) = Endpoint_Read_Byte();
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
|
|
@ -247,7 +407,7 @@ uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length
|
|||
Length--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return ENDPOINT_RWSTREAM_NoError;
|
||||
}
|
||||
|
||||
|
|
@ -263,6 +423,46 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
|
|||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
{
|
||||
Endpoint_ClearOUT();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return ENDPOINT_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Endpoint_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
*(DataStream--) = Endpoint_Read_Byte();
|
||||
case 7: *(DataStream--) = Endpoint_Read_Byte();
|
||||
case 6: *(DataStream--) = Endpoint_Read_Byte();
|
||||
case 5: *(DataStream--) = Endpoint_Read_Byte();
|
||||
case 4: *(DataStream--) = Endpoint_Read_Byte();
|
||||
case 3: *(DataStream--) = Endpoint_Read_Byte();
|
||||
case 2: *(DataStream--) = Endpoint_Read_Byte();
|
||||
case 1: *(DataStream--) = Endpoint_Read_Byte();
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Endpoint_IsReadWriteAllowed()))
|
||||
|
|
@ -283,7 +483,7 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
|
|||
Length--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return ENDPOINT_RWSTREAM_NoError;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -117,13 +117,13 @@
|
|||
|
||||
/** Maximum size in bytes of a given endpoint.
|
||||
*
|
||||
* \param n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
|
||||
* \param[in] n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
|
||||
*/
|
||||
#define ENDPOINT_MAX_SIZE(n) _ENDPOINT_GET_MAXSIZE(n)
|
||||
|
||||
/** Indicates if the given endpoint supports double banking.
|
||||
*
|
||||
* \param n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
|
||||
* \param[in] n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
|
||||
*/
|
||||
#define ENDPOINT_DOUBLEBANK_SUPPORTED(n) _ENDPOINT_GET_DOUBLEBANK(n)
|
||||
|
||||
|
|
@ -169,14 +169,14 @@
|
|||
* Any endpoint operations which do not require the endpoint number to be indicated will operate on
|
||||
* the currently selected endpoint.
|
||||
*
|
||||
* \param EndpointNumber Endpoint number to select
|
||||
* \param[in] EndpointNumber Endpoint number to select
|
||||
*/
|
||||
static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber);
|
||||
|
||||
/** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's
|
||||
* In and Out pointers to the bank's contents.
|
||||
*
|
||||
* \param EndpointNumber Endpoint number whose FIFO buffers are to be reset
|
||||
* \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset
|
||||
*/
|
||||
static inline void Endpoint_ResetFIFO(uint8_t EndpointNumber);
|
||||
|
||||
|
|
@ -227,7 +227,7 @@
|
|||
/** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type
|
||||
* endpoints).
|
||||
*
|
||||
* \param EndpointNumber Index of the endpoint whose interrupt flag should be tested
|
||||
* \param[in] EndpointNumber Index of the endpoint whose interrupt flag should be tested
|
||||
*
|
||||
* \return Boolean true if the specified endpoint has interrupted, false otherwise
|
||||
*/
|
||||
|
|
@ -454,7 +454,7 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Byte Next byte to write into the the currently selected endpoint's FIFO buffer
|
||||
* \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer
|
||||
*/
|
||||
static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
|
||||
static inline void Endpoint_Write_Byte(const uint8_t Byte)
|
||||
|
|
@ -515,7 +515,7 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Word Next word to write to the currently selected endpoint's FIFO buffer
|
||||
* \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer
|
||||
*/
|
||||
static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;
|
||||
static inline void Endpoint_Write_Word_LE(const uint16_t Word)
|
||||
|
|
@ -529,7 +529,7 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Word Next word to write to the currently selected endpoint's FIFO buffer
|
||||
* \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer
|
||||
*/
|
||||
static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;
|
||||
static inline void Endpoint_Write_Word_BE(const uint16_t Word)
|
||||
|
|
@ -604,7 +604,7 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param DWord Next double word to write to the currently selected endpoint's FIFO buffer
|
||||
* \param[in] DWord Next double word to write to the currently selected endpoint's FIFO buffer
|
||||
*/
|
||||
static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
|
||||
static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)
|
||||
|
|
@ -620,7 +620,7 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param DWord Next double word to write to the currently selected endpoint's FIFO buffer
|
||||
* \param[in] DWord Next double word to write to the currently selected endpoint's FIFO buffer
|
||||
*/
|
||||
static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
|
||||
static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)
|
||||
|
|
@ -722,8 +722,8 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[in] Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -748,9 +748,9 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to read from.
|
||||
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[in] Buffer Pointer to the source data buffer to read from.
|
||||
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -775,9 +775,9 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to read from.
|
||||
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[in] Buffer Pointer to the source data buffer to read from.
|
||||
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -802,9 +802,9 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the destination data buffer to write to.
|
||||
* \param Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[out] Buffer Pointer to the destination data buffer to write to.
|
||||
* \param[in] Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -829,9 +829,9 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the destination data buffer to write to.
|
||||
* \param Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[out] Buffer Pointer to the destination data buffer to write to.
|
||||
* \param[in] Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -855,8 +855,8 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to read from.
|
||||
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
* \param[in] Buffer Pointer to the source data buffer to read from.
|
||||
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
*
|
||||
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -874,8 +874,8 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to read from.
|
||||
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
* \param[in] Buffer Pointer to the source data buffer to read from.
|
||||
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
|
||||
*
|
||||
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -893,8 +893,8 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the destination data buffer to write to.
|
||||
* \param Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param[out] Buffer Pointer to the destination data buffer to write to.
|
||||
* \param[in] Length Number of bytes to send via the currently selected endpoint.
|
||||
*
|
||||
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -912,8 +912,8 @@
|
|||
*
|
||||
* \ingroup Group_EndpointRW
|
||||
*
|
||||
* \param Buffer Pointer to the destination data buffer to write to.
|
||||
* \param Length Number of bytes to send via the currently selected endpoint.
|
||||
* \param[out] Buffer Pointer to the destination data buffer to write to.
|
||||
* \param[in] Length Number of bytes to send via the currently selected endpoint.
|
||||
*
|
||||
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@
|
|||
*
|
||||
* \note After this routine returns, the control pipe will be selected.
|
||||
*
|
||||
* \param ConfigNumber Configuration index to send to the device
|
||||
* \param[in] ConfigNumber Configuration index to send to the device
|
||||
*
|
||||
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
|
||||
*/
|
||||
|
|
@ -194,8 +194,8 @@
|
|||
*
|
||||
* \note After this routine returns, the control pipe will be selected.
|
||||
*
|
||||
* \param DeviceDescriptorPtr Pointer to the destination device descriptor structure where
|
||||
* the read data is to be stored
|
||||
* \param[out] DeviceDescriptorPtr Pointer to the destination device descriptor structure where
|
||||
* the read data is to be stored
|
||||
*
|
||||
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
|
||||
*/
|
||||
|
|
@ -205,7 +205,7 @@
|
|||
*
|
||||
* \note After this routine returns, the control pipe will be selected.
|
||||
*
|
||||
* \param EndpointIndex Index of the endpoint to clear
|
||||
* \param[in] EndpointIndex Index of the endpoint to clear
|
||||
*
|
||||
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -71,8 +71,8 @@
|
|||
*
|
||||
* \ingroup Group_PipeControlReq
|
||||
*
|
||||
* \param BufferPtr Pointer to the start of the data buffer if the request has a data stage, or
|
||||
* NULL if the request transfers no data to or from the device.
|
||||
* \param[in] BufferPtr Pointer to the start of the data buffer if the request has a data stage, or
|
||||
* NULL if the request transfers no data to or from the device.
|
||||
*
|
||||
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -228,14 +228,14 @@
|
|||
* Calling this function when the USB interface is already initialized will cause a complete USB
|
||||
* interface reset and re-enumeration.
|
||||
*
|
||||
* \param Mode This is a mask indicating what mode the USB interface is to be initialized to.
|
||||
* Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.
|
||||
* \param[in] Mode This is a mask indicating what mode the USB interface is to be initialized to.
|
||||
* Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.
|
||||
*
|
||||
* \param Options Mask indicating the options which should be used when initializing the USB
|
||||
* interface to control the USB interface's behaviour. This should be comprised of
|
||||
* a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the
|
||||
* PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device
|
||||
* mode speed.
|
||||
* \param[in] Options Mask indicating the options which should be used when initializing the USB
|
||||
* interface to control the USB interface's behaviour. This should be comprised of
|
||||
* a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the
|
||||
* PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device
|
||||
* mode speed.
|
||||
*
|
||||
* \note To reduce the FLASH requirements of the library if only device or host mode is required,
|
||||
* this can be statically set via defining the token USB_DEVICE_ONLY for device mode or
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@
|
|||
* There are two different methods of sending a SRP - either pulses on the VBUS line, or by
|
||||
* pulsing the Data + line via the internal pull-up resistor.
|
||||
*
|
||||
* \param SRPTypeMask Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or \ref USB_OTG_STP_DATA.
|
||||
* \param[in] SRPTypeMask Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or \ref USB_OTG_STP_DATA.
|
||||
*/
|
||||
static inline void USB_OTG_Dev_InitiateSRP(uint8_t SRPTypeMask);
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -120,6 +120,46 @@ uint8_t Pipe_Write_Stream_LE(const void* Data, uint16_t Length
|
|||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
{
|
||||
Pipe_ClearOUT();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return PIPE_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
Pipe_Write_Byte(*(DataStream++));
|
||||
case 7: Pipe_Write_Byte(*(DataStream++));
|
||||
case 6: Pipe_Write_Byte(*(DataStream++));
|
||||
case 5: Pipe_Write_Byte(*(DataStream++));
|
||||
case 4: Pipe_Write_Byte(*(DataStream++));
|
||||
case 3: Pipe_Write_Byte(*(DataStream++));
|
||||
case 2: Pipe_Write_Byte(*(DataStream++));
|
||||
case 1: Pipe_Write_Byte(*(DataStream++));
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
|
|
@ -158,6 +198,46 @@ uint8_t Pipe_Write_Stream_BE(const void* Data, uint16_t Length
|
|||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
{
|
||||
Pipe_ClearOUT();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return PIPE_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
Pipe_Write_Byte(*(DataStream--));
|
||||
case 7: Pipe_Write_Byte(*(DataStream--));
|
||||
case 6: Pipe_Write_Byte(*(DataStream--));
|
||||
case 5: Pipe_Write_Byte(*(DataStream--));
|
||||
case 4: Pipe_Write_Byte(*(DataStream--));
|
||||
case 3: Pipe_Write_Byte(*(DataStream--));
|
||||
case 2: Pipe_Write_Byte(*(DataStream--));
|
||||
case 1: Pipe_Write_Byte(*(DataStream--));
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
|
|
@ -195,6 +275,46 @@ uint8_t Pipe_Discard_Stream(uint16_t Length
|
|||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
{
|
||||
Pipe_ClearIN();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return PIPE_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
Pipe_Discard_Byte();
|
||||
case 7: Pipe_Discard_Byte();
|
||||
case 6: Pipe_Discard_Byte();
|
||||
case 5: Pipe_Discard_Byte();
|
||||
case 4: Pipe_Discard_Byte();
|
||||
case 3: Pipe_Discard_Byte();
|
||||
case 2: Pipe_Discard_Byte();
|
||||
case 1: Pipe_Discard_Byte();
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
|
|
@ -233,6 +353,46 @@ uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length
|
|||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
{
|
||||
Pipe_ClearIN();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return PIPE_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
*(DataStream++) = Pipe_Read_Byte();
|
||||
case 7: *(DataStream++) = Pipe_Read_Byte();
|
||||
case 6: *(DataStream++) = Pipe_Read_Byte();
|
||||
case 5: *(DataStream++) = Pipe_Read_Byte();
|
||||
case 4: *(DataStream++) = Pipe_Read_Byte();
|
||||
case 3: *(DataStream++) = Pipe_Read_Byte();
|
||||
case 2: *(DataStream++) = Pipe_Read_Byte();
|
||||
case 1: *(DataStream++) = Pipe_Read_Byte();
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
|
|
@ -271,6 +431,46 @@ uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length
|
|||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
|
||||
#if defined(FAST_STREAM_TRANSFERS)
|
||||
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
|
||||
|
||||
if (Length >= 8)
|
||||
{
|
||||
Length -= BytesRemToAlignment;
|
||||
|
||||
switch (BytesRemToAlignment)
|
||||
{
|
||||
default:
|
||||
do
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
{
|
||||
Pipe_ClearIN();
|
||||
|
||||
#if !defined(NO_STREAM_CALLBACKS)
|
||||
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
|
||||
return PIPE_RWSTREAM_CallbackAborted;
|
||||
#endif
|
||||
|
||||
if ((ErrorCode = Pipe_WaitUntilReady()))
|
||||
return ErrorCode;
|
||||
}
|
||||
|
||||
Length -= 8;
|
||||
|
||||
*(DataStream--) = Pipe_Read_Byte();
|
||||
case 7: *(DataStream--) = Pipe_Read_Byte();
|
||||
case 6: *(DataStream--) = Pipe_Read_Byte();
|
||||
case 5: *(DataStream--) = Pipe_Read_Byte();
|
||||
case 4: *(DataStream--) = Pipe_Read_Byte();
|
||||
case 3: *(DataStream--) = Pipe_Read_Byte();
|
||||
case 2: *(DataStream--) = Pipe_Read_Byte();
|
||||
case 1: *(DataStream--) = Pipe_Read_Byte();
|
||||
} while (Length >= 8);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
while (Length)
|
||||
{
|
||||
if (!(Pipe_IsReadWriteAllowed()))
|
||||
|
|
|
|||
|
|
@ -187,13 +187,13 @@
|
|||
/** Selects the given pipe number. Any pipe operations which do not require the pipe number to be
|
||||
* indicated will operate on the currently selected pipe.
|
||||
*
|
||||
* \param PipeNumber Index of the pipe to select
|
||||
* \param[in] PipeNumber Index of the pipe to select
|
||||
*/
|
||||
static inline void Pipe_SelectPipe(uint8_t PipeNumber);
|
||||
|
||||
/** Resets the desired pipe, including the pipe banks and flags.
|
||||
*
|
||||
* \param PipeNumber Index of the pipe to reset
|
||||
* \param[in] PipeNumber Index of the pipe to reset
|
||||
*/
|
||||
static inline void Pipe_ResetPipe(uint8_t PipeNumber);
|
||||
|
||||
|
|
@ -226,7 +226,7 @@
|
|||
* control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices
|
||||
* which have two endpoints of opposite direction sharing the same endpoint address within the device.
|
||||
*
|
||||
* \param Token New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask
|
||||
* \param[in] Token New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask
|
||||
*/
|
||||
static inline void Pipe_SetPipeToken(uint8_t Token);
|
||||
|
||||
|
|
@ -236,7 +236,7 @@
|
|||
/** Configures the currently selected pipe to only allow the specified number of IN requests to be
|
||||
* accepted by the pipe before it is automatically frozen.
|
||||
*
|
||||
* \param TotalINRequests Total number of IN requests that the pipe may receive before freezing
|
||||
* \param[in] TotalINRequests Total number of IN requests that the pipe may receive before freezing
|
||||
*/
|
||||
static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);
|
||||
|
||||
|
|
@ -248,7 +248,7 @@
|
|||
|
||||
/** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.
|
||||
*
|
||||
* \param Milliseconds Number of milliseconds between each pipe poll
|
||||
* \param[in] Milliseconds Number of milliseconds between each pipe poll
|
||||
*/
|
||||
static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);
|
||||
|
||||
|
|
@ -262,7 +262,7 @@
|
|||
/** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type
|
||||
* pipes).
|
||||
*
|
||||
* \param PipeNumber Index of the pipe whose interrupt flag should be tested
|
||||
* \param[in] PipeNumber Index of the pipe whose interrupt flag should be tested
|
||||
*
|
||||
* \return Boolean true if the specified pipe has interrupted, false otherwise
|
||||
*/
|
||||
|
|
@ -516,7 +516,7 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Byte Next byte to write into the the currently selected pipe's FIFO buffer
|
||||
* \param[in] Byte Next byte to write into the the currently selected pipe's FIFO buffer
|
||||
*/
|
||||
static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
|
||||
static inline void Pipe_Write_Byte(const uint8_t Byte)
|
||||
|
|
@ -577,7 +577,7 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Word Next word to write to the currently selected pipe's FIFO buffer
|
||||
* \param[in] Word Next word to write to the currently selected pipe's FIFO buffer
|
||||
*/
|
||||
static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;
|
||||
static inline void Pipe_Write_Word_LE(const uint16_t Word)
|
||||
|
|
@ -591,7 +591,7 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Word Next word to write to the currently selected pipe's FIFO buffer
|
||||
* \param[in] Word Next word to write to the currently selected pipe's FIFO buffer
|
||||
*/
|
||||
static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;
|
||||
static inline void Pipe_Write_Word_BE(const uint16_t Word)
|
||||
|
|
@ -666,7 +666,7 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param DWord Next double word to write to the currently selected pipe's FIFO buffer
|
||||
* \param[in] DWord Next double word to write to the currently selected pipe's FIFO buffer
|
||||
*/
|
||||
static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
|
||||
static inline void Pipe_Write_DWord_LE(const uint32_t DWord)
|
||||
|
|
@ -680,7 +680,7 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param DWord Next double word to write to the currently selected pipe's FIFO buffer
|
||||
* \param[in] DWord Next double word to write to the currently selected pipe's FIFO buffer
|
||||
*/
|
||||
static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
|
||||
static inline void Pipe_Write_DWord_BE(const uint32_t DWord)
|
||||
|
|
@ -771,9 +771,9 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to read from.
|
||||
* \param Length Number of bytes to read for the currently selected pipe into the buffer.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[in] Buffer Pointer to the source data buffer to read from.
|
||||
* \param[in] Length Number of bytes to read for the currently selected pipe into the buffer.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -798,9 +798,9 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to read from.
|
||||
* \param Length Number of bytes to read for the currently selected pipe into the buffer.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[in] Buffer Pointer to the source data buffer to read from.
|
||||
* \param[in] Length Number of bytes to read for the currently selected pipe into the buffer.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -825,8 +825,8 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Length Number of bytes to send via the currently selected pipe.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[in] Length Number of bytes to send via the currently selected pipe.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -851,9 +851,9 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to write to.
|
||||
* \param Length Number of bytes to read for the currently selected pipe to read from.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[out] Buffer Pointer to the source data buffer to write to.
|
||||
* \param[in] Length Number of bytes to read for the currently selected pipe to read from.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
@ -878,9 +878,9 @@
|
|||
*
|
||||
* \ingroup Group_PipeRW
|
||||
*
|
||||
* \param Buffer Pointer to the source data buffer to write to.
|
||||
* \param Length Number of bytes to read for the currently selected pipe to read from.
|
||||
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
* \param[out] Buffer Pointer to the source data buffer to write to.
|
||||
* \param[in] Length Number of bytes to read for the currently selected pipe to read from.
|
||||
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
|
||||
*
|
||||
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
|
||||
*/
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue