Changeset 224 for rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB

Timestamp:

Apr 30, 2016, 11:29:25 PM (8 years ago)

Author:

ertl-honda

Message:

1.7.10のファイルに更新

Location:

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB

Files:

• CDC.cpp (modified) (10 diffs)
• HID.cpp (modified) (4 diffs)
• SAMD21_USBDevice.h (added)
• USBAPI.h (modified) (8 diffs)
• USBCore.cpp (modified) (4 diffs)
• USBCore.h (modified) (12 diffs)
• USBDesc.h (modified) (3 diffs)
• USB_device.h (deleted)
• USB_host.h (modified) (3 diffs)
• samd21_device.c (deleted)
• samd21_device.h (deleted)
• samd21_host.c (modified) (17 diffs)
• samd21_host.h (modified) (2 diffs)

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/CDC.cpp

@@ -1 @@
-/* Copyright (c) 2011, Peter Barrett
-**
-** Permission to use, copy, modify, and/or distribute this software for
-** any purpose with or without fee is hereby granted, provided that the
-** above copyright notice and this permission notice appear in all copies.
-**
-** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
-** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
-** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
-** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-** SOFTWARE.
+/*
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+** Modified 04/04/2016 by Arduino.org development team
 */
 
@@ -20 +25 @@
 
 // Include Atmel headers
-#include "Arduino.h"
-#include "sam.h"
-#include "wiring_constants.h"
-#include "USBCore.h"
-#include "USB/USB_device.h"
-#include "USBDesc.h"
-#include "USBAPI.h"
-
-#include "Reset.h"
-
+#include <Arduino.h>
+#include <Reset.h> 
 
 #ifdef CDC_ENABLED
 
-#define CDC_SERIAL_BUFFER_SIZE  64
+#define CDC_SERIAL_BUFFER_SIZE  256
 
 /* For information purpose only since RTS is not always handled by the terminal application */
@@ -41 +38 @@
 #define CDC_LINESTATE_READY             (CDC_LINESTATE_RTS | CDC_LINESTATE_DTR)
 
-struct ring_buffer
-{
+struct ring_buffer {
         uint8_t buffer[CDC_SERIAL_BUFFER_SIZE];
         volatile uint32_t head;
         volatile uint32_t tail;
+        volatile bool full;
 };
-
-ring_buffer cdc_rx_buffer = { { 0 }, 0, 0};
-
-typedef struct
-{
-        uint32_t        dwDTERate;
-        uint8_t         bCharFormat;
-        uint8_t         bParityType;
-        uint8_t         bDataBits;
-        uint8_t         lineState;
+ring_buffer cdc_rx_buffer = {{0}, 0, 0, false};
+
+typedef struct {
+        uint32_t dwDTERate;
+        uint8_t bCharFormat;
+        uint8_t bParityType;
+        uint8_t bDataBits;
+        uint8_t lineState;
 } LineInfo;
 
 _Pragma("pack(1)")
-static volatile LineInfo _usbLineInfo = { 
-   115200, // dWDTERate
-    0x00,  // bCharFormat
-    0x00,  // bParityType
-    0x08,  // bDataBits
-    0x00   // lineState
+static volatile LineInfo _usbLineInfo = {
+        115200, // dWDTERate
+        0x00,   // bCharFormat
+        0x00,   // bParityType
+        0x08,   // bDataBits
+        0x00    // lineState
 };
 
-static const CDCDescriptor _cdcInterface =
-{
-#if (defined CDC_ENABLED) && defined(HID_ENABLED)
+static volatile int32_t breakValue = -1;
+
+static CDCDescriptor _cdcInterface = {
         D_IAD(0, 2, CDC_COMMUNICATION_INTERFACE_CLASS, CDC_ABSTRACT_CONTROL_MODEL, 0),
-#endif
-        //      CDC communication interface
-        D_INTERFACE(CDC_ACM_INTERFACE,1,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0),
-        D_CDCCS( CDC_HEADER, CDC_V1_10 & 0xFF, (CDC_V1_10>>8) & 0x0FF ),        // Header (1.10 bcd)
-        
-        D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),                            // SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
-        D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE,CDC_DATA_INTERFACE),        // Communication interface is master, data interface is slave 0
-        D_CDCCS(CDC_CALL_MANAGEMENT,1,1),                                                       // Device handles call management (not)
-        D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM),USB_ENDPOINT_TYPE_INTERRUPT,0x10, 0x10),
-
-        //      CDC data interface
-        D_INTERFACE(CDC_DATA_INTERFACE,2,CDC_DATA_INTERFACE_CLASS,0,0),
-        D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT),USB_ENDPOINT_TYPE_BULK,EPX_SIZE,0),
-        D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,EPX_SIZE,0)
+
+        // CDC communication interface
+        D_INTERFACE(CDC_ACM_INTERFACE, 1, CDC_COMMUNICATION_INTERFACE_CLASS, CDC_ABSTRACT_CONTROL_MODEL, 0),
+        D_CDCCS(CDC_HEADER, CDC_V1_10 & 0xFF, (CDC_V1_10>>8) & 0x0FF), // Header (1.10 bcd)
+
+        D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT, 6), // SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
+        D_CDCCS(CDC_UNION, CDC_ACM_INTERFACE, CDC_DATA_INTERFACE), // Communication interface is master, data interface is slave 0
+        D_CDCCS(CDC_CALL_MANAGEMENT, 1, 1), // Device handles call management (not)
+        D_ENDPOINT(USB_ENDPOINT_IN(CDC_ENDPOINT_ACM), USB_ENDPOINT_TYPE_INTERRUPT, 0x10, 0x10),
+
+        // CDC data interface
+        D_INTERFACE(CDC_DATA_INTERFACE, 2, CDC_DATA_INTERFACE_CLASS, 0, 0),
+        D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT), USB_ENDPOINT_TYPE_BULK, EPX_SIZE, 0),
+        D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ), USB_ENDPOINT_TYPE_BULK, EPX_SIZE, 0)
 };
 _Pragma("pack()")
 
-const void* WEAK CDC_GetInterface(void)
-{
-        return  &_cdcInterface;
-}
-
-uint32_t WEAK CDC_GetInterfaceLength(void)
-{
-    return sizeof( _cdcInterface );
-}
-
-bool WEAK CDC_Setup(Setup& setup)
-{
-        uint8_t r = setup.bRequest;
-        uint8_t requestType = setup.bmRequestType;
+const void* _CDC_GetInterface(void)
+{
+        return &_cdcInterface;
+}
+
+uint32_t _CDC_GetInterfaceLength(void)
+{
+        return sizeof(_cdcInterface);
+}
+
+int CDC_GetInterface(uint8_t* interfaceNum)
+{
+        interfaceNum[0] += 2;   // uses 2
+        return USBD_SendControl(&_cdcInterface,sizeof(_cdcInterface));
+}
+
+bool CDC_Setup(Setup& pSetup)
+{
+        uint8_t requestType = pSetup.bmRequestType;
+        uint8_t r = pSetup.bRequest;
 
         if (REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType)
@@ -108 +109 @@
                 if (CDC_GET_LINE_CODING == r)
                 {
-                        USBD_SendControl(0,(void*)&_usbLineInfo,7);
+                        USBD_SendControl((void*)&_usbLineInfo, 7);
                         return true;
                 }
@@ -117 +118 @@
                 if (CDC_SET_LINE_CODING == r)
                 {
-                        while( UDD_FifoByteCount(EP0) <15);
-                        //USBD_RecvControl((void*)&_usbLineInfo,7);
-                        uint8_t* line = (uint8_t*)&_usbLineInfo;
-                        for(uint8_t i = 0; i<7; i++)
-                                line[i] = setup.data[i];
-                        return false;
+                        USBD_RecvControl((void*)&_usbLineInfo, 7);
                 }
 
                 if (CDC_SET_CONTROL_LINE_STATE == r)
                 {
-                        _usbLineInfo.lineState = setup.wValueL;
+                        _usbLineInfo.lineState = pSetup.wValueL;
+                }
+
+                if (r == CDC_SET_LINE_CODING || r == CDC_SET_CONTROL_LINE_STATE)
+                {
                         // auto-reset into the bootloader is triggered when the port, already
-                        // open at 1200 bps, is closed.
-                        if (1200 == _usbLineInfo.dwDTERate)
+                        // open at 1200 bps, is closed. We check DTR state to determine if host 
+                        // port is open (bit 0 of lineState).
+                        if (_usbLineInfo.dwDTERate == 1200 && (_usbLineInfo.lineState & 0x01) == 0)
                         {
-                                // We check DTR state to determine if host port is open (bit 0 of lineState).
-                                if ((_usbLineInfo.lineState & 0x01) == 0)
-                                        initiateReset(250);
-                                else
-                                        cancelReset();
+                                initiateReset(250);
+                        }
+                        else
+                        {
+                                cancelReset();
                         }
                         return false;
                 }
+
+                if (r == CDC_SEND_BREAK)
+                {
+                        breakValue = ((uint16_t)pSetup.wValueH << 8) | pSetup.wValueL;
+                        return false;
+                }
         }
         return false;
@@ -159 +166 @@
 void Serial_::accept(void)
 {
+        uint8_t buffer[CDC_SERIAL_BUFFER_SIZE];
+        uint32_t len = USBD_Recv(CDC_ENDPOINT_OUT, &buffer, CDC_SERIAL_BUFFER_SIZE);
+
+        uint8_t enableInterrupts = ((__get_PRIMASK() & 0x1) == 0);
+        __disable_irq();
+
+        ring_buffer *ringBuffer = &cdc_rx_buffer;
+        uint32_t i = ringBuffer->head;
+
+        uint32_t k = 0;
+        while (len > 0 && !ringBuffer->full) {
+                len--;
+                ringBuffer->buffer[i++] = buffer[k++];
+                i %= CDC_SERIAL_BUFFER_SIZE;
+                if (i == ringBuffer->tail)
+                        ringBuffer->full = true;
+        }
+        ringBuffer->head = i;
+        if (enableInterrupts) {
+                __enable_irq();
+        }
+}
+
+int Serial_::available(void)
+{
         ring_buffer *buffer = &cdc_rx_buffer;
-        uint32_t i = (uint32_t)(buffer->head+1) % CDC_SERIAL_BUFFER_SIZE;
-
-        // if we should be storing the received character into the location
-        // just before the tail (meaning that the head would advance to the
-        // current location of the tail), we're about to overflow the buffer
-        // and so we don't write the character or advance the head.
-        while (i != buffer->tail) {
-                uint32_t c;
-                if (!USBD_Available(CDC_ENDPOINT_OUT)) {
-            UDD_ReleaseRX(CDC_ENDPOINT_OUT);
-                        break;
-                }
-                c = USBD_Recv(CDC_ENDPOINT_OUT);
-                buffer->buffer[buffer->head] = c;
-                buffer->head = i;
-
-                i = (i + 1) % CDC_SERIAL_BUFFER_SIZE;
-        }
-}
-
-int Serial_::available(void)
+        if (buffer->full) {
+                return CDC_SERIAL_BUFFER_SIZE;
+        }
+        if (buffer->head == buffer->tail) {
+                USB->DEVICE.DeviceEndpoint[CDC_ENDPOINT_OUT].EPINTENSET.reg = USB_DEVICE_EPINTENCLR_TRCPT(1);
+        }
+        return (uint32_t)(CDC_SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % CDC_SERIAL_BUFFER_SIZE;
+}
+
+int Serial_::peek(void)
 {
         ring_buffer *buffer = &cdc_rx_buffer;
-        return (uint32_t)(CDC_SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % CDC_SERIAL_BUFFER_SIZE;
-}
-
-int Serial_::peek(void)
+        if (buffer->head == buffer->tail && !buffer->full) {
+                return -1;
+        } else {
+                return buffer->buffer[buffer->tail];
+        }
+}
+
+
+// if the ringBuffer is empty: try to fill it
+// if it's still empty: return -1
+// else return the last char
+// so the buffer is filled only when needed
+int Serial_::read(void)
 {
         ring_buffer *buffer = &cdc_rx_buffer;
 
-        if (buffer->head == buffer->tail)
-        {
-                return -1;
-        }
-        else
-        {
-                return buffer->buffer[buffer->tail];
-        }
-}
-
-int Serial_::read(void)
-{
-        ring_buffer *buffer = &cdc_rx_buffer;
-
         // if the head isn't ahead of the tail, we don't have any characters
-        if (buffer->head == buffer->tail)
+        if (buffer->head == buffer->tail && !buffer->full)
+        {
+                if (USBD_Available(CDC_ENDPOINT_OUT))
+                        accept();
+        }
+        if (buffer->head == buffer->tail && !buffer->full)
         {
                 return -1;
@@ -213 +234 @@
                 unsigned char c = buffer->buffer[buffer->tail];
                 buffer->tail = (uint32_t)(buffer->tail + 1) % CDC_SERIAL_BUFFER_SIZE;
-                if (USBD_Available(CDC_ENDPOINT_OUT))
-                        accept();
+                buffer->full = false;
                 return c;
         }
@@ -231 +251 @@
          bytes sent before the user opens the connection or after
          the connection is closed are lost - just like with a UART. */
-
+        if (_usbLineInfo.lineState > 0)  // Problem with Windows(R)
         {
                 uint32_t r = USBD_Send(CDC_ENDPOINT_IN, buffer, size);
 
-                if (r > 0)
-                {
+                if (r == 0) {
                         return r;
-                } else
-                {
+                } else {
                         setWriteError();
                         return 0;
                 }
-        }
+         }
         setWriteError();
         return 0;
@@ -259 +277 @@
 // We add a short delay before returning to fix a bug observed by Federico
 // where the port is configured (lineState != 0) but not quite opened.
-
 Serial_::operator bool()
 {
@@ -277 +294 @@
 }
 
-Serial_ SerialUSB;
+int32_t Serial_::readBreak() {
+        uint8_t enableInterrupts = ((__get_PRIMASK() & 0x1) == 0);
+
+        // disable interrupts,
+        // to avoid clearing a breakValue that might occur 
+        // while processing the current break value
+        __disable_irq();
+
+        int32_t ret = breakValue;
+
+        breakValue = -1;
+
+        if (enableInterrupts) {
+                // re-enable the interrupts
+                __enable_irq();
+        }
+
+        return ret;
+}
+
+unsigned long Serial_::baud() {
+        return _usbLineInfo.dwDTERate;
+}
+
+uint8_t Serial_::stopbits() {
+        return _usbLineInfo.bCharFormat;
+}
+
+uint8_t Serial_::paritytype() {
+        return _usbLineInfo.bParityType;
+}
+
+uint8_t Serial_::numbits() {
+        return _usbLineInfo.bDataBits;
+}
+
+bool Serial_::dtr() {
+        return _usbLineInfo.lineState & 0x1;
+}
+
+bool Serial_::rts() {
+        return _usbLineInfo.lineState & 0x2;
+}
+
+Serial_ SerialUSB(USBDevice);
 
 #endif

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/HID.cpp

@@ -21 +21 @@
 #include "USBDesc.h"
 #include "sam.h"
-#include "USB/USB_device.h"
 
 
@@ -45 +44 @@
 //      HID report descriptor
 _Pragma("pack(1)")
-extern const uint8_t _hidReportDescriptor[] = {
+extern const uint32_t _hidReportDescriptor[] = {
         //      Mouse
     0x05, 0x01,                    //   USAGE_PAGE (Generic Desktop)    // 54
@@ -162 +161 @@
 uint32_t WEAK HID_GetDescriptor(void)
 {
-        return USBD_SendControl(0,_hidReportDescriptor,sizeof(_hidReportDescriptor));
+        return USBD_SendControl(_hidReportDescriptor,sizeof(_hidReportDescriptor));
 }
 
@@ -197 +196 @@
                 if (HID_GET_IDLE == r)
                 {
-                        UDD_Send(0, &_hid_idle, 1);
-                        UDD_ClearIN();
+                        USBD_Send(0, &_hid_idle, 1);
+                        USB->DEVICE.DeviceEndpoint[EP0].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK1RDY;
                         return true;
                 }

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBAPI.h

@@ -1 +1 @@
 /*
-  Copyright (c) 2012 Arduino.  All right reserved.
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
 
   This library is free software; you can redistribute it and/or
@@ -16 +16 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
-
-#ifndef __USBAPI__
-#define __USBAPI__
-
-
-/* Define attribute */
-#if defined   ( __CC_ARM   ) /* Keil uVision 4 */
-    #define WEAK (__attribute__ ((weak)))
-#elif defined ( __ICCARM__ ) /* IAR Ewarm 5.41+ */
-    #define WEAK __weak
-#elif defined (  __GNUC__  ) /* GCC CS */
-    #define WEAK __attribute__ ((weak))
-#endif
-
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
+
+#pragma once
+
+#define WEAK __attribute__ ((weak))
+
+#define HSTPIPCFG_PTYPE_BLK 1
+#define HSTPIPCFG_PTOKEN_IN 2
+#define HSTPIPCFG_PTOKEN_OUT 3
+#define HSTPIPCFG_PBK_1_BANK 4
+#define HSTPIPCFG_PTYPE_INTRPT 5
+
+#define EP0      0
+#define EPX_SIZE 64 // 64 for Full Speed, EPT size max is 1024
 
 #if defined __cplusplus
@@ -37 +39 @@
 
 //================================================================================
-//================================================================================
-//      USB
-
-class USBDevice_
-{
-public:
-        USBDevice_();
+// USB
+//================================================================================
+//================================================================================
+// Low level API
+typedef struct {
+        union {
+                uint8_t bmRequestType;
+                struct {
+                        uint8_t direction : 5;
+                        uint8_t type : 2;
+                        uint8_t transferDirection : 1;
+                };
+        };
+        uint8_t bRequest;
+        uint8_t wValueL;
+        uint8_t wValueH;
+        uint16_t wIndex;
+        uint16_t wLength;
+} Setup;
+
+
+class USBDevice_ {
+public:
+        USBDevice_() {};
+
+        // USB Device API
+        void init();
+        bool attach();  // Serial port goes down too...
+        bool detach();
+
         bool configured();
 
-        bool attach();
-        bool detach();  // Serial port goes down too...
-        void poll();
-        void init();
-};
+private:
+        bool initialized;
+};
+
 extern USBDevice_ USBDevice;
 
 //================================================================================
-//================================================================================
 //      Serial over CDC (Serial1 is the physical port)
 
 class Serial_ : public Stream
 {
-private:
-        RingBuffer *_cdc_rx_buffer;
-public:
+public:
+        Serial_(USBDevice_ &_usb) : usb(_usb) { }
         void begin(uint32_t baud_count);
         void begin(unsigned long, uint8_t);
@@ -75 +97 @@
         using Print::write; // pull in write(str) from Print
         operator bool();
+
+        // This method allows processing "SEND_BREAK" requests sent by
+        // the USB host. Those requests indicate that the host wants to
+        // send a BREAK signal and are accompanied by a single uint16_t
+        // value, specifying the duration of the break. The value 0
+        // means to end any current break, while the value 0xffff means
+        // to start an indefinite break.
+        // readBreak() will return the value of the most recent break
+        // request, but will return it at most once, returning -1 when
+        // readBreak() is called again (until another break request is
+        // received, which is again returned once).
+        // This also mean that if two break requests are received
+        // without readBreak() being called in between, the value of the
+        // first request is lost.
+        // Note that the value returned is a long, so it can return
+        // 0-0xffff as well as -1.
+        int32_t readBreak();
+
+        // These return the settings specified by the USB host for the
+        // serial port. These aren't really used, but are offered here
+        // in case a sketch wants to act on these settings.
+        uint32_t baud();
+        uint8_t stopbits();
+        uint8_t paritytype();
+        uint8_t numbits();
+        bool dtr();
+        bool rts();
+        enum {
+                ONE_STOP_BIT = 0,
+                ONE_AND_HALF_STOP_BIT = 1,
+                TWO_STOP_BITS = 2,
+        };
+        enum {
+                NO_PARITY = 0,
+                ODD_PARITY = 1,
+                EVEN_PARITY = 2,
+                MARK_PARITY = 3,
+                SPACE_PARITY = 4,
+        };
+
+private:
+        USBDevice_ &usb;
+        RingBuffer *_cdc_rx_buffer;
 };
 extern Serial_ SerialUSB;
@@ -171 +236 @@
 //================================================================================
 //================================================================================
-//      Low level API
-
-typedef struct
-{
-        uint8_t bmRequestType;
-        uint8_t bRequest;
-        uint8_t wValueL;
-        uint8_t wValueH;
-        uint16_t wIndex;
-        uint16_t wLength;
-        uint8_t data[8];
-} Setup;
-
-//================================================================================
-//================================================================================
 //      HID 'Driver'
 
@@ -202 +252 @@
 uint32_t                MSC_GetInterface(uint8_t* interfaceNum);
 uint32_t                MSC_GetDescriptor(uint32_t i);
-bool    MSC_Setup(Setup& setup);
+bool    MSC_Setup(Setup& pSetup);
 bool    MSC_Data(uint8_t rx,uint8_t tx);
 
@@ -209 +259 @@
 //      CDC 'Driver'
 
-const void* CDC_GetInterface(/*uint8_t* interfaceNum*/);
-uint32_t WEAK CDC_GetInterfaceLength(void);
+int CDC_GetInterface(uint8_t* interfaceNum);
+const void* _CDC_GetInterface(void);
+uint32_t _CDC_GetInterfaceLength(void);
 uint32_t                CDC_GetOtherInterface(uint8_t* interfaceNum);
 uint32_t                CDC_GetDescriptor(uint32_t i);
-bool    CDC_Setup(Setup& setup);
-
-//================================================================================
-//================================================================================
-
-uint32_t USBD_SendControl(uint8_t flags, const void* d, uint32_t len);
+bool    CDC_Setup(Setup& pSetup);
+
+
+//================================================================================
+//================================================================================
+
+uint32_t USBD_SendControl(const void* _data, uint32_t len);
 uint32_t USBD_RecvControl(void* d, uint32_t len);
+void USBD_Calibrate();
 uint32_t USBD_SendInterfaces(void);
 bool USBD_ClassInterfaceRequest(Setup& setup);
@@ -228 +281 @@
 uint32_t USBD_Recv(uint32_t ep, void* data, uint32_t len);              // non-blocking
 uint32_t USBD_Recv(uint32_t ep);                                                        // non-blocking
+uint8_t USBD_armRecv(uint32_t ep);
 void USBD_Flush(uint32_t ep);
 uint32_t USBD_Connected(void);
 
 #endif  // __cplusplus
-#endif  // __USBAPI__

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBCore.cpp

@@ -1 @@
-// Copyright (c) 2010, Peter Barrett
 /*
-** Permission to use, copy, modify, and/or distribute this software for
-** any purpose with or without fee is hereby granted, provided that the
-** above copyright notice and this permission notice appear in all copies.
-**
-** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
-** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
-** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
-** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-** SOFTWARE.
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
+
+#include <Arduino.h>
+
+#include "SAMD21_USBDevice.h"
+#include "USB_host.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
-//#include "../Arduino.h"
-
-#include "sam.h"
-#include "wiring_constants.h"
-#include "USBCore.h"
-#include "USB/USB_device.h"   // needed for USB PID define
-#include "USBDesc.h"
-#include "USBAPI.h"
-
-#define TRACE_CORE(x)
-
-//==================================================================
-
-
-
-/*
-#if (defined CDC_ENABLED) && defined(HID_ENABLED)
-//#define USB_PID_ZERO       0x004B  // CDC and HID
-#define USB_PID_ZERO       0x804d  // CDC only
-#else
-#if (defined CDC_ENABLED)
-#define USB_PID_ZERO       0x804d  // CDC only  usbserial.name
-#else
-#define USB_PID_ZERO       0x804d  // HID only
-#endif
-#endif
-*/
-
-#define USB_PID_ZERO_PRO        0x804d
-
-// USB Device
-//#define USB_VID                       0x2a03 // arduino srl vid
-//#undef USB_PID
-//#define USB_PID            USB_PID_ZERO
-
-//==================================================================
+#include <limits.h>
+
+USBDevice_SAMD21G18x usbd;
 
 static char isRemoteWakeUpEnabled = 0;
 static char isEndpointHalt = 0;
+
+extern void (*gpf_isr)(void);
 
 
@@ -64 +43 @@
 };
 
+#define USB_PID_ZERO_PRO        0x804d
+#define USB_PRODUCT "Arduino M0 Pro"
 #ifndef USB_PRODUCT
 // Use a hardcoded product name if none is provided
@@ -88 +69 @@
 
 
-
-//      DEVICE DESCRIPTOR
 #if (defined CDC_ENABLED) && defined(HID_ENABLED)
 const DeviceDescriptor USB_DeviceDescriptor =
@@ -101 +80 @@
 #endif
 
+
 //==================================================================
 
 volatile uint32_t _usbConfiguration = 0;
-volatile uint32_t _usbInitialized = 0;
 volatile uint32_t _usbSetInterface = 0;
 
+static __attribute__((__aligned__(4))) //__attribute__((__section__(".bss_hram0")))
+uint8_t udd_ep_out_cache_buffer[7][64];
+
+static __attribute__((__aligned__(4))) //__attribute__((__section__(".bss_hram0")))
+uint8_t udd_ep_in_cache_buffer[7][64];
+
 //==================================================================
 
-
-//      Number of bytes, assumes a rx endpoint
-uint32_t USBD_Available(uint32_t ep)
-{
-        return UDD_FifoByteCount(ep);
-}
-
-//      Non Blocking receive
-//      Return number of bytes read
-uint32_t USBD_Recv(uint32_t ep, void* d, uint32_t len)
-{
-        if (!_usbConfiguration || len < 0)
+bool _dry_run = false;
+bool _pack_message = false;
+uint16_t _pack_size = 0;
+uint8_t _pack_buffer[256];
+
+
+void packMessages(bool val)
+{
+        if (val) {
+                _pack_message = true;
+                _pack_size = 0;
+        } else {
+                _pack_message = false;
+                USBD_SendControl(_pack_buffer, _pack_size);
+        }
+}
+
+// Blocking Send of data to an endpoint
+uint32_t USBD_Send(uint32_t ep, const void *data, uint32_t len)
+{
+        uint32_t length = 0;
+
+        if (!_usbConfiguration)
                 return -1;
-
-        uint32_t n = UDD_FifoByteCount(ep);
-        len = min(n,len);
-        n = len;
-        uint8_t* dst = (uint8_t*)d;
-        while (n--)
-                *dst++ = UDD_Recv8(ep);
-        
-        
-        
-        
-        if (len && !UDD_FifoByteCount(ep)) // release empty buffer
-                UDD_ReleaseRX(ep);
-                
-  //----- Tx & Rx led blinking during transmission ----- begin ----     
-        PORT->Group[1].OUTTGL.reg =0x00000008 ;  //RxLED
-        for(int i=0; i < 100000; i++)
-        {
-                asm("NOP");
-        }
-        PORT->Group[1].OUTTGL.reg =0x00000008 ; 
-  //----- Tx & Rx led blinking during transmission ----- end ----
+        if (len > 16384)
+                return -1;
+
+        PORT->Group[0].OUTCLR.reg =0x08000000 ; //TxLED on
+        // Flash area
+        while (len != 0)
+        {
+                if (len >= 64) {
+                        length = 64;
+                } else {
+                        length = len;
+                }
+
+                /* memcopy could be safer in multi threaded environment */
+                memcpy(&udd_ep_in_cache_buffer[ep], data, length);
+
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+
+                usbd.epBank1SetByteCount(ep, length);
+
+                // Clear the transfer complete flag
+                usbd.epBank1AckTransferComplete(ep);
+
+                // RAM buffer is full, we can send data (IN)
+                usbd.epBank1SetReady(ep);
+
+                // Wait for transfer to complete
+                while (!usbd.epBank1IsTransferComplete(ep)) {
+                        ;  // need fire exit.
+                }
+                len -= length;
+                data = (char *)data + length;
+        }
         return len;
 }
 
-//      Recv 1 byte if ready
-uint32_t USBD_Recv(uint32_t ep)
-{
-        uint8_t c;
-        if (USBD_Recv(ep, &c, 1) != 1)
-                return -1;
-        else
-                return c;
-}
-
-//      Blocking Send of data to an endpoint
-uint32_t USBD_Send(uint32_t ep, const void* d, uint32_t len)
-{
-        int r = len;
-        const uint8_t* data = (const uint8_t*)d;
-
-    if (!_usbConfiguration)
-    {
-        TRACE_CORE(printf("pb conf\n\r");)
-                return -1;
-    }
-        UDD_Send(ep, data, len);
-
-        /* Clear the transfer complete flag  */
-        udd_clear_transf_cplt(ep);
-        /* Set the bank as ready */
-        udd_bk_rdy(ep);
-
-        /* Wait for transfer to complete */
-        while (! udd_is_transf_cplt(ep));  // need fire exit.
-        
-  //----- Tx & Rx led blinking during transmission ----- begin ----
-        PORT->Group[0].OUTTGL.reg =0x08000000 ; //TxLED
-        for(int i=0; i < 100000; i++)
-        {
-                asm("NOP");
-        }
-        PORT->Group[0].OUTTGL.reg =0x08000000 ;
-        /*for(int i=0; i < 100000; i++)
-        {
-                asm("NOP");
-        }*/
-  //----- Tx & Rx led blinking during transmission ----- end ----       
-        return r;
-}
-
-uint32_t USBD_SendControl(uint8_t flags, const void* d, uint32_t len)
-{
-        const uint8_t* data = (const uint8_t*)d;
+uint32_t USBD_armSend(uint32_t ep, const void* data, uint32_t len)
+{
+        memcpy(&udd_ep_in_cache_buffer[ep], data, len);
+
+        // Get endpoint configuration from setting register
+        usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+        usbd.epBank1SetMultiPacketSize(ep, 0);
+        usbd.epBank1SetByteCount(ep, len);
+
+        return len;
+}
+
+uint32_t USBD_SendControl(const void* _data, uint32_t len)
+{
+        const uint8_t *data = reinterpret_cast<const uint8_t *>(_data);
         uint32_t length = len;
         uint32_t sent = 0;
         uint32_t pos = 0;
 
-        TRACE_CORE(printf("=> USBD_SendControl TOTAL len=%lu\r\n", len);)
-
-                while (len > 0)
-                {
-                        sent = UDD_Send(EP0, data + pos, len);
-                        TRACE_CORE(printf("=> USBD_SendControl sent=%lu\r\n", sent);)
-                        pos += sent;
-                        len -= sent;
-                }
+        if (_dry_run == true)
+                return length;
+
+        if (_pack_message == true) {
+                memcpy(&_pack_buffer[_pack_size], data, len);
+                _pack_size += len;
+                return length;
+        }
+
+        while (len > 0)
+        {
+                sent = USBD_armSend(EP0, data + pos, len);
+                pos += sent;
+                len -= sent;
+        }
 
         return length;
 }
 
-// Send a USB descriptor string. The string is stored as a
-// plain ASCII string but is sent out as UTF-16 with the
-// correct 2-byte prefix
-static bool USB_SendStringDescriptor(const uint8_t *string, int wLength)
-{
-        uint16_t buff[64];
+bool USBD_SendStringDescriptor(const uint8_t *string, uint8_t maxlen)
+{
+        if (maxlen < 2)
+                return false;
+
+        uint16_t buff[maxlen/2];
         int l = 1;
 
-        wLength -= 2;
-        while (*string && wLength>0)
+        maxlen -= 2;
+        while (*string && maxlen>0)
         {
                 buff[l++] = (uint8_t)(*string++);
-                wLength -= 2;
+                maxlen -= 2;
         }
         buff[0] = (3<<8) | (l*2);
 
-        return USBD_SendControl(0, (uint8_t*)buff, l*2);
-}
-
-uint32_t USBD_RecvControl(void* d, uint32_t len)
-{
-        udd_ack_out_received(0);
-
-        return len;
-}
-
-//      Handle CLASS_INTERFACE requests
-bool USBD_ClassInterfaceRequest(Setup& setup)
-{
-        uint8_t i = setup.wIndex;
-
-        TRACE_CORE(printf("=> USBD_ClassInterfaceRequest\r\n");)
-
-#ifdef CDC_ENABLED
-        if (CDC_ACM_INTERFACE == i)
-        {
-                if( CDC_Setup(setup) == false )
-                {
-                        send_zlp();
-                }
+        return USBD_SendControl((uint8_t*)buff, l*2);
+}
+
+uint8_t USBD_SendInterfaces(uint32_t* total)
+{
+        uint8_t interfaces = 0;
+
+#if defined(CDC_ENABLED)
+        total[0] += CDC_GetInterface(&interfaces);
+#endif
+
+        return interfaces;
+}
+
+// Construct a dynamic configuration descriptor
+// This really needs dynamic endpoint allocation etc
+uint32_t USBD_SendConfiguration(uint32_t maxlen)
+{
+        uint32_t total = 0;
+        // Count and measure interfaces
+        _dry_run = true;
+        uint8_t interfaces = USBD_SendInterfaces(&total);
+
+        _Pragma("pack(1)")
+        ConfigDescriptor config = D_CONFIG((uint16_t)(total + sizeof(ConfigDescriptor)), interfaces);
+        _Pragma("pack()")
+
+        //      Now send them
+        _dry_run = false;
+
+        if (maxlen == sizeof(ConfigDescriptor)) {
+                USBD_SendControl(&config, sizeof(ConfigDescriptor));
                 return true;
         }
-#endif
-
-#ifdef HID_ENABLED
-        if (HID_INTERFACE == i)
-        {
-                if( HID_Setup(setup) == true )
-                {
-                        send_zlp();
-                }
-                return true;
-        }
-#endif
-
-        return false;
-}
-
-//      Construct a dynamic configuration descriptor
-//      This really needs dynamic endpoint allocation etc
-//      TODO
-static bool USBD_SendConfiguration(uint32_t maxlen)
-{
-        uint8_t cache_buffer[128];
-        uint8_t i;
-
-        const uint8_t* interfaces;
-        uint32_t interfaces_length = 0;
-        uint8_t num_interfaces[1];
-        
-        num_interfaces[0] = 0;
-
-#if (defined CDC_ENABLED) && defined(HID_ENABLED)
-    num_interfaces[0] += 3;
-    interfaces = (const uint8_t*) CDC_GetInterface();
-    interfaces_length = CDC_GetInterfaceLength() + HID_GetInterfaceLength();
-    if( maxlen > CDC_GetInterfaceLength() + HID_GetInterfaceLength() + sizeof(ConfigDescriptor) )
-    {
-            maxlen = CDC_GetInterfaceLength() + HID_GetInterfaceLength() + sizeof(ConfigDescriptor);
-    }
-
-#else
-#ifdef CDC_ENABLED
-    num_interfaces[0] += 2;
-        interfaces = (const uint8_t*) CDC_GetInterface();
-        interfaces_length += CDC_GetInterfaceLength();
-        if( maxlen > CDC_GetInterfaceLength()+ sizeof(ConfigDescriptor) )
-        {
-                maxlen = CDC_GetInterfaceLength()+ sizeof(ConfigDescriptor);
-        }
-#endif
-
-#ifdef HID_ENABLED
-    num_interfaces[0] += 1;
-        interfaces = (const uint8_t*) HID_GetInterface();
-        interfaces_length += HID_GetInterfaceLength();
-        if( maxlen > HID_GetInterfaceLength()+ sizeof(ConfigDescriptor) )
-        {
-                maxlen = HID_GetInterfaceLength()+ sizeof(ConfigDescriptor);
-        }
-#endif
-#endif
-
-_Pragma("pack(1)")
-        ConfigDescriptor config = D_CONFIG((uint16_t)(interfaces_length + sizeof(ConfigDescriptor)),num_interfaces[0]);
-_Pragma("pack()")
-
-        memcpy( cache_buffer, &config, sizeof(ConfigDescriptor) );
-
-#if (defined CDC_ENABLED) && defined(HID_ENABLED)
-        for ( i=0; i<CDC_GetInterfaceLength(); i++)
-        {
-                cache_buffer[i+sizeof(ConfigDescriptor)] = interfaces[i];
-        }
-        interfaces = (const uint8_t*) HID_GetInterface();
-        for ( i=0; i<HID_GetInterfaceLength(); i++)
-        {
-                cache_buffer[i+sizeof(ConfigDescriptor)+CDC_GetInterfaceLength()] = interfaces[i];
-        }
-#else
-#ifdef HID_ENABLED
-        for ( i=0; i<interfaces_length; i++)
-        {
-                cache_buffer[i+sizeof(ConfigDescriptor)] = interfaces[i];
-        }
-#endif
-
-#ifdef CDC_ENABLED
-        for ( i=0; i<interfaces_length; i++)
-        {
-                cache_buffer[i+sizeof(ConfigDescriptor)] = interfaces[i];
-        }
-#endif  
-#endif
-
-        if (maxlen > sizeof(cache_buffer))
-        {
-                 maxlen = sizeof(cache_buffer);
-        }
-        USBD_SendControl(0,cache_buffer, maxlen );
+
+        total = 0;
+
+        packMessages(true);
+        USBD_SendControl(&config, sizeof(ConfigDescriptor));
+        USBD_SendInterfaces(&total);
+        packMessages(false);
+
         return true;
 }
 
-static bool USBD_SendDescriptor(Setup* pSetup)
-{
-        uint8_t t = pSetup->wValueH;
+bool USBD_SendDescriptor(Setup &setup)
+{
+        uint8_t t = setup.wValueH;
         uint8_t desc_length = 0;
-        const uint8_t* desc_addr = 0;
-
-        if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t)
-        {
-                TRACE_CORE(printf("=> USBD_SendDescriptor : USB_CONFIGURATION_DESCRIPTOR_TYPE length=%d\r\n", setup.wLength);)
-                return USBD_SendConfiguration(pSetup->wLength);
-        }
-
-#ifdef HID_ENABLED
-        if (HID_REPORT_DESCRIPTOR_TYPE == t)
-        {
-                TRACE_CORE(puts("=> USBD_SendDescriptor : HID_REPORT_DESCRIPTOR_TYPE\r\n");)
-                return HID_GetDescriptor();
-        }
-        if (HID_HID_DESCRIPTOR_TYPE == t)
-        {
-                uint8_t tab[9] = D_HIDREPORT((uint8_t)HID_SizeReportDescriptor());
-
-                TRACE_CORE(puts("=> USBD_SendDescriptor : HID_HID_DESCRIPTOR_TYPE\r\n");)
-
-                return USBD_SendControl(0, tab, sizeof(tab));
-        }
-#endif
-
-        if (USB_DEVICE_DESCRIPTOR_TYPE == t)
-        {
-                TRACE_CORE(puts("=> USBD_SendDescriptor : USB_DEVICE_DESCRIPTOR_TYPE\r\n");)
-                desc_addr = (const uint8_t*)&USB_DeviceDescriptor;
-        if( *desc_addr > pSetup->wLength ) {
-            desc_length = pSetup->wLength;
-        }
+        bool _cdcComposite;
+        int ret;
+        const uint8_t *desc_addr = 0;
+
+        if (t == USB_CONFIGURATION_DESCRIPTOR_TYPE)
+        {
+                return USBD_SendConfiguration(setup.wLength);
+        }
+
+        if (t == USB_DEVICE_DESCRIPTOR_TYPE)
+        {
+                if (setup.wLength == 8)
+                        _cdcComposite = 1;
+
+                desc_addr = _cdcComposite ?  (const uint8_t*)&USB_DeviceDescriptor : (const uint8_t*)&USB_DeviceDescriptor;
+
+                if (*desc_addr > setup.wLength) {
+                        desc_length = setup.wLength;
+                }
         }
         else if (USB_STRING_DESCRIPTOR_TYPE == t)
         {
-                TRACE_CORE(puts("=> USBD_SendDescriptor : USB_STRING_DESCRIPTOR_TYPE\r\n");)
-                if (pSetup->wValueL == 0) {
+                if (setup.wValueL == 0) {
                         desc_addr = (const uint8_t*)&STRING_LANGUAGE;
                 }
-                else if (pSetup->wValueL == IPRODUCT) {
-                        return USB_SendStringDescriptor(STRING_PRODUCT, pSetup->wLength);
-                }
-                else if (pSetup->wValueL == IMANUFACTURER) {
-                        return USB_SendStringDescriptor(STRING_MANUFACTURER, pSetup->wLength);
+                else if (setup.wValueL == IPRODUCT) {
+                        return USBD_SendStringDescriptor(STRING_PRODUCT, setup.wLength);
+                }
+                else if (setup.wValueL == IMANUFACTURER) {
+                        return USBD_SendStringDescriptor(STRING_MANUFACTURER, setup.wLength);
                 }
                 else {
                         return false;
                 }
-                if( *desc_addr > pSetup->wLength ) {
-                        desc_length = pSetup->wLength;
-                }
-        }
-    else
-    {
-        TRACE_CORE(printf("Device ERROR");)
-    }
-
-        if (desc_addr == 0)
-        {
+                if (*desc_addr > setup.wLength) {
+                        desc_length = setup.wLength;
+                }
+        }
+        else
+        {
+        }
+
+        if (desc_addr == 0) {
                 return false;
         }
 
-        if (desc_length == 0)
-        {
+        if (desc_length == 0) {
                 desc_length = *desc_addr;
         }
 
-        TRACE_CORE(printf("=> USBD_SendDescriptor : desc_addr=%p desc_length=%d\r\n", desc_addr, desc_length);)
-        USBD_SendControl(0, desc_addr, desc_length);
+        USBD_SendControl(desc_addr, desc_length);
 
         return true;
 }
 
-
-void EndpointHandler(uint8_t bEndpoint)
-{
+void initEP(uint32_t ep, uint32_t config)
+{
+        if (config == (USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0)))
+        {
+                usbd.epBank1SetSize(ep, 64);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+                usbd.epBank1SetType(ep, 4); // INTERRUPT IN
+        }
+        else if (config == (USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_OUT(0)))
+        {
+                usbd.epBank0SetSize(ep, 64);
+                usbd.epBank0SetAddress(ep, &udd_ep_out_cache_buffer[ep]);
+                usbd.epBank0SetType(ep, 3); // BULK OUT
+
+                // Release OUT EP
+                usbd.epBank0SetMultiPacketSize(ep, 64);
+                usbd.epBank0SetByteCount(ep, 0);
+        }
+        else if (config == (USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0)))
+        {
+                usbd.epBank1SetSize(ep, 64);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+
+                // NAK on endpoint IN, the bank is not yet filled in.
+                usbd.epBank1ResetReady(ep);
+
+                usbd.epBank1SetType(ep, 3); // BULK IN
+        }
+        else if (config == USB_ENDPOINT_TYPE_CONTROL)
+        {
+                // XXX: Needed?
+//              usbd.epBank0DisableAutoZLP(ep);
+//              usbd.epBank1DisableAutoZLP(ep);
+
+                // Setup Control OUT
+                usbd.epBank0SetSize(ep, 64);
+                usbd.epBank0SetAddress(ep, &udd_ep_out_cache_buffer[ep]);
+                usbd.epBank0SetType(ep, 1); // CONTROL OUT / SETUP
+
+                // Setup Control IN
+                usbd.epBank1SetSize(ep, 64);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[0]);
+                usbd.epBank1SetType(ep, 1); // CONTROL IN
+
+                // Release OUT EP
+                usbd.epBank0SetMultiPacketSize(ep, 64);
+                usbd.epBank0SetByteCount(ep, 0);
+
+                // NAK on endpoint OUT, the bank is full.
+                usbd.epBank0SetReady(ep);
+        }
+}
+
+void sendZlp(uint32_t ep)
+{
+        // Set the byte count as zero
+        usbd.epBank1SetByteCount(ep, 0);
+}
+
+void setAddress(uint32_t addr)
+{
+        usbd.epBank1SetByteCount(0, 0);
+        usbd.epBank1AckTransferComplete(0);
+
+        // RAM buffer is full, we can send data (IN)
+        usbd.epBank1SetReady(0);
+
+        // Wait for transfer to complete
+        while (!usbd.epBank1IsTransferComplete(0)) {}
+
+        // Set USB address to addr
+        USB->DEVICE.DADD.bit.DADD = addr; // Address
+        USB->DEVICE.DADD.bit.ADDEN = 1; // Enable
+}
+
+uint32_t EndPoints[] =
+{
+        USB_ENDPOINT_TYPE_CONTROL,
+
 #ifdef CDC_ENABLED
-        if( bEndpoint == CDC_ENDPOINT_OUT )
-        {
-                udd_ack_out_received(CDC_ENDPOINT_OUT);
-
-                // Handle received bytes                
+        USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0),           // CDC_ENDPOINT_ACM
+        USB_ENDPOINT_TYPE_BULK      | USB_ENDPOINT_OUT(0),               // CDC_ENDPOINT_OUT
+        USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0),                // CDC_ENDPOINT_IN
+#endif
+
+};
+
+void initEndpoints() {
+        for (uint8_t i = 1; i < sizeof(EndPoints) && EndPoints[i] != 0; i++) {
+                initEP(i, EndPoints[i]);
+        }
+}
+
+bool handleStandardSetup(Setup &setup)
+{
+        switch (setup.bRequest) {
+        case GET_STATUS:
+                if (setup.bmRequestType == 0)  // device
+                {
+                        // Send the device status
+                        // TODO: Check current configuration for power mode (if device is configured)
+                        // TODO: Check if remote wake-up is enabled
+                        uint8_t buff[] = { 0, 0 };
+                        USBD_armSend(0, buff, 2);
+                        return true;
+                }
+                // if( setup.bmRequestType == 2 ) // Endpoint:
+                else
+                {
+                        // Send the endpoint status
+                        // Check if the endpoint if currently halted
+                        uint8_t buff[] = { 0, 0 };
+                        if (isEndpointHalt == 1)
+                                buff[0] = 1;
+                        USBD_armSend(0, buff, 2);
+                        return true;
+                }
+
+        case CLEAR_FEATURE:
+                // Check which is the selected feature
+                if (setup.wValueL == 1) // DEVICEREMOTEWAKEUP
+                {
+                        // Enable remote wake-up and send a ZLP
+                        uint8_t buff[] = { 0, 0 };
+                        if (isRemoteWakeUpEnabled == 1)
+                                buff[0] = 1;
+                        USBD_armSend(0, buff, 2);
+                        return true;
+                }
+                else // if( setup.wValueL == 0) // ENDPOINTHALT
+                {
+                        isEndpointHalt = 0;
+                        sendZlp(0);
+                        return true;
+                }
+
+        case SET_FEATURE:
+                // Check which is the selected feature
+                if (setup.wValueL == 1) // DEVICEREMOTEWAKEUP
+                {
+                        // Enable remote wake-up and send a ZLP
+                        isRemoteWakeUpEnabled = 1;
+                        uint8_t buff[] = { 0 };
+                        USBD_armSend(0, buff, 1);
+                        return true;
+                }
+                if (setup.wValueL == 0) // ENDPOINTHALT
+                {
+                        // Halt endpoint
+                        isEndpointHalt = 1;
+                        sendZlp(0);
+                        return true;
+                }
+
+        case SET_ADDRESS:
+                setAddress(setup.wValueL);
+                return true;
+
+        case GET_DESCRIPTOR:
+                return USBD_SendDescriptor(setup);
+
+        case SET_DESCRIPTOR:
+                return false;
+
+        case GET_CONFIGURATION:
+                USBD_armSend(0, (void*)&_usbConfiguration, 1);
+                return true;
+
+        case SET_CONFIGURATION:
+                if (REQUEST_DEVICE == (setup.bmRequestType & REQUEST_RECIPIENT)) {
+
+                        initEndpoints();
+                        _usbConfiguration = setup.wValueL;
+
+                        #if defined(CDC_ENABLED)
+                        // Enable interrupt for CDC reception from host (OUT packet)
+                        usbd.epBank1EnableTransferComplete(CDC_ENDPOINT_ACM);
+                        usbd.epBank0EnableTransferComplete(CDC_ENDPOINT_OUT);
+                        #endif
+
+                        sendZlp(0);
+                        return true;
+                } else {
+                        return false;
+                }
+
+        case GET_INTERFACE:
+                USBD_armSend(0, (void*)&_usbSetInterface, 1);
+                return true;
+
+        case SET_INTERFACE:
+                _usbSetInterface = setup.wValueL;
+                sendZlp(0);
+                return true;
+
+        default:
+                return true;
+        }
+}
+
+bool handleClassInterfaceSetup(Setup& setup)
+{
+        uint8_t i = setup.wIndex;
+
+        #if defined(CDC_ENABLED)
+        if (CDC_ACM_INTERFACE == i)
+        {
+                if (CDC_Setup(setup) == false) {
+                        sendZlp(0);
+                }
+                return true;
+        }
+        #endif
+
+        return false;
+}
+
+void stall(uint32_t ep)
+{
+        // TODO: test
+        // TODO: use .bit. notation
+
+        // Stall endpoint
+        USB->DEVICE.DeviceEndpoint[ep].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_STALLRQ(2);
+}
+
+void handleEndpoint(uint8_t ep)
+{
+#if defined(CDC_ENABLED)
+        if (ep == CDC_ENDPOINT_OUT)
+        {
+                // The RAM Buffer is empty: we can receive data
+                //usbd.epBank0ResetReady(CDC_ENDPOINT_OUT);
+
+                // Handle received bytes
                 if (USBD_Available(CDC_ENDPOINT_OUT))
+                        SerialUSB.accept();
+        }
+        if (ep == CDC_ENDPOINT_IN)
+        {
+                // NAK on endpoint IN, the bank is not yet filled in.
+                usbd.epBank1ResetReady(CDC_ENDPOINT_IN);
+                usbd.epBank1AckTransferComplete(CDC_ENDPOINT_IN);
+        }
+        if (ep == CDC_ENDPOINT_ACM)
+        {
+                // NAK on endpoint IN, the bank is not yet filled in.
+                usbd.epBank1ResetReady(CDC_ENDPOINT_ACM);
+                usbd.epBank1AckTransferComplete(CDC_ENDPOINT_ACM);
+        }
+#endif
+
+}
+
+void ISRHandler()
+{
+
+        if (_pack_message == true) {
+                return;
+        }
+        // End-Of-Reset
+        if (usbd.isEndOfResetInterrupt())
+        {
+                // Configure EP 0
+                initEP(0, USB_ENDPOINT_TYPE_CONTROL);
+
+                // Enable Setup-Received interrupt
+                usbd.epBank0EnableSetupReceived(0);
+
+                _usbConfiguration = 0;
+
+                usbd.ackEndOfResetInterrupt();
+        }
+
+        // Start-Of-Frame
+        if (usbd.isStartOfFrameInterrupt())
+        {
+                usbd.ackStartOfFrameInterrupt();
+        }
+
+        // Endpoint 0 Received Setup interrupt
+        if (usbd.epBank0IsSetupReceived(0))
+        {
+                usbd.epBank0AckSetupReceived(0);
+
+                Setup *setup = reinterpret_cast<Setup *>(udd_ep_out_cache_buffer[0]);
+
+                /* Clear the Bank 0 ready flag on Control OUT */
+                // The RAM Buffer is empty: we can receive data
+                usbd.epBank0ResetReady(0);
+
+                bool ok;
+                if (REQUEST_STANDARD == (setup->bmRequestType & REQUEST_TYPE)) {
+                        // Standard Requests
+                        ok = handleStandardSetup(*setup);
+                } else {
+                        // Class Interface Requests
+                        ok = handleClassInterfaceSetup(*setup);
+                }
+
+                if (ok) {
+                        usbd.epBank1SetReady(0);
+                } else {
+                        stall(0);
+                }
+
+                if (usbd.epBank1IsStalled(0))
                 {
-                        SerialUSB.accept();
-                }
-        }
-        if( bEndpoint == CDC_ENDPOINT_IN )
-        {
-                udd_ack_in_received(CDC_ENDPOINT_IN);
-                /* Clear the transfer complete flag  */
-                udd_clear_transf_cplt(CDC_ENDPOINT_IN);
-                
-        }
-        if( bEndpoint == CDC_ENDPOINT_ACM )
-        {
-                udd_ack_in_received(CDC_ENDPOINT_ACM);
-                /* Clear the transfer complete flag  */
-                udd_clear_transf_cplt(CDC_ENDPOINT_ACM);
-        }
-#endif
-
-#ifdef HID_ENABLED
-        /* Nothing to do in our example */
-#endif
-}
-
-
-void USB_Handler(void)
-{
-        uint16_t flags;
-        uint8_t i;
-        uint8_t ept_int;
-
-        ept_int = udd_endpoint_interrupt();
+                        usbd.epBank1AckStalled(0);
+
+                        // Remove stall request
+                        usbd.epBank1DisableStalled(0);
+                }
         
-        /* Not endpoint interrupt */
-        if (0 == ept_int)
-        {
-                udd_clear_wakeup_interrupt();
-                udd_clear_eorsm_interrupt();
-                udd_clear_suspend_interrupt();
-
-                // End of bus reset
-                if (Is_udd_reset())
+        } // end Received Setup handler
+        PORT->Group[0].OUTSET.reg =0x08000000 ; //TxLED off
+        PORT->Group[1].OUTSET.reg =0x00000008 ; //RxLED off
+
+        uint8_t i=0;
+        uint8_t ept_int = usbd.epInterruptSummary() & 0xFE; // Remove endpoint number 0 (setup)
+        while (ept_int != 0)
+        {
+                // Check if endpoint has a pending interrupt
+                if ((ept_int & (1 << i)) != 0)
                 {
-                        TRACE_CORE(printf(">>> End of Reset\r\n");)
-                        // Reset USB address to 0
-                        udd_configure_address(0);
-
-                        // Configure EP 0
-                        UDD_InitEP(0, USB_ENDPOINT_TYPE_CONTROL);
-                        udd_enable_setup_received_interrupt(0);
-                        _usbConfiguration = 0;
-                        udd_ack_reset();
-                }
-
-                if (Is_udd_sof())
-                {
-                        udd_ack_sof();
-                }
-
-        }
-        else 
-        {
-                // Endpoint interrupt
-                flags = udd_read_endpoint_flag(0);
-
-                // endpoint received setup interrupt
-                if (flags & USB_DEVICE_EPINTFLAG_RXSTP)
-                {
-                        Setup *pSetupData;
-
-                        /* Clear the Received Setup flag */
-                        udd_read_endpoint_flag(0) = USB_DEVICE_EPINTFLAG_RXSTP;
-
-                        UDD_Recv(EP0, (uint8_t**)&pSetupData);
-
-                        /* Clear the Bank 0 ready flag on Control OUT */
-                        udd_ack_out_received(0);
-
-                        bool ok = true;
-                        if (REQUEST_STANDARD == (pSetupData->bmRequestType & REQUEST_TYPE))
+                        // Endpoint Transfer Complete (0/1) Interrupt
+                        if (usbd.epBank0IsTransferComplete(i) ||
+                            usbd.epBank1IsTransferComplete(i))
                         {
-                                unsigned char data_to_be_send[2];
-
-                                // Standard Requests
-                                uint8_t r = pSetupData->bRequest;
-                                if (GET_STATUS == r)
-                                {
-                                        if( pSetupData->bmRequestType == 0 )  // device
-                                        {
-                                                // Send the device status
-                                        TRACE_CORE(puts(">>> EP0 Int: GET_STATUS\r\n");)
-                                                // Check current configuration for power mode (if device is configured)
-                                                
-                                                // Check if remote wake-up is enabled
-                                                
-                                                data_to_be_send[0]=0;
-                                                data_to_be_send[1]=0;
-                                                UDD_Send(0, data_to_be_send, 2);
-                                        }
-                                        // if( pSetupData->bmRequestType == 2 ) // Endpoint:
-                                        else
-                                        {
-                                                // Send the endpoint status
-                                                // Check if the endpoint if currently halted
-                                                if( isEndpointHalt == 1 )
-                                                        data_to_be_send[0]=1;
-                                                else
-                                                        data_to_be_send[0]=0;
-                                                data_to_be_send[1]=0;
-                                                UDD_Send(0, data_to_be_send, 2);
-                                        }
-                                }
-                                else if (CLEAR_FEATURE == r)
-                                {
-                                   // Check which is the selected feature
-                                        if( pSetupData->wValueL == 1) // DEVICEREMOTEWAKEUP
-                                        {
-                                                // Enable remote wake-up and send a ZLP
-                                                if( isRemoteWakeUpEnabled == 1 )
-                                                        data_to_be_send[0]=1;
-                                                else
-                                                        data_to_be_send[0]=0;
-                                                data_to_be_send[1]=0;
-                                                UDD_Send(0, data_to_be_send, 2);
-                                        }
-                                        else // if( pSetupData->wValueL == 0) // ENDPOINTHALT
-                                        {
-                                                isEndpointHalt = 0;
-                                                send_zlp();
-                                        }
-                                }
-                                else if (SET_FEATURE == r)
-                                {
-                                        // Check which is the selected feature
-                                        if( pSetupData->wValueL == 1) // DEVICEREMOTEWAKEUP
-                                        {
-                                                // Enable remote wake-up and send a ZLP
-                                                isRemoteWakeUpEnabled = 1;
-                                        data_to_be_send[0] = 0;
-                                                UDD_Send(0, data_to_be_send, 1);
-                                        }
-                                        if( pSetupData->wValueL == 0) // ENDPOINTHALT
-                                        {
-                                                // Halt endpoint
-                                                isEndpointHalt = 1;
-                                                send_zlp();
-                                        }
-                                }
-                                else if (SET_ADDRESS == r)
-                                {
-                                        TRACE_CORE(puts(">>> EP0 Int: SET_ADDRESS\r\n");)
-                                        UDD_SetAddress(pSetupData->wValueL);
-                                }
-                                else if (GET_DESCRIPTOR == r)
-                                {
-                                        TRACE_CORE(puts(">>> EP0 Int: GET_DESCRIPTOR\r\n");)
-                                        ok = USBD_SendDescriptor(pSetupData);
-                                }
-                                else if (SET_DESCRIPTOR == r)
-                                {
-                                        TRACE_CORE(puts(">>> EP0 Int: SET_DESCRIPTOR\r\n");)
-                                        ok = false;
-                                }
-                                else if (GET_CONFIGURATION == r)
-                                {
-                                        TRACE_CORE(puts(">>> EP0 Int: GET_CONFIGURATION\r\n");)
-                                        UDD_Send(0, (void*)&_usbConfiguration, 1);
-                                }
-                                else if (SET_CONFIGURATION == r)
-                                {
-                                        if (REQUEST_DEVICE == (pSetupData->bmRequestType & REQUEST_RECIPIENT))
-                                        {
-                                                TRACE_CORE(printf(">>> EP0 Int: SET_CONFIGURATION REQUEST_DEVICE %d\r\n", pSetupData->wValueL);)
-#ifdef HID_ENABLED
-                                                UDD_InitEP( HID_ENDPOINT_INT, USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0));
-#endif
-
-#ifdef CDC_ENABLED
-                                                UDD_InitEP( CDC_ENDPOINT_ACM, USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0));
-                                                UDD_InitEP( CDC_ENDPOINT_OUT, USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_OUT(0));
-                                                UDD_InitEP( CDC_ENDPOINT_IN, USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0));
-#endif
-                                                _usbConfiguration = pSetupData->wValueL;
-
-#ifdef CDC_ENABLED
-                                                // Enable interrupt for CDC reception from host (OUT packet)
-                                                udd_ept_enable_it_transf_cplt_in(CDC_ENDPOINT_ACM);
-                                                udd_ept_enable_it_transf_cplt_out(CDC_ENDPOINT_OUT);
-#endif
-                                                send_zlp();
-                                        }
-                                        else
-                                        {
-                                                TRACE_CORE(puts(">>> EP0 Int: SET_CONFIGURATION failed!\r\n");)
-                                                ok = false;
-                                        }
-                                }
-                                else if (GET_INTERFACE == r)
-                                {
-                                        TRACE_CORE(puts(">>> EP0 Int: GET_INTERFACE\r\n");)
-                                        UDD_Send(0, (void*)&_usbSetInterface, 1);
-                                }
-                                else if (SET_INTERFACE == r)
-                                {
-                                        _usbSetInterface = pSetupData->wValueL;
-                                        TRACE_CORE(puts(">>> EP0 Int: SET_INTERFACE\r\n");)
-                                        send_zlp();
-                                }
+                                handleEndpoint(i);
                         }
-                        else
-                        {
-                                TRACE_CORE(puts(">>> EP0 Int: ClassInterfaceRequest\r\n");)
-                                ok =  USBD_ClassInterfaceRequest(*pSetupData);
-                        }
-
-                        if (ok)
-                        {
-                                TRACE_CORE(puts(">>> EP0 Int: Send packet\r\n");)
-                                UDD_ClearIN();
-                        }
-                        else
-                        {
-                                TRACE_CORE(puts(">>> EP0 Int: Stall\r\n");)
-                                UDD_Stall(0);
-                        }
-
-                        if( flags & USB_DEVICE_EPINTFLAG_STALL1 )
-                        {
-                                /* Clear the stall flag */
-                                udd_clear_stall_request(0);
-
-                                // Remove stall request
-                                udd_remove_stall_request(0);
-                        }
-                }  // end if USB_DEVICE_EPINTFLAG_RXSTP
-
-                i=0;
-                ept_int &= 0xFE;  // Remove endpoint number 0 (setup)
-                while (ept_int != 0)
-                {
-            // Check if endpoint has a pending interrupt
-            if ((ept_int & (1 << i)) != 0)
-                        {
-                                if( (udd_read_endpoint_flag(i) & USB_DEVICE_EPINTFLAG_TRCPT_Msk ) != 0 )
-                                
-                                {
-                                        EndpointHandler(i);
-                                }
-                ept_int &= ~(1 << i);
-                
-                if (ept_int != 0)
-                                {
-                
-                    TRACE_CORE("\n\r  - ");
-                }
-            }
-            i++;
-                        if( i> USB_EPT_NUM) break;  // exit
-        }
-        }
-}
-
+                        ept_int &= ~(1 << i);
+                }
+                i++;
+                if (i > USB_EPT_NUM)
+                        break;  // fire exit
+        }
+}
+
+// USB_Handler ISR
+extern "C" void UDD_Handler(void) {
+        ISRHandler();
+}
 
 
 void USBD_Flush(uint32_t ep)
 {
-        if (UDD_FifoByteCount(ep))
-        {
-                UDD_ReleaseTX(ep);
-        }
-}
-
-//      Counting frames
-uint32_t USBD_Connected(void)
-{
-        uint8_t f = UDD_GetFrameNumber();
-        return f != UDD_GetFrameNumber();
-}
-
-
-//=======================================================================
-//=======================================================================
-
-USBDevice_ USBDevice;
-
-USBDevice_::USBDevice_()
-{
+        if (USBD_Available(ep)) {
+                // RAM buffer is full, we can send data (IN)
+                usbd.epBank1SetReady(ep);
+
+                // Clear the transfer complete flag
+                usbd.epBank1AckTransferComplete(ep);
+        }
+}
+
+
+bool connected()
+{
+        // Count frame numbers
+        uint8_t f = USB->DEVICE.FNUM.bit.FNUM;
+        //delay(3);
+        return f != USB->DEVICE.FNUM.bit.FNUM;
+}
+
+uint8_t armRecvCtrlOUT(uint32_t ep)
+{
+        // Get endpoint configuration from setting register
+        usbd.epBank0SetAddress(ep, &udd_ep_out_cache_buffer[ep]);
+        usbd.epBank0SetMultiPacketSize(ep, 8);
+        usbd.epBank0SetByteCount(ep, 0);
+
+        usbd.epBank0ResetReady(ep);
+
+        // Wait OUT
+        while (!usbd.epBank0IsReady(ep)) {}
+        while (!usbd.epBank0IsTransferComplete(ep)) {}
+        return usbd.epBank0ByteCount(ep);
+}
+
+
+uint32_t USBD_RecvControl(void *_data, uint32_t len)
+{
+        uint8_t *data = reinterpret_cast<uint8_t *>(_data);
+
+        // The RAM Buffer is empty: we can receive data
+        usbd.epBank0ResetReady(0);
+
+        //usbd.epBank0AckSetupReceived(0);
+        uint32_t read = armRecvCtrlOUT(0);
+        if (read > len)
+                read = len;
+        //while (!usbd.epBank0AckTransferComplete(0)) {}
+        uint8_t *buffer = udd_ep_out_cache_buffer[0];
+        for (uint32_t i=0; i<len; i++) {
+                data[i] = buffer[i];
+        }
+
+        return read;
+}
+
+// Number of bytes, assumes a rx endpoint
+uint32_t USBD_Available(uint32_t ep)
+{
+        return usbd.epBank0ByteCount(ep);
+}
+
+uint8_t armRecv(uint32_t ep)
+{
+        uint16_t count = usbd.epBank0ByteCount(ep);
+        if (count >= 64) {
+                usbd.epBank0SetByteCount(ep, count - 64);
+        } else {
+                usbd.epBank0SetByteCount(ep, 0);
+        }
+        return usbd.epBank0ByteCount(ep);
+}
+
+// Non Blocking receive
+// Return number of bytes read
+uint32_t USBD_Recv(uint32_t ep, void *_data, uint32_t len)
+{
+        if (!_usbConfiguration)
+                return -1;
+
+        PORT->Group[1].OUTCLR.reg =0x00000008 ; //RxLED on
+        if (USBD_Available(ep) < len)
+                len = USBD_Available(ep);
+
+        armRecv(ep);
+
+        usbd.epBank0DisableTransferComplete(ep);
+
+        memcpy(_data, udd_ep_out_cache_buffer[ep], len);
+
+        // release empty buffer
+        if (len && !USBD_Available(ep)) {
+                // The RAM Buffer is empty: we can receive data
+                usbd.epBank0ResetReady(ep);
+
+                // Clear Transfer complete 0 flag
+                usbd.epBank0AckTransferComplete(ep);
+        }
+
+        return len;
+}
+
+// Recv 1 byte if ready
+uint32_t USBD_Recv(uint32_t ep)
+{
+        uint8_t c;
+        if (USBD_Recv(ep, &c, 1) != 1) {
+                return -1;
+        } else {
+                return c;
+        }
+}
+
+
+
+//==================================================================
+
+void USBDevice_::init()
+{
+        // Enable USB clock
+        PM->APBBMASK.reg |= PM_APBBMASK_USB;
+
+        // Set up the USB DP/DN pins
+        PORT->Group[0].PINCFG[PIN_PA24G_USB_DM].bit.PMUXEN = 1;
+        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg &= ~(0xF << (4 * (PIN_PA24G_USB_DM & 0x01u)));
+        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg |= MUX_PA24G_USB_DM << (4 * (PIN_PA24G_USB_DM & 0x01u));
+        PORT->Group[0].PINCFG[PIN_PA25G_USB_DP].bit.PMUXEN = 1;
+        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg &= ~(0xF << (4 * (PIN_PA25G_USB_DP & 0x01u)));
+        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg |= MUX_PA25G_USB_DP << (4 * (PIN_PA25G_USB_DP & 0x01u));
+
+        // Put Generic Clock Generator 0 as source for Generic Clock Multiplexer 6 (USB reference)
+        GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID(6)     | // Generic Clock Multiplexer 6
+                            GCLK_CLKCTRL_GEN_GCLK0 | // Generic Clock Generator 0 is source
+                            GCLK_CLKCTRL_CLKEN;
+        while (GCLK->STATUS.bit.SYNCBUSY)
+                ;
+
+        USB_SetHandler(&UDD_Handler);
+
+        // Reset USB Device
+        usbd.reset();
+
+        usbd.calibrate();
+        usbd.setUSBDeviceMode();
+        usbd.runInStandby();
+        usbd.setFullSpeed();
+
+        // Configure interrupts
+        NVIC_SetPriority((IRQn_Type) USB_IRQn, 0UL);
+        NVIC_EnableIRQ((IRQn_Type) USB_IRQn);
+
+        usbd.enable();
+
+        initialized = true;
 }
 
 bool USBDevice_::attach()
 {
-  if (_usbInitialized != 0UL)
-  {
-    UDD_Attach();
+        if (!initialized)
+                return false;
+
+        usbd.attach();
+        usbd.enableEndOfResetInterrupt();
+        usbd.enableStartOfFrameInterrupt();
+
         _usbConfiguration = 0;
         return true;
-  }
-  else
-  {
-    return false;
-  }
-}
+}
+
 
 bool USBDevice_::detach()
 {
-        if (_usbInitialized != 0UL)
-        {
-                UDD_Detach();
-                return true;
-        }
-        else
-        {
+        if (!initialized)
                 return false;
-        }
+        usbd.detach();
+        return true;
 }
 
 bool USBDevice_::configured()
 {
-        return _usbConfiguration;
-}
-
-void USBDevice_::poll()
-{
-}
-
-void USBDevice_::init()
-{
-        UDD_Init();
-        _usbInitialized=1UL;
-}
+        return _usbConfiguration != 0;
+}
+
+
+        
+/*
+ * USB Device instance
+ * -------------------
+ */
+
+// USBDevice class instance
+USBDevice_ USBDevice;

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBCore.h

@@ -1 @@
-// Copyright (c) 2010, Peter Barrett
 /*
-** Permission to use, copy, modify, and/or distribute this software for
-** any purpose with or without fee is hereby granted, provided that the
-** above copyright notice and this permission notice appear in all copies.
-**
-** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
-** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
-** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
-** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-** SOFTWARE.
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
+
 
 #ifndef __USBCORE_H__
@@ -30 +36 @@
 #define SET_INTERFACE                           11
 
+// bEndpointAddress in Endpoint Descriptor
+#define USB_ENDPOINT_DIRECTION_MASK            0x80
+#define USB_ENDPOINT_OUT(addr)                 ((addr) | 0x00)
+#define USB_ENDPOINT_IN(addr)                  ((addr) | 0x80)
+
+#define USB_ENDPOINTS                          7
+
+#define USB_ENDPOINT_TYPE_MASK                 0x03
+#define USB_ENDPOINT_TYPE_CONTROL              0x00
+#define USB_ENDPOINT_TYPE_ISOCHRONOUS          0x01
+#define USB_ENDPOINT_TYPE_BULK                 0x02
+#define USB_ENDPOINT_TYPE_INTERRUPT            0x03
 
 // bmRequestType
@@ -47 +65 @@
 #define REQUEST_RECIPIENT                       0x1F
 
-#define REQUEST_DEVICETOHOST_CLASS_INTERFACE  (REQUEST_DEVICETOHOST + REQUEST_CLASS + REQUEST_INTERFACE)
-#define REQUEST_HOSTTODEVICE_CLASS_INTERFACE  (REQUEST_HOSTTODEVICE + REQUEST_CLASS + REQUEST_INTERFACE)
+#define REQUEST_DEVICETOHOST_CLASS_INTERFACE    (REQUEST_DEVICETOHOST | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_HOSTTODEVICE_CLASS_INTERFACE    (REQUEST_HOSTTODEVICE | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_DEVICETOHOST_STANDARD_INTERFACE (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_INTERFACE)
 
 //      Class requests
@@ -55 +74 @@
 #define CDC_GET_LINE_CODING                     0x21
 #define CDC_SET_CONTROL_LINE_STATE      0x22
+#define CDC_SEND_BREAK                          0x23
 
 #define MSC_RESET                                       0xFF
@@ -108 +128 @@
 #define MSC_SUBCLASS_SCSI                                               0x06
 #define MSC_PROTOCOL_BULK_ONLY                                  0x50
-
-#define HID_HID_DESCRIPTOR_TYPE                                 0x21
-#define HID_REPORT_DESCRIPTOR_TYPE                              0x22
-#define HID_PHYSICAL_DESCRIPTOR_TYPE                    0x23
-
-#define TX_RX_LED_PULSE_MS 100     //----- Tx & Rx led blinking during transmission (declaration)
 
 _Pragma("pack(1)")
@@ -225 +239 @@
 typedef struct
 {
-#if (defined CDC_ENABLED) && defined(HID_ENABLED)
         //      IAD
         IADDescriptor                           iad;    // Only needed on compound device
-#endif
         //      Control
         InterfaceDescriptor                     cif;
@@ -249 +261 @@
         EndpointDescriptor                      out;
 } MSCDescriptor;
+
 
 typedef struct
@@ -273 +286 @@
 
 #define D_DEVICE(_class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs) \
-        { 18, 1, 0x110, _class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs }
+        { 18, 1, 0x200, _class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs }
 /* Table 9-8. Standard Device Descriptor
  * bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
@@ -279 +292 @@
 
 #define D_CONFIG(_totalLength,_interfaces) \
-        { 9, 2, _totalLength,_interfaces, 1, 0, USB_CONFIG_SELF_POWERED, USB_CONFIG_POWER_MA(500) }
+        { 9, 2, _totalLength,_interfaces, 1, 0, USB_CONFIG_BUS_POWERED, USB_CONFIG_POWER_MA(500) }
 /* Table 9-10. Standard Configuration Descriptor
  * bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
  * bmAttributes, bMaxPower */
- 
+
 #define D_INTERFACE(_n,_numEndpoints,_class,_subClass,_protocol) \
         { 9, 4, _n, 0, _numEndpoints, _class,_subClass, _protocol, 0 }
@@ -289 +302 @@
  * bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
  * bInterfaceSubClass, bInterfaceProtocol, iInterface */
- 
+
 #define D_ENDPOINT(_addr,_attr,_packetSize, _interval) \
         { 7, 5, _addr,_attr,_packetSize, _interval }
@@ -297 +310 @@
 #define D_IAD(_firstInterface, _count, _class, _subClass, _protocol) \
         { 8, 11, _firstInterface, _count, _class, _subClass, _protocol, 0 }
-/* iadclasscode_r10.pdf, Table 9–Z. Standard Interface Association Descriptor
+/* iadclasscode_r10.pdf, Table 9\96Z. Standard Interface Association Descriptor
  * bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass, bFunctionProtocol, iFunction */
 #define D_HIDREPORT(_descriptorLength) \
@@ -303 +316 @@
 /* HID1_11.pdf  E.8 HID Descriptor (Mouse)
  * bLength, bDescriptorType, bcdHID, bCountryCode, bNumDescriptors, bDescriptorType, wItemLength */
-
+ 
 // Functional Descriptor General Format
 #define D_CDCCS(_subtype,_d0,_d1)       { 5, 0x24, _subtype, _d0, _d1 }

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBDesc.h

@@ -1 @@
-// Copyright (c) 2010, Peter Barrett
 /*
-** Permission to use, copy, modify, and/or distribute this software for
-** any purpose with or without fee is hereby granted, provided that the
-** above copyright notice and this permission notice appear in all copies.
-**
-** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
-** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
-** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
-** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-** SOFTWARE.
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+**Modified 04/04/2016 by Arduino.org development team
 */
 
@@ -22 +27 @@
 #define HID_ENABLED
 
+
+#ifdef CDC_ENABLED
+#define CDC_INTERFACE_COUNT 2
+#define CDC_ENPOINT_COUNT 3
+#endif
+
 // CDC
 #define CDC_ACM_INTERFACE       0       // CDC ACM
 #define CDC_DATA_INTERFACE      1       // CDC Data
+#define CDC_FIRST_ENDPOINT  1
 #define CDC_ENDPOINT_ACM        1
 #define CDC_ENDPOINT_OUT        2
 #define CDC_ENDPOINT_IN         3
+
+#ifdef CDC_ENABLED
+#define CDC_RX CDC_ENDPOINT_OUT
+#define CDC_TX CDC_ENDPOINT_IN
+#endif
 
 // HID
@@ -33 +50 @@
 #define HID_ENDPOINT_INT        4  
 
+
+#define ISERIAL_MAX_LEN        20
+
 // Defined string description
 #define IMANUFACTURER   1
-#define IPRODUCT                2
+#define IPRODUCT    2
+#define ISERIAL    3
 
 #endif /* __USBDESC_H__ */

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USB_host.h

@@ -1 @@
-/* ----------------------------------------------------------------------------
- *         SAM Software Package License
- * ----------------------------------------------------------------------------
- * Copyright (c) 2011-2012, Atmel Corporation
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following condition is met:
- *
- * - Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the disclaimer below.
- *
- * Atmel's name may not be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
- * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * ----------------------------------------------------------------------------
- */
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
 
 #ifndef USB_HOST_H_INCLUDED
@@ -32 +24 @@
 
 #include <stdint.h>
-
+#include "samd21_host.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define tokSETUP                UOTGHS_HSTPIPCFG_PTOKEN_SETUP
-#define tokIN                   UOTGHS_HSTPIPCFG_PTOKEN_IN
-#define tokOUT                  UOTGHS_HSTPIPCFG_PTOKEN_OUT
-#define tokINHS                 UOTGHS_HSTPIPCFG_PTOKEN_IN
-#define tokOUTHS                UOTGHS_HSTPIPCFG_PTOKEN_OUT
+#define tokSETUP                USB_HOST_PCFG_PTOKEN_SETUP
+#define tokIN                   USB_HOST_PCFG_PTOKEN_IN
+#define tokOUT                  USB_HOST_PCFG_PTOKEN_OUT
+#define tokINHS                 USB_HOST_PCFG_PTOKEN_IN
+#define tokOUTHS                USB_HOST_PCFG_PTOKEN_OUT
 
 //! \brief Device speed
@@ -58 +50 @@
 } uhd_vbus_state_t;
 
-//extern uhd_speed_t uhd_get_speed(void);
-
-extern void UHD_SetStack(void (*pf_isr)(void));
 extern void UHD_Init(void);
-extern void UHD_BusReset(void);
+extern void UHD_Handler(void);
+extern void USB_SetHandler(void (*pf_isr)(void));
 extern uhd_vbus_state_t UHD_GetVBUSState(void);
 extern uint32_t UHD_Pipe0_Alloc(uint32_t ul_add, uint32_t ul_ep_size);
 extern uint32_t UHD_Pipe_Alloc(uint32_t ul_dev_addr, uint32_t ul_dev_ep, uint32_t ul_type, uint32_t ul_dir, uint32_t ul_maxsize, uint32_t ul_interval, uint32_t ul_nb_bank);
+extern void UHD_Pipe_CountZero(uint32_t ul_pipe);
 extern void UHD_Pipe_Free(uint32_t ul_pipe);
 extern uint32_t UHD_Pipe_Read(uint32_t ul_pipe, uint32_t ul_size, uint8_t* data);

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/samd21_host.c

@@ -1 @@
-/* ----------------------------------------------------------------------------
- *         SAM Software Package License
- * ----------------------------------------------------------------------------
- * Copyright (c) 2011-2012, Atmel Corporation
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following condition is met:
- *
- * - Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the disclaimer below.
- *
- * Atmel's name may not be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
- * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * ----------------------------------------------------------------------------
- */
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+** Modified 04/04/2016 by Arduino.org development team
+*/
+
+
 
 #include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../Arduino.h"
+#include "variant.h"
+#include "USB_host.h"
+#include "samd21_host.h"
+#include "sam.h"
+#include "wiring_digital.h"
+#include "wiring_private.h"
+
+#define HOST_DEFINED
 
 #ifdef HOST_DEFINED
@@ -35 +41 @@
 #define TRACE_UOTGHS_HOST(x)
 
-//extern void (*gpf_isr)(void);
-
 // Handle UOTGHS Host driver state
 static uhd_vbus_state_t uhd_state = UHD_STATE_NO_VBUS;
 
- __attribute__((__aligned__(4))) UsbHostDescriptor usb_pipe_table[USB_EPT_NUM];
+__attribute__((__aligned__(4))) volatile UsbHostDescriptor usb_pipe_table[USB_EPT_NUM];
+
+extern void (*gpf_isr)(void);
 
 
 // NVM Software Calibration Area Mapping
 // USB TRANSN calibration value. Should be written to the USB PADCAL register.
-#define NVM_USB_PAD_TRANSN_POS  45
-#define NVM_USB_PAD_TRANSN_SIZE 5
+#define NVM_USB_PAD_TRANSN_POS     45
+#define NVM_USB_PAD_TRANSN_SIZE    5
 // USB TRANSP calibration value. Should be written to the USB PADCAL register.
-#define NVM_USB_PAD_TRANSP_POS  50
-#define NVM_USB_PAD_TRANSP_SIZE 5
+#define NVM_USB_PAD_TRANSP_POS     50
+#define NVM_USB_PAD_TRANSP_SIZE    5
 // USB TRIM calibration value. Should be written to the USB PADCAL register.
-#define NVM_USB_PAD_TRIM_POS  55
-#define NVM_USB_PAD_TRIM_SIZE 3
+#define NVM_USB_PAD_TRIM_POS       55
+#define NVM_USB_PAD_TRIM_SIZE      3
+
+static void UHD_ISR(void);
 
 /**
@@ -60 +68 @@
 {
         uint32_t pad_transn;
-    uint32_t pad_transp;
-    uint32_t pad_trim;
+        uint32_t pad_transp;
+        uint32_t pad_trim;
+        uint32_t i;
+
+//      USB_SetHandler(&USB_Handler);
+        USB_SetHandler(&UHD_ISR);
 
         /* Enable USB clock */
         PM->APBBMASK.reg |= PM_APBBMASK_USB;
 
-        /* Set up the USB DP/DN pins */
-        PORT->Group[0].PINCFG[PIN_PA24G_USB_DM].bit.PMUXEN = 1;
-        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg &= ~(0xF << (4 * (PIN_PA24G_USB_DM & 0x01u)));
-        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg |= MUX_PA24G_USB_DM << (4 * (PIN_PA24G_USB_DM & 0x01u));
-        PORT->Group[0].PINCFG[PIN_PA25G_USB_DP].bit.PMUXEN = 1;
-        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg &= ~(0xF << (4 * (PIN_PA25G_USB_DP & 0x01u)));
-        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg |= MUX_PA25G_USB_DP << (4 * (PIN_PA25G_USB_DP & 0x01u));
+        /* Set up the USB DP/DM pins */
+        pinPeripheral( 33ul, PIO_COM );
+        pinPeripheral( 34ul, PIO_COM );
 
         /* ----------------------------------------------------------------------------------------------
-         * Put Generic Clock Generator 0 as source for Generic Clock Multiplexer 6 (USB reference)
-         */
-        GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID( 6 ) | // Generic Clock Multiplexer 6
-                                        GCLK_CLKCTRL_GEN_GCLK0 | // Generic Clock Generator 0 is source
-                                        GCLK_CLKCTRL_CLKEN ;
-
-        while ( GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY )
-        {
-        /* Wait for synchronization */
+        * Put Generic Clock Generator 0 as source for Generic Clock Multiplexer 6 (USB reference)
+        */
+        GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID(6) |        // Generic Clock Multiplexer 6
+                                                GCLK_CLKCTRL_GEN_GCLK0 |    // Generic Clock Generator 0 is source
+                                                GCLK_CLKCTRL_CLKEN;
+
+        while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY)
+        {
+                /* Wait for synchronization */
         }
 
         /* Reset */
         USB->HOST.CTRLA.bit.SWRST = 1;
-        while (USB->HOST.SYNCBUSY.bit.SWRST) {
+        while (USB->HOST.SYNCBUSY.bit.SWRST)
+        {
                 /* Sync wait */
         }
 
-        udd_enable();
+        //  uhd_enable();
+        USB->DEVICE.CTRLA.reg |= USB_CTRLA_ENABLE | USB_CTRLA_MODE;
+        uhd_force_host_mode();
+        while (USB->HOST.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE);
 
         /* Load Pad Calibration */
-        pad_transn =( *((uint32_t *)(NVMCTRL_OTP4)  // Non-Volatile Memory Controller
-        + (NVM_USB_PAD_TRANSN_POS / 32))
-        >> (NVM_USB_PAD_TRANSN_POS % 32))
-        & ((1 << NVM_USB_PAD_TRANSN_SIZE) - 1);
-
-        if (pad_transn == 0x1F) {  // maximum value (31)
+        pad_transn = (*((uint32_t *)(NVMCTRL_OTP4)       // Non-Volatile Memory Controller
+                                        + (NVM_USB_PAD_TRANSN_POS / 32))
+                                        >> (NVM_USB_PAD_TRANSN_POS % 32))
+                                & ((1 << NVM_USB_PAD_TRANSN_SIZE) - 1);
+
+        if (pad_transn == 0x1F)         // maximum value (31)
+        {
                 pad_transn = 5;
         }
@@ -106 +119 @@
         USB->HOST.PADCAL.bit.TRANSN = pad_transn;
 
-        pad_transp =( *((uint32_t *)(NVMCTRL_OTP4)
-        + (NVM_USB_PAD_TRANSP_POS / 32))
-        >> (NVM_USB_PAD_TRANSP_POS % 32))
-        & ((1 << NVM_USB_PAD_TRANSP_SIZE) - 1);
-
-        if (pad_transp == 0x1F) {  // maximum value (31)
+        pad_transp = (*((uint32_t *)(NVMCTRL_OTP4)
+                                        + (NVM_USB_PAD_TRANSP_POS / 32))
+                                        >> (NVM_USB_PAD_TRANSP_POS % 32))
+                                & ((1 << NVM_USB_PAD_TRANSP_SIZE) - 1);
+
+        if (pad_transp == 0x1F)         // maximum value (31)
+        {
                 pad_transp = 29;
         }
@@ -117 +131 @@
         USB->HOST.PADCAL.bit.TRANSP = pad_transp;
 
-        pad_trim =( *((uint32_t *)(NVMCTRL_OTP4)
-        + (NVM_USB_PAD_TRIM_POS / 32))
-        >> (NVM_USB_PAD_TRIM_POS % 32))
-        & ((1 << NVM_USB_PAD_TRIM_SIZE) - 1);
-
-        if (pad_trim == 0x7) {  // maximum value (7)
+        pad_trim = (*((uint32_t *)(NVMCTRL_OTP4)
+                                        + (NVM_USB_PAD_TRIM_POS / 32))
+                                >> (NVM_USB_PAD_TRIM_POS % 32))
+                                & ((1 << NVM_USB_PAD_TRIM_SIZE) - 1);
+
+        if (pad_trim == 0x7)         // maximum value (7)
+        {
                 pad_trim = 3;
         }
@@ -128 +143 @@
         USB->HOST.PADCAL.bit.TRIM = pad_trim;
 
+
         /* Set the configuration */
-        udd_force_host_mode();
-        udd_device_run_in_standby();
-    // Set address of USB SRAM
-        USB->HOST.DESCADD.reg = (uint32_t)(&usb_endpoint_table[0]);
-        // For USB_SPEED_FULL 
-        udd_force_full_speed();
-        for (uint32_t i = 0; i < sizeof(usb_endpoint_table); i++) {
-                (*(uint32_t *)(&usb_endpoint_table[0]+i)) = 0;
-        }
+        uhd_run_in_standby();
+        // Set address of USB SRAM
+        USB->HOST.DESCADD.reg = (uint32_t)(&usb_pipe_table[0]);
+        // For USB_SPEED_FULL
+        uhd_force_full_speed();
+        for (i = 0; i < sizeof(usb_pipe_table); i++)
+        {
+                (*(uint32_t *)(&usb_pipe_table[0] + i)) = 0;
+        }
 
         uhd_state = UHD_STATE_NO_VBUS;
 
+        // Put VBUS on USB port
+        pinMode( 32ul, OUTPUT );
+        digitalWrite( 32ul, HIGH );
+
+        uhd_enable_connection_int();
+
+        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DCONN;
+        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_WAKEUP;
+        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DDISC;
+
         USB->HOST.CTRLB.bit.VBUSOK = 1;
 
         // Configure interrupts
-        NVIC_SetPriority((IRQn_Type) USB_IRQn, 0UL);
-        NVIC_EnableIRQ((IRQn_Type) USB_IRQn);
-}
-
-//static void UHD_ISR(void)
-void USB_Handler(void)
-{
-        uint16_t flags;
-        uint8_t i;
-        uint8_t ept_int;
-
-        ept_int = udd_endpoint_interrupt();
-        
-        /* Not endpoint interrupt */
-        if (0 == ept_int)
-        {
-
-
-        }
-        else
-        {
-                /* host interrupts */
+        NVIC_SetPriority((IRQn_Type)USB_IRQn, 0UL);
+        NVIC_EnableIRQ((IRQn_Type)USB_IRQn);
+}
+
+
+static void UHD_ISR(void)
+//void USB_Handler(void)
+{
+   uint16_t flags;
+
+        if (USB->HOST.CTRLA.bit.MODE) {
+                /*host mode ISR */
 
                 /* get interrupt flags */
@@ -171 +187 @@
 
                 /* host SOF interrupt */
-                if (flags & USB_HOST_INTFLAG_HSOF) {
+                if (flags & USB_HOST_INTFLAG_HSOF)
+                {
                         /* clear the flag */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_HSOF;
-                        uhd_state = UHD_STATE_CONNECTED;
+                        uhd_state             = UHD_STATE_CONNECTED;
                         return;
                 }
 
                 /* host reset interrupt */
-                if (flags & USB_HOST_INTFLAG_RST) {
+                if (flags & USB_HOST_INTFLAG_RST)
+                {
                         /* clear the flag */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_RST;
-                        uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
                 }
 
                 /* host upstream resume interrupts */
-                if (flags & USB_HOST_INTFLAG_UPRSM) {
+                if (flags & USB_HOST_INTFLAG_UPRSM)
+                {
                         /* clear the flags */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_UPRSM;
-                        uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
                 }
 
                 /* host downstream resume interrupts */
-                if (flags & USB_HOST_INTFLAG_DNRSM) {
+                if (flags & USB_HOST_INTFLAG_DNRSM)
+                {
                         /* clear the flags */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_DNRSM;
-                        uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
                 }
 
                 /* host wakeup interrupts */
-                if (flags & USB_HOST_INTFLAG_WAKEUP) {
+                if (flags & USB_HOST_INTFLAG_WAKEUP)
+                {
                         /* clear the flags */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_WAKEUP;
-                        uhd_state = UHD_STATE_CONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_CONNECTED;    //UHD_STATE_ERROR;
                         return;
                 }
 
                 /* host ram access interrupt  */
-                if (flags & USB_HOST_INTFLAG_RAMACER) {
+                if (flags & USB_HOST_INTFLAG_RAMACER)
+                {
                         /* clear the flag */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_RAMACER;
-                        uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
                 }
 
                 /* host connect interrupt */
-                if (flags & USB_HOST_INTFLAG_DCONN) {
-                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Connection INT\r\n");)
+                if (flags & USB_HOST_INTFLAG_DCONN)
+                {
+                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Connection INT\r\n");
+                                                        )
                         /* clear the flag */
                         uhd_ack_connection();
@@ -231 +255 @@
                 }
 
-                /* host disconnect interrupt    */
-                if (flags & USB_HOST_INTFLAG_DDISC) {
-                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Disconnection INT\r\n");)
+                /* host disconnect interrupt  */
+                if (flags & USB_HOST_INTFLAG_DDISC)
+                {
+                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Disconnection INT\r\n");
+                                                        )
                         /* clear the flag */
                         uhd_ack_disconnection();
@@ -246 +272 @@
                         return;
                 }
-
-        }
-
-}
-
-
-
-
-/**
- * \brief Trigger a USB bus reset.
- */
-void UHD_BusReset(void)
-{
-        USB->HOST.CTRLB.bit.BUSRESET = 1;;
-}
+        }
+        else {
+                while(1);
+        }
+}
+
+
 
 /**
@@ -269 +287 @@
 uhd_vbus_state_t UHD_GetVBUSState(void)
 {
-        return uhd_state;
-}
-
+   return uhd_state;
+}
 
 
@@ -283 +300 @@
  * \retval 1 error.
  */
-uint32_t UHD_Pipe0_Alloc(uint32_t ul_add, uint32_t ul_ep_size)
-{
-        struct usb_host_pipe_config cfg;
-
-        if (ep_size < 8)
-        {
-                return 0;
-        }
-
-        /* set pipe config */
-        USB->HOST.HostPipe[0].PCFG.bit.BK = 0;
-        USB->HOST.HostPipe[0].PCFG.bit.PTYPE = USB_HOST_PIPE_TYPE_CONTROL;
-        USB->HOST.HostPipe[0].BINTERVAL.reg = 0;
-        USB->HOST.HostPipe[0].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_SETUP;
-
-        memset((uint8_t *)&usb_pipe_table[pipe_num], 0, sizeof(usb_pipe_table[0]));
-        usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PDADDR = 0;
-        usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = 0;
-        usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.SIZE = 0x03;  // 64 bytes
-
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRCPT_Msk;
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRFAIL | USB_HOST_PINTENSET_PERR;
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TXSTP;
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_STALL;
-
-        return 1;
-}
+uint32_t UHD_Pipe0_Alloc(uint32_t ul_add , uint32_t ul_ep_size)
+{
+        (void)(ul_add); // Unused argument
+
+        if( USB->HOST.STATUS.reg & USB_HOST_STATUS_SPEED(1) )
+                ul_ep_size = USB_PCKSIZE_SIZE_8_BYTES;  // Low Speed
+        else
+                ul_ep_size = USB_PCKSIZE_SIZE_64_BYTES; // Full Speed
+
+        USB->HOST.HostPipe[0].PCFG.bit.PTYPE = 1; //USB_HOST_PCFG_PTYPE_CTRL;
+        usb_pipe_table[0].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = 0;
+        usb_pipe_table[0].HostDescBank[0].PCKSIZE.bit.SIZE = ul_ep_size;
+
+        return 0;
+}
+
 
 /**
@@ -336 +342 @@
 {
         /* set pipe config */
-        USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.BK = ul_nb_bank;
-        USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTYPE = ul_type;
-        USB->HOST.HostPipe[ul_dev_ep].BINTERVAL.reg = ul_interval;
-
-        if (ul_dir & USB_EP_DIR_IN)
-        {
-                USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_IN;
-                USB->HOST.HostPipe[ul_dev_ep].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
-        }
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.BK    = ul_nb_bank;
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.reg &= ~USB_HOST_PCFG_MASK;  // USB->HOST.HostPipe[0].PCFG.bit.PTYPE = 1; //USB_HOST_PCFG_PTYPE_CTRL;
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.reg |= ul_type;
+        USB->HOST.HostPipe[ul_dev_ep].BINTERVAL.reg  = ul_interval;
+
+   if (ul_dir & USB_EP_DIR_IN)
+   {
+      USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PCFG_PTOKEN_IN;
+      USB->HOST.HostPipe[ul_dev_ep].PSTATUSSET.reg  = USB_HOST_PSTATUSSET_BK0RDY;
+   }
+   else
+   {
+      USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PCFG_PTOKEN_OUT;
+      USB->HOST.HostPipe[ul_dev_ep].PSTATUSCLR.reg  = USB_HOST_PSTATUSCLR_BK0RDY;
+   }
+
+        if( USB->HOST.STATUS.reg & USB_HOST_STATUS_SPEED(1) )
+           ul_maxsize = USB_PCKSIZE_SIZE_8_BYTES;  // Low Speed
         else
-        {
-                USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_OUT;
-                USB->HOST.HostPipe[ul_dev_ep].PSTATUSCLR.reg =  USB_HOST_PSTATUSCLR_BK0RDY;
-        }
-
-        memset((uint8_t *)&usb_descriptor_table.usb_pipe_table[ul_dev_ep], 0, sizeof(usb_pipe_table[ul_dev_ep]));
-
-        usb_descriptor_table.usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PDADDR = ul_dev_addr;
-        usb_descriptor_table.usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = ul_dev_ep;
-        usb_descriptor_table.usb_pipe_table[ul_dev_ep].HostDescBank[0].PCKSIZE.bit.SIZE = 0x03;  // 64 bytes
-
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRCPT_Msk;
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRFAIL | USB_HOST_PINTENSET_PERR;
-        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_STALL;
-
-        return 1;
-}
-
+           ul_maxsize = USB_PCKSIZE_SIZE_64_BYTES; // Full Speed
+
+   memset((uint8_t *)&usb_pipe_table[ul_dev_ep], 0, sizeof(usb_pipe_table[ul_dev_ep]));
+
+   usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PDADDR = ul_dev_addr;
+   usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = ul_dev_ep;
+   usb_pipe_table[ul_dev_ep].HostDescBank[0].PCKSIZE.bit.SIZE     = ul_maxsize;
+
+   return 1;
+}
+
+
+void UHD_Pipe_CountZero(uint32_t ul_pipe)
+{
+        usb_pipe_table[ul_pipe].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = 0;
+}
 
 /**
@@ -372 +385 @@
 void UHD_Pipe_Free(uint32_t ul_pipe)
 {
-        // Unalloc pipe
-        uhd_disable_pipe(ul_pipe);
-        uhd_unallocate_memory(ul_pipe);
-        uhd_reset_pipe(ul_pipe);
-
-        // The Pipe is frozen and no additional requests will be sent to the device on this pipe address.
-        USB->HOST.HostPipe[pipe_num].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE;
-}
+   // The Pipe is frozen and no additional requests will be sent to the device on this pipe address.
+   USB->HOST.HostPipe[ul_pipe].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE;
+}
+
 
 /**
@@ -390 +399 @@
  * \return number of data read.
  */
-uint32_t UHD_Pipe_Read(uint32_t pipe_num, uint32_t buf_size, uint8_t* buf)
-{
-        if (USB->HOST.HostPipe[pipe_num].PCFG.bit.PTYPE == USB_HOST_PIPE_TYPE_DISABLE)
-        {
-                return 0;
-        }
-
-        /* get pipe config from setting register */
-        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].ADDR.reg = (uint32_t)buf;
-        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = 0;
-        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = buf_size;
-        USB->HOST.HostPipe[pipe_num].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_IN;
-
-        /* Start transfer */
-        USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_BK0RDY;
-
-        // Unfreeze pipe
-        USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE;
-
-        return buf_size;
-}
+uint32_t UHD_Pipe_Read(uint32_t pipe_num, uint32_t buf_size, uint8_t *buf)
+{
+   if (USB->HOST.HostPipe[pipe_num].PCFG.bit.PTYPE == USB_HOST_PTYPE_DIS)
+   {
+      return 0;
+   }
+
+   /* get pipe config from setting register */
+   usb_pipe_table[pipe_num].HostDescBank[0].ADDR.reg = (uint32_t)buf;
+   usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT        = 0;
+   usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = buf_size;
+   USB->HOST.HostPipe[pipe_num].PCFG.bit.PTOKEN = USB_HOST_PCFG_PTOKEN_IN;
+
+   /* Start transfer */
+   USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_BK0RDY;
+
+   // Unfreeze pipe
+   USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE;
+
+   return buf_size;
+}
+
 
 /**
@@ -419 +429 @@
  * \param data Buffer containing data to write.
  */
-void UHD_Pipe_Write(uint32_t ul_pipe, uint32_t ul_size, uint8_t* data)
-{
-
-        if (USB->HOST.HostPipe[pipe_num].PCFG.bit.PTYPE == USB_HOST_PIPE_TYPE_DISABLE) 
-        {
-                return 0;
-        }
-
-        /* get pipe config from setting register */
-        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].ADDR.reg = (uint32_t)buf;
-        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = buf_size;
-        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = 0;
-        USB->HOST.HostPipe[pipe_num].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_OUT;
-
-
-        return 1;
+void UHD_Pipe_Write(uint32_t ul_pipe, uint32_t ul_size, uint8_t *buf)
+{
+   /* get pipe config from setting register */
+   usb_pipe_table[ul_pipe].HostDescBank[0].ADDR.reg = (uint32_t)buf;
+   usb_pipe_table[ul_pipe].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = ul_size;
+   usb_pipe_table[ul_pipe].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = 0;
 }
 
@@ -445 +445 @@
 void UHD_Pipe_Send(uint32_t ul_pipe, uint32_t ul_token_type)
 {
-        /* Start transfer */
-        USB->HOST.HostPipe[pipe_num].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
-
+        USB->HOST.HostPipe[ul_pipe].PCFG.bit.PTOKEN = ul_token_type;
+
+   /* Start transfer */
+        if(ul_token_type == USB_HOST_PCFG_PTOKEN_SETUP )
+        {
+                USB->HOST.HostPipe[ul_pipe].PINTFLAG.reg = USB_HOST_PINTFLAG_TXSTP;
+                USB->HOST.HostPipe[ul_pipe].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
+        }
+        else if(ul_token_type == USB_HOST_PCFG_PTOKEN_IN )
+        {
+                USB->HOST.HostPipe[ul_pipe].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_BK0RDY;
+        }
+        else
+        {
+                USB->HOST.HostPipe[ul_pipe].PINTFLAG.reg = USB_HOST_PINTFLAG_TRCPT(1);  // Transfer Complete 0
+                USB->HOST.HostPipe[ul_pipe].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
+        }
+   
         // Unfreeze pipe
-        USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE;
-}
+    uhd_unfreeze_pipe(ul_pipe);
+}
+
+#define USB_HOST_PINTFLAG_TRCPT_Pos 0            /**< \brief (USB_HOST_PINTFLAG) Transfer Complete 0/1 Interrupt Flag */
+#define USB_HOST_PINTFLAG_TRCPT_Msk (0x3u << USB_HOST_PINTFLAG_TRCPT_Pos)
+#define USB_HOST_PINTFLAG_TRCPT(value) ((USB_HOST_PINTFLAG_TRCPT_Msk & ((value) << USB_HOST_PINTFLAG_TRCPT_Pos)))
 
 /**
@@ -463 +482 @@
 uint32_t UHD_Pipe_Is_Transfer_Complete(uint32_t ul_pipe, uint32_t ul_token_type)
 {
-
-        // Freeze pipe
-        USB->HOST.HostPipe[pipe_num].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE;
-        switch(uhd_ctrl_request_phase) {
-                case UHD_CTRL_REQ_PHASE_DATA_IN:
-                _uhd_ctrl_phase_data_in(p_callback_para->transfered_size);
-                break;
-                case UHD_CTRL_REQ_PHASE_ZLP_IN:
-                _uhd_ctrl_request_end(UHD_TRANS_NOERROR);
-                break;
-                case UHD_CTRL_REQ_PHASE_DATA_OUT:
-                _uhd_ctrl_phase_data_out();
-                break;
-                case UHD_CTRL_REQ_PHASE_ZLP_OUT:
-                _uhd_ctrl_request_end(UHD_TRANS_NOERROR);
-                break;
-        }
-        return 0;
-}
-
-#endif 
-
+   // Check for transfer completion depending on token type
+   switch (ul_token_type)
+   {
+      case USB_HOST_PCFG_PTOKEN_SETUP:
+         if (Is_uhd_setup_ready(ul_pipe))
+         {
+            uhd_ack_setup_ready(ul_pipe);
+            uhd_freeze_pipe(ul_pipe);
+            return 1;
+         }
+                 break;
+
+      case USB_HOST_PCFG_PTOKEN_IN:
+         if (Is_uhd_in_received(ul_pipe))
+         {
+            // IN packet received
+            uhd_ack_in_received(ul_pipe);
+                        // Freeze will stop after the transfer
+                        uhd_freeze_pipe(ul_pipe);
+            return 1;
+         }
+                 break;
+ 
+      case USB_HOST_PCFG_PTOKEN_OUT:
+         if (Is_uhd_out_ready(ul_pipe))
+         {
+            // OUT packet sent
+            uhd_ack_out_ready(ul_pipe);
+            uhd_freeze_pipe(ul_pipe);
+            return 1;
+         }
+                 break;
+   }
+
+   return 0;
+}
+
+#endif //  HOST_DEFINED

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/samd21_host.h

@@ -1 @@
-/* ----------------------------------------------------------------------------
- *         SAM Software Package License
- * ----------------------------------------------------------------------------
- * Copyright (c) 2011-2012, Atmel Corporation
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following condition is met:
- *
- * - Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the disclaimer below.
- *
- * Atmel's name may not be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
- * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * ----------------------------------------------------------------------------
- */
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
 
 #ifndef UOTGHS_HOST_H_INCLUDED
 #define UOTGHS_HOST_H_INCLUDED
-
 
 #ifdef __cplusplus
@@ -36 +27 @@
 #endif
 
-//! \ingroup usb_host_group
-//! \defgroup uhd_group USB Host Driver (UHD)
-//! UOTGHS low-level driver for USB host mode
-//!
-//! @{
+extern __attribute__((__aligned__(4))) volatile UsbHostDescriptor usb_pipe_table[USB_EPT_NUM];
 
-//! @name UOTGHS Host IP properties
-//!
-//! @{
-//! Get maximal number of endpoints
-#define uhd_get_pipe_max_nbr()                (9)
-#define UOTGHS_EPT_NUM                        (uhd_get_pipe_max_nbr()+1)
-//! @}
+#define  USB_EP_DIR_IN        0x80  // USB_SETUP_DEVICE_TO_HOST
+#define  USB_EP_DIR_OUT       0x00  // USB_SETUP_HOST_TO_DEVICE
 
-//! @name Host Vbus line control
-//!
-//! VBOF is an optional output pin which allows to enable or disable
-//! the external VBus generator.
-//!
-//! @{
-//! Enables hardware control of USB_VBOF output pin when a Vbus error occur
-#define uhd_enable_vbus_error_hw_control()    (Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSHWC))
-//! Disables hardware control of USB_VBOF output pin when a Vbus error occur
-#define uhd_disable_vbus_error_hw_control()   (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSHWC))
+#define USB_HOST_PTYPE_DIS     USB_HOST_PCFG_PTYPE(0x0) // Pipe is disabled
+#define USB_HOST_PTYPE_CTRL    USB_HOST_PCFG_PTYPE(0x1) // Pipe is enabled and configured as CONTROL
+#define USB_HOST_PTYPE_ISO     USB_HOST_PCFG_PTYPE(0x2) // Pipe is enabled and configured as ISO
+#define USB_HOST_PTYPE_BULK    USB_HOST_PCFG_PTYPE(0x3) // Pipe is enabled and configured as BULK
+#define USB_HOST_PTYPE_INT     USB_HOST_PCFG_PTYPE(0x4) // Pipe is enabled and configured as INTERRUPT
+#define USB_HOST_PTYPE_EXT     USB_HOST_PCFG_PTYPE(0x5) // Pipe is enabled and configured as EXTENDED
 
-//! Pin and function for USB_VBOF according to configuration from USB_VBOF
-#define USB_VBOF_PIN            USB_VBOF_GPIO
-#define USB_VBOF_FUNCTION       USB_VBOF_FLAGS
-//! Output USB_VBOF onto its pin
-#define uhd_output_vbof_pin() do {\
-        pio_configure_pin(USB_VBOF_PIN, USB_VBOF_FUNCTION); \
-} while (0)
+#define USB_HOST_NB_BK_1                1
 
-//! Set USB_VBOF output pin polarity
-#define uhd_set_vbof_active_high()            (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSPO))
-#define uhd_set_vbof_active_low()             (Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSPO))
-//! Requests VBus activation
-#define uhd_enable_vbus()                     (Set_bits(UOTGHS->UOTGHS_SFR, UOTGHS_SR_VBUSRQ))
-//! Requests VBus deactivation
-#define uhd_disable_vbus()                    (Set_bits(UOTGHS->UOTGHS_SCR, UOTGHS_SR_VBUSRQ))
-//! Tests if VBus activation has been requested
-#define Is_uhd_vbus_enabled()                 (Tst_bits(UOTGHS->UOTGHS_SR, UOTGHS_SR_VBUSRQ))
-//! @}
+#define USB_HOST_PCFG_PTOKEN_SETUP  USB_HOST_PCFG_PTOKEN(0x0)
+#define USB_HOST_PCFG_PTOKEN_IN     USB_HOST_PCFG_PTOKEN(0x1)
+#define USB_HOST_PCFG_PTOKEN_OUT    USB_HOST_PCFG_PTOKEN(0x2)
 
-//! @name Host Vbus line monitoring
-//!
-//! The VBus level is always checked by USBC hardware.
-//!
-//! @{
-#define uhd_enable_vbus_error_interrupt()     (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE))
-#define uhd_disable_vbus_error_interrupt()    (Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE))
-#define Is_uhd_vbus_error_interrupt_enabled() (Tst_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE))
-#define uhd_ack_vbus_error_interrupt()        (Set_bits(UOTGHS->UOTGHS_SCR, UOTGHS_SCR_VBERRIC))
-#define Is_uhd_vbus_error_interrupt()         (Tst_bits(UOTGHS->UOTGHS_SR, UOTGHS_SR_VBERRI))
-//! @}
+#define USB_ERRORFLOW         USB_HOST_STATUS_BK_ERRORFLOW
+#define USB_ERRORTIMEOUT      USB_HOST_STATUS_PIPE_TOUTER
+#define USB_ERROR_DATATOGGLE  USB_HOST_STATUS_PIPE_DTGLER
 
-#define uhd_ack_errors_interrupt()            (UOTGHS->UOTGHS_SCR = (UOTGHS_SCR_VBERRIC|UOTGHS_SCR_BCERRIC|UOTGHS_SCR_HNPERRIC|UOTGHS_SCR_STOIC))
-#define Is_uhd_errors_interrupt()             (Tst_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE|UOTGHS_CTRL_BCERRE|UOTGHS_CTRL_HNPERRE|UOTGHS_CTRL_STOE))
-#define uhd_enable_suspend_error_interrupt()
-#define uhd_enable_hnp_error_interrupt()
-#define uhd_enable_bconn_error_interrupt()
+#define USB_PCKSIZE_SIZE_8_BYTES        0
+#define USB_PCKSIZE_SIZE_16_BYTES       1
+#define USB_PCKSIZE_SIZE_32_BYTES       2
+#define USB_PCKSIZE_SIZE_64_BYTES       3 
+#define USB_PCKSIZE_SIZE_128_BYTES      4
+#define USB_PCKSIZE_SIZE_256_BYTES      5
+#define USB_PCKSIZE_SIZE_512_BYTES      6
+#define USB_PCKSIZE_SIZE_1023_BYTES_FS  7   
+#define USB_PCKSIZE_SIZE_1024_BYTES_HS  7  
 
-//! @name USB device connection/disconnection monitoring
-//! @{
-#define uhd_enable_connection_int()           (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_DCONNIES)
-#define uhd_disable_connection_int()          (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_DCONNIEC)
-#define Is_uhd_connection_int_enabled()       (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_DCONNIE))
-#define uhd_ack_connection()                  (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_DCONNIC)
-#define Is_uhd_connection()                   (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_DCONNI))
+#define USB_HOST_DTGL(p)               (USB->HOST.HostPipe[p].PSTATUS.reg & USB_HOST_PSTATUS_DTGL)>>USB_HOST_PSTATUS_DTGL_Pos
 
-#define uhd_enable_disconnection_int()        (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_DDISCIES)
-#define uhd_disable_disconnection_int()       (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_DDISCIEC)
-#define Is_uhd_disconnection_int_enabled()    (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_DDISCIE))
-#define uhd_ack_disconnection()               (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_DDISCIC)
-#define Is_uhd_disconnection()                (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_DDISCI))
-//! @}
+// USB host connection/disconnection monitoring
+#define uhd_enable_connection_int()           USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DCONN
+#define uhd_disable_connection_int()          USB->HOST.INTENCLR.reg = USB_HOST_INTENCLR_DCONN
+#define uhd_ack_connection()                  USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_DCONN
 
-//! @name USB device speed control
-//! @{
-#define uhd_get_speed_mode()                  (Rd_bits(UOTGHS->UOTGHS_SR, UOTGHS_SR_SPEED_Msk))
-#define Is_uhd_low_speed_mode()                 (uhd_get_speed_mode() == UOTGHS_SR_SPEED_LOW_SPEED)
-#define Is_uhd_full_speed_mode()                (uhd_get_speed_mode() == UOTGHS_SR_SPEED_FULL_SPEED)
-#define Is_uhd_high_speed_mode()                (uhd_get_speed_mode() == UOTGHS_SR_SPEED_HIGH_SPEED)
-//! Enable high speed mode
-# define uhd_enable_high_speed_mode()        (Wr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SPDCONF_Msk, UOTGHS_HSTCTRL_SPDCONF_HIGH_SPEED))
-//! Disable high speed mode
-# define uhd_disable_high_speed_mode()       (Wr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SPDCONF_Msk, UOTGHS_HSTCTRL_SPDCONF_FORCED_FS))
-//! @}
+#define uhd_enable_disconnection_int()        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DDISC
+#define uhd_disable_disconnection_int()       USB->HOST.INTENCLR.reg = USB_HOST_INTENCLR_DDISC
+#define uhd_ack_disconnection()               USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_DDISC
 
-//! @name Bus events control
-//! These macros manage the bus events: reset, SOF, resume, wakeup.
-//! @{
+// Initiates a USB register reset
+#define uhd_start_USB_reg_reset()             USB->HOST.CTRLA.bit.SWRST = 1;
 
-//! Initiates a reset event
-//! @{
-#define uhd_start_reset()                            (Set_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESET))
-#define Is_uhd_starting_reset()                      (Tst_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESET))
-#define uhd_stop_reset()                             (Clr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESET))
+// Bus Reset
+#define Is_uhd_starting_reset()             (USB->HOST.CTRLB.bit.BUSRESET == 1)
+#define UHD_BusReset()                      USB->HOST.CTRLB.bit.BUSRESET = 1
+#define uhd_stop_reset()                    // nothing to do
 
-#define uhd_enable_reset_sent_interrupt()            (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_RSTIES)
-#define uhd_disable_reset_sent_interrupt()           (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_RSTIEC)
-#define Is_uhd_reset_sent_interrupt_enabled()        (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_RSTIE))
-#define uhd_ack_reset_sent()                         (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_RSTIC)
-#define Is_uhd_reset_sent()                          (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_RSTI))
-//! @}
+#define uhd_ack_reset_sent()                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_RST
+#define Is_uhd_reset_sent()                          (USB->HOST.INTFLAG.reg & USB_HOST_INTFLAG_RST)
 
-//! Initiates a SOF events
-//! @{
-#define uhd_enable_sof()                             (Set_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SOFE))
-#define uhd_disable_sof()                            (Clr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SOFE))
-#define Is_uhd_sof_enabled()                         (Tst_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SOFE))
-#define uhd_get_sof_number()                         ((UOTGHS->UOTGHS_HSTFNUM&UOTGHS_HSTFNUM_FNUM_Msk)>>UOTGHS_HSTFNUM_FNUM_Pos)
-#define uhd_get_microsof_number()                    ((UOTGHS->UOTGHS_HSTFNUM&UOTGHS_HSTFNUM_MFNUM_Msk)>>UOTGHS_HSTFNUM_MFNUM_Pos)
-#define uhd_get_frame_position()                     (Rd_bits(UOTGHS->UOTGHS_HSTFNUM, UOTGHS_HSTFNUM_FLENHIGH_Msk))
-#define uhd_enable_sof_interrupt()                   (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_HSOFIES)
-#define uhd_disable_sof_interrupt()                  (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_HSOFIEC)
-#define Is_uhd_sof_interrupt_enabled()               (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_HSOFIE))
-#define uhd_ack_sof()                                (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_HSOFIC)
-#define Is_uhd_sof()                                 (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_HSOFI))
-//! @}
+// Initiates a SOF events
+#define uhd_enable_sof()                             USB->HOST.CTRLB.bit.SOFE = 1
+#define uhd_disable_sof()                            USB->HOST.CTRLB.bit.SOFE = 0
+#define Is_uhd_sof_enabled()                         (USB->HOST.CTRLB & USB_HOST_CTRLB_SOFE)
+#define Is_uhd_sof()                                 (USB->HOST.INTFLAG.reg & USB_HOST_INTFLAG_HSOF)
 
-//! Initiates a resume event
-//! It is called downstream resume event.
-//! @{
-#define uhd_send_resume()                            (Set_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESUME))
-#define Is_uhd_sending_resume()                      (Tst_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESUME))
+// USB address of pipes
+#define uhd_configure_address(pipe_num, addr) usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PDADDR = addr
+#define uhd_get_configured_address(pipe_num)  usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PDADDR
 
-#define uhd_enable_downstream_resume_interrupt()     (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_RSMEDIES)
-#define uhd_disable_downstream_resume_interrupt()    (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_RSMEDIEC)
-#define Is_uhd_downstream_resume_interrupt_enabled() (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_RSMEDIE))
-#define uhd_ack_downstream_resume()                  (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_RSMEDIC)
-#define Is_uhd_downstream_resume()                   (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_RSMEDI))
-//! @}
+// Pipes
+#define uhd_freeze_pipe(p)                       USB->HOST.HostPipe[p].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE
+#define uhd_unfreeze_pipe(p)                     USB->HOST.HostPipe[p].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE
+#define Is_uhd_pipe_frozen(p)                    ((USB->HOST.HostPipe[p].PSTATUS.reg&USB_HOST_PSTATUS_PFREEZE)==USB_HOST_PSTATUS_PFREEZE)
 
-//! Detection of a wake-up event
-//! A wake-up event is received when the host controller is in the suspend mode:
-//! - and an upstream resume from the peripheral is detected.
-//! - and a peripheral disconnection is detected.
-//! @{
-#define uhd_enable_wakeup_interrupt()                (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_HWUPIES)
-#define uhd_disable_wakeup_interrupt()               (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_HWUPIEC)
-#define Is_uhd_wakeup_interrupt_enabled()            (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_HWUPIE))
-#define uhd_ack_wakeup()                             (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_HWUPIC)
-#define Is_uhd_wakeup()                              (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_HWUPI))
+// Pipe configuration
+#define uhd_configure_pipe_token(p, token)       USB->HOST.HostPipe[p].PCFG.bit.PTOKEN = token
 
-#define uhd_enable_upstream_resume_interrupt()       (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_RXRSMIES)
-#define uhd_disable_upstream_resume_interrupt()      (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_RXRSMIEC)
-#define Is_uhd_upstream_resume_interrupt_enabled()   (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_RXRSMIE))
-#define uhd_ack_upstream_resume()                    (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_RXRSMIC)
-#define Is_uhd_upstream_resume()                     (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_RXRSMI))
-//! @}
-//! @}
+// Pipe data management
+#define uhd_byte_count(p)                        usb_pipe_table[p].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT
+#define uhd_ack_setup_ready(p)                   USB->HOST.HostPipe[p].PINTFLAG.reg = USB_HOST_PINTFLAG_TXSTP
+#define Is_uhd_setup_ready(p)                    ((USB->HOST.HostPipe[p].PINTFLAG.reg&USB_HOST_PINTFLAG_TXSTP) == USB_HOST_PINTFLAG_TXSTP)
+#define uhd_ack_in_received(p)                   USB->HOST.HostPipe[p].PINTFLAG.reg = USB_HOST_PINTFLAG_TRCPT(1)
+#define Is_uhd_in_received(p)                    ((USB->HOST.HostPipe[p].PINTFLAG.reg&USB_HOST_PINTFLAG_TRCPT(1)) == USB_HOST_PINTFLAG_TRCPT(1))
+#define uhd_ack_out_ready(p)                     USB->HOST.HostPipe[p].PINTFLAG.reg = USB_HOST_PINTFLAG_TRCPT(1)
+#define Is_uhd_out_ready(p)                      ((USB->HOST.HostPipe[p].PINTFLAG.reg&USB_HOST_PINTFLAG_TRCPT(1)) == USB_HOST_PINTFLAG_TRCPT(1))
+#define uhd_ack_nak_received(p)                  usb_pipe_table[p].HostDescBank[1].STATUS_BK.reg &= ~USB_HOST_STATUS_BK_ERRORFLOW
+#define Is_uhd_nak_received(p)                   (usb_pipe_table[p].HostDescBank[1].STATUS_BK.reg & USB_HOST_STATUS_BK_ERRORFLOW)
 
+// Endpoint Interrupt Summary
+#define uhd_endpoint_interrupt()            USB->HOST.PINTSMRY.reg
 
-//! @name Pipes management
-//! @{
+// Run in Standby
+#define uhd_run_in_standby()                USB->HOST.CTRLA.reg |= USB_CTRLA_RUNSTDBY
+// Force host mode
+#define uhd_force_host_mode()               USB->HOST.CTRLA.reg |= USB_CTRLA_MODE
 
-//! USB address of pipes
-//! @{
-#define uhd_configure_address(p, addr) \
-                (Wr_bitfield((&UOTGHS->UOTGHS_HSTADDR1)[(p)>>2], \
-                UOTGHS_HSTADDR1_HSTADDRP0_Msk << (((p)&0x03)<<3), addr))
-#define uhd_get_configured_address(p) \
-                (Rd_bitfield((&UOTGHS->UOTGHS_HSTADDR1)[(p)>>2], \
-                UOTGHS_HSTADDR1_HSTADDRP0_Msk << (((p)&0x03)<<3)))
-//! @}
+// Enable USB macro
+#define uhd_enable()                        USB->HOST.CTRLA.reg |= USB_CTRLA_ENABLE
+// Disable USB macro
+#define uhd_disable()                       USB->HOST.CTRLA.reg &= ~USB_CTRLA_ENABLE
 
-//! Pipe enable
-//! Enable, disable, reset, freeze
-//! @{
-#define uhd_enable_pipe(p) \
-                (Set_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
-#define uhd_disable_pipe(p) \
-                (Clr_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
-#define Is_uhd_pipe_enabled(p) \
-                (Tst_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
-#define uhd_reset_pipe(p) \
-                (Set_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p))); \
-                (Clr_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
-#define Is_uhd_resetting_pipe(p) \
-                (Tst_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
-#define uhd_freeze_pipe(p)                       (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_PFREEZES)
-#define uhd_unfreeze_pipe(p)                     (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_PFREEZEC)
-#define Is_uhd_pipe_frozen(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_PFREEZE))
-#define uhd_reset_data_toggle(p)                 (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_RSTDTS)
-#define Is_uhd_data_toggle_reset(p)              (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_RSTDT))
-//! @}
-
-//! Pipe configuration
-//! @{
-#define uhd_configure_pipe_int_req_freq(p,freq)  (Wr_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_INTFRQ_Msk, (freq)))
-#define uhd_get_pipe_int_req_freq(p)             (Rd_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_INTFRQ_Msk))
-#define uhd_configure_pipe_endpoint_number(p,ep) (Wr_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PEPNUM_Msk, (ep)))
-#define uhd_get_pipe_endpoint_address(p) \
-                (uhd_is_pipe_in(p) ?\
-                        (uhd_get_pipe_endpoint_number(p) | USB_EP_DIR_IN) :\
-                        (uhd_get_pipe_endpoint_number(p) | USB_EP_DIR_OUT))
-#define uhd_get_pipe_endpoint_number(p)          (Rd_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], (UOTGHS_HSTPIPCFG_PEPNUM_Msk)))
-#define uhd_configure_pipe_type(p, type)         (Wr_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTYPE_Msk, type))
-#define uhd_get_pipe_type(p)                     (Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTYPE_Msk))
-#define uhd_enable_pipe_bank_autoswitch(p)       (Set_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_AUTOSW))
-#define uhd_disable_pipe_bank_autoswitch(p)      (Clr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_AUTOSW))
-#define Is_uhd_pipe_bank_autoswitch_enabled(p)   (Tst_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_AUTOSW))
-#define uhd_configure_pipe_token(p, token)       (Wr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTOKEN_Msk, token))
-#define uhd_get_pipe_token(p)                    (Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTOKEN_Msk))
-#define uhd_is_pipe_in(p)                        (UOTGHS_HSTPIPCFG_PTOKEN_IN==uhd_get_pipe_token(p))
-#define uhd_is_pipe_out(p)                       (UOTGHS_HSTPIPCFG_PTOKEN_OUT==uhd_get_pipe_token(p))
-//! Bounds given integer size to allowed range and rounds it up to the nearest
-//! available greater size, then applies register format of UOTGHS controller
-//! for pipe size bit-field.
-#define uhd_format_pipe_size(size) \
-                (32 - clz(((uint32_t)min(max(size, 8), 1024) << 1) - 1) - 1 - 3)
-#define uhd_configure_pipe_size(p,size) \
-                (Wr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PSIZE_Msk, uhd_format_pipe_size(size)))
-#define uhd_get_pipe_size(p)                     (8<<((Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], (UOTGHS_HSTPIPCFG_PSIZE_Msk)))>> UOTGHS_HSTPIPCFG_PSIZE_Pos))
-#define uhd_configure_pipe_bank(p,bank)          (Wr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PBK_Msk, (bank)))
-#define uhd_get_pipe_bank(p)                     (Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PBK_Msk))
-#define uhd_allocate_memory(p)                   (Set_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_ALLOC))
-#define uhd_unallocate_memory(p)                 (Clr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_ALLOC))
-#define Is_uhd_memory_allocated(p)               (Tst_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_ALLOC))
-
-//! Enable PING management only available in HS mode
-#  define uhd_enable_ping(p)                     (Set_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PINGEN))
-//#endif
-#define uhd_configure_pipe(p, freq, ep_num, type, token, size, bank, bank_switch) \
-        (UOTGHS->UOTGHS_HSTPIPCFG[p] = \
-                (bank)|\
-                ((uhd_format_pipe_size(size)<<UOTGHS_HSTPIPCFG_PSIZE_Pos)&UOTGHS_HSTPIPCFG_PSIZE_Msk)|\
-                ((token)&UOTGHS_HSTPIPCFG_PTOKEN_Msk)|\
-                ((type)&UOTGHS_HSTPIPCFG_PTYPE_Msk)|\
-                (((ep_num)<<UOTGHS_HSTPIPCFG_PEPNUM_Pos)&UOTGHS_HSTPIPCFG_PEPNUM_Msk)|\
-                bank_switch |\
-                (((freq)<<UOTGHS_HSTPIPCFG_INTFRQ_Pos)&UOTGHS_HSTPIPCFG_INTFRQ_Msk))
-
-#define Is_uhd_pipe_configured(p)                (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_CFGOK))
-//! @}
-
-//! Pipe main interrupts management
-//! @{
-#define uhd_enable_pipe_interrupt(p)            (UOTGHS->UOTGHS_HSTIER = (UOTGHS_HSTIER_PEP_0 << (p)))
-#define uhd_disable_pipe_interrupt(p)           (UOTGHS->UOTGHS_HSTIDR = (UOTGHS_HSTIDR_PEP_0 << (p)))
-#define Is_uhd_pipe_interrupt_enabled(p)        (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_PEP_0 << (p)))
-#define Is_uhd_pipe_interrupt(p)                (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_PEP_0 << (p)))
-//! returns the lowest pipe number generating a pipe interrupt or UOTGHS_EPT_NUM if none
-#define uhd_get_interrupt_pipe_number() \
-        (ctz(((UOTGHS->UOTGHS_HSTISR >> 8) & (UOTGHS->UOTGHS_HSTIMR >> 8)) | (1 << UOTGHS_EPT_NUM)))
-//! @}
-
-//! Pipe overflow and underflow for isochronous and interrupt endpoints
-//! @{
-#define uhd_enable_overflow_interrupt(p)         (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_OVERFIES)
-#define uhd_disable_overflow_interrupt(p)        (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_OVERFIEC)
-#define Is_uhd_overflow_interrupt_enabled(p)     (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_OVERFIE))
-#define uhd_ack_overflow_interrupt(p)            (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_OVERFIC)
-#define Is_uhd_overflow(p)                       (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_OVERFI))
-
-#define uhd_enable_underflow_interrupt(p)        (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_UNDERFIES)
-#define uhd_disable_underflow_interrupt(p)       (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_UNDERFIEC)
-#define Is_uhd_underflow_interrupt_enabled(p)    (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_UNDERFIE))
-#define uhd_ack_underflow_interrupt(p)           (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_UNDERFIC)
-#define Is_uhd_underflow(p)                      (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_UNDERFI))
-//! @}
-
-//! USB packet errors management
-//! @{
-#define uhd_enable_stall_interrupt(p)            (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_RXSTALLDES)
-#define uhd_disable_stall_interrupt(p)           (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_RXSTALLDEC)
-#define Is_uhd_stall_interrupt_enabled(p)        (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_RXSTALLDE))
-#define uhd_ack_stall(p)                         (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_RXSTALLDIC)
-#define Is_uhd_stall(p)                          (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RXSTALLDI))
-
-#define uhd_enable_pipe_error_interrupt(p)       (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_PERRES)
-#define uhd_disable_pipe_error_interrupt(p)      (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_PERREC)
-#define Is_uhd_pipe_error_interrupt_enabled(p)   (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_PERRE))
-#define uhd_ack_all_errors(p)                    (UOTGHS->UOTGHS_HSTPIPERR[p] = 0UL)
-#define Is_uhd_pipe_error(p)                     (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_PERRI))
-#define uhd_error_status(p)                      (UOTGHS->UOTGHS_HSTPIPERR[p])
-#define Is_uhd_bad_data_toggle(p)                (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_DATATGL))
-#define Is_uhd_data_pid_error(p)                 (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_DATAPID))
-#define Is_uhd_pid_error(p)                      (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_PID))
-#define Is_uhd_timeout_error(p)                  (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_TIMEOUT))
-#define Is_uhd_crc16_error(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_CRC16))
-#define uhd_get_error_counter(p)                 (Rd_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_COUNTER))
-//! @}
-
-//! Pipe data management
-//! @{
-#define uhd_data_toggle(p)                       (Rd_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_DTSEQ))
-
-#define uhd_enable_bank_interrupt(p)             (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_NBUSYBKES)
-#define uhd_disable_bank_interrupt(p)            (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_NBUSYBKEC)
-#define Is_uhd_bank_interrupt_enabled(p)         (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_NBUSYBKE))
-#define uhd_nb_busy_bank(p)                      (Rd_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_NBUSYBK_Msk))
-#define uhd_current_bank(p)                      (Rd_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_CURRBK_Msk ))
-
-#define uhd_enable_short_packet_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_SHORTPACKETES)
-#define uhd_disable_short_packet_interrupt(p)    (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_SHORTPACKETIEC)
-#define Is_uhd_short_packet_interrupt_enabled(p) (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_SHORTPACKETIE))  )
-#define uhd_ack_short_packet(p)                  (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_SHORTPACKETIC)
-#define Is_uhd_short_packet(p)                   (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_SHORTPACKETI))
-#define uhd_byte_count(p)                        (Rd_bitfield(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_PBYCT_Msk))
-
-#define Is_uhd_fifocon(p)                        (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_FIFOCON))
-#define uhd_ack_fifocon(p)                       (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_FIFOCONC)
-
-#define uhd_enable_setup_ready_interrupt(p)      (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_TXSTPES)
-#define uhd_disable_setup_ready_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_TXSTPEC)
-#define Is_uhd_setup_ready_interrupt_enabled(p)  (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_TXSTPE))
-#define uhd_ack_setup_ready(p)                   (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_TXSTPIC)
-#define Is_uhd_setup_ready(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_TXSTPI))
-
-#define uhd_enable_in_received_interrupt(p)      (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_RXINES)
-#define uhd_disable_in_received_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_RXINEC)
-#define Is_uhd_in_received_interrupt_enabled(p)  (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_RXINE))
-#define uhd_ack_in_received(p)                   (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_RXINIC)
-#define Is_uhd_in_received(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RXINI))
-
-#define uhd_enable_out_ready_interrupt(p)        (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_TXOUTES)
-#define uhd_disable_out_ready_interrupt(p)       (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_TXOUTEC)
-#define Is_uhd_out_ready_interrupt_enabled(p)    (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_TXOUTE))
-#define uhd_ack_out_ready(p)                     (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_TXOUTIC)
-#define Is_uhd_out_ready(p)                      (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_TXOUTI))
-#define uhd_raise_out_ready(p)                   (UOTGHS->UOTGHS_HSTPIPIFR[p] = UOTGHS_HSTPIPIFR_TXOUTIS)
-
-#define uhd_enable_nak_received_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_NAKEDES)
-#define uhd_disable_nak_received_interrupt(p)    (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_NAKEDEC)
-#define Is_uhd_nak_received_interrupt_enabled(p) (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_NAKEDE))
-#define uhd_ack_nak_received(p)                  (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_NAKEDIC)
-#define Is_uhd_nak_received(p)                   (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_NAKEDI))
-
-#define Is_uhd_read_enabled(p)                   (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RWALL))
-#define Is_uhd_write_enabled(p)                  (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RWALL ))
-
-#define uhd_enable_continuous_in_mode(p)         (Set_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INMODE))
-#define uhd_disable_continuous_in_mode(p)        (Clr_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INMODE))
-#define Is_uhd_continuous_in_mode_enabled(p)     (Tst_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INMODE))
-
-#define uhd_in_request_number(p, in_num)         (Set_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], (in_num)-1))
-#define uhd_get_in_request_number(p)             (((Rd_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INRQ_Msk))>>UOTGHS_HSTPIPINRQ_INRQ_Pos)+1)
-//! @}
-
-//! Maximum transfer size on USB DMA
-#define UHD_PIPE_MAX_TRANS 0x8000
-
-//! Get 64-, 32-, 16- or 8-bit access to FIFO data register of selected pipe.
-//! @param p      Target Pipe number
-//! @param scale  Data scale in bits: 64, 32, 16 or 8
-//! @return       Volatile 64-, 32-, 16- or 8-bit data pointer to FIFO data register
-//! @warning It is up to the user of this macro to make sure that all accesses
-//! are aligned with their natural boundaries except 64-bit accesses which
-//! require only 32-bit alignment.
-//! @warning It is up to the user of this macro to make sure that used HSB
-//! addresses are identical to the DPRAM internal pointer modulo 32 bits.
-#define uhd_get_pipe_fifo_access(p, scale) \
-        (((volatile TPASTE2(U, scale) (*)[UHD_PIPE_MAX_TRANS / ((scale) / 8)])UOTGHS_RAM_ADDR)[(p)])
-
+// Force full speed mode
+#define uhd_force_full_speed()              USB->HOST.CTRLB.reg &= ~USB_HOST_CTRLB_SPDCONF_Msk
 
 #ifdef __cplusplus