Added new Printer Host mode Class driver.

[pub/USBasp.git] / LUFA / Drivers / USB / LowLevel / Endpoint.h

diff --git a/LUFA/Drivers/USB/LowLevel/Endpoint.h b/LUFA/Drivers/USB/LowLevel/Endpoint.h
index 4882acc..4dfa1ef 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Endpoint.h
+++ b/LUFA/Drivers/USB/LowLevel/Endpoint.h
@@ -33,7 +33,7 @@
  *\r
  *  Functions, macros and enums related to endpoint management when in USB Device mode. This\r
  *  module contains the endpoint management macros, as well as endpoint interrupt and data\r
  *\r
  *  Functions, macros and enums related to endpoint management when in USB Device mode. This\r
  *  module contains the endpoint management macros, as well as endpoint interrupt and data\r

- *  send/recieve functions for various data types.\r
+ *  send/receive functions for various data types.\r

  *\r
  *  @{\r
  */\r
  *\r
  *  @{\r
  */\r


@@ -43,6 +43,20 @@
  *  Functions, macros, variables, enums and types related to data reading and writing from and to endpoints.\r
  */\r
  \r
  *  Functions, macros, variables, enums and types related to data reading and writing from and to endpoints.\r
  */\r
  \r

+/** \ingroup Group_EndpointRW  \r
+ *  @defgroup Group_EndpointPrimitiveRW 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 endpoints.\r
+ */ \r
+\r
+/** \ingroup Group_EndpointRW  \r
+ *  @defgroup Group_EndpointStreamRW 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 endpoints.\r
+ */ \r
+\r

 /** @defgroup Group_EndpointPacketManagement Endpoint Packet Management\r
  *\r
  *  Functions, macros, variables, enums and types related to packet management of endpoints.\r
 /** @defgroup Group_EndpointPacketManagement Endpoint Packet Management\r
  *\r
  *  Functions, macros, variables, enums and types related to packet management of endpoints.\r


@@ -53,6 +67,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


@@ -108,7 +124,7 @@
                        /** Endpoint number mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  numerical address in the device.\r
                         */\r
                        /** Endpoint number mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  numerical address in the device.\r
                         */\r

-                       #define ENDPOINT_EPNUM_MASK                   0x03\r
+                       #define ENDPOINT_EPNUM_MASK                   0x07\r

 \r
                        /** Endpoint bank size mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  bank size in the device.\r
 \r
                        /** Endpoint bank size mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  bank size in the device.\r


@@ -117,18 +133,18 @@
                        \r
                        /** Maximum size in bytes of a given endpoint.\r
                         *\r
                        \r
                        /** Maximum size in bytes of a given endpoint.\r
                         *\r

-                        *  \param n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r
+                        *  \param[in] n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r

                         */                             \r
                        #define ENDPOINT_MAX_SIZE(n)                  _ENDPOINT_GET_MAXSIZE(n)\r
 \r
                        /** Indicates if the given endpoint supports double banking.\r
                         *\r
                         */                             \r
                        #define ENDPOINT_MAX_SIZE(n)                  _ENDPOINT_GET_MAXSIZE(n)\r
 \r
                        /** Indicates if the given endpoint supports double banking.\r
                         *\r

-                        *  \param n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r
+                        *  \param[in] n  Endpoint number, a value between 0 and (ENDPOINT_TOTAL_ENDPOINTS - 1)\r

                         */                             \r
                        #define ENDPOINT_DOUBLEBANK_SUPPORTED(n)      _ENDPOINT_GET_DOUBLEBANK(n)\r
 \r
                        #if !defined(CONTROL_ONLY_DEVICE)\r
                         */                             \r
                        #define ENDPOINT_DOUBLEBANK_SUPPORTED(n)      _ENDPOINT_GET_DOUBLEBANK(n)\r
 \r
                        #if !defined(CONTROL_ONLY_DEVICE)\r

-                               #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) || defined(__DOXYGEN__)\r
+                               #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) || defined(__DOXYGEN__)\r

                                        /** Total number of endpoints (including the default control endpoint at address 0) which may\r
                                         *  be used in the device. Different USB AVR models support different amounts of endpoints,\r
                                         *  this value reflects the maximum number of endpoints for the currently selected AVR model.\r
                                        /** Total number of endpoints (including the default control endpoint at address 0) which may\r
                                         *  be used in the device. Different USB AVR models support different amounts of endpoints,\r
                                         *  this value reflects the maximum number of endpoints for the currently selected AVR model.\r


@@ -140,19 +156,6 @@
                        #else\r
                                #define ENDPOINT_TOTAL_ENDPOINTS              1\r
                        #endif\r
                        #else\r
                                #define ENDPOINT_TOTAL_ENDPOINTS              1\r
                        #endif\r

-\r
-                       /** Interrupt definition for the endpoint SETUP interrupt (for CONTROL type endpoints). Should be\r
-                        *  used with the USB_INT_* macros located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on a CONTROL type endpoint if a new control packet is\r
-                        *  received from the host.\r
-                        *\r
-                        *  \note This interrupt must be enabled and cleared on *each* endpoint which requires it (after the\r
-                        *        endpoint is selected), and will fire the common endpoint interrupt vector.\r
-                        *\r
-                        *  \see \ref ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define ENDPOINT_INT_SETUP                    UEIENX, (1 << RXSTPE), UEINTX, (1 << RXSTPI)\r

                        \r
                /* Pseudo-Function Macros: */\r
                        #if defined(__DOXYGEN__)\r
                        \r
                /* Pseudo-Function Macros: */\r
                        #if defined(__DOXYGEN__)\r


@@ -182,14 +185,14 @@
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
                                 *  the currently selected endpoint.\r
                                 *\r
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
                                 *  the currently selected endpoint.\r
                                 *\r

-                                *  \param EndpointNumber Endpoint number to select\r
+                                *  \param[in] EndpointNumber Endpoint number to select\r

                                 */\r
                                static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber);\r
                                \r
                                /** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's\r
                                 *  In and Out pointers to the bank's contents.\r
                                 *\r
                                 */\r
                                static inline void Endpoint_SelectEndpoint(uint8_t EndpointNumber);\r
                                \r
                                /** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's\r
                                 *  In and Out pointers to the bank's contents.\r
                                 *\r

-                                *  \param EndpointNumber Endpoint number whose FIFO buffers are to be reset\r
+                                *  \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset\r

                                 */\r
                                static inline void Endpoint_ResetFIFO(uint8_t EndpointNumber);\r
                                \r
                                 */\r
                                static inline void Endpoint_ResetFIFO(uint8_t EndpointNumber);\r
                                \r


@@ -240,7 +243,7 @@
                                /** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type\r
                                 *  endpoints).\r
                                 *\r
                                /** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type\r
                                 *  endpoints).\r
                                 *\r

-                                *  \param EndpointNumber  Index of the endpoint whose interrupt flag should be tested\r
+                                *  \param[in] EndpointNumber  Index of the endpoint whose interrupt flag should be tested\r

                                 *\r
                                 *  \return Boolean true if the specified endpoint has interrupted, false otherwise\r
                                 */\r
                                 *\r
                                 *  \return Boolean true if the specified endpoint has interrupted, false otherwise\r
                                 */\r


@@ -328,8 +331,14 @@
                                 *  \return The currently selected endpoint's direction, as a ENDPOINT_DIR_* mask.\r
                                 */\r
                                static inline uint8_t Endpoint_GetEndpointDirection(void);\r
                                 *  \return The currently selected endpoint's direction, as a ENDPOINT_DIR_* mask.\r
                                 */\r
                                static inline uint8_t Endpoint_GetEndpointDirection(void);\r

+\r
+                               /** Sets the direction of the currently selected endpoint.\r
+                                *\r
+                                *  \param[in] DirectionMask  New endpoint direction, as a ENDPOINT_DIR_* mask.\r
+                                */\r
+                               static inline void Endpoint_SetEndpointDirection(uint8_t DirectionMask);\r

                        #else\r
                        #else\r

-                               #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) || defined(__DOXYGEN__)\r
+                               #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) || defined(__DOXYGEN__)\r

                                        #define Endpoint_BytesInEndpoint()        UEBCX\r
                                #else\r
                                        #define Endpoint_BytesInEndpoint()        UEBCLX\r
                                        #define Endpoint_BytesInEndpoint()        UEBCX\r
                                #else\r
                                        #define Endpoint_BytesInEndpoint()        UEBCLX\r


@@ -396,6 +405,8 @@
                                #define Endpoint_ResetDataToggle()            MACROS{ UECONX |= (1 << RSTDT); }MACROE\r
                                \r
                                #define Endpoint_GetEndpointDirection()       (UECFG0X & ENDPOINT_DIR_IN)\r
                                #define Endpoint_ResetDataToggle()            MACROS{ UECONX |= (1 << RSTDT); }MACROE\r
                                \r
                                #define Endpoint_GetEndpointDirection()       (UECFG0X & ENDPOINT_DIR_IN)\r

+                               \r
+                               #define Endpoint_SetEndpointDirection(dir)    MACROS{ UECFG0X = ((UECFG0X & ~ENDPOINT_DIR_IN) | dir); }MACROE\r

                        #endif\r
 \r
                /* Enums: */\r
                        #endif\r
 \r
                /* Enums: */\r


@@ -420,7 +431,7 @@
                \r
                        /** Enum for the possible error return codes of the Endpoint_*_Stream_* functions.\r
                         *\r
                \r
                        /** Enum for the possible error return codes of the Endpoint_*_Stream_* functions.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         */\r
                        enum Endpoint_Stream_RW_ErrorCodes_t\r
                        {\r
                         */\r
                        enum Endpoint_Stream_RW_ErrorCodes_t\r
                        {\r


@@ -428,32 +439,35 @@
                                ENDPOINT_RWSTREAM_EndpointStalled    = 1, /**< The endpoint was stalled during the stream\r
                                                                           *   transfer by the host or device.\r
                                                                           */\r
                                ENDPOINT_RWSTREAM_EndpointStalled    = 1, /**< The endpoint was stalled during the stream\r
                                                                           *   transfer by the host or device.\r
                                                                           */\r

-                               ENDPOINT_RWSTREAM_DeviceDisconnected = 1, /**< Device was disconnected from the host during\r
+                               ENDPOINT_RWSTREAM_DeviceDisconnected = 2, /**< Device was disconnected from the host during\r

                                                                           *   the transfer.\r
                                                                           */\r
                                                                           *   the transfer.\r
                                                                           */\r

-                               ENDPOINT_RWSTREAM_Timeout            = 2, /**< The host failed to accept or send the next packet\r
+                               ENDPOINT_RWSTREAM_Timeout            = 3, /**< The host failed to accept or send the next packet\r

                                                                           *   within the software timeout period set by the\r
                                                                           *   \ref USB_STREAM_TIMEOUT_MS macro.\r
                                                                           */\r
                                                                           *   within the software timeout period set by the\r
                                                                           *   \ref USB_STREAM_TIMEOUT_MS macro.\r
                                                                           */\r

-                               ENDPOINT_RWSTREAM_CallbackAborted    = 3, /**< Indicates that the stream's callback function\r
+                               ENDPOINT_RWSTREAM_CallbackAborted    = 4, /**< Indicates that the stream's callback function\r

                                                                       *   aborted the transfer early.\r
                                                                           */\r
                        };\r
                        \r
                        /** Enum for the possible error return codes of the Endpoint_*_Control_Stream_* functions..\r
                         *\r
                                                                       *   aborted the transfer early.\r
                                                                           */\r
                        };\r
                        \r
                        /** Enum for the possible error return codes of the Endpoint_*_Control_Stream_* functions..\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         */\r
                        enum Endpoint_ControlStream_RW_ErrorCodes_t\r
                        {\r
                                ENDPOINT_RWCSTREAM_NoError            = 0, /**< Command completed successfully, no error. */\r
                                ENDPOINT_RWCSTREAM_HostAborted        = 1, /**< The aborted the transfer prematurely. */\r
                         */\r
                        enum Endpoint_ControlStream_RW_ErrorCodes_t\r
                        {\r
                                ENDPOINT_RWCSTREAM_NoError            = 0, /**< Command completed successfully, no error. */\r
                                ENDPOINT_RWCSTREAM_HostAborted        = 1, /**< The aborted the transfer prematurely. */\r

+                               ENDPOINT_RWCSTREAM_DeviceDisconnected = 2, /**< Device was disconnected from the host during\r
+                                                                           *   the transfer.\r
+                                                                           */\r

                        };\r
 \r
                /* Inline Functions: */\r
                        /** Reads one byte from the currently selected endpoint's bank, for OUT direction endpoints.\r
                         *\r
                        };\r
 \r
                /* Inline Functions: */\r
                        /** Reads one byte from the currently selected endpoint's bank, for OUT direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *  \return Next byte in the currently selected endpoint's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next byte in the currently selected endpoint's FIFO buffer\r
                         */\r


@@ -465,9 +479,9 @@
 \r
                        /** Writes one byte from the currently selected endpoint's bank, for IN direction endpoints.\r
                         *\r
 \r
                        /** Writes one byte from the currently selected endpoint's bank, for IN direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *\r

-                        *  \param Byte  Next byte to write into the the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] Byte  Next byte to write into the the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte)\r
                         */\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte)\r


@@ -477,7 +491,7 @@
 \r
                        /** Discards one byte from the currently selected endpoint's bank, for OUT direction endpoints.\r
                         *\r
 \r
                        /** Discards one byte from the currently selected endpoint's bank, for OUT direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         */\r
                        static inline void Endpoint_Discard_Byte(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Discard_Byte(void)\r
                         */\r
                        static inline void Endpoint_Discard_Byte(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Discard_Byte(void)\r


@@ -490,45 +504,53 @@
                        /** Reads two bytes from the currently selected endpoint's bank in little endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r
                        /** Reads two bytes from the currently selected endpoint's bank in little endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *  \return Next word in the currently selected endpoint's FIFO buffer\r
                         */\r
                        static inline uint16_t Endpoint_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_LE(void)\r
                        {\r
                         *\r
                         *  \return Next word in the currently selected endpoint's FIFO buffer\r
                         */\r
                        static inline uint16_t Endpoint_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_LE(void)\r
                        {\r

-                               uint16_t Data;\r
+                               union\r
+                               {\r
+                                       uint16_t Word;\r
+                                       uint8_t  Bytes[2];\r
+                               } Data;\r

                                \r
                                \r

-                               Data  = UEDATX;\r
-                               Data |= (((uint16_t)UEDATX) << 8);\r
+                               Data.Bytes[0] = UEDATX;\r
+                               Data.Bytes[1] = UEDATX;\r

                        \r
                        \r

-                               return Data;\r
+                               return Data.Word;\r

                        }\r
 \r
                        /** Reads two bytes from the currently selected endpoint's bank in big endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r
                        }\r
 \r
                        /** Reads two bytes from the currently selected endpoint's bank in big endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *  \return Next word in the currently selected endpoint's FIFO buffer\r
                         */\r
                        static inline uint16_t Endpoint_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_BE(void)\r
                        {\r
                         *\r
                         *  \return Next word in the currently selected endpoint's FIFO buffer\r
                         */\r
                        static inline uint16_t Endpoint_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_BE(void)\r
                        {\r

-                               uint16_t Data;\r
+                               union\r
+                               {\r
+                                       uint16_t Word;\r
+                                       uint8_t  Bytes[2];\r
+                               } Data;\r

                                \r
                                \r

-                               Data  = (((uint16_t)UEDATX) << 8);\r
-                               Data |= UEDATX;\r
+                               Data.Bytes[1] = UEDATX;\r
+                               Data.Bytes[0] = UEDATX;\r

                        \r
                        \r

-                               return Data;\r
+                               return Data.Word;\r

                        }\r
 \r
                        /** Writes two bytes to the currently selected endpoint's bank in little endian format, for IN\r
                         *  direction endpoints.\r
                         *\r
                        }\r
 \r
                        /** Writes two bytes to the currently selected endpoint's bank in little endian format, for IN\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *\r

-                        *  \param Word  Next word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word)\r
                         */\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word)\r


@@ -540,9 +562,9 @@
                        /** Writes two bytes to the currently selected endpoint's bank in big endian format, for IN\r
                         *  direction endpoints.\r
                         *\r
                        /** Writes two bytes to the currently selected endpoint's bank in big endian format, for IN\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *\r

-                        *  \param Word  Next word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] Word  Next word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word)\r
                         */\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word)\r


@@ -553,7 +575,7 @@
 \r
                        /** Discards two bytes from the currently selected endpoint's bank, for OUT direction endpoints.\r
                         *\r
 \r
                        /** Discards two bytes from the currently selected endpoint's bank, for OUT direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         */\r
                        static inline void Endpoint_Discard_Word(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Discard_Word(void)\r
                         */\r
                        static inline void Endpoint_Discard_Word(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Discard_Word(void)\r


@@ -567,7 +589,7 @@
                        /** Reads four bytes from the currently selected endpoint's bank in little endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r
                        /** Reads four bytes from the currently selected endpoint's bank in little endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *  \return Next double word in the currently selected endpoint's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next double word in the currently selected endpoint's FIFO buffer\r
                         */\r


@@ -591,7 +613,7 @@
                        /** Reads four bytes from the currently selected endpoint's bank in big endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r
                        /** Reads four bytes from the currently selected endpoint's bank in big endian format, for OUT\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *  \return Next double word in the currently selected endpoint's FIFO buffer\r
                         */\r
                         *\r
                         *  \return Next double word in the currently selected endpoint's FIFO buffer\r
                         */\r


@@ -615,9 +637,9 @@
                        /** Writes four bytes to the currently selected endpoint's bank in little endian format, for IN\r
                         *  direction endpoints.\r
                         *\r
                        /** Writes four bytes to the currently selected endpoint's bank in little endian format, for IN\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *\r

-                        *  \param DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)\r
                         */\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)\r


@@ -631,9 +653,9 @@
                        /** Writes four bytes to the currently selected endpoint's bank in big endian format, for IN\r
                         *  direction endpoints.\r
                         *\r
                        /** Writes four bytes to the currently selected endpoint's bank in big endian format, for IN\r
                         *  direction endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         *\r
                         *\r

-                        *  \param DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r
+                        *  \param[in] DWord  Next double word to write to the currently selected endpoint's FIFO buffer\r

                         */\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)\r
                         */\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)\r


@@ -646,7 +668,7 @@
 \r
                        /** Discards four bytes from the currently selected endpoint's bank, for OUT direction endpoints.       \r
                         *\r
 \r
                        /** Discards four bytes from the currently selected endpoint's bank, for OUT direction endpoints.       \r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointPrimitiveRW\r

                         */\r
                        static inline void Endpoint_Discard_DWord(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Discard_DWord(void)\r
                         */\r
                        static inline void Endpoint_Discard_DWord(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Discard_DWord(void)\r


@@ -682,9 +704,16 @@
                        #endif\r
 \r
                /* Function Prototypes: */\r
                        #endif\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 endpoint number with the given endpoint type, direction, bank size\r
                         *  and banking mode. Endpoints should be allocated in ascending order by their address in the\r
                        /** Configures the specified endpoint number with the given endpoint type, direction, bank size\r
                         *  and banking mode. Endpoints should be allocated in ascending order by their address in the\r

-                        *  device (i.e. endpoint 1 should be configured before endpoint 2 and so on).\r
+                        *  device (i.e. endpoint 1 should be configured before endpoint 2 and so on) to prevent fragmentation\r
+                        *  of the USB FIFO memory.\r

                         *\r
                         *  The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction\r
                         *  may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.\r
                         *\r
                         *  The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction\r
                         *  may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.\r


@@ -695,7 +724,8 @@
                         *\r
                         *  The banking mode may be either \ref ENDPOINT_BANK_SINGLE or \ref ENDPOINT_BANK_DOUBLE.\r
                         *\r
                         *\r
                         *  The banking mode may be either \ref ENDPOINT_BANK_SINGLE or \ref ENDPOINT_BANK_DOUBLE.\r
                         *\r

-                        *  The success of this routine can be determined via the \ref Endpoint_IsConfigured() macro.\r
+                        *  \note The default control endpoint 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 endpoint, and the endpoint will remain selected\r
                         *        once the routine completes regardless of if the endpoint configuration succeeds.\r
                         *\r
                         *  \note This routine will select the specified endpoint, and the endpoint will remain selected\r
                         *        once the routine completes regardless of if the endpoint configuration succeeds.\r


@@ -705,8 +735,6 @@
                        bool Endpoint_ConfigureEndpoint(const uint8_t  Number, const uint8_t Type, const uint8_t Direction,\r
                                                        const uint16_t Size, const uint8_t Banks);\r
 \r
                        bool Endpoint_ConfigureEndpoint(const uint8_t  Number, const uint8_t Type, const uint8_t Direction,\r
                                                        const uint16_t Size, const uint8_t Banks);\r
 \r

-                       #if !defined(CONTROL_ONLY_DEVICE)\r
-\r

                        /** Spinloops until the currently selected non-control endpoint is ready for the next packet of data\r
                         *  to be read or written to it.\r
                         *\r
                        /** Spinloops until the currently selected non-control endpoint is ready for the next packet of data\r
                         *  to be read or written to it.\r
                         *\r


@@ -717,6 +745,12 @@
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_WaitUntilReady(void);\r
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_WaitUntilReady(void);\r

+                       \r
+                       /** Completes the status stage of a control transfer on a CONTROL type endpoint automatically,\r
+                        *  with respect to the data direction. This is a convenience function which can be used to\r
+                        *  simplify user control request handling.\r
+                        */\r
+                       void Endpoint_ClearStatusStage(void);\r

 \r
                        /** Reads and discards the given number of bytes from the endpoint from the given buffer,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
 \r
                        /** Reads and discards the given number of bytes from the endpoint from the given buffer,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r


@@ -725,24 +759,20 @@
                         *  each USB packet, the given stream callback function is executed repeatedly until the next\r
                         *  packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  each USB packet, the given stream callback function is executed repeatedly until the next\r
                         *  packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the \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
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         *\r
                         *\r

-                        *  \param Length    Number of bytes to send via the currently selected endpoint.\r
-                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

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

-                       uint8_t Endpoint_Discard_Stream(uint16_t Length\r
-                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                       , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                       );\r
+                       uint8_t Endpoint_Discard_Stream(uint16_t Length __CALLBACK_PARAM);\r

 \r
                        /** Writes the given number of bytes to the endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r
 \r
                        /** Writes the given number of bytes to the endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r


@@ -751,25 +781,47 @@
                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r
                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the \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
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\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 endpoint 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 endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

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

-                       uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length\r
-                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                        , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                        ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Endpoint_Write_Stream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** EEPROM buffer source version of \ref Endpoint_Write_Stream_LE().\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_EStream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** FLASH buffer source version of \ref Endpoint_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_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_PStream_LE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Writes the given number of bytes to the endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r
 \r
                        /** Writes the given number of bytes to the endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The last packet filled is not automatically sent;\r


@@ -778,25 +830,47 @@
                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r
                         *  is executed repeatedly until the endpoint is ready to accept the next packet, allowing for early\r
                         *  aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the \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
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\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 endpoint 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 endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

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

-                       uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length\r
-                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                        , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                        ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Endpoint_Write_Stream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** EEPROM buffer source version of \ref Endpoint_Write_Stream_BE().\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_EStream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** FLASH buffer source version of \ref Endpoint_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_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer    Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length    Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_PStream_BE(const void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Reads the given number of bytes from the endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
 \r
                        /** Reads the given number of bytes from the endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r


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

-                        *      The callback routine should be created using the \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
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         *\r
                         *\r

-                        *  \param Buffer    Pointer to the destination data buffer to write to.\r
-                        *  \param Length    Number of bytes to send via the currently selected endpoint.\r
-                        *  \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 destination data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

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

-                       uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length\r
-                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                       , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                       ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Endpoint_Read_Stream_LE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
 \r

+                       /** EEPROM buffer source version of \ref Endpoint_Read_Stream_LE().\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[out] Buffer   Pointer to the destination data buffer to write to, located in EEPROM memory space.\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_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 endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
                        /** Reads the given number of bytes from the endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The last packet is not automatically\r
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r


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

-                        *      The callback routine should be created using the \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
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should not be used on CONTROL type endpoints.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         *\r
                         *\r

-                        *  \param Buffer    Pointer to the destination data buffer to write to.\r
-                        *  \param Length    Number of bytes to send via the currently selected endpoint.\r
-                        *  \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 destination data buffer to write to.\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

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

-                       uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length\r
-                       #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                       , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                       ) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Endpoint_Read_Stream_BE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
 \r

-                       #endif\r
+                       /** EEPROM buffer source version of \ref Endpoint_Read_Stream_BE().\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[out] Buffer   Pointer to the destination data buffer to write to, located in EEPROM memory space.\r
+                        *  \param[in] Length    Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[in] Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Read_EStream_BE(void* Buffer, uint16_t Length __CALLBACK_PARAM) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r
                         *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r
                         *\r
 \r
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in little endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r
                         *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r
                         *\r

+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r

                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\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 endpoint into the buffer.\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r

+                       /** EEPROM buffer source version of Endpoint_Write_Control_Stream_LE.\r
+                        *\r
+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r
+                        *  \note This routine should only be used on CONTROL type endpoints.\r
+                        *\r
+                        *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
+                        *           together; i.e. the entire stream data must be read or written at the one time.\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_Control_EStream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** FLASH buffer source version of \ref Endpoint_Write_Control_Stream_LE().\r
+                        *\r
+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r
+                        *  \note The FLASH data must be located in the first 64KB of FLASH for this function to work correctly.\r
+                        *\r
+                        *  \note This routine should only be used on CONTROL type endpoints.\r
+                        *\r
+                        *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
+                        *           together; i.e. the entire stream data must be read or written at the one time.\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_Control_PStream_LE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
+\r

                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r
                         *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r
                         *\r
                        /** Writes the given number of bytes to the CONTROL type endpoint from the given buffer in big endian,\r
                         *  sending full packets to the host as needed. The host OUT acknowledgement is not automatically cleared\r
                         *  in both failure and success states; the user is responsible for manually clearing the setup OUT to\r
                         *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r
                         *\r

+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r

                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\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 endpoint into the buffer.\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r

+                       /** EEPROM buffer source version of \ref Endpoint_Write_Control_Stream_BE().\r
+                        *\r
+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r
+                        *  \note This routine should only be used on CONTROL type endpoints.\r
+                        *\r
+                        *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
+                        *           together; i.e. the entire stream data must be read or written at the one time.\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_Control_EStream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       /** FLASH buffer source version of \ref Endpoint_Write_Control_Stream_BE().\r
+                        *\r
+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r
+                        *  \note The FLASH data must be located in the first 64KB of FLASH for this function to work correctly.\r
+                        *\r
+                        *  \note This routine should only be used on CONTROL type endpoints.\r
+                        *\r
+                        *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
+                        *           together; i.e. the entire stream data must be read or written at the one time.\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[in] Buffer  Pointer to the source data buffer to read from.\r
+                        *  \param[in] Length  Number of bytes to read for the currently selected endpoint into the buffer.\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Write_Control_PStream_BE(const void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
+\r

                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r
                         *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r
                         *\r
                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in little endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r
                         *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r
                         *\r

+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r

                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         *\r
                         *\r

-                        *  \param Buffer  Pointer to the destination data buffer to write to.\r
-                        *  \param Length  Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[out] Buffer  Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected endpoint.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
 \r

+                       /** EEPROM buffer source version of \ref Endpoint_Read_Control_Stream_LE().\r
+                        *\r
+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r
+                        *  \note This routine should only be used on CONTROL type endpoints.\r
+                        *\r
+                        *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
+                        *           together; i.e. the entire stream data must be read or written at the one time.\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[out] Buffer  Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected endpoint.\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Read_Control_EStream_LE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);\r
+\r

                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r
                         *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r
                         *\r
                        /** Reads the given number of bytes from the CONTROL endpoint from the given buffer in big endian,\r
                         *  discarding fully read packets from the host as needed. The device IN acknowledgement is not\r
                         *  automatically sent after success or failure states; the user is responsible for manually sending the\r
                         *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r
                         *\r

+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r

                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
                         *           together; i.e. the entire stream data must be read or written at the one time.\r
                         *\r

-                        *  \ingroup Group_EndpointRW\r
+                        *  \ingroup Group_EndpointStreamRW\r

                         *\r
                         *\r

-                        *  \param Buffer  Pointer to the destination data buffer to write to.\r
-                        *  \param Length  Number of bytes to send via the currently selected endpoint.\r
+                        *  \param[out] Buffer  Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected endpoint.\r

                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);                \r
                        \r
                         *\r
                         *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1);                \r
                        \r

+                       /** EEPROM buffer source version of \ref Endpoint_Read_Control_Stream_BE().\r
+                        *\r
+                        *  \note This function automatically clears the control transfer's status stage. Do not manually attempt\r
+                        *        to clear the status stage when using this routine in a control transaction.\r
+                        *\r
+                        *  \note This routine should only be used on CONTROL type endpoints.\r
+                        *\r
+                        *  \warning Unlike the standard stream read/write commands, the control stream commands cannot be chained\r
+                        *           together; i.e. the entire stream data must be read or written at the one time.\r
+                        *\r
+                        *  \ingroup Group_EndpointStreamRW\r
+                        *\r
+                        *  \param[out] Buffer  Pointer to the destination data buffer to write to.\r
+                        *  \param[in] Length  Number of bytes to send via the currently selected endpoint.\r
+                        *\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        */\r
+                       uint8_t Endpoint_Read_Control_EStream_BE(void* Buffer, uint16_t Length) 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


@@ -944,7 +1162,7 @@
                        #define _ENDPOINT_GET_DOUBLEBANK2(details)     _ENDPOINT_GET_DOUBLEBANK3(details)\r
                        #define _ENDPOINT_GET_DOUBLEBANK3(maxsize, db) db\r
                        \r
                        #define _ENDPOINT_GET_DOUBLEBANK2(details)     _ENDPOINT_GET_DOUBLEBANK3(details)\r
                        #define _ENDPOINT_GET_DOUBLEBANK3(maxsize, db) db\r
                        \r

-                       #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)\r
+                       #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)\r

                                #define ENDPOINT_DETAILS_EP0               64,  true\r
                                #define ENDPOINT_DETAILS_EP1               256, true\r
                                #define ENDPOINT_DETAILS_EP2               64,  true\r
                                #define ENDPOINT_DETAILS_EP0               64,  true\r
                                #define ENDPOINT_DETAILS_EP1               256, true\r
                                #define ENDPOINT_DETAILS_EP2               64,  true\r