/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
#ifdef CHIP_HAS_USB

#include "plat_addr_map.h"
#include "reg_usb.h"
#include "hal_usbhost.h"
#include "hal_trace.h"
#include "hal_cmu.h"
#include "hal_timer.h"
#include "hal_sysfreq.h"
#include "string.h"
#include "cmsis_nvic.h"
#include "hwtimer_list.h"
#include "pmu.h"

#define MAX_CHAN_NUM                            10
#define MAX_EP_NUM                              16

#define MAX_XFER_SIZE                           (USBC_HCTSIZN_XFERSIZE_MASK >> USBC_HCTSIZN_XFERSIZE_SHIFT)
#define MAX_XFER_PKT                            (USBC_HCTSIZN_PKTCNT_MASK >> USBC_HCTSIZN_PKTCNT_SHIFT)

#define HAL_USBC_PHY_FREQ_MHZ                   48
#define HAL_USBC_PHY_FREQ_MHZ_HS                60
#define HAL_USBC_HPRT_WC_MASK                   \
    (USBC_HPRT_PRTSUSP | USBC_HPRT_PRTOVRCURRCHNG | USBC_HPRT_PRTENCHNG | USBC_HPRT_PRTENA | USBC_HPRT_PRTCONNDET)

#define HAL_USBHOST_TIMEOUT_TICKS               MS_TO_TICKS(200)

#define USBHOST_TRACE(n, mask, str, ...)        { if (usbhost_trmask & (1 << mask)) { TRACE(n, str, ##__VA_ARGS__); } }
#define USBHOST_FUNC_ENTRY_TRACE(mask)          { if (usbhost_trmask & (1 << mask)) { FUNC_ENTRY_TRACE(); } }

enum HAL_USBHOST_CHAN_STATE_T {
    HAL_USBHOST_CHAN_IDLE,
    HAL_USBHOST_CHAN_ALLOC,
    HAL_USBHOST_CHAN_INIT,
    HAL_USBHOST_CHAN_XFER,

    HAL_USBHOST_CHAN_QTY
};

struct HAL_USBHOST_CHAN_DESC_T {
    enum HAL_USBHOST_CHAN_STATE_T state;
    uint32_t start_xfer_size;
    uint16_t start_pkt_cnt;
    uint8_t err_cnt;
    struct HAL_USBHOST_CHAN_TYPE_T type;
    struct HAL_USBHOST_XFER_T xfer;
};

static const uint32_t usbhost_trmask = (1 << 0); //~0UL; //(1 << 3) | (1 << 4);

static struct USBC_T * const usbc = (struct USBC_T *)USB_BASE;

static HAL_USBHOST_PORT_HANDLER port_handler;
static HAL_USBHOST_DELAY_FUNC delay_func;

static struct HAL_USBHOST_CHAN_DESC_T chan_desc[MAX_CHAN_NUM];

static struct HAL_USBHOST_SETUP_XFER_T setup_xfer;

static volatile bool in_setup = false;

static bool usbhost_opened = false;

static enum HAL_USBHOST_SETUP_STAGE_T cur_setup_stage;

static HWTIMER_ID usbhost_timer[MAX_CHAN_NUM];

#ifdef PMU_USB_PIN_CHECK
static HAL_USBHOST_PLUG_HANDLER plug_handler;
#endif

static uint32_t hal_usbhost_get_xfer_size(uint8_t chan, int complete);
static void hal_usbhost_irq_handler(void);
static void hal_usbhost_timeout(void *param);

void hal_usbhost_halt_chan(uint8_t chan)
{
    uint32_t mask;

    USBHOST_TRACE(2,17, "%s: %d", __FUNCTION__, chan);

    if (chan >= MAX_CHAN_NUM) {
        return;
    }

    hwtimer_stop(usbhost_timer[chan]);

    mask = usbc->HCSR[chan].HCINTMSKn;
    usbc->HCSR[chan].HCINTMSKn = 0;
    if ((usbc->HCSR[chan].HCCHARn & USBC_HCCHARN_CHENA) == 0) {
        goto _exit;
    }
    usbc->HCSR[chan].HCINTn = USBC_HCINTN_CHHLTD;
    usbc->HCSR[chan].HCCHARn |= USBC_HCCHARN_CHENA | USBC_HCCHARN_CHDIS;
    while ((usbc->HCSR[chan].HCINTn & USBC_HCINTN_CHHLTD) == 0);

_exit:
    usbc->HCSR[chan].HCINTn = ~0UL;
    usbc->HCSR[chan].HCINTMSKn = mask;
}

static void hal_usbhost_soft_reset(void)
{
    usbc->GRSTCTL |= USBC_CSFTRST;
    while ((usbc->GRSTCTL & USBC_CSFTRST) != 0);
    while ((usbc->GRSTCTL & USBC_AHBIDLE) == 0);
}

static void hal_usbhost_init_phy(void)
{
    usbc->GUSBCFG |= USBC_FORCEHSTMODE | USBC_ULPIAUTORES | USBC_ULPIFSLS |
        USBC_PHYSEL | USBC_ULPI_UTMI_SEL;
    usbc->GUSBCFG &= ~(USBC_FSINTF | USBC_PHYIF | USBC_USBTRDTIM_MASK);
    // USBC_USBTRDTIM(9) if AHB bus is 26M
    usbc->GUSBCFG |= USBC_USBTRDTIM(5);
}

int hal_usbhost_open(HAL_USBHOST_PORT_HANDLER port_cb, HAL_USBHOST_DELAY_FUNC delay_fn)
{
    int i;

    USBHOST_FUNC_ENTRY_TRACE(16);

    for (i = 0; i < MAX_CHAN_NUM; i++) {
        chan_desc[i].state = HAL_USBHOST_CHAN_IDLE;
    }

    hal_sysfreq_req(HAL_SYSFREQ_USER_USB, HAL_CMU_FREQ_52M);

    hal_cmu_usb_set_host_mode();
    hal_cmu_usb_clock_enable();

    hal_usbhost_soft_reset();
    hal_usbhost_init_phy();
    // Reset after selecting PHY
    hal_usbhost_soft_reset();
    // Some core cfg (except for PHY selection) will also be reset during soft reset
    hal_usbhost_init_phy();

#ifdef USB_HIGH_SPEED
    usbc->HCFG = USBC_HCFG_FSLSPCLKSEL(0);
#else
    usbc->HCFG = USBC_HCFG_FSLSSUPP | USBC_HCFG_FSLSPCLKSEL(1);
#endif

    usbc->HPRT = USBC_HPRT_PRTPWR;

    // Clear previous interrupts
    usbc->GINTMSK = 0;
    usbc->GINTSTS = ~0UL;
    usbc->HAINTMSK = 0;
    for (i = 0; i < MAX_CHAN_NUM; i++) {
        usbc->HCSR[i].HCINTMSKn = 0;
        usbc->HCSR[i].HCINTn = ~0UL;
    }
    usbc->GINTMSK = USBC_PRTINT | USBC_HCHINT | USBC_DISCONNINT;

    // Enable DMA mode
    // Burst size 16 words
    usbc->GAHBCFG  = USBC_DMAEN | USBC_HBSTLEN(7);
    usbc->GAHBCFG |= USBC_GLBLINTRMSK;

    port_handler = port_cb;
    delay_func = delay_fn;

    usbhost_opened = true;

    NVIC_SetVector(USB_IRQn, (uint32_t)hal_usbhost_irq_handler);
    NVIC_SetPriority(USB_IRQn, IRQ_PRIORITY_NORMAL);
    NVIC_ClearPendingIRQ(USB_IRQn);
    NVIC_EnableIRQ(USB_IRQn);

    //usbc->TPORTDBG1 = 0x11;

    return 0;
}

void hal_usbhost_close(void)
{
    uint8_t chan;

    USBHOST_FUNC_ENTRY_TRACE(15);

#ifdef PMU_USB_PIN_CHECK
    pmu_usb_disable_pin_status_check();
#endif

    NVIC_DisableIRQ(USB_IRQn);

    usbhost_opened = false;

    hal_cmu_usb_clock_disable();

    for (chan = 0; chan < MAX_CHAN_NUM; chan++) {
        hal_usbhost_free_chan(chan);
    }

    hal_sysfreq_req(HAL_SYSFREQ_USER_USB, HAL_CMU_FREQ_32K);
}

static void hal_usbhost_delay(uint32_t ms)
{
    if (delay_func) {
        delay_func(ms);
    } else {
        hal_sys_timer_delay(MS_TO_TICKS(ms));
    }
}

void hal_usbhost_port_reset(uint32_t ms)
{
    int lock;

    USBHOST_TRACE(2,14, "%s: %d", __FUNCTION__, ms);

    lock = int_lock();
    usbc->HPRT = (usbc->HPRT & ~HAL_USBC_HPRT_WC_MASK) | USBC_HPRT_PRTRST;
    int_unlock(lock);

    hal_usbhost_delay(ms);

    lock = int_lock();
    usbc->HPRT = (usbc->HPRT & ~HAL_USBC_HPRT_WC_MASK) & ~USBC_HPRT_PRTRST;
    int_unlock(lock);
}

static void hal_usbhost_port_suspend(void)
{
    int lock;

    USBHOST_FUNC_ENTRY_TRACE(22);

    lock = int_lock();
    usbc->HPRT = (usbc->HPRT & ~HAL_USBC_HPRT_WC_MASK) | USBC_HPRT_PRTSUSP;
    int_unlock(lock);

    hal_usbhost_delay(3);
}

static void hal_usbhost_port_resume(void)
{
    int lock;

    USBHOST_FUNC_ENTRY_TRACE(22);

    lock = int_lock();
    usbc->HPRT = (usbc->HPRT & ~HAL_USBC_HPRT_WC_MASK) | USBC_HPRT_PRTRES;
    int_unlock(lock);

    hal_usbhost_delay(20);

    lock = int_lock();
    usbc->HPRT = (usbc->HPRT & ~HAL_USBC_HPRT_WC_MASK) & ~USBC_HPRT_PRTRES;
    int_unlock(lock);
}

int hal_usbhost_get_chan(uint8_t *chan)
{
    int i;
    uint32_t lock;

    lock = int_lock();
    for (i = 0; i < MAX_CHAN_NUM; i++) {
        if (chan_desc[i].state == HAL_USBHOST_CHAN_IDLE) {
            chan_desc[i].state = HAL_USBHOST_CHAN_ALLOC;
            break;
        }
    }
    int_unlock(lock);

    USBHOST_TRACE(2,13, "%s: %d", __FUNCTION__, i);

    if (i == MAX_CHAN_NUM) {
        return 1;
    }

    *chan = i;

    ASSERT(usbhost_timer[i] == NULL, "%s: Prev hwtimer not released: 0x%08x", __FUNCTION__, (uint32_t)usbhost_timer[i]);
    usbhost_timer[i] = hwtimer_alloc(hal_usbhost_timeout, (void *)(uint32_t)i);
    if (usbhost_timer[i] == NULL) {
        USBHOST_TRACE(2,0, "%s: WARNING: Failed to alloc hwtimer for chan=%d", __FUNCTION__, i);
        // Continue even if usbhost_timer is null
    }

    return 0;
}

int hal_usbhost_free_chan(uint8_t chan)
{
    USBHOST_TRACE(2,12, "%s: %d", __FUNCTION__, chan);

    if (chan >= MAX_CHAN_NUM) {
        return 1;
    }

    hwtimer_stop(usbhost_timer[chan]);
    hwtimer_free(usbhost_timer[chan]);
    usbhost_timer[chan] = NULL;

    chan_desc[chan].state = HAL_USBHOST_CHAN_IDLE;

    return 0;
}

int hal_usbhost_init_chan(uint8_t chan, const struct HAL_USBHOST_CHAN_TYPE_T *type)
{
    USBHOST_TRACE(7,11, "%s: chan=%d mps=%d ep=%d in=%d type=%d addr=%d",
        __FUNCTION__, chan, type->mps, type->ep_num, type->ep_in, type->ep_type, type->dev_addr);

    if (chan >= MAX_CHAN_NUM) {
        return 1;
    }
    if (chan_desc[chan].state != HAL_USBHOST_CHAN_ALLOC) {
        return 2;
    }
    if (usbc->HCSR[chan].HCCHARn & USBC_HCCHARN_CHENA) {
        return 3;
    }
    if ((type->dev_addr & (USBC_HCCHARN_DEVADDR_MASK >> USBC_HCCHARN_DEVADDR_SHIFT)) != type->dev_addr) {
        return 4;
    }
    if (type->ep_num >= MAX_EP_NUM) {
        return 5;
    }
    if (type->ep_type >= HAL_USBHOST_EP_QTY) {
        return 6;
    }
    if ((type->mps & (USBC_HCCHARN_MPS_MASK >> USBC_HCCHARN_MPS_SHIFT)) != type->mps) {
        return 7;
    }
    if (type->mps == 0) {
        return 8;
    }

    memcpy(&chan_desc[chan].type, type, sizeof(chan_desc[chan].type));
    chan_desc[chan].err_cnt = 0;

    usbc->HCSR[chan].HCINTMSKn = 0;
    usbc->HCSR[chan].HCINTn = ~0UL;

    usbc->HCSR[chan].HCCHARn = USBC_HCCHARN_MPS(type->mps) | USBC_HCCHARN_EPNUM(type->ep_num) |
        (type->ep_in ? USBC_HCCHARN_EPDIR : 0) | USBC_HCCHARN_EPTYPE(type->ep_type) |
        USBC_HCCHARN_DEVADDR(type->dev_addr);

    usbc->HCSR[chan].HCINTMSKn = USBC_HCINTN_AHBERR | USBC_HCINTN_CHHLTD;
    usbc->HAINTMSK |= (1 << chan);
    usbc->GINTMSK |= USBC_HCHINT;

    chan_desc[chan].state = HAL_USBHOST_CHAN_INIT;

    return 0;
}

int hal_usbhost_update_chan_dev_addr(uint8_t chan, uint8_t dev_addr)
{
    USBHOST_TRACE(3,10, "%s: chan=%d dev_addr=%d", __FUNCTION__, chan, dev_addr);

    if (chan >= MAX_CHAN_NUM) {
        return 1;
    }
    if (chan_desc[chan].state != HAL_USBHOST_CHAN_INIT) {
        return 2;
    }

    chan_desc[chan].type.dev_addr = dev_addr;

    usbc->HCSR[chan].HCCHARn = SET_BITFIELD(usbc->HCSR[chan].HCCHARn, USBC_HCCHARN_DEVADDR, dev_addr);

    chan_desc[chan].state = HAL_USBHOST_CHAN_INIT;

    return 0;
}

int hal_usbhost_update_chan_mps(uint8_t chan, uint16_t mps)
{
    USBHOST_TRACE(3,9, "%s: chan=%d mps=%d", __FUNCTION__, chan, mps);

    if (chan >= MAX_CHAN_NUM) {
        return 1;
    }
    if (chan_desc[chan].state != HAL_USBHOST_CHAN_INIT) {
        return 2;
    }

    chan_desc[chan].type.mps = mps;

    usbc->HCSR[chan].HCCHARn = SET_BITFIELD(usbc->HCSR[chan].HCCHARn, USBC_HCCHARN_MPS, mps);

    chan_desc[chan].state = HAL_USBHOST_CHAN_INIT;

    return 0;
}

int hal_usbhost_start_xfer(uint8_t chan, const struct HAL_USBHOST_XFER_T *xfer)
{
    uint32_t max_periodic_len;
    uint32_t pkt_cnt;
    uint32_t size;
    enum HAL_USBHOST_PID_TYPE_T pid;
    uint8_t multi_cnt;

    USBHOST_TRACE(5,7, "%s: chan=%d size=%u mc=%d pid=%d",
        __FUNCTION__, chan, xfer->size, xfer->multi_cnt, xfer->pid);

    if (chan >= MAX_CHAN_NUM) {
        return 1;
    }
    if (chan_desc[chan].state != HAL_USBHOST_CHAN_INIT) {
        return 2;
    }
    if (usbc->HCSR[chan].HCCHARn & USBC_HCCHARN_CHENA) {
        return 3;
    }
    if (((uint32_t)xfer->buf & 0x3) != 0) {
        return 4;
    }
    if (chan_desc[chan].type.ep_type == HAL_USBHOST_EP_ISO ||
            chan_desc[chan].type.ep_type == HAL_USBHOST_EP_INT) {
        max_periodic_len = xfer->multi_cnt * chan_desc[chan].type.mps;
        if (max_periodic_len < xfer->size) {
            return 5;
        }
    } else {
        if (xfer->size > MAX_XFER_SIZE) {
            return 6;
        }
    }

    pkt_cnt = (xfer->size + (chan_desc[chan].type.mps - 1)) / chan_desc[chan].type.mps;
    if (pkt_cnt > MAX_XFER_PKT) {
        return 7;
    }
    if (pkt_cnt == 0) {
        pkt_cnt = 1;
    }

    if (chan_desc[chan].type.ep_in) {
        size = pkt_cnt * chan_desc[chan].type.mps;
    } else {
        size = xfer->size;
    }

    chan_desc[chan].start_xfer_size = size;
    chan_desc[chan].start_pkt_cnt = pkt_cnt;
    memcpy(&chan_desc[chan].xfer, xfer, sizeof(chan_desc[chan].xfer));

    pid = xfer->pid;
    if (pid == HAL_USBHOST_PID_AUTO) {
        pid = GET_BITFIELD(usbc->HCSR[chan].HCTSIZn, USBC_HCTSIZN_PID);
    }
    multi_cnt = xfer->multi_cnt;

    if (chan_desc[chan].type.ep_type == HAL_USBHOST_EP_ISO ||
            chan_desc[chan].type.ep_type == HAL_USBHOST_EP_INT) {
        multi_cnt = pkt_cnt;

        if (chan_desc[chan].type.ep_type == HAL_USBHOST_EP_ISO) {
            pid = HAL_USBHOST_PID_DATA0; // Full speed
        }

        if (usbc->HFNUM & 0x1) {
            usbc->HCSR[chan].HCCHARn &= ~USBC_HCCHARN_ODDFRM;
        } else {
            usbc->HCSR[chan].HCCHARn |= USBC_HCCHARN_ODDFRM;
        }
    }

    chan_desc[chan].state = HAL_USBHOST_CHAN_XFER;

    usbc->HCSR[chan].HCTSIZn = USBC_HCTSIZN_PID(pid) | USBC_HCTSIZN_PKTCNT(pkt_cnt) | USBC_HCTSIZN_XFERSIZE(size);
    usbc->HCSR[chan].HCDMAn = (uint32_t)xfer->buf;

    usbc->HCSR[chan].HCINTn = ~0UL;

    usbc->HCSR[chan].HCCHARn = SET_BITFIELD(usbc->HCSR[chan].HCCHARn, USBC_HCCHARN_EC, multi_cnt);
    usbc->HCSR[chan].HCCHARn &= ~USBC_HCCHARN_CHDIS;
    usbc->HCSR[chan].HCCHARn |= USBC_HCCHARN_CHENA;

    if (xfer->handler) {
        hwtimer_start(usbhost_timer[chan], HAL_USBHOST_TIMEOUT_TICKS);
    }

    return 0;
}

static void hal_usbhost_setup_xfer_handler(uint8_t chan, uint8_t *buf, uint32_t len, enum HAL_USBHOST_XFER_ERR_T error)
{
    int ret;
    struct HAL_USBHOST_XFER_T xfer;
    enum HAL_USBHOST_SETUP_STAGE_T handler_stage;
    uint8_t handler_chan;

    ret = 1;
    if (error != HAL_USBHOST_XFER_ERR_NONE) {
        goto _exit;
    }

    USBHOST_TRACE(5,6, "%s: chan=%d cur=%d next=%d error=%d",
        __FUNCTION__, chan, cur_setup_stage, setup_xfer.next_stage, error);

    handler_stage = setup_xfer.next_stage;
    handler_chan = HAL_USBHOST_CHAN_NONE;

    switch (handler_stage) {
        case HAL_USBHOST_SETUP_DATA_IN:
        case HAL_USBHOST_SETUP_DATA_OUT:
            xfer.buf = setup_xfer.data_buf;
            xfer.size = setup_xfer.setup_pkt.wLength;
            xfer.pid = HAL_USBHOST_PID_DATA1;
            xfer.multi_cnt = 0;
            xfer.handler = hal_usbhost_setup_xfer_handler;
            if (handler_stage == HAL_USBHOST_SETUP_DATA_IN) {
                handler_chan = setup_xfer.chan_in;
                setup_xfer.next_stage = HAL_USBHOST_SETUP_STATUS_OUT;
            } else {
                handler_chan = setup_xfer.chan_out;
                setup_xfer.next_stage = HAL_USBHOST_SETUP_STATUS_IN;
            }
            ret = hal_usbhost_start_xfer(handler_chan, &xfer);
            if (ret) {
                goto _exit;
            }
            break;
        case HAL_USBHOST_SETUP_STATUS_IN:
        case HAL_USBHOST_SETUP_STATUS_OUT:
            if (cur_setup_stage == HAL_USBHOST_SETUP_DATA_IN) {
                if (setup_xfer.setup_pkt.wLength != len) {
                    USBHOST_TRACE(2,0, "Invalid setup data length: %d expect=%d", len, setup_xfer.setup_pkt.wLength);
                    // Update received len
                    setup_xfer.setup_pkt.wLength = len;
                }
            }
            xfer.buf = NULL;
            xfer.size = 0;
            xfer.pid = HAL_USBHOST_PID_DATA1;
            xfer.multi_cnt = 0;
            xfer.handler = hal_usbhost_setup_xfer_handler;
            if (handler_stage == HAL_USBHOST_SETUP_STATUS_IN) {
                handler_chan = setup_xfer.chan_in;
            } else {
                handler_chan = setup_xfer.chan_out;
            }
            setup_xfer.next_stage = HAL_USBHOST_SETUP_DONE;
            ret = hal_usbhost_start_xfer(handler_chan, &xfer);
            if (ret) {
                goto _exit;
            }
            break;
        case HAL_USBHOST_SETUP_DONE:
            ret = 0;
            goto _exit;
            break;
        default:
            ASSERT(false, "Invalid setup next stage %d for chan %d", setup_xfer.next_stage, chan);
            ret = 1;
            goto _exit;
    }

    cur_setup_stage = handler_stage;

    return;

_exit:
    if (error != HAL_USBHOST_XFER_ERR_NONE) {
        setup_xfer.next_stage = HAL_USBHOST_SETUP_ERROR;
    }

    {
        struct HAL_USBHOST_SETUP_XFER_T setup;

        memcpy(&setup, &setup_xfer, sizeof(setup));
        in_setup = false;
        if (setup.handler) {
            setup.handler(&setup, ret);
        }
    }

    return;
}

int hal_usbhost_start_setup_xfer(const struct HAL_USBHOST_SETUP_XFER_T *setup, uint32_t *recv_len)
{
    int ret;
    struct HAL_USBHOST_XFER_T xfer;

    USBHOST_TRACE(7,6, "%s: out=%d in=%d type=0x%02x req=0x%02x wlen=%d next_stage=%d",
        __FUNCTION__, setup->chan_out, setup->chan_in, setup->setup_pkt.bmRequestType,
        setup->setup_pkt.bRequest, setup->setup_pkt.wLength, setup->next_stage);

    if (setup->next_stage >= HAL_USBHOST_SETUP_STATUS_OUT) {
        return -1;
    }

    if (in_setup) {
        return -2;
    }
    in_setup = true;

    memcpy(&setup_xfer, setup, sizeof(setup_xfer));
    cur_setup_stage = HAL_USBHOST_SETUP_STAGE_QTY;

    xfer.buf = (uint8_t *)&setup_xfer.setup_pkt;
    xfer.size = sizeof(setup_xfer.setup_pkt);
    xfer.pid = HAL_USBHOST_PID_SETUP;
    xfer.multi_cnt = 0;
    xfer.handler = hal_usbhost_setup_xfer_handler;

    ret = hal_usbhost_start_xfer(setup_xfer.chan_out, &xfer);
    if (ret) {
        in_setup = false;
        return ret;
    }

    if (setup->handler == NULL) {
        while (in_setup);
        if (setup_xfer.next_stage != HAL_USBHOST_SETUP_DONE) {
            return -3;
        }
        if (recv_len) {
            if (setup->next_stage == HAL_USBHOST_SETUP_DATA_IN) {
                *recv_len = setup_xfer.setup_pkt.wLength;
            } else {
                *recv_len = 0;
            }
        }
    }

    return 0;
}

static void hal_usbhost_stop_all_chans(void)
{
    int i;
    uint32_t xfer;
    HAL_USBHOST_XFER_COMPL_HANDLER handler;
    uint8_t *buf;

    usbc->HAINTMSK = 0;

    for (i = 0; i < MAX_CHAN_NUM; i++) {
        hal_usbhost_halt_chan(i);

        if (chan_desc[i].state != HAL_USBHOST_CHAN_XFER) {
            continue;
        }

        if (chan_desc[i].xfer.handler) {
            // TODO: Check whether HCTSIZn is reset after channel is halted
            xfer = hal_usbhost_get_xfer_size(i, 0);

            // Reset the chan_desc to INIT state so that it can be reused in callback
            handler = chan_desc[i].xfer.handler;
            buf = chan_desc[i].xfer.buf;
            chan_desc[i].state = HAL_USBHOST_CHAN_INIT;

            handler(i, buf, xfer, HAL_USBHOST_XFER_ERR_DISCONN);
        }
    }

    usbc->HAINT = ~0UL;
}

static void hal_usbhost_disconn_handler(void)
{
    USBHOST_FUNC_ENTRY_TRACE(5);

    usbc->GINTMSK &= ~USBC_HCHINT;

    hal_usbhost_stop_all_chans();

    if (port_handler) {
        port_handler(HAL_USBHOST_PORT_DISCONN);
    }
}

static void hal_usbhost_alloc_fifo(void)
{
    // FIFO configuration should be started after port enabled, or 60 ms after soft reset

    hal_usbhost_stop_all_chans();

    // RX FIFO Calculation
    // -------------------
    // DATA Packets + Status Info   : (MPS / 4 + 1) * m
    // OutEp XFER COMPL             : 1 * m
    // NAK/NYET Handling            : 1 * outEpNum

#define RXFIFOSIZE  (2 * (MAX_USBHOST_PACKET_SIZE / 4 + 1 + 1) + USBHOST_EPNUM)
#define TXFIFOSIZE  (2 * (MAX_USBHOST_PACKET_SIZE / 4))

    // Rx Fifo Size (and init fifo_addr)
    usbc->GRXFSIZ = USBC_RXFDEP(RXFIFOSIZE);

    // EP0 / Non-periodic Tx Fifo Size
    usbc->GNPTXFSIZ = USBC_NPTXFSTADDR(RXFIFOSIZE) | USBC_NPTXFDEPS(TXFIFOSIZE);

    // Flush all FIFOs
    usbc->GRSTCTL = USBC_TXFNUM(0x10) | USBC_TXFFLSH | USBC_RXFFLSH;
    while ((usbc->GRSTCTL & (USBC_TXFFLSH | USBC_RXFFLSH)) != 0);
}

static void hal_usbhost_port_handler(void)
{
    uint32_t prt;
    uint32_t speed;
    enum HAL_USBHOST_PORT_EVENT_T event;

    prt = usbc->HPRT;
    // USBC_HPRT_PRTENA also controls the port status
    usbc->HPRT = prt & ~(USBC_HPRT_PRTENA | USBC_HPRT_PRTSUSP);

    USBHOST_TRACE(2,4, "%s: 0x%08x", __FUNCTION__, prt);

    if (prt & USBC_HPRT_PRTCONNDET) {
        if (port_handler) {
            port_handler(HAL_USBHOST_PORT_CONN);
        }
    }

    if (prt & USBC_HPRT_PRTENCHNG) {
        if (prt & USBC_HPRT_PRTENA) {
            speed = GET_BITFIELD(usbc->HPRT,USBC_HPRT_PRTSPD);
            if (speed == 1 ||
#ifdef USB_HIGH_SPEED
                    speed == 0 ||
#endif
                    0) {
#ifdef USB_HIGH_SPEED
                if (speed == 0) {
                    // High speed
                    usbc->HFIR = SET_BITFIELD(usbc->HFIR, USBC_HFIR_FRINT, 125 * HAL_USBC_PHY_FREQ_MHZ_HS);
                    event = HAL_USBHOST_PORT_EN_HS;
                } else
#else
                {
                    // Full speed
                    usbc->HFIR = SET_BITFIELD(usbc->HFIR, USBC_HFIR_FRINT, 1000 * HAL_USBC_PHY_FREQ_MHZ);
                    event = HAL_USBHOST_PORT_EN_FS;
                }
#endif
                // Config FIFOs
                hal_usbhost_alloc_fifo();
                // Notify upper layer
                if (port_handler) {
                    port_handler(event);
                }
            } else {
                // High (0) or low (2) speed not supported
                if (port_handler) {
                    port_handler(HAL_USBHOST_PORT_EN_BAD);
                }
            }
        }
    }
}

static void hal_usbhost_retry_chan(uint8_t chan, uint32_t size)
{
    uint32_t pkt_cnt;

    USBHOST_TRACE(3,20, "%s: chan=%d size=%u", __FUNCTION__, chan, size);

#if 0
    if (chan_desc[chan].state != HAL_USBHOST_CHAN_XFER) {
        return;
    }
#endif

    hal_usbhost_halt_chan(chan);

    pkt_cnt = (size + chan_desc[chan].type.mps - 1) / chan_desc[chan].type.mps;
    if (pkt_cnt == 0) {
        pkt_cnt = 1;
    }

    usbc->HCSR[chan].HCTSIZn = (usbc->HCSR[chan].HCTSIZn & ~(USBC_HCTSIZN_PKTCNT_MASK | USBC_HCTSIZN_XFERSIZE_MASK)) |
        USBC_HCTSIZN_PKTCNT(pkt_cnt) | USBC_HCTSIZN_XFERSIZE(size);
    usbc->HCSR[chan].HCDMAn = (uint32_t)chan_desc[chan].xfer.buf + (chan_desc[chan].start_xfer_size - size);

    usbc->HCSR[chan].HCINTn = ~0UL;

    //usbc->HCSR[chan].HCCHARn = SET_BITFIELD(usbc->HCSR[chan].HCCHARn, USBC_HCCHARN_EC, multi_cnt);
    usbc->HCSR[chan].HCCHARn &= ~USBC_HCCHARN_CHDIS;
    usbc->HCSR[chan].HCCHARn |= USBC_HCCHARN_CHENA;
}

static uint32_t hal_usbhost_get_xfer_size(uint8_t chan, int complete)
{
    uint32_t xfer;

    if (complete) {
        if (chan_desc[chan].type.ep_in) {
            xfer = GET_BITFIELD(usbc->HCSR[chan].HCTSIZn, USBC_HCTSIZN_XFERSIZE);
            if (chan_desc[chan].start_xfer_size > xfer) {
                xfer = chan_desc[chan].start_xfer_size - xfer;
            } else {
                xfer = 0;
            }
        } else {
            xfer = chan_desc[chan].start_xfer_size;
        }
    } else {
        xfer = GET_BITFIELD(usbc->HCSR[chan].HCTSIZn, USBC_HCTSIZN_PKTCNT);
        if (chan_desc[chan].start_pkt_cnt > xfer) {
            xfer = (chan_desc[chan].start_pkt_cnt - xfer) * chan_desc[chan].type.mps;
        } else {
            xfer = 0;
        }
    }

    return xfer;
}

static enum HAL_USBHOST_XFER_ERR_T hal_usbhost_get_xfer_error(uint32_t irq)
{
    if (irq & USBC_HCINTN_XFERCOMPL)    return HAL_USBHOST_XFER_ERR_NONE;
    if (irq & USBC_HCINTN_AHBERR)       return HAL_USBHOST_XFER_ERR_AHB;
    if (irq & USBC_HCINTN_STALL)        return HAL_USBHOST_XFER_ERR_STALL;
    if (irq & USBC_HCINTN_XACTERR)      return HAL_USBHOST_XFER_ERR_TRANSACTION;
    if (irq & USBC_HCINTN_BBLERR)       return HAL_USBHOST_XFER_ERR_BABBLE;
    if (irq & USBC_HCINTN_FRMOVRUN)     return HAL_USBHOST_XFER_ERR_FRAME_OVERRUN;
    if (irq & USBC_HCINTN_DATATGLERR)   return HAL_USBHOST_XFER_ERR_DATA_TOGGLE;

    return HAL_USBHOST_XFER_ERR_QTY;
}

static void hal_usbhost_chan_n_handler(uint8_t chan)
{
    uint32_t raw_irq;
    uint32_t irq;
    uint32_t xfer;
    enum HAL_USBHOST_XFER_ERR_T error;
    HAL_USBHOST_XFER_COMPL_HANDLER handler;
    uint8_t *buf;

    USBHOST_TRACE(2,3, "%s: %d", __FUNCTION__, chan);

    if (chan_desc[chan].state != HAL_USBHOST_CHAN_XFER) {
        return;
    }

    raw_irq = usbc->HCSR[chan].HCINTn;
    usbc->HCSR[chan].HCINTn = raw_irq;
    irq = raw_irq & usbc->HCSR[chan].HCINTMSKn;

    xfer = hal_usbhost_get_xfer_size(chan, (raw_irq & USBC_HCINTN_XFERCOMPL));

    USBHOST_TRACE(4,18, "%s: chan=%d HCINTn=0x%08x xfer=%u", __FUNCTION__, chan, raw_irq, xfer);

    error = HAL_USBHOST_XFER_ERR_QTY;

    if (chan_desc[chan].type.ep_type == HAL_USBHOST_EP_BULK ||
            chan_desc[chan].type.ep_type == HAL_USBHOST_EP_CTRL) {
        if (chan_desc[chan].type.ep_in) {
            if (raw_irq & USBC_HCINTN_CHHLTD) {
                if (raw_irq & (USBC_HCINTN_XFERCOMPL | USBC_HCINTN_STALL | USBC_HCINTN_BBLERR)) {
                    chan_desc[chan].err_cnt = 0;
                    usbc->HCSR[chan].HCINTMSKn &= ~(USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_DATATGLERR);
                    error = hal_usbhost_get_xfer_error(raw_irq);
                } else if (raw_irq & USBC_HCINTN_XACTERR) {
                    if (chan_desc[chan].err_cnt >= 2) {
                        error = HAL_USBHOST_XFER_ERR_TRANSACTION;
                    } else {
                        chan_desc[chan].err_cnt++;
                        usbc->HCSR[chan].HCINTMSKn |= USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_DATATGLERR;
                        hal_usbhost_retry_chan(chan, chan_desc[chan].start_xfer_size - xfer);
                        return;
                    }
                }
            } else if (raw_irq & (USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_DATATGLERR)) {
                chan_desc[chan].err_cnt = 0;
                usbc->HCSR[chan].HCINTMSKn &= ~(USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_DATATGLERR);
                return;
            }
        } else {
            if (raw_irq & USBC_HCINTN_CHHLTD) {
                if (raw_irq & (USBC_HCINTN_XFERCOMPL | USBC_HCINTN_STALL)) {
                    chan_desc[chan].err_cnt = 0;
                    usbc->HCSR[chan].HCINTMSKn &= ~(USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_NYET);
                    error = hal_usbhost_get_xfer_error(raw_irq);
                } else if (raw_irq & USBC_HCINTN_XACTERR) {
                    if (chan_desc[chan].err_cnt >= 2) {
                        usbc->HCSR[chan].HCINTMSKn &= ~(USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_NYET);
                        error = HAL_USBHOST_XFER_ERR_TRANSACTION;
                    } else {
                        chan_desc[chan].err_cnt++;
                        usbc->HCSR[chan].HCINTMSKn |= (USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_NYET);
                        hal_usbhost_retry_chan(chan, chan_desc[chan].start_xfer_size - xfer);
                        return;
                    }
                }
            } else if (raw_irq & (USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_NYET)) {
                chan_desc[chan].err_cnt = 0;
                usbc->HCSR[chan].HCINTMSKn &= ~(USBC_HCINTN_ACK | USBC_HCINTN_NAK | USBC_HCINTN_NYET);
                return;
            }
        }
    }

    if (error == HAL_USBHOST_XFER_ERR_QTY) {
        error = hal_usbhost_get_xfer_error(raw_irq);
    }

    if (error == HAL_USBHOST_XFER_ERR_QTY) {
        // Unknown IRQ
        usbc->HCSR[chan].HCINTMSKn &= ~irq;
        USBHOST_TRACE(3,19, "%s: Got unknown IRQ chan=%d irq=0x%08x", __FUNCTION__, chan, irq);
    } else {
        // Stop xfer timer
        hwtimer_stop(usbhost_timer[chan]);

        // Reset the chan_desc to INIT state so that it can be reused in callback
        handler = chan_desc[chan].xfer.handler;
        buf = chan_desc[chan].xfer.buf;
        chan_desc[chan].state = HAL_USBHOST_CHAN_INIT;

        if (error != HAL_USBHOST_XFER_ERR_NONE) {
            usbc->HAINTMSK &= ~(1 << chan);
            if ((raw_irq & USBC_HCINTN_CHHLTD) == 0) {
                hal_usbhost_halt_chan(chan);
            }
        }
        if (handler) {
            handler(chan, buf, xfer, error);
        }
    }
}

static void hal_usbhost_chan_handler(void)
{
    uint8_t i;

    USBHOST_FUNC_ENTRY_TRACE(2);

    for (i = 0; i < MAX_CHAN_NUM; i++) {
        if (usbc->HAINT & (1 << i)) {
            hal_usbhost_chan_n_handler(i);
        }
    }
}

static void hal_usbhost_irq_handler(void)
{
    uint32_t status;

    // Store interrupt flag and reset it
    status = usbc->GINTSTS;
    usbc->GINTSTS = status;

    status &= (usbc->GINTMSK & (USBC_PRTINT | USBC_HCHINT | USBC_DISCONNINT));

    USBHOST_TRACE(2,1, "%s: 0x%08x", __FUNCTION__, status);

    if (status & USBC_DISCONNINT) {
        hal_usbhost_disconn_handler();
        return;
    }
    if (status & USBC_PRTINT) {
        hal_usbhost_port_handler();
    }
    if (status & USBC_HCHINT) {
        hal_usbhost_chan_handler();
    }
}

static void hal_usbhost_timeout(void *param)
{
    uint8_t chan = (uint8_t)(uint32_t)param;
    uint32_t xfer;
    HAL_USBHOST_XFER_COMPL_HANDLER handler;
    uint8_t *buf;

    USBHOST_TRACE(2,21, "%s: %d", __FUNCTION__, chan);

    if (chan_desc[chan].state != HAL_USBHOST_CHAN_XFER) {
        return;
    }

    hal_usbhost_halt_chan(chan);

    if (chan_desc[chan].xfer.handler) {
        // TODO: Check whether HCTSIZn is reset after channel is halted
        xfer = hal_usbhost_get_xfer_size(chan, 0);

        // Reset the chan_desc to INIT state so that it can be reused in callback
        handler = chan_desc[chan].xfer.handler;
        buf = chan_desc[chan].xfer.buf;
        chan_desc[chan].state = HAL_USBHOST_CHAN_INIT;

        handler(chan, buf, xfer, HAL_USBHOST_XFER_ERR_TIMEOUT);
    }
}

#ifdef PMU_USB_PIN_CHECK
static void hal_usbhost_pin_status_change(enum PMU_USB_PIN_CHK_STATUS_T status)
{
    USBHOST_TRACE(2,24, "%s: %d", __FUNCTION__, status);

    if (plug_handler) {
        if (status == PMU_USB_PIN_CHK_DEV_CONN) {
            plug_handler(HAL_USBHOST_PLUG_IN);
        } else if (status == PMU_USB_PIN_CHK_DEV_DISCONN) {
            plug_handler(HAL_USBHOST_PLUG_OUT);
        }
    }
}
#endif

void hal_usbhost_detect(enum HAL_USBHOST_PLUG_STATUS_T status, HAL_USBHOST_PLUG_HANDLER handler)
{
#ifdef PMU_USB_PIN_CHECK
    enum PMU_USB_PIN_CHK_STATUS_T pmu_status;

    USBHOST_FUNC_ENTRY_TRACE(23);

    if (status == HAL_USBHOST_PLUG_IN) {
        pmu_status = PMU_USB_PIN_CHK_DEV_CONN;
    } else if (status == HAL_USBHOST_PLUG_OUT) {
        pmu_status = PMU_USB_PIN_CHK_DEV_DISCONN;
    } else {
        pmu_status = PMU_USB_PIN_CHK_NONE;
    }

    plug_handler = handler;
    if (handler && pmu_status != PMU_USB_PIN_CHK_NONE) {
        pmu_usb_config_pin_status_check(pmu_status, hal_usbhost_pin_status_change, true);
    } else {
        pmu_usb_disable_pin_status_check();
    }
#else
    ASSERT(false, "No aux usb pin status check support");
#endif
}

void hal_usbhost_sleep(void)
{
    USBHOST_FUNC_ENTRY_TRACE(22);

    if (usbhost_opened) {
        hal_usbhost_port_suspend();
#ifdef PMU_USB_PIN_CHECK
        hal_cmu_clock_disable(HAL_CMU_MOD_H_USBC);
        hal_cmu_clock_disable(HAL_CMU_MOD_O_USB);
        pmu_usb_config_pin_status_check(PMU_USB_PIN_CHK_DEV_DISCONN, hal_usbhost_pin_status_change, true);
#endif
    }
}

void hal_usbhost_wakeup(void)
{
    USBHOST_FUNC_ENTRY_TRACE(22);

    if (usbhost_opened) {
#ifdef PMU_USB_PIN_CHECK
        pmu_usb_disable_pin_status_check();
        hal_cmu_clock_enable(HAL_CMU_MOD_H_USBC);
        hal_cmu_clock_enable(HAL_CMU_MOD_O_USB);
#endif
        hal_usbhost_port_resume();
    }
}

#endif // CHIP_HAS_USB