Documentation enhancements to improve documentation cross-references.

diff --git a/Demos/Device/DualCDC/DualCDC.c b/Demos/Device/DualCDC/DualCDC.c
index 4185a76..5d2dd5f 100644 (file)
--- a/Demos/Device/DualCDC/DualCDC.c
+++ b/Demos/Device/DualCDC/DualCDC.c
@@ -207,7 +207,7 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                Endpoint_ClearSETUP();\r
 \r
                                /* Write the line coding data to the control endpoint */\r
                                Endpoint_ClearSETUP();\r
 \r
                                /* Write the line coding data to the control endpoint */\r

-                               Endpoint_Write_Control_Stream_LE(LineCodingData, sizeof(CDC_Line_Coding_t));\r
+                               Endpoint_Write_Control_Stream_LE(LineCodingData, sizeof(CDC_Line_Coding_t), Endpoint_MemSpaceCallback_RAM);\r

                                \r
                                /* Finalize the stream transfer to send the last packet or clear the host abort */\r
                                Endpoint_ClearOUT();\r
                                \r
                                /* Finalize the stream transfer to send the last packet or clear the host abort */\r
                                Endpoint_ClearOUT();\r


@@ -304,7 +304,7 @@ TASK(CDC1_Task)
                Endpoint_SelectEndpoint(CDC1_TX_EPNUM);\r
 \r
                /* Write the String to the Endpoint */\r
                Endpoint_SelectEndpoint(CDC1_TX_EPNUM);\r
 \r
                /* Write the String to the Endpoint */\r

-               Endpoint_Write_Stream_LE(ReportString, strlen(ReportString));\r
+               Endpoint_Write_Stream_LE(ReportString, strlen(ReportString), Endpoint_MemSpaceCallback_RAM);\r

                \r
                /* Finalize the stream transfer to send the last packet */\r
                Endpoint_ClearIN();\r
                \r
                /* Finalize the stream transfer to send the last packet */\r
                Endpoint_ClearIN();\r


@@ -351,7 +351,7 @@ TASK(CDC2_Task)
                Endpoint_SelectEndpoint(CDC2_TX_EPNUM);\r
                \r
                /* Write the received data to the endpoint */\r
                Endpoint_SelectEndpoint(CDC2_TX_EPNUM);\r
                \r
                /* Write the received data to the endpoint */\r

-               Endpoint_Write_Stream_LE(&Buffer, DataLength);\r
+               Endpoint_Write_Stream_LE(&Buffer, DataLength, Endpoint_MemSpaceCallback_RAM);\r

 \r
                /* Finalize the stream transfer to send the last packet */\r
                Endpoint_ClearIN();\r
 \r
                /* Finalize the stream transfer to send the last packet */\r
                Endpoint_ClearIN();\r

diff --git a/LUFA/Drivers/Board/Dataflash.h b/LUFA/Drivers/Board/Dataflash.h
index 01ee889..2030093 100644 (file)
--- a/LUFA/Drivers/Board/Dataflash.h
+++ b/LUFA/Drivers/Board/Dataflash.h
@@ -79,7 +79,7 @@
                        #if defined(__DOXYGEN__)\r
                                /** Determines the currently selected dataflash chip.\r
                                 *\r
                        #if defined(__DOXYGEN__)\r
                                /** Determines the currently selected dataflash chip.\r
                                 *\r

-                                *  \return Mask of the currently selected Dataflash chip, either DATAFLASH_NO_CHIP if no chip is selected\r
+                                *  \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected\r

                                 *  or a DATAFLASH_CHIPn mask (where n is the chip number).\r
                                 */\r
                                static inline uint8_t Dataflash_GetSelectedChip(void);\r
                                 *  or a DATAFLASH_CHIPn mask (where n is the chip number).\r
                                 */\r
                                static inline uint8_t Dataflash_GetSelectedChip(void);\r

diff --git a/LUFA/Drivers/Board/Temperature.h b/LUFA/Drivers/Board/Temperature.h
index 56e5790..30c311f 100644 (file)
--- a/LUFA/Drivers/Board/Temperature.h
+++ b/LUFA/Drivers/Board/Temperature.h
@@ -76,10 +76,10 @@
                        /** ADC channel number for the temperature sensor. */\r
                        #define TEMP_ADC_CHANNEL   0\r
                        \r
                        /** ADC channel number for the temperature sensor. */\r
                        #define TEMP_ADC_CHANNEL   0\r
                        \r

-                       /** Minimum returnable temperature from the Temperature_GetTemperature() function. */\r
+                       /** Minimum returnable temperature from the \ref Temperature_GetTemperature() function. */\r

                        #define TEMP_MIN_TEMP      TEMP_TABLE_OFFSET\r
 \r
                        #define TEMP_MIN_TEMP      TEMP_TABLE_OFFSET\r
 \r

-                       /** Maximum returnable temperature from the Temperature_GetTemperature() function. */\r
+                       /** Maximum returnable temperature from the \ref Temperature_GetTemperature() function. */\r

                        #define TEMP_MAX_TEMP      ((TEMP_TABLE_SIZE - 1) + TEMP_TABLE_OFFSET)\r
                \r
                /* Pseudo-Function Macros: */\r
                        #define TEMP_MAX_TEMP      ((TEMP_TABLE_SIZE - 1) + TEMP_TABLE_OFFSET)\r
                \r
                /* Pseudo-Function Macros: */\r


@@ -97,7 +97,7 @@
 \r
                /* Function Prototypes: */\r
                        /** Performs a complete ADC on the temperature sensor channel, and converts the result into a\r
 \r
                /* Function Prototypes: */\r
                        /** Performs a complete ADC on the temperature sensor channel, and converts the result into a\r

-                        *  valid temperature between TEMP_MIN_TEMP and TEMP_MAX_TEMP in degrees Celsius.\r
+                        *  valid temperature between \ref TEMP_MIN_TEMP and \ref TEMP_MAX_TEMP in degrees Celsius.\r

                         *\r
                         *  \return Signed temperature in degrees Celsius\r
                         */\r
                         *\r
                         *  \return Signed temperature in degrees Celsius\r
                         */\r

diff --git a/LUFA/Drivers/Misc/TerminalCodes.h b/LUFA/Drivers/Misc/TerminalCodes.h
index b81a8d6..11dcc03 100644 (file)
--- a/LUFA/Drivers/Misc/TerminalCodes.h
+++ b/LUFA/Drivers/Misc/TerminalCodes.h
@@ -175,10 +175,10 @@
                        /** Moves the cursor to the left the given number of columns. */\r
                        #define ESC_CURSOR_BACKWARD(C)   ANSI_ESCAPE_SEQUENCE(#C "D")\r
 \r
                        /** Moves the cursor to the left the given number of columns. */\r
                        #define ESC_CURSOR_BACKWARD(C)   ANSI_ESCAPE_SEQUENCE(#C "D")\r
 \r

-                       /** Saves the current cursor position so that it may be restored with ESC_CURSOR_POS_RESTORE. */\r
+                       /** Saves the current cursor position so that it may be restored with \ref ESC_CURSOR_POS_RESTORE. */\r

                        #define ESC_CURSOR_POS_SAVE      ANSI_ESCAPE_SEQUENCE("s")\r
 \r
                        #define ESC_CURSOR_POS_SAVE      ANSI_ESCAPE_SEQUENCE("s")\r
 \r

-                       /** Restores the cursor position to the last position saved with ESC_CURSOR_POS_SAVE. */\r
+                       /** Restores the cursor position to the last position saved with \ref ESC_CURSOR_POS_SAVE. */\r

                        #define ESC_CURSOR_POS_RESTORE   ANSI_ESCAPE_SEQUENCE("u")\r
                        \r
                        /** Erases the entire display, returning the cursor to the top left. */\r
                        #define ESC_CURSOR_POS_RESTORE   ANSI_ESCAPE_SEQUENCE("u")\r
                        \r
                        /** Erases the entire display, returning the cursor to the top left. */\r

diff --git a/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h b/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
index 494c1e4..358629c 100644 (file)
--- a/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
+++ b/LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h
@@ -120,7 +120,7 @@
                                static inline void ADC_Init(uint8_t Mode);\r
                                \r
                                /** Turns off the ADC. If this is called, any further ADC operations will require a call to\r
                                static inline void ADC_Init(uint8_t Mode);\r
                                \r
                                /** Turns off the ADC. If this is called, any further ADC operations will require a call to\r

-                                *  ADC_Init() before the ADC can be used again.\r
+                                *  \ref ADC_Init() before the ADC can be used again.\r

                                 */\r
                                static inline void ADC_Off(void);\r
                                \r
                                 */\r
                                static inline void ADC_Off(void);\r
                                \r


@@ -133,7 +133,7 @@
                                /** Indicates if the current ADC conversion is completed, or still in progress.\r
                                 *\r
                                 *  \return Boolean false if the reading is still taking place, or true if the conversion is\r
                                /** Indicates if the current ADC conversion is completed, or still in progress.\r
                                 *\r
                                 *  \return Boolean false if the reading is still taking place, or true if the conversion is\r

-                                *          complete and ready to be read out with ADC_GetResult()\r
+                                *          complete and ready to be read out with \ref ADC_GetResult()\r

                                 */\r
                                static inline bool ADC_IsReadingComplete(void);\r
                                \r
                                 */\r
                                static inline bool ADC_IsReadingComplete(void);\r
                                \r


@@ -168,8 +168,8 @@
                        }\r
                        \r
                        /** Starts the reading of the given channel, but does not wait until the conversion has completed.\r
                        }\r
                        \r
                        /** Starts the reading of the given channel, but does not wait until the conversion has completed.\r

-                        *  Once executed, the conversion status can be determined via the ADC_IsReadingComplete() macro and\r
-                        *  the result read via the ADC_GetResult() macro.\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
                         */\r
                         *\r
                         *  \param MUXMask  Mask comprising of an ADC channel number, reference mask and adjustment mask\r
                         */\r

diff --git a/LUFA/Drivers/USB/Class/ConfigDescriptor.h b/LUFA/Drivers/USB/Class/ConfigDescriptor.h
index 362a43e..da38492 100644 (file)
--- a/LUFA/Drivers/USB/Class/ConfigDescriptor.h
+++ b/LUFA/Drivers/USB/Class/ConfigDescriptor.h
@@ -118,7 +118,7 @@
                         *  for certain descriptors matching unique criteria.\r
                         *\r
                         *  Comparator routines are passed in a single pointer named CurrentDescriptor, and should return a value\r
                         *  for certain descriptors matching unique criteria.\r
                         *\r
                         *  Comparator routines are passed in a single pointer named CurrentDescriptor, and should return a value\r

-                        *  of a member of the DSearch_Return_ErrorCodes_t enum.\r
+                        *  of a member of the \ref DSearch_Return_ErrorCodes_t enum.\r

                         */\r
                        #define DESCRIPTOR_COMPARATOR(name)           uint8_t DCOMP_##name (void* const CurrentDescriptor)\r
 \r
                         */\r
                        #define DESCRIPTOR_COMPARATOR(name)           uint8_t DCOMP_##name (void* const CurrentDescriptor)\r
 \r


@@ -137,7 +137,7 @@
                                 *  \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
                                 *\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
                                 *\r

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

                                 *\r
                                 *  Usage Example:\r
                                 *  \code\r
                                 *\r
                                 *  Usage Example:\r
                                 *  \code\r


@@ -166,7 +166,7 @@
                        #endif\r
                        \r
                /* Enums: */\r
                        #endif\r
                        \r
                /* Enums: */\r

-                       /** Enum for return values of a descriptor comparator made with DESCRIPTOR_COMPARATOR. */\r
+                       /** Enum for return values of a descriptor comparator made with \ref DESCRIPTOR_COMPARATOR. */\r

                        enum DSearch_Return_ErrorCodes_t\r
                        {\r
                                DESCRIPTOR_SEARCH_Found                = 0, /**< Current descriptor matches comparator criteria. */\r
                        enum DSearch_Return_ErrorCodes_t\r
                        {\r
                                DESCRIPTOR_SEARCH_Found                = 0, /**< Current descriptor matches comparator criteria. */\r


@@ -174,7 +174,7 @@
                                DESCRIPTOR_SEARCH_NotFound             = 2, /**< Current descriptor does not match comparator criteria. */\r
                        };\r
 \r
                                DESCRIPTOR_SEARCH_NotFound             = 2, /**< Current descriptor does not match comparator criteria. */\r
                        };\r
 \r

-                       /** Enum for return values of USB_GetNextDescriptorComp(). */\r
+                       /** Enum for return values of \ref USB_GetNextDescriptorComp(). */\r

                        enum DSearch_Comp_Return_ErrorCodes_t\r
                        {\r
                                DESCRIPTOR_SEARCH_COMP_Found           = 0, /**< Configuration descriptor now points to descriptor which matches\r
                        enum DSearch_Comp_Return_ErrorCodes_t\r
                        {\r
                                DESCRIPTOR_SEARCH_COMP_Found           = 0, /**< Configuration descriptor now points to descriptor which matches\r

diff --git a/LUFA/Drivers/USB/Class/HIDParser.h b/LUFA/Drivers/USB/Class/HIDParser.h
index f02f1fd..49e57c2 100644 (file)
--- a/LUFA/Drivers/USB/Class/HIDParser.h
+++ b/LUFA/Drivers/USB/Class/HIDParser.h
@@ -114,7 +114,7 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Enums: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Enums: */\r

-                       /** Enum for indicating what type of report item an entry in a HID_ReportInfo_t ReportItem array is */\r
+                       /** Enum for indicating what type of report item an entry in a \ref HID_ReportInfo_t ReportItem array is */\r

                        enum HID_ReportItemTypes_t\r
                        {\r
                                REPORT_ITEM_TYPE_In                   = 0, /**< Indicates that the item is an IN report type. */\r
                        enum HID_ReportItemTypes_t\r
                        {\r
                                REPORT_ITEM_TYPE_In                   = 0, /**< Indicates that the item is an IN report type. */\r


@@ -122,16 +122,16 @@
                                REPORT_ITEM_TYPE_Feature              = 2, /**< Indicates that the item is a FEATURE report type. */\r
                        };\r
                        \r
                                REPORT_ITEM_TYPE_Feature              = 2, /**< Indicates that the item is a FEATURE report type. */\r
                        };\r
                        \r

-                       /** Enum for the possible error codes in the return value of the ProcessHIDReport() function */\r
+                       /** Enum for the possible error codes in the return value of the \ref USB_ProcessHIDReport() function */\r

                        enum HID_Parse_ErrorCodes_t\r
                        {\r
                                HID_PARSE_Successful                  = 0, /**< Successful parse of the HID report descriptor, no error. */\r
                        enum HID_Parse_ErrorCodes_t\r
                        {\r
                                HID_PARSE_Successful                  = 0, /**< Successful parse of the HID report descriptor, no error. */\r

-                               HID_PARSE_HIDStackOverflow            = 1, /**< More than HID_STATETABLE_STACK_DEPTH nested PUSHes in the report. */ \r
+                               HID_PARSE_HIDStackOverflow            = 1, /**< More than \ref HID_STATETABLE_STACK_DEPTH nested PUSHes in the report. */ \r

                                HID_PARSE_HIDStackUnderflow           = 2, /**< A POP was found when the state table stack was empty. */\r
                                HID_PARSE_HIDStackUnderflow           = 2, /**< A POP was found when the state table stack was empty. */\r

-                               HID_PARSE_InsufficientReportItems     = 3, /**< More than HID_MAX_REPORTITEMS report items in the report. */\r
+                               HID_PARSE_InsufficientReportItems     = 3, /**< More than \ref HID_MAX_REPORTITEMS report items in the report. */\r

                                HID_PARSE_UnexpectedEndCollection     = 4, /**< END COLLECTION found without matching COLLECTION item. */\r
                                HID_PARSE_UnexpectedEndCollection     = 4, /**< END COLLECTION found without matching COLLECTION item. */\r

-                               HID_PARSE_InsufficientCollectionPaths = 5, /**< More than HID_MAX_COLLECTIONS collections in the report. */\r
-                               HID_PARSE_UsageStackOverflow          = 6, /**< More than HID_USAGE_STACK_DEPTH usages listed in a row. */\r
+                               HID_PARSE_InsufficientCollectionPaths = 5, /**< More than \ref HID_MAX_COLLECTIONS collections in the report. */\r
+                               HID_PARSE_UsageStackOverflow          = 6, /**< More than \ref HID_USAGE_STACK_DEPTH usages listed in a row. */\r

                        };\r
                \r
                /* Type Defines: */             \r
                        };\r
                \r
                /* Type Defines: */             \r


@@ -162,7 +162,7 @@
                         */\r
                        typedef struct CollectionPath\r
                        {\r
                         */\r
                        typedef struct CollectionPath\r
                        {\r

-                               uint8_t                      Type;   /**< Collection type (for example "Generic Desktop"). */\r
+                               uint8_t                      Type;   /**< Collection type (e.g. "Generic Desktop"). */\r

                                HID_Usage_t                  Usage;  /**< Collection usage. */\r
                                struct CollectionPath*       Parent; /**< Reference to parent collection, or NULL if root collection. */\r
                        } HID_CollectionPath_t;\r
                                HID_Usage_t                  Usage;  /**< Collection usage. */\r
                                struct CollectionPath*       Parent; /**< Reference to parent collection, or NULL if root collection. */\r
                        } HID_CollectionPath_t;\r


@@ -207,22 +207,22 @@
                        \r
                /* Function Prototypes: */\r
                        /** Function to process a given HID report returned from an attached device, and store it into a given\r
                        \r
                /* Function Prototypes: */\r
                        /** Function to process a given HID report returned from an attached device, and store it into a given\r

-                        *  HID_ReportInfo_t structure.\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
                         *\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 HID_ReportInfo_t instance for the parser output\r
+                        *  \param ParserData  Pointer to a \ref HID_ReportInfo_t instance for the parser output\r

                         *\r
                         *\r

-                        *  \return A value in the HID_Parse_ErrorCodes_t enum\r
+                        *  \return A value in the \ref HID_Parse_ErrorCodes_t enum\r

                         */\r
                        uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)\r
                                                     ATTR_NON_NULL_PTR_ARG(1, 3);\r
 \r
                        /** Extracts the given report item's value out of the given HID report and places it into the Value\r
                         */\r
                        uint8_t USB_ProcessHIDReport(const uint8_t* ReportData, uint16_t ReportSize, HID_ReportInfo_t* const ParserData)\r
                                                     ATTR_NON_NULL_PTR_ARG(1, 3);\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 HID_ReportItem_t structure.\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
                         *\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 HID_ReportInfo_t ReportItem array\r
+                        *  \param 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


@@ -230,14 +230,14 @@
                                                      ATTR_NON_NULL_PTR_ARG(1, 2);\r
 \r
                        /** Retrieves the given report item's value out of the Value member of the report item's\r
                                                      ATTR_NON_NULL_PTR_ARG(1, 2);\r
 \r
                        /** Retrieves the given report item's value out of the Value member of the report item's\r

-                        *  HID_ReportItem_t structure and places it into the correct position in the HID report\r
+                        *  \ref HID_ReportItem_t structure and places it into the correct position in the HID report\r

                         *  buffer. The report buffer is assumed to have the appropriate bits cleared before calling\r
                         *  this function (i.e., the buffer should be explicitly cleared before report values are added).\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
                         *  buffer. The report buffer is assumed to have the appropriate bits cleared before calling\r
                         *  this function (i.e., the buffer should be explicitly cleared before report values are added).\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 HID_ReportInfo_t ReportItem array\r
+                        *  \param 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/Events.h b/LUFA/Drivers/USB/HighLevel/Events.h
index 73a804c..317495c 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/Events.h
+++ b/LUFA/Drivers/USB/HighLevel/Events.h
@@ -36,7 +36,7 @@
  *  multiple places in the user or library code, which may or may not be inside an ISR, thus each handler\r
  *  should be written to be as small and fast as possible to prevent possible problems.\r
  *\r
  *  multiple places in the user or library code, which may or may not be inside an ISR, thus each handler\r
  *  should be written to be as small and fast as possible to prevent possible problems.\r
  *\r

- *  Events can be hooked by the user application using the EVENT_HANDLER() and HANDLES_EVENT() macros. If an\r
+ *  Events can be hooked by the user application using the \ref EVENT_HANDLER() and \ref HANDLES_EVENT() macros. If an\r

  *  event with no associated handler is fired within the library, it by default fires an internal empty stub\r
  *  function. This is achieved through the use of the GCC compiler's "alias" attribute.\r
  *\r
  *  event with no associated handler is fired within the library, it by default fires an internal empty stub\r
  *  function. This is achieved through the use of the GCC compiler's "alias" attribute.\r
  *\r


@@ -82,7 +82,7 @@
 \r
                        /** Indicates that a given module can raise a given event. This is the equivalent of putting the\r
                         *  event function's prototype into the module, but in a cleaner way. Each event which may be\r
 \r
                        /** Indicates that a given module can raise a given event. This is the equivalent of putting the\r
                         *  event function's prototype into the module, but in a cleaner way. Each event which may be\r

-                        *  fired via the RAISE_EVENT macro in the module should have an accompanying RAISES_EVENT\r
+                        *  fired via the \ref RAISE_EVENT macro in the module should have an accompanying \ref RAISES_EVENT\r

                         *  prototype in the module's header file.\r
                         *\r
                         *  Usage Examples:\r
                         *  prototype in the module's header file.\r
                         *\r
                         *  Usage Examples:\r


@@ -122,7 +122,7 @@
                        \r
                        /** Indicates that a given module handles an event. This is the equivalent of putting the\r
                         *  event function's prototype into the module, but in a cleaner way. Each event which may be\r
                        \r
                        /** Indicates that a given module handles an event. This is the equivalent of putting the\r
                         *  event function's prototype into the module, but in a cleaner way. Each event which may be\r

-                        *  handled via the EVENT_HANDLER macro in the module should have an accompanying HANDLES_EVENT\r
+                        *  handled via the \ref EVENT_HANDLER macro in the module should have an accompanying \ref HANDLES_EVENT\r

                         *  prototype in the module's header file.\r
                         *\r
                         *  Usage Examples:\r
                         *  prototype in the module's header file.\r
                         *\r
                         *  Usage Examples:\r


@@ -178,7 +178,7 @@
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r

-                        *        and disconnection events may be manually fired by RAISE_EVENT(), and the USB_IsConnected global changed manually.\r
+                        *        and disconnection events may be manually fired by \ref RAISE_EVENT(), and the \ref USB_IsConnected global changed manually.\r

                         *\r
                         *  \see USBTask.h for more information on the USB management task and reducing CPU usage.\r
                         */\r
                         *\r
                         *  \see USBTask.h for more information on the USB management task and reducing CPU usage.\r
                         */\r


@@ -196,7 +196,7 @@
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r

-                        *        and disconnection events may be manually fired by RAISE_EVENT(), and the USB_IsConnected global changed manually.\r
+                        *        and disconnection events may be manually fired by \ref RAISE_EVENT(), and the \ref USB_IsConnected global changed manually.\r

                         *\r
                         *  \see USBTask.h for more information on the USB management task and reducing CPU usage.\r
                         */\r
                         *\r
                         *  \see USBTask.h for more information on the USB management task and reducing CPU usage.\r
                         */\r


@@ -205,7 +205,7 @@
                        /** Event for USB device power on failure. This event fires when the USB interface fails to\r
                         *  initialize correctly due to a hardware or software fault.\r
                         *\r
                        /** Event for USB device power on failure. This event fires when the USB interface fails to\r
                         *  initialize correctly due to a hardware or software fault.\r
                         *\r

-                        *  \param ErrorCode  Error code indicating the failure reason, a value in USB_PowerOnErrorCodes_t\r
+                        *  \param ErrorCode  Error code indicating the failure reason, a value in \ref USB_PowerOnErrorCodes_t\r

                         *                    located in LowLevel.h.\r
                         */\r
                        void USB_PowerOnFail(const uint8_t ErrorCode);\r
                         *                    located in LowLevel.h.\r
                         */\r
                        void USB_PowerOnFail(const uint8_t ErrorCode);\r


@@ -224,7 +224,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 USB_Host_ErrorCodes_t\r
+                        *  \param ErrorCode  Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t\r

                         *                    located in Host.h.\r
                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r
                         *                    located in Host.h.\r
                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r


@@ -236,7 +236,7 @@
                        \r
                        /** Event for USB device attachment. This event fires when a the USB interface is in host mode, and\r
                         *  a USB device has been connected to the USB interface. This is interrupt driven, thus fires before\r
                        \r
                        /** Event for USB device attachment. This event fires when a the USB interface is in host mode, and\r
                         *  a USB device has been connected to the USB interface. This is interrupt driven, thus fires before\r

-                        *  the standard USB_DeviceConnect event and so can be used to programmatically start the USB management\r
+                        *  the standard \ref USB_Connect event and so can be used to programmatically start the USB management\r

                         *  task to reduce CPU consumption.\r
                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r
                         *  task to reduce CPU consumption.\r
                         *\r
                         *  \note This event only exists on USB AVR models which supports host mode.\r


@@ -291,19 +291,13 @@
                         *  issued to the device which must be handled appropriately. Due to the strict timing requirements\r
                         *  on control transfers, interrupts are disabled during control request processing.\r
                         *\r
                         *  issued to the device which must be handled appropriately. Due to the strict timing requirements\r
                         *  on control transfers, interrupts are disabled during control request processing.\r
                         *\r

-                        *  \param bRequest       Request value, indicating what command the host has issued.\r
-                        *  \param bmRequestType  Mask indicating the request data direction (if any), type and recipient.\r
-                        *\r

                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r
                         *  \note Requests should be handled in the same manner as described in the USB 2.0 Specification,\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r
                         *  \note Requests should be handled in the same manner as described in the USB 2.0 Specification,\r

-                        *        or appropriate class' specification. In all instances, the library has already read the\r
-                        *        request bmRequestType and bRequest values out (into the Request and RequestType parameters\r
-                        *        respectively) so that it can correctly determine if it is able to handle the request\r
-                        *        internally, or hand off the request to the user application via this event. Other request\r
-                        *        parameters (wValue, wIndex, wLength, and Data) remain in the control endpoint bank until\r
-                        *        read out by the user application for processing.\r
+                        *        or appropriate class specification. In all instances, the library has already read the\r
+                        *        request SETUP parameters into the \ref USB_ControlRequest structure which should then be used\r
+                        *        by the application to determine how to handle the issued request.\r

                         */\r
                        void USB_UnhandledControlPacket(void);\r
 \r
                         */\r
                        void USB_UnhandledControlPacket(void);\r
 \r


@@ -311,7 +305,7 @@
                         *  selected configuration number while in device mode. This event should be hooked in device\r
                         *  applications to create the endpoints and configure the device for the selected configuration.\r
                         *\r
                         *  selected configuration number while in device mode. This event should be hooked in device\r
                         *  applications to create the endpoints and configure the device for the selected configuration.\r
                         *\r

-                        *  This event fires after the value of USB_ConfigurationNumber has been changed.\r
+                        *  This event fires after the value of \ref USB_ConfigurationNumber has been changed.\r

                         *\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r


@@ -325,7 +319,7 @@
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r

-                        *  \see USB_WakeUp() event for accompanying Wake Up event.\r
+                        *  \see \ref USB_WakeUp() event for accompanying Wake Up event.\r

                         */\r
                        void USB_Suspend(void);\r
 \r
                         */\r
                        void USB_Suspend(void);\r
 \r


@@ -337,7 +331,7 @@
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r

-                        *  \see USB_Suspend() event for accompanying Suspend event.\r
+                        *  \see \ref USB_Suspend() event for accompanying Suspend event.\r

                         */\r
                        void USB_WakeUp(void);\r
 \r
                         */\r
                        void USB_WakeUp(void);\r
 \r


@@ -356,7 +350,7 @@
                         *  and an error occurs which prevents it from operating normally.\r
                         *\r
                         *  \param ErrorCode  Error code indicating the source of the error. One of the values in the\r
                         *  and an error occurs which prevents it from operating normally.\r
                         *\r
                         *  \param ErrorCode  Error code indicating the source of the error. One of the values in the\r

-                        *                    USB_Device_ErrorCodes_t enum located in Device.h.\r
+                        *                    \ref USB_Device_ErrorCodes_t enum located in Device.h.\r

                         *\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r
                         *\r
                         *  \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see\r
                         *        LowLevel.h documentation).\r

diff --git a/LUFA/Drivers/USB/HighLevel/StdDescriptors.h b/LUFA/Drivers/USB/HighLevel/StdDescriptors.h
index 431080b..caa0fb0 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/StdDescriptors.h
+++ b/LUFA/Drivers/USB/HighLevel/StdDescriptors.h
@@ -90,85 +90,85 @@
                        #define VERSION_BCD(x)                    ((((VERSION_TENS(x) << 4) | VERSION_ONES(x)) << 8) | \\r
                                                                  ((VERSION_TENTHS(x) << 4) | VERSION_HUNDREDTHS(x)))\r
 \r
                        #define VERSION_BCD(x)                    ((((VERSION_TENS(x) << 4) | VERSION_ONES(x)) << 8) | \\r
                                                                  ((VERSION_TENTHS(x) << 4) | VERSION_HUNDREDTHS(x)))\r
 \r

-                       /** String language ID for the English language. Should be used in USB_Descriptor_Language_t descriptors\r
+                       /** String language ID for the English language. Should be used in \ref USB_Descriptor_String_t descriptors\r

                         *  to indicate that the English language is supported by the device in its string descriptors.\r
                         */\r
                        #define LANGUAGE_ID_ENG                   0x0409\r
 \r
                         *  to indicate that the English language is supported by the device in its string descriptors.\r
                         */\r
                        #define LANGUAGE_ID_ENG                   0x0409\r
 \r

-                       /** Can be masked with an endpoint address for a USB_Descriptor_Endpoint_t endpoint descriptor's\r
+                       /** Can be masked with an endpoint address for a \ref USB_Descriptor_Endpoint_t endpoint descriptor's\r

                         *  EndpointAddress value to indicate to the host that the endpoint is of the IN direction (i.e, from\r
                         *  device to host).\r
                         */\r
                        #define ENDPOINT_DESCRIPTOR_DIR_IN        0x80\r
 \r
                         *  EndpointAddress value to indicate to the host that the endpoint is of the IN direction (i.e, from\r
                         *  device to host).\r
                         */\r
                        #define ENDPOINT_DESCRIPTOR_DIR_IN        0x80\r
 \r

-                       /** Can be masked with an endpoint address for a USB_Descriptor_Endpoint_t endpoint descriptor's\r
+                       /** Can be masked with an endpoint address for a \ref USB_Descriptor_Endpoint_t endpoint descriptor's\r

                         *  EndpointAddress value to indicate to the host that the endpoint is of the OUT direction (i.e, from\r
                         *  host to device).\r
                         */\r
                        #define ENDPOINT_DESCRIPTOR_DIR_OUT       0x00          \r
 \r
                         *  EndpointAddress value to indicate to the host that the endpoint is of the OUT direction (i.e, from\r
                         *  host to device).\r
                         */\r
                        #define ENDPOINT_DESCRIPTOR_DIR_OUT       0x00          \r
 \r

-                       /** Can be masked with other configuration descriptor attributes for a USB_Descriptor_Configuration_Header_t\r
+                       /** Can be masked with other configuration descriptor attributes for a \ref USB_Descriptor_Configuration_Header_t\r

                         *  descriptor's ConfigAttributes value to indicate that the specified configuration can draw its power\r
                         *  from the host's VBUS line.\r
                         */\r
                        #define USB_CONFIG_ATTR_BUSPOWERED        0x80\r
 \r
                         *  descriptor's ConfigAttributes value to indicate that the specified configuration can draw its power\r
                         *  from the host's VBUS line.\r
                         */\r
                        #define USB_CONFIG_ATTR_BUSPOWERED        0x80\r
 \r

-                       /** Can be masked with other configuration descriptor attributes for a USB_Descriptor_Configuration_Header_t\r
+                       /** Can be masked with other configuration descriptor attributes for a \ref USB_Descriptor_Configuration_Header_t\r

                         *  descriptor's ConfigAttributes value to indicate that the specified configuration can draw its power\r
                         *  from the device's own power source.\r
                         */\r
                        #define USB_CONFIG_ATTR_SELFPOWERED       0xC0\r
 \r
                         *  descriptor's ConfigAttributes value to indicate that the specified configuration can draw its power\r
                         *  from the device's own power source.\r
                         */\r
                        #define USB_CONFIG_ATTR_SELFPOWERED       0xC0\r
 \r

-                       /** Can be masked with other configuration descriptor attributes for a USB_Descriptor_Configuration_Header_t\r
+                       /** Can be masked with other configuration descriptor attributes for a \ref USB_Descriptor_Configuration_Header_t\r

                         *  descriptor's ConfigAttributes value to indicate that the specified configuration supports the\r
                         *  remote wakeup feature of the USB standard, allowing a suspended USB device to wake up the host upon\r
                         *  request.\r
                         */\r
                        #define USB_CONFIG_ATTR_REMOTEWAKEUP      0xA0\r
 \r
                         *  descriptor's ConfigAttributes value to indicate that the specified configuration supports the\r
                         *  remote wakeup feature of the USB standard, allowing a suspended USB device to wake up the host upon\r
                         *  request.\r
                         */\r
                        #define USB_CONFIG_ATTR_REMOTEWAKEUP      0xA0\r
 \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is not synchronized.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_NO_SYNC             (0 << 2)\r
 \r
                         *  Attributes value to indicate that the specified endpoint is not synchronized.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_NO_SYNC             (0 << 2)\r
 \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is asynchronous.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_ASYNC               (1 << 2)\r
 \r
                         *  Attributes value to indicate that the specified endpoint is asynchronous.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_ASYNC               (1 << 2)\r
 \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is adaptive.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_ADAPTIVE            (2 << 2)\r
 \r
                         *  Attributes value to indicate that the specified endpoint is adaptive.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_ADAPTIVE            (2 << 2)\r
 \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is synchronized.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_SYNC                (3 << 2)\r
                        \r
                         *  Attributes value to indicate that the specified endpoint is synchronized.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint attributes.\r
                         */\r
                        #define ENDPOINT_ATTR_SYNC                (3 << 2)\r
                        \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is used for data transfers.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint usage attributes.\r
                         */\r
                        #define ENDPOINT_USAGE_DATA               (0 << 4)\r
 \r
                         *  Attributes value to indicate that the specified endpoint is used for data transfers.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint usage attributes.\r
                         */\r
                        #define ENDPOINT_USAGE_DATA               (0 << 4)\r
 \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is used for feedback.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint usage attributes.\r
                         */\r
                        #define ENDPOINT_USAGE_FEEDBACK           (1 << 4)\r
 \r
                         *  Attributes value to indicate that the specified endpoint is used for feedback.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint usage attributes.\r
                         */\r
                        #define ENDPOINT_USAGE_FEEDBACK           (1 << 4)\r
 \r

-                       /** Can be masked with other endpoint descriptor attributes for a USB_Descriptor_Endpoint_t descriptor's\r
+                       /** Can be masked with other endpoint descriptor attributes for a \ref USB_Descriptor_Endpoint_t descriptor's\r

                         *  Attributes value to indicate that the specified endpoint is used for implicit feedback.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint usage attributes.\r
                         *  Attributes value to indicate that the specified endpoint is used for implicit feedback.\r
                         *\r
                         *  \see The USB specification for more details on the possible Endpoint usage attributes.\r


@@ -180,7 +180,7 @@
 \r
                /* Events: */\r
                        #if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)\r
 \r
                /* Events: */\r
                        #if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)\r

-                               /** This module raises the Device Error event while in device mode, if the USB_GetDescriptor()\r
+                               /** This module raises the Device Error event while in device mode, if the \ref USB_GetDescriptor()\r

                                 *  routine is not hooked in the user application to properly return descriptors to the library.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 *  routine is not hooked in the user application to properly return descriptors to the library.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r


@@ -215,7 +215,7 @@
                        {\r
                                #if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES) || defined(__DOXYGEN__)\r
                                uint8_t Size; /**< Size of the descriptor, in bytes. */\r
                        {\r
                                #if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES) || defined(__DOXYGEN__)\r
                                uint8_t Size; /**< Size of the descriptor, in bytes. */\r

-                               uint8_t Type; /**< Type of the descriptor, either a value in DescriptorTypes_t or a value\r
+                               uint8_t Type; /**< Type of the descriptor, either a value in \ref USB_DescriptorTypes_t or a value\r

                                               *   given by the specific class.\r
                                               */\r
                                #else\r
                                               *   given by the specific class.\r
                                               */\r
                                #else\r


@@ -251,7 +251,7 @@
                                                                *   host will request this string via a separate\r
                                                                           *   control request for the string descriptor.\r
                                                                               *\r
                                                                *   host will request this string via a separate\r
                                                                           *   control request for the string descriptor.\r
                                                                               *\r

-                                                                              *   \note If no string supplied, use NO_DESCRIPTOR.\r
+                                                                              *   \note If no string supplied, use \ref NO_DESCRIPTOR.\r

                                                                               */\r
                                uint8_t                 ProductStrIndex; /**< String index for the product name/details.\r
                                                                          *\r
                                                                               */\r
                                uint8_t                 ProductStrIndex; /**< String index for the product name/details.\r
                                                                          *\r


@@ -309,7 +309,7 @@
                                                                           */\r
                                \r
                                uint8_t                 MaxPowerConsumption; /**< Maximum power consumption of the device while in the\r
                                                                           */\r
                                \r
                                uint8_t                 MaxPowerConsumption; /**< Maximum power consumption of the device while in the\r

-                                                                             *   current configuration, calculated by the USB_CONFIG_POWER_MA()\r
+                                                                             *   current configuration, calculated by the \ref USB_CONFIG_POWER_MA()\r

                                                                              *   macro.\r
                                                                              */\r
                                #else\r
                                                                              *   macro.\r
                                                                              */\r
                                #else\r


@@ -364,7 +364,7 @@
                                #endif\r
                        } USB_Descriptor_Interface_t;\r
 \r
                                #endif\r
                        } USB_Descriptor_Interface_t;\r
 \r

-                       /** Type define for a standard interface association descriptor.\r
+                       /** Type define for a standard Interface Association descriptor.\r

                         *\r
                         *  This descriptor has been added as a supplement to the USB2.0 standard, in the ECN located at\r
                         *  <a>http://www.usb.org/developers/docs/InterfaceAssociationDescriptor_ecn.pdf</a>. It allows compound\r
                         *\r
                         *  This descriptor has been added as a supplement to the USB2.0 standard, in the ECN located at\r
                         *  <a>http://www.usb.org/developers/docs/InterfaceAssociationDescriptor_ecn.pdf</a>. It allows compound\r


@@ -442,7 +442,7 @@
                        } USB_Descriptor_Endpoint_t;\r
 \r
                        /** Type define for a standard string descriptor. Unlike other standard descriptors, the length\r
                        } USB_Descriptor_Endpoint_t;\r
 \r
                        /** Type define for a standard string descriptor. Unlike other standard descriptors, the length\r

-                        *  of the descriptor for placement in the descriptor header must be determined by the USB_STRING_LEN()\r
+                        *  of the descriptor for placement in the descriptor header must be determined by the \ref USB_STRING_LEN()\r

                         *  macro rather than by the size of the descriptor structure, as the length is not fixed.\r
                         *\r
                         *  This structure should also be used for string index 0, which contains the supported language IDs for\r
                         *  macro rather than by the size of the descriptor structure, as the length is not fixed.\r
                         *\r
                         *  This structure should also be used for string index 0, which contains the supported language IDs for\r


@@ -479,7 +479,7 @@
                /* Function Prototypes: */\r
                        /** Function to retrieve a given descriptor's size and memory location from the given descriptor type value,\r
                         *  index and language ID. This function MUST be overridden in the user application (added with full, identical  \r
                /* Function Prototypes: */\r
                        /** Function to retrieve a given descriptor's size and memory location from the given descriptor type value,\r
                         *  index and language ID. This function MUST be overridden in the user application (added with full, identical  \r

-                        *  prototype and name except for the ATTR_WEAK attribute) so that the library can call it to retrieve descriptor \r
+                        *  prototype and name except for the \ref ATTR_WEAK attribute) so that the library can call it to retrieve descriptor \r

                         *  data.\r
                         *\r
                         *  \param wValue             The type of the descriptor to retrieve in the upper byte, and the index in the \r
                         *  data.\r
                         *\r
                         *  \param wValue             The type of the descriptor to retrieve in the upper byte, and the index in the \r


@@ -490,7 +490,7 @@
                         *                            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
                         *                            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 location of the descriptor, found by the DESCRIPTOR_ADDRESS macro.\r
+                        *                            the location of the descriptor, found by the \ref DESCRIPTOR_ADDRESS() macro.\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


@@ -498,7 +498,7 @@
                         *        USE_EEPROM_DESCRIPTORS tokens may be defined in the project makefile and passed to the compiler by the -D\r
                         *        switch.\r
                         *\r
                         *        USE_EEPROM_DESCRIPTORS tokens may be defined in the project makefile and passed to the compiler by the -D\r
                         *        switch.\r
                         *\r

-                        *  \return Size in bytes of the descriptor if it exists, zero or NO_DESCRIPTOR otherwise\r
+                        *  \return Size in bytes of the descriptor if it exists, zero or \ref NO_DESCRIPTOR otherwise\r

                         */\r
                        uint16_t USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)\r
                                                                           ATTR_WARN_UNUSED_RESULT ATTR_WEAK ATTR_NON_NULL_PTR_ARG(3);\r
                         */\r
                        uint16_t USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)\r
                                                                           ATTR_WARN_UNUSED_RESULT ATTR_WEAK ATTR_NON_NULL_PTR_ARG(3);\r

diff --git a/LUFA/Drivers/USB/HighLevel/StdRequestType.h b/LUFA/Drivers/USB/HighLevel/StdRequestType.h
index 6f21489..fc626cc 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/StdRequestType.h
+++ b/LUFA/Drivers/USB/HighLevel/StdRequestType.h
@@ -66,58 +66,58 @@
 \r
                        /** Request data direction mask, indicating that the request data will flow from host to device.\r
                         *\r
 \r
                        /** Request data direction mask, indicating that the request data will flow from host to device.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_DIRECTION macro.\r
+                        *  \see \ref CONTROL_REQTYPE_DIRECTION macro.\r

                         */\r
                        #define REQDIR_HOSTTODEVICE        (0 << 7)\r
 \r
                        /** Request data direction mask, indicating that the request data will flow from device to host.\r
                         *\r
                         */\r
                        #define REQDIR_HOSTTODEVICE        (0 << 7)\r
 \r
                        /** Request data direction mask, indicating that the request data will flow from device to host.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_DIRECTION macro.\r
+                        *  \see \ref CONTROL_REQTYPE_DIRECTION macro.\r

                         */\r
                        #define REQDIR_DEVICETOHOST        (1 << 7)\r
 \r
                        /** Request type mask, indicating that the request is a standard request.\r
                         *\r
                         */\r
                        #define REQDIR_DEVICETOHOST        (1 << 7)\r
 \r
                        /** Request type mask, indicating that the request is a standard request.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_TYPE macro.\r
+                        *  \see \ref CONTROL_REQTYPE_TYPE macro.\r

                         */\r
                        #define REQTYPE_STANDARD           (0 << 5)\r
 \r
                        /** Request type mask, indicating that the request is a class-specific request.\r
                         *\r
                         */\r
                        #define REQTYPE_STANDARD           (0 << 5)\r
 \r
                        /** Request type mask, indicating that the request is a class-specific request.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_TYPE macro.\r
+                        *  \see \ref CONTROL_REQTYPE_TYPE macro.\r

                         */\r
                        #define REQTYPE_CLASS              (1 << 5)\r
 \r
                        /** Request type mask, indicating that the request is a vendor specific request.\r
                         *\r
                         */\r
                        #define REQTYPE_CLASS              (1 << 5)\r
 \r
                        /** Request type mask, indicating that the request is a vendor specific request.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_TYPE macro.\r
+                        *  \see \ref CONTROL_REQTYPE_TYPE macro.\r

                         */\r
                        #define REQTYPE_VENDOR             (2 << 5)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to the device as a whole.\r
                         *\r
                         */\r
                        #define REQTYPE_VENDOR             (2 << 5)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to the device as a whole.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_RECIPIENT macro.\r
+                        *  \see \ref CONTROL_REQTYPE_RECIPIENT macro.\r

                         */\r
                        #define REQREC_DEVICE              (0 << 0)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to an interface in the\r
                         *  currently selected configuration.\r
                         *\r
                         */\r
                        #define REQREC_DEVICE              (0 << 0)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to an interface in the\r
                         *  currently selected configuration.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_RECIPIENT macro.\r
+                        *  \see \ref CONTROL_REQTYPE_RECIPIENT macro.\r

                         */\r
                        #define REQREC_INTERFACE           (1 << 0)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to an endpoint in the\r
                         *  currently selected configuration.\r
                         *\r
                         */\r
                        #define REQREC_INTERFACE           (1 << 0)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to an endpoint in the\r
                         *  currently selected configuration.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_RECIPIENT macro.\r
+                        *  \see \ref CONTROL_REQTYPE_RECIPIENT macro.\r

                         */\r
                        #define REQREC_ENDPOINT            (2 << 0)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to an unspecified element\r
                         *  in the currently selected configuration.\r
                         *\r
                         */\r
                        #define REQREC_ENDPOINT            (2 << 0)\r
 \r
                        /** Request recipient mask, indicating that the request is to be issued to an unspecified element\r
                         *  in the currently selected configuration.\r
                         *\r

-                        *  \see CONTROL_REQTYPE_RECIPIENT macro.\r
+                        *  \see \ref CONTROL_REQTYPE_RECIPIENT macro.\r

                         */\r
                        #define REQREC_OTHER               (3 << 0)\r
                        \r
                         */\r
                        #define REQREC_OTHER               (3 << 0)\r
                        \r


@@ -151,7 +151,7 @@
 \r
                /* Enums: */\r
                        /** Enumeration for the various standard request commands. These commands are applicable when the\r
 \r
                /* Enums: */\r
                        /** Enumeration for the various standard request commands. These commands are applicable when the\r

-                        *  request type is REQTYPE_STANDARD (with the exception of REQ_GetDescriptor, which is always\r
+                        *  request type is \ref REQTYPE_STANDARD (with the exception of \ref REQ_GetDescriptor, which is always\r

                         *  handled regardless of the request type value).\r
                         *\r
                         *  \see Chapter 9 of the USB 2.0 Specification.\r
                         *  handled regardless of the request type value).\r
                         *\r
                         *  \see Chapter 9 of the USB 2.0 Specification.\r


@@ -160,41 +160,41 @@
                        {\r
                                REQ_GetStatus           = 0, /**< Implemented in the library for device, endpoint and interface\r
                                                              *   recipients. Passed to the user application for other recipients\r
                        {\r
                                REQ_GetStatus           = 0, /**< Implemented in the library for device, endpoint and interface\r
                                                              *   recipients. Passed to the user application for other recipients\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_ClearFeature        = 1, /**< Implemented in the library for device, endpoint and interface\r
                                                              *   recipients. Passed to the user application for other recipients\r
                                                              *   device mode. */\r
                                REQ_ClearFeature        = 1, /**< Implemented in the library for device, endpoint and interface\r
                                                              *   recipients. Passed to the user application for other recipients\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_SetFeature          = 3, /**< Implemented in the library for device, endpoint and interface\r
                                                              *   recipients. Passed to the user application for other recipients\r
                                                              *   device mode. */\r
                                REQ_SetFeature          = 3, /**< Implemented in the library for device, endpoint and interface\r
                                                              *   recipients. Passed to the user application for other recipients\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_SetAddress          = 5, /**< Implemented in the library for the device recipient. Passed\r
                                                              *   to the user application for other recipients via the\r
                                                              *   device mode. */\r
                                REQ_SetAddress          = 5, /**< Implemented in the library for the device recipient. Passed\r
                                                              *   to the user application for other recipients via the\r

-                                                             *   USB_UnhandledControlPacket() event when received in\r
+                                                             *   \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_GetDescriptor       = 6, /**< Implemented in the library for all recipients and all request\r
                                                              *   types. */\r
                                REQ_SetDescriptor       = 7, /**< Not implemented in the library, passed to the user application\r
                                                              *   device mode. */\r
                                REQ_GetDescriptor       = 6, /**< Implemented in the library for all recipients and all request\r
                                                              *   types. */\r
                                REQ_SetDescriptor       = 7, /**< Not implemented in the library, passed to the user application\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_GetConfiguration    = 8, /**< Implemented in the library for the device recipient. Passed\r
                                                              *   to the user application for other recipients via the\r
                                                              *   device mode. */\r
                                REQ_GetConfiguration    = 8, /**< Implemented in the library for the device recipient. Passed\r
                                                              *   to the user application for other recipients via the\r

-                                                             *   USB_UnhandledControlPacket() event when received in\r
+                                                             *   \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_SetConfiguration    = 9, /**< Implemented in the library for the device recipient. Passed\r
                                                              *   to the user application for other recipients via the\r
                                                              *   device mode. */\r
                                REQ_SetConfiguration    = 9, /**< Implemented in the library for the device recipient. Passed\r
                                                              *   to the user application for other recipients via the\r

-                                                             *   USB_UnhandledControlPacket() event when received in\r
+                                                             *   \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_GetInterface        = 10, /**< Not implemented in the library, passed to the user application\r
                                                              *   device mode. */\r
                                REQ_GetInterface        = 10, /**< Not implemented in the library, passed to the user application\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_SetInterface        = 11, /**< Not implemented in the library, passed to the user application\r
                                                              *   device mode. */\r
                                REQ_SetInterface        = 11, /**< Not implemented in the library, passed to the user application\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                                REQ_SynchFrame          = 12, /**< Not implemented in the library, passed to the user application\r
                                                              *   device mode. */\r
                                REQ_SynchFrame          = 12, /**< Not implemented in the library, passed to the user application\r

-                                                             *   via the USB_UnhandledControlPacket() event when received in\r
+                                                             *   via the \ref USB_UnhandledControlPacket() event when received in\r

                                                              *   device mode. */\r
                        };\r
 \r
                                                              *   device mode. */\r
                        };\r
 \r

diff --git a/LUFA/Drivers/USB/HighLevel/StreamCallbacks.h b/LUFA/Drivers/USB/HighLevel/StreamCallbacks.h
index 5f0b737..6a18920 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/StreamCallbacks.h
+++ b/LUFA/Drivers/USB/HighLevel/StreamCallbacks.h
@@ -47,7 +47,7 @@
                         *  these functions are used) which allow the user application to abort the transfer when certain\r
                         *  arbitrary conditions are met.\r
                         *\r
                         *  these functions are used) which allow the user application to abort the transfer when certain\r
                         *  arbitrary conditions are met.\r
                         *\r

-                        *  Stream callback functions should return a value from the StreamCallback_Return_ErrorCodes_t\r
+                        *  Stream callback functions should return a value from the \ref StreamCallback_Return_ErrorCodes_t\r

                         *  enum.\r
                         *\r
                         *  Usage Example (Device Endpoint, but applicable for Host Pipes also):\r
                         *  enum.\r
                         *\r
                         *  Usage Example (Device Endpoint, but applicable for Host Pipes also):\r

diff --git a/LUFA/Drivers/USB/HighLevel/USBInterrupt.h b/LUFA/Drivers/USB/HighLevel/USBInterrupt.h
index c5b0a83..ee13f25 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/USBInterrupt.h
+++ b/LUFA/Drivers/USB/HighLevel/USBInterrupt.h
@@ -70,7 +70,7 @@
 \r
                        /** Disables the given USB interrupt vector.\r
                         *\r
 \r
                        /** Disables the given USB interrupt vector.\r
                         *\r

-                        *  \see USB_INT_Enable()\r
+                        *  \see \ref USB_INT_Enable()\r

                         */\r
                        #define USB_INT_Disable(int)             MACROS{ USB_INT_GET_EN_REG(int)   &= ~(USB_INT_GET_EN_MASK(int));  }MACROE\r
 \r
                         */\r
                        #define USB_INT_Disable(int)             MACROS{ USB_INT_GET_EN_REG(int)   &= ~(USB_INT_GET_EN_MASK(int));  }MACROE\r
 \r


@@ -96,7 +96,7 @@
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r

-                        *        and disconnection events may be manually fired by RAISE_EVENT(), and the USB_IsConnected global changed manually.\r
+                        *        and disconnection events may be manually fired by \ref RAISE_EVENT(), and the USB_IsConnected global changed manually.\r

                         */\r
                        RAISES_EVENT(USB_Connect);\r
 \r
                         */\r
                        RAISES_EVENT(USB_Connect);\r
 \r


@@ -108,7 +108,7 @@
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r

-                        *        and disconnection events may be manually fired by RAISE_EVENT(), and the USB_IsConnected global changed manually.\r
+                        *        and disconnection events may be manually fired by \ref RAISE_EVENT(), and the USB_IsConnected global changed manually.\r

                         */\r
                        RAISES_EVENT(USB_Disconnect);\r
 \r
                         */\r
                        RAISES_EVENT(USB_Disconnect);\r
 \r

diff --git a/LUFA/Drivers/USB/HighLevel/USBTask.h b/LUFA/Drivers/USB/HighLevel/USBTask.h
index 7e88ce8..918fa5e 100644 (file)
--- a/LUFA/Drivers/USB/HighLevel/USBTask.h
+++ b/LUFA/Drivers/USB/HighLevel/USBTask.h
@@ -67,14 +67,14 @@
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r
                         *        which is not always accurate (host may suspend the bus while still connected). If the actual connection state\r
                         *        needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by\r
                         *        passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection\r

-                        *        and disconnection events may be manually fired by RAISE_EVENT(), and the USB_IsConnected global changed manually.\r
+                        *        and disconnection events may be manually fired by \ref RAISE_EVENT(), and the \ref USB_IsConnected global changed manually.\r

                         *\r
                         *  \ingroup Group_USBManagement\r
                         */\r
                        extern volatile bool USB_IsConnected;\r
 \r
                        /** Indicates if the USB interface is currently initialized but not necessarily connected to a host\r
                         *\r
                         *  \ingroup Group_USBManagement\r
                         */\r
                        extern volatile bool USB_IsConnected;\r
 \r
                        /** Indicates if the USB interface is currently initialized but not necessarily connected to a host\r

-                        *  or device (i.e. if USB_Init() has been run). If this is false, all other library globals are invalid.\r
+                        *  or device (i.e. if \ref USB_Init() has been run). If this is false, all other library globals are invalid.\r

                         *\r
                         *  \note This variable should be treated as read-only in the user application, and never manually\r
                         *        changed in value.\r
                         *\r
                         *  \note This variable should be treated as read-only in the user application, and never manually\r
                         *        changed in value.\r


@@ -84,8 +84,8 @@
                        extern volatile bool USB_IsInitialized;\r
 \r
                        /** Structure containing the last received Control request when in Device mode (for use in user-applications\r
                        extern volatile bool USB_IsInitialized;\r
 \r
                        /** Structure containing the last received Control request when in Device mode (for use in user-applications\r

-                        *  inside of the USB_UnhandledControlPacket() event, or for filling up with a control request to issue when\r
-                        *  in Host mode before calling USB_Host_SendControlRequest().\r
+                        *  inside of the \ref USB_UnhandledControlPacket() event, or for filling up with a control request to issue when\r
+                        *  in Host mode before calling \ref USB_Host_SendControlRequest().\r

                         *\r
                         *  \ingroup Group_USBManagement\r
                         */\r
                         *\r
                         *  \ingroup Group_USBManagement\r
                         */\r


@@ -94,7 +94,7 @@
                        #if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)\r
                        /** Indicates if the USB interface is currently suspended by the host when in device mode. When suspended,\r
                         *  the device should consume minimal power, and cannot communicate to the host. If Remote Wakeup is\r
                        #if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)\r
                        /** Indicates if the USB interface is currently suspended by the host when in device mode. When suspended,\r
                         *  the device should consume minimal power, and cannot communicate to the host. If Remote Wakeup is\r

-                        *  supported by the device and USB_RemoteWakeupEnabled is true, suspension can be terminated by the device\r
+                        *  supported by the device and \ref USB_RemoteWakeupEnabled is true, suspension can be terminated by the device\r

                         *  by issuing a Remote Wakeup request.\r
                         *\r
                         *  \note This global is only present if the user application can be a USB device.\r
                         *  by issuing a Remote Wakeup request.\r
                         *\r
                         *  \note This global is only present if the user application can be a USB device.\r


@@ -109,11 +109,11 @@
 \r
                        #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)\r
                        /** Indicates the current host state machine state. When in host mode, this indicates the state\r
 \r
                        #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)\r
                        /** Indicates the current host state machine state. When in host mode, this indicates the state\r

-                        *  via one of the values of the USB_Host_States_t enum values in Host.h.\r
+                        *  via one of the values of the \ref USB_Host_States_t enum values in Host.h.\r

                         *\r
                         *\r

-                        *  This value may be altered by the user application to implement the HOST_STATE_Addressed,\r
-                        *  HOST_STATE_Configured, HOST_STATE_Ready and HOST_STATE_Suspended states which are not implemented\r
-                        *  by the library.\r
+                        *  This value may be altered by the user application to implement the \ref HOST_STATE_Addressed,\r
+                        *  \ref HOST_STATE_Configured, \ref HOST_STATE_Ready and \ref HOST_STATE_Suspended states which\r
+                        *  are not implemented by the library.\r

                         *\r
                         *  \note This global is only present if the user application can be a USB host.\r
                         *\r
                         *\r
                         *  \note This global is only present if the user application can be a USB host.\r
                         *\r


@@ -124,35 +124,35 @@
 \r
                /* Throwable Events: */\r
                        #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)\r
 \r
                /* Throwable Events: */\r
                        #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)\r

-                               /** This module raises the USB Connect event when a USB device has been connected whilst in host\r
+                               /** This module raises the \ref USB_Connect event when a USB device has been connected whilst in host\r

                                 *  mode, but not yet enumerated.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_Connect);\r
 \r
                                 *  mode, but not yet enumerated.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_Connect);\r
 \r

-                               /** This module raises the USB Device Attached event when in host mode, and a device is attached\r
+                               /** This module raises the \ref USB_DeviceAttached event when in host mode, and a device is attached\r

                                 *  to the AVR's USB interface.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_DeviceAttached);\r
 \r
                                 *  to the AVR's USB interface.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_DeviceAttached);\r
 \r

-                               /** This module raises the USB Device Unattached event when in host mode, and a device is removed\r
+                               /** This module raises the \ref USB_DeviceUnattached event when in host mode, and a device is removed\r

                                 *  from the AVR's USB interface.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_DeviceUnattached);\r
                                \r
                                 *  from the AVR's USB interface.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_DeviceUnattached);\r
                                \r

-                               /** This module raises the USB Device Enumeration Failed event when in host mode, and an\r
+                               /** This module raises the \ref USB_DeviceEnumerationFailed event when in host mode, and an\r

                                 *  attached USB device has failed to successfully enumerated.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_DeviceEnumerationFailed);\r
 \r
                                 *  attached USB device has failed to successfully enumerated.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 */\r
                                RAISES_EVENT(USB_DeviceEnumerationFailed);\r
 \r

-                               /** This module raises the USB Device Enumeration Complete event when in host mode, and an\r
+                               /** This module raises the \ref USB_DeviceEnumerationComplete event when in host mode, and an\r

                                 *  attached USB device has been successfully enumerated and ready to be used by the user\r
                                 *  application.\r
                                 *\r
                                 *  attached USB device has been successfully enumerated and ready to be used by the user\r
                                 *  application.\r
                                 *\r


@@ -160,7 +160,7 @@
                                 */\r
                                RAISES_EVENT(USB_DeviceEnumerationComplete);\r
 \r
                                 */\r
                                RAISES_EVENT(USB_DeviceEnumerationComplete);\r
 \r

-                               /** This module raises the USB Disconnect event when an attached USB device is removed from the USB\r
+                               /** This module raises the \ref USB_Disconnect event when an attached USB device is removed from the USB\r

                                 *  bus.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r
                                 *  bus.\r
                                 *\r
                                 *  \see Events.h for more information on this event.\r


@@ -177,11 +177,11 @@
                         *  The USB task must be serviced within 50mS in all modes, when needed. The task may be serviced \r
                         *  at all times, or (for minimum CPU consumption):\r
                         *\r
                         *  The USB task must be serviced within 50mS in all modes, when needed. The task may be serviced \r
                         *  at all times, or (for minimum CPU consumption):\r
                         *\r

-                        *    - In device mode, it may be disabled at start-up, enabled on the firing of the USB_Connect event\r
-                        *    and disabled again on the firing of the USB_Disconnect event.\r
+                        *    - In device mode, it may be disabled at start-up, enabled on the firing of the \ref USB_Connect event\r
+                        *    and disabled again on the firing of the \ref USB_Disconnect event.\r

                         *\r
                         *\r

-                        *    - In host mode, it may be disabled at start-up, enabled on the firing of the USB_DeviceAttached\r
-                        *    event and disabled again on the firing of the USB_DeviceUnattached event.\r
+                        *    - In host mode, it may be disabled at start-up, enabled on the firing of the \ref USB_DeviceAttached\r
+                        *    event and disabled again on the firing of the \ref USB_DeviceUnattached event.\r

                         *\r
                         *  \see Events.h for more information on the USB events.\r
                         *\r
                         *\r
                         *  \see Events.h for more information on the USB events.\r
                         *\r

diff --git a/LUFA/Drivers/USB/LowLevel/DevChapter9.h b/LUFA/Drivers/USB/LowLevel/DevChapter9.h
index 10a9193..b3cac2d 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/DevChapter9.h
+++ b/LUFA/Drivers/USB/LowLevel/DevChapter9.h
@@ -83,22 +83,22 @@
                        extern bool USB_CurrentlySelfPowered;\r
 \r
                /* Throwable Events: */\r
                        extern bool USB_CurrentlySelfPowered;\r
 \r
                /* Throwable Events: */\r

-                       /** This module raises the USB_UnhandledControlPacket event when a request to the default control\r
+                       /** This module raises the \ref USB_UnhandledControlPacket event when a request to the default control\r

                         *  endpoint has been received, but the library does not implement an internal handler for it.\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        RAISES_EVENT(USB_UnhandledControlPacket);\r
 \r
                         *  endpoint has been received, but the library does not implement an internal handler for it.\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        RAISES_EVENT(USB_UnhandledControlPacket);\r
 \r

-                       /** This module raises the USB_ConfigurationChanged event when the host issues a REQ_SetConfiguration\r
+                       /** This module raises the \ref USB_ConfigurationChanged event when the host issues a \ref REQ_SetConfiguration\r

                         *  device request, to change the currently selected configuration number.\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        RAISES_EVENT(USB_ConfigurationChanged);\r
 \r
                         *  device request, to change the currently selected configuration number.\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        RAISES_EVENT(USB_ConfigurationChanged);\r
 \r

-                       /** This module raises the USB_DeviceEnumerationComplete event when the host has completed its\r
-                        *  enumeration of the device (i.e. when a REQ_SetConfiguration request changes the current configuration\r
+                       /** This module raises the \ref USB_DeviceEnumerationComplete event when the host has completed its\r
+                        *  enumeration of the device (i.e. when a \ref REQ_SetConfiguration request changes the current configuration\r

                         *  number from 0 to a non-zero value).\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         *  number from 0 to a non-zero value).\r
                         *\r
                         *  \see Events.h for more information on this event.\r

diff --git a/LUFA/Drivers/USB/LowLevel/Device.h b/LUFA/Drivers/USB/LowLevel/Device.h
index 206a993..b3a11d2 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Device.h
+++ b/LUFA/Drivers/USB/LowLevel/Device.h
@@ -51,7 +51,7 @@
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
                        #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) || defined(__DOXYGEN__)\r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
                        #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) || defined(__DOXYGEN__)\r

-                               /** Mask for the Options parameter of the USB_Init() function. This indicates that the\r
+                               /** Mask for the Options parameter of the \ref USB_Init() function. This indicates that the\r

                                 *  USB interface should be initialized in low speed (1.5Mb/s) mode.\r
                                 *\r
                                 *  \note Low Speed mode is not available on all USB AVR models.\r
                                 *  USB interface should be initialized in low speed (1.5Mb/s) mode.\r
                                 *\r
                                 *  \note Low Speed mode is not available on all USB AVR models.\r


@@ -78,7 +78,7 @@
                                 *  \note This macro should only be used if the device has indicated to the host that it\r
                                 *        supports the Remote Wakeup feature in the device descriptors, and should only be\r
                                 *        issued if the host is currently allowing remote wakeup events from the device (i.e.,\r
                                 *  \note This macro should only be used if the device has indicated to the host that it\r
                                 *        supports the Remote Wakeup feature in the device descriptors, and should only be\r
                                 *        issued if the host is currently allowing remote wakeup events from the device (i.e.,\r

-                                *        the USB_RemoteWakeupEnabled flag is set, see DevChapter9.h documentation).\r
+                                *        the \ref USB_RemoteWakeupEnabled flag is set).\r

                                 *\r
                                 *  \see StdDescriptors.h for more information on the RMWAKEUP feature and device descriptors.\r
                                 */\r
                                 *\r
                                 *  \see StdDescriptors.h for more information on the RMWAKEUP feature and device descriptors.\r
                                 */\r


@@ -87,7 +87,7 @@
                                /** Indicates if a Remote Wakeup request is being sent to the host. This returns true if a\r
                                 *  remote wakeup is currently being sent, false otherwise.\r
                                 *\r
                                /** Indicates if a Remote Wakeup request is being sent to the host. This returns true if a\r
                                 *  remote wakeup is currently being sent, false otherwise.\r
                                 *\r

-                                *  This can be used in conjunction with the USB_Device_IsUSBSuspended() macro to determine if\r
+                                *  This can be used in conjunction with the \ref USB_Device_IsUSBSuspended() macro to determine if\r

                                 *  a sent RMWAKEUP request was accepted or rejected by the host.\r
                                 *\r
                                 *  \note This macro should only be used if the device has indicated to the host that it\r
                                 *  a sent RMWAKEUP request was accepted or rejected by the host.\r
                                 *\r
                                 *  \note This macro should only be used if the device has indicated to the host that it\r


@@ -99,9 +99,9 @@
                                 */\r
                                static inline bool USB_Device_IsRemoteWakeupSent(void);\r
                                \r
                                 */\r
                                static inline bool USB_Device_IsRemoteWakeupSent(void);\r
                                \r

-                               /** Indicates if the device is currently suspended by the host. While suspended, the device is\r
-                                *  to enter a low power state until resumed by the host. While suspended no USB traffic to or\r
-                                *  from the device can occur (except for Remote Wakeup requests).\r
+                               /** Indicates if the device is currently suspended by the host. Whilst suspended, the device is\r
+                                *  to enter a low power state until resumed by the host. No USB traffic to or from the device\r
+                                *  can occur (except for Remote Wakeup requests) during suspension by the host.\r

                                 *\r
                                 *  \return Boolean true if the USB communications have been suspended by the host, false otherwise.\r
                                 */\r
                                 *\r
                                 *  \return Boolean true if the USB communications have been suspended by the host, false otherwise.\r
                                 */\r


@@ -115,17 +115,17 @@
                        #endif\r
 \r
                /* Enums: */\r
                        #endif\r
 \r
                /* Enums: */\r

-                       /** Enum for the ErrorCode parameter of the USB_DeviceError event.\r
+                       /** Enum for the ErrorCode parameter of the \ref USB_DeviceError event.\r

                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        enum USB_Device_ErrorCodes_t\r
                        {\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        enum USB_Device_ErrorCodes_t\r
                        {\r

-                               DEVICE_ERROR_GetDescriptorNotHooked        = 0, /**< Indicates that the GetDescriptor() method\r
+                               DEVICE_ERROR_GetDescriptorNotHooked        = 0, /**< Indicates that the \ref USB_GetDescriptor() method\r

                                                                                 *   has not been hooked by the user application.\r
                                                                                 *\r
                                                                                 *   \see StdDescriptors.h for more information on\r
                                                                                 *   has not been hooked by the user application.\r
                                                                                 *\r
                                                                                 *   \see StdDescriptors.h for more information on\r

-                                                                                *        the GetDescriptor() method.\r
+                                                                                *        the \ref USB_GetDescriptor() method.\r

                                                                                 */\r
                        };\r
 \r
                                                                                 */\r
                        };\r
 \r

diff --git a/LUFA/Drivers/USB/LowLevel/Endpoint.h b/LUFA/Drivers/USB/LowLevel/Endpoint.h
index 816e763..172ab33 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Endpoint.h
+++ b/LUFA/Drivers/USB/LowLevel/Endpoint.h
@@ -69,24 +69,24 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r

-                       /** Endpoint data direction mask for Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r
+                       /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r

                         *  should be initialized in the OUT direction - i.e. data flows from host to device.\r
                         */\r
                        #define ENDPOINT_DIR_OUT                      (0 << EPDIR)\r
 \r
                         *  should be initialized in the OUT direction - i.e. data flows from host to device.\r
                         */\r
                        #define ENDPOINT_DIR_OUT                      (0 << EPDIR)\r
 \r

-                       /** Endpoint data direction mask for Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r
+                       /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r

                         *  should be initialized in the IN direction - i.e. data flows from device to host.\r
                         */\r
                        #define ENDPOINT_DIR_IN                       (1 << EPDIR)\r
 \r
                         *  should be initialized in the IN direction - i.e. data flows from device to host.\r
                         */\r
                        #define ENDPOINT_DIR_IN                       (1 << EPDIR)\r
 \r

-                       /** Mask for the bank mode selection for the Endpoint_ConfigureEndpoint() macro. This indicates\r
+                       /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates\r

                         *  that the endpoint should have one single bank, which requires less USB FIFO memory but results\r
                         *  in slower transfers as only one USB device (the AVR or the host) can access the endpoint's\r
                         *  bank at the one time.\r
                         */\r
                        #define ENDPOINT_BANK_SINGLE                  (0 << EPBK0)\r
 \r
                         *  that the endpoint should have one single bank, which requires less USB FIFO memory but results\r
                         *  in slower transfers as only one USB device (the AVR or the host) can access the endpoint's\r
                         *  bank at the one time.\r
                         */\r
                        #define ENDPOINT_BANK_SINGLE                  (0 << EPBK0)\r
 \r

-                       /** Mask for the bank mode selection for the Endpoint_ConfigureEndpoint() macro. This indicates\r
+                       /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates\r

                         *  that the endpoint should have two banks, which requires more USB FIFO memory but results\r
                         *  in faster transfers as one USB device (the AVR or the host) can access one bank while the other\r
                         *  accesses the second bank.\r
                         *  that the endpoint should have two banks, which requires more USB FIFO memory but results\r
                         *  in faster transfers as one USB device (the AVR or the host) can access one bank while the other\r
                         *  accesses the second bank.\r


@@ -146,7 +146,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
                         *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
                         *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define ENDPOINT_INT_SETUP                    UEIENX, (1 << RXSTPE), UEINTX, (1 << RXSTPI)\r
 \r
                         */\r
                        #define ENDPOINT_INT_SETUP                    UEIENX, (1 << RXSTPE), UEINTX, (1 << RXSTPI)\r
 \r


@@ -160,7 +160,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
                         *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
                         *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define ENDPOINT_INT_IN                       UEIENX, (1 << TXINE) , UEINTX, (1 << TXINI)\r
 \r
                         */\r
                        #define ENDPOINT_INT_IN                       UEIENX, (1 << TXINE) , UEINTX, (1 << TXINI)\r
 \r


@@ -174,7 +174,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
                         *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
                         *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define ENDPOINT_INT_OUT                      UEIENX, (1 << RXOUTE), UEINTX, (1 << RXOUTI)\r
                        \r
                         */\r
                        #define ENDPOINT_INT_OUT                      UEIENX, (1 << RXOUTE), UEINTX, (1 << RXOUTI)\r
                        \r


@@ -200,7 +200,7 @@
                                static inline uint8_t Endpoint_GetCurrentEndpoint(void);\r
                                \r
                                /** Selects the given endpoint number. If the address from the device descriptors is used, the\r
                                static inline uint8_t Endpoint_GetCurrentEndpoint(void);\r
                                \r
                                /** Selects the given endpoint number. If the address from the device descriptors is used, the\r

-                                *  value should be masked with the ENDPOINT_EPNUM_MASK constant to extract only the endpoint\r
+                                *  value should be masked with the \ref ENDPOINT_EPNUM_MASK constant to extract only the endpoint\r

                                 *  number (and discarding the endpoint direction bit).\r
                                 *\r
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
                                 *  number (and discarding the endpoint direction bit).\r
                                 *\r
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r


@@ -220,8 +220,7 @@
                                /** Enables the currently selected endpoint so that data can be sent and received through it to\r
                                 *  and from a host.\r
                                 *\r
                                /** Enables the currently selected endpoint so that data can be sent and received through it to\r
                                 *  and from a host.\r
                                 *\r

-                                *  \note Endpoints must first be configured properly rather than just being enabled via the\r
-                                *        Endpoint_ConfigureEndpoint() macro, which calls Endpoint_EnableEndpoint() automatically.\r
+                                *  \note Endpoints must first be configured properly via \ref Endpoint_ConfigureEndpoint().\r

                                 */\r
                                static inline void Endpoint_EnableEndpoint(void);\r
 \r
                                 */\r
                                static inline void Endpoint_EnableEndpoint(void);\r
 \r


@@ -330,7 +329,7 @@
                                 *  way for devices to indicate invalid commands to the host so that the current transfer can be\r
                                 *  aborted and the host can begin its own recovery sequence.\r
                                 *\r
                                 *  way for devices to indicate invalid commands to the host so that the current transfer can be\r
                                 *  aborted and the host can begin its own recovery sequence.\r
                                 *\r

-                                *  The currently selected endpoint remains stalled until either the Endpoint_ClearStall() macro\r
+                                *  The currently selected endpoint remains stalled until either the \ref Endpoint_ClearStall() macro\r

                                 *  is called, or the host issues a CLEAR FEATURE request to the device for the currently selected\r
                                 *  endpoint.\r
                                 *\r
                                 *  is called, or the host issues a CLEAR FEATURE request to the device for the currently selected\r
                                 *  endpoint.\r
                                 *\r


@@ -415,7 +414,7 @@
                        #endif\r
 \r
                /* Enums: */\r
                        #endif\r
 \r
                /* Enums: */\r

-                       /** Enum for the possible error return codes of the Endpoint_WaitUntilReady function.\r
+                       /** Enum for the possible error return codes of the \ref Endpoint_WaitUntilReady() function.\r

                         *\r
                         *  \ingroup Group_EndpointRW\r
                         */\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         */\r


@@ -430,7 +429,7 @@
                                                                                 */     \r
                                ENDPOINT_READYWAIT_Timeout                 = 3, /**< The host failed to accept or send the next packet\r
                                                                                 *   within the software timeout period set by the\r
                                                                                 */     \r
                                ENDPOINT_READYWAIT_Timeout                 = 3, /**< The host failed to accept or send the next packet\r
                                                                                 *   within the software timeout period set by the\r

-                                                                                *   USB_STREAM_TIMEOUT_MS macro.\r
+                                                                                *   \ref USB_STREAM_TIMEOUT_MS macro.\r

                                                                                 */\r
                        };\r
                \r
                                                                                 */\r
                        };\r
                \r


@@ -449,7 +448,7 @@
                                                                                 */\r
                                ENDPOINT_RWSTREAM_ERROR_Timeout            = 2, /**< The host failed to accept or send the next packet\r
                                                                                 *   within the software timeout period set by the\r
                                                                                 */\r
                                ENDPOINT_RWSTREAM_ERROR_Timeout            = 2, /**< The host failed to accept or send the next packet\r
                                                                                 *   within the software timeout period set by the\r

-                                                                                *   USB_STREAM_TIMEOUT_MS macro.\r
+                                                                                *   \ref USB_STREAM_TIMEOUT_MS macro.\r

                                                                                 */\r
                                ENDPOINT_RWSTREAM_ERROR_CallbackAborted    = 3, /**< Indicates that the stream's callback function\r
                                                                             *   aborted the transfer early.\r
                                                                                 */\r
                                ENDPOINT_RWSTREAM_ERROR_CallbackAborted    = 3, /**< Indicates that the stream's callback function\r
                                                                             *   aborted the transfer early.\r


@@ -703,15 +702,15 @@
                         *  device (i.e. endpoint 1 should be configured before endpoint 2 and so on).\r
                         *\r
                         *  The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction\r
                         *  device (i.e. endpoint 1 should be configured before endpoint 2 and so on).\r
                         *\r
                         *  The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction\r

-                        *  may be either ENDPOINT_DIR_OUT or ENDPOINT_DIR_IN.\r
+                        *  may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.\r

                         *\r
                         *  The bank size must indicate the maximum packet size that the endpoint can handle. Different\r
                         *  endpoint numbers can handle different maximum packet sizes - refer to the chosen USB AVR's\r
                         *  datasheet to determine the maximum bank size for each endpoint.\r
                         *\r
                         *\r
                         *  The bank size must indicate the maximum packet size that the endpoint can handle. Different\r
                         *  endpoint numbers can handle different maximum packet sizes - refer to the chosen USB AVR's\r
                         *  datasheet to determine the maximum bank size for each endpoint.\r
                         *\r

-                        *  The banking mode may be either ENDPOINT_BANK_SINGLE or ENDPOINT_BANK_DOUBLE.\r
+                        *  The banking mode may be either \ref ENDPOINT_BANK_SINGLE or \ref ENDPOINT_BANK_DOUBLE.\r

                         *\r
                         *\r

-                        *  The success of this routine can be determined via the Endpoint_IsConfigured() macro.\r
+                        *  The success of this routine can be determined via the \ref Endpoint_IsConfigured() macro.\r

                         *\r
                         *  By default, the routine is entirely dynamic, and will accept both constant and variable inputs.\r
                         *  If dynamic configuration is unused, a small space savings can be made by defining the\r
                         *\r
                         *  By default, the routine is entirely dynamic, and will accept both constant and variable inputs.\r
                         *  If dynamic configuration is unused, a small space savings can be made by defining the\r


@@ -733,18 +732,18 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r

-                        *  \return A value from the Endpoint_WaitUntilReady_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_WaitUntilReady(void);\r
 \r
                        /** Reads and discards the given number of bytes from the endpoint from the given buffer,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
                         */\r
                        uint8_t Endpoint_WaitUntilReady(void);\r
 \r
                        /** Reads and discards the given number of bytes from the endpoint from the given buffer,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r

-                        *  discarding the last packet from the host via the Endpoint_ClearOUT() macro. Between\r
+                        *  discarding the last packet from the host via the \ref Endpoint_ClearOUT() macro. Between\r

                         *  each USB packet, the given stream callback function is executed repeatedly until the next\r
                         *  packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  each USB packet, the given stream callback function is executed repeatedly until the next\r
                         *  packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -755,7 +754,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Discard_Stream(uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Endpoint_Discard_Stream(uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -766,11 +765,11 @@
                        /** Writes the given number of bytes to the endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Writes the given number of bytes to the endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r
+                        *  \ref Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r

                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r
                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -782,7 +781,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -793,11 +792,11 @@
                        /** Writes the given number of bytes to the endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Writes the given number of bytes to the endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r
+                        *  \ref Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r

                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r
                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -809,7 +808,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -820,11 +819,11 @@
                        /** Reads the given number of bytes from the endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
                        /** Reads the given number of bytes from the endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r

-                        *  discarding the last packet from the host via the Endpoint_ClearOUT() macro. Between\r
+                        *  discarding the last packet from the host via the \ref Endpoint_ClearOUT() macro. Between\r

                         *  each USB packet, the given stream callback function is executed repeatedly until the endpoint\r
                         *  is ready to accept the next packet, allowing for early aborts of stream transfers.\r
                         *\r
                         *  each USB packet, the given stream callback function is executed repeatedly until the endpoint\r
                         *  is ready to accept the next packet, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -836,7 +835,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -847,11 +846,11 @@
                        /** Reads the given number of bytes from the endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
                        /** Reads the given number of bytes from the endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r

-                        *  discarding the last packet from the host via the Endpoint_ClearOUT() macro. Between\r
+                        *  discarding the last packet from the host via the \ref Endpoint_ClearOUT() macro. Between\r

                         *  each USB packet, the given stream callback function is executed repeatedly until the endpoint\r
                         *  is ready to accept the next packet, allowing for early aborts of stream transfers.\r
                         *\r
                         *  each USB packet, the given stream callback function is executed repeatedly until the endpoint\r
                         *  is ready to accept the next packet, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -863,7 +862,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -874,7 +873,7 @@
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r

-                        *  finalize the transfer via the Endpoint_ClearOUT() macro.\r
+                        *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r

                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r


@@ -886,14 +885,14 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r

-                        *  finalize the transfer via the Endpoint_ClearOUT() macro.\r
+                        *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r

                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r


@@ -905,14 +904,14 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r

-                        *  setup IN to finalize the transfer via the Endpoint_ClearIN() macro.\r
+                        *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r

                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r


@@ -924,14 +923,14 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r
                         */\r
                        uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r

-                        *  setup IN to finalize the transfer via the Endpoint_ClearIN() macro.\r
+                        *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r

                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r


@@ -943,7 +942,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);                \r
                        \r
                         */\r
                        uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);                \r
                        \r

diff --git a/LUFA/Drivers/USB/LowLevel/Host.h b/LUFA/Drivers/USB/LowLevel/Host.h
index 62921e8..0eb4843 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Host.h
+++ b/LUFA/Drivers/USB/LowLevel/Host.h
@@ -68,7 +68,7 @@
                                 *  library will return a timeout error code.\r
                                 *\r
                                 *  This value may be overridden in the user project makefile as the value of the \r
                                 *  library will return a timeout error code.\r
                                 *\r
                                 *  This value may be overridden in the user project makefile as the value of the \r

-                                *  USB_HOST_TIMEOUT_MS token, and passed to the compiler using the -D switch.\r
+                                *  \ref USB_HOST_TIMEOUT_MS token, and passed to the compiler using the -D switch.\r

                                 */\r
                                #define USB_HOST_TIMEOUT_MS                1000\r
                        #endif\r
                                 */\r
                                #define USB_HOST_TIMEOUT_MS                1000\r
                        #endif\r


@@ -95,7 +95,7 @@
                                 */\r
                                static inline void USB_Host_ResetBus(void);\r
 \r
                                 */\r
                                static inline void USB_Host_ResetBus(void);\r
 \r

-                               /** Determines if a previously issued bus reset (via the USB_Host_ResetBus() macro) has\r
+                               /** Determines if a previously issued bus reset (via the \ref USB_Host_ResetBus() macro) has\r

                                 *  completed.\r
                                 *\r
                                 *  \return Boolean true if no bus reset is currently being sent, false otherwise.\r
                                 *  completed.\r
                                 *\r
                                 *  \return Boolean true if no bus reset is currently being sent, false otherwise.\r


@@ -114,7 +114,7 @@
                                 */\r
                                static inline void USB_Host_SuspendBus(void);\r
                                \r
                                 */\r
                                static inline void USB_Host_SuspendBus(void);\r
                                \r

-                               /** Determines if the USB bus has been suspended via the use of the USB_Host_SuspendBus() macro,\r
+                               /** Determines if the USB bus has been suspended via the use of the \ref USB_Host_SuspendBus() macro,\r

                                 *  false otherwise. While suspended, no USB communications can occur until the bus is resumed,\r
                                 *  except for the Remote Wakeup event from the device if supported.\r
                                 *\r
                                 *  false otherwise. While suspended, no USB communications can occur until the bus is resumed,\r
                                 *  except for the Remote Wakeup event from the device if supported.\r
                                 *\r


@@ -200,28 +200,28 @@
                                HOST_STATE_Suspended                    = 13, /**< May be implemented by the user project. */\r
                        };\r
                        \r
                                HOST_STATE_Suspended                    = 13, /**< May be implemented by the user project. */\r
                        };\r
                        \r

-                       /** Enum for the error codes for the USB_HostError event.\r
+                       /** Enum for the error codes for the \ref USB_HostError event.\r

                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        enum USB_Host_ErrorCodes_t\r
                        {\r
                                HOST_ERROR_VBusVoltageDip       = 0, /**< VBUS voltage dipped to an unacceptable level. This\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        enum USB_Host_ErrorCodes_t\r
                        {\r
                                HOST_ERROR_VBusVoltageDip       = 0, /**< VBUS voltage dipped to an unacceptable level. This\r

-                                                                     *  error may be the result of an attached device drawing\r
+                                                                     *   error may be the result of an attached device drawing\r

                                                                      *   too much current from the VBUS line, or due to the\r
                                                                      *   AVR's power source being unable to supply sufficient\r
                                                                      *   current.\r
                                                                      */\r
                        };\r
                        \r
                                                                      *   too much current from the VBUS line, or due to the\r
                                                                      *   AVR's power source being unable to supply sufficient\r
                                                                      *   current.\r
                                                                      */\r
                        };\r
                        \r

-                       /** Enum for the error codes for the USB_DeviceEnumerationFailed event.\r
+                       /** Enum for the error codes for the \ref USB_DeviceEnumerationFailed event.\r

                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        enum USB_Host_EnumerationErrorCodes_t\r
                        {\r
                                HOST_ENUMERROR_NoError          = 0, /**< No error occurred. Used internally, this is not a valid\r
                         *\r
                         *  \see Events.h for more information on this event.\r
                         */\r
                        enum USB_Host_EnumerationErrorCodes_t\r
                        {\r
                                HOST_ENUMERROR_NoError          = 0, /**< No error occurred. Used internally, this is not a valid\r

-                                                                     *   ErrorCode parameter value for the USB_DeviceEnumerationFailed\r
+                                                                     *   ErrorCode parameter value for the \ref USB_DeviceEnumerationFailed\r

                                                                      *   event.\r
                                                                      */\r
                                HOST_ENUMERROR_WaitStage        = 1, /**< One of the delays between enumeration steps failed\r
                                                                      *   event.\r
                                                                      */\r
                                HOST_ENUMERROR_WaitStage        = 1, /**< One of the delays between enumeration steps failed\r

diff --git a/LUFA/Drivers/USB/LowLevel/HostChapter9.h b/LUFA/Drivers/USB/LowLevel/HostChapter9.h
index cbb5ba5..1e3f7b2 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/HostChapter9.h
+++ b/LUFA/Drivers/USB/LowLevel/HostChapter9.h
@@ -46,7 +46,7 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Enums: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Enums: */\r

-                       /** Enum for the USB_Host_SendControlRequest() return code, indicating the reason for the error\r
+                       /** Enum for the \ref USB_Host_SendControlRequest() return code, indicating the reason for the error\r

                         *  if the transfer of the request is unsuccessful.\r
                         *\r
                         *  \ingroup Group_PipeControlReq\r
                         *  if the transfer of the request is unsuccessful.\r
                         *\r
                         *  \ingroup Group_PipeControlReq\r


@@ -65,7 +65,7 @@
                        };\r
                        \r
                /* Function Prototypes: */\r
                        };\r
                        \r
                /* Function Prototypes: */\r

-                       /** Sends the request stored in the USB_ControlRequest global structure to the attached device,\r
+                       /** Sends the request stored in the \ref USB_ControlRequest global structure to the attached device,\r

                         *  and transfers the data stored in the buffer to the device, or from the device to the buffer\r
                         *  as requested. The transfer is made on the currently selected pipe.\r
                         *\r
                         *  and transfers the data stored in the buffer to the device, or from the device to the buffer\r
                         *  as requested. The transfer is made on the currently selected pipe.\r
                         *\r


@@ -74,7 +74,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the USB_Host_SendControlErrorCodes_t enum to indicate the result.\r
+                        *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.\r

                         */\r
                        uint8_t USB_Host_SendControlRequest(void* BufferPtr);\r
                        \r
                         */\r
                        uint8_t USB_Host_SendControlRequest(void* BufferPtr);\r
                        \r

diff --git a/LUFA/Drivers/USB/LowLevel/LowLevel.h b/LUFA/Drivers/USB/LowLevel/LowLevel.h
index 5c474df..3bf4137 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/LowLevel.h
+++ b/LUFA/Drivers/USB/LowLevel/LowLevel.h
@@ -102,18 +102,18 @@
                \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
                \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r

-                       /** Mode mask for the USB_CurrentMode global. This indicates that the USB interface is currently not\r
+                       /** Mode mask for the \ref USB_CurrentMode global. This indicates that the USB interface is currently not\r

                         *  initialized into any mode.\r
                         */\r
                        #define USB_MODE_NONE                      0\r
 \r
                         *  initialized into any mode.\r
                         */\r
                        #define USB_MODE_NONE                      0\r
 \r

-                       /** Mode mask for the USB_CurrentMode global and the USB_Init() function. This indicates that the\r
+                       /** Mode mask for the \ref USB_CurrentMode global and the \ref USB_Init() function. This indicates that the\r

                         *  USB interface is or should be initialized in the USB device mode.\r
                         */\r
                        #define USB_MODE_DEVICE                    1\r
 \r
                        #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)\r
                         *  USB interface is or should be initialized in the USB device mode.\r
                         */\r
                        #define USB_MODE_DEVICE                    1\r
 \r
                        #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)\r

-                               /** Mode mask for the USB_CurrentMode global and the USB_Init() function. This indicates that the\r
+                               /** Mode mask for the \ref USB_CurrentMode global and the \ref USB_Init() function. This indicates that the\r

                                 *  USB interface is or should be initialized in the USB host mode.\r
                                 *\r
                                 *  \note This token is not available on AVR models which do not support host mode.\r
                                 *  USB interface is or should be initialized in the USB host mode.\r
                                 *\r
                                 *  \note This token is not available on AVR models which do not support host mode.\r


@@ -122,7 +122,7 @@
                        #endif\r
                        \r
                        #if defined(USB_CAN_BE_BOTH) || defined(__DOXYGEN__)\r
                        #endif\r
                        \r
                        #if defined(USB_CAN_BE_BOTH) || defined(__DOXYGEN__)\r

-                               /** Mode mask for the the USB_Init() function. This indicates that the USB interface should be\r
+                               /** Mode mask for the the \ref USB_Init() function. This indicates that the USB interface should be\r

                                 *  initialized into whatever mode the UID pin of the USB AVR indicates, and that the device\r
                                 *  should swap over its mode when the level of the UID pin changes during operation.\r
                                 *\r
                                 *  initialized into whatever mode the UID pin of the USB AVR indicates, and that the device\r
                                 *  should swap over its mode when the level of the UID pin changes during operation.\r
                                 *\r


@@ -131,27 +131,27 @@
                                #define USB_MODE_UID                       3\r
                        #endif\r
                        \r
                                #define USB_MODE_UID                       3\r
                        #endif\r
                        \r

-                       /** Regulator disable option mask for USB_Init(). This indicates that the internal 3.3V USB data pad\r
+                       /** Regulator disable option mask for \ref USB_Init(). This indicates that the internal 3.3V USB data pad\r

                         *  regulator should be enabled to regulate the data pin voltages to within the USB standard.\r
                         *\r
                         *  \note See USB AVR data sheet for more information on the internal pad regulator.\r
                         */\r
                        #define USB_OPT_REG_DISABLED               (1 << 1)\r
 \r
                         *  regulator should be enabled to regulate the data pin voltages to within the USB standard.\r
                         *\r
                         *  \note See USB AVR data sheet for more information on the internal pad regulator.\r
                         */\r
                        #define USB_OPT_REG_DISABLED               (1 << 1)\r
 \r

-                       /** Regulator enable option mask for USB_Init(). This indicates that the internal 3.3V USB data pad\r
+                       /** Regulator enable option mask for \ref USB_Init(). This indicates that the internal 3.3V USB data pad\r

                         *  regulator should be disabled and the AVR's VCC level used for the data pads.\r
                         *\r
                         *  \note See USB AVR data sheet for more information on the internal pad regulator.\r
                         */\r
                        #define USB_OPT_REG_ENABLED                (0 << 1)\r
                        \r
                         *  regulator should be disabled and the AVR's VCC level used for the data pads.\r
                         *\r
                         *  \note See USB AVR data sheet for more information on the internal pad regulator.\r
                         */\r
                        #define USB_OPT_REG_ENABLED                (0 << 1)\r
                        \r

-                       /** Manual PLL control option mask for USB_Init(). This indicates to the library that the user application\r
+                       /** Manual PLL control option mask for \ref USB_Init(). This indicates to the library that the user application\r

                         *  will take full responsibility for controlling the AVR's PLL (used to generate the high frequency clock\r
                         *  that the USB controller requires) and ensuring that it is locked at the correct frequency for USB operations.\r
                         */\r
                        #define USB_OPT_MANUAL_PLL                 (1 << 2)\r
 \r
                         *  will take full responsibility for controlling the AVR's PLL (used to generate the high frequency clock\r
                         *  that the USB controller requires) and ensuring that it is locked at the correct frequency for USB operations.\r
                         */\r
                        #define USB_OPT_MANUAL_PLL                 (1 << 2)\r
 \r

-                       /** Automatic PLL control option mask for USB_Init(). This indicates to the library that the library should\r
+                       /** Automatic PLL control option mask for \ref USB_Init(). This indicates to the library that the library should\r

                         *  take full responsibility for controlling the AVR's PLL (used to generate the high frequency clock\r
                         *  that the USB controller requires) and ensuring that it is locked at the correct frequency for USB operations.\r
                         */\r
                         *  take full responsibility for controlling the AVR's PLL (used to generate the high frequency clock\r
                         *  that the USB controller requires) and ensuring that it is locked at the correct frequency for USB operations.\r
                         */\r


@@ -192,7 +192,7 @@
 \r
                        /** Detaches the device from the USB bus. This has the effect of removing the device from any\r
                         *  host if, ceasing USB communications. If no host is present, this prevents any host from\r
 \r
                        /** Detaches the device from the USB bus. This has the effect of removing the device from any\r
                         *  host if, ceasing USB communications. If no host is present, this prevents any host from\r

-                        *  enumerating the device once attached until USB_Attach() is called.\r
+                        *  enumerating the device once attached until \ref USB_Attach() is called.\r

                         */\r
                        #define USB_Detach()                    MACROS{ UDCON  |=  (1 << DETACH);  }MACROE\r
 \r
                         */\r
                        #define USB_Detach()                    MACROS{ UDCON  |=  (1 << DETACH);  }MACROE\r
 \r


@@ -212,7 +212,7 @@
                                 *  is not received or acknowledged within this time period, the stream function will fail.\r
                                 *\r
                                 *  This value may be overridden in the user project makefile as the value of the \r
                                 *  is not received or acknowledged within this time period, the stream function will fail.\r
                                 *\r
                                 *  This value may be overridden in the user project makefile as the value of the \r

-                                *  USB_STREAM_TIMEOUT_MS token, and passed to the compiler using the -D switch.\r
+                                *  \ref USB_STREAM_TIMEOUT_MS token, and passed to the compiler using the -D switch.\r

                                 */\r
                                #define USB_STREAM_TIMEOUT_MS       100\r
                        #endif\r
                                 */\r
                                #define USB_STREAM_TIMEOUT_MS       100\r
                        #endif\r


@@ -229,7 +229,7 @@
                         *  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
                         *  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 USB_MODE_DEVICE, USB_MODE_HOST or USB_MODE_UID.\r
+                        *                  Valid mode masks are \ref USB_MODE_DEVICE, \ref USB_MODE_HOST or \ref USB_MODE_UID.\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
                         *\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


@@ -272,7 +272,7 @@
                        \r
                        /** Shuts down the USB interface. This turns off the USB interface after deallocating all USB FIFO\r
                         *  memory, endpoints and pipes. When turned off, no USB functionality can be used until the interface\r
                        \r
                        /** Shuts down the USB interface. This turns off the USB interface after deallocating all USB FIFO\r
                         *  memory, endpoints and pipes. When turned off, no USB functionality can be used until the interface\r

-                        *  is restarted with the USB_Init() function.\r
+                        *  is restarted with the \ref USB_Init() function.\r

                         */\r
                        void USB_ShutDown(void);\r
 \r
                         */\r
                        void USB_ShutDown(void);\r
 \r


@@ -283,11 +283,11 @@
 \r
                /* Enums: */\r
                        /** Enum for error codes relating to the powering on of the USB interface. These error codes are\r
 \r
                /* Enums: */\r
                        /** Enum for error codes relating to the powering on of the USB interface. These error codes are\r

-                        *  used in the ErrorCode parameter value of the USB_PowerOnFail event.\r
+                        *  used in the ErrorCode parameter value of the \ref USB_PowerOnFail event.\r

                         */\r
                        enum USB_PowerOnErrorCodes_t\r
                        {\r
                         */\r
                        enum USB_PowerOnErrorCodes_t\r
                        {\r

-                               POWERON_ERROR_NoUSBModeSpecified       = 0, /**< Indicates that USB_Init() was called with an\r
+                               POWERON_ERROR_NoUSBModeSpecified       = 0, /**< Indicates that \ref USB_Init() was called with an\r

                                                                         *   invalid or missing Mode parameter.\r
                                                                         */\r
                        };\r
                                                                         *   invalid or missing Mode parameter.\r
                                                                         */\r
                        };\r


@@ -305,7 +305,7 @@
                        \r
                        #if !defined(USE_STATIC_OPTIONS) || defined(__DOXYGEN__)\r
                                extern volatile uint8_t USB_Options;\r
                        \r
                        #if !defined(USE_STATIC_OPTIONS) || defined(__DOXYGEN__)\r
                                extern volatile uint8_t USB_Options;\r

-                               /** Indicates the current USB options that the USB interface was initialized with when USB_Init()\r
+                               /** Indicates the current USB options that the USB interface was initialized with when \ref USB_Init()\r

                                 *  was called. This value will be one of the USB_MODE_* masks defined elsewhere in this module.\r
                                 *\r
                                 *  \note This variable should be treated as read-only in the user application, and never manually\r
                                 *  was called. This value will be one of the USB_MODE_* masks defined elsewhere in this module.\r
                                 *\r
                                 *  \note This variable should be treated as read-only in the user application, and never manually\r


@@ -314,7 +314,7 @@
                        #endif\r
 \r
                /* Throwable Events: */\r
                        #endif\r
 \r
                /* Throwable Events: */\r

-                       /** This module raises the USB_Disconnect event if the USB interface is reset (such as during a mode\r
+                       /** This module raises the \ref USB_Disconnect event if the USB interface is reset (such as during a mode\r

                         *  change while in UID mode) while the USB interface is connected to a device when in host mode, or\r
                         *  a host while in device mode.\r
                         *\r
                         *  change while in UID mode) while the USB interface is connected to a device when in host mode, or\r
                         *  a host while in device mode.\r
                         *\r

diff --git a/LUFA/Drivers/USB/LowLevel/OTG.h b/LUFA/Drivers/USB/LowLevel/OTG.h
index 1f59e0c..8defff7 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 USB_OTG_SRP_VBUS or USB_OTG_STP_DATA.\r
+                                *  \param 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_Initiate_SRP(uint8_t SRPTypeMask);\r
                        #else\r
                                 */\r
                                static inline void USB_OTG_DEV_Initiate_SRP(uint8_t SRPTypeMask);\r
                        #else\r


@@ -115,7 +115,7 @@
                                \r
                                #define USB_OTG_HOST_Accept_HNP()          MACROS{ OTGCON |=  (1 << HNPREQ); }MACROE\r
 \r
                                \r
                                #define USB_OTG_HOST_Accept_HNP()          MACROS{ OTGCON |=  (1 << HNPREQ); }MACROE\r
 \r

-                               #define USB_OTG_HOST_Reject_HNP()         MACROS{ OTGCON &= ~(1 << HNPREQ); }MACROE\r
+                               #define USB_OTG_HOST_Reject_HNP()          MACROS{ OTGCON &= ~(1 << HNPREQ); }MACROE\r

                                \r
                                #define USB_OTG_HOST_IsHNPReceived()             ((OTGCON &   (1 << HNPREQ)) ? true : false)\r
                                \r
                                \r
                                #define USB_OTG_HOST_IsHNPReceived()             ((OTGCON &   (1 << HNPREQ)) ? true : false)\r
                                \r

diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.h b/LUFA/Drivers/USB/LowLevel/Pipe.h
index 25121ca..748dc59 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Pipe.h
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.h
@@ -77,43 +77,43 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a CRC error occurred in the pipe on the received data. */\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a CRC error occurred in the pipe on the received data. */\r

                        #define PIPE_ERRORFLAG_CRC16            (1 << 4)\r
 \r
                        #define PIPE_ERRORFLAG_CRC16            (1 << 4)\r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware timeout error occurred in the pipe. */\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware timeout error occurred in the pipe. */\r

                        #define PIPE_ERRORFLAG_TIMEOUT          (1 << 3)\r
 \r
                        #define PIPE_ERRORFLAG_TIMEOUT          (1 << 3)\r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware PID error occurred in the pipe. */\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware PID error occurred in the pipe. */\r

                        #define PIPE_ERRORFLAG_PID              (1 << 2)\r
 \r
                        #define PIPE_ERRORFLAG_PID              (1 << 2)\r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware data PID error occurred in the pipe. */\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware data PID error occurred in the pipe. */\r

                        #define PIPE_ERRORFLAG_DATAPID          (1 << 1)\r
 \r
                        #define PIPE_ERRORFLAG_DATAPID          (1 << 1)\r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware data toggle error occurred in the pipe. */\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware data toggle error occurred in the pipe. */\r

                        #define PIPE_ERRORFLAG_DATATGL          (1 << 0)\r
 \r
                        #define PIPE_ERRORFLAG_DATATGL          (1 << 0)\r
 \r

-                       /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a SETUP token (for CONTROL type pipes),\r
+                       /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a SETUP token (for CONTROL type pipes),\r

                         *  which will trigger a control request on the attached device when data is written to the pipe.\r
                         */\r
                        #define PIPE_TOKEN_SETUP                (0 << PTOKEN0)\r
 \r
                         *  which will trigger a control request on the attached device when data is written to the pipe.\r
                         */\r
                        #define PIPE_TOKEN_SETUP                (0 << PTOKEN0)\r
 \r

-                       /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
+                       /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r

                         *  indicating that the pipe data will flow from device to host.\r
                         */\r
                        #define PIPE_TOKEN_IN                   (1 << PTOKEN0)\r
 \r
                         *  indicating that the pipe data will flow from device to host.\r
                         */\r
                        #define PIPE_TOKEN_IN                   (1 << PTOKEN0)\r
 \r

-                       /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
+                       /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r

                         *  indicating that the pipe data will flow from host to device.\r
                         */\r
                        #define PIPE_TOKEN_OUT                  (2 << PTOKEN0)\r
 \r
                         *  indicating that the pipe data will flow from host to device.\r
                         */\r
                        #define PIPE_TOKEN_OUT                  (2 << PTOKEN0)\r
 \r

-                       /** Mask for the bank mode selection for the Pipe_ConfigurePipe() macro. This indicates that the pipe\r
+                       /** Mask for the bank mode selection for the \ref Pipe_ConfigurePipe() macro. This indicates that the pipe\r

                         *  should have one single bank, which requires less USB FIFO memory but results in slower transfers as\r
                         *  only one USB device (the AVR or the attached device) can access the pipe's bank at the one time.\r
                         */\r
                        #define PIPE_BANK_SINGLE                (0 << EPBK0)\r
 \r
                         *  should have one single bank, which requires less USB FIFO memory but results in slower transfers as\r
                         *  only one USB device (the AVR or the attached device) can access the pipe's bank at the one time.\r
                         */\r
                        #define PIPE_BANK_SINGLE                (0 << EPBK0)\r
 \r

-                       /** Mask for the bank mode selection for the Pipe_ConfigurePipe() macro. This indicates that the pipe\r
+                       /** Mask for the bank mode selection for the \ref Pipe_ConfigurePipe() macro. This indicates that the pipe\r

                         *  should have two banks, which requires more USB FIFO memory but results in faster transfers as one\r
                         *  USB device (the AVR or the attached device) can access one bank while the other accesses the second\r
                         *  bank.\r
                         *  should have two banks, which requires more USB FIFO memory but results in faster transfers as one\r
                         *  USB device (the AVR or the attached device) can access one bank while the other accesses the second\r
                         *  bank.\r


@@ -168,7 +168,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define PIPE_INT_IN                     UPIENX, (1 << RXINE) , UPINTX, (1 << RXINI)\r
 \r
                         */\r
                        #define PIPE_INT_IN                     UPIENX, (1 << RXINE) , UPINTX, (1 << RXINI)\r
 \r


@@ -182,7 +182,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define PIPE_INT_OUT                   UPIENX, (1 << TXOUTE), UPINTX, (1 << TXOUTI)\r
 \r
                         */\r
                        #define PIPE_INT_OUT                   UPIENX, (1 << TXOUTE), UPINTX, (1 << TXOUTI)\r
 \r


@@ -195,7 +195,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define PIPE_INT_SETUP                 UPIENX, (1 << TXSTPE) , UPINTX, (1 << TXSTPI)\r
 \r
                         */\r
                        #define PIPE_INT_SETUP                 UPIENX, (1 << TXSTPE) , UPINTX, (1 << TXSTPI)\r
 \r


@@ -208,9 +208,9 @@
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         *\r
                         *\r

-                        *  \see Pipe_GetErrorFlags() for more information on the pipe errors.\r
+                        *  \see \ref Pipe_GetErrorFlags() for more information on the pipe errors.\r

                         */\r
                        #define PIPE_INT_ERROR                 UPIENX, (1 << PERRE), UPINTX, (1 << PERRI)\r
 \r
                         */\r
                        #define PIPE_INT_ERROR                 UPIENX, (1 << PERRE), UPINTX, (1 << PERRI)\r
 \r


@@ -223,9 +223,9 @@
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         *\r
                         *\r

-                        *  \see Pipe_IsNAKReceived() for more information on pipe NAKs.\r
+                        *  \see \ref Pipe_IsNAKReceived() for more information on pipe NAKs.\r

                         */\r
                        #define PIPE_INT_NAK                   UPIENX, (1 << NAKEDE), UPINTX, (1 << NAKEDI)\r
 \r
                         */\r
                        #define PIPE_INT_NAK                   UPIENX, (1 << NAKEDE), UPINTX, (1 << NAKEDI)\r
 \r


@@ -238,7 +238,7 @@
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r
                         *  \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
                         *        is selected), and will fire the common pipe interrupt vector.\r
                         *\r

-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
+                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r

                         */\r
                        #define PIPE_INT_STALL                 UPIENX, (1 << RXSTALLE), UPINTX, (1 << RXSTALLI)\r
 \r
                         */\r
                        #define PIPE_INT_STALL                 UPIENX, (1 << RXSTALLE), UPINTX, (1 << RXSTALLI)\r
 \r


@@ -278,8 +278,7 @@
                                /** Enables the currently selected pipe so that data can be sent and received through it to and from\r
                                 *  an attached device.\r
                                 *\r
                                /** Enables the currently selected pipe so that data can be sent and received through it to and from\r
                                 *  an attached device.\r
                                 *\r

-                                *  \note Pipes must first be configured properly rather than just being enabled via the\r
-                                *        Pipe_ConfigurePipe() macro, which calls Pipe_EnablePipe() automatically.\r
+                                *  \note Pipes must first be configured properly via \ref Pipe_ConfigurePipe().\r

                                 */\r
                                static inline void Pipe_EnablePipe(void);\r
 \r
                                 */\r
                                static inline void Pipe_EnablePipe(void);\r
 \r


@@ -365,7 +364,7 @@
                                /** Determines if the master pipe error flag is set for the currently selected pipe, indicating that\r
                                 *  some sort of hardware error has occurred on the pipe.\r
                                 *\r
                                /** Determines if the master pipe error flag is set for the currently selected pipe, indicating that\r
                                 *  some sort of hardware error has occurred on the pipe.\r
                                 *\r

-                                *  \see Pipe_GetErrorFlags() macro for information on retrieving the exact error flag.\r
+                                *  \see \ref Pipe_GetErrorFlags() macro for information on retrieving the exact error flag.\r

                                 *\r
                                 *  \return Boolean true if an error has occurred on the selected pipe, false otherwise\r
                                 */\r
                                 *\r
                                 *  \return Boolean true if an error has occurred on the selected pipe, false otherwise\r
                                 */\r


@@ -445,7 +444,7 @@
                                /** Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on\r
                                 *  the currently selected pipe. This occurs when the host sends a packet to the device, but the device\r
                                 *  is not currently ready to handle the packet (i.e. its endpoint banks are full). Once a NAK has been\r
                                /** Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on\r
                                 *  the currently selected pipe. This occurs when the host sends a packet to the device, but the device\r
                                 *  is not currently ready to handle the packet (i.e. its endpoint banks are full). Once a NAK has been\r

-                                *  received, it must be cleared using Pipe_ClearNAKReceived() before the previous (or any other) packet\r
+                                *  received, it must be cleared using \ref Pipe_ClearNAKReceived() before the previous (or any other) packet\r

                                 *  can be re-sent.\r
                                 *\r
                                 *  \ingroup Group_PipePacketManagement\r
                                 *  can be re-sent.\r
                                 *\r
                                 *  \ingroup Group_PipePacketManagement\r


@@ -458,7 +457,7 @@
                                 *\r
                                 *  \ingroup Group_PipePacketManagement\r
                                 *\r
                                 *\r
                                 *  \ingroup Group_PipePacketManagement\r
                                 *\r

-                                *  \see Pipe_IsNAKReceived() for more details.\r
+                                *  \see \ref Pipe_IsNAKReceived() for more details.\r

                                 */\r
                                static inline void Pipe_ClearNAKReceived(void);\r
                                 \r
                                 */\r
                                static inline void Pipe_ClearNAKReceived(void);\r
                                 \r


@@ -559,7 +558,7 @@
                                PIPE_READYWAIT_DeviceDisconnected      = 2,     /**< Device was disconnected from the host while waiting. */\r
                                PIPE_READYWAIT_Timeout                 = 3, /**< The device failed to accept or send the next packet\r
                                                                             *   within the software timeout period set by the\r
                                PIPE_READYWAIT_DeviceDisconnected      = 2,     /**< Device was disconnected from the host while waiting. */\r
                                PIPE_READYWAIT_Timeout                 = 3, /**< The device failed to accept or send the next packet\r
                                                                             *   within the software timeout period set by the\r

-                                                                            *   USB_STREAM_TIMEOUT_MS macro.\r
+                                                                            *   \ref USB_STREAM_TIMEOUT_MS macro.\r

                                                                             */\r
                        };\r
 \r
                                                                             */\r
                        };\r
 \r


@@ -576,7 +575,7 @@
                                                                         */             \r
                                PIPE_RWSTREAM_ERROR_Timeout            = 3, /**< The device failed to accept or send the next packet\r
                                                                             *   within the software timeout period set by the\r
                                                                         */             \r
                                PIPE_RWSTREAM_ERROR_Timeout            = 3, /**< The device failed to accept or send the next packet\r
                                                                             *   within the software timeout period set by the\r

-                                                                            *   USB_STREAM_TIMEOUT_MS macro.\r
+                                                                            *   \ref USB_STREAM_TIMEOUT_MS macro.\r

                                                                             */\r
                                PIPE_RWSTREAM_ERROR_CallbackAborted    = 4, /**< Indicates that the stream's callback function aborted\r
                                                                         *   the transfer early.\r
                                                                             */\r
                                PIPE_RWSTREAM_ERROR_CallbackAborted    = 4, /**< Indicates that the stream's callback function aborted\r
                                                                         *   the transfer early.\r


@@ -811,9 +810,9 @@
                         *  numbers can handle different maximum packet sizes - refer to the chosen USB AVR's datasheet to\r
                         *  determine the maximum bank size for each pipe.\r
                         *\r
                         *  numbers can handle different maximum packet sizes - refer to the chosen USB AVR's datasheet to\r
                         *  determine the maximum bank size for each pipe.\r
                         *\r

-                        *  The banking mode may be either PIPE_BANK_SINGLE or PIPE_BANK_DOUBLE.\r
+                        *  The banking mode may be either \ref PIPE_BANK_SINGLE or \ref PIPE_BANK_DOUBLE.\r

                         *\r
                         *\r

-                        *  A newly configured pipe is frozen by default, and must be unfrozen before use via the Pipe_Unfreeze() macro.\r
+                        *  A newly configured pipe is frozen by default, and must be unfrozen before use via the \ref Pipe_Unfreeze() macro.\r

                         *\r
                         *  \note This routine will select the specified pipe, and the pipe will remain selected once the\r
                         *        routine completes regardless of if the pipe configuration succeeds.\r
                         *\r
                         *  \note This routine will select the specified pipe, and the pipe will remain selected once the\r
                         *        routine completes regardless of if the pipe configuration succeeds.\r


@@ -835,10 +834,10 @@
                        /** Writes the given number of bytes to the pipe from the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Writes the given number of bytes to the pipe from the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -848,7 +847,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Write_Stream_LE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Write_Stream_LE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -859,10 +858,10 @@
                        /** Writes the given number of bytes to the pipe from the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Writes the given number of bytes to the pipe from the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -872,7 +871,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Write_Stream_BE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Write_Stream_BE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -882,11 +881,11 @@
 \r
                        /** Reads and discards the given number of bytes from the pipe, discarding fully read packets from the host\r
                         *  as needed. The last packet is not automatically discarded once the remaining bytes has been read; the\r
 \r
                        /** Reads and discards the given number of bytes from the pipe, discarding fully read packets from the host\r
                         *  as needed. The last packet is not automatically discarded once the remaining bytes has been read; the\r

-                        *  user is responsible for manually discarding the last packet from the device via the Pipe_ClearIN() macro.\r
+                        *  user is responsible for manually discarding the last packet from the device via the \ref Pipe_ClearIN() macro.\r

                         *  Between each USB packet, the given stream callback function is executed repeatedly until the next packet is ready,\r
                         *  allowing for early aborts of stream transfers.\r
                         *\r
                         *  Between each USB packet, the given stream callback function is executed repeatedly until the next packet is ready,\r
                         *  allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -895,7 +894,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Discard_Stream(uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Discard_Stream(uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -906,10 +905,10 @@
                        /** Reads the given number of bytes from the pipe into the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Reads the given number of bytes from the pipe into the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -919,7 +918,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r


@@ -930,10 +929,10 @@
                        /** Reads the given number of bytes from the pipe into the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Reads the given number of bytes from the pipe into the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
+                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r

                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r
                         *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
                         *  and this function has the Callback parameter omitted.\r
                         *\r


@@ -943,7 +942,7 @@
                         *  \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
                         *\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
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r

diff --git a/LUFA/VIDAndPIDValues.txt b/LUFA/VIDAndPIDValues.txt
index de0896d..441875c 100644 (file)
--- a/LUFA/VIDAndPIDValues.txt
+++ b/LUFA/VIDAndPIDValues.txt
@@ -220,5 +220,197 @@
  *    </td>\r
  *   </tr>\r
  *\r
  *    </td>\r
  *   </tr>\r
  *\r

+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2060\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2061\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2062\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2063\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2064\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2065\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2066\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2067\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2068\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x2069\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x206A\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x206B\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x206C\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x206D\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x206E\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r
+ *   <tr>\r
+ *    <td>\r
+ *     0x03EB\r
+ *    </td>\r
+ *    <td>\r
+ *     0x206F\r
+ *    </td>\r
+ *    <td>\r
+ *     <i>Currently Unallocated</i>\r
+ *    </td>\r
+ *   </tr>\r
+ *\r

  *  </table>\r
  */\r
  *  </table>\r
  */\r