Diff: source/hic_hal/freescale/k26f/usbd_MK26F.c

Revision:

0:01f31e923fe2

diff -r 000000000000 -r 01f31e923fe2 source/hic_hal/freescale/k26f/usbd_MK26F.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/source/hic_hal/freescale/k26f/usbd_MK26F.c	Tue Apr 07 12:55:42 2020 +0200
@@ -0,0 +1,892 @@
+/**
+ * @file    usbd_LPC43xx_USBD0.c
+ * @brief
+ *
+ * DAPLink Interface Firmware
+ * Copyright (c) 2009-2016, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rl_usb.h"
+#include "usb.h"
+#include "fsl_device_registers.h"
+#include "hic_init.h"
+
+#define __NO_USB_LIB_C
+#include "usb_config.c"
+
+/* Endpoint queue head */
+typedef struct __EPQH {
+    uint32_t cap;
+    uint32_t curr_dTD;
+    uint32_t next_dTD;
+    uint32_t dTD_token;
+    uint32_t buf[5];
+    uint32_t reserved;
+    uint32_t setup[2];
+    uint32_t reserved1[4];
+} EPQH;
+
+/* Endpoint transfer descriptor */
+typedef struct __dTD {
+    uint32_t next_dTD;
+    uint32_t dTD_token;
+    uint32_t buf[5];
+    uint32_t reserved;
+} dTD;
+
+/* Endpoint */
+typedef struct __EP {
+    uint8_t *buf;
+    uint32_t maxPacket;
+} EP;
+
+EPQH __align(2048) EPQHx[(USBD_EP_NUM + 1) * 2];
+dTD  __align(32) dTDx[(USBD_EP_NUM + 1) * 2];
+
+EP Ep[(USBD_EP_NUM + 1) * 2];
+uint32_t BufUsed;
+uint32_t IsoEp;
+uint32_t cmpl_pnd;
+
+#define ENDPTCTRL(EPNum) *(volatile uint32_t *)((uint32_t)(&USBHS->EPCR0) + 4 * EPNum)
+#define EP_OUT_IDX(EPNum) (EPNum * 2    )
+#define EP_IN_IDX(EPNum) (EPNum * 2 + 1)
+#define HS(en) (USBD_HS_ENABLE * en)
+
+/* reserve RAM for endpoint buffers */
+#if USBD_VENDOR_ENABLE
+/* custom class: user defined buffer size */
+#define EP_BUF_POOL_SIZE 0x1000
+uint8_t __align(4096) EPBufPool[EP_BUF_POOL_SIZE]
+#else
+/* supported classes are used */
+uint8_t __align(4096) EPBufPool[
+    USBD_MAX_PACKET0                                                                                                     * 2 +
+    USBD_HID_ENABLE     *  (HS(USBD_HID_HS_ENABLE)      ? USBD_HID_HS_WMAXPACKETSIZE     : USBD_HID_WMAXPACKETSIZE)      * 2 +
+    USBD_MSC_ENABLE     *  (HS(USBD_MSC_HS_ENABLE)      ? USBD_MSC_HS_WMAXPACKETSIZE     : USBD_MSC_WMAXPACKETSIZE)      * 2 +
+    USBD_ADC_ENABLE     *  (HS(USBD_ADC_HS_ENABLE)      ? USBD_ADC_HS_WMAXPACKETSIZE     : USBD_ADC_WMAXPACKETSIZE)          +
+    USBD_CDC_ACM_ENABLE * ((HS(USBD_CDC_ACM_HS_ENABLE) ? USBD_CDC_ACM_HS_WMAXPACKETSIZE  : USBD_CDC_ACM_WMAXPACKETSIZE)      +
+                           (HS(USBD_CDC_ACM_HS_ENABLE) ? USBD_CDC_ACM_HS_WMAXPACKETSIZE1 : USBD_CDC_ACM_WMAXPACKETSIZE1) * 2) + 
+    USBD_BULK_ENABLE     *  (HS(USBD_BULK_HS_ENABLE)      ? USBD_BULK_HS_WMAXPACKETSIZE     : USBD_BULK_WMAXPACKETSIZE)      * 2 
+];
+#endif
+
+void USBD_PrimeEp(uint32_t EPNum, uint32_t cnt);
+
+/*
+ *  Usb interrupt enable/disable
+ *    Parameters:      ena: enable/disable
+ *                       0: disable interrupt
+ *                       1: enable interrupt
+ */
+
+#ifdef __RTX
+void __svc(1) USBD_Intr(int ena);
+void __SVC_1(int ena)
+{
+#else
+void USBD_Intr(int ena)
+{
+#endif
+
+    if (ena) {
+        NVIC_EnableIRQ(USBHS_IRQn);          /* Enable USB interrupt */
+    } else {
+        NVIC_DisableIRQ(USBHS_IRQn);         /* Disable USB interrupt */
+    }
+}
+
+
+/*
+ *  USB Device Initialize Function
+ *   Called by the User to initialize USB Device
+ *    Return Value:    None
+ */
+
+void USBD_Init(void)
+{
+    USBD_Intr(0);
+
+    hic_enable_usb_clocks();
+
+    USBHS->USBCMD |= (1UL << 1);     /* usb reset */
+
+    while (USBHS->USBCMD & (1UL << 1));
+
+    USBHS->USBMODE  = 2 | (1UL << 3);/* device mode */
+#if USBD_HS_ENABLE
+    USBHS->PORTSC1 &= ~(1UL << 24);
+#else
+    USBHS->PORTSC1 |= (1UL << 24);
+#endif
+    USBHS->OTGSC = 1 | (1UL << 3);
+    Ep[EP_OUT_IDX(0)].maxPacket = USBD_MAX_PACKET0;
+    USBHS->USBINTR  = (1UL << 0) |   /* usb int enable */
+                           (1UL << 2) |   /* port change detect int enable */
+                           (1UL << 8) |   /* suspend int enable */
+                           (1UL << 16) |  /* nak int enable */
+                           (1UL << 6) |   /* reset int enable */
+#ifdef __RTX
+                           ((USBD_RTX_DevTask   != 0) ? (1UL << 7) : 0) |   /* SOF */
+                           ((USBD_RTX_DevTask   != 0) ? (1UL << 1) : 0) ;   /* Error */
+#else
+                           ((USBD_P_SOF_Event   != 0) ? (1UL << 7) : 0) |   /* SOF */
+                           ((USBD_P_Error_Event != 0) ? (1UL << 1) : 0) ;   /* Error */
+#endif
+    USBD_Reset();
+    USBD_Intr(1);
+}
+
+
+/*
+ *  USB Device Connect Function
+ *   Called by the User to Connect/Disconnect USB Device
+ *    Parameters:      con:   Connect/Disconnect
+ *    Return Value:    None
+ */
+
+void USBD_Connect(uint32_t con)
+{
+    if (con) {
+        USBHS->USBCMD |= 1;            /* run */
+    } else {
+        USBHS->USBCMD &= ~1;           /* stop */
+    }
+}
+
+
+/*
+ *  USB Device Reset Function
+ *   Called automatically on USB Device Reset
+ *    Return Value:    None
+ */
+
+void USBD_Reset(void)
+{
+    uint32_t i;
+    uint8_t *ptr;
+    cmpl_pnd = 0;
+
+    for (i = 1; i < USBD_EP_NUM + 1; i++) {
+        ENDPTCTRL(i) &= ~((1UL << 7) | (1UL << 23));
+    }
+
+    /* clear interrupts */
+    USBHS->ENDPTNAK       = 0xFFFFFFFF;
+    USBHS->ENDPTNAKEN     = 0;
+    USBHS->USBSTS       = 0xFFFFFFFF;
+    USBHS->EPSETUPSR = USBHS->EPSETUPSR;
+    USBHS->EPCOMPLETE  = USBHS->EPCOMPLETE;
+
+    while (USBHS->EPPRIME);
+
+    USBHS->EPFLUSH = 0xFFFFFFFF;
+
+    while (USBHS->EPFLUSH);
+
+    USBHS->USBCMD &= ~0x00FF0000;    /* immediate intrrupt treshold */
+    /* clear endpoint queue heads */
+    ptr = (uint8_t *)EPQHx;
+
+    for (i = 0; i < sizeof(EPQHx); i++) {
+        ptr[i] = 0;
+    }
+
+    /* clear endpoint transfer descriptors */
+    ptr = (uint8_t *)dTDx;
+
+    for (i = 0; i < sizeof(dTDx); i++) {
+        ptr[i] = 0;
+    }
+
+    Ep[EP_OUT_IDX(0)].maxPacket  = USBD_MAX_PACKET0;
+    Ep[EP_OUT_IDX(0)].buf        = EPBufPool;
+    BufUsed                      = USBD_MAX_PACKET0;
+    Ep[EP_IN_IDX(0)].maxPacket   = USBD_MAX_PACKET0;
+    Ep[EP_IN_IDX(0)].buf         = &(EPBufPool[BufUsed]);
+    BufUsed                     += USBD_MAX_PACKET0;
+    dTDx[EP_OUT_IDX(0)].next_dTD = 1;
+    dTDx[EP_IN_IDX(0)].next_dTD = 1;
+    dTDx[EP_OUT_IDX(0)].dTD_token = (USBD_MAX_PACKET0 << 16) | /* total bytes */
+                                    (1UL << 15);               /* int on compl */
+    dTDx[EP_IN_IDX(0)].dTD_token = (USBD_MAX_PACKET0 << 16) |  /* total bytes */
+                                   (1UL << 15);                /* int on compl */
+    EPQHx[EP_OUT_IDX(0)].next_dTD = (uint32_t) &dTDx[EP_OUT_IDX(0)];
+    EPQHx[EP_IN_IDX(0)].next_dTD = (uint32_t) &dTDx[EP_IN_IDX(0)];
+    EPQHx[EP_OUT_IDX(0)].cap = ((USBD_MAX_PACKET0 & 0x0EFF) << 16) |
+                               (1UL << 29) |
+                               (1UL << 15);                    /* int on setup */
+    EPQHx[EP_IN_IDX(0)].cap = (USBD_MAX_PACKET0 << 16) |
+                              (1UL << 29) |
+                              (1UL << 15);                    /* int on setup */
+    USBHS->EPLISTADDR = (uint32_t)EPQHx;
+    USBHS->USBMODE |= (1UL << 3);    /* Setup lockouts off */
+    USBHS->EPCR0 = 0x00C000C0;
+    USBD_PrimeEp(0, Ep[EP_OUT_IDX(0)].maxPacket);
+}
+
+
+/*
+ *  USB Device Suspend Function
+ *   Called automatically on USB Device Suspend
+ *    Return Value:    None
+ */
+
+void USBD_Suspend(void)
+{
+    /* Performed by Hardware */
+}
+
+
+/*
+ *  USB Device Resume Function
+ *   Called automatically on USB Device Resume
+ *    Return Value:    None
+ */
+
+void USBD_Resume(void)
+{
+    /* Performed by Hardware */
+}
+
+
+/*
+ *  USB Device Remote Wakeup Function
+ *   Called automatically on USB Device Remote Wakeup
+ *    Return Value:    None
+ */
+
+void USBD_WakeUp(void)
+{
+    USBHS->PORTSC1 |= (1UL << 6);
+}
+
+
+/*
+ *  USB Device Remote Wakeup Configuration Function
+ *    Parameters:      cfg:   Device Enable/Disable
+ *    Return Value:    None
+ */
+
+void USBD_WakeUpCfg(uint32_t cfg)
+{
+    /* Not needed */
+}
+
+
+/*
+ *  USB Device Set Address Function
+ *    Parameters:      adr:   USB Device Address
+ *    Return Value:    None
+ */
+
+void USBD_SetAddress(uint32_t adr, uint32_t setup)
+{
+    if (setup == 0) {
+        USBHS->DEVICEADDR  = (adr << 25);
+        USBHS->DEVICEADDR |= (1UL << 24);
+    }
+}
+
+
+/*
+ *  USB Device Configure Function
+ *    Parameters:      cfg:   Device Configure/Deconfigure
+ *    Return Value:    None
+ */
+
+void USBD_Configure(uint32_t cfg)
+{
+    uint32_t i;
+
+    if (!cfg) {
+        for (i = 2; i < (2 * (USBD_EP_NUM + 1)); i++) {
+            Ep[i].buf = 0;
+            Ep[i].maxPacket = 0;
+        }
+
+        BufUsed = 2 * USBD_MAX_PACKET0;
+    }
+}
+
+
+/*
+ *  Configure USB Device Endpoint according to Descriptor
+ *    Parameters:      pEPD:  Pointer to Device Endpoint Descriptor
+ *    Return Value:    None
+ */
+
+void USBD_ConfigEP(USB_ENDPOINT_DESCRIPTOR *pEPD)
+{
+    uint32_t num, val, type, idx;
+
+    if ((pEPD->bEndpointAddress & USB_ENDPOINT_DIRECTION_MASK)) {
+        val = 16;
+        num = pEPD->bEndpointAddress & ~0x80;
+        idx = EP_IN_IDX(num);
+
+    } else {
+        val = 0;
+        num = pEPD->bEndpointAddress;
+        idx = EP_OUT_IDX(num);
+    }
+
+    type = pEPD->bmAttributes & USB_ENDPOINT_TYPE_MASK;
+
+    if (!(Ep[idx].buf)) {
+        Ep[idx].buf          =  &(EPBufPool[BufUsed]);
+        Ep[idx].maxPacket    =  pEPD->wMaxPacketSize;
+        BufUsed             +=  pEPD->wMaxPacketSize;
+
+        /* Isochronous endpoint */
+        if (type == USB_ENDPOINT_TYPE_ISOCHRONOUS) {
+            IsoEp |= (1UL << (num + val));
+        }
+    }
+
+    dTDx[idx].buf[0]    = (uint32_t)(Ep[idx].buf);
+    dTDx[idx].next_dTD  =  1;
+    EPQHx[idx].cap      = (Ep[idx].maxPacket << 16) |
+                          (1UL               << 29);
+    ENDPTCTRL(num)  &= ~(0xFFFF << val);
+    ENDPTCTRL(num)  |= ((type << 2) << val) |
+                       ((1UL  << 6) << val);   /* Data toogle reset */
+}
+
+
+/*
+ *  Set Direction for USB Device Control Endpoint
+ *    Parameters:      dir:   Out (dir == 0), In (dir <> 0)
+ *    Return Value:    None
+ */
+
+void USBD_DirCtrlEP(uint32_t dir)
+{
+    /* Not needed */
+}
+
+
+/*
+ *  Enable USB Device Endpoint
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *    Return Value:    None
+ */
+
+void USBD_EnableEP(uint32_t EPNum)
+{
+    if (EPNum & 0x80) {
+        EPNum &= 0x7F;
+        ENDPTCTRL(EPNum) |= (1UL << 23);    /* EP enabled */
+    } else {
+        ENDPTCTRL(EPNum) |= (1UL << 7);     /* EP enabled */
+    }
+}
+
+
+/*
+ *  Disable USB Device Endpoint
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *    Return Value:    None
+ */
+
+void USBD_DisableEP(uint32_t EPNum)
+{
+    if (EPNum & 0x80) {
+        EPNum &= 0x7F;
+        ENDPTCTRL(EPNum) &= ~(1UL << 23);   /* EP disabled */
+    } else {
+        ENDPTCTRL(EPNum)     &= ~(1UL << 7); /* EP disabled */
+    }
+}
+
+
+/*
+ *  Reset USB Device Endpoint
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *    Return Value:    None
+ */
+
+void USBD_ResetEP(uint32_t EPNum)
+{
+    if (EPNum & 0x80) {
+        EPNum &= 0x7F;
+        EPQHx[EP_IN_IDX(EPNum)].dTD_token &= 0xC0;
+        USBHS->EPFLUSH = (1UL << (EPNum + 16));  /* flush endpoint */
+
+        while (USBHS->EPFLUSH & (1UL << (EPNum + 16)));
+
+        ENDPTCTRL(EPNum) |= (1UL << 22);    /* data toggle reset */
+
+    } else {
+        EPQHx[EP_OUT_IDX(EPNum)].dTD_token &= 0xC0;
+        USBHS->EPFLUSH = (1UL << EPNum);         /* flush endpoint */
+
+        while (USBHS->EPFLUSH & (1UL << EPNum));
+
+        ENDPTCTRL(EPNum) |= (1UL << 6);     /* data toggle reset */
+        USBD_PrimeEp(EPNum, Ep[EP_OUT_IDX(EPNum)].maxPacket);
+    }
+}
+
+
+/*
+ *  Set Stall for USB Device Endpoint
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *    Return Value:    None
+ */
+
+void USBD_SetStallEP(uint32_t EPNum)
+{
+    if (EPNum & 0x80) {
+        EPNum &= 0x7F;
+        ENDPTCTRL(EPNum) |= (1UL << 16);    /* IN endpoint stall */
+    } else {
+        ENDPTCTRL(EPNum) |= (1UL << 0);     /* OUT endpoint stall */
+    }
+}
+
+
+/*
+ *  Clear Stall for USB Device Endpoint
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *    Return Value:    None
+ */
+
+void USBD_ClrStallEP(uint32_t EPNum)
+{
+    if (EPNum & 0x80) {
+        EPNum &= 0x7F;
+        ENDPTCTRL(EPNum) &= ~(1UL << 16);   /* clear stall */
+        ENDPTCTRL(EPNum) |= (1UL << 22);    /* data toggle reset */
+
+        while (ENDPTCTRL(EPNum) & (1UL << 16));
+
+        USBD_ResetEP(EPNum | 0x80);
+
+    } else {
+        ENDPTCTRL(EPNum) &= ~(1UL << 0);    /* clear stall */
+        ENDPTCTRL(EPNum) |= (1UL << 6);     /* data toggle reset */
+    }
+}
+
+
+/*
+ *  Clear USB Device Endpoint Buffer
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *    Return Value:    None
+ */
+
+void USBD_ClearEPBuf(uint32_t EPNum)
+{
+}
+
+
+/*
+ *  USB Device Prime endpoint function
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *                     cnt:   Bytes to transfer/receive
+ *    Return Value:    None
+ */
+
+void USBD_PrimeEp(uint32_t EPNum, uint32_t cnt)
+{
+    uint32_t idx, val;
+
+    /* IN endpoint */
+    if (EPNum & 0x80) {
+        EPNum &= 0x7F;
+        idx    = EP_IN_IDX(EPNum);
+        val    = (1UL << (EPNum + 16));
+    }
+
+    /* OUT endpoint */
+    else {
+        val    = (1UL << EPNum);
+        idx    = EP_OUT_IDX(EPNum);
+    }
+
+    dTDx[idx].buf[0]    = (uint32_t)(Ep[idx].buf);
+    dTDx[idx].next_dTD  = 1;
+
+    if (IsoEp & val) {
+        if (Ep[idx].maxPacket <= cnt) {
+            dTDx[idx].dTD_token = (1 << 10);             /* MultO = 1 */
+
+        } else if ((Ep[idx].maxPacket * 2) <= cnt) {
+            dTDx[idx].dTD_token = (2 << 10);             /* MultO = 2 */
+
+        } else {
+            dTDx[idx].dTD_token = (3 << 10);             /* MultO = 3 */
+        }
+
+    } else {
+        dTDx[idx].dTD_token = 0;
+    }
+
+    dTDx[idx].dTD_token  |= (cnt << 16) |         /* bytes to transfer */
+                            (1UL << 15) |         /* int on complete */
+                            0x80;                 /* status - active */
+    EPQHx[idx].next_dTD   = (uint32_t)(&dTDx[idx]);
+    EPQHx[idx].dTD_token &= ~0xC0;
+    USBHS->EPPRIME = (val);
+
+    while ((USBHS->EPPRIME & val));
+}
+
+
+/*
+ *  Read USB Device Endpoint Data
+ *    Parameters:      EPNum: Device Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *                     pData: Pointer to Data Buffer
+ *    Return Value:    Number of bytes read
+ */
+
+uint32_t USBD_ReadEP(uint32_t EPNum, uint8_t *pData, uint32_t size)
+{
+    uint32_t cnt  = 0;
+    uint32_t i;
+
+    /* Setup packet */
+    if ((USBHS->EPSETUPSR & 1) && (!EPNum)) {
+        USBHS->EPSETUPSR = 1;
+
+        while (USBHS->EPSETUPSR & 1);
+
+        do {
+            *((__packed uint32_t *) pData)      = EPQHx[EP_OUT_IDX(0)].setup[0];
+            *((__packed uint32_t *)(pData + 4)) = EPQHx[EP_OUT_IDX(0)].setup[1];
+            cnt = 8;
+            USBHS->USBCMD |= (1UL << 13);
+        } while (!(USBHS->USBCMD & (1UL << 13)));
+
+        USBHS->USBCMD &= (~(1UL << 13));
+        USBHS->EPFLUSH = (1UL << EPNum) | (1UL << (EPNum + 16));
+
+        while (USBHS->EPFLUSH & ((1UL << (EPNum + 16)) | (1UL << EPNum)));
+
+        while (USBHS->EPSETUPSR & 1);
+
+        USBD_PrimeEp(EPNum, Ep[EP_OUT_IDX(EPNum)].maxPacket);
+    }
+
+    /* OUT Packet */
+    else {
+        if (Ep[EP_OUT_IDX(EPNum)].buf) {
+            cnt = Ep[EP_OUT_IDX(EPNum)].maxPacket -
+                  ((dTDx[EP_OUT_IDX(EPNum)].dTD_token >> 16) & 0x7FFF);
+
+            for (i = 0; i < cnt; i++) {
+                pData[i] =  Ep[EP_OUT_IDX(EPNum)].buf[i];
+            }
+        }
+
+        USBHS->EPCOMPLETE = (1UL << EPNum);
+        cmpl_pnd &= ~(1UL << EPNum);
+        USBD_PrimeEp(EPNum, Ep[EP_OUT_IDX(EPNum)].maxPacket);
+    }
+
+    return (cnt);
+}
+
+
+/*
+ *  Write USB Device Endpoint Data
+ *    Parameters:      EPNum: Endpoint Number
+ *                       EPNum.0..3: Address
+ *                       EPNum.7:    Dir
+ *                     pData: Pointer to Data Buffer
+ *                     cnt:   Number of bytes to write
+ *    Return Value:    Number of bytes written
+ */
+
+uint32_t USBD_WriteEP(uint32_t EPNum, uint8_t *pData, uint32_t cnt)
+{
+    uint32_t i;
+    EPNum &= 0x7f;
+
+    for (i = 0; i < cnt; i++) {
+        Ep[EP_IN_IDX(EPNum)].buf[i] = pData[i];
+    }
+
+    USBD_PrimeEp(EPNum | 0x80, cnt);
+    return (cnt);
+}
+
+
+/*
+ *  Get USB Device Last Frame Number
+ *    Parameters:      None
+ *    Return Value:    Frame Number
+ */
+
+uint32_t USBD_GetFrame(void)
+{
+    return ((USBHS->FRINDEX >> 3) & 0x0FFF);
+}
+
+
+#ifdef __RTX
+uint32_t LastError;                     /* Last Error */
+
+/*
+ *  Get USB Device Last Error Code
+ *    Parameters:      None
+ *    Return Value:    Error Code
+ */
+
+uint32_t USBD_GetError(void)
+{
+    return (LastError);
+}
+#endif
+
+
+/*
+ *  USB Device Interrupt Service Routine
+ */
+void USBHS_IRQHandler(void)
+{
+    NVIC_DisableIRQ(USBHS_IRQn);
+    USBD_SignalHandler();
+}
+
+/*
+ *  USB Device Interrupt Service Routine
+ */
+
+void USBD_Handler(void)
+{
+    uint32_t sts, cmpl, num;
+    sts  = USBHS->USBSTS & USBHS->USBINTR;
+    cmpl = USBHS->EPCOMPLETE;
+    USBHS->USBSTS = sts;                     /* clear interupt flags */
+
+    /* reset interrupt */
+    if (sts & (1UL << 6)) {
+        USBD_Reset();
+        usbd_reset_core();
+#ifdef __RTX
+
+        if (USBD_RTX_DevTask) {
+            isr_evt_set(USBD_EVT_RESET, USBD_RTX_DevTask);
+        }
+
+#else
+
+        if (USBD_P_Reset_Event) {
+            USBD_P_Reset_Event();
+        }
+
+#endif
+    }
+
+    /* suspend interrupt */
+    if (sts & (1UL << 8)) {
+        USBD_Suspend();
+#ifdef __RTX
+
+        if (USBD_RTX_DevTask) {
+            isr_evt_set(USBD_EVT_SUSPEND, USBD_RTX_DevTask);
+        }
+
+#else
+
+        if (USBD_P_Suspend_Event) {
+            USBD_P_Suspend_Event();
+        }
+
+#endif
+    }
+
+    /* SOF interrupt */
+    if (sts & (1UL << 7)) {
+        if (IsoEp) {
+            for (num = 0; num < USBD_EP_NUM + 1; num++) {
+                if (IsoEp & (1UL << num)) {
+                    USBD_PrimeEp(num, Ep[EP_OUT_IDX(num)].maxPacket);
+                }
+            }
+
+        } else {
+#ifdef __RTX
+
+            if (USBD_RTX_DevTask) {
+                isr_evt_set(USBD_EVT_SOF, USBD_RTX_DevTask);
+            }
+
+#else
+
+            if (USBD_P_SOF_Event) {
+                USBD_P_SOF_Event();
+            }
+
+#endif
+        }
+    }
+
+    /* port change detect interrupt */
+    if (sts & (1UL << 2)) {
+        if (((USBHS->PORTSC1 >> 26) & 0x03) == 2) {
+            USBD_HighSpeed = __TRUE;
+        }
+
+        USBD_Resume();
+#ifdef __RTX
+
+        if (USBD_RTX_DevTask) {
+            isr_evt_set(USBD_EVT_RESUME,  USBD_RTX_DevTask);
+        }
+
+#else
+
+        if (USBD_P_Resume_Event) {
+            USBD_P_Resume_Event();
+        }
+
+#endif
+    }
+
+    /* USB interrupt - completed transfer */
+    if (sts & 1) {
+        /* Setup Packet */
+        if (USBHS->EPSETUPSR) {
+#ifdef __RTX
+
+            if (USBD_RTX_EPTask[0]) {
+                isr_evt_set(USBD_EVT_SETUP, USBD_RTX_EPTask[0]);
+            }
+
+#else
+
+            if (USBD_P_EP[0]) {
+                USBD_P_EP[0](USBD_EVT_SETUP);
+            }
+
+#endif
+        }
+
+        /* IN Packet */
+        if (cmpl & (0x3F << 16)) {
+            for (num = 0; num < USBD_EP_NUM + 1; num++) {
+                if (((cmpl >> 16) & 0x3F) & (1UL << num)) {
+                    USBHS->EPCOMPLETE = (1UL << (num + 16));    /* Clear completed */
+#ifdef __RTX
+
+                    if (USBD_RTX_EPTask[num]) {
+                        isr_evt_set(USBD_EVT_IN,  USBD_RTX_EPTask[num]);
+                    }
+
+#else
+
+                    if (USBD_P_EP[num]) {
+                        USBD_P_EP[num](USBD_EVT_IN);
+                    }
+
+#endif
+                }
+            }
+        }
+
+        /* OUT Packet */
+        if (cmpl & 0x3F) {
+            for (num = 0; num < USBD_EP_NUM + 1; num++) {
+                if ((cmpl ^ cmpl_pnd) & cmpl & (1UL << num)) {
+                    cmpl_pnd |= 1UL << num;
+#ifdef __RTX
+
+                    if (USBD_RTX_EPTask[num]) {
+                        isr_evt_set(USBD_EVT_OUT, USBD_RTX_EPTask[num]);
+
+                    } else if (IsoEp & (1UL << num)) {
+                        if (USBD_RTX_DevTask) {
+                            isr_evt_set(USBD_EVT_SOF, USBD_RTX_DevTask);
+                        }
+                    }
+
+#else
+
+                    if (USBD_P_EP[num]) {
+                        USBD_P_EP[num](USBD_EVT_OUT);
+
+                    } else if (IsoEp & (1UL << num)) {
+                        if (USBD_P_SOF_Event) {
+                            USBD_P_SOF_Event();
+                        }
+                    }
+
+#endif
+                }
+            }
+        }
+    }
+
+    /* error interrupt */
+    if (sts & (1UL << 1)) {
+        for (num = 0; num < USBD_EP_NUM + 1; num++) {
+            if (cmpl & (1UL << num)) {
+#ifdef __RTX
+
+                if (USBD_RTX_DevTask) {
+                    LastError = dTDx[EP_OUT_IDX(num)].dTD_token & 0xE8;
+                    isr_evt_set(USBD_EVT_ERROR, USBD_RTX_DevTask);
+                }
+
+#else
+
+                if (USBD_P_Error_Event) {
+                    USBD_P_Error_Event(dTDx[EP_OUT_IDX(num)].dTD_token & 0xE8);
+                }
+
+#endif
+            }
+
+            if (cmpl & (1UL << (num + 16))) {
+#ifdef __RTX
+
+                if (USBD_RTX_DevTask) {
+                    LastError = dTDx[EP_IN_IDX(num)].dTD_token & 0xE8;
+                    isr_evt_set(USBD_EVT_ERROR, USBD_RTX_DevTask);
+                }
+
+#else
+
+                if (USBD_P_Error_Event) {
+                    USBD_P_Error_Event(dTDx[EP_IN_IDX(num)].dTD_token & 0xE8);
+                }
+
+#endif
+            }
+        }
+    }
+
+    NVIC_EnableIRQ(USBHS_IRQn);
+}