Fix makefiles -- the auto-addition of -D switches to each LUFA compile time option...
[pub/USBasp.git] / LUFA / Drivers / USB / LowLevel / Endpoint.h
index aa5005a..2c7a064 100644 (file)
                        /** 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
                        #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
                        #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
-                       /** 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 \ref 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 \ref 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
                                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
                                 */\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
 \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
                /* 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
                         *  may be either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.\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
                         *  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
                        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
                         *  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
                        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
                         *  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
                        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
                         *  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
                        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
                         *  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
                        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
                        #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