projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Use sane ANSI terminal escape codes for the Host mode demos, so that they do not...
[pub/USBasp.git] / LUFA / Drivers / USB / LowLevel / Pipe.h
diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.h b/LUFA/Drivers/USB/LowLevel/Pipe.h
index d5c2094..f03ea09 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Pipe.h
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.h
@@ -43,6 +43,20 @@
  *  Functions, macros, variables, enums and types related to data reading and writing from and to pipes.\r
  */\r
  \r
  *  Functions, macros, variables, enums and types related to data reading and writing from and to pipes.\r
  */\r
  \r
+/** \ingroup Group_PipeRW  \r
+ *  @defgroup Group_PipePrimitiveRW Read/Write of Primitive Data Types\r
+ *\r
+ *  Functions, macros, variables, enums and types related to data reading and writing of primitive data types\r
+ *  from and to pipes.\r
+ */ \r
+\r
+/** \ingroup Group_PipeRW  \r
+ *  @defgroup Group_PipeStreamRW Read/Write of Multi-Byte Streams\r
+ *\r
+ *  Functions, macros, variables, enums and types related to data reading and writing of data streams from\r
+ *  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
 /** @defgroup Group_PipePacketManagement Pipe Packet Management\r
  *\r
  *  Functions, macros, variables, enums and types related to packet management of pipes.\r
@@ -61,6 +75,8 @@
 \r
        /* Includes: */\r
                #include <avr/io.h>\r
 \r
        /* Includes: */\r
                #include <avr/io.h>\r
+               #include <avr/pgmspace.h>\r
+               #include <avr/eeprom.h>\r
                #include <stdbool.h>\r
 \r
                #include "../../../Common/Common.h"\r
                #include <stdbool.h>\r
 \r
                #include "../../../Common/Common.h"\r
@@ -77,6 +93,12 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that an overflow error occurred in the pipe on the received data. */\r
+                       #define PIPE_ERRORFLAG_OVERFLOW         (1 << 6)\r
+\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that an underflow error occurred in the pipe on the received data. */\r
+                       #define PIPE_ERRORFLAG_UNDERFLOW        (1 << 5)\r
+\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 \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
@@ -151,69 +173,13 @@
                        /** Endpoint number mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  numerical address in the attached device.\r
                         */\r
                        /** Endpoint number mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  numerical address in the attached device.\r
                         */\r
-                       #define PIPE_EPNUM_MASK                 0x07\r
+                       #define PIPE_EPNUM_MASK                 0x0F\r
 \r
                        /** Endpoint bank size mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  bank size in the attached device.\r
                         */\r
                        #define PIPE_EPSIZE_MASK                0x7FF\r
 \r
 \r
                        /** Endpoint bank size mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  bank size in the attached device.\r
                         */\r
                        #define PIPE_EPSIZE_MASK                0x7FF\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 \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define PIPE_INT_SETUP                 UPIENX, (1 << TXSTPE) , UPINTX, (1 << TXSTPI)\r
-\r
-                       /** 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 \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        *\r
-                        *  \see \ref Pipe_GetErrorFlags() for more information on the pipe errors.\r
-                        */\r
-                       #define PIPE_INT_ERROR                 UPIENX, (1 << PERRE), UPINTX, (1 << PERRI)\r
-\r
-                       /** 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 \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        *\r
-                        *  \see \ref Pipe_IsNAKReceived() for more information on pipe NAKs.\r
-                        */\r
-                       #define PIPE_INT_NAK                   UPIENX, (1 << NAKEDE), UPINTX, (1 << NAKEDI)\r
-\r
-                       /** 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 \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define PIPE_INT_STALL                 UPIENX, (1 << RXSTALLE), UPINTX, (1 << RXSTALLI)\r
-\r
                /* Pseudo-Function Macros: */\r
                        #if defined(__DOXYGEN__)\r
                                /** Indicates the number of bytes currently stored in the current pipes's selected bank.\r
                /* Pseudo-Function Macros: */\r
                        #if defined(__DOXYGEN__)\r
                                /** Indicates the number of bytes currently stored in the current pipes's selected bank.\r
@@ -237,13 +203,13 @@
                                /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
                                 *  indicated will operate on the currently selected pipe.\r
                                 *\r
                                /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
                                 *  indicated will operate on the currently selected pipe.\r
                                 *\r
-                                *  \param PipeNumber  Index of the pipe to select\r
+                                *  \param[in] PipeNumber  Index of the pipe to select\r
                                 */\r
                                static inline void Pipe_SelectPipe(uint8_t PipeNumber);\r
                                \r
                                /** Resets the desired pipe, including the pipe banks and flags.\r
                                 *\r
                                 */\r
                                static inline void Pipe_SelectPipe(uint8_t PipeNumber);\r
                                \r
                                /** Resets the desired pipe, including the pipe banks and flags.\r
                                 *\r
-                                *  \param PipeNumber  Index of the pipe to reset\r
+                                *  \param[in] PipeNumber  Index of the pipe to reset\r
                                 */\r
                                static inline void Pipe_ResetPipe(uint8_t PipeNumber);\r
                                \r
                                 */\r
                                static inline void Pipe_ResetPipe(uint8_t PipeNumber);\r
                                \r
@@ -269,14 +235,14 @@
                                 *\r
                                 *  \return The current pipe token, as a PIPE_TOKEN_* mask\r
                                 */\r
                                 *\r
                                 *  \return The current pipe token, as a PIPE_TOKEN_* mask\r
                                 */\r
-                               static inline uint8_t Pipe_GetCurrentToken(void);\r
+                               static inline uint8_t Pipe_GetPipeToken(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
                                \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
+                                *  \param[in] Token  New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask\r
                                 */\r
                                static inline void Pipe_SetPipeToken(uint8_t Token);\r
                                \r
                                 */\r
                                static inline void Pipe_SetPipeToken(uint8_t Token);\r
                                \r
@@ -286,7 +252,7 @@
                                /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
                                 *  accepted by the pipe before it is automatically frozen.\r
                                 *\r
                                /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
                                 *  accepted by the pipe before it is automatically frozen.\r
                                 *\r
-                                *  \param TotalINRequests  Total number of IN requests that the pipe may receive before freezing\r
+                                *  \param[in] TotalINRequests  Total number of IN requests that the pipe may receive before freezing\r
                                 */\r
                                static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);\r
 \r
                                 */\r
                                static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);\r
 \r
@@ -298,7 +264,7 @@
                                \r
                                /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
                                 *\r
                                \r
                                /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
                                 *\r
-                                *  \param Milliseconds  Number of milliseconds between each pipe poll\r
+                                *  \param[in] Milliseconds  Number of milliseconds between each pipe poll\r
                                 */\r
                                static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);\r
                                \r
                                 */\r
                                static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);\r
                                \r
@@ -312,7 +278,7 @@
                                /** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type\r
                                 *  pipes).\r
                                 *\r
                                /** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type\r
                                 *  pipes).\r
                                 *\r
-                                *  \param PipeNumber  Index of the pipe whose interrupt flag should be tested\r
+                                *  \param[in] PipeNumber  Index of the pipe whose interrupt flag should be tested\r
                                 *\r
                                 *  \return Boolean true if the specified pipe has interrupted, false otherwise\r
                                 */\r
                                 *\r
                                 *  \return Boolean true if the specified pipe has interrupted, false otherwise\r
                                 */\r
@@ -482,7 +448,10 @@
                                \r
                                #define Pipe_ClearErrorFlags()         MACROS{ UPERRX = 0; }MACROE\r
 \r
                                \r
                                #define Pipe_ClearErrorFlags()         MACROS{ UPERRX = 0; }MACROE\r
 \r
-                               #define Pipe_GetErrorFlags()           UPERRX\r
+                               #define Pipe_GetErrorFlags()           ((UPERRX & (PIPE_ERRORFLAG_CRC16 | PIPE_ERRORFLAG_TIMEOUT | \\r
+                                                                                  PIPE_ERRORFLAG_PID   | PIPE_ERRORFLAG_DATAPID | \\r
+                                                                                  PIPE_ERRORFLAG_DATATGL))                      | \\r
+                                                                       (UPSTAX & PIPE_ERRORFLAG_OVERFLOW | PIPE_ERRORFLAG_UNDERFLOW))\r
 \r
                                #define Pipe_IsReadWriteAllowed()      ((UPINTX & (1 << RWAL)) ? true : false)\r
 \r
 \r
                                #define Pipe_IsReadWriteAllowed()      ((UPINTX & (1 << RWAL)) ? true : false)\r
 \r
@@ -549,7 +518,7 @@
                /* Inline Functions: */\r
                        /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes.\r
                         *\r
                /* Inline Functions: */\r
                        /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes.\r
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *  \return Next byte in the currently selected pipe's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next byte in the currently selected pipe's FIFO buffer\r
                         */\r
@@ -561,9 +530,9 @@
 \r
                        /** Writes one byte from the currently selected pipe's bank, for IN direction pipes.\r
                         *\r
 \r
                        /** Writes one byte from the currently selected pipe's bank, for IN direction pipes.\r
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *\r
-                        *  \param Byte  Next byte to write into the the currently selected pipe's FIFO buffer\r
+                        *  \param[in] Byte  Next byte to write into the the currently selected pipe's FIFO buffer\r
                         */\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte)\r
                         */\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Byte(const uint8_t Byte)\r
@@ -573,7 +542,7 @@
 \r
                        /** Discards one byte from the currently selected pipe's bank, for OUT direction pipes.\r
                         *\r
 \r
                        /** Discards one byte from the currently selected pipe's bank, for OUT direction pipes.\r
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  \ingroup Group_PipePrimitiveRW\r
                         */\r
                        static inline void Pipe_Discard_Byte(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Discard_Byte(void)\r
                         */\r
                        static inline void Pipe_Discard_Byte(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Discard_Byte(void)\r
@@ -586,7 +555,7 @@
                        /** Reads two bytes from the currently selected pipe's bank in little endian format, for OUT\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *  \return Next word in the currently selected pipe's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next word in the currently selected pipe's FIFO buffer\r
                         */\r
@@ -604,7 +573,7 @@
                        /** Reads two bytes from the currently selected pipe's bank in big endian format, for OUT\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *  \return Next word in the currently selected pipe's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next word in the currently selected pipe's FIFO buffer\r
                         */\r
@@ -622,9 +591,9 @@
                        /** Writes two bytes to the currently selected pipe's bank in little endian format, for IN\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *\r
-                        *  \param Word  Next word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected pipe's FIFO buffer\r
                         */\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word)\r
                         */\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word)\r
@@ -636,9 +605,9 @@
                        /** Writes two bytes to the currently selected pipe's bank in big endian format, for IN\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *\r
-                        *  \param Word  Next word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected pipe's FIFO buffer\r
                         */\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word)\r
                         */\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word)\r
@@ -649,7 +618,7 @@
 \r
                        /** Discards two bytes from the currently selected pipe's bank, for OUT direction pipes.\r
                         *\r
 \r
                        /** Discards two bytes from the currently selected pipe's bank, for OUT direction pipes.\r
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  \ingroup Group_PipePrimitiveRW\r
                         */\r
                        static inline void Pipe_Discard_Word(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Discard_Word(void)\r
                         */\r
                        static inline void Pipe_Discard_Word(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Discard_Word(void)\r
@@ -663,7 +632,7 @@
                        /** Reads four bytes from the currently selected pipe's bank in little endian format, for OUT\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *  \return Next double word in the currently selected pipe's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next double word in the currently selected pipe's FIFO buffer\r
                         */\r
@@ -687,7 +656,7 @@
                        /** Reads four bytes from the currently selected pipe's bank in big endian format, for OUT\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *  \return Next double word in the currently selected pipe's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next double word in the currently selected pipe's FIFO buffer\r
                         */\r
@@ -711,9 +680,9 @@
                        /** Writes four bytes to the currently selected pipe's bank in little endian format, for IN\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *\r
-                        *  \param DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
                         */\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r
                         */\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r
@@ -725,9 +694,9 @@
                        /** Writes four bytes to the currently selected pipe's bank in big endian format, for IN\r
                         *  direction pipes.\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
+                        *  \ingroup Group_PipePrimitiveRW\r
                         *\r
                         *\r
-                        *  \param DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
                         */\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r
                         */\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r
@@ -738,7 +707,7 @@
                        \r
                        /** Discards four bytes from the currently selected pipe's bank, for OUT direction pipes.       \r
                         *\r
                        \r
                        /** Discards four bytes from the currently selected pipe's bank, for OUT direction pipes.       \r
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  \ingroup Group_PipePrimitiveRW\r
                         */\r
                        static inline void Pipe_Discard_DWord(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Discard_DWord(void)\r
                         */\r
                        static inline void Pipe_Discard_DWord(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Discard_DWord(void)\r
@@ -763,9 +732,16 @@
                        extern uint8_t USB_ControlPipeSize;\r
 \r
                /* Function Prototypes: */\r
                        extern uint8_t USB_ControlPipeSize;\r
 \r
                /* Function Prototypes: */\r
+                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
+                               #define _CALLBACK_PARAM     , StreamCallbackPtr_t Callback\r
+                       #else\r
+                               #define _CALLBACK_PARAM                 \r
+                       #endif\r
+\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
                        /** 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
                         *\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
@@ -776,7 +752,14 @@
                         *\r
                         *  The banking mode may be either \ref PIPE_BANK_SINGLE or \ref PIPE_BANK_DOUBLE.\r
                         *\r
                         *\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 \ref Pipe_Unfreeze() macro.\r
+                        *  A newly configured pipe is frozen by default, and must be unfrozen before use via the \ref Pipe_Unfreeze()\r
+                        *  before being used. Pipes should be kept frozen unless waiting for data from a device while in IN mode, or\r
+                        *  sending data to the device in OUT mode. IN type pipes are also automatically configured to accept infinite\r
+                        *  numbers of IN requests without automatic freezing - this can be overridden by a call to\r
+                        *  \ref Pipe_SetFiniteINRequests().\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
                         *\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
@@ -795,76 +778,125 @@
                         */\r
                        uint8_t Pipe_WaitUntilReady(void);              \r
                \r
                         */\r
                        uint8_t Pipe_WaitUntilReady(void);              \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 \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 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
+                        *  The pipe token is set automatically, thus this can be used on bi-directional pipes directly without\r
+                        *  having to explicitly change the data direction with a call to \ref Pipe_SetPipeToken().\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\r
+                        *\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected pipe.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Pipe_Discard_Stream(uint16_t Length _CALLBACK_PARAM);\r
+\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
                         *  \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
                        /** 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
                         *  \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 \ref STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter omitted.\r
+                        *      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
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  The pipe token is set automatically, thus this can be used on bi-directional pipes directly without\r
+                        *  having to explicitly change the data direction with a call to \ref Pipe_SetPipeToken().\r
                         *\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
+                        *  \ingroup Group_PipeStreamRW\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 pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
-                       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
-                       #endif\r
-                                                    ) ATTR_NON_NULL_PTR_ARG(1);                                \r
+                       uint8_t Pipe_Write_Stream_LE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);                           \r
 \r
 \r
+                       /** EEPROM buffer source version of \ref Pipe_Write_Stream_LE.\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\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 pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Pipe_Write_EStream_LE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+                       \r
+                       /** FLASH buffer source version of \ref Pipe_Write_Stream_LE.\r
+                        *\r
+                        *  \note The FLASH data must be located in the first 64KB of FLASH for this function to work correctly.\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\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 pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Pipe_Write_PStream_LE(void* Buffer, uint16_t Length _CALLBACK_PARAM) 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
                         *  \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
                        /** 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
                         *  \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 \ref STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter omitted.\r
+                        *      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
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  The pipe token is set automatically, thus this can be used on bi-directional pipes directly without\r
+                        *  having to explicitly change the data direction with a call to \ref Pipe_SetPipeToken().\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\r
                         *\r
                         *\r
-                        *  \param Buffer    Pointer to the source data buffer to read from.\r
-                        *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
-                       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
-                       #endif\r
-                                                    ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Pipe_Write_Stream_BE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
 \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 \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
+                       /** EEPROM buffer source version of \ref Pipe_Write_Stream_BE.\r
                         *\r
                         *\r
-                        *      The callback routine should be created using the \ref STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter omitted.\r
+                        *  \ingroup Group_PipeStreamRW\r
                         *\r
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
                         *\r
                         *\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
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Pipe_Write_EStream_BE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+                       \r
+                       /** FLASH buffer source version of \ref Pipe_Write_Stream_BE.\r
+                        *\r
+                        *  \note The FLASH data must be located in the first 64KB of FLASH for this function to work correctly.\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\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 pipe into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
-                       uint8_t Pipe_Discard_Stream(uint16_t Length\r
-                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                   , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                   );\r
+                       uint8_t Pipe_Write_PStream_BE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\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
 \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
@@ -872,23 +904,34 @@
                         *  \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
                         *  \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 \ref STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter omitted.\r
+                        *      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
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  The pipe token is set automatically, thus this can be used on bi-directional pipes directly without\r
+                        *  having to explicitly change the data direction with a call to \ref Pipe_SetPipeToken().\r
                         *\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
+                        *  \ingroup Group_PipeStreamRW\r
+                        *\r
+                        *  \param[out] Buffer    Pointer to the source data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe to read from.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
-                       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
-                       #endif\r
-                                                   ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** EEPROM buffer source version of \ref Pipe_Read_Stream_LE.\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\r
+                        *\r
+                        *  \param[out] Buffer    Pointer to the source data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe to read from.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Pipe_Read_EStream_LE(void* Buffer, uint16_t Length _CALLBACK_PARAM) 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
 \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
@@ -896,24 +939,35 @@
                         *  \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
                         *  \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 \ref STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter omitted.\r
+                        *      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
                         *\r
-                        *  \ingroup Group_PipeRW\r
+                        *  The pipe token is set automatically, thus this can be used on bi-directional pipes directly without\r
+                        *  having to explicitly change the data direction with a call to \ref Pipe_SetPipeToken().\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\r
                         *\r
                         *\r
-                        *  \param Buffer    Pointer to the source data buffer to write to.\r
-                        *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[out] Buffer    Pointer to the source data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe to read from.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
                         */\r
-                       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
-                       #endif\r
-                                                   ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
                        \r
                        \r
+                       /** EEPROM buffer source version of \ref Pipe_Read_Stream_BE.\r
+                        *\r
+                        *  \ingroup Group_PipeStreamRW\r
+                        *\r
+                        *  \param[out] Buffer    Pointer to the source data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected pipe to read from.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Pipe_Read_EStream_BE(void* Buffer, uint16_t Length _CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Macros: */\r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Macros: */\r
USB isp AVR programmer