forksand
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added const modifiers to device mode class drivers.

Browse Source 
Added parameter directions to function parameter documentation.

Added new experimental FAST_STREAM_FUNCTIONS compile time option to speed up stream transfers at the expense of a higher FLASH consumption (needs testing to verify improved throughput).
pull/1469/head
Dean Camera 15 years ago
parent 3cbdcd3686
commit f1076ac4d6
115 changed files with 1031 additions and 633 deletions
Show Stats Download Patch File Download Diff File

4
Bootloaders/CDC/BootloaderCDC.c
Unescape View File

@ -206,7 +206,7 @@ void EVENT_USB_UnhandledControlPacket(void)
/** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
* on the AVR910 protocol command issued.
*
* \param Command Single character AVR910 protocol command indicating what memory operation to perform
* \param[in] Command Single character AVR910 protocol command indicating what memory operation to perform
*/
static void ReadWriteMemoryBlock(const uint8_t Command)
{
@ -343,7 +343,7 @@ static uint8_t FetchNextCommandByte(void)
/** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
* bank when full ready for the next byte in the packet to the host.
*
* \param Response Next response byte to send to the host
* \param[in] Response Next response byte to send to the host
*/
static void WriteNextResponseByte(const uint8_t Response)
{

2
Bootloaders/CDC/Descriptors.h
Unescape View File

@ -84,7 +84,7 @@
* type define so that the same macro can be used for functional descriptors of varying data lengths,
* while allowing the sizeof() operator to return correct results.
*
* \param DataSize Size of the functional descriptor's data payload, in bytes
* \param[in] DataSize Size of the functional descriptor's data payload, in bytes
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

2
Bootloaders/DFU/BootloaderDFU.c
Unescape View File

@ -454,7 +454,7 @@ void EVENT_USB_UnhandledControlPacket(void)
/** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
* discard unused bytes in the stream from the host, including the memory program block suffix.
*
* \param NumberOfBytes Number of bytes to discard from the host from the control endpoint
* \param[in] NumberOfBytes Number of bytes to discard from the host from the control endpoint
*/
static void DiscardFillerBytes(uint8_t NumberOfBytes)
{

10
Bootloaders/DFU/BootloaderDFU.h
Unescape View File

@ -76,16 +76,16 @@
/** Convenience macro, used to determine if the issued command is the given one-byte long command.
*
* \param dataarr Command byte array to check against
* \param cb1 First command byte to check
* \param[in] dataarr Command byte array to check against
* \param[in] cb1 First command byte to check
*/
#define IS_ONEBYTE_COMMAND(dataarr, cb1) (dataarr[0] == cb1)
/** Convenience macro, used to determine if the issued command is the given two-byte long command.
*
* \param dataarr Command byte array to check against
* \param cb1 First command byte to check
* \param cb2 Second command byte to check
* \param[in] dataarr Command byte array to check against
* \param[in] cb1 First command byte to check
* \param[in] cb2 Second command byte to check
*/
#define IS_TWOBYTE_COMMAND(dataarr, cb1, cb2) ((dataarr[0] == cb1) && (dataarr[1] == cb2))

20
Demos/Device/ClassDriver/GenericHID/GenericHID.c
Unescape View File

@ -131,13 +131,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** HID class driver callback function for the creation of HID reports to the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param ReportData Pointer to a buffer where the created report should be stored
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in,out] ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param[out] ReportData Pointer to a buffer where the created report should be stored
*
* \return Number of bytes written in the report (or zero if no report is to be sent
*/
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
{
// Create generic HID report here
@ -146,13 +146,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
/** HID class driver callback function for the processing of HID reports from the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID of the received report from the host
* \param ReportData Pointer to a buffer where the created report has been stored
* \param ReportSize Size in bytes of the received HID report
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in] ReportID Report ID of the received report from the host
* \param[in] ReportData Pointer to a buffer where the created report has been stored
* \param[in] ReportSize Size in bytes of the received HID report
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize)
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize)
{
// Process received generic HID report here
}

6
Demos/Device/ClassDriver/GenericHID/GenericHID.h
Unescape View File

@ -72,9 +72,9 @@
void EVENT_USB_ConfigurationChanged(void);
void EVENT_USB_UnhandledControlPacket(void);
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
void* ReportData);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize);
#endif

20
Demos/Device/ClassDriver/Joystick/Joystick.c
Unescape View File

@ -133,13 +133,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** HID class driver callback function for the creation of HID reports to the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param ReportData Pointer to a buffer where the created report should be stored
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in,out] ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param[out] ReportData Pointer to a buffer where the created report should be stored
*
* \return Number of bytes written in the report (or zero if no report is to be sent
*/
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
{
USB_JoystickReport_Data_t* JoystickReport = (USB_JoystickReport_Data_t*)ReportData;
@ -167,13 +167,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
/** HID class driver callback function for the processing of HID reports from the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID of the received report from the host
* \param ReportData Pointer to a buffer where the created report has been stored
* \param ReportSize Size in bytes of the received HID report
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in] ReportID Report ID of the received report from the host
* \param[in] ReportData Pointer to a buffer where the created report has been stored
* \param[in] ReportSize Size in bytes of the received HID report
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize)
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize)
{
// Unused (but mandatory for the HID class driver) in this demo, since there are no Host->Device reports
}

6
Demos/Device/ClassDriver/Joystick/Joystick.h
Unescape View File

@ -83,9 +83,9 @@
void EVENT_USB_ConfigurationChanged(void);
void EVENT_USB_UnhandledControlPacket(void);
uint16_t CALLBACK_HID_Device_CreateNextHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,
uint16_t CALLBACK_HID_Device_CreateNextHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
void* ReportData);
void CALLBACK_HID_Device_ProcessReceivedHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize);
void CALLBACK_HID_Device_ProcessReceivedHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize);
#endif

20
Demos/Device/ClassDriver/Keyboard/Keyboard.c
Unescape View File

@ -134,13 +134,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** HID class driver callback function for the creation of HID reports to the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param ReportData Pointer to a buffer where the created report should be stored
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in,out] ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param[out] ReportData Pointer to a buffer where the created report should be stored
*
* \return Number of bytes written in the report (or zero if no report is to be sent
*/
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
{
USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;
@ -168,13 +168,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
/** HID class driver callback function for the processing of HID reports from the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID of the received report from the host
* \param ReportData Pointer to a buffer where the created report has been stored
* \param ReportSize Size in bytes of the received HID report
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in] ReportID Report ID of the received report from the host
* \param[in] ReportData Pointer to a buffer where the created report has been stored
* \param[in] ReportSize Size in bytes of the received HID report
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize)
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize)
{
uint8_t LEDMask = LEDS_NO_LEDS;
uint8_t* LEDReport = (uint8_t*)ReportData;

6
Demos/Device/ClassDriver/Keyboard/Keyboard.h
Unescape View File

@ -86,9 +86,9 @@
void EVENT_USB_ConfigurationChanged(void);
void EVENT_USB_UnhandledControlPacket(void);
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
void* ReportData);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize);
#endif

20
Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.c
Unescape View File

@ -165,13 +165,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** HID class driver callback function for the creation of HID reports to the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param ReportData Pointer to a buffer where the created report should be stored
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in,out] ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param[out] ReportData Pointer to a buffer where the created report should be stored
*
* \return Number of bytes written in the report (or zero if no report is to be sent
*/
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
{
uint8_t JoyStatus_LCL = Joystick_GetStatus();
uint8_t ButtonStatus_LCL = Buttons_GetStatus();
@ -226,13 +226,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
/** HID class driver callback function for the processing of HID reports from the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID of the received report from the host
* \param ReportData Pointer to a buffer where the created report has been stored
* \param ReportSize Size in bytes of the received HID report
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in] ReportID Report ID of the received report from the host
* \param[in] ReportData Pointer to a buffer where the created report has been stored
* \param[in] ReportSize Size in bytes of the received HID report
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize)
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize)
{
if (HIDInterfaceInfo == &Keyboard_HID_Interface)
{

6
Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.h
Unescape View File

@ -90,9 +90,9 @@
void EVENT_USB_ConfigurationChanged(void);
void EVENT_USB_UnhandledControlPacket(void);
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
void* ReportData);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize);
#endif

24
Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c
Unescape View File

@ -43,9 +43,9 @@
* the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
* them to the dataflash in Dataflash page sized blocks.
*
* \param MSInterfaceInfo Pointer to a Mass Storage class state structure for the Mass Storage interface being used
* \param BlockAddress Data block starting address for the write sequence
* \param TotalBlocks Number of blocks of data to write
* \param[in] MSInterfaceInfo Pointer to a Mass Storage class state structure for the Mass Storage interface being used
* \param[in] BlockAddress Data block starting address for the write sequence
* \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)
{
@ -169,9 +169,9 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, co
* the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
* and writes them in OS sized blocks to the endpoint.
*
* \param MSInterfaceInfo Pointer to a Mass Storage class state structure for the Mass Storage interface being used
* \param BlockAddress Data block starting address for the read sequence
* \param TotalBlocks Number of blocks of data to read
* \param[in] MSInterfaceInfo Pointer to a Mass Storage class state structure for the Mass Storage interface being used
* \param[in] BlockAddress Data block starting address for the read sequence
* \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)
{
@ -273,9 +273,9 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, con
* dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* dataflash.
*
* \param BlockAddress Data block starting address for the write sequence
* \param TotalBlocks Number of blocks of data to write
* \param BufferPtr Pointer to the data source RAM buffer
* \param[in] BlockAddress Data block starting address for the write sequence
* \param[in] TotalBlocks Number of blocks of data to write
* \param[in] BufferPtr Pointer to the data source RAM buffer
*/
void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)
{
@ -365,9 +365,9 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t Tota
* and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
* the files stored on the dataflash.
*
* \param BlockAddress Data block starting address for the read sequence
* \param TotalBlocks Number of blocks of data to read
* \param BufferPtr Pointer to the data destination RAM buffer
* \param[in] BlockAddress Data block starting address for the read sequence
* \param[in] TotalBlocks Number of blocks of data to read
* \param[out] BufferPtr Pointer to the data destination RAM buffer
*/
void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)
{

14
Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c
Unescape View File

@ -84,7 +84,7 @@ SCSI_Request_Sense_Response_t SenseData =
* to the appropriate SCSI command handling routine if the issued command is supported by the device, else it returns
* a command failure due to a ILLEGAL REQUEST.
*
* \param 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)
{
@ -142,7 +142,7 @@ bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
/** Command processing for an issued SCSI INQUIRY command. This command returns information about the device's features
* and capabilities to the host.
*
* \param 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
*
* \return Boolean true if the command completed successfully, false otherwise.
*/
@ -184,7 +184,7 @@ static bool SCSI_Command_Inquiry(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
/** Command processing for an issued SCSI REQUEST SENSE command. This command returns information about the last issued command,
* including the error code and additional error information so that the host can determine why a command failed to complete.
*
* \param 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
*
* \return Boolean true if the command completed successfully, false otherwise.
*/
@ -208,7 +208,7 @@ static bool SCSI_Command_Request_Sense(USB_ClassInfo_MS_Device_t* MSInterfaceInf
/** Command processing for an issued SCSI READ CAPACITY (10) command. This command returns information about the device's capacity
* on the selected Logical Unit (drive), as a number of OS-sized blocks.
*
* \param 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
*
* \return Boolean true if the command completed successfully, false otherwise.
*/
@ -231,7 +231,7 @@ static bool SCSI_Command_Read_Capacity_10(USB_ClassInfo_MS_Device_t* MSInterface
* board, and indicates if they are present and functioning correctly. Only the Self-Test portion of the diagnostic command is
* supported.
*
* \param 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
*
* \return Boolean true if the command completed successfully, false otherwise.
*/
@ -296,8 +296,8 @@ static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* MSInterfaceI
* and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
* reading and writing of the data.
*
* \param MSInterfaceInfo Pointer to the Mass Storage class interface structure that the command is associated with
* \param IsDataRead Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)
* \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)
*
* \return Boolean true if the command completed successfully, false otherwise.
*/

6
Demos/Device/ClassDriver/MassStorage/Lib/SCSI.h
Unescape View File

@ -53,9 +53,9 @@
* is for convenience, as it allows for all three sense values (returned upon request to the host to give information about
* the last command failure) in a quick and easy manner.
*
* \param key New SCSI sense key to set the sense code to
* \param acode New SCSI additional sense key to set the additional sense code to
* \param aqual New SCSI additional sense key qualifier to set the additional sense qualifier code to
* \param[in] key New SCSI sense key to set the sense code to
* \param[in] acode New SCSI additional sense key to set the additional sense code to
* \param[in] aqual New SCSI additional sense key qualifier to set the additional sense qualifier code to
*/
#define SCSI_SET_SENSE(key, acode, aqual) MACROS{ SenseData.SenseKey = key; \
SenseData.AdditionalSenseCode = acode; \

2
Demos/Device/ClassDriver/MassStorage/MassStorage.c
Unescape View File

@ -125,7 +125,7 @@ void EVENT_USB_UnhandledControlPacket(void)
/** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.
*
* \param MSInterfaceInfo Pointer to the Mass Storage class interface configuration structure being referenced
* \param[in] MSInterfaceInfo Pointer to the Mass Storage class interface configuration structure being referenced
*/
bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
{

20
Demos/Device/ClassDriver/Mouse/Mouse.c
Unescape View File

@ -133,13 +133,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** HID class driver callback function for the creation of HID reports to the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param ReportData Pointer to a buffer where the created report should be stored
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in,out] ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param[out] ReportData Pointer to a buffer where the created report should be stored
*
* \return Number of bytes written in the report (or zero if no report is to be sent
*/
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
{
USB_MouseReport_Data_t* MouseReport = (USB_MouseReport_Data_t*)ReportData;
@ -167,13 +167,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
/** HID class driver callback function for the processing of HID reports from the host.
*
* \param HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param ReportID Report ID of the received report from the host
* \param ReportData Pointer to a buffer where the created report has been stored
* \param ReportSize Size in bytes of the received HID report
* \param[in] HIDInterfaceInfo Pointer to the HID class interface configuration structure being referenced
* \param[in] ReportID Report ID of the received report from the host
* \param[in] ReportData Pointer to a buffer where the created report has been stored
* \param[in] ReportSize Size in bytes of the received HID report
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize)
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize)
{
// Unused (but mandatory for the HID class driver) in this demo, since there are no Host->Device reports
}

6
Demos/Device/ClassDriver/Mouse/Mouse.h
Unescape View File

@ -85,9 +85,9 @@
void EVENT_USB_ConfigurationChanged(void);
void EVENT_USB_UnhandledControlPacket(void);
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,
uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
void* ReportData);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize);
#endif

2
Demos/Device/ClassDriver/RNDISEthernet/Descriptors.h
Unescape View File

@ -47,7 +47,7 @@
* a single typedef struct. A macro is used instead so that functional descriptors can be created
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
*
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

4
Demos/Device/ClassDriver/RNDISEthernet/Lib/ARP.c
Unescape View File

@ -41,8 +41,8 @@
* to the output Ethernet frame if the host is requesting the IP or MAC address of the
* virtual server device on the network.
*
* \param InDataStart Pointer to the start of the incoming packet's ARP header
* \param OutDataStart Pointer to the start of the outgoing packet's ARP header
* \param[in] InDataStart Pointer to the start of the incoming packet's ARP header
* \param[out] OutDataStart Pointer to the start of the outgoing packet's ARP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

6
Demos/Device/ClassDriver/RNDISEthernet/Lib/DHCP.c
Unescape View File

@ -40,9 +40,9 @@
/** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if the host is requesting or accepting an IP address.
*
* \param IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param DHCPHeaderInStart Pointer to the start of the incoming packet's DHCP header
* \param DHCPHeaderOutStart Pointer to the start of the outgoing packet's DHCP header
* \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param[in] DHCPHeaderInStart Pointer to the start of the incoming packet's DHCP header
* \param[out] DHCPHeaderOutStart Pointer to the start of the outgoing packet's DHCP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

4
Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c
Unescape View File

@ -110,8 +110,8 @@ void Ethernet_ProcessPacket(Ethernet_Frame_Info_t* FrameIN, Ethernet_Frame_Info_
/** Calculates the appropriate ethernet checksum, consisting of the addition of the one's
* compliment of each word, complimented.
*
* \param Data Pointer to the packet buffer data whose checksum must be calculated
* \param Bytes Number of bytes in the data buffer to process
* \param[in] Data Pointer to the packet buffer data whose checksum must be calculated
* \param[in] Bytes Number of bytes in the data buffer to process
*
* \return A 16-bit Ethernet checksum value
*/

4
Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.h
Unescape View File

@ -63,8 +63,8 @@
/** Performs a comparison between two MAC addresses, indicating if they are identical.
*
* \param MAC1 First MAC address
* \param MAC2 Second MAC address
* \param[in] MAC1 First MAC address
* \param[in] MAC2 Second MAC address
*
* \return True if the addresses match, false otherwise
*/

6
Demos/Device/ClassDriver/RNDISEthernet/Lib/ICMP.c
Unescape View File

@ -40,9 +40,9 @@
/** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if the host is issuing a ICMP ECHO request.
*
* \param FrameIN Pointer to the incomming Ethernet frame information structure
* \param InDataStart Pointer to the start of the incoming packet's ICMP header
* \param OutDataStart Pointer to the start of the outgoing packet's ICMP header
* \param[in] FrameIN Pointer to the incomming Ethernet frame information structure
* \param[in] InDataStart Pointer to the start of the incoming packet's ICMP header
* \param[out] OutDataStart Pointer to the start of the outgoing packet's ICMP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

6
Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.c
Unescape View File

@ -39,9 +39,9 @@
/** Processes an IP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if one is created by a subprotocol handler.
*
* \param FrameIN Pointer to the incomming Ethernet frame information structure
* \param InDataStart Pointer to the start of the incoming packet's IP header
* \param OutDataStart Pointer to the start of the outgoing packet's IP header
* \param[in] FrameIN Pointer to the incomming Ethernet frame information structure
* \param[in] InDataStart Pointer to the start of the incoming packet's IP header
* \param[out] OutDataStart Pointer to the start of the outgoing packet's IP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
* response was generated, NO_PROCESS if the packet processing was deferred until the

4
Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.h
Unescape View File

@ -59,8 +59,8 @@
/** Performs a comparison between two IP addresses, indicating if they are identical.
*
* \param IP1 First IP address
* \param IP2 Second IP address
* \param[in] IP1 First IP address
* \param[in] IP2 Second IP address
*
* \return True if the addresses match, false otherwise
*/

14
Demos/Device/ClassDriver/RNDISEthernet/Lib/ProtocolDecoders.c
Unescape View File

@ -51,7 +51,7 @@
/** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an Ethernet frame header
* \param[in] InDataStart Pointer to the start of an Ethernet frame header
*/
void DecodeEthernetFrameHeader(void* InDataStart)
{
@ -93,7 +93,7 @@ void DecodeEthernetFrameHeader(void* InDataStart)
/** Decodes an ARP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an ARP packet header
* \param[in] InDataStart Pointer to the start of an ARP packet header
*/
void DecodeARPHeader(void* InDataStart)
{
@ -143,7 +143,7 @@ void DecodeARPHeader(void* InDataStart)
/** Decodes an IP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an IP packet header
* \param[in] InDataStart Pointer to the start of an IP packet header
*/
void DecodeIPHeader(void* InDataStart)
{
@ -181,7 +181,7 @@ void DecodeIPHeader(void* InDataStart)
/** Decodes an ICMP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an ICMP packet header
* \param[in] InDataStart Pointer to the start of an ICMP packet header
*/
void DecodeICMPHeader(void* InDataStart)
{
@ -197,7 +197,7 @@ void DecodeICMPHeader(void* InDataStart)
/** Decodes a TCP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of a TCP packet header
* \param[in] InDataStart Pointer to the start of a TCP packet header
*/
void DecodeTCPHeader(void* InDataStart)
{
@ -225,7 +225,7 @@ void DecodeTCPHeader(void* InDataStart)
/** Decodes an UDP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of a UDP packet header
* \param[in] InDataStart Pointer to the start of a UDP packet header
*/
void DecodeUDPHeader(void* InDataStart)
{
@ -243,7 +243,7 @@ void DecodeUDPHeader(void* InDataStart)
/** Decodes an DHCP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of a DHCP packet header
* \param[in] InDataStart Pointer to the start of a DHCP packet header
*/
void DecodeDHCPHeader(void* InDataStart)
{

42
Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.c
Unescape View File

@ -171,9 +171,9 @@ void TCP_Init(void)
/** Sets the state and callback handler of the given port, specified in big endian to the given state.
*
* \param Port Port whose state and callback function to set, specified in big endian
* \param State New state of the port, a value from the TCP_PortStates_t enum
* \param Handler Application callback handler for the port
* \param[in] Port Port whose state and callback function to set, specified in big endian
* \param[in] State New state of the port, a value from the TCP_PortStates_t enum
* \param[in] Handler Application callback handler for the port
*
* \return Boolean true if the port state was set, false otherwise (no more space in the port state table)
*/
@ -220,7 +220,7 @@ bool TCP_SetPortState(uint16_t Port, uint8_t State, void (*Handler)(TCP_Connecti
/** Retrieves the current state of a given TCP port, specified in big endian.
*
* \param Port TCP port whose state is to be retrieved, given in big-endian
* \param[in] Port TCP port whose state is to be retrieved, given in big-endian
*
* \return A value from the TCP_PortStates_t enum
*/
@ -242,10 +242,10 @@ uint8_t TCP_GetPortState(uint16_t Port)
/** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the
* connection exists in the connection state table it is updated, otherwise it is created if possible.
*
* \param Port TCP port of the connection on the device, specified in big endian
* \param RemoteAddress Remote protocol IP address of the connected device
* \param RemotePort TCP port of the remote device in the connection, specified in big endian
* \param State TCP connection state, a value from the TCP_ConnectionStates_t enum
* \param[in] Port TCP port of the connection on the device, specified in big endian
* \param[in] RemoteAddress Remote protocol IP address of the connected device
* \param[in] RemotePort TCP port of the remote device in the connection, specified in big endian
* \param[in] State TCP connection state, a value from the TCP_ConnectionStates_t enum
*
* \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)
*/
@ -283,9 +283,9 @@ bool TCP_SetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t
/** Retrieves the current state of a given TCP connection to a host.
*
* \param Port TCP port on the device in the connection, specified in big endian
* \param RemoteAddress Remote protocol IP address of the connected host
* \param RemotePort Remote TCP port of the connected host, specified in big endian
* \param[in] Port TCP port on the device in the connection, specified in big endian
* \param[in] RemoteAddress Remote protocol IP address of the connected host
* \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
*
* \return A value from the TCP_ConnectionStates_t enum
*/
@ -310,9 +310,9 @@ uint8_t TCP_GetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16
/** Retrieves the connection info structure of a given connection to a host.
*
* \param Port TCP port on the device in the connection, specified in big endian
* \param RemoteAddress Remote protocol IP address of the connected host
* \param RemotePort Remote TCP port of the connected host, specified in big endian
* \param[in] Port TCP port on the device in the connection, specified in big endian
* \param[in] RemoteAddress Remote protocol IP address of the connected host
* \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
*
* \return ConnectionInfo structure of the connection if found, NULL otherwise
*/
@ -337,9 +337,9 @@ TCP_ConnectionInfo_t* TCP_GetConnectionInfo(uint16_t Port, IP_Address_t RemoteAd
/** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if one is created by a application handler.
*
* \param IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param TCPHeaderInStart Pointer to the start of the incoming packet's TCP header
* \param TCPHeaderOutStart Pointer to the start of the outgoing packet's TCP header
* \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param[in] TCPHeaderInStart Pointer to the start of the incoming packet's TCP header
* \param[out] TCPHeaderOutStart Pointer to the start of the outgoing packet's TCP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
* response was generated, NO_PROCESS if the packet processing was deferred until the
@ -579,10 +579,10 @@ int16_t TCP_ProcessTCPPacket(void* IPHeaderInStart, void* TCPHeaderInStart, void
/** Calculates the appropriate TCP checksum, consisting of the addition of the one's compliment of each word,
* complimented.
*
* \param TCPHeaderOutStart Pointer to the start of the packet's outgoing TCP header
* \param SourceAddress Source protocol IP address of the outgoing IP header
* \param DestinationAddress Destination protocol IP address of the outgoing IP header
* \param TCPOutSize Size in bytes of the TCP data header and payload
* \param[in] TCPHeaderOutStart Pointer to the start of the packet's outgoing TCP header
* \param[in] SourceAddress Source protocol IP address of the outgoing IP header
* \param[in] DestinationAddress Destination protocol IP address of the outgoing IP header
* \param[in] TCPOutSize Size in bytes of the TCP data header and payload
*
* \return A 16-bit TCP checksum value
*/

18
Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.h
Unescape View File

@ -89,7 +89,7 @@
/** Application macro: Determines if the given application buffer contains a packet received from the host
*
* \param Buffer Application buffer to check
* \param[in] Buffer Application buffer to check
*
* \return Boolean true if the buffer contains a packet from the host, false otherwise
*/
@ -97,7 +97,7 @@
/** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.
*
* \param Buffer Application buffer to check
* \param[in] Buffer Application buffer to check
*
* \return Boolean true if the buffer has been captured by the application for device-to-host transmissions, false otherwise
*/
@ -106,7 +106,7 @@
/** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.
*
* \param Buffer Application buffer to check
* \param[in] Buffer Application buffer to check
*
* \return Boolean true if the buffer may be captured by the application for device-to-host transmissions, false otherwise
*/
@ -117,32 +117,32 @@
*
* \note The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().
*
* \param Buffer Application buffer to lock
* \param[in] Buffer Application buffer to lock
*/
#define TCP_APP_CAPTURE_BUFFER(Buffer) MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; }MACROE
/** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.
*
* \param Buffer Application buffer to release
* \param[in] Buffer Application buffer to release
*/
#define TCP_APP_RELEASE_BUFFER(Buffer) MACROS{ Buffer->InUse = false; }MACROE
/** Application macro: Sends the contents of the given application buffer to the host.
*
* \param Buffer Application buffer to send
* \param Len Length of data contained in the buffer
* \param[in] Buffer Application buffer to send
* \param[in] Len Length of data contained in the buffer
*/
#define TCP_APP_SEND_BUFFER(Buffer, Len) MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; }MACROE
/** Application macro: Clears the application buffer, ready for a packet to be written to it.
*
* \param Buffer Application buffer to clear
* \param[in] Buffer Application buffer to clear
*/
#define TCP_APP_CLEAR_BUFFER(Buffer) MACROS{ Buffer->Ready = false; Buffer->Length = 0; }MACROE
/** Application macro: Closes an open connection to a host.
*
* \param Connection Open TCP connection to close
* \param[in] Connection Open TCP connection to close
*/
#define TCP_APP_CLOSECONNECTION(Connection) MACROS{ Connection->State = TCP_Connection_Closing; }MACROE

6
Demos/Device/ClassDriver/RNDISEthernet/Lib/UDP.c
Unescape View File

@ -40,9 +40,9 @@
/** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if a subprotocol handler has created a response packet.
*
* \param IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param UDPHeaderInStart Pointer to the start of the incoming packet's UDP header
* \param UDPHeaderOutStart Pointer to the start of the outgoing packet's UDP header
* \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param[in] UDPHeaderInStart Pointer to the start of the incoming packet's UDP header
* \param[out] UDPHeaderOutStart Pointer to the start of the outgoing packet's UDP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

8
Demos/Device/ClassDriver/RNDISEthernet/Lib/Webserver.c
Unescape View File

@ -78,8 +78,8 @@ void Webserver_Init(void)
/** Indicates if a given request equals the given HTTP command.
*
* \param RequestHeader HTTP request made by the host
* \param Command HTTP command to compare the request to
* \param[in] RequestHeader HTTP request made by the host
* \param[in] Command HTTP command to compare the request to
*
* \return Boolean true if the command matches the request, false otherwise
*/
@ -92,8 +92,8 @@ static bool IsHTTPCommand(uint8_t* RequestHeader, char* Command)
/** Application callback routine, executed each time the TCP processing task runs. This callback determines what request
* has been made (if any), and serves up appropriate responses.
*
* \param ConnectionState Pointer to a TCP Connection State structure giving connection information
* \param Buffer Pointer to the application's send/receive packet buffer
* \param[in] ConnectionState Pointer to a TCP Connection State structure giving connection information
* \param[in,out] Buffer Pointer to the application's send/receive packet buffer
*/
void Webserver_ApplicationCallback(TCP_ConnectionState_t* ConnectionState, TCP_ConnectionBuffer_t* Buffer)
{

4
Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.c
Unescape View File

@ -158,9 +158,9 @@ ISR(USART1_RX_vect, ISR_BLOCK)
/** Event handler for the CDC Class driver Line Encoding Changed event.
*
* \param CDCInterfaceInfo Pointer to the CDC class interface configuration structure being referenced
* \param[in] CDCInterfaceInfo Pointer to the CDC class interface configuration structure being referenced
*/
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
uint8_t ConfigMask = 0;

2
Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.h
Unescape View File

@ -74,6 +74,6 @@
void EVENT_USB_ConfigurationChanged(void);
void EVENT_USB_UnhandledControlPacket(void);
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
#endif

2
Demos/Device/LowLevel/AudioInput/Descriptors.h
Unescape View File

@ -123,7 +123,7 @@
/** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.
*
* \param freq Required audio sampling frequency in HZ
* \param[in] freq Required audio sampling frequency in HZ
*/
#define SAMPLE_FREQ(freq) {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}

2
Demos/Device/LowLevel/AudioOutput/Descriptors.h
Unescape View File

@ -123,7 +123,7 @@
/** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.
*
* \param freq Required audio sampling frequency in HZ
* \param[in] freq Required audio sampling frequency in HZ
*/
#define SAMPLE_FREQ(freq) {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}

2
Demos/Device/LowLevel/CDC/Descriptors.h
Unescape View File

@ -47,7 +47,7 @@
* a single typedef struct. A macro is used instead so that functional descriptors can be created
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
*
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

2
Demos/Device/LowLevel/DualCDC/Descriptors.h
Unescape View File

@ -47,7 +47,7 @@
* a single typedef struct. A macro is used instead so that functional descriptors can be created
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
*
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

4
Demos/Device/LowLevel/GenericHID/GenericHID.c
Unescape View File

@ -170,7 +170,7 @@ void EVENT_USB_UnhandledControlPacket(void)
/** Function to process the lest received report from the host.
*
* \param DataArray Pointer to a buffer where the last report data is stored
* \param[in] DataArray Pointer to a buffer where the last report data is stored
*/
void ProcessGenericHIDReport(uint8_t* DataArray)
{
@ -186,7 +186,7 @@ void ProcessGenericHIDReport(uint8_t* DataArray)
/** Function to create the next report to send back to the host at the next reporting interval.
*
* \param DataArray Pointer to a buffer where the next report data should be stored
* \param[out] DataArray Pointer to a buffer where the next report data should be stored
*/
void CreateGenericHIDReport(uint8_t* DataArray)
{

2
Demos/Device/LowLevel/Joystick/Joystick.c
Unescape View File

@ -136,7 +136,7 @@ void EVENT_USB_UnhandledControlPacket(void)
/** Fills the given HID report data structure with the next HID report to send to the host.
*
* \param ReportData Pointer to a HID report data structure to be filled
* \param[out] ReportData Pointer to a HID report data structure to be filled
*
* \return Boolean true if the new report differs from the last report, false otherwise
*/

4
Demos/Device/LowLevel/Keyboard/Keyboard.c
Unescape View File

@ -266,7 +266,7 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** Fills the given HID report data structure with the next HID report to send to the host.
*
* \param ReportData Pointer to a HID report data structure to be filled
* \param[out] ReportData Pointer to a HID report data structure to be filled
*/
void CreateKeyboardReport(USB_KeyboardReport_Data_t* ReportData)
{
@ -291,7 +291,7 @@ void CreateKeyboardReport(USB_KeyboardReport_Data_t* ReportData)
/** Processes a received LED report, and updates the board LEDs states to match.
*
* \param LEDReport LED status report from the host
* \param[in] LEDReport LED status report from the host
*/
void ProcessLEDReport(uint8_t LEDReport)
{

2
Demos/Device/LowLevel/MIDI/MIDI.h
Unescape View File

@ -63,7 +63,7 @@
/** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel
* addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.
*
* \param channel MIDI channel number to address
* \param[in] channel MIDI channel number to address
*/
#define MIDI_CHANNEL(channel) (channel - 1)

20
Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c
Unescape View File

@ -43,8 +43,8 @@
* the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
* them to the dataflash in Dataflash page sized blocks.
*
* \param BlockAddress Data block starting address for the write sequence
* \param TotalBlocks Number of blocks of data to write
* \param[in] BlockAddress Data block starting address for the write sequence
* \param[in] TotalBlocks Number of blocks of data to write
*/
void DataflashManager_WriteBlocks(const uint32_t BlockAddress, uint16_t TotalBlocks)
{
@ -168,8 +168,8 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress, uint16_t TotalBlo
* the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
* and writes them in OS sized blocks to the endpoint.
*
* \param BlockAddress Data block starting address for the read sequence
* \param TotalBlocks Number of blocks of data to read
* \param[in] BlockAddress Data block starting address for the read sequence
* \param[in] TotalBlocks Number of blocks of data to read
*/
void DataflashManager_ReadBlocks(const uint32_t BlockAddress, uint16_t TotalBlocks)
{
@ -271,9 +271,9 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress, uint16_t TotalBloc
* dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* dataflash.
*
* \param BlockAddress Data block starting address for the write sequence
* \param TotalBlocks Number of blocks of data to write
* \param BufferPtr Pointer to the data source RAM buffer
* \param[in] BlockAddress Data block starting address for the write sequence
* \param[in] TotalBlocks Number of blocks of data to write
* \param[in] BufferPtr Pointer to the data source RAM buffer
*/
void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)
{
@ -367,9 +367,9 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t Tota
* and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
* the files stored on the dataflash.
*
* \param BlockAddress Data block starting address for the read sequence
* \param TotalBlocks Number of blocks of data to read
* \param BufferPtr Pointer to the data destination RAM buffer
* \param[in] BlockAddress Data block starting address for the read sequence
* \param[in] TotalBlocks Number of blocks of data to read
* \param[out] BufferPtr Pointer to the data destination RAM buffer
*/
void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)
{

2
Demos/Device/LowLevel/MassStorage/Lib/SCSI.c
Unescape View File

@ -302,7 +302,7 @@ static bool SCSI_Command_Send_Diagnostic(void)
* and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
* reading and writing of the data.
*
* \param 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)
*
* \return Boolean true if the command completed successfully, false otherwise.
*/

6
Demos/Device/LowLevel/MassStorage/Lib/SCSI.h
Unescape View File

@ -54,9 +54,9 @@
* is for convenience, as it allows for all three sense values (returned upon request to the host to give information about
* the last command failure) in a quick and easy manner.
*
* \param key New SCSI sense key to set the sense code to
* \param acode New SCSI additional sense key to set the additional sense code to
* \param aqual New SCSI additional sense key qualifier to set the additional sense qualifier code to
* \param[in] key New SCSI sense key to set the sense code to
* \param[in] acode New SCSI additional sense key to set the additional sense code to
* \param[in] aqual New SCSI additional sense key qualifier to set the additional sense qualifier code to
*/
#define SCSI_SET_SENSE(key, acode, aqual) MACROS{ SenseData.SenseKey = key; \
SenseData.AdditionalSenseCode = acode; \

2
Demos/Device/LowLevel/Mouse/Mouse.c
Unescape View File

@ -238,7 +238,7 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** Fills the given HID report data structure with the next HID report to send to the host.
*
* \param ReportData Pointer to a HID report data structure to be filled
* \param[out] ReportData Pointer to a HID report data structure to be filled
*/
void CreateMouseReport(USB_MouseReport_Data_t* ReportData)
{

2
Demos/Device/LowLevel/RNDISEthernet/Descriptors.h
Unescape View File

@ -47,7 +47,7 @@
* a single typedef struct. A macro is used instead so that functional descriptors can be created
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
*
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

4
Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c
Unescape View File

@ -41,8 +41,8 @@
* to the output Ethernet frame if the host is requesting the IP or MAC address of the
* virtual server device on the network.
*
* \param InDataStart Pointer to the start of the incoming packet's ARP header
* \param OutDataStart Pointer to the start of the outgoing packet's ARP header
* \param[in] InDataStart Pointer to the start of the incoming packet's ARP header
* \param[out] OutDataStart Pointer to the start of the outgoing packet's ARP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

6
Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c
Unescape View File

@ -40,9 +40,9 @@
/** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if the host is requesting or accepting an IP address.
*
* \param IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param DHCPHeaderInStart Pointer to the start of the incoming packet's DHCP header
* \param DHCPHeaderOutStart Pointer to the start of the outgoing packet's DHCP header
* \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param[in] DHCPHeaderInStart Pointer to the start of the incoming packet's DHCP header
* \param[out] DHCPHeaderOutStart Pointer to the start of the outgoing packet's DHCP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

4
Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c
Unescape View File

@ -116,8 +116,8 @@ void Ethernet_ProcessPacket(void)
/** Calculates the appropriate ethernet checksum, consisting of the addition of the one's
* compliment of each word, complimented.
*
* \param Data Pointer to the packet buffer data whose checksum must be calculated
* \param Bytes Number of bytes in the data buffer to process
* \param[in] Data Pointer to the packet buffer data whose checksum must be calculated
* \param[in] Bytes Number of bytes in the data buffer to process
*
* \return A 16-bit Ethernet checksum value
*/

4
Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h
Unescape View File

@ -58,8 +58,8 @@
/** Performs a comparison between two MAC addresses, indicating if they are identical.
*
* \param MAC1 First MAC address
* \param MAC2 Second MAC address
* \param[in] MAC1 First MAC address
* \param[in] MAC2 Second MAC address
*
* \return True if the addresses match, false otherwise
*/

4
Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c
Unescape View File

@ -40,8 +40,8 @@
/** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if the host is issuing a ICMP ECHO request.
*
* \param InDataStart Pointer to the start of the incoming packet's ICMP header
* \param OutDataStart Pointer to the start of the outgoing packet's ICMP header
* \param[in] InDataStart Pointer to the start of the incoming packet's ICMP header
* \param[out] OutDataStart Pointer to the start of the outgoing packet's ICMP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

4
Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c
Unescape View File

@ -39,8 +39,8 @@
/** Processes an IP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if one is created by a subprotocol handler.
*
* \param InDataStart Pointer to the start of the incoming packet's IP header
* \param OutDataStart Pointer to the start of the outgoing packet's IP header
* \param[in] InDataStart Pointer to the start of the incoming packet's IP header
* \param[out] OutDataStart Pointer to the start of the outgoing packet's IP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
* response was generated, NO_PROCESS if the packet processing was deferred until the

4
Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h
Unescape View File

@ -59,8 +59,8 @@
/** Performs a comparison between two IP addresses, indicating if they are identical.
*
* \param IP1 First IP address
* \param IP2 Second IP address
* \param[in] IP1 First IP address
* \param[in] IP2 Second IP address
*
* \return True if the addresses match, false otherwise
*/

14
Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c
Unescape View File

@ -51,7 +51,7 @@
/** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an Ethernet frame header
* \param[in] InDataStart Pointer to the start of an Ethernet frame header
*/
void DecodeEthernetFrameHeader(void* InDataStart)
{
@ -93,7 +93,7 @@ void DecodeEthernetFrameHeader(void* InDataStart)
/** Decodes an ARP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an ARP packet header
* \param[in] InDataStart Pointer to the start of an ARP packet header
*/
void DecodeARPHeader(void* InDataStart)
{
@ -143,7 +143,7 @@ void DecodeARPHeader(void* InDataStart)
/** Decodes an IP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an IP packet header
* \param[in] InDataStart Pointer to the start of an IP packet header
*/
void DecodeIPHeader(void* InDataStart)
{
@ -181,7 +181,7 @@ void DecodeIPHeader(void* InDataStart)
/** Decodes an ICMP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of an ICMP packet header
* \param[in] InDataStart Pointer to the start of an ICMP packet header
*/
void DecodeICMPHeader(void* InDataStart)
{
@ -197,7 +197,7 @@ void DecodeICMPHeader(void* InDataStart)
/** Decodes a TCP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of a TCP packet header
* \param[in] InDataStart Pointer to the start of a TCP packet header
*/
void DecodeTCPHeader(void* InDataStart)
{
@ -225,7 +225,7 @@ void DecodeTCPHeader(void* InDataStart)
/** Decodes an UDP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of a UDP packet header
* \param[in] InDataStart Pointer to the start of a UDP packet header
*/
void DecodeUDPHeader(void* InDataStart)
{
@ -243,7 +243,7 @@ void DecodeUDPHeader(void* InDataStart)
/** Decodes an DHCP header and prints its contents to through the USART in a human readable format.
*
* \param InDataStart Pointer to the start of a DHCP packet header
* \param[in] InDataStart Pointer to the start of a DHCP packet header
*/
void DecodeDHCPHeader(void* InDataStart)
{

16
Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c
Unescape View File

@ -232,11 +232,11 @@ void ProcessRNDISControlMessage(void)
/** Processes RNDIS query commands, retrieving information from the adapter and reporting it back to the host. The requested
* parameter is given as an OID value.
*
* \param OId OId value of the parameter being queried
* \param QueryData Pointer to any extra query data being sent by the host to the device inside the RNDIS message buffer
* \param QuerySize Size in bytes of the extra query data being sent by the host
* \param ResponseData Pointer to the start of the query response inside the RNDIS message buffer
* \param ResponseSize Pointer to the size in bytes of the response data being sent to the host
* \param[in] OId OId value of the parameter being queried
* \param[in] QueryData Pointer to any extra query data being sent by the host to the device inside the RNDIS message buffer
* \param[in] QuerySize Size in bytes of the extra query data being sent by the host
* \param[out] ResponseData Pointer to the start of the query response inside the RNDIS message buffer
* \param[out] ResponseSize Pointer to the size in bytes of the response data being sent to the host
*
* \return Boolean true if the query was handled, false otherwise
*/
@ -364,9 +364,9 @@ static bool ProcessNDISQuery(uint32_t OId, void* QueryData, uint16_t QuerySize,
/** Processes RNDIS set commands, setting adapter parameters to values given by the host. The requested parameter is given
* as an OID value.
*
* \param OId OId value of the parameter being set
* \param SetData Pointer to the parameter value in the RNDIS message buffer
* \param SetSize Size in bytes of the parameter value being sent by the host
* \param[in] OId OId value of the parameter being set
* \param[in] SetData Pointer to the parameter value in the RNDIS message buffer
* \param[in] SetSize Size in bytes of the parameter value being sent by the host
*
* \return Boolean true if the set was handled, false otherwise
*/

42
Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c
Unescape View File

@ -171,9 +171,9 @@ void TCP_Init(void)
/** Sets the state and callback handler of the given port, specified in big endian to the given state.
*
* \param Port Port whose state and callback function to set, specified in big endian
* \param State New state of the port, a value from the TCP_PortStates_t enum
* \param Handler Application callback handler for the port
* \param[in] Port Port whose state and callback function to set, specified in big endian
* \param[in] State New state of the port, a value from the TCP_PortStates_t enum
* \param[in] Handler Application callback handler for the port
*
* \return Boolean true if the port state was set, false otherwise (no more space in the port state table)
*/
@ -220,7 +220,7 @@ bool TCP_SetPortState(uint16_t Port, uint8_t State, void (*Handler)(TCP_Connecti
/** Retrieves the current state of a given TCP port, specified in big endian.
*
* \param Port TCP port whose state is to be retrieved, given in big-endian
* \param[in] Port TCP port whose state is to be retrieved, given in big-endian
*
* \return A value from the TCP_PortStates_t enum
*/
@ -242,10 +242,10 @@ uint8_t TCP_GetPortState(uint16_t Port)
/** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the
* connection exists in the connection state table it is updated, otherwise it is created if possible.
*
* \param Port TCP port of the connection on the device, specified in big endian
* \param RemoteAddress Remote protocol IP address of the connected device
* \param RemotePort TCP port of the remote device in the connection, specified in big endian
* \param State TCP connection state, a value from the TCP_ConnectionStates_t enum
* \param[in] Port TCP port of the connection on the device, specified in big endian
* \param[in] RemoteAddress Remote protocol IP address of the connected device
* \param[in] RemotePort TCP port of the remote device in the connection, specified in big endian
* \param[in] State TCP connection state, a value from the TCP_ConnectionStates_t enum
*
* \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)
*/
@ -283,9 +283,9 @@ bool TCP_SetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t
/** Retrieves the current state of a given TCP connection to a host.
*
* \param Port TCP port on the device in the connection, specified in big endian
* \param RemoteAddress Remote protocol IP address of the connected host
* \param RemotePort Remote TCP port of the connected host, specified in big endian
* \param[in] Port TCP port on the device in the connection, specified in big endian
* \param[in] RemoteAddress Remote protocol IP address of the connected host
* \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
*
* \return A value from the TCP_ConnectionStates_t enum
*/
@ -310,9 +310,9 @@ uint8_t TCP_GetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16
/** Retrieves the connection info structure of a given connection to a host.
*
* \param Port TCP port on the device in the connection, specified in big endian
* \param RemoteAddress Remote protocol IP address of the connected host
* \param RemotePort Remote TCP port of the connected host, specified in big endian
* \param[in] Port TCP port on the device in the connection, specified in big endian
* \param[in] RemoteAddress Remote protocol IP address of the connected host
* \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
*
* \return ConnectionInfo structure of the connection if found, NULL otherwise
*/
@ -337,9 +337,9 @@ TCP_ConnectionInfo_t* TCP_GetConnectionInfo(uint16_t Port, IP_Address_t RemoteAd
/** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if one is created by a application handler.
*
* \param IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param TCPHeaderInStart Pointer to the start of the incoming packet's TCP header
* \param TCPHeaderOutStart Pointer to the start of the outgoing packet's TCP header
* \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param[in] TCPHeaderInStart Pointer to the start of the incoming packet's TCP header
* \param[out] TCPHeaderOutStart Pointer to the start of the outgoing packet's TCP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
* response was generated, NO_PROCESS if the packet processing was deferred until the
@ -579,10 +579,10 @@ int16_t TCP_ProcessTCPPacket(void* IPHeaderInStart, void* TCPHeaderInStart, void
/** Calculates the appropriate TCP checksum, consisting of the addition of the one's compliment of each word,
* complimented.
*
* \param TCPHeaderOutStart Pointer to the start of the packet's outgoing TCP header
* \param SourceAddress Source protocol IP address of the outgoing IP header
* \param DestinationAddress Destination protocol IP address of the outgoing IP header
* \param TCPOutSize Size in bytes of the TCP data header and payload
* \param[in] TCPHeaderOutStart Pointer to the start of the packet's outgoing TCP header
* \param[in] SourceAddress Source protocol IP address of the outgoing IP header
* \param[in] DestinationAddress Destination protocol IP address of the outgoing IP header
* \param[in] TCPOutSize Size in bytes of the TCP data header and payload
*
* \return A 16-bit TCP checksum value
*/

18
Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h
Unescape View File

@ -89,7 +89,7 @@
/** Application macro: Determines if the given application buffer contains a packet received from the host
*
* \param Buffer Application buffer to check
* \param[in] Buffer Application buffer to check
*
* \return Boolean true if the buffer contains a packet from the host, false otherwise
*/
@ -97,7 +97,7 @@
/** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.
*
* \param Buffer Application buffer to check
* \param[in] Buffer Application buffer to check
*
* \return Boolean true if the buffer has been captured by the application for device-to-host transmissions, false otherwise
*/
@ -106,7 +106,7 @@
/** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.
*
* \param Buffer Application buffer to check
* \param[in] Buffer Application buffer to check
*
* \return Boolean true if the buffer may be captured by the application for device-to-host transmissions, false otherwise
*/
@ -117,32 +117,32 @@
*
* \note The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().
*
* \param Buffer Application buffer to lock
* \param[in] Buffer Application buffer to lock
*/
#define TCP_APP_CAPTURE_BUFFER(Buffer) MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; }MACROE
/** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.
*
* \param Buffer Application buffer to release
* \param[in] Buffer Application buffer to release
*/
#define TCP_APP_RELEASE_BUFFER(Buffer) MACROS{ Buffer->InUse = false; }MACROE
/** Application macro: Sends the contents of the given application buffer to the host.
*
* \param Buffer Application buffer to send
* \param Len Length of data contained in the buffer
* \param[in] Buffer Application buffer to send
* \param[in] Len Length of data contained in the buffer
*/
#define TCP_APP_SEND_BUFFER(Buffer, Len) MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; }MACROE
/** Application macro: Clears the application buffer, ready for a packet to be written to it.
*
* \param Buffer Application buffer to clear
* \param[in] Buffer Application buffer to clear
*/
#define TCP_APP_CLEAR_BUFFER(Buffer) MACROS{ Buffer->Ready = false; Buffer->Length = 0; }MACROE
/** Application macro: Closes an open connection to a host.
*
* \param Connection Open TCP connection to close
* \param[in] Connection Open TCP connection to close
*/
#define TCP_APP_CLOSECONNECTION(Connection) MACROS{ Connection->State = TCP_Connection_Closing; }MACROE

6
Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c
Unescape View File

@ -40,9 +40,9 @@
/** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response
* to the output Ethernet frame if a subprotocol handler has created a response packet.
*
* \param IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param UDPHeaderInStart Pointer to the start of the incoming packet's UDP header
* \param UDPHeaderOutStart Pointer to the start of the outgoing packet's UDP header
* \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
* \param[in] UDPHeaderInStart Pointer to the start of the incoming packet's UDP header
* \param[out] UDPHeaderOutStart Pointer to the start of the outgoing packet's UDP header
*
* \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise
*/

8
Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c
Unescape View File

@ -78,8 +78,8 @@ void Webserver_Init(void)
/** Indicates if a given request equals the given HTTP command.
*
* \param RequestHeader HTTP request made by the host
* \param Command HTTP command to compare the request to
* \param[in] RequestHeader HTTP request made by the host
* \param[in] Command HTTP command to compare the request to
*
* \return Boolean true if the command matches the request, false otherwise
*/
@ -92,8 +92,8 @@ static bool IsHTTPCommand(uint8_t* RequestHeader, char* Command)
/** Application callback routine, executed each time the TCP processing task runs. This callback determines what request
* has been made (if any), and serves up appropriate responses.
*
* \param ConnectionState Pointer to a TCP Connection State structure giving connection information
* \param Buffer Pointer to the application's send/receive packet buffer
* \param[in] ConnectionState Pointer to a TCP Connection State structure giving connection information
* \param[in,out] Buffer Pointer to the application's send/receive packet buffer
*/
void Webserver_ApplicationCallback(TCP_ConnectionState_t* ConnectionState, TCP_ConnectionBuffer_t* Buffer)
{

2
Demos/Device/LowLevel/USBtoSerial/Descriptors.h
Unescape View File

@ -47,7 +47,7 @@
* a single typedef struct. A macro is used instead so that functional descriptors can be created
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
*
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

8
Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.c
Unescape View File

@ -164,10 +164,10 @@ void ReadNextReport(void)
/** Writes a report to the attached device.
*
* \param ReportOUTData Buffer containing the report to send to the device
* \param ReportIndex Index of the report in the device (zero if the device does not use multiple reports)
* \param ReportType Type of report to send, either HID_REPORTTYPE_OUTPUT or HID_REPORTTYPE_FEATURE
* \param ReportLength Length of the report to send
* \param[in] ReportOUTData Buffer containing the report to send to the device
* \param[in] ReportIndex Index of the report in the device (zero if the device does not use multiple reports)
* \param[in] ReportType Type of report to send, either HID_REPORTTYPE_OUTPUT or HID_REPORTTYPE_FEATURE
* \param[in] ReportLength Length of the report to send
*/
void WriteNextReport(uint8_t* ReportOUTData, uint8_t ReportIndex, uint8_t ReportType, uint16_t ReportLength)
{

2
Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c
Unescape View File

@ -224,7 +224,7 @@ void Keyboard_HID_Task(void)
/** Processes a read HID report from an attached keyboard, extracting out elements via the HID parser results
* as required and prints pressed characters to the serial port. Each time a key is typed, a board LED is toggled.
*
* \param KeyboardReport Pointer to a HID report from an attached keyboard device
* \param[in] KeyboardReport Pointer to a HID report from an attached keyboard device
*/
void ProcessKeyboardReport(uint8_t* KeyboardReport)
{

42
Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.c
Unescape View File

@ -170,7 +170,7 @@ static uint8_t MassStore_WaitForDataReceived(void)
/** Sends or receives the transaction's data stage to or from the attached device, reading or
* writing to the nominated buffer.
*
* \param BufferPtr Pointer to the data buffer to read from or write to
* \param[in,out] BufferPtr Pointer to the data buffer to read from or write to
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -269,7 +269,7 @@ uint8_t MassStore_MassStorageReset(void)
/** Issues a Mass Storage class specific request to determine the index of the highest numbered Logical
* Unit in the attached device.
*
* \param MaxLUNIndex Pointer to the location that the maximum LUN index value should be stored
* \param[out] MaxLUNIndex Pointer to the location that the maximum LUN index value should be stored
*
* \return A value from the USB_Host_SendControlErrorCodes_t enum
*/
@ -304,8 +304,8 @@ uint8_t MassStore_GetMaxLUN(uint8_t* const MaxLUNIndex)
/** Issues a SCSI Inquiry command to the attached device, to determine the device's information. This
* gives information on the device's capabilities.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param InquiryPtr Pointer to the inquiry data structure where the inquiry data from the device is to be stored
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[out] InquiryPtr Pointer to the inquiry data structure where the inquiry data from the device is to be stored
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -367,8 +367,8 @@ uint8_t MassStore_Inquiry(const uint8_t LUNIndex, const SCSI_Inquiry_Response_t*
/** Issues a SCSI Request Sense command to the attached device, to determine the current SCSI sense information. This
* gives error codes for the last issued SCSI command to the device.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param SensePtr Pointer to the sense data structure where the sense data from the device is to be stored
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[out] SensePtr Pointer to the sense data structure where the sense data from the device is to be stored
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -430,11 +430,11 @@ uint8_t MassStore_RequestSense(const uint8_t LUNIndex, const SCSI_Request_Sense_
/** Issues a SCSI Device Block Read command to the attached device, to read in one or more data blocks from the
* storage medium into a buffer.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param BlockAddress Start block address to read from
* \param Blocks Number of blocks to read from the device
* \param BlockSize Size in bytes of each block to read
* \param BufferPtr Pointer to the buffer where the read data is to be written to
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[in] BlockAddress Start block address to read from
* \param[in] Blocks Number of blocks to read from the device
* \param[in] BlockSize Size in bytes of each block to read
* \param[out] BufferPtr Pointer to the buffer where the read data is to be written to
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -501,11 +501,11 @@ uint8_t MassStore_ReadDeviceBlock(const uint8_t LUNIndex, const uint32_t BlockAd
/** Issues a SCSI Device Block Write command to the attached device, to write one or more data blocks to the
* storage medium from a buffer.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param BlockAddress Start block address to write to
* \param Blocks Number of blocks to write to in the device
* \param BlockSize Size in bytes of each block to write
* \param BufferPtr Pointer to the buffer where the write data is to be sourced from
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[in] BlockAddress Start block address to write to
* \param[in] Blocks Number of blocks to write to in the device
* \param[in] BlockSize Size in bytes of each block to write
* \param[in] BufferPtr Pointer to the buffer where the write data is to be sourced from
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -565,7 +565,7 @@ uint8_t MassStore_WriteDeviceBlock(const uint8_t LUNIndex, const uint32_t BlockA
/** Issues a SCSI Device Test Unit Ready command to the attached device, to determine if the device is ready to accept
* other commands.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -613,8 +613,8 @@ uint8_t MassStore_TestUnitReady(const uint8_t LUNIndex)
/** Issues a SCSI Device Read Capacity command to the attached device, to determine the capacity of the
* given Logical Unit within the device.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param CapacityPtr Device capacity structure where the capacity data is to be stored
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[out] CapacityPtr Device capacity structure where the capacity data is to be stored
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -685,8 +685,8 @@ uint8_t MassStore_ReadCapacity(const uint8_t LUNIndex, SCSI_Capacity_t* const Ca
* being removed. This is a legacy command for SCSI disks with removable storage (such as ZIP disks), but should still
* be issued before the first read or write command is sent.
*
* \param LUNIndex Index of the LUN inside the device the command is being addressed to
* \param PreventRemoval Whether or not the LUN media should be locked to prevent removal or not
* \param[in] LUNIndex Index of the LUN inside the device the command is being addressed to
* \param[in] PreventRemoval Whether or not the LUN media should be locked to prevent removal or not
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/

2
Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.h
Unescape View File

@ -42,7 +42,7 @@
#include "MassStorageHost.h"
#include "SCSI_Codes.h"
#include <LUFA/Drivers/USB/USB.h> // USB Functionality
#include <LUFA/Drivers/USB/USB.h>
/* Macros: */
/** Class specific request to reset the Mass Storage interface of the attached device */

6
Demos/Host/LowLevel/MassStorageHost/MassStorageHost.c
Unescape View File

@ -349,9 +349,9 @@ void MassStorage_Task(void)
* printing error codes to the serial port and waiting until the device is removed before
* continuing.
*
* \param CommandString ASCII string located in PROGMEM space indicating what operation failed
* \param FailedAtSCSILayer Indicates if the command failed at the (logical) SCSI layer or at the physical USB layer
* \param ErrorCode Error code of the function which failed to complete successfully
* \param[in] CommandString ASCII string located in PROGMEM space indicating what operation failed
* \param[in] FailedAtSCSILayer Indicates if the command failed at the (logical) SCSI layer or at the physical USB layer
* \param[in] ErrorCode Error code of the function which failed to complete successfully
*/
void ShowDiskReadError(char* CommandString, bool FailedAtSCSILayer, uint8_t ErrorCode)
{

12
Demos/Host/LowLevel/MassStorageHost/MassStorageHost.h
Unescape View File

@ -49,12 +49,12 @@
#include "Lib/MassStoreCommands.h"
#include <LUFA/Version.h> // Library Version Information
#include <LUFA/Drivers/Misc/TerminalCodes.h> // ANSI Terminal Escape Codes
#include <LUFA/Drivers/USB/USB.h> // USB Functionality
#include <LUFA/Drivers/Peripheral/SerialStream.h> // Serial stream driver
#include <LUFA/Drivers/Board/LEDs.h> // LEDs driver
#include <LUFA/Drivers/Board/Buttons.h> // Board Buttons driver
#include <LUFA/Version.h>
#include <LUFA/Drivers/Misc/TerminalCodes.h>
#include <LUFA/Drivers/USB/USB.h>
#include <LUFA/Drivers/Peripheral/SerialStream.h>
#include <LUFA/Drivers/Board/LEDs.h>
#include <LUFA/Drivers/Board/Buttons.h>
/* Macros: */
/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */

2
Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.c
Unescape View File

@ -224,7 +224,7 @@ void Mouse_HID_Task(void)
/** Processes a read HID report from an attached mouse, extracting out elements via the HID parser results
* as required and displays movement and button presses on the board LEDs.
*
* \param MouseReport Pointer to a HID report from an attached mouse device
* \param[in] MouseReport Pointer to a HID report from an attached mouse device
*/
void ProcessMouseReport(uint8_t* MouseReport)
{

10
Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.c
Unescape View File

@ -190,8 +190,8 @@ uint8_t SImage_RecieveBlockHeader(void)
/** Function to send the given data to the device, after a command block has been issued.
*
* \param Buffer Source data buffer to send to the device
* \param Bytes Number of bytes to send
* \param[in] Buffer Source data buffer to send to the device
* \param[in] Bytes Number of bytes to send
*/
void SImage_SendData(void* Buffer, uint16_t Bytes)
{
@ -211,8 +211,8 @@ void SImage_SendData(void* Buffer, uint16_t Bytes)
/** Function to receive the given data to the device, after a response block has been received.
*
* \param Buffer Destination data buffer to put read bytes from the device
* \param Bytes Number of bytes to receive
* \param[out] Buffer Destination data buffer to put read bytes from the device
* \param[in] Bytes Number of bytes to receive
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
@ -257,7 +257,7 @@ bool SImage_IsEventReceived(void)
/** Clears the stall condition in the attached device on the nominated endpoint number.
*
* \param EndpointNum Endpoint number in the attached device whose stall condition is to be cleared
* \param[in] EndpointNum Endpoint number in the attached device whose stall condition is to be cleared
*
* \return A value from the USB_Host_SendControlErrorCodes_t enum
*/

4
Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.h
Unescape View File

@ -57,7 +57,7 @@
/** Used in the DataLength field of a PIMA container, to give the total container size in bytes for
* a command container.
*
* \param params Number of parameters which are to be sent in the Param field of the container
* \param[in] params Number of parameters which are to be sent in the Param field of the container
*/
#define PIMA_COMMAND_SIZE(params) ((sizeof(PIMA_SendBlock) - sizeof(PIMA_SendBlock.Params)) + \
(params * sizeof(PIMA_SendBlock.Params[0])))
@ -65,7 +65,7 @@
/** Used in the DataLength field of a PIMA container, to give the total container size in bytes for
* a data container.
*
* \param datalen Length in bytes of the data in the container
* \param[in] datalen Length in bytes of the data in the container
*/
#define PIMA_DATA_SIZE(datalen) ((sizeof(PIMA_SendBlock) - sizeof(PIMA_SendBlock.Params)) + datalen)

8
Demos/Host/LowLevel/StillImageHost/StillImageHost.c
Unescape View File

@ -327,8 +327,8 @@ void StillImage_Task(void)
/** Function to convert a given Unicode encoded string to ASCII. This function will only work correctly on Unicode
* strings which contain ASCII printable characters only.
*
* \param UnicodeString Pointer to a Unicode encoded input string
* \param Buffer Pointer to a buffer where the converted ASCII string should be stored
* \param[in] UnicodeString Pointer to a Unicode encoded input string
* \param[out] Buffer Pointer to a buffer where the converted ASCII string should be stored
*/
void UnicodeToASCII(uint8_t* UnicodeString, char* Buffer)
{
@ -351,8 +351,8 @@ void UnicodeToASCII(uint8_t* UnicodeString, char* Buffer)
/** Displays a PIMA command error via the device's serial port.
*
* \param ErrorCode Error code of the function which failed to complete successfully
* \param ResponseCodeError Indicates if the error is due to a command failed indication from the device, or a communication failure
* \param[in] ErrorCode Error code of the function which failed to complete successfully
* \param[in] ResponseCodeError Indicates if the error is due to a command failed indication from the device, or a communication failure
*/
void ShowCommandError(uint8_t ErrorCode, bool ResponseCodeError)
{

10
LUFA/Common/Common.h
Unescape View File

@ -121,7 +121,7 @@
*
* \ingroup Group_BitManip
*
* \param Byte Byte of data whose bits are to be reversed
* \param[in] Byte Byte of data whose bits are to be reversed
*/
static inline uint8_t BitReverse(uint8_t Byte) ATTR_WARN_UNUSED_RESULT ATTR_CONST;
static inline uint8_t BitReverse(uint8_t Byte)
@ -137,7 +137,7 @@
*
* \ingroup Group_BitManip
*
* \param 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(uint16_t Word)
@ -149,7 +149,7 @@
*
* \ingroup Group_BitManip
*
* \param 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(uint32_t DWord)
@ -164,8 +164,8 @@
*
* \ingroup Group_BitManip
*
* \param Data Pointer to a number containing an even number of bytes to be reversed
* \param Bytes Length of the data in bytes
* \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
*/
static inline void SwapEndian_n(uint8_t* Data, uint8_t Bytes);
static inline void SwapEndian_n(uint8_t* Data, uint8_t Bytes)

8
LUFA/DriverStubs/Dataflash.h
Unescape View File

@ -85,8 +85,8 @@
* the total number of pages contained in the boards dataflash ICs, all dataflash ICs
* are deselected.
*
* \param PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
* \param[in] PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
*/
static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)
{
@ -102,8 +102,8 @@
/** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with
* dataflash commands which require a complete 24-byte address.
*
* \param PageAddress Page address within the selected dataflash IC
* \param BufferByte Address within the dataflash's buffer
* \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer
*/
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)
{

18
LUFA/Drivers/Board/Dataflash.h
Unescape View File

@ -86,8 +86,8 @@
/** Selects the given dataflash chip.
*
* \param ChipMask Mask of the Dataflash IC to select, in the form of DATAFLASH_CHIPn mask (where n is
* the chip number).
* \param[in] ChipMask Mask of the Dataflash IC to select, in the form of DATAFLASH_CHIPn mask (where n is
* the chip number).
*/
static inline void Dataflash_SelectChip(uint8_t ChipMask);
@ -105,7 +105,7 @@
/* Inline Functions: */
/** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.
*
* \param Byte of data to send to the dataflash
* \param[in] Byte of data to send to the dataflash
*
* \return Last response byte from the dataflash
*/
@ -117,7 +117,7 @@
/** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.
*
* \param Byte of data to send to the dataflash
* \param[in] Byte of data to send to the dataflash
*/
static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void Dataflash_SendByte(const uint8_t Byte)
@ -154,7 +154,7 @@
/** Initializes the dataflash driver (including the SPI driver) so that commands and data may be
* sent to an attached dataflash IC.
*
* \param PrescalerMask SPI prescaler mask, see SPI.h documentation
* \param[in] PrescalerMask SPI prescaler mask, see SPI.h documentation
*/
static inline void Dataflash_Init(const uint8_t PrescalerMask)
{
@ -191,16 +191,16 @@
* the total number of pages contained in the boards dataflash ICs, all dataflash ICs
* are deselected.
*
* \param PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
* \param[in] PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
*/
static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress);
/** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with
* dataflash commands which require a complete 24-byte address.
*
* \param PageAddress Page address within the selected dataflash IC
* \param BufferByte Address within the dataflash's buffer
* \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer
*/
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte);

10
LUFA/Drivers/Board/LEDs.h
Unescape View File

@ -117,28 +117,28 @@
/** Turns on the LEDs specified in the given LED mask.
*
* \param 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)
*/
static inline void LEDs_TurnOnLEDs(const uint8_t LEDMask);
/** Turns off the LEDs specified in the given LED mask.
*
* \param 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)
*/
static inline void LEDs_TurnOffLEDs(const uint8_t LEDMask);
/** Turns off all LEDs not specified in the given LED mask, and turns on all the LEDs in the given LED
* mask.
*
* \param 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)
*/
static inline void LEDs_SetAllLEDs(const uint8_t LEDMask);
/** Turns off all LEDs in the LED mask that are not set in the active mask, and turns on all the LEDs
* specified in both the LED and active masks.
*
* \param LEDMask Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)
* \param ActiveMask Mask of whether the LEDs in the LED mask should be turned on or off
* \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
*/
static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask);

8
LUFA/Drivers/Board/STK525/Dataflash.h
Unescape View File

@ -85,8 +85,8 @@
* the total number of pages contained in the boards dataflash ICs, all dataflash ICs
* are deselected.
*
* \param PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
* \param[in] PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
*/
static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)
{
@ -101,8 +101,8 @@
/** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with
* dataflash commands which require a complete 24-byte address.
*
* \param PageAddress Page address within the selected dataflash IC
* \param BufferByte Address within the dataflash's buffer
* \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer
*/
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)
{

8
LUFA/Drivers/Board/STK526/Dataflash.h
Unescape View File

@ -85,8 +85,8 @@
* the total number of pages contained in the boards dataflash ICs, all dataflash ICs
* are deselected.
*
* \param PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
* \param[in] PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
*/
static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)
{
@ -101,8 +101,8 @@
/** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with
* dataflash commands which require a complete 24-byte address.
*
* \param PageAddress Page address within the selected dataflash IC
* \param BufferByte Address within the dataflash's buffer
* \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer
*/
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)
{

8
LUFA/Drivers/Board/USBKEY/Dataflash.h
Unescape View File

@ -88,8 +88,8 @@
* the total number of pages contained in the boards dataflash ICs, all dataflash ICs
* are deselected.
*
* \param PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
* \param[in] PageAddress Address of the page to manipulate, ranging from
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).
*/
static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)
{
@ -107,8 +107,8 @@
/** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with
* dataflash commands which require a complete 24-byte address.
*
* \param PageAddress Page address within the selected dataflash IC
* \param BufferByte Address within the dataflash's buffer
* \param[in] PageAddress Page address within the selected dataflash IC
* \param[in] BufferByte Address within the dataflash's buffer
*/
static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)
{

8
LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
Unescape View File

@ -115,7 +115,7 @@
* The "mode" parameter should be a mask comprised of a conversion mode (free running or single) and
* prescaler masks.
*
* \param Mode Mask of ADC settings, including adjustment, prescale, mode and reference
* \param[in] Mode Mask of ADC settings, including adjustment, prescale, mode and reference
*/
static inline void ADC_Init(uint8_t Mode);
@ -159,7 +159,7 @@
* associated port pin as an input and disables the digital portion of the I/O to reduce
* power consumption.
*
* \param Channel ADC channel number to set up for conversions
* \param[in] Channel ADC channel number to set up for conversions
*/
static inline void ADC_SetupChannel(const uint8_t Channel)
{
@ -196,7 +196,7 @@
* Once executed, the conversion status can be determined via the \ref ADC_IsReadingComplete() macro and
* the result read via the \ref ADC_GetResult() macro.
*
* \param MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
* \param[in] MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
*/
static inline void ADC_StartReading(const uint8_t MUXMask)
{
@ -208,7 +208,7 @@
/** Performs a complete single reading from channel, including a polling spinloop to wait for the
* conversion to complete, and the returning of the converted value.
*
* \param MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
* \param[in] MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
*/
static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask) ATTR_WARN_UNUSED_RESULT;
static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask)

8
LUFA/Drivers/Peripheral/SPI.h
Unescape View File

@ -90,8 +90,8 @@
/** Initializes the SPI subsystem, ready for transfers. Must be called before calling any other
* SPI routines.
*
* \param PrescalerMask Prescaler mask to set the SPI clock speed
* \param Master If true, sets the SPI system to use master mode, slave if false
* \param[in] PrescalerMask Prescaler mask to set the SPI clock speed
* \param[in] Master If true, sets the SPI system to use master mode, slave if false
*/
static inline void SPI_Init(const uint8_t PrescalerMask, const bool Master)
{
@ -109,7 +109,7 @@
/** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.
*
* \param Byte Byte to send through the SPI interface
* \param[in] Byte Byte to send through the SPI interface
*
* \return Response byte from the attached SPI device
*/
@ -124,7 +124,7 @@
/** Sends a byte through the SPI interface, blocking until the transfer is complete. The response
* byte sent to from the attached SPI device is ignored.
*
* \param Byte Byte to send through the SPI interface
* \param[in] Byte Byte to send through the SPI interface
*/
static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void SPI_SendByte(const uint8_t Byte)

10
LUFA/Drivers/Peripheral/Serial.h
Unescape View File

@ -88,13 +88,13 @@
/* Function Prototypes: */
/** Transmits a given string located in program space (FLASH) through the USART.
*
* \param 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);
/** Transmits a given string located in SRAM memory through the USART.
*
* \param 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);
@ -102,8 +102,8 @@
/** Initializes the USART, ready for serial data transmission and reception. This initialises the interface to
* standard 8-bit, no parity, 1 stop bit settings suitable for most applications.
*
* \param BaudRate Serial baud rate, in bits per second
* \param DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate
* \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
*/
static inline void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed)
{
@ -119,7 +119,7 @@
/** Transmits a given byte through the USART.
*
* \param DataByte Byte to transmit through the USART
* \param[in] DataByte Byte to transmit through the USART
*/
static inline void Serial_TxByte(const char DataByte)
{

4
LUFA/Drivers/Peripheral/SerialStream.h
Unescape View File

@ -79,8 +79,8 @@
/** Initializes the serial stream (and regular USART driver) so that both the stream and regular
* USART driver functions can be used. Must be called before any stream or regular USART functions.
*
* \param BaudRate Baud rate to configure the USART to
* \param DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate
* \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
*/
static inline void SerialStream_Init(const uint32_t BaudRate, const bool DoubleSpeed)
{

2
LUFA/Drivers/USB/Class/Common/Audio.h
Unescape View File

@ -201,7 +201,7 @@
/** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.
*
* \param freq Required audio sampling frequency in HZ
* \param[in] freq Required audio sampling frequency in HZ
*/
#define AUDIO_SAMPLE_FREQ(freq) {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}

2
LUFA/Drivers/USB/Class/Common/CDC.h
Unescape View File

@ -111,7 +111,7 @@
* a single typedef struct. A macro is used instead so that functional descriptors can be created
* easily by specifying the size of the payload. This allows sizeof() to work correctly.
*
* \param DataSize Size in bytes of the CDC functional descriptor's data payload
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload
*/
#define CDC_FUNCTIONAL_DESCRIPTOR(DataSize) \
struct \

2
LUFA/Drivers/USB/Class/Common/MIDI.h
Unescape View File

@ -71,7 +71,7 @@
/** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel
* addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.
*
* \param channel MIDI channel number to address
* \param[in] channel MIDI channel number to address
*/
#define MIDI_CHANNEL(channel) (channel - 1)

14
LUFA/Drivers/USB/Class/Device/Audio.c
Unescape View File

@ -33,7 +33,7 @@
#include "Audio.h"
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
{
if (!(Endpoint_IsSETUPReceived()))
return;
@ -83,7 +83,7 @@ bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfac
return true;
}
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
{
}
@ -124,7 +124,7 @@ int32_t Audio_Device_ReadSample24(void)
return Sample;
}
void Audio_Device_WriteSample8(int8_t Sample)
void Audio_Device_WriteSample8(const int8_t Sample)
{
Endpoint_Write_Byte(Sample);
@ -132,7 +132,7 @@ void Audio_Device_WriteSample8(int8_t Sample)
Endpoint_ClearIN();
}
void Audio_Device_WriteSample16(int16_t Sample)
void Audio_Device_WriteSample16(const int16_t Sample)
{
Endpoint_Write_Word_LE(Sample);
@ -140,7 +140,7 @@ void Audio_Device_WriteSample16(int16_t Sample)
Endpoint_ClearIN();
}
void Audio_Device_WriteSample24(int32_t Sample)
void Audio_Device_WriteSample24(const int32_t Sample)
{
Endpoint_Write_Byte(Sample >> 16);
Endpoint_Write_Word_LE(Sample);
@ -149,13 +149,13 @@ void Audio_Device_WriteSample24(int32_t Sample)
Endpoint_ClearIN();
}
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
{
Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpointNumber);
return Endpoint_IsOUTReceived();
}
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
{
Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpointNumber);
return Endpoint_IsINReady();

32
LUFA/Drivers/USB/Class/Device/Audio.h
Unescape View File

@ -97,25 +97,25 @@
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the
* given Audio interface is selected.
*
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
*/
bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
/** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
*
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*/
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
/** General management task for a given Audio class interface, required for the correct operation of the interface. This should
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
*
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*/
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
/** Reads the next 8-bit audio sample from the current audio interface.
*
@ -149,43 +149,43 @@
* \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that
* the correct endpoint is selected and ready for data.
*
* \param Sample Signed 8-bit audio sample
* \param[in] Sample Signed 8-bit audio sample
*/
void Audio_Device_WriteSample8(int8_t Sample);
void Audio_Device_WriteSample8(const int8_t Sample);
/** Writes the next 16-bit audio sample to the current audio interface.
*
* \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that
* the correct endpoint is selected and ready for data.
*
* \param Sample Signed 16-bit audio sample
* \param[in] Sample Signed 16-bit audio sample
*/
void Audio_Device_WriteSample16(int16_t Sample);
void Audio_Device_WriteSample16(const int16_t Sample);
/** Writes the next 24-bit audio sample to the current audio interface.
*
* \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that
* the correct endpoint is selected and ready for data.
*
* \param Sample Signed 24-bit audio sample
* \param[in] Sample Signed 24-bit audio sample
*/
void Audio_Device_WriteSample24(int32_t Sample);
void Audio_Device_WriteSample24(const int32_t Sample);
/** Determines if the given audio interface is ready for a sample to be read from it.
*
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*
* \return Boolean true if the given Audio interface has a sample to be read, false otherwise
*/
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
/** Determines if the given audio interface is ready to accept the next sample to be written to it.
*
* \param AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*
* \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise
*/
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);
bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)

8
LUFA/Drivers/USB/Class/Device/CDC.c
Unescape View File

@ -131,7 +131,7 @@ void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
Endpoint_ClearIN();
}
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length)
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)
{
if (!(USB_IsConnected))
return;
@ -140,7 +140,7 @@ void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* D
Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);
}
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data)
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data)
{
if (!(USB_IsConnected))
return;
@ -156,7 +156,7 @@ void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t D
Endpoint_Write_Byte(Data);
}
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);
@ -178,7 +178,7 @@ uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
return DataByte;
}
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
if (!(USB_IsConnected))
return;

50
LUFA/Drivers/USB/Class/Device/CDC.h
Unescape View File

@ -108,34 +108,34 @@
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the
* given CDC interface is selected.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
*/
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*/
void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** General management task for a given CDC class interface, required for the correct operation of the interface. This should
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*/
void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a
* line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the
* user program by declaring a handler function with the same name and parameters listed here. The new line encoding
* settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*/
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a
* control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the
@ -143,62 +143,62 @@
* are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as
* a mask of CDC_CONTROL_LINE_OUT_* masks.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*/
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the
* string is discarded.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param Data Pointer to the string to send to the host
* \param Length Size in bytes of the string to send to the host
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in] Data Pointer to the string to send to the host
* \param[in] Length Size in bytes of the string to send to the host
*/
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length);
void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length);
/** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the
* byte is discarded.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param Data Byte of data to send to the host
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in] Data Byte of data to send to the host
*/
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data);
void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data);
/** Determines the number of bytes received by the CDC interface from the host, waiting to be read.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*
* \return Total number of buffered bytes received from the host
*/
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** Reads a byte of data from the host. If no data is waiting to be read of if a USB host is not connected, the function
* returns 0. The USB_CDC_BytesReceived() function should be queried before data is recieved to ensure that no data
* underflow occurs.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*
* \return Next received byte from the host, or 0 if no data received
*/
uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial
* control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist
* until they are cleared via a second notification. This should be called each time the CDC class driver's
* ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.
*
* \param CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*/
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Function Prototypes: */
#if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)
void CDC_Device_Event_Stub(void);
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);
#endif

6
LUFA/Drivers/USB/Class/Device/HID.c
Unescape View File

@ -33,7 +33,7 @@
#include "HID.h"
void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
if (!(Endpoint_IsSETUPReceived()))
return;
@ -130,7 +130,7 @@ void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInf
}
}
bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
HIDInterfaceInfo->State.UsingReportProtocol = true;
@ -143,7 +143,7 @@ bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
return true;
}
void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
if (!(USB_IsConnected))
return;

28
LUFA/Drivers/USB/Class/Device/HID.h
Unescape View File

@ -89,7 +89,7 @@
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
* containing the given HID interface is selected.
*
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
*
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
*/
@ -98,14 +98,14 @@
/** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
*
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
*/
void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);
/** General management task for a given HID class interface, required for the correct operation of the interface. This should
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
*
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
*/
void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);
@ -113,11 +113,11 @@
* HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the
* user is responsible for the creation of the next HID input report to be sent to the host.
*
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param ReportID If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should
* be set to the report ID of the generated HID input report. If multiple reports are not sent via the
* given HID interface, this parameter should be ignored.
* \param ReportData Pointer to a buffer where the generated HID report should be stored.
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param[in,out] ReportID If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should
* be set to the report ID of the generated HID input report. If multiple reports are not sent via the
* given HID interface, this parameter should be ignored.
* \param[out] ReportData Pointer to a buffer where the generated HID report should be stored.
*
* \return Number of bytes in the generated input report, or zero if no report is to be sent
*/
@ -127,14 +127,14 @@
* either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback
* the user is responsible for the processing of the received HID output report from the host.
*
* \param HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param ReportID Report ID of the received output report. If multiple reports are not received via the given HID
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
* \param[in] ReportID Report ID of the received output report. If multiple reports are not received via the given HID
* interface, this parameter should be ignored.
* \param ReportData Pointer to a buffer where the received HID report is stored.
* \param ReportSize Size in bytes of the received report from the host.
* \param[in] ReportData Pointer to a buffer where the received HID report is stored.
* \param[in] ReportSize Size in bytes of the received report from the host.
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, void* ReportData,
uint16_t ReportSize);
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
const void* ReportData, const uint16_t ReportSize);
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)

10
LUFA/Drivers/USB/Class/Device/MIDI.c
Unescape View File

@ -33,12 +33,12 @@
#include "MIDI.h"
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
{
}
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
{
if (MIDIInterfaceInfo->Config.DataINEndpointNumber)
{
@ -63,12 +63,12 @@ bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceIn
return true;
}
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)
{
}
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)
{
if (!(USB_IsConnected))
return;
@ -82,7 +82,7 @@ void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo,
}
}
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)
{
if (!(USB_IsConnected))
return false;

30
LUFA/Drivers/USB/Class/Device/MIDI.h
Unescape View File

@ -54,12 +54,6 @@
/* Public Interface - May be used in end-application: */
/* Type Define: */
/** Configuration information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */
typedef USB_ClassInfo_MIDI_Device_Config_t;
/** Current State information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */
typedef USB_ClassInfo_MIDI_Device_State_t;
/** Class state structure. An instance of this structure should be made for each MIDI interface
* within the user application, and passed to each of the MIDI class driver functions as the
* MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.
@ -92,41 +86,41 @@
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
* containing the given MIDI interface is selected.
*
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
*
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
*/
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);
/** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
*
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
*/
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);
void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);
/** General management task for a given MIDI class interface, required for the correct operation of the interface. This should
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
*
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
*/
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);
void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);
/** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.
*
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param Event Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[in] Event Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send
*/
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);
void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);
/** Receives a MIDI event packet from the host.
*
* \param MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param Event Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[out] Event Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed
*
* \return Boolean true if a MIDI event packet was received, false otherwise
*/
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)

10
LUFA/Drivers/USB/Class/Device/MassStorage.c
Unescape View File

@ -36,7 +36,7 @@
static USB_ClassInfo_MS_Device_t* CallbackMSInterfaceInfo;
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
if (!(Endpoint_IsSETUPReceived()))
return;
@ -75,7 +75,7 @@ void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
}
}
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
ENDPOINT_DIR_IN, MSInterfaceInfo->Config.DataINEndpointSize,
@ -94,7 +94,7 @@ bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
return true;
}
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
if (!(USB_IsConnected))
return;
@ -138,7 +138,7 @@ void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
MSInterfaceInfo->State.IsMassStoreReset = false;
}
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
@ -171,7 +171,7 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceI
return true;
}
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);

20
LUFA/Drivers/USB/Class/Device/MassStorage.h
Unescape View File

@ -95,43 +95,43 @@
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
* containing the given Mass Storage interface is selected.
*
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
*
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
*/
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
/** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
*
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
*/
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
/** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
*
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage configuration and state.
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage configuration and state.
*/
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
/** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the
* host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible
* for the processing of the received SCSI command from the host. The SCSI command is available in the CommandBlock structure
* inside the Mass Storage class state structure passed as a parameter to the callback function.
*
* \param MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
*
* \return Boolean true if the SCSI command was successfully processed, false otherwise
*/
bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Function Prototypes: */
#if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);
static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);
static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);
#endif

18
LUFA/Drivers/USB/Class/Device/RNDIS.c
Unescape View File

@ -65,7 +65,7 @@ static const uint32_t PROGMEM AdapterSupportedOIDList[] =
OID_802_3_XMIT_MORE_COLLISIONS,
};
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
{
if (!(Endpoint_IsSETUPReceived()))
return;
@ -110,7 +110,7 @@ void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterf
}
}
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
{
if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.DataINEndpointSize,
@ -136,7 +136,7 @@ bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfac
return true;
}
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
{
if (!(USB_IsConnected))
return;
@ -208,7 +208,7 @@ void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
}
}
void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
{
/* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of
this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */
@ -331,9 +331,9 @@ void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDIS
}
}
static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo,
uint32_t OId, void* QueryData, uint16_t QuerySize,
void* ResponseData, uint16_t* ResponseSize)
static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
const uint32_t OId, void* const QueryData, const uint16_t QuerySize,
void* ResponseData, uint16_t* const ResponseSize)
{
switch (OId)
{
@ -443,8 +443,8 @@ static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInt
}
}
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId, void* SetData,
uint16_t SetSize)
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId, void* SetData,
const uint16_t SetSize)
{
switch (OId)
{

24
LUFA/Drivers/USB/Class/Device/RNDIS.h
Unescape View File

@ -103,36 +103,36 @@
* \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration
* containing the given HID interface is selected.
*
* \param RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
*
* \return Boolean true if the endpoints were sucessfully configured, false otherwise
*/
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
/** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be
* linked to the library \ref EVENT_USB_UnhandledControlPacket() event.
*
* \param RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
*/
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
/** General management task for a given HID class interface, required for the correct operation of the interface. This should
* be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
*
* \param RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
*/
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Function Prototypes: */
#if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)
static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);
static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo,
uint32_t OId, void* QueryData, uint16_t QuerySize,
void* ResponseData, uint16_t* ResponseSize);
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId,
void* SetData, uint16_t SetSize);
static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);
static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
const uint32_t OId, void* const QueryData, const uint16_t QuerySize,
void* ResponseData, uint16_t* const ResponseSize);
static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,
void* SetData, const uint16_t SetSize);
#endif
#endif

14
LUFA/Drivers/USB/Class/Host/HIDParser.h
Unescape View File

@ -209,9 +209,9 @@
/** Function to process a given HID report returned from an attached device, and store it into a given
* \ref HID_ReportInfo_t structure.
*
* \param ReportData Buffer containing the device's HID report table
* \param ReportSize Size in bytes of the HID report table
* \param ParserData Pointer to a \ref HID_ReportInfo_t instance for the parser output
* \param[in] ReportData Buffer containing the device's HID report table
* \param[in] ReportSize Size in bytes of the HID report table
* \param[out] ParserData Pointer to a \ref HID_ReportInfo_t instance for the parser output
*
* \return A value in the \ref HID_Parse_ErrorCodes_t enum
*/
@ -221,8 +221,8 @@
/** Extracts the given report item's value out of the given HID report and places it into the Value
* member of the report item's \ref HID_ReportItem_t structure.
*
* \param ReportData Buffer containing an IN or FEATURE report from an attached device
* \param ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
* \param[in] ReportData Buffer containing an IN or FEATURE report from an attached device
* \param[in,out] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
*
* \returns Boolean true if the item to retrieve was located in the given report, false otherwise
*/
@ -236,8 +236,8 @@
*
* If the device has multiple HID reports, the report ID is set to the report ID of the given item.
*
* \param ReportData Buffer holding the current OUT report data
* \param ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
* \param[out] ReportData Buffer holding the current OUT report data
* \param[in] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array
*/
void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)
ATTR_NON_NULL_PTR_ARG(1, 2);

50
LUFA/Drivers/USB/HighLevel/ConfigDescriptor.h
Unescape View File

@ -133,9 +133,9 @@
*
* \note This function is available in USB Host mode only.
*
* \param BytesRem Pointer to an int storing the remaining bytes in the configuration descriptor
* \param CurrConfigLoc Pointer to the current position in the configuration descriptor
* \param ComparatorRoutine Name of the comparator search function to use on the configuration descriptor
* \param[in,out] BytesRem Pointer to an int storing the remaining bytes in the configuration descriptor
* \param[in,out] CurrConfigLoc Pointer to the current position in the configuration descriptor
* \param[in] ComparatorRoutine Name of the comparator search function to use on the configuration descriptor
*
* \return Value of one of the members of the \ref DSearch_Comp_Return_ErrorCodes_t enum
*
@ -183,17 +183,17 @@
/* Function Prototypes: */
/** Retrieves the configuration descriptor data or size from an attached device via a standard request.
*
* \param ConfigNumber Device configuration descriptor number to fetch from the device (usually set to 1 for
* single configuration devices)
* \param[in] ConfigNumber Device configuration descriptor number to fetch from the device (usually set to 1 for
* single configuration devices)
*
* \param ConfigSizePtr Pointer to a uint16_t for either storing or retrieving the configuration
* descriptor size
* \param[in,out] ConfigSizePtr Pointer to a uint16_t for either storing or retrieving the configuration
* descriptor size
*
* \param BufferPtr Pointer to the buffer for storing the configuration descriptor data. If this is
* NULL, the size of the configuration descriptor will be retrieved instead and
* placed in the variable pointed to by ConfigSizePtr. If this is non-NULL, the number
* of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded
* into the buffer
* \param[out] BufferPtr Pointer to the buffer for storing the configuration descriptor data. If this is
* NULL, the size of the configuration descriptor will be retrieved instead and
* placed in the variable pointed to by ConfigSizePtr. If this is non-NULL, the number
* of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded
* into the buffer
*/
uint8_t USB_GetDeviceConfigDescriptor(uint8_t ConfigNumber, uint16_t* const ConfigSizePtr, void* BufferPtr)
ATTR_NON_NULL_PTR_ARG(2);
@ -201,9 +201,9 @@
/** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value.
* The bytes remaining value is automatically decremented.
*
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param Type Descriptor type value to search for
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param[in] Type Descriptor type value to search for
*/
void USB_GetNextDescriptorOfType(uint16_t* const BytesRem,
uint8_t** const CurrConfigLoc,
@ -215,10 +215,10 @@
* descriptor is reached first, the number of bytes remaining to process is set to zero and the
* function exits. The bytes remaining value is automatically decremented.
*
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param Type Descriptor type value to search for
* \param BeforeType Descriptor type value which must not be reached before the given Type descriptor
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param[in] Type Descriptor type value to search for
* \param[in] BeforeType Descriptor type value which must not be reached before the given Type descriptor
*/
void USB_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,
uint8_t** const CurrConfigLoc,
@ -230,10 +230,10 @@
* which must come after a descriptor of the second given type value. The bytes remaining value is
* automatically decremented.
*
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param Type Descriptor type value to search for
* \param AfterType Descriptor type value which must be reached before the given Type descriptor
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param[in] Type Descriptor type value to search for
* \param[in] AfterType Descriptor type value which must be reached before the given Type descriptor
*/
void USB_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,
uint8_t** const CurrConfigLoc,
@ -245,8 +245,8 @@
/** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then
points to the next sub-descriptor. The bytes remaining value is automatically decremented.
*
* \param BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
* \param[in,out] BytesRem Pointer to the number of bytes remaining of the configuration descriptor
* \param[in,out] CurrConfigLoc Pointer to the current descriptor inside the configuration descriptor
*/
static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,
uint8_t** const CurrConfigLoc)

14
LUFA/Drivers/USB/HighLevel/Events.h
Unescape View File

@ -127,7 +127,7 @@
*
* \note This event only exists on USB AVR models which support dual role modes.
*
* \param ErrorCode Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t
* \param[in] ErrorCode Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t
*/
void EVENT_USB_InitFailure(const uint8_t ErrorCode);
@ -146,7 +146,7 @@
/** Event for USB host error. This event fires when a hardware fault has occurred whilst the USB
* interface is in host mode.
*
* \param ErrorCode Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t
* \param[in] ErrorCode Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t
*
* \note This event only exists on USB AVR models which supports host mode.
*
@ -185,12 +185,12 @@
/** Event for USB device enumeration failure. This event fires when a the USB interface is
* in host mode, and an attached USB device has failed to enumerate completely.
*
* \param ErrorCode Error code indicating the failure reason, a value in
* \ref USB_Host_EnumerationErrorCodes_t
* \param[in] ErrorCode Error code indicating the failure reason, a value in
* \ref USB_Host_EnumerationErrorCodes_t
*
* \param SubErrorCode Sub error code indicating the reason for failure - for example, if the
* ErrorCode parameter indicates a control error, this will give the error
* code returned by the \ref USB_Host_SendControlRequest() function.
* \param[in] SubErrorCode Sub error code indicating the reason for failure - for example, if the
* ErrorCode parameter indicates a control error, this will give the error
* code returned by the \ref USB_Host_SendControlRequest() function.
*
* \note This event only exists on USB AVR models which supports host mode.
*

18
LUFA/Drivers/USB/LowLevel/Device.h
Unescape View File

@ -124,15 +124,15 @@
* index and language ID. This function MUST be overridden in the user application (added with full, identical
* prototype and name so that the library can call it to retrieve descriptor data.
*
* \param wValue The type of the descriptor to retrieve in the upper byte, and the index in the
* lower byte (when more than one descriptor of the given type exists, such as the
* case of string descriptors). The type may be one of the standard types defined
* in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.
* \param wIndex The language ID of the string to return if the wValue type indicates DTYPE_String,
* otherwise zero for standard descriptors, or as defined in a class-specific
* standards.
* \param DescriptorAddress Pointer to the descriptor in memory. This should be set by the routine to
* the address of the descriptor.
* \param[in] wValue The type of the descriptor to retrieve in the upper byte, and the index in the
* lower byte (when more than one descriptor of the given type exists, such as the
* case of string descriptors). The type may be one of the standard types defined
* in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.
* \param[in] wIndex The language ID of the string to return if the wValue type indicates DTYPE_String,
* otherwise zero for standard descriptors, or as defined in a class-specific
* standards.
* \param[out] DescriptorAddress Pointer to the descriptor in memory. This should be set by the routine to
* the address of the descriptor.
*
* \note By default, the library expects all descriptors to be located in flash memory via the PROGMEM attribute.
* If descriptors should be located in RAM or EEPROM instead (to speed up access in the case of RAM, or to

208
LUFA/Drivers/USB/LowLevel/Endpoint.c
Unescape View File

@ -119,6 +119,46 @@ uint8_t Endpoint_Discard_Stream(uint16_t Length
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearOUT();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return ENDPOINT_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
Endpoint_Discard_Byte();
case 7: Endpoint_Discard_Byte();
case 6: Endpoint_Discard_Byte();
case 5: Endpoint_Discard_Byte();
case 4: Endpoint_Discard_Byte();
case 3: Endpoint_Discard_Byte();
case 2: Endpoint_Discard_Byte();
case 1: Endpoint_Discard_Byte();
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Endpoint_IsReadWriteAllowed()))
@ -155,6 +195,46 @@ uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearIN();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return ENDPOINT_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
Endpoint_Write_Byte(*(DataStream++));
case 7: Endpoint_Write_Byte(*(DataStream++));
case 6: Endpoint_Write_Byte(*(DataStream++));
case 5: Endpoint_Write_Byte(*(DataStream++));
case 4: Endpoint_Write_Byte(*(DataStream++));
case 3: Endpoint_Write_Byte(*(DataStream++));
case 2: Endpoint_Write_Byte(*(DataStream++));
case 1: Endpoint_Write_Byte(*(DataStream++));
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Endpoint_IsReadWriteAllowed()))
@ -175,7 +255,7 @@ uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length
Length--;
}
}
return ENDPOINT_RWSTREAM_NoError;
}
@ -191,6 +271,46 @@ uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearIN();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return ENDPOINT_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
Endpoint_Write_Byte(*(DataStream--));
case 7: Endpoint_Write_Byte(*(DataStream--));
case 6: Endpoint_Write_Byte(*(DataStream--));
case 5: Endpoint_Write_Byte(*(DataStream--));
case 4: Endpoint_Write_Byte(*(DataStream--));
case 3: Endpoint_Write_Byte(*(DataStream--));
case 2: Endpoint_Write_Byte(*(DataStream--));
case 1: Endpoint_Write_Byte(*(DataStream--));
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Endpoint_IsReadWriteAllowed()))
@ -211,7 +331,7 @@ uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length
Length--;
}
}
return ENDPOINT_RWSTREAM_NoError;
}
@ -227,6 +347,46 @@ uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearOUT();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return ENDPOINT_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
*(DataStream++) = Endpoint_Read_Byte();
case 7: *(DataStream++) = Endpoint_Read_Byte();
case 6: *(DataStream++) = Endpoint_Read_Byte();
case 5: *(DataStream++) = Endpoint_Read_Byte();
case 4: *(DataStream++) = Endpoint_Read_Byte();
case 3: *(DataStream++) = Endpoint_Read_Byte();
case 2: *(DataStream++) = Endpoint_Read_Byte();
case 1: *(DataStream++) = Endpoint_Read_Byte();
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Endpoint_IsReadWriteAllowed()))
@ -247,7 +407,7 @@ uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length
Length--;
}
}
return ENDPOINT_RWSTREAM_NoError;
}
@ -263,6 +423,46 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Endpoint_IsReadWriteAllowed()))
{
Endpoint_ClearOUT();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return ENDPOINT_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Endpoint_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
*(DataStream--) = Endpoint_Read_Byte();
case 7: *(DataStream--) = Endpoint_Read_Byte();
case 6: *(DataStream--) = Endpoint_Read_Byte();
case 5: *(DataStream--) = Endpoint_Read_Byte();
case 4: *(DataStream--) = Endpoint_Read_Byte();
case 3: *(DataStream--) = Endpoint_Read_Byte();
case 2: *(DataStream--) = Endpoint_Read_Byte();
case 1: *(DataStream--) = Endpoint_Read_Byte();
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Endpoint_IsReadWriteAllowed()))
@ -283,7 +483,7 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
Length--;
}
}
return ENDPOINT_RWSTREAM_NoError;
}
#endif

64
LUFA/Drivers/USB/LowLevel/Endpoint.h
Unescape View File

@ -117,13 +117,13 @@
/** Maximum size in bytes of a given endpoint.
*
* \param n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
* \param[in] n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
*/
#define ENDPOINT_MAX_SIZE(n) _ENDPOINT_GET_MAXSIZE(n)
/** Indicates if the given endpoint supports double banking.
*
* \param n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
* \param[in] n Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
*/
#define ENDPOINT_DOUBLEBANK_SUPPORTED(n) _ENDPOINT_GET_DOUBLEBANK(n)
@ -169,14 +169,14 @@
* Any endpoint operations which do not require the endpoint number to be indicated will operate on
* the currently selected endpoint.
*
* \param EndpointNumber Endpoint number to select
* \param[in] EndpointNumber Endpoint number to select
*/
static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber);
/** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's
* In and Out pointers to the bank's contents.
*
* \param EndpointNumber Endpoint number whose FIFO buffers are to be reset
* \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset
*/
static inline void Endpoint_ResetFIFO(uint8_t EndpointNumber);
@ -227,7 +227,7 @@
/** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type
* endpoints).
*
* \param EndpointNumber Index of the endpoint whose interrupt flag should be tested
* \param[in] EndpointNumber Index of the endpoint whose interrupt flag should be tested
*
* \return Boolean true if the specified endpoint has interrupted, false otherwise
*/
@ -454,7 +454,7 @@
*
* \ingroup Group_EndpointRW
*
* \param Byte Next byte to write into the the currently selected endpoint's FIFO buffer
* \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer
*/
static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_Byte(const uint8_t Byte)
@ -515,7 +515,7 @@
*
* \ingroup Group_EndpointRW
*
* \param Word Next word to write to the currently selected endpoint's FIFO buffer
* \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer
*/
static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_Word_LE(const uint16_t Word)
@ -529,7 +529,7 @@
*
* \ingroup Group_EndpointRW
*
* \param Word Next word to write to the currently selected endpoint's FIFO buffer
* \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer
*/
static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_Word_BE(const uint16_t Word)
@ -604,7 +604,7 @@
*
* \ingroup Group_EndpointRW
*
* \param DWord Next double word to write to the currently selected endpoint's FIFO buffer
* \param[in] DWord Next double word to write to the currently selected endpoint's FIFO buffer
*/
static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)
@ -620,7 +620,7 @@
*
* \ingroup Group_EndpointRW
*
* \param DWord Next double word to write to the currently selected endpoint's FIFO buffer
* \param[in] DWord Next double word to write to the currently selected endpoint's FIFO buffer
*/
static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)
@ -722,8 +722,8 @@
*
* \ingroup Group_EndpointRW
*
* \param Length Number of bytes to send via the currently selected endpoint.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[in] Length Number of bytes to send via the currently selected endpoint.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/
@ -748,9 +748,9 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the source data buffer to read from.
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[in] Buffer Pointer to the source data buffer to read from.
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/
@ -775,9 +775,9 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the source data buffer to read from.
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[in] Buffer Pointer to the source data buffer to read from.
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/
@ -802,9 +802,9 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the destination data buffer to write to.
* \param Length Number of bytes to send via the currently selected endpoint.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[out] Buffer Pointer to the destination data buffer to write to.
* \param[in] Length Number of bytes to send via the currently selected endpoint.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/
@ -829,9 +829,9 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the destination data buffer to write to.
* \param Length Number of bytes to send via the currently selected endpoint.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[out] Buffer Pointer to the destination data buffer to write to.
* \param[in] Length Number of bytes to send via the currently selected endpoint.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
*/
@ -855,8 +855,8 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the source data buffer to read from.
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
* \param[in] Buffer Pointer to the source data buffer to read from.
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
*
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/
@ -874,8 +874,8 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the source data buffer to read from.
* \param Length Number of bytes to read for the currently selected endpoint into the buffer.
* \param[in] Buffer Pointer to the source data buffer to read from.
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.
*
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/
@ -893,8 +893,8 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the destination data buffer to write to.
* \param Length Number of bytes to send via the currently selected endpoint.
* \param[out] Buffer Pointer to the destination data buffer to write to.
* \param[in] Length Number of bytes to send via the currently selected endpoint.
*
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/
@ -912,8 +912,8 @@
*
* \ingroup Group_EndpointRW
*
* \param Buffer Pointer to the destination data buffer to write to.
* \param Length Number of bytes to send via the currently selected endpoint.
* \param[out] Buffer Pointer to the destination data buffer to write to.
* \param[in] Length Number of bytes to send via the currently selected endpoint.
*
* \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.
*/

8
LUFA/Drivers/USB/LowLevel/Host.h
Unescape View File

@ -182,7 +182,7 @@
*
* \note After this routine returns, the control pipe will be selected.
*
* \param ConfigNumber Configuration index to send to the device
* \param[in] ConfigNumber Configuration index to send to the device
*
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/
@ -194,8 +194,8 @@
*
* \note After this routine returns, the control pipe will be selected.
*
* \param DeviceDescriptorPtr Pointer to the destination device descriptor structure where
* the read data is to be stored
* \param[out] DeviceDescriptorPtr Pointer to the destination device descriptor structure where
* the read data is to be stored
*
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/
@ -205,7 +205,7 @@
*
* \note After this routine returns, the control pipe will be selected.
*
* \param EndpointIndex Index of the endpoint to clear
* \param[in] EndpointIndex Index of the endpoint to clear
*
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/

4
LUFA/Drivers/USB/LowLevel/HostChapter9.h
Unescape View File

@ -71,8 +71,8 @@
*
* \ingroup Group_PipeControlReq
*
* \param BufferPtr Pointer to the start of the data buffer if the request has a data stage, or
* NULL if the request transfers no data to or from the device.
* \param[in] BufferPtr Pointer to the start of the data buffer if the request has a data stage, or
* NULL if the request transfers no data to or from the device.
*
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/

14
LUFA/Drivers/USB/LowLevel/LowLevel.h
Unescape View File

@ -228,14 +228,14 @@
* Calling this function when the USB interface is already initialized will cause a complete USB
* interface reset and re-enumeration.
*
* \param Mode This is a mask indicating what mode the USB interface is to be initialized to.
* Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.
* \param[in] Mode This is a mask indicating what mode the USB interface is to be initialized to.
* Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.
*
* \param Options Mask indicating the options which should be used when initializing the USB
* interface to control the USB interface's behaviour. This should be comprised of
* a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the
* PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device
* mode speed.
* \param[in] Options Mask indicating the options which should be used when initializing the USB
* interface to control the USB interface's behaviour. This should be comprised of
* a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the
* PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device
* mode speed.
*
* \note To reduce the FLASH requirements of the library if only device or host mode is required,
* this can be statically set via defining the token USB_DEVICE_ONLY for device mode or

2
LUFA/Drivers/USB/LowLevel/OTG.h
Unescape View File

@ -102,7 +102,7 @@
* There are two different methods of sending a SRP - either pulses on the VBUS line, or by
* pulsing the Data + line via the internal pull-up resistor.
*
* \param SRPTypeMask Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or \ref USB_OTG_STP_DATA.
* \param[in] SRPTypeMask Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or \ref USB_OTG_STP_DATA.
*/
static inline void USB_OTG_Dev_InitiateSRP(uint8_t SRPTypeMask);
#else

200
LUFA/Drivers/USB/LowLevel/Pipe.c
Unescape View File

@ -120,6 +120,46 @@ uint8_t Pipe_Write_Stream_LE(const void* Data, uint16_t Length
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_ClearOUT();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return PIPE_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
Pipe_Write_Byte(*(DataStream++));
case 7: Pipe_Write_Byte(*(DataStream++));
case 6: Pipe_Write_Byte(*(DataStream++));
case 5: Pipe_Write_Byte(*(DataStream++));
case 4: Pipe_Write_Byte(*(DataStream++));
case 3: Pipe_Write_Byte(*(DataStream++));
case 2: Pipe_Write_Byte(*(DataStream++));
case 1: Pipe_Write_Byte(*(DataStream++));
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Pipe_IsReadWriteAllowed()))
@ -158,6 +198,46 @@ uint8_t Pipe_Write_Stream_BE(const void* Data, uint16_t Length
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_ClearOUT();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return PIPE_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
Pipe_Write_Byte(*(DataStream--));
case 7: Pipe_Write_Byte(*(DataStream--));
case 6: Pipe_Write_Byte(*(DataStream--));
case 5: Pipe_Write_Byte(*(DataStream--));
case 4: Pipe_Write_Byte(*(DataStream--));
case 3: Pipe_Write_Byte(*(DataStream--));
case 2: Pipe_Write_Byte(*(DataStream--));
case 1: Pipe_Write_Byte(*(DataStream--));
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Pipe_IsReadWriteAllowed()))
@ -195,6 +275,46 @@ uint8_t Pipe_Discard_Stream(uint16_t Length
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_ClearIN();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return PIPE_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
Pipe_Discard_Byte();
case 7: Pipe_Discard_Byte();
case 6: Pipe_Discard_Byte();
case 5: Pipe_Discard_Byte();
case 4: Pipe_Discard_Byte();
case 3: Pipe_Discard_Byte();
case 2: Pipe_Discard_Byte();
case 1: Pipe_Discard_Byte();
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Pipe_IsReadWriteAllowed()))
@ -233,6 +353,46 @@ uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_ClearIN();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return PIPE_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
*(DataStream++) = Pipe_Read_Byte();
case 7: *(DataStream++) = Pipe_Read_Byte();
case 6: *(DataStream++) = Pipe_Read_Byte();
case 5: *(DataStream++) = Pipe_Read_Byte();
case 4: *(DataStream++) = Pipe_Read_Byte();
case 3: *(DataStream++) = Pipe_Read_Byte();
case 2: *(DataStream++) = Pipe_Read_Byte();
case 1: *(DataStream++) = Pipe_Read_Byte();
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Pipe_IsReadWriteAllowed()))
@ -271,6 +431,46 @@ uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
#if defined(FAST_STREAM_TRANSFERS)
uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
if (Length >= 8)
{
Length -= BytesRemToAlignment;
switch (BytesRemToAlignment)
{
default:
do
{
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_ClearIN();
#if !defined(NO_STREAM_CALLBACKS)
if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
return PIPE_RWSTREAM_CallbackAborted;
#endif
if ((ErrorCode = Pipe_WaitUntilReady()))
return ErrorCode;
}
Length -= 8;
*(DataStream--) = Pipe_Read_Byte();
case 7: *(DataStream--) = Pipe_Read_Byte();
case 6: *(DataStream--) = Pipe_Read_Byte();
case 5: *(DataStream--) = Pipe_Read_Byte();
case 4: *(DataStream--) = Pipe_Read_Byte();
case 3: *(DataStream--) = Pipe_Read_Byte();
case 2: *(DataStream--) = Pipe_Read_Byte();
case 1: *(DataStream--) = Pipe_Read_Byte();
} while (Length >= 8);
}
}
#endif
while (Length)
{
if (!(Pipe_IsReadWriteAllowed()))

50
LUFA/Drivers/USB/LowLevel/Pipe.h
Unescape View File

@ -187,13 +187,13 @@
/** Selects the given pipe number. Any pipe operations which do not require the pipe number to be
* indicated will operate on the currently selected pipe.
*
* \param PipeNumber Index of the pipe to select
* \param[in] PipeNumber Index of the pipe to select
*/
static inline void Pipe_SelectPipe(uint8_t PipeNumber);
/** Resets the desired pipe, including the pipe banks and flags.
*
* \param PipeNumber Index of the pipe to reset
* \param[in] PipeNumber Index of the pipe to reset
*/
static inline void Pipe_ResetPipe(uint8_t PipeNumber);
@ -226,7 +226,7 @@
* control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices
* which have two endpoints of opposite direction sharing the same endpoint address within the device.
*
* \param Token New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask
* \param[in] Token New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask
*/
static inline void Pipe_SetPipeToken(uint8_t Token);
@ -236,7 +236,7 @@
/** Configures the currently selected pipe to only allow the specified number of IN requests to be
* accepted by the pipe before it is automatically frozen.
*
* \param TotalINRequests Total number of IN requests that the pipe may receive before freezing
* \param[in] TotalINRequests Total number of IN requests that the pipe may receive before freezing
*/
static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);
@ -248,7 +248,7 @@
/** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.
*
* \param Milliseconds Number of milliseconds between each pipe poll
* \param[in] Milliseconds Number of milliseconds between each pipe poll
*/
static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);
@ -262,7 +262,7 @@
/** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type
* pipes).
*
* \param PipeNumber Index of the pipe whose interrupt flag should be tested
* \param[in] PipeNumber Index of the pipe whose interrupt flag should be tested
*
* \return Boolean true if the specified pipe has interrupted, false otherwise
*/
@ -516,7 +516,7 @@
*
* \ingroup Group_PipeRW
*
* \param Byte Next byte to write into the the currently selected pipe's FIFO buffer
* \param[in] Byte Next byte to write into the the currently selected pipe's FIFO buffer
*/
static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void Pipe_Write_Byte(const uint8_t Byte)
@ -577,7 +577,7 @@
*
* \ingroup Group_PipeRW
*
* \param Word Next word to write to the currently selected pipe's FIFO buffer
* \param[in] Word Next word to write to the currently selected pipe's FIFO buffer
*/
static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;
static inline void Pipe_Write_Word_LE(const uint16_t Word)
@ -591,7 +591,7 @@
*
* \ingroup Group_PipeRW
*
* \param Word Next word to write to the currently selected pipe's FIFO buffer
* \param[in] Word Next word to write to the currently selected pipe's FIFO buffer
*/
static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;
static inline void Pipe_Write_Word_BE(const uint16_t Word)
@ -666,7 +666,7 @@
*
* \ingroup Group_PipeRW
*
* \param DWord Next double word to write to the currently selected pipe's FIFO buffer
* \param[in] DWord Next double word to write to the currently selected pipe's FIFO buffer
*/
static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
static inline void Pipe_Write_DWord_LE(const uint32_t DWord)
@ -680,7 +680,7 @@
*
* \ingroup Group_PipeRW
*
* \param DWord Next double word to write to the currently selected pipe's FIFO buffer
* \param[in] DWord Next double word to write to the currently selected pipe's FIFO buffer
*/
static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
static inline void Pipe_Write_DWord_BE(const uint32_t DWord)
@ -771,9 +771,9 @@
*
* \ingroup Group_PipeRW
*
* \param Buffer Pointer to the source data buffer to read from.
* \param Length Number of bytes to read for the currently selected pipe into the buffer.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[in] Buffer Pointer to the source data buffer to read from.
* \param[in] Length Number of bytes to read for the currently selected pipe into the buffer.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/
@ -798,9 +798,9 @@
*
* \ingroup Group_PipeRW
*
* \param Buffer Pointer to the source data buffer to read from.
* \param Length Number of bytes to read for the currently selected pipe into the buffer.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[in] Buffer Pointer to the source data buffer to read from.
* \param[in] Length Number of bytes to read for the currently selected pipe into the buffer.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/
@ -825,8 +825,8 @@
*
* \ingroup Group_PipeRW
*
* \param Length Number of bytes to send via the currently selected pipe.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[in] Length Number of bytes to send via the currently selected pipe.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/
@ -851,9 +851,9 @@
*
* \ingroup Group_PipeRW
*
* \param Buffer Pointer to the source data buffer to write to.
* \param Length Number of bytes to read for the currently selected pipe to read from.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[out] Buffer Pointer to the source data buffer to write to.
* \param[in] Length Number of bytes to read for the currently selected pipe to read from.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/
@ -878,9 +878,9 @@
*
* \ingroup Group_PipeRW
*
* \param Buffer Pointer to the source data buffer to write to.
* \param Length Number of bytes to read for the currently selected pipe to read from.
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
* \param[out] Buffer Pointer to the source data buffer to write to.
* \param[in] Length Number of bytes to read for the currently selected pipe to read from.
* \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback
*
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.
*/

1
LUFA/ManPages/FutureChanges.txt
Unescape View File

@ -19,6 +19,7 @@
* - Add standardized descriptor names to class driver structures, controlled by USE_NONSTANDARD_DESCRIPTOR_NAMES
* - Update Host mode Class Driver demo .txt files
* - Debug mode for pipe/endpoint calls
* - Test and document new FAST_STREAM_TRANSFERS compile time option
*
* <b>Targeted for Future Releases:</b>
* - Remake AVRStudio project files

3
LUFA/ManPages/LibraryApps.txt
Unescape View File

@ -9,6 +9,9 @@
* The LUFA library ships with several different host and device demos, located in the /Demos/ subdirectory.
* If this directory is missing, please re-download the project from the project homepage. Within this directory the demos
* are seperated by USB mode (Device, Host, OTG) and further seperated by the use or non-use of the library USB Class drivers.
* With one or two exceptions (e.g. proprietary classes such as RNDIS) all the included demos will work across all OSes without
* the need for special drivers. One Windows, some demos require the supplied .INF file to be used as the device driver, which
* directs the OS to use its inbuilt class drivers for the device.
*
* Also included with the library are three fully functional bootloaders, located in the /Bootloaders/ subdirectory.
* The DFU class bootloader is compatible with Atmel's FLIP software or the open source dfu-programmer project, the

2
LUFA/ManPages/Licence.txt
Unescape View File

@ -5,7 +5,7 @@
*/
/**
* \page Page_Licence licence
* \page Page_Licence Source Code Licence
*
* The LUFA library is currently released under the MIT licence, included below.
*

14
LUFA/Scheduler/Scheduler.h
Unescape View File

@ -196,7 +196,7 @@
/** Resets the delay counter value to the current tick count. This should be called to reset the period
* for a delay in a task which is dependant on the current tick value.
*
* \param DelayCounter Counter which is storing the starting tick count for a given delay.
* \param[out] DelayCounter Counter which is storing the starting tick count for a given delay.
*/
static inline void Scheduler_ResetDelay(SchedulerDelayCounter_t* const DelayCounter)
ATTR_NON_NULL_PTR_ARG(1) ATTR_ALWAYS_INLINE;
@ -211,8 +211,8 @@
/* Function Prototypes: */
/** Determines if the given tick delay has elapsed, based on the given .
*
* \param Delay The delay to test for, measured in ticks
* \param DelayCounter The counter which is storing the starting tick value for the delay
* \param[in] Delay The delay to test for, measured in ticks
* \param[in] DelayCounter The counter which is storing the starting tick value for the delay
*
* \return Boolean true if the delay has elapsed, false otherwise
*
@ -233,16 +233,16 @@
/** Sets the task mode for a given task.
*
* \param Task Name of the task whose status is to be changed
* \param TaskStatus New task status for the task (TASK_RUN or TASK_STOP)
* \param[in] Task Name of the task whose status is to be changed
* \param[in] TaskStatus New task status for the task (TASK_RUN or TASK_STOP)
*/
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
* statuses changed at once.
*
* \param GroupID Value of the task group ID whose status is to be changed
* \param TaskStatus New task status for tasks in the specified group (TASK_RUN or TASK_STOP)
* \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 (TASK_RUN or TASK_STOP)
*/
void Scheduler_SetGroupTaskMode(const uint8_t GroupID, const bool TaskStatus);

8
Projects/Magstripe/Lib/CircularBitBuffer.h
Unescape View File

@ -73,20 +73,20 @@
/* Function Prototypes: */
/** Initializes or resets a given bit buffer, ready to store new bits.
*
* \param Buffer Bit buffer to initialize
* \param[in,out] Buffer Bit buffer to initialize
*/
void BitBuffer_Init(BitBuffer_t* Buffer) ATTR_NON_NULL_PTR_ARG(1);
/** Stores a bit into the next location inside a given bit buffer.
*
* \param Buffer Bit buffer to store a bit into
* \param Bit Bit to store into the buffer
* \param[in,out] Buffer Bit buffer to store a bit into
* \param[in] Bit Bit to store into the buffer
*/
void BitBuffer_StoreNextBit(BitBuffer_t* Buffer, bool Bit) ATTR_NON_NULL_PTR_ARG(1);
/** Retrieves a bit from the next location inside a given bit buffer.
*
* \param Buffer Bit buffer to store a bit into
* \param[in,out] Buffer Bit buffer to store a bit into
*
* \return Next bit from the buffer
*/

14
Projects/Magstripe/Magstripe.c
Unescape View File

@ -160,9 +160,9 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
/** HID Class driver callback function for the creation of a HID report for the host.
*
* \param HIDInterfaceInfo Pointer to the HID interface structure for the HID interface being referenced
* \param ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param ReportData Pointer to the preallocated report buffer where the created report should be stored
* \param[in] HIDInterfaceInfo Pointer to the HID interface structure for the HID interface being referenced
* \param[in,out] ReportID Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
* \param[out] ReportData Pointer to the preallocated report buffer where the created report should be stored
*
* \return Number of bytes in the created report
*/
@ -209,10 +209,10 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
/** HID Class driver callback function for the processing of a received HID report from the host.
*
* \param HIDInterfaceInfo Pointer to the HID interface structure for the HID interface being referenced
* \param ReportID Report ID of the received report from the host
* \param ReportData Pointer to the report buffer where the received report is stored
* \param ReportSize Size in bytes of the report received from the host
* \param[in] HIDInterfaceInfo Pointer to the HID interface structure for the HID interface being referenced
* \param[in] ReportID Report ID of the received report from the host
* \param[in] ReportData Pointer to the report buffer where the received report is stored
* \param[in] ReportSize Size in bytes of the report received from the host
*/
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,
void* ReportData, uint16_t ReportSize)

12
Projects/MissileLauncher/MissileLauncher.c
Unescape View File

@ -154,8 +154,8 @@ void Read_Joystick_Status(void)
/** Lower level send routine, copies report into a larger buffer and sends.
*
* \param Report Report data to send.
* \param ReportSize Report length in bytes.
* \param[in] Report Report data to send.
* \param[in] ReportSize Report length in bytes.
*/
void Send_Command_Report(uint8_t *Report, uint16_t ReportSize)
{
@ -163,9 +163,9 @@ void Send_Command_Report(uint8_t *Report, uint16_t ReportSize)
WriteNextReport(CmdBuffer, ReportSize);
}
/** Send one of the CMD_* command constants listed above.
/** Sends one of the CMD_* command constants to the attached device.
*
* \param Command One of the command constants.
* \param[in] Command One of the command constants.
*/
void Send_Command(uint8_t* Command)
{
@ -248,8 +248,8 @@ void DiscardNextReport(void)
/** Writes a report to the attached device.
*
* \param ReportOUTData Buffer containing the report to send to the device
* \param ReportLength Length of the report to send
* \param[in] ReportOUTData Buffer containing the report to send to the device
* \param[in] ReportLength Length of the report to send
*/
void WriteNextReport(uint8_t* ReportOUTData, uint16_t ReportLength)
{

Write Preview
Loading…
Cancel
Save