Add missing const qualifiers to class drivers.

Indent core library function parameters so that there is only one parameter per line, to increase readability.
pull/1469/head
Dean Camera 15 years ago
parent 99d8a39363
commit 97143bf814

@ -47,7 +47,7 @@
* \param[in] BlockAddress Data block starting address for the write sequence * \param[in] BlockAddress Data block starting address for the write sequence
* \param[in] TotalBlocks Number of blocks of data to write * \param[in] TotalBlocks Number of blocks of data to write
*/ */
void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks) void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
{ {
uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE); uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE); uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
@ -181,7 +181,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, co
* \param[in] BlockAddress Data block starting address for the read sequence * \param[in] BlockAddress Data block starting address for the read sequence
* \param[in] TotalBlocks Number of blocks of data to read * \param[in] TotalBlocks Number of blocks of data to read
*/ */
void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks) void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
{ {
uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE); uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE); uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);

@ -67,9 +67,9 @@
#define VIRTUAL_MEMORY_BLOCKS (VIRTUAL_MEMORY_BYTES / VIRTUAL_MEMORY_BLOCK_SIZE) #define VIRTUAL_MEMORY_BLOCKS (VIRTUAL_MEMORY_BYTES / VIRTUAL_MEMORY_BLOCK_SIZE)
/* Function Prototypes: */ /* Function Prototypes: */
void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,
uint16_t TotalBlocks); uint16_t TotalBlocks);
void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,
uint16_t TotalBlocks); uint16_t TotalBlocks);
void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,
uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3); uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);

@ -86,7 +86,7 @@ SCSI_Request_Sense_Response_t SenseData =
* *
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
*/ */
bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
/* Set initial sense data, before the requested command is processed */ /* Set initial sense data, before the requested command is processed */
SCSI_SET_SENSE(SCSI_SENSE_KEY_GOOD, SCSI_SET_SENSE(SCSI_SENSE_KEY_GOOD,
@ -136,7 +136,7 @@ bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
* *
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
*/ */
static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint16_t AllocationLength = SwapEndian_16(*(uint16_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[3]); uint16_t AllocationLength = SwapEndian_16(*(uint16_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[3]);
uint16_t BytesTransferred = (AllocationLength < sizeof(InquiryData))? AllocationLength : uint16_t BytesTransferred = (AllocationLength < sizeof(InquiryData))? AllocationLength :
@ -173,7 +173,7 @@ static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
* *
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
*/ */
static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint8_t AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4]; uint8_t AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4];
uint8_t BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData); uint8_t BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData);
@ -193,7 +193,7 @@ static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInf
* *
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
*/ */
static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint32_t LastBlockAddressInLUN = (LUN_MEDIA_BLOCKS - 1); uint32_t LastBlockAddressInLUN = (LUN_MEDIA_BLOCKS - 1);
uint32_t MediaBlockSize = VIRTUAL_MEMORY_BLOCK_SIZE; uint32_t MediaBlockSize = VIRTUAL_MEMORY_BLOCK_SIZE;
@ -212,7 +212,7 @@ static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterface
* *
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
*/ */
static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
/* Check to see if the SELF TEST bit is not set */ /* Check to see if the SELF TEST bit is not set */
if (!(MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & (1 << 2))) if (!(MSInterfaceInfo->State.CommandBlock.SCSICommandData[1] & (1 << 2)))
@ -247,7 +247,7 @@ static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceI
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
* \param[in] IsDataRead Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE) * \param[in] IsDataRead Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)
*/ */
static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const bool IsDataRead) static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead)
{ {
uint32_t BlockAddress = SwapEndian_32(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[2]); uint32_t BlockAddress = SwapEndian_32(*(uint32_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[2]);
uint16_t TotalBlocks = SwapEndian_16(*(uint16_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[7]); uint16_t TotalBlocks = SwapEndian_16(*(uint16_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[7]);

@ -73,14 +73,14 @@
#define DEVICE_TYPE_CDROM 0x05 #define DEVICE_TYPE_CDROM 0x05
/* Function Prototypes: */ /* Function Prototypes: */
bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
#if defined(INCLUDE_FROM_SCSI_C) #if defined(INCLUDE_FROM_SCSI_C)
static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static void SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static void SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const bool IsDataRead); static void SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead);
#endif #endif
#endif #endif

@ -47,7 +47,7 @@
* \param[in] BlockAddress Data block starting address for the write sequence * \param[in] BlockAddress Data block starting address for the write sequence
* \param[in] TotalBlocks Number of blocks of data to write * \param[in] TotalBlocks Number of blocks of data to write
*/ */
void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks) void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
{ {
uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE); uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE); uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);
@ -181,7 +181,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, co
* \param[in] BlockAddress Data block starting address for the read sequence * \param[in] BlockAddress Data block starting address for the read sequence
* \param[in] TotalBlocks Number of blocks of data to read * \param[in] TotalBlocks Number of blocks of data to read
*/ */
void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks) void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)
{ {
uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE); uint16_t CurrDFPage = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) / DATAFLASH_PAGE_SIZE);
uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE); uint16_t CurrDFPageByte = ((BlockAddress * VIRTUAL_MEMORY_BLOCK_SIZE) % DATAFLASH_PAGE_SIZE);

@ -70,9 +70,9 @@
#define LUN_MEDIA_BLOCKS (VIRTUAL_MEMORY_BLOCKS / TOTAL_LUNS) #define LUN_MEDIA_BLOCKS (VIRTUAL_MEMORY_BLOCKS / TOTAL_LUNS)
/* Function Prototypes: */ /* Function Prototypes: */
void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,
uint16_t TotalBlocks); uint16_t TotalBlocks);
void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const uint32_t BlockAddress,
uint16_t TotalBlocks); uint16_t TotalBlocks);
void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks,
uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3); uint8_t* BufferPtr) ATTR_NON_NULL_PTR_ARG(3);

@ -86,7 +86,7 @@ SCSI_Request_Sense_Response_t SenseData =
* *
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with * \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
*/ */
bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
bool CommandSuccess = false; bool CommandSuccess = false;
@ -146,7 +146,7 @@ bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
* *
* \return Boolean true if the command completed successfully, false otherwise. * \return Boolean true if the command completed successfully, false otherwise.
*/ */
static bool SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static bool SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint16_t AllocationLength = SwapEndian_16(*(uint16_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[3]); uint16_t AllocationLength = SwapEndian_16(*(uint16_t*)&MSInterfaceInfo->State.CommandBlock.SCSICommandData[3]);
uint16_t BytesTransferred = (AllocationLength < sizeof(InquiryData))? AllocationLength : uint16_t BytesTransferred = (AllocationLength < sizeof(InquiryData))? AllocationLength :
@ -187,7 +187,7 @@ static bool SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
* *
* \return Boolean true if the command completed successfully, false otherwise. * \return Boolean true if the command completed successfully, false otherwise.
*/ */
static bool SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static bool SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint8_t AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4]; uint8_t AllocationLength = MSInterfaceInfo->State.CommandBlock.SCSICommandData[4];
uint8_t BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData); uint8_t BytesTransferred = (AllocationLength < sizeof(SenseData))? AllocationLength : sizeof(SenseData);
@ -211,7 +211,7 @@ static bool SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInf
* *
* \return Boolean true if the command completed successfully, false otherwise. * \return Boolean true if the command completed successfully, false otherwise.
*/ */
static bool SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static bool SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint32_t LastBlockAddressInLUN = (LUN_MEDIA_BLOCKS - 1); uint32_t LastBlockAddressInLUN = (LUN_MEDIA_BLOCKS - 1);
uint32_t MediaBlockSize = VIRTUAL_MEMORY_BLOCK_SIZE; uint32_t MediaBlockSize = VIRTUAL_MEMORY_BLOCK_SIZE;
@ -234,7 +234,7 @@ static bool SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterface
* *
* \return Boolean true if the command completed successfully, false otherwise. * \return Boolean true if the command completed successfully, false otherwise.
*/ */
static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceInfo) static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{ {
uint8_t ReturnByte; uint8_t ReturnByte;
@ -300,7 +300,7 @@ static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceI
* *
* \return Boolean true if the command completed successfully, false otherwise. * \return Boolean true if the command completed successfully, false otherwise.
*/ */
static bool SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const bool IsDataRead) static bool SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead)
{ {
uint32_t BlockAddress; uint32_t BlockAddress;
uint16_t TotalBlocks; uint16_t TotalBlocks;

@ -74,14 +74,14 @@
#define DEVICE_TYPE_CDROM 0x05 #define DEVICE_TYPE_CDROM 0x05
/* Function Prototypes: */ /* Function Prototypes: */
bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
#if defined(INCLUDE_FROM_SCSI_C) #if defined(INCLUDE_FROM_SCSI_C)
static bool SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static bool SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static bool SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static bool SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static bool SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static bool SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static bool SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const bool IsDataRead); static bool SCSI_Command_ReadWrite_10(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo, const bool IsDataRead);
#endif #endif
#endif #endif

@ -172,8 +172,8 @@
* *
* \param[in] Word Word of data whose bytes are to be swapped. * \param[in] Word Word of data whose bytes are to be swapped.
*/ */
static inline uint16_t SwapEndian_16(uint16_t Word) ATTR_WARN_UNUSED_RESULT ATTR_CONST; static inline uint16_t SwapEndian_16(const uint16_t Word) ATTR_WARN_UNUSED_RESULT ATTR_CONST;
static inline uint16_t SwapEndian_16(uint16_t Word) static inline uint16_t SwapEndian_16(const uint16_t Word)
{ {
uint8_t Temp; uint8_t Temp;
@ -198,8 +198,8 @@
* *
* \param[in] DWord Double word of data whose bytes are to be swapped. * \param[in] DWord Double word of data whose bytes are to be swapped.
*/ */
static inline uint32_t SwapEndian_32(uint32_t DWord) ATTR_WARN_UNUSED_RESULT ATTR_CONST; static inline uint32_t SwapEndian_32(const uint32_t DWord) ATTR_WARN_UNUSED_RESULT ATTR_CONST;
static inline uint32_t SwapEndian_32(uint32_t DWord) static inline uint32_t SwapEndian_32(const uint32_t DWord)
{ {
uint8_t Temp; uint8_t Temp;
@ -229,8 +229,10 @@
* \param[in,out] Data Pointer to a number containing an even number of bytes to be reversed. * \param[in,out] Data Pointer to a number containing an even number of bytes to be reversed.
* \param[in] Bytes Length of the data in bytes. * \param[in] Bytes Length of the data in bytes.
*/ */
static inline void SwapEndian_n(void* Data, uint8_t Bytes); static inline void SwapEndian_n(void* Data,
static inline void SwapEndian_n(void* Data, uint8_t Bytes) uint8_t Bytes) ATTR_NON_NULL_PTR_ARG(1);
static inline void SwapEndian_n(void* Data,
uint8_t Bytes)
{ {
uint8_t* CurrDataPos = (uint8_t*)Data; uint8_t* CurrDataPos = (uint8_t*)Data;

@ -112,7 +112,8 @@
PORTD = (PORTD & ~LEDS_ALL_LEDS) | (LEDMask & LEDS_ALL_LEDS); PORTD = (PORTD & ~LEDS_ALL_LEDS) | (LEDMask & LEDS_ALL_LEDS);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD & ~(LEDMask & LEDS_ALL_LEDS)) | (ActiveMask & LEDS_ALL_LEDS)); PORTD = ((PORTD & ~(LEDMask & LEDS_ALL_LEDS)) | (ActiveMask & LEDS_ALL_LEDS));
} }

@ -101,7 +101,8 @@
PORTC = ((PORTC | LEDS_ALL_LEDS) & ~LEDMask); PORTC = ((PORTC | LEDS_ALL_LEDS) & ~LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTC = ((PORTC | ActiveMask) & ~LEDMask); PORTC = ((PORTC | ActiveMask) & ~LEDMask);
} }

@ -114,7 +114,8 @@
PORTB = ((PORTB & ~LEDS_ALL_LEDS) | LedMask); PORTB = ((PORTB & ~LEDS_ALL_LEDS) | LedMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LedMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LedMask,
const uint8_t ActiveMask)
{ {
PORTB = ((PORTB & ~LedMask) | ActiveMask); PORTB = ((PORTB & ~LedMask) | ActiveMask);
} }

@ -221,7 +221,8 @@
* \param[in] PageAddress Page address within the selected dataflash IC. * \param[in] PageAddress Page address within the selected dataflash IC.
* \param[in] BufferByte Address within the dataflash's buffer. * \param[in] BufferByte Address within the dataflash's buffer.
*/ */
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte); static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,
const uint16_t BufferByte);
/* Disable C linkage for C++ Compilers: */ /* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus) #if defined(__cplusplus)

@ -110,7 +110,8 @@
* \param[in] PageAddress Page address within the selected dataflash IC * \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer * \param[in] BufferByte Address within the dataflash's buffer
*/ */
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte) static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,
const uint16_t BufferByte)
{ {
Dataflash_SendByte(PageAddress >> 5); Dataflash_SendByte(PageAddress >> 5);
Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8)); Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8));

@ -106,7 +106,8 @@
PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask); PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD & ~LEDMask) | ActiveMask); PORTD = ((PORTD & ~LEDMask) | ActiveMask);
} }

@ -100,7 +100,8 @@
PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask); PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD & ~LEDMask) | ActiveMask); PORTD = ((PORTD & ~LEDMask) | ActiveMask);
} }

@ -163,7 +163,8 @@
* \param[in] LEDMask Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file). * \param[in] LEDMask Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file).
* \param[in] ActiveMask Mask of whether the LEDs in the LED mask should be turned on or off. * \param[in] ActiveMask Mask of whether the LEDs in the LED mask should be turned on or off.
*/ */
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask); static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask);
/** Toggles all LEDs in the LED mask, leaving all others in their current states. /** Toggles all LEDs in the LED mask, leaving all others in their current states.
* *

@ -129,7 +129,8 @@
~((LEDMask & LEDS_PORTE_LEDS) << LEDS_PORTE_MASK_SHIFT)); ~((LEDMask & LEDS_PORTE_LEDS) << LEDS_PORTE_MASK_SHIFT));
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = (((PORTD & ~(LEDMask & LEDS_LED1)) | (ActiveMask & LEDS_LED1)) | PORTD = (((PORTD & ~(LEDMask & LEDS_LED1)) | (ActiveMask & LEDS_LED1)) |
((PORTD | (LEDMask & LEDS_LED2)) & ~(ActiveMask & LEDS_LED2))); ((PORTD | (LEDMask & LEDS_LED2)) & ~(ActiveMask & LEDS_LED2)));

@ -110,7 +110,8 @@
* \param[in] PageAddress Page address within the selected dataflash IC * \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer * \param[in] BufferByte Address within the dataflash's buffer
*/ */
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte) static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,
const uint16_t BufferByte)
{ {
Dataflash_SendByte(PageAddress >> 6); Dataflash_SendByte(PageAddress >> 6);
Dataflash_SendByte((PageAddress << 2) | (BufferByte >> 8)); Dataflash_SendByte((PageAddress << 2) | (BufferByte >> 8));

@ -109,7 +109,8 @@
PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask); PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD & ~LEDMask) | ActiveMask); PORTD = ((PORTD & ~LEDMask) | ActiveMask);
} }

@ -110,7 +110,8 @@
* \param[in] PageAddress Page address within the selected dataflash IC * \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer * \param[in] BufferByte Address within the dataflash's buffer
*/ */
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte) static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,
const uint16_t BufferByte)
{ {
Dataflash_SendByte(PageAddress >> 5); Dataflash_SendByte(PageAddress >> 5);
Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8)); Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8));

@ -109,7 +109,8 @@
PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask); PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD & ~(LEDMask & LEDS_ALL_LEDS)) | (ActiveMask & LEDS_ALL_LEDS)); PORTD = ((PORTD & ~(LEDMask & LEDS_ALL_LEDS)) | (ActiveMask & LEDS_ALL_LEDS));
} }

@ -100,7 +100,8 @@
PORTD = ((PORTD | LEDS_ALL_LEDS) & ~LEDMask); PORTD = ((PORTD | LEDS_ALL_LEDS) & ~LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD | LEDMask) & ~ActiveMask); PORTD = ((PORTD | LEDMask) & ~ActiveMask);
} }

@ -116,7 +116,8 @@
* \param[in] PageAddress Page address within the selected dataflash IC * \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer * \param[in] BufferByte Address within the dataflash's buffer
*/ */
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte) static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,
const uint16_t BufferByte)
{ {
PageAddress >>= 1; PageAddress >>= 1;

@ -109,7 +109,8 @@
PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask); PORTD = ((PORTD & ~LEDS_ALL_LEDS) | LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTD = ((PORTD & ~LEDMask) | ActiveMask); PORTD = ((PORTD & ~LEDMask) | ActiveMask);
} }

@ -101,7 +101,8 @@
PORTB = ((PORTB & ~LEDS_ALL_LEDS) | LedMask); PORTB = ((PORTB & ~LEDS_ALL_LEDS) | LedMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LedMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LedMask,
const uint8_t ActiveMask)
{ {
PORTB = ((PORTB & ~LedMask) | ActiveMask); PORTB = ((PORTB & ~LedMask) | ActiveMask);
} }

@ -116,7 +116,8 @@
* \param[in] PageAddress Page address within the selected dataflash IC * \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer * \param[in] BufferByte Address within the dataflash's buffer
*/ */
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte) static inline void Dataflash_SendAddressBytes(uint16_t PageAddress,
const uint16_t BufferByte)
{ {
Dataflash_SendByte(PageAddress >> 5); Dataflash_SendByte(PageAddress >> 5);
Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8)); Dataflash_SendByte((PageAddress << 3) | (BufferByte >> 8));

@ -100,7 +100,8 @@
PORTB = ((PORTB | LEDS_ALL_LEDS) & ~LEDMask); PORTB = ((PORTB | LEDS_ALL_LEDS) & ~LEDMask);
} }
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask) static inline void LEDs_ChangeLEDs(const uint8_t LEDMask,
const uint8_t ActiveMask)
{ {
PORTB = ((PORTB | (LEDMask & LEDS_ALL_LEDS)) & (~ActiveMask & LEDS_ALL_LEDS)); PORTB = ((PORTB | (LEDMask & LEDS_ALL_LEDS)) & (~ActiveMask & LEDS_ALL_LEDS));
} }

@ -99,7 +99,7 @@
* *
* \return Boolean true if the recipient ACKed the byte, false otherwise * \return Boolean true if the recipient ACKed the byte, false otherwise
*/ */
static inline bool TWI_SendByte(uint8_t Byte) static inline bool TWI_SendByte(const uint8_t Byte)
{ {
TWDR = Byte; TWDR = Byte;
TWCR = ((1 << TWINT) | (1 << TWEN)); TWCR = ((1 << TWINT) | (1 << TWEN));
@ -115,7 +115,8 @@
* *
* \return Boolean true if the byte reception successfully completed, false otherwise * \return Boolean true if the byte reception successfully completed, false otherwise
*/ */
static inline bool TWI_ReceiveByte(uint8_t* Byte, bool LastByte) static inline bool TWI_ReceiveByte(uint8_t* const Byte,
const bool LastByte)
{ {
uint8_t TWCRMask = ((1 << TWINT) | (1 << TWEN)); uint8_t TWCRMask = ((1 << TWINT) | (1 << TWEN));
@ -137,7 +138,8 @@
* *
* \return Boolean true if the device is ready for data, false otherwise * \return Boolean true if the device is ready for data, false otherwise
*/ */
bool TWI_StartTransmission(uint8_t SlaveAddress, uint8_t TimeoutMS); bool TWI_StartTransmission(const uint8_t SlaveAddress,
const uint8_t TimeoutMS);
/* Disable C linkage for C++ Compilers: */ /* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus) #if defined(__cplusplus)

@ -30,7 +30,7 @@
#include "Serial.h" #include "Serial.h"
void Serial_TxString_P(const char *FlashStringPtr) void Serial_TxString_P(const char* FlashStringPtr)
{ {
uint8_t CurrByte; uint8_t CurrByte;
@ -41,7 +41,7 @@ void Serial_TxString_P(const char *FlashStringPtr)
} }
} }
void Serial_TxString(const char *StringPtr) void Serial_TxString(const char* StringPtr)
{ {
uint8_t CurrByte; uint8_t CurrByte;

@ -92,13 +92,13 @@
* *
* \param[in] FlashStringPtr Pointer to a string located in program space. * \param[in] FlashStringPtr Pointer to a string located in program space.
*/ */
void Serial_TxString_P(const char *FlashStringPtr) ATTR_NON_NULL_PTR_ARG(1); void Serial_TxString_P(const char* FlashStringPtr) ATTR_NON_NULL_PTR_ARG(1);
/** Transmits a given string located in SRAM memory through the USART. /** Transmits a given string located in SRAM memory through the USART.
* *
* \param[in] StringPtr Pointer to a string located in SRAM space. * \param[in] StringPtr Pointer to a string located in SRAM space.
*/ */
void Serial_TxString(const char *StringPtr) ATTR_NON_NULL_PTR_ARG(1); void Serial_TxString(const char* StringPtr) ATTR_NON_NULL_PTR_ARG(1);
/* Inline Functions: */ /* Inline Functions: */
/** Initializes the USART, ready for serial data transmission and reception. This initializes the interface to /** Initializes the USART, ready for serial data transmission and reception. This initializes the interface to
@ -107,7 +107,8 @@
* \param[in] BaudRate Serial baud rate, in bits per second. * \param[in] BaudRate Serial baud rate, in bits per second.
* \param[in] DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate. * \param[in] DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate.
*/ */
static inline void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed) static inline void Serial_Init(const uint32_t BaudRate,
const bool DoubleSpeed)
{ {
UCSR1A = (DoubleSpeed ? (1 << U2X1) : 0); UCSR1A = (DoubleSpeed ? (1 << U2X1) : 0);
UCSR1B = ((1 << TXEN1) | (1 << RXEN1)); UCSR1B = ((1 << TXEN1) | (1 << RXEN1));

@ -33,7 +33,8 @@
FILE USARTStream = FDEV_SETUP_STREAM(SerialStream_TxByte, SerialStream_RxByte, _FDEV_SETUP_RW); FILE USARTStream = FDEV_SETUP_STREAM(SerialStream_TxByte, SerialStream_RxByte, _FDEV_SETUP_RW);
static int SerialStream_TxByte(char DataByte, FILE *Stream) static int SerialStream_TxByte(char DataByte,
FILE *Stream)
{ {
(void)Stream; (void)Stream;

@ -74,7 +74,8 @@
/* Function Prototypes: */ /* Function Prototypes: */
#if defined(__INCLUDE_FROM_SERIALSTREAM_C) #if defined(__INCLUDE_FROM_SERIALSTREAM_C)
static int SerialStream_TxByte(char DataByte, FILE *Stream) ATTR_NON_NULL_PTR_ARG(2); static int SerialStream_TxByte(char DataByte,
FILE *Stream) ATTR_NON_NULL_PTR_ARG(2);
static int SerialStream_RxByte(FILE *Stream) ATTR_NON_NULL_PTR_ARG(1); static int SerialStream_RxByte(FILE *Stream) ATTR_NON_NULL_PTR_ARG(1);
#endif #endif
#endif #endif
@ -87,7 +88,8 @@
* \param[in] BaudRate Baud rate to configure the USART to. * \param[in] BaudRate Baud rate to configure the USART to.
* \param[in] DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate. * \param[in] DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate.
*/ */
static inline void SerialStream_Init(const uint32_t BaudRate, const bool DoubleSpeed) static inline void SerialStream_Init(const uint32_t BaudRate,
const bool DoubleSpeed)
{ {
Serial_Init(BaudRate, DoubleSpeed); Serial_Init(BaudRate, DoubleSpeed);

@ -7,7 +7,8 @@
#include "TWI.h" #include "TWI.h"
bool TWI_StartTransmission(uint8_t SlaveAddress, uint8_t TimeoutMS) bool TWI_StartTransmission(const uint8_t SlaveAddress,
const uint8_t TimeoutMS)
{ {
for (;;) for (;;)
{ {

@ -59,7 +59,7 @@ void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const Audi
} }
} }
bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo) bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
{ {
memset(&AudioInterfaceInfo->State, 0x00, sizeof(AudioInterfaceInfo->State)); memset(&AudioInterfaceInfo->State, 0x00, sizeof(AudioInterfaceInfo->State));

@ -41,7 +41,7 @@ void CDC_Device_Event_Stub(void)
} }
void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo) void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{ {
if (!(Endpoint_IsSETUPReceived())) if (!(Endpoint_IsSETUPReceived()))
return; return;
@ -96,7 +96,7 @@ void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* CDCInterfaceIn
} }
} }
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo) bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{ {
memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State)); memset(&CDCInterfaceInfo->State, 0x00, sizeof(CDCInterfaceInfo->State));
@ -124,7 +124,7 @@ bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
return true; return true;
} }
void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo) void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{ {
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return; return;
@ -137,7 +137,9 @@ void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
CDC_Device_Flush(CDCInterfaceInfo); CDC_Device_Flush(CDCInterfaceInfo);
} }
uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length) uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
char* const Data,
const uint16_t Length)
{ {
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return ENDPOINT_RWSTREAM_DeviceDisconnected; return ENDPOINT_RWSTREAM_DeviceDisconnected;
@ -146,7 +148,8 @@ uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo
return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK); return Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
} }
uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data) uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
const uint8_t Data)
{ {
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return ENDPOINT_RWSTREAM_DeviceDisconnected; return ENDPOINT_RWSTREAM_DeviceDisconnected;
@ -219,7 +222,7 @@ uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterface
} }
} }
uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo) uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{ {
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS)) if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return 0; return 0;
@ -257,19 +260,22 @@ void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDC
Endpoint_ClearIN(); Endpoint_ClearIN();
} }
void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, FILE* const Stream) void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
FILE* const Stream)
{ {
*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW); *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
fdev_set_udata(Stream, CDCInterfaceInfo); fdev_set_udata(Stream, CDCInterfaceInfo);
} }
void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, FILE* const Stream) void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
FILE* const Stream)
{ {
*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW); *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
fdev_set_udata(Stream, CDCInterfaceInfo); fdev_set_udata(Stream, CDCInterfaceInfo);
} }
static int CDC_Device_putchar(char c, FILE* Stream) static int CDC_Device_putchar(char c,
FILE* Stream)
{ {
return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0; return CDC_Device_SendByte((USB_ClassInfo_CDC_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
} }

@ -196,7 +196,8 @@
* \param[in,out] 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.
* \param[in] Duration Duration of the break that has been sent by the host, in milliseconds. * \param[in] Duration Duration of the break that has been sent by the host, in milliseconds.
*/ */
void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Duration) ATTR_NON_NULL_PTR_ARG(1); void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
const uint8_t Duration) ATTR_NON_NULL_PTR_ARG(1);
/** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the /** 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. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the * string is discarded. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the
@ -212,8 +213,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length) uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); char* const Data,
const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the /** 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. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the * byte is discarded. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the
@ -228,7 +230,8 @@
* *
* \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum. * \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.
*/ */
uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1); uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);
/** Determines the number of bytes received by the CDC interface from the host, waiting to be read. /** Determines the number of bytes received by the CDC interface from the host, waiting to be read.
* *
@ -292,8 +295,8 @@
* \param[in,out] 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.
* \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed. * \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed.
*/ */
void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, FILE* const Stream) void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); FILE* const Stream) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Identical to CDC_Device_CreateStream(), except that reads are blocking until the calling stream function terminates /** Identical to CDC_Device_CreateStream(), except that reads are blocking until the calling stream function terminates
* the transfer. While blocking, the USB and CDC service tasks are called repeatedly to maintain USB communications. * the transfer. While blocking, the USB and CDC service tasks are called repeatedly to maintain USB communications.
@ -301,14 +304,15 @@
* \param[in,out] 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.
* \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed. * \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed.
*/ */
void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, FILE* const Stream) void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); FILE* const Stream) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)
/* Function Prototypes: */ /* Function Prototypes: */
#if defined(__INCLUDE_FROM_CDC_CLASS_DEVICE_C) #if defined(__INCLUDE_FROM_CDC_CLASS_DEVICE_C)
static int CDC_Device_putchar(char c, FILE* Stream) ATTR_NON_NULL_PTR_ARG(2); static int CDC_Device_putchar(char c,
FILE* Stream) ATTR_NON_NULL_PTR_ARG(2);
static int CDC_Device_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1); static int CDC_Device_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
static int CDC_Device_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1); static int CDC_Device_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
@ -317,8 +321,9 @@
ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub); ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub); ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Duration) void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub); const uint8_t Duration) ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1)
ATTR_ALIAS(CDC_Device_Event_Stub);
#endif #endif
#endif #endif

@ -163,8 +163,11 @@
* \return Boolean true to force the sending of the report even if it is identical to the previous report and still within * \return Boolean true to force the sending of the report even if it is identical to the previous report and still within
* the idle period (useful for devices which report relative movement), false otherwise. * the idle period (useful for devices which report relative movement), false otherwise.
*/ */
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
const uint8_t ReportType, void* ReportData, uint16_t* const ReportSize) ATTR_NON_NULL_PTR_ARG(1) uint8_t* const ReportID,
const uint8_t ReportType,
void* ReportData,
uint16_t* const ReportSize) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(2) ATTR_NON_NULL_PTR_ARG(4) ATTR_NON_NULL_PTR_ARG(5); ATTR_NON_NULL_PTR_ARG(2) ATTR_NON_NULL_PTR_ARG(4) ATTR_NON_NULL_PTR_ARG(5);
/** HID class driver callback for the user processing of a received HID OUT report. This callback may fire in response to /** HID class driver callback for the user processing of a received HID OUT report. This callback may fire in response to
@ -178,9 +181,11 @@
* \param[in] ReportData Pointer to a buffer where the received HID report is stored. * \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. * \param[in] ReportSize Size in bytes of the received report from the host.
*/ */
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
const uint8_t ReportType, const void* ReportData, const uint16_t ReportSize) const uint8_t ReportID,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(4); const uint8_t ReportType,
const void* ReportData,
const uint16_t ReportSize) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(4);
/* Inline Functions: */ /* Inline Functions: */
/** Indicates that a millisecond of idle time has elapsed on the given HID interface, and the interface's idle count should be /** Indicates that a millisecond of idle time has elapsed on the given HID interface, and the interface's idle count should be

@ -62,7 +62,8 @@ bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInter
return true; return true;
} }
uint8_t MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, const MIDI_EventPacket_t* const Event) uint8_t MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo,
const MIDI_EventPacket_t* const Event)
{ {
if (USB_DeviceState != DEVICE_STATE_Configured) if (USB_DeviceState != DEVICE_STATE_Configured)
return ENDPOINT_RWSTREAM_DeviceDisconnected; return ENDPOINT_RWSTREAM_DeviceDisconnected;
@ -103,7 +104,8 @@ uint8_t MIDI_Device_Flush(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
return ENDPOINT_READYWAIT_NoError; return ENDPOINT_READYWAIT_NoError;
} }
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event) bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event)
{ {
if (USB_DeviceState != DEVICE_STATE_Configured) if (USB_DeviceState != DEVICE_STATE_Configured)
return false; return false;

@ -333,8 +333,11 @@ void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const
} }
static bool RNDIS_Device_ProcessNDISQuery(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, const uint32_t OId,
void* ResponseData, uint16_t* const ResponseSize) void* const QueryData,
const uint16_t QuerySize,
void* ResponseData,
uint16_t* const ResponseSize)
{ {
(void)QueryData; (void)QueryData;
(void)QuerySize; (void)QuerySize;
@ -447,8 +450,10 @@ static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RN
} }
} }
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId, static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
const void* SetData, const uint16_t SetSize) const uint32_t OId,
const void* SetData,
const uint16_t SetSize)
{ {
(void)SetSize; (void)SetSize;

@ -151,11 +151,16 @@
static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo) static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
ATTR_NON_NULL_PTR_ARG(1); ATTR_NON_NULL_PTR_ARG(1);
static bool RNDIS_Device_ProcessNDISQuery(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, const uint32_t OId,
void* ResponseData, uint16_t* const ResponseSize) ATTR_NON_NULL_PTR_ARG(1) void* const QueryData,
const uint16_t QuerySize,
void* ResponseData,
uint16_t* const ResponseSize) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(5) ATTR_NON_NULL_PTR_ARG(6); ATTR_NON_NULL_PTR_ARG(5) ATTR_NON_NULL_PTR_ARG(6);
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId, static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
const void* SetData, const uint16_t SetSize) ATTR_NON_NULL_PTR_ARG(1) const uint32_t OId,
const void* SetData,
const uint16_t SetSize) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(3); ATTR_NON_NULL_PTR_ARG(3);
#endif #endif

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_CDC_DRIVER #define __INCLUDE_FROM_CDC_DRIVER
#include "CDC.h" #include "CDC.h"
uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* ConfigDescriptorData) void* ConfigDescriptorData)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -261,7 +262,8 @@ uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* const CDCI
return USB_Host_SendControlRequest(NULL); return USB_Host_SendControlRequest(NULL);
} }
uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, const uint8_t Duration) uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
const uint8_t Duration)
{ {
USB_ControlRequest = (USB_Request_Header_t) USB_ControlRequest = (USB_Request_Header_t)
{ {
@ -277,7 +279,9 @@ uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, con
return USB_Host_SendControlRequest(NULL); return USB_Host_SendControlRequest(NULL);
} }
uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, char* Data, const uint16_t Length) uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
char* const Data,
const uint16_t Length)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected; return PIPE_READYWAIT_DeviceDisconnected;
@ -293,7 +297,8 @@ uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, ch
return ErrorCode; return ErrorCode;
} }
uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, const uint8_t Data) uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
const uint8_t Data)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected; return PIPE_READYWAIT_DeviceDisconnected;
@ -399,19 +404,22 @@ uint8_t CDC_Host_Flush(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
return PIPE_READYWAIT_NoError; return PIPE_READYWAIT_NoError;
} }
void CDC_Host_CreateStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, FILE* const Stream) void CDC_Host_CreateStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
FILE* const Stream)
{ {
*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar, _FDEV_SETUP_RW); *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar, _FDEV_SETUP_RW);
fdev_set_udata(Stream, CDCInterfaceInfo); fdev_set_udata(Stream, CDCInterfaceInfo);
} }
void CDC_Host_CreateBlockingStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, FILE* const Stream) void CDC_Host_CreateBlockingStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
FILE* const Stream)
{ {
*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar_Blocking, _FDEV_SETUP_RW); *Stream = (FILE)FDEV_SETUP_STREAM(CDC_Host_putchar, CDC_Host_getchar_Blocking, _FDEV_SETUP_RW);
fdev_set_udata(Stream, CDCInterfaceInfo); fdev_set_udata(Stream, CDCInterfaceInfo);
} }
static int CDC_Host_putchar(char c, FILE* Stream) static int CDC_Host_putchar(char c,
FILE* Stream)
{ {
return CDC_Host_SendByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0; return CDC_Host_SendByte((USB_ClassInfo_CDC_Host_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
} }

@ -167,7 +167,8 @@
* *
* \return A value from the \ref CDCHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref CDCHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Sets the line encoding for the attached device's virtual serial port. This should be called when the LineEncoding /** Sets the line encoding for the attached device's virtual serial port. This should be called when the LineEncoding
@ -198,7 +199,8 @@
* *
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum. * \return A value from the \ref USB_Host_SendControlErrorCodes_t enum.
*/ */
uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, const uint8_t Duration) ATTR_NON_NULL_PTR_ARG(1); uint8_t CDC_Host_SendBreak(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
const uint8_t Duration) ATTR_NON_NULL_PTR_ARG(1);
/** Sends a given string to the attached USB device, if connected. If a device is not connected when the function is called, the /** Sends a given string to the attached USB device, if connected. If a device is not connected when the function is called, the
* string is discarded. Bytes will be queued for transmission to the device until either the pipe bank becomes full, or the * string is discarded. Bytes will be queued for transmission to the device until either the pipe bank becomes full, or the
@ -214,8 +216,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, char* Data, const uint16_t Length) uint8_t CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); char* const Data,
const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Sends a given byte to the attached USB device, if connected. If a device is not connected when the function is called, the /** Sends a given byte to the attached USB device, if connected. If a device is not connected when the function is called, the
* byte is discarded. Bytes will be queued for transmission to the device until either the pipe bank becomes full, or the * byte is discarded. Bytes will be queued for transmission to the device until either the pipe bank becomes full, or the
@ -230,7 +233,8 @@
* *
* \return A value from the \ref Pipe_WaitUntilReady_ErrorCodes_t enum. * \return A value from the \ref Pipe_WaitUntilReady_ErrorCodes_t enum.
*/ */
uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1); uint8_t CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);
/** Determines the number of bytes received by the CDC interface from the device, waiting to be read. /** Determines the number of bytes received by the CDC interface from the device, waiting to be read.
* *
@ -277,7 +281,8 @@
* \param[in,out] 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.
* \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed. * \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed.
*/ */
void CDC_Host_CreateStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, FILE* const Stream); void CDC_Host_CreateStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
FILE* const Stream);
/** Identical to CDC_Host_CreateStream(), except that reads are blocking until the calling stream function terminates /** Identical to CDC_Host_CreateStream(), except that reads are blocking until the calling stream function terminates
* the transfer. While blocking, the USB and CDC service tasks are called repeatedly to maintain USB communications. * the transfer. While blocking, the USB and CDC service tasks are called repeatedly to maintain USB communications.
@ -285,7 +290,8 @@
* \param[in,out] 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.
* \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed. * \param[in,out] Stream Pointer to a FILE structure where the created stream should be placed.
*/ */
void CDC_Host_CreateBlockingStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo, FILE* const Stream); void CDC_Host_CreateBlockingStream(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo,
FILE* const Stream);
/** CDC class driver event for a control line state change on a CDC host interface. This event fires each time the device notifies /** CDC class driver event for a control line state change on a CDC host interface. This event fires each time the device notifies
* the host of a control line state change (containing the virtual serial control line states, such as DCD) and may be hooked in the * the host of a control line state change (containing the virtual serial control line states, such as DCD) and may be hooked in the
@ -313,7 +319,8 @@
/* Function Prototypes: */ /* Function Prototypes: */
#if defined(__INCLUDE_FROM_CDC_CLASS_HOST_C) #if defined(__INCLUDE_FROM_CDC_CLASS_HOST_C)
static int CDC_Host_putchar(char c, FILE* Stream) ATTR_NON_NULL_PTR_ARG(2); static int CDC_Host_putchar(char c,
FILE* Stream) ATTR_NON_NULL_PTR_ARG(2);
static int CDC_Host_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1); static int CDC_Host_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
static int CDC_Host_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1); static int CDC_Host_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_HID_DRIVER #define __INCLUDE_FROM_HID_DRIVER
#include "HID.h" #include "HID.h"
uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* ConfigDescriptorData) void* ConfigDescriptorData)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -153,7 +154,9 @@ static uint8_t DCOMP_HID_Host_NextHIDInterfaceEndpoint(void* const CurrentDescri
} }
#if !defined(HID_HOST_BOOT_PROTOCOL_ONLY) #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, const uint8_t ReportID, void* Buffer) uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
const uint8_t ReportID,
void* Buffer)
{ {
USB_ControlRequest = (USB_Request_Header_t) USB_ControlRequest = (USB_Request_Header_t)
{ {
@ -170,7 +173,8 @@ uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceI
} }
#endif #endif
uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, void* Buffer) uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
void* Buffer)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected; return PIPE_READYWAIT_DeviceDisconnected;
@ -215,7 +219,9 @@ uint8_t HID_Host_SendReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo
#if !defined(HID_HOST_BOOT_PROTOCOL_ONLY) #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
const uint8_t ReportID, const uint8_t ReportID,
#endif #endif
const uint8_t ReportType, void* Buffer, const uint16_t ReportSize) const uint8_t ReportType,
void* Buffer,
const uint16_t ReportSize)
{ {
#if !defined(HID_HOST_BOOT_PROTOCOL_ONLY) #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))

@ -161,7 +161,8 @@
* *
* \return A value from the \ref HIDHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref HIDHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
@ -178,8 +179,8 @@
* *
* \return An error code from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return An error code from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, void* Buffer) uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); void* Buffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
#if !defined(HID_HOST_BOOT_PROTOCOL_ONLY) #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
/** Receives a HID IN report from the attached device, by the report ID. /** Receives a HID IN report from the attached device, by the report ID.
@ -195,7 +196,8 @@
* *
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum. * \return A value from the \ref USB_Host_SendControlErrorCodes_t enum.
*/ */
uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, const uint8_t ReportID, uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
const uint8_t ReportID,
void* Buffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* Buffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
#endif #endif
@ -221,7 +223,9 @@
#if !defined(HID_HOST_BOOT_PROTOCOL_ONLY) #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
const uint8_t ReportID, const uint8_t ReportID,
#endif #endif
const uint8_t ReportType, void* Buffer, const uint16_t ReportSize) ATTR_NON_NULL_PTR_ARG(1) const uint8_t ReportType,
void* Buffer,
const uint16_t ReportSize) ATTR_NON_NULL_PTR_ARG(1)
#if !defined(HID_HOST_BOOT_PROTOCOL_ONLY) #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
ATTR_NON_NULL_PTR_ARG(4); ATTR_NON_NULL_PTR_ARG(4);
#else #else

@ -34,7 +34,9 @@
#include "HIDParser.h" #include "HIDParser.h"
uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData) uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
uint16_t ReportSize,
HID_ReportInfo_t* const ParserData)
{ {
HID_StateTable_t StateTable[HID_STATETABLE_STACK_DEPTH]; HID_StateTable_t StateTable[HID_STATETABLE_STACK_DEPTH];
HID_StateTable_t* CurrStateTable = &StateTable[0]; HID_StateTable_t* CurrStateTable = &StateTable[0];
@ -284,7 +286,8 @@ uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID
return HID_PARSE_Successful; return HID_PARSE_Successful;
} }
bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem) bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
HID_ReportItem_t* const ReportItem)
{ {
uint16_t DataBitsRem = ReportItem->Attributes.BitSize; uint16_t DataBitsRem = ReportItem->Attributes.BitSize;
uint16_t CurrentBit = ReportItem->BitOffset; uint16_t CurrentBit = ReportItem->BitOffset;
@ -313,7 +316,8 @@ bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const
return true; return true;
} }
void USB_SetHIDReportItemInfo(uint8_t* ReportData, HID_ReportItem_t* const ReportItem) void USB_SetHIDReportItemInfo(uint8_t* ReportData,
HID_ReportItem_t* const ReportItem)
{ {
uint16_t DataBitsRem = ReportItem->Attributes.BitSize; uint16_t DataBitsRem = ReportItem->Attributes.BitSize;
uint16_t CurrentBit = ReportItem->BitOffset; uint16_t CurrentBit = ReportItem->BitOffset;
@ -337,7 +341,9 @@ void USB_SetHIDReportItemInfo(uint8_t* ReportData, HID_ReportItem_t* const Repor
} }
} }
uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t ReportID, const uint8_t ReportType) uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
const uint8_t ReportID,
const uint8_t ReportType)
{ {
for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++) for (uint8_t i = 0; i < HID_MAX_REPORT_IDS; i++)
{ {

@ -278,8 +278,9 @@
* *
* \return A value in the \ref HID_Parse_ErrorCodes_t enum. * \return A value in the \ref HID_Parse_ErrorCodes_t enum.
*/ */
uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData) uint8_t USB_ProcessHIDReport(const uint8_t* ReportData,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); uint16_t ReportSize,
HID_ReportInfo_t* const ParserData) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Extracts the given report item's value out of the given HID report and places it into the Value /** 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. * member of the report item's \ref HID_ReportItem_t structure.
@ -292,8 +293,8 @@
* *
* \returns Boolean true if the item to retrieve was located in the given report, false otherwise. * \returns Boolean true if the item to retrieve was located in the given report, false otherwise.
*/ */
bool USB_GetHIDReportItemInfo(const uint8_t* ReportData, HID_ReportItem_t* const ReportItem) bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); HID_ReportItem_t* const ReportItem) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Retrieves the given report item's value out of the Value member of the report item's /** Retrieves the given report item's value out of the Value member of the report item's
* \ref HID_ReportItem_t structure and places it into the correct position in the HID report * \ref HID_ReportItem_t structure and places it into the correct position in the HID report
@ -308,8 +309,8 @@
* \param[out] ReportData Buffer holding the current OUT or FEATURE report data. * \param[out] ReportData Buffer holding the current OUT or FEATURE report data.
* \param[in] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array. * \param[in] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array.
*/ */
void USB_SetHIDReportItemInfo(uint8_t* ReportData, HID_ReportItem_t* const ReportItem) void USB_SetHIDReportItemInfo(uint8_t* ReportData,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); HID_ReportItem_t* const ReportItem) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Retrieves the size of a given HID report in bytes from it's Report ID. /** Retrieves the size of a given HID report in bytes from it's Report ID.
* *
@ -320,7 +321,8 @@
* *
* \return Size of the report in bytes, or 0 if the report does not exist. * \return Size of the report in bytes, or 0 if the report does not exist.
*/ */
uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData, const uint8_t ReportID, uint16_t USB_GetHIDReportSize(HID_ReportInfo_t* const ParserData,
const uint8_t ReportID,
const uint8_t ReportType) ATTR_CONST ATTR_NON_NULL_PTR_ARG(1); const uint8_t ReportType) ATTR_CONST ATTR_NON_NULL_PTR_ARG(1);
/** Callback routine for the HID Report Parser. This callback <b>must</b> be implemented by the user code when /** Callback routine for the HID Report Parser. This callback <b>must</b> be implemented by the user code when

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_MIDI_DRIVER #define __INCLUDE_FROM_MIDI_DRIVER
#include "MIDI.h" #include "MIDI.h"
uint8_t MIDI_Host_ConfigurePipes(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t MIDI_Host_ConfigurePipes(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* ConfigDescriptorData) void* ConfigDescriptorData)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -144,7 +145,8 @@ uint8_t MIDI_Host_Flush(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo)
return PIPE_READYWAIT_NoError; return PIPE_READYWAIT_NoError;
} }
uint8_t MIDI_Host_SendEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event) uint8_t MIDI_Host_SendEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected; return HOST_SENDCONTROL_DeviceDisconnected;
@ -165,7 +167,8 @@ uint8_t MIDI_Host_SendEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterface
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
bool MIDI_Host_ReceiveEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event) bool MIDI_Host_ReceiveEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected; return HOST_SENDCONTROL_DeviceDisconnected;

@ -125,7 +125,8 @@
* *
* \return A value from the \ref MIDIHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref MIDIHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t MIDI_Host_ConfigurePipes(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t MIDI_Host_ConfigurePipes(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Sends a MIDI event packet to the device. If no device is connected, the event packet is discarded. /** Sends a MIDI event packet to the device. If no device is connected, the event packet is discarded.

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_MS_DRIVER #define __INCLUDE_FROM_MS_DRIVER
#include "MassStorage.h" #include "MassStorage.h"
uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) void* DeviceConfigDescriptor)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -129,7 +130,8 @@ static uint8_t DCOMP_MS_NextMSInterfaceEndpoint(void* const CurrentDescriptor)
return DESCRIPTOR_SEARCH_NotFound; return DESCRIPTOR_SEARCH_NotFound;
} }
static uint8_t MS_Host_SendCommand(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, MS_CommandBlockWrapper_t* const SCSICommandBlock, static uint8_t MS_Host_SendCommand(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
MS_CommandBlockWrapper_t* const SCSICommandBlock,
const void* const BufferPtr) const void* const BufferPtr)
{ {
uint8_t ErrorCode = PIPE_RWSTREAM_NoError; uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
@ -216,7 +218,8 @@ static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInte
} }
static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
MS_CommandBlockWrapper_t* const SCSICommandBlock, void* BufferPtr) MS_CommandBlockWrapper_t* const SCSICommandBlock,
void* BufferPtr)
{ {
uint8_t ErrorCode = PIPE_RWSTREAM_NoError; uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
uint16_t BytesRem = SCSICommandBlock->DataTransferLength; uint16_t BytesRem = SCSICommandBlock->DataTransferLength;
@ -301,7 +304,8 @@ uint8_t MS_Host_ResetMSInterface(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo)
return USB_Host_SendControlRequest(NULL); return USB_Host_SendControlRequest(NULL);
} }
uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint8_t* const MaxLUNIndex) uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
uint8_t* const MaxLUNIndex)
{ {
uint8_t ErrorCode = HOST_SENDCONTROL_Successful; uint8_t ErrorCode = HOST_SENDCONTROL_Successful;
@ -325,7 +329,8 @@ uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint8_
return ErrorCode; return ErrorCode;
} }
uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
SCSI_Inquiry_Response_t* const InquiryData) SCSI_Inquiry_Response_t* const InquiryData)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
@ -361,7 +366,8 @@ uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, c
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex) uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected; return HOST_SENDCONTROL_DeviceDisconnected;
@ -396,7 +402,8 @@ uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, co
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
SCSI_Capacity_t* const DeviceCapacity) SCSI_Capacity_t* const DeviceCapacity)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
@ -439,7 +446,8 @@ uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInf
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
SCSI_Request_Sense_Response_t* const SenseData) SCSI_Request_Sense_Response_t* const SenseData)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
@ -475,7 +483,8 @@ uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, con
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
const bool PreventRemoval) const bool PreventRemoval)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
@ -511,8 +520,12 @@ uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInter
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, const uint32_t BlockAddress, uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t Blocks, const uint16_t BlockSize, void* BlockBuffer) const uint8_t LUNIndex,
const uint32_t BlockAddress,
const uint8_t Blocks,
const uint16_t BlockSize,
void* BlockBuffer)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected; return HOST_SENDCONTROL_DeviceDisconnected;
@ -551,8 +564,12 @@ uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t MS_Host_WriteDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, const uint32_t BlockAddress, uint8_t MS_Host_WriteDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t Blocks, const uint16_t BlockSize, const void* BlockBuffer) const uint8_t LUNIndex,
const uint32_t BlockAddress,
const uint8_t Blocks,
const uint16_t BlockSize,
const void* BlockBuffer)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected; return HOST_SENDCONTROL_DeviceDisconnected;

@ -143,7 +143,8 @@
* *
* \return A value from the \ref MSHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref MSHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Sends a MASS STORAGE RESET control request to the attached device, resetting the Mass Storage Interface /** Sends a MASS STORAGE RESET control request to the attached device, resetting the Mass Storage Interface
@ -168,8 +169,8 @@
* *
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum. * \return A value from the \ref USB_Host_SendControlErrorCodes_t enum.
*/ */
uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint8_t* const MaxLUNIndex) uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); uint8_t* const MaxLUNIndex) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Retrieves the Mass Storage device's inquiry data for the specified LUN, indicating the device characteristics and /** Retrieves the Mass Storage device's inquiry data for the specified LUN, indicating the device characteristics and
* properties. * properties.
@ -183,7 +184,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED.
*/ */
uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
SCSI_Inquiry_Response_t* const InquiryData) ATTR_NON_NULL_PTR_ARG(1) SCSI_Inquiry_Response_t* const InquiryData) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(3); ATTR_NON_NULL_PTR_ARG(3);
@ -194,8 +196,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/ */
uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex) uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1); const uint8_t LUNIndex) ATTR_NON_NULL_PTR_ARG(1);
/** Retrieves the total capacity of the attached USB Mass Storage device, in blocks, and block size. /** Retrieves the total capacity of the attached USB Mass Storage device, in blocks, and block size.
* *
@ -208,7 +210,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/ */
uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
SCSI_Capacity_t* const DeviceCapacity) ATTR_NON_NULL_PTR_ARG(1) SCSI_Capacity_t* const DeviceCapacity) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(3); ATTR_NON_NULL_PTR_ARG(3);
@ -224,7 +227,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/ */
uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
SCSI_Request_Sense_Response_t* const SenseData) ATTR_NON_NULL_PTR_ARG(1) SCSI_Request_Sense_Response_t* const SenseData) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(3); ATTR_NON_NULL_PTR_ARG(3);
@ -240,7 +244,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/ */
uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint8_t LUNIndex,
const bool PreventRemoval) ATTR_NON_NULL_PTR_ARG(1); const bool PreventRemoval) ATTR_NON_NULL_PTR_ARG(1);
/** Reads blocks of data from the attached Mass Storage device's medium. /** Reads blocks of data from the attached Mass Storage device's medium.
@ -257,8 +262,11 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/ */
uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint32_t BlockAddress, const uint8_t Blocks, const uint16_t BlockSize, const uint8_t LUNIndex,
const uint32_t BlockAddress,
const uint8_t Blocks,
const uint16_t BlockSize,
void* BlockBuffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(6); void* BlockBuffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(6);
/** Writes blocks of data to the attached Mass Storage device's medium. /** Writes blocks of data to the attached Mass Storage device's medium.
@ -275,8 +283,11 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/ */
uint8_t MS_Host_WriteDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, uint8_t MS_Host_WriteDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
const uint32_t BlockAddress, const uint8_t Blocks, const uint16_t BlockSize, const uint8_t LUNIndex,
const uint32_t BlockAddress,
const uint8_t Blocks,
const uint16_t BlockSize,
const void* BlockBuffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(6); const void* BlockBuffer) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(6);
/* Inline Functions: */ /* Inline Functions: */
@ -323,8 +334,8 @@
const void* const BufferPtr) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); const void* const BufferPtr) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1); static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
MS_CommandBlockWrapper_t* const SCSICommandBlock, void* BufferPtr) MS_CommandBlockWrapper_t* const SCSICommandBlock,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); void* BufferPtr) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
static uint8_t MS_Host_GetReturnedStatus(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, static uint8_t MS_Host_GetReturnedStatus(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
MS_CommandStatusWrapper_t* const SCSICommandStatus) MS_CommandStatusWrapper_t* const SCSICommandStatus)
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_PRINTER_DRIVER #define __INCLUDE_FROM_PRINTER_DRIVER
#include "Printer.h" #include "Printer.h"
uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) void* DeviceConfigDescriptor)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -148,7 +149,8 @@ uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInte
return HOST_SENDCONTROL_Successful; return HOST_SENDCONTROL_Successful;
} }
uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, uint8_t* const PortStatus) uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
uint8_t* const PortStatus)
{ {
USB_ControlRequest = (USB_Request_Header_t) USB_ControlRequest = (USB_Request_Header_t)
{ {
@ -180,7 +182,9 @@ uint8_t PRNT_Host_SoftReset(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
return USB_Host_SendControlRequest(NULL); return USB_Host_SendControlRequest(NULL);
} }
uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, void* PrinterCommands, const uint16_t CommandSize) uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
void* PrinterCommands,
const uint16_t CommandSize)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -205,7 +209,9 @@ uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, v
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, char* DeviceIDString, const uint16_t BufferSize) uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
char* const DeviceIDString,
const uint16_t BufferSize)
{ {
uint8_t ErrorCode = HOST_SENDCONTROL_Successful; uint8_t ErrorCode = HOST_SENDCONTROL_Successful;
uint16_t DeviceIDStringLength = 0; uint16_t DeviceIDStringLength = 0;

@ -126,7 +126,8 @@
* *
* \return A value from the \ref PRNTHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref PRNTHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Configures the printer to enable Bidirectional mode, if it is not already in this mode. This should be called /** Configures the printer to enable Bidirectional mode, if it is not already in this mode. This should be called
@ -146,7 +147,8 @@
* *
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum. * \return A value from the \ref USB_Host_SendControlErrorCodes_t enum.
*/ */
uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, uint8_t* const PortStatus) uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
uint8_t* const PortStatus)
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Soft-resets the attached printer, readying it for new commands. /** Soft-resets the attached printer, readying it for new commands.
@ -170,7 +172,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, void* PrinterCommands, uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
void* PrinterCommands,
const uint16_t CommandSize) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); const uint16_t CommandSize) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Retrieves the attached printer device's ID string, formatted according to IEEE 1284. This string is sent as a /** Retrieves the attached printer device's ID string, formatted according to IEEE 1284. This string is sent as a
@ -186,7 +189,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, char* DeviceIDString, uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
char* const DeviceIDString,
const uint16_t BufferSize) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); const uint16_t BufferSize) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/* Inline Functions: */ /* Inline Functions: */

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_RNDIS_DRIVER #define __INCLUDE_FROM_RNDIS_DRIVER
#include "RNDIS.h" #include "RNDIS.h"
uint8_t RNDIS_Host_ConfigurePipes(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t RNDIS_Host_ConfigurePipes(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* ConfigDescriptorData) void* ConfigDescriptorData)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -195,7 +196,8 @@ static uint8_t DCOMP_RNDIS_Host_NextRNDISInterfaceEndpoint(void* const CurrentDe
} }
static uint8_t RNDIS_SendEncapsulatedCommand(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, static uint8_t RNDIS_SendEncapsulatedCommand(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer, const uint16_t Length) void* Buffer,
const uint16_t Length)
{ {
USB_ControlRequest = (USB_Request_Header_t) USB_ControlRequest = (USB_Request_Header_t)
{ {
@ -211,7 +213,8 @@ static uint8_t RNDIS_SendEncapsulatedCommand(USB_ClassInfo_RNDIS_Host_t* const R
} }
static uint8_t RNDIS_GetEncapsulatedResponse(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, static uint8_t RNDIS_GetEncapsulatedResponse(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer, const uint16_t Length) void* Buffer,
const uint16_t Length)
{ {
USB_ControlRequest = (USB_Request_Header_t) USB_ControlRequest = (USB_Request_Header_t)
{ {
@ -287,8 +290,10 @@ uint8_t RNDIS_Host_InitializeDevice(USB_ClassInfo_RNDIS_Host_t* const RNDISInter
return HOST_SENDCONTROL_Successful; return HOST_SENDCONTROL_Successful;
} }
uint8_t RNDIS_Host_SetRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, const uint32_t Oid, uint8_t RNDIS_Host_SetRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer, const uint16_t Length) const uint32_t Oid,
void* Buffer,
const uint16_t Length)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -329,8 +334,10 @@ uint8_t RNDIS_Host_SetRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInter
return HOST_SENDCONTROL_Successful; return HOST_SENDCONTROL_Successful;
} }
uint8_t RNDIS_Host_QueryRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, const uint32_t Oid, uint8_t RNDIS_Host_QueryRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer, const uint16_t MaxLength) const uint32_t Oid,
void* Buffer,
const uint16_t MaxLength)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -390,7 +397,9 @@ bool RNDIS_Host_IsPacketReceived(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfac
return PacketWaiting; return PacketWaiting;
} }
uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, void* Buffer, uint16_t* const PacketLength) uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer,
uint16_t* const PacketLength)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -434,7 +443,9 @@ uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceIn
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t RNDIS_Host_SendPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, void* Buffer, const uint16_t PacketLength) uint8_t RNDIS_Host_SendPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer,
const uint16_t PacketLength)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;

@ -144,7 +144,8 @@
* *
* \return A value from the \ref RNDISHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref RNDISHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t RNDIS_Host_ConfigurePipes(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t RNDIS_Host_ConfigurePipes(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Sends a RNDIS KEEPALIVE command to the device, to ensure that it does not enter standby mode after periods /** Sends a RNDIS KEEPALIVE command to the device, to ensure that it does not enter standby mode after periods
@ -177,7 +178,9 @@
* \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a
* logical command failure. * logical command failure.
*/ */
uint8_t RNDIS_Host_SetRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, const uint32_t Oid, void* Buffer, uint8_t RNDIS_Host_SetRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
const uint32_t Oid,
void* Buffer,
const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Gets a given RNDIS property of an attached RNDIS device. /** Gets a given RNDIS property of an attached RNDIS device.
@ -190,7 +193,9 @@
* \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a * \return A value from the USB_Host_SendControlErrorCodes_t enum or RNDIS_COMMAND_FAILED if the device returned a
* logical command failure. * logical command failure.
*/ */
uint8_t RNDIS_Host_QueryRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, const uint32_t Oid, void* Buffer, uint8_t RNDIS_Host_QueryRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
const uint32_t Oid,
void* Buffer,
const uint16_t MaxLength) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); const uint16_t MaxLength) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Determines if a packet is currently waiting for the host to read in and process. /** Determines if a packet is currently waiting for the host to read in and process.
@ -216,8 +221,10 @@
* *
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, void* Buffer, uint16_t* const PacketLength) uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2) ATTR_NON_NULL_PTR_ARG(3); void* Buffer,
uint16_t* const PacketLength) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2)
ATTR_NON_NULL_PTR_ARG(3);
/** Sends the given packet to the attached RNDIS device, after adding a RNDIS packet message header. /** Sends the given packet to the attached RNDIS device, after adding a RNDIS packet message header.
* *
@ -230,8 +237,9 @@
* *
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t RNDIS_Host_SendPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, void* Buffer, const uint16_t PacketLength) uint8_t RNDIS_Host_SendPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); void* Buffer,
const uint16_t PacketLength) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/* Inline Functions: */ /* Inline Functions: */
/** General management task for a given RNDIS host class interface, required for the correct operation of the interface. This should /** General management task for a given RNDIS host class interface, required for the correct operation of the interface. This should
@ -262,10 +270,12 @@
/* Function Prototypes: */ /* Function Prototypes: */
#if defined(__INCLUDE_FROM_RNDIS_CLASS_HOST_C) #if defined(__INCLUDE_FROM_RNDIS_CLASS_HOST_C)
static uint8_t RNDIS_SendEncapsulatedCommand(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, static uint8_t RNDIS_SendEncapsulatedCommand(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer, const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) void* Buffer,
const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(2); ATTR_NON_NULL_PTR_ARG(2);
static uint8_t RNDIS_GetEncapsulatedResponse(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, static uint8_t RNDIS_GetEncapsulatedResponse(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
void* Buffer, const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) void* Buffer,
const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1)
ATTR_NON_NULL_PTR_ARG(2); ATTR_NON_NULL_PTR_ARG(2);
static uint8_t DCOMP_RNDIS_Host_NextRNDISControlInterface(void* const CurrentDescriptor) ATTR_NON_NULL_PTR_ARG(1); static uint8_t DCOMP_RNDIS_Host_NextRNDISControlInterface(void* const CurrentDescriptor) ATTR_NON_NULL_PTR_ARG(1);

@ -36,7 +36,8 @@
#define __INCLUDE_FROM_SI_DRIVER #define __INCLUDE_FROM_SI_DRIVER
#include "StillImage.h" #include "StillImage.h"
uint8_t SImage_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t SImage_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) void* DeviceConfigDescriptor)
{ {
uint8_t FoundEndpoints = 0; uint8_t FoundEndpoints = 0;
@ -144,7 +145,8 @@ uint8_t DCOMP_SI_Host_NextSIInterfaceEndpoint(void* const CurrentDescriptor)
return DESCRIPTOR_SEARCH_NotFound; return DESCRIPTOR_SEARCH_NotFound;
} }
uint8_t SImage_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader) uint8_t SImage_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
SI_PIMA_Container_t* const PIMAHeader)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -174,7 +176,8 @@ uint8_t SImage_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceIn
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t SImage_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader) uint8_t SImage_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
SI_PIMA_Container_t* const PIMAHeader)
{ {
uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS; uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;
@ -238,7 +241,9 @@ uint8_t SImage_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfac
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t SImage_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, const uint16_t Bytes) uint8_t SImage_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
void* Buffer,
const uint16_t Bytes)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -256,7 +261,9 @@ uint8_t SImage_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, voi
return ErrorCode; return ErrorCode;
} }
uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, const uint16_t Bytes) uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
void* Buffer,
const uint16_t Bytes)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -273,7 +280,7 @@ uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, voi
return ErrorCode; return ErrorCode;
} }
bool SImage_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* SIInterfaceInfo) bool SImage_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
{ {
bool IsEventReceived = false; bool IsEventReceived = false;
@ -291,7 +298,8 @@ bool SImage_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* SIInterfaceInfo)
return IsEventReceived; return IsEventReceived;
} }
uint8_t SImage_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader) uint8_t SImage_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
SI_PIMA_Container_t* const PIMAHeader)
{ {
uint8_t ErrorCode; uint8_t ErrorCode;
@ -370,8 +378,10 @@ uint8_t SImage_Host_CloseSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
return PIPE_RWSTREAM_NoError; return PIPE_RWSTREAM_NoError;
} }
uint8_t SImage_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, const uint16_t Operation, uint8_t SImage_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
const uint8_t TotalParams, uint32_t* const Params) const uint16_t Operation,
const uint8_t TotalParams,
uint32_t* const Params)
{ {
if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive)) if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected; return HOST_SENDCONTROL_DeviceDisconnected;

@ -140,7 +140,8 @@
* *
* \return A value from the \ref SIHost_EnumerationFailure_ErrorCodes_t enum. * \return A value from the \ref SIHost_EnumerationFailure_ErrorCodes_t enum.
*/ */
uint8_t SImage_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, uint16_t ConfigDescriptorSize, uint8_t SImage_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3); void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
/** Opens a new PIMA session with the attached device. This should be used before any session-orientated PIMA commands /** Opens a new PIMA session with the attached device. This should be used before any session-orientated PIMA commands
@ -212,8 +213,10 @@
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum, or \ref SI_ERROR_LOGICAL_CMD_FAILED if the device * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum, or \ref SI_ERROR_LOGICAL_CMD_FAILED if the device
* returned a logical command failure. * returned a logical command failure.
*/ */
uint8_t SImage_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, const uint16_t Operation, uint8_t SImage_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
const uint8_t TotalParams, uint32_t* const Params) ATTR_NON_NULL_PTR_ARG(1); const uint16_t Operation,
const uint8_t TotalParams,
uint32_t* const Params) ATTR_NON_NULL_PTR_ARG(1);
/** Receives and checks a response block from the attached PIMA device, once a command has been issued and all data /** Receives and checks a response block from the attached PIMA device, once a command has been issued and all data
* associated with the command has been transferred. * associated with the command has been transferred.
@ -266,7 +269,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t SImage_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, uint8_t SImage_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
void* Buffer,
const uint16_t Bytes) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); const uint16_t Bytes) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Receives arbitrary data from the attached device, for use in the data phase of PIMA commands which require data /** Receives arbitrary data from the attached device, for use in the data phase of PIMA commands which require data
@ -281,7 +285,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
void* Buffer,
const uint16_t Bytes) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); const uint16_t Bytes) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/* Inline Functions: */ /* Inline Functions: */

@ -254,7 +254,9 @@
* } * }
* \endcode * \endcode
*/ */
uint8_t USB_GetNextDescriptorComp(uint16_t* const BytesRem, void** const CurrConfigLoc, ConfigComparatorPtr_t const ComparatorRoutine); uint8_t USB_GetNextDescriptorComp(uint16_t* const BytesRem,
void** const CurrConfigLoc,
ConfigComparatorPtr_t const ComparatorRoutine);
/* Inline Functions: */ /* Inline Functions: */
/** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then /** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then
@ -263,9 +265,10 @@
* \param[in,out] BytesRem Pointer to the number of bytes remaining of 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. * \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor.
*/ */
static inline void USB_GetNextDescriptor(uint16_t* const BytesRem, void** CurrConfigLoc) static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,
ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2); void** CurrConfigLoc) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
static inline void USB_GetNextDescriptor(uint16_t* const BytesRem, void** CurrConfigLoc) static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,
void** CurrConfigLoc)
{ {
uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).Size; uint16_t CurrDescriptorSize = DESCRIPTOR_CAST(*CurrConfigLoc, USB_Descriptor_Header_t).Size;

@ -167,7 +167,8 @@
* \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see * \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation). * \ref Group_USBManagement documentation).
*/ */
void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode); void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
const uint8_t SubErrorCode);
/** Event for USB device enumeration completion. This event fires when a the USB interface is /** Event for USB device enumeration completion. This event fires when a the USB interface is
* in host mode and an attached USB device has been completely enumerated and is ready to be * in host mode and an attached USB device has been completely enumerated and is ready to be
@ -335,7 +336,8 @@
void EVENT_USB_Host_DeviceAttached(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub); void EVENT_USB_Host_DeviceAttached(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_Host_DeviceUnattached(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub); void EVENT_USB_Host_DeviceUnattached(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_Host_DeviceEnumerationComplete(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub); void EVENT_USB_Host_DeviceEnumerationComplete(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode) void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
const uint8_t SubErrorCode)
ATTR_WEAK ATTR_ALIAS(USB_Event_Stub); ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
#endif #endif

@ -36,7 +36,7 @@
#define __INCLUDE_FROM_HOSTSTDREQ_C #define __INCLUDE_FROM_HOSTSTDREQ_C
#include "HostStandardReq.h" #include "HostStandardReq.h"
uint8_t USB_Host_SendControlRequest(void* BufferPtr) uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
{ {
uint8_t* HeaderStream = (uint8_t*)&USB_ControlRequest; uint8_t* HeaderStream = (uint8_t*)&USB_ControlRequest;
uint8_t* DataStream = (uint8_t*)BufferPtr; uint8_t* DataStream = (uint8_t*)BufferPtr;

@ -91,7 +91,7 @@
* *
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result. * \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/ */
uint8_t USB_Host_SendControlRequest(void* BufferPtr); uint8_t USB_Host_SendControlRequest(void* const BufferPtr);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)

@ -181,12 +181,13 @@
* *
* \return Size in bytes of the descriptor if it exists, zero or \ref NO_DESCRIPTOR otherwise. * \return Size in bytes of the descriptor if it exists, zero or \ref NO_DESCRIPTOR otherwise.
*/ */
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
const uint8_t wIndex,
void** const DescriptorAddress
#if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS) #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
, uint8_t* MemoryAddressSpace , uint8_t* MemoryAddressSpace
#endif #endif
) ) ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)

@ -45,7 +45,9 @@ uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size)
return Endpoint_BytesToEPSizeMask(Size); return Endpoint_BytesToEPSizeMask(Size);
} }
bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number, const uint8_t UECFG0XData, const uint8_t UECFG1XData) bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,
const uint8_t UECFG0XData,
const uint8_t UECFG1XData)
{ {
Endpoint_SelectEndpoint(Number); Endpoint_SelectEndpoint(Number);
Endpoint_EnableEndpoint(); Endpoint_EnableEndpoint();

@ -207,14 +207,14 @@
* *
* \param[in] EndpointNumber Endpoint number to select. * \param[in] EndpointNumber Endpoint number to select.
*/ */
static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber); static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber);
/** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's /** 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. * In and Out pointers to the bank's contents.
* *
* \param[in] 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); static inline void Endpoint_ResetFIFO(const uint8_t EndpointNumber);
/** Enables the currently selected endpoint so that data can be sent and received through it to /** Enables the currently selected endpoint so that data can be sent and received through it to
* and from a host. * and from a host.
@ -267,7 +267,7 @@
* *
* \return Boolean true if the specified endpoint has interrupted, false otherwise. * \return Boolean true if the specified endpoint has interrupted, false otherwise.
*/ */
static inline bool Endpoint_HasEndpointInterrupted(uint8_t EndpointNumber); static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber);
/** Determines if the selected IN endpoint is ready for a new packet. /** Determines if the selected IN endpoint is ready for a new packet.
* *
@ -356,7 +356,7 @@
* *
* \param[in] DirectionMask New endpoint direction, as a ENDPOINT_DIR_* mask. * \param[in] DirectionMask New endpoint direction, as a ENDPOINT_DIR_* mask.
*/ */
static inline void Endpoint_SetEndpointDirection(uint8_t DirectionMask); static inline void Endpoint_SetEndpointDirection(const uint8_t DirectionMask);
#else #else
#if defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) #if defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
#define Endpoint_BytesInEndpoint() UEBCX #define Endpoint_BytesInEndpoint() UEBCX
@ -765,8 +765,11 @@
* *
* \return Boolean true if the configuration succeeded, false otherwise. * \return Boolean true if the configuration succeeded, false otherwise.
*/ */
bool Endpoint_ConfigureEndpoint(const uint8_t Number, const uint8_t Type, const uint8_t Direction, bool Endpoint_ConfigureEndpoint(const uint8_t Number,
const uint16_t Size, const uint8_t Banks); const uint8_t Type,
const uint8_t Direction,
const uint16_t Size,
const uint8_t Banks);
/** Spin-loops until the currently selected non-control endpoint is ready for the next packet of data /** Spin-loops until the currently selected non-control endpoint is ready for the next packet of data
* to be read or written to it. * to be read or written to it.
@ -805,7 +808,8 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Discard_Stream(uint16_t Length __CALLBACK_PARAM); uint8_t Endpoint_Discard_Stream(uint16_t Length
__CALLBACK_PARAM);
/** Writes the given number of bytes to the endpoint from the given buffer in little endian, /** Writes the given number of bytes to the endpoint from the given buffer in little endian,
* sending full packets to the host as needed. The last packet filled is not automatically sent; * sending full packets to the host as needed. The last packet filled is not automatically sent;
@ -828,7 +832,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Stream_LE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Write_Stream_LE(). /** EEPROM buffer source version of \ref Endpoint_Write_Stream_LE().
* *
@ -840,7 +846,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_EStream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_EStream_LE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** FLASH buffer source version of \ref Endpoint_Write_Stream_LE(). /** FLASH buffer source version of \ref Endpoint_Write_Stream_LE().
* *
@ -854,7 +862,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_PStream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_PStream_LE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Writes the given number of bytes to the endpoint from the given buffer in big endian, /** Writes the given number of bytes to the endpoint from the given buffer in big endian,
* sending full packets to the host as needed. The last packet filled is not automatically sent; * sending full packets to the host as needed. The last packet filled is not automatically sent;
@ -877,7 +887,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Stream_BE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Write_Stream_BE(). /** EEPROM buffer source version of \ref Endpoint_Write_Stream_BE().
* *
@ -889,7 +901,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_EStream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_EStream_BE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** FLASH buffer source version of \ref Endpoint_Write_Stream_BE(). /** FLASH buffer source version of \ref Endpoint_Write_Stream_BE().
* *
@ -903,7 +917,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_PStream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_PStream_BE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Reads the given number of bytes from the endpoint from the given buffer in little endian, /** Reads the given number of bytes from the endpoint from the given buffer in little endian,
* discarding fully read packets from the host as needed. The last packet is not automatically * discarding fully read packets from the host as needed. The last packet is not automatically
@ -926,7 +942,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_Stream_LE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Read_Stream_LE(). /** EEPROM buffer source version of \ref Endpoint_Read_Stream_LE().
* *
@ -938,7 +956,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_EStream_LE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_EStream_LE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Reads the given number of bytes from the endpoint from the given buffer in big endian, /** Reads the given number of bytes from the endpoint from the given buffer in big endian,
* discarding fully read packets from the host as needed. The last packet is not automatically * discarding fully read packets from the host as needed. The last packet is not automatically
@ -961,7 +981,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_Stream_BE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Read_Stream_BE(). /** EEPROM buffer source version of \ref Endpoint_Read_Stream_BE().
* *
@ -973,7 +995,9 @@
* *
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_EStream_BE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_EStream_BE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in little endian, /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in little endian,
* sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared * sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared
@ -996,7 +1020,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of Endpoint_Write_Control_Stream_LE. /** EEPROM buffer source version of Endpoint_Write_Control_Stream_LE.
* *
@ -1016,7 +1041,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Control_EStream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Control_EStream_LE(const void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** FLASH buffer source version of \ref Endpoint_Write_Control_Stream_LE(). /** FLASH buffer source version of \ref Endpoint_Write_Control_Stream_LE().
* *
@ -1038,7 +1064,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Control_PStream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Control_PStream_LE(const void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in big endian, /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in big endian,
* sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared * sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared
@ -1061,7 +1088,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Write_Control_Stream_BE(). /** EEPROM buffer source version of \ref Endpoint_Write_Control_Stream_BE().
* *
@ -1081,7 +1109,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Control_EStream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Control_EStream_BE(const void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** FLASH buffer source version of \ref Endpoint_Write_Control_Stream_BE(). /** FLASH buffer source version of \ref Endpoint_Write_Control_Stream_BE().
* *
@ -1103,7 +1132,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Write_Control_PStream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Write_Control_PStream_BE(const void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** Reads the given number of bytes from the CONTROL endpoint from the given buffer in little endian, /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in little endian,
* discarding fully read packets from the host as needed. The device IN acknowledgement is not * discarding fully read packets from the host as needed. The device IN acknowledgement is not
@ -1126,7 +1156,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Read_Control_Stream_LE(). /** EEPROM buffer source version of \ref Endpoint_Read_Control_Stream_LE().
* *
@ -1146,7 +1177,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_Control_EStream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_Control_EStream_LE(void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** Reads the given number of bytes from the CONTROL endpoint from the given buffer in big endian, /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in big endian,
* discarding fully read packets from the host as needed. The device IN acknowledgement is not * discarding fully read packets from the host as needed. The device IN acknowledgement is not
@ -1169,7 +1201,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Endpoint_Read_Control_Stream_BE(). /** EEPROM buffer source version of \ref Endpoint_Read_Control_Stream_BE().
* *
@ -1189,7 +1222,8 @@
* *
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum. * \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/ */
uint8_t Endpoint_Read_Control_EStream_BE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1); uint8_t Endpoint_Read_Control_EStream_BE(void* Buffer,
uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)
@ -1229,7 +1263,9 @@
/* Function Prototypes: */ /* Function Prototypes: */
void Endpoint_ClearEndpoints(void); void Endpoint_ClearEndpoints(void);
uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size); uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size);
bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number, const uint8_t UECFG0XData, const uint8_t UECFG1XData); bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,
const uint8_t UECFG0XData,
const uint8_t UECFG1XData);
/* Inline Functions: */ /* Inline Functions: */
static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE; static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;

@ -305,7 +305,9 @@ uint8_t USB_Host_GetDeviceDescriptor(void* const DeviceDescriptorPtr)
return USB_Host_SendControlRequest(DeviceDescriptorPtr); return USB_Host_SendControlRequest(DeviceDescriptorPtr);
} }
uint8_t USB_Host_GetDeviceStringDescriptor(const uint8_t Index, void* const Buffer, const uint8_t BufferLength) uint8_t USB_Host_GetDeviceStringDescriptor(const uint8_t Index,
void* const Buffer,
const uint8_t BufferLength)
{ {
USB_ControlRequest = (USB_Request_Header_t) USB_ControlRequest = (USB_Request_Header_t)
{ {

@ -229,7 +229,9 @@
* *
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result. * \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/ */
uint8_t USB_Host_GetDeviceStringDescriptor(const uint8_t Index, void* const Buffer, const uint8_t BufferLength); uint8_t USB_Host_GetDeviceStringDescriptor(const uint8_t Index,
void* const Buffer,
const uint8_t BufferLength);
/** Clears a stall condition on the given pipe, via a ClearFeature request to the attached device. /** Clears a stall condition on the given pipe, via a ClearFeature request to the attached device.
* *

@ -104,7 +104,7 @@
* \param[in] SRPTypeMask Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or * \param[in] SRPTypeMask Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or
* \ref USB_OTG_STP_DATA. * \ref USB_OTG_STP_DATA.
*/ */
static inline void USB_OTG_Device_InitiateSRP(uint8_t SRPTypeMask); static inline void USB_OTG_Device_InitiateSRP(const uint8_t SRPTypeMask);
/** Accepts a HNP from a connected device, indicating that both devices should exchange /** Accepts a HNP from a connected device, indicating that both devices should exchange
* device/host roles. * device/host roles.

@ -38,8 +38,12 @@
uint8_t USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE; uint8_t USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;
bool Pipe_ConfigurePipe(const uint8_t Number, const uint8_t Type, const uint8_t Token, const uint8_t EndpointNumber, bool Pipe_ConfigurePipe(const uint8_t Number,
const uint16_t Size, const uint8_t Banks) const uint8_t Type,
const uint8_t Token,
const uint8_t EndpointNumber,
const uint16_t Size,
const uint8_t Banks)
{ {
Pipe_SelectPipe(Number); Pipe_SelectPipe(Number);
Pipe_EnablePipe(); Pipe_EnablePipe();

@ -808,8 +808,12 @@
* *
* \return Boolean true if the configuration is successful, false otherwise. * \return Boolean true if the configuration is successful, false otherwise.
*/ */
bool Pipe_ConfigurePipe(const uint8_t Number, const uint8_t Type, const uint8_t Token, const uint8_t EndpointNumber, bool Pipe_ConfigurePipe(const uint8_t Number,
const uint16_t Size, const uint8_t Banks); const uint8_t Type,
const uint8_t Token,
const uint8_t EndpointNumber,
const uint16_t Size,
const uint8_t Banks);
/** Spin-loops until the currently selected non-control pipe is ready for the next packed of data to be read /** Spin-loops until the currently selected non-control pipe is ready for the next packed of data to be read
* or written to it, aborting in the case of an error condition (such as a timeout or device disconnect). * or written to it, aborting in the case of an error condition (such as a timeout or device disconnect).
@ -850,7 +854,8 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Discard_Stream(uint16_t Length __CALLBACK_PARAM); uint8_t Pipe_Discard_Stream(uint16_t Length
__CALLBACK_PARAM);
/** Writes the given number of bytes to the pipe from the given buffer in little endian, /** Writes the given number of bytes to the pipe from the given buffer in little endian,
* sending full packets to the device as needed. The last packet filled is not automatically sent; * sending full packets to the device as needed. The last packet filled is not automatically sent;
@ -873,7 +878,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Write_Stream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Write_Stream_LE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Pipe_Write_Stream_LE(). /** EEPROM buffer source version of \ref Pipe_Write_Stream_LE().
* *
@ -885,7 +892,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Write_EStream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Write_EStream_LE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** FLASH buffer source version of \ref Pipe_Write_Stream_LE(). /** FLASH buffer source version of \ref Pipe_Write_Stream_LE().
* *
@ -899,7 +908,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Write_PStream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Write_PStream_LE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Writes the given number of bytes to the pipe from the given buffer in big endian, /** Writes the given number of bytes to the pipe from the given buffer in big endian,
* sending full packets to the device as needed. The last packet filled is not automatically sent; * sending full packets to the device as needed. The last packet filled is not automatically sent;
@ -922,7 +933,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Write_Stream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Write_Stream_BE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Pipe_Write_Stream_BE(). /** EEPROM buffer source version of \ref Pipe_Write_Stream_BE().
* *
@ -934,7 +947,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Write_EStream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Write_EStream_BE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** FLASH buffer source version of \ref Pipe_Write_Stream_BE(). /** FLASH buffer source version of \ref Pipe_Write_Stream_BE().
* *
@ -948,7 +963,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Write_PStream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Write_PStream_BE(const void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Reads the given number of bytes from the pipe into the given buffer in little endian, /** Reads the given number of bytes from the pipe into the given buffer in little endian,
* sending full packets to the device as needed. The last packet filled is not automatically sent; * sending full packets to the device as needed. The last packet filled is not automatically sent;
@ -971,7 +988,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Read_Stream_LE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Pipe_Read_Stream_LE(). /** EEPROM buffer source version of \ref Pipe_Read_Stream_LE().
* *
@ -983,7 +1002,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Read_EStream_LE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Read_EStream_LE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** Reads the given number of bytes from the pipe into the given buffer in big endian, /** Reads the given number of bytes from the pipe into the given buffer in big endian,
* sending full packets to the device as needed. The last packet filled is not automatically sent; * sending full packets to the device as needed. The last packet filled is not automatically sent;
@ -1006,7 +1027,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Read_Stream_BE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/** EEPROM buffer source version of \ref Pipe_Read_Stream_BE(). /** EEPROM buffer source version of \ref Pipe_Read_Stream_BE().
* *
@ -1018,7 +1041,9 @@
* *
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum. * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/ */
uint8_t Pipe_Read_EStream_BE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1); uint8_t Pipe_Read_EStream_BE(void* Buffer,
uint16_t Length
__CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)
@ -1033,8 +1058,8 @@
void Pipe_ClearPipes(void); void Pipe_ClearPipes(void);
/* Inline Functions: */ /* Inline Functions: */
static inline uint8_t Pipe_BytesToEPSizeMask(uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE; static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;
static inline uint8_t Pipe_BytesToEPSizeMask(uint16_t Bytes) static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes)
{ {
if (Bytes <= 8) if (Bytes <= 8)
return (0 << EPSIZE0); return (0 << EPSIZE0);

@ -1,4 +1,5 @@
uint8_t TEMPLATE_FUNC_NAME (void* Buffer, uint16_t Length) uint8_t TEMPLATE_FUNC_NAME (void* Buffer,
uint16_t Length)
{ {
uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));

@ -1,4 +1,5 @@
uint8_t TEMPLATE_FUNC_NAME (const void* Buffer, uint16_t Length) uint8_t TEMPLATE_FUNC_NAME (const void* Buffer,
uint16_t Length)
{ {
uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
bool LastPacketFull = false; bool LastPacketFull = false;

@ -1,4 +1,6 @@
uint8_t TEMPLATE_FUNC_NAME (TEMPLATE_BUFFER_TYPE Buffer, uint16_t Length __CALLBACK_PARAM) uint8_t TEMPLATE_FUNC_NAME (TEMPLATE_BUFFER_TYPE Buffer,
uint16_t Length
__CALLBACK_PARAM)
{ {
uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
uint8_t ErrorCode; uint8_t ErrorCode;

@ -1,4 +1,6 @@
uint8_t TEMPLATE_FUNC_NAME (TEMPLATE_BUFFER_TYPE Buffer, uint16_t Length __CALLBACK_PARAM) uint8_t TEMPLATE_FUNC_NAME (TEMPLATE_BUFFER_TYPE Buffer,
uint16_t Length
__CALLBACK_PARAM)
{ {
uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length)); uint8_t* DataStream = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
uint8_t ErrorCode; uint8_t ErrorCode;

@ -34,6 +34,7 @@
* - The USBtoSerial project now flushes received data via a flush timer, so that several bytes can be transmitted at once * - The USBtoSerial project now flushes received data via a flush timer, so that several bytes can be transmitted at once
* - Removed the automated checking of event names in the demo, project and bootloader makefiles due to inconsistancies between the * - Removed the automated checking of event names in the demo, project and bootloader makefiles due to inconsistancies between the
* behaviour of the command line tools used to perform the check on each platform * behaviour of the command line tools used to perform the check on each platform
* - Internal USB driver source files renamed and moved to ease future possible architecture ports
* *
* <b>Fixed:</b> * <b>Fixed:</b>
* - Fixed AVRISP project sending a LOAD EXTENDED ADDRESS command to 128KB AVRs after programming or reading from * - Fixed AVRISP project sending a LOAD EXTENDED ADDRESS command to 128KB AVRs after programming or reading from

@ -33,7 +33,8 @@
volatile SchedulerDelayCounter_t Scheduler_TickCounter; volatile SchedulerDelayCounter_t Scheduler_TickCounter;
volatile uint8_t Scheduler_TotalTasks; volatile uint8_t Scheduler_TotalTasks;
bool Scheduler_HasDelayElapsed(const uint16_t Delay, SchedulerDelayCounter_t* const DelayCounter) bool Scheduler_HasDelayElapsed(const uint16_t Delay,
SchedulerDelayCounter_t* const DelayCounter)
{ {
SchedulerDelayCounter_t CurrentTickValue_LCL; SchedulerDelayCounter_t CurrentTickValue_LCL;
SchedulerDelayCounter_t DelayCounter_LCL; SchedulerDelayCounter_t DelayCounter_LCL;
@ -65,7 +66,8 @@ bool Scheduler_HasDelayElapsed(const uint16_t Delay, SchedulerDelayCounter_t* co
return false; return false;
} }
void Scheduler_SetTaskMode(const TaskPtr_t Task, const bool TaskStatus) void Scheduler_SetTaskMode(const TaskPtr_t Task,
const bool TaskStatus)
{ {
TaskEntry_t* CurrTask = &Scheduler_TaskList[0]; TaskEntry_t* CurrTask = &Scheduler_TaskList[0];
@ -81,7 +83,8 @@ void Scheduler_SetTaskMode(const TaskPtr_t Task, const bool TaskStatus)
} }
} }
void Scheduler_SetGroupTaskMode(const uint8_t GroupID, const bool TaskStatus) void Scheduler_SetGroupTaskMode(const uint8_t GroupID,
const bool TaskStatus)
{ {
TaskEntry_t* CurrTask = &Scheduler_TaskList[0]; TaskEntry_t* CurrTask = &Scheduler_TaskList[0];

@ -239,7 +239,8 @@
* \param[in] Task Name of the task whose status is to be changed. * \param[in] Task Name of the task whose status is to be changed.
* \param[in] TaskStatus New task status for the task (\ref TASK_RUN or \ref TASK_STOP). * \param[in] TaskStatus New task status for the task (\ref TASK_RUN or \ref TASK_STOP).
*/ */
void Scheduler_SetTaskMode(const TaskPtr_t Task, const bool TaskStatus); void Scheduler_SetTaskMode(const TaskPtr_t Task,
const bool TaskStatus);
/** Sets the task mode for a given task group ID, allowing for an entire group of tasks to have their /** Sets the task mode for a given task group ID, allowing for an entire group of tasks to have their
* statuses changed at once. * statuses changed at once.
@ -247,7 +248,8 @@
* \param[in] GroupID Value of the task group ID whose status is to be changed. * \param[in] GroupID Value of the task group ID whose status is to be changed.
* \param[in] TaskStatus New task status for tasks in the specified group (\ref TASK_RUN or \ref TASK_STOP). * \param[in] TaskStatus New task status for tasks in the specified group (\ref TASK_RUN or \ref TASK_STOP).
*/ */
void Scheduler_SetGroupTaskMode(const uint8_t GroupID, const bool TaskStatus); void Scheduler_SetGroupTaskMode(const uint8_t GroupID,
const bool TaskStatus);
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)

@ -51,7 +51,7 @@ LUFA_SRC_SCHEDULER = $(LUFA_ROOT_PATH)/Scheduler/Scheduler.c
# Check to see if the LUFA_PATH variable has not been set (the makefile is not being included from a project makefile) # Check to see if the LUFA_PATH variable has not been set (the makefile is not being included from a project makefile)
ifeq ($(origin LUFA_PATH), undefined) ifeq ($(origin LUFA_PATH), undefined)
LUFA_SRC_FILES = $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS) \ LUFA_SRC_ALL_FILES = $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS) \
$(LUFA_SRC_TEMPERATURE) $(LUFA_SRC_SERIAL) \ $(LUFA_SRC_TEMPERATURE) $(LUFA_SRC_SERIAL) \
$(LUFA_SRC_SERIALSTREAM) $(LUFA_SRC_TWI) \ $(LUFA_SRC_SERIALSTREAM) $(LUFA_SRC_TWI) \
$(LUFA_SRC_SCHEDULER) $(LUFA_SRC_SCHEDULER)
@ -59,7 +59,7 @@ ifeq ($(origin LUFA_PATH), undefined)
all: all:
clean: clean:
rm -f $(LUFA_SRC_FILES:%.c=%.o) rm -f $(LUFA_SRC_ALL_FILES:%.c=%.o)
clean_list: clean_list:

@ -73,7 +73,7 @@
/* Function Prototypes: */ /* Function Prototypes: */
#if defined(USB_CAN_BE_DEVICE) #if defined(USB_CAN_BE_DEVICE)
bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo); bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
#if defined(INCLUDE_FROM_SCSI_C) #if defined(INCLUDE_FROM_SCSI_C)
static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo); static void SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);

Loading…
Cancel
Save