Added const modifiers to device mode class drivers.

Added parameter directions to function parameter documentation.

Added new experimental FAST_STREAM_FUNCTIONS compile time option to speed up stream transfers at the expense of a higher FLASH consumption (needs testing to verify improved throughput).

diff --git a/Bootloaders/CDC/BootloaderCDC.c b/Bootloaders/CDC/BootloaderCDC.c
index 92c2291..d875b84 100644 (file)
--- a/Bootloaders/CDC/BootloaderCDC.c
+++ b/Bootloaders/CDC/BootloaderCDC.c
@@ -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\r
  *  on the AVR910 protocol command issued.\r
  *\r
 /** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending\r
  *  on the AVR910 protocol command issued.\r
  *\r

- *  \param Command  Single character AVR910 protocol command indicating what memory operation to perform\r
+ *  \param[in] Command  Single character AVR910 protocol command indicating what memory operation to perform\r

  */\r
 static void ReadWriteMemoryBlock(const uint8_t Command)\r
 {\r
  */\r
 static void ReadWriteMemoryBlock(const uint8_t Command)\r
 {\r


@@ -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\r
  *  bank when full ready for the next byte in the packet to the host.\r
  *\r
 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the\r
  *  bank when full ready for the next byte in the packet to the host.\r
  *\r

- *  \param Response  Next response byte to send to the host\r
+ *  \param[in] Response  Next response byte to send to the host\r

  */\r
 static void WriteNextResponseByte(const uint8_t Response)\r
 {\r
  */\r
 static void WriteNextResponseByte(const uint8_t Response)\r
 {\r

diff --git a/Bootloaders/CDC/Descriptors.h b/Bootloaders/CDC/Descriptors.h
index 62d7598..8bccd68 100644 (file)
--- a/Bootloaders/CDC/Descriptors.h
+++ b/Bootloaders/CDC/Descriptors.h
@@ -84,7 +84,7 @@
                 *  type define so that the same macro can be used for functional descriptors of varying data lengths,\r
                 *  while allowing the sizeof() operator to return correct results.\r
                 *\r
                 *  type define so that the same macro can be used for functional descriptors of varying data lengths,\r
                 *  while allowing the sizeof() operator to return correct results.\r
                 *\r

-                *  \param DataSize  Size of the functional descriptor's data payload, in bytes\r
+                *  \param[in] DataSize  Size of the functional descriptor's data payload, in bytes\r

                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/Bootloaders/DFU/BootloaderDFU.c b/Bootloaders/DFU/BootloaderDFU.c
index b8a2518..2086a91 100644 (file)
--- a/Bootloaders/DFU/BootloaderDFU.c
+++ b/Bootloaders/DFU/BootloaderDFU.c
@@ -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\r
  *  discard unused bytes in the stream from the host, including the memory program block suffix.\r
  *\r
 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to\r
  *  discard unused bytes in the stream from the host, including the memory program block suffix.\r
  *\r

- *  \param NumberOfBytes  Number of bytes to discard from the host from the control endpoint\r
+ *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint\r

  */\r
 static void DiscardFillerBytes(uint8_t NumberOfBytes)\r
 {\r
  */\r
 static void DiscardFillerBytes(uint8_t NumberOfBytes)\r
 {\r

diff --git a/Bootloaders/DFU/BootloaderDFU.h b/Bootloaders/DFU/BootloaderDFU.h
index a47da3d..9366c22 100644 (file)
--- a/Bootloaders/DFU/BootloaderDFU.h
+++ b/Bootloaders/DFU/BootloaderDFU.h
@@ -76,16 +76,16 @@
                \r
                /** Convenience macro, used to determine if the issued command is the given one-byte long command.\r
                 *\r
                \r
                /** Convenience macro, used to determine if the issued command is the given one-byte long command.\r
                 *\r

-                *  \param dataarr  Command byte array to check against\r
-                *  \param cb1      First command byte to check\r
+                *  \param[in] dataarr  Command byte array to check against\r
+                *  \param[in] cb1      First command byte to check\r

                 */\r
                #define IS_ONEBYTE_COMMAND(dataarr, cb1)       (dataarr[0] == cb1)\r
 \r
                /** Convenience macro, used to determine if the issued command is the given two-byte long command.\r
                 *\r
                 */\r
                #define IS_ONEBYTE_COMMAND(dataarr, cb1)       (dataarr[0] == cb1)\r
 \r
                /** Convenience macro, used to determine if the issued command is the given two-byte long command.\r
                 *\r

-                *  \param dataarr  Command byte array to check against\r
-                *  \param cb1      First command byte to check\r
-                *  \param cb2      Second command byte to check\r
+                *  \param[in] dataarr  Command byte array to check against\r
+                *  \param[in] cb1      First command byte to check\r
+                *  \param[in] cb2      Second command byte to check\r

                 */\r
                #define IS_TWOBYTE_COMMAND(dataarr, cb1, cb2) ((dataarr[0] == cb1) && (dataarr[1] == cb2))\r
        \r
                 */\r
                #define IS_TWOBYTE_COMMAND(dataarr, cb1, cb2) ((dataarr[0] == cb1) && (dataarr[1] == cb2))\r
        \r

diff --git a/Demos/Device/ClassDriver/GenericHID/GenericHID.c b/Demos/Device/ClassDriver/GenericHID/GenericHID.c
index 823fa45..3f9c402 100644 (file)
--- a/Demos/Device/ClassDriver/GenericHID/GenericHID.c
+++ b/Demos/Device/ClassDriver/GenericHID/GenericHID.c
@@ -131,13 +131,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
- *  \param ReportData  Pointer to a buffer where the created report should be stored\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
+ *  \param[out] ReportData  Pointer to a buffer where the created report should be stored\r

  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r
  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r

-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)\r
+uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)\r

 {\r
        // Create generic HID report here\r
        \r
 {\r
        // Create generic HID report here\r
        \r


@@ -146,13 +146,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID of the received report from the host\r
- *  \param ReportData  Pointer to a buffer where the created report has been stored\r
- *  \param ReportSize  Size in bytes of the received HID report\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in] ReportID  Report ID of the received report from the host\r
+ *  \param[in] ReportData  Pointer to a buffer where the created report has been stored\r
+ *  \param[in] ReportSize  Size in bytes of the received HID report\r

  */\r
  */\r

-void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
-                                          void* ReportData, uint16_t ReportSize)\r
+void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
+                                          const void* ReportData, const uint16_t ReportSize)\r

 {\r
        // Process received generic HID report here\r
 }\r
 {\r
        // Process received generic HID report here\r
 }\r

diff --git a/Demos/Device/ClassDriver/GenericHID/GenericHID.h b/Demos/Device/ClassDriver/GenericHID/GenericHID.h
index 843b262..6d5de71 100644 (file)
--- a/Demos/Device/ClassDriver/GenericHID/GenericHID.h
+++ b/Demos/Device/ClassDriver/GenericHID/GenericHID.h
@@ -72,9 +72,9 @@
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r

-               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,\r
+               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r

                                                             void* ReportData);\r
                                                             void* ReportData);\r

-               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, \r
-                                                             void* ReportData, uint16_t ReportSize);\r
+               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, \r
+                                                             const void* ReportData, const uint16_t ReportSize);\r

                \r
 #endif\r
                \r
 #endif\r

diff --git a/Demos/Device/ClassDriver/Joystick/Joystick.c b/Demos/Device/ClassDriver/Joystick/Joystick.c
index 0a1d380..1e13e99 100644 (file)
--- a/Demos/Device/ClassDriver/Joystick/Joystick.c
+++ b/Demos/Device/ClassDriver/Joystick/Joystick.c
@@ -133,13 +133,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
- *  \param ReportData  Pointer to a buffer where the created report should be stored\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
+ *  \param[out] ReportData  Pointer to a buffer where the created report should be stored\r

  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r
  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r

-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)\r
+uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)\r

 {\r
        USB_JoystickReport_Data_t* JoystickReport = (USB_JoystickReport_Data_t*)ReportData;\r
        \r
 {\r
        USB_JoystickReport_Data_t* JoystickReport = (USB_JoystickReport_Data_t*)ReportData;\r
        \r


@@ -167,13 +167,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID of the received report from the host\r
- *  \param ReportData  Pointer to a buffer where the created report has been stored\r
- *  \param ReportSize  Size in bytes of the received HID report\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in] ReportID  Report ID of the received report from the host\r
+ *  \param[in] ReportData  Pointer to a buffer where the created report has been stored\r
+ *  \param[in] ReportSize  Size in bytes of the received HID report\r

  */\r
  */\r

-void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
-                                          void* ReportData, uint16_t ReportSize)\r
+void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
+                                          const void* ReportData, const uint16_t ReportSize)\r

 {\r
        // Unused (but mandatory for the HID class driver) in this demo, since there are no Host->Device reports\r
 }\r
 {\r
        // Unused (but mandatory for the HID class driver) in this demo, since there are no Host->Device reports\r
 }\r

diff --git a/Demos/Device/ClassDriver/Joystick/Joystick.h b/Demos/Device/ClassDriver/Joystick/Joystick.h
index 343b190..0f35fcc 100644 (file)
--- a/Demos/Device/ClassDriver/Joystick/Joystick.h
+++ b/Demos/Device/ClassDriver/Joystick/Joystick.h
@@ -83,9 +83,9 @@
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r

-               uint16_t CALLBACK_HID_Device_CreateNextHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,\r
+               uint16_t CALLBACK_HID_Device_CreateNextHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r

                                                                 void* ReportData);\r
                                                                 void* ReportData);\r

-               void     CALLBACK_HID_Device_ProcessReceivedHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, \r
-                                                                     void* ReportData, uint16_t ReportSize);\r
+               void     CALLBACK_HID_Device_ProcessReceivedHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, const uint8_t ReportID, \r
+                                                                     const void* ReportData, const uint16_t ReportSize);\r

 \r
 #endif\r
 \r
 #endif\r

diff --git a/Demos/Device/ClassDriver/Keyboard/Keyboard.c b/Demos/Device/ClassDriver/Keyboard/Keyboard.c
index f44a934..af56a22 100644 (file)
--- a/Demos/Device/ClassDriver/Keyboard/Keyboard.c
+++ b/Demos/Device/ClassDriver/Keyboard/Keyboard.c
@@ -134,13 +134,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
- *  \param ReportData  Pointer to a buffer where the created report should be stored\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
+ *  \param[out] ReportData  Pointer to a buffer where the created report should be stored\r

  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r
  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r

-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)\r
+uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)\r

 {\r
        USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;\r
        \r
 {\r
        USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;\r
        \r


@@ -168,13 +168,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID of the received report from the host\r
- *  \param ReportData  Pointer to a buffer where the created report has been stored\r
- *  \param ReportSize  Size in bytes of the received HID report\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in] ReportID  Report ID of the received report from the host\r
+ *  \param[in] ReportData  Pointer to a buffer where the created report has been stored\r
+ *  \param[in] ReportSize  Size in bytes of the received HID report\r

  */\r
  */\r

-void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
-                                          void* ReportData, uint16_t ReportSize)\r
+void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
+                                          const void* ReportData, const uint16_t ReportSize)\r

 {\r
        uint8_t  LEDMask   = LEDS_NO_LEDS;\r
        uint8_t* LEDReport = (uint8_t*)ReportData;\r
 {\r
        uint8_t  LEDMask   = LEDS_NO_LEDS;\r
        uint8_t* LEDReport = (uint8_t*)ReportData;\r

diff --git a/Demos/Device/ClassDriver/Keyboard/Keyboard.h b/Demos/Device/ClassDriver/Keyboard/Keyboard.h
index 3dc7eae..52b07ce 100644 (file)
--- a/Demos/Device/ClassDriver/Keyboard/Keyboard.h
+++ b/Demos/Device/ClassDriver/Keyboard/Keyboard.h
@@ -86,9 +86,9 @@
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r

-               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,\r
+               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r

                                                             void* ReportData);\r
                                                             void* ReportData);\r

-               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, \r
-                                                             void* ReportData, uint16_t ReportSize);\r
+               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, \r
+                                                             const void* ReportData, const uint16_t ReportSize);\r

 \r
 #endif\r
 \r
 #endif\r

diff --git a/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.c b/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.c
index 9372219..5c33eeb 100644 (file)
--- a/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.c
+++ b/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.c
@@ -165,13 +165,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
- *  \param ReportData  Pointer to a buffer where the created report should be stored\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
+ *  \param[out] ReportData  Pointer to a buffer where the created report should be stored\r

  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r
  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r

-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)\r
+uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)\r

 {\r
        uint8_t JoyStatus_LCL    = Joystick_GetStatus();\r
        uint8_t ButtonStatus_LCL = Buttons_GetStatus();\r
 {\r
        uint8_t JoyStatus_LCL    = Joystick_GetStatus();\r
        uint8_t ButtonStatus_LCL = Buttons_GetStatus();\r


@@ -226,13 +226,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID of the received report from the host\r
- *  \param ReportData  Pointer to a buffer where the created report has been stored\r
- *  \param ReportSize  Size in bytes of the received HID report\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in] ReportID  Report ID of the received report from the host\r
+ *  \param[in] ReportData  Pointer to a buffer where the created report has been stored\r
+ *  \param[in] ReportSize  Size in bytes of the received HID report\r

  */\r
  */\r

-void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
-                                          void* ReportData, uint16_t ReportSize)\r
+void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
+                                          const void* ReportData, const uint16_t ReportSize)\r

 {\r
        if (HIDInterfaceInfo == &Keyboard_HID_Interface)\r
        {\r
 {\r
        if (HIDInterfaceInfo == &Keyboard_HID_Interface)\r
        {\r

diff --git a/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.h b/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.h
index 81ca3f6..a04051b 100644 (file)
--- a/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.h
+++ b/Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.h
@@ -90,9 +90,9 @@
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r

-               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,\r
+               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r

                                                             void* ReportData);\r
                                                             void* ReportData);\r

-               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, \r
-                                                             void* ReportData, uint16_t ReportSize);\r
+               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, \r
+                                                             const void* ReportData, const uint16_t ReportSize);\r

                \r
 #endif\r
                \r
 #endif\r

diff --git a/Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c b/Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c
index 5b5a2bd..326f660 100644 (file)
--- a/Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c
+++ b/Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c
@@ -43,9 +43,9 @@
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes\r
  *  them to the dataflash in Dataflash page sized blocks.\r
  *\r
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes\r
  *  them to the dataflash in Dataflash page sized blocks.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to a Mass Storage class state structure for the Mass Storage interface being used\r
- *  \param BlockAddress  Data block starting address for the write sequence\r
- *  \param TotalBlocks   Number of blocks of data to write\r
+ *  \param[in] MSInterfaceInfo  Pointer to a Mass Storage class state structure for the Mass Storage interface being used\r
+ *  \param[in] BlockAddress  Data block starting address for the write sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to write\r

  */\r
 void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r
  */\r
 void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r


@@ -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\r
  *  and writes them in OS sized blocks to the endpoint.\r
  *\r
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash\r
  *  and writes them in OS sized blocks to the endpoint.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to a Mass Storage class state structure for the Mass Storage interface being used\r
- *  \param BlockAddress  Data block starting address for the read sequence\r
- *  \param TotalBlocks   Number of blocks of data to read\r
+ *  \param[in] MSInterfaceInfo  Pointer to a Mass Storage class state structure for the Mass Storage interface being used\r
+ *  \param[in] BlockAddress  Data block starting address for the read sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to read\r

  */\r
 void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r
  */\r
 void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* MSInterfaceInfo, const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r


@@ -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\r
  *  dataflash.\r
  *\r
  *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the\r
  *  dataflash.\r
  *\r

- *  \param BlockAddress  Data block starting address for the write sequence\r
- *  \param TotalBlocks   Number of blocks of data to write\r
- *  \param BufferPtr     Pointer to the data source RAM buffer\r
+ *  \param[in] BlockAddress  Data block starting address for the write sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to write\r
+ *  \param[in] BufferPtr     Pointer to the data source RAM buffer\r

  */\r
 void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r
  */\r
 void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r


@@ -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\r
  *  the files stored on the dataflash.\r
  *\r
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read\r
  *  the files stored on the dataflash.\r
  *\r

- *  \param BlockAddress  Data block starting address for the read sequence\r
- *  \param TotalBlocks   Number of blocks of data to read\r
- *  \param BufferPtr     Pointer to the data destination RAM buffer\r
+ *  \param[in] BlockAddress  Data block starting address for the read sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to read\r
+ *  \param[out] BufferPtr     Pointer to the data destination RAM buffer\r

  */\r
 void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r
  */\r
 void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r

diff --git a/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c b/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c
index 4e6c050..08f11b7 100644 (file)
--- a/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c
+++ b/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c
@@ -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\r
  *  a command failure due to a ILLEGAL REQUEST.\r
  *\r
  *  to the appropriate SCSI command handling routine if the issued command is supported by the device, else it returns\r
  *  a command failure due to a ILLEGAL REQUEST.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r

  */\r
 bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
 {\r
  */\r
 bool SCSI_DecodeSCSICommand(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
 {\r


@@ -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\r
  *  and capabilities to the host.\r
  *\r
 /** Command processing for an issued SCSI INQUIRY command. This command returns information about the device's features\r
  *  and capabilities to the host.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r

  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r
  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r


@@ -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,\r
  *  including the error code and additional error information so that the host can determine why a command failed to complete.\r
  *\r
 /** Command processing for an issued SCSI REQUEST SENSE command. This command returns information about the last issued command,\r
  *  including the error code and additional error information so that the host can determine why a command failed to complete.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r

  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r
  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r


@@ -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\r
  *  on the selected Logical Unit (drive), as a number of OS-sized blocks.\r
  *\r
 /** Command processing for an issued SCSI READ CAPACITY (10) command. This command returns information about the device's capacity\r
  *  on the selected Logical Unit (drive), as a number of OS-sized blocks.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r

  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r
  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r


@@ -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\r
  *  supported.\r
  *\r
  *  board, and indicates if they are present and functioning correctly. Only the Self-Test portion of the diagnostic command is\r
  *  supported.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r

  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r
  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r


@@ -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\r
  *  reading and writing of the data.\r
  *\r
  *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual\r
  *  reading and writing of the data.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
- *  \param IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with\r
+ *  \param[in] IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)\r

  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r
  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r

diff --git a/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.h b/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.h
index bf61d8e..052f908 100644 (file)
--- a/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.h
+++ b/Demos/Device/ClassDriver/MassStorage/Lib/SCSI.h
@@ -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\r
                 *  the last command failure) in a quick and easy manner.\r
                 *\r
                 *  is for convenience, as it allows for all three sense values (returned upon request to the host to give information about\r
                 *  the last command failure) in a quick and easy manner.\r
                 *\r

-                *  \param key    New SCSI sense key to set the sense code to\r
-                *  \param acode  New SCSI additional sense key to set the additional sense code to\r
-                *  \param aqual  New SCSI additional sense key qualifier to set the additional sense qualifier code to\r
+                *  \param[in] key    New SCSI sense key to set the sense code to\r
+                *  \param[in] acode  New SCSI additional sense key to set the additional sense code to\r
+                *  \param[in] aqual  New SCSI additional sense key qualifier to set the additional sense qualifier code to\r

                 */\r
                #define SCSI_SET_SENSE(key, acode, aqual)  MACROS{ SenseData.SenseKey = key;              \\r
                                                                   SenseData.AdditionalSenseCode = acode; \\r
                 */\r
                #define SCSI_SET_SENSE(key, acode, aqual)  MACROS{ SenseData.SenseKey = key;              \\r
                                                                   SenseData.AdditionalSenseCode = acode; \\r

diff --git a/Demos/Device/ClassDriver/MassStorage/MassStorage.c b/Demos/Device/ClassDriver/MassStorage/MassStorage.c
index 87da975..0a6604c 100644 (file)
--- a/Demos/Device/ClassDriver/MassStorage/MassStorage.c
+++ b/Demos/Device/ClassDriver/MassStorage/MassStorage.c
@@ -125,7 +125,7 @@ void EVENT_USB_UnhandledControlPacket(void)
 \r
 /** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.\r
  *\r
 \r
 /** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.\r
  *\r

- *  \param MSInterfaceInfo  Pointer to the Mass Storage class interface configuration structure being referenced\r
+ *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface configuration structure being referenced\r

  */\r
 bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
 {\r
  */\r
 bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
 {\r

diff --git a/Demos/Device/ClassDriver/Mouse/Mouse.c b/Demos/Device/ClassDriver/Mouse/Mouse.c
index 0d63c7a..45d14a3 100644 (file)
--- a/Demos/Device/ClassDriver/Mouse/Mouse.c
+++ b/Demos/Device/ClassDriver/Mouse/Mouse.c
@@ -133,13 +133,13 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r
 \r
 /** HID class driver callback function for the creation of HID reports to the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
- *  \param ReportData  Pointer to a buffer where the created report should be stored\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
+ *  \param[out] ReportData  Pointer to a buffer where the created report should be stored\r

  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r
  *\r
  *  \return Number of bytes written in the report (or zero if no report is to be sent\r
  */\r

-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData)\r
+uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)\r

 {\r
        USB_MouseReport_Data_t* MouseReport = (USB_MouseReport_Data_t*)ReportData;\r
                \r
 {\r
        USB_MouseReport_Data_t* MouseReport = (USB_MouseReport_Data_t*)ReportData;\r
                \r


@@ -167,13 +167,13 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r
 \r
 /** HID class driver callback function for the processing of HID reports from the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
- *  \param ReportID  Report ID of the received report from the host\r
- *  \param ReportData  Pointer to a buffer where the created report has been stored\r
- *  \param ReportSize  Size in bytes of the received HID report\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced\r
+ *  \param[in] ReportID  Report ID of the received report from the host\r
+ *  \param[in] ReportData  Pointer to a buffer where the created report has been stored\r
+ *  \param[in] ReportSize  Size in bytes of the received HID report\r

  */\r
  */\r

-void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
-                                          void* ReportData, uint16_t ReportSize)\r
+void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
+                                          const void* ReportData, const uint16_t ReportSize)\r

 {\r
        // Unused (but mandatory for the HID class driver) in this demo, since there are no Host->Device reports\r
 }\r
 {\r
        // Unused (but mandatory for the HID class driver) in this demo, since there are no Host->Device reports\r
 }\r

diff --git a/Demos/Device/ClassDriver/Mouse/Mouse.h b/Demos/Device/ClassDriver/Mouse/Mouse.h
index f973f72..f134d92 100644 (file)
--- a/Demos/Device/ClassDriver/Mouse/Mouse.h
+++ b/Demos/Device/ClassDriver/Mouse/Mouse.h
@@ -85,9 +85,9 @@
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
 \r

-               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID,\r
+               uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r

                                                             void* ReportData);\r
                                                             void* ReportData);\r

-               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, \r
-                                                             void* ReportData, uint16_t ReportSize);\r
+               void     CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, \r
+                                                             const void* ReportData, const uint16_t ReportSize);\r

 \r
 #endif\r
 \r
 #endif\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Descriptors.h b/Demos/Device/ClassDriver/RNDISEthernet/Descriptors.h
index eb43735..28b801f 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Descriptors.h
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Descriptors.h
@@ -47,7 +47,7 @@
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r

-                *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload\r
+                *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload\r

                 */             \r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */             \r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/ARP.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/ARP.c
index 0f108c2..c3f0d14 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/ARP.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/ARP.c
@@ -41,8 +41,8 @@
  *  to the output Ethernet frame if the host is requesting the IP or MAC address of the\r
  *  virtual server device on the network.\r
  *\r
  *  to the output Ethernet frame if the host is requesting the IP or MAC address of the\r
  *  virtual server device on the network.\r
  *\r

- *  \param InDataStart   Pointer to the start of the incoming packet's ARP header\r
- *  \param OutDataStart  Pointer to the start of the outgoing packet's ARP header\r
+ *  \param[in] InDataStart   Pointer to the start of the incoming packet's ARP header\r
+ *  \param[out] OutDataStart  Pointer to the start of the outgoing packet's ARP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/DHCP.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/DHCP.c
index 76711fb..89d5bc9 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/DHCP.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/DHCP.c
@@ -40,9 +40,9 @@
 /** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is requesting or accepting an IP address.\r
  *\r
 /** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is requesting or accepting an IP address.\r
  *\r

- *  \param IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
- *  \param DHCPHeaderInStart   Pointer to the start of the incoming packet's DHCP header\r
- *  \param DHCPHeaderOutStart  Pointer to the start of the outgoing packet's DHCP header\r
+ *  \param[in] IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
+ *  \param[in] DHCPHeaderInStart   Pointer to the start of the incoming packet's DHCP header\r
+ *  \param[out] DHCPHeaderOutStart  Pointer to the start of the outgoing packet's DHCP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c
index 57380a0..fb6bb1a 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c
@@ -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\r
  *  compliment of each word, complimented.\r
  *\r
 /** Calculates the appropriate ethernet checksum, consisting of the addition of the one's\r
  *  compliment of each word, complimented.\r
  *\r

- *  \param Data   Pointer to the packet buffer data whose checksum must be calculated\r
- *  \param Bytes  Number of bytes in the data buffer to process\r
+ *  \param[in] Data   Pointer to the packet buffer data whose checksum must be calculated\r
+ *  \param[in] Bytes  Number of bytes in the data buffer to process\r

  *\r
  *  \return A 16-bit Ethernet checksum value\r
  */\r
  *\r
  *  \return A 16-bit Ethernet checksum value\r
  */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.h b/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.h
index 0708268..a867ff6 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.h
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.h
@@ -63,8 +63,8 @@
        \r
                /** Performs a comparison between two MAC addresses, indicating if they are identical.\r
                 *  \r
        \r
                /** Performs a comparison between two MAC addresses, indicating if they are identical.\r
                 *  \r

-                *  \param MAC1  First MAC address\r
-                *  \param MAC2  Second MAC address\r
+                *  \param[in] MAC1  First MAC address\r
+                *  \param[in] MAC2  Second MAC address\r

                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r
                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/ICMP.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/ICMP.c
index ee87f83..618faea 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/ICMP.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/ICMP.c
@@ -40,9 +40,9 @@
 /** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is issuing a ICMP ECHO request.\r
  *\r
 /** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is issuing a ICMP ECHO request.\r
  *\r

- *  \param FrameIN  Pointer to the incomming Ethernet frame information structure\r
- *  \param InDataStart   Pointer to the start of the incoming packet's ICMP header\r
- *  \param OutDataStart  Pointer to the start of the outgoing packet's ICMP header\r
+ *  \param[in] FrameIN        Pointer to the incomming Ethernet frame information structure\r
+ *  \param[in] InDataStart    Pointer to the start of the incoming packet's ICMP header\r
+ *  \param[out] OutDataStart  Pointer to the start of the outgoing packet's ICMP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.c
index c5c38fc..db09a26 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.c
@@ -39,9 +39,9 @@
 /** Processes an IP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if one is created by a subprotocol handler.\r
  *\r
 /** Processes an IP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if one is created by a subprotocol handler.\r
  *\r

- *  \param FrameIN       Pointer to the incomming Ethernet frame information structure\r
- *  \param InDataStart   Pointer to the start of the incoming packet's IP header\r
- *  \param OutDataStart  Pointer to the start of the outgoing packet's IP header\r
+ *  \param[in] FrameIN        Pointer to the incomming Ethernet frame information structure\r
+ *  \param[in] InDataStart    Pointer to the start of the incoming packet's IP header\r
+ *  \param[out] OutDataStart  Pointer to the start of the outgoing packet's IP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.h b/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.h
index f77c772..ebb9270 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.h
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/IP.h
@@ -59,8 +59,8 @@
                \r
                /** Performs a comparison between two IP addresses, indicating if they are identical.\r
                 *  \r
                \r
                /** Performs a comparison between two IP addresses, indicating if they are identical.\r
                 *  \r

-                *  \param IP1  First IP address\r
-                *  \param IP2  Second IP address\r
+                *  \param[in] IP1  First IP address\r
+                *  \param[in] IP2  Second IP address\r

                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r
                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/ProtocolDecoders.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/ProtocolDecoders.c
index add0333..aac72ae 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/ProtocolDecoders.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/ProtocolDecoders.c
@@ -51,7 +51,7 @@
 \r
 /** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an Ethernet frame header\r
+ *  \param[in] InDataStart  Pointer to the start of an Ethernet frame header\r

  */\r
 void DecodeEthernetFrameHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeEthernetFrameHeader(void* InDataStart)\r
 {\r


@@ -93,7 +93,7 @@ void DecodeEthernetFrameHeader(void* InDataStart)
 \r
 /** Decodes an ARP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an ARP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an ARP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of an ARP packet header\r

  */\r
 void DecodeARPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeARPHeader(void* InDataStart)\r
 {\r


@@ -143,7 +143,7 @@ void DecodeARPHeader(void* InDataStart)
 \r
 /** Decodes an IP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an IP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an IP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of an IP packet header\r

  */\r
 void DecodeIPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeIPHeader(void* InDataStart)\r
 {\r


@@ -181,7 +181,7 @@ void DecodeIPHeader(void* InDataStart)
 \r
 /** Decodes an ICMP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an ICMP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an ICMP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of an ICMP packet header\r

  */\r
 void DecodeICMPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeICMPHeader(void* InDataStart)\r
 {\r


@@ -197,7 +197,7 @@ void DecodeICMPHeader(void* InDataStart)
 \r
 /** Decodes a TCP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes a TCP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of a TCP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of a TCP packet header\r

  */\r
 void DecodeTCPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeTCPHeader(void* InDataStart)\r
 {\r


@@ -225,7 +225,7 @@ void DecodeTCPHeader(void* InDataStart)
 \r
 /** Decodes an UDP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an UDP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of a UDP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of a UDP packet header\r

  */\r
 void DecodeUDPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeUDPHeader(void* InDataStart)\r
 {\r


@@ -243,7 +243,7 @@ void DecodeUDPHeader(void* InDataStart)
 \r
 /** Decodes an DHCP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an DHCP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of a DHCP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of a DHCP packet header\r

  */\r
 void DecodeDHCPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeDHCPHeader(void* InDataStart)\r
 {\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.c
index 6527149..6746433 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.c
@@ -171,9 +171,9 @@ void TCP_Init(void)
 \r
 /** Sets the state and callback handler of the given port, specified in big endian to the given state.\r
  *\r
 \r
 /** Sets the state and callback handler of the given port, specified in big endian to the given state.\r
  *\r

- *  \param Port     Port whose state and callback function to set, specified in big endian\r
- *  \param State    New state of the port, a value from the TCP_PortStates_t enum\r
- *  \param Handler  Application callback handler for the port\r
+ *  \param[in] Port     Port whose state and callback function to set, specified in big endian\r
+ *  \param[in] State    New state of the port, a value from the TCP_PortStates_t enum\r
+ *  \param[in] Handler  Application callback handler for the port\r

  *\r
  *  \return Boolean true if the port state was set, false otherwise (no more space in the port state table)\r
  */\r
  *\r
  *  \return Boolean true if the port state was set, false otherwise (no more space in the port state table)\r
  */\r


@@ -220,7 +220,7 @@ bool TCP_SetPortState(uint16_t Port, uint8_t State, void (*Handler)(TCP_Connecti
 \r
 /** Retrieves the current state of a given TCP port, specified in big endian.\r
  *\r
 \r
 /** Retrieves the current state of a given TCP port, specified in big endian.\r
  *\r

- *  \param Port  TCP port whose state is to be retrieved, given in big-endian\r
+ *  \param[in] Port  TCP port whose state is to be retrieved, given in big-endian\r

  *\r
  *  \return A value from the TCP_PortStates_t enum\r
  */\r
  *\r
  *  \return A value from the TCP_PortStates_t enum\r
  */\r


@@ -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\r
  *  connection exists in the connection state table it is updated, otherwise it is created if possible.\r
  *\r
 /** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the\r
  *  connection exists in the connection state table it is updated, otherwise it is created if possible.\r
  *\r

- *  \param Port           TCP port of the connection on the device, specified in big endian\r
- *  \param RemoteAddress  Remote protocol IP address of the connected device\r
- *  \param RemotePort     TCP port of the remote device in the connection, specified in big endian\r
- *  \param State          TCP connection state, a value from the TCP_ConnectionStates_t enum\r
+ *  \param[in] Port           TCP port of the connection on the device, specified in big endian\r
+ *  \param[in] RemoteAddress  Remote protocol IP address of the connected device\r
+ *  \param[in] RemotePort     TCP port of the remote device in the connection, specified in big endian\r
+ *  \param[in] State          TCP connection state, a value from the TCP_ConnectionStates_t enum\r

  *\r
  *  \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)\r
  */\r
  *\r
  *  \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)\r
  */\r


@@ -283,9 +283,9 @@ bool TCP_SetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t
 \r
 /** Retrieves the current state of a given TCP connection to a host.\r
  *\r
 \r
 /** Retrieves the current state of a given TCP connection to a host.\r
  *\r

- *  \param Port           TCP port on the device in the connection, specified in big endian\r
- *  \param RemoteAddress  Remote protocol IP address of the connected host\r
- *  \param RemotePort     Remote TCP port of the connected host, specified in big endian\r
+ *  \param[in] Port           TCP port on the device in the connection, specified in big endian\r
+ *  \param[in] RemoteAddress  Remote protocol IP address of the connected host\r
+ *  \param[in] RemotePort     Remote TCP port of the connected host, specified in big endian\r

  *\r
  *  \return A value from the TCP_ConnectionStates_t enum\r
  */\r
  *\r
  *  \return A value from the TCP_ConnectionStates_t enum\r
  */\r


@@ -310,9 +310,9 @@ uint8_t TCP_GetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16
 \r
 /** Retrieves the connection info structure of a given connection to a host.\r
  *\r
 \r
 /** Retrieves the connection info structure of a given connection to a host.\r
  *\r

- *  \param Port           TCP port on the device in the connection, specified in big endian\r
- *  \param RemoteAddress  Remote protocol IP address of the connected host\r
- *  \param RemotePort     Remote TCP port of the connected host, specified in big endian\r
+ *  \param[in] Port           TCP port on the device in the connection, specified in big endian\r
+ *  \param[in] RemoteAddress  Remote protocol IP address of the connected host\r
+ *  \param[in] RemotePort     Remote TCP port of the connected host, specified in big endian\r

  *\r
  *  \return ConnectionInfo structure of the connection if found, NULL otherwise\r
  */\r
  *\r
  *  \return ConnectionInfo structure of the connection if found, NULL otherwise\r
  */\r


@@ -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\r
  *  to the output Ethernet frame if one is created by a application handler.\r
  *\r
 /** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if one is created by a application handler.\r
  *\r

- *  \param IPHeaderInStart    Pointer to the start of the incoming packet's IP header\r
- *  \param TCPHeaderInStart   Pointer to the start of the incoming packet's TCP header\r
- *  \param TCPHeaderOutStart  Pointer to the start of the outgoing packet's TCP header\r
+ *  \param[in] IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
+ *  \param[in] TCPHeaderInStart    Pointer to the start of the incoming packet's TCP header\r
+ *  \param[out] TCPHeaderOutStart  Pointer to the start of the outgoing packet's TCP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r


@@ -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,\r
  *  complimented.\r
  *\r
 /** Calculates the appropriate TCP checksum, consisting of the addition of the one's compliment of each word,\r
  *  complimented.\r
  *\r

- *  \param TCPHeaderOutStart  Pointer to the start of the packet's outgoing TCP header\r
- *  \param SourceAddress      Source protocol IP address of the outgoing IP header\r
- *  \param DestinationAddress Destination protocol IP address of the outgoing IP header\r
- *  \param TCPOutSize         Size in bytes of the TCP data header and payload\r
+ *  \param[in] TCPHeaderOutStart   Pointer to the start of the packet's outgoing TCP header\r
+ *  \param[in] SourceAddress       Source protocol IP address of the outgoing IP header\r
+ *  \param[in] DestinationAddress  Destination protocol IP address of the outgoing IP header\r
+ *  \param[in] TCPOutSize          Size in bytes of the TCP data header and payload\r

  *\r
  *  \return A 16-bit TCP checksum value\r
  */\r
  *\r
  *  \return A 16-bit TCP checksum value\r
  */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.h b/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.h
index 919245a..b7c991e 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.h
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/TCP.h
@@ -89,7 +89,7 @@
                \r
                /** Application macro: Determines if the given application buffer contains a packet received from the host\r
                 *\r
                \r
                /** Application macro: Determines if the given application buffer contains a packet received from the host\r
                 *\r

-                *  \param Buffer  Application buffer to check\r
+                *  \param[in] Buffer  Application buffer to check\r

                 *\r
                 *  \return Boolean true if the buffer contains a packet from the host, false otherwise\r
                 */\r
                 *\r
                 *  \return Boolean true if the buffer contains a packet from the host, false otherwise\r
                 */\r


@@ -97,7 +97,7 @@
 \r
                /** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.\r
                 *\r
 \r
                /** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.\r
                 *\r

-                *  \param Buffer  Application buffer to check\r
+                *  \param[in] Buffer  Application buffer to check\r

                 *\r
                 *  \return Boolean true if the buffer has been captured by the application for device-to-host transmissions, false otherwise\r
                 */\r
                 *\r
                 *  \return Boolean true if the buffer has been captured by the application for device-to-host transmissions, false otherwise\r
                 */\r


@@ -106,7 +106,7 @@
 \r
                /** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.\r
                 *\r
 \r
                /** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.\r
                 *\r

-                *  \param Buffer  Application buffer to check\r
+                *  \param[in] Buffer  Application buffer to check\r

                 *\r
                 *  \return Boolean true if the buffer may be captured by the application for device-to-host transmissions, false otherwise\r
                 */\r
                 *\r
                 *  \return Boolean true if the buffer may be captured by the application for device-to-host transmissions, false otherwise\r
                 */\r


@@ -117,32 +117,32 @@
                 *\r
                 *  \note The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().\r
                 *\r
                 *\r
                 *  \note The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().\r
                 *\r

-                *  \param Buffer  Application buffer to lock\r
+                *  \param[in] Buffer  Application buffer to lock\r

                 */\r
                #define TCP_APP_CAPTURE_BUFFER(Buffer)       MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; }MACROE\r
 \r
                /** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.\r
                 *\r
                 */\r
                #define TCP_APP_CAPTURE_BUFFER(Buffer)       MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; }MACROE\r
 \r
                /** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.\r
                 *\r

-                *  \param Buffer  Application buffer to release\r
+                *  \param[in] Buffer  Application buffer to release\r

                 */\r
                #define TCP_APP_RELEASE_BUFFER(Buffer)       MACROS{ Buffer->InUse = false; }MACROE\r
 \r
                /** Application macro: Sends the contents of the given application buffer to the host.\r
                 *\r
                 */\r
                #define TCP_APP_RELEASE_BUFFER(Buffer)       MACROS{ Buffer->InUse = false; }MACROE\r
 \r
                /** Application macro: Sends the contents of the given application buffer to the host.\r
                 *\r

-                *  \param Buffer  Application buffer to send\r
-                *  \param Len     Length of data contained in the buffer\r
+                *  \param[in] Buffer  Application buffer to send\r
+                *  \param[in] Len     Length of data contained in the buffer\r

                 */\r
                #define TCP_APP_SEND_BUFFER(Buffer, Len)     MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; }MACROE\r
 \r
                /** Application macro: Clears the application buffer, ready for a packet to be written to it.\r
                 *\r
                 */\r
                #define TCP_APP_SEND_BUFFER(Buffer, Len)     MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; }MACROE\r
 \r
                /** Application macro: Clears the application buffer, ready for a packet to be written to it.\r
                 *\r

-                *  \param Buffer  Application buffer to clear\r
+                *  \param[in] Buffer  Application buffer to clear\r

                 */\r
                #define TCP_APP_CLEAR_BUFFER(Buffer)         MACROS{ Buffer->Ready = false; Buffer->Length = 0; }MACROE\r
                \r
                /** Application macro: Closes an open connection to a host.\r
                 *\r
                 */\r
                #define TCP_APP_CLEAR_BUFFER(Buffer)         MACROS{ Buffer->Ready = false; Buffer->Length = 0; }MACROE\r
                \r
                /** Application macro: Closes an open connection to a host.\r
                 *\r

-                *  \param Connection  Open TCP connection to close\r
+                *  \param[in] Connection  Open TCP connection to close\r

                 */\r
                #define TCP_APP_CLOSECONNECTION(Connection)  MACROS{ Connection->State = TCP_Connection_Closing;  }MACROE\r
 \r
                 */\r
                #define TCP_APP_CLOSECONNECTION(Connection)  MACROS{ Connection->State = TCP_Connection_Closing;  }MACROE\r
 \r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/UDP.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/UDP.c
index 1f571c3..dbd33d1 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/UDP.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/UDP.c
@@ -40,9 +40,9 @@
 /** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if a subprotocol handler has created a response packet.\r
  *\r
 /** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if a subprotocol handler has created a response packet.\r
  *\r

- *  \param IPHeaderInStart    Pointer to the start of the incoming packet's IP header\r
- *  \param UDPHeaderInStart   Pointer to the start of the incoming packet's UDP header\r
- *  \param UDPHeaderOutStart  Pointer to the start of the outgoing packet's UDP header\r
+ *  \param[in] IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
+ *  \param[in] UDPHeaderInStart    Pointer to the start of the incoming packet's UDP header\r
+ *  \param[out] UDPHeaderOutStart  Pointer to the start of the outgoing packet's UDP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/ClassDriver/RNDISEthernet/Lib/Webserver.c b/Demos/Device/ClassDriver/RNDISEthernet/Lib/Webserver.c
index c07f2c8..8055d91 100644 (file)
--- a/Demos/Device/ClassDriver/RNDISEthernet/Lib/Webserver.c
+++ b/Demos/Device/ClassDriver/RNDISEthernet/Lib/Webserver.c
@@ -78,8 +78,8 @@ void Webserver_Init(void)
 \r
 /** Indicates if a given request equals the given HTTP command.\r
  *\r
 \r
 /** Indicates if a given request equals the given HTTP command.\r
  *\r

- *  \param RequestHeader  HTTP request made by the host\r
- *  \param Command        HTTP command to compare the request to\r
+ *  \param[in] RequestHeader  HTTP request made by the host\r
+ *  \param[in] Command        HTTP command to compare the request to\r

  *\r
  *  \return Boolean true if the command matches the request, false otherwise\r
  */\r
  *\r
  *  \return Boolean true if the command matches the request, false otherwise\r
  */\r


@@ -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\r
  *  has been made (if any), and serves up appropriate responses.\r
  *\r
 /** Application callback routine, executed each time the TCP processing task runs. This callback determines what request\r
  *  has been made (if any), and serves up appropriate responses.\r
  *\r

- *  \param ConnectionState  Pointer to a TCP Connection State structure giving connection information\r
- *  \param Buffer           Pointer to the application's send/receive packet buffer\r
+ *  \param[in] ConnectionState  Pointer to a TCP Connection State structure giving connection information\r
+ *  \param[in,out] Buffer       Pointer to the application's send/receive packet buffer\r

  */\r
 void Webserver_ApplicationCallback(TCP_ConnectionState_t* ConnectionState, TCP_ConnectionBuffer_t* Buffer)\r
 {\r
  */\r
 void Webserver_ApplicationCallback(TCP_ConnectionState_t* ConnectionState, TCP_ConnectionBuffer_t* Buffer)\r
 {\r

diff --git a/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.c b/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.c
index a2ba253..ac63f0f 100644 (file)
--- a/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.c
+++ b/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.c
@@ -158,9 +158,9 @@ ISR(USART1_RX_vect, ISR_BLOCK)
 \r
 /** Event handler for the CDC Class driver Line Encoding Changed event.\r
  *\r
 \r
 /** Event handler for the CDC Class driver Line Encoding Changed event.\r
  *\r

- *  \param CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced\r
+ *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced\r

  */\r
  */\r

-void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)\r
+void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

 {\r
        uint8_t ConfigMask = 0;\r
 \r
 {\r
        uint8_t ConfigMask = 0;\r
 \r

diff --git a/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.h b/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.h
index d0d4edb..3ee7e89 100644 (file)
--- a/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.h
+++ b/Demos/Device/ClassDriver/USBtoSerial/USBtoSerial.h
@@ -74,6 +74,6 @@
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
                \r
                void EVENT_USB_ConfigurationChanged(void);\r
                void EVENT_USB_UnhandledControlPacket(void);\r
                \r

-               void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+               void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

 \r
 #endif\r
 \r
 #endif\r

diff --git a/Demos/Device/LowLevel/AudioInput/Descriptors.h b/Demos/Device/LowLevel/AudioInput/Descriptors.h
index 2cbd1cb..678eaaf 100644 (file)
--- a/Demos/Device/LowLevel/AudioInput/Descriptors.h
+++ b/Demos/Device/LowLevel/AudioInput/Descriptors.h
@@ -123,7 +123,7 @@
 \r
                /** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.\r
                 *\r
 \r
                /** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.\r
                 *\r

-                *  \param freq  Required audio sampling frequency in HZ\r
+                *  \param[in] freq  Required audio sampling frequency in HZ\r

                 */\r
                #define SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}\r
                \r
                 */\r
                #define SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}\r
                \r

diff --git a/Demos/Device/LowLevel/AudioOutput/Descriptors.h b/Demos/Device/LowLevel/AudioOutput/Descriptors.h
index f09bd08..a16a76f 100644 (file)
--- a/Demos/Device/LowLevel/AudioOutput/Descriptors.h
+++ b/Demos/Device/LowLevel/AudioOutput/Descriptors.h
@@ -123,7 +123,7 @@
 \r
                /** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.\r
                 *\r
 \r
                /** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.\r
                 *\r

-                *  \param freq  Required audio sampling frequency in HZ\r
+                *  \param[in] freq  Required audio sampling frequency in HZ\r

                 */\r
                #define SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}\r
                \r
                 */\r
                #define SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}\r
                \r

diff --git a/Demos/Device/LowLevel/CDC/Descriptors.h b/Demos/Device/LowLevel/CDC/Descriptors.h
index 41b4430..bf9e7df 100644 (file)
--- a/Demos/Device/LowLevel/CDC/Descriptors.h
+++ b/Demos/Device/LowLevel/CDC/Descriptors.h
@@ -47,7 +47,7 @@
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r

-                *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload\r
+                *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload\r

                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/Demos/Device/LowLevel/DualCDC/Descriptors.h b/Demos/Device/LowLevel/DualCDC/Descriptors.h
index 2c2311b..aa95b8a 100644 (file)
--- a/Demos/Device/LowLevel/DualCDC/Descriptors.h
+++ b/Demos/Device/LowLevel/DualCDC/Descriptors.h
@@ -47,7 +47,7 @@
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r

-                *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload\r
+                *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload\r

                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/Demos/Device/LowLevel/GenericHID/GenericHID.c b/Demos/Device/LowLevel/GenericHID/GenericHID.c
index 40de8b9..f467494 100644 (file)
--- a/Demos/Device/LowLevel/GenericHID/GenericHID.c
+++ b/Demos/Device/LowLevel/GenericHID/GenericHID.c
@@ -170,7 +170,7 @@ void EVENT_USB_UnhandledControlPacket(void)
 \r
 /** Function to process the lest received report from the host.\r
  *\r
 \r
 /** Function to process the lest received report from the host.\r
  *\r

- *  \param DataArray  Pointer to a buffer where the last report data is stored\r
+ *  \param[in] DataArray  Pointer to a buffer where the last report data is stored\r

  */\r
 void ProcessGenericHIDReport(uint8_t* DataArray)\r
 {\r
  */\r
 void ProcessGenericHIDReport(uint8_t* DataArray)\r
 {\r


@@ -186,7 +186,7 @@ void ProcessGenericHIDReport(uint8_t* DataArray)
 \r
 /** Function to create the next report to send back to the host at the next reporting interval.\r
  *\r
 \r
 /** Function to create the next report to send back to the host at the next reporting interval.\r
  *\r

- *  \param DataArray  Pointer to a buffer where the next report data should be stored\r
+ *  \param[out] DataArray  Pointer to a buffer where the next report data should be stored\r

  */\r
 void CreateGenericHIDReport(uint8_t* DataArray)\r
 {\r
  */\r
 void CreateGenericHIDReport(uint8_t* DataArray)\r
 {\r

diff --git a/Demos/Device/LowLevel/Joystick/Joystick.c b/Demos/Device/LowLevel/Joystick/Joystick.c
index 0c018aa..42ae62c 100644 (file)
--- a/Demos/Device/LowLevel/Joystick/Joystick.c
+++ b/Demos/Device/LowLevel/Joystick/Joystick.c
@@ -136,7 +136,7 @@ void EVENT_USB_UnhandledControlPacket(void)
 \r
 /** Fills the given HID report data structure with the next HID report to send to the host.\r
  *\r
 \r
 /** Fills the given HID report data structure with the next HID report to send to the host.\r
  *\r

- *  \param ReportData  Pointer to a HID report data structure to be filled\r
+ *  \param[out] ReportData  Pointer to a HID report data structure to be filled\r

  *\r
  *  \return Boolean true if the new report differs from the last report, false otherwise\r
  */\r
  *\r
  *  \return Boolean true if the new report differs from the last report, false otherwise\r
  */\r

diff --git a/Demos/Device/LowLevel/Keyboard/Keyboard.c b/Demos/Device/LowLevel/Keyboard/Keyboard.c
index 35ef41b..185d968 100644 (file)
--- a/Demos/Device/LowLevel/Keyboard/Keyboard.c
+++ b/Demos/Device/LowLevel/Keyboard/Keyboard.c
@@ -266,7 +266,7 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** Fills the given HID report data structure with the next HID report to send to the host.\r
  *\r
 \r
 /** Fills the given HID report data structure with the next HID report to send to the host.\r
  *\r

- *  \param ReportData  Pointer to a HID report data structure to be filled\r
+ *  \param[out] ReportData  Pointer to a HID report data structure to be filled\r

  */\r
 void CreateKeyboardReport(USB_KeyboardReport_Data_t* ReportData)\r
 {\r
  */\r
 void CreateKeyboardReport(USB_KeyboardReport_Data_t* ReportData)\r
 {\r


@@ -291,7 +291,7 @@ void CreateKeyboardReport(USB_KeyboardReport_Data_t* ReportData)
 \r
 /** Processes a received LED report, and updates the board LEDs states to match.\r
  *\r
 \r
 /** Processes a received LED report, and updates the board LEDs states to match.\r
  *\r

- *  \param LEDReport  LED status report from the host\r
+ *  \param[in] LEDReport  LED status report from the host\r

  */\r
 void ProcessLEDReport(uint8_t LEDReport)\r
 {\r
  */\r
 void ProcessLEDReport(uint8_t LEDReport)\r
 {\r

diff --git a/Demos/Device/LowLevel/MIDI/MIDI.h b/Demos/Device/LowLevel/MIDI/MIDI.h
index 735ac84..3b9b938 100644 (file)
--- a/Demos/Device/LowLevel/MIDI/MIDI.h
+++ b/Demos/Device/LowLevel/MIDI/MIDI.h
@@ -63,7 +63,7 @@
                /** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel\r
                 *  addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.\r
                 *\r
                /** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel\r
                 *  addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.\r
                 *\r

-                *  \param channel  MIDI channel number to address\r
+                *  \param[in] channel  MIDI channel number to address\r

                 */\r
                #define MIDI_CHANNEL(channel)     (channel - 1)\r
 \r
                 */\r
                #define MIDI_CHANNEL(channel)     (channel - 1)\r
 \r

diff --git a/Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c b/Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c
index 4b62419..c5035fe 100644 (file)
--- a/Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c
+++ b/Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c
@@ -43,8 +43,8 @@
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes\r
  *  them to the dataflash in Dataflash page sized blocks.\r
  *\r
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes\r
  *  them to the dataflash in Dataflash page sized blocks.\r
  *\r

- *  \param BlockAddress  Data block starting address for the write sequence\r
- *  \param TotalBlocks   Number of blocks of data to write\r
+ *  \param[in] BlockAddress  Data block starting address for the write sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to write\r

  */\r
 void DataflashManager_WriteBlocks(const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r
  */\r
 void DataflashManager_WriteBlocks(const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r


@@ -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\r
  *  and writes them in OS sized blocks to the endpoint.\r
  *\r
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash\r
  *  and writes them in OS sized blocks to the endpoint.\r
  *\r

- *  \param BlockAddress  Data block starting address for the read sequence\r
- *  \param TotalBlocks   Number of blocks of data to read\r
+ *  \param[in] BlockAddress  Data block starting address for the read sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to read\r

  */\r
 void DataflashManager_ReadBlocks(const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r
  */\r
 void DataflashManager_ReadBlocks(const uint32_t BlockAddress, uint16_t TotalBlocks)\r
 {\r


@@ -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\r
  *  dataflash.\r
  *\r
  *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the\r
  *  dataflash.\r
  *\r

- *  \param BlockAddress  Data block starting address for the write sequence\r
- *  \param TotalBlocks   Number of blocks of data to write\r
- *  \param BufferPtr     Pointer to the data source RAM buffer\r
+ *  \param[in] BlockAddress  Data block starting address for the write sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to write\r
+ *  \param[in] BufferPtr     Pointer to the data source RAM buffer\r

  */\r
 void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r
  */\r
 void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r


@@ -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\r
  *  the files stored on the dataflash.\r
  *\r
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read\r
  *  the files stored on the dataflash.\r
  *\r

- *  \param BlockAddress  Data block starting address for the read sequence\r
- *  \param TotalBlocks   Number of blocks of data to read\r
- *  \param BufferPtr     Pointer to the data destination RAM buffer\r
+ *  \param[in] BlockAddress  Data block starting address for the read sequence\r
+ *  \param[in] TotalBlocks   Number of blocks of data to read\r
+ *  \param[out] BufferPtr    Pointer to the data destination RAM buffer\r

  */\r
 void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r
  */\r
 void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress, uint16_t TotalBlocks, uint8_t* BufferPtr)\r
 {\r

diff --git a/Demos/Device/LowLevel/MassStorage/Lib/SCSI.c b/Demos/Device/LowLevel/MassStorage/Lib/SCSI.c
index 5993a54..53d773f 100644 (file)
--- a/Demos/Device/LowLevel/MassStorage/Lib/SCSI.c
+++ b/Demos/Device/LowLevel/MassStorage/Lib/SCSI.c
@@ -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\r
  *  reading and writing of the data.\r
  *\r
  *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual\r
  *  reading and writing of the data.\r
  *\r

- *  \param IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)\r
+ *  \param[in] IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)\r

  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r
  *\r
  *  \return Boolean true if the command completed successfully, false otherwise.\r
  */\r

diff --git a/Demos/Device/LowLevel/MassStorage/Lib/SCSI.h b/Demos/Device/LowLevel/MassStorage/Lib/SCSI.h
index d7693ca..5002df5 100644 (file)
--- a/Demos/Device/LowLevel/MassStorage/Lib/SCSI.h
+++ b/Demos/Device/LowLevel/MassStorage/Lib/SCSI.h
@@ -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\r
                 *  the last command failure) in a quick and easy manner.\r
                 *\r
                 *  is for convenience, as it allows for all three sense values (returned upon request to the host to give information about\r
                 *  the last command failure) in a quick and easy manner.\r
                 *\r

-                *  \param key    New SCSI sense key to set the sense code to\r
-                *  \param acode  New SCSI additional sense key to set the additional sense code to\r
-                *  \param aqual  New SCSI additional sense key qualifier to set the additional sense qualifier code to\r
+                *  \param[in] key    New SCSI sense key to set the sense code to\r
+                *  \param[in] acode  New SCSI additional sense key to set the additional sense code to\r
+                *  \param[in] aqual  New SCSI additional sense key qualifier to set the additional sense qualifier code to\r

                 */\r
                #define SCSI_SET_SENSE(key, acode, aqual)  MACROS{ SenseData.SenseKey = key;              \\r
                                                                   SenseData.AdditionalSenseCode = acode; \\r
                 */\r
                #define SCSI_SET_SENSE(key, acode, aqual)  MACROS{ SenseData.SenseKey = key;              \\r
                                                                   SenseData.AdditionalSenseCode = acode; \\r

diff --git a/Demos/Device/LowLevel/Mouse/Mouse.c b/Demos/Device/LowLevel/Mouse/Mouse.c
index c586b59..c0989c5 100644 (file)
--- a/Demos/Device/LowLevel/Mouse/Mouse.c
+++ b/Demos/Device/LowLevel/Mouse/Mouse.c
@@ -238,7 +238,7 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** Fills the given HID report data structure with the next HID report to send to the host.\r
  *\r
 \r
 /** Fills the given HID report data structure with the next HID report to send to the host.\r
  *\r

- *  \param ReportData  Pointer to a HID report data structure to be filled\r
+ *  \param[out] ReportData  Pointer to a HID report data structure to be filled\r

  */\r
 void CreateMouseReport(USB_MouseReport_Data_t* ReportData)\r
 {\r
  */\r
 void CreateMouseReport(USB_MouseReport_Data_t* ReportData)\r
 {\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Descriptors.h b/Demos/Device/LowLevel/RNDISEthernet/Descriptors.h
index eb43735..28b801f 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Descriptors.h
+++ b/Demos/Device/LowLevel/RNDISEthernet/Descriptors.h
@@ -47,7 +47,7 @@
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r

-                *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload\r
+                *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload\r

                 */             \r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */             \r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c
index 0f108c2..f2dc9ff 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/ARP.c
@@ -41,8 +41,8 @@
  *  to the output Ethernet frame if the host is requesting the IP or MAC address of the\r
  *  virtual server device on the network.\r
  *\r
  *  to the output Ethernet frame if the host is requesting the IP or MAC address of the\r
  *  virtual server device on the network.\r
  *\r

- *  \param InDataStart   Pointer to the start of the incoming packet's ARP header\r
- *  \param OutDataStart  Pointer to the start of the outgoing packet's ARP header\r
+ *  \param[in] InDataStart    Pointer to the start of the incoming packet's ARP header\r
+ *  \param[out] OutDataStart  Pointer to the start of the outgoing packet's ARP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c
index 76711fb..4301554 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/DHCP.c
@@ -40,9 +40,9 @@
 /** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is requesting or accepting an IP address.\r
  *\r
 /** Processes a DHCP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is requesting or accepting an IP address.\r
  *\r

- *  \param IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
- *  \param DHCPHeaderInStart   Pointer to the start of the incoming packet's DHCP header\r
- *  \param DHCPHeaderOutStart  Pointer to the start of the outgoing packet's DHCP header\r
+ *  \param[in] IPHeaderInStart      Pointer to the start of the incoming packet's IP header\r
+ *  \param[in] DHCPHeaderInStart    Pointer to the start of the incoming packet's DHCP header\r
+ *  \param[out] DHCPHeaderOutStart  Pointer to the start of the outgoing packet's DHCP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c
index 3d34f71..2856131 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.c
@@ -116,8 +116,8 @@ void Ethernet_ProcessPacket(void)
 /** Calculates the appropriate ethernet checksum, consisting of the addition of the one's\r
  *  compliment of each word, complimented.\r
  *\r
 /** Calculates the appropriate ethernet checksum, consisting of the addition of the one's\r
  *  compliment of each word, complimented.\r
  *\r

- *  \param Data   Pointer to the packet buffer data whose checksum must be calculated\r
- *  \param Bytes  Number of bytes in the data buffer to process\r
+ *  \param[in] Data   Pointer to the packet buffer data whose checksum must be calculated\r
+ *  \param[in] Bytes  Number of bytes in the data buffer to process\r

  *\r
  *  \return A 16-bit Ethernet checksum value\r
  */\r
  *\r
  *  \return A 16-bit Ethernet checksum value\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h b/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h
index b360f07..b91a56b 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/Ethernet.h
@@ -58,8 +58,8 @@
        \r
                /** Performs a comparison between two MAC addresses, indicating if they are identical.\r
                 *  \r
        \r
                /** Performs a comparison between two MAC addresses, indicating if they are identical.\r
                 *  \r

-                *  \param MAC1  First MAC address\r
-                *  \param MAC2  Second MAC address\r
+                *  \param[in] MAC1  First MAC address\r
+                *  \param[in] MAC2  Second MAC address\r

                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r
                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c
index da4ffcf..6ff3311 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/ICMP.c
@@ -40,8 +40,8 @@
 /** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is issuing a ICMP ECHO request.\r
  *\r
 /** Processes an ICMP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if the host is issuing a ICMP ECHO request.\r
  *\r

- *  \param InDataStart   Pointer to the start of the incoming packet's ICMP header\r
- *  \param OutDataStart  Pointer to the start of the outgoing packet's ICMP header\r
+ *  \param[in] InDataStart    Pointer to the start of the incoming packet's ICMP header\r
+ *  \param[out] OutDataStart  Pointer to the start of the outgoing packet's ICMP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c
index 8fb0b44..2b88157 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.c
@@ -39,8 +39,8 @@
 /** Processes an IP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if one is created by a subprotocol handler.\r
  *\r
 /** Processes an IP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if one is created by a subprotocol handler.\r
  *\r

- *  \param InDataStart   Pointer to the start of the incoming packet's IP header\r
- *  \param OutDataStart  Pointer to the start of the outgoing packet's IP header\r
+ *  \param[in] InDataStart    Pointer to the start of the incoming packet's IP header\r
+ *  \param[out] OutDataStart  Pointer to the start of the outgoing packet's IP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h b/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h
index fc1a46a..5d9f91d 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/IP.h
@@ -59,8 +59,8 @@
                \r
                /** Performs a comparison between two IP addresses, indicating if they are identical.\r
                 *  \r
                \r
                /** Performs a comparison between two IP addresses, indicating if they are identical.\r
                 *  \r

-                *  \param IP1  First IP address\r
-                *  \param IP2  Second IP address\r
+                *  \param[in] IP1  First IP address\r
+                *  \param[in] IP2  Second IP address\r

                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r
                 *\r
                 *  \return True if the addresses match, false otherwise\r
                 */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c
index add0333..aac72ae 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/ProtocolDecoders.c
@@ -51,7 +51,7 @@
 \r
 /** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an Ethernet frame header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an Ethernet frame header\r
+ *  \param[in] InDataStart  Pointer to the start of an Ethernet frame header\r

  */\r
 void DecodeEthernetFrameHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeEthernetFrameHeader(void* InDataStart)\r
 {\r


@@ -93,7 +93,7 @@ void DecodeEthernetFrameHeader(void* InDataStart)
 \r
 /** Decodes an ARP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an ARP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an ARP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of an ARP packet header\r

  */\r
 void DecodeARPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeARPHeader(void* InDataStart)\r
 {\r


@@ -143,7 +143,7 @@ void DecodeARPHeader(void* InDataStart)
 \r
 /** Decodes an IP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an IP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an IP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of an IP packet header\r

  */\r
 void DecodeIPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeIPHeader(void* InDataStart)\r
 {\r


@@ -181,7 +181,7 @@ void DecodeIPHeader(void* InDataStart)
 \r
 /** Decodes an ICMP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an ICMP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of an ICMP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of an ICMP packet header\r

  */\r
 void DecodeICMPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeICMPHeader(void* InDataStart)\r
 {\r


@@ -197,7 +197,7 @@ void DecodeICMPHeader(void* InDataStart)
 \r
 /** Decodes a TCP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes a TCP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of a TCP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of a TCP packet header\r

  */\r
 void DecodeTCPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeTCPHeader(void* InDataStart)\r
 {\r


@@ -225,7 +225,7 @@ void DecodeTCPHeader(void* InDataStart)
 \r
 /** Decodes an UDP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an UDP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of a UDP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of a UDP packet header\r

  */\r
 void DecodeUDPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeUDPHeader(void* InDataStart)\r
 {\r


@@ -243,7 +243,7 @@ void DecodeUDPHeader(void* InDataStart)
 \r
 /** Decodes an DHCP header and prints its contents to through the USART in a human readable format.\r
  *\r
 \r
 /** Decodes an DHCP header and prints its contents to through the USART in a human readable format.\r
  *\r

- *  \param InDataStart  Pointer to the start of a DHCP packet header\r
+ *  \param[in] InDataStart  Pointer to the start of a DHCP packet header\r

  */\r
 void DecodeDHCPHeader(void* InDataStart)\r
 {\r
  */\r
 void DecodeDHCPHeader(void* InDataStart)\r
 {\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c
index 8bbc9f2..454d1b4 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.c
@@ -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\r
  *  parameter is given as an OID value.\r
  *\r
 /** Processes RNDIS query commands, retrieving information from the adapter and reporting it back to the host. The requested\r
  *  parameter is given as an OID value.\r
  *\r

- *  \param OId           OId value of the parameter being queried\r
- *  \param QueryData     Pointer to any extra query data being sent by the host to the device inside the RNDIS message buffer\r
- *  \param QuerySize     Size in bytes of the extra query data being sent by the host\r
- *  \param ResponseData  Pointer to the start of the query response inside the RNDIS message buffer\r
- *  \param ResponseSize  Pointer to the size in bytes of the response data being sent to the host\r
+ *  \param[in] OId            OId value of the parameter being queried\r
+ *  \param[in] QueryData      Pointer to any extra query data being sent by the host to the device inside the RNDIS message buffer\r
+ *  \param[in] QuerySize      Size in bytes of the extra query data being sent by the host\r
+ *  \param[out] ResponseData  Pointer to the start of the query response inside the RNDIS message buffer\r
+ *  \param[out] ResponseSize  Pointer to the size in bytes of the response data being sent to the host\r

  *\r
  *  \return Boolean true if the query was handled, false otherwise\r
  */\r
  *\r
  *  \return Boolean true if the query was handled, false otherwise\r
  */\r


@@ -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 \r
  *  as an OID value.\r
  *\r
 /** Processes RNDIS set commands, setting adapter parameters to values given by the host. The requested parameter is given \r
  *  as an OID value.\r
  *\r

- *  \param OId      OId value of the parameter being set\r
- *  \param SetData  Pointer to the parameter value in the RNDIS message buffer\r
- *  \param SetSize  Size in bytes of the parameter value being sent by the host\r
+ *  \param[in] OId      OId value of the parameter being set\r
+ *  \param[in] SetData  Pointer to the parameter value in the RNDIS message buffer\r
+ *  \param[in] SetSize  Size in bytes of the parameter value being sent by the host\r

  *\r
  *  \return Boolean true if the set was handled, false otherwise\r
  */\r
  *\r
  *  \return Boolean true if the set was handled, false otherwise\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c
index b7b225a..b4fc12c 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c
@@ -171,9 +171,9 @@ void TCP_Init(void)
 \r
 /** Sets the state and callback handler of the given port, specified in big endian to the given state.\r
  *\r
 \r
 /** Sets the state and callback handler of the given port, specified in big endian to the given state.\r
  *\r

- *  \param Port     Port whose state and callback function to set, specified in big endian\r
- *  \param State    New state of the port, a value from the TCP_PortStates_t enum\r
- *  \param Handler  Application callback handler for the port\r
+ *  \param[in] Port     Port whose state and callback function to set, specified in big endian\r
+ *  \param[in] State    New state of the port, a value from the TCP_PortStates_t enum\r
+ *  \param[in] Handler  Application callback handler for the port\r

  *\r
  *  \return Boolean true if the port state was set, false otherwise (no more space in the port state table)\r
  */\r
  *\r
  *  \return Boolean true if the port state was set, false otherwise (no more space in the port state table)\r
  */\r


@@ -220,7 +220,7 @@ bool TCP_SetPortState(uint16_t Port, uint8_t State, void (*Handler)(TCP_Connecti
 \r
 /** Retrieves the current state of a given TCP port, specified in big endian.\r
  *\r
 \r
 /** Retrieves the current state of a given TCP port, specified in big endian.\r
  *\r

- *  \param Port  TCP port whose state is to be retrieved, given in big-endian\r
+ *  \param[in] Port  TCP port whose state is to be retrieved, given in big-endian\r

  *\r
  *  \return A value from the TCP_PortStates_t enum\r
  */\r
  *\r
  *  \return A value from the TCP_PortStates_t enum\r
  */\r


@@ -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\r
  *  connection exists in the connection state table it is updated, otherwise it is created if possible.\r
  *\r
 /** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the\r
  *  connection exists in the connection state table it is updated, otherwise it is created if possible.\r
  *\r

- *  \param Port           TCP port of the connection on the device, specified in big endian\r
- *  \param RemoteAddress  Remote protocol IP address of the connected device\r
- *  \param RemotePort     TCP port of the remote device in the connection, specified in big endian\r
- *  \param State          TCP connection state, a value from the TCP_ConnectionStates_t enum\r
+ *  \param[in] Port           TCP port of the connection on the device, specified in big endian\r
+ *  \param[in] RemoteAddress  Remote protocol IP address of the connected device\r
+ *  \param[in] RemotePort     TCP port of the remote device in the connection, specified in big endian\r
+ *  \param[in] State          TCP connection state, a value from the TCP_ConnectionStates_t enum\r

  *\r
  *  \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)\r
  */\r
  *\r
  *  \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)\r
  */\r


@@ -283,9 +283,9 @@ bool TCP_SetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t
 \r
 /** Retrieves the current state of a given TCP connection to a host.\r
  *\r
 \r
 /** Retrieves the current state of a given TCP connection to a host.\r
  *\r

- *  \param Port           TCP port on the device in the connection, specified in big endian\r
- *  \param RemoteAddress  Remote protocol IP address of the connected host\r
- *  \param RemotePort     Remote TCP port of the connected host, specified in big endian\r
+ *  \param[in] Port           TCP port on the device in the connection, specified in big endian\r
+ *  \param[in] RemoteAddress  Remote protocol IP address of the connected host\r
+ *  \param[in] RemotePort     Remote TCP port of the connected host, specified in big endian\r

  *\r
  *  \return A value from the TCP_ConnectionStates_t enum\r
  */\r
  *\r
  *  \return A value from the TCP_ConnectionStates_t enum\r
  */\r


@@ -310,9 +310,9 @@ uint8_t TCP_GetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16
 \r
 /** Retrieves the connection info structure of a given connection to a host.\r
  *\r
 \r
 /** Retrieves the connection info structure of a given connection to a host.\r
  *\r

- *  \param Port           TCP port on the device in the connection, specified in big endian\r
- *  \param RemoteAddress  Remote protocol IP address of the connected host\r
- *  \param RemotePort     Remote TCP port of the connected host, specified in big endian\r
+ *  \param[in] Port           TCP port on the device in the connection, specified in big endian\r
+ *  \param[in] RemoteAddress  Remote protocol IP address of the connected host\r
+ *  \param[in] RemotePort     Remote TCP port of the connected host, specified in big endian\r

  *\r
  *  \return ConnectionInfo structure of the connection if found, NULL otherwise\r
  */\r
  *\r
  *  \return ConnectionInfo structure of the connection if found, NULL otherwise\r
  */\r


@@ -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\r
  *  to the output Ethernet frame if one is created by a application handler.\r
  *\r
 /** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if one is created by a application handler.\r
  *\r

- *  \param IPHeaderInStart    Pointer to the start of the incoming packet's IP header\r
- *  \param TCPHeaderInStart   Pointer to the start of the incoming packet's TCP header\r
- *  \param TCPHeaderOutStart  Pointer to the start of the outgoing packet's TCP header\r
+ *  \param[in] IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
+ *  \param[in] TCPHeaderInStart    Pointer to the start of the incoming packet's TCP header\r
+ *  \param[out] TCPHeaderOutStart  Pointer to the start of the outgoing packet's TCP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no\r
  *           response was generated, NO_PROCESS if the packet processing was deferred until the\r


@@ -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,\r
  *  complimented.\r
  *\r
 /** Calculates the appropriate TCP checksum, consisting of the addition of the one's compliment of each word,\r
  *  complimented.\r
  *\r

- *  \param TCPHeaderOutStart  Pointer to the start of the packet's outgoing TCP header\r
- *  \param SourceAddress      Source protocol IP address of the outgoing IP header\r
- *  \param DestinationAddress Destination protocol IP address of the outgoing IP header\r
- *  \param TCPOutSize         Size in bytes of the TCP data header and payload\r
+ *  \param[in] TCPHeaderOutStart  Pointer to the start of the packet's outgoing TCP header\r
+ *  \param[in] SourceAddress      Source protocol IP address of the outgoing IP header\r
+ *  \param[in] DestinationAddress Destination protocol IP address of the outgoing IP header\r
+ *  \param[in] TCPOutSize         Size in bytes of the TCP data header and payload\r

  *\r
  *  \return A 16-bit TCP checksum value\r
  */\r
  *\r
  *  \return A 16-bit TCP checksum value\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h b/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h
index 313bd02..e98085f 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.h
@@ -89,7 +89,7 @@
                \r
                /** Application macro: Determines if the given application buffer contains a packet received from the host\r
                 *\r
                \r
                /** Application macro: Determines if the given application buffer contains a packet received from the host\r
                 *\r

-                *  \param Buffer  Application buffer to check\r
+                *  \param[in] Buffer  Application buffer to check\r

                 *\r
                 *  \return Boolean true if the buffer contains a packet from the host, false otherwise\r
                 */\r
                 *\r
                 *  \return Boolean true if the buffer contains a packet from the host, false otherwise\r
                 */\r


@@ -97,7 +97,7 @@
 \r
                /** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.\r
                 *\r
 \r
                /** Application macro: Indicates if the application buffer is currently locked by the application for device-to-host transfers.\r
                 *\r

-                *  \param Buffer  Application buffer to check\r
+                *  \param[in] Buffer  Application buffer to check\r

                 *\r
                 *  \return Boolean true if the buffer has been captured by the application for device-to-host transmissions, false otherwise\r
                 */\r
                 *\r
                 *  \return Boolean true if the buffer has been captured by the application for device-to-host transmissions, false otherwise\r
                 */\r


@@ -106,7 +106,7 @@
 \r
                /** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.\r
                 *\r
 \r
                /** Application macro: Indicates if the application can lock the buffer for multiple continued device-to-host transmissions.\r
                 *\r

-                *  \param Buffer  Application buffer to check\r
+                *  \param[in] Buffer  Application buffer to check\r

                 *\r
                 *  \return Boolean true if the buffer may be captured by the application for device-to-host transmissions, false otherwise\r
                 */\r
                 *\r
                 *  \return Boolean true if the buffer may be captured by the application for device-to-host transmissions, false otherwise\r
                 */\r


@@ -117,32 +117,32 @@
                 *\r
                 *  \note The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().\r
                 *\r
                 *\r
                 *  \note The application must check that the buffer can be locked first using TCP_APP_CAN_CAPTURE_BUFFER().\r
                 *\r

-                *  \param Buffer  Application buffer to lock\r
+                *  \param[in] Buffer  Application buffer to lock\r

                 */\r
                #define TCP_APP_CAPTURE_BUFFER(Buffer)       MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; }MACROE\r
 \r
                /** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.\r
                 *\r
                 */\r
                #define TCP_APP_CAPTURE_BUFFER(Buffer)       MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->InUse = true; }MACROE\r
 \r
                /** Application macro: Releases a captured application buffer, allowing for host-to-device packets to be received.\r
                 *\r

-                *  \param Buffer  Application buffer to release\r
+                *  \param[in] Buffer  Application buffer to release\r

                 */\r
                #define TCP_APP_RELEASE_BUFFER(Buffer)       MACROS{ Buffer->InUse = false; }MACROE\r
 \r
                /** Application macro: Sends the contents of the given application buffer to the host.\r
                 *\r
                 */\r
                #define TCP_APP_RELEASE_BUFFER(Buffer)       MACROS{ Buffer->InUse = false; }MACROE\r
 \r
                /** Application macro: Sends the contents of the given application buffer to the host.\r
                 *\r

-                *  \param Buffer  Application buffer to send\r
-                *  \param Len     Length of data contained in the buffer\r
+                *  \param[in] Buffer  Application buffer to send\r
+                *  \param[in] Len     Length of data contained in the buffer\r

                 */\r
                #define TCP_APP_SEND_BUFFER(Buffer, Len)     MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; }MACROE\r
 \r
                /** Application macro: Clears the application buffer, ready for a packet to be written to it.\r
                 *\r
                 */\r
                #define TCP_APP_SEND_BUFFER(Buffer, Len)     MACROS{ Buffer->Direction = TCP_PACKETDIR_OUT; Buffer->Length = Len; Buffer->Ready = true; }MACROE\r
 \r
                /** Application macro: Clears the application buffer, ready for a packet to be written to it.\r
                 *\r

-                *  \param Buffer  Application buffer to clear\r
+                *  \param[in] Buffer  Application buffer to clear\r

                 */\r
                #define TCP_APP_CLEAR_BUFFER(Buffer)         MACROS{ Buffer->Ready = false; Buffer->Length = 0; }MACROE\r
                \r
                /** Application macro: Closes an open connection to a host.\r
                 *\r
                 */\r
                #define TCP_APP_CLEAR_BUFFER(Buffer)         MACROS{ Buffer->Ready = false; Buffer->Length = 0; }MACROE\r
                \r
                /** Application macro: Closes an open connection to a host.\r
                 *\r

-                *  \param Connection  Open TCP connection to close\r
+                *  \param[in] Connection  Open TCP connection to close\r

                 */\r
                #define TCP_APP_CLOSECONNECTION(Connection)  MACROS{ Connection->State = TCP_Connection_Closing;  }MACROE\r
 \r
                 */\r
                #define TCP_APP_CLOSECONNECTION(Connection)  MACROS{ Connection->State = TCP_Connection_Closing;  }MACROE\r
 \r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c
index 1f571c3..dbd33d1 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/UDP.c
@@ -40,9 +40,9 @@
 /** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if a subprotocol handler has created a response packet.\r
  *\r
 /** Processes a UDP packet inside an Ethernet frame, and writes the appropriate response\r
  *  to the output Ethernet frame if a subprotocol handler has created a response packet.\r
  *\r

- *  \param IPHeaderInStart    Pointer to the start of the incoming packet's IP header\r
- *  \param UDPHeaderInStart   Pointer to the start of the incoming packet's UDP header\r
- *  \param UDPHeaderOutStart  Pointer to the start of the outgoing packet's UDP header\r
+ *  \param[in] IPHeaderInStart     Pointer to the start of the incoming packet's IP header\r
+ *  \param[in] UDPHeaderInStart    Pointer to the start of the incoming packet's UDP header\r
+ *  \param[out] UDPHeaderOutStart  Pointer to the start of the outgoing packet's UDP header\r

  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r
  *\r
  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE otherwise\r
  */\r

diff --git a/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c b/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c
index c07f2c8..8055d91 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/Lib/Webserver.c
@@ -78,8 +78,8 @@ void Webserver_Init(void)
 \r
 /** Indicates if a given request equals the given HTTP command.\r
  *\r
 \r
 /** Indicates if a given request equals the given HTTP command.\r
  *\r

- *  \param RequestHeader  HTTP request made by the host\r
- *  \param Command        HTTP command to compare the request to\r
+ *  \param[in] RequestHeader  HTTP request made by the host\r
+ *  \param[in] Command        HTTP command to compare the request to\r

  *\r
  *  \return Boolean true if the command matches the request, false otherwise\r
  */\r
  *\r
  *  \return Boolean true if the command matches the request, false otherwise\r
  */\r


@@ -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\r
  *  has been made (if any), and serves up appropriate responses.\r
  *\r
 /** Application callback routine, executed each time the TCP processing task runs. This callback determines what request\r
  *  has been made (if any), and serves up appropriate responses.\r
  *\r

- *  \param ConnectionState  Pointer to a TCP Connection State structure giving connection information\r
- *  \param Buffer           Pointer to the application's send/receive packet buffer\r
+ *  \param[in] ConnectionState  Pointer to a TCP Connection State structure giving connection information\r
+ *  \param[in,out] Buffer       Pointer to the application's send/receive packet buffer\r

  */\r
 void Webserver_ApplicationCallback(TCP_ConnectionState_t* ConnectionState, TCP_ConnectionBuffer_t* Buffer)\r
 {\r
  */\r
 void Webserver_ApplicationCallback(TCP_ConnectionState_t* ConnectionState, TCP_ConnectionBuffer_t* Buffer)\r
 {\r

diff --git a/Demos/Device/LowLevel/USBtoSerial/Descriptors.h b/Demos/Device/LowLevel/USBtoSerial/Descriptors.h
index 41b4430..bf9e7df 100644 (file)
--- a/Demos/Device/LowLevel/USBtoSerial/Descriptors.h
+++ b/Demos/Device/LowLevel/USBtoSerial/Descriptors.h
@@ -47,7 +47,7 @@
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r

-                *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload\r
+                *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload\r

                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.c b/Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.c
index 5bb89af..9f7da59 100644 (file)
--- a/Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.c
+++ b/Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.c
@@ -164,10 +164,10 @@ void ReadNextReport(void)
 \r
 /** Writes a report to the attached device.\r
  *\r
 \r
 /** Writes a report to the attached device.\r
  *\r

- *  \param ReportOUTData  Buffer containing the report to send to the device\r
- *  \param ReportIndex  Index of the report in the device (zero if the device does not use multiple reports)\r
- *  \param ReportType  Type of report to send, either HID_REPORTTYPE_OUTPUT or HID_REPORTTYPE_FEATURE\r
- *  \param ReportLength  Length of the report to send\r
+ *  \param[in] ReportOUTData  Buffer containing the report to send to the device\r
+ *  \param[in] ReportIndex  Index of the report in the device (zero if the device does not use multiple reports)\r
+ *  \param[in] ReportType  Type of report to send, either HID_REPORTTYPE_OUTPUT or HID_REPORTTYPE_FEATURE\r
+ *  \param[in] ReportLength  Length of the report to send\r

  */\r
 void WriteNextReport(uint8_t* ReportOUTData, uint8_t ReportIndex, uint8_t ReportType, uint16_t ReportLength)\r
 {\r
  */\r
 void WriteNextReport(uint8_t* ReportOUTData, uint8_t ReportIndex, uint8_t ReportType, uint16_t ReportLength)\r
 {\r

diff --git a/Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c b/Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c
index 54e400d..4e78b0d 100644 (file)
--- a/Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c
+++ b/Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c
@@ -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\r
  *  as required and prints pressed characters to the serial port. Each time a key is typed, a board LED is toggled.\r
  *\r
 /** Processes a read HID report from an attached keyboard, extracting out elements via the HID parser results\r
  *  as required and prints pressed characters to the serial port. Each time a key is typed, a board LED is toggled.\r
  *\r

- *  \param KeyboardReport  Pointer to a HID report from an attached keyboard device\r
+ *  \param[in] KeyboardReport  Pointer to a HID report from an attached keyboard device\r

  */\r
 void ProcessKeyboardReport(uint8_t* KeyboardReport)\r
 {\r
  */\r
 void ProcessKeyboardReport(uint8_t* KeyboardReport)\r
 {\r

diff --git a/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.c b/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.c
index e2a64da..7ee7de1 100644 (file)
--- a/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.c
+++ b/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.c
@@ -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\r
  *  writing to the nominated buffer.\r
  *\r
 /** Sends or receives the transaction's data stage to or from the attached device, reading or\r
  *  writing to the nominated buffer.\r
  *\r

- *  \param  BufferPtr  Pointer to the data buffer to read from or write to\r
+ *  \param[in,out]  BufferPtr  Pointer to the data buffer to read from or write to\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  Unit in the attached device.\r
  *\r
 /** Issues a Mass Storage class specific request to determine the index of the highest numbered Logical\r
  *  Unit in the attached device.\r
  *\r

- *  \param MaxLUNIndex  Pointer to the location that the maximum LUN index value should be stored\r
+ *  \param[out] MaxLUNIndex  Pointer to the location that the maximum LUN index value should be stored\r

  *\r
  *  \return A value from the USB_Host_SendControlErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the USB_Host_SendControlErrorCodes_t enum\r
  */\r


@@ -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\r
  *  gives information on the device's capabilities.\r
  *\r
 /** Issues a SCSI Inquiry command to the attached device, to determine the device's information. This\r
  *  gives information on the device's capabilities.\r
  *\r

- *  \param LUNIndex    Index of the LUN inside the device the command is being addressed to\r
- *  \param InquiryPtr  Pointer to the inquiry data structure where the inquiry data from the device is to be stored\r
+ *  \param[in] LUNIndex    Index of the LUN inside the device the command is being addressed to\r
+ *  \param[out] InquiryPtr  Pointer to the inquiry data structure where the inquiry data from the device is to be stored\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  gives error codes for the last issued SCSI command to the device.\r
  *\r
 /** Issues a SCSI Request Sense command to the attached device, to determine the current SCSI sense information. This\r
  *  gives error codes for the last issued SCSI command to the device.\r
  *\r

- *  \param LUNIndex  Index of the LUN inside the device the command is being addressed to\r
- *  \param SensePtr  Pointer to the sense data structure where the sense data from the device is to be stored\r
+ *  \param[in] LUNIndex   Index of the LUN inside the device the command is being addressed to\r
+ *  \param[out] SensePtr  Pointer to the sense data structure where the sense data from the device is to be stored\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  storage medium into a buffer.\r
  *\r
 /** Issues a SCSI Device Block Read command to the attached device, to read in one or more data blocks from the\r
  *  storage medium into a buffer.\r
  *\r

- *  \param LUNIndex      Index of the LUN inside the device the command is being addressed to\r
- *  \param BlockAddress  Start block address to read from\r
- *  \param Blocks        Number of blocks to read from the device\r
- *  \param BlockSize     Size in bytes of each block to read\r
- *  \param BufferPtr     Pointer to the buffer where the read data is to be written to\r
+ *  \param[in] LUNIndex      Index of the LUN inside the device the command is being addressed to\r
+ *  \param[in] BlockAddress  Start block address to read from\r
+ *  \param[in] Blocks        Number of blocks to read from the device\r
+ *  \param[in] BlockSize     Size in bytes of each block to read\r
+ *  \param[out] BufferPtr    Pointer to the buffer where the read data is to be written to\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  storage medium from a buffer.\r
  *\r
 /** Issues a SCSI Device Block Write command to the attached device, to write one or more data blocks to the\r
  *  storage medium from a buffer.\r
  *\r

- *  \param LUNIndex      Index of the LUN inside the device the command is being addressed to\r
- *  \param BlockAddress  Start block address to write to\r
- *  \param Blocks        Number of blocks to write to in the device\r
- *  \param BlockSize     Size in bytes of each block to write\r
- *  \param BufferPtr     Pointer to the buffer where the write data is to be sourced from\r
+ *  \param[in] LUNIndex      Index of the LUN inside the device the command is being addressed to\r
+ *  \param[in] BlockAddress  Start block address to write to\r
+ *  \param[in] Blocks        Number of blocks to write to in the device\r
+ *  \param[in] BlockSize     Size in bytes of each block to write\r
+ *  \param[in] BufferPtr     Pointer to the buffer where the write data is to be sourced from\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  other commands.\r
  *\r
 /** Issues a SCSI Device Test Unit Ready command to the attached device, to determine if the device is ready to accept\r
  *  other commands.\r
  *\r

- *  \param LUNIndex      Index of the LUN inside the device the command is being addressed to\r
+ *  \param[in] LUNIndex      Index of the LUN inside the device the command is being addressed to\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  given Logical Unit within the device.\r
  *\r
 /** Issues a SCSI Device Read Capacity command to the attached device, to determine the capacity of the\r
  *  given Logical Unit within the device.\r
  *\r

- *  \param LUNIndex     Index of the LUN inside the device the command is being addressed to\r
- *  \param CapacityPtr  Device capacity structure where the capacity data is to be stored\r
+ *  \param[in] LUNIndex      Index of the LUN inside the device the command is being addressed to\r
+ *  \param[out] CapacityPtr  Device capacity structure where the capacity data is to be stored\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -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\r
  *  be issued before the first read or write command is sent.\r
  *\r
  *  being removed. This is a legacy command for SCSI disks with removable storage (such as ZIP disks), but should still\r
  *  be issued before the first read or write command is sent.\r
  *\r

- *  \param LUNIndex        Index of the LUN inside the device the command is being addressed to\r
- *  \param PreventRemoval  Whether or not the LUN media should be locked to prevent removal or not\r
+ *  \param[in] LUNIndex        Index of the LUN inside the device the command is being addressed to\r
+ *  \param[in] PreventRemoval  Whether or not the LUN media should be locked to prevent removal or not\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r

diff --git a/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.h b/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.h
index 8f3e8a1..f13b4b1 100644 (file)
--- a/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.h
+++ b/Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.h
@@ -42,7 +42,7 @@
                #include "MassStorageHost.h"\r
                #include "SCSI_Codes.h"\r
 \r
                #include "MassStorageHost.h"\r
                #include "SCSI_Codes.h"\r
 \r

-               #include <LUFA/Drivers/USB/USB.h>                    // USB Functionality\r
+               #include <LUFA/Drivers/USB/USB.h>\r

 \r
        /* Macros: */\r
                /** Class specific request to reset the Mass Storage interface of the attached device */\r
 \r
        /* Macros: */\r
                /** Class specific request to reset the Mass Storage interface of the attached device */\r

diff --git a/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.c b/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.c
index 200c81a..2f84d0f 100644 (file)
--- a/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.c
+++ b/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.c
@@ -349,9 +349,9 @@ void MassStorage_Task(void)
  *  printing error codes to the serial port and waiting until the device is removed before\r
  *  continuing.\r
  *\r
  *  printing error codes to the serial port and waiting until the device is removed before\r
  *  continuing.\r
  *\r

- *  \param CommandString  ASCII string located in PROGMEM space indicating what operation failed\r
- *  \param FailedAtSCSILayer  Indicates if the command failed at the (logical) SCSI layer or at the physical USB layer\r
- *  \param ErrorCode      Error code of the function which failed to complete successfully\r
+ *  \param[in] CommandString      ASCII string located in PROGMEM space indicating what operation failed\r
+ *  \param[in] FailedAtSCSILayer  Indicates if the command failed at the (logical) SCSI layer or at the physical USB layer\r
+ *  \param[in] ErrorCode          Error code of the function which failed to complete successfully\r

  */\r
 void ShowDiskReadError(char* CommandString, bool FailedAtSCSILayer, uint8_t ErrorCode)\r
 {\r
  */\r
 void ShowDiskReadError(char* CommandString, bool FailedAtSCSILayer, uint8_t ErrorCode)\r
 {\r

diff --git a/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.h b/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.h
index a5b84c2..1307a1a 100644 (file)
--- a/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.h
+++ b/Demos/Host/LowLevel/MassStorageHost/MassStorageHost.h
@@ -49,12 +49,12 @@
 \r
                #include "Lib/MassStoreCommands.h"\r
 \r
 \r
                #include "Lib/MassStoreCommands.h"\r
 \r

-               #include <LUFA/Version.h>                                // Library Version Information\r
-               #include <LUFA/Drivers/Misc/TerminalCodes.h>             // ANSI Terminal Escape Codes\r
-               #include <LUFA/Drivers/USB/USB.h>                        // USB Functionality\r
-               #include <LUFA/Drivers/Peripheral/SerialStream.h>        // Serial stream driver\r
-               #include <LUFA/Drivers/Board/LEDs.h>                     // LEDs driver\r
-               #include <LUFA/Drivers/Board/Buttons.h>                  // Board Buttons driver\r
+               #include <LUFA/Version.h>\r
+               #include <LUFA/Drivers/Misc/TerminalCodes.h>\r
+               #include <LUFA/Drivers/USB/USB.h>\r
+               #include <LUFA/Drivers/Peripheral/SerialStream.h>\r
+               #include <LUFA/Drivers/Board/LEDs.h>\r
+               #include <LUFA/Drivers/Board/Buttons.h>\r

 \r
        /* Macros: */\r
                /** LED mask for the library LED driver, to indicate that the USB interface is not ready. */\r
 \r
        /* Macros: */\r
                /** LED mask for the library LED driver, to indicate that the USB interface is not ready. */\r

diff --git a/Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.c b/Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.c
index 5f0d358..d7a9471 100644 (file)
--- a/Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.c
+++ b/Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.c
@@ -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\r
  *  as required and displays movement and button presses on the board LEDs.\r
  *\r
 /** Processes a read HID report from an attached mouse, extracting out elements via the HID parser results\r
  *  as required and displays movement and button presses on the board LEDs.\r
  *\r

- *  \param MouseReport  Pointer to a HID report from an attached mouse device\r
+ *  \param[in] MouseReport  Pointer to a HID report from an attached mouse device\r

  */\r
 void ProcessMouseReport(uint8_t* MouseReport)\r
 {\r
  */\r
 void ProcessMouseReport(uint8_t* MouseReport)\r
 {\r

diff --git a/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.c b/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.c
index 8f05e48..bf85750 100644 (file)
--- a/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.c
+++ b/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.c
@@ -190,8 +190,8 @@ uint8_t SImage_RecieveBlockHeader(void)
 \r
 /** Function to send the given data to the device, after a command block has been issued.\r
  *\r
 \r
 /** Function to send the given data to the device, after a command block has been issued.\r
  *\r

- *  \param Buffer  Source data buffer to send to the device\r
- *  \param Bytes   Number of bytes to send\r
+ *  \param[in] Buffer  Source data buffer to send to the device\r
+ *  \param[in] Bytes   Number of bytes to send\r

  */\r
 void SImage_SendData(void* Buffer, uint16_t Bytes)\r
 {\r
  */\r
 void SImage_SendData(void* Buffer, uint16_t Bytes)\r
 {\r


@@ -211,8 +211,8 @@ void SImage_SendData(void* Buffer, uint16_t Bytes)
 \r
 /** Function to receive the given data to the device, after a response block has been received.\r
  *\r
 \r
 /** Function to receive the given data to the device, after a response block has been received.\r
  *\r

- *  \param Buffer  Destination data buffer to put read bytes from the device\r
- *  \param Bytes   Number of bytes to receive\r
+ *  \param[out] Buffer  Destination data buffer to put read bytes from the device\r
+ *  \param[in] Bytes    Number of bytes to receive\r

  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum\r
  */\r


@@ -257,7 +257,7 @@ bool SImage_IsEventReceived(void)
 \r
 /** Clears the stall condition in the attached device on the nominated endpoint number.\r
  *\r
 \r
 /** Clears the stall condition in the attached device on the nominated endpoint number.\r
  *\r

- *  \param EndpointNum  Endpoint number in the attached device whose stall condition is to be cleared\r
+ *  \param[in] EndpointNum  Endpoint number in the attached device whose stall condition is to be cleared\r

  *\r
  *  \return A value from the USB_Host_SendControlErrorCodes_t enum\r
  */\r
  *\r
  *  \return A value from the USB_Host_SendControlErrorCodes_t enum\r
  */\r

diff --git a/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.h b/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.h
index ad0ba55..2674b6a 100644 (file)
--- a/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.h
+++ b/Demos/Host/LowLevel/StillImageHost/Lib/StillImageCommands.h
@@ -57,7 +57,7 @@
                /** Used in the DataLength field of a PIMA container, to give the total container size in bytes for\r
                 *  a command container.\r
                 *\r
                /** Used in the DataLength field of a PIMA container, to give the total container size in bytes for\r
                 *  a command container.\r
                 *\r

-                *  \param params  Number of parameters which are to be sent in the Param field of the container\r
+                *  \param[in] params  Number of parameters which are to be sent in the Param field of the container\r

                 */\r
                #define PIMA_COMMAND_SIZE(params)      ((sizeof(PIMA_SendBlock) - sizeof(PIMA_SendBlock.Params)) + \\r
                                                        (params * sizeof(PIMA_SendBlock.Params[0])))\r
                 */\r
                #define PIMA_COMMAND_SIZE(params)      ((sizeof(PIMA_SendBlock) - sizeof(PIMA_SendBlock.Params)) + \\r
                                                        (params * sizeof(PIMA_SendBlock.Params[0])))\r


@@ -65,7 +65,7 @@
                /** Used in the DataLength field of a PIMA container, to give the total container size in bytes for\r
                 *  a data container.\r
                 *\r
                /** Used in the DataLength field of a PIMA container, to give the total container size in bytes for\r
                 *  a data container.\r
                 *\r

-                *  \param datalen  Length in bytes of the data in the container\r
+                *  \param[in] datalen  Length in bytes of the data in the container\r

                 */\r
                #define PIMA_DATA_SIZE(datalen)        ((sizeof(PIMA_SendBlock) - sizeof(PIMA_SendBlock.Params)) + datalen)\r
 \r
                 */\r
                #define PIMA_DATA_SIZE(datalen)        ((sizeof(PIMA_SendBlock) - sizeof(PIMA_SendBlock.Params)) + datalen)\r
 \r

diff --git a/Demos/Host/LowLevel/StillImageHost/StillImageHost.c b/Demos/Host/LowLevel/StillImageHost/StillImageHost.c
index a337ab0..5243871 100644 (file)
--- a/Demos/Host/LowLevel/StillImageHost/StillImageHost.c
+++ b/Demos/Host/LowLevel/StillImageHost/StillImageHost.c
@@ -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\r
  *  strings which contain ASCII printable characters only.\r
  *\r
 /** Function to convert a given Unicode encoded string to ASCII. This function will only work correctly on Unicode\r
  *  strings which contain ASCII printable characters only.\r
  *\r

- *  \param UnicodeString  Pointer to a Unicode encoded input string\r
- *  \param Buffer         Pointer to a buffer where the converted ASCII string should be stored\r
+ *  \param[in] UnicodeString  Pointer to a Unicode encoded input string\r
+ *  \param[out] Buffer        Pointer to a buffer where the converted ASCII string should be stored\r

  */\r
 void UnicodeToASCII(uint8_t* UnicodeString, char* Buffer)\r
 {\r
  */\r
 void UnicodeToASCII(uint8_t* UnicodeString, char* Buffer)\r
 {\r


@@ -351,8 +351,8 @@ void UnicodeToASCII(uint8_t* UnicodeString, char* Buffer)
 \r
 /** Displays a PIMA command error via the device's serial port.\r
  *\r
 \r
 /** Displays a PIMA command error via the device's serial port.\r
  *\r

- *  \param ErrorCode          Error code of the function which failed to complete successfully\r
- *  \param ResponseCodeError  Indicates if the error is due to a command failed indication from the device, or a communication failure\r
+ *  \param[in] ErrorCode          Error code of the function which failed to complete successfully\r
+ *  \param[in] ResponseCodeError  Indicates if the error is due to a command failed indication from the device, or a communication failure\r

  */\r
 void ShowCommandError(uint8_t ErrorCode, bool ResponseCodeError)\r
 {\r
  */\r
 void ShowCommandError(uint8_t ErrorCode, bool ResponseCodeError)\r
 {\r

diff --git a/LUFA/Common/Common.h b/LUFA/Common/Common.h
index 24ba1f6..92f4f22 100644 (file)
--- a/LUFA/Common/Common.h
+++ b/LUFA/Common/Common.h
@@ -121,7 +121,7 @@
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r

-                        *  \param Byte   Byte of data whose bits are to be reversed\r
+                        *  \param[in] Byte   Byte of data whose bits are to be reversed\r

                         */\r
                        static inline uint8_t BitReverse(uint8_t Byte) ATTR_WARN_UNUSED_RESULT ATTR_CONST;\r
                        static inline uint8_t BitReverse(uint8_t Byte)\r
                         */\r
                        static inline uint8_t BitReverse(uint8_t Byte) ATTR_WARN_UNUSED_RESULT ATTR_CONST;\r
                        static inline uint8_t BitReverse(uint8_t Byte)\r


@@ -137,7 +137,7 @@
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r

-                        *  \param Word   Word of data whose bytes are to be swapped\r
+                        *  \param[in] Word   Word of data whose bytes are to be swapped\r

                         */\r
                        static inline uint16_t SwapEndian_16(uint16_t Word) ATTR_WARN_UNUSED_RESULT ATTR_CONST;\r
                        static inline uint16_t SwapEndian_16(uint16_t Word)\r
                         */\r
                        static inline uint16_t SwapEndian_16(uint16_t Word) ATTR_WARN_UNUSED_RESULT ATTR_CONST;\r
                        static inline uint16_t SwapEndian_16(uint16_t Word)\r


@@ -149,7 +149,7 @@
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r

-                        *  \param DWord   Double word of data whose bytes are to be swapped\r
+                        *  \param[in] DWord   Double word of data whose bytes are to be swapped\r

                         */\r
                        static inline uint32_t SwapEndian_32(uint32_t DWord) ATTR_WARN_UNUSED_RESULT ATTR_CONST;\r
                        static inline uint32_t SwapEndian_32(uint32_t DWord)\r
                         */\r
                        static inline uint32_t SwapEndian_32(uint32_t DWord) ATTR_WARN_UNUSED_RESULT ATTR_CONST;\r
                        static inline uint32_t SwapEndian_32(uint32_t DWord)\r


@@ -164,8 +164,8 @@
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r
                         *\r
                         *  \ingroup Group_BitManip\r
                         *\r

-                        *  \param Data   Pointer to a number containing an even number of bytes to be reversed\r
-                        *  \param Bytes  Length of the data in bytes\r
+                        *  \param[in,out] Data  Pointer to a number containing an even number of bytes to be reversed\r
+                        *  \param[in] Bytes  Length of the data in bytes\r

                         */\r
                        static inline void SwapEndian_n(uint8_t* Data, uint8_t Bytes);\r
                        static inline void SwapEndian_n(uint8_t* Data, uint8_t Bytes)\r
                         */\r
                        static inline void SwapEndian_n(uint8_t* Data, uint8_t Bytes);\r
                        static inline void SwapEndian_n(uint8_t* Data, uint8_t Bytes)\r

diff --git a/LUFA/DriverStubs/Dataflash.h b/LUFA/DriverStubs/Dataflash.h
index 41581a7..92de426 100644 (file)
--- a/LUFA/DriverStubs/Dataflash.h
+++ b/LUFA/DriverStubs/Dataflash.h
@@ -85,8 +85,8 @@
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r

-                        *  \param PageAddress  Address of the page to manipulate, ranging from\r
-                        *                      ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r
+                        *  \param[in] PageAddress  Address of the page to manipulate, ranging from\r
+                        *                          ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r

                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r
                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r


@@ -102,8 +102,8 @@
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r

-                        *  \param PageAddress  Page address within the selected dataflash IC\r
-                        *  \param BufferByte   Address within the dataflash's buffer\r
+                        *  \param[in] PageAddress  Page address within the selected dataflash IC\r
+                        *  \param[in] BufferByte   Address within the dataflash's buffer\r

                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r
                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r

diff --git a/LUFA/Drivers/Board/Dataflash.h b/LUFA/Drivers/Board/Dataflash.h
index 2030093..57ce92d 100644 (file)
--- a/LUFA/Drivers/Board/Dataflash.h
+++ b/LUFA/Drivers/Board/Dataflash.h
@@ -86,8 +86,8 @@
 \r
                                /** Selects the given dataflash chip.\r
                                 *\r
 \r
                                /** Selects the given dataflash chip.\r
                                 *\r

-                                *  \param  ChipMask  Mask of the Dataflash IC to select, in the form of DATAFLASH_CHIPn mask (where n is\r
-                                *          the chip number).\r
+                                *  \param[in]  ChipMask  Mask of the Dataflash IC to select, in the form of DATAFLASH_CHIPn mask (where n is\r
+                                *              the chip number).\r

                                 */\r
                                static inline void Dataflash_SelectChip(uint8_t ChipMask);\r
 \r
                                 */\r
                                static inline void Dataflash_SelectChip(uint8_t ChipMask);\r
 \r


@@ -105,7 +105,7 @@
                /* Inline Functions: */\r
                        /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.\r
                         *\r
                /* Inline Functions: */\r
                        /** Sends a byte to the currently selected dataflash IC, and returns a byte from the dataflash.\r
                         *\r

-                        *  \param Byte of data to send to the dataflash\r
+                        *  \param[in] Byte of data to send to the dataflash\r

                         *\r
                         *  \return Last response byte from the dataflash\r
                         */\r
                         *\r
                         *  \return Last response byte from the dataflash\r
                         */\r


@@ -117,7 +117,7 @@
 \r
                        /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.\r
                         *\r
 \r
                        /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.\r
                         *\r

-                        *  \param Byte of data to send to the dataflash\r
+                        *  \param[in] Byte of data to send to the dataflash\r

                         */\r
                        static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Dataflash_SendByte(const uint8_t Byte)\r
                         */\r
                        static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Dataflash_SendByte(const uint8_t Byte)\r


@@ -154,7 +154,7 @@
                        /** Initializes the dataflash driver (including the SPI driver) so that commands and data may be\r
                         *  sent to an attached dataflash IC.\r
                         *\r
                        /** Initializes the dataflash driver (including the SPI driver) so that commands and data may be\r
                         *  sent to an attached dataflash IC.\r
                         *\r

-                        *  \param PrescalerMask  SPI prescaler mask, see SPI.h documentation\r
+                        *  \param[in] PrescalerMask  SPI prescaler mask, see SPI.h documentation\r

                         */\r
                        static inline void Dataflash_Init(const uint8_t PrescalerMask)\r
                        {\r
                         */\r
                        static inline void Dataflash_Init(const uint8_t PrescalerMask)\r
                        {\r


@@ -191,16 +191,16 @@
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r

-                        *  \param PageAddress  Address of the page to manipulate, ranging from\r
-                        *                      ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r
+                        *  \param[in] PageAddress  Address of the page to manipulate, ranging from\r
+                        *                          ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r

                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress);\r
 \r
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r
                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress);\r
 \r
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r

-                        *  \param PageAddress  Page address within the selected dataflash IC\r
-                        *  \param BufferByte   Address within the dataflash's buffer\r
+                        *  \param[in] PageAddress  Page address within the selected dataflash IC\r
+                        *  \param[in] BufferByte   Address within the dataflash's buffer\r

                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte);\r
 \r
                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte);\r
 \r

diff --git a/LUFA/Drivers/Board/LEDs.h b/LUFA/Drivers/Board/LEDs.h
index f65e67c..9693999 100644 (file)
--- a/LUFA/Drivers/Board/LEDs.h
+++ b/LUFA/Drivers/Board/LEDs.h
@@ -117,28 +117,28 @@
 \r
                /** Turns on the LEDs specified in the given LED mask.\r
                 *\r
 \r
                /** Turns on the LEDs specified in the given LED mask.\r
                 *\r

-                *  \param LEDMask  Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r
+                *  \param[in] LEDMask  Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r

                 */\r
                static inline void LEDs_TurnOnLEDs(const uint8_t LEDMask);\r
 \r
                /** Turns off the LEDs specified in the given LED mask.\r
                 *\r
                 */\r
                static inline void LEDs_TurnOnLEDs(const uint8_t LEDMask);\r
 \r
                /** Turns off the LEDs specified in the given LED mask.\r
                 *\r

-                *  \param LEDMask  Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r
+                *  \param[in] LEDMask  Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r

                 */\r
                static inline void LEDs_TurnOffLEDs(const uint8_t LEDMask);\r
 \r
                /** Turns off all LEDs not specified in the given LED mask, and turns on all the LEDs in the given LED\r
                 *  mask.\r
                 *\r
                 */\r
                static inline void LEDs_TurnOffLEDs(const uint8_t LEDMask);\r
 \r
                /** Turns off all LEDs not specified in the given LED mask, and turns on all the LEDs in the given LED\r
                 *  mask.\r
                 *\r

-                *  \param LEDMask  Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r
+                *  \param[in] LEDMask  Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r

                 */\r
                static inline void LEDs_SetAllLEDs(const uint8_t LEDMask);\r
 \r
                /** Turns off all LEDs in the LED mask that are not set in the active mask, and turns on all the LEDs\r
                 *  specified in both the LED and active masks.\r
                 *\r
                 */\r
                static inline void LEDs_SetAllLEDs(const uint8_t LEDMask);\r
 \r
                /** Turns off all LEDs in the LED mask that are not set in the active mask, and turns on all the LEDs\r
                 *  specified in both the LED and active masks.\r
                 *\r

-                *  \param LEDMask     Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r
-                *  \param ActiveMask  Mask of whether the LEDs in the LED mask should be turned on or off\r
+                *  \param[in] LEDMask     Mask of the board LEDs to manipulate (see board-specific LEDs.h driver file)\r
+                *  \param[in] ActiveMask  Mask of whether the LEDs in the LED mask should be turned on or off\r

                 */\r
                static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask);\r
 \r
                 */\r
                static inline void LEDs_ChangeLEDs(const uint8_t LEDMask, const uint8_t ActiveMask);\r
 \r

diff --git a/LUFA/Drivers/Board/STK525/Dataflash.h b/LUFA/Drivers/Board/STK525/Dataflash.h
index bc9ab9f..3378756 100644 (file)
--- a/LUFA/Drivers/Board/STK525/Dataflash.h
+++ b/LUFA/Drivers/Board/STK525/Dataflash.h
@@ -85,8 +85,8 @@
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r

-                        *  \param PageAddress  Address of the page to manipulate, ranging from\r
-                        *                      ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r
+                        *  \param[in] PageAddress  Address of the page to manipulate, ranging from\r
+                        *                          ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r

                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r
                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r


@@ -101,8 +101,8 @@
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r

-                        *  \param PageAddress  Page address within the selected dataflash IC\r
-                        *  \param BufferByte   Address within the dataflash's buffer\r
+                        *  \param[in] PageAddress  Page address within the selected dataflash IC\r
+                        *  \param[in] BufferByte   Address within the dataflash's buffer\r

                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r
                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r

diff --git a/LUFA/Drivers/Board/STK526/Dataflash.h b/LUFA/Drivers/Board/STK526/Dataflash.h
index cb8193e..0b388e3 100644 (file)
--- a/LUFA/Drivers/Board/STK526/Dataflash.h
+++ b/LUFA/Drivers/Board/STK526/Dataflash.h
@@ -85,8 +85,8 @@
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r

-                        *  \param PageAddress  Address of the page to manipulate, ranging from\r
-                        *                      ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r
+                        *  \param[in] PageAddress  Address of the page to manipulate, ranging from\r
+                        *                          ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r

                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r
                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r


@@ -101,8 +101,8 @@
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r

-                        *  \param PageAddress  Page address within the selected dataflash IC\r
-                        *  \param BufferByte   Address within the dataflash's buffer\r
+                        *  \param[in] PageAddress  Page address within the selected dataflash IC\r
+                        *  \param[in] BufferByte   Address within the dataflash's buffer\r

                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r
                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r

diff --git a/LUFA/Drivers/Board/USBKEY/Dataflash.h b/LUFA/Drivers/Board/USBKEY/Dataflash.h
index d4bfdc9..52681de 100644 (file)
--- a/LUFA/Drivers/Board/USBKEY/Dataflash.h
+++ b/LUFA/Drivers/Board/USBKEY/Dataflash.h
@@ -88,8 +88,8 @@
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r
                         *  the total number of pages contained in the boards dataflash ICs, all dataflash ICs\r
                         *  are deselected.\r
                         *\r

-                        *  \param PageAddress  Address of the page to manipulate, ranging from\r
-                        *                      ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r
+                        *  \param[in] PageAddress  Address of the page to manipulate, ranging from\r
+                        *                          ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1).\r

                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r
                         */\r
                        static inline void Dataflash_SelectChipFromPage(const uint16_t PageAddress)\r
                        {\r


@@ -107,8 +107,8 @@
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r
                        /** Sends a set of page and buffer address bytes to the currently selected dataflash IC, for use with\r
                         *  dataflash commands which require a complete 24-byte address.\r
                         *\r

-                        *  \param PageAddress  Page address within the selected dataflash IC\r
-                        *  \param BufferByte   Address within the dataflash's buffer\r
+                        *  \param[in] PageAddress  Page address within the selected dataflash IC\r
+                        *  \param[in] BufferByte   Address within the dataflash's buffer\r

                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r
                         */\r
                        static inline void Dataflash_SendAddressBytes(uint16_t PageAddress, const uint16_t BufferByte)\r
                        {       \r

diff --git a/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h b/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
index 4cc7c32..4110a50 100644 (file)
--- a/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
+++ b/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
@@ -115,7 +115,7 @@
                                 *  The "mode" parameter should be a mask comprised of a conversion mode (free running or single) and\r
                                 *  prescaler masks.\r
                                 *\r
                                 *  The "mode" parameter should be a mask comprised of a conversion mode (free running or single) and\r
                                 *  prescaler masks.\r
                                 *\r

-                                *  \param Mode  Mask of ADC settings, including adjustment, prescale, mode and reference\r
+                                *  \param[in] Mode  Mask of ADC settings, including adjustment, prescale, mode and reference\r

                                 */\r
                                static inline void ADC_Init(uint8_t Mode);\r
                                \r
                                 */\r
                                static inline void ADC_Init(uint8_t Mode);\r
                                \r


@@ -159,7 +159,7 @@
                         *  associated port pin as an input and disables the digital portion of the I/O to reduce\r
                         *  power consumption.\r
                         *\r
                         *  associated port pin as an input and disables the digital portion of the I/O to reduce\r
                         *  power consumption.\r
                         *\r

-                        *  \param Channel  ADC channel number to set up for conversions\r
+                        *  \param[in] Channel  ADC channel number to set up for conversions\r

                         */\r
                        static inline void ADC_SetupChannel(const uint8_t Channel)\r
                        {\r
                         */\r
                        static inline void ADC_SetupChannel(const uint8_t Channel)\r
                        {\r


@@ -196,7 +196,7 @@
                         *  Once executed, the conversion status can be determined via the \ref ADC_IsReadingComplete() macro and\r
                         *  the result read via the \ref ADC_GetResult() macro.\r
                         *\r
                         *  Once executed, the conversion status can be determined via the \ref ADC_IsReadingComplete() macro and\r
                         *  the result read via the \ref ADC_GetResult() macro.\r
                         *\r

-                        *  \param MUXMask  Mask comprising of an ADC channel number, reference mask and adjustment mask\r
+                        *  \param[in] MUXMask  Mask comprising of an ADC channel number, reference mask and adjustment mask\r

                         */\r
                        static inline void ADC_StartReading(const uint8_t MUXMask)\r
                        {\r
                         */\r
                        static inline void ADC_StartReading(const uint8_t MUXMask)\r
                        {\r


@@ -208,7 +208,7 @@
                        /** Performs a complete single reading from channel, including a polling spinloop to wait for the\r
                         *  conversion to complete, and the returning of the converted value.\r
                         *\r
                        /** Performs a complete single reading from channel, including a polling spinloop to wait for the\r
                         *  conversion to complete, and the returning of the converted value.\r
                         *\r

-                        *  \param MUXMask  Mask comprising of an ADC channel number, reference mask and adjustment mask\r
+                        *  \param[in] MUXMask  Mask comprising of an ADC channel number, reference mask and adjustment mask\r

                         */\r
                        static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask) ATTR_WARN_UNUSED_RESULT;\r
                        static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask)\r
                         */\r
                        static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask) ATTR_WARN_UNUSED_RESULT;\r
                        static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask)\r

diff --git a/LUFA/Drivers/Peripheral/SPI.h b/LUFA/Drivers/Peripheral/SPI.h
index 66cdaf5..dc8661a 100644 (file)
--- a/LUFA/Drivers/Peripheral/SPI.h
+++ b/LUFA/Drivers/Peripheral/SPI.h
@@ -90,8 +90,8 @@
                        /** Initializes the SPI subsystem, ready for transfers. Must be called before calling any other\r
                         *  SPI routines.\r
                         *\r
                        /** Initializes the SPI subsystem, ready for transfers. Must be called before calling any other\r
                         *  SPI routines.\r
                         *\r

-                        *  \param PrescalerMask  Prescaler mask to set the SPI clock speed\r
-                        *  \param Master         If true, sets the SPI system to use master mode, slave if false\r
+                        *  \param[in] PrescalerMask  Prescaler mask to set the SPI clock speed\r
+                        *  \param[in] Master         If true, sets the SPI system to use master mode, slave if false\r

                         */\r
                        static inline void SPI_Init(const uint8_t PrescalerMask, const bool Master)\r
                        {\r
                         */\r
                        static inline void SPI_Init(const uint8_t PrescalerMask, const bool Master)\r
                        {\r


@@ -109,7 +109,7 @@
                        \r
                        /** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.\r
                         *\r
                        \r
                        /** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.\r
                         *\r

-                        *  \param Byte  Byte to send through the SPI interface\r
+                        *  \param[in] Byte  Byte to send through the SPI interface\r

                         *\r
                         *  \return Response byte from the attached SPI device\r
                         */\r
                         *\r
                         *  \return Response byte from the attached SPI device\r
                         */\r


@@ -124,7 +124,7 @@
                        /** Sends a byte through the SPI interface, blocking until the transfer is complete. The response\r
                         *  byte sent to from the attached SPI device is ignored.\r
                         *\r
                        /** Sends a byte through the SPI interface, blocking until the transfer is complete. The response\r
                         *  byte sent to from the attached SPI device is ignored.\r
                         *\r

-                        *  \param Byte Byte to send through the SPI interface\r
+                        *  \param[in] Byte Byte to send through the SPI interface\r

                         */\r
                        static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void SPI_SendByte(const uint8_t Byte)\r
                         */\r
                        static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void SPI_SendByte(const uint8_t Byte)\r

diff --git a/LUFA/Drivers/Peripheral/Serial.h b/LUFA/Drivers/Peripheral/Serial.h
index 7e718fe..82cbcfc 100644 (file)
--- a/LUFA/Drivers/Peripheral/Serial.h
+++ b/LUFA/Drivers/Peripheral/Serial.h
@@ -88,13 +88,13 @@
                /* Function Prototypes: */\r
                        /** Transmits a given string located in program space (FLASH) through the USART.\r
                         *\r
                /* Function Prototypes: */\r
                        /** Transmits a given string located in program space (FLASH) through the USART.\r
                         *\r

-                        *  \param FlashStringPtr  Pointer to a string located in program space\r
+                        *  \param[in] FlashStringPtr  Pointer to a string located in program space\r

                         */\r
                        void Serial_TxString_P(const char *FlashStringPtr) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Transmits a given string located in SRAM memory through the USART.\r
                         *\r
                         */\r
                        void Serial_TxString_P(const char *FlashStringPtr) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Transmits a given string located in SRAM memory through the USART.\r
                         *\r

-                        *  \param StringPtr  Pointer to a string located in SRAM space\r
+                        *  \param[in] StringPtr  Pointer to a string located in SRAM space\r

                         */\r
                        void Serial_TxString(const char *StringPtr) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                         */\r
                        void Serial_TxString(const char *StringPtr) ATTR_NON_NULL_PTR_ARG(1);\r
 \r


@@ -102,8 +102,8 @@
                        /** Initializes the USART, ready for serial data transmission and reception. This initialises the interface to\r
                         *  standard 8-bit, no parity, 1 stop bit settings suitable for most applications.\r
                         *\r
                        /** Initializes the USART, ready for serial data transmission and reception. This initialises the interface to\r
                         *  standard 8-bit, no parity, 1 stop bit settings suitable for most applications.\r
                         *\r

-                        *  \param BaudRate     Serial baud rate, in bits per second\r
-                        *  \param DoubleSpeed  Enables double speed mode when set, halving the sample time to double the baud rate\r
+                        *  \param[in] BaudRate     Serial baud rate, in bits per second\r
+                        *  \param[in] DoubleSpeed  Enables double speed mode when set, halving the sample time to double the baud rate\r

                         */\r
                        static inline void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed)\r
                        {\r
                         */\r
                        static inline void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed)\r
                        {\r


@@ -119,7 +119,7 @@
 \r
                        /** Transmits a given byte through the USART.\r
                         *\r
 \r
                        /** Transmits a given byte through the USART.\r
                         *\r

-                        *  \param DataByte  Byte to transmit through the USART\r
+                        *  \param[in] DataByte  Byte to transmit through the USART\r

                         */\r
                        static inline void Serial_TxByte(const char DataByte)\r
                        {\r
                         */\r
                        static inline void Serial_TxByte(const char DataByte)\r
                        {\r

diff --git a/LUFA/Drivers/Peripheral/SerialStream.h b/LUFA/Drivers/Peripheral/SerialStream.h
index 2753135..d3f0014 100644 (file)
--- a/LUFA/Drivers/Peripheral/SerialStream.h
+++ b/LUFA/Drivers/Peripheral/SerialStream.h
@@ -79,8 +79,8 @@
                        /** Initializes the serial stream (and regular USART driver) so that both the stream and regular\r
                         *  USART driver functions can be used. Must be called before any stream or regular USART functions.\r
                         *\r
                        /** Initializes the serial stream (and regular USART driver) so that both the stream and regular\r
                         *  USART driver functions can be used. Must be called before any stream or regular USART functions.\r
                         *\r

-                        *  \param BaudRate     Baud rate to configure the USART to\r
-                        *  \param DoubleSpeed  Enables double speed mode when set, halving the sample time to double the baud rate\r
+                        *  \param[in] BaudRate     Baud rate to configure the USART to\r
+                        *  \param[in] DoubleSpeed  Enables double speed mode when set, halving the sample time to double the baud rate\r

                         */\r
                        static inline void SerialStream_Init(const uint32_t BaudRate, const bool DoubleSpeed)\r
                        {\r
                         */\r
                        static inline void SerialStream_Init(const uint32_t BaudRate, const bool DoubleSpeed)\r
                        {\r

diff --git a/LUFA/Drivers/USB/Class/Common/Audio.h b/LUFA/Drivers/USB/Class/Common/Audio.h
index a55fd0d..33bc898 100644 (file)
--- a/LUFA/Drivers/USB/Class/Common/Audio.h
+++ b/LUFA/Drivers/USB/Class/Common/Audio.h
@@ -201,7 +201,7 @@
 \r
                /** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.\r
                 *\r
 \r
                /** Convenience macro, to fill a 24-bit AudioSampleFreq_t structure with the given sample rate as a 24-bit number.\r
                 *\r

-                *  \param freq  Required audio sampling frequency in HZ\r
+                *  \param[in] freq  Required audio sampling frequency in HZ\r

                 */\r
                #define AUDIO_SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}\r
                \r
                 */\r
                #define AUDIO_SAMPLE_FREQ(freq)  {LowWord: ((uint32_t)freq & 0x00FFFF), HighByte: (((uint32_t)freq >> 16) & 0x0000FF)}\r
                \r

diff --git a/LUFA/Drivers/USB/Class/Common/CDC.h b/LUFA/Drivers/USB/Class/Common/CDC.h
index 5138032..6980315 100644 (file)
--- a/LUFA/Drivers/USB/Class/Common/CDC.h
+++ b/LUFA/Drivers/USB/Class/Common/CDC.h
@@ -111,7 +111,7 @@
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r
                 *  a single typedef struct. A macro is used instead so that functional descriptors can be created\r
                 *  easily by specifying the size of the payload. This allows sizeof() to work correctly.\r
                 *\r

-                *  \param DataSize  Size in bytes of the CDC functional descriptor's data payload\r
+                *  \param[in] DataSize  Size in bytes of the CDC functional descriptor's data payload\r

                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r
                 */\r
                #define CDC_FUNCTIONAL_DESCRIPTOR(DataSize)        \\r
                     struct                                        \\r

diff --git a/LUFA/Drivers/USB/Class/Common/MIDI.h b/LUFA/Drivers/USB/Class/Common/MIDI.h
index dfeadb0..7dfb0e7 100644 (file)
--- a/LUFA/Drivers/USB/Class/Common/MIDI.h
+++ b/LUFA/Drivers/USB/Class/Common/MIDI.h
@@ -71,7 +71,7 @@
                /** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel\r
                 *  addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.\r
                 *\r
                /** Convenience macro. MIDI channels are numbered from 1-10 (natural numbers) however the logical channel\r
                 *  addresses are zero-indexed. This converts a natural MIDI channel number into the logical channel address.\r
                 *\r

-                *  \param channel  MIDI channel number to address\r
+                *  \param[in] channel  MIDI channel number to address\r

                 */\r
                #define MIDI_CHANNEL(channel)        (channel - 1)\r
                \r
                 */\r
                #define MIDI_CHANNEL(channel)        (channel - 1)\r
                \r

diff --git a/LUFA/Drivers/USB/Class/Device/Audio.c b/LUFA/Drivers/USB/Class/Device/Audio.c
index e398f1c..d117bed 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/Audio.c
+++ b/LUFA/Drivers/USB/Class/Device/Audio.c
@@ -33,7 +33,7 @@
 \r
 #include "Audio.h"\r
 \r
 \r
 #include "Audio.h"\r
 \r

-void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)\r
+void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)\r

 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r
 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r


@@ -83,7 +83,7 @@ bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfac
        return true;\r
 }\r
 \r
        return true;\r
 }\r
 \r

-void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)\r
+void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)\r

 {\r
 \r
 }\r
 {\r
 \r
 }\r


@@ -124,7 +124,7 @@ int32_t Audio_Device_ReadSample24(void)
        return Sample;\r
 }\r
 \r
        return Sample;\r
 }\r
 \r

-void Audio_Device_WriteSample8(int8_t Sample)\r
+void Audio_Device_WriteSample8(const int8_t Sample)\r

 {\r
        Endpoint_Write_Byte(Sample);\r
 \r
 {\r
        Endpoint_Write_Byte(Sample);\r
 \r


@@ -132,7 +132,7 @@ void Audio_Device_WriteSample8(int8_t Sample)
          Endpoint_ClearIN();\r
 }\r
 \r
          Endpoint_ClearIN();\r
 }\r
 \r

-void Audio_Device_WriteSample16(int16_t Sample)\r
+void Audio_Device_WriteSample16(const int16_t Sample)\r

 {\r
        Endpoint_Write_Word_LE(Sample);\r
 \r
 {\r
        Endpoint_Write_Word_LE(Sample);\r
 \r


@@ -140,7 +140,7 @@ void Audio_Device_WriteSample16(int16_t Sample)
          Endpoint_ClearIN();\r
 }\r
 \r
          Endpoint_ClearIN();\r
 }\r
 \r

-void Audio_Device_WriteSample24(int32_t Sample)\r
+void Audio_Device_WriteSample24(const int32_t Sample)\r

 {\r
        Endpoint_Write_Byte(Sample >> 16);\r
        Endpoint_Write_Word_LE(Sample);\r
 {\r
        Endpoint_Write_Byte(Sample >> 16);\r
        Endpoint_Write_Word_LE(Sample);\r


@@ -149,13 +149,13 @@ void Audio_Device_WriteSample24(int32_t Sample)
          Endpoint_ClearIN();\r
 }\r
 \r
          Endpoint_ClearIN();\r
 }\r
 \r

-bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)\r
+bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)\r

 {\r
        Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpointNumber);\r
        return Endpoint_IsOUTReceived();\r
 }\r
 \r
 {\r
        Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataOUTEndpointNumber);\r
        return Endpoint_IsOUTReceived();\r
 }\r
 \r

-bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo)\r
+bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)\r

 {\r
        Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpointNumber);\r
        return Endpoint_IsINReady();\r
 {\r
        Endpoint_SelectEndpoint(AudioInterfaceInfo->Config.DataINEndpointNumber);\r
        return Endpoint_IsINReady();\r

diff --git a/LUFA/Drivers/USB/Class/Device/Audio.h b/LUFA/Drivers/USB/Class/Device/Audio.h
index faa9c92..7ce0624 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/Audio.h
+++ b/LUFA/Drivers/USB/Class/Device/Audio.h
@@ -97,25 +97,25 @@
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the\r
                         *  given Audio interface is selected.\r
                         *\r
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the\r
                         *  given Audio interface is selected.\r
                         *\r

-                        *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
+                        *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);\r
+                       bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r

 \r
                        /** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r
 \r
                        /** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r

-                        *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
+                        *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r

                         */\r
                         */\r

-                       void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);\r
+                       void Audio_Device_ProcessControlPacket(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r

 \r
                        /** General management task for a given Audio class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
 \r
                        /** General management task for a given Audio class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
+                        *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r

                         */\r
                         */\r

-                       void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);\r
+                       void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r

                        \r
                        /** Reads the next 8-bit audio sample from the current audio interface.\r
                         *\r
                        \r
                        /** Reads the next 8-bit audio sample from the current audio interface.\r
                         *\r


@@ -149,43 +149,43 @@
                         *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that\r
                         *        the correct endpoint is selected and ready for data.\r
                         *\r
                         *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that\r
                         *        the correct endpoint is selected and ready for data.\r
                         *\r

-                        *  \param Sample  Signed 8-bit audio sample\r
+                        *  \param[in] Sample  Signed 8-bit audio sample\r

                         */\r
                         */\r

-                       void Audio_Device_WriteSample8(int8_t Sample);\r
+                       void Audio_Device_WriteSample8(const int8_t Sample);\r

 \r
                        /** Writes the next 16-bit audio sample to the current audio interface.\r
                         *\r
                         *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that\r
                         *        the correct endpoint is selected and ready for data.\r
                         *\r
 \r
                        /** Writes the next 16-bit audio sample to the current audio interface.\r
                         *\r
                         *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that\r
                         *        the correct endpoint is selected and ready for data.\r
                         *\r

-                        *  \param Sample  Signed 16-bit audio sample\r
+                        *  \param[in] Sample  Signed 16-bit audio sample\r

                         */\r
                         */\r

-                       void Audio_Device_WriteSample16(int16_t Sample);\r
+                       void Audio_Device_WriteSample16(const int16_t Sample);\r

 \r
                        /** Writes the next 24-bit audio sample to the current audio interface.\r
                         *\r
                         *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that\r
                         *        the correct endpoint is selected and ready for data.\r
                         *\r
 \r
                        /** Writes the next 24-bit audio sample to the current audio interface.\r
                         *\r
                         *  \note This should be preceeded immediately by a call to the USB_Audio_IsReadyForNextSample() function to ensure that\r
                         *        the correct endpoint is selected and ready for data.\r
                         *\r

-                        *  \param Sample  Signed 24-bit audio sample\r
+                        *  \param[in] Sample  Signed 24-bit audio sample\r

                         */\r
                         */\r

-                       void Audio_Device_WriteSample24(int32_t Sample);\r
+                       void Audio_Device_WriteSample24(const int32_t Sample);\r

 \r
                        /** Determines if the given audio interface is ready for a sample to be read from it.\r
                         *\r
 \r
                        /** Determines if the given audio interface is ready for a sample to be read from it.\r
                         *\r

-                        *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
+                        *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the given Audio interface has a sample to be read, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the given Audio interface has a sample to be read, false otherwise\r
                         */\r

-                       bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);\r
+                       bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r

 \r
                        /** Determines if the given audio interface is ready to accept the next sample to be written to it.\r
                         *\r
 \r
                        /** Determines if the given audio interface is ready to accept the next sample to be written to it.\r
                         *\r

-                        *  \param AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
+                        *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise\r
                         */\r

-                       bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* AudioInterfaceInfo);\r
+                       bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/USB/Class/Device/CDC.c b/LUFA/Drivers/USB/Class/Device/CDC.c
index fc6ea93..07c0514 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/CDC.c
+++ b/LUFA/Drivers/USB/Class/Device/CDC.c
@@ -131,7 +131,7 @@ void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
        Endpoint_ClearIN();\r
 }\r
 \r
        Endpoint_ClearIN();\r
 }\r
 \r

-void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length)\r
+void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r


@@ -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);\r
 }\r
 \r
        Endpoint_Write_Stream_LE(Data, Length, NO_STREAM_CALLBACK);\r
 }\r
 \r

-void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data)\r
+void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r


@@ -156,7 +156,7 @@ void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t D
        Endpoint_Write_Byte(Data);      \r
 }\r
 \r
        Endpoint_Write_Byte(Data);      \r
 }\r
 \r

-uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)\r
+uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

 {\r
        Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);\r
 \r
 {\r
        Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.DataOUTEndpointNumber);\r
 \r


@@ -178,7 +178,7 @@ uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)
        return DataByte;\r
 }\r
 \r
        return DataByte;\r
 }\r
 \r

-void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)\r
+void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r

diff --git a/LUFA/Drivers/USB/Class/Device/CDC.h b/LUFA/Drivers/USB/Class/Device/CDC.h
index 157b350..7b232fc 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/CDC.h
+++ b/LUFA/Drivers/USB/Class/Device/CDC.h
@@ -108,34 +108,34 @@
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the\r
                         *  given CDC interface is selected.\r
                         *\r
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration containing the\r
                         *  given CDC interface is selected.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

 \r
                        /** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r
 \r
                        /** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         */\r
                         */\r

-                       void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       void CDC_Device_ProcessControlPacket(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

 \r
                        /** General management task for a given CDC class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
 \r
                        /** General management task for a given CDC class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         */\r
                         */\r

-                       void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

 \r
                        /** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a\r
                         *  line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the\r
                         *  user program by declaring a handler function with the same name and parameters listed here. The new line encoding\r
                         *  settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.\r
                         *\r
 \r
                        /** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a\r
                         *  line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the\r
                         *  user program by declaring a handler function with the same name and parameters listed here. The new line encoding\r
                         *  settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         */\r
                         */\r

-                       void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

                        \r
                        /** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a\r
                         *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the\r
                        \r
                        /** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a\r
                         *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the\r


@@ -143,62 +143,62 @@
                         *  are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as\r
                         *  a mask of CDC_CONTROL_LINE_OUT_* masks.\r
                         *\r
                         *  are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as\r
                         *  a mask of CDC_CONTROL_LINE_OUT_* masks.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         */             \r
                         */             \r

-                       void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

 \r
                        /** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  string is discarded.\r
                         *\r
 \r
                        /** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  string is discarded.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
-                        *  \param Data  Pointer to the string to send to the host\r
-                        *  \param Length  Size in bytes of the string to send to the host\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in] Data  Pointer to the string to send to the host\r
+                        *  \param[in] Length  Size in bytes of the string to send to the host\r

                         */\r
                         */\r

-                       void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, char* Data, uint16_t Length);\r
+                       void CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length);\r

                        \r
                        /** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  byte is discarded.\r
                         *\r
                        \r
                        /** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  byte is discarded.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
-                        *  \param Data  Byte of data to send to the host\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in] Data  Byte of data to send to the host\r

                         */\r
                         */\r

-                       void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, uint8_t Data);\r
+                       void CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data);\r

                        \r
                        /** Determines the number of bytes received by the CDC interface from the host, waiting to be read.\r
                         *\r
                        \r
                        /** Determines the number of bytes received by the CDC interface from the host, waiting to be read.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         *\r
                         *  \return Total number of buffered bytes received from the host\r
                         */\r
                         *\r
                         *  \return Total number of buffered bytes received from the host\r
                         */\r

-                       uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

                        \r
                        /** 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\r
                         *  returns 0. The USB_CDC_BytesReceived() function should be queried before data is recieved to ensure that no data\r
                         *  underflow occurs.\r
                         *\r
                        \r
                        /** 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\r
                         *  returns 0. The USB_CDC_BytesReceived() function should be queried before data is recieved to ensure that no data\r
                         *  underflow occurs.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         *\r
                         *  \return Next received byte from the host, or 0 if no data received\r
                         */\r
                         *\r
                         *  \return Next received byte from the host, or 0 if no data received\r
                         */\r

-                       uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

                        \r
                        /** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial\r
                         *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist\r
                         *  until they are cleared via a second notification. This should be called each time the CDC class driver's \r
                         *  ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.\r
                         *\r
                        \r
                        /** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial\r
                         *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist\r
                         *  until they are cleared via a second notification. This should be called each time the CDC class driver's \r
                         *  ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.\r
                         *\r

-                        *  \param CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r

                         */\r
                         */\r

-                       void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo);\r
+                       void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r

 \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)\r
                                void CDC_Device_Event_Stub(void);\r
 \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)\r
                                void CDC_Device_Event_Stub(void);\r

-                               void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)\r
+                               void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

                                                                                                                  ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);\r
                                                                                                                  ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);\r

-                               void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo)\r
+                               void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

                                                                                                                         ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);\r
                        #endif\r
 \r
                                                                                                                         ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);\r
                        #endif\r
 \r

diff --git a/LUFA/Drivers/USB/Class/Device/HID.c b/LUFA/Drivers/USB/Class/Device/HID.c
index c37dc5d..d032086 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/HID.c
+++ b/LUFA/Drivers/USB/Class/Device/HID.c
@@ -33,7 +33,7 @@
 \r
 #include "HID.h"\r
 \r
 \r
 #include "HID.h"\r
 \r

-void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)\r
+void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)\r

 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r
 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r


@@ -130,7 +130,7 @@ void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInf
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)\r
+bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)\r

 {\r
        HIDInterfaceInfo->State.UsingReportProtocol = true;\r
 \r
 {\r
        HIDInterfaceInfo->State.UsingReportProtocol = true;\r
 \r


@@ -143,7 +143,7 @@ bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)
        return true;\r
 }\r
                \r
        return true;\r
 }\r
                \r

-void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo)\r
+void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r

diff --git a/LUFA/Drivers/USB/Class/Device/HID.h b/LUFA/Drivers/USB/Class/Device/HID.h
index 61e5eed..984078c 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/HID.h
+++ b/LUFA/Drivers/USB/Class/Device/HID.h
@@ -89,7 +89,7 @@
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given HID interface is selected.\r
                         *\r
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given HID interface is selected.\r
                         *\r

-                        *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
+                        *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r


@@ -98,14 +98,14 @@
                        /** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r
                        /** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r

-                        *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
+                        *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r

                         */             \r
                        void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
 \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         */             \r
                        void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
 \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
+                        *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r

                         */\r
                        void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
                        \r
                         */\r
                        void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
                        \r


@@ -113,11 +113,11 @@
                         *  HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the\r
                         *  user is responsible for the creation of the next HID input report to be sent to the host.\r
                         *\r
                         *  HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the\r
                         *  user is responsible for the creation of the next HID input report to be sent to the host.\r
                         *\r

-                        *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
-                        *  \param ReportID  If preset to a non-zero value, this is the report ID being requested by the host. If zero, this should\r
-                        *                   be set to the report ID of the generated HID input report. If multiple reports are not sent via the\r
-                        *                   given HID interface, this parameter should be ignored.\r
-                        *  \param ReportData  Pointer to a buffer where the generated HID report should be stored.\r
+                        *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
+                        *  \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\r
+                        *                 be set to the report ID of the generated HID input report. If multiple reports are not sent via the\r
+                        *                 given HID interface, this parameter should be ignored.\r
+                        *  \param[out] ReportData  Pointer to a buffer where the generated HID report should be stored.\r

                         *\r
                         *  \return  Number of bytes in the generated input report, or zero if no report is to be sent\r
                         */\r
                         *\r
                         *  \return  Number of bytes in the generated input report, or zero if no report is to be sent\r
                         */\r


@@ -127,14 +127,14 @@
                         *  either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback\r
                         *  the user is responsible for the processing of the received HID output report from the host.\r
                         *\r
                         *  either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback\r
                         *  the user is responsible for the processing of the received HID output report from the host.\r
                         *\r

-                        *  \param HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
-                        *  \param ReportID  Report ID of the received output report. If multiple reports are not received via the given HID\r
+                        *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
+                        *  \param[in] ReportID  Report ID of the received output report. If multiple reports are not received via the given HID\r

                         *                   interface, this parameter should be ignored.\r
                         *                   interface, this parameter should be ignored.\r

-                        *  \param ReportData  Pointer to a buffer where the received HID report is stored.\r
-                        *  \param ReportSize  Size in bytes of the received report from the host.\r
+                        *  \param[in] ReportData  Pointer to a buffer where the received HID report is stored.\r
+                        *  \param[in] ReportSize  Size in bytes of the received report from the host.\r

                         */\r
                         */\r

-                       void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID, void* ReportData,\r
-                                                                                                         uint16_t ReportSize);\r
+                       void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
+                                                                 const void* ReportData, const uint16_t ReportSize);\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/USB/Class/Device/MIDI.c b/LUFA/Drivers/USB/Class/Device/MIDI.c
index 0dcc94d..da33bdb 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/MIDI.c
+++ b/LUFA/Drivers/USB/Class/Device/MIDI.c
@@ -33,12 +33,12 @@
 \r
 #include "MIDI.h"\r
 \r
 \r
 #include "MIDI.h"\r
 \r

-void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)\r
+void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)\r

 {\r
 \r
 }\r
 \r
 {\r
 \r
 }\r
 \r

-bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)\r
+bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)\r

 {\r
        if (MIDIInterfaceInfo->Config.DataINEndpointNumber)\r
        {\r
 {\r
        if (MIDIInterfaceInfo->Config.DataINEndpointNumber)\r
        {\r


@@ -63,12 +63,12 @@ bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceIn
        return true;\r
 }\r
 \r
        return true;\r
 }\r
 \r

-void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo)\r
+void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo)\r

 {\r
 \r
 }\r
 \r
 {\r
 \r
 }\r
 \r

-void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)\r
+void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r


@@ -82,7 +82,7 @@ void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo,
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event)\r
+bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event)\r

 {\r
        if (!(USB_IsConnected))\r
          return false;\r
 {\r
        if (!(USB_IsConnected))\r
          return false;\r

diff --git a/LUFA/Drivers/USB/Class/Device/MIDI.h b/LUFA/Drivers/USB/Class/Device/MIDI.h
index e81089c..19ff5d4 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/MIDI.h
+++ b/LUFA/Drivers/USB/Class/Device/MIDI.h
@@ -54,12 +54,6 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Type Define: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Type Define: */\r

-                       /** Configuration information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */\r
-                       typedef  USB_ClassInfo_MIDI_Device_Config_t;\r
-       \r
-                       /** Current State information structure for \ref USB_ClassInfo_MIDI_Device_t MIDI device interface structures. */\r
-                       typedef  USB_ClassInfo_MIDI_Device_State_t;\r
-       \r

                        /** Class state structure. An instance of this structure should be made for each MIDI interface\r
                         *  within the user application, and passed to each of the MIDI class driver functions as the\r
                         *  MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.\r
                        /** Class state structure. An instance of this structure should be made for each MIDI interface\r
                         *  within the user application, and passed to each of the MIDI class driver functions as the\r
                         *  MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.\r


@@ -92,41 +86,41 @@
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given MIDI interface is selected.\r
                         *\r
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given MIDI interface is selected.\r
                         *\r

-                        *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
+                        *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);\r
+                       bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);\r

                        \r
                        /** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r
                        \r
                        /** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r

-                        *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
+                        *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r

                         */             \r
                         */             \r

-                       void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);\r
+                       void MIDI_Device_ProcessControlPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);\r

 \r
                        /** General management task for a given MIDI class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
 \r
                        /** General management task for a given MIDI class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
+                        *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r

                         */\r
                         */\r

-                       void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo);\r
+                       void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);\r

 \r
                        /** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.\r
                         *\r
 \r
                        /** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.\r
                         *\r

-                        *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
-                        *  \param Event  Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send\r
+                        *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
+                        *  \param[in] Event  Pointer to a populated USB_MIDI_EventPacket_t structure containing the MIDI event to send\r

                         */\r
                         */\r

-                       void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);\r
+                       void MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);\r

 \r
                        /** Receives a MIDI event packet from the host.\r
                         *\r
 \r
                        /** Receives a MIDI event packet from the host.\r
                         *\r

-                        *  \param MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
-                        *  \param Event  Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed\r
+                        *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
+                        *  \param[out] Event  Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed\r

                         *\r
                         *  \return Boolean true if a MIDI event packet was received, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if a MIDI event packet was received, false otherwise\r
                         */\r

-                       bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* MIDIInterfaceInfo, MIDI_EventPacket_t* Event);\r
+                       bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/USB/Class/Device/MassStorage.c b/LUFA/Drivers/USB/Class/Device/MassStorage.c
index aedab10..9d73989 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/MassStorage.c
+++ b/LUFA/Drivers/USB/Class/Device/MassStorage.c
@@ -36,7 +36,7 @@
 \r
 static USB_ClassInfo_MS_Device_t* CallbackMSInterfaceInfo;\r
 \r
 \r
 static USB_ClassInfo_MS_Device_t* CallbackMSInterfaceInfo;\r
 \r

-void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
+void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)\r

 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r
 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r


@@ -75,7 +75,7 @@ void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
+bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)\r

 {\r
        if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,\r
                                                                 ENDPOINT_DIR_IN, MSInterfaceInfo->Config.DataINEndpointSize,\r
 {\r
        if (!(Endpoint_ConfigureEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,\r
                                                                 ENDPOINT_DIR_IN, MSInterfaceInfo->Config.DataINEndpointSize,\r


@@ -94,7 +94,7 @@ bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
        return true;\r
 }\r
 \r
        return true;\r
 }\r
 \r

-void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
+void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r


@@ -138,7 +138,7 @@ void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
        MSInterfaceInfo->State.IsMassStoreReset = false;\r
 }\r
 \r
        MSInterfaceInfo->State.IsMassStoreReset = false;\r
 }\r
 \r

-static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
+static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)\r

 {\r
        Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);\r
 \r
 {\r
        Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);\r
 \r


@@ -171,7 +171,7 @@ static bool MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceI
        return true;\r
 }\r
 \r
        return true;\r
 }\r
 \r

-static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)\r
+static void MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)\r

 {\r
        Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);\r
 \r
 {\r
        Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);\r
 \r

diff --git a/LUFA/Drivers/USB/Class/Device/MassStorage.h b/LUFA/Drivers/USB/Class/Device/MassStorage.h
index 15be00e..6b139ad 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/MassStorage.h
+++ b/LUFA/Drivers/USB/Class/Device/MassStorage.h
@@ -95,43 +95,43 @@
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given Mass Storage interface is selected.\r
                         *\r
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given Mass Storage interface is selected.\r
                         *\r

-                        *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);\r
+                       bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r

                        \r
                        /** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r
                        \r
                        /** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r

-                        *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r

                         */             \r
                         */             \r

-                       void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);\r
+                       void MS_Device_ProcessControlPacket(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r

 \r
                        /** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
 \r
                        /** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage configuration and state.\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage configuration and state.\r

                         */\r
                         */\r

-                       void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);\r
+                       void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r

                        \r
                        /** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the\r
                         *  host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible\r
                         *  for the processing of the received SCSI command from the host. The SCSI command is available in the CommandBlock structure\r
                         *  inside the Mass Storage class state structure passed as a parameter to the callback function.\r
                         *\r
                        \r
                        /** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the\r
                         *  host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible\r
                         *  for the processing of the received SCSI command from the host. The SCSI command is available in the CommandBlock structure\r
                         *  inside the Mass Storage class state structure passed as a parameter to the callback function.\r
                         *\r

-                        *  \param MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the SCSI command was successfully processed, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the SCSI command was successfully processed, false otherwise\r
                         */\r

-                       bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);\r
+                       bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r

                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)\r
                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)\r

-                               static void    MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);\r
-                               static bool    MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* MSInterfaceInfo);\r
+                               static void    MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
+                               static bool    MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r

                                static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);\r
                        #endif\r
                \r
                                static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);\r
                        #endif\r
                \r

diff --git a/LUFA/Drivers/USB/Class/Device/RNDIS.c b/LUFA/Drivers/USB/Class/Device/RNDIS.c
index bf753bf..1b2da6f 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/RNDIS.c
+++ b/LUFA/Drivers/USB/Class/Device/RNDIS.c
@@ -65,7 +65,7 @@ static const uint32_t PROGMEM AdapterSupportedOIDList[]  =
                OID_802_3_XMIT_MORE_COLLISIONS,\r
        };\r
 \r
                OID_802_3_XMIT_MORE_COLLISIONS,\r
        };\r
 \r

-void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)\r
+void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)\r

 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r
 {\r
        if (!(Endpoint_IsSETUPReceived()))\r
          return;\r


@@ -110,7 +110,7 @@ void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterf
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)\r
+bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)\r

 {\r
        if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,\r
                                                                 ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.DataINEndpointSize,\r
 {\r
        if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,\r
                                                                 ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.DataINEndpointSize,\r


@@ -136,7 +136,7 @@ bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfac
        return true;\r
 }\r
 \r
        return true;\r
 }\r
 \r

-void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)\r
+void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)\r

 {\r
        if (!(USB_IsConnected))\r
          return;\r
 {\r
        if (!(USB_IsConnected))\r
          return;\r


@@ -208,7 +208,7 @@ void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
        }\r
 }                                                      \r
 \r
        }\r
 }                                                      \r
 \r

-void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)\r
+void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)\r

 {\r
        /* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of\r
                 this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */\r
 {\r
        /* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of\r
                 this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */\r


@@ -331,9 +331,9 @@ void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDIS
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo,\r
-                                          uint32_t OId, void* QueryData, uint16_t QuerySize,\r
-                                          void* ResponseData, uint16_t* ResponseSize)\r
+static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,\r
+                                          const uint32_t OId, void* const QueryData, const uint16_t QuerySize,\r
+                                          void* ResponseData, uint16_t* const ResponseSize)\r

 {\r
        switch (OId)\r
        {\r
 {\r
        switch (OId)\r
        {\r


@@ -443,8 +443,8 @@ static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInt
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId, void* SetData,\r
-                                        uint16_t SetSize)\r
+static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId, void* SetData,\r
+                                        const uint16_t SetSize)\r

 {\r
        switch (OId)\r
        {\r
 {\r
        switch (OId)\r
        {\r

diff --git a/LUFA/Drivers/USB/Class/Device/RNDIS.h b/LUFA/Drivers/USB/Class/Device/RNDIS.h
index 21fb094..a4c2050 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/RNDIS.h
+++ b/LUFA/Drivers/USB/Class/Device/RNDIS.h
@@ -103,36 +103,36 @@
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given HID interface is selected.\r
                         *\r
                         *  \ref EVENT_USB_ConfigurationChanged() event so that the endpoints are configured when the configuration\r
                         *  containing the given HID interface is selected.\r
                         *\r

-                        *  \param RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
+                        *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r

                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);\r
+                       bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r

 \r
                        /** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r
 \r
                        /** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_UnhandledControlPacket() event.\r
                         *\r

-                        *  \param RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
+                        *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r

                         */             \r
                         */             \r

-                       void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);\r
+                       void RNDIS_Device_ProcessControlPacket(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r

                        \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                        \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
+                        *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r

                         */\r
                         */\r

-                       void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);\r
+                       void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r

                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                #if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)\r
                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                #if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)\r

-                       static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo);\r
-                       static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, \r
-                                                                 uint32_t OId, void* QueryData, uint16_t QuerySize,\r
-                                                                                             void* ResponseData, uint16_t* ResponseSize);\r
-                       static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo, uint32_t OId,\r
-                                                               void* SetData, uint16_t SetSize);       \r
+                       static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r
+                       static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, \r
+                                                                 const uint32_t OId, void* const QueryData, const uint16_t QuerySize,\r
+                                                                                             void* ResponseData, uint16_t* const ResponseSize);\r
+                       static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,\r
+                                                               void* SetData, const uint16_t SetSize); \r

                #endif\r
                \r
        #endif\r
                #endif\r
                \r
        #endif\r

diff --git a/LUFA/Drivers/USB/Class/Host/HIDParser.h b/LUFA/Drivers/USB/Class/Host/HIDParser.h
index 4acce24..f878aa1 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/HIDParser.h
+++ b/LUFA/Drivers/USB/Class/Host/HIDParser.h
@@ -209,9 +209,9 @@
                        /** Function to process a given HID report returned from an attached device, and store it into a given\r
                         *  \ref HID_ReportInfo_t structure.\r
                         *\r
                        /** Function to process a given HID report returned from an attached device, and store it into a given\r
                         *  \ref HID_ReportInfo_t structure.\r
                         *\r

-                        *  \param ReportData  Buffer containing the device's HID report table\r
-                        *  \param ReportSize  Size in bytes of the HID report table\r
-                        *  \param ParserData  Pointer to a \ref HID_ReportInfo_t instance for the parser output\r
+                        *  \param[in] ReportData  Buffer containing the device's HID report table\r
+                        *  \param[in] ReportSize  Size in bytes of the HID report table\r
+                        *  \param[out] ParserData  Pointer to a \ref HID_ReportInfo_t instance for the parser output\r

                         *\r
                         *  \return A value in the \ref HID_Parse_ErrorCodes_t enum\r
                         */\r
                         *\r
                         *  \return A value in the \ref HID_Parse_ErrorCodes_t enum\r
                         */\r


@@ -221,8 +221,8 @@
                        /** Extracts the given report item's value out of the given HID report and places it into the Value\r
                         *  member of the report item's \ref HID_ReportItem_t structure.\r
                         *\r
                        /** Extracts the given report item's value out of the given HID report and places it into the Value\r
                         *  member of the report item's \ref HID_ReportItem_t structure.\r
                         *\r

-                        *  \param ReportData  Buffer containing an IN or FEATURE report from an attached device\r
-                        *  \param ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array\r
+                        *  \param[in] ReportData  Buffer containing an IN or FEATURE report from an attached device\r
+                        *  \param[in,out] ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array\r

                         *\r
                         *  \returns Boolean true if the item to retrieve was located in the given report, false otherwise\r
                         */\r
                         *\r
                         *  \returns Boolean true if the item to retrieve was located in the given report, false otherwise\r
                         */\r


@@ -236,8 +236,8 @@
                         *\r
                         *  If the device has multiple HID reports, the report ID is set to the report ID of the given item.\r
                         *\r
                         *\r
                         *  If the device has multiple HID reports, the report ID is set to the report ID of the given item.\r
                         *\r

-                        *  \param ReportData  Buffer holding the current OUT report data\r
-                        *  \param ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array\r
+                        *  \param[out] ReportData  Buffer holding the current OUT report data\r
+                        *  \param[in] ReportItem  Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array\r

                         */\r
                        void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)\r
                                                      ATTR_NON_NULL_PTR_ARG(1, 2);\r
                         */\r
                        void USB_SetHIDReportItemInfo(uint8_t* ReportData, const HID_ReportItem_t* ReportItem)\r
                                                      ATTR_NON_NULL_PTR_ARG(1, 2);\r

diff --git a/LUFA/Drivers/USB/HighLevel/ConfigDescriptor.h b/LUFA/Drivers/USB/HighLevel/ConfigDescriptor.h
index 17b6378..a9b0b14 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/ConfigDescriptor.h
+++ b/LUFA/Drivers/USB/HighLevel/ConfigDescriptor.h
@@ -133,9 +133,9 @@
                         *\r
                         *  \note This function is available in USB Host mode only.\r
                         *\r
                         *\r
                         *  \note This function is available in USB Host mode only.\r
                         *\r

-                        *  \param BytesRem  Pointer to an int storing the remaining bytes in the configuration descriptor\r
-                        *  \param CurrConfigLoc  Pointer to the current position in the configuration descriptor\r
-                        *  \param ComparatorRoutine  Name of the comparator search function to use on the configuration descriptor\r
+                        *  \param[in,out] BytesRem  Pointer to an int storing the remaining bytes in the configuration descriptor\r
+                        *  \param[in,out] CurrConfigLoc  Pointer to the current position in the configuration descriptor\r
+                        *  \param[in] ComparatorRoutine  Name of the comparator search function to use on the configuration descriptor\r

                         *\r
                         *  \return Value of one of the members of the \ref DSearch_Comp_Return_ErrorCodes_t enum\r
                         *\r
                         *\r
                         *  \return Value of one of the members of the \ref DSearch_Comp_Return_ErrorCodes_t enum\r
                         *\r


@@ -183,17 +183,17 @@
                /* Function Prototypes: */\r
                        /** Retrieves the configuration descriptor data or size from an attached device via a standard request.\r
                         *\r
                /* Function Prototypes: */\r
                        /** Retrieves the configuration descriptor data or size from an attached device via a standard request.\r
                         *\r

-                        *  \param ConfigNumber  Device configuration descriptor number to fetch from the device (usually set to 1 for\r
-                        *                       single configuration devices)\r
+                        *  \param[in] ConfigNumber  Device configuration descriptor number to fetch from the device (usually set to 1 for\r
+                        *                           single configuration devices)\r

                         *\r
                         *\r

-                        *  \param ConfigSizePtr  Pointer to a uint16_t for either storing or retrieving the configuration\r
-                        *         descriptor size\r
+                        *  \param[in,out] ConfigSizePtr  Pointer to a uint16_t for either storing or retrieving the configuration\r
+                        *                                descriptor size\r

                         *\r
                         *\r

-                        *  \param BufferPtr  Pointer to the buffer for storing the configuration descriptor data. If this is\r
-                        *                    NULL, the size of the configuration descriptor will be retrieved instead and\r
-                        *                    placed in the variable pointed to by ConfigSizePtr. If this is non-NULL, the number\r
-                        *                    of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded\r
-                        *                    into the buffer\r
+                        *  \param[out] BufferPtr  Pointer to the buffer for storing the configuration descriptor data. If this is\r
+                        *                         NULL, the size of the configuration descriptor will be retrieved instead and\r
+                        *                         placed in the variable pointed to by ConfigSizePtr. If this is non-NULL, the number\r
+                        *                         of bytes indicated by ConfigSizePtr of the configuration descriptor will be loaded\r
+                        *                         into the buffer\r

                         */\r
                        uint8_t USB_GetDeviceConfigDescriptor(uint8_t ConfigNumber, uint16_t* const ConfigSizePtr, void* BufferPtr)\r
                                                              ATTR_NON_NULL_PTR_ARG(2);\r
                         */\r
                        uint8_t USB_GetDeviceConfigDescriptor(uint8_t ConfigNumber, uint16_t* const ConfigSizePtr, void* BufferPtr)\r
                                                              ATTR_NON_NULL_PTR_ARG(2);\r


@@ -201,9 +201,9 @@
                        /** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value.\r
                         *  The bytes remaining value is automatically decremented.\r
                         *\r
                        /** Skips to the next sub-descriptor inside the configuration descriptor of the specified type value.\r
                         *  The bytes remaining value is automatically decremented.\r
                         *\r

-                        * \param BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
-                        * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
-                        * \param Type  Descriptor type value to search for\r
+                        * \param[in,out] BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
+                        * \param[in,out] CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
+                        * \param[in] Type  Descriptor type value to search for\r

                         */\r
                        void USB_GetNextDescriptorOfType(uint16_t* const BytesRem,\r
                                                         uint8_t** const CurrConfigLoc,\r
                         */\r
                        void USB_GetNextDescriptorOfType(uint16_t* const BytesRem,\r
                                                         uint8_t** const CurrConfigLoc,\r


@@ -215,10 +215,10 @@
                         *  descriptor is reached first, the number of bytes remaining to process is set to zero and the\r
                         *  function exits. The bytes remaining value is automatically decremented.\r
                         *\r
                         *  descriptor is reached first, the number of bytes remaining to process is set to zero and the\r
                         *  function exits. The bytes remaining value is automatically decremented.\r
                         *\r

-                        * \param BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
-                        * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
-                        * \param Type  Descriptor type value to search for\r
-                        * \param BeforeType  Descriptor type value which must not be reached before the given Type descriptor\r
+                        * \param[in,out] BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
+                        * \param[in,out] CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
+                        * \param[in] Type  Descriptor type value to search for\r
+                        * \param[in] BeforeType  Descriptor type value which must not be reached before the given Type descriptor\r

                         */\r
                        void USB_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,\r
                                                               uint8_t** const CurrConfigLoc,\r
                         */\r
                        void USB_GetNextDescriptorOfTypeBefore(uint16_t* const BytesRem,\r
                                                               uint8_t** const CurrConfigLoc,\r


@@ -230,10 +230,10 @@
                         *  which must come after a descriptor of the second given type value. The bytes remaining value is\r
                         *  automatically decremented.\r
                         *\r
                         *  which must come after a descriptor of the second given type value. The bytes remaining value is\r
                         *  automatically decremented.\r
                         *\r

-                        * \param BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
-                        * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
-                        * \param Type  Descriptor type value to search for\r
-                        * \param AfterType  Descriptor type value which must be reached before the given Type descriptor\r
+                        * \param[in,out] BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
+                        * \param[in,out] CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
+                        * \param[in] Type  Descriptor type value to search for\r
+                        * \param[in] AfterType  Descriptor type value which must be reached before the given Type descriptor\r

                         */\r
                        void USB_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,\r
                                                              uint8_t** const CurrConfigLoc,\r
                         */\r
                        void USB_GetNextDescriptorOfTypeAfter(uint16_t* const BytesRem,\r
                                                              uint8_t** const CurrConfigLoc,\r


@@ -245,8 +245,8 @@
                        /** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then\r
                            points to the next sub-descriptor. The bytes remaining value is automatically decremented.\r
                         *\r
                        /** Skips over the current sub-descriptor inside the configuration descriptor, so that the pointer then\r
                            points to the next sub-descriptor. The bytes remaining value is automatically decremented.\r
                         *\r

-                        * \param BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
-                        * \param CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r
+                        * \param[in,out] BytesRem  Pointer to the number of bytes remaining of the configuration descriptor\r
+                        * \param[in,out] CurrConfigLoc  Pointer to the current descriptor inside the configuration descriptor\r

                         */\r
                        static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,\r
                                                                 uint8_t** const CurrConfigLoc) \r
                         */\r
                        static inline void USB_GetNextDescriptor(uint16_t* const BytesRem,\r
                                                                 uint8_t** const CurrConfigLoc) \r

diff --git a/LUFA/Drivers/USB/HighLevel/Events.h b/LUFA/Drivers/USB/HighLevel/Events.h
index 7f369bc..2df0dda 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/Events.h
+++ b/LUFA/Drivers/USB/HighLevel/Events.h
@@ -127,7 +127,7 @@
                         *\r
                         *  \note This event only exists on USB AVR models which support dual role modes.\r
                         *\r
                         *\r
                         *  \note This event only exists on USB AVR models which support dual role modes.\r
                         *\r

-                        *  \param ErrorCode  Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t\r
+                        *  \param[in] ErrorCode  Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t\r

                         */\r
                        void EVENT_USB_InitFailure(const uint8_t ErrorCode);\r
 \r
                         */\r
                        void EVENT_USB_InitFailure(const uint8_t ErrorCode);\r
 \r


@@ -146,7 +146,7 @@
                        /** Event for USB host error. This event fires when a hardware fault has occurred whilst the USB\r
                         *  interface is in host mode.\r
                         *\r
                        /** Event for USB host error. This event fires when a hardware fault has occurred whilst the USB\r
                         *  interface is in host mode.\r
                         *\r

-                        *  \param ErrorCode  Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t\r
+                        *  \param[in] ErrorCode  Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t\r

                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r
                         *\r
                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r
                         *\r


@@ -185,12 +185,12 @@
                        /** Event for USB device enumeration failure. This event fires when a the USB interface is\r
                         *  in host mode, and an attached USB device has failed to enumerate completely.\r
                         *\r
                        /** Event for USB device enumeration failure. This event fires when a the USB interface is\r
                         *  in host mode, and an attached USB device has failed to enumerate completely.\r
                         *\r

-                        *  \param ErrorCode  Error code indicating the failure reason, a value in \r
-                        *                    \ref USB_Host_EnumerationErrorCodes_t\r
+                        *  \param[in] ErrorCode  Error code indicating the failure reason, a value in \r
+                        *                        \ref USB_Host_EnumerationErrorCodes_t\r

                         *\r
                         *\r

-                        *  \param SubErrorCode  Sub error code indicating the reason for failure - for example, if the\r
-                        *                       ErrorCode parameter indicates a control error, this will give the error\r
-                        *                       code returned by the \ref USB_Host_SendControlRequest() function.\r
+                        *  \param[in] SubErrorCode  Sub error code indicating the reason for failure - for example, if the\r
+                        *                           ErrorCode parameter indicates a control error, this will give the error\r
+                        *                           code returned by the \ref USB_Host_SendControlRequest() function.\r

                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r
                         *\r
                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r
                         *\r

diff --git a/LUFA/Drivers/USB/LowLevel/Device.h b/LUFA/Drivers/USB/LowLevel/Device.h
index 6661b9e..470c317 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Device.h
+++ b/LUFA/Drivers/USB/LowLevel/Device.h
@@ -124,15 +124,15 @@
                         *  index and language ID. This function MUST be overridden in the user application (added with full, identical  \r
                         *  prototype and name so that the library can call it to retrieve descriptor data.\r
                         *\r
                         *  index and language ID. This function MUST be overridden in the user application (added with full, identical  \r
                         *  prototype and name so that the library can call it to retrieve descriptor data.\r
                         *\r

-                        *  \param wValue             The type of the descriptor to retrieve in the upper byte, and the index in the \r
-                        *                            lower byte (when more than one descriptor of the given type exists, such as the\r
-                        *                            case of string descriptors). The type may be one of the standard types defined\r
-                        *                            in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.\r
-                        *  \param wIndex             The language ID of the string to return if the wValue type indicates DTYPE_String,\r
-                        *                            otherwise zero for standard descriptors, or as defined in a class-specific\r
-                        *                            standards.\r
-                        *  \param DescriptorAddress  Pointer to the descriptor in memory. This should be set by the routine to\r
-                        *                            the address of the descriptor.\r
+                        *  \param[in] wValue  The type of the descriptor to retrieve in the upper byte, and the index in the \r
+                        *                     lower byte (when more than one descriptor of the given type exists, such as the\r
+                        *                     case of string descriptors). The type may be one of the standard types defined\r
+                        *                     in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.\r
+                        *  \param[in] wIndex  The language ID of the string to return if the wValue type indicates DTYPE_String,\r
+                        *                     otherwise zero for standard descriptors, or as defined in a class-specific\r
+                        *                     standards.\r
+                        *  \param[out] DescriptorAddress  Pointer to the descriptor in memory. This should be set by the routine to\r
+                        *                                 the address of the descriptor.\r

                         *\r
                         *  \note By default, the library expects all descriptors to be located in flash memory via the PROGMEM attribute.\r
                         *        If descriptors should be located in RAM or EEPROM instead (to speed up access in the case of RAM, or to\r
                         *\r
                         *  \note By default, the library expects all descriptors to be located in flash memory via the PROGMEM attribute.\r
                         *        If descriptors should be located in RAM or EEPROM instead (to speed up access in the case of RAM, or to\r

diff --git a/LUFA/Drivers/USB/LowLevel/Endpoint.c b/LUFA/Drivers/USB/LowLevel/Endpoint.c
index dca7554..1ff66dd 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Endpoint.c
+++ b/LUFA/Drivers/USB/LowLevel/Endpoint.c
@@ -119,6 +119,46 @@ uint8_t Endpoint_Discard_Stream(uint16_t Length
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Endpoint_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Endpoint_ClearOUT();\r
+\r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return ENDPOINT_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Endpoint_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       Endpoint_Discard_Byte();\r
+                       case 7: Endpoint_Discard_Byte();\r
+                       case 6: Endpoint_Discard_Byte();\r
+                       case 5: Endpoint_Discard_Byte();\r
+                       case 4: Endpoint_Discard_Byte();\r
+                       case 3: Endpoint_Discard_Byte();\r
+                       case 2: Endpoint_Discard_Byte();\r
+                       case 1: Endpoint_Discard_Byte();\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r


@@ -155,6 +195,46 @@ uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Endpoint_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Endpoint_ClearIN();\r
+\r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return ENDPOINT_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Endpoint_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       Endpoint_Write_Byte(*(DataStream++));\r
+                       case 7: Endpoint_Write_Byte(*(DataStream++));\r
+                       case 6: Endpoint_Write_Byte(*(DataStream++));\r
+                       case 5: Endpoint_Write_Byte(*(DataStream++));\r
+                       case 4: Endpoint_Write_Byte(*(DataStream++));\r
+                       case 3: Endpoint_Write_Byte(*(DataStream++));\r
+                       case 2: Endpoint_Write_Byte(*(DataStream++));\r
+                       case 1: Endpoint_Write_Byte(*(DataStream++));\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r


@@ -175,7 +255,7 @@ uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length
                        Length--;\r
                }\r
        }\r
                        Length--;\r
                }\r
        }\r

-       \r
+\r

        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 \r
        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 \r


@@ -191,6 +271,46 @@ uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Endpoint_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Endpoint_ClearIN();\r
+\r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return ENDPOINT_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Endpoint_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       Endpoint_Write_Byte(*(DataStream--));\r
+                       case 7: Endpoint_Write_Byte(*(DataStream--));\r
+                       case 6: Endpoint_Write_Byte(*(DataStream--));\r
+                       case 5: Endpoint_Write_Byte(*(DataStream--));\r
+                       case 4: Endpoint_Write_Byte(*(DataStream--));\r
+                       case 3: Endpoint_Write_Byte(*(DataStream--));\r
+                       case 2: Endpoint_Write_Byte(*(DataStream--));\r
+                       case 1: Endpoint_Write_Byte(*(DataStream--));\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r


@@ -211,7 +331,7 @@ uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length
                        Length--;\r
                }\r
        }\r
                        Length--;\r
                }\r
        }\r

-       \r
+\r

        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 \r
        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 \r


@@ -227,6 +347,46 @@ uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Endpoint_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Endpoint_ClearOUT();\r
+\r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return ENDPOINT_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Endpoint_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 7: *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 6: *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 5: *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 4: *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 3: *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 2: *(DataStream++) = Endpoint_Read_Byte();\r
+                       case 1: *(DataStream++) = Endpoint_Read_Byte();\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r


@@ -247,7 +407,7 @@ uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length
                        Length--;\r
                }\r
        }\r
                        Length--;\r
                }\r
        }\r

-       \r
+\r

        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 \r
        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 \r


@@ -263,6 +423,46 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Endpoint_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Endpoint_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Endpoint_ClearOUT();\r
+\r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return ENDPOINT_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Endpoint_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 7: *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 6: *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 5: *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 4: *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 3: *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 2: *(DataStream--) = Endpoint_Read_Byte();\r
+                       case 1: *(DataStream--) = Endpoint_Read_Byte();\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Endpoint_IsReadWriteAllowed()))\r


@@ -283,7 +483,7 @@ uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length
                        Length--;\r
                }\r
        }\r
                        Length--;\r
                }\r
        }\r

-       \r
+\r

        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 #endif\r
        return ENDPOINT_RWSTREAM_NoError;\r
 }\r
 #endif\r

diff --git a/LUFA/Drivers/USB/LowLevel/Endpoint.h b/LUFA/Drivers/USB/LowLevel/Endpoint.h
index 2c7a064..772d1fe 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Endpoint.h
+++ b/LUFA/Drivers/USB/LowLevel/Endpoint.h
@@ -117,13 +117,13 @@
                        \r
                        /** Maximum size in bytes of a given endpoint.\r
                         *\r
                        \r
                        /** Maximum size in bytes of a given endpoint.\r
                         *\r

-                        *  \param n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r
+                        *  \param[in] n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r

                         */                             \r
                        #define ENDPOINT_MAX_SIZE(n)                  _ENDPOINT_GET_MAXSIZE(n)\r
 \r
                        /** Indicates if the given endpoint supports double banking.\r
                         *\r
                         */                             \r
                        #define ENDPOINT_MAX_SIZE(n)                  _ENDPOINT_GET_MAXSIZE(n)\r
 \r
                        /** Indicates if the given endpoint supports double banking.\r
                         *\r

-                        *  \param n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r
+                        *  \param[in] n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r

                         */                             \r
                        #define ENDPOINT_DOUBLEBANK_SUPPORTED(n)      _ENDPOINT_GET_DOUBLEBANK(n)\r
 \r
                         */                             \r
                        #define ENDPOINT_DOUBLEBANK_SUPPORTED(n)      _ENDPOINT_GET_DOUBLEBANK(n)\r
 \r


@@ -169,14 +169,14 @@
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
                                 *  the currently selected endpoint.\r
                                 *\r
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
                                 *  the currently selected endpoint.\r
                                 *\r

-                                *  \param EndpointNumber Endpoint number to select\r
+                                *  \param[in] EndpointNumber Endpoint number to select\r

                                 */\r
                                static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber);\r
                                \r
                                /** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's\r
                                 *  In and Out pointers to the bank's contents.\r
                                 *\r
                                 */\r
                                static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber);\r
                                \r
                                /** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's\r
                                 *  In and Out pointers to the bank's contents.\r
                                 *\r

-                                *  \param EndpointNumber Endpoint number whose FIFO buffers are to be reset\r
+                                *  \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset\r

                                 */\r
                                static inline void Endpoint_ResetFIFO(uint8_t EndpointNumber);\r
                                \r
                                 */\r
                                static inline void Endpoint_ResetFIFO(uint8_t EndpointNumber);\r
                                \r


@@ -227,7 +227,7 @@
                                /** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type\r
                                 *  endpoints).\r
                                 *\r
                                /** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type\r
                                 *  endpoints).\r
                                 *\r

-                                *  \param EndpointNumber  Index of the endpoint whose interrupt flag should be tested\r
+                                *  \param[in] EndpointNumber  Index of the endpoint whose interrupt flag should be tested\r

                                 *\r
                                 *  \return Boolean true if the specified endpoint has interrupted, false otherwise\r
                                 */\r
                                 *\r
                                 *  \return Boolean true if the specified endpoint has interrupted, false otherwise\r
                                 */\r


@@ -454,7 +454,7 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Byte  Next byte to write into the the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] Byte  Next byte to write into the the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte)\r
                         */\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte)\r


@@ -515,7 +515,7 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Word  Next word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word)\r
                         */\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word)\r


@@ -529,7 +529,7 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Word  Next word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word)\r
                         */\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word)\r


@@ -604,7 +604,7 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)\r
                         */\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)\r


@@ -620,7 +620,7 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)\r
                         */\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)\r


@@ -722,8 +722,8 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Length    Number of bytes to send via the currently selected endpoint.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -748,9 +748,9 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer    Pointer to the source data buffer to read from.\r
-                        *  \param Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -775,9 +775,9 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer    Pointer to the source data buffer to read from.\r
-                        *  \param Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -802,9 +802,9 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer    Pointer to the destination data buffer to write to.\r
-                        *  \param Length    Number of bytes to send via the currently selected endpoint.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[out] Buffer    Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -829,9 +829,9 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer    Pointer to the destination data buffer to write to.\r
-                        *  \param Length    Number of bytes to send via the currently selected endpoint.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[out] Buffer    Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -855,8 +855,8 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer  Pointer to the source data buffer to read from.\r
-                        *  \param Length  Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -874,8 +874,8 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer  Pointer to the source data buffer to read from.\r
-                        *  \param Length  Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -893,8 +893,8 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer  Pointer to the destination data buffer to write to.\r
-                        *  \param Length  Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[out] Buffer  Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected endpoint.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -912,8 +912,8 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \param Buffer  Pointer to the destination data buffer to write to.\r
-                        *  \param Length  Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[out] Buffer  Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected endpoint.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r

diff --git a/LUFA/Drivers/USB/LowLevel/Host.h b/LUFA/Drivers/USB/LowLevel/Host.h
index 26e2d76..08b21f6 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Host.h
+++ b/LUFA/Drivers/USB/LowLevel/Host.h
@@ -182,7 +182,7 @@
                         *\r
                         *  \note After this routine returns, the control pipe will be selected.\r
                         *\r
                         *\r
                         *  \note After this routine returns, the control pipe will be selected.\r
                         *\r

-                        *  \param ConfigNumber  Configuration index to send to the device\r
+                        *  \param[in] ConfigNumber  Configuration index to send to the device\r

                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */\r
                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */\r


@@ -194,8 +194,8 @@
                         *\r
                         *  \note After this routine returns, the control pipe will be selected.\r
                         *\r
                         *\r
                         *  \note After this routine returns, the control pipe will be selected.\r
                         *\r

-                        *  \param DeviceDescriptorPtr  Pointer to the destination device descriptor structure where\r
-                        *                              the read data is to be stored\r
+                        *  \param[out] DeviceDescriptorPtr  Pointer to the destination device descriptor structure where\r
+                        *                                   the read data is to be stored\r

                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */\r
                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */\r


@@ -205,7 +205,7 @@
                         *\r
                         *  \note After this routine returns, the control pipe will be selected.\r
                         *\r
                         *\r
                         *  \note After this routine returns, the control pipe will be selected.\r
                         *\r

-                        *  \param EndpointIndex  Index of the endpoint to clear\r
+                        *  \param[in] EndpointIndex  Index of the endpoint to clear\r

                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */                     \r
                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */                     \r

diff --git a/LUFA/Drivers/USB/LowLevel/HostChapter9.h b/LUFA/Drivers/USB/LowLevel/HostChapter9.h
index 1e3f7b2..3fa5277 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/HostChapter9.h
+++ b/LUFA/Drivers/USB/LowLevel/HostChapter9.h
@@ -71,8 +71,8 @@
                         *\r
                         *  \ingroup Group_PipeControlReq\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeControlReq\r
                         *\r

-                        *  \param BufferPtr  Pointer to the start of the data buffer if the request has a data stage, or\r
-                        *                    NULL if the request transfers no data to or from the device.\r
+                        *  \param[in] BufferPtr  Pointer to the start of the data buffer if the request has a data stage, or\r
+                        *                        NULL if the request transfers no data to or from the device.\r

                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */\r
                         *\r
                         *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
                         */\r

diff --git a/LUFA/Drivers/USB/LowLevel/LowLevel.h b/LUFA/Drivers/USB/LowLevel/LowLevel.h
index 14d10c7..df1fa0b 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/LowLevel.h
+++ b/LUFA/Drivers/USB/LowLevel/LowLevel.h
@@ -228,14 +228,14 @@
                         *  Calling this function when the USB interface is already initialized will cause a complete USB\r
                         *  interface reset and re-enumeration.\r
                         *\r
                         *  Calling this function when the USB interface is already initialized will cause a complete USB\r
                         *  interface reset and re-enumeration.\r
                         *\r

-                        *  \param Mode     This is a mask indicating what mode the USB interface is to be initialized to.\r
-                        *                  Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.\r
+                        *  \param[in] Mode     This is a mask indicating what mode the USB interface is to be initialized to.\r
+                        *                      Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.\r

                         *\r
                         *\r

-                        *  \param Options  Mask indicating the options which should be used when initializing the USB\r
-                        *                  interface to control the USB interface's behaviour. This should be comprised of\r
-                        *                  a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the\r
-                        *                  PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device\r
-                        *                  mode speed.\r
+                        *  \param[in] Options  Mask indicating the options which should be used when initializing the USB\r
+                        *                      interface to control the USB interface's behaviour. This should be comprised of\r
+                        *                      a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the\r
+                        *                      PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device\r
+                        *                      mode speed.\r

                         *\r
                         *  \note To reduce the FLASH requirements of the library if only device or host mode is required, \r
                         *        this can be statically set via defining the token USB_DEVICE_ONLY for device mode or \r
                         *\r
                         *  \note To reduce the FLASH requirements of the library if only device or host mode is required, \r
                         *        this can be statically set via defining the token USB_DEVICE_ONLY for device mode or \r

diff --git a/LUFA/Drivers/USB/LowLevel/OTG.h b/LUFA/Drivers/USB/LowLevel/OTG.h
index d3dee96..d95488e 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/OTG.h
+++ b/LUFA/Drivers/USB/LowLevel/OTG.h
@@ -102,7 +102,7 @@
                                 *  There are two different methods of sending a SRP - either pulses on the VBUS line, or by\r
                                 *  pulsing the Data + line via the internal pull-up resistor.\r
                                 *\r
                                 *  There are two different methods of sending a SRP - either pulses on the VBUS line, or by\r
                                 *  pulsing the Data + line via the internal pull-up resistor.\r
                                 *\r

-                                *  \param SRPTypeMask  Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or \ref USB_OTG_STP_DATA.\r
+                                *  \param[in] SRPTypeMask  Mask indicating the type of SRP to use, either \ref USB_OTG_SRP_VBUS or \ref USB_OTG_STP_DATA.\r

                                 */\r
                                static inline void USB_OTG_Dev_InitiateSRP(uint8_t SRPTypeMask);\r
                        #else\r
                                 */\r
                                static inline void USB_OTG_Dev_InitiateSRP(uint8_t SRPTypeMask);\r
                        #else\r

diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.c b/LUFA/Drivers/USB/LowLevel/Pipe.c
index 1376de4..ab09279 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Pipe.c
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.c
@@ -120,6 +120,46 @@ uint8_t Pipe_Write_Stream_LE(const void* Data, uint16_t Length
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Pipe_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Pipe_ClearOUT();\r
+                                                       \r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return PIPE_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Pipe_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       Pipe_Write_Byte(*(DataStream++));\r
+                       case 7: Pipe_Write_Byte(*(DataStream++));\r
+                       case 6: Pipe_Write_Byte(*(DataStream++));\r
+                       case 5: Pipe_Write_Byte(*(DataStream++));\r
+                       case 4: Pipe_Write_Byte(*(DataStream++));\r
+                       case 3: Pipe_Write_Byte(*(DataStream++));\r
+                       case 2: Pipe_Write_Byte(*(DataStream++));\r
+                       case 1: Pipe_Write_Byte(*(DataStream++));\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+       \r

        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r


@@ -158,6 +198,46 @@ uint8_t Pipe_Write_Stream_BE(const void* Data, uint16_t Length
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Pipe_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Pipe_ClearOUT();\r
+                                                       \r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return PIPE_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Pipe_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       Pipe_Write_Byte(*(DataStream--));\r
+                       case 7: Pipe_Write_Byte(*(DataStream--));\r
+                       case 6: Pipe_Write_Byte(*(DataStream--));\r
+                       case 5: Pipe_Write_Byte(*(DataStream--));\r
+                       case 4: Pipe_Write_Byte(*(DataStream--));\r
+                       case 3: Pipe_Write_Byte(*(DataStream--));\r
+                       case 2: Pipe_Write_Byte(*(DataStream--));\r
+                       case 1: Pipe_Write_Byte(*(DataStream--));\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r


@@ -195,6 +275,46 @@ uint8_t Pipe_Discard_Stream(uint16_t Length
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Pipe_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Pipe_ClearIN();\r
+                                                       \r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return PIPE_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Pipe_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       Pipe_Discard_Byte();\r
+                       case 7: Pipe_Discard_Byte();\r
+                       case 6: Pipe_Discard_Byte();\r
+                       case 5: Pipe_Discard_Byte();\r
+                       case 4: Pipe_Discard_Byte();\r
+                       case 3: Pipe_Discard_Byte();\r
+                       case 2: Pipe_Discard_Byte();\r
+                       case 1: Pipe_Discard_Byte();\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r


@@ -233,6 +353,46 @@ uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Pipe_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Pipe_ClearIN();\r
+                                                       \r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return PIPE_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Pipe_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       *(DataStream++) = Pipe_Read_Byte();\r
+                       case 7: *(DataStream++) = Pipe_Read_Byte();\r
+                       case 6: *(DataStream++) = Pipe_Read_Byte();\r
+                       case 5: *(DataStream++) = Pipe_Read_Byte();\r
+                       case 4: *(DataStream++) = Pipe_Read_Byte();\r
+                       case 3: *(DataStream++) = Pipe_Read_Byte();\r
+                       case 2: *(DataStream++) = Pipe_Read_Byte();\r
+                       case 1: *(DataStream++) = Pipe_Read_Byte();\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r


@@ -271,6 +431,46 @@ uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r
        if ((ErrorCode = Pipe_WaitUntilReady()))\r
          return ErrorCode;\r
 \r

+       #if defined(FAST_STREAM_TRANSFERS)\r
+       uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);\r
+\r
+       if (Length >= 8)\r
+       {\r
+               Length -= BytesRemToAlignment;\r
+\r
+               switch (BytesRemToAlignment)\r
+               {\r
+                       default:\r
+                               do\r
+                               {\r
+                                       if (!(Pipe_IsReadWriteAllowed()))\r
+                                       {\r
+                                               Pipe_ClearIN();\r
+                                                       \r
+                                               #if !defined(NO_STREAM_CALLBACKS)\r
+                                               if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))\r
+                                                 return PIPE_RWSTREAM_CallbackAborted;\r
+                                               #endif\r
+\r
+                                               if ((ErrorCode = Pipe_WaitUntilReady()))\r
+                                                 return ErrorCode;\r
+                                       }\r
+\r
+                                       Length -= 8;\r
+                                       \r
+                                       *(DataStream--) = Pipe_Read_Byte();\r
+                       case 7: *(DataStream--) = Pipe_Read_Byte();\r
+                       case 6: *(DataStream--) = Pipe_Read_Byte();\r
+                       case 5: *(DataStream--) = Pipe_Read_Byte();\r
+                       case 4: *(DataStream--) = Pipe_Read_Byte();\r
+                       case 3: *(DataStream--) = Pipe_Read_Byte();\r
+                       case 2: *(DataStream--) = Pipe_Read_Byte();\r
+                       case 1: *(DataStream--) = Pipe_Read_Byte();\r
+                               } while (Length >= 8);  \r
+               }\r
+       }\r
+       #endif\r
+\r

        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r
        while (Length)\r
        {\r
                if (!(Pipe_IsReadWriteAllowed()))\r

diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.h b/LUFA/Drivers/USB/LowLevel/Pipe.h
index 30e0fde..cf61eea 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Pipe.h
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.h
@@ -187,13 +187,13 @@
                                /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
                                 *  indicated will operate on the currently selected pipe.\r
                                 *\r
                                /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
                                 *  indicated will operate on the currently selected pipe.\r
                                 *\r

-                                *  \param PipeNumber  Index of the pipe to select\r
+                                *  \param[in] PipeNumber  Index of the pipe to select\r

                                 */\r
                                static inline void Pipe_SelectPipe(uint8_t PipeNumber);\r
                                \r
                                /** Resets the desired pipe, including the pipe banks and flags.\r
                                 *\r
                                 */\r
                                static inline void Pipe_SelectPipe(uint8_t PipeNumber);\r
                                \r
                                /** Resets the desired pipe, including the pipe banks and flags.\r
                                 *\r

-                                *  \param PipeNumber  Index of the pipe to reset\r
+                                *  \param[in] PipeNumber  Index of the pipe to reset\r

                                 */\r
                                static inline void Pipe_ResetPipe(uint8_t PipeNumber);\r
                                \r
                                 */\r
                                static inline void Pipe_ResetPipe(uint8_t PipeNumber);\r
                                \r


@@ -226,7 +226,7 @@
                                 *  control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices\r
                                 *  which have two endpoints of opposite direction sharing the same endpoint address within the device.\r
                                 *\r
                                 *  control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices\r
                                 *  which have two endpoints of opposite direction sharing the same endpoint address within the device.\r
                                 *\r

-                                *  \param Token  New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask\r
+                                *  \param[in] Token  New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask\r

                                 */\r
                                static inline void Pipe_SetPipeToken(uint8_t Token);\r
                                \r
                                 */\r
                                static inline void Pipe_SetPipeToken(uint8_t Token);\r
                                \r


@@ -236,7 +236,7 @@
                                /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
                                 *  accepted by the pipe before it is automatically frozen.\r
                                 *\r
                                /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
                                 *  accepted by the pipe before it is automatically frozen.\r
                                 *\r

-                                *  \param TotalINRequests  Total number of IN requests that the pipe may receive before freezing\r
+                                *  \param[in] TotalINRequests  Total number of IN requests that the pipe may receive before freezing\r

                                 */\r
                                static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);\r
 \r
                                 */\r
                                static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);\r
 \r


@@ -248,7 +248,7 @@
                                \r
                                /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
                                 *\r
                                \r
                                /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
                                 *\r

-                                *  \param Milliseconds  Number of milliseconds between each pipe poll\r
+                                *  \param[in] Milliseconds  Number of milliseconds between each pipe poll\r

                                 */\r
                                static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);\r
                                \r
                                 */\r
                                static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);\r
                                \r


@@ -262,7 +262,7 @@
                                /** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type\r
                                 *  pipes).\r
                                 *\r
                                /** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type\r
                                 *  pipes).\r
                                 *\r

-                                *  \param PipeNumber  Index of the pipe whose interrupt flag should be tested\r
+                                *  \param[in] PipeNumber  Index of the pipe whose interrupt flag should be tested\r

                                 *\r
                                 *  \return Boolean true if the specified pipe has interrupted, false otherwise\r
                                 */\r
                                 *\r
                                 *  \return Boolean true if the specified pipe has interrupted, false otherwise\r
                                 */\r


@@ -516,7 +516,7 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Byte  Next byte to write into the the currently selected pipe's FIFO buffer\r
+                        *  \param[in] Byte  Next byte to write into the the currently selected pipe's FIFO buffer\r

                         */\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte)\r
                         */\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte)\r


@@ -577,7 +577,7 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Word  Next word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word)\r
                         */\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word)\r


@@ -591,7 +591,7 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Word  Next word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word)\r
                         */\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word)\r


@@ -666,7 +666,7 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r
                         */\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r


@@ -680,7 +680,7 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r
                         */\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r


@@ -771,9 +771,9 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Buffer    Pointer to the source data buffer to read from.\r
-                        *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -798,9 +798,9 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Buffer    Pointer to the source data buffer to read from.\r
-                        *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -825,8 +825,8 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Length  Number of bytes to send via the currently selected pipe.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected pipe.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -851,9 +851,9 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Buffer    Pointer to the source data buffer to write to.\r
-                        *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[out] Buffer    Pointer to the source data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe to read from.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r


@@ -878,9 +878,9 @@
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r
                         *\r
                         *  \ingroup Group_PipeRW\r
                         *\r

-                        *  \param Buffer    Pointer to the source data buffer to write to.\r
-                        *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[out] Buffer    Pointer to the source data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe to read from.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r

diff --git a/LUFA/ManPages/FutureChanges.txt b/LUFA/ManPages/FutureChanges.txt
index fd066d0..5163ee6 100644 (file)
--- a/LUFA/ManPages/FutureChanges.txt
+++ b/LUFA/ManPages/FutureChanges.txt
@@ -19,6 +19,7 @@
   *  - Add standardized descriptor names to class driver structures, controlled by USE_NONSTANDARD_DESCRIPTOR_NAMES\r
   *  - Update Host mode Class Driver demo .txt files\r
   *  - Debug mode for pipe/endpoint calls\r
   *  - Add standardized descriptor names to class driver structures, controlled by USE_NONSTANDARD_DESCRIPTOR_NAMES\r
   *  - Update Host mode Class Driver demo .txt files\r
   *  - Debug mode for pipe/endpoint calls\r

+  *  - Test and document new FAST_STREAM_TRANSFERS compile time option\r

   *\r
   *  <b>Targeted for Future Releases:</b>\r
   *  - Remake AVRStudio project files\r
   *\r
   *  <b>Targeted for Future Releases:</b>\r
   *  - Remake AVRStudio project files\r

diff --git a/LUFA/ManPages/LibraryApps.txt b/LUFA/ManPages/LibraryApps.txt
index 3a6fecc..5b25c89 100644 (file)
--- a/LUFA/ManPages/LibraryApps.txt
+++ b/LUFA/ManPages/LibraryApps.txt
@@ -9,6 +9,9 @@
  *  The LUFA library ships with several different host and device demos, located in the /Demos/ subdirectory.\r
  *  If this directory is missing, please re-download the project from the project homepage. Within this directory the demos\r
  *  are seperated by USB mode (Device, Host, OTG) and further seperated by the use or non-use of the library USB Class drivers.\r
  *  The LUFA library ships with several different host and device demos, located in the /Demos/ subdirectory.\r
  *  If this directory is missing, please re-download the project from the project homepage. Within this directory the demos\r
  *  are seperated by USB mode (Device, Host, OTG) and further seperated by the use or non-use of the library USB Class drivers.\r

+ *  With one or two exceptions (e.g. proprietary classes such as RNDIS) all the included demos will work across all OSes without\r
+ *  the need for special drivers. One Windows, some demos require the supplied .INF file to be used as the device driver, which\r
+ *  directs the OS to use its inbuilt class drivers for the device.\r

  *\r
  *  Also included with the library are three fully functional bootloaders, located in the /Bootloaders/ subdirectory.\r
  *  The DFU class bootloader is compatible with Atmel's FLIP software or the open source dfu-programmer project, the\r
  *\r
  *  Also included with the library are three fully functional bootloaders, located in the /Bootloaders/ subdirectory.\r
  *  The DFU class bootloader is compatible with Atmel's FLIP software or the open source dfu-programmer project, the\r

diff --git a/LUFA/ManPages/Licence.txt b/LUFA/ManPages/Licence.txt
index 120e937..36f0267 100644 (file)
--- a/LUFA/ManPages/Licence.txt
+++ b/LUFA/ManPages/Licence.txt
@@ -5,7 +5,7 @@
  */\r
 \r
 /**\r
  */\r
 \r
 /**\r

- *  \page Page_Licence licence\r
+ *  \page Page_Licence Source Code Licence\r

  *\r
  *  The LUFA library is currently released under the MIT licence, included below.\r
  *\r
  *\r
  *  The LUFA library is currently released under the MIT licence, included below.\r
  *\r

diff --git a/LUFA/Scheduler/Scheduler.h b/LUFA/Scheduler/Scheduler.h
index 44e6bb0..51679eb 100644 (file)
--- a/LUFA/Scheduler/Scheduler.h
+++ b/LUFA/Scheduler/Scheduler.h
@@ -196,7 +196,7 @@
                        /** Resets the delay counter value to the current tick count. This should be called to reset the period\r
                         *  for a delay in a task which is dependant on the current tick value.\r
                         *\r
                        /** Resets the delay counter value to the current tick count. This should be called to reset the period\r
                         *  for a delay in a task which is dependant on the current tick value.\r
                         *\r

-                        *  \param DelayCounter  Counter which is storing the starting tick count for a given delay.\r
+                        *  \param[out] DelayCounter  Counter which is storing the starting tick count for a given delay.\r

                         */\r
                        static inline void Scheduler_ResetDelay(SchedulerDelayCounter_t* const DelayCounter)\r
                                                                ATTR_NON_NULL_PTR_ARG(1) ATTR_ALWAYS_INLINE;\r
                         */\r
                        static inline void Scheduler_ResetDelay(SchedulerDelayCounter_t* const DelayCounter)\r
                                                                ATTR_NON_NULL_PTR_ARG(1) ATTR_ALWAYS_INLINE;\r


@@ -211,8 +211,8 @@
                /* Function Prototypes: */\r
                        /** Determines if the given tick delay has elapsed, based on the given .\r
                         *\r
                /* Function Prototypes: */\r
                        /** Determines if the given tick delay has elapsed, based on the given .\r
                         *\r

-                        *  \param Delay         The delay to test for, measured in ticks\r
-                        *  \param DelayCounter  The counter which is storing the starting tick value for the delay\r
+                        *  \param[in] Delay         The delay to test for, measured in ticks\r
+                        *  \param[in] DelayCounter  The counter which is storing the starting tick value for the delay\r

                         *\r
                         *  \return Boolean true if the delay has elapsed, false otherwise\r
                         *\r
                         *\r
                         *  \return Boolean true if the delay has elapsed, false otherwise\r
                         *\r


@@ -233,16 +233,16 @@
                        \r
                        /** Sets the task mode for a given task.\r
                         *\r
                        \r
                        /** Sets the task mode for a given task.\r
                         *\r

-                        *  \param Task        Name of the task whose status is to be changed\r
-                        *  \param TaskStatus  New task status for the task (TASK_RUN or TASK_STOP)\r
+                        *  \param[in] Task        Name of the task whose status is to be changed\r
+                        *  \param[in] TaskStatus  New task status for the task (TASK_RUN or TASK_STOP)\r

                         */\r
                        void Scheduler_SetTaskMode(const TaskPtr_t Task, const bool TaskStatus);\r
                        \r
                        /** Sets the task mode for a given task group ID, allowing for an entire group of tasks to have their\r
                         *  statuses changed at once.\r
                         *\r
                         */\r
                        void Scheduler_SetTaskMode(const TaskPtr_t Task, const bool TaskStatus);\r
                        \r
                        /** Sets the task mode for a given task group ID, allowing for an entire group of tasks to have their\r
                         *  statuses changed at once.\r
                         *\r

-                        *  \param GroupID     Value of the task group ID whose status is to be changed\r
-                        *  \param TaskStatus  New task status for tasks in the specified group (TASK_RUN or TASK_STOP)\r
+                        *  \param[in] GroupID     Value of the task group ID whose status is to be changed\r
+                        *  \param[in] TaskStatus  New task status for tasks in the specified group (TASK_RUN or TASK_STOP)\r

                         */\r
                        void Scheduler_SetGroupTaskMode(const uint8_t GroupID, const bool TaskStatus);\r
 \r
                         */\r
                        void Scheduler_SetGroupTaskMode(const uint8_t GroupID, const bool TaskStatus);\r
 \r

diff --git a/Projects/Magstripe/Lib/CircularBitBuffer.h b/Projects/Magstripe/Lib/CircularBitBuffer.h
index 6f1fa15..ffbdc86 100644 (file)
--- a/Projects/Magstripe/Lib/CircularBitBuffer.h
+++ b/Projects/Magstripe/Lib/CircularBitBuffer.h
@@ -73,20 +73,20 @@
        /* Function Prototypes: */      \r
                /** Initializes or resets a given bit buffer, ready to store new bits.\r
                 *  \r
        /* Function Prototypes: */      \r
                /** Initializes or resets a given bit buffer, ready to store new bits.\r
                 *  \r

-                *  \param Buffer  Bit buffer to initialize\r
+                *  \param[in,out] Buffer  Bit buffer to initialize\r

                 */\r
                void BitBuffer_Init(BitBuffer_t* Buffer) ATTR_NON_NULL_PTR_ARG(1);\r
                \r
                /** Stores a bit into the next location inside a given bit buffer.\r
                 *\r
                 */\r
                void BitBuffer_Init(BitBuffer_t* Buffer) ATTR_NON_NULL_PTR_ARG(1);\r
                \r
                /** Stores a bit into the next location inside a given bit buffer.\r
                 *\r

-                *  \param Buffer  Bit buffer to store a bit into\r
-                *  \param Bit  Bit to store into the buffer\r
+                *  \param[in,out] Buffer  Bit buffer to store a bit into\r
+                *  \param[in] Bit  Bit to store into the buffer\r

                 */\r
                void BitBuffer_StoreNextBit(BitBuffer_t* Buffer, bool Bit) ATTR_NON_NULL_PTR_ARG(1);\r
                \r
                /** Retrieves a bit from the next location inside a given bit buffer.\r
                 *\r
                 */\r
                void BitBuffer_StoreNextBit(BitBuffer_t* Buffer, bool Bit) ATTR_NON_NULL_PTR_ARG(1);\r
                \r
                /** Retrieves a bit from the next location inside a given bit buffer.\r
                 *\r

-                *  \param Buffer  Bit buffer to store a bit into\r
+                *  \param[in,out] Buffer  Bit buffer to store a bit into\r

                 *\r
                 *  \return Next bit from the buffer\r
                 */\r
                 *\r
                 *  \return Next bit from the buffer\r
                 */\r

diff --git a/Projects/Magstripe/Magstripe.c b/Projects/Magstripe/Magstripe.c
index 1963973..ec2313c 100644 (file)
--- a/Projects/Magstripe/Magstripe.c
+++ b/Projects/Magstripe/Magstripe.c
@@ -160,9 +160,9 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 \r
 /** HID Class driver callback function for the creation of a HID report for the host.\r
  *\r
 \r
 /** HID Class driver callback function for the creation of a HID report for the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID interface structure for the HID interface being referenced\r
- *  \param ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
- *  \param ReportData  Pointer to the preallocated report buffer where the created report should be stored\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID interface structure for the HID interface being referenced\r
+ *  \param[in,out] ReportID      Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID\r
+ *  \param[out] ReportData       Pointer to the preallocated report buffer where the created report should be stored\r

  *\r
  *  \return Number of bytes in the created report\r
  */\r
  *\r
  *  \return Number of bytes in the created report\r
  */\r


@@ -209,10 +209,10 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInte
 \r
 /** HID Class driver callback function for the processing of a received HID report from the host.\r
  *\r
 \r
 /** HID Class driver callback function for the processing of a received HID report from the host.\r
  *\r

- *  \param HIDInterfaceInfo  Pointer to the HID interface structure for the HID interface being referenced\r
- *  \param ReportID  Report ID of the received report from the host\r
- *  \param ReportData  Pointer to the report buffer where the received report is stored\r
- *  \param ReportSize  Size in bytes of the report received from the host\r
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID interface structure for the HID interface being referenced\r
+ *  \param[in] ReportID          Report ID of the received report from the host\r
+ *  \param[in] ReportData        Pointer to the report buffer where the received report is stored\r
+ *  \param[in] ReportSize        Size in bytes of the report received from the host\r

  */\r
 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
                                           void* ReportData, uint16_t ReportSize)\r
  */\r
 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t ReportID,\r
                                           void* ReportData, uint16_t ReportSize)\r

diff --git a/Projects/MissileLauncher/MissileLauncher.c b/Projects/MissileLauncher/MissileLauncher.c
index bd542ee..192ca33 100644 (file)
--- a/Projects/MissileLauncher/MissileLauncher.c
+++ b/Projects/MissileLauncher/MissileLauncher.c
@@ -154,8 +154,8 @@ void Read_Joystick_Status(void)
 \r
 /** Lower level send routine, copies report into a larger buffer and sends.\r
  *\r
 \r
 /** Lower level send routine, copies report into a larger buffer and sends.\r
  *\r

- *  \param Report  Report data to send.\r
- *  \param ReportSize  Report length in bytes.\r
+ *  \param[in] Report  Report data to send.\r
+ *  \param[in] ReportSize  Report length in bytes.\r

  */\r
 void Send_Command_Report(uint8_t *Report, uint16_t ReportSize)\r
 {\r
  */\r
 void Send_Command_Report(uint8_t *Report, uint16_t ReportSize)\r
 {\r


@@ -163,9 +163,9 @@ void Send_Command_Report(uint8_t *Report, uint16_t ReportSize)
        WriteNextReport(CmdBuffer, ReportSize);\r
 }\r
 \r
        WriteNextReport(CmdBuffer, ReportSize);\r
 }\r
 \r

-/** Send one of the CMD_* command constants listed above.\r
+/** Sends one of the CMD_* command constants to the attached device.\r

  *\r
  *\r

- *  \param Command  One of the command constants.\r
+ *  \param[in] Command  One of the command constants.\r

  */\r
 void Send_Command(uint8_t* Command)\r
 {\r
  */\r
 void Send_Command(uint8_t* Command)\r
 {\r


@@ -248,8 +248,8 @@ void DiscardNextReport(void)
 \r
 /** Writes a report to the attached device.\r
  *\r
 \r
 /** Writes a report to the attached device.\r
  *\r

- *  \param ReportOUTData  Buffer containing the report to send to the device\r
- *  \param ReportLength  Length of the report to send\r
+ *  \param[in] ReportOUTData  Buffer containing the report to send to the device\r
+ *  \param[in] ReportLength  Length of the report to send\r

  */\r
 void WriteNextReport(uint8_t* ReportOUTData, uint16_t ReportLength)\r
 {\r
  */\r
 void WriteNextReport(uint8_t* ReportOUTData, uint16_t ReportLength)\r
 {\r