rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/platform/hal/hal_usb.c

2726 lines
71 KiB
C
Raw Blame History

/***************************************************************************
*
* 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 "hal_usb.h"
#include "cmsis_nvic.h"
#include "hal_chipid.h"
#include "hal_cmu.h"
#include "hal_sysfreq.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "hwtimer_list.h"
#include "plat_addr_map.h"
#include "pmu.h"
#include "reg_usb.h"
#include "string.h"
#include "usb_descriptor.h"
#ifdef CHIP_HAS_USBPHY
#include "usbphy.h"
#endif
// TODO List:
// 1) Thread-safe issue (race condition)
// Hardware configuration:
// GHWCFG1 = 0x00000000
// GHWCFG2 = 0x228a5512
// GHWCFG3 = 0x03f404e8
// GHWCFG4 = 0x16108020
#define USB_TRACE(n, mask, str, ...) \
{ \
if (usb_trmask & (1 << mask)) { \
TRACE(n, str, ##__VA_ARGS__); \
} \
}
#define USB_FUNC_ENTRY_TRACE(mask) \
{ \
if (usb_trmask & (1 << mask)) { \
FUNC_ENTRY_TRACE(); \
} \
}
#ifndef CHIP_BEST1000
#define CHIP_HAS_USBIF
#endif
#ifdef USB_HIGH_SPEED
#ifndef USB_ISO_INTERVAL
#define USB_ISO_INTERVAL 8 // ANY value larger than 1
#endif
#if (USB_ISO_INTERVAL <= 1)
#error "Invalid USB_ISO_INTERVAL"
#endif
#else
#undef USB_ISO_INTERVAL
#define USB_ISO_INTERVAL 1
#endif
#ifdef SIMU_UAUD_MAX_PKT
// SEND/RECV with mps = USB_MAX_PACKET_SIZE_ISO
#define USB_FIFO_MPS_ISO_RECV USB_FIFO_MPS_ISO_SEND
#else
#ifdef USB_HIGH_SPEED
// 384K sample rate, 32 bits, 2 channels = 3072 bytes/ms
#define USB_FIFO_MPS_ISO_RECV 1200
#else
// 192K sample rate, 16 bits, 2 channels = 768 bytes/ms
#define USB_FIFO_MPS_ISO_RECV USB_FIFO_MPS_ISO_SEND
#endif
#endif
#define PIN_CHECK_ENABLE_INTERVAL MS_TO_TICKS(1)
#define PIN_CHECK_WAIT_RESUME_INTERVAL MS_TO_TICKS(30)
#define LPM_CHECK_INTERVAL MS_TO_TICKS(100) //(US_TO_TICKS(8 + 50) + 2)
#define USB_SYS_FREQ HAL_CMU_FREQ_52M
enum DEVICE_STATE {
ATTACHED,
POWERED,
DEFAULT,
ADDRESS,
CONFIGURED,
};
struct EPN_OUT_TRANSFER {
uint8_t *data;
uint32_t length;
bool enabled;
};
struct EPN_IN_TRANSFER {
const uint8_t *data;
uint32_t length;
uint16_t pkt_cnt;
bool zero_len_pkt;
bool enabled;
};
enum DATA_PID_T {
DATA_PID_DATA0 = 0,
DATA_PID_DATA1 = 2,
DATA_PID_DATA2 = 1,
DATA_PID_MDATA = 3,
};
enum USB_SLEEP_T {
USB_SLEEP_NONE,
USB_SLEEP_SUSPEND,
USB_SLEEP_L1,
};
static const uint32_t usb_trmask = (1 << 0); //(1 << 2) | (1 << 6) | (1 << 8);
static struct USBC_T *const usbc = (struct USBC_T *)USB_BASE;
#ifdef CHIP_HAS_USBIF
static struct USBIF_T *const usbif = (struct USBIF_T *)(USB_BASE + 0x00040000);
#endif
static uint16_t fifo_addr;
static uint32_t ep0_out_buffer[USB_MAX_PACKET_SIZE_CTRL / 4];
static uint32_t ep0_in_buffer[USB_MAX_PACKET_SIZE_CTRL / 4];
static struct EPN_OUT_TRANSFER epn_out_transfer[EPNUM - 1];
static struct EPN_IN_TRANSFER epn_in_transfer[EPNUM - 1];
#ifdef USB_HIGH_SPEED
static uint8_t epn_in_mc[EPNUM - 1];
#endif
static struct EP0_TRANSFER ep0_transfer;
static struct HAL_USB_CALLBACKS callbacks;
static volatile enum DEVICE_STATE device_state = ATTACHED;
static uint8_t device_cfg = 0;
static uint8_t currentAlternate;
static uint16_t currentInterface;
static enum USB_SLEEP_T device_sleep_status;
static uint8_t device_pwr_wkup_status;
static uint8_t device_test_mode;
#if defined(USB_SUSPEND) && (defined(PMU_USB_PIN_CHECK) || defined(USB_LPM))
#ifdef USB_LPM
static bool lpm_entry;
#endif
static bool usbdev_timer_active;
static HWTIMER_ID usbdev_timer;
static void hal_usb_stop_usbdev_timer(void);
#endif
static void hal_usb_irq_handler(void);
static void hal_usb_init_ep0_transfer(void) {
ep0_transfer.stage = NONE_STAGE;
ep0_transfer.data = NULL;
ep0_transfer.length = 0;
ep0_transfer.trx_len = 0;
}
static void hal_usb_init_epn_transfer(void) {
memset(&epn_out_transfer[0], 0, sizeof(epn_out_transfer));
memset(&epn_in_transfer[0], 0, sizeof(epn_in_transfer));
}
static void get_setup_packet(uint8_t *data, struct SETUP_PACKET *packet) {
packet->bmRequestType.direction = (data[0] & 0x80) >> 7;
packet->bmRequestType.type = (data[0] & 0x60) >> 5;
packet->bmRequestType.recipient = data[0] & 0x1f;
packet->bRequest = data[1];
packet->wValue = (data[2] | data[3] << 8);
packet->wIndex = (data[4] | data[5] << 8);
packet->wLength = (data[6] | data[7] << 8);
}
static void reset_epn_out_transfer(uint8_t ep) {
bool enabled;
enabled = epn_out_transfer[ep - 1].enabled;
// Clear epn_out_transfer[] before invoking the callback,
// so that ep can be restarted in the callback
memset(&epn_out_transfer[ep - 1], 0, sizeof(epn_out_transfer[0]));
if (enabled && callbacks.epn_recv_compl[ep - 1]) {
callbacks.epn_recv_compl[ep - 1](NULL, 0, XFER_COMPL_ERROR);
}
}
static void reset_epn_in_transfer(uint8_t ep) {
bool enabled;
enabled = epn_in_transfer[ep - 1].enabled;
// Clear epn_in_transfer[] before invoking the callback,
// so that ep can be restarted in the callback
memset(&epn_in_transfer[ep - 1], 0, sizeof(epn_in_transfer[0]));
if (enabled && callbacks.epn_send_compl[ep - 1]) {
callbacks.epn_send_compl[ep - 1](NULL, 0, XFER_COMPL_ERROR);
}
}
static uint32_t get_ep_type(enum EP_DIR dir, uint8_t ep) {
uint32_t type;
if (ep == 0) {
return E_CONTROL;
}
if (dir == EP_OUT) {
type = GET_BITFIELD(usbc->DOEPnCONFIG[ep - 1].DOEPCTL, USBC_EPTYPE);
} else {
type = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPTYPE);
}
return type;
}
static void _set_global_out_nak(void) {
uint32_t start;
uint32_t sts;
uint32_t ep;
usbc->DCTL |= USBC_SGOUTNAK;
start = hal_sys_timer_get();
while (((usbc->GINTSTS & USBC_GOUTNAKEFF) == 0) &&
(hal_sys_timer_get() - start < MS_TO_TICKS(5))) {
if (hal_sys_timer_get() - start >= US_TO_TICKS(60)) {
if ((usbc->GRSTCTL & USBC_DMAREQ) == 0) {
break;
}
}
}
if (usbc->GINTSTS & USBC_GOUTNAKEFF) {
return;
}
start = hal_sys_timer_get();
while ((usbc->GINTSTS & USBC_RXFLVL) &&
(hal_sys_timer_get() - start < MS_TO_TICKS(5))) {
sts = usbc->GRXSTSP;
ep = GET_BITFIELD(sts, USBC_EPNUM);
ASSERT(ep == 0,
"Global OUT NAK: Only ep0 packets can be dropped: ep=%u sts=0x%08X",
ep, sts);
// NOTE:
// Global OUT NAK pattern cannot be read out from GRXSTSP -- consumed by
// controller automatically when poping?
hal_sys_timer_delay(US_TO_TICKS(60));
if (usbc->GINTSTS & USBC_GOUTNAKEFF) {
return;
}
}
ASSERT((usbc->GINTSTS & USBC_GOUTNAKEFF),
"Global OUT NAK: Failed to recover");
}
static void _disable_out_ep(uint8_t ep, uint32_t set, uint32_t clr) {
volatile uint32_t *ctrl;
volatile uint32_t *intr;
uint32_t doepctl;
if (ep >= EPNUM) {
return;
}
if (ep == 0) {
ctrl = &usbc->DOEPCTL0;
intr = &usbc->DOEPINT0;
} else {
ctrl = &usbc->DOEPnCONFIG[ep - 1].DOEPCTL;
intr = &usbc->DOEPnCONFIG[ep - 1].DOEPINT;
}
doepctl = *ctrl;
if ((doepctl & (USBC_EPENA | USBC_USBACTEP)) == 0) {
goto _exit;
}
if ((doepctl & (USBC_EPENA | USBC_NAKSTS)) == USBC_NAKSTS &&
set == USBC_SNAK && clr == 0) {
goto _exit;
}
_set_global_out_nak();
*ctrl |= USBC_SNAK | USBC_USBACTEP | set;
if (clr) {
*ctrl &= ~clr;
}
// EP0 out cannot be disabled, but stalled
if (ep != 0) {
if (doepctl & USBC_EPENA) {
*intr = USBC_EPDISBLD;
*ctrl |= USBC_EPDIS;
while ((*intr & USBC_EPDISBLD) == 0)
;
}
if ((doepctl & USBC_USBACTEP) == 0) {
*ctrl &= ~USBC_USBACTEP;
}
}
usbc->DCTL |= USBC_CGOUTNAK;
_exit:
if (ep > 0) {
reset_epn_out_transfer(ep);
}
}
static void _disable_in_ep(uint8_t ep, uint32_t set, uint32_t clr) {
volatile uint32_t *ctrl;
volatile uint32_t *intr;
uint32_t diepctl;
if (ep >= EPNUM) {
return;
}
if (ep == 0) {
ctrl = &usbc->DIEPCTL0;
intr = &usbc->DIEPINT0;
} else {
ctrl = &usbc->DIEPnCONFIG[ep - 1].DIEPCTL;
intr = &usbc->DIEPnCONFIG[ep - 1].DIEPINT;
}
diepctl = *ctrl;
if ((diepctl & (USBC_EPENA | USBC_USBACTEP)) == 0) {
goto _exit;
}
if ((diepctl & (USBC_EPENA | USBC_NAKSTS)) == USBC_NAKSTS &&
set == USBC_SNAK && clr == 0) {
goto _exit;
}
*intr = USBC_INEPNAKEFF;
*ctrl |= USBC_SNAK | USBC_USBACTEP | set;
if ((diepctl & USBC_EPENA) && (diepctl & USBC_NAKSTS) == 0) {
while ((*intr & USBC_INEPNAKEFF) == 0)
;
*intr = USBC_INEPNAKEFF;
}
if (clr) {
*ctrl &= ~clr;
}
if (diepctl & USBC_EPENA) {
*intr = USBC_EPDISBLD;
*ctrl |= USBC_EPDIS;
while ((*intr & USBC_EPDISBLD) == 0)
;
}
usbc->GRSTCTL = USBC_TXFNUM(ep) | USBC_TXFFLSH;
while ((usbc->GRSTCTL & USBC_TXFFLSH) != 0)
;
if ((diepctl & USBC_USBACTEP) == 0) {
*ctrl &= ~USBC_USBACTEP;
}
_exit:
if (ep > 0) {
reset_epn_in_transfer(ep);
}
}
void hal_usb_disable_ep(enum EP_DIR dir, uint8_t ep) {
USB_TRACE(3, 14, "%s: %d ep%d", __FUNCTION__, dir, ep);
if (dir == EP_OUT) {
_disable_out_ep(ep, USBC_SNAK, 0);
} else {
_disable_in_ep(ep, USBC_SNAK, 0);
}
}
void hal_usb_stall_ep(enum EP_DIR dir, uint8_t ep) {
uint32_t set;
uint32_t clr;
USB_TRACE(3, 13, "%s: %d ep%d", __FUNCTION__, dir, ep);
set = USBC_STALL;
clr = 0;
if (dir == EP_OUT) {
_disable_out_ep(ep, set, clr);
} else {
_disable_in_ep(ep, set, clr);
}
}
void hal_usb_unstall_ep(enum EP_DIR dir, uint8_t ep) {
uint32_t set;
uint32_t clr;
uint8_t type;
USB_TRACE(3, 12, "%s: %d ep%d", __FUNCTION__, dir, ep);
set = USBC_SNAK;
clr = USBC_STALL;
type = get_ep_type(dir, ep);
if (type == E_INTERRUPT || type == E_BULK) {
set |= USBC_SETD0PID;
}
if (hal_usb_get_ep_stall_state(dir, ep) == 0) {
// Ep not in stall state
if (ep != 0 && (type == E_INTERRUPT || type == E_BULK)) {
if (dir == EP_OUT) {
usbc->DOEPnCONFIG[ep - 1].DOEPCTL |= USBC_SETD0PID;
} else {
usbc->DIEPnCONFIG[ep - 1].DIEPCTL |= USBC_SETD0PID;
}
}
return;
}
if (dir == EP_OUT) {
_disable_out_ep(ep, set, clr);
} else {
_disable_in_ep(ep, set, clr);
}
}
int hal_usb_get_ep_stall_state(enum EP_DIR dir, uint8_t ep) {
volatile uint32_t *ctrl;
if (ep >= EPNUM) {
return 0;
}
// Select ctl register
if (ep == 0) {
if (dir == EP_IN) {
ctrl = &usbc->DIEPCTL0;
} else {
ctrl = &usbc->DOEPCTL0;
}
} else {
if (dir == EP_IN) {
ctrl = &usbc->DIEPnCONFIG[ep - 1].DIEPCTL;
} else {
ctrl = &usbc->DOEPnCONFIG[ep - 1].DOEPCTL;
}
}
return ((*ctrl & USBC_STALL) != 0);
}
void hal_usb_stop_ep(enum EP_DIR dir, uint8_t ep) {
USB_TRACE(3, 11, "%s: %d ep%d", __FUNCTION__, dir, ep);
hal_usb_disable_ep(dir, ep);
}
static void hal_usb_stop_all_out_eps(void) {
int i;
volatile uint32_t *ctrl;
volatile uint32_t *intr;
uint32_t doepctl;
USB_FUNC_ENTRY_TRACE(11);
// Enable global out nak
_set_global_out_nak();
for (i = 0; i < EPNUM; i++) {
if (i == 0) {
ctrl = &usbc->DOEPCTL0;
intr = &usbc->DOEPINT0;
} else {
ctrl = &usbc->DOEPnCONFIG[i - 1].DOEPCTL;
intr = &usbc->DOEPnCONFIG[i - 1].DOEPINT;
}
doepctl = *ctrl;
// BUS RESET will clear USBC_USBACTEP but keep USBC_EPENA in ep ctrl
if (doepctl & (USBC_EPENA | USBC_USBACTEP)) {
*ctrl |= USBC_SNAK | USBC_USBACTEP;
// EP0 out cannot be disabled, but stalled
if (i != 0) {
if (doepctl & USBC_EPENA) {
*intr = USBC_EPDISBLD;
*ctrl |= USBC_EPDIS;
while ((*intr & USBC_EPDISBLD) == 0)
;
}
if ((doepctl & USBC_USBACTEP) == 0) {
*ctrl &= ~USBC_USBACTEP;
}
}
}
}
// Disable global out nak
usbc->DCTL |= USBC_CGOUTNAK;
}
static void hal_usb_stop_all_in_eps(void) {
int i;
volatile uint32_t *ctrl;
volatile uint32_t *intr;
uint32_t diepctl;
USB_FUNC_ENTRY_TRACE(11);
usbc->DCTL |= USBC_SGNPINNAK;
while ((usbc->GINTSTS & USBC_GINNAKEFF) == 0)
;
for (i = 0; i < EPNUM; i++) {
if (i == 0) {
ctrl = &usbc->DIEPCTL0;
intr = &usbc->DIEPINT0;
} else {
ctrl = &usbc->DIEPnCONFIG[i - 1].DIEPCTL;
intr = &usbc->DIEPnCONFIG[i - 1].DIEPINT;
}
diepctl = *ctrl;
// BUS RESET will clear USBC_USBACTEP but keep USBC_EPENA in ep ctrl
if (diepctl & (USBC_EPENA | USBC_USBACTEP)) {
*intr = USBC_INEPNAKEFF;
*ctrl |= USBC_SNAK | USBC_USBACTEP;
if ((diepctl & USBC_EPENA) && (diepctl & USBC_NAKSTS) == 0) {
while ((*intr & USBC_INEPNAKEFF) == 0)
;
*intr = USBC_INEPNAKEFF;
}
if (diepctl & USBC_EPENA) {
*intr = USBC_EPDISBLD;
*ctrl |= USBC_EPDIS;
while ((*intr & USBC_EPDISBLD) == 0)
;
}
if ((diepctl & USBC_USBACTEP) == 0) {
*ctrl &= ~USBC_USBACTEP;
}
}
}
// Flush Tx Fifo
usbc->GRSTCTL = USBC_TXFNUM(0x10) | USBC_TXFFLSH | USBC_RXFFLSH;
while ((usbc->GRSTCTL & (USBC_TXFFLSH | USBC_RXFFLSH)) != 0)
;
usbc->DCTL |= USBC_CGNPINNAK;
}
static void hal_usb_flush_tx_fifo(uint8_t ep) {
usbc->DCTL |= USBC_SGNPINNAK;
while ((usbc->GINTSTS & USBC_GINNAKEFF) == 0)
;
while ((usbc->GRSTCTL & USBC_AHBIDLE) == 0)
;
// while ((usbc->GRSTCTL & USBC_TXFFLSH) != 0);
usbc->GRSTCTL = USBC_TXFNUM(ep) | USBC_TXFFLSH;
while ((usbc->GRSTCTL & USBC_TXFFLSH) != 0)
;
usbc->DCTL |= USBC_CGNPINNAK;
}
static void hal_usb_flush_all_tx_fifos(void) { hal_usb_flush_tx_fifo(0x10); }
static void POSSIBLY_UNUSED hal_usb_flush_rx_fifo(void) {
_set_global_out_nak();
usbc->GRSTCTL |= USBC_RXFFLSH;
while ((usbc->GRSTCTL & USBC_RXFFLSH) != 0)
;
usbc->DCTL |= USBC_CGOUTNAK;
}
static void hal_usb_alloc_ep0_fifo(void) {
uint32_t ram_size;
uint32_t ram_avail;
if ((usbc->GHWCFG2 & USBC_DYNFIFOSIZING) == 0) {
return;
}
// All endpoints have been stopped in hal_usb_irq_reset()
// Configure FIFOs
// RX FIFO Calculation
// -------------------
// SETUP Packets : 4 * n + 6
// Global OUT NAK : 1
// DATA Packets + Status Info : (MPS / 4 + 1) * m
// OutEp XFER COMPL : 1 * outEpNum
// OutEp Disable : 1 * outEpNum
#ifdef USB_ISO
#define RXFIFOSIZE \
((4 * CTRL_EPNUM + 6) + 1 + (2 * (USB_FIFO_MPS_ISO_RECV / 4 + 1)) + \
(EPNUM * 2))
#else
#define RXFIFOSIZE \
((4 * CTRL_EPNUM + 6) + 1 + (2 * (USB_MAX_PACKET_SIZE_BULK / 4 + 1)) + \
(EPNUM * 2))
#endif
#define EP0_TXFIFOSIZE (2 * (USB_MAX_PACKET_SIZE_CTRL + 3) / 4)
#if (RXFIFOSIZE + EP0_TXFIFOSIZE > SPFIFORAM_SIZE)
#error "Invalid FIFO size configuration"
#endif
ram_size = GET_BITFIELD(usbc->GDFIFOCFG, USBC_GDFIFOCFG);
ram_avail = GET_BITFIELD(usbc->GDFIFOCFG, USBC_EPINFOBASEADDR);
ASSERT(SPFIFORAM_SIZE == ram_size, "Bad dfifo size: %u (should be %u)",
ram_size, SPFIFORAM_SIZE);
ASSERT(RXFIFOSIZE + EP0_TXFIFOSIZE <= ram_avail,
"Bad dfifo size cfg: rx=%u ep0=%u avail=%u", RXFIFOSIZE,
EP0_TXFIFOSIZE, ram_avail);
// Rx Fifo Size (and init fifo_addr)
usbc->GRXFSIZ = USBC_RXFDEP(RXFIFOSIZE);
fifo_addr = RXFIFOSIZE;
// EP0 / Non-periodic Tx Fifo Size
usbc->GNPTXFSIZ =
USBC_NPTXFSTADDR(fifo_addr) | USBC_NPTXFDEPS(EP0_TXFIFOSIZE);
fifo_addr += EP0_TXFIFOSIZE;
// Flush Tx FIFOs
hal_usb_flush_all_tx_fifos();
}
static void hal_usb_alloc_epn_fifo(uint8_t ep, uint16_t mps) {
uint16_t size;
uint32_t ram_avail;
if (ep == 0 || ep >= EPNUM) {
return;
}
size = (mps + 3) / 4 * 2;
ram_avail = GET_BITFIELD(usbc->GDFIFOCFG, USBC_EPINFOBASEADDR);
ASSERT(fifo_addr + size <= ram_avail,
"Fifo overflow: fifo_addr=%u, size=%u, avail=%u", fifo_addr, size,
ram_avail);
usbc->DTXFSIZE[ep - 1].DIEPTXFn =
USBC_INEPNTXFSTADDR(fifo_addr) | USBC_INEPNTXFDEP(size);
fifo_addr += size;
}
static void hal_usb_soft_reset(void) {
usbc->GRSTCTL |= USBC_CSFTRST;
while ((usbc->GRSTCTL & USBC_CSFTRST) != 0)
;
while ((usbc->GRSTCTL & USBC_AHBIDLE) == 0)
;
}
static void hal_usb_init_phy(void) {
#ifdef USB_HIGH_SPEED
usbc->GUSBCFG |=
USBC_FORCEDEVMODE | USBC_ULPIAUTORES | USBC_ULPIFSLS | USBC_ULPI_UTMI_SEL;
usbc->GUSBCFG &=
~(USBC_FSINTF | USBC_PHYIF | USBC_PHYSEL | USBC_USBTRDTIM_MASK);
#else
usbc->GUSBCFG |= USBC_FORCEDEVMODE | USBC_ULPIAUTORES | USBC_ULPIFSLS |
USBC_PHYSEL | USBC_ULPI_UTMI_SEL;
usbc->GUSBCFG &= ~(USBC_FSINTF | USBC_PHYIF | USBC_USBTRDTIM_MASK);
#endif
// USB turnaround time = 4 * AHB Clock + 1 PHY Clock, in terms of PHY clocks.
// If AHB Clock >= PHY Clock, time can be set to 5.
// If AHB Clock * 2 == PHY Clock, time should be set to 9.
usbc->GUSBCFG |= USBC_USBTRDTIM(5);
}
static void hal_usb_device_init(void) {
int i;
uint8_t speed;
#ifdef CHIP_HAS_USBPHY
usbphy_open();
#endif
#ifdef USB_HIGH_SPEED
#ifdef CHIP_HAS_USBIF
usbif->USBIF_00 &= ~(USBIF_00_CFG_DR_SUSPEND | USBIF_00_CFG_REG_SUSPEND);
usbif->USBIF_08 &= ~USBIF_08_CFG_SEL48M;
#endif
speed = 0;
#else
#ifdef CHIP_HAS_USBIF
usbif->USBIF_00 |= USBIF_00_CFG_DR_SUSPEND | USBIF_00_CFG_REG_SUSPEND;
usbif->USBIF_08 |= USBIF_08_CFG_SEL48M;
#endif
speed = 3;
#endif
#ifdef CHIP_BEST2000
if (hal_get_chip_metal_id() >= HAL_CHIP_METAL_ID_1) {
// dr_suspend and reg_suspend are inverted since metal 1
usbif->USBIF_00 ^= USBIF_00_CFG_DR_SUSPEND | USBIF_00_CFG_REG_SUSPEND;
}
#endif
#ifdef USB_HIGH_SPEED
// Wait until usbphy clock is ready
hal_sys_timer_delay(US_TO_TICKS(60));
#endif
hal_usb_soft_reset();
hal_usb_init_phy();
// Reset after selecting PHY
hal_usb_soft_reset();
// Some core cfg (except for PHY selection) will also be reset during soft
// reset
hal_usb_init_phy();
usbc->DCFG &= ~(USBC_DEVSPD_MASK | USBC_PERFRINT_MASK);
usbc->DCFG |= USBC_DEVSPD(speed) | USBC_NZSTSOUTHSHK | USBC_PERFRINT(0);
// Clear previous interrupts
usbc->GINTMSK = 0;
usbc->GINTSTS = ~0UL;
usbc->DAINTMSK = 0;
usbc->DOEPMSK = 0;
usbc->DIEPMSK = 0;
for (i = 0; i < EPNUM; ++i) {
if (i == 0) {
usbc->DOEPINT0 = ~0UL;
usbc->DIEPINT0 = ~0UL;
} else {
usbc->DOEPnCONFIG[i - 1].DOEPINT = ~0UL;
usbc->DIEPnCONFIG[i - 1].DIEPINT = ~0UL;
}
}
usbc->GINTMSK = USBC_USBRST | USBC_ENUMDONE | USBC_ERLYSUSP | USBC_USBSUSP;
usbc->DCTL &= ~USBC_SFTDISCON;
#if (USB_ISO_INTERVAL > 1)
// Not to check frame number and ignore ISO incomplete interrupts
usbc->DCTL |= USBC_IGNRFRMNUM;
#endif
// Enable DMA mode
// Burst size 16 words
usbc->GAHBCFG = USBC_DMAEN | USBC_HBSTLEN(7);
usbc->GAHBCFG |= USBC_GLBLINTRMSK;
}
static void hal_usb_soft_disconnect(void) {
// Disable global interrupt
usbc->GAHBCFG &= ~USBC_GLBLINTRMSK;
// Soft disconnection
usbc->DCTL |= USBC_SFTDISCON;
hal_usb_device_init();
}
static void enable_usb_irq(void) {
NVIC_SetVector(USB_IRQn, (uint32_t)hal_usb_irq_handler);
#ifdef USB_ISO
NVIC_SetPriority(USB_IRQn, IRQ_PRIORITY_HIGH);
#else
NVIC_SetPriority(USB_IRQn, IRQ_PRIORITY_NORMAL);
#endif
NVIC_ClearPendingIRQ(USB_IRQn);
NVIC_EnableIRQ(USB_IRQn);
}
int hal_usb_open(const struct HAL_USB_CALLBACKS *c, enum HAL_USB_API_MODE m) {
if (c == NULL) {
return 1;
}
if (c->device_desc == NULL || c->cfg_desc == NULL || c->string_desc == NULL ||
c->setcfg == NULL) {
return 2;
}
if (device_state != ATTACHED) {
return 3;
}
device_state = POWERED;
device_sleep_status = USB_SLEEP_NONE;
hal_sysfreq_req(HAL_SYSFREQ_USER_USB, USB_SYS_FREQ);
#if defined(USB_SUSPEND) && (defined(PMU_USB_PIN_CHECK) || defined(USB_LPM))
if (usbdev_timer == NULL) {
usbdev_timer = hwtimer_alloc(NULL, NULL);
ASSERT(usbdev_timer, "Failed to alloc usbdev_timer");
}
#endif
hal_cmu_usb_set_device_mode();
hal_cmu_usb_clock_enable();
memcpy(&callbacks, c, sizeof(callbacks));
if (usbc->GAHBCFG & USBC_GLBLINTRMSK) {
hal_usb_soft_disconnect();
} else {
hal_usb_device_init();
}
enable_usb_irq();
if (m == HAL_USB_API_BLOCKING) {
while (device_state != CONFIGURED)
;
}
return 0;
}
int hal_usb_reopen(const struct HAL_USB_CALLBACKS *c, uint8_t dcfg, uint8_t alt,
uint16_t itf) {
if (c == NULL) {
return 1;
}
if (c->device_desc == NULL || c->cfg_desc == NULL || c->string_desc == NULL ||
c->setcfg == NULL) {
return 2;
}
hal_sysfreq_req(HAL_SYSFREQ_USER_USB, USB_SYS_FREQ);
memcpy(&callbacks, c, sizeof(callbacks));
device_state = CONFIGURED;
device_cfg = dcfg;
currentAlternate = alt;
currentInterface = itf;
enable_usb_irq();
return 0;
}
void hal_usb_close(void) {
#ifdef USB_SUSPEND
#if defined(PMU_USB_PIN_CHECK) || defined(USB_LPM)
// Stop pin check timer
hal_usb_stop_usbdev_timer();
#ifdef PMU_USB_PIN_CHECK
// Disabe PMU pin status check
pmu_usb_disable_pin_status_check();
#endif
#endif
#endif
NVIC_DisableIRQ(USB_IRQn);
device_state = ATTACHED;
// Disable global interrupt
usbc->GAHBCFG &= ~USBC_GLBLINTRMSK;
// Soft disconnection
usbc->DCTL |= USBC_SFTDISCON;
// Soft reset
usbc->GRSTCTL |= USBC_CSFTRST;
usbc->DCTL |= USBC_SFTDISCON;
usbc->GRSTCTL |= USBC_CSFTRST;
// while ((usbc->GRSTCTL & USBC_CSFTRST) != 0);
// while ((usbc->GRSTCTL & USBC_AHBIDLE) == 0);
#ifdef CHIP_HAS_USBPHY
usbphy_close();
#endif
hal_cmu_usb_clock_disable();
memset(&callbacks, 0, sizeof(callbacks));
hal_sysfreq_req(HAL_SYSFREQ_USER_USB, HAL_CMU_FREQ_32K);
}
void hal_usb_detect_disconn(void) {
// NOTE:
// PHY detects the disconnection event by DP/DN voltage level change.
// But DP/DN voltages are provided by vusb ldo inside chip, which has nothing
// to do with VBUS. That is why USB controller cannot generate the
// disconnection interrupt. Meanwhile VBUS detection or charger detection can
// help to generate USB disconnection event via this function.
USB_FUNC_ENTRY_TRACE(26);
if (device_state != ATTACHED && callbacks.state_change) {
callbacks.state_change(HAL_USB_EVENT_DISCONNECT, 0);
}
}
int hal_usb_configured(void) { return (device_state == CONFIGURED); }
int hal_usb_suspended(void) {
return (device_sleep_status == USB_SLEEP_SUSPEND);
}
uint32_t hal_usb_get_soffn(void) {
return GET_BITFIELD(usbc->DSTS, USBC_SOFFN);
}
#ifdef USB_HIGH_SPEED
uint32_t hal_usb_calc_hshb_ep_mps(uint32_t pkt_size) {
// For high speed, high bandwidth endpoints
if (pkt_size <= USB_MAX_PACKET_SIZE_ISO) {
return pkt_size;
} else if (pkt_size > USB_MAX_PACKET_SIZE_ISO &&
pkt_size <= USB_MAX_PACKET_SIZE_ISO * 2) {
return ALIGN(pkt_size / 2, 4);
} else {
// if (pkt_size > USB_MAX_PACKET_SIZE_ISO * 2 && pkt_size <=
// USB_MAX_PACKET_SIZE_ISO * 3)
return ALIGN(pkt_size / 3, 4);
}
}
#endif
int hal_usb_activate_epn(enum EP_DIR dir, uint8_t ep, uint8_t type,
uint16_t mps) {
uint32_t fifo_mps;
USB_TRACE(3, 10, "%s: %d ep%d", __FUNCTION__, dir, ep);
if (ep == 0 || ep >= EPNUM) {
return 1;
}
if (dir == EP_OUT) {
// Stop ep out
if (usbc->DOEPnCONFIG[ep - 1].DOEPCTL & (USBC_EPENA | USBC_USBACTEP)) {
hal_usb_stop_ep(dir, ep);
}
// Config ep out
usbc->DOEPnCONFIG[ep - 1].DOEPCTL = USBC_EPN_MPS(mps) | USBC_EPTYPE(type) |
USBC_USBACTEP | USBC_SNAK |
USBC_SETD0PID;
// Unstall ep out
usbc->DOEPnCONFIG[ep - 1].DOEPCTL &= ~USBC_STALL;
// Unmask ep out interrupt
usbc->DAINTMSK |= USBC_OUTEPMSK(1 << ep);
} else {
fifo_mps = mps;
#ifdef USB_HIGH_SPEED
if (type == E_ISOCHRONOUS || type == E_INTERRUPT) {
if (mps > USB_FIFO_MPS_ISO_SEND) {
fifo_mps = USB_FIFO_MPS_ISO_SEND;
}
epn_in_mc[ep - 1] = 1;
}
#endif
// Stop ep in
if (usbc->DIEPnCONFIG[ep - 1].DIEPCTL & (USBC_EPENA | USBC_USBACTEP)) {
hal_usb_stop_ep(dir, ep);
}
// Config ep in
usbc->DIEPnCONFIG[ep - 1].DIEPCTL = USBC_EPN_MPS(mps) | USBC_EPTYPE(type) |
USBC_USBACTEP | USBC_EPTXFNUM(ep) |
USBC_SNAK | USBC_SETD0PID;
// Allocate tx fifo
hal_usb_alloc_epn_fifo(ep, fifo_mps);
// Unstall ep in
usbc->DIEPnCONFIG[ep - 1].DIEPCTL &= ~USBC_STALL;
// Unmask ep in interrupt
usbc->DAINTMSK |= USBC_INEPMSK(1 << ep);
}
return 0;
}
int hal_usb_deactivate_epn(enum EP_DIR dir, uint8_t ep) {
USB_TRACE(3, 9, "%s: %d ep%d", __FUNCTION__, dir, ep);
if (ep == 0 || ep >= EPNUM) {
return 1;
}
hal_usb_stop_ep(dir, ep);
if (dir == EP_OUT) {
usbc->DOEPnCONFIG[ep - 1].DOEPCTL &= ~USBC_USBACTEP;
// Mask ep out interrupt
usbc->DAINTMSK &= ~USBC_OUTEPMSK(1 << ep);
} else {
usbc->DIEPnCONFIG[ep - 1].DIEPCTL &= ~USBC_USBACTEP;
// Mask ep in interrupt
usbc->DAINTMSK &= ~USBC_INEPMSK(1 << ep);
}
return 0;
}
// NOTE: Not support send epn mps change, which will involve tx fifo
// reallocation
int hal_usb_update_recv_epn_mps(uint8_t ep, uint16_t mps) {
uint8_t type;
USB_TRACE(3, 9, "%s: ep%d mps=%u", __FUNCTION__, ep, mps);
if (ep == 0 || ep >= EPNUM) {
return 1;
}
if ((usbc->DOEPnCONFIG[ep - 1].DOEPCTL & USBC_USBACTEP) == 0) {
return 2;
}
hal_usb_stop_ep(EP_OUT, ep);
usbc->DOEPnCONFIG[ep - 1].DOEPCTL &= ~USBC_USBACTEP;
// Mask ep out interrupt
usbc->DAINTMSK &= ~USBC_OUTEPMSK(1 << ep);
// Config ep out
type = GET_BITFIELD(usbc->DOEPnCONFIG[ep - 1].DOEPCTL, USBC_EPTYPE);
usbc->DOEPnCONFIG[ep - 1].DOEPCTL = USBC_EPN_MPS(mps) | USBC_EPTYPE(type) |
USBC_USBACTEP | USBC_SNAK | USBC_SETD0PID;
// Unmask ep out interrupt
usbc->DAINTMSK |= USBC_OUTEPMSK(1 << ep);
return 0;
}
int hal_usb_update_send_epn_mc(uint8_t ep, uint8_t mc) {
#ifdef USB_HIGH_SPEED
uint8_t type;
USB_TRACE(3, 9, "%s: ep%d mc=%u", __FUNCTION__, ep, mc);
if (ep == 0 || ep >= EPNUM) {
return 1;
}
if (mc < 1 || mc > 3) {
return 3;
}
if ((usbc->DIEPnCONFIG[ep - 1].DIEPCTL & USBC_USBACTEP) == 0) {
return 2;
}
type = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPTYPE);
if (type == E_INTERRUPT || type == E_ISOCHRONOUS) {
epn_in_mc[ep - 1] = mc;
return 0;
}
#endif
return 4;
}
static void hal_usb_recv_ep0(void) {
USB_FUNC_ENTRY_TRACE(8);
// Enable EP0 to receive a new setup packet
usbc->DOEPTSIZ0 = USBC_SUPCNT(3) |
USBC_OEPXFERSIZE0(USB_MAX_PACKET_SIZE_CTRL) |
USBC_OEPPKTCNT0;
usbc->DOEPDMA0 = (uint32_t)ep0_out_buffer;
usbc->DOEPINT0 = usbc->DOEPINT0;
usbc->DOEPCTL0 |= USBC_CNAK | USBC_EPENA;
}
static void hal_usb_send_ep0(const uint8_t *data, uint16_t size) {
USB_TRACE(2, 8, "%s: %d", __FUNCTION__, size);
ASSERT(size <= USB_MAX_PACKET_SIZE_CTRL, "Invalid ep0 send size: %d", size);
if (data && size) {
memcpy(ep0_in_buffer, data, size);
}
// Enable EP0 to send one packet
usbc->DIEPTSIZ0 = USBC_IEPXFERSIZE0(size) | USBC_IEPPKTCNT0(1);
usbc->DIEPDMA0 = (uint32_t)ep0_in_buffer;
usbc->DIEPINT0 = usbc->DIEPINT0;
usbc->DIEPCTL0 |= USBC_CNAK | USBC_EPENA;
}
int hal_usb_recv_epn(uint8_t ep, uint8_t *buffer, uint32_t size) {
uint16_t mps;
uint32_t pkt;
uint32_t xfer;
uint32_t fn = 0;
#ifdef USB_ISO
bool isoEp;
uint32_t lock;
#endif
USB_TRACE(3, 7, "%s: ep%d %d", __FUNCTION__, ep, size);
if (device_state != CONFIGURED) {
return 1;
}
if (ep == 0 || ep > EPNUM) {
return 2;
}
if (((uint32_t)buffer & 0x3) != 0) {
return 3;
}
if (epn_out_transfer[ep - 1].data != NULL) {
return 4;
}
if ((usbc->DOEPnCONFIG[ep - 1].DOEPCTL & USBC_USBACTEP) == 0) {
return 5;
}
mps = GET_BITFIELD(usbc->DOEPnCONFIG[ep - 1].DOEPCTL, USBC_EPN_MPS);
mps = ALIGN(mps, 4);
if (size < mps) {
return 6;
}
if (size > EPN_MAX_XFERSIZE) {
return 7;
}
pkt = size / mps;
if (pkt > EPN_MAX_PKTCNT) {
return 8;
}
xfer = pkt * mps;
if (size != xfer) {
return 9;
}
usbc->DOEPnCONFIG[ep - 1].DOEPTSIZ =
USBC_OEPXFERSIZE(xfer) | USBC_OEPPKTCNT(pkt);
usbc->DOEPnCONFIG[ep - 1].DOEPDMA = (uint32_t)buffer;
usbc->DOEPnCONFIG[ep - 1].DOEPINT = usbc->DOEPnCONFIG[ep - 1].DOEPINT;
epn_out_transfer[ep - 1].data = buffer;
epn_out_transfer[ep - 1].length = xfer;
epn_out_transfer[ep - 1].enabled = true;
#ifdef USB_ISO
if (GET_BITFIELD(usbc->DOEPnCONFIG[ep - 1].DOEPCTL, USBC_EPTYPE) ==
E_ISOCHRONOUS) {
isoEp = true;
} else {
isoEp = false;
}
if (isoEp) {
// Set the frame number in time
lock = int_lock();
// Get next frame number
if (GET_BITFIELD(usbc->DSTS, USBC_SOFFN) & 0x1) {
fn = USBC_SETD0PID;
} else {
fn = USBC_SETD1PID;
}
}
#endif
usbc->DOEPnCONFIG[ep - 1].DOEPCTL |= USBC_EPENA | USBC_CNAK | fn;
#ifdef USB_ISO
if (isoEp) {
int_unlock(lock);
}
#endif
return 0;
}
int hal_usb_send_epn(uint8_t ep, const uint8_t *buffer, uint32_t size,
enum ZLP_STATE zlp) {
uint16_t mps;
uint8_t type;
uint32_t pkt;
uint32_t fn = 0;
#ifdef USB_ISO
bool isoEp;
uint32_t lock;
#endif
USB_TRACE(3, 6, "%s: ep%d %d", __FUNCTION__, ep, size);
if (device_state != CONFIGURED) {
return 1;
}
if (ep == 0 || ep > EPNUM) {
return 2;
}
if (((uint32_t)buffer & 0x3) != 0) {
return 3;
}
if (epn_in_transfer[ep - 1].data != NULL) {
return 4;
}
if ((usbc->DIEPnCONFIG[ep - 1].DIEPCTL & USBC_USBACTEP) == 0) {
return 5;
}
if (size > EPN_MAX_XFERSIZE) {
return 7;
}
mps = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPN_MPS);
if (size <= mps) {
// Also taking care of 0 size packet
pkt = 1;
} else {
// If mps is not aligned in 4 bytes, application should add padding at the
// end of each packet to make sure a new packet always starts at 4-byte
// boundary
pkt = (size + mps - 1) / mps;
if (pkt > EPN_MAX_PKTCNT) {
return 8;
}
}
type = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPTYPE);
if (type == E_INTERRUPT || type == E_ISOCHRONOUS) {
#ifdef USB_HIGH_SPEED
if (pkt != epn_in_mc[ep - 1] && (pkt % epn_in_mc[ep - 1])) {
// MC is the pkt cnt must be sent in every (micro)frame.
// The total pkt cnt should be integral multiple of MC value.
return 9;
}
#endif
// Never send a zero length packet at the end of transfer
epn_in_transfer[ep - 1].zero_len_pkt = false;
usbc->DIEPnCONFIG[ep - 1].DIEPTSIZ = USBC_IEPXFERSIZE(size) |
USBC_IEPPKTCNT(pkt) |
#ifdef USB_HIGH_SPEED
USBC_MC(epn_in_mc[ep - 1]);
#else
USBC_MC(1);
#endif
} else {
// Check if a zero length packet is needed at the end of transfer
if (zlp == ZLP_AUTO) {
epn_in_transfer[ep - 1].zero_len_pkt = ((size % mps) == 0);
} else {
epn_in_transfer[ep - 1].zero_len_pkt = false;
}
usbc->DIEPnCONFIG[ep - 1].DIEPTSIZ =
USBC_IEPXFERSIZE(size) | USBC_IEPPKTCNT(pkt);
}
usbc->DIEPnCONFIG[ep - 1].DIEPDMA = (uint32_t)buffer;
usbc->DIEPnCONFIG[ep - 1].DIEPINT = usbc->DIEPnCONFIG[ep - 1].DIEPINT;
epn_in_transfer[ep - 1].data = buffer;
epn_in_transfer[ep - 1].length = size;
epn_in_transfer[ep - 1].pkt_cnt = pkt;
epn_in_transfer[ep - 1].enabled = true;
#ifdef USB_ISO
if (GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPTYPE) ==
E_ISOCHRONOUS) {
isoEp = true;
} else {
isoEp = false;
}
if (isoEp) {
// Set the frame number in time
lock = int_lock();
// Get next frame number
if (GET_BITFIELD(usbc->DSTS, USBC_SOFFN) & 0x1) {
fn = USBC_SETD0PID;
} else {
fn = USBC_SETD1PID;
}
}
#endif
usbc->DIEPnCONFIG[ep - 1].DIEPCTL |= USBC_EPENA | USBC_CNAK | fn;
#ifdef USB_ISO
if (isoEp) {
int_unlock(lock);
}
#endif
return 0;
}
static void hal_usb_recv_epn_complete(uint8_t ep, uint32_t statusEp) {
uint8_t *data;
uint32_t size;
uint32_t doeptsiz;
enum XFER_COMPL_STATE state = XFER_COMPL_SUCCESS;
USB_TRACE(3, 5, "%s: ep%d 0x%08x", __FUNCTION__, ep, statusEp);
if (!epn_out_transfer[ep - 1].enabled) {
return;
}
doeptsiz = usbc->DOEPnCONFIG[ep - 1].DOEPTSIZ;
data = epn_out_transfer[ep - 1].data;
size = GET_BITFIELD(doeptsiz, USBC_OEPXFERSIZE);
ASSERT(size <= epn_out_transfer[ep - 1].length,
"Invalid xfer size: size=%d, len=%d", size,
epn_out_transfer[ep - 1].length);
size = epn_out_transfer[ep - 1].length - size;
#ifdef USB_ISO
uint32_t doepctl = usbc->DOEPnCONFIG[ep - 1].DOEPCTL;
if (GET_BITFIELD(doepctl, USBC_EPTYPE) == E_ISOCHRONOUS) {
#if (USB_ISO_INTERVAL == 1)
#if 1
if (GET_BITFIELD(doeptsiz, USBC_OEPPKTCNT) != 0) {
state = XFER_COMPL_ERROR;
}
#else
uint32_t rxdpid = GET_BITFIELD(doeptsiz, USBC_RXDPID);
uint32_t pkt =
epn_out_transfer[ep - 1].length / GET_BITFIELD(doepctl, USBC_EPN_MPS) -
GET_BITFIELD(doeptsiz, USBC_OEPPKTCNT);
if ((rxdpid == DATA_PID_DATA0 && pkt != 1) ||
(rxdpid == DATA_PID_DATA1 && pkt != 2) ||
(rxdpid == DATA_PID_DATA2 && pkt != 3)) {
state = XFER_COMPL_ERROR;
}
#endif
#else // USB_ISO_INTERVAL != 1
if (statusEp & USBC_PKTDRPSTS) {
state = XFER_COMPL_ERROR;
}
#endif // USB_ISO_INTERVAL != 1
}
#endif // USB_ISO
// Clear epn_out_transfer[] before invoking the callback,
// so that ep can be restarted in the callback
memset(&epn_out_transfer[ep - 1], 0, sizeof(epn_out_transfer[0]));
if (callbacks.epn_recv_compl[ep - 1]) {
callbacks.epn_recv_compl[ep - 1](data, size, state);
}
}
static void hal_usb_send_epn_complete(uint8_t ep, uint32_t statusEp) {
const uint8_t *data;
uint32_t size;
uint16_t pkt, mps;
uint8_t type;
uint32_t mc;
enum XFER_COMPL_STATE state = XFER_COMPL_SUCCESS;
USB_TRACE(3, 4, "%s: ep%d 0x%08x", __FUNCTION__, ep, statusEp);
if (!epn_in_transfer[ep - 1].enabled) {
return;
}
if ((statusEp & USBC_XFERCOMPLMSK) == 0) {
state = XFER_COMPL_ERROR;
}
pkt = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPTSIZ, USBC_IEPPKTCNT);
if (pkt != 0) {
state = XFER_COMPL_ERROR;
mps = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPN_MPS);
ASSERT(pkt <= epn_in_transfer[ep - 1].pkt_cnt,
"Invalid pkt cnt: pkt=%d, pkt_cnt=%d", pkt,
epn_in_transfer[ep - 1].pkt_cnt);
size = (epn_in_transfer[ep - 1].pkt_cnt - pkt) * mps;
} else {
size = epn_in_transfer[ep - 1].length;
}
if (state == XFER_COMPL_SUCCESS && epn_in_transfer[ep - 1].zero_len_pkt) {
epn_in_transfer[ep - 1].zero_len_pkt = false;
// Send the last zero length packet, except for isochronous/interrupt
// endpoints
type = GET_BITFIELD(usbc->DIEPnCONFIG[ep - 1].DIEPCTL, USBC_EPTYPE);
if (type == E_INTERRUPT || type == E_ISOCHRONOUS) {
#ifdef USB_HIGH_SPEED
mc = USBC_MC(epn_in_mc[ep - 1]);
#else
mc = USBC_MC(1);
#endif
} else {
mc = 0;
}
usbc->DIEPnCONFIG[ep - 1].DIEPTSIZ =
USBC_IEPXFERSIZE(0) | USBC_IEPPKTCNT(1) | mc;
usbc->DIEPnCONFIG[ep - 1].DIEPCTL |= USBC_EPENA | USBC_CNAK;
} else {
data = epn_in_transfer[ep - 1].data;
// Clear epn_in_transfer[] before invoking the callback,
// so that ep can be restarted in the callback
memset(&epn_in_transfer[ep - 1], 0, sizeof(epn_in_transfer[0]));
if (state != XFER_COMPL_SUCCESS) {
// The callback will not be invoked when stopping ep,
// for epn_in_transfer[] has been cleared
hal_usb_stop_ep(EP_IN, ep);
}
if (callbacks.epn_send_compl[ep - 1]) {
callbacks.epn_send_compl[ep - 1](data, size, state);
}
}
}
static bool requestSetAddress(void) {
USB_FUNC_ENTRY_TRACE(25);
/* Set the device address */
usbc->DCFG =
SET_BITFIELD(usbc->DCFG, USBC_DEVADDR, ep0_transfer.setup_pkt.wValue);
ep0_transfer.stage = STATUS_IN_STAGE;
if (ep0_transfer.setup_pkt.wValue == 0) {
device_state = DEFAULT;
} else {
device_state = ADDRESS;
}
return true;
}
static bool requestSetConfiguration(void) {
USB_FUNC_ENTRY_TRACE(24);
device_cfg = ep0_transfer.setup_pkt.wValue;
/* Set the device configuration */
if (device_cfg == 0) {
/* Not configured */
device_state = ADDRESS;
} else {
if (callbacks.setcfg && callbacks.setcfg(device_cfg)) {
/* Valid configuration */
device_state = CONFIGURED;
ep0_transfer.stage = STATUS_IN_STAGE;
} else {
return false;
}
}
return true;
}
static bool requestGetConfiguration(void) {
USB_FUNC_ENTRY_TRACE(23);
/* Send the device configuration */
ep0_transfer.data = &device_cfg;
ep0_transfer.length = sizeof(device_cfg);
ep0_transfer.stage = DATA_IN_STAGE;
return true;
}
static bool requestGetInterface(void) {
USB_FUNC_ENTRY_TRACE(22);
/* Return the selected alternate setting for an interface */
if (device_state != CONFIGURED) {
return false;
}
/* Send the alternate setting */
ep0_transfer.setup_pkt.wIndex = currentInterface;
ep0_transfer.data = &currentAlternate;
ep0_transfer.length = sizeof(currentAlternate);
ep0_transfer.stage = DATA_IN_STAGE;
return true;
}
static bool requestSetInterface(void) {
bool success = false;
USB_FUNC_ENTRY_TRACE(21);
if (callbacks.setitf && callbacks.setitf(ep0_transfer.setup_pkt.wIndex,
ep0_transfer.setup_pkt.wValue)) {
success = true;
currentInterface = ep0_transfer.setup_pkt.wIndex;
currentAlternate = ep0_transfer.setup_pkt.wValue;
ep0_transfer.stage = STATUS_IN_STAGE;
}
return success;
}
static bool requestSetFeature(void) {
bool success = false;
USB_FUNC_ENTRY_TRACE(20);
if (device_state != CONFIGURED) {
/* Endpoint or interface must be zero */
if (ep0_transfer.setup_pkt.wIndex != 0) {
return false;
}
}
switch (ep0_transfer.setup_pkt.bmRequestType.recipient) {
case DEVICE_RECIPIENT:
if (ep0_transfer.setup_pkt.wValue == TEST_MODE) {
// TODO: Check test mode
device_test_mode = (ep0_transfer.setup_pkt.wIndex >> 8);
success = true;
}
#ifdef USB_SUSPEND
else if (ep0_transfer.setup_pkt.wValue == DEVICE_REMOTE_WAKEUP) {
if (callbacks.set_remote_wakeup) {
callbacks.set_remote_wakeup(1);
device_pwr_wkup_status |= DEVICE_STATUS_REMOTE_WAKEUP;
success = true;
}
}
#endif
break;
case ENDPOINT_RECIPIENT:
if (ep0_transfer.setup_pkt.wValue == ENDPOINT_HALT) {
// TODO: Check endpoint number
hal_usb_stall_ep((ep0_transfer.setup_pkt.wIndex & 0x80) ? EP_IN : EP_OUT,
ep0_transfer.setup_pkt.wIndex & 0xF);
if (callbacks.state_change) {
callbacks.state_change(HAL_USB_EVENT_STALL,
ep0_transfer.setup_pkt.wIndex & 0xFF);
}
success = true;
}
break;
default:
break;
}
ep0_transfer.stage = STATUS_IN_STAGE;
return success;
}
static bool requestClearFeature(void) {
bool success = false;
USB_FUNC_ENTRY_TRACE(19);
if (device_state != CONFIGURED) {
/* Endpoint or interface must be zero */
if (ep0_transfer.setup_pkt.wIndex != 0) {
return false;
}
}
switch (ep0_transfer.setup_pkt.bmRequestType.recipient) {
case DEVICE_RECIPIENT:
#ifdef USB_SUSPEND
if (ep0_transfer.setup_pkt.wValue == DEVICE_REMOTE_WAKEUP) {
if (callbacks.set_remote_wakeup) {
callbacks.set_remote_wakeup(0);
device_pwr_wkup_status &= ~DEVICE_STATUS_REMOTE_WAKEUP;
success = true;
}
}
#endif
break;
case ENDPOINT_RECIPIENT:
/* TODO: We should check that the endpoint number is valid */
if (ep0_transfer.setup_pkt.wValue == ENDPOINT_HALT) {
hal_usb_unstall_ep((ep0_transfer.setup_pkt.wIndex & 0x80) ? EP_IN
: EP_OUT,
ep0_transfer.setup_pkt.wIndex & 0xF);
if (callbacks.state_change) {
callbacks.state_change(HAL_USB_EVENT_UNSTALL,
ep0_transfer.setup_pkt.wIndex & 0xFF);
}
success = true;
}
break;
default:
break;
}
ep0_transfer.stage = STATUS_IN_STAGE;
return success;
}
static bool requestGetStatus(void) {
static uint16_t status;
bool success = false;
USB_FUNC_ENTRY_TRACE(18);
if (device_state != CONFIGURED) {
/* Endpoint or interface must be zero */
if (ep0_transfer.setup_pkt.wIndex != 0) {
return false;
}
}
switch (ep0_transfer.setup_pkt.bmRequestType.recipient) {
case DEVICE_RECIPIENT:
status = device_pwr_wkup_status;
success = true;
break;
case INTERFACE_RECIPIENT:
status = 0;
success = true;
break;
case ENDPOINT_RECIPIENT:
/* TODO: We should check that the endpoint number is valid */
if (hal_usb_get_ep_stall_state(
(ep0_transfer.setup_pkt.wIndex & 0x80) ? EP_IN : EP_OUT,
ep0_transfer.setup_pkt.wIndex & 0xF)) {
status = ENDPOINT_STATUS_HALT;
} else {
status = 0;
}
success = true;
break;
default:
break;
}
if (success) {
/* Send the status */
ep0_transfer.data = (uint8_t *)&status; /* Assumes little endian */
ep0_transfer.length = sizeof(status);
ep0_transfer.stage = DATA_IN_STAGE;
}
return success;
}
static bool requestGetDescriptor(void) {
bool success = false;
uint8_t type;
uint8_t index;
uint8_t *desc;
type = DESCRIPTOR_TYPE(ep0_transfer.setup_pkt.wValue);
index = DESCRIPTOR_INDEX(ep0_transfer.setup_pkt.wValue);
USB_TRACE(3, 3, "%s: %d %d", __FUNCTION__, type, index);
switch (type) {
case DEVICE_DESCRIPTOR:
desc = (uint8_t *)callbacks.device_desc(type);
if (desc != NULL) {
if ((desc[0] == DEVICE_DESCRIPTOR_LENGTH) &&
(desc[1] == DEVICE_DESCRIPTOR)) {
ep0_transfer.length = desc[0];
ep0_transfer.data = desc;
success = true;
}
}
break;
case CONFIGURATION_DESCRIPTOR:
desc = (uint8_t *)callbacks.cfg_desc(index);
if (desc != NULL) {
if ((desc[0] == CONFIGURATION_DESCRIPTOR_LENGTH) &&
(desc[1] == CONFIGURATION_DESCRIPTOR)) {
/* Get wTotalLength */
ep0_transfer.length = desc[2] | (desc[3] << 8);
ep0_transfer.data = desc;
// Get self-powered status
if ((desc[7] >> 6) & 0x01) {
device_pwr_wkup_status |= DEVICE_STATUS_SELF_POWERED;
} else {
device_pwr_wkup_status &= ~DEVICE_STATUS_SELF_POWERED;
}
success = true;
}
}
break;
case STRING_DESCRIPTOR:
ep0_transfer.data = (uint8_t *)callbacks.string_desc(index);
if (ep0_transfer.data) {
ep0_transfer.length = ep0_transfer.data[0];
success = true;
}
break;
case INTERFACE_DESCRIPTOR:
case ENDPOINT_DESCRIPTOR:
/* TODO: Support is optional, not implemented here */
break;
case QUALIFIER_DESCRIPTOR:
#ifdef USB_HIGH_SPEED
desc = (uint8_t *)callbacks.device_desc(type);
if (desc != NULL) {
if (desc[0] == QUALIFIER_DESCRIPTOR_LENGTH && desc[1] == type) {
ep0_transfer.length = desc[0];
ep0_transfer.data = desc;
success = true;
}
}
#endif
break;
case BOS_DESCRIPTOR:
#ifdef USB_HIGH_SPEED
desc = (uint8_t *)callbacks.device_desc(type);
if (desc != NULL) {
if (desc[0] == BOS_DESCRIPTOR_LENGTH && desc[1] == type) {
// Total length
ep0_transfer.length = desc[2];
ep0_transfer.data = desc;
success = true;
}
}
#endif
break;
default:
// Might be a class or vendor specific descriptor, which
// should be handled in setuprecv callback
USB_TRACE(1, 0, "*** Error: Unknown desc type: %d", type);
break;
}
if (success) {
ep0_transfer.stage = DATA_IN_STAGE;
}
return success;
}
static void hal_usb_reset_all_transfers(void) {
int ep;
USB_FUNC_ENTRY_TRACE(31);
for (ep = 1; ep < EPNUM; ep++) {
reset_epn_out_transfer(ep);
reset_epn_in_transfer(ep);
}
}
static bool hal_usb_handle_setup(void) {
bool success = false;
enum DEVICE_STATE old_state;
USB_FUNC_ENTRY_TRACE(17);
old_state = device_state;
/* Process standard requests */
if (ep0_transfer.setup_pkt.bmRequestType.type == STANDARD_TYPE) {
switch (ep0_transfer.setup_pkt.bRequest) {
case GET_STATUS:
success = requestGetStatus();
break;
case CLEAR_FEATURE:
success = requestClearFeature();
break;
case SET_FEATURE:
success = requestSetFeature();
break;
case SET_ADDRESS:
success = requestSetAddress();
break;
case GET_DESCRIPTOR:
success = requestGetDescriptor();
break;
case SET_DESCRIPTOR:
/* TODO: Support is optional, not implemented here */
success = false;
break;
case GET_CONFIGURATION:
success = requestGetConfiguration();
break;
case SET_CONFIGURATION:
success = requestSetConfiguration();
break;
case GET_INTERFACE:
success = requestGetInterface();
break;
case SET_INTERFACE:
success = requestSetInterface();
break;
default:
break;
}
}
if (old_state == CONFIGURED && device_state != CONFIGURED) {
hal_usb_reset_all_transfers();
}
return success;
}
static int hal_usb_ep0_setup_stage(uint32_t statusEp) {
uint8_t *data;
uint8_t setup_cnt;
uint16_t pkt_len;
// Skip the check on IN/OUT tokens
usbc->DOEPMSK &= ~USBC_OUTTKNEPDISMSK;
usbc->DIEPMSK &= ~USBC_INTKNTXFEMPMSK;
if (statusEp & USBC_BACK2BACKSETUP) {
data = (uint8_t *)(usbc->DOEPDMA0 - 8);
} else {
setup_cnt = GET_BITFIELD(usbc->DOEPTSIZ0, USBC_SUPCNT);
if (setup_cnt >= 3) {
setup_cnt = 2;
}
data = (uint8_t *)((uint32_t)ep0_out_buffer + 8 * (2 - setup_cnt));
}
// Init new transfer
hal_usb_init_ep0_transfer();
ep0_transfer.stage = SETUP_STAGE;
get_setup_packet(data, &ep0_transfer.setup_pkt);
USB_TRACE(5, 2, "Got SETUP type=%d, req=0x%x, val=0x%x, idx=0x%x, len=%d",
ep0_transfer.setup_pkt.bmRequestType.type,
ep0_transfer.setup_pkt.bRequest, ep0_transfer.setup_pkt.wValue,
ep0_transfer.setup_pkt.wIndex, ep0_transfer.setup_pkt.wLength);
if (ep0_transfer.setup_pkt.wLength == 0 &&
ep0_transfer.setup_pkt.bmRequestType.direction != EP_OUT) {
USB_TRACE(0, 0, "*** Error: Ep0 dir should be out if wLength=0");
return 1;
}
if (callbacks.setuprecv == NULL || !callbacks.setuprecv(&ep0_transfer)) {
if (!hal_usb_handle_setup()) {
return 1;
}
}
#if 0
if (ep0_transfer.setup_pkt.wLength == 0) {
ep0_transfer.setup_pkt.bmRequestType.direction = EP_OUT;
}
#endif
if (ep0_transfer.stage == DATA_OUT_STAGE) {
if (ep0_transfer.data == NULL) {
ep0_transfer.data = (uint8_t *)ep0_out_buffer;
}
} else if (ep0_transfer.stage == DATA_IN_STAGE) {
if (ep0_transfer.length > ep0_transfer.setup_pkt.wLength) {
ep0_transfer.length = ep0_transfer.setup_pkt.wLength;
}
pkt_len = ep0_transfer.length;
if (pkt_len > USB_MAX_PACKET_SIZE_CTRL) {
pkt_len = USB_MAX_PACKET_SIZE_CTRL;
}
hal_usb_send_ep0(ep0_transfer.data, pkt_len);
} else if (ep0_transfer.stage == STATUS_IN_STAGE) {
hal_usb_send_ep0(NULL, 0);
} else {
USB_TRACE(1, 0, "*** Setup stage switches to invalid stage: %d",
ep0_transfer.stage);
return 1;
}
return 0;
}
static int hal_usb_ep0_data_out_stage(void) {
uint16_t pkt_len;
uint16_t reg_size;
reg_size = GET_BITFIELD(usbc->DOEPTSIZ0, USBC_OEPXFERSIZE0);
ASSERT(reg_size <= USB_MAX_PACKET_SIZE_CTRL, "Invalid ep0 recv size");
pkt_len = MIN(USB_MAX_PACKET_SIZE_CTRL - reg_size,
(uint16_t)(ep0_transfer.length - ep0_transfer.trx_len));
ASSERT(ep0_transfer.length >= ep0_transfer.trx_len + pkt_len,
"Invalid ep0 recv len: length=%u trx_len=%u pkt_len=%u",
ep0_transfer.length, ep0_transfer.trx_len, pkt_len);
memcpy(ep0_transfer.data + ep0_transfer.trx_len, ep0_out_buffer, pkt_len);
ep0_transfer.trx_len += pkt_len;
// Always enable setup packet receiving
// CAUTION: Start ep0 recv before invoking datarecv callbacks to handle all
// kinds of endpoints.
// Some USBC events are triggered by patterns in receive FIFO, only
// when these patterns are popped by the core (DMA reading) or the
// application (usbc->GRXSTSP reading). E.g., Global OUT NAK
// (DCTL.SGOUTNak) triggers GINTSTS.GOUTNakEff, but the interrupt
// will never raise in data out stage without DMA or usbc->GRXSTSP
// reading.
hal_usb_recv_ep0();
pkt_len = ep0_transfer.length - ep0_transfer.trx_len;
if (pkt_len == 0) {
if (callbacks.datarecv == NULL || !callbacks.datarecv(&ep0_transfer)) {
// hal_usb_stall_ep(EP_OUT, 0);
// hal_usb_stall_ep(EP_IN, 0);
// return;
}
ep0_transfer.stage = STATUS_IN_STAGE;
// Check error on IN/OUT tokens
usbc->DOEPMSK |= USBC_OUTTKNEPDISMSK;
// Send status packet
hal_usb_send_ep0(NULL, 0);
} else {
// Receive next data packet
}
return 0;
}
static int hal_usb_ep0_data_in_stage(void) {
uint16_t pkt_len;
bool zero_len_pkt = false;
ASSERT(GET_BITFIELD(usbc->DIEPTSIZ0, USBC_IEPPKTCNT0) == 0,
"Invalid ep0 sent pkt cnt");
ASSERT(ep0_transfer.length >= ep0_transfer.trx_len,
"Invalid ep0 sent len 1: length=%u trx_len=%u", ep0_transfer.length,
ep0_transfer.trx_len);
pkt_len = ep0_transfer.length - ep0_transfer.trx_len;
if (pkt_len == 0) {
// The last zero length packet was sent successfully
ep0_transfer.stage = STATUS_OUT_STAGE;
// Receive status packet (receiving is always enabled)
} else {
// Update sent count
if (pkt_len == USB_MAX_PACKET_SIZE_CTRL) {
zero_len_pkt = true;
} else if (pkt_len > USB_MAX_PACKET_SIZE_CTRL) {
pkt_len = USB_MAX_PACKET_SIZE_CTRL;
}
ep0_transfer.trx_len += pkt_len;
ASSERT(ep0_transfer.length >= ep0_transfer.trx_len,
"Invalid ep0 sent len 2: length=%u trx_len=%u", ep0_transfer.length,
ep0_transfer.trx_len);
// Send next packet
pkt_len = ep0_transfer.length - ep0_transfer.trx_len;
if (pkt_len > USB_MAX_PACKET_SIZE_CTRL) {
pkt_len = USB_MAX_PACKET_SIZE_CTRL;
}
if (pkt_len == 0) {
if (zero_len_pkt) {
// Send the last zero length packet
hal_usb_send_ep0(NULL, 0);
} else {
ep0_transfer.stage = STATUS_OUT_STAGE;
// Check error on IN/OUT tokens
usbc->DIEPMSK |= USBC_INTKNTXFEMPMSK;
// Receive status packet (receiving is always enabled)
}
} else {
hal_usb_send_ep0(ep0_transfer.data + ep0_transfer.trx_len, pkt_len);
}
}
return 0;
}
static int hal_usb_ep0_status_stage(void) {
// Done with status packet
ep0_transfer.stage = NONE_STAGE;
// Skip the check on IN/OUT tokens
usbc->DOEPMSK &= ~USBC_OUTTKNEPDISMSK;
usbc->DIEPMSK &= ~USBC_INTKNTXFEMPMSK;
return 0;
}
static void hal_usb_ep0_test_mode_check(void) {
if (device_test_mode) {
usbc->DCTL = SET_BITFIELD(usbc->DCTL, USBC_TSTCTL, device_test_mode);
device_test_mode = 0;
}
}
static void hal_usb_handle_ep0_packet(enum EP_DIR dir, uint32_t statusEp) {
int ret;
USB_TRACE(3, 16, "%s: dir=%d, statusEp=0x%08x", __FUNCTION__, dir, statusEp);
if (dir == EP_OUT) {
if ((statusEp & (USBC_XFERCOMPL | USBC_STSPHSERCVD)) ==
(USBC_XFERCOMPL | USBC_STSPHSERCVD)) {
// From Linux driver
if (GET_BITFIELD(usbc->DOEPTSIZ0, USBC_OEPXFERSIZE0) ==
USB_MAX_PACKET_SIZE_CTRL &&
(usbc->DOEPTSIZ0 & USBC_OEPPKTCNT0)) {
// Abnormal case
USB_TRACE(
2, 0,
"*** EP0 OUT empty compl with stsphsercvd: stage=%d, size=0x%08x",
ep0_transfer.stage, usbc->DOEPTSIZ0);
// Always enable setup packet receiving
hal_usb_recv_ep0();
return;
}
}
if (statusEp & USBC_XFERCOMPL) {
// New packet received
if (statusEp & USBC_SETUP) {
// Clean previous transfer
if (ep0_transfer.stage != NONE_STAGE) {
USB_TRACE(1, 0, "*** Setup stage breaks previous stage %d",
ep0_transfer.stage);
hal_usb_stop_ep(EP_IN, 0);
}
// New setup packet
ep0_transfer.stage = SETUP_STAGE;
} else if (statusEp & USBC_STUPPKTRCVD) {
// Clean previous transfer
if (ep0_transfer.stage != NONE_STAGE) {
USB_TRACE(1, 0, "*** Wait setup stage breaks previous stage %d",
ep0_transfer.stage);
hal_usb_stop_ep(EP_IN, 0);
}
// New setup packet received, and wait for USBC h/w state machine
// finished CAUTION: Enabling data receipt before getting USBC_SETUP
// interrupt might cause
// race condition in h/w, which leads to missing USBC_XFERCOMPL
// interrupt after the data has been received and acked
ep0_transfer.stage = WAIT_SETUP_STAGE;
return;
}
} else {
// No packet received
if (statusEp & USBC_SETUP) {
if (ep0_transfer.stage == WAIT_SETUP_STAGE) {
// Previous packet is setup packet
ep0_transfer.stage = SETUP_STAGE;
} else {
USB_TRACE(1, 0, "*** Setup interrupt occurs in stage %d",
ep0_transfer.stage);
// The setup packet has been processed
return;
}
}
}
}
if (ep0_transfer.stage == SETUP_STAGE) {
ASSERT(dir == EP_OUT, "Invalid dir for setup stage");
ret = hal_usb_ep0_setup_stage(statusEp);
if (ret) {
// Error
ep0_transfer.stage = NONE_STAGE;
hal_usb_stall_ep(EP_OUT, 0);
hal_usb_stall_ep(EP_IN, 0);
// H/w will unstall EP0 automatically when a setup token is received
// hal_usb_recv_ep0();
}
// Always enable setup packet receiving
hal_usb_recv_ep0();
return;
}
if (statusEp & USBC_XFERCOMPL) {
if (dir == EP_OUT) {
if (ep0_transfer.stage == DATA_OUT_STAGE) {
hal_usb_ep0_data_out_stage();
} else if (ep0_transfer.stage == STATUS_OUT_STAGE) {
hal_usb_ep0_status_stage();
// Always enable setup packet receiving
hal_usb_recv_ep0();
} else {
// Abnormal case
USB_TRACE(2, 0, "*** EP0 OUT compl in stage %d with size 0x%08x",
ep0_transfer.stage, usbc->DOEPTSIZ0);
// Always enable setup packet receiving
hal_usb_recv_ep0();
}
} else {
if (ep0_transfer.stage == DATA_IN_STAGE) {
hal_usb_ep0_data_in_stage();
} else if (ep0_transfer.stage == STATUS_IN_STAGE) {
hal_usb_ep0_status_stage();
hal_usb_ep0_test_mode_check();
} else {
// Abnormal case
USB_TRACE(2, 0, "*** EP0 IN compl in stage %d with size 0x%08x",
ep0_transfer.stage, usbc->DIEPTSIZ0);
}
}
}
}
static void hal_usb_irq_reset(void) {
USB_FUNC_ENTRY_TRACE(2);
device_state = DEFAULT;
device_pwr_wkup_status = 0;
device_sleep_status = USB_SLEEP_NONE;
usbc->PCGCCTL &= ~USBC_STOPPCLK;
usbc->DCTL &= ~USBC_RMTWKUPSIG;
hal_usb_reset_all_transfers();
hal_usb_stop_all_out_eps();
hal_usb_stop_all_in_eps();
// Unmask ep0 interrupts
usbc->DAINTMSK = USBC_INEPMSK(1 << 0) | USBC_OUTEPMSK(1 << 0);
usbc->DOEPMSK = USBC_XFERCOMPLMSK | USBC_SETUPMSK;
usbc->DIEPMSK = USBC_XFERCOMPLMSK | USBC_TIMEOUTMSK;
usbc->GINTMSK |= USBC_OEPINT | USBC_IEPINT
#if defined(USB_ISO) && (USB_ISO_INTERVAL == 1)
| USBC_INCOMPISOOUT | USBC_INCOMPISOIN
#endif
;
#ifdef USB_SUSPEND
usbc->GINTMSK &= ~USBC_WKUPINT;
#endif
#ifdef USB_LPM
usbc->GINTMSK |= USBC_LPM_INT;
usbc->PCGCCTL |= USBC_ENBL_L1GATING;
usbc->GLPMCFG =
SET_BITFIELD(usbc->GLPMCFG, USBC_HIRD_THRES, USB_L1_LIGHT_SLEEP_BESL) |
USBC_HIRD_THRES_BIT4 | USBC_LPMCAP | USBC_APPL1RES |
USBC_ENBESL; // | USBC_ENBLSLPM;
#ifdef CHIP_HAS_USBIF
usbif->USBIF_04 = SET_BITFIELD(usbif->USBIF_04, USBIF_04_CFG_SLEEP_THSD,
USB_L1_LIGHT_SLEEP_BESL);
#endif
#endif
// Config ep0 size
hal_usb_alloc_ep0_fifo();
// Reset device address
usbc->DCFG &= ~USBC_DEVADDR_MASK;
hal_usb_init_ep0_transfer();
hal_usb_init_epn_transfer();
if (callbacks.state_change) {
callbacks.state_change(HAL_USB_EVENT_RESET, 0);
}
}
static void hal_usb_irq_enum_done(void) {
uint8_t speed;
uint8_t mps = 0;
USB_FUNC_ENTRY_TRACE(2);
speed = GET_BITFIELD(usbc->DSTS, USBC_ENUMSPD);
if (speed == 0) {
// High speed -- ERROR!
mps = 0; // 64 bytes
} else if (speed == 1 || speed == 3) {
// Full speed
mps = 0; // 64 bytes
} else {
// Low speed -- ERROR!
mps = 3; // 8 bytes
}
// Only support 64-byte MPS !
mps = 0;
// Config max packet size
usbc->DIEPCTL0 =
USBC_EP0_MPS(mps) | USBC_USBACTEP | USBC_EPTXFNUM(0) | USBC_SNAK;
usbc->DOEPCTL0 = USBC_EP0_MPS(mps) | USBC_USBACTEP | USBC_SNAK;
hal_usb_recv_ep0();
}
#if defined(USB_ISO) && (USB_ISO_INTERVAL == 1)
static void hal_usb_irq_incomp_iso_out(void) {
int i;
uint32_t ctrl;
uint32_t sof_fn;
uint32_t statusEp;
sof_fn = GET_BITFIELD(usbc->DSTS, USBC_SOFFN);
for (i = 0; i < EPNUM - 1; i++) {
ctrl = usbc->DOEPnCONFIG[i].DOEPCTL;
if ((ctrl & USBC_EPENA) &&
((ctrl >> USBC_EPDPID_SHIFT) & 1) == (sof_fn & 1) &&
GET_BITFIELD(ctrl, USBC_EPTYPE) == E_ISOCHRONOUS) {
statusEp = usbc->DOEPnCONFIG[i].DOEPINT;
hal_usb_disable_ep(EP_OUT, i + 1);
break;
}
}
if (i < EPNUM - 1) {
USB_TRACE(4, 17, "%s ep%d: INT=0x%08x, SOF=0x%04x", __FUNCTION__, i + 1,
statusEp, sof_fn);
} else {
USB_TRACE(1, 17, "%s: No valid ISO ep", __FUNCTION__);
}
}
static void hal_usb_irq_incomp_iso_in(void) {
int i;
uint32_t ctrl;
uint32_t sof_fn;
uint32_t statusEp;
sof_fn = GET_BITFIELD(usbc->DSTS, USBC_SOFFN);
for (i = 0; i < EPNUM - 1; i++) {
ctrl = usbc->DIEPnCONFIG[i].DIEPCTL;
if ((ctrl & USBC_EPENA) &&
((ctrl >> USBC_EPDPID_SHIFT) & 1) == (sof_fn & 1) &&
GET_BITFIELD(ctrl, USBC_EPTYPE) == E_ISOCHRONOUS) {
statusEp = usbc->DIEPnCONFIG[i].DIEPINT;
hal_usb_disable_ep(EP_IN, i + 1);
break;
}
}
if (i < EPNUM - 1) {
USB_TRACE(4, 17, "%s ep%d: INT=0x%08x, SOF=0x%04x", __FUNCTION__, i + 1,
statusEp, sof_fn);
} else {
USB_TRACE(1, 17, "%s: No valid ISO ep", __FUNCTION__);
}
}
#endif
#ifdef USB_SUSPEND
static void hal_usb_restore_clock(void) {
hal_sysfreq_req(HAL_SYSFREQ_USER_USB, USB_SYS_FREQ);
#ifdef PMU_USB_PIN_CHECK
#ifdef CHIP_HAS_USBPHY
// Enable dig phy clock
usbphy_wakeup();
#endif
hal_cmu_clock_enable(HAL_CMU_MOD_H_USBC);
hal_cmu_clock_enable(HAL_CMU_MOD_O_USB);
#endif
usbc->PCGCCTL &= ~USBC_STOPPCLK;
#ifdef PMU_USB_PIN_CHECK
NVIC_ClearPendingIRQ(USB_IRQn);
NVIC_EnableIRQ(USB_IRQn);
#endif
}
static void hal_usb_stop_clock(void) {
#ifdef PMU_USB_PIN_CHECK
// Disable USB IRQ to avoid errors when RESET/RESUME is detected before
// stopping USB clock
NVIC_DisableIRQ(USB_IRQn);
#endif
usbc->PCGCCTL |= USBC_STOPPCLK;
#ifdef PMU_USB_PIN_CHECK
hal_cmu_clock_disable(HAL_CMU_MOD_O_USB);
hal_cmu_clock_disable(HAL_CMU_MOD_H_USBC);
#ifdef CHIP_HAS_USBPHY
// Disable dig phy clock
usbphy_sleep();
#endif
#endif
hal_sysfreq_req(HAL_SYSFREQ_USER_USB, HAL_CMU_FREQ_32K);
}
#ifdef PMU_USB_PIN_CHECK
static void hal_usb_pin_status_resume(enum PMU_USB_PIN_CHK_STATUS_T status);
static void hal_usb_pin_check_enable_check(void *param) {
pmu_usb_enable_pin_status_check();
}
static void hal_usb_pin_check_cancel_resume(void *param) {
USB_TRACE(3, 18, "[%X] %s: DSTS=0x%08x", hal_sys_timer_get(), __FUNCTION__,
usbc->DSTS);
if (usbc->DSTS & USBC_SUSPSTS) {
hal_usb_stop_clock();
pmu_usb_enable_pin_status_check();
}
}
static void hal_usb_pin_status_resume(enum PMU_USB_PIN_CHK_STATUS_T status) {
USB_TRACE(2, 18, "%s: %d", __FUNCTION__, status);
// Start timer to check resume status, so as to avoid fake pin resume signal
if (usbdev_timer_active) {
hwtimer_stop(usbdev_timer);
}
hwtimer_update_then_start(usbdev_timer, hal_usb_pin_check_cancel_resume, NULL,
PIN_CHECK_WAIT_RESUME_INTERVAL);
usbdev_timer_active = 1;
hal_usb_restore_clock();
}
#endif
#if defined(PMU_USB_PIN_CHECK) || defined(USB_LPM)
static void hal_usb_stop_usbdev_timer(void) {
if (usbdev_timer_active) {
hwtimer_stop(usbdev_timer);
usbdev_timer_active = 0;
}
}
#endif
static void hal_usb_sleep(enum USB_SLEEP_T cause) {
USB_FUNC_ENTRY_TRACE(18);
device_sleep_status = cause;
if (callbacks.state_change) {
callbacks.state_change((cause == USB_SLEEP_SUSPEND)
? HAL_USB_EVENT_SUSPEND
: HAL_USB_EVENT_L1_DEEP_SLEEP,
0);
}
usbc->GINTMSK |= USBC_WKUPINT;
#ifdef USB_LPM
usbc->GINTMSK &= ~USBC_LPM_INT;
#endif
hal_usb_stop_clock();
#ifdef PMU_USB_PIN_CHECK
pmu_usb_config_pin_status_check(PMU_USB_PIN_CHK_HOST_RESUME,
hal_usb_pin_status_resume, false);
// Stat timer to check current pin status
if (usbdev_timer_active) {
hwtimer_stop(usbdev_timer);
}
hwtimer_update_then_start(usbdev_timer, hal_usb_pin_check_enable_check, NULL,
PIN_CHECK_ENABLE_INTERVAL);
usbdev_timer_active = 1;
#endif
}
static void hal_usb_wakeup(void) {
USB_FUNC_ENTRY_TRACE(18);
device_sleep_status = USB_SLEEP_NONE;
#ifndef PMU_USB_PIN_CHECK
hal_usb_restore_clock();
#endif
usbc->GINTMSK &= ~USBC_WKUPINT;
#ifdef USB_LPM
usbc->GINTMSK |= USBC_LPM_INT;
#endif
if (callbacks.state_change) {
callbacks.state_change(HAL_USB_EVENT_RESUME, 0);
}
}
static void hal_usb_send_resume_signal(int enable) {
if (enable) {
#ifdef PMU_USB_PIN_CHECK
// Stop pin check timer
hal_usb_stop_usbdev_timer();
// Disabe PMU pin status check
pmu_usb_disable_pin_status_check();
#endif
// Restore USB clock and IRQ
hal_usb_restore_clock();
usbc->GINTMSK &= ~USBC_WKUPINT;
usbc->DCTL |= USBC_RMTWKUPSIG;
} else {
usbc->DCTL &= ~USBC_RMTWKUPSIG;
}
}
#endif
int hal_usb_remote_wakeup(int signal) {
#ifdef USB_SUSPEND
USB_TRACE(2, 15, "%s: %d", __FUNCTION__, signal);
if (signal) {
if (device_sleep_status != USB_SLEEP_SUSPEND) {
return 1;
}
if ((device_pwr_wkup_status & DEVICE_STATUS_REMOTE_WAKEUP) == 0) {
return 2;
}
hal_usb_send_resume_signal(1);
} else {
hal_usb_send_resume_signal(0);
// USBC will NOT generate resume IRQ in case of remote wakeup, so fake one
// here
hal_usb_wakeup();
}
#endif
return 0;
}
void hal_usb_lpm_sleep_enable(void) {
#ifdef USB_LPM
if (usbc->GLPMCFG & USBC_ENBESL) {
// usbc->GLPMCFG &= ~USBC_RSTRSLPSTS;
}
usbc->GLPMCFG |= (USBC_APPL1RES | USBC_HIRD_THRES_BIT4);
usbc->PCGCCTL |= USBC_ENBL_L1GATING;
#endif
}
void hal_usb_lpm_sleep_disable(void) {
#ifdef USB_LPM
uint32_t cnt;
uint32_t lock;
uint32_t lpm;
bool POSSIBLY_UNUSED rmtWake = false;
usbc->PCGCCTL &= ~USBC_ENBL_L1GATING;
usbc->GLPMCFG &= ~(USBC_APPL1RES | USBC_HIRD_THRES_BIT4 | USBC_ENBLSLPM);
if (usbc->GLPMCFG & USBC_ENBESL) {
usbc->GLPMCFG |= USBC_RSTRSLPSTS;
}
lpm_entry = false;
// Resume if in L1 state
if (usbc->GLPMCFG & USBC_SLPSTS) {
cnt = 0;
while (
(usbc->GLPMCFG & (USBC_BREMOTEWAKE | USBC_SLPSTS | USBC_L1RESUMEOK)) ==
(USBC_BREMOTEWAKE | USBC_SLPSTS)) {
hal_sys_timer_delay(US_TO_TICKS(0));
if (++cnt > 3) {
break;
}
}
lock = int_lock();
lpm = usbc->GLPMCFG;
if (lpm & USBC_SLPSTS) {
if ((lpm & (USBC_BREMOTEWAKE | USBC_L1RESUMEOK)) ==
(USBC_BREMOTEWAKE | USBC_L1RESUMEOK)) {
hal_usb_send_resume_signal(1);
rmtWake = true;
#if 0
// Detect race condition between remote wake and L1 state change
if ((usbc->GLPMCFG & USBC_SLPSTS) == 0) {
usbc->DCTL &= ~USBC_RMTWKUPSIG;
}
#endif
#ifdef USB_SUSPEND
if (device_sleep_status == USB_SLEEP_L1) {
// USBC will NOT generate resume IRQ in case of remote wakeup, so fake
// one here
hal_usb_wakeup();
}
#endif
} else if ((lpm & (USBC_BREMOTEWAKE | USBC_L1RESUMEOK)) ==
USBC_BREMOTEWAKE) {
TRACE(1,
"\n*** ERROR: LPM Disable: Failed to wait L1 resume OK: 0x%08X\n",
lpm);
}
}
int_unlock(lock);
if (rmtWake) {
USB_TRACE(1, 0, "LPM RmtWake: 0x%08X", lpm);
}
}
#endif
}
#ifdef USB_LPM
#ifdef USB_SUSPEND
static void hal_usb_lpm_check(void *param) {
uint32_t lpm;
uint32_t lock;
// TODO: Disable USB irq only (might conflict with hal_usb_stop_clock)
lock = int_lock();
lpm = usbc->GLPMCFG;
if (lpm_entry && GET_BITFIELD(lpm, USBC_HIRD) >= USB_L1_DEEP_SLEEP_BESL) {
if ((lpm & USBC_SLPSTS) &&
(lpm & (USBC_BREMOTEWAKE | USBC_L1RESUMEOK)) != USBC_BREMOTEWAKE) {
lpm_entry = false;
hal_usb_sleep(USB_SLEEP_L1);
} else {
hwtimer_update_then_start(usbdev_timer, hal_usb_lpm_check, NULL,
LPM_CHECK_INTERVAL);
usbdev_timer_active = 1;
}
}
int_unlock(lock);
}
#endif
static void hal_usb_irq_lpm(void) {
static const uint32_t lpm_trace_interval = MS_TO_TICKS(2000);
static uint32_t last_lpm_irq_time;
static uint32_t cnt = 0;
uint32_t time;
uint32_t lpm;
cnt++;
lpm = usbc->GLPMCFG;
#ifdef USB_SUSPEND
if (GET_BITFIELD(lpm, USBC_HIRD) >= USB_L1_DEEP_SLEEP_BESL) {
// Stat timer to check L1 sleep state
if (usbdev_timer_active) {
hwtimer_stop(usbdev_timer);
}
hwtimer_update_then_start(usbdev_timer, hal_usb_lpm_check, NULL,
LPM_CHECK_INTERVAL);
usbdev_timer_active = 1;
lpm_entry = true;
}
#endif
time = hal_sys_timer_get();
if (time - last_lpm_irq_time >= lpm_trace_interval ||
GET_BITFIELD(lpm, USBC_HIRD) >= USB_L1_DEEP_SLEEP_BESL) {
last_lpm_irq_time = time;
USB_TRACE(6, 0,
"LPM IRQ: 0x%08X rmtWake=%d hird=0x%x l1Res=%d slpSts=%d cnt=%u",
lpm, !!(lpm & USBC_BREMOTEWAKE), GET_BITFIELD(lpm, USBC_HIRD),
GET_BITFIELD(lpm, USBC_COREL1RES), !!(lpm & USBC_SLPSTS), cnt);
}
}
#endif
static void hal_usb_irq_handler(void) {
uint32_t status, rawStatus;
uint32_t statusEp, rawStatusEp;
uint32_t data;
uint8_t i;
// Store interrupt flag and reset it
rawStatus = usbc->GINTSTS;
usbc->GINTSTS = rawStatus;
status = rawStatus &
(usbc->GINTMSK & (USBC_USBRST | USBC_ENUMDONE
#if defined(USB_ISO) && (USB_ISO_INTERVAL == 1)
| USBC_INCOMPISOOUT | USBC_INCOMPISOIN
#endif
| USBC_IEPINT | USBC_OEPINT | USBC_ERLYSUSP |
USBC_USBSUSP | USBC_WKUPINT | USBC_LPM_INT));
USB_TRACE(3, 1, "%s: 0x%08x / 0x%08x", __FUNCTION__, status, rawStatus);
#if defined(USB_SUSPEND) && (defined(PMU_USB_PIN_CHECK) || defined(USB_LPM))
bool stop_timer = true;
#ifdef USB_LPM
if (lpm_entry && status == USBC_ERLYSUSP &&
(usbc->DSTS & USBC_ERRTICERR) == 0) {
// LPM TL1TokenRetry (8 us) timer has expired. L1 state transition will be
// finished after TL1Residency (50 us) timer from now.
stop_timer = false;
} else {
lpm_entry = false;
}
#endif
if (stop_timer) {
hal_usb_stop_usbdev_timer();
}
#endif
if (status & USBC_USBRST) {
// Usb reset
hal_usb_irq_reset();
// We got a reset, and reseted the soft state machine: Discard all other
// interrupt causes.
status &= USBC_ENUMDONE;
}
if (status & USBC_ENUMDONE) {
// Enumeration done
hal_usb_irq_enum_done();
}
#if defined(USB_ISO) && (USB_ISO_INTERVAL == 1)
if (status & USBC_INCOMPISOOUT) {
// Incomplete ISO OUT
hal_usb_irq_incomp_iso_out();
}
if (status & USBC_INCOMPISOIN) {
// Incomplete ISO IN
hal_usb_irq_incomp_iso_in();
}
#endif
if (status & USBC_IEPINT) {
// Tx
data = usbc->DAINT & usbc->DAINTMSK;
for (i = 0; i < EPNUM; ++i) {
if (data & USBC_INEPMSK(1 << i)) {
if (i == 0) {
// EP0
rawStatusEp = usbc->DIEPINT0;
usbc->DIEPINT0 = rawStatusEp;
statusEp = rawStatusEp & usbc->DIEPMSK;
if ((statusEp & USBC_TIMEOUT) || (statusEp & USBC_INTKNTXFEMP)) {
usbc->DIEPMSK &= ~USBC_INTKNTXFEMPMSK;
hal_usb_stall_ep(EP_IN, i);
} else if (statusEp & USBC_XFERCOMPL) {
// Handle ep0 command
hal_usb_handle_ep0_packet(EP_IN, rawStatusEp);
}
} else {
rawStatusEp = usbc->DIEPnCONFIG[i - 1].DIEPINT;
usbc->DIEPnCONFIG[i - 1].DIEPINT = rawStatusEp;
statusEp = rawStatusEp & usbc->DIEPMSK;
if ((statusEp & USBC_TIMEOUT) || (statusEp & USBC_XFERCOMPL)) {
hal_usb_send_epn_complete(i, rawStatusEp);
}
}
}
}
}
if (status & USBC_OEPINT) {
// Rx
data = usbc->DAINT & usbc->DAINTMSK;
for (i = 0; i < EPNUM; ++i) {
if (data & USBC_OUTEPMSK(1 << i)) {
if (i == 0) {
rawStatusEp = usbc->DOEPINT0;
usbc->DOEPINT0 = rawStatusEp;
statusEp = rawStatusEp & usbc->DOEPMSK;
if (statusEp & USBC_OUTTKNEPDIS) {
usbc->DOEPMSK &= ~USBC_OUTTKNEPDISMSK;
hal_usb_stall_ep(EP_OUT, i);
if (statusEp & USBC_XFERCOMPL) {
// Always enable setup packet receiving
hal_usb_recv_ep0();
}
} else if (statusEp & (USBC_XFERCOMPL | USBC_SETUP)) {
// Handle ep0 command
hal_usb_handle_ep0_packet(EP_OUT, rawStatusEp);
}
} else {
rawStatusEp = usbc->DOEPnCONFIG[i - 1].DOEPINT;
usbc->DOEPnCONFIG[i - 1].DOEPINT = rawStatusEp;
statusEp = rawStatusEp & usbc->DOEPMSK;
if (statusEp & USBC_XFERCOMPL) {
hal_usb_recv_epn_complete(i, rawStatusEp);
}
}
}
}
}
#ifdef USB_SUSPEND
if (status & USBC_ERLYSUSP) {
if (usbc->DSTS & USBC_ERRTICERR) {
hal_usb_soft_disconnect();
return;
}
}
if (status & USBC_USBSUSP) {
hal_usb_sleep(USB_SLEEP_SUSPEND);
}
if (status & USBC_WKUPINT) {
hal_usb_wakeup();
}
#endif
#ifdef USB_LPM
if (status & USBC_LPM_INT) {
hal_usb_irq_lpm();
}
#endif
}
#endif // CHIP_HAS_USB
Reference in New Issue View Git Blame Copy Permalink