*/
#define ATTR_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
- /** Indicates that the specified parameters of the function are pointers which should never be NULL.
+ /** Indicates that the specified parameters of the function are pointers which should never be \c NULL.
* When applied as a 1-based comma separated list the compiler will emit a warning if the specified
- * parameters are known at compiler time to be NULL at the point of calling the function.
+ * parameters are known at compiler time to be \c NULL at the point of calling the function.
*/
#define ATTR_NON_NULL_PTR_ARG(...) __attribute__ ((nonnull (__VA_ARGS__)))
#define BOARD_ATAVRUSBRF01 4
/** Selects the user-defined board drivers, which should be placed in the user project's folder
- * under a directory named /Board/. Each board driver should be named identically to the LUFA
- * master board driver (i.e., driver in the LUFA/Drivers/Board director) so that the library
+ * under a directory named \c /Board/. Each board driver should be named identically to the LUFA
+ * master board driver (i.e., driver in the \c LUFA/Drivers/Board directory) so that the library
* can correctly identify it.
*/
#define BOARD_USER 5
* \brief Common library convenience macros and functions.
*
* This file contains macros which are common to all library elements, and which may be useful in user code. It
- * also includes other common headers, such as Atomic.h, Attributes.h and BoardTypes.h.
+ * also includes other common code headers.
*/
/** @defgroup Group_Common Common Utility Headers - LUFA/Drivers/Common/Common.h
/** Macro for encasing other multi-statement macros. This should be used along with an opening brace
* before the start of any multi-statement macro, so that the macros contents as a whole are treated
* as a discrete block and not as a list of separate statements which may cause problems when used as
- * a block (such as inline IF statements).
+ * a block (such as inline \c if statements).
*/
#define MACROS do
/** Macro for encasing other multi-statement macros. This should be used along with a preceding closing
* brace at the end of any multi-statement macro, so that the macros contents as a whole are treated
* as a discrete block and not as a list of separate statements which may cause problems when used as
- * a block (such as inline IF statements).
+ * a block (such as inline \c if statements).
*/
#define MACROE while (0)
- /** Defines a volatile NOP statement which cannot be optimized out by the compiler, and thus can always
+ /** Defines a volatile \c NOP statement which cannot be optimized out by the compiler, and thus can always
* be set as a breakpoint in the resulting code. Useful for debugging purposes, where the optimiser
* removes/reorders code to the point where break points cannot reliably be set.
*
*/
#define JTAG_DEBUG_POINT() __asm__ __volatile__ ("NOP" ::)
- /** Defines an explicit JTAG break point in the resulting binary via the ASM BREAK statement. When
+ /** Defines an explicit JTAG break point in the resulting binary via the assembly \c BREAK statement. When
* a JTAG is used, this causes the program execution to halt when reached until manually resumed.
*
* \ingroup Group_Debugging
*/
#define JTAG_DEBUG_BREAK() __asm__ __volatile__ ("BREAK" ::)
- /** Macro for testing condition "x" and breaking via JTAG_DEBUG_BREAK() if the condition is false.
+ /** Macro for testing condition "x" and breaking via \ref JTAG_DEBUG_BREAK() if the condition is false.
*
* \param[in] Condition Condition that will be evaluated,
*
*/
#define JTAG_DEBUG_ASSERT(Condition) MACROS{ if (!(Condition)) { JTAG_DEBUG_BREAK(); } }MACROE
- /** Macro for testing condition "x" and writing debug data to the stdout stream if false. The stdout stream
+ /** Macro for testing condition "x" and writing debug data to the stdout stream if \c false. The stdout stream
* must be pre-initialized before this macro is run and linked to an output device, such as the AVR's USART
* peripheral.
*
/** Forces GCC to use pointer indirection (via the AVR's pointer register pairs) when accessing the given
* struct pointer. In some cases GCC will emit non-optimal assembly code when accessing a structure through
- * a pointer, resulting in a larger binary. When this macro is used on a (non-const) structure pointer before
+ * a pointer, resulting in a larger binary. When this macro is used on a (non \c const) structure pointer before
* use, it will force GCC to use pointer indirection on the elements rather than direct store and load
* instructions.
*
#define GCC_FORCE_POINTER_ACCESS(StructPtr) __asm__ __volatile__("" : "=b" (StructPtr) : "0" (StructPtr))
#if !defined(pgm_read_ptr) || defined(__DOXYGEN__)
- /** Reads a pointer out of PROGMEM space. This is currently a wrapper for the avr-libc pgm_read_ptr()
- * macro with a void* cast, so that its value can be assigned directly to a pointer variable or used
+ /** Reads a pointer out of PROGMEM space. This is currently a wrapper for the avr-libc \c pgm_read_ptr()
+ * macro with a \c void* cast, so that its value can be assigned directly to a pointer variable or used
* in pointer arithmetic without further casting in C. In a future avr-libc distribution this will be
* part of the standard API and will be implemented in a more formal manner.
*
* User code should include this file, which will in turn include the correct Button driver header file for the
* currently selected board.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Buttons.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Buttons.h file in the user project
* directory.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*/
/** \ingroup Group_BoardDrivers
* It provides a way to easily configure and check the status of all the buttons on the board so that appropriate
* actions can be taken.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Dataflash.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Dataflash.h file in the user project
* directory. Otherwise, it will include the appropriate built in board driver header file.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*
* \section Sec_ExampleUsage Example Usage
* The following snippet is an example of how this module may be used within a typical
* User code should include this file, which will in turn include the correct dataflash driver header file for
* the currently selected board.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Dataflash.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Dataflash.h file in the user project
* directory.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*/
/** \ingroup Group_BoardDrivers
* Dataflash driver. This module provides an easy to use interface for the Dataflash ICs located on many boards,
* for the storage of large amounts of data into the Dataflash's non-volatile memory.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Dataflash.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Dataflash.h file in the user project
* directory. Otherwise, it will include the appropriate built in board driver header file.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*
* \section Sec_ExampleUsage Example Usage
* The following snippet is an example of how this module may be used within a typical
/** Determines the currently selected dataflash chip.
*
* \return Mask of the currently selected Dataflash chip, either \ref DATAFLASH_NO_CHIP if no chip is selected
- * or a DATAFLASH_CHIPn mask (where n is the chip number).
+ * or a \c DATAFLASH_CHIPn mask (where n is the chip number).
*/
static inline uint8_t Dataflash_GetSelectedChip(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
/** Selects the given dataflash chip.
*
- * \param[in] ChipMask Mask of the Dataflash IC to select, in the form of DATAFLASH_CHIPn mask (where n is
+ * \param[in] ChipMask Mask of the Dataflash IC to select, in the form of \c DATAFLASH_CHIPn mask (where n is
* the chip number).
*/
static inline void Dataflash_SelectChip(const uint8_t ChipMask) ATTR_ALWAYS_INLINE;
/** Selects a dataflash IC from the given page number, which should range from 0 to
* ((DATAFLASH_PAGES * DATAFLASH_TOTALCHIPS) - 1). For boards containing only one
- * dataflash IC, this will select DATAFLASH_CHIP1. If the given page number is outside
+ * dataflash IC, this will select \ref DATAFLASH_CHIP1. If the given page number is outside
* the total number of pages contained in the boards dataflash ICs, all dataflash ICs
* are deselected.
*
* User code should include this file, which will in turn include the correct joystick driver header file for the
* currently selected board.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Joystick.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Joystick.h file in the user project
* directory.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*/
/** \ingroup Group_BoardDrivers
* Hardware Joystick driver. This module provides an easy to use interface to control the hardware digital Joystick
* located on many boards.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Dataflash.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Dataflash.h file in the user project
* directory. Otherwise, it will include the appropriate built in board driver header file.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*
* \section Sec_ExampleUsage Example Usage
* The following snippet is an example of how this module may be used within a typical
* User code should include this file, which will in turn include the correct LED driver header file for the
* currently selected board.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/LEDs.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/LEDs.h file in the user project
* directory.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*/
/** \ingroup Group_BoardDrivers
* Hardware LEDs driver. This provides an easy to use driver for the hardware LEDs present on many boards. It
* provides an interface to configure, test and change the status of all the board LEDs.
*
- * If the BOARD value is set to BOARD_USER, this will include the /Board/Dataflash.h file in the user project
+ * If the \c BOARD value is set to \c BOARD_USER, this will include the \c /Board/Dataflash.h file in the user project
* directory. Otherwise, it will include the appropriate built in board driver header file. If the BOARD value
- * is set to BOARD_NONE, this driver is silently disabled.
+ * is set to \c BOARD_NONE, this driver is silently disabled.
*
- * For possible BOARD makefile values, see \ref Group_BoardTypes.
+ * For possible \c BOARD makefile values, see \ref Group_BoardTypes.
*
* \note To make code as compatible as possible, it is assumed that all boards carry a minimum of four LEDs. If
* a board contains less than four LEDs, the remaining LED masks are defined to 0 so as to have no effect.
*\r
* \param[in,out] Buffer Pointer to a ring buffer structure to insert into.\r
*\r
- * \return Boolean true if the buffer contains no free space, false otherwise.\r
+ * \return Boolean \c true if the buffer contains no free space, false otherwise.\r
*/\r
static inline bool RingBuffer_IsFull(RingBuffer_t* const Buffer)\r
{\r
*\r
* \param[in,out] Buffer Pointer to a ring buffer structure to insert into.\r
*\r
- * \return Boolean true if the buffer contains no free space, false otherwise.\r
+ * \return Boolean \c true if the buffer contains no free space, false otherwise.\r
*/\r
static inline bool RingBuffer_IsEmpty(RingBuffer_t* const Buffer)\r
{\r
* \section Sec_ModDescription Module Description
* Escape code macros for ANSI compliant text terminals.
*
- * \note If desired, the macro DISABLE_TERMINAL_CODES can be defined in the project makefile and passed to the GCC
+ * \note If desired, the macro \c DISABLE_TERMINAL_CODES can be defined in the project makefile and passed to the GCC
* compiler via the -D switch to disable the terminal codes without modifying the source, for use with non
* compatible terminals (any terminal codes then equate to empty strings).
*
#if !defined(DISABLE_TERMINAL_CODES)
/** Creates an ANSI escape sequence with the specified payload.
*
- * \param[in] EscapeSeq Payload to encode as an ANSI escape sequence, a ESC_* mask.
+ * \param[in] EscapeSeq Payload to encode as an ANSI escape sequence, a \c ESC_* mask.
*/
#define ANSI_ESCAPE_SEQUENCE(EscapeSeq) "\33[" EscapeSeq
#else
/** \name ADC Result Adjustment Configuration Masks */
//@{
/** Left-adjusts the 10-bit ADC result, so that the upper 8 bits of the value returned by the
- * ADC_GetResult() macro contain the 8 most significant bits of the result.
+ * \ref ADC_GetResult() macro contain the 8 most significant bits of the result.
*/
#define ADC_LEFT_ADJUSTED (1 << ADLAR)
/** Right-adjusts the 10-bit ADC result, so that the lower 8 bits of the value returned by the
- * ADC_GetResult() macro contain the 8 least significant bits of the result.
+ * \ref ADC_GetResult() macro contain the 8 least significant bits of the result.
*/
#define ADC_RIGHT_ADJUSTED (0 << ADLAR)
//@}
/** \name ADC MUX Masks */
//@{
- /** MUX mask define for the ADC0 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
+ /** MUX mask define for the ADC0 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading(). */
#define ADC_CHANNEL0 (0x00 << MUX0)
- /** MUX mask define for the ADC1 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
+ /** MUX mask define for the ADC1 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading(). */
#define ADC_CHANNEL1 (0x01 << MUX0)
#if !(defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__DOXYGEN__))
- /** MUX mask define for the ADC2 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC2 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL2 (0x02 << MUX0)
- /** MUX mask define for the ADC3 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC3 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL3 (0x03 << MUX0)
#endif
- /** MUX mask define for the ADC4 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
+ /** MUX mask define for the ADC4 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading(). */
#define ADC_CHANNEL4 (0x04 << MUX0)
- /** MUX mask define for the ADC5 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
+ /** MUX mask define for the ADC5 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading(). */
#define ADC_CHANNEL5 (0x05 << MUX0)
- /** MUX mask define for the ADC6 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
+ /** MUX mask define for the ADC6 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading(). */
#define ADC_CHANNEL6 (0x06 << MUX0)
/** MUX mask define for the ADC7 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
#define ADC_CHANNEL7 (0x07 << MUX0)
- /** MUX mask define for the internal 1.1V bandgap channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading. */
+ /** MUX mask define for the internal 1.1V bandgap channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading(). */
#define ADC_1100MV_BANDGAP (0x1E << MUX0)
#if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__DOXYGEN__))
- /** MUX mask define for the ADC8 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC8 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL8 ((1 << 8) | (0x00 << MUX0))
- /** MUX mask define for the ADC9 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC9 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL9 ((1 << 8) | (0x01 << MUX0))
- /** MUX mask define for the ADC10 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC10 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL10 ((1 << 8) | (0x02 << MUX0))
- /** MUX mask define for the ADC11 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC11 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL11 ((1 << 8) | (0x03 << MUX0))
- /** MUX mask define for the ADC12 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC12 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL12 ((1 << 8) | (0x04 << MUX0))
- /** MUX mask define for the ADC13 channel of the ADC. See \ref ADC_StartReading and \ref ADC_GetChannelReading.
+ /** MUX mask define for the ADC13 channel of the ADC. See \ref ADC_StartReading() and \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
#define ADC_CHANNEL13 ((1 << 8) | (0x05 << MUX0))
- /** MUX mask define for the internal temperature sensor channel of the ADC. See \ref ADC_StartReading and
- * \ref ADC_GetChannelReading.
+ /** MUX mask define for the internal temperature sensor channel of the ADC. See \ref ADC_StartReading() and
+ * \ref ADC_GetChannelReading().
*
* \note Not available on all AVR models.
*/
* pin of the AVR, denoted by its special alternative function ADCx.
* \n\n
*
- * \note The channel number must be specified as an integer, and NOT a ADC_CHANNELx mask.
+ * \note The channel number must be specified as an integer, and <b>not</b> a \c ADC_CHANNEL* mask.
*
* \param[in] ChannelIndex ADC channel number to set up for conversions.
*/
* pin of the AVR, denoted by its special alternative function ADCx.
* \n\n
*
- * \note The channel number must be specified as an integer, and NOT a ADC_CHANNELx mask.
+ * \note The channel number must be specified as an integer, and <b>not</b> a \c ADC_CHANNEL* mask.
*
* \param[in] ChannelIndex ADC channel number to set up for conversions.
*/
/** Indicates if the ADC is currently enabled.
*
- * \return Boolean true if the ADC subsystem is currently enabled, false otherwise.
+ * \return Boolean \c true if the ADC subsystem is currently enabled, \c false otherwise.
*/
static inline bool ADC_GetStatus(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool ADC_GetStatus(void)
*
* \param[in] Byte Byte to send to the currently addressed device
*
- * \return Boolean true if the recipient ACKed the byte, false otherwise
+ * \return Boolean \c true if the recipient ACKed the byte, \c false otherwise
*/
static inline bool TWI_SendByte(const uint8_t Byte)
{
* \param[in] Byte Location where the read byte is to be stored
* \param[in] LastByte Indicates if the byte should be ACKed if false, NAKed if true
*
- * \return Boolean true if the byte reception successfully completed, false otherwise
+ * \return Boolean \c true if the byte reception successfully completed, \c false otherwise
*/
static inline bool TWI_ReceiveByte(uint8_t* const Byte,
const bool LastByte)
* \param[in] SlaveAddress Address of the slave TWI device to communicate with
* \param[in] TimeoutMS Timeout period within which the slave must respond, in milliseconds
*
- * \return Boolean true if the device is ready for data, false otherwise
+ * \return Boolean \c true if the device is ready for data, \c false otherwise
*/
bool TWI_StartTransmission(const uint8_t SlaveAddress,
const uint8_t TimeoutMS);
/* Macros: */
/** \name SPI Prescaler Configuration Masks */
//@{
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 2. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 2. */
#define SPI_SPEED_FCPU_DIV_2 SPI_USE_DOUBLESPEED
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 4. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 4. */
#define SPI_SPEED_FCPU_DIV_4 0
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 8. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 8. */
#define SPI_SPEED_FCPU_DIV_8 (SPI_USE_DOUBLESPEED | (1 << SPR0))
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 16. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 16. */
#define SPI_SPEED_FCPU_DIV_16 (1 << SPR0)
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 32. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 32. */
#define SPI_SPEED_FCPU_DIV_32 (SPI_USE_DOUBLESPEED | (1 << SPR1))
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 64. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 64. */
#define SPI_SPEED_FCPU_DIV_64 (SPI_USE_DOUBLESPEED | (1 << SPR1) | (1 << SPR0))
- /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 128. */
+ /** SPI prescaler mask for \c SPI_Init(). Divides the system clock by a factor of 128. */
#define SPI_SPEED_FCPU_DIV_128 ((1 << SPR1) | (1 << SPR0))
//@}
/** \name SPI SCK Polarity Configuration Masks */
//@{
- /** SPI clock polarity mask for SPI_Init(). Indicates that the SCK should lead on the rising edge. */
+ /** SPI clock polarity mask for \c SPI_Init(). Indicates that the SCK should lead on the rising edge. */
#define SPI_SCK_LEAD_RISING (0 << CPOL)
- /** SPI clock polarity mask for SPI_Init(). Indicates that the SCK should lead on the falling edge. */
+ /** SPI clock polarity mask for \c SPI_Init(). Indicates that the SCK should lead on the falling edge. */
#define SPI_SCK_LEAD_FALLING (1 << CPOL)
//@}
/** \name SPI Sample Edge Configuration Masks */
//@{
- /** SPI data sample mode mask for SPI_Init(). Indicates that the data should sampled on the leading edge. */
+ /** SPI data sample mode mask for \c SPI_Init(). Indicates that the data should sampled on the leading edge. */
#define SPI_SAMPLE_LEADING (0 << CPHA)
- /** SPI data sample mode mask for SPI_Init(). Indicates that the data should be sampled on the trailing edge. */
+ /** SPI data sample mode mask for \c SPI_Init(). Indicates that the data should be sampled on the trailing edge. */
#define SPI_SAMPLE_TRAILING (1 << CPHA)
//@}
/** \name SPI Data Ordering Configuration Masks */
//@{
- /** SPI data order mask for SPI_Init(). Indicates that data should be shifted out MSB first. */
+ /** SPI data order mask for \c SPI_Init(). Indicates that data should be shifted out MSB first. */
#define SPI_ORDER_MSB_FIRST (0 << DORD)
- /** SPI data order mask for SPI_Init(). Indicates that data should be shifted out MSB first. */
+ /** SPI data order mask for \c SPI_Init(). Indicates that data should be shifted out MSB first. */
#define SPI_ORDER_LSB_FIRST (1 << DORD)
//@}
/** \name SPI Mode Configuration Masks */
//@{
- /** SPI mode mask for SPI_Init(). Indicates that the SPI interface should be initialized into slave mode. */
+ /** SPI mode mask for \c SPI_Init(). Indicates that the SPI interface should be initialized into slave mode. */
#define SPI_MODE_SLAVE (0 << MSTR)
- /** SPI mode mask for SPI_Init(). Indicates that the SPI interface should be initialized into master mode. */
+ /** SPI mode mask for \c SPI_Init(). Indicates that the SPI interface should be initialized into master mode. */
#define SPI_MODE_MASTER (1 << MSTR)
//@}
/** Initialises the SPI subsystem, ready for transfers. Must be called before calling any other
* SPI routines.
*
- * \param[in] SPIOptions SPI Options, a mask consisting of one of each of the SPI_SPEED_*,
- * SPI_SCK_*, SPI_SAMPLE_*, SPI_ORDER_* and SPI_MODE_* masks.
+ * \param[in] SPIOptions SPI Options, a mask consisting of one of each of the \c SPI_SPEED_*,
+ * \c SPI_SCK_*, \c SPI_SAMPLE_*, \c SPI_ORDER_* and \c SPI_MODE_* masks.
*/
static inline void SPI_Init(const uint8_t SPIOptions)
{
/** Indicates whether a character has been received through the USART.
*
- * \return Boolean true if a character has been received, false otherwise.
+ * \return Boolean \c true if a character has been received, \c false otherwise.
*/
static inline bool Serial_IsCharReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Serial_IsCharReceived(void)
* \brief Standard avr-libc character stream driver for the USART.
*
* Serial stream driver for the USART subsystem on supported USB AVRs. This makes use of the functions in the
- * regular USART driver (see \ref Group_Serial), but allows the avr-libc standard stream functions (printf,
- * puts, etc.) to work with the
+ * regular USART driver (see \ref Group_Serial), but allows the avr-libc standard stream functions (\c printf,
+ * \c puts, etc.) to work with the
* USART.
*/
*
* \section Sec_ModDescription Module Description
* Serial stream driver for the USART subsystem on supported USB AVRs. This makes use of the functions in the
- * regular USART driver (see \ref Group_Serial), but allows the avr-libc standard stream functions (printf,
- * puts, etc.) to work with the USART. Upon configuration, this will redirect the standard input and output
- * streams to the USART.
+ * regular USART driver (see \ref Group_Serial), but allows the avr-libc standard stream functions (\c printf,
+ * \c puts, etc.) to work with the USART. Upon configuration, this will redirect the \c stdin standard input
+ * and \c stdout output streams to the USART.
*
* \section Sec_ExampleUsage Example Usage
* The following snippet is an example of how this module may be used within a typical
*
* \param[in] freq Required audio sampling frequency in HZ
*/
- #define AUDIO_SAMPLE_FREQ(freq) {((uint32_t)freq & 0x00FFFF), (((uint32_t)freq >> 16) & 0x0000FF)}
+ #define AUDIO_SAMPLE_FREQ(freq) {.Byte1 = (freq & 0x0000FF), .Byte2 = ((freq >> 8) & 0xFF), .Byte3 = ((freq >> 16) & 0xFF)}
/** Mask for the attributes parameter of an Audio class-specific Endpoint descriptor, indicating that the endpoint
* accepts only filled endpoint packets of audio samples.
*/
uint8_t TerminalID; /**< ID value of this terminal unit - must be a unique value within the device. */
- uint16_t TerminalType; /**< Type of terminal, a TERMINAL_* mask. */
+ uint16_t TerminalType; /**< Type of terminal, a \c TERMINAL_* mask. */
uint8_t AssociatedOutputTerminal; /**< ID of associated output terminal, for physically grouped terminals
* such as the speaker and microphone of a phone handset.
*/
uint8_t TotalChannels; /**< Total number of separate audio channels within this interface (right, left, etc.) */
- uint16_t ChannelConfig; /**< CHANNEL_* masks indicating what channel layout is supported by this terminal. */
+ uint16_t ChannelConfig; /**< \c CHANNEL_* masks indicating what channel layout is supported by this terminal. */
uint8_t ChannelStrIndex; /**< Index of a string descriptor describing this channel within the device. */
uint8_t TerminalStrIndex; /**< Index of a string descriptor describing this descriptor within the device. */
* must be \ref AUDIO_DSUBTYPE_CSInterface_InputTerminal.
*/
uint8_t bTerminalID; /**< ID value of this terminal unit - must be a unique value within the device. */
- uint16_t wTerminalType; /**< Type of terminal, a TERMINAL_* mask. */
+ uint16_t wTerminalType; /**< Type of terminal, a \c TERMINAL_* mask. */
uint8_t bAssocTerminal; /**< ID of associated output terminal, for physically grouped terminals
* such as the speaker and microphone of a phone handset.
*/
uint8_t bNrChannels; /**< Total number of separate audio channels within this interface (right, left, etc.) */
- uint16_t wChannelConfig; /**< CHANNEL_* masks indicating what channel layout is supported by this terminal. */
+ uint16_t wChannelConfig; /**< \c CHANNEL_* masks indicating what channel layout is supported by this terminal. */
uint8_t iChannelNames; /**< Index of a string descriptor describing this channel within the device. */
uint8_t iTerminal; /**< Index of a string descriptor describing this descriptor within the device. */
*/
uint8_t TerminalID; /**< ID value of this terminal unit - must be a unique value within the device. */
- uint16_t TerminalType; /**< Type of terminal, a TERMINAL_* mask. */
+ uint16_t TerminalType; /**< Type of terminal, a \c TERMINAL_* mask. */
uint8_t AssociatedInputTerminal; /**< ID of associated input terminal, for physically grouped terminals
* such as the speaker and microphone of a phone handset.
*/
* a value from the \ref Audio_CSInterface_AC_SubTypes_t enum.
*/
uint8_t bTerminalID; /**< ID value of this terminal unit - must be a unique value within the device. */
- uint16_t wTerminalType; /**< Type of terminal, a TERMINAL_* mask. */
+ uint16_t wTerminalType; /**< Type of terminal, a \c TERMINAL_* mask. */
uint8_t bAssocTerminal; /**< ID of associated input terminal, for physically grouped terminals
* such as the speaker and microphone of a phone handset.
*/
uint8_t UnitID; /**< ID value of this feature unit - must be a unique value within the device. */
uint8_t SourceID; /**< Source ID value of the audio source input into this feature unit. */
- uint8_t ControlSize; /**< Size of each element in the ChanelControlls array. */
+ uint8_t ControlSize; /**< Size of each element in the \c ChanelControlls array. */
uint8_t ChannelControls[3]; /**< Feature masks for the control channel, and each separate audio channel. */
uint8_t FeatureUnitStrIndex; /**< Index of a string descriptor describing this descriptor within the device. */
uint8_t bUnitID; /**< ID value of this feature unit - must be a unique value within the device. */
uint8_t bSourceID; /**< Source ID value of the audio source input into this feature unit. */
- uint8_t bControlSize; /**< Size of each element in the ChanelControlls array. */
+ uint8_t bControlSize; /**< Size of each element in the \c ChanelControlls array. */
uint8_t bmaControls[3]; /**< Feature masks for the control channel, and each separate audio channel. */
uint8_t iFeature; /**< Index of a string descriptor describing this descriptor within the device. */
*/
typedef struct
{
- uint16_t LowWord; /**< Low 16 bits of the 24-bit value. */
- uint8_t HighByte; /**< Upper 8 bits of the 24-bit value. */
+ uint8_t Byte1; /**< Lowest 8 bits of the 24-bit value. */
+ uint8_t Byte2; /**< Middle 8 bits of the 24-bit value. */
+ uint8_t Byte3; /**< Upper 8 bits of the 24-bit value. */
} USB_Audio_SampleFreq_t;
/** \brief Audio class-specific Format Descriptor (LUFA naming conventions).
uint8_t bEndpointAddress; /**< Logical address of the endpoint within the device for the current
* configuration, including direction mask.
*/
- uint8_t bmAttributes; /**< Endpoint attributes, comprised of a mask of the endpoint type (EP_TYPE_*)
- * and attributes (ENDPOINT_ATTR_*) masks.
+ uint8_t bmAttributes; /**< Endpoint attributes, comprised of a mask of the endpoint type (\c EP_TYPE_*)
+ * and attributes (\c ENDPOINT_ATTR_*) masks.
*/
uint16_t wMaxPacketSize; /**< Size of the endpoint bank, in bytes. This indicates the maximum packet size
* that the endpoint can receive at a time.
* a value from the \ref Audio_CSEndpoint_SubTypes_t enum.
*/
- uint8_t Attributes; /**< Audio class-specific endpoint attributes, such as ACCEPTS_SMALL_PACKETS. */
+ uint8_t Attributes; /**< Audio class-specific endpoint attributes, such as \ref AUDIO_EP_FULL_PACKETS_ONLY. */
uint8_t LockDelayUnits; /**< Units used for the LockDelay field, see Audio class specification. */
uint16_t LockDelay; /**< Time required to internally lock endpoint's internal clock recovery circuitry. */
* a value from the \ref Audio_CSEndpoint_SubTypes_t enum.
*/
- uint8_t bmAttributes; /**< Audio class-specific endpoint attributes, such as ACCEPTS_SMALL_PACKETS. */
+ uint8_t bmAttributes; /**< Audio class-specific endpoint attributes, such as \ref AUDIO_EP_FULL_PACKETS_ONLY. */
uint8_t bLockDelayUnits; /**< Units used for the LockDelay field, see Audio class specification. */
uint16_t wLockDelay; /**< Time required to internally lock endpoint's internal clock recovery circuitry. */
/** Macro to define a CDC class-specific functional descriptor. CDC functional descriptors have a
* uniform structure but variable sized data payloads, thus cannot be represented accurately by
* a single typedef struct. A macro is used instead so that functional descriptors can be created
- * easily by specifying the size of the payload. This allows sizeof() to work correctly.
+ * easily by specifying the size of the payload. This allows \c sizeof() to work correctly.
*
* \param[in] DataSize Size in bytes of the CDC functional descriptor's data payload.
*/
typedef struct
{
uint8_t Modifier; /**< Keyboard modifier byte, indicating pressed modifier keys (a combination of
- * HID_KEYBOARD_MODIFER_* masks).
+ * \c HID_KEYBOARD_MODIFER_* masks).
*/
uint8_t Reserved; /**< Reserved for OEM use, always set to 0. */
uint8_t KeyCode[6]; /**< Key codes of the currently pressed keys. */
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length. */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class-specific descriptors. */
- uint8_t JackType; /**< Type of jack, one of the JACKTYPE_* mask values. */
+ uint8_t JackType; /**< Type of jack, one of the \c JACKTYPE_* mask values. */
uint8_t JackID; /**< ID value of this jack - must be a unique value within the device. */
uint8_t JackStrIndex; /**< Index of a string descriptor describing this descriptor within the device. */
uint8_t bDescriptorSubtype; /**< Sub type value used to distinguish between audio class-specific descriptors. */
- uint8_t bJackType; /**< Type of jack, one of the JACKTYPE_* mask values. */
+ uint8_t bJackType; /**< Type of jack, one of the \c JACKTYPE_* mask values. */
uint8_t bJackID; /**< ID value of this jack - must be a unique value within the device. */
uint8_t iJack; /**< Index of a string descriptor describing this descriptor within the device. */
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length. */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class-specific descriptors. */
- uint8_t JackType; /**< Type of jack, one of the JACKTYPE_* mask values. */
+ uint8_t JackType; /**< Type of jack, one of the \c JACKTYPE_* mask values. */
uint8_t JackID; /**< ID value of this jack - must be a unique value within the device. */
uint8_t NumberOfPins; /**< Number of output channels within the jack, either physical or logical. */
uint8_t bDescriptorSubtype; /**< Sub type value used to distinguish between audio class-specific descriptors. */
- uint8_t bJackType; /**< Type of jack, one of the JACKTYPE_* mask values. */
+ uint8_t bJackType; /**< Type of jack, one of the \c JACKTYPE_* mask values. */
uint8_t bJackID; /**< ID value of this jack - must be a unique value within the device. */
uint8_t bNrInputPins; /**< Number of output channels within the jack, either physical or logical. */
* Type define for a Command Block Wrapper, used in the Mass Storage Bulk-Only Transport protocol. */
typedef struct
{
- uint32_t Signature; /**< Command block signature, must be CBW_SIGNATURE to indicate a valid Command Block. */
+ uint32_t Signature; /**< Command block signature, must be \ref MS_CBW_SIGNATURE to indicate a valid Command Block. */
uint32_t Tag; /**< Unique command ID value, to associate a command block wrapper with its command status wrapper. */
uint32_t DataTransferLength; /**< Length of the optional data portion of the issued command, in bytes. */
uint8_t Flags; /**< Command block flags, indicating command data direction. */
*/
typedef struct
{
- uint32_t Signature; /**< Status block signature, must be CSW_SIGNATURE to indicate a valid Command Status. */
+ uint32_t Signature; /**< Status block signature, must be \ref MS_CSW_SIGNATURE to indicate a valid Command Status. */
uint32_t Tag; /**< Unique command ID value, to associate a command block wrapper with its command status wrapper. */
uint32_t DataTransferResidue; /**< Number of bytes of data not processed in the SCSI command. */
uint8_t Status; /**< Status code of the issued command - a value from the \ref MS_CommandStatusCodes_t enum. */
/** Enum for the RNDIS class specific notification requests that can be issued by a RNDIS device to a host. */
enum RNDIS_ClassNotifications_t
{
- RNDIS_NOTIF_ResponseAvailable = 0x01, /**< Notification request value for a RNDIS Response Available notification. */
+ RNDIS_NOTIF_ResponseAvailable 0x01, /**< Notification request value for a RNDIS Response Available notification. */
};
/** Enum for the NDIS hardware states. */
*/
typedef struct
{
- uint32_t MessageType; /**< RNDIS message type, a REMOTE_NDIS_*_MSG constant */
+ uint32_t MessageType; /**< RNDIS message type, a \c REMOTE_NDIS_*_MSG constant */
uint32_t MessageLength; /**< Total length of the RNDIS message, in bytes */
} RNDIS_Message_Header_t;
/** Used in the DataLength field of a PIMA container, to give the total container size in bytes for
* a command container.
*
- * \param[in] Params Number of parameters which are to be sent in the Param field of the container.
+ * \param[in] Params Number of parameters which are to be sent in the \c Param field of the container.
*/
#define PIMA_COMMAND_SIZE(Params) ((sizeof(PIMA_Container_t) - 12) + ((Params) * sizeof(uint32_t)))
*
* Class state structure. An instance of this structure should be made for each Audio interface
* within the user application, and passed to each of the Audio class driver functions as the
- * AudioInterfaceInfo parameter. This stores each Audio interface's configuration and state information.
+ * \c AudioInterfaceInfo parameter. This stores each Audio interface's configuration and state information.
*/
typedef struct
{
*
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*
- * \return Boolean true if the endpoints were successfully configured, false otherwise.
+ * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise.
*/
bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
*
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*
- * \return Boolean true if the given Audio interface has a sample to be read, false otherwise.
+ * \return Boolean \c true if the given Audio interface has a sample to be read, \c false otherwise.
*/
static inline bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
ATTR_NON_NULL_PTR_ARG(1) ATTR_ALWAYS_INLINE;
*
* \param[in,out] AudioInterfaceInfo Pointer to a structure containing an Audio Class configuration and state.
*
- * \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise.
+ * \return Boolean \c true if the given Audio interface is ready to accept the next sample, \c false otherwise.
*/
static inline bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo)
ATTR_NON_NULL_PTR_ARG(1) ATTR_ALWAYS_INLINE;
{
struct
{
- uint8_t HostToDevice; /**< Control line states from the host to device, as a set of CDC_CONTROL_LINE_OUT_*
+ uint8_t HostToDevice; /**< Control line states from the host to device, as a set of \c CDC_CONTROL_LINE_OUT_*
* masks. This value is updated each time \ref CDC_Device_USBTask() is called.
*/
- uint8_t DeviceToHost; /**< Control line states from the device to host, as a set of CDC_CONTROL_LINE_IN_*
+ uint8_t DeviceToHost; /**< Control line states from the device to host, as a set of \c CDC_CONTROL_LINE_IN_*
* masks - to notify the host of changes to these values, call the
* \ref CDC_Device_SendControlLineStateChange() function.
*/
*
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
*
- * \return Boolean true if the endpoints were successfully configured, false otherwise.
+ * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise.
*/
bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
static int CDC_Device_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
static int CDC_Device_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
- void CDC_Device_Event_Stub(void);
+ void CDC_Device_Event_Stub(void) ATTR_CONST;
void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
*
* Class state structure. An instance of this structure should be made for each HID interface
* within the user application, and passed to each of the HID class driver functions as the
- * HIDInterfaceInfo parameter. This stores each HID interface's configuration and state information.
+ * \c HIDInterfaceInfo parameter. This stores each HID interface's configuration and state information.
*
* \note Due to technical limitations, the HID device class driver does not utilize a separate OUT
* endpoint for host->device communications. Instead, the host->device data (if any) is sent to
* stored by the driver, for comparison purposes to detect report changes that
* must be sent immediately to the host. This should point to a buffer big enough
* to hold the largest HID input report sent from the HID interface. If this is set
- * to NULL, it is up to the user to force transfers when needed in the
+ * to \c NULL, it is up to the user to force transfers when needed in the
* \ref CALLBACK_HID_Device_CreateHIDReport() callback function.
*
* \note Due to the single buffer, the internal driver can only correctly compare
* subsequent reports with identical report IDs. In multiple report devices,
- * this buffer should be set to NULL and the decision to send reports made
+ * this buffer should be set to \c NULL and the decision to send reports made
* by the user application instead.
*/
uint8_t PrevReportINBufferSize; /**< Size in bytes of the given input report buffer. This is used to create a
* second buffer of the same size within the driver so that subsequent reports
* can be compared. If the user app is to determine when reports are to be sent
- * exclusively (i.e. \ref PrevReportINBuffer is NULL) this value must still be
+ * exclusively (i.e. \ref PrevReportINBuffer is \c NULL) this value must still be
* set to the size of the largest report the device can issue to the host.
*/
} Config; /**< Config data for the USB class interface within the device. All elements in this section
*
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class configuration and state.
*
- * \return Boolean true if the endpoints were successfully configured, false otherwise.
+ * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise.
*/
bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
* \param[out] ReportData Pointer to a buffer where the generated HID report should be stored.
* \param[out] ReportSize Number of bytes in the generated input report, or zero if no report is to be sent.
*
- * \return Boolean true to force the sending of the report even if it is identical to the previous report and still within
- * the idle period (useful for devices which report relative movement), false otherwise.
+ * \return Boolean \c true to force the sending of the report even if it is identical to the previous report and still within
+ * the idle period (useful for devices which report relative movement), \c false otherwise.
*/
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
uint8_t* const ReportID,
*
* Class state structure. An instance of this structure should be made for each MIDI interface
* within the user application, and passed to each of the MIDI class driver functions as the
- * MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.
+ * \c MIDIInterfaceInfo parameter. This stores each MIDI interface's configuration and state information.
*/
typedef struct
{
*
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
*
- * \return Boolean true if the endpoints were successfully configured, false otherwise.
+ * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise.
*/
bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[out] Event Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed.
*
- * \return Boolean true if a MIDI event packet was received, false otherwise.
+ * \return Boolean \c true if a MIDI event packet was received, \c false otherwise.
*/
bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
*
* Class state structure. An instance of this structure should be made for each Mass Storage interface
* within the user application, and passed to each of the Mass Storage class driver functions as the
- * MSInterfaceInfo parameter. This stores each Mass Storage interface's configuration and state information.
+ * \c MSInterfaceInfo parameter. This stores each Mass Storage interface's configuration and state information.
*/
typedef struct
{
*
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
*
- * \return Boolean true if the endpoints were successfully configured, false otherwise.
+ * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise.
*/
bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
*
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a Mass Storage Class configuration and state.
*
- * \return Boolean true if the SCSI command was successfully processed, false otherwise.
+ * \return Boolean \c true if the SCSI command was successfully processed, \c false otherwise.
*/
bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
*
* Class state structure. An instance of this structure should be made for each RNDIS interface
* within the user application, and passed to each of the RNDIS class driver functions as the
- * RNDISInterfaceInfo parameter. This stores each RNDIS interface's configuration and state information.
+ * \c RNDISInterfaceInfo parameter. This stores each RNDIS interface's configuration and state information.
*/
typedef struct
{
*
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing a RNDIS Class configuration and state.
*
- * \return Boolean true if the endpoints were successfully configured, false otherwise.
+ * \return Boolean \c true if the endpoints were successfully configured, \c false otherwise.
*/
bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
/** \brief CDC Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the CDC class driver functions as the CDCInterfaceInfo parameter. This
+ * and passed to each of the CDC class driver functions as the \c CDCInterfaceInfo parameter. This
* stores each CDC interface's configuration and state information.
*/
typedef struct
struct
{
- uint8_t HostToDevice; /**< Control line states from the host to device, as a set of CDC_CONTROL_LINE_OUT_*
+ uint8_t HostToDevice; /**< Control line states from the host to device, as a set of \c CDC_CONTROL_LINE_OUT_*
* masks - to notify the device of changes to these values, call the
* \ref CDC_Host_SendControlLineStateChange() function.
*/
- uint8_t DeviceToHost; /**< Control line states from the device to host, as a set of CDC_CONTROL_LINE_IN_*
+ uint8_t DeviceToHost; /**< Control line states from the device to host, as a set of \c CDC_CONTROL_LINE_IN_*
* masks. This value is updated each time \ref CDC_Host_USBTask() is called.
*/
} ControlLineStates; /**< Current states of the virtual serial port's control lines between the device and host. */
uint16_t ConfigDescriptorSize,
void* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(3);
- /** Sets the line encoding for the attached device's virtual serial port. This should be called when the LineEncoding
+ /** Sets the line encoding for the attached device's virtual serial port. This should be called when the \c LineEncoding
* values of the interface have been changed to push the new settings to the USB device.
*
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class host configuration and state.
/** Sends a Serial Control Line State Change notification to the device. This should be called when the virtual serial
* control lines (DTR, RTS, etc.) have changed states. Line states persist until they are cleared via a second
- * notification. This should be called each time the CDC class driver's ControlLineStates.HostToDevice value is updated
+ * notification. This should be called each time the CDC class driver's \c ControlLineStates.HostToDevice value is updated
* to push the new states to the USB device.
*
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class host configuration and state.
uint8_t CDC_Host_Flush(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
/** Creates a standard character stream for the given CDC Device instance so that it can be used with all the regular
- * functions in the avr-libc <stdio.h> library that accept a FILE stream as a destination (e.g. fprintf). The created
+ * functions in the avr-libc \c <stdio.h> library that accept a FILE stream as a destination (e.g. fprintf). The created
* stream is bidirectional and can be used for both input and output functions.
*
- * \note The created stream can be given as stdout if desired to direct the standard output from all <stdio.h> functions
+ * \note The created stream can be given as stdout if desired to direct the standard output from all \c <stdio.h> functions
* to the given CDC interface.
*
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class configuration and state.
* the host of a control line state change (containing the virtual serial control line states, such as DCD) and may be hooked in the
* user program by declaring a handler function with the same name and parameters listed here. The new control line states
* are available in the ControlLineStates.DeviceToHost value inside the CDC host interface structure passed as a parameter, set as
- * a mask of CDC_CONTROL_LINE_IN_* masks.
+ * a mask of \c CDC_CONTROL_LINE_IN_* masks.
*
* \param[in,out] CDCInterfaceInfo Pointer to a structure containing a CDC Class host configuration and state.
*/
static int CDC_Host_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
static int CDC_Host_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
- void CDC_Host_Event_Stub(void);
+ void CDC_Host_Event_Stub(void) ATTR_CONST;
void EVENT_CDC_Host_ControLineStateChanged(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Host_Event_Stub);
/** \brief HID Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the HID class driver functions as the HIDInterfaceInfo parameter. This
+ * and passed to each of the HID class driver functions as the \c HIDInterfaceInfo parameter. This
* stores each HID interface's configuration and state information.
*/
typedef struct
HID_ReportInfo_t* HIDParserData; /**< HID parser data to store the parsed HID report data, when boot protocol
* is not used.
*
- * \note When the HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined,
+ * \note When the \c HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined,
* this method is unavailable.
*/
#endif
* \pre This function must only be called when the Host state machine is in the \ref HOST_STATE_Configured state or the
* call will fail.
*
- * \note When the HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, this method is unavailable.
+ * \note When the \c HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, this method is unavailable.
*
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class host configuration and state.
* \param[in] ReportID Report ID of the received report if ControlRequest is false, set by the to the Report ID to fetch.
* \pre This function must only be called when the Host state machine is in the \ref HOST_STATE_Configured state or the
* call will fail.
*
- * \note When the HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, the ReportID parameter is removed
+ * \note When the \c HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, the ReportID parameter is removed
* from the parameter list of this function.
*
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class host configuration and state.
*
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class host configuration and state.
*
- * \return Boolean true if a report has been received, false otherwise.
+ * \return Boolean \c true if a report has been received, \c false otherwise.
*/
bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
/** Switches the attached HID device's reporting protocol over to the Boot Report protocol mode, on supported devices.
*
- * \note When the HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, this method must still be called
+ * \note When the \c HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, this method must still be called
* to explicitly place the attached device into boot protocol mode before use.
*
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class host configuration and state.
* Report Parser this function references <b>must</b> be implemented in the user code.
* \n\n
*
- * \note When the HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, this method is unavailable.
+ * \note When the \c HID_HOST_BOOT_PROTOCOL_ONLY compile time token is defined, this method is unavailable.
*
* \param[in,out] HIDInterfaceInfo Pointer to a structure containing a HID Class host configuration and state.
*
/** Constant indicating the maximum stack depth of the state table. A larger state table
* allows for more PUSH/POP report items to be nested, but consumes more memory. By default
* this is set to 2 levels (allowing non-nested PUSH items) but this can be overridden by
- * defining HID_STATETABLE_STACK_DEPTH to another value in the user project makefile, passing the
+ * defining \c HID_STATETABLE_STACK_DEPTH to another value in the user project makefile, passing the
* define to the compiler using the -D compiler switch.
*/
#define HID_STATETABLE_STACK_DEPTH 2
/** Constant indicating the maximum stack depth of the usage table. A larger usage table
* allows for more USAGE items to be indicated sequentially for REPORT COUNT entries of more than
* one, but requires more stack space. By default this is set to 8 levels (allowing for a report
- * item with a count of 8) but this can be overridden by defining HID_USAGE_STACK_DEPTH to another
+ * item with a count of 8) but this can be overridden by defining \c HID_USAGE_STACK_DEPTH to another
* value in the user project makefile, passing the define to the compiler using the -D compiler
* switch.
*/
/** Constant indicating the maximum number of COLLECTION items (nested or unnested) that can be
* processed in the report item descriptor. A large value allows for more COLLECTION items to be
* processed, but consumes more memory. By default this is set to 10 collections, but this can be
- * overridden by defining HID_MAX_COLLECTIONS to another value in the user project makefile, passing
+ * overridden by defining \c HID_MAX_COLLECTIONS to another value in the user project makefile, passing
* the define to the compiler using the -D compiler switch.
*/
#define HID_MAX_COLLECTIONS 10
/** Constant indicating the maximum number of report items (IN, OUT or FEATURE) that can be processed
* in the report item descriptor and stored in the user HID Report Info structure. A large value allows
* for more report items to be stored, but consumes more memory. By default this is set to 20 items,
- * but this can be overridden by defining HID_MAX_REPORTITEMS to another value in the user project
+ * but this can be overridden by defining \c HID_MAX_REPORTITEMS to another value in the user project
* makefile, and passing the define to the compiler using the -D compiler switch.
*/
#define HID_MAX_REPORTITEMS 20
/** Constant indicating the maximum number of unique report IDs that can be processed in the report item
* descriptor for the report size information array in the user HID Report Info structure. A large value
* allows for more report ID report sizes to be stored, but consumes more memory. By default this is set
- * to 10 items, but this can be overridden by defining HID_MAX_REPORT_IDS to another value in the user project
+ * to 10 items, but this can be overridden by defining \c HID_MAX_REPORT_IDS to another value in the user project
* makefile, and passing the define to the compiler using the -D compiler switch. Note that IN, OUT and FEATURE
* items sharing the same report ID consume only one size item in the array.
*/
{
uint8_t Type; /**< Collection type (e.g. "Generic Desktop"). */
HID_Usage_t Usage; /**< Collection usage. */
- struct CollectionPath* Parent; /**< Reference to parent collection, or NULL if root collection. */
+ struct CollectionPath* Parent; /**< Reference to parent collection, or \c NULL if root collection. */
} HID_CollectionPath_t;
/** \brief HID Parser Report Item Attributes Structure.
typedef struct
{
uint16_t BitOffset; /**< Bit offset in the IN, OUT or FEATURE report of the item. */
- uint8_t ItemType; /**< Report item type, a value in HID_ReportItemTypes_t. */
+ uint8_t ItemType; /**< Report item type, a value in \ref HID_ReportItemTypes_t. */
uint16_t ItemFlags; /**< Item data flags, such as constant/variable, etc. */
uint8_t ReportID; /**< Report ID this item belongs to, or 0x00 if device has only one report */
HID_CollectionPath_t* CollectionPath; /**< Collection path of the item. */
typedef struct
{
uint8_t TotalReportItems; /**< Total number of report items stored in the
- * ReportItems array.
+ * \c ReportItems array.
*/
HID_ReportItem_t ReportItems[HID_MAX_REPORTITEMS]; /**< Report items array, including
* all IN, OUT and FEATURE items.
* \param[in] ReportData Buffer containing an IN or FEATURE report from an attached device.
* \param[in,out] ReportItem Pointer to the report item of interest in a \ref HID_ReportInfo_t ReportItem array.
*
- * \returns Boolean true if the item to retrieve was located in the given report, false otherwise.
+ * \returns Boolean \c true if the item to retrieve was located in the given report, \c false otherwise.
*/
bool USB_GetHIDReportItemInfo(const uint8_t* ReportData,
HID_ReportItem_t* const ReportItem) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** Callback routine for the HID Report Parser. This callback <b>must</b> be implemented by the user code when
* the parser is used, to determine what report IN, OUT and FEATURE item's information is stored into the user
- * HID_ReportInfo_t structure. This can be used to filter only those items the application will be using, so that
+ * \ref HID_ReportInfo_t structure. This can be used to filter only those items the application will be using, so that
* no RAM is wasted storing the attributes for report items which will never be referenced by the application.
*
* \param[in] CurrentItem Pointer to the current report item for user checking.
*
- * \return Boolean true if the item should be stored into the HID_ReportInfo_t structure, false if it should be ignored.
+ * \return Boolean \c true if the item should be stored into the \ref HID_ReportInfo_t structure, \c false if
+ * it should be ignored.
*/
bool CALLBACK_HIDParser_FilterHIDReportItem(HID_ReportItem_t* const CurrentItem);
/** \brief MIDI Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the MIDI class driver functions as the MIDIInterfaceInfo parameter. This
+ * and passed to each of the MIDI class driver functions as the \c MIDIInterfaceInfo parameter. This
* stores each MIDI interface's configuration and state information.
*/
typedef struct
* \param[in,out] MIDIInterfaceInfo Pointer to a structure containing a MIDI Class configuration and state.
* \param[out] Event Pointer to a USB_MIDI_EventPacket_t structure where the received MIDI event is to be placed.
*
- * \return Boolean true if a MIDI event packet was received, false otherwise.
+ * \return Boolean \c true if a MIDI event packet was received, \c false otherwise.
*/
bool MIDI_Host_ReceiveEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
/** \brief Mass Storage Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the Mass Storage class driver functions as the MSInterfaceInfo parameter. This
+ * and passed to each of the Mass Storage class driver functions as the \c MSInterfaceInfo parameter. This
* stores each Mass Storage interface's configuration and state information.
*/
typedef struct
*
* \param[in,out] MSInterfaceInfo Pointer to a structure containing a MS Class host configuration and state.
* \param[in] LUNIndex LUN index within the device the command is being issued to.
- * \param[in] PreventRemoval Boolean true if the device should be locked from removal, false otherwise.
+ * \param[in] PreventRemoval Boolean \c true if the device should be locked from removal, \c false otherwise.
*
* \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum or \ref MS_ERROR_LOGICAL_CMD_FAILED if not ready.
*/
/** \brief Printer Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the Printer class driver functions as the PRNTInterfaceInfo parameter. This
+ * and passed to each of the Printer class driver functions as the \c PRNTInterfaceInfo parameter. This
* stores each Printer interface's configuration and state information.
*/
typedef struct
uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
/** Retrieves the status of the virtual Printer port's inbound status lines. The result can then be masked against the
- * PRNT_PORTSTATUS_* macros to determine the printer port's status.
+ * \c PRNT_PORTSTATUS_* macros to determine the printer port's status.
*
* \param[in,out] PRNTInterfaceInfo Pointer to a structure containing a Printer Class host configuration and state.
* \param[out] PortStatus Location where the retrieved port status should be stored.
/** \brief RNDIS Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the RNDIS class driver functions as the RNDISInterfaceInfo parameter. This
+ * and passed to each of the RNDIS class driver functions as the \c RNDISInterfaceInfo parameter. This
* stores each RNDIS interface's configuration and state information.
*/
typedef struct
*
* \param[in,out] RNDISInterfaceInfo Pointer to a structure containing an RNDIS Class host configuration and state.
*
- * \return Boolean true if a packet is waiting to be read in by the host, false otherwise.
+ * \return Boolean \c true if a packet is waiting to be read in by the host, \c false otherwise.
*/
bool RNDIS_Host_IsPacketReceived(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
/** \brief Still Image Class Host Mode Configuration and State Structure.
*
* Class state structure. An instance of this structure should be made within the user application,
- * and passed to each of the Still Image class driver functions as the SIInterfaceInfo parameter. This
+ * and passed to each of the Still Image class driver functions as the \c SIInterfaceInfo parameter. This
* stores each Still Image interface's configuration and state information.
*/
typedef struct
*
* \param[in,out] SIInterfaceInfo Pointer to a structure containing a Still Image Class host configuration and state.
*
- * \return Boolean true if an event is waiting to be read, false otherwise.
+ * \return Boolean \c true if an event is waiting to be read, \c false otherwise.
*/
bool SI_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
/* Public Interface - May be used in end-application: */
/* Macros: */
/** Mask for determining the type of an endpoint from an endpoint descriptor. This should then be compared
- * with the EP_TYPE_* masks to determine the exact type of the endpoint.
+ * with the \c EP_TYPE_* masks to determine the exact type of the endpoint.
*/
#define EP_TYPE_MASK 0x03
{
DESCRIPTOR_SEARCH_COMP_Found = 0, /**< Configuration descriptor now points to descriptor which matches
* search criteria of the given comparator function. */
- DESCRIPTOR_SEARCH_COMP_Fail = 1, /**< Comparator function returned Descriptor_Search_Fail. */
+ DESCRIPTOR_SEARCH_COMP_Fail = 1, /**< Comparator function returned \ref DESCRIPTOR_SEARCH_Fail. */
DESCRIPTOR_SEARCH_COMP_EndOfDescriptor = 2, /**< End of configuration descriptor reached before match found. */
};
*
* \param[in] ConfigNumber Device configuration descriptor number to fetch from the device (usually set to 1 for
* single configuration devices).
- * \param[in,out] ConfigSizePtr Pointer to a uint16_t for storing the retrieved configuration descriptor size.
+ * \param[in,out] ConfigSizePtr Pointer to a location for storing the retrieved configuration descriptor size.
* \param[out] BufferPtr Pointer to the buffer for storing the configuration descriptor data.
* \param[out] BufferSize Size of the allocated buffer where the configuration descriptor is to be stored.
*
/* Enums: */
#if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
- /** Enum for the possible descriptor memory spaces, for the MemoryAddressSpace of the
- * \ref CALLBACK_USB_GetDescriptor() function. This can be used when none of the USE_*_DESCRIPTORS
+ /** Enum for the possible descriptor memory spaces, for the \c MemoryAddressSpace parameter of the
+ * \ref CALLBACK_USB_GetDescriptor() function. This can be used when none of the \c USE_*_DESCRIPTORS
* compile time options are used, to indicate in which memory space the descriptor is stored.
*
* \ingroup Group_Device
*
* \note To reduce FLASH usage of the compiled applications where Remote Wakeup is not supported,
* this global and the underlying management code can be disabled by defining the
- * NO_DEVICE_REMOTE_WAKEUP token in the project makefile and passing it to the compiler via
+ * \c NO_DEVICE_REMOTE_WAKEUP token in the project makefile and passing it to the compiler via
* the -D switch.
*
* \ingroup Group_Device
\r
/* Public Interface - May be used in end-application: */\r
/* Enums: */\r
- /** Enum for the possible error return codes of the Endpoint_*_Stream_* functions. */\r
+ /** Enum for the possible error return codes of the \c Endpoint_*_Stream_* functions. */\r
enum Endpoint_Stream_RW_ErrorCodes_t\r
{\r
ENDPOINT_RWSTREAM_NoError = 0, /**< Command completed successfully, no error. */\r
*/\r
};\r
\r
- /** Enum for the possible error return codes of the Endpoint_*_Control_Stream_* functions. */\r
+ /** Enum for the possible error return codes of the \c Endpoint_*_Control_Stream_* functions. */\r
enum Endpoint_ControlStream_RW_ErrorCodes_t\r
{\r
ENDPOINT_RWCSTREAM_NoError = 0, /**< Command completed successfully, no error. */\r
* packet is ready, allowing for early aborts of stream transfers.\r
*\r
* The callback routine should be created according to the information in \ref Group_StreamCallbacks.\r
- * If the token NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
+ * If the token \c NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
* disabled and this function has the Callback parameter omitted.\r
*\r
* \note This routine should not be used on CONTROL type endpoints.\r
*\r
* \param[in] Length Number of bytes to send via the currently selected endpoint.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
* aborts of stream transfers.\r
*\r
* The callback routine should be created according to the information in \ref Group_StreamCallbacks.\r
- * If the token NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
+ * If the token \c NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
* disabled and this function has the Callback parameter omitted.\r
*\r
* \note This routine should not be used on CONTROL type endpoints.\r
*\r
* \param[in] Buffer Pointer to the source data buffer to read from.\r
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
*\r
* \param[in] Buffer Pointer to the source data buffer to read from.\r
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
*\r
* \param[in] Buffer Pointer to the source data buffer to read from.\r
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
* aborts of stream transfers.\r
*\r
* The callback routine should be created according to the information in \ref Group_StreamCallbacks.\r
- * If the token NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
+ * If the token \c NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
* disabled and this function has the Callback parameter omitted.\r
*\r
* \note This routine should not be used on CONTROL type endpoints.\r
*\r
* \param[in] Buffer Pointer to the source data buffer to read from.\r
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
*\r
* \param[in] Buffer Pointer to the source data buffer to read from.\r
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
*\r
* \param[in] Buffer Pointer to the source data buffer to read from.\r
* \param[in] Length Number of bytes to read for the currently selected endpoint into the buffer.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
* is ready to accept the next packet, allowing for early aborts of stream transfers.\r
*\r
* The callback routine should be created according to the information in \ref Group_StreamCallbacks.\r
- * If the token NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
+ * If the token \c NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
* disabled and this function has the Callback parameter omitted.\r
*\r
* \note This routine should not be used on CONTROL type endpoints.\r
*\r
* \param[out] Buffer Pointer to the destination data buffer to write to.\r
* \param[in] Length Number of bytes to send via the currently selected endpoint.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
*\r
* \param[out] Buffer Pointer to the destination data buffer to write to, located in EEPROM memory space.\r
* \param[in] Length Number of bytes to send via the currently selected endpoint.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
* is ready to accept the next packet, allowing for early aborts of stream transfers.\r
*\r
* The callback routine should be created according to the information in \ref Group_StreamCallbacks.\r
- * If the token NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
+ * If the token \c NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are\r
* disabled and this function has the Callback parameter omitted.\r
*\r
* \note This routine should not be used on CONTROL type endpoints.\r
*\r
* \param[out] Buffer Pointer to the destination data buffer to write to.\r
* \param[in] Length Number of bytes to send via the currently selected endpoint.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
*\r
* \param[out] Buffer Pointer to the destination data buffer to write to, located in EEPROM memory space.\r
* \param[in] Length Number of bytes to send via the currently selected endpoint.\r
- * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback.\r
+ * \param[in] Callback Name of a callback routine to call between successive USB packet transfers, \c NULL if no callback.\r
*\r
* \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
*/\r
* \note This event only exists on USB AVR models which support dual role modes.
* \n\n
*
- * \note This event does not exist if the USB_DEVICE_ONLY or USB_HOST_ONLY tokens have been supplied
+ * \note This event does not exist if the \c USB_DEVICE_ONLY or \c USB_HOST_ONLY tokens have been supplied
* to the compiler (see \ref Group_USBManagement documentation).
*/
void EVENT_USB_UIDChange(void);
* \note This event only exists on USB AVR models which supports host mode.
* \n\n
*
- * \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void EVENT_USB_Host_HostError(const uint8_t ErrorCode);
* \note This event only exists on USB AVR models which supports host mode.
* \n\n
*
- * \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*
* \see \ref USB_USBTask() for more information on the USB management task and reducing CPU usage.
* \note This event only exists on USB AVR models which supports host mode.
* \n\n
*
- * \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*
* \see \ref USB_USBTask() for more information on the USB management task and reducing CPU usage.
* \note This event only exists on USB AVR models which supports host mode.
* \n\n
*
- * \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
* a USB device.
* \n\n
*
- * \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void EVENT_USB_Host_StartOfFrame(void);
* this means that the current connection state is derived from the bus suspension and wake up events by default,
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
- * passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
+ * passing the \c NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired, and the \ref USB_DeviceState global changed manually.
* \n\n
*
* \note This event may fire multiple times during device enumeration on the series 2 USB AVRs with limited USB controllers
- * if NO_LIMITED_CONTROLLER_CONNECT is not defined.
+ * if \c NO_LIMITED_CONTROLLER_CONNECT is not defined.
*
- * \see USBTask.h for more information on the USB management task and reducing CPU usage.
+ * \see \ref Group_USBManagement for more information on the USB management task and reducing CPU usage.
*/
void EVENT_USB_Device_Connect(void);
* this means that the current connection state is derived from the bus suspension and wake up events by default,
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
- * passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
+ * passing the \c NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired, and the \ref USB_DeviceState global changed manually.
* \n\n
*
* \note This event may fire multiple times during device enumeration on the series 2 USB AVRs with limited USB controllers
- * if NO_LIMITED_CONTROLLER_CONNECT is not defined.
+ * if \c NO_LIMITED_CONTROLLER_CONNECT is not defined.
*
- * \see USBTask.h for more information on the USB management task and reducing CPU usage.
+ * \see \ref Group_USBManagement for more information on the USB management task and reducing CPU usage.
*/
void EVENT_USB_Device_Disconnect(void);
* for the user to process via this event if desired. If not handled in the user application or by
* the library internally, unknown requests are automatically STALLed.
*
- * \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
* \n\n
*
*
* This event fires after the value of \ref USB_ConfigurationNumber has been changed.
*
- * \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void EVENT_USB_Device_ConfigurationChanged(void);
* enumerated with the \ref USB_OPT_AUTO_PLL option set, the library will automatically suspend the
* USB PLL before the event is fired to save power.
*
- * \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
* \n\n
*
- * \note This event does not exist on the series 2 USB AVRs when the NO_LIMITED_CONTROLLER_CONNECT
+ * \note This event does not exist on the series 2 USB AVRs when the \c NO_LIMITED_CONTROLLER_CONNECT
* compile time token is not set - see \ref EVENT_USB_Device_Disconnect.
*
* \see \ref EVENT_USB_Device_WakeUp() event for accompanying Wake Up event.
* mode. If the USB interface is enumerated with the \ref USB_OPT_AUTO_PLL option set, the library
* will automatically restart the USB PLL before the event is fired.
*
- * \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
* \n\n
*
- * \note This event does not exist on the series 2 USB AVRs when the NO_LIMITED_CONTROLLER_CONNECT
+ * \note This event does not exist on the series 2 USB AVRs when the \c NO_LIMITED_CONTROLLER_CONNECT
* compile time token is not set - see \ref EVENT_USB_Device_Connect.
*
* \see \ref EVENT_USB_Device_Suspend() event for accompanying Suspend event.
* This event is time-critical; exceeding OS-specific delays within this event handler (typically of around
* two seconds) will prevent the device from enumerating correctly.
*
- * \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void EVENT_USB_Device_Reset(void);
* \ref USB_Device_EnableSOFEvents() and \ref USB_Device_DisableSOFEvents() commands after enumeration.
* \n\n
*
- * \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
+ * \note This event does not exist if the \c USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void EVENT_USB_Device_StartOfFrame(void);
* \ingroup Group_PipeControlReq
*
* \param[in] BufferPtr Pointer to the start of the data buffer if the request has a data stage, or
- * NULL if the request transfers no data to or from the device.
+ * \c NULL if the request transfers no data to or from the device.
*
* \return A value from the \ref USB_Host_SendControlErrorCodes_t enum to indicate the result.
*/
* \note This macro should only be used if the device has indicated to the host that it
* supports the Remote Wakeup feature in the device descriptors, and should only be
* issued if the host is currently allowing remote wakeup events from the device (i.e.,
- * the \ref USB_RemoteWakeupEnabled flag is set). When the NO_DEVICE_REMOTE_WAKEUP compile
+ * the \ref USB_RemoteWakeupEnabled flag is set). When the \c NO_DEVICE_REMOTE_WAKEUP compile
* time option is used, this macro is unavailable.
* \n\n
*
* \ref EVENT_USB_Device_StartOfFrame() event to fire once per millisecond, synchronized to the USB bus,
* at the start of each USB frame when enumerated in device mode.
*
- * \note Not available when the NO_SOF_EVENTS compile time token is defined.
+ * \note Not available when the \c NO_SOF_EVENTS compile time token is defined.
*/
static inline void USB_Device_EnableSOFEvents(void) ATTR_ALWAYS_INLINE;
static inline void USB_Device_EnableSOFEvents(void)
/** Disables the device mode Start Of Frame events. When disabled, this stops the firing of the
* \ref EVENT_USB_Device_StartOfFrame() event when enumerated in device mode.
*
- * \note Not available when the NO_SOF_EVENTS compile time token is defined.
+ * \note Not available when the \c NO_SOF_EVENTS compile time token is defined.
*/
static inline void USB_Device_DisableSOFEvents(void) ATTR_ALWAYS_INLINE;
static inline void USB_Device_DisableSOFEvents(void)
* lower byte (when more than one descriptor of the given type exists, such as the
* case of string descriptors). The type may be one of the standard types defined
* in the DescriptorTypes_t enum, or may be a class-specific descriptor type value.
- * \param[in] wIndex The language ID of the string to return if the wValue type indicates DTYPE_String,
- * otherwise zero for standard descriptors, or as defined in a class-specific
- * standards.
+ * \param[in] wIndex The language ID of the string to return if the \c wValue type indicates
+ * \ref DTYPE_String, otherwise zero for standard descriptors, or as defined in a
+ * class-specific standards.
* \param[out] DescriptorAddress Pointer to the descriptor in memory. This should be set by the routine to
* the address of the descriptor.
* \param[out] MemoryAddressSpace A value from the \ref USB_DescriptorMemorySpaces_t enum to indicate the memory
* space in which the descriptor is stored. This parameter does not exist when one
- * of the USE_*_DESCRIPTORS compile time options is used.
+ * of the \c USE_*_DESCRIPTORS compile time options is used.
*
- * \note By default, the library expects all descriptors to be located in flash memory via the PROGMEM attribute.
+ * \note By default, the library expects all descriptors to be located in flash memory via the \c PROGMEM attribute.
* If descriptors should be located in RAM or EEPROM instead (to speed up access in the case of RAM, or to
- * allow the descriptors to be changed dynamically at runtime) either the USE_RAM_DESCRIPTORS or the
- * USE_EEPROM_DESCRIPTORS tokens may be defined in the project makefile and passed to the compiler by the -D
+ * allow the descriptors to be changed dynamically at runtime) either the \c USE_RAM_DESCRIPTORS or the
+ * \c USE_EEPROM_DESCRIPTORS tokens may be defined in the project makefile and passed to the compiler by the -D
* switch.
*
* \return Size in bytes of the descriptor if it exists, zero or \ref NO_DESCRIPTOR otherwise.
#if (!defined(FIXED_CONTROL_ENDPOINT_SIZE) || defined(__DOXYGEN__))
/** Default size of the default control endpoint's bank, until altered by the control endpoint bank size
- * value in the device descriptor. Not available if the FIXED_CONTROL_ENDPOINT_SIZE token is defined.
+ * value in the device descriptor. Not available if the \c FIXED_CONTROL_ENDPOINT_SIZE token is defined.
*/
#define ENDPOINT_CONTROLEP_DEFAULT_SIZE 8
#endif
#define ENDPOINT_EPNUM_MASK 0x07
/** Endpoint direction mask, for masking against endpoint addresses to retrieve the endpoint's
- * direction for comparing with the ENDPOINT_DESCRIPTOR_DIR_* masks.
+ * direction for comparing with the \c ENDPOINT_DESCRIPTOR_DIR_* masks.
*/
#define ENDPOINT_EPDIR_MASK 0x80
/** Maximum size in bytes of a given endpoint.
*
- * \param[in] EPIndex Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
+ * \param[in] EPIndex Endpoint number, a value between 0 and (\ref ENDPOINT_TOTAL_ENDPOINTS - 1)
*/
#define ENDPOINT_MAX_SIZE(EPIndex) _ENDPOINT_GET_MAXSIZE(EPIndex)
/** Indicates the total number of banks supported by the given endpoint.
*
- * \param[in] EPIndex Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)
+ * \param[in] EPIndex Endpoint number, a value between 0 and (\ref ENDPOINT_TOTAL_ENDPOINTS - 1)
*/
#define ENDPOINT_BANKS_SUPPORTED(EPIndex) _ENDPOINT_GET_BANKS(EPIndex)
* \param[in] Number Endpoint number to configure. This must be more than 0 and less than
* \ref ENDPOINT_TOTAL_ENDPOINTS.
*
- * \param[in] Type Type of endpoint to configure, a EP_TYPE_* mask. Not all endpoint types
+ * \param[in] Type Type of endpoint to configure, a \c EP_TYPE_* mask. Not all endpoint types
* are available on Low Speed USB devices - refer to the USB 2.0 specification.
*
* \param[in] Direction Endpoint data direction, either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.
* the endpoint's data direction). The bank size must indicate the maximum packet size
* that the endpoint can handle.
*
- * \param[in] Banks Number of banks to use for the endpoint being configured, an ENDPOINT_BANK_* mask.
+ * \param[in] Banks Number of banks to use for the endpoint being configured, an \c ENDPOINT_BANK_* mask.
* More banks uses more USB DPRAM, but offers better performance. Isochronous type
* endpoints <b>must</b> have at least two banks.
*
- * \note When the ORDERED_EP_CONFIG compile time option is used, Endpoints <b>must</b> be configured in ascending
- * order, or bank corruption will occur.
+ * \note When the \c ORDERED_EP_CONFIG compile time option is used, Endpoints <b>must</b> be configured in
+ * ascending order, or bank corruption will occur.
* \n\n
*
* \note Certain models of USB AVR's endpoints may have different maximum packet sizes based on the endpoint's
* \note This routine will automatically select the specified endpoint upon success. Upon failure, the endpoint
* which failed to reconfigure correctly will be selected.
*
- * \return Boolean true if the configuration succeeded, false otherwise.
+ * \return Boolean \c true if the configuration succeeded, \c false otherwise.
*/
static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
const uint8_t Type,
}
/** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's
- * In and Out pointers to the bank's contents.
+ * data In and Out pointers to the bank's contents.
*
* \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset.
*/
/** Determines if the currently selected endpoint is enabled, but not necessarily configured.
*
- * \return Boolean True if the currently selected endpoint is enabled, false otherwise.
+ * \return Boolean \c true if the currently selected endpoint is enabled, \c false otherwise.
*/
static inline bool Endpoint_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsEnabled(void)
*
* \ingroup Group_EndpointPacketManagement
*
- * \return Boolean true if the currently selected endpoint may be read from or written to, depending on its direction.
+ * \return Boolean \c true if the currently selected endpoint may be read from or written to, depending
+ * on its direction.
*/
static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsReadWriteAllowed(void)
/** Determines if the currently selected endpoint is configured.
*
- * \return Boolean true if the currently selected endpoint has been configured, false otherwise.
+ * \return Boolean \c true if the currently selected endpoint has been configured, \c false otherwise.
*/
static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsConfigured(void)
/** Returns a mask indicating which INTERRUPT type endpoints have interrupted - i.e. their
* interrupt duration has elapsed. Which endpoints have interrupted can be determined by
- * masking the return value against (1 << {Endpoint Number}).
+ * masking the return value against <tt>(1 << <i>{Endpoint Number}</i>)</tt>.
*
* \return Mask whose bits indicate which endpoints have interrupted.
*/
*
* \param[in] EndpointNumber Index of the endpoint whose interrupt flag should be tested.
*
- * \return Boolean true if the specified endpoint has interrupted, false otherwise.
+ * \return Boolean \c true if the specified endpoint has interrupted, \c false otherwise.
*/
static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber)
*
* \ingroup Group_EndpointPacketManagement
*
- * \return Boolean true if the current endpoint is ready for an IN packet, false otherwise.
+ * \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
*/
static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsINReady(void)
*
* \ingroup Group_EndpointPacketManagement
*
- * \return Boolean true if current endpoint is has received an OUT packet, false otherwise.
+ * \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
*/
static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsOUTReceived(void)
*
* \ingroup Group_EndpointPacketManagement
*
- * \return Boolean true if the selected endpoint has received a SETUP packet, false otherwise.
+ * \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
*/
static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsSETUPReceived(void)
*
* \ingroup Group_EndpointPacketManagement
*
- * \return Boolean true if the currently selected endpoint is stalled, false otherwise.
+ * \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
*/
static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Endpoint_IsStalled(void)
/** Determines the currently selected endpoint's direction.
*
- * \return The currently selected endpoint's direction, as a ENDPOINT_DIR_* mask.
+ * \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
*/
static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Endpoint_GetEndpointDirection(void)
/** Sets the direction of the currently selected endpoint.
*
- * \param[in] DirectionMask New endpoint direction, as a ENDPOINT_DIR_* mask.
+ * \param[in] DirectionMask New endpoint direction, as a \c ENDPOINT_DIR_* mask.
*/
static inline void Endpoint_SetEndpointDirection(const uint8_t DirectionMask) ATTR_ALWAYS_INLINE;
static inline void Endpoint_SetEndpointDirection(const uint8_t DirectionMask)
* project once the USB interface is initialized into device mode.
*
* If space is an issue, it is possible to fix this to a static value by defining the control
- * endpoint size in the FIXED_CONTROL_ENDPOINT_SIZE token passed to the compiler in the makefile
+ * endpoint size in the \c FIXED_CONTROL_ENDPOINT_SIZE token passed to the compiler in the makefile
* via the -D switch. When a fixed control endpoint size is used, the size is no longer dynamically
* read from the descriptors at runtime and instead fixed to the given value. When used, it is
* important that the descriptor control endpoint size value matches the size given as the
- * FIXED_CONTROL_ENDPOINT_SIZE token - it is recommended that the FIXED_CONTROL_ENDPOINT_SIZE token
- * be used in the descriptors to ensure this.
+ * \c FIXED_CONTROL_ENDPOINT_SIZE token - it is recommended that the \c FIXED_CONTROL_ENDPOINT_SIZE token
+ * be used in the device descriptors to ensure this.
*
* \note This variable should be treated as read-only in the user application, and never manually
* changed in value.
* occur.
*
* The default delay value may be overridden in the user project makefile by definining the
- * HOST_DEVICE_SETTLE_DELAY_MS token to tbe required delay in milliseconds, and passed to the
+ * \c HOST_DEVICE_SETTLE_DELAY_MS token to tbe required delay in milliseconds, and passed to the
* compiler using the -D switch.
*/
#define HOST_DEVICE_SETTLE_DELAY_MS 1000
* \ref EVENT_USB_Host_StartOfFrame() event to fire once per millisecond, synchronized to the USB bus,
* at the start of each USB frame when a device is enumerated while in host mode.
*
- * \note Not available when the NO_SOF_EVENTS compile time token is defined.
+ * \note Not available when the \c NO_SOF_EVENTS compile time token is defined.
*/
static inline void USB_Host_EnableSOFEvents(void) ATTR_ALWAYS_INLINE;
static inline void USB_Host_EnableSOFEvents(void)
/** Determines if a previously issued bus reset (via the \ref USB_Host_ResetBus() macro) has
* completed.
*
- * \return Boolean true if no bus reset is currently being sent, false otherwise.
+ * \return Boolean \c true if no bus reset is currently being sent, \c false otherwise.
*/
static inline bool USB_Host_IsBusResetComplete(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_Host_IsBusResetComplete(void)
* false otherwise. While suspended, no USB communications can occur until the bus is resumed,
* except for the Remote Wakeup event from the device if supported.
*
- * \return Boolean true if the bus is currently suspended, false otherwise.
+ * \return Boolean \c true if the bus is currently suspended, \c false otherwise.
*/
static inline bool USB_Host_IsBusSuspended(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_Host_IsBusSuspended(void)
/** Determines if the attached device is currently enumerated in Full Speed mode (12Mb/s), or
* false if the attached device is enumerated in Low Speed mode (1.5Mb/s).
*
- * \return Boolean true if the attached device is enumerated in Full Speed mode, false otherwise.
+ * \return Boolean \c true if the attached device is enumerated in Full Speed mode, \c false otherwise.
*/
static inline bool USB_Host_IsDeviceFullSpeed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_Host_IsDeviceFullSpeed(void)
/** Determines if the attached device is currently issuing a Remote Wakeup request, requesting
* that the host resume the USB bus and wake up the device, false otherwise.
*
- * \return Boolean true if the attached device has sent a Remote Wakeup request, false otherwise.
+ * \return Boolean \c true if the attached device has sent a Remote Wakeup request, \c false otherwise.
*/
static inline bool USB_Host_IsRemoteWakeupSent(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_Host_IsRemoteWakeupSent(void)
/** Determines if a resume from Remote Wakeup request is currently being sent to an attached
* device.
*
- * \return Boolean true if no resume request is currently being sent, false otherwise.
+ * \return Boolean \c true if no resume request is currently being sent, \c false otherwise.
*/
static inline bool USB_Host_IsResumeFromWakeupRequestSent(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_Host_IsResumeFromWakeupRequestSent(void)
}
/* Function Prototypes: */
- /** Convenience function. This routine sends a SetConfiguration standard request to the attached
+ /** Convenience function. This routine sends a SET CONFIGURATION standard request to the attached
* device, with the given configuration index. This can be used to easily set the device
* configuration without creating and sending the request manually.
*
*/
uint8_t USB_Host_SetDeviceConfiguration(const uint8_t ConfigNumber);
- /** Convenience function. This routine sends a GetDescriptor standard request to the attached
+ /** Convenience function. This routine sends a GET DESCRIPTOR standard request to the attached
* device, requesting the device descriptor. This can be used to easily retrieve information
* about the device such as its VID, PID and power requirements.
*
*/
uint8_t USB_Host_GetDeviceDescriptor(void* const DeviceDescriptorPtr);
- /** Convenience function. This routine sends a GetDescriptor standard request to the attached
+ /** Convenience function. This routine sends a GET DESCRIPTOR standard request to the attached
* device, requesting the string descriptor of the specified index. This can be used to easily
* retrieve string descriptors from the device by index, after the index is obtained from the
* Device or Configuration descriptors.
void* const Buffer,
const uint8_t BufferLength);
- /** Clears a stall condition on the given pipe, via a ClearFeature request to the attached device.
+ /** Clears a stall condition on the given pipe, via a CLEAR FEATURE standard request to the attached device.
*
* \note After this routine returns, the control pipe will be selected.
*
/** Determines if the device is currently sending a HNP to an attached host.
*
- * \return Boolean true if currently sending a HNP to the other connected device, false otherwise
+ * \return Boolean \c true if currently sending a HNP to the other connected device, \c false otherwise
*/
static inline bool USB_OTG_Device_IsSendingHNP(void) ATTR_ALWAYS_INLINE;
static inline bool USB_OTG_Device_IsSendingHNP(void)
/** Indicates if the connected device is not currently sending a HNP request.
*
- * \return Boolean true if a HNP is currently being issued by the connected device, false otherwise.
+ * \return Boolean \c true if a HNP is currently being issued by the connected device, \c false otherwise.
*/
static inline bool USB_OTG_Host_IsHNPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_OTG_Host_IsHNPReceived(void)
#define PIPE_EPNUM_MASK 0x0F
/** Endpoint direction mask, for masking against endpoint addresses to retrieve the endpoint's
- * direction for comparing with the ENDPOINT_DESCRIPTOR_DIR_* masks.
+ * direction for comparing with the \c ENDPOINT_DESCRIPTOR_DIR_* masks.
*/
#define PIPE_EPDIR_MASK 0x80
/* Enums: */
- /** Enum for the possible error return codes of the Pipe_WaitUntilReady function.
+ /** Enum for the possible error return codes of the \ref Pipe_WaitUntilReady() function.
*
* \ingroup Group_PipeRW
*/
*
* \ingroup Group_PipeRW
*
- * \return Total number of bytes in the currently selected Pipe's FIFO buffer.
+ * \return Total number of bytes in the currently selected pipe's FIFO buffer.
*/
static inline uint16_t Pipe_BytesInPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint16_t Pipe_BytesInPipe(void)
/** Determines if the currently selected pipe is enabled, but not necessarily configured.
*
- * \return Boolean True if the currently selected pipe is enabled, false otherwise.
+ * \return Boolean \c true if the currently selected pipe is enabled, \c false otherwise.
*/
static inline bool Pipe_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsEnabled(void)
/** Gets the current pipe token, indicating the pipe's data direction and type.
*
- * \return The current pipe token, as a PIPE_TOKEN_* mask.
+ * \return The current pipe token, as a \c PIPE_TOKEN_* mask.
*/
static inline uint8_t Pipe_GetPipeToken(void) ATTR_ALWAYS_INLINE;
static inline uint8_t Pipe_GetPipeToken(void)
return (UPCFG0X & (0x03 << PTOKEN0));
}
- /** Sets the token for the currently selected pipe to one of the tokens specified by the PIPE_TOKEN_*
+ /** Sets the token for the currently selected pipe to one of the tokens specified by the \c PIPE_TOKEN_*
* masks. This can be used on CONTROL type pipes, to allow for bidirectional transfer of data during
* control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices
* which have two endpoints of opposite direction sharing the same endpoint address within the device.
*
- * \param[in] Token New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask.
+ * \param[in] Token New pipe token to set the selected pipe to, as a \c PIPE_TOKEN_* mask.
*/
static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE;
static inline void Pipe_SetPipeToken(const uint8_t Token)
/** Determines if the currently selected pipe is configured.
*
- * \return Boolean true if the selected pipe is configured, false otherwise.
+ * \return Boolean \c true if the selected pipe is configured, \c false otherwise.
*/
static inline bool Pipe_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsConfigured(void)
*
* \param[in] PipeNumber Index of the pipe whose interrupt flag should be tested.
*
- * \return Boolean true if the specified pipe has interrupted, false otherwise.
+ * \return Boolean \c true if the specified pipe has interrupted, \c false otherwise.
*/
static inline bool Pipe_HasPipeInterrupted(const uint8_t PipeNumber) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_HasPipeInterrupted(const uint8_t PipeNumber)
/** Determines if the currently selected pipe is frozen, and not able to accept data.
*
- * \return Boolean true if the currently selected pipe is frozen, false otherwise.
+ * \return Boolean \c true if the currently selected pipe is frozen, \c false otherwise.
*/
static inline bool Pipe_IsFrozen(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsFrozen(void)
*
* \see \ref Pipe_GetErrorFlags() macro for information on retrieving the exact error flag.
*
- * \return Boolean true if an error has occurred on the selected pipe, false otherwise.
+ * \return Boolean \c true if an error has occurred on the selected pipe, \c false otherwise.
*/
static inline bool Pipe_IsError(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsError(void)
}
/** Gets a mask of the hardware error flags which have occurred on the currently selected pipe. This
- * value can then be masked against the PIPE_ERRORFLAG_* masks to determine what error has occurred.
+ * value can then be masked against the \c PIPE_ERRORFLAG_* masks to determine what error has occurred.
*
- * \return Mask comprising of PIPE_ERRORFLAG_* bits indicating what error has occurred on the selected pipe.
+ * \return Mask comprising of \c PIPE_ERRORFLAG_* bits indicating what error has occurred on the selected pipe.
*/
static inline uint8_t Pipe_GetErrorFlags(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline uint8_t Pipe_GetErrorFlags(void)
*
* \ingroup Group_PipePacketManagement
*
- * \return Boolean true if the currently selected pipe may be read from or written to, depending on its direction.
+ * \return Boolean \c true if the currently selected pipe may be read from or written to, depending
+ * on its direction.
*/
static inline bool Pipe_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsReadWriteAllowed(void)
*
* \ingroup Group_PipePacketManagement
*
- * \return Boolean true if the current pipe has received an IN packet, false otherwise.
+ * \return Boolean \c true if the current pipe has received an IN packet, \c false otherwise.
*/
static inline bool Pipe_IsINReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsINReceived(void)
*
* \ingroup Group_PipePacketManagement
*
- * \return Boolean true if the current pipe is ready for an OUT packet, false otherwise.
+ * \return Boolean \c true if the current pipe is ready for an OUT packet, \c false otherwise.
*/
static inline bool Pipe_IsOUTReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsOUTReady(void)
*
* \ingroup Group_PipePacketManagement
*
- * \return Boolean true if the current pipe is ready for a SETUP packet, false otherwise.
+ * \return Boolean \c true if the current pipe is ready for a SETUP packet, \c false otherwise.
*/
static inline bool Pipe_IsSETUPSent(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsSETUPSent(void)
*
* \ingroup Group_PipePacketManagement
*
- * \return Boolean true if an NAK has been received on the current pipe, false otherwise.
+ * \return Boolean \c true if an NAK has been received on the current pipe, \c false otherwise.
*/
static inline bool Pipe_IsNAKReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsNAKReceived(void)
*
* \ingroup Group_PipePacketManagement
*
- * \return Boolean true if the current pipe has been stalled by the attached device, false otherwise.
+ * \return Boolean \c true if the current pipe has been stalled by the attached device, \c false otherwise.
*/
static inline bool Pipe_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool Pipe_IsStalled(void)
*
* \param[in] Number Pipe number to configure. This must be more than 0 and less than \ref PIPE_TOTAL_PIPES.
*
- * \param[in] Type Type of pipe to configure, a EP_TYPE_* mask. Not all pipe types are available on Low
+ * \param[in] Type Type of pipe to configure, an \c EP_TYPE_* mask. Not all pipe types are available on Low
* Speed USB devices - refer to the USB 2.0 specification.
*
* \param[in] Token Pipe data token, either \ref PIPE_TOKEN_SETUP, \ref PIPE_TOKEN_OUT or \ref PIPE_TOKEN_IN.
* the pipe's data direction). The bank size must indicate the maximum packet size that
* the pipe can handle.
*
- * \param[in] Banks Number of banks to use for the pipe being configured, a PIPE_BANK_* mask. More banks
+ * \param[in] Banks Number of banks to use for the pipe being configured, a \c PIPE_BANK_* mask. More banks
* uses more USB DPRAM, but offers better performance. Isochronous type pipes <b>must</b>
* have at least two banks.
*
- * \note When the ORDERED_EP_CONFIG compile time option is used, Pipes <b>must</b> be configured in ascending order,
+ * \note When the \c ORDERED_EP_CONFIG compile time option is used, Pipes <b>must</b> be configured in ascending order,
* or bank corruption will occur.
* \n\n
*
* \note This routine will automatically select the specified pipe upon success. Upon failure, the pipe which
* failed to reconfigure correctly will be selected.
*
- * \return Boolean true if the configuration succeeded, false otherwise.
+ * \return Boolean \c true if the configuration succeeded, \c false otherwise.
*/
bool Pipe_ConfigurePipe(const uint8_t Number,
const uint8_t Type,
*
* \param[in] EndpointAddress Address and direction mask of the endpoint within the attached device to check.
*
- * \return Boolean true if a pipe bound to the given endpoint address of the specified direction is found, false
- * otherwise.
+ * \return Boolean \c true if a pipe bound to the given endpoint address of the specified direction is found,
+ * \c false otherwise.
*/
bool Pipe_IsEndpointBound(const uint8_t EndpointAddress);
/* Inline Functions: */
#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) || defined(__DOXYGEN__)
- /** Returns boolean true if the VBUS line is currently high (i.e. the USB host is supplying power),
- * otherwise returns false.
+ /** Determines if the VBUS line is currently high (i.e. the USB host is supplying power).
*
* \note This function is not available on some AVR models which do not support hardware VBUS monitoring.
+ *
+ * \return Boolean \c true if the VBUS line is currently detecting power from a host, \c false otherwise.
*/
static inline bool USB_VBUS_GetStatus(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
static inline bool USB_VBUS_GetStatus(void)
*
* \param[in] Options Mask indicating the options which should be used when initializing the USB
* interface to control the USB interface's behaviour. This should be comprised of
- * a USB_OPT_REG_* mask to control the regulator, a USB_OPT_*_PLL mask to control the
- * PLL, and a USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device
+ * a \c USB_OPT_REG_* mask to control the regulator, a \c USB_OPT_*_PLL mask to control the
+ * PLL, and a \c USB_DEVICE_OPT_* mask (when the device mode is enabled) to set the device
* mode speed.
*
* \note To reduce the FLASH requirements of the library if only device or host mode is required,
- * the mode can be statically set in the project makefile by defining the token USB_DEVICE_ONLY
- * (for device mode) or USB_HOST_ONLY (for host mode), passing the token to the compiler
+ * the mode can be statically set in the project makefile by defining the token \c USB_DEVICE_ONLY
+ * (for device mode) or \c USB_HOST_ONLY (for host mode), passing the token to the compiler
* via the -D switch. If the mode is statically set, this parameter does not exist in the
* function prototype.
* \n\n
*
* \note To reduce the FLASH requirements of the library if only fixed settings are are required,
* the options may be set statically in the same manner as the mode (see the Mode parameter of
- * this function). To statically set the USB options, pass in the USE_STATIC_OPTIONS token,
+ * this function). To statically set the USB options, pass in the \c USE_STATIC_OPTIONS token,
* defined to the appropriate options masks. When the options are statically set, this
* parameter does not exist in the function prototype.
* \n\n
* \note The mode parameter does not exist on devices where only one mode is possible, such as USB
* AVR models which only implement the USB device mode in hardware.
*
- * \see Device.h for the USB_DEVICE_OPT_* masks.
+ * \see \ref Group_Device for the \c USB_DEVICE_OPT_* masks.
*/
void USB_Init(
#if defined(USB_CAN_BE_BOTH) || defined(__DOXYGEN__)
*
* \note When the controller is initialized into UID autodetection mode, this variable will hold the
* currently selected USB mode (i.e. \ref USB_MODE_Device or \ref USB_MODE_Host). If the controller
- * is fixed into a specific mode (either through the USB_DEVICE_ONLY or USB_HOST_ONLY compile time
+ * is fixed into a specific mode (either through the \c USB_DEVICE_ONLY or \c USB_HOST_ONLY compile time
* options, or a limitation of the USB controller in the chosen device model) this will evaluate to
* a constant of the appropriate value and will never evaluate to \ref USB_MODE_None even when the
* USB interface is not initialized.
#if !defined(USE_STATIC_OPTIONS) || defined(__DOXYGEN__)
/** Indicates the current USB options that the USB interface was initialized with when \ref USB_Init()
- * was called. This value will be one of the USB_MODE_* masks defined elsewhere in this module.
+ * was called. This value will be one of the \c USB_MODE_* masks defined elsewhere in this module.
*
* \note This variable should be treated as read-only in the user application, and never manually
* changed in value.
* \subsection Sec_ClassDriverDevice Device Mode Class Drivers
* Implementing a Device Mode Class Driver in a user application requires a number of steps to be followed. Firstly,
* the module configuration and state structure must be added to the project source. These structures are named in a
- * similar manner between classes, that of <i>USB_ClassInfo_<b>{Class Name}</b>_Device_t</i>, and are used to hold the
+ * similar manner between classes, that of <tt>USB_ClassInfo_<i>{Class Name}</i>_Device_t</tt>, and are used to hold the
* complete state and configuration for each class instance. Multiple class instances is where the power of the class
- * drivers lie; multiple interfaces of the same class simply require more instances of the Class Driver's ClassInfo
+ * drivers lie; multiple interfaces of the same class simply require more instances of the Class Driver's \c USB_ClassInfo_*
* structure.
*
- * Inside the ClassInfo structure lies two sections, a <i>Config</i> section, and a <i>State</i> section. The Config
+ * Inside the ClassInfo structure lies two sections, a \c Config section, and a \c State section. The \c Config
* section contains the instance's configuration parameters, and <b>must have all fields set by the user application</b>
* before the class driver is used. Each Device mode Class driver typically contains a set of configuration parameters
* for the endpoint size/number of the associated logical USB interface, plus any class-specific configuration parameters.
*
- * The <i>State</i> section of the ClassInfo structures are designed to be controlled by the Class Drivers only for
+ * The \c State section of the \c USB_ClassInfo_* structures are designed to be controlled by the Class Drivers only for
* maintaining the Class Driver instance's state, and should not normally be set by the user application.
*
* The following is an example of a properly initialized instance of the Audio Class Driver structure:
* \note The class driver's configuration parameters should match those used in the device's descriptors that are
* sent to the host.
*
- * To initialize the Class driver instance, the driver's <i><b>{Class Name}</b>_Device_ConfigureEndpoints()</i> function
+ * To initialize the Class driver instance, the driver's <tt><i>{Class Name}</i>_Device_ConfigureEndpoints()</tt> function
* should be called in response to the \ref EVENT_USB_Device_ConfigurationChanged() event. This function will return a
* boolean value if the driver successfully initialized the instance. Like all the class driver functions, this function
* takes in the address of the specific instance you wish to initialize - in this manner, multiple separate instances of
- * the same class type can be initialized like thus:
+ * the same class type can be initialized like this:
*
* \code
* void EVENT_USB_Device_ConfigurationChanged(void)
* \endcode
*
* Once initialized, it is important to maintain the class driver's state by repeatedly calling the Class Driver's
- * <i><b>{Class Name}</b>_Device_USBTask()</i> function in the main program loop. The exact implementation of this
+ * <tt><i>{Class Name}</i>_Device_USBTask()</tt> function in the main program loop. The exact implementation of this
* function varies between class drivers, and can be used for any internal class driver purpose to maintain each
* instance. Again, this function uses the address of the instance to operate on, and thus needs to be called for each
* separate instance, just like the main USB maintenance routine \ref USB_USBTask():
* \endcode
*
* The final standardized Device Class Driver function is the Control Request handler function
- * <i><b>{Class Name}</b>_Device_ProcessControlRequest()</i>, which should be called when the
+ * <tt><i>{Class Name}</i>_Device_ProcessControlRequest()</tt>, which should be called when the
* \ref EVENT_USB_Device_ControlRequest() event fires. This function should also be called for
* each class driver instance, using the address of the instance to operate on as the function's
* parameter. The request handler will abort if it is determined that the current request is not
* }
* \endcode
*
- * Each class driver may also define a set of callback functions (which are prefixed by "CALLBACK_"
+ * Each class driver may also define a set of callback functions (which are prefixed by \c CALLBACK_*
* in the function's name) which <b>must</b> also be added to the user application - refer to each
* individual class driver's documentation for mandatory callbacks. In addition, each class driver may
- * also define a set of events (identifiable by their prefix of "EVENT_" in the function's name), which
+ * also define a set of events (identifiable by their prefix of \c EVENT_* in the function's name), which
* the user application <b>may</b> choose to implement, or ignore if not needed.
*
* The individual Device Mode Class Driver documentation contains more information on the non-standardized,
* \subsection Sec_ClassDriverHost Host Mode Class Drivers
* Implementing a Host Mode Class Driver in a user application requires a number of steps to be followed. Firstly,
* the module configuration and state structure must be added to the project source. These structures are named in a
- * similar manner between classes, that of <i>USB_ClassInfo_<b>{Class Name}</b>_Host_t</i>, and are used to hold the
+ * similar manner between classes, that of <tt>USB_ClassInfo_<b>{Class Name}</b>_Host_t</tt>, and are used to hold the
* complete state and configuration for each class instance. Multiple class instances is where the power of the class
- * drivers lie; multiple interfaces of the same class simply require more instances of the Class Driver's ClassInfo
+ * drivers lie; multiple interfaces of the same class simply require more instances of the Class Driver's \c USB_ClassInfo_*
* structure.
*
- * Inside the ClassInfo structure lies two sections, a <i>Config</i> section, and a <i>State</i> section. The Config
+ * Inside the \c USB_ClassInfo_* structure lies two sections, a \c Config section, and a \c State section. The \c Config
* section contains the instance's configuration parameters, and <b>must have all fields set by the user application</b>
* before the class driver is used. Each Device mode Class driver typically contains a set of configuration parameters
* for the endpoint size/number of the associated logical USB interface, plus any class-specific configuration parameters.
*
- * The <i>State</i> section of the ClassInfo structures are designed to be controlled by the Class Drivers only for
+ * The \c State section of the \c USB_ClassInfo_* structures are designed to be controlled by the Class Drivers only for
* maintaining the Class Driver instance's state, and should not normally be set by the user application.
*
* The following is an example of a properly initialized instance of the MIDI Class Driver structure:
* };
* \endcode
*
- * To initialize the Class driver instance, the driver's <i><b>{Class Name}</b>_Host_ConfigurePipes()</i> function
+ * To initialize the Class driver instance, the driver's <tt><b>{Class Name}</b>_Host_ConfigurePipes()</tt> function
* should be called in response to the host state machine entering the \ref HOST_STATE_Addressed state. This function
- * will return an error code from the class driver's <i><b>{Class Name}</b>_EnumerationFailure_ErrorCodes_t</i> enum
+ * will return an error code from the class driver's <tt><b>{Class Name}</b>_EnumerationFailure_ErrorCodes_t</tt> enum
* to indicate if the driver successfully initialized the instance and bound it to an interface in the attached device.
* Like all the class driver functions, this function takes in the address of the specific instance you wish to initialize -
* in this manner, multiple separate instances of the same class type can be initialized. A fragment of a Class Driver
* the configuration will fail.
*
* Once initialized, it is important to maintain the class driver's state by repeatedly calling the Class Driver's
- * <i><b>{Class Name}</b>_Host_USBTask()</i> function in the main program loop. The exact implementation of this
+ * <tt><b>{Class Name}</b>_Host_USBTask()</tt> function in the main program loop. The exact implementation of this
* function varies between class drivers, and can be used for any internal class driver purpose to maintain each
* instance. Again, this function uses the address of the instance to operate on, and thus needs to be called for each
* separate instance, just like the main USB maintenance routine \ref USB_USBTask():
* }
* \endcode
*
- * Each class driver may also define a set of callback functions (which are prefixed by "CALLBACK_"
+ * Each class driver may also define a set of callback functions (which are prefixed by \c CALLBACK_*
* in the function's name) which <b>must</b> also be added to the user application - refer to each
* individual class driver's documentation for mandatory callbacks. In addition, each class driver may
- * also define a set of events (identifiable by their prefix of "EVENT_" in the function's name), which
+ * also define a set of events (identifiable by their prefix of \c EVENT_* in the function's name), which
* the user application <b>may</b> choose to implement, or ignore if not needed.
*
* The individual Host Mode Class Driver documentation contains more information on the non-standardized,
* Simple round-robbin cooperative scheduler for use in basic projects where non real-time tasks need
* to be executed. Each task is executed in sequence, and can be enabled or disabled individually or as a group.
*
- * For a task to yield it must return, thus each task should have persistent data marked with the static attribute.
+ * For a task to yield it must \c return, thus each task should have persistent data marked with the \c static keyword.
*
* Each LUFA scheduler task should be written similar to an ISR; it should execute quickly (so that no one task
* hogs the processor, preventing another from running before some sort of timeout is exceeded). Unlike normal RTOS
* tasks, each LUFA scheduler task is a regular function, and thus must be designed to be called, and designed to
* return to the calling scheduler function repeatedly. Data which must be preserved between task calls should be
- * declared as global or (preferably) as a static local variable inside the task.
+ * declared as global or (preferably) as a \c static local variable inside the task.
*
* The scheduler consists of a task list, listing all the tasks which can be executed by the scheduler. Once started,
* each task is then called one after another, unless the task is stopped by another running task or interrupt.
*/
#define TASK(name) void name (void)
- /** Defines a task list array, containing one or more task entries of the type TaskEntry_t. Each task list
+ /** Defines a task list array, containing one or more task entries of the type \ref TaskEntry_t. Each task list
* should be encased in curly braces and ended with a comma.
*
* Usage Example:
/* Pseudo-Function Macros: */
#if defined(__DOXYGEN__)
/** Starts the scheduler in its infinite loop, executing running tasks. This should be placed at the end
- * of the user application's main() function, as it can never return to the calling function.
+ * of the user application's \c main() function, as it can never return to the calling function.
*/
void Scheduler_Start(void);
/** Initialises the scheduler so that the scheduler functions can be called before the scheduler itself
- * is started. This must be executed before any scheduler function calls other than Scheduler_Start(),
+ * is started. This must be executed before any scheduler function calls other than \ref Scheduler_Start(),
* and can be omitted if no such functions could be called before the scheduler is started.
*/
void Scheduler_Init(void);
/* Global Variables: */
/** Task entry list, containing the scheduler tasks, task statuses and group IDs. Each entry is of type
- * TaskEntry_t and can be manipulated as desired, although it is preferential that the proper Scheduler
+ * \ref TaskEntry_t and can be manipulated as desired, although it is preferred that the proper Scheduler
* functions should be used instead of direct manipulation.
*/
exter TaskEntry_t Scheduler_TaskList[];
* \param[in] Delay The delay to test for, measured in ticks.
* \param[in] DelayCounter The counter which is storing the starting tick value for the delay.
*
- * \return Boolean true if the delay has elapsed, false otherwise.
+ * \return Boolean \c true if the delay has elapsed, \c false otherwise.
*
* Usage Example:
* \code
projects / pub / USBasp.git / commitdiff