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

4
Bootloaders/CDC/BootloaderCDC.c
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
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
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
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
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)
{

10
LUFA/Common/Common.h
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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

Some files were not shown because too many files have changed in this diff Show more