arising out of or in connection with the use or performance of\r
this software.\r
*/\r
-\r
-/** \file\r
- *\r
- * Functions, macros and enums related to pipe management when in USB Host mode. This\r
- * module contains the pipe management macros, as well as pipe interrupt and data\r
- * send/recieve functions for various data types.\r
- */\r
\r
/** \ingroup Group_USB\r
* @defgroup Group_PipeManagement Pipe Management\r
*\r
- * Functions, macros, variables, enums and types related to the setup and management of pipes while in USB Device mode.\r
+ * This module contains functions, macros and enums related to pipe management when in USB Host mode. This\r
+ * module contains the pipe management macros, as well as pipe interrupt and data send/recieve functions\r
+ * for various data types.\r
*\r
* @{\r
*/\r
\r
/** @defgroup Group_PipeControlReq Pipe Control Request Management\r
*\r
- * Functions, macros, variables, enums and types related to control request management of pipes.\r
- */\r
+ * Module for host mode request processing. This module allows for the transmission of standard, class and\r
+ * vendor control requests to the default control endpoint of an attached device while in host mode.\r
+ *\r
+ * \see Chapter 9 of the USB 2.0 specification.\r
+ */ \r
\r
#ifndef __PIPE_H__\r
#define __PIPE_H__\r
\r
/* Public Interface - May be used in end-application: */\r
/* Macros: */\r
- /** Mask for Pipe_GetErrorFlags(), indicating that a CRC error occurred in the pipe on the received data. */\r
+ /** Mask for \ref Pipe_GetErrorFlags(), indicating that a CRC error occurred in the pipe on the received data. */\r
#define PIPE_ERRORFLAG_CRC16 (1 << 4)\r
\r
- /** Mask for Pipe_GetErrorFlags(), indicating that a hardware timeout error occurred in the pipe. */\r
+ /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware timeout error occurred in the pipe. */\r
#define PIPE_ERRORFLAG_TIMEOUT (1 << 3)\r
\r
- /** Mask for Pipe_GetErrorFlags(), indicating that a hardware PID error occurred in the pipe. */\r
+ /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware PID error occurred in the pipe. */\r
#define PIPE_ERRORFLAG_PID (1 << 2)\r
\r
- /** Mask for Pipe_GetErrorFlags(), indicating that a hardware data PID error occurred in the pipe. */\r
+ /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware data PID error occurred in the pipe. */\r
#define PIPE_ERRORFLAG_DATAPID (1 << 1)\r
\r
- /** Mask for Pipe_GetErrorFlags(), indicating that a hardware data toggle error occurred in the pipe. */\r
+ /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware data toggle error occurred in the pipe. */\r
#define PIPE_ERRORFLAG_DATATGL (1 << 0)\r
\r
- /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a SETUP token (for CONTROL type pipes),\r
+ /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a SETUP token (for CONTROL type pipes),\r
* which will trigger a control request on the attached device when data is written to the pipe.\r
*/\r
#define PIPE_TOKEN_SETUP (0 << PTOKEN0)\r
\r
- /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
+ /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
* indicating that the pipe data will flow from device to host.\r
*/\r
#define PIPE_TOKEN_IN (1 << PTOKEN0)\r
\r
- /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
+ /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
* indicating that the pipe data will flow from host to device.\r
*/\r
#define PIPE_TOKEN_OUT (2 << PTOKEN0)\r
\r
- /** Mask for the bank mode selection for the Pipe_ConfigurePipe() macro. This indicates that the pipe\r
+ /** Mask for the bank mode selection for the \ref Pipe_ConfigurePipe() macro. This indicates that the pipe\r
* should have one single bank, which requires less USB FIFO memory but results in slower transfers as\r
* only one USB device (the AVR or the attached device) can access the pipe's bank at the one time.\r
*/\r
#define PIPE_BANK_SINGLE (0 << EPBK0)\r
\r
- /** Mask for the bank mode selection for the Pipe_ConfigurePipe() macro. This indicates that the pipe\r
+ /** Mask for the bank mode selection for the \ref Pipe_ConfigurePipe() macro. This indicates that the pipe\r
* should have two banks, which requires more USB FIFO memory but results in faster transfers as one\r
* USB device (the AVR or the attached device) can access one bank while the other accesses the second\r
* bank.\r
/** Default size of the default control pipe's bank, until altered by the Endpoint0Size value \r
* in the device descriptor of the attached device.\r
*/\r
- #define PIPE_CONTROLPIPE_DEFAULT_SIZE 8\r
+ #define PIPE_CONTROLPIPE_DEFAULT_SIZE 64\r
\r
/** Pipe number mask, for masking against pipe addresses to retrieve the pipe's numerical address\r
* in the device.\r
*/\r
#define PIPE_EPSIZE_MASK 0x7FF\r
\r
- /** Interrupt definition for the pipe IN interrupt (for INTERRUPT type pipes). Should be used with\r
- * the USB_INT_* macros located in USBInterrupt.h.\r
- *\r
- * This interrupt will fire if enabled on an INTERRUPT type pipe if the pipe interrupt period has\r
- * elapsed and the pipe is ready for the next packet from the attached device to be read out from its\r
- * FIFO buffer (if received).\r
- *\r
- * \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
- * is selected), and will fire the common pipe interrupt vector.\r
- *\r
- * \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
- */\r
- #define PIPE_INT_IN UPIENX, (1 << RXINE) , UPINTX, (1 << RXINI)\r
-\r
- /** Interrupt definition for the pipe OUT interrupt (for INTERRUPT type pipes). Should be used with\r
- * the USB_INT_* macros located in USBInterrupt.h.\r
- *\r
- * This interrupt will fire if enabled on an INTERRUPT type endpoint if a the pipe interrupt period\r
- * has elapsed and the pipe is ready for a packet to be written to the pipe's FIFO buffer and sent\r
- * to the attached device (if required).\r
- * \r
- * \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
- * is selected), and will fire the common pipe interrupt vector.\r
- *\r
- * \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
- */\r
- #define PIPE_INT_OUT UPIENX, (1 << TXOUTE), UPINTX, (1 << TXOUTI)\r
-\r
- /** Interrupt definition for the pipe SETUP bank ready interrupt (for CONTROL type pipes). Should be\r
- * used with the USB_INT_* macros located in USBInterrupt.h.\r
- *\r
- * This interrupt will fire if enabled on an CONTROL type pipe when the pipe is ready for a new\r
- * control request.\r
- *\r
- * \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
- * is selected), and will fire the common pipe interrupt vector.\r
- *\r
- * \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
- */\r
- #define PIPE_INT_SETUP UPIENX, (1 << TXSTPE) , UPINTX, (1 << TXSTPI)\r
-\r
- /** Interrupt definition for the pipe error interrupt. Should be used with the USB_INT_* macros\r
- * located in USBInterrupt.h.\r
- *\r
- * This interrupt will fire if enabled on a particular pipe if an error occurs on that pipe, such\r
- * as a CRC mismatch error.\r
- *\r
- * \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
- * is selected), and will fire the common pipe interrupt vector.\r
- *\r
- * \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
- *\r
- * \see Pipe_GetErrorFlags() for more information on the pipe errors.\r
- */\r
- #define PIPE_INT_ERROR UPIENX, (1 << PERRE), UPINTX, (1 << PERRI)\r
-\r
- /** Interrupt definition for the pipe NAK received interrupt. Should be used with the USB_INT_* macros\r
- * located in USBInterrupt.h.\r
- *\r
- * This interrupt will fire if enabled on a particular pipe if an attached device returns a NAK in\r
- * response to a sent packet.\r
- *\r
- * \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
- * is selected), and will fire the common pipe interrupt vector.\r
- *\r
- * \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
- *\r
- * \see Pipe_IsNAKReceived() for more information on pipe NAKs.\r
- */\r
- #define PIPE_INT_NAK UPIENX, (1 << NAKEDE), UPINTX, (1 << NAKEDI)\r
-\r
- /** Interrupt definition for the pipe STALL received interrupt. Should be used with the USB_INT_* macros\r
- * located in USBInterrupt.h.\r
- *\r
- * This interrupt will fire if enabled on a particular pipe if an attached device returns a STALL on the\r
- * currently selected pipe. This will also fire if the pipe is an isochronous pipe and a CRC error occurs.\r
- *\r
- * \note This interrupt must be enabled and cleared on *each* pipe which requires it (after the pipe\r
- * is selected), and will fire the common pipe interrupt vector.\r
- *\r
- * \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
- */\r
- #define PIPE_INT_STALL UPIENX, (1 << RXSTALLE), UPINTX, (1 << RXSTALLI)\r
-\r
- /* Psuedo-Function Macros: */\r
+ /* Pseudo-Function Macros: */\r
#if defined(__DOXYGEN__)\r
/** Indicates the number of bytes currently stored in the current pipes's selected bank.\r
*\r
/** Enables the currently selected pipe so that data can be sent and received through it to and from\r
* an attached device.\r
*\r
- * \note Pipes must first be configured properly rather than just being enabled via the\r
- * Pipe_ConfigurePipe() macro, which calls Pipe_EnablePipe() automatically.\r
+ * \note Pipes must first be configured properly via \ref Pipe_ConfigurePipe().\r
*/\r
static inline void Pipe_EnablePipe(void);\r
\r
*/\r
static inline uint8_t Pipe_GetPipeInterrupts(void);\r
\r
- /** Clears the interrupt flag for the specified pipe number.\r
- *\r
- * \param PipeNumber Index of the pipe whose interrupt flag is to be cleared\r
- */\r
- static inline void Pipe_ClearPipeInterrupt(uint8_t PipeNumber);\r
- \r
/** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type\r
* pipes).\r
*\r
/** Determines if the master pipe error flag is set for the currently selected pipe, indicating that\r
* some sort of hardware error has occurred on the pipe.\r
*\r
- * \see Pipe_GetErrorFlags() macro for information on retrieving the exact error flag.\r
+ * \see \ref Pipe_GetErrorFlags() macro for information on retrieving the exact error flag.\r
*\r
- * \return Boolean true if an error has ocurred on the selected pipe, false otherwise\r
+ * \return Boolean true if an error has occurred on the selected pipe, false otherwise\r
*/\r
static inline bool Pipe_IsError(void);\r
\r
/** Gets a mask of the hardware error flags which have occurred on the currently selected pipe. This\r
* value can then be masked against the PIPE_ERRORFLAG_* masks to determine what error has occurred.\r
*\r
- * \return Mask comprising of PIPE_ERRORFLAG_* bits indicating what error has ocurred on the selected pipe\r
+ * \return Mask comprising of PIPE_ERRORFLAG_* bits indicating what error has occurred on the selected pipe\r
*/\r
static inline uint8_t Pipe_GetErrorFlags(void);\r
\r
* is an IN direction and no packet (or an empty packet) has been received, or if the pipe is an OUT\r
* direction and the pipe bank is full.\r
*\r
+ * \note This function is not valid on CONTROL type pipes.\r
+ *\r
* \ingroup Group_PipePacketManagement\r
* \r
* \return Boolean true if the currently selected pipe may be read from or written to, depending on its direction\r
*/\r
static inline bool Pipe_IsSETUPSent(void);\r
\r
- /** Acknowledges the reception of a setup IN request from the attached device on the currently selected\r
- * CONTROL type pipe, freeing the bank ready for the next packet.\r
- *\r
- * \ingroup Group_PipePacketManagement\r
- *\r
- * \note For non CONTROL type pipes, use Pipe_ClearIN() instead. \r
- */\r
- static inline void Pipe_ClearControlIN(void);\r
-\r
- /** Sends the currently selected pipe's contents to the device as an OUT packet on the selected pipe, freeing\r
- * the bank ready for the next packet.\r
- *\r
- * \ingroup Group_PipePacketManagement\r
- *\r
- * \note For non CONTROL type pipes, use Pipe_ClearOUT() instead. \r
- */\r
- static inline void Pipe_ClearControlOUT(void);\r
-\r
/** Sends the currently selected CONTROL type pipe's contents to the device as a SETUP packet.\r
*\r
- * \ingroup Group_PipePacketManagement\r
- *\r
- * \note This is not applicable for non CONTROL type pipes. \r
+ * \ingroup Group_PipePacketManagement \r
*/\r
- static inline void Pipe_ClearControlSETUP(void);\r
+ static inline void Pipe_ClearSETUP(void);\r
\r
/** Acknowledges the reception of a setup IN request from the attached device on the currently selected\r
* pipe, freeing the bank ready for the next packet.\r
*\r
* \ingroup Group_PipePacketManagement\r
- *\r
- * \note For CONTROL type pipes, use Pipe_ClearControlIN() instead. \r
*/\r
static inline void Pipe_ClearIN(void);\r
\r
* the bank ready for the next packet.\r
*\r
* \ingroup Group_PipePacketManagement\r
- *\r
- * \note For CONTROL type pipes, use Pipe_ClearControlOUT() instead. \r
*/\r
static inline void Pipe_ClearOUT(void);\r
\r
/** Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on\r
* the currently selected pipe. This occurs when the host sends a packet to the device, but the device\r
* is not currently ready to handle the packet (i.e. its endpoint banks are full). Once a NAK has been\r
- * received, it must be cleared using Pipe_ClearNAKReceived() before the previous (or any other) packet\r
+ * received, it must be cleared using \ref Pipe_ClearNAKReceived() before the previous (or any other) packet\r
* can be re-sent.\r
*\r
* \ingroup Group_PipePacketManagement\r
*\r
* \ingroup Group_PipePacketManagement\r
*\r
- * \see Pipe_IsNAKReceived() for more details.\r
+ * \see \ref Pipe_IsNAKReceived() for more details.\r
*/\r
static inline void Pipe_ClearNAKReceived(void);\r
\r
\r
#define Pipe_GetPipeInterrupts() UPINT\r
\r
- #define Pipe_ClearPipeInterrupt(n) MACROS{ UPINT &= ~(1 << n); }MACROE\r
-\r
#define Pipe_HasPipeInterrupted(n) ((UPINT & (1 << n)) ? true : false)\r
\r
#define Pipe_Unfreeze() MACROS{ UPCONX &= ~(1 << PFREEZE); }MACROE\r
#define Pipe_ClearIN() MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << RXINI)); \\r
UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
\r
- #define Pipe_ClearControlIN() MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << RXINI)); \\r
- UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
-\r
#define Pipe_ClearOUT() MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << TXOUTI)); \\r
UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
\r
- #define Pipe_ClearControlOUT() MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << TXOUTI)); \\r
- UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
-\r
- #define Pipe_ClearControlSETUP() MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << TXSTPI)); \\r
+ #define Pipe_ClearSETUP() MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << TXSTPI)); \\r
UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
\r
#define Pipe_IsNAKReceived() ((UPINTX & (1 << NAKEDI)) ? true : false)\r
PIPE_READYWAIT_DeviceDisconnected = 2, /**< Device was disconnected from the host while waiting. */\r
PIPE_READYWAIT_Timeout = 3, /**< The device failed to accept or send the next packet\r
* within the software timeout period set by the\r
- * USB_STREAM_TIMEOUT_MS macro.\r
+ * \ref USB_STREAM_TIMEOUT_MS macro.\r
*/\r
};\r
\r
*/\r
enum Pipe_Stream_RW_ErrorCodes_t\r
{\r
- PIPE_RWSTREAM_ERROR_NoError = 0, /**< Command completed successfully, no error. */\r
- PIPE_RWSTREAM_ERROR_PipeStalled = 1, /**< The device stalled the pipe during the transfer. */ \r
- PIPE_RWSTREAM_ERROR_DeviceDisconnected = 2, /**< Device was disconnected from the host during\r
- * the transfer.\r
- */ \r
- PIPE_RWSTREAM_ERROR_Timeout = 3, /**< The device failed to accept or send the next packet\r
- * within the software timeout period set by the\r
- * USB_STREAM_TIMEOUT_MS macro.\r
- */\r
- PIPE_RWSTREAM_ERROR_CallbackAborted = 4, /**< Indicates that the stream's callback function aborted\r
- * the transfer early.\r
- */\r
+ PIPE_RWSTREAM_NoError = 0, /**< Command completed successfully, no error. */\r
+ PIPE_RWSTREAM_PipeStalled = 1, /**< The device stalled the pipe during the transfer. */ \r
+ PIPE_RWSTREAM_DeviceDisconnected = 2, /**< Device was disconnected from the host during\r
+ * the transfer.\r
+ */ \r
+ PIPE_RWSTREAM_Timeout = 3, /**< The device failed to accept or send the next packet\r
+ * within the software timeout period set by the\r
+ * \ref USB_STREAM_TIMEOUT_MS macro.\r
+ */\r
+ PIPE_RWSTREAM_CallbackAborted = 4, /**< Indicates that the stream's callback function aborted\r
+ * the transfer early.\r
+ */\r
};\r
\r
/* Inline Functions: */\r
*\r
* \ingroup Group_PipeRW\r
*/\r
- static inline void Pipe_Ignore_DWord(void) ATTR_ALWAYS_INLINE;\r
- static inline void Pipe_Ignore_DWord(void)\r
+ static inline void Pipe_Discard_DWord(void) ATTR_ALWAYS_INLINE;\r
+ static inline void Pipe_Discard_DWord(void)\r
{\r
uint8_t Dummy;\r
\r
/* Function Prototypes: */\r
/** Configures the specified pipe number with the given pipe type, token, target endpoint number in the\r
* attached device, bank size and banking mode. Pipes should be allocated in ascending order by their\r
- * address in the device (i.e. pipe 1 should be configured before pipe 2 and so on).\r
+ * address in the device (i.e. pipe 1 should be configured before pipe 2 and so on) to prevent fragmentation\r
+ * of the USB FIFO memory.\r
*\r
* The pipe type may be one of the EP_TYPE_* macros listed in LowLevel.h, the token may be one of the\r
* PIPE_TOKEN_* masks.\r
* numbers can handle different maximum packet sizes - refer to the chosen USB AVR's datasheet to\r
* determine the maximum bank size for each pipe.\r
*\r
- * The banking mode may be either PIPE_BANK_SINGLE or PIPE_BANK_DOUBLE.\r
+ * The banking mode may be either \ref PIPE_BANK_SINGLE or \ref PIPE_BANK_DOUBLE.\r
*\r
- * A newly configured pipe is frozen by default, and must be unfrozen before use via the Pipe_Unfreeze() macro.\r
+ * A newly configured pipe is frozen by default, and must be unfrozen before use via the \ref Pipe_Unfreeze() macro.\r
+ *\r
+ * \note The default control pipe does not have to be manually configured, as it is automatically\r
+ * configured by the library internally.\r
*\r
* \note This routine will select the specified pipe, and the pipe will remain selected once the\r
* routine completes regardless of if the pipe configuration succeeds.\r
/** Spinloops until the currently selected non-control pipe is ready for the next packed of data\r
* to be read or written to it.\r
*\r
- * \note This routine should not be called on CONTROL type pipes.\r
- *\r
* \ingroup Group_PipeRW\r
*\r
* \return A value from the Pipe_WaitUntilReady_ErrorCodes_t enum.\r
/** Writes the given number of bytes to the pipe from the given buffer in little endian,\r
* sending full packets to the device as needed. The last packet filled is not automatically sent;\r
* the user is responsible for manually sending the last written packet to the host via the\r
- * Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r
+ * \ref Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r
* executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
*\r
- * The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
- * NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
- * and this function has the Callback parameter omitted.\r
+ * 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
+ * disabled and this function has the Callback parameter omitted.\r
*\r
* \ingroup Group_PipeRW\r
*\r
* \param Length Number of bytes to read for the currently selected pipe into the buffer.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
*\r
- * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+ * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
*/\r
uint8_t Pipe_Write_Stream_LE(const void* Buffer, uint16_t Length\r
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
- , uint8_t (* const Callback)(void)\r
+ , StreamCallbackPtr_t Callback\r
#endif\r
) ATTR_NON_NULL_PTR_ARG(1); \r
\r
/** Writes the given number of bytes to the pipe from the given buffer in big endian,\r
* sending full packets to the device as needed. The last packet filled is not automatically sent;\r
* the user is responsible for manually sending the last written packet to the host via the\r
- * Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r
+ * \ref Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r
* executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
*\r
- * The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
- * NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
- * and this function has the Callback parameter omitted.\r
+ * 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
+ * disabled and this function has the Callback parameter omitted.\r
*\r
* \ingroup Group_PipeRW\r
*\r
* \param Length Number of bytes to read for the currently selected pipe into the buffer.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
*\r
- * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+ * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
*/\r
uint8_t Pipe_Write_Stream_BE(const void* Buffer, uint16_t Length\r
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
- , uint8_t (* const Callback)(void)\r
+ , StreamCallbackPtr_t Callback\r
#endif\r
) ATTR_NON_NULL_PTR_ARG(1);\r
\r
/** Reads and discards the given number of bytes from the pipe, discarding fully read packets from the host\r
* as needed. The last packet is not automatically discarded once the remaining bytes has been read; the\r
- * user is responsible for manually discarding the last packet from the device via the Pipe_ClearIN() macro.\r
+ * user is responsible for manually discarding the last packet from the device via the \ref Pipe_ClearIN() macro.\r
* Between each USB packet, the given stream callback function is executed repeatedly until the next packet is ready,\r
* allowing for early aborts of stream transfers.\r
*\r
- * The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
- * NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
- * and this function has the Callback parameter omitted.\r
+ * 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
+ * disabled and this function has the Callback parameter omitted.\r
*\r
* \ingroup Group_PipeRW\r
*\r
* \param Length Number of bytes to send via the currently selected pipe.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
*\r
- * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+ * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
*/\r
uint8_t Pipe_Discard_Stream(uint16_t Length\r
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
- , uint8_t (* const Callback)(void)\r
+ , StreamCallbackPtr_t Callback\r
#endif\r
);\r
\r
/** Reads the given number of bytes from the pipe into the given buffer in little endian,\r
* sending full packets to the device as needed. The last packet filled is not automatically sent;\r
* the user is responsible for manually sending the last written packet to the host via the\r
- * Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r
+ * \ref Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r
* executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
*\r
- * The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
- * NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
- * and this function has the Callback parameter omitted.\r
+ * 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
+ * disabled and this function has the Callback parameter omitted.\r
*\r
* \ingroup Group_PipeRW\r
*\r
* \param Length Number of bytes to read for the currently selected pipe to read from.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
*\r
- * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+ * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
*/\r
uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length\r
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
- , uint8_t (* const Callback)(void)\r
+ , StreamCallbackPtr_t Callback\r
#endif\r
) ATTR_NON_NULL_PTR_ARG(1);\r
\r
/** Reads the given number of bytes from the pipe into the given buffer in big endian,\r
* sending full packets to the device as needed. The last packet filled is not automatically sent;\r
* the user is responsible for manually sending the last written packet to the host via the\r
- * Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r
+ * \ref Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r
* executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
*\r
- * The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
- * NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
- * and this function has the Callback parameter omitted.\r
+ * 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
+ * disabled and this function has the Callback parameter omitted.\r
*\r
* \ingroup Group_PipeRW\r
*\r
* \param Length Number of bytes to read for the currently selected pipe to read from.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
*\r
- * \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+ * \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
*/\r
uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length\r
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
- , uint8_t (* const Callback)(void)\r
+ , StreamCallbackPtr_t Callback\r
#endif\r
) ATTR_NON_NULL_PTR_ARG(1);\r
\r
/* Macros: */\r
#define PIPE_TOKEN_MASK (0x03 << PTOKEN0)\r
\r
+ #if !defined(ENDPOINT_CONTROLEP)\r
+ #define ENDPOINT_CONTROLEP 0\r
+ #endif\r
+ \r
#define Pipe_AllocateMemory() MACROS{ UPCFG1X |= (1 << ALLOC); }MACROE\r
#define Pipe_DeallocateMemory() MACROS{ UPCFG1X &= ~(1 << ALLOC); }MACROE\r
\r
projects / pub / USBasp.git / blobdiff