1079 lines
31 KiB
C
1079 lines
31 KiB
C
/***************************************************************************
|
|
*
|
|
* 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
|