Fixes to the MIDI device demos (ClassDriver, LowLevel); discard unused read-in events...

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

diff --git a/LUFA/Drivers/USB/LowLevel/Pipe.h b/LUFA/Drivers/USB/LowLevel/Pipe.h
index a1f28cc..f3da9d1 100644 (file)
--- a/LUFA/Drivers/USB/LowLevel/Pipe.h
+++ b/LUFA/Drivers/USB/LowLevel/Pipe.h
@@ -27,14 +27,35 @@
   arising out of or in connection with the use or performance of\r
   this software.\r
 */\r
   arising out of or in connection with the use or performance of\r
   this software.\r
 */\r

+ \r
+/** \ingroup Group_USB\r
+ *  @defgroup Group_PipeManagement Pipe Management\r
+ *\r
+ *  This module contains functions, macros and enums related to pipe management when in USB Host mode. This\r
+ *  module contains the pipe management macros, as well as pipe interrupt and data send/recieve functions\r
+ *  for various data types.\r
+ *\r
+ *  @{\r
+ */\r

 \r
 \r

-/** \file\r
+/** @defgroup Group_PipeRW Pipe Data Reading and Writing\r
+ *\r
+ *  Functions, macros, variables, enums and types related to data reading and writing from and to pipes.\r
+ */\r
+ \r
+/** @defgroup Group_PipePacketManagement Pipe Packet Management\r

  *\r
  *\r

- *  Functions, macros and enums related to pipe management when in USB Host mode. This\r
- *  module contains the pipe management macros, as well as pipe interrupt and data\r
- *  send/recieve functions for various datatypes.\r
+ *  Functions, macros, variables, enums and types related to packet management of pipes.\r

  */\r
  \r
  */\r
  \r

+/** @defgroup Group_PipeControlReq Pipe Control Request Management\r
+ *\r
+ *  Module for host mode request processing. This module allows for the transmission of standard, class and\r
+ *  vendor control requests to the default control endpoint of an attached device while in host mode.\r
+ *\r
+ *  \see Chapter 9 of the USB 2.0 specification.\r
+ */ \r
+\r

 #ifndef __PIPE_H__\r
 #define __PIPE_H__\r
 \r
 #ifndef __PIPE_H__\r
 #define __PIPE_H__\r
 \r


@@ -46,8 +67,9 @@
                #include "../HighLevel/USBTask.h"\r
 \r
                #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                #include "../HighLevel/USBTask.h"\r
 \r
                #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r

-               #include "StreamCallbacks.h"\r
+                       #include "../HighLevel/StreamCallbacks.h"\r

                #endif\r
                #endif\r

+               \r

        /* Enable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
                        extern "C" {\r
        /* Enable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
                        extern "C" {\r


@@ -55,322 +77,388 @@
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r
 \r
        /* Public Interface - May be used in end-application: */\r
                /* Macros: */\r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a CRC error occurred in the pipe on the received data. */\r
-                       #define PIPE_ERRORFLAG_CRC16                   (1 << 4)\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a CRC error occurred in the pipe on the received data. */\r
+                       #define PIPE_ERRORFLAG_CRC16            (1 << 4)\r

 \r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware timeout error occurred in the pipe. */\r
-                       #define PIPE_ERRORFLAG_TIMEOUT                 (1 << 3)\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware timeout error occurred in the pipe. */\r
+                       #define PIPE_ERRORFLAG_TIMEOUT          (1 << 3)\r

 \r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware PID error occurred in the pipe. */\r
-                       #define PIPE_ERRORFLAG_PID                     (1 << 2)\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware PID error occurred in the pipe. */\r
+                       #define PIPE_ERRORFLAG_PID              (1 << 2)\r

 \r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware data PID error occurred in the pipe. */\r
-                       #define PIPE_ERRORFLAG_DATAPID                 (1 << 1)\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware data PID error occurred in the pipe. */\r
+                       #define PIPE_ERRORFLAG_DATAPID          (1 << 1)\r

 \r
 \r

-                       /** Mask for Pipe_GetErrorFlags(), indicating that a hardware data toggle error occurred in the pipe. */\r
-                       #define PIPE_ERRORFLAG_DATATGL                 (1 << 0)\r
+                       /** Mask for \ref Pipe_GetErrorFlags(), indicating that a hardware data toggle error occurred in the pipe. */\r
+                       #define PIPE_ERRORFLAG_DATATGL          (1 << 0)\r

 \r
 \r

-                       /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a SETUP token (for CONTROL type pipes),\r
+                       /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a SETUP token (for CONTROL type pipes),\r

                         *  which will trigger a control request on the attached device when data is written to the pipe.\r
                         */\r
                         *  which will trigger a control request on the attached device when data is written to the pipe.\r
                         */\r

-                       #define PIPE_TOKEN_SETUP                       (0b00 << PTOKEN0)\r
+                       #define PIPE_TOKEN_SETUP                (0 << PTOKEN0)\r

 \r
 \r

-                       /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
+                       /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r

                         *  indicating that the pipe data will flow from device to host.\r
                         */\r
                         *  indicating that the pipe data will flow from device to host.\r
                         */\r

-                       #define PIPE_TOKEN_IN                          (0b01 << PTOKEN0)\r
+                       #define PIPE_TOKEN_IN                   (1 << PTOKEN0)\r

 \r
 \r

-                       /** Token mask for Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r
+                       /** Token mask for \ref Pipe_ConfigurePipe(). This sets the pipe as a IN token (for non-CONTROL type pipes),\r

                         *  indicating that the pipe data will flow from host to device.\r
                         */\r
                         *  indicating that the pipe data will flow from host to device.\r
                         */\r

-                       #define PIPE_TOKEN_OUT                         (0b10 << PTOKEN0)\r
+                       #define PIPE_TOKEN_OUT                  (2 << PTOKEN0)\r

 \r
 \r

-                       /** Mask for the bank mode selection for the Pipe_ConfigurePipe() macro. This indicates that the pipe\r
+                       /** Mask for the bank mode selection for the \ref Pipe_ConfigurePipe() macro. This indicates that the pipe\r

                         *  should have one single bank, which requires less USB FIFO memory but results in slower transfers as\r
                         *  only one USB device (the AVR or the attached device) can access the pipe's bank at the one time.\r
                         */\r
                         *  should have one single bank, which requires less USB FIFO memory but results in slower transfers as\r
                         *  only one USB device (the AVR or the attached device) can access the pipe's bank at the one time.\r
                         */\r

-                       #define PIPE_BANK_SINGLE                       0\r
+                       #define PIPE_BANK_SINGLE                (0 << EPBK0)\r

 \r
 \r

-                       /** Mask for the bank mode selection for the Pipe_ConfigurePipe() macro. This indicates that the pipe\r
+                       /** Mask for the bank mode selection for the \ref Pipe_ConfigurePipe() macro. This indicates that the pipe\r

                         *  should have two banks, which requires more USB FIFO memory but results in faster transfers as one\r
                         *  USB device (the AVR or the attached device) can access one bank while the other accesses the second\r
                         *  bank.\r
                         */\r
                         *  should have two banks, which requires more USB FIFO memory but results in faster transfers as one\r
                         *  USB device (the AVR or the attached device) can access one bank while the other accesses the second\r
                         *  bank.\r
                         */\r

-                       #define PIPE_BANK_DOUBLE                       (1 << EPBK0)\r
+                       #define PIPE_BANK_DOUBLE                (1 << EPBK0)\r

                        \r
                        /** Pipe address for the default control pipe, which always resides in address 0. This is\r
                         *  defined for convenience to give more readable code when used with the pipe macros.\r
                         */\r
                        \r
                        /** Pipe address for the default control pipe, which always resides in address 0. This is\r
                         *  defined for convenience to give more readable code when used with the pipe macros.\r
                         */\r

-                       #define PIPE_CONTROLPIPE                       0\r
+                       #define PIPE_CONTROLPIPE                0\r

 \r
                        /** Default size of the default control pipe's bank, until altered by the Endpoint0Size value \r
                         *  in the device descriptor of the attached device.\r
                         */\r
 \r
                        /** Default size of the default control pipe's bank, until altered by the Endpoint0Size value \r
                         *  in the device descriptor of the attached device.\r
                         */\r

-                       #define PIPE_CONTROLPIPE_DEFAULT_SIZE          8\r
+                       #define PIPE_CONTROLPIPE_DEFAULT_SIZE   64\r

                        \r
                        /** Pipe number mask, for masking against pipe addresses to retrieve the pipe's numerical address\r
                         *  in the device.\r
                         */\r
                        \r
                        /** Pipe number mask, for masking against pipe addresses to retrieve the pipe's numerical address\r
                         *  in the device.\r
                         */\r

-                       #define PIPE_PIPENUM_MASK                      0x07\r
+                       #define PIPE_PIPENUM_MASK               0x07\r

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

-                       #define PIPE_TOTAL_PIPES                       7\r
+                       #define PIPE_TOTAL_PIPES                7\r

 \r
                        /** Size in bytes of the largest pipe bank size possible in the device. Not all banks on each AVR\r
                         *  model supports the largest bank size possible on the device; different pipe numbers support\r
                         *  different maximum bank sizes. This value reflects the largest possible bank of any pipe on the\r
                         *  currently selected USB AVR model.\r
                         */\r
 \r
                        /** Size in bytes of the largest pipe bank size possible in the device. Not all banks on each AVR\r
                         *  model supports the largest bank size possible on the device; different pipe numbers support\r
                         *  different maximum bank sizes. This value reflects the largest possible bank of any pipe on the\r
                         *  currently selected USB AVR model.\r
                         */\r

-                       #define PIPE_MAX_SIZE                          256\r
+                       #define PIPE_MAX_SIZE                   256\r

 \r
                        /** Endpoint number mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  numerical address in the attached device.\r
                         */\r
 \r
                        /** Endpoint number mask, for masking against endpoint addresses to retrieve the endpoint's\r
                         *  numerical address in the attached device.\r
                         */\r

-                       #define PIPE_EPNUM_MASK                        0x07\r
+                       #define PIPE_EPNUM_MASK                 0x07\r

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

-                       #define PIPE_EPSIZE_MASK                       0x7FF\r
-\r
-                       /** Interrupt definition for the pipe IN interrupt (for INTERRUPT type pipes). Should be used with\r
-                        *  the USB_INT_* macros located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on an INTERRUPT type pipe if the pipe interrupt period has\r
-                        *  elapsed and the pipe is ready for the next packet from the attached device to be read out from its\r
-                        *  FIFO buffer (if received).\r
-                        *\r
-                        *  This interrupt must be enabled on *each* pipe which requires it (after the pipe is selected), and\r
-                        *  will fire the common pipe interrupt vector.\r
-                        *\r
-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define PIPE_INT_IN                            UPIENX, (1 << RXINE) , UPINTX, (1 << RXINI)\r
-\r
-                       /** Interrupt definition for the pipe OUT interrupt (for INTERRUPT type pipes). Should be used with\r
-                        *  the USB_INT_* macros located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on an INTERRUPT type endpoint if a the pipe interrupt period\r
-                        *  has elapsed and the pipe is ready for a packet to be written to the pipe's FIFO buffer and sent\r
-                        *  to the attached device (if required).\r
-                        *  \r
-                        *  This interrupt must be enabled on *each* pipe which requires it (after the pipe is selected), and\r
-                        *  will fire the common pipe interrupt vector.\r
-                        *\r
-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.                       */\r
-                       #define PIPE_INT_OUT                           UPIENX, (1 << TXOUTE), UPINTX, (1 << TXOUTI)\r
-\r
-                       /** Interrupt definition for the pipe SETUP bank ready interrupt (for CONTROL type pipes). Should be\r
-                        *  used with the USB_INT_* macros located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on an CONTROL type pipe when the pipe is ready for a new\r
-                        *  control request.\r
-                        *\r
-                        *  This interrupt must be enabled on *each* pipe which requires it (after the pipe is selected), and\r
-                        *  will fire the common pipe interrupt vector.\r
-                        *\r
-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define PIPE_INT_SETUP                         UPIENX, (1 << TXSTPE) , UPINTX, (1 << TXSTPI)\r
-\r
-                       /** Interrupt definition for the pipe error interrupt. Should be used with the USB_INT_* macros\r
-                        *  located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on a particular pipe if an error occurs on that pipe, such\r
-                        *  as a CRC mismatch error.\r
-                        *\r
-                        *  This interrupt must be enabled on *each* pipe which requires it (after the pipe is selected), and\r
-                        *  will fire the common pipe interrupt vector.\r
-                        *\r
-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        *\r
-                        *  \see Pipe_GetErrorFlags() for more information on the pipe errors.\r
-                        */\r
-                       #define PIPE_INT_ERROR                         UPIENX, (1 << PERRE), UPINTX, (1 << PERRI)\r
+                       #define PIPE_EPSIZE_MASK                0x7FF\r
+\r
+               /* Pseudo-Function Macros: */\r
+                       #if defined(__DOXYGEN__)\r
+                               /** Indicates the number of bytes currently stored in the current pipes's selected bank.\r
+                                *\r
+                                *  \note The return width of this function may differ, depending on the maximum pipe bank size\r
+                                *        of the selected AVR model.\r
+                                *\r
+                                *  \ingroup Group_PipeRW\r
+                                *\r
+                                *  \return Total number of bytes in the currently selected Pipe's FIFO buffer\r
+                                */\r
+                               static inline uint16_t Pipe_BytesInPipe(void);\r
+                               \r
+                               /** Returns the pipe address of the currently selected pipe. This is typically used to save the\r
+                                *  currently selected pipe number so that it can be restored after another pipe has been manipulated.\r
+                                *\r
+                                *  \return Index of the currently selected pipe\r
+                                */\r
+                               static inline uint8_t Pipe_GetCurrentPipe(void);\r
+\r
+                               /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
+                                *  indicated will operate on the currently selected pipe.\r
+                                *\r
+                                *  \param PipeNumber  Index of the pipe to select\r
+                                */\r
+                               static inline void Pipe_SelectPipe(uint8_t PipeNumber);\r
+                               \r
+                               /** Resets the desired pipe, including the pipe banks and flags.\r
+                                *\r
+                                *  \param PipeNumber  Index of the pipe to reset\r
+                                */\r
+                               static inline void Pipe_ResetPipe(uint8_t PipeNumber);\r
+                               \r
+                               /** Enables the currently selected pipe so that data can be sent and received through it to and from\r
+                                *  an attached device.\r
+                                *\r
+                                *  \note Pipes must first be configured properly via \ref Pipe_ConfigurePipe().\r
+                                */\r
+                               static inline void Pipe_EnablePipe(void);\r
+\r
+                               /** Disables the currently selected pipe so that data cannot be sent and received through it to and\r
+                                *  from an attached device.\r
+                                */\r
+                               static inline void Pipe_DisablePipe(void);\r
+\r
+                               /** Determines if the currently selected pipe is enabled, but not necessarily configured.\r
+                                *\r
+                                * \return Boolean True if the currently selected pipe is enabled, false otherwise\r
+                                */\r
+                               static inline bool Pipe_IsEnabled(void);\r
+                               \r
+                               /** Gets the current pipe token, indicating the pipe's data direction and type.\r
+                                *\r
+                                *  \return The current pipe token, as a PIPE_TOKEN_* mask\r
+                                */\r
+                               static inline uint8_t Pipe_GetCurrentToken(void);\r
+                               \r
+                               /** Sets the token for the currently selected pipe to one of the tokens specified by the PIPE_TOKEN_*\r
+                                *  masks. This can be used on CONTROL type pipes, to allow for bidirectional transfer of data during\r
+                                *  control requests, or on regular pipes to allow for half-duplex bidirectional data transfer to devices\r
+                                *  which have two endpoints of opposite direction sharing the same endpoint address within the device.\r
+                                *\r
+                                *  \param Token  New pipe token to set the selected pipe to, as a PIPE_TOKEN_* mask\r
+                                */\r
+                               static inline void Pipe_SetPipeToken(uint8_t Token);\r
+                               \r
+                               /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */\r
+                               static inline void Pipe_SetInfiniteINRequests(void);\r
+                               \r
+                               /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
+                                *  accepted by the pipe before it is automatically frozen.\r
+                                *\r
+                                *  \param TotalINRequests  Total number of IN requests that the pipe may receive before freezing\r
+                                */\r
+                               static inline void Pipe_SetFiniteINRequests(uint8_t TotalINRequests);\r
+\r
+                               /** Determines if the currently selected pipe is configured.\r
+                                *\r
+                                *  \return Boolean true if the selected pipe is configured, false otherwise\r
+                                */\r
+                               static inline bool Pipe_IsConfigured(void);\r
+                               \r
+                               /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
+                                *\r
+                                *  \param Milliseconds  Number of milliseconds between each pipe poll\r
+                                */\r
+                               static inline void Pipe_SetInterruptPeriod(uint8_t Milliseconds);\r
+                               \r
+                               /** Returns a mask indicating which pipe's interrupt periods have elapsed, indicating that the pipe should\r
+                                *  be serviced.\r
+                                *\r
+                                *  \return Mask whose bits indicate which pipes have interrupted\r
+                                */\r
+                               static inline uint8_t Pipe_GetPipeInterrupts(void);\r
+                               \r
+                               /** Determines if the specified pipe number has interrupted (valid only for INTERRUPT type\r
+                                *  pipes).\r
+                                *\r
+                                *  \param PipeNumber  Index of the pipe whose interrupt flag should be tested\r
+                                *\r
+                                *  \return Boolean true if the specified pipe has interrupted, false otherwise\r
+                                */\r
+                               static inline bool Pipe_HasPipeInterrupted(uint8_t PipeNumber);\r
+                               \r
+                               /** Unfreezes the selected pipe, allowing it to communicate with an attached device. */\r
+                               static inline void Pipe_Unfreeze(void);\r
+                               \r
+                               /** Freezes the selected pipe, preventing it from communicating with an attached device. */\r
+                               static inline void Pipe_Freeze(void);\r

 \r
 \r

-                       /** Interrupt definition for the pipe NAK received interrupt. Should be used with the USB_INT_* macros\r
-                        *  located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on a particular pipe if an attached device returns a NAK in\r
-                        *  response to a sent packet.\r
-                        *\r
-                        *  This interrupt must be enabled on *each* pipe which requires it (after the pipe is selected), and\r
-                        *  will fire the common pipe interrupt vector.\r
-                        *\r
-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        *\r
-                        *  \see Pipe_IsNAKReceived() for more information on pipe NAKs.\r
-                        */\r
-                       #define PIPE_INT_NAK                         UPIENX, (1 << NAKEDE), UPINTX, (1 << NAKEDI)\r
+                               /** Clears the master pipe error flag. */\r
+                               static inline void Pipe_ClearError(void);\r
+                               \r
+                               /** Determines if the master pipe error flag is set for the currently selected pipe, indicating that\r
+                                *  some sort of hardware error has occurred on the pipe.\r
+                                *\r
+                                *  \see \ref Pipe_GetErrorFlags() macro for information on retrieving the exact error flag.\r
+                                *\r
+                                *  \return Boolean true if an error has occurred on the selected pipe, false otherwise\r
+                                */\r
+                               static inline bool Pipe_IsError(void);\r
+                               \r
+                               /** Clears all the currently selected pipe's hardware error flags, but does not clear the master error\r
+                                *  flag for the pipe.\r
+                                */\r
+                               static inline void Pipe_ClearErrorFlags(void);\r
+                               \r
+                               /** Gets a mask of the hardware error flags which have occurred on the currently selected pipe. This\r
+                                *  value can then be masked against the PIPE_ERRORFLAG_* masks to determine what error has occurred.\r
+                                *\r
+                                *  \return  Mask comprising of PIPE_ERRORFLAG_* bits indicating what error has occurred on the selected pipe\r
+                                */\r
+                               static inline uint8_t Pipe_GetErrorFlags(void);\r
+                               \r
+                               /** Determines if the currently selected pipe may be read from (if data is waiting in the pipe\r
+                                *  bank and the pipe is an IN direction, or if the bank is not yet full if the pipe is an OUT\r
+                                *  direction). This function will return false if an error has occurred in the pipe, or if the pipe\r
+                                *  is an IN direction and no packet (or an empty packet) has been received, or if the pipe is an OUT\r
+                                *  direction and the pipe bank is full.\r
+                                *\r
+                                *  \note This function is not valid on CONTROL type pipes.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *  \r
+                                *  \return Boolean true if the currently selected pipe may be read from or written to, depending on its direction\r
+                                */\r
+                               static inline bool Pipe_IsReadWriteAllowed(void);\r
+                               \r
+                               /** Determines if an IN request has been received on the currently selected pipe.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *\r
+                                *  \return Boolean true if the current pipe has received an IN packet, false otherwise.\r
+                                */\r
+                               static inline bool Pipe_IsINReceived(void);\r
+                               \r
+                               /** Determines if the currently selected pipe is ready to send an OUT request.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *\r
+                                *  \return Boolean true if the current pipe is ready for an OUT packet, false otherwise.\r
+                                */\r
+                               static inline bool Pipe_IsOUTReady(void);\r
+\r
+                               /** Determines if no SETUP request is currently being sent to the attached device on the selected\r
+                                *  CONTROL type pipe.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *\r
+                                *  \return Boolean true if the current pipe is ready for a SETUP packet, false otherwise.\r
+                                */\r
+                               static inline bool Pipe_IsSETUPSent(void);\r
+                               \r
+                               /** Sends the currently selected CONTROL type pipe's contents to the device as a SETUP packet.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement         \r
+                                */\r
+                               static inline void Pipe_ClearSETUP(void);\r
+\r
+                               /** Acknowledges the reception of a setup IN request from the attached device on the currently selected\r
+                                *  pipe, freeing the bank ready for the next packet.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                */\r
+                               static inline void Pipe_ClearIN(void);\r
+\r
+                               /** Sends the currently selected pipe's contents to the device as an OUT packet on the selected pipe, freeing\r
+                                *  the bank ready for the next packet.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                */\r
+                               static inline void Pipe_ClearOUT(void);\r
+\r
+                               /** Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on\r
+                                *  the currently selected pipe. This occurs when the host sends a packet to the device, but the device\r
+                                *  is not currently ready to handle the packet (i.e. its endpoint banks are full). Once a NAK has been\r
+                                *  received, it must be cleared using \ref Pipe_ClearNAKReceived() before the previous (or any other) packet\r
+                                *  can be re-sent.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *\r
+                                *  \return Boolean true if an NAK has been received on the current pipe, false otherwise\r
+                                */\r
+                               static inline bool Pipe_IsNAKReceived(void);\r
+\r
+                               /** Clears the NAK condition on the currently selected pipe.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *\r
+                                *  \see \ref Pipe_IsNAKReceived() for more details.\r
+                                */\r
+                               static inline void Pipe_ClearNAKReceived(void);\r
+                                \r
+                               /** Determines if the currently selected pipe has had the STALL condition set by the attached device.\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                *\r
+                                *  \return Boolean true if the current pipe has been stalled by the attached device, false otherwise\r
+                               */\r
+                               static inline bool Pipe_IsStalled(void);\r
+                               \r
+                               /** Clears the STALL condition detection flag on the currently selected pipe, but does not clear the\r
+                                *  STALL condition itself (this must be done via a ClearFeature control request to the device).\r
+                                *\r
+                                *  \ingroup Group_PipePacketManagement\r
+                                */\r
+                               static inline void Pipe_ClearStall(void);\r
+                       #else\r
+                               #define Pipe_BytesInPipe()             UPBCX\r

 \r
 \r

-                       /** Interrupt definition for the pipe STALL received interrupt. Should be used with the USB_INT_* macros\r
-                        *  located in USBInterrupt.h.\r
-                        *\r
-                        *  This interrupt will fire if enabled on a particular pipe if an attached device returns a STALL on the\r
-                        *  currently selected pipe. This will also fire if the pipe is an isochronous pipe and a CRC error occurs.\r
-                        *\r
-                        *  This interrupt must be enabled on *each* pipe which requires it (after the pipe is selected), and\r
-                        *  will fire the common pipe interrupt vector.\r
-                        *\r
-                        *  \see ENDPOINT_PIPE_vect for more information on the common pipe and endpoint interrupt vector.\r
-                        */\r
-                       #define PIPE_INT_STALL                       UPIENX, (1 << RXSTALLE), UPINTX, (1 << RXSTALLI)\r
+                               #define Pipe_GetCurrentPipe()          (UPNUM & PIPE_PIPENUM_MASK)\r

 \r
 \r

-                       /** Indicates the number of bytes currently stored in the current pipe's selected bank. */\r
-                       #define Pipe_BytesInPipe()                     UPBCX\r
+                               #define Pipe_SelectPipe(pipenum)       MACROS{ UPNUM = pipenum; }MACROE\r
+                               \r
+                               #define Pipe_ResetPipe(pipenum)        MACROS{ UPRST = (1 << pipenum); UPRST = 0; }MACROE\r

 \r
 \r

-                       /** Resets the desired pipe, including the pipe banks and flags. */\r
-                       #define Pipe_ResetPipe(pipenum)        MACROS{ UPRST    =  (1 << pipenum); UPRST = 0;                  }MACROE\r
+                               #define Pipe_EnablePipe()              MACROS{ UPCONX |= (1 << PEN); }MACROE\r

 \r
 \r

-                       /** Selects the given pipe number. Any pipe operations which do not require the pipe number to be\r
-                        *  indicated will operate on the currently selected pipe.\r
-                        */\r
-                       #define Pipe_SelectPipe(pipenum)       MACROS{ UPNUM    =  pipenum;                                    }MACROE\r
+                               #define Pipe_DisablePipe()             MACROS{ UPCONX &= ~(1 << PEN); }MACROE\r

 \r
 \r

-                       /** Returns the pipe address of the currently selected pipe. This is typically used to save the\r
-                        *  currently selected pipe number so that it can be restored after another pipe has been manipulated.\r
-                        */\r
-                       #define Pipe_GetCurrentPipe()                 (UPNUM   &   PIPE_PIPENUM_MASK)\r
+                               #define Pipe_IsEnabled()               ((UPCONX & (1 << PEN)) ? true : false)\r

 \r
 \r

-                       /** Enables the currently selected pipe so that data can be sent and received through it to and from\r
-                        *  an attached device.\r
-                        *\r
-                        *  \note Pipes must first be configured properly rather than just being enabled via the\r
-                        *        Pipe_ConfigurePipe() macro, which calls Pipe_EnablePipe() automatically.\r
-                        */\r
-                       #define Pipe_EnablePipe()              MACROS{ UPCONX  |=  (1 << PEN);                                 }MACROE\r
+                               #define Pipe_GetPipeToken()            (UPCFG0X & PIPE_TOKEN_MASK)\r

 \r
 \r

-                       /** Disables the currently selected pipe so that data cannot be sent and received through it to and\r
-                        *  from an attached device.\r
-                        */\r
-                       #define Pipe_DisablePipe()             MACROS{ UPCONX  &= ~(1 << PEN);                                 }MACROE\r
+                               #define Pipe_SetToken(token)           MACROS{ UPCFG0X = ((UPCFG0X & ~PIPE_TOKEN_MASK) | token); }MACROE\r
+                               \r
+                               #define Pipe_SetInfiniteINRequests()   MACROS{ UPCONX |= (1 << INMODE); }MACROE\r

 \r
 \r

-                       /** Returns true if the currently selected pipe is enabled, false otherwise. */\r
-                       #define Pipe_IsEnabled()                     ((UPCONX  &   (1 << PEN)) ? true : false)\r
+                               #define Pipe_SetFiniteINRequests(n)    MACROS{ UPCONX &= ~(1 << INMODE); UPINRQX = n; }MACROE\r

 \r
 \r

-                       /** Sets the token for the currently selected endpoint to one of the tokens specified by the PIPE_TOKEN_*\r
-                        *  masks. This should only be used on CONTROL type endpoints, to allow for bidirectional transfer of\r
-                        *  data during control requests.\r
-                        */\r
-                       #define Pipe_SetToken(token)           MACROS{ UPCFG0X  = ((UPCFG0X & ~PIPE_TOKEN_MASK) | token);      }MACROE\r
-                       \r
-                       /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */\r
-                       #define Pipe_SetInfiniteINRequests()   MACROS{ UPCONX  |=  (1 << INMODE);                              }MACROE\r
+                               #define Pipe_IsConfigured()            ((UPSTAX  & (1 << CFGOK)) ? true : false)\r

 \r
 \r

-                       /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
-                        *  accepted by the pipe before it is automatically frozen.\r
-                        */\r
-                       #define Pipe_SetFiniteINRequests(n)    MACROS{ UPCONX  &= ~(1 << INMODE); UPINRQX = n;                 }MACROE\r
+                               #define Pipe_SetInterruptPeriod(ms)    MACROS{ UPCFG2X = ms; }MACROE\r

 \r
 \r

-                       /** Returns true if the currently selected pipe is configured, false otherwise. */\r
-                       #define Pipe_IsConfigured()                  ((UPSTAX  & (1 << CFGOK)) ? true : false)\r
+                               #define Pipe_GetPipeInterrupts()       UPINT\r

 \r
 \r

-                       /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds. */\r
-                       #define Pipe_SetInterruptPeriod(ms)    MACROS{ UPCFG2X  = ms;                                          }MACROE\r
+                               #define Pipe_HasPipeInterrupted(n)     ((UPINT & (1 << n)) ? true : false)\r

 \r
 \r

-                       /** Returns a mask indicating which pipe's interrupt periods have elapsed, indicating that the pipe should\r
-                        *  be serviced.\r
-                        */\r
-                       #define Pipe_GetPipeInterrupts()               UPINT\r
+                               #define Pipe_Unfreeze()                MACROS{ UPCONX &= ~(1 << PFREEZE); }MACROE\r

 \r
 \r

-                       /** Clears the interrupt flag for the specified pipe number. */\r
-                       #define Pipe_ClearPipeInterrupt(n)     MACROS{ UPINT   &= ~(1 << n);                                   }MACROE\r
+                               #define Pipe_Freeze()                  MACROS{ UPCONX |= (1 << PFREEZE); }MACROE\r

 \r
 \r

-                       /** Returns true if the specified pipe's interrupt period has elapsed, false otherwise. */\r
-                       #define Pipe_HasPipeInterrupted(n)           ((UPINT   &   (1 << n)) ? true : false)\r
-                       \r
-                       /** Clears the pipe bank, and switches to the alternate bank if the currently selected pipe is\r
-                        *  dual-banked. When cleared, this either frees the bank up for the next packet from the host\r
-                        *  (if the endpoint is of the OUT direction) or sends the packet contents to the host (if the\r
-                        *  pipe is of the IN direction).\r
-                        */\r
-                       #define Pipe_ClearCurrentBank()        MACROS{ UPINTX  &= ~(1 << FIFOCON);                             }MACROE\r
+                               #define Pipe_ClearError()              MACROS{ UPINTX &= ~(1 << PERRI); }MACROE\r

 \r
 \r

-                       /** Unfreezes the pipe, allowing it to communicate with an attached device. */\r
-                       #define Pipe_Unfreeze()                MACROS{ UPCONX  &= ~(1 << PFREEZE);                             }MACROE\r
+                               #define Pipe_IsError()                 ((UPINTX & (1 << PERRI)) ? true : false)\r
+                               \r
+                               #define Pipe_ClearErrorFlags()         MACROS{ UPERRX = 0; }MACROE\r

 \r
 \r

-                       /** Freezes the pipe, preventing it from communicating with an attached device. */\r
-                       #define Pipe_Freeze()                  MACROS{ UPCONX  |=  (1 << PFREEZE);                             }MACROE\r
+                               #define Pipe_GetErrorFlags()           UPERRX\r

 \r
 \r

-                       /** Clears the master pipe error flag. */\r
-                       #define Pipe_ClearError()              MACROS{ UPINTX  &= ~(1 << PERRI);                               }MACROE\r
+                               #define Pipe_IsReadWriteAllowed()      ((UPINTX & (1 << RWAL)) ? true : false)\r

 \r
 \r

-                       /** Returns true if the master pipe error flag is set for the currently selected pipe, indicating that\r
-                        *  some sort of hardware error has occurred on the pipe.\r
-                        *\r
-                        *  \see Pipe_GetErrorFlags() macro for information on retreiving the exact error flag.\r
-                        */\r
-                       #define Pipe_IsError()                       ((UPINTX  &   (1 << PERRI)) ? true : false)\r
-                       \r
-                       /** Clears all the currently selected pipe's hardware error flags, but does not clear the master error\r
-                        *  flag for the pipe. */\r
-                       #define Pipe_ClearErrorFlags()         MACROS{ UPERRX   = 0;                                           }MACROE\r
+                               #define Pipe_IsINReceived()            ((UPINTX & (1 << RXINI)) ? true : false)\r

 \r
 \r

-                       /** Returns a mask of the hardware error flags which have occured on the currently selected pipe. This\r
-                        *  value can then be masked against the PIPE_ERRORFLAG_* masks to determine what error has occurred.\r
-                        */\r
-                       #define Pipe_GetErrorFlags()                   UPERRX\r
+                               #define Pipe_IsOUTReady()              ((UPINTX & (1 << TXOUTI)) ? true : false)\r

 \r
 \r

-                       /** Returns true if the currently selected pipe may be read from (if data is waiting in the pipe\r
-                        *  bank and the pipe is an IN direction, or if the bank is not yet full if the pipe is an OUT\r
-                        *  direction). This function will return false if an error has occured in the pipe, or if the pipe\r
-                        *  is an IN direction and no packet has been received, or if the pipe is an OUT direction and the\r
-                        *  pipe bank is full.\r
-                        */\r
-                       #define Pipe_ReadWriteAllowed()              ((UPINTX  & (1 << RWAL)) ? true : false)\r
+                               #define Pipe_IsSETUPSent()             ((UPINTX & (1 << TXSTPI)) ? true : false)\r

 \r
 \r

-                       /** Clears the flag indicating that a SETUP request has been sent to the attached device from the\r
-                        *  currently selected CONTROL type pipe.\r
-                        */\r
-                       #define Pipe_ClearSetupSent()          MACROS{ UPINTX  &= ~(1 << TXSTPI);                              }MACROE\r
+                               #define Pipe_ClearIN()                 MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << RXINI)); \\r
+                                                                              UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r

 \r
 \r

-                       /** Returns true if no SETUP request is currently being sent to the attached device, false otherwise. */\r
-                       #define Pipe_IsSetupSent()                   ((UPINTX  &   (1 << TXSTPI)) ? true : false)\r
-\r
-                       /** Returns true if the currently selected pipe has been stalled by the attached device, false otherwise. */\r
-                       #define Pipe_IsStalled()                     ((UPINTX  &   (1 << RXSTALLI)) ? true : false)\r
+                               #define Pipe_ClearOUT()                MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << TXOUTI)); \\r
+                                                                              UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r
+                               \r
+                               #define Pipe_ClearSETUP()              MACROS{ uint8_t Temp = UPINTX; UPINTX = (Temp & ~(1 << TXSTPI)); \\r
+                                                                              UPINTX = (Temp & ~(1 << FIFOCON)); }MACROE\r

 \r
 \r

-                       /** Clears the stall condition on the currently selected pipe. */\r
-                       #define Pipe_ClearStall()              MACROS{ UPINTX  &= ~(1 << RXSTALLI);                            }MACROE             \r
+                               #define Pipe_IsNAKReceived()           ((UPINTX & (1 << NAKEDI)) ? true : false)\r

 \r
 \r

-                       /** Returns true if an IN request has been received on the currently selected CONTROL type pipe, false\r
-                        *  otherwise.\r
-                        */\r
-                       #define Pipe_IsSetupINReceived()             ((UPINTX  &   (1 << RXINI)) ? true : false)\r
-\r
-                       /** Returns true if the currently selected CONTROL type pipe is ready to send an OUT request, false\r
-                        *  otherwise.\r
-                        */\r
-                       #define Pipe_IsSetupOUTReady()               ((UPINTX  &   (1 << TXOUTI)) ? true : false)\r
+                               #define Pipe_ClearNAKReceived()        MACROS{ UPINTX &= ~(1 << NAKEDI); }MACROE\r

 \r
 \r

-                       /** Acknowedges the reception of a setup IN request from the attached device on the currently selected\r
-                        *  CONTROL type endpoint, allowing for the transmission of a setup OUT packet, or the reception of\r
-                        *  another setup IN packet.\r
-                        */\r
-                       #define Pipe_ClearSetupIN()            MACROS{ UPINTX  &= ~(1 << RXINI); UPINTX &= ~(1 << FIFOCON);    }MACROE\r
+                               #define Pipe_IsStalled()               ((UPINTX & (1 << RXSTALLI)) ? true : false)\r

 \r
 \r

-                       /** Sends the currently selected CONTROL type pipe's contents to the device as a setup OUT packet. */\r
-                       #define Pipe_ClearSetupOUT()           MACROS{ UPINTX  &= ~(1 << TXOUTI); UPINTX &= ~(1 << FIFOCON);   }MACROE\r
-                       \r
-                       /** Returns true if the device sent a NAK (Negative Acknowedge) in response to the last sent packet on\r
-                        *  the currently selected pipe. This ocurrs when the host sends a packet to the device, but the device\r
-                        *  is not currently ready to handle the packet (i.e. its endpoint banks are full). Once a NAK has been\r
-                        *  received, it must be cleard using Pipe_ClearNAKReceived() before the previous (or any other) packet\r
-                        *  can be re-sent.\r
-                        */\r
-                       #define Pipe_IsNAKReceived()                 ((UPINTX & (1 << NAKEDI)) ? true : false)\r
+                               #define Pipe_ClearStall()              MACROS{ UPINTX &= ~(1 << RXSTALLI); }MACROE\r
+                       #endif\r

 \r
 \r

-                       /** Clears the NAK condition on the currently selected pipe.\r
+               /* Enums: */\r
+                       /** Enum for the possible error return codes of the Pipe_WaitUntilReady function\r

                         *\r
                         *\r

-                        *  \see Pipe_IsNAKReceived() for more details.\r
+                        *  \ingroup Group_PipeRW\r

                         */\r
                         */\r

-                       #define Pipe_ClearNAKReceived()        MACROS{ UPINTX &= ~(1 << NAKEDI);                              }MACROE\r
-\r
-               /* Enums: */\r
-                       /** Enum for the possible error return codes of the Pipe_WaitUntilReady function */\r

                        enum Pipe_WaitUntilReady_ErrorCodes_t\r
                        {\r
                                PIPE_READYWAIT_NoError                 = 0, /**< Pipe ready for next packet, no error */\r
                        enum Pipe_WaitUntilReady_ErrorCodes_t\r
                        {\r
                                PIPE_READYWAIT_NoError                 = 0, /**< Pipe ready for next packet, no error */\r


@@ -378,42 +466,60 @@
                                PIPE_READYWAIT_DeviceDisconnected      = 2,     /**< Device was disconnected from the host while waiting. */\r
                                PIPE_READYWAIT_Timeout                 = 3, /**< The device failed to accept or send the next packet\r
                                                                             *   within the software timeout period set by the\r
                                PIPE_READYWAIT_DeviceDisconnected      = 2,     /**< Device was disconnected from the host while waiting. */\r
                                PIPE_READYWAIT_Timeout                 = 3, /**< The device 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

-                       /** Enum for the possible error return codes of the Pipe_*_Stream_* functions. */\r
+                       /** Enum for the possible error return codes of the Pipe_*_Stream_* functions.\r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        */\r

                        enum Pipe_Stream_RW_ErrorCodes_t\r
                        {\r
                        enum Pipe_Stream_RW_ErrorCodes_t\r
                        {\r

-                               PIPE_RWSTREAM_ERROR_NoError            = 0, /**< Command completed successfully, no error. */\r
-                               PIPE_RWSTREAM_ERROR_PipeStalled        = 1, /**< The device stalled the pipe during the transfer. */            \r
-                               PIPE_RWSTREAM_ERROR_DeviceDisconnected = 2, /**< Device was disconnected from the host during\r
-                                                                        *   the transfer.\r
-                                                                        */             \r
-                               PIPE_RWSTREAM_ERROR_Timeout            = 3, /**< The device 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
-                               PIPE_RWSTREAM_ERROR_CallbackAborted    = 4, /**< Indicates that the stream's callback function aborted\r
-                                                                        *   the transfer early.\r
-                                                                            */\r
+                               PIPE_RWSTREAM_NoError            = 0, /**< Command completed successfully, no error. */\r
+                               PIPE_RWSTREAM_PipeStalled        = 1, /**< The device stalled the pipe during the transfer. */          \r
+                               PIPE_RWSTREAM_DeviceDisconnected = 2, /**< Device was disconnected from the host during\r
+                                                                  *   the transfer.\r
+                                                                  */           \r
+                               PIPE_RWSTREAM_Timeout            = 3, /**< The device 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
+                               PIPE_RWSTREAM_CallbackAborted    = 4, /**< Indicates that the stream's callback function aborted\r
+                                                                  *   the transfer early.\r
+                                                                      */\r

                        };\r
 \r
                /* Inline Functions: */\r
                        };\r
 \r
                /* Inline Functions: */\r

-                       /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes. */\r
-                       static inline uint8_t Pipe_Read_Byte(void) ATTR_WARN_UNUSED_RESULT;\r
+                       /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes.\r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \return Next byte in the currently selected pipe's FIFO buffer\r
+                        */\r
+                       static inline uint8_t Pipe_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r

                        static inline uint8_t Pipe_Read_Byte(void)\r
                        {\r
                                return UPDATX;\r
                        }\r
 \r
                        static inline uint8_t Pipe_Read_Byte(void)\r
                        {\r
                                return UPDATX;\r
                        }\r
 \r

-                       /** Writes one byte from the currently selected pipe's bank, for IN direction pipes. */\r
+                       /** Writes one byte from the currently selected pipe's bank, for IN direction pipes.\r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \param Byte  Next byte to write into the the currently selected pipe's FIFO buffer\r
+                        */\r
+                       static inline void Pipe_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r

                        static inline void Pipe_Write_Byte(const uint8_t Byte)\r
                        {\r
                                UPDATX = Byte;\r
                        }\r
 \r
                        static inline void Pipe_Write_Byte(const uint8_t Byte)\r
                        {\r
                                UPDATX = Byte;\r
                        }\r
 \r

-                       /** Discards one byte from the currently selected pipe's bank, for OUT direction pipes. */\r
+                       /** Discards one byte from the currently selected pipe's bank, for OUT direction pipes.\r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        */\r
+                       static inline void Pipe_Discard_Byte(void) ATTR_ALWAYS_INLINE;\r

                        static inline void Pipe_Discard_Byte(void)\r
                        {\r
                                uint8_t Dummy;\r
                        static inline void Pipe_Discard_Byte(void)\r
                        {\r
                                uint8_t Dummy;\r


@@ -423,8 +529,12 @@
                        \r
                        /** Reads two bytes from the currently selected pipe's bank in little endian format, for OUT\r
                         *  direction pipes.\r
                        \r
                        /** Reads two bytes from the currently selected pipe's bank in little endian format, for OUT\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \return Next word in the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

-                       static inline uint16_t Pipe_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint16_t Pipe_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r

                        static inline uint16_t Pipe_Read_Word_LE(void)\r
                        {\r
                                uint16_t Data;\r
                        static inline uint16_t Pipe_Read_Word_LE(void)\r
                        {\r
                                uint16_t Data;\r


@@ -437,8 +547,12 @@
 \r
                        /** Reads two bytes from the currently selected pipe's bank in big endian format, for OUT\r
                         *  direction pipes.\r
 \r
                        /** Reads two bytes from the currently selected pipe's bank in big endian format, for OUT\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \return Next word in the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

-                       static inline uint16_t Pipe_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint16_t Pipe_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r

                        static inline uint16_t Pipe_Read_Word_BE(void)\r
                        {\r
                                uint16_t Data;\r
                        static inline uint16_t Pipe_Read_Word_BE(void)\r
                        {\r
                                uint16_t Data;\r


@@ -451,7 +565,12 @@
                        \r
                        /** Writes two bytes to the currently selected pipe's bank in little endian format, for IN\r
                         *  direction pipes.\r
                        \r
                        /** Writes two bytes to the currently selected pipe's bank in little endian format, for IN\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \param Word  Next word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

+                       static inline void Pipe_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r

                        static inline void Pipe_Write_Word_LE(const uint16_t Word)\r
                        {\r
                                UPDATX = (Word & 0xFF);\r
                        static inline void Pipe_Write_Word_LE(const uint16_t Word)\r
                        {\r
                                UPDATX = (Word & 0xFF);\r


@@ -460,15 +579,24 @@
                        \r
                        /** Writes two bytes to the currently selected pipe's bank in big endian format, for IN\r
                         *  direction pipes.\r
                        \r
                        /** Writes two bytes to the currently selected pipe's bank in big endian format, for IN\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \param Word  Next word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

+                       static inline void Pipe_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r

                        static inline void Pipe_Write_Word_BE(const uint16_t Word)\r
                        {\r
                                UPDATX = (Word >> 8);\r
                                UPDATX = (Word & 0xFF);\r
                        }\r
 \r
                        static inline void Pipe_Write_Word_BE(const uint16_t Word)\r
                        {\r
                                UPDATX = (Word >> 8);\r
                                UPDATX = (Word & 0xFF);\r
                        }\r
 \r

-                       /** Discards two bytes from the currently selected pipe's bank, for OUT direction pipes. */\r
-                       static inline void Pipe_Ignore_Word(void)\r
+                       /** Discards two bytes from the currently selected pipe's bank, for OUT direction pipes.\r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        */\r
+                       static inline void Pipe_Discard_Word(void) ATTR_ALWAYS_INLINE;\r
+                       static inline void Pipe_Discard_Word(void)\r

                        {\r
                                uint8_t Dummy;\r
                                \r
                        {\r
                                uint8_t Dummy;\r
                                \r


@@ -478,8 +606,12 @@
 \r
                        /** Reads four bytes from the currently selected pipe's bank in little endian format, for OUT\r
                         *  direction pipes.\r
 \r
                        /** Reads four bytes from the currently selected pipe's bank in little endian format, for OUT\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \return Next double word in the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

-                       static inline uint32_t Pipe_Read_DWord_LE(void) ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint32_t Pipe_Read_DWord_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r

                        static inline uint32_t Pipe_Read_DWord_LE(void)\r
                        {\r
                                union\r
                        static inline uint32_t Pipe_Read_DWord_LE(void)\r
                        {\r
                                union\r


@@ -498,8 +630,12 @@
 \r
                        /** Reads four bytes from the currently selected pipe's bank in big endian format, for OUT\r
                         *  direction pipes.\r
 \r
                        /** Reads four bytes from the currently selected pipe's bank in big endian format, for OUT\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \return Next double word in the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

-                       static inline uint32_t Pipe_Read_DWord_BE(void) ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint32_t Pipe_Read_DWord_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r

                        static inline uint32_t Pipe_Read_DWord_BE(void)\r
                        {\r
                                union\r
                        static inline uint32_t Pipe_Read_DWord_BE(void)\r
                        {\r
                                union\r


@@ -518,7 +654,12 @@
 \r
                        /** Writes four bytes to the currently selected pipe's bank in little endian format, for IN\r
                         *  direction pipes.\r
 \r
                        /** Writes four bytes to the currently selected pipe's bank in little endian format, for IN\r
                         *  direction pipes.\r

+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \param DWord  Next double word to write to the currently selected pipe's FIFO buffer\r

                         */\r
                         */\r

+                       static inline void Pipe_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r

                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r
                        {\r
                                Pipe_Write_Word_LE(DWord);\r
                        static inline void Pipe_Write_DWord_LE(const uint32_t DWord)\r
                        {\r
                                Pipe_Write_Word_LE(DWord);\r


@@ -527,15 +668,24 @@
                        \r
                        /** Writes four bytes to the currently selected pipe's bank in big endian format, for IN\r
                         *  direction pipes.\r
                        \r
                        /** Writes four bytes to the currently selected pipe's bank in big endian format, for IN\r
                         *  direction pipes.\r

-                        */                     \r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        *\r
+                        *  \param DWord  Next double word to write to the currently selected pipe's FIFO buffer\r
+                        */\r
+                       static inline void Pipe_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r

                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r
                        {\r
                                Pipe_Write_Word_BE(DWord >> 16);\r
                                Pipe_Write_Word_BE(DWord);\r
                        }                       \r
                        \r
                        static inline void Pipe_Write_DWord_BE(const uint32_t DWord)\r
                        {\r
                                Pipe_Write_Word_BE(DWord >> 16);\r
                                Pipe_Write_Word_BE(DWord);\r
                        }                       \r
                        \r

-                       /** Discards four bytes from the currently selected pipe's bank, for OUT direction pipes. */\r
-                       static inline void Pipe_Ignore_DWord(void)\r
+                       /** Discards four bytes from the currently selected pipe's bank, for OUT direction pipes.       \r
+                        *\r
+                        *  \ingroup Group_PipeRW\r
+                        */\r
+                       static inline void Pipe_Discard_DWord(void) ATTR_ALWAYS_INLINE;\r
+                       static inline void Pipe_Discard_DWord(void)\r

                        {\r
                                uint8_t Dummy;\r
                                \r
                        {\r
                                uint8_t Dummy;\r
                                \r


@@ -559,7 +709,8 @@
                /* Function Prototypes: */\r
                        /** Configures the specified pipe number with the given pipe type, token, target endpoint number in the\r
                         *  attached device, bank size and banking mode. Pipes should be allocated in ascending order by their\r
                /* Function Prototypes: */\r
                        /** Configures the specified pipe number with the given pipe type, token, target endpoint number in the\r
                         *  attached device, bank size and banking mode. Pipes should be allocated in ascending order by their\r

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

                         *\r
                         *  The pipe type may be one of the EP_TYPE_* macros listed in LowLevel.h, the token may be one of the\r
                         *  PIPE_TOKEN_* masks.\r
                         *\r
                         *  The pipe type may be one of the EP_TYPE_* macros listed in LowLevel.h, the token may be one of the\r
                         *  PIPE_TOKEN_* masks.\r


@@ -568,9 +719,12 @@
                         *  numbers can handle different maximum packet sizes - refer to the chosen USB AVR's datasheet to\r
                         *  determine the maximum bank size for each pipe.\r
                         *\r
                         *  numbers can handle different maximum packet sizes - refer to the chosen USB AVR's datasheet to\r
                         *  determine the maximum bank size for each pipe.\r
                         *\r

-                        *  The banking mode may be either PIPE_BANK_SINGLE or PIPE_BANK_DOUBLE.\r
+                        *  The banking mode may be either \ref PIPE_BANK_SINGLE or \ref PIPE_BANK_DOUBLE.\r
+                        *\r
+                        *  A newly configured pipe is frozen by default, and must be unfrozen before use via the \ref Pipe_Unfreeze() macro.\r

                         *\r
                         *\r

-                        *  A newly configured pipe is frozen by default, and must be unfrozen before use via the Pipe_Unfreeze() macro.\r
+                        *  \note The default control pipe does not have to be manually configured, as it is automatically\r
+                        *  configured by the library internally.\r

                         *\r
                         *  \note This routine will select the specified pipe, and the pipe will remain selected once the\r
                         *        routine completes regardless of if the pipe configuration succeeds.\r
                         *\r
                         *  \note This routine will select the specified pipe, and the pipe will remain selected once the\r
                         *        routine completes regardless of if the pipe configuration succeeds.\r


@@ -583,7 +737,7 @@
                        /** Spinloops until the currently selected non-control pipe is ready for the next packed of data\r
                         *  to be read or written to it.\r
                         *\r
                        /** Spinloops until the currently selected non-control pipe is ready for the next packed of data\r
                         *  to be read or written to it.\r
                         *\r

-                        *  \note This routine should not be called on CONTROL type pipes.\r
+                        *  \ingroup Group_PipeRW\r

                         *\r
                         *  \return A value from the Pipe_WaitUntilReady_ErrorCodes_t enum.\r
                         */\r
                         *\r
                         *  \return A value from the Pipe_WaitUntilReady_ErrorCodes_t enum.\r
                         */\r


@@ -592,176 +746,139 @@
                        /** Writes the given number of bytes to the pipe from the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        /** Writes the given number of bytes to the pipe from the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter ommitted.\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
+                        *  \ingroup Group_PipeRW\r

                         *\r
                         *  \param Buffer    Pointer to the source data buffer to read from.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r
                         *\r
                         *  \param Buffer    Pointer to the source data buffer to read from.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r

-                        *  \param Callback  Name of a callback routine to call between sucessive USB packet transfers, NULL if no callback\r
+                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Write_Stream_LE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Write_Stream_LE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r

-                                                    , uint8_t (* const Callback)(void)\r
+                                                    , StreamCallbackPtr_t Callback\r

                        #endif\r
                                                     ) ATTR_NON_NULL_PTR_ARG(1);                                \r
 \r
                        /** Writes the given number of bytes to the pipe from the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        #endif\r
                                                     ) ATTR_NON_NULL_PTR_ARG(1);                                \r
 \r
                        /** Writes the given number of bytes to the pipe from the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearOUT() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter ommitted.\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
+                        *  \ingroup Group_PipeRW\r

                         *\r
                         *  \param Buffer    Pointer to the source data buffer to read from.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r
                         *\r
                         *  \param Buffer    Pointer to the source data buffer to read from.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe into the buffer.\r

-                        *  \param Callback  Name of a callback routine to call between sucessive USB packet transfers, NULL if no callback\r
+                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Write_Stream_BE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Write_Stream_BE(const void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r

-                                                    , uint8_t (* const Callback)(void)\r
+                                                    , StreamCallbackPtr_t Callback\r

                        #endif\r
                                                     ) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads and discards the given number of bytes from the pipe, discarding fully read packets from the host\r
                         *  as needed. The last packet is not automatically discarded once the remaining bytes has been read; the\r
                        #endif\r
                                                     ) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads and discards the given number of bytes from the pipe, discarding fully read packets from the host\r
                         *  as needed. The last packet is not automatically discarded once the remaining bytes has been read; the\r

-                        *  user is responsible for manually discarding the last packet from the host via the Pipe_ClearCurrentBank() macro.\r
+                        *  user is responsible for manually discarding the last packet from the device via the \ref Pipe_ClearIN() macro.\r

                         *  Between each USB packet, the given stream callback function is executed repeatedly until the next packet is ready,\r
                         *  allowing for early aborts of stream transfers.\r
                         *\r
                         *  Between each USB packet, the given stream callback function is executed repeatedly until the next packet is ready,\r
                         *  allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created 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 ommitted.\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
+                        *  \ingroup Group_PipeRW\r

                         *\r
                         *  \param Length  Number of bytes to send via the currently selected pipe.\r
                         *\r
                         *  \param Length  Number of bytes to send via the currently selected pipe.\r

-                        *  \param Callback  Name of a callback routine to call between sucessive USB packet transfers, NULL if no callback\r
+                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Discard_Stream(uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_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
                        /** Reads the given number of bytes from the pipe into the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r
                        #endif\r
                                                    );\r
 \r
                        /** Reads the given number of bytes from the pipe into the given buffer in little endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter ommitted.\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
+                        *  \ingroup Group_PipeRW\r

                         *\r
                         *  \param Buffer    Pointer to the source data buffer to write to.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r
                         *\r
                         *  \param Buffer    Pointer to the source data buffer to write to.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r

-                        *  \param Callback  Name of a callback routine to call between sucessive USB packet transfers, NULL if no callback\r
+                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Read_Stream_LE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r

-                                                   , uint8_t (* const Callback)(void)\r
+                                                   , StreamCallbackPtr_t Callback\r

                        #endif\r
                                                    ) ATTR_NON_NULL_PTR_ARG(1);\r
 \r
                        /** Reads the given number of bytes from the pipe into the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  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
                        /** Reads the given number of bytes from the pipe into the given buffer in big endian,\r
                         *  sending full packets to the device as needed. The last packet filled is not automatically sent;\r
                         *  the user is responsible for manually sending the last written packet to the host via the\r

-                        *  Pipe_ClearCurrentBank() macro. Between each USB packet, the given stream callback function is\r
+                        *  \ref Pipe_ClearIN() macro. Between each USB packet, the given stream callback function is\r

                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r
                         *  executed repeatedly until the next packet is ready, allowing for early aborts of stream transfers.\r
                         *\r

-                        *      The callback routine should be created using the STREAM_CALLBACK() macro. If the token\r
-                        *  NO_STREAM_CALLBACKS is passed via the -D option to the compiler, stream callbacks are disabled\r
-                        *  and this function has the Callback parameter ommitted.\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
+                        *  \ingroup Group_PipeRW\r

                         *\r
                         *  \param Buffer    Pointer to the source data buffer to write to.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r
                         *\r
                         *  \param Buffer    Pointer to the source data buffer to write to.\r
                         *  \param Length    Number of bytes to read for the currently selected pipe to read from.\r

-                        *  \param Callback  Name of a callback routine to call between sucessive USB packet transfers, NULL if no callback\r
+                        *  \param Callback  Name of a callback routine to call between successive USB packet transfers, NULL if no callback\r

                         *\r
                         *\r

-                        *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum.\r
+                        *  \return A value from the \ref Pipe_Stream_RW_ErrorCodes_t enum.\r

                         */\r
                        uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r
                         */\r
                        uint8_t Pipe_Read_Stream_BE(void* Buffer, uint16_t Length\r
                        #if !defined(NO_STREAM_CALLBACKS) || defined(__DOXYGEN__)\r

-                                                   , uint8_t (* const Callback)(void)\r
-                       #endif\r
-                                                   ) ATTR_NON_NULL_PTR_ARG(1);                         \r
-\r
-               /* Function Aliases: */\r
-                       /** Alias for Pipe_Discard_Byte().\r
-                        */\r
-                       #define Pipe_Ignore_Byte()                 Pipe_Discard_Byte()\r
-\r
-                       /** Alias for Pipe_Discard_Word().\r
-                        */\r
-                       #define Pipe_Ignore_Word()                 Pipe_Discard_Word()          \r
-\r
-                       /** Alias for Pipe_Discard_DWord().\r
-                        */\r
-                       #define Pipe_Ignore_DWord()                Pipe_Discard_DWord()\r
-\r
-                       /** Alias for Pipe_Read_Word_LE(). By default USB transfers use little endian format, thus\r
-                        *  the command with no endianness specifier indicates little endian mode.\r
-                        */\r
-                       #define Pipe_Read_Word()                   Pipe_Read_Word_LE()\r
-\r
-                       /** Alias for Pipe_Write_Word_LE(). By default USB transfers use little endian format, thus\r
-                        *  the command with no endianness specifier indicates little endian mode.\r
-                        */\r
-                       #define Pipe_Write_Word(Word)              Pipe_Write_Word_LE(Word)\r
-\r
-                       /** Alias for Pipe_Read_DWord_LE(). By default USB transfers use little endian format, thus\r
-                        *  the command with no endianness specifier indicates little endian mode.\r
-                        */\r
-                       #define Pipe_Read_DWord()                  Pipe_Read_DWord_LE()\r
-\r
-                       /** Alias for Pipe_Write_DWord_LE(). By default USB transfers use little endian format, thus\r
-                        *  the command with no endianness specifier indicates little endian mode.\r
-                        */\r
-                       #define Pipe_Write_DWord(DWord)            Pipe_Write_DWord_LE(DWord)\r
-\r
-                       /** Alias for Pipe_Read_Stream_LE(). By default USB transfers use little endian format, thus\r
-                        *  the command with no endianness specifier indicates little endian mode.\r
-                        */\r
-                       #if !defined(NO_STREAM_CALLBACKS)\r
-                               #define Pipe_Read_Stream(Buffer, Length, Callback) Pipe_Read_Stream_LE(Buffer, Length, Callback)\r
-                       #else\r
-                               #define Pipe_Read_Stream(Buffer, Length)           Pipe_Read_Stream_LE(Buffer, Length)\r
-                       #endif\r
-\r
-                       /** Alias for Pipe_Write_Stream_LE(). By default USB transfers use little endian format, thus\r
-                        *  the command with no endianness specifier indicates little endian mode.\r
-                        */\r
-                       #if !defined(NO_STREAM_CALLBACKS)\r
-                               #define Pipe_Write_Stream(Buffer, Length, Callback) Pipe_Read_Stream_LE(Buffer, Length, Callback)\r
-                       #else\r
-                               #define Pipe_Write_Stream(Buffer, Length)           Pipe_Read_Stream_LE(Buffer, Length)\r
+                                                   , StreamCallbackPtr_t Callback\r

                        #endif\r
                        #endif\r

+                                                   ) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Macros: */\r
                        \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Macros: */\r

-                       #define PIPE_TOKEN_MASK                    (0x03 << PTOKEN0)\r
+                       #define PIPE_TOKEN_MASK                (0x03 << PTOKEN0)\r

 \r
 \r

-                       #define Pipe_AllocateMemory()          MACROS{ UPCFG1X |=  (1 << ALLOC);                               }MACROE\r
-                       #define Pipe_DeallocateMemory()        MACROS{ UPCFG1X &= ~(1 << ALLOC);                               }MACROE\r
+                       #if !defined(ENDPOINT_CONTROLEP)\r
+                               #define ENDPOINT_CONTROLEP         0\r
+                       #endif\r
+                       \r
+                       #define Pipe_AllocateMemory()          MACROS{ UPCFG1X |=  (1 << ALLOC); }MACROE\r
+                       #define Pipe_DeallocateMemory()        MACROS{ UPCFG1X &= ~(1 << ALLOC); }MACROE\r

 \r
                /* Function Prototypes: */\r
                        void Pipe_ClearPipes(void);\r
 \r
                /* Inline Functions: */\r
 \r
                /* Function Prototypes: */\r
                        void Pipe_ClearPipes(void);\r
 \r
                /* Inline Functions: */\r

-                       static inline uint8_t Pipe_BytesToEPSizeMask(uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYSINLINE;\r
+                       static inline uint8_t Pipe_BytesToEPSizeMask(uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST ATTR_ALWAYS_INLINE;\r

                        static inline uint8_t Pipe_BytesToEPSizeMask(uint16_t Bytes)\r
                        {\r
                                if (Bytes <= 8)\r
                        static inline uint8_t Pipe_BytesToEPSizeMask(uint16_t Bytes)\r
                        {\r
                                if (Bytes <= 8)\r


@@ -772,7 +889,7 @@
                                  return (2 << EPSIZE0);\r
                                else if (Bytes <= 64)\r
                                  return (3 << EPSIZE0);\r
                                  return (2 << EPSIZE0);\r
                                else if (Bytes <= 64)\r
                                  return (3 << EPSIZE0);\r

-                               else if (Bytes <= (8 << 4))\r
+                               else if (Bytes <= 128)\r

                                  return (4 << EPSIZE0);\r
                                else\r
                                  return (5 << EPSIZE0);\r
                                  return (4 << EPSIZE0);\r
                                else\r
                                  return (5 << EPSIZE0);\r


@@ -784,5 +901,7 @@
                #if defined(__cplusplus)\r
                        }\r
                #endif\r
                #if defined(__cplusplus)\r
                        }\r
                #endif\r

-               \r
+       \r

 #endif\r
 #endif\r

+\r
+/** @} */\r