* 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
+ *\r
+ * @{\r
+ */\r
+\r
+/** @defgroup Group_PipeRW Pipe Data Reading and Writing\r
+ *\r
+ * Functions, macros, variables, enums and types related to data reading and writing from and to pipes.\r
+ */\r
+ \r
+/** @defgroup Group_PipePacketManagement Pipe Packet Management\r
+ *\r
+ * Functions, macros, variables, enums and types related to packet management of pipes.\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
+\r
#ifndef __PIPE_H__\r
#define __PIPE_H__\r
\r
*/\r
#define PIPE_INT_STALL UPIENX, (1 << RXSTALLE), UPINTX, (1 << RXSTALLI)\r
\r
- /** Indicates the number of bytes currently stored in the current pipe's selected bank. */\r
- #define Pipe_BytesInPipe() UPBCX\r
+ /* Psuedo-Function Macros: */\r
+ #if defined(__DOXYGEN__)\r
+ /** Indicates the number of bytes currently stored in the current pipes's selected bank.\r
+ *\r
+ * \note The return width of this function may differ, depending on the maximum pipe bank size\r
+ * of the selected AVR model.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \return Total number of bytes in the currently selected Pipe's FIFO buffer\r
+ */\r
+ static inline uint16_t Pipe_BytesInPipe(void);\r
+ \r
+ /** Returns the pipe address of the currently selected pipe. This is typically used to save the\r
+ * currently selected pipe number so that it can be restored after another pipe has been manipulated.\r
+ *\r
+ * \return Index of the currently selected pipe\r
+ */\r
+ static inline uint8_t Pipe_GetCurrentPipe(void);\r
+\r
+ /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
+ * indicated will operate on the currently selected pipe.\r
+ *\r
+ * \param PipeNumber Index of the pipe to select\r
+ */\r
+ static inline void Pipe_SelectPipe(uint8_t PipeNumber);\r
+ \r
+ /** Resets the desired pipe, including the pipe banks and flags.\r
+ *\r
+ * \param PipeNumber Index of the pipe to reset\r
+ */\r
+ static inline void Pipe_ResetPipe(uint8_t PipeNumber);\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
+ */\r
+ static inline void Pipe_EnablePipe(void);\r
+\r
+ /** Disables the currently selected pipe so that data cannot be sent and received through it to and\r
+ * from an attached device.\r
+ */\r
+ static inline void Pipe_DisablePipe(void);\r
+\r
+ /** Determines if the currently selected pipe is enabled, but not necessarily configured.\r
+ *\r
+ * \return Boolean True if the currently selected pipe is enabled, false otherwise\r
+ */\r
+ static inline bool Pipe_IsEnabled(void);\r
+ \r
+ /** Gets the current pipe token, indicating the pipe's data direction and type.\r
+ *\r
+ * \return The current pipe token, as a PIPE_TOKEN_* mask\r
+ */\r
+ static inline uint8_t Pipe_GetCurrentToken(void);\r
+ \r
+ /** Sets the token for the currently selected pipe to one of the tokens specified by the PIPE_TOKEN_*\r
+ * masks. This can be used on CONTROL type pipes, to allow for bidirectional transfer of data during\r
+ * control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices\r
+ * which have two endpoints of opposite direction sharing the same endpoint address within the device.\r
+ *\r
+ * \param Token New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask\r
+ */\r
+ static inline void Pipe_SetPipeToken(uint8_t Token);\r
+ \r
+ /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */\r
+ static inline void Pipe_SetInfiniteINRequests(void);\r
+ \r
+ /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
+ * accepted by the pipe before it is automatically frozen.\r
+ *\r
+ * \param TotalINRequests Total number of IN requests that the pipe may receive before freezing\r
+ */\r
+ static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);\r
+\r
+ /** Determines if the currently selected pipe is configured.\r
+ *\r
+ * \return Boolean true if the selected pipe is configured, false otherwise\r
+ */\r
+ static inline bool Pipe_IsConfigured(void);\r
+ \r
+ /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
+ *\r
+ * \param Milliseconds Number of milliseconds between each pipe poll\r
+ */\r
+ static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);\r
+ \r
+ /** Returns a mask indicating which pipe's interrupt periods have elapsed, indicating that the pipe should\r
+ * be serviced.\r
+ *\r
+ * \return Mask whose bits indicate which pipes have interrupted\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
+ * \param PipeNumber Index of the pipe whose interrupt flag should be tested\r
+ *\r
+ * \return Boolean true if the specified pipe has interrupted, false otherwise\r
+ */\r
+ static inline bool Pipe_HasPipeInterrupted(uint8_t PipeNumber);\r
+ \r
+ /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */\r
+ static inline void Pipe_Unfreeze(void);\r
+ \r
+ /** Freezes the selected pipe, preventing it from communicating with an attached device. */\r
+ static inline void Pipe_Freeze(void);\r
\r
- /** Resets the desired pipe, including the pipe banks and flags. */\r
- #define Pipe_ResetPipe(pipenum) MACROS{ UPRST = (1 << pipenum); UPRST = 0; }MACROE\r
+ /** Clears the master pipe error flag. */\r
+ static inline void Pipe_ClearError(void);\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
+ *\r
+ * \return Boolean true if an error has ocurred on the selected pipe, false otherwise\r
+ */\r
+ static inline bool Pipe_IsError(void);\r
+ \r
+ /** Clears all the currently selected pipe's hardware error flags, but does not clear the master error\r
+ * flag for the pipe.\r
+ */\r
+ static inline void Pipe_ClearErrorFlags(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
+ */\r
+ static inline uint8_t Pipe_GetErrorFlags(void);\r
+ \r
+ /** Determines if the currently selected pipe may be read from (if data is waiting in the pipe\r
+ * bank and the pipe is an IN direction, or if the bank is not yet full if the pipe is an OUT\r
+ * direction). This function will return false if an error has occurred in the pipe, or if the pipe\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
+ * \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_IsReadWriteAllowed(void);\r
+ \r
+ /** Determines if an IN request has been received on the currently selected pipe.\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ *\r
+ * \return Boolean true if the current pipe has received an IN packet, false otherwise.\r
+ */\r
+ static inline bool Pipe_IsINReceived(void);\r
+ \r
+ /** Determines if the currently selected pipe is ready to send an OUT request.\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ *\r
+ * \return Boolean true if the current pipe is ready for an OUT packet, false otherwise.\r
+ */\r
+ static inline bool Pipe_IsOUTReady(void);\r
+\r
+ /** Determines if no SETUP request is currently being sent to the attached device on the selected\r
+ * CONTROL type pipe.\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ *\r
+ * \return Boolean true if the current pipe is ready for a SETUP packet, false otherwise.\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
+ */\r
+ static inline void Pipe_ClearControlSETUP(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
+ /** 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 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
+ * can be re-sent.\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ *\r
+ * \return Boolean true if an NAK has been received on the current pipe, false otherwise\r
+ */\r
+ static inline bool Pipe_IsNAKReceived(void);\r
+\r
+ /** Clears the NAK condition on the currently selected pipe.\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ *\r
+ * \see Pipe_IsNAKReceived() for more details.\r
+ */\r
+ static inline void Pipe_ClearNAKReceived(void);\r
+ \r
+ /** Determines if the currently selected pipe has had the STALL condition set by the attached device.\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ *\r
+ * \return Boolean true if the current pipe has been stalled by the attached device, false otherwise\r
+ */\r
+ static inline bool Pipe_IsStalled(void);\r
+ \r
+ /** Clears the STALL condition detection flag on the currently selected pipe, but does not clear the\r
+ * STALL condition itself (this must be done via a ClearFeature control request to the device).\r
+ *\r
+ * \ingroup Group_PipePacketManagement\r
+ */\r
+ static inline void Pipe_ClearStall(void);\r
+ #else\r
+ #define Pipe_BytesInPipe() UPBCX\r
\r
- /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
- * indicated will operate on the currently selected pipe.\r
- */\r
- #define Pipe_SelectPipe(pipenum) MACROS{ UPNUM = pipenum; }MACROE\r
+ #define Pipe_GetCurrentPipe() (UPNUM & PIPE_PIPENUM_MASK)\r
\r
- /** Returns the pipe address of the currently selected pipe. This is typically used to save the\r
- * currently selected pipe number so that it can be restored after another pipe has been manipulated.\r
- */\r
- #define Pipe_GetCurrentPipe() (UPNUM & PIPE_PIPENUM_MASK)\r
+ #define Pipe_SelectPipe(pipenum) MACROS{ UPNUM = pipenum; }MACROE\r
+ \r
+ #define Pipe_ResetPipe(pipenum) MACROS{ UPRST = (1 << pipenum); UPRST = 0; }MACROE\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
- */\r
- #define Pipe_EnablePipe() MACROS{ UPCONX |= (1 << PEN); }MACROE\r
+ #define Pipe_EnablePipe() MACROS{ UPCONX |= (1 << PEN); }MACROE\r
\r
- /** Disables the currently selected pipe so that data cannot be sent and received through it to and\r
- * from an attached device.\r
- */\r
- #define Pipe_DisablePipe() MACROS{ UPCONX &= ~(1 << PEN); }MACROE\r
+ #define Pipe_DisablePipe() MACROS{ UPCONX &= ~(1 << PEN); }MACROE\r
\r
- /** Returns true if the currently selected pipe is enabled, false otherwise. */\r
- #define Pipe_IsEnabled() ((UPCONX & (1 << PEN)) ? true : false)\r
+ #define Pipe_IsEnabled() ((UPCONX & (1 << PEN)) ? true : false)\r
\r
- /** Sets the token for the currently selected endpoint to one of the tokens specified by the PIPE_TOKEN_*\r
- * masks. This should only be used on CONTROL type endpoints, to allow for bidirectional transfer of\r
- * data during control requests.\r
- */\r
- #define Pipe_SetToken(token) MACROS{ UPCFG0X = ((UPCFG0X & ~PIPE_TOKEN_MASK) | token); }MACROE\r
- \r
- /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */\r
- #define Pipe_SetInfiniteINRequests() MACROS{ UPCONX |= (1 << INMODE); }MACROE\r
+ #define Pipe_GetPipeToken() (UPCFG0X & PIPE_TOKEN_MASK)\r
\r
- /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
- * accepted by the pipe before it is automatically frozen.\r
- */\r
- #define Pipe_SetFiniteINRequests(n) MACROS{ UPCONX &= ~(1 << INMODE); UPINRQX = n; }MACROE\r
+ #define Pipe_SetToken(token) MACROS{ UPCFG0X = ((UPCFG0X & ~PIPE_TOKEN_MASK) | token); }MACROE\r
+ \r
+ #define Pipe_SetInfiniteINRequests() MACROS{ UPCONX |= (1 << INMODE); }MACROE\r
\r
- /** Returns true if the currently selected pipe is configured, false otherwise. */\r
- #define Pipe_IsConfigured() ((UPSTAX & (1 << CFGOK)) ? true : false)\r
+ #define Pipe_SetFiniteINRequests(n) MACROS{ UPCONX &= ~(1 << INMODE); UPINRQX = n; }MACROE\r
\r
- /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds. */\r
- #define Pipe_SetInterruptPeriod(ms) MACROS{ UPCFG2X = ms; }MACROE\r
+ #define Pipe_IsConfigured() ((UPSTAX & (1 << CFGOK)) ? true : false)\r
\r
- /** Returns a mask indicating which pipe's interrupt periods have elapsed, indicating that the pipe should\r
- * be serviced.\r
- */\r
- #define Pipe_GetPipeInterrupts() UPINT\r
+ #define Pipe_SetInterruptPeriod(ms) MACROS{ UPCFG2X = ms; }MACROE\r
\r
- /** Clears the interrupt flag for the specified pipe number. */\r
- #define Pipe_ClearPipeInterrupt(n) MACROS{ UPINT &= ~(1 << n); }MACROE\r
+ #define Pipe_GetPipeInterrupts() UPINT\r
\r
- /** Returns true if the specified pipe's interrupt period has elapsed, false otherwise. */\r
- #define Pipe_HasPipeInterrupted(n) ((UPINT & (1 << n)) ? true : false)\r
- \r
- /** Clears the pipe bank, and switches to the alternate bank if the currently selected pipe is\r
- * dual-banked. When cleared, this either frees the bank up for the next packet from the host\r
- * (if the endpoint is of the OUT direction) or sends the packet contents to the host (if the\r
- * pipe is of the IN direction).\r
- */\r
- #define Pipe_ClearCurrentBank() MACROS{ UPINTX &= ~(1 << FIFOCON); }MACROE\r
+ #define Pipe_ClearPipeInterrupt(n) MACROS{ UPINT &= ~(1 << n); }MACROE\r
\r
- /** Unfreezes the pipe, allowing it to communicate with an attached device. */\r
- #define Pipe_Unfreeze() MACROS{ UPCONX &= ~(1 << PFREEZE); }MACROE\r
+ #define Pipe_HasPipeInterrupted(n) ((UPINT & (1 << n)) ? true : false)\r
\r
- /** Freezes the pipe, preventing it from communicating with an attached device. */\r
- #define Pipe_Freeze() MACROS{ UPCONX |= (1 << PFREEZE); }MACROE\r
+ #define Pipe_Unfreeze() MACROS{ UPCONX &= ~(1 << PFREEZE); }MACROE\r
\r
- /** Clears the master pipe error flag. */\r
- #define Pipe_ClearError() MACROS{ UPINTX &= ~(1 << PERRI); }MACROE\r
+ #define Pipe_Freeze() MACROS{ UPCONX |= (1 << PFREEZE); }MACROE\r
\r
- /** Returns true 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
- */\r
- #define Pipe_IsError() ((UPINTX & (1 << PERRI)) ? true : false)\r
- \r
- /** Clears all the currently selected pipe's hardware error flags, but does not clear the master error\r
- * flag for the pipe. */\r
- #define Pipe_ClearErrorFlags() MACROS{ UPERRX = 0; }MACROE\r
+ #define Pipe_ClearError() MACROS{ UPINTX &= ~(1 << PERRI); }MACROE\r
\r
- /** Returns 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
- #define Pipe_GetErrorFlags() UPERRX\r
+ #define Pipe_IsError() ((UPINTX & (1 << PERRI)) ? true : false)\r
+ \r
+ #define Pipe_ClearErrorFlags() MACROS{ UPERRX = 0; }MACROE\r
\r
- /** Returns true if the currently selected pipe may be read from (if data is waiting in the pipe\r
- * bank and the pipe is an IN direction, or if the bank is not yet full if the pipe is an OUT\r
- * direction). This function will return false if an error has occurred in the pipe, or if the pipe\r
- * is an IN direction and no packet has been received, or if the pipe is an OUT direction and the\r
- * pipe bank is full.\r
- */\r
- #define Pipe_ReadWriteAllowed() ((UPINTX & (1 << RWAL)) ? true : false)\r
+ #define Pipe_GetErrorFlags() UPERRX\r
\r
- /** Clears the flag indicating that a SETUP request has been sent to the attached device from the\r
- * currently selected CONTROL type pipe.\r
- */\r
- #define Pipe_ClearSetupSent() MACROS{ UPINTX &= ~(1 << TXSTPI); }MACROE\r
+ #define Pipe_IsReadWriteAllowed() ((UPINTX & (1 << RWAL)) ? true : false)\r
\r
- /** Returns true if no SETUP request is currently being sent to the attached device, false otherwise. */\r
- #define Pipe_IsSetupSent() ((UPINTX & (1 << TXSTPI)) ? true : false)\r
+ #define Pipe_IsINReceived() ((UPINTX & (1 << RXINI)) ? true : false)\r
\r
- /** Returns true if the currently selected pipe has been stalled by the attached device, false otherwise. */\r
- #define Pipe_IsStalled() ((UPINTX & (1 << RXSTALLI)) ? true : false)\r
+ #define Pipe_IsOUTReady() ((UPINTX & (1 << TXOUTI)) ? true : false)\r
\r
- /** Clears the stall condition on the currently selected pipe. */\r
- #define Pipe_ClearStall() MACROS{ UPINTX &= ~(1 << RXSTALLI); }MACROE \r
+ #define Pipe_IsSETUPSent() ((UPINTX & (1 << TXSTPI)) ? true : false)\r
\r
- /** Returns true if an IN request has been received on the currently selected CONTROL type pipe, false\r
- * otherwise.\r
- */\r
- #define Pipe_IsSetupINReceived() ((UPINTX & (1 << RXINI)) ? true : false)\r
+ #define Pipe_ClearIN() MACROS{ UPINTX &= ~(1 << RXINI); UPINTX &= ~(1 << FIFOCON); }MACROE\r
\r
- /** Returns true if the currently selected CONTROL type pipe is ready to send an OUT request, false\r
- * otherwise.\r
- */\r
- #define Pipe_IsSetupOUTReady() ((UPINTX & (1 << TXOUTI)) ? true : false)\r
+ #define Pipe_ClearControlIN() MACROS{ UPINTX &= ~(1 << RXINI); UPINTX &= ~(1 << FIFOCON); }MACROE\r
\r
- /** Acknowledges the reception of a setup IN request from the attached device on the currently selected\r
- * CONTROL type endpoint, allowing for the transmission of a setup OUT packet, or the reception of\r
- * another setup IN packet.\r
- */\r
- #define Pipe_ClearSetupIN() MACROS{ UPINTX &= ~(1 << RXINI); UPINTX &= ~(1 << FIFOCON); }MACROE\r
+ #define Pipe_ClearOUT() MACROS{ UPINTX &= ~(1 << TXOUTI); UPINTX &= ~(1 << FIFOCON); }MACROE\r
+ \r
+ #define Pipe_ClearControlOUT() MACROS{ UPINTX &= ~(1 << TXOUTI); UPINTX &= ~(1 << FIFOCON); }MACROE\r
\r
- /** Sends the currently selected CONTROL type pipe's contents to the device as a setup OUT packet. */\r
- #define Pipe_ClearSetupOUT() MACROS{ UPINTX &= ~(1 << TXOUTI); UPINTX &= ~(1 << FIFOCON); }MACROE\r
- \r
- /** Returns true 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
- * can be re-sent.\r
- */\r
- #define Pipe_IsNAKReceived() ((UPINTX & (1 << NAKEDI)) ? true : false)\r
+ #define Pipe_ClearControlSETUP() MACROS{ UPINTX &= ~(1 << TXSTPI); UPINTX &= ~(1 << FIFOCON); }MACROE \r
\r
- /** Clears the NAK condition on the currently selected pipe.\r
- *\r
- * \see Pipe_IsNAKReceived() for more details.\r
- */\r
- #define Pipe_ClearNAKReceived() MACROS{ UPINTX &= ~(1 << NAKEDI); }MACROE\r
+ #define Pipe_IsNAKReceived() ((UPINTX & (1 << NAKEDI)) ? true : false)\r
+\r
+ #define Pipe_ClearNAKReceived() MACROS{ UPINTX &= ~(1 << NAKEDI); }MACROE\r
+\r
+ #define Pipe_IsStalled() ((UPINTX & (1 << RXSTALLI)) ? true : false)\r
+\r
+ #define Pipe_ClearStall() MACROS{ UPINTX &= ~(1 << RXSTALLI); }MACROE\r
+ #endif\r
\r
/* Enums: */\r
- /** Enum for the possible error return codes of the Pipe_WaitUntilReady function */\r
+ /** Enum for the possible error return codes of the Pipe_WaitUntilReady function\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ */\r
enum Pipe_WaitUntilReady_ErrorCodes_t\r
{\r
PIPE_READYWAIT_NoError = 0, /**< Pipe ready for next packet, no error */\r
*/\r
};\r
\r
- /** Enum for the possible error return codes of the Pipe_*_Stream_* functions. */\r
+ /** Enum for the possible error return codes of the Pipe_*_Stream_* functions.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ */\r
enum Pipe_Stream_RW_ErrorCodes_t\r
{\r
PIPE_RWSTREAM_ERROR_NoError = 0, /**< Command completed successfully, no error. */\r
};\r
\r
/* Inline Functions: */\r
- /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes. */\r
+ /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \return Next byte in the currently selected pipe's FIFO buffer\r
+ */\r
static inline uint8_t Pipe_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
static inline uint8_t Pipe_Read_Byte(void)\r
{\r
return UPDATX;\r
}\r
\r
- /** Writes one byte from the currently selected pipe's bank, for IN direction pipes. */\r
+ /** Writes one byte from the currently selected pipe's bank, for IN direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \param Byte Next byte to write into the the currently selected pipe's FIFO buffer\r
+ */\r
static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
static inline void Pipe_Write_Byte(const uint8_t Byte)\r
{\r
UPDATX = Byte;\r
}\r
\r
- /** Discards one byte from the currently selected pipe's bank, for OUT direction pipes. */\r
+ /** Discards one byte from the currently selected pipe's bank, for OUT direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ */\r
static inline void Pipe_Discard_Byte(void) ATTR_ALWAYS_INLINE;\r
static inline void Pipe_Discard_Byte(void)\r
{\r
\r
/** Reads two bytes from the currently selected pipe's bank in little endian format, for OUT\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \return Next word in the currently selected pipe's FIFO buffer\r
*/\r
static inline uint16_t Pipe_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
static inline uint16_t Pipe_Read_Word_LE(void)\r
\r
/** Reads two bytes from the currently selected pipe's bank in big endian format, for OUT\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \return Next word in the currently selected pipe's FIFO buffer\r
*/\r
static inline uint16_t Pipe_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
static inline uint16_t Pipe_Read_Word_BE(void)\r
\r
/** Writes two bytes to the currently selected pipe's bank in little endian format, for IN\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \param Word Next word to write to the currently selected pipe's FIFO buffer\r
*/\r
static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
static inline void Pipe_Write_Word_LE(const uint16_t Word)\r
\r
/** Writes two bytes to the currently selected pipe's bank in big endian format, for IN\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \param Word Next word to write to the currently selected pipe's FIFO buffer\r
*/\r
static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
static inline void Pipe_Write_Word_BE(const uint16_t Word)\r
UPDATX = (Word & 0xFF);\r
}\r
\r
- /** Discards two bytes from the currently selected pipe's bank, for OUT direction pipes. */\r
- static inline void Pipe_Ignore_Word(void) ATTR_ALWAYS_INLINE;\r
- static inline void Pipe_Ignore_Word(void)\r
+ /** Discards two bytes from the currently selected pipe's bank, for OUT direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ */\r
+ static inline void Pipe_Discard_Word(void) ATTR_ALWAYS_INLINE;\r
+ static inline void Pipe_Discard_Word(void)\r
{\r
uint8_t Dummy;\r
\r
\r
/** Reads four bytes from the currently selected pipe's bank in little endian format, for OUT\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \return Next double word in the currently selected pipe's FIFO buffer\r
*/\r
static inline uint32_t Pipe_Read_DWord_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
static inline uint32_t Pipe_Read_DWord_LE(void)\r
\r
/** Reads four bytes from the currently selected pipe's bank in big endian format, for OUT\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \return Next double word in the currently selected pipe's FIFO buffer\r
*/\r
static inline uint32_t Pipe_Read_DWord_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
static inline uint32_t Pipe_Read_DWord_BE(void)\r
\r
/** Writes four bytes to the currently selected pipe's bank in little endian format, for IN\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \param DWord Next double word to write to the currently selected pipe's FIFO buffer\r
*/\r
static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r
\r
/** Writes four bytes to the currently selected pipe's bank in big endian format, for IN\r
* direction pipes.\r
+ *\r
+ * \ingroup Group_PipeRW\r
+ *\r
+ * \param DWord Next double word to write to the currently selected pipe's FIFO buffer\r
*/\r
static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r
Pipe_Write_Word_BE(DWord);\r
} \r
\r
- /** Discards four bytes from the currently selected pipe's bank, for OUT direction pipes. */\r
+ /** Discards four bytes from the currently selected pipe's bank, for OUT direction pipes. \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
{\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
*/\r
uint8_t Pipe_WaitUntilReady(void); \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_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+ * 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
*\r
+ * \ingroup Group_PipeRW\r
+ *\r
* \param Buffer Pointer to the source data buffer to read from.\r
* \param Length Number of bytes to read for the currently selected pipe into the buffer.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
/** 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_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+ * 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
*\r
+ * \ingroup Group_PipeRW\r
+ *\r
* \param Buffer Pointer to the source data buffer to read from.\r
* \param Length Number of bytes to read for the currently selected pipe into the buffer.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
\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 host via the Pipe_ClearCurrentBank() macro.\r
+ * user is responsible for manually discarding the last packet from the device via the 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
* NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
* and this function has the Callback parameter omitted.\r
*\r
+ * \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
/** 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_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+ * 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
*\r
+ * \ingroup Group_PipeRW\r
+ *\r
* \param Buffer Pointer to the source data buffer to write to.\r
* \param Length Number of bytes to read for the currently selected pipe to read from.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
/** 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_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+ * 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
*\r
+ * \ingroup Group_PipeRW\r
+ *\r
* \param Buffer Pointer to the source data buffer to write to.\r
* \param Length Number of bytes to read for the currently selected pipe to read from.\r
* \param Callback Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
#if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
, uint8_t (* const Callback)(void)\r
#endif\r
- ) ATTR_NON_NULL_PTR_ARG(1); \r
-\r
- /* Function Aliases: */\r
- /** Alias for Pipe_Discard_Byte().\r
- */\r
- #define Pipe_Ignore_Byte() Pipe_Discard_Byte()\r
-\r
- /** Alias for Pipe_Discard_Word().\r
- */\r
- #define Pipe_Ignore_Word() Pipe_Discard_Word() \r
-\r
- /** Alias for Pipe_Discard_DWord().\r
- */\r
- #define Pipe_Ignore_DWord() Pipe_Discard_DWord()\r
-\r
- /** Alias for Pipe_Read_Word_LE(). By default USB transfers use little endian format, thus\r
- * the command with no endianness specified indicates little endian mode.\r
- */\r
- #define Pipe_Read_Word() Pipe_Read_Word_LE()\r
-\r
- /** Alias for Pipe_Write_Word_LE(). By default USB transfers use little endian format, thus\r
- * the command with no endianness specified indicates little endian mode.\r
- */\r
- #define Pipe_Write_Word(Word) Pipe_Write_Word_LE(Word)\r
-\r
- /** Alias for Pipe_Read_DWord_LE(). By default USB transfers use little endian format, thus\r
- * the command with no endianness specified indicates little endian mode.\r
- */\r
- #define Pipe_Read_DWord() Pipe_Read_DWord_LE()\r
-\r
- /** Alias for Pipe_Write_DWord_LE(). By default USB transfers use little endian format, thus\r
- * the command with no endianness specified indicates little endian mode.\r
- */\r
- #define Pipe_Write_DWord(DWord) Pipe_Write_DWord_LE(DWord)\r
-\r
- /** Alias for Pipe_Read_Stream_LE(). By default USB transfers use little endian format, thus\r
- * the command with no endianness specified indicates little endian mode.\r
- */\r
- #if !defined(NO_STREAM_CALLBACKS)\r
- #define Pipe_Read_Stream(Buffer, Length, Callback) Pipe_Read_Stream_LE(Buffer, Length, Callback)\r
- #else\r
- #define Pipe_Read_Stream(Buffer, Length) Pipe_Read_Stream_LE(Buffer, Length)\r
- #endif\r
-\r
- /** Alias for Pipe_Write_Stream_LE(). By default USB transfers use little endian format, thus\r
- * the command with no endianness specified indicates little endian mode.\r
- */\r
- #if !defined(NO_STREAM_CALLBACKS)\r
- #define Pipe_Write_Stream(Buffer, Length, Callback) Pipe_Read_Stream_LE(Buffer, Length, Callback)\r
- #else\r
- #define Pipe_Write_Stream(Buffer, Length) Pipe_Read_Stream_LE(Buffer, Length)\r
- #endif\r
+ ) ATTR_NON_NULL_PTR_ARG(1);\r
\r
/* Private Interface - For use in library only: */\r
#if !defined(__DOXYGEN__)\r
#if defined(__cplusplus)\r
}\r
#endif\r
- \r
+ \r
#endif\r
+\r
+/** @} */\r
projects / pub / USBasp.git / blobdiff