ahoneybun/qmk_firmware
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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).
This commit is contained in:
Dean Camera 2009-06-28 13:39:08 +00:00
parent 3cbdcd3686
commit f1076ac4d6
115 changed files with 1031 additions and 633 deletions
Download patch file Download diff file Expand all files Collapse all files

20
Demos/Device/ClassDriver/GenericHID/GenericHID.c
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
{