[clinton/Smoothieware.git] / src / libs / USBDevice / USBDevice / USBHAL_LPC17.cpp

/* Copyright (c) 2010-2011 mbed.org, MIT License\r
*\r
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software\r
* and associated documentation files (the "Software"), to deal in the Software without\r
* restriction, including without limitation the rights to use, copy, modify, merge, publish,\r
* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the\r
* Software is furnished to do so, subject to the following conditions:\r
*\r
* The above copyright notice and this permission notice shall be included in all copies or\r
* substantial portions of the Software.\r
*\r
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING\r
* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\r
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
*/\r
\r
#if defined(TARGET_LPC1768) || defined (__LPC17XX__)\r
\r
// void setled(int, bool);\r
#define setled(a, b) do {} while (0)\r
\r
#include "USBHAL.h"\r
\r
#include <cstdio>\r
\r
#include <LPC17xx.h>\r
\r
#ifdef MBED\r
    #include <score_cm3.h>\r
#else\r
    #include <lpc17xx_nvic.h>\r
#endif\r
\r
#include "debug.h"\r
\r
#ifndef ENTER_ISR\r
    #define ENTER_ISR() do {} while (0)\r
#endif\r
\r
#ifndef LEAVE_ISR\r
    #define LEAVE_ISR() do {} while (0)\r
#endif\r
\r
#define iprintf(...)\r
\r
// Get endpoint direction\r
#define IN_EP(endpoint)     ((endpoint) & 1U ? true : false)\r
#define OUT_EP(endpoint)    ((endpoint) & 1U ? false : true)\r
\r
#define  IN_BEP(endpoint)    ((endpoint) & 0x80 ? true : false)\r
#define OUT_BEP(endpoint)    ((endpoint) & 0x80 ? false : true)\r
\r
// Convert physical endpoint number to register bit\r
#define EP(endpoint) (1UL<<endpoint)\r
\r
#define ISOCHRONOUS_ENDPOINTS ((1UL << 3) | (1UL << 6) | (1UL << 9) | (1UL << 12))\r
\r
#define IS_ISOCHRONOUS(bEP) ((1UL << (bEP & 0x0F)) & ISOCHRONOUS_ENDPOINTS)\r
\r
// Power Control for Peripherals register\r
#define PCUSB      (1UL<<31)\r
\r
// USB Clock Control register\r
#define DEV_CLK_EN (1UL<<1)\r
#define AHB_CLK_EN (1UL<<4)\r
\r
// USB Clock Status register\r
#define DEV_CLK_ON (1UL<<1)\r
#define AHB_CLK_ON (1UL<<4)\r
\r
// USB Device Interupt registers\r
#define FRAME      (1UL<<0)\r
#define EP_FAST    (1UL<<1)\r
#define EP_SLOW    (1UL<<2)\r
#define DEV_STAT   (1UL<<3)\r
#define CCEMPTY    (1UL<<4)\r
#define CDFULL     (1UL<<5)\r
#define RxENDPKT   (1UL<<6)\r
#define TxENDPKT   (1UL<<7)\r
#define EP_RLZED   (1UL<<8)\r
#define ERR_INT    (1UL<<9)\r
\r
/* USBRxPLen bits */\r
#define PKT_LNGTH                   (1<<0)\r
#define PKT_LNGTH_MASK              0x3FF\r
#define DV                          (1<<10)\r
#define PKT_RDY                     (1<<11)\r
\r
/* Select Endpoint command read bits */\r
#define EPSTAT_FE                   (1<<0)\r
#define EPSTAT_ST                   (1<<1)\r
#define EPSTAT_STP                  (1<<2)\r
#define EPSTAT_PO                   (1<<3)\r
#define EPSTAT_EPN                  (1<<4)\r
#define EPSTAT_B1FULL               (1<<5)\r
#define EPSTAT_B2FULL               (1<<6)\r
\r
// endpoint status sent through callback\r
#define EP_STATUS_DATA      (1<<0)      /**< EP has data */\r
#define EP_STATUS_STALLED   (1<<1)      /**< EP is stalled */\r
#define EP_STATUS_SETUP     (1<<2)      /**< EP received setup packet */\r
#define EP_STATUS_ERROR     (1<<3)      /**< EP data was overwritten by setup packet */\r
#define EP_STATUS_NACKED    (1<<4)      /**< EP sent NAK */\r
\r
// USB Control register\r
#define RD_EN (1<<0)\r
#define WR_EN (1<<1)\r
#define LOG_ENDPOINT(endpoint) ((endpoint>>1)<<2)\r
\r
// USB Receive Packet Length register\r
// #define DV      (1UL<<10)\r
// #define PKT_RDY (1UL<<11)\r
// #define PKT_LNGTH_MASK (0x3ff)\r
\r
// Serial Interface Engine (SIE)\r
#define SIE_WRITE   (0x01)\r
#define SIE_READ    (0x02)\r
#define SIE_COMMAND (0x05)\r
#define SIE_CMD_CODE(phase, data) ((phase<<8)|(data<<16))\r
\r
// SIE Command codes\r
#define SIE_CMD_SET_ADDRESS        (0xD0)\r
#define SIE_CMD_CONFIGURE_DEVICE   (0xD8)\r
#define SIE_CMD_SET_MODE           (0xF3)\r
#define SIE_CMD_READ_FRAME_NUMBER  (0xF5)\r
#define SIE_CMD_READ_TEST_REGISTER (0xFD)\r
#define SIE_CMD_SET_DEVICE_STATUS  (0xFE)\r
#define SIE_CMD_GET_DEVICE_STATUS  (0xFE)\r
#define SIE_CMD_GET_ERROR_CODE     (0xFF)\r
#define SIE_CMD_READ_ERROR_STATUS  (0xFB)\r
\r
#define SIE_CMD_SELECT_ENDPOINT(endpoint)                 (0x00+endpoint)\r
#define SIE_CMD_SELECT_ENDPOINT_CLEAR_INTERRUPT(endpoint) (0x40+endpoint)\r
#define SIE_CMD_SET_ENDPOINT_STATUS(endpoint)             (0x40+endpoint)\r
\r
#define SIE_CMD_CLEAR_BUFFER    (0xF2)\r
#define SIE_CMD_VALIDATE_BUFFER (0xFA)\r
\r
// SIE Device Status register\r
#define SIE_DS_CON    (1<<0)\r
#define SIE_DS_CON_CH (1<<1)\r
#define SIE_DS_SUS    (1<<2)\r
#define SIE_DS_SUS_CH (1<<3)\r
#define SIE_DS_RST    (1<<4)\r
\r
// SIE Device Set Address register\r
#define SIE_DSA_DEV_EN  (1<<7)\r
\r
// SIE Configue Device register\r
#define SIE_CONF_DEVICE (1<<0)\r
\r
// Select Endpoint register\r
#define SIE_SE_FE       (1<<0)\r
#define SIE_SE_ST       (1<<1)\r
#define SIE_SE_STP      (1<<2)\r
#define SIE_SE_PO       (1<<3)\r
#define SIE_SE_EPN      (1<<4)\r
#define SIE_SE_B_1_FULL (1<<5)\r
#define SIE_SE_B_2_FULL (1<<6)\r
\r
// Set Endpoint Status command\r
#define SIE_SES_ST      (1<<0)\r
#define SIE_SES_DA      (1<<5)\r
#define SIE_SES_RF_MO   (1<<6)\r
#define SIE_SES_CND_ST  (1<<7)\r
\r
// endpoint modes\r
#define SIE_MODE_AP_CLK     (1<<0)\r
#define SIE_MODE_INAK_CI    (1<<1)\r
#define SIE_MODE_INAK_CO    (1<<2)\r
#define SIE_MODE_INAK_II    (1<<3)\r
#define SIE_MODE_INAK_IO    (1<<4)\r
#define SIE_MODE_INAK_BI    (1<<5)\r
#define SIE_MODE_INAK_BO    (1<<6)\r
\r
USBHAL * USBHAL::instance;\r
\r
// volatile uint32_t epComplete;\r
volatile uint32_t USBEpIntEn;\r
uint32_t endpointStallState;\r
\r
static void SIECommand(uint32_t command) {\r
    // The command phase of a SIE transaction\r
    LPC_USB->USBDevIntClr = CCEMPTY;\r
    LPC_USB->USBCmdCode = SIE_CMD_CODE(SIE_COMMAND, command);\r
    setled(4, 1); while (!(LPC_USB->USBDevIntSt & CCEMPTY)); setled(4, 0);\r
}\r
\r
static void SIEWriteData(uint8_t data) {\r
    // The data write phase of a SIE transaction\r
    LPC_USB->USBDevIntClr = CCEMPTY;\r
    LPC_USB->USBCmdCode = SIE_CMD_CODE(SIE_WRITE, data);\r
    setled(4, 1); while (!(LPC_USB->USBDevIntSt & CCEMPTY)); setled(4, 0);\r
}\r
\r
static uint8_t SIEReadData(uint32_t command) {\r
    // The data read phase of a SIE transaction\r
    LPC_USB->USBDevIntClr = CDFULL;\r
    LPC_USB->USBCmdCode = SIE_CMD_CODE(SIE_READ, command);\r
    setled(4, 1); while (!(LPC_USB->USBDevIntSt & CDFULL)); setled(4, 0);\r
    return (uint8_t)LPC_USB->USBCmdData;\r
}\r
\r
static void SIEsetDeviceStatus(uint8_t status) {\r
    // Write SIE device status register\r
//     iprintf("SIEsetDeviceStatus: %02X\n", status);\r
    SIECommand(SIE_CMD_SET_DEVICE_STATUS);\r
//     iprintf("SIEsetDeviceStatus Write\n");\r
    SIEWriteData(status);\r
//     iprintf("SIEsetDeviceStatus OK\n");\r
}\r
\r
static uint8_t SIEgetDeviceStatus(void) {\r
    // Read SIE device status register\r
    SIECommand(SIE_CMD_GET_DEVICE_STATUS);\r
    return SIEReadData(SIE_CMD_GET_DEVICE_STATUS);\r
}\r
\r
static void SIEsetMode(uint8_t mode) {\r
    SIECommand(SIE_CMD_SET_MODE);\r
    SIEWriteData(mode);\r
}\r
\r
static void SIEsetAddress(uint8_t address) {\r
    // Write SIE device address register\r
    SIECommand(SIE_CMD_SET_ADDRESS);\r
    SIEWriteData((address & 0x7f) | SIE_DSA_DEV_EN);\r
}\r
\r
static uint8_t SIEselectEndpoint(uint8_t bEP) {\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // SIE select endpoint command\r
    SIECommand(SIE_CMD_SELECT_ENDPOINT(endpoint));\r
    return SIEReadData(SIE_CMD_SELECT_ENDPOINT(endpoint));\r
}\r
\r
static uint8_t SIEclearBuffer(void) {\r
    // SIE clear buffer command\r
    SIECommand(SIE_CMD_CLEAR_BUFFER);\r
    return SIEReadData(SIE_CMD_CLEAR_BUFFER);\r
}\r
\r
static void SIEvalidateBuffer(void) {\r
    // SIE validate buffer command\r
    SIECommand(SIE_CMD_VALIDATE_BUFFER);\r
}\r
\r
static void SIEsetEndpointStatus(uint8_t bEP, uint8_t status) {\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // SIE set endpoint status command\r
    SIECommand(SIE_CMD_SET_ENDPOINT_STATUS(endpoint));\r
    SIEWriteData(status);\r
}\r
\r
static uint16_t SIEgetFrameNumber(void) __attribute__ ((unused));\r
static uint16_t SIEgetFrameNumber(void) {\r
    // Read current frame number\r
    uint16_t lowByte;\r
    uint16_t highByte;\r
\r
    SIECommand(SIE_CMD_READ_FRAME_NUMBER);\r
    lowByte = SIEReadData(SIE_CMD_READ_FRAME_NUMBER);\r
    highByte = SIEReadData(SIE_CMD_READ_FRAME_NUMBER);\r
\r
    return (highByte << 8) | lowByte;\r
}\r
\r
static void SIEconfigureDevice(void) {\r
    // SIE Configure device command\r
    SIECommand(SIE_CMD_CONFIGURE_DEVICE);\r
    SIEWriteData(SIE_CONF_DEVICE);\r
}\r
\r
static void SIEunconfigureDevice(void) {\r
    // SIE Configure device command\r
    SIECommand(SIE_CMD_CONFIGURE_DEVICE);\r
    SIEWriteData(0);\r
}\r
\r
static void SIEconnect(void) {\r
    // Connect USB device\r
    uint8_t status;\r
\r
    status = SIEgetDeviceStatus();\r
//     iprintf("USBHAL::SIEconnect status is %02X\n", status);\r
    SIEsetDeviceStatus(status | SIE_DS_CON);\r
//     iprintf("USBHAL::SIEconnect ok\n");\r
}\r
\r
\r
static void SIEdisconnect(void) {\r
    // Disconnect USB device\r
    uint8_t status;\r
\r
    status = SIEgetDeviceStatus();\r
    SIEsetDeviceStatus(status & ~SIE_DS_CON);\r
}\r
\r
\r
static uint8_t selectEndpointClearInterrupt(uint8_t bEP) {\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // Implemented using using EP_INT_CL\r
    LPC_USB->USBEpIntClr = EP(endpoint);\r
    setled(4, 1); while (!(LPC_USB->USBDevIntSt & CDFULL)); setled(4, 0);\r
    return (uint8_t)LPC_USB->USBCmdData;\r
}\r
\r
static void enableEndpointEvent(uint8_t bEP) {\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // Enable an endpoint interrupt\r
    LPC_USB->USBEpIntEn |= EP(endpoint);\r
}\r
\r
static void disableEndpointEvent(uint8_t bEP) __attribute__ ((unused));\r
static void disableEndpointEvent(uint8_t bEP) {\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // Disable an endpoint interrupt\r
    LPC_USB->USBEpIntEn &= ~EP(endpoint);\r
}\r
\r
static volatile uint32_t __attribute__((used)) dummyRead;\r
\r
\r
uint32_t USBHAL::endpointReadcore(uint8_t bEP, uint8_t *buffer)\r
{\r
    // Read from an OUT endpoint\r
    uint32_t size;\r
    uint32_t i;\r
    uint32_t data = 0;\r
    uint8_t offset;\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    uint8_t irq = NVIC_GetActive(USB_IRQn);\r
    NVIC_DisableIRQ(USB_IRQn);\r
\r
//     iprintf("epReadCore 0x%02X = %d, 0x%02X\n", bEP, endpoint, LOG_ENDPOINT(endpoint));\r
\r
    LPC_USB->USBCtrl = LOG_ENDPOINT(endpoint) | RD_EN;\r
\r
//     iprintf("0x%02lX\n", LPC_USB->USBCtrl);\r
\r
    setled(4, 1); while (!(LPC_USB->USBRxPLen & PKT_RDY))\r
    {\r
//         iprintf("ep not ready, Waiting for data...\n");\r
    }\r
    setled(4, 0);\r
\r
//     iprintf("0x%02lX 0x%02lX\n", LPC_USB->USBCtrl, LPC_USB->USBRxPLen);\r
\r
    size = LPC_USB->USBRxPLen & PKT_LNGTH_MASK;\r
\r
    if ((IS_ISOCHRONOUS(bEP) == 0) && (size > 64))\r
    {\r
//         iprintf("BOGUS SIZE FOR EP 0x%02X! Got %ld, max is 64!\n", bEP, size);\r
        size = 64;\r
    }\r
\r
//     iprintf("Reading %ld bytes\n", size);\r
\r
    offset = 0;\r
\r
    if (size > 0)\r
    {\r
        for (i = 0; i < size; i++)\r
        {\r
            if (offset==0)\r
            {\r
                // Fetch up to four bytes of data as a word\r
                data = LPC_USB->USBRxData;\r
            }\r
\r
            // extract a byte\r
            *buffer = (data>>offset) & 0xff;\r
            buffer++;\r
\r
            // move on to the next byte\r
            offset = (offset + 8) & 24;\r
        }\r
    } else\r
    {\r
        dummyRead = LPC_USB->USBRxData;\r
    }\r
\r
    setled(4, 1); while ((LPC_USB->USBDevIntSt & RxENDPKT) == 0)\r
        dummyRead = LPC_USB->USBRxData;\r
    setled(4, 0);\r
\r
//     iprintf("Read %ld\n", size);\r
\r
    if (can_transfer[endpoint] != 0)\r
        can_transfer[endpoint]--;\r
\r
    LPC_USB->USBCtrl = 0;\r
\r
    if (IS_ISOCHRONOUS(bEP) == 0)\r
    {\r
//         iprintf("Buffer Clear 0x%02X\n", bEP);\r
        SIEselectEndpoint(bEP);\r
        if (SIEclearBuffer())\r
        {\r
//             iprintf("EP%dIN OVERRUN\n", bEP & 0x0F);\r
        }\r
    }\r
\r
    if (irq)\r
        NVIC_EnableIRQ(USB_IRQn);\r
\r
    return size;\r
}\r
\r
static void endpointWritecore(uint8_t bEP, uint8_t *buffer, uint32_t size)\r
{\r
    // Write to an IN endpoint\r
//     uint32_t temp, data;\r
//     uint8_t offset;\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    LPC_USB->USBCtrl = LOG_ENDPOINT(endpoint) | WR_EN;\r
\r
    LPC_USB->USBTxPLen = size;\r
//         offset = 0;\r
//         data = 0;\r
//     iprintf("EP%d%s(%d) W:", (endpoint >> 1), ((endpoint & 1)?"IN":"OUT"), endpoint);\r
    while (LPC_USB->USBCtrl & WR_EN)\r
    {\r
//         iprintf("0x%02X 0x%02X 0x%02X 0x%02X ", buffer[0], buffer[1], buffer[2], buffer[3]);\r
        LPC_USB->USBTxData = (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];\r
        buffer += 4;\r
    }\r
\r
//     iprintf("!_(%ld)>", size);\r
\r
    // Clear WR_EN to cover zero length packet case\r
    LPC_USB->USBCtrl = 0;\r
\r
    SIEselectEndpoint(bEP);\r
    SIEvalidateBuffer();\r
\r
    uint8_t status __attribute__ ((unused)) = SIEselectEndpoint(bEP);\r
//     iprintf("EP 0x%02X ST 0x%02X\n", bEP, status);\r
}\r
\r
\r
USBHAL::USBHAL(void) {\r
    instance = this;\r
}\r
\r
void USBHAL::init() {\r
    // Disable IRQ\r
    NVIC_DisableIRQ(USB_IRQn);\r
\r
    // Enable power to USB device controller\r
    LPC_SC->PCONP |= PCUSB;\r
\r
    // Enable USB clocks\r
    LPC_USB->USBClkCtrl |= DEV_CLK_EN | AHB_CLK_EN;\r
    setled(4, 1); while (LPC_USB->USBClkSt != (DEV_CLK_ON | AHB_CLK_ON)); setled(4, 0);\r
\r
    // Configure pins P0.29 and P0.30 to be USB D+ and USB D-\r
    LPC_PINCON->PINSEL1 &= 0xc3ffffff;\r
    LPC_PINCON->PINSEL1 |= 0x14000000;\r
\r
    // Disconnect USB device\r
    SIEdisconnect();\r
\r
    // Configure pin P2.9 to be Connect\r
    LPC_PINCON->PINSEL4 &= 0xfffcffff;\r
    LPC_PINCON->PINSEL4 |= 0x00040000;\r
\r
    // Connect must be low for at least 2.5uS\r
    //     wait(0.3);\r
\r
    // Set the maximum packet size for the control endpoints\r
    realiseEndpoint(IDX2EP(EP0IN), MAX_PACKET_SIZE_EP0, 0);\r
    realiseEndpoint(IDX2EP(EP0OUT), MAX_PACKET_SIZE_EP0, 0);\r
\r
    // Attach IRQ\r
//     instance = this;\r
    //     NVIC_SetVector(USB_IRQn, (uint32_t)&_usbisr);\r
    //     NVIC_EnableIRQ(USB_IRQn);\r
\r
    USBEpIntEn = 0x3;\r
\r
    // Enable interrupts for device events and EP0\r
//     LPC_USB->USBDevIntEn = EP_SLOW | DEV_STAT | FRAME;\r
    LPC_USB->USBDevIntEn = EP_SLOW | DEV_STAT;\r
    //     enableEndpointEvent(EP0IN);\r
    //     enableEndpointEvent(EP0OUT);\r
}\r
\r
USBHAL::~USBHAL(void) {\r
    // Ensure device disconnected\r
    SIEdisconnect();\r
\r
    // Disable USB interrupts\r
    NVIC_DisableIRQ(USB_IRQn);\r
}\r
\r
uint32_t USBHAL::getSerialNumber(int length, uint32_t *buf) {\r
    #define IAP_LOCATION 0x1FFF1FF1\r
    uint32_t command[1];\r
    uint32_t result[5];\r
    typedef void (*IAP)(uint32_t*, uint32_t*);\r
    IAP iap = (IAP) IAP_LOCATION;\r
\r
    __disable_irq();\r
\r
    command[0] = 58;\r
//     iprintf("Getting Serial...\n");\r
    iap(command, result);\r
//     iprintf("HW Serial Number: %08lX %08lX %08lX %08lX\n", result[1], result[2], result[3], result[4]);\r
    int i;\r
    for (i = 0; i < 4; i++) {\r
        if (i < length) {\r
            buf[i] = result[i + 1];\r
        }\r
    }\r
\r
    __enable_irq();\r
\r
    return i;\r
}\r
\r
void USBHAL::connect(void) {\r
    // Connect USB device\r
//     iprintf("USBHAL::connect\n");\r
    NVIC_EnableIRQ(USB_IRQn);\r
    SIEconnect();\r
//     iprintf("USBHAL::connect OK\n");\r
}\r
\r
void USBHAL::disconnect(void) {\r
    // Disconnect USB device\r
    SIEdisconnect();\r
}\r
\r
void USBHAL::configureDevice(void) {\r
    SIEconfigureDevice();\r
}\r
\r
void USBHAL::unconfigureDevice(void) {\r
    SIEunconfigureDevice();\r
}\r
\r
void USBHAL::setAddress(uint8_t address) {\r
    SIEsetAddress(address);\r
//     SIEsetMode(SIE_MODE_INAK_CI | SIE_MODE_INAK_CO | SIE_MODE_INAK_BI | SIE_MODE_INAK_BO);\r
    SIEsetMode(SIE_MODE_INAK_CI | SIE_MODE_INAK_CO);\r
}\r
\r
void USBHAL::EP0setup(uint8_t *buffer) {\r
    endpointReadcore(IDX2EP(EP0OUT), buffer);\r
}\r
\r
void USBHAL::EP0read(void) {\r
    // Not required\r
}\r
\r
uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) {\r
    return endpointReadcore(IDX2EP(EP0OUT), buffer);\r
}\r
\r
void USBHAL::EP0write(uint8_t *buffer, uint32_t size) {\r
    endpointWritecore(IDX2EP(EP0IN), buffer, size);\r
}\r
\r
void USBHAL::EP0getWriteResult(void) {\r
    // Not required\r
}\r
\r
void USBHAL::EP0stall(void) {\r
    // This will stall both control endpoints\r
    stallEndpoint(IDX2EP(EP0OUT));\r
}\r
\r
EP_STATUS USBHAL::endpointRead(uint8_t bEP, uint32_t maximumSize) {\r
    return EP_PENDING;\r
}\r
\r
EP_STATUS USBHAL::endpointReadResult(uint8_t bEP, uint8_t * buffer, uint32_t *bytesRead)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
//     iprintf("epReadResult 0x%02X = %d\n", bEP, endpoint);\r
\r
    //for isochronous endpoint, we don't wait an interrupt\r
    if (IS_ISOCHRONOUS(bEP) == 0) {\r
//         iprintf("not Isochronous\n");\r
//         if (!(epComplete & EP(endpoint)))\r
        if (can_transfer[endpoint] == 0)\r
        {\r
//             iprintf("Pending\n");\r
            return EP_PENDING;\r
        }\r
    }\r
\r
//     iprintf("reading...\n");\r
\r
    __disable_irq();\r
    __ISB();\r
\r
    if (can_transfer[endpoint])\r
    {\r
        can_transfer[endpoint]--;\r
        __enable_irq();\r
        *bytesRead = endpointReadcore(bEP, buffer);\r
    }\r
    else {\r
        __enable_irq();\r
        *bytesRead = 0;\r
    }\r
//     epComplete &= ~EP(endpoint);\r
\r
//     iprintf("OK\n");\r
\r
    return EP_COMPLETED;\r
}\r
\r
EP_STATUS USBHAL::endpointWrite(uint8_t bEP, uint8_t *data, uint32_t size)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    if (getEndpointStallState(bEP)) {\r
        return EP_STALLED;\r
    }\r
\r
    do {\r
        __disable_irq();\r
        __ISB();\r
\r
        if (can_transfer[endpoint])\r
        {\r
            can_transfer[endpoint]--;\r
            __enable_irq();\r
            endpointWritecore(bEP, data, size);\r
            return EP_PENDING;\r
        }\r
        __enable_irq();\r
        endpointSetInterrupt(bEP, true);\r
    } while (1);\r
}\r
\r
EP_STATUS USBHAL::endpointWriteResult(uint8_t bEP)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
//     if (epComplete & EP(endpoint)) {\r
    if (can_transfer[endpoint] < 2) {\r
//         epComplete &= ~EP(endpoint);\r
        return EP_COMPLETED;\r
    }\r
\r
    return EP_PENDING;\r
}\r
\r
uint8_t USBHAL::endpointStatus(uint8_t bEP)\r
{\r
    uint8_t bEPStat = SIEselectEndpoint(EP2IDX(bEP));\r
\r
    uint8_t bStat __attribute__ ((unused))\r
                  = ((bEPStat & EPSTAT_FE ) ? EP_STATUS_DATA    : 0) |\r
                    ((bEPStat & EPSTAT_ST ) ? EP_STATUS_STALLED : 0) |\r
                    ((bEPStat & EPSTAT_STP) ? EP_STATUS_SETUP   : 0) |\r
                    ((bEPStat & EPSTAT_EPN) ? EP_STATUS_NACKED  : 0) |\r
                    ((bEPStat & EPSTAT_PO ) ? EP_STATUS_ERROR   : 0);\r
\r
    return bEPStat;\r
}\r
\r
bool USBHAL::realiseEndpoint(uint8_t bEP, uint32_t maxPacket, uint32_t flags)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // Realise an endpoint\r
    LPC_USB->USBDevIntClr = EP_RLZED;\r
    LPC_USB->USBReEp |= EP(endpoint);\r
    LPC_USB->USBEpInd = endpoint;\r
    LPC_USB->USBMaxPSize = maxPacket;\r
\r
    setled(4, 1); while (!(LPC_USB->USBDevIntSt & EP_RLZED)); setled(4, 0);\r
    LPC_USB->USBDevIntClr = EP_RLZED;\r
\r
    // Clear stall state\r
//     endpointStallState &= ~EP(endpoint);\r
    unstallEndpoint(bEP);\r
\r
    enableEndpointEvent(bEP);\r
\r
    /*\r
     * if this is an OUT endpoint, enable interrupts so we can receive any\r
     *   data the host sends to us.\r
     *\r
     * if this is an IN endpoint, don't enable interrupts just yet, but have\r
     *   an event waiting so we can immediately interrupt later on when the\r
     *   user app calls endpointSetInterrupt(bEP, true)\r
    */\r
\r
    if (IN_BEP(bEP))\r
    {\r
//         epComplete |= EP(endpoint);\r
        can_transfer[endpoint] = 2;\r
    }\r
    else\r
    {\r
        can_transfer[endpoint] = 0;\r
        endpointSetInterrupt(bEP, true);\r
    }\r
\r
//     iprintf("EP 0x%02X realised @%ld!\n", bEP, maxPacket);\r
    return true;\r
}\r
\r
void USBHAL::stallEndpoint(uint8_t bEP)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // Stall an endpoint\r
    if ( (endpoint==EP0IN) || (endpoint==EP0OUT) ) {\r
        // Conditionally stall both control endpoints\r
        SIEsetEndpointStatus(IDX2EP(EP0OUT), SIE_SES_CND_ST);\r
    } else {\r
        SIEsetEndpointStatus(bEP, SIE_SES_ST);\r
\r
        // Update stall state\r
        endpointStallState |= EP(endpoint);\r
    }\r
}\r
\r
void USBHAL::unstallEndpoint(uint8_t bEP)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    // Unstall an endpoint. The endpoint will also be reinitialised\r
    SIEsetEndpointStatus(bEP, 0);\r
\r
    // Update stall state\r
    endpointStallState &= ~EP(endpoint);\r
}\r
\r
bool USBHAL::getEndpointStallState(uint8_t bEP)\r
{\r
    // Returns true if endpoint stalled\r
    return endpointStallState & EP(EP2IDX(bEP));\r
}\r
\r
void USBHAL::remoteWakeup(void)\r
{\r
    // Remote wakeup\r
    uint8_t status;\r
\r
    // Enable USB clocks\r
    LPC_USB->USBClkCtrl |= DEV_CLK_EN | AHB_CLK_EN;\r
    setled(4, 1); while (LPC_USB->USBClkSt != (DEV_CLK_ON | AHB_CLK_ON)); setled(4, 0);\r
\r
    status = SIEgetDeviceStatus();\r
    SIEsetDeviceStatus(status & ~SIE_DS_SUS);\r
}\r
\r
uint16_t USBHAL::lastFrame(void)\r
{\r
    return SIEgetFrameNumber();\r
}\r
\r
extern "C" {\r
    __attribute__ ((interrupt)) void USB_IRQHandler() {\r
//         iprintf("!0x%08lX/0x%08lX:", LPC_USB->USBDevIntSt, LPC_USB->USBDevIntEn);\r
        ENTER_ISR();\r
        USBHAL::_usbisr();\r
        LEAVE_ISR();\r
    }\r
}\r
\r
void USBHAL::_usbisr(void) {\r
    instance->usbisr();\r
}\r
\r
bool USBHAL::endpointSetInterrupt(uint8_t bEP, bool enabled)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    bool r = USBEpIntEn | EP(endpoint);\r
\r
    if (enabled)\r
    {\r
        __disable_irq();\r
        USBEpIntEn |= EP(endpoint);\r
        if (can_transfer[endpoint])\r
            endpointTriggerInterrupt(bEP);\r
//             LPC_USB->USBEpIntSet = EP(endpoint);\r
        __enable_irq();\r
    }\r
    else\r
    {\r
        USBEpIntEn &= ~EP(endpoint);\r
    }\r
\r
    return r;\r
}\r
\r
bool USBHAL::endpointGetInterrupt(uint8_t bEP)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    return USBEpIntEn | EP(endpoint);\r
}\r
\r
void USBHAL::endpointTriggerInterrupt(uint8_t bEP)\r
{\r
    uint8_t endpoint = EP2IDX(bEP);\r
\r
    LPC_USB->USBEpIntSet = EP(endpoint);\r
}\r
\r
void USBHAL::usbisr(void)\r
{\r
    uint8_t devStat;\r
\r
    if (LPC_USB->USBDevIntSt & FRAME)\r
    {\r
//         iprintf("F");\r
        // Start of frame event\r
//         SOF(SIEgetFrameNumber());\r
        USBEvent_Frame(SIEgetFrameNumber());\r
        // Clear interrupt status flag\r
        LPC_USB->USBDevIntClr = FRAME;\r
\r
//         static uint8_t lst;\r
//         uint8_t st = SIEselectEndpoint(0x80);\r
//         if (st != lst)\r
//         {\r
//             iprintf("EP1S:%02X\n", st);\r
//             lst = st;\r
//         }\r
    }\r
\r
    if (LPC_USB->USBDevIntSt & DEV_STAT)\r
    {\r
        iprintf("D");\r
        // Device Status interrupt\r
        // Must clear the interrupt status flag before reading the device status from the SIE\r
        LPC_USB->USBDevIntClr = DEV_STAT;\r
\r
        // Read device status from SIE\r
        devStat = SIEgetDeviceStatus();\r
        //printf("devStat: %d\r\n", devStat);\r
\r
        if (devStat & SIE_DS_SUS_CH)\r
        {\r
            // Suspend status changed\r
//             if((devStat & SIE_DS_SUS) != 0) {\r
//                 USBEvent_suspendStateChanged(false);\r
//             }\r
            USBEvent_suspendStateChanged(devStat & SIE_DS_SUS);\r
        }\r
\r
        if (devStat & SIE_DS_RST)\r
        {\r
            // Bus reset\r
//             if((devStat & SIE_DS_SUS) == 0) {\r
//                 USBEvent_suspendStateChanged(true);\r
//             }\r
            USBEvent_busReset();\r
\r
            realiseEndpoint(IDX2EP(EP0IN), MAX_PACKET_SIZE_EP0, 0);\r
            realiseEndpoint(IDX2EP(EP0OUT), MAX_PACKET_SIZE_EP0, 0);\r
\r
            SIEsetMode(SIE_MODE_INAK_CI | SIE_MODE_INAK_CO | SIE_MODE_INAK_BI | SIE_MODE_INAK_BO);\r
        }\r
\r
        if (devStat & SIE_DS_CON_CH)\r
        {\r
            USBEvent_connectStateChanged(devStat & SIE_DS_CON);\r
        }\r
    }\r
\r
    if (LPC_USB->USBDevIntSt & EP_SLOW)\r
    {\r
        // (Slow) Endpoint Interrupt\r
\r
        // Process each endpoint interrupt\r
        if (LPC_USB->USBEpIntSt & EP(EP0OUT))\r
        {\r
            uint8_t bEPStat = selectEndpointClearInterrupt(IDX2EP(EP0OUT));\r
            if (bEPStat & SIE_SE_STP)\r
            {\r
                // this is a setup packet\r
                EP0setupCallback();\r
            }\r
            else if (bEPStat & EPSTAT_FE) // OUT endpoint, FE = 1 - data in buffer\r
            {\r
                EP0out();\r
            }\r
        }\r
        if (LPC_USB->USBEpIntSt & EP(EP0IN))\r
        {\r
            uint8_t bEPStat = selectEndpointClearInterrupt(IDX2EP(EP0IN));\r
            if ((bEPStat & EPSTAT_FE) == 0) // IN endpoint, FE = 0 - empty space in buffer\r
                EP0in();\r
        }\r
\r
        if (USBEpIntEn & ~(3UL))\r
        {\r
            int i;\r
            uint32_t bitmask;\r
\r
            for (i = 2, bitmask = 4; i < 32; i++, bitmask <<= 1)\r
            {\r
                uint8_t bEPStat = 255;\r
                uint8_t ep = IDX2EP(i);\r
                if (LPC_USB->USBEpIntSt & bitmask)\r
                {\r
                    bEPStat = selectEndpointClearInterrupt(ep);\r
                    if (can_transfer[i] < 2)\r
                        can_transfer[i]++;\r
                }\r
\r
                if ((USBEpIntEn & bitmask) && (can_transfer[i]))\r
                {\r
                    if (bEPStat == 255)\r
                        bEPStat = SIEselectEndpoint(ep);\r
\r
                    iprintf("!02X", ep);\r
\r
                    uint8_t bStat = ((bEPStat & EPSTAT_FE ) ? EP_STATUS_DATA    : 0) |\r
                                    ((bEPStat & EPSTAT_ST ) ? EP_STATUS_STALLED : 0) |\r
                                    ((bEPStat & EPSTAT_STP) ? EP_STATUS_SETUP   : 0) |\r
                                    ((bEPStat & EPSTAT_EPN) ? EP_STATUS_NACKED  : 0) |\r
                                    ((bEPStat & EPSTAT_PO ) ? EP_STATUS_ERROR   : 0);\r
\r
                    bool r = true;\r
\r
                    if (IN_EP(i))\r
                    {\r
//                         iprintf("IN[%02X]:", IDX2EP(i));\r
                        if ((bEPStat & EPSTAT_FE) == 0) // IN endpoint, FE = 0 - empty space in buffer\r
                            r = USBEvent_EPIn(ep, bStat);\r
                    }\r
                    else\r
                    {\r
//                         iprintf("OUT[%02X]:", IDX2EP(i));\r
                        if (bEPStat & EPSTAT_FE) // OUT endpoint, FE = 1 - data in buffer\r
                            r = USBEvent_EPOut(ep, bStat);\r
                    }\r
\r
                    if (!r)\r
                    {\r
                        USBEpIntEn &= ~bitmask;\r
                    }\r
//                     iprintf("\n");\r
                }\r
            }\r
            iprintf("\n");\r
        }\r
\r
        LPC_USB->USBDevIntClr = EP_SLOW;\r
    }\r
}\r
\r
#endif\r