Porting updates for the UC3B architecture - get UC3B partially enumerating using...

diff --git a/LUFA/Common/Attributes.h b/LUFA/Common/Attributes.h
index 8c40069..62ce9f2 100644 (file)
--- a/LUFA/Common/Attributes.h
+++ b/LUFA/Common/Attributes.h
@@ -133,6 +133,15 @@
                         *  \param[in] Func  Name of the function which the given function name should alias.
                         */
                        #define ATTR_ALIAS(Func)               __attribute__ ((alias( #Func )))
                         *  \param[in] Func  Name of the function which the given function name should alias.
                         */
                        #define ATTR_ALIAS(Func)               __attribute__ ((alias( #Func )))

+                       
+                       /** Marks a variable or struct element for packing into the smallest space available. */
+                       #define ATTR_PACKED                     __attribute__ ((packed))
+
+                       /** Indicates the minimum alignment in bytes for a variable or struct element.
+                        * 
+                        *  \param[in] Bytes  Minimum number of bytes the item should be aligned to.
+                        */
+                       #define ATTR_ALIGNED(Bytes)            __attribute__ ((aligned(Bytes)))

 #endif
 
 /** @} */
 #endif
 
 /** @} */

diff --git a/LUFA/Common/Common.h b/LUFA/Common/Common.h
index 76e1be1..147ae8e 100644 (file)
--- a/LUFA/Common/Common.h
+++ b/LUFA/Common/Common.h
@@ -87,15 +87,50 @@
                        #include <util/delay.h>
                        
                        typedef uint8_t uint_reg_t;
                        #include <util/delay.h>
                        
                        typedef uint8_t uint_reg_t;

+
+                       #define le16_to_cpu(x)           x
+                       #define le32_to_cpu(x)           x
+                       #define be16_to_cpu(x)           SwapEndian_16(x)
+                       #define be32_to_cpu(x)           SwapEndian_32(x)
+                       #define cpu_to_le16(x)           x
+                       #define cpu_to_le32(x)           x
+                       #define cpu_to_be16(x)           SwapEndian_16(x)
+                       #define cpu_to_be32(x)           SwapEndian_32(x)
+                       #define LE16_TO_CPU(x)           x
+                       #define LE32_TO_CPU(x)           x
+                       #define BE16_TO_CPU(x)           SWAPENDIAN_16(x)
+                       #define BE32_TO_CPU(x)           SWAPENDIAN_32(x)
+                       #define CPU_TO_LE16(x)           x
+                       #define CPU_TO_LE32(x)           x
+                       #define CPU_TO_BE16(x)           SWAPENDIAN_16(x)
+                       #define CPU_TO_BE32(x)           SWAPENDIAN_32(x)
+

                #elif (ARCH == ARCH_UC3B)
                        #include <avr32/io.h>
 
                        typedef uint32_t uint_reg_t;
                        
                        // TODO
                #elif (ARCH == ARCH_UC3B)
                        #include <avr32/io.h>
 
                        typedef uint32_t uint_reg_t;
                        
                        // TODO

+                       #define le16_to_cpu(x)           SwapEndian_16(x)
+                       #define le32_to_cpu(x)           SwapEndian_32(x)
+                       #define be16_to_cpu(x)           x
+                       #define be32_to_cpu(x)           x
+                       #define cpu_to_le16(x)           SwapEndian_16(x)
+                       #define cpu_to_le32(x)           SwapEndian_32(x)
+                       #define cpu_to_be16(x)           x
+                       #define cpu_to_be32(x)           x
+                       #define LE16_TO_CPU(x)           SWAPENDIAN_16(x)
+                       #define LE32_TO_CPU(x)           SWAPENDIAN_32(x)
+                       #define BE16_TO_CPU(x)           x
+                       #define BE32_TO_CPU(x)           x
+                       #define CPU_TO_LE16(x)           SWAPENDIAN_16(x)
+                       #define CPU_TO_LE32(x)           SWAPENDIAN_32(x)
+                       #define CPU_TO_BE16(x)           x
+                       #define CPU_TO_BE32(x)           x
+                       
+                       #define ISR(Name)                void Name (void) __attribute__((__interrupt__)); void Name (void)

                        #define EEMEM
                        #define PROGMEM                  const
                        #define EEMEM
                        #define PROGMEM                  const

-                       #define ISR(Name)                void Name (void) __attribute__((__interrupt__)); void Name (void)

                        #define ATOMIC_BLOCK(x)          if (1)
                        #define ATOMIC_RESTORESTATE
                        #define pgm_read_byte(x)         *x
                        #define ATOMIC_BLOCK(x)          if (1)
                        #define ATOMIC_RESTORESTATE
                        #define pgm_read_byte(x)         *x


@@ -105,10 +140,6 @@
                        #define _delay_ms(x)
                        #define memcmp_P(...)            memcmp(__VA_ARGS__)
                        #define memcpy_P(...)            memcpy(__VA_ARGS__)
                        #define _delay_ms(x)
                        #define memcmp_P(...)            memcmp(__VA_ARGS__)
                        #define memcpy_P(...)            memcpy(__VA_ARGS__)

-                       #define cpu_irq_enable()         do { asm volatile("" ::: "memory"); __builtin_csrf(AVR32_SR_GM_OFFSET); } while (0)
-                       #define cpu_irq_disable()        do { __builtin_ssrf(AVR32_SR_GM_OFFSET); asm volatile("" ::: "memory"); } while (0)
-                       
-                       #warning The UC3B architecture support is currently experimental and incomplete!

                #endif
 
        /* Public Interface - May be used in end-application: */
                #endif
 
        /* Public Interface - May be used in end-application: */

diff --git a/LUFA/Drivers/USB/Core/AVR8/USBController_AVR8.c b/LUFA/Drivers/USB/Core/AVR8/USBController_AVR8.c
index ceb0ebd..18fa48a 100644 (file)
--- a/LUFA/Drivers/USB/Core/AVR8/USBController_AVR8.c
+++ b/LUFA/Drivers/USB/Core/AVR8/USBController_AVR8.c
@@ -59,8 +59,6 @@ void USB_Init(
        #if !defined(USE_STATIC_OPTIONS)
        USB_Options = Options;
        #endif
        #if !defined(USE_STATIC_OPTIONS)
        USB_Options = Options;
        #endif

-       
-       USB_INT_RegisterHandlers();

 
        if (!(USB_Options & USB_OPT_REG_DISABLED))
          USB_REG_On();
 
        if (!(USB_Options & USB_OPT_REG_DISABLED))
          USB_REG_On();

diff --git a/LUFA/Drivers/USB/Core/AVR8/USBInterrupt_AVR8.h b/LUFA/Drivers/USB/Core/AVR8/USBInterrupt_AVR8.h
index 14e5c51..6115ec6 100644 (file)
--- a/LUFA/Drivers/USB/Core/AVR8/USBInterrupt_AVR8.h
+++ b/LUFA/Drivers/USB/Core/AVR8/USBInterrupt_AVR8.h
@@ -84,11 +84,6 @@
                        };
 
                /* Inline Functions: */
                        };
 
                /* Inline Functions: */

-                       static inline void USB_INT_RegisterHandlers(void)
-                       {
-                               // Not required for AVR8
-                       }
-

                        static inline void USB_INT_Enable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;
                        static inline void USB_INT_Enable(const uint8_t Interrupt)
                        {
                        static inline void USB_INT_Enable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;
                        static inline void USB_INT_Enable(const uint8_t Interrupt)
                        {

diff --git a/LUFA/Drivers/USB/Core/DeviceStandardReq.c b/LUFA/Drivers/USB/Core/DeviceStandardReq.c
index f0c336e..e43543d 100644 (file)
--- a/LUFA/Drivers/USB/Core/DeviceStandardReq.c
+++ b/LUFA/Drivers/USB/Core/DeviceStandardReq.c
@@ -48,10 +48,11 @@ bool    USB_RemoteWakeupEnabled;
 
 void USB_Device_ProcessControlRequest(void)
 {
 
 void USB_Device_ProcessControlRequest(void)
 {

-       uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest;
-
-       for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
-         *(RequestHeader++) = Endpoint_Read_Byte();
+       USB_ControlRequest.bmRequestType = Endpoint_Read_Byte();
+       USB_ControlRequest.bRequest      = Endpoint_Read_Byte();
+       USB_ControlRequest.wValue        = le16_to_cpu(Endpoint_Read_Word_LE());
+       USB_ControlRequest.wIndex        = le16_to_cpu(Endpoint_Read_Word_LE());
+       USB_ControlRequest.wLength       = le16_to_cpu(Endpoint_Read_Word_LE());

 
        EVENT_USB_Device_ControlRequest();
 
 
        EVENT_USB_Device_ControlRequest();
 

diff --git a/LUFA/Drivers/USB/Core/StdDescriptors.h b/LUFA/Drivers/USB/Core/StdDescriptors.h
index 8599f47..6f12207 100644 (file)
--- a/LUFA/Drivers/USB/Core/StdDescriptors.h
+++ b/LUFA/Drivers/USB/Core/StdDescriptors.h
@@ -88,13 +88,13 @@
                         *  Decimal format for descriptor fields requiring BCD encoding, such as the USB version number in the
                         *  standard device descriptor.
                         */
                         *  Decimal format for descriptor fields requiring BCD encoding, such as the USB version number in the
                         *  standard device descriptor.
                         */

-                       #define VERSION_BCD(x)                    ((((VERSION_TENS(x) << 4) | VERSION_ONES(x)) << 8) | \
+                       #define VERSION_BCD(x)                    CPU_TO_LE16((((VERSION_TENS(x) << 4) | VERSION_ONES(x)) << 8) | \

                                                                  ((VERSION_TENTHS(x) << 4) | VERSION_HUNDREDTHS(x)))
 
                        /** String language ID for the English language. Should be used in \ref USB_Descriptor_String_t descriptors
                         *  to indicate that the English language is supported by the device in its string descriptors.
                         */
                                                                  ((VERSION_TENTHS(x) << 4) | VERSION_HUNDREDTHS(x)))
 
                        /** String language ID for the English language. Should be used in \ref USB_Descriptor_String_t descriptors
                         *  to indicate that the English language is supported by the device in its string descriptors.
                         */

-                       #define LANGUAGE_ID_ENG                   0x0409
+                       #define LANGUAGE_ID_ENG                   CPU_TO_LE16(0x0409)

 
                        /** \name Endpoint Address Direction Masks */
                        //@{
 
                        /** \name Endpoint Address Direction Masks */
                        //@{

diff --git a/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.c b/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.c
index 1f5004d..ee9d35f 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.c
+++ b/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.c
@@ -39,17 +39,18 @@
 uint8_t USB_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE;\r
 #endif\r
 \r
 uint8_t USB_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE;\r
 #endif\r
 \r

-uint8_t USB_SelectedEndpoint = ENDPOINT_CONTROLEP;\r
-\r
+volatile uint8_t USB_SelectedEndpoint = ENDPOINT_CONTROLEP;\r
+volatile void*   USB_EndpointFIFOPos[ENDPOINT_TOTAL_ENDPOINTS];\r

 \r
 bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,\r
 \r
 bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,\r

-                                    const uint32_t UECFGXData)\r
+                                    const uint32_t UECFG0Data)\r

 {\r
        Endpoint_SelectEndpoint(Number);\r
        Endpoint_EnableEndpoint();\r
 \r
 {\r
        Endpoint_SelectEndpoint(Number);\r
        Endpoint_EnableEndpoint();\r
 \r

-       ((uint32_t*)AVR32_USBB_UECFG0)[USB_SelectedEndpoint] = 0;\r
-       ((uint32_t*)AVR32_USBB_UECFG0)[USB_SelectedEndpoint] = UECFGXData;\r
+       (&AVR32_USBB.uecfg0)[Number] = 0;\r
+       (&AVR32_USBB.uecfg0)[Number] = UECFG0Data;\r
+       USB_EndpointFIFOPos[Number] = &AVR32_USBB_SLAVE[Number * 0x10000];\r

 \r
        return Endpoint_IsConfigured();\r
 }\r
 \r
        return Endpoint_IsConfigured();\r
 }\r


@@ -59,8 +60,9 @@ void Endpoint_ClearEndpoints(void)
        for (uint8_t EPNum = 0; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)\r
        {\r
                Endpoint_SelectEndpoint(EPNum);\r
        for (uint8_t EPNum = 0; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)\r
        {\r
                Endpoint_SelectEndpoint(EPNum);\r

-               ((uint32_t*)AVR32_USBB_UECFG0)[USB_SelectedEndpoint]    = 0;\r
-               ((uint32_t*)AVR32_USBB_UECON0CLR)[USB_SelectedEndpoint] = 0xFFFFFFFF;\r
+               (&AVR32_USBB.uecfg0)[EPNum]    = 0;\r
+               (&AVR32_USBB.uecon0clr)[EPNum] = 0xFFFFFFFF;\r
+               USB_EndpointFIFOPos[EPNum] = &AVR32_USBB_SLAVE[EPNum * 0x10000];\r

                Endpoint_DisableEndpoint();\r
        }\r
 }\r
                Endpoint_DisableEndpoint();\r
        }\r
 }\r

diff --git a/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.h b/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.h
index 556ac84..4860d26 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.h
+++ b/LUFA/Drivers/USB/Core/UC3B/Endpoint_UC3B.h
@@ -131,7 +131,8 @@
                                                            const uint32_t UECFGXData);\r
                \r
                /* External Variables: */\r
                                                            const uint32_t UECFGXData);\r
                \r
                /* External Variables: */\r

-                       extern uint8_t USB_SelectedEndpoint;\r
+                       extern volatile uint8_t USB_SelectedEndpoint;\r
+                       extern volatile void*   USB_EndpointFIFOPos[];\r

        #endif\r
 \r
        /* Public Interface - May be used in end-application: */\r
        #endif\r
 \r
        /* Public Interface - May be used in end-application: */\r


@@ -296,7 +297,7 @@
                        static inline uint16_t Endpoint_BytesInEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_BytesInEndpoint(void)\r
                        {\r
                        static inline uint16_t Endpoint_BytesInEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_BytesInEndpoint(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].byct;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].byct;\r

                        }\r
 \r
                        /** Get the endpoint address of the currently selected endpoint. This is typically used to save\r
                        }\r
 \r
                        /** Get the endpoint address of the currently selected endpoint. This is typically used to save\r


@@ -336,6 +337,7 @@
                        {\r
                                AVR32_USBB.uerst |=  (AVR32_USBB_EPRST0_MASK << EndpointNumber);\r
                                AVR32_USBB.uerst &= ~(AVR32_USBB_EPRST0_MASK << EndpointNumber);\r
                        {\r
                                AVR32_USBB.uerst |=  (AVR32_USBB_EPRST0_MASK << EndpointNumber);\r
                                AVR32_USBB.uerst &= ~(AVR32_USBB_EPRST0_MASK << EndpointNumber);\r

+                               USB_EndpointFIFOPos[EndpointNumber] = &AVR32_USBB_SLAVE[EndpointNumber * 0x10000];\r

                        }\r
 \r
                        /** Enables the currently selected endpoint so that data can be sent and received through it to\r
                        }\r
 \r
                        /** Enables the currently selected endpoint so that data can be sent and received through it to\r


@@ -378,7 +380,7 @@
                         */\r
                        static inline uint8_t Endpoint_GetBusyBanks(void)\r
                        {\r
                         */\r
                        static inline uint8_t Endpoint_GetBusyBanks(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].nbusybk;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].nbusybk;\r

                        }\r
 \r
                        /** Aborts all pending IN transactions on the currently selected endpoint, once the bank\r
                        }\r
 \r
                        /** Aborts all pending IN transactions on the currently selected endpoint, once the bank\r


@@ -392,9 +394,11 @@
                        {\r
                                while (Endpoint_GetBusyBanks() != 0)\r
                                {\r
                        {\r
                                while (Endpoint_GetBusyBanks() != 0)\r
                                {\r

-                                       ((avr32_usbb_uecon0_t*)AVR32_USBB_UECON0SET)[USB_SelectedEndpoint].killbk = true;\r
-                                       while (((avr32_usbb_uecon0_t*)AVR32_USBB_UECON0)[USB_SelectedEndpoint].killbk);\r
+                                       (&AVR32_USBB.UECON0SET)[USB_SelectedEndpoint].killbks = true;\r
+                                       while ((&AVR32_USBB.UECON0)[USB_SelectedEndpoint].killbk);\r

                                }\r
                                }\r

+\r
+                               USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];\r

                        }\r
                        \r
                        /** Determines if the currently selected endpoint may be read from (if data is waiting in the endpoint\r
                        }\r
                        \r
                        /** Determines if the currently selected endpoint may be read from (if data is waiting in the endpoint\r


@@ -411,7 +415,7 @@
                        static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsReadWriteAllowed(void)\r
                        {\r
                        static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsReadWriteAllowed(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].rwall;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].rwall;\r

                        }\r
 \r
                        /** Determines if the currently selected endpoint is configured.\r
                        }\r
 \r
                        /** Determines if the currently selected endpoint is configured.\r


@@ -421,7 +425,7 @@
                        static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsConfigured(void)\r
                        {\r
                        static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsConfigured(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].cfgok;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].cfgok;\r

                        }\r
 \r
                        /** Returns a mask indicating which INTERRUPT type endpoints have interrupted - i.e. their\r
                        }\r
 \r
                        /** Returns a mask indicating which INTERRUPT type endpoints have interrupted - i.e. their\r


@@ -461,7 +465,7 @@
                        static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsINReady(void)\r
                        {\r
                        static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsINReady(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].txini;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].txini;\r

                        }\r
 \r
                        /** Determines if the selected OUT endpoint has received new packet from the host.\r
                        }\r
 \r
                        /** Determines if the selected OUT endpoint has received new packet from the host.\r


@@ -473,7 +477,7 @@
                        static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsOUTReceived(void)\r
                        {\r
                        static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsOUTReceived(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].rxouti;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].rxouti;\r

                        }\r
 \r
                        /** Determines if the current CONTROL type endpoint has received a SETUP packet.\r
                        }\r
 \r
                        /** Determines if the current CONTROL type endpoint has received a SETUP packet.\r


@@ -485,7 +489,7 @@
                        static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsSETUPReceived(void)\r
                        {\r
                        static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsSETUPReceived(void)\r
                        {\r

-                               return ((avr32_usbb_uesta0_t*)AVR32_USBB_UESTA0)[USB_SelectedEndpoint].rxstpi;\r
+                               return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].rxstpi;\r

                        }\r
 \r
                        /** Clears a received SETUP packet on the currently selected CONTROL type endpoint, freeing up the\r
                        }\r
 \r
                        /** Clears a received SETUP packet on the currently selected CONTROL type endpoint, freeing up the\r


@@ -498,7 +502,8 @@
                        static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearSETUP(void)\r
                        {\r
                        static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearSETUP(void)\r
                        {\r

-                               ((avr32_usbb_uesta0clr_t*)AVR32_USBB_UESTA0CLR)[USB_SelectedEndpoint].rxstpic = true;\r
+                               (&AVR32_USBB.UESTA0CLR)[USB_SelectedEndpoint].rxstpic = true;\r
+                               USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];\r

                        }\r
 \r
                        /** Sends an IN packet to the host on the currently selected endpoint, freeing up the endpoint for the\r
                        }\r
 \r
                        /** Sends an IN packet to the host on the currently selected endpoint, freeing up the endpoint for the\r


@@ -509,8 +514,9 @@
                        static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearIN(void)\r
                        {\r
                        static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearIN(void)\r
                        {\r

-                               ((avr32_usbb_uesta0clr_t*)AVR32_USBB_UESTA0CLR)[USB_SelectedEndpoint].txinic   = true;\r
-                               ((avr32_usbb_uecon0clr_t*)AVR32_USBB_UECON0CLR)[USB_SelectedEndpoint].fifoconc = true;\r
+                               (&AVR32_USBB.UESTA0CLR)[USB_SelectedEndpoint].txinic   = true;\r
+                               (&AVR32_USBB.UECON0CLR)[USB_SelectedEndpoint].fifoconc = true;\r
+                               USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];\r

                        }\r
 \r
                        /** Acknowledges an OUT packet to the host on the currently selected endpoint, freeing up the endpoint\r
                        }\r
 \r
                        /** Acknowledges an OUT packet to the host on the currently selected endpoint, freeing up the endpoint\r


@@ -521,8 +527,9 @@
                        static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearOUT(void)\r
                        {\r
                        static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearOUT(void)\r
                        {\r

-                               ((avr32_usbb_uesta0clr_t*)AVR32_USBB_UESTA0CLR)[USB_SelectedEndpoint].rxoutic  = true;\r
-                               ((avr32_usbb_uecon0clr_t*)AVR32_USBB_UECON0CLR)[USB_SelectedEndpoint].fifoconc = true;\r
+                               (&AVR32_USBB.UESTA0CLR)[USB_SelectedEndpoint].rxoutic  = true;\r
+                               (&AVR32_USBB.UECON0CLR)[USB_SelectedEndpoint].fifoconc = true;\r
+                               USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];\r

                        }\r
 \r
                        /** Stalls the current endpoint, indicating to the host that a logical problem occurred with the\r
                        }\r
 \r
                        /** Stalls the current endpoint, indicating to the host that a logical problem occurred with the\r


@@ -539,7 +546,7 @@
                        static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_StallTransaction(void)\r
                        {\r
                        static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_StallTransaction(void)\r
                        {\r

-                               ((avr32_usbb_uecon0set_t*)AVR32_USBB_UECON0SET)[USB_SelectedEndpoint].stallrqs = true;\r
+                               (&AVR32_USBB.UECON0SET)[USB_SelectedEndpoint].stallrqs = true;\r

                        }\r
 \r
                        /** Clears the STALL condition on the currently selected endpoint.\r
                        }\r
 \r
                        /** Clears the STALL condition on the currently selected endpoint.\r


@@ -549,7 +556,7 @@
                        static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearStall(void)\r
                        {\r
                        static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ClearStall(void)\r
                        {\r

-                               ((avr32_usbb_uecon0clr_t*)AVR32_USBB_UECON0CLR)[USB_SelectedEndpoint].stallrqc = true;\r
+                               (&AVR32_USBB.UECON0CLR)[USB_SelectedEndpoint].stallrqc = true;\r

                        }\r
 \r
                        /** Determines if the currently selected endpoint is stalled, false otherwise.\r
                        }\r
 \r
                        /** Determines if the currently selected endpoint is stalled, false otherwise.\r


@@ -561,24 +568,24 @@
                        static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsStalled(void)\r
                        {\r
                        static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Endpoint_IsStalled(void)\r
                        {\r

-                               return ((avr32_usbb_uecon0_t*)AVR32_USBB_UECON0)[USB_SelectedEndpoint].stallrq;\r
+                               return (&AVR32_USBB.UECON0)[USB_SelectedEndpoint].stallrq;\r

                        }\r
 \r
                        /** Resets the data toggle of the currently selected endpoint. */\r
                        static inline void Endpoint_ResetDataToggle(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ResetDataToggle(void)\r
                        {\r
                        }\r
 \r
                        /** Resets the data toggle of the currently selected endpoint. */\r
                        static inline void Endpoint_ResetDataToggle(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_ResetDataToggle(void)\r
                        {\r

-                               ((avr32_usbb_uecon0set_t*)AVR32_USBB_UECON0SET)[USB_SelectedEndpoint].rstdts = true;\r
+                               (&AVR32_USBB.UECON0SET)[USB_SelectedEndpoint].rstdts = true;\r

                        }\r
 \r
                        /** Determines the currently selected endpoint's direction.\r
                         *\r
                         *  \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.\r
                         */\r
                        }\r
 \r
                        /** Determines the currently selected endpoint's direction.\r
                         *\r
                         *  \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.\r
                         */\r

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

                        {\r
                        {\r

-                               return (((uint32_t*)AVR32_USBB_UECFG0)[USB_SelectedEndpoint] & AVR32_USBB_UECFG0_EPDIR_MASK);\r
+                               return ((&AVR32_USBB.uecfg0)[USB_SelectedEndpoint] & AVR32_USBB_UECFG0_EPDIR_MASK);\r

                        }\r
 \r
                        /** Sets the direction of the currently selected endpoint.\r
                        }\r
 \r
                        /** Sets the direction of the currently selected endpoint.\r


@@ -588,7 +595,7 @@
                        static inline void Endpoint_SetEndpointDirection(const uint32_t DirectionMask) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_SetEndpointDirection(const uint32_t DirectionMask)\r
                        {\r
                        static inline void Endpoint_SetEndpointDirection(const uint32_t DirectionMask) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_SetEndpointDirection(const uint32_t DirectionMask)\r
                        {\r

-                               ((avr32_usbb_uecfg0_t*)AVR32_USBB_UECFG0)[USB_SelectedEndpoint].epdir = (DirectionMask == ENDPOINT_DIR_IN);\r
+                               (&AVR32_USBB.UECFG0)[USB_SelectedEndpoint].epdir = (DirectionMask == ENDPOINT_DIR_IN);\r

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


@@ -600,7 +607,7 @@
                        static inline uint8_t Endpoint_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Endpoint_Read_Byte(void)\r
                        {\r
                        static inline uint8_t Endpoint_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Endpoint_Read_Byte(void)\r
                        {\r

-                               return *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               return *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

                        }\r
 \r
                        /** Writes one byte from the currently selected endpoint's bank, for IN direction endpoints.\r
                        }\r
 \r
                        /** Writes one byte from the currently selected endpoint's bank, for IN direction endpoints.\r


@@ -612,7 +619,7 @@
                        static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte)\r
                        {\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Byte(const uint8_t Byte)\r
                        {\r

-                               *((uint8_t*)AVR32_USBB_EP_DATA) = Byte;\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = Byte;\r

                        }\r
 \r
                        /** Discards one byte from the currently selected endpoint's bank, for OUT direction endpoints.\r
                        }\r
 \r
                        /** Discards one byte from the currently selected endpoint's bank, for OUT direction endpoints.\r


@@ -624,7 +631,7 @@
                        {\r
                                uint8_t Dummy;\r
 \r
                        {\r
                                uint8_t Dummy;\r
 \r

-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

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


@@ -637,16 +644,10 @@
                        static inline uint16_t Endpoint_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_LE(void)\r
                        {\r
                        static inline uint16_t Endpoint_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_LE(void)\r
                        {\r

-                               union\r
-                               {\r
-                                       uint16_t Word;\r
-                                       uint8_t  Bytes[2];\r
-                               } Data;\r
-\r
-                               Data.Bytes[0] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[1] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               uint16_t Byte1 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint16_t Byte0 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

 \r
 \r

-                               return Data.Word;\r
+                               return ((Byte1 << 8) | Byte0);\r

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


@@ -659,16 +660,10 @@
                        static inline uint16_t Endpoint_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_BE(void)\r
                        {\r
                        static inline uint16_t Endpoint_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Endpoint_Read_Word_BE(void)\r
                        {\r

-                               union\r
-                               {\r
-                                       uint16_t Word;\r
-                                       uint8_t  Bytes[2];\r
-                               } Data;\r
-\r
-                               Data.Bytes[1] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[0] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               uint16_t Byte0 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint16_t Byte1 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

 \r
 \r

-                               return Data.Word;\r
+                               return ((Byte1 << 8) | Byte0);\r

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


@@ -681,8 +676,8 @@
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word)\r
                        {\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_LE(const uint16_t Word)\r
                        {\r

-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (Word & 0xFF);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (Word >> 8);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (Word & 0xFF);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (Word >> 8);\r

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


@@ -695,8 +690,8 @@
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word)\r
                        {\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_Word_BE(const uint16_t Word)\r
                        {\r

-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (Word >> 8);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (Word & 0xFF);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (Word >> 8);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (Word & 0xFF);\r

                        }\r
 \r
                        /** Discards two bytes from the currently selected endpoint's bank, for OUT direction endpoints.\r
                        }\r
 \r
                        /** Discards two bytes from the currently selected endpoint's bank, for OUT direction endpoints.\r


@@ -708,8 +703,8 @@
                        {\r
                                uint8_t Dummy;\r
 \r
                        {\r
                                uint8_t Dummy;\r
 \r

-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

                        }\r
 \r
                        /** Reads four bytes from the currently selected endpoint's bank in little endian format, for OUT\r
                        }\r
 \r
                        /** Reads four bytes from the currently selected endpoint's bank in little endian format, for OUT\r


@@ -722,18 +717,12 @@
                        static inline uint32_t Endpoint_Read_DWord_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint32_t Endpoint_Read_DWord_LE(void)\r
                        {\r
                        static inline uint32_t Endpoint_Read_DWord_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint32_t Endpoint_Read_DWord_LE(void)\r
                        {\r

-                               union\r
-                               {\r
-                                       uint32_t DWord;\r
-                                       uint8_t  Bytes[4];\r
-                               } Data;\r
-\r
-                               Data.Bytes[0] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[1] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[2] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[3] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               uint32_t Byte3 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint32_t Byte2 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint32_t Byte1 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint32_t Byte0 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

 \r
 \r

-                               return Data.DWord;\r
+                               return ((Byte3 << 24) | (Byte2 << 16) | (Byte1 << 8) | Byte0);\r

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


@@ -746,18 +735,12 @@
                        static inline uint32_t Endpoint_Read_DWord_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint32_t Endpoint_Read_DWord_BE(void)\r
                        {\r
                        static inline uint32_t Endpoint_Read_DWord_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint32_t Endpoint_Read_DWord_BE(void)\r
                        {\r

-                               union\r
-                               {\r
-                                       uint32_t DWord;\r
-                                       uint8_t  Bytes[4];\r
-                               } Data;\r
-\r
-                               Data.Bytes[3] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[2] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[1] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Data.Bytes[0] = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               uint32_t Byte0 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint32_t Byte1 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint32_t Byte2 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               uint32_t Byte3 = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

 \r
 \r

-                               return Data.DWord;\r
+                               return ((Byte3 << 24) | (Byte2 << 16) | (Byte1 << 8) | Byte0);\r

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


@@ -770,10 +753,10 @@
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)\r
                        {\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)\r
                        {\r

-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord &  0xFF);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord >> 8);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord >> 16);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord >> 24);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord &  0xFF);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord >> 8);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord >> 16);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord >> 24);\r

                        }\r
 \r
                        /** Writes four bytes to the currently selected endpoint's bank in big endian format, for IN\r
                        }\r
 \r
                        /** Writes four bytes to the currently selected endpoint's bank in big endian format, for IN\r


@@ -786,10 +769,10 @@
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)\r
                        {\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;\r
                        static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)\r
                        {\r

-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord >> 24);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord >> 16);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord >> 8);\r
-                               *((uint8_t*)AVR32_USBB_EP_DATA) = (DWord &  0xFF);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord >> 24);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord >> 16);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord >> 8);\r
+                               *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++) = (DWord &  0xFF);\r

                        }\r
 \r
                        /** Discards four bytes from the currently selected endpoint's bank, for OUT direction endpoints.\r
                        }\r
 \r
                        /** Discards four bytes from the currently selected endpoint's bank, for OUT direction endpoints.\r


@@ -801,10 +784,10 @@
                        {\r
                                uint8_t Dummy;\r
 \r
                        {\r
                                uint8_t Dummy;\r
 \r

-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
-                               Dummy = *((uint8_t*)AVR32_USBB_EP_DATA);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r
+                               Dummy = *(((volatile uint8_t** volatile)USB_EndpointFIFOPos)[USB_SelectedEndpoint]++);\r

                        }\r
 \r
                /* External Variables: */\r
                        }\r
 \r
                /* External Variables: */\r

diff --git a/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.c b/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.c
index 9d9c600..eb41143 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.c
+++ b/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.c
@@ -36,7 +36,7 @@
 #include "../Pipe.h"\r
 \r
 uint8_t USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;\r
 #include "../Pipe.h"\r
 \r
 uint8_t USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;\r

-uint8_t USB_SelectedPipe    = PIPE_CONTROLPIPE;\r
+volatile uint8_t USB_SelectedPipe = PIPE_CONTROLPIPE;\r

 \r
 bool Pipe_ConfigurePipe(const uint8_t Number,\r
                         const uint8_t Type,\r
 \r
 bool Pipe_ConfigurePipe(const uint8_t Number,\r
                         const uint8_t Type,\r


@@ -48,8 +48,8 @@ bool Pipe_ConfigurePipe(const uint8_t Number,
        Pipe_SelectPipe(Number);\r
        Pipe_EnablePipe();\r
 \r
        Pipe_SelectPipe(Number);\r
        Pipe_EnablePipe();\r
 \r

-       ((uint32_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe] = 0;\r
-       ((uint32_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe] = (AVR32_USBB_ALLOC_MASK |\r
+       (&AVR32_USBB.upcfg0)[Number] = 0;\r
+       (&AVR32_USBB.upcfg0)[Number] = (AVR32_USBB_ALLOC_MASK |\r

                                                           ((uint32_t)Type  << AVR32_USBB_PTYPE_OFFSET)  |\r
                                                           ((uint32_t)Token << AVR32_USBB_PTOKEN_OFFSET) |\r
                                                           ((uint32_t)Banks << AVR32_USBB_PBK_OFFSET)    |\r
                                                           ((uint32_t)Type  << AVR32_USBB_PTYPE_OFFSET)  |\r
                                                           ((uint32_t)Token << AVR32_USBB_PTOKEN_OFFSET) |\r
                                                           ((uint32_t)Banks << AVR32_USBB_PBK_OFFSET)    |\r


@@ -65,8 +65,8 @@ void Pipe_ClearPipes(void)
        for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)\r
        {\r
                Pipe_SelectPipe(PNum);\r
        for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)\r
        {\r
                Pipe_SelectPipe(PNum);\r

-               ((uint32_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe]    = 0;\r
-               ((uint32_t*)AVR32_USBB_UPCON0CLR)[USB_SelectedPipe] = 0xFFFFFFFF;\r
+               (&AVR32_USBB.upcfg0)[PNum]    = 0;\r
+               (&AVR32_USBB.upcon0clr)[PNum] = 0xFFFFFFFF;\r

                Pipe_DisablePipe();\r
        }\r
 }\r
                Pipe_DisablePipe();\r
        }\r
 }\r

diff --git a/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.h b/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.h
index 484e48a..033dd01 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.h
+++ b/LUFA/Drivers/USB/Core/UC3B/Pipe_UC3B.h
@@ -99,7 +99,7 @@
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* External Variables: */\r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* External Variables: */\r

-                       extern uint8_t USB_SelectedPipe;\r
+                       extern volatile uint8_t USB_SelectedPipe;\r

        #endif\r
 \r
        /* Public Interface - May be used in end-application: */\r
        #endif\r
 \r
        /* Public Interface - May be used in end-application: */\r


@@ -212,7 +212,7 @@
                        static inline uint16_t Pipe_BytesInPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Pipe_BytesInPipe(void)\r
                        {\r
                        static inline uint16_t Pipe_BytesInPipe(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint16_t Pipe_BytesInPipe(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].pbyct;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].pbyct;\r

                        }\r
 \r
                        /** Returns the pipe address of the currently selected pipe. This is typically used to save the\r
                        }\r
 \r
                        /** Returns the pipe address of the currently selected pipe. This is typically used to save the\r


@@ -285,7 +285,7 @@
                        static inline uint8_t Pipe_GetPipeToken(void) ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Pipe_GetPipeToken(void)\r
                        {\r
                        static inline uint8_t Pipe_GetPipeToken(void) ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Pipe_GetPipeToken(void)\r
                        {\r

-                               return ((avr32_usbb_upcfg0_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe].ptoken;\r
+                               return (&AVR32_USBB.UPCFG0)[USB_SelectedPipe].ptoken;\r

                        }\r
 \r
                        /** Sets the token for the currently selected pipe to one of the tokens specified by the \c PIPE_TOKEN_*\r
                        }\r
 \r
                        /** Sets the token for the currently selected pipe to one of the tokens specified by the \c PIPE_TOKEN_*\r


@@ -298,14 +298,14 @@
                        static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetPipeToken(const uint8_t Token)\r
                        {\r
                        static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetPipeToken(const uint8_t Token)\r
                        {\r

-                               ((avr32_usbb_upcfg0_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe].ptoken = Token;\r
+                               (&AVR32_USBB.UPCFG0)[USB_SelectedPipe].ptoken = Token;\r

                        }\r
 \r
                        /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */\r
                        static inline void Pipe_SetInfiniteINRequests(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetInfiniteINRequests(void)\r
                        {\r
                        }\r
 \r
                        /** Configures the currently selected pipe to allow for an unlimited number of IN requests. */\r
                        static inline void Pipe_SetInfiniteINRequests(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetInfiniteINRequests(void)\r
                        {\r

-                               ((avr32_usbb_upinrq0_t*)AVR32_USBB_UPINRQ0)[USB_SelectedPipe].inmode = true;\r
+                               (&AVR32_USBB.UPINRQ0)[USB_SelectedPipe].inmode = true;\r

                        }\r
 \r
                        /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r
                        }\r
 \r
                        /** Configures the currently selected pipe to only allow the specified number of IN requests to be\r


@@ -316,8 +316,8 @@
                        static inline void Pipe_SetFiniteINRequests(const uint8_t TotalINRequests) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetFiniteINRequests(const uint8_t TotalINRequests)\r
                        {\r
                        static inline void Pipe_SetFiniteINRequests(const uint8_t TotalINRequests) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetFiniteINRequests(const uint8_t TotalINRequests)\r
                        {\r

-                               ((avr32_usbb_upinrq0_t*)AVR32_USBB_UPINRQ0)[USB_SelectedPipe].inmode = false;\r
-                               ((avr32_usbb_upinrq0_t*)AVR32_USBB_UPINRQ0)[USB_SelectedPipe].inrq   = TotalINRequests;\r
+                               (&AVR32_USBB.UPINRQ0)[USB_SelectedPipe].inmode = false;\r
+                               (&AVR32_USBB.UPINRQ0)[USB_SelectedPipe].inrq   = TotalINRequests;\r

                        }\r
 \r
                        /** Determines if the currently selected pipe is configured.\r
                        }\r
 \r
                        /** Determines if the currently selected pipe is configured.\r


@@ -327,7 +327,7 @@
                        static inline bool Pipe_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsConfigured(void)\r
                        {\r
                        static inline bool Pipe_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsConfigured(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].cfgok;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].cfgok;\r

                        }\r
 \r
                        /** Retrieves the endpoint number of the endpoint within the attached device that the currently selected\r
                        }\r
 \r
                        /** Retrieves the endpoint number of the endpoint within the attached device that the currently selected\r


@@ -338,7 +338,7 @@
                        static inline uint8_t Pipe_BoundEndpointNumber(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Pipe_BoundEndpointNumber(void)\r
                        {\r
                        static inline uint8_t Pipe_BoundEndpointNumber(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Pipe_BoundEndpointNumber(void)\r
                        {\r

-                               return ((avr32_usbb_upcfg0_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe].pepnum;\r
+                               return (&AVR32_USBB.UPCFG0)[USB_SelectedPipe].pepnum;\r

                        }\r
 \r
                        /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r
                        }\r
 \r
                        /** Sets the period between interrupts for an INTERRUPT type pipe to a specified number of milliseconds.\r


@@ -348,7 +348,7 @@
                        static inline void Pipe_SetInterruptPeriod(const uint8_t Milliseconds) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetInterruptPeriod(const uint8_t Milliseconds)\r
                        {\r
                        static inline void Pipe_SetInterruptPeriod(const uint8_t Milliseconds) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_SetInterruptPeriod(const uint8_t Milliseconds)\r
                        {\r

-                               ((avr32_usbb_upcfg0_t*)AVR32_USBB_UPCFG0)[USB_SelectedPipe].intfrq = Milliseconds;\r
+                               (&AVR32_USBB.UPCFG0)[USB_SelectedPipe].intfrq = Milliseconds;\r

                        }\r
 \r
                        /** Returns a mask indicating which pipe's interrupt periods have elapsed, indicating that the pipe should\r
                        }\r
 \r
                        /** Returns a mask indicating which pipe's interrupt periods have elapsed, indicating that the pipe should\r


@@ -382,14 +382,14 @@
                        static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Unfreeze(void)\r
                        {\r
                        static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Unfreeze(void)\r
                        {\r

-                               ((avr32_usbb_upcon0clr_t*)AVR32_USBB_UPCON0CLR)[USB_SelectedPipe].pfreezec = true;\r
+                               (&AVR32_USBB.UPCON0CLR)[USB_SelectedPipe].pfreezec = true;\r

                        }\r
 \r
                        /** Freezes the selected pipe, preventing it from communicating with an attached device. */\r
                        static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Freeze(void)\r
                        {\r
                        }\r
 \r
                        /** Freezes the selected pipe, preventing it from communicating with an attached device. */\r
                        static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_Freeze(void)\r
                        {\r

-                               ((avr32_usbb_upcon0set_t*)AVR32_USBB_UPCON0SET)[USB_SelectedPipe].pfreezes = true;\r
+                               (&AVR32_USBB.UPCON0SET)[USB_SelectedPipe].pfreezes = true;\r

                        }\r
 \r
                        /** Determines if the currently selected pipe is frozen, and not able to accept data.\r
                        }\r
 \r
                        /** Determines if the currently selected pipe is frozen, and not able to accept data.\r


@@ -399,15 +399,15 @@
                        static inline bool Pipe_IsFrozen(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsFrozen(void)\r
                        {\r
                        static inline bool Pipe_IsFrozen(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsFrozen(void)\r
                        {\r

-                               return ((((avr32_usbb_upcon0_t*)AVR32_USBB_UPCON0)[USB_SelectedPipe].pfreeze) ? true : false);\r
+                               return (((&AVR32_USBB.UPCON0)[USB_SelectedPipe].pfreeze) ? true : false);\r

                        }\r
 \r
                        /** Clears the error flags for the currently selected pipe. */\r
                        static inline void Pipe_ClearError(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearError(void)\r
                        {\r
                        }\r
 \r
                        /** Clears the error flags for the currently selected pipe. */\r
                        static inline void Pipe_ClearError(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearError(void)\r
                        {\r

-                               ((uint32_t*)AVR32_USBB_UPERR0)[USB_SelectedPipe] = 0;\r
-                               ((avr32_usbb_upsta0clr_t*)AVR32_USBB_UPSTA0CLR)[USB_SelectedPipe].overfic  = true;\r
+                               (&AVR32_USBB.uperr0)[USB_SelectedPipe] = 0;\r
+                               (&AVR32_USBB.UPSTA0CLR)[USB_SelectedPipe].overfic  = true;\r

                        }\r
 \r
                        /** Determines if the master pipe error flag is set for the currently selected pipe, indicating that\r
                        }\r
 \r
                        /** Determines if the master pipe error flag is set for the currently selected pipe, indicating that\r


@@ -420,7 +420,7 @@
                        static inline bool Pipe_IsError(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsError(void)\r
                        {\r
                        static inline bool Pipe_IsError(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsError(void)\r
                        {\r

-                               return ((((uint32_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe] &\r
+                               return (((&AVR32_USBB.upsta0)[USB_SelectedPipe] &\r

                                        (AVR32_USBB_PERRI_MASK | AVR32_USBB_OVERFI_MASK)) ? true : false);\r
                        }\r
 \r
                                        (AVR32_USBB_PERRI_MASK | AVR32_USBB_OVERFI_MASK)) ? true : false);\r
                        }\r
 \r


@@ -433,11 +433,11 @@
                        static inline uint8_t Pipe_GetErrorFlags(void)\r
                        {\r
                                \r
                        static inline uint8_t Pipe_GetErrorFlags(void)\r
                        {\r
                                \r

-                               return ((((uint32_t*)AVR32_USBB_UPERR0)[USB_SelectedPipe] &\r
+                               return (((&AVR32_USBB.uperr0)[USB_SelectedPipe] &\r

                                        (PIPE_ERRORFLAG_CRC16 | PIPE_ERRORFLAG_TIMEOUT |\r
                                         PIPE_ERRORFLAG_PID   | PIPE_ERRORFLAG_DATAPID |\r
                                         PIPE_ERRORFLAG_DATATGL)) |\r
                                        (PIPE_ERRORFLAG_CRC16 | PIPE_ERRORFLAG_TIMEOUT |\r
                                         PIPE_ERRORFLAG_PID   | PIPE_ERRORFLAG_DATAPID |\r
                                         PIPE_ERRORFLAG_DATATGL)) |\r

-                                       ((((uint32_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe] << 8) &\r
+                                       (((&AVR32_USBB.upsta0)[USB_SelectedPipe] << 8) &\r

                                                 PIPE_ERRORFLAG_OVERFLOW));\r
                        }\r
                        \r
                                                 PIPE_ERRORFLAG_OVERFLOW));\r
                        }\r
                        \r


@@ -451,7 +451,7 @@
                         */\r
                        static inline uint8_t Pipe_GetBusyBanks(void)\r
                        {\r
                         */\r
                        static inline uint8_t Pipe_GetBusyBanks(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].nbusybk;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].nbusybk;\r

                        }\r
 \r
                        /** Determines if the currently selected pipe may be read from (if data is waiting in the pipe\r
                        }\r
 \r
                        /** Determines if the currently selected pipe may be read from (if data is waiting in the pipe\r


@@ -470,7 +470,7 @@
                        static inline bool Pipe_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsReadWriteAllowed(void)\r
                        {\r
                        static inline bool Pipe_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsReadWriteAllowed(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].rwall;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].rwall;\r

                        }\r
 \r
                        /** Determines if a packet has been received on the currently selected IN pipe from the attached device.\r
                        }\r
 \r
                        /** Determines if a packet has been received on the currently selected IN pipe from the attached device.\r


@@ -482,7 +482,7 @@
                        static inline bool Pipe_IsINReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsINReceived(void)\r
                        {\r
                        static inline bool Pipe_IsINReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsINReceived(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].rxini;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].rxini;\r

                        }\r
 \r
                        /** Determines if the currently selected OUT pipe is ready to send an OUT packet to the attached device.\r
                        }\r
 \r
                        /** Determines if the currently selected OUT pipe is ready to send an OUT packet to the attached device.\r


@@ -494,7 +494,7 @@
                        static inline bool Pipe_IsOUTReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsOUTReady(void)\r
                        {\r
                        static inline bool Pipe_IsOUTReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsOUTReady(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].txouti;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].txouti;\r

                        }\r
 \r
                        /** Determines if no SETUP request is currently being sent to the attached device on the selected\r
                        }\r
 \r
                        /** Determines if no SETUP request is currently being sent to the attached device on the selected\r


@@ -507,7 +507,7 @@
                        static inline bool Pipe_IsSETUPSent(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsSETUPSent(void)\r
                        {\r
                        static inline bool Pipe_IsSETUPSent(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsSETUPSent(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].txstpi;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].txstpi;\r

                        }\r
 \r
                        /** Sends the currently selected CONTROL type pipe's contents to the device as a SETUP packet.\r
                        }\r
 \r
                        /** Sends the currently selected CONTROL type pipe's contents to the device as a SETUP packet.\r


@@ -517,7 +517,7 @@
                        static inline void Pipe_ClearSETUP(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearSETUP(void)\r
                        {\r
                        static inline void Pipe_ClearSETUP(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearSETUP(void)\r
                        {\r

-                               ((avr32_usbb_upsta0clr_t*)AVR32_USBB_UPSTA0CLR)[USB_SelectedPipe].txstpic = true;\r
+                               (&AVR32_USBB.UPSTA0CLR)[USB_SelectedPipe].txstpic = true;\r

                        }\r
 \r
                        /** Acknowledges the reception of a setup IN request from the attached device on the currently selected\r
                        }\r
 \r
                        /** Acknowledges the reception of a setup IN request from the attached device on the currently selected\r


@@ -528,8 +528,8 @@
                        static inline void Pipe_ClearIN(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearIN(void)\r
                        {\r
                        static inline void Pipe_ClearIN(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearIN(void)\r
                        {\r

-                               ((avr32_usbb_upsta0clr_t*)AVR32_USBB_UPSTA0CLR)[USB_SelectedPipe].rxinic   = true;\r
-                               ((avr32_usbb_upcon0clr_t*)AVR32_USBB_UPCON0CLR)[USB_SelectedPipe].fifoconc = true;\r
+                               (&AVR32_USBB.UPSTA0CLR)[USB_SelectedPipe].rxinic   = true;\r
+                               (&AVR32_USBB.UPCON0CLR)[USB_SelectedPipe].fifoconc = true;\r

                        }\r
 \r
                        /** Sends the currently selected pipe's contents to the device as an OUT packet on the selected pipe, freeing\r
                        }\r
 \r
                        /** Sends the currently selected pipe's contents to the device as an OUT packet on the selected pipe, freeing\r


@@ -540,8 +540,8 @@
                        static inline void Pipe_ClearOUT(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearOUT(void)\r
                        {\r
                        static inline void Pipe_ClearOUT(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearOUT(void)\r
                        {\r

-                               ((avr32_usbb_upsta0clr_t*)AVR32_USBB_UPSTA0CLR)[USB_SelectedPipe].txoutic  = true;\r
-                               ((avr32_usbb_upcon0clr_t*)AVR32_USBB_UPCON0CLR)[USB_SelectedPipe].fifoconc = true;\r
+                               (&AVR32_USBB.UPSTA0CLR)[USB_SelectedPipe].txoutic  = true;\r
+                               (&AVR32_USBB.UPCON0CLR)[USB_SelectedPipe].fifoconc = true;\r

                        }\r
 \r
                        /** Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on\r
                        }\r
 \r
                        /** Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on\r


@@ -557,7 +557,7 @@
                        static inline bool Pipe_IsNAKReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsNAKReceived(void)\r
                        {\r
                        static inline bool Pipe_IsNAKReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsNAKReceived(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].nakedi;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].nakedi;\r

                        }\r
 \r
                        /** Clears the NAK condition on the currently selected pipe.\r
                        }\r
 \r
                        /** Clears the NAK condition on the currently selected pipe.\r


@@ -569,7 +569,7 @@
                        static inline void Pipe_ClearNAKReceived(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearNAKReceived(void)\r
                        {\r
                        static inline void Pipe_ClearNAKReceived(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearNAKReceived(void)\r
                        {\r

-                               ((avr32_usbb_upsta0clr_t*)AVR32_USBB_UPSTA0CLR)[USB_SelectedPipe].nakedic = true;\r
+                               (&AVR32_USBB.UPSTA0CLR)[USB_SelectedPipe].nakedic = true;\r

                        }\r
 \r
                        /** Determines if the currently selected pipe has had the STALL condition set by the attached device.\r
                        }\r
 \r
                        /** Determines if the currently selected pipe has had the STALL condition set by the attached device.\r


@@ -581,7 +581,7 @@
                        static inline bool Pipe_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsStalled(void)\r
                        {\r
                        static inline bool Pipe_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;\r
                        static inline bool Pipe_IsStalled(void)\r
                        {\r

-                               return ((avr32_usbb_upsta0_t*)AVR32_USBB_UPSTA0)[USB_SelectedPipe].rxstalldi;\r
+                               return (&AVR32_USBB.UPSTA0)[USB_SelectedPipe].rxstalldi;\r

                        }\r
 \r
                        /** Clears the STALL condition detection flag on the currently selected pipe, but does not clear the\r
                        }\r
 \r
                        /** Clears the STALL condition detection flag on the currently selected pipe, but does not clear the\r


@@ -592,7 +592,7 @@
                        static inline void Pipe_ClearStall(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearStall(void)\r
                        {\r
                        static inline void Pipe_ClearStall(void) ATTR_ALWAYS_INLINE;\r
                        static inline void Pipe_ClearStall(void)\r
                        {\r

-                               ((avr32_usbb_upsta0clr_t*)AVR32_USBB_UPSTA0CLR)[USB_SelectedPipe].rxstalldic = true;\r
+                               (&AVR32_USBB.UPSTA0CLR)[USB_SelectedPipe].rxstalldic = true;\r

                        }\r
 \r
                        /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes.\r
                        }\r
 \r
                        /** Reads one byte from the currently selected pipe's bank, for OUT direction pipes.\r

diff --git a/LUFA/Drivers/USB/Core/UC3B/USBController_UC3B.c b/LUFA/Drivers/USB/Core/UC3B/USBController_UC3B.c
index 191e084..8241e0b 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/USBController_UC3B.c
+++ b/LUFA/Drivers/USB/Core/UC3B/USBController_UC3B.c
@@ -60,8 +60,6 @@ void USB_Init(
        USB_Options = Options;\r
        #endif\r
        \r
        USB_Options = Options;\r
        #endif\r
        \r

-       USB_INT_RegisterHandlers();\r
-\r

        #if defined(USB_CAN_BE_BOTH)\r
        if (Mode == USB_MODE_UID)\r
        {\r
        #if defined(USB_CAN_BE_BOTH)\r
        if (Mode == USB_MODE_UID)\r
        {\r


@@ -71,6 +69,7 @@ void USB_Init(
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

+               AVR32_USBB.USBCON.uide = false;\r

                USB_CurrentMode = Mode;\r
        }\r
        #endif\r
                USB_CurrentMode = Mode;\r
        }\r
        #endif\r


@@ -108,7 +107,7 @@ void USB_ResetInterface(void)
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].pllsel = !(USB_Options & USB_OPT_GCLK_SRC_OSC);\r
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].oscsel = !(USB_Options & USB_OPT_GCLK_CHANNEL_0);\r
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].diven  = (F_CLOCK != 48000000UL);\r
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].pllsel = !(USB_Options & USB_OPT_GCLK_SRC_OSC);\r
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].oscsel = !(USB_Options & USB_OPT_GCLK_CHANNEL_0);\r
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].diven  = (F_CLOCK != 48000000UL);\r

-       AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].div    = ((F_CLOCK / 2) / 48000000UL);\r
+       AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].div    = (F_CLOCK == 48000000UL) ? 0 : (uint32_t)(((F_CLOCK / 48000000UL) - 1) / 2);\r

        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].cen    = true;\r
 \r
        USB_INT_DisableAllInterrupts();\r
        AVR32_PM.GCCTRL[USB_GCLK_USBB_INDEX].cen    = true;\r
 \r
        USB_INT_DisableAllInterrupts();\r


@@ -181,6 +180,7 @@ static void USB_Init_Device(void)
        USB_INT_Enable(USB_INT_EORSTI);\r
 \r
        USB_Attach();\r
        USB_INT_Enable(USB_INT_EORSTI);\r
 \r
        USB_Attach();\r

+       USB_Device_SetDeviceAddress(0);\r

 }\r
 #endif\r
 \r
 }\r
 #endif\r
 \r

diff --git a/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.c b/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.c
index 77dbc9f..aee8940 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.c
+++ b/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.c
@@ -118,6 +118,7 @@ ISR(USB_GEN_vect)
                USB_INT_Disable(USB_INT_SUSPI);\r
                USB_INT_Enable(USB_INT_WAKEUPI);\r
 \r
                USB_INT_Disable(USB_INT_SUSPI);\r
                USB_INT_Enable(USB_INT_WAKEUPI);\r
 \r

+               USB_Device_SetDeviceAddress(0);\r

                Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,\r
                                           ENDPOINT_DIR_OUT, USB_ControlEndpointSize,\r
                                           ENDPOINT_BANK_SINGLE);\r
                Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,\r
                                           ENDPOINT_DIR_OUT, USB_ControlEndpointSize,\r
                                           ENDPOINT_BANK_SINGLE);\r

diff --git a/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.h b/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.h
index ca60e7f..6bc836b 100644 (file)
--- a/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.h
+++ b/LUFA/Drivers/USB/Core/UC3B/USBInterrupt_UC3B.h
@@ -83,11 +83,6 @@
                        ISR(USB_GEN_vect);\r
                \r
                /* Inline Functions: */\r
                        ISR(USB_GEN_vect);\r
                \r
                /* Inline Functions: */\r

-                       static inline void USB_INT_RegisterHandlers(void)\r
-                       {\r
-                               AVR32_INTC.IPR[AVR32_USBB_IRQ % 32].autovector = (uintptr_t)&USB_GEN_vect;                      \r
-                       }\r
-               \r

                        static inline void USB_INT_Enable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;\r
                        static inline void USB_INT_Enable(const uint8_t Interrupt)\r
                        {                       \r
                        static inline void USB_INT_Enable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;\r
                        static inline void USB_INT_Enable(const uint8_t Interrupt)\r
                        {                       \r