projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix makefiles -- the auto-addition of -D switches to each LUFA compile time option...
[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 90375b0..2c7a064 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Endpoint.h
+++ b/LUFA/Drivers/USB/LowLevel/Endpoint.h
@@ -69,24 +69,24 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
-                       /** Endpoint data direction mask for Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r
+                       /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r
                         *  should be initialized in the OUT direction - i.e. data flows from host to device.\r
                         */\r
                        #define ENDPOINT_DIR_OUT                      (0 << EPDIR)\r
 \r
                         *  should be initialized in the OUT direction - i.e. data flows from host to device.\r
                         */\r
                        #define ENDPOINT_DIR_OUT                      (0 << EPDIR)\r
 \r
-                       /** Endpoint data direction mask for Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r
+                       /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint\r
                         *  should be initialized in the IN direction - i.e. data flows from device to host.\r
                         */\r
                        #define ENDPOINT_DIR_IN                       (1 << EPDIR)\r
 \r
                         *  should be initialized in the IN direction - i.e. data flows from device to host.\r
                         */\r
                        #define ENDPOINT_DIR_IN                       (1 << EPDIR)\r
 \r
-                       /** Mask for the bank mode selection for the Endpoint_ConfigureEndpoint() macro. This indicates\r
+                       /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates\r
                         *  that the endpoint should have one single bank, which requires less USB FIFO memory but results\r
                         *  in slower transfers as only one USB device (the AVR or the host) can access the endpoint's\r
                         *  bank at the one time.\r
                         */\r
                        #define ENDPOINT_BANK_SINGLE                  (0 << EPBK0)\r
 \r
                         *  that the endpoint should have one single bank, which requires less USB FIFO memory but results\r
                         *  in slower transfers as only one USB device (the AVR or the host) can access the endpoint's\r
                         *  bank at the one time.\r
                         */\r
                        #define ENDPOINT_BANK_SINGLE                  (0 << EPBK0)\r
 \r
-                       /** Mask for the bank mode selection for the Endpoint_ConfigureEndpoint() macro. This indicates\r
+                       /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates\r
                         *  that the endpoint should have two banks, which requires more USB FIFO memory but results\r
                         *  in faster transfers as one USB device (the AVR or the host) can access one bank while the other\r
                         *  accesses the second bank.\r
                         *  that the endpoint should have two banks, which requires more USB FIFO memory but results\r
                         *  in faster transfers as one USB device (the AVR or the host) can access one bank while the other\r
                         *  accesses the second bank.\r
@@ -108,7 +108,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
@@ -127,56 +127,19 @@
                         */                             \r
                        #define ENDPOINT_DOUBLEBANK_SUPPORTED(n)      _ENDPOINT_GET_DOUBLEBANK(n)\r
 \r
                         */                             \r
                        #define ENDPOINT_DOUBLEBANK_SUPPORTED(n)      _ENDPOINT_GET_DOUBLEBANK(n)\r
 \r
-                       #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) || 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
-                                */\r
-                               #define ENDPOINT_TOTAL_ENDPOINTS          7\r
+                       #if !defined(CONTROL_ONLY_DEVICE)\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
+                                        */\r
+                                       #define ENDPOINT_TOTAL_ENDPOINTS          7\r
+                               #else\r
+                                       #define ENDPOINT_TOTAL_ENDPOINTS          5                     \r
+                               #endif\r
                        #else\r
                        #else\r
-                               #define ENDPOINT_TOTAL_ENDPOINTS          5                     \r
+                               #define ENDPOINT_TOTAL_ENDPOINTS              1\r
                        #endif\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 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
-                       /** Interrupt definition for the endpoint IN interrupt (for INTERRUPT type endpoints). Should be\r
-                        *  used with the USB_INT_* macros located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on an INTERRUPT type endpoint if a the endpoint interrupt\r
-                        *  period has elapsed and the endpoint is ready for a new packet to be written to its FIFO buffer\r
-                        *  (if required).\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 ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define ENDPOINT_INT_IN                       UEIENX, (1 << TXINE) , UEINTX, (1 << TXINI)\r
-\r
-                       /** Interrupt definition for the endpoint OUT interrupt (for INTERRUPT type endpoints). Should be\r
-                        *  used with the USB_INT_* macros located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on an INTERRUPT type endpoint if a the endpoint interrupt\r
-                        *  period has elapsed and the endpoint is ready for a packet from the host to be read from its\r
-                        *  FIFO buffer (if received).\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 ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define ENDPOINT_INT_OUT                      UEIENX, (1 << RXOUTE), UEINTX, (1 << RXOUTI)\r
                        \r
                /* Pseudo-Function Macros: */\r
                        #if defined(__DOXYGEN__)\r
                        \r
                /* Pseudo-Function Macros: */\r
                        #if defined(__DOXYGEN__)\r
@@ -200,7 +163,7 @@
                                static inline uint8_t Endpoint_GetCurrentEndpoint(void);\r
                                \r
                                /** Selects the given endpoint number. If the address from the device descriptors is used, the\r
                                static inline uint8_t Endpoint_GetCurrentEndpoint(void);\r
                                \r
                                /** Selects the given endpoint number. If the address from the device descriptors is used, the\r
-                                *  value should be masked with the ENDPOINT_EPNUM_MASK constant to extract only the endpoint\r
+                                *  value should be masked with the \ref ENDPOINT_EPNUM_MASK constant to extract only the endpoint\r
                                 *  number (and discarding the endpoint direction bit).\r
                                 *\r
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
                                 *  number (and discarding the endpoint direction bit).\r
                                 *\r
                                 *  Any endpoint operations which do not require the endpoint number to be indicated will operate on\r
@@ -220,8 +183,7 @@
                                /** Enables the currently selected endpoint so that data can be sent and received through it to\r
                                 *  and from a host.\r
                                 *\r
                                /** Enables the currently selected endpoint so that data can be sent and received through it to\r
                                 *  and from a host.\r
                                 *\r
-                                *  \note Endpoints must first be configured properly rather than just being enabled via the\r
-                                *        Endpoint_ConfigureEndpoint() macro, which calls Endpoint_EnableEndpoint() automatically.\r
+                                *  \note Endpoints must first be configured properly via \ref Endpoint_ConfigureEndpoint().\r
                                 */\r
                                static inline void Endpoint_EnableEndpoint(void);\r
 \r
                                 */\r
                                static inline void Endpoint_EnableEndpoint(void);\r
 \r
@@ -262,13 +224,6 @@
                                 */\r
                                static inline uint8_t Endpoint_GetEndpointInterrupts(void);\r
                                \r
                                 */\r
                                static inline uint8_t Endpoint_GetEndpointInterrupts(void);\r
                                \r
-                               /** Clears the endpoint interrupt flag. This clears the specified endpoint number's interrupt\r
-                                *  mask in the endpoint interrupt flag register.\r
-                                *\r
-                                *  \param EndpointNumber  Index of the endpoint whose interrupt flag should be cleared\r
-                                */\r
-                               static inline void Endpoint_ClearEndpointInterrupt(uint8_t EndpointNumber);\r
-                               \r
                                /** 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
@@ -309,41 +264,19 @@
                                 *\r
                                 *  \note This is not applicable for non CONTROL type endpoints.                         \r
                                 */\r
                                 *\r
                                 *  \note This is not applicable for non CONTROL type endpoints.                         \r
                                 */\r
-                               static inline void Endpoint_ClearControlSETUP(void);\r
-                               \r
-                               /** Sends an IN packet to the host on the currently selected CONTROL type endpoint, freeing up the\r
-                                *  endpoint for the next packet.\r
-                                *\r
-                                *  \ingroup Group_EndpointPacketManagement\r
-                                *\r
-                                *  \note For non CONTROL type endpoints, use Endpoint_ClearIN() instead.                        \r
-                                */\r
-                               static inline void Endpoint_ClearControlIN(void);\r
-                               \r
-                               /** Acknowledges an OUT packet to the host on the currently selected CONTROL type endpoint, freeing\r
-                                *  up the endpoint for the next packet.\r
-                                *\r
-                                *  \ingroup Group_EndpointPacketManagement\r
-                                *\r
-                                *  \note For non CONTROL type endpoints, use Endpoint_ClearOUT() instead.\r
-                                */\r
-                               static inline void Endpoint_ClearControlOUT(void);\r
+                               static inline void Endpoint_ClearSETUP(void);\r
                                \r
                                \r
-                               /** Sends an IN packet to the host on the currently selected non CONTROL type endpoint, freeing\r
-                                *  up the endpoint for the next packet and switching to the alternative endpoint bank if double banked.\r
+                               /** Sends an IN packet to the host on the currently selected endpoint, freeing up the endpoint for the\r
+                                *  next packet and switching to the alternative endpoint bank if double banked.\r
                                 *\r
                                 *  \ingroup Group_EndpointPacketManagement\r
                                 *\r
                                 *  \ingroup Group_EndpointPacketManagement\r
-                                *\r
-                                *  \note For CONTROL type endpoints, use Endpoint_ClearControlIN() instead.\r
                                 */\r
                                static inline void Endpoint_ClearIN(void);\r
                                \r
                                 */\r
                                static inline void Endpoint_ClearIN(void);\r
                                \r
-                               /** Acknowledges an OUT packet to the host on the currently selected non CONTROL type endpoint, freeing\r
-                                *  up the endpoint for the next packet and switching to the alternative endpoint bank if double banked.\r
+                               /** Acknowledges an OUT packet to the host on the currently selected endpoint, freeing up the endpoint\r
+                                *  for the next packet and switching to the alternative endpoint bank if double banked.\r
                                 *\r
                                 *  \ingroup Group_EndpointPacketManagement\r
                                 *\r
                                 *  \ingroup Group_EndpointPacketManagement\r
-                                *\r
-                                *  \note For CONTROL type endpoints, use Endpoint_ClearControlOUT() instead.\r
                                 */\r
                                static inline void Endpoint_ClearOUT(void);\r
                                \r
                                 */\r
                                static inline void Endpoint_ClearOUT(void);\r
                                \r
@@ -352,7 +285,7 @@
                                 *  way for devices to indicate invalid commands to the host so that the current transfer can be\r
                                 *  aborted and the host can begin its own recovery sequence.\r
                                 *\r
                                 *  way for devices to indicate invalid commands to the host so that the current transfer can be\r
                                 *  aborted and the host can begin its own recovery sequence.\r
                                 *\r
-                                *  The currently selected endpoint remains stalled until either the Endpoint_ClearStall() macro\r
+                                *  The currently selected endpoint remains stalled until either the \ref Endpoint_ClearStall() macro\r
                                 *  is called, or the host issues a CLEAR FEATURE request to the device for the currently selected\r
                                 *  endpoint.\r
                                 *\r
                                 *  is called, or the host issues a CLEAR FEATURE request to the device for the currently selected\r
                                 *  endpoint.\r
                                 *\r
@@ -383,15 +316,23 @@
                                 */\r
                                static inline uint8_t Endpoint_GetEndpointDirection(void);\r
                        #else\r
                                 */\r
                                static inline uint8_t Endpoint_GetEndpointDirection(void);\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
                                #endif\r
                                \r
                                        #define Endpoint_BytesInEndpoint()        UEBCX\r
                                #else\r
                                        #define Endpoint_BytesInEndpoint()        UEBCLX\r
                                #endif\r
                                \r
-                               #define Endpoint_GetCurrentEndpoint()         (UENUM & ENDPOINT_EPNUM_MASK)\r
+                               #if !defined(CONTROL_ONLY_DEVICE)\r
+                                       #define Endpoint_GetCurrentEndpoint()     (UENUM & ENDPOINT_EPNUM_MASK)\r
+                               #else\r
+                                       #define Endpoint_GetCurrentEndpoint()     ENDPOINT_CONTROLEP\r
+                               #endif\r
                                \r
                                \r
-                               #define Endpoint_SelectEndpoint(epnum)        MACROS{ UENUM = epnum; }MACROE\r
+                               #if !defined(CONTROL_ONLY_DEVICE)\r
+                                       #define Endpoint_SelectEndpoint(epnum)    MACROS{ UENUM = epnum; }MACROE\r
+                               #else\r
+                                       #define Endpoint_SelectEndpoint(epnum)    (void)epnum\r
+                               #endif\r
 \r
                                #define Endpoint_ResetFIFO(epnum)             MACROS{ UERST = (1 << epnum); UERST = 0; }MACROE\r
 \r
 \r
                                #define Endpoint_ResetFIFO(epnum)             MACROS{ UERST = (1 << epnum); UERST = 0; }MACROE\r
 \r
@@ -401,14 +342,14 @@
 \r
                                #define Endpoint_IsEnabled()                  ((UECONX & (1 << EPEN)) ? true : false)\r
 \r
 \r
                                #define Endpoint_IsEnabled()                  ((UECONX & (1 << EPEN)) ? true : false)\r
 \r
-                               #define Endpoint_IsReadWriteAllowed()         ((UEINTX & (1 << RWAL)) ? true : false)\r
-\r
+                               #if !defined(CONTROL_ONLY_DEVICE)\r
+                                       #define Endpoint_IsReadWriteAllowed()     ((UEINTX & (1 << RWAL)) ? true : false)\r
+                               #endif\r
+                               \r
                                #define Endpoint_IsConfigured()               ((UESTA0X & (1 << CFGOK)) ? true : false)\r
 \r
                                #define Endpoint_GetEndpointInterrupts()      UEINT\r
 \r
                                #define Endpoint_IsConfigured()               ((UESTA0X & (1 << CFGOK)) ? true : false)\r
 \r
                                #define Endpoint_GetEndpointInterrupts()      UEINT\r
 \r
-                               #define Endpoint_ClearEndpointInterrupt(n)    MACROS{ UEINT &= ~(1 << n); }MACROE\r
-\r
                                #define Endpoint_HasEndpointInterrupted(n)    ((UEINT & (1 << n)) ? true : false)\r
                                \r
                                #define Endpoint_IsINReady()                  ((UEINTX & (1 << TXINI))  ? true : false)\r
                                #define Endpoint_HasEndpointInterrupted(n)    ((UEINT & (1 << n)) ? true : false)\r
                                \r
                                #define Endpoint_IsINReady()                  ((UEINTX & (1 << TXINI))  ? true : false)\r
@@ -417,17 +358,21 @@
 \r
                                #define Endpoint_IsSETUPReceived()            ((UEINTX & (1 << RXSTPI)) ? true : false)\r
 \r
 \r
                                #define Endpoint_IsSETUPReceived()            ((UEINTX & (1 << RXSTPI)) ? true : false)\r
 \r
-                               #define Endpoint_ClearControlSETUP()          MACROS{ UEINTX &= ~(1 << RXSTPI); }MACROE\r
-\r
-                               #define Endpoint_ClearControlIN()             MACROS{ UEINTX &= ~(1 << TXINI); }MACROE\r
+                               #define Endpoint_ClearSETUP()                 MACROS{ UEINTX &= ~(1 << RXSTPI); }MACROE\r
 \r
 \r
-                               #define Endpoint_ClearControlOUT()            MACROS{ UEINTX &= ~(1 << RXOUTI); }MACROE\r
-\r
-                               #define Endpoint_ClearIN()                    MACROS{ uint8_t Temp = UEINTX; UEINTX = (Temp & ~(1 << TXINI)); \\r
-                                                                                     UEINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
+                               #if !defined(CONTROL_ONLY_DEVICE)\r
+                                       #define Endpoint_ClearIN()                MACROS{ uint8_t Temp = UEINTX; UEINTX = (Temp & ~(1 << TXINI)); \\r
+                                                                                         UEINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
+                               #else\r
+                                       #define Endpoint_ClearIN()                MACROS{ UEINTX &= ~(1 << TXINI); }MACROE\r
+                               #endif\r
 \r
 \r
-                               #define Endpoint_ClearOUT()                   MACROS{ uint8_t Temp = UEINTX; UEINTX = (Temp & ~(1 << RXOUTI)); \\r
-                                                                                     UEINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
+                               #if !defined(CONTROL_ONLY_DEVICE)\r
+                                       #define Endpoint_ClearOUT()               MACROS{ uint8_t Temp = UEINTX; UEINTX = (Temp & ~(1 << RXOUTI)); \\r
+                                                                                         UEINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
+                               #else\r
+                                       #define Endpoint_ClearOUT()               MACROS{ UEINTX &= ~(1 << RXOUTI); }MACROE                     \r
+                               #endif\r
 \r
                                #define Endpoint_StallTransaction()           MACROS{ UECONX |= (1 << STALLRQ); }MACROE\r
 \r
 \r
                                #define Endpoint_StallTransaction()           MACROS{ UECONX |= (1 << STALLRQ); }MACROE\r
 \r
@@ -441,7 +386,7 @@
                        #endif\r
 \r
                /* Enums: */\r
                        #endif\r
 \r
                /* Enums: */\r
-                       /** Enum for the possible error return codes of the Endpoint_WaitUntilReady function.\r
+                       /** Enum for the possible error return codes of the \ref Endpoint_WaitUntilReady() function.\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         */\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         */\r
@@ -456,7 +401,7 @@
                                                                                 */     \r
                                ENDPOINT_READYWAIT_Timeout                 = 3, /**< The host failed to accept or send the next packet\r
                                                                                 *   within the software timeout period set by the\r
                                                                                 */     \r
                                ENDPOINT_READYWAIT_Timeout                 = 3, /**< The host failed to accept or send the next packet\r
                                                                                 *   within the software timeout period set by the\r
-                                                                                *   USB_STREAM_TIMEOUT_MS macro.\r
+                                                                                *   \ref USB_STREAM_TIMEOUT_MS macro.\r
                                                                                 */\r
                        };\r
                \r
                                                                                 */\r
                        };\r
                \r
@@ -466,20 +411,20 @@
                         */\r
                        enum Endpoint_Stream_RW_ErrorCodes_t\r
                        {\r
                         */\r
                        enum Endpoint_Stream_RW_ErrorCodes_t\r
                        {\r
-                               ENDPOINT_RWSTREAM_ERROR_NoError            = 0, /**< Command completed successfully, no error. */\r
-                               ENDPOINT_RWSTREAM_ERROR_EndpointStalled    = 1, /**< The endpoint was stalled during the stream\r
-                                                                                *   transfer by the host or device.\r
-                                                                                */\r
-                               ENDPOINT_RWSTREAM_ERROR_DeviceDisconnected = 1, /**< Device was disconnected from the host during\r
-                                                                                *   the transfer.\r
-                                                                                */\r
-                               ENDPOINT_RWSTREAM_ERROR_Timeout            = 2, /**< The host failed to accept or send the next packet\r
-                                                                                *   within the software timeout period set by the\r
-                                                                                *   USB_STREAM_TIMEOUT_MS macro.\r
-                                                                                */\r
-                               ENDPOINT_RWSTREAM_ERROR_CallbackAborted    = 3, /**< Indicates that the stream's callback function\r
-                                                                            *   aborted the transfer early.\r
-                                                                                */\r
+                               ENDPOINT_RWSTREAM_NoError            = 0, /**< Command completed successfully, no error. */\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
+                                                                          *   the transfer.\r
+                                                                          */\r
+                               ENDPOINT_RWSTREAM_Timeout            = 2, /**< 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
+                               ENDPOINT_RWSTREAM_CallbackAborted    = 3, /**< 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
                        \r
                        /** Enum for the possible error return codes of the Endpoint_*_Control_Stream_* functions..\r
@@ -488,8 +433,8 @@
                         */\r
                        enum Endpoint_ControlStream_RW_ErrorCodes_t\r
                        {\r
                         */\r
                        enum Endpoint_ControlStream_RW_ErrorCodes_t\r
                        {\r
-                               ENDPOINT_RWCSTREAM_ERROR_NoError            = 0, /**< Command completed successfully, no error. */\r
-                               ENDPOINT_RWCSTREAM_ERROR_HostAborted        = 1, /**< The aborted the transfer prematurely. */\r
+                               ENDPOINT_RWCSTREAM_NoError            = 0, /**< Command completed successfully, no error. */\r
+                               ENDPOINT_RWCSTREAM_HostAborted        = 1, /**< The aborted the transfer prematurely. */\r
                        };\r
 \r
                /* Inline Functions: */\r
                        };\r
 \r
                /* Inline Functions: */\r
@@ -726,23 +671,20 @@
                /* Function Prototypes: */\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
                /* Function Prototypes: */\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
                         *\r
                         *  The endpoint type may be one of the EP_TYPE_* macros listed in LowLevel.h and the direction\r
-                        *  may be either ENDPOINT_DIR_OUT or ENDPOINT_DIR_IN.\r
+                        *  may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.\r
                         *\r
                         *  The bank size must indicate the maximum packet size that the endpoint can handle. Different\r
                         *  endpoint numbers can handle different maximum packet sizes - refer to the chosen USB AVR's\r
                         *  datasheet to determine the maximum bank size for each endpoint.\r
                         *\r
                         *\r
                         *  The bank size must indicate the maximum packet size that the endpoint can handle. Different\r
                         *  endpoint numbers can handle different maximum packet sizes - refer to the chosen USB AVR's\r
                         *  datasheet to determine the maximum bank size for each endpoint.\r
                         *\r
-                        *  The banking mode may be either ENDPOINT_BANK_SINGLE or ENDPOINT_BANK_DOUBLE.\r
-                        *\r
-                        *  The success of this routine can be determined via the Endpoint_IsConfigured() macro.\r
+                        *  The banking mode may be either \ref ENDPOINT_BANK_SINGLE or \ref ENDPOINT_BANK_DOUBLE.\r
                         *\r
                         *\r
-                        *  By default, the routine is entirely dynamic, and will accept both constant and variable inputs.\r
-                        *  If dynamic configuration is unused, a small space savings can be made by defining the\r
-                        *  STATIC_ENDPOINT_CONFIGURATION macro via the -D switch to the compiler, to optimize for constant\r
-                        *  input values.\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
@@ -752,6 +694,8 @@
                        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
@@ -759,20 +703,20 @@
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
                         *\r
                         *  \ingroup Group_EndpointRW\r
                         *\r
-                        *  \return A value from the Endpoint_WaitUntilReady_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.\r
                         */\r
                        uint8_t Endpoint_WaitUntilReady(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
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
                         */\r
                        uint8_t Endpoint_WaitUntilReady(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
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
-                        *  discarding the last packet from the host via the Endpoint_ClearOUT() macro. Between\r
+                        *  discarding the last packet from the host via the \ref Endpoint_ClearOUT() macro. Between\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
                         *  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 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
@@ -781,24 +725,24 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\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
                         */\r
                        uint8_t Endpoint_Discard_Stream(uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
-                                                       , uint8_t (* const Callback)(void)\r
+                                                       , StreamCallbackPtr_t Callback\r
                        #endif\r
                                                        );\r
 \r
                        /** 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
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        #endif\r
                                                        );\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
                         *  the user is responsible for manually sending the last written packet to the host via the\r
-                        *  Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r
+                        *  \ref Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r
                         *  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 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
@@ -808,24 +752,24 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\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
                         */\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
+                                                        , StreamCallbackPtr_t Callback\r
                        #endif\r
                                                         ) 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
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        #endif\r
                                                         ) 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
                         *  the user is responsible for manually sending the last written packet to the host via the\r
-                        *  Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r
+                        *  \ref Endpoint_ClearIN() macro. Between each USB packet, the given stream callback function\r
                         *  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 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
@@ -835,24 +779,24 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\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
                         */\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
+                                                        , StreamCallbackPtr_t Callback\r
                        #endif\r
                                                         ) 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
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
                        #endif\r
                                                         ) 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
                         *  discarded once the remaining bytes has been read; the user is responsible for manually\r
-                        *  discarding the last packet from the host via the Endpoint_ClearOUT() macro. Between\r
+                        *  discarding the last packet from the host via the \ref Endpoint_ClearOUT() macro. Between\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
                         *  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 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
@@ -862,24 +806,24 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\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
                         */\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
+                                                       , StreamCallbackPtr_t Callback\r
                        #endif\r
                                                        ) 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
                        #endif\r
                                                        ) 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
-                        *  discarding the last packet from the host via the Endpoint_ClearOUT() macro. Between\r
+                        *  discarding the last packet from the host via the \ref Endpoint_ClearOUT() macro. Between\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
                         *  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 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
@@ -889,18 +833,20 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_Stream_RW_ErrorCodes_t enum.\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
                         */\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
+                                                       , StreamCallbackPtr_t Callback\r
                        #endif\r
                                                        ) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        #endif\r
                                                        ) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
+                       #endif\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
                        /** 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 Endpoint_ClearControlOUT() macro.\r
+                        *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
@@ -912,14 +858,14 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\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
                        /** 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
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_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 Endpoint_ClearControlOUT() macro.\r
+                        *  finalize the transfer via the \ref Endpoint_ClearOUT() macro.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
@@ -931,14 +877,14 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\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
                        /** 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
                         */\r
                        uint8_t Endpoint_Write_Control_Stream_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 Endpoint_ClearControlIN() macro.\r
+                        *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
@@ -950,14 +896,14 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                         */\r
-                       uint8_t Endpoint_Read_Control_Stream_LE(void* Buffer, uint16_t Length)  ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t Endpoint_Read_Control_Stream_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
 \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 Endpoint_ClearControlIN() macro.\r
+                        *  setup IN to finalize the transfer via the \ref Endpoint_ClearIN() macro.\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
                         *\r
                         *  \note This routine should only be used on CONTROL type endpoints.\r
                         *\r
@@ -969,9 +915,9 @@
                         *  \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
                         *\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
                         *\r
-                        *  \return A value from the Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Endpoint_ControlStream_RW_ErrorCodes_t enum.\r
                         */\r
                         */\r
-                       uint8_t Endpoint_Read_Control_Stream_BE(void* Buffer, uint16_t Length)  ATTR_NON_NULL_PTR_ARG(1);               \r
+                       uint8_t Endpoint_Read_Control_Stream_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
                        \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
@@ -987,7 +933,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
@@ -1003,38 +949,33 @@
                                #define ENDPOINT_DETAILS_EP4               64,  true                    \r
                        #endif\r
 \r
                                #define ENDPOINT_DETAILS_EP4               64,  true                    \r
                        #endif\r
 \r
-                       #if defined(STATIC_ENDPOINT_CONFIGURATION)\r
-                               #define Endpoint_ConfigureEndpoint(Number, Type, Direction, Size, Banks)        \\r
-                                                                    Endpoint_ConfigureEndpointStatic(Number,   \\r
-                                                                             ((Type << EPTYPE0) | Direction),  \\r
-                                                                             ((1 << ALLOC) | Banks | Endpoint_BytesToEPSizeMask(Size)));\r
-                       #endif\r
-\r
+                       #define Endpoint_ConfigureEndpoint(Number, Type, Direction, Size, Banks)            \\r
+                                                           Endpoint_ConfigureEndpoint_Prv(Number,          \\r
+                                                                     ((Type << EPTYPE0) | Direction),      \\r
+                                                                     ((1 << ALLOC) | Banks |               \\r
+                                                                       (__builtin_constant_p(Size) ?       \\r
+                                                                        Endpoint_BytesToEPSizeMask(Size) :  \\r
+                                                                        Endpoint_BytesToEPSizeMaskDynamic(Size))))\r
+                                                                                                       \r
                /* Function Prototypes: */\r
                /* Function Prototypes: */\r
-                       void Endpoint_ClearEndpoints(void);\r
-                       bool Endpoint_ConfigureEndpointStatic(const uint8_t Number, const uint8_t UECFG0XData, const uint8_t UECFG1XData);\r
+                       void    Endpoint_ClearEndpoints(void);\r
+                       uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size);\r
+                       bool    Endpoint_ConfigureEndpoint_Prv(const uint8_t Number, const uint8_t UECFG0XData, const uint8_t UECFG1XData);\r
                        \r
                /* Inline Functions: */\r
                        static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)\r
                        {\r
                        \r
                /* Inline Functions: */\r
                        static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)\r
                        {\r
-                               if (Bytes <= 8)\r
-                                 return (0 << EPSIZE0);\r
-                               else if (Bytes <= 16)\r
-                                 return (1 << EPSIZE0);\r
-                               else if (Bytes <= 32)\r
-                                 return (2 << EPSIZE0);\r
-                               #if defined(USB_LIMITED_CONTROLLER)\r
-                               else\r
-                                 return (3 << EPSIZE0);\r
-                               #else\r
-                               else if (Bytes <= 64)\r
-                                 return (3 << EPSIZE0);\r
-                               else if (Bytes <= 128)\r
-                                 return (4 << EPSIZE0);\r
-                               else\r
-                                 return (5 << EPSIZE0);\r
-                               #endif\r
+                               uint8_t  MaskVal    = 0;\r
+                               uint16_t CheckBytes = 8;\r
+                               \r
+                               while (CheckBytes < Bytes)\r
+                               {\r
+                                       MaskVal++;\r
+                                       CheckBytes <<= 1;\r
+                               }\r
+                               \r
+                               return (MaskVal << EPSIZE0);\r
                        };\r
 \r
        #endif\r
                        };\r
 \r
        #endif\r
USB isp AVR programmer