wen/luban-lite-t3e-pro
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git synced 2025-12-15 02:48:54 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
3b4064f334acf90ed035839e784c2efe38910324
luban-lite-t3e-pro/packages/third-party/cherryusb/port/ehci/usb_hc_ehci.c
刘可亮 7bbc029dae v1.0.0
2023-08-30 16:21:18 +08:00

1415 lines
39 KiB
C
Raw Blame History

/*
* Copyright (c) 2022, sakumisu
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "usb_ehci_priv.h"
struct ehci_hcd g_ehci_hcd;
USB_NOCACHE_RAM_SECTION struct ehci_qh_hw ehci_qh_pool[CONFIG_USB_EHCI_QH_NUM];
USB_NOCACHE_RAM_SECTION struct ehci_qtd_hw ehci_qtd_pool[CONFIG_USB_EHCI_QTD_NUM];
/* The head of the asynchronous queue */
USB_NOCACHE_RAM_SECTION struct ehci_qh_hw g_async_qh_head;
/* The head of the periodic queue */
USB_NOCACHE_RAM_SECTION struct ehci_qh_hw g_periodic_qh_head[EHCI_PERIOIDIC_QH_NUM];
/* The frame list */
USB_NOCACHE_RAM_SECTION uint32_t g_framelist[CONFIG_USB_EHCI_FRAME_LIST_SIZE] __attribute__((aligned(4096)));
static const uint8_t g_ehci_speed[4] = {
0, EHCI_LOW_SPEED, EHCI_FULL_SPEED, EHCI_HIGH_SPEED
};
#ifdef CONFIG_USB_DCACHE_ENABLE
void usb_ehci_dcache_clean(uintptr_t addr, uint32_t len);
void usb_ehci_dcache_invalidate(uintptr_t addr, uint32_t len);
void usb_ehci_dcache_clean_invalidate(uintptr_t addr, uint32_t len);
static int usb_ehci_qtd_flush(struct ehci_qtd_hw *qtd)
{
/* Flush the D-Cache, i.e., make the contents of the memory match the
* contents of the D-Cache in the specified address range and invalidate
* the D-Cache to force re-loading of the data from memory when next
* accessed.
*/
usb_ehci_dcache_clean_invalidate((uintptr_t)&qtd->hw, sizeof(struct ehci_qtd_hw));
return 0;
}
static int usb_ehci_qh_flush(struct ehci_qh_hw *qh)
{
struct ehci_qtd_hw *qtd;
struct ehci_qtd_hw *next;
/* Flush the QH first. This will write the contents of the D-cache to RAM
* and invalidate the contents of the D-cache so that the next access will
* be reloaded from D-Cache.
*/
usb_ehci_dcache_clean_invalidate((uintptr_t)&qh->hw, sizeof(struct ehci_qh_hw));
/* Then flush all of the qTD entries in the queue */
if ((qh->first_qtd & QTD_LIST_END) == 0) {
qtd = (struct ehci_qtd_hw *)(uintptr_t)qh->first_qtd;
while (qtd) {
if (qtd->hw.next_qtd & QTD_LIST_END) {
next = NULL;
} else {
next = (struct ehci_qtd_hw *)(uintptr_t)qtd->hw.next_qtd;
}
usb_ehci_qtd_flush(qtd);
qtd = next;
}
}
return 0;
}
#else
#define usb_ehci_dcache_clean(addr, len)
#define usb_ehci_dcache_invalidate(addr, len)
#define usb_ehci_dcache_clean_invalidate(addr, len)
#define usb_ehci_qtd_flush(qtd, bp, arg)
#define usb_ehci_qh_flush(qh)
#endif
static struct ehci_qh_hw *ehci_qh_alloc(void)
{
struct ehci_qh_hw *qh;
for (uint32_t i = 0; i < CONFIG_USB_EHCI_QH_NUM; i++) {
if (!g_ehci_hcd.ehci_qh_used[i]) {
g_ehci_hcd.ehci_qh_used[i] = true;
qh = &ehci_qh_pool[i];
memset(qh, 0, sizeof(struct ehci_qh_hw));
qh->hw.hlp = QTD_LIST_END;
qh->hw.overlay.next_qtd = QTD_LIST_END;
qh->hw.overlay.alt_next_qtd = QTD_LIST_END;
return qh;
}
}
return NULL;
}
static void ehci_qh_free(struct ehci_qh_hw *qh)
{
for (uint32_t i = 0; i < CONFIG_USB_EHCI_QH_NUM; i++) {
if (&ehci_qh_pool[i] == qh) {
g_ehci_hcd.ehci_qh_used[i] = false;
return;
}
}
}
static struct ehci_qtd_hw *ehci_qtd_alloc(void)
{
struct ehci_qtd_hw *qtd;
for (uint32_t i = 0; i < CONFIG_USB_EHCI_QTD_NUM; i++) {
if (!g_ehci_hcd.ehci_qtd_used[i]) {
g_ehci_hcd.ehci_qtd_used[i] = true;
qtd = &ehci_qtd_pool[i];
memset(qtd, 0, sizeof(struct ehci_qtd_hw));
qtd->hw.next_qtd = QTD_LIST_END;
qtd->hw.alt_next_qtd = QTD_LIST_END;
qtd->hw.token = QTD_TOKEN_STATUS_HALTED;
return qtd;
}
}
return NULL;
}
static void ehci_qtd_free(struct ehci_qtd_hw *qtd)
{
#ifdef CONFIG_USB_DCACHE_ENABLE
if (qtd->align_buffer) {
aicos_free_align(0, qtd->align_buffer);
qtd->align_buffer = 0;
}
#endif
for (uint32_t i = 0; i < CONFIG_USB_EHCI_QTD_NUM; i++) {
if (&ehci_qtd_pool[i] == qtd) {
g_ehci_hcd.ehci_qtd_used[i] = false;
return;
}
}
}
static struct ehci_pipe *ehci_pipe_alloc(void)
{
int pipe;
for (pipe = 0; pipe < CONFIG_USB_EHCI_QH_NUM; pipe++) {
if (!g_ehci_hcd.pipe_pool[pipe].inuse) {
g_ehci_hcd.pipe_pool[pipe].inuse = true;
return &g_ehci_hcd.pipe_pool[pipe];
}
}
return NULL;
}
static void ehci_pipe_free(struct ehci_pipe *pipe)
{
pipe->inuse = false;
}
static inline void ehci_qh_add_head(struct ehci_qh_hw *head, struct ehci_qh_hw *n)
{
n->hw.hlp = head->hw.hlp;
usb_ehci_qh_flush(n);
usb_ehci_dcache_invalidate((uintptr_t)&head->hw, CACHE_LINE_SIZE);
head->hw.hlp = QH_HLP_QH(n);
usb_ehci_dcache_clean((uintptr_t)&head->hw, CACHE_LINE_SIZE);
}
static inline void ehci_qh_remove(struct ehci_qh_hw *head, struct ehci_qh_hw *n)
{
struct ehci_qh_hw *tmp = head;
usb_ehci_dcache_invalidate((uintptr_t)&tmp->hw, CACHE_LINE_SIZE);
while (EHCI_ADDR2QH(tmp->hw.hlp) && EHCI_ADDR2QH(tmp->hw.hlp) != n) {
tmp = EHCI_ADDR2QH(tmp->hw.hlp);
usb_ehci_dcache_invalidate((uintptr_t)&tmp->hw, CACHE_LINE_SIZE);
}
if (tmp) {
tmp->hw.hlp = n->hw.hlp;
usb_ehci_dcache_clean((uintptr_t)&tmp->hw, CACHE_LINE_SIZE);
}
}
static int ehci_caculate_smask(int binterval)
{
int order, interval;
interval = 1;
while (binterval > 1) {
interval *= 2;
binterval--;
}
if (interval < 2) /* interval 1 */
return 0xFF;
if (interval < 4) /* interval 2 */
return 0x55;
if (interval < 8) /* interval 4 */
return 0x22;
for (order = 0; (interval > 1); order++) {
interval >>= 1;
}
return (0x1 << (order % 8));
}
static struct ehci_qh_hw *ehci_get_periodic_qhead(uint8_t interval)
{
interval /= 8;
for (uint8_t i = 0; i < EHCI_PERIOIDIC_QH_NUM - 1; i++) {
interval >>= 1;
if (interval == 0) {
return &g_periodic_qh_head[i];
}
}
return &g_periodic_qh_head[EHCI_PERIOIDIC_QH_NUM - 1];
}
static void ehci_qh_fill(struct ehci_qh_hw *qh,
struct ehci_pipe *pipe)
{
struct usbh_hub *hub;
uint32_t regval;
/* QH endpoint characteristics:
*
* FIELD DESCRIPTION
* -------- -------------------------------
* DEVADDR Device address
* I Inactivate on Next Transaction
* ENDPT Endpoint number
* EPS Endpoint speed
* DTC Data toggle control
* MAXPKT Max packet size
* C Control endpoint
* RL NAK count reloaded
*/
regval = ((uint32_t)pipe->dev_addr << QH_EPCHAR_DEVADDR_SHIFT) |
((uint32_t)(pipe->ep_addr & 0xf) << QH_EPCHAR_ENDPT_SHIFT) |
((uint32_t)g_ehci_speed[pipe->speed] << QH_EPCHAR_EPS_SHIFT) |
((uint32_t)pipe->ep_mps << QH_EPCHAR_MAXPKT_SHIFT) |
QH_EPCHAR_DTC |
((uint32_t)0 << QH_EPCHAR_RL_SHIFT);
if (pipe->ep_type == USB_ENDPOINT_TYPE_CONTROL && (pipe->speed != USB_SPEED_HIGH)) {
regval |= QH_EPCHAR_C;
}
qh->hw.epchar = regval;
/* QH endpoint capabilities
*
* FIELD DESCRIPTION
* -------- -------------------------------
* SSMASK Interrupt Schedule Mask
* SCMASK Split Completion Mask
* HUBADDR Hub Address
* PORT Port number
* MULT High band width multiplier
*/
regval = 0;
hub = pipe->hport->parent;
regval |= QH_EPCAPS_HUBADDR(hub->hub_addr);
regval |= QH_EPCAPS_PORT(pipe->hport->port);
regval |= QH_EPCAPS_MULT(1);
if (pipe->ep_type == USB_ENDPOINT_TYPE_INTERRUPT) {
if (pipe->speed == USB_SPEED_HIGH) {
regval |= ehci_caculate_smask(pipe->ep_interval);
} else {
regval |= QH_EPCAPS_SSMASK(2);
regval |= QH_EPCAPS_SCMASK(0x78);
}
regval |= QH_EPCAPS_MULT(1);
}
qh->hw.epcap = regval;
qh->pipe = pipe;
}
static void ehci_qtd_bpl_fill(struct ehci_qtd_hw *qtd, uint32_t bufaddr, size_t buflen)
{
uint32_t rest;
#ifdef CONFIG_USB_DCACHE_ENABLE
if (((bufaddr % CACHE_LINE_SIZE) != 0) ||
(((bufaddr + buflen) % CACHE_LINE_SIZE) != 0)) {
qtd->align_buffer = aicos_malloc_align(0, buflen, CACHE_LINE_SIZE);
if (NULL == qtd->align_buffer) {
USB_LOG_ERR("alloc error.\r\n");
return;
}
/* out direction */
if (qtd->dir_in == 0) {
memcpy(qtd->align_buffer, (void *)(uintptr_t)bufaddr, buflen);
}
qtd->buffer = (void *)(uintptr_t)bufaddr;
qtd->buffer_len = buflen;
bufaddr = (uint32_t)(uintptr_t)qtd->align_buffer;
} else {
qtd->align_buffer = 0;
qtd->buffer = (void *)(uintptr_t)bufaddr;
qtd->buffer_len = buflen;
}
usb_ehci_dcache_clean_invalidate((uintptr_t)bufaddr, buflen);
#endif
qtd->hw.bpl[0] = bufaddr;
rest = 0x1000 - (bufaddr & 0xfff);
if (buflen < rest) {
rest = buflen;
} else {
bufaddr += 0x1000;
bufaddr &= ~0x0fff;
for (int i = 1; rest < buflen && i < 5; i++) {
qtd->hw.bpl[i] = bufaddr;
bufaddr += 0x1000;
if ((rest + 0x1000) < buflen) {
rest += 0x1000;
} else {
rest = buflen;
}
}
}
}
static void ehci_qtd_fill(struct ehci_pipe *pipe, struct ehci_qtd_hw *qtd, uint32_t bufaddr, size_t buflen, uint32_t token)
{
/* qTD token
*
* FIELD DESCRIPTION
* -------- -------------------------------
* STATUS Status
* PID PID Code
* CERR Error Counter
* CPAGE Current Page
* IOC Interrupt on complete
* NBYTES Total Bytes to Transfer
* TOGGLE Data Toggle
*/
qtd->hw.token = token;
ehci_qtd_bpl_fill(qtd, bufaddr, buflen);
pipe->xfrd += buflen;
}
static struct ehci_qh_hw *ehci_control_pipe_init(struct ehci_pipe *pipe, struct usb_setup_packet *setup, uint8_t *buffer, uint32_t buflen)
{
struct ehci_qh_hw *qh = NULL;
struct ehci_qtd_hw *qtd_setup = NULL;
struct ehci_qtd_hw *qtd_data = NULL;
struct ehci_qtd_hw *qtd_status = NULL;
uint32_t token;
size_t flags;
qh = ehci_qh_alloc();
if (qh == NULL) {
return NULL;
}
qtd_setup = ehci_qtd_alloc();
if (buflen > 0) {
qtd_data = ehci_qtd_alloc();
}
qtd_status = ehci_qtd_alloc();
if (qtd_status == NULL) {
ehci_qh_free(qh);
if (qtd_setup) {
ehci_qtd_free(qtd_setup);
}
if (qtd_data) {
ehci_qtd_free(qtd_data);
}
return NULL;
}
ehci_qh_fill(qh, pipe);
/* fill setup qtd */
token = QTD_TOKEN_STATUS_ACTIVE |
QTD_TOKEN_PID_SETUP |
((uint32_t)3 << QTD_TOKEN_CERR_SHIFT) |
((uint32_t)8 << QTD_TOKEN_NBYTES_SHIFT);
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd_setup->dir_in = 0;
#endif
ehci_qtd_fill(pipe, qtd_setup, EHCI_PTR2ADDR(setup), 8, token);
/* fill data qtd */
if (setup->wLength > 0) {
if ((setup->bmRequestType & 0x80) == 0x80) {
token = QTD_TOKEN_PID_IN;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd_data->dir_in = 1;
#endif
} else {
token = QTD_TOKEN_PID_OUT;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd_data->dir_in = 0;
#endif
}
token |= QTD_TOKEN_STATUS_ACTIVE |
QTD_TOKEN_PID_OUT |
QTD_TOKEN_TOGGLE |
((uint32_t)3 << QTD_TOKEN_CERR_SHIFT) |
((uint32_t)buflen << QTD_TOKEN_NBYTES_SHIFT);
ehci_qtd_fill(pipe, qtd_data, EHCI_PTR2ADDR(buffer), buflen, token);
qtd_setup->hw.next_qtd = EHCI_PTR2ADDR(qtd_data);
qtd_data->hw.next_qtd = EHCI_PTR2ADDR(qtd_status);
} else {
qtd_setup->hw.next_qtd = EHCI_PTR2ADDR(qtd_status);
}
/* fill status qtd */
if ((setup->bmRequestType & 0x80) == 0x80) {
token = QTD_TOKEN_PID_OUT;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd_status->dir_in = 0;
#endif
} else {
token = QTD_TOKEN_PID_IN;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd_status->dir_in = 1;
#endif
}
token |= QTD_TOKEN_STATUS_ACTIVE |
QTD_TOKEN_TOGGLE |
QTD_TOKEN_IOC |
((uint32_t)3 << QTD_TOKEN_CERR_SHIFT) |
((uint32_t)0 << QTD_TOKEN_NBYTES_SHIFT);
ehci_qtd_fill(pipe, qtd_status, 0, 0, token);
qtd_status->hw.next_qtd = QTD_LIST_END;
/* update qh first qtd */
qh->hw.overlay.next_qtd = EHCI_PTR2ADDR(qtd_setup);
/* record qh first qtd */
qh->first_qtd = EHCI_PTR2ADDR(qtd_setup);
flags = usb_osal_enter_critical_section();
pipe->qh = qh;
/* add qh into async list */
ehci_qh_add_head(&g_async_qh_head, qh);
usb_osal_leave_critical_section(flags);
return qh;
}
static struct ehci_qh_hw *ehci_bulk_pipe_init(struct ehci_pipe *pipe, uint8_t *buffer, uint32_t buflen)
{
struct ehci_qh_hw *qh = NULL;
struct ehci_qtd_hw *qtd = NULL;
struct ehci_qtd_hw *first_qtd = NULL;
struct ehci_qtd_hw *prev_qtd = NULL;
uint32_t qtd_num = 0;
uint32_t xfer_len = 0;
uint32_t token;
size_t flags;
qh = ehci_qh_alloc();
if (qh == NULL) {
return NULL;
}
for (uint32_t i = 0; i < CONFIG_USB_EHCI_QTD_NUM; i++) {
if (!g_ehci_hcd.ehci_qtd_used[i]) {
qtd_num++;
}
}
if (qtd_num < ((buflen + 0x3fff) / 0x4000)) {
ehci_qh_free(qh);
return NULL;
}
ehci_qh_fill(qh, pipe);
while (buflen >= 0) {
qtd = ehci_qtd_alloc();
if (buflen > 0x4000) {
xfer_len = 0x4000;
buflen -= 0x4000;
} else {
xfer_len = buflen;
buflen = 0;
}
/* fill qtd */
if (pipe->toggle) {
token = QTD_TOKEN_TOGGLE;
} else {
token = 0;
}
if (pipe->ep_addr & 0x80) {
token |= QTD_TOKEN_PID_IN;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd->dir_in = 1;
#endif
} else {
token |= QTD_TOKEN_PID_OUT;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd->dir_in = 0;
#endif
}
token |= QTD_TOKEN_STATUS_ACTIVE |
((uint32_t)3 << QTD_TOKEN_CERR_SHIFT) |
((uint32_t)xfer_len << QTD_TOKEN_NBYTES_SHIFT);
if (buflen == 0) {
token |= QTD_TOKEN_IOC;
}
ehci_qtd_fill(pipe, qtd, (uint32_t)(uintptr_t)buffer, xfer_len, token);
qtd->hw.next_qtd = QTD_LIST_END;
buffer += xfer_len;
if (prev_qtd) {
prev_qtd->hw.next_qtd = EHCI_PTR2ADDR(qtd);
} else {
first_qtd = qtd;
}
prev_qtd = qtd;
if (buflen == 0) {
break;
}
}
/* update qh first qtd */
qh->hw.overlay.next_qtd = EHCI_PTR2ADDR(first_qtd);
/* record qh first qtd */
qh->first_qtd = EHCI_PTR2ADDR(first_qtd);
flags = usb_osal_enter_critical_section();
pipe->qh = qh;
/* add qh into async list */
ehci_qh_add_head(&g_async_qh_head, qh);
usb_osal_leave_critical_section(flags);
return qh;
}
static struct ehci_qh_hw *ehci_intr_pipe_init(struct ehci_pipe *pipe, uint8_t *buffer, uint32_t buflen)
{
struct ehci_qh_hw *qh = NULL;
struct ehci_qtd_hw *qtd = NULL;
struct ehci_qtd_hw *first_qtd = NULL;
struct ehci_qtd_hw *prev_qtd = NULL;
uint32_t qtd_num = 0;
uint32_t xfer_len = 0;
uint32_t token;
size_t flags;
qh = ehci_qh_alloc();
if (qh == NULL) {
return NULL;
}
for (uint32_t i = 0; i < CONFIG_USB_EHCI_QTD_NUM; i++) {
if (!g_ehci_hcd.ehci_qtd_used[i]) {
qtd_num++;
}
}
if (qtd_num < ((buflen + 0x3fff) / 0x4000)) {
ehci_qh_free(qh);
return NULL;
}
ehci_qh_fill(qh, pipe);
while (buflen >= 0) {
qtd = ehci_qtd_alloc();
if (buflen > 0x4000) {
xfer_len = 0x4000;
buflen -= 0x4000;
} else {
xfer_len = buflen;
buflen = 0;
}
/* fill qtd */
if (pipe->toggle) {
token = QTD_TOKEN_TOGGLE;
} else {
token = 0;
}
if (pipe->ep_addr & 0x80) {
token |= QTD_TOKEN_PID_IN;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd->dir_in = 1;
#endif
} else {
token |= QTD_TOKEN_PID_OUT;
#ifdef CONFIG_USB_DCACHE_ENABLE
qtd->dir_in = 0;
#endif
}
token |= QTD_TOKEN_STATUS_ACTIVE |
((uint32_t)3 << QTD_TOKEN_CERR_SHIFT) |
((uint32_t)xfer_len << QTD_TOKEN_NBYTES_SHIFT);
if (buflen == 0) {
token |= QTD_TOKEN_IOC;
}
ehci_qtd_fill(pipe, qtd, (uint32_t)(uintptr_t)buffer, xfer_len, token);
qtd->hw.next_qtd = QTD_LIST_END;
buffer += xfer_len;
if (prev_qtd) {
prev_qtd->hw.next_qtd = EHCI_PTR2ADDR(qtd);
} else {
first_qtd = qtd;
}
prev_qtd = qtd;
if (buflen == 0) {
break;
}
}
/* update qh first qtd */
qh->hw.overlay.next_qtd = EHCI_PTR2ADDR(first_qtd);
/* record qh first qtd */
qh->first_qtd = EHCI_PTR2ADDR(first_qtd);
flags = usb_osal_enter_critical_section();
pipe->qh = qh;
/* add qh into periodic list */
if (pipe->speed == USB_SPEED_HIGH) {
ehci_qh_add_head(ehci_get_periodic_qhead(pipe->ep_interval), qh);
} else {
ehci_qh_add_head(ehci_get_periodic_qhead(pipe->ep_interval * 8), qh);
}
usb_osal_leave_critical_section(flags);
return qh;
}
void ehci_pipe_waitup(struct ehci_pipe *pipe)
{
struct usbh_urb *urb;
urb = pipe->urb;
pipe->urb = NULL;
if (pipe->waiter) {
pipe->waiter = false;
usb_osal_sem_give(pipe->waitsem);
}
if (urb->complete) {
if (urb->errorcode < 0) {
urb->complete(urb->arg, urb->errorcode);
} else {
urb->complete(urb->arg, urb->actual_length);
}
}
}
static void ehci_qh_scan_qtds(struct ehci_qh_hw *qh, struct ehci_pipe *pipe)
{
struct ehci_qtd_hw *qtd;
struct ehci_qtd_hw *next;
if ((qh->first_qtd & QTD_LIST_END) == 0) {
qtd = (struct ehci_qtd_hw *)(uintptr_t)qh->first_qtd;
while (qtd) {
usb_ehci_dcache_invalidate((uintptr_t)&qtd->hw, sizeof(struct ehci_qtd));
if (qtd->hw.next_qtd & QTD_LIST_END) {
next = NULL;
} else {
next = (struct ehci_qtd_hw *)(uintptr_t)qtd->hw.next_qtd;
}
qh->first_qtd = qtd->hw.next_qtd;
if (pipe) {
pipe->xfrd -= (qtd->hw.token & QTD_TOKEN_NBYTES_MASK) >>
QTD_TOKEN_NBYTES_SHIFT;
}
#ifdef CONFIG_USB_DCACHE_ENABLE
if ((qtd->align_buffer) && (qtd->dir_in == 1)) {
memcpy(qtd->buffer, qtd->align_buffer, qtd->buffer_len);
}
#endif
ehci_qtd_free(qtd);
qtd = next;
}
}
}
static void ehci_check_qh(struct ehci_qh_hw *qhead, struct ehci_qh_hw *qh, struct ehci_pipe *pipe)
{
struct usbh_urb *urb;
uint32_t token;
usb_ehci_dcache_invalidate((uintptr_t)&qh->hw, sizeof(struct ehci_qh));
token = qh->hw.overlay.token;
if (token & QTD_TOKEN_STATUS_ACTIVE) {
} else {
urb = pipe->urb;
ehci_qh_scan_qtds(qh, pipe);
if (qh->first_qtd & QTD_LIST_END) {
/* remove qh from list */
ehci_qh_remove(qhead, qh);
if ((token & QTD_TOKEN_STATUS_ERRORS) == 0) {
if (token & QTD_TOKEN_TOGGLE) {
pipe->toggle = true;
} else {
pipe->toggle = false;
}
urb->errorcode = 0;
} else {
if (token & QTD_TOKEN_STATUS_BABBLE) {
urb->errorcode = -EPERM;
pipe->toggle = 0;
} else if (token & QTD_TOKEN_STATUS_HALTED) {
urb->errorcode = -EPERM;
pipe->toggle = 0;
} else if (token & (QTD_TOKEN_STATUS_DBERR | QTD_TOKEN_STATUS_XACTERR)) {
urb->errorcode = -EIO;
}
}
urb->actual_length = pipe->xfrd;
ehci_qh_free(qh);
pipe->qh = NULL;
ehci_pipe_waitup(pipe);
}
}
}
static void ehci_kill_qh(struct ehci_qh_hw *qhead, struct ehci_qh_hw *qh)
{
ehci_qh_remove(qhead, qh);
ehci_qh_scan_qtds(qh, NULL);
ehci_qh_free(qh);
}
static int usbh_reset_port(const uint8_t port)
{
uint32_t timeout = 0;
uint32_t regval;
#if defined(CONFIG_USB_EHCI_HPMICRO) && CONFIG_USB_EHCI_HPMICRO
if ((*(volatile uint32_t *)(CONFIG_HPM_USB_BASE + 0x224) & 0xc0) == (2 << 6)) { /* Hardcode for hpm */
EHCI_HCOR->portsc[port - 1] |= (1 << 29);
} else {
EHCI_HCOR->portsc[port - 1] &= ~(1 << 29);
}
#endif
regval = EHCI_HCOR->portsc[port - 1];
regval &= ~EHCI_PORTSC_PE;
regval |= EHCI_PORTSC_RESET;
EHCI_HCOR->portsc[port - 1] = regval;
usb_osal_msleep(55);
EHCI_HCOR->portsc[port - 1] &= ~EHCI_PORTSC_RESET;
while ((EHCI_HCOR->portsc[port - 1] & EHCI_PORTSC_RESET) != 0) {
usb_osal_msleep(1);
timeout++;
if (timeout > 100) {
return -ETIMEDOUT;
}
}
return 0;
}
__WEAK void usb_hc_low_level_init(void)
{
}
__WEAK void usb_hc_low_level2_init(void)
{
}
int usb_hc_init(void)
{
uint32_t interval;
struct ehci_qh_hw *qh;
uint32_t timeout = 0;
uint32_t regval;
memset(&g_ehci_hcd, 0, sizeof(struct ehci_hcd));
if (sizeof(struct ehci_qh_hw) % 32) {
USB_LOG_ERR("struct ehci_qh_hw is not align 32\r\n");
return -EINVAL;
}
if (sizeof(struct ehci_qtd_hw) % 32) {
USB_LOG_ERR("struct ehci_qtd_hw is not align 32\r\n");
return -EINVAL;
}
for (uint8_t index = 0; index < CONFIG_USB_EHCI_QH_NUM; index++) {
struct ehci_pipe *pipe;
pipe = &g_ehci_hcd.pipe_pool[index];
pipe->waitsem = usb_osal_sem_create(0);
}
memset(&g_async_qh_head, 0, sizeof(struct ehci_qh_hw));
g_async_qh_head.hw.hlp = QH_HLP_QH(&g_async_qh_head);
g_async_qh_head.hw.epchar = QH_EPCHAR_H;
g_async_qh_head.hw.overlay.next_qtd = QTD_LIST_END;
g_async_qh_head.hw.overlay.alt_next_qtd = QTD_LIST_END;
g_async_qh_head.hw.overlay.token = QTD_TOKEN_STATUS_HALTED;
g_async_qh_head.first_qtd = QTD_LIST_END;
usb_ehci_dcache_clean((uintptr_t)&g_async_qh_head.hw, sizeof(struct ehci_qh_hw));
memset(g_framelist, 0, sizeof(uint32_t) * CONFIG_USB_EHCI_FRAME_LIST_SIZE);
for (int i = EHCI_PERIOIDIC_QH_NUM - 1; i >= 0; i--) {
memset(&g_periodic_qh_head[i], 0, sizeof(struct ehci_qh_hw));
g_periodic_qh_head[i].hw.hlp = QH_HLP_END;
g_periodic_qh_head[i].hw.epchar = QH_EPCAPS_SSMASK(1);
g_periodic_qh_head[i].hw.overlay.next_qtd = QTD_LIST_END;
g_periodic_qh_head[i].hw.overlay.alt_next_qtd = QTD_LIST_END;
g_periodic_qh_head[i].hw.overlay.token = QTD_TOKEN_STATUS_HALTED;
g_periodic_qh_head[i].first_qtd = QTD_LIST_END;
interval = 1 << i;
for (uint32_t j = interval - 1; j < CONFIG_USB_EHCI_FRAME_LIST_SIZE; j += interval) {
if (g_framelist[j] == 0) {
g_framelist[j] = QH_HLP_QH(&g_periodic_qh_head[i]);
} else {
qh = EHCI_ADDR2QH(g_framelist[j]);
while (1) {
if (qh == &g_periodic_qh_head[i]) {
break;
}
if (qh->hw.hlp == QH_HLP_END) {
qh->hw.hlp = QH_HLP_QH(&g_periodic_qh_head[i]);
break;
}
qh = EHCI_ADDR2QH(qh->hw.hlp);
}
}
}
}
usb_ehci_dcache_clean((uintptr_t)g_periodic_qh_head, EHCI_PERIOIDIC_QH_NUM * sizeof(struct ehci_qh_hw));
usb_ehci_dcache_clean((uintptr_t)g_framelist, CONFIG_USB_EHCI_FRAME_LIST_SIZE * sizeof(uint32_t));
usb_hc_low_level_init();
EHCI_HCOR->usbcmd |= EHCI_USBCMD_HCRESET;
while (EHCI_HCOR->usbcmd & EHCI_USBCMD_HCRESET) {
usb_osal_msleep(1);
timeout++;
if (timeout > 100) {
return -ETIMEDOUT;
}
}
usb_hc_low_level2_init();
EHCI_HCOR->usbintr = 0;
EHCI_HCOR->usbsts = EHCI_HCOR->usbsts;
#if CONFIG_USB_EHCI_HCCR_BASE != 0
USB_LOG_INFO("EHCI HCIVERSION:%04x\r\n", (int)EHCI_HCCR->hciversion);
USB_LOG_INFO("EHCI HCSPARAMS:%06x\r\n", (int)EHCI_HCCR->hcsparams);
USB_LOG_INFO("EHCI HCCPARAMS:%04x\r\n", (int)EHCI_HCCR->hccparams);
#endif
/* Set the Current Asynchronous List Address. */
EHCI_HCOR->asynclistaddr = EHCI_PTR2ADDR(&g_async_qh_head);
/* Set the Periodic Frame List Base Address. */
EHCI_HCOR->periodiclistbase = EHCI_PTR2ADDR(g_framelist);
regval = 0;
#if CONFIG_USB_EHCI_FRAME_LIST_SIZE == 1024
regval |= EHCI_USBCMD_FLSIZE_1024;
#elif CONFIG_USB_EHCI_FRAME_LIST_SIZE == 512
regval |= EHCI_USBCMD_FLSIZE_512;
#elif CONFIG_USB_EHCI_FRAME_LIST_SIZE == 256
regval |= EHCI_USBCMD_FLSIZE_256;
#else
#error Unsupported frame size list size
#endif
regval |= EHCI_USBCMD_ITHRE_1MF;
regval |= EHCI_USBCMD_ASEN;
regval |= EHCI_USBCMD_PSEN;
regval |= EHCI_USBCMD_RUN;
EHCI_HCOR->usbcmd = regval;
#ifdef CONFIG_USB_EHCI_CONFIGFLAG
EHCI_HCOR->configflag = EHCI_CONFIGFLAG;
#endif
/* Wait for the EHCI to run (no longer report halted) */
timeout = 0;
while (EHCI_HCOR->usbsts & EHCI_USBSTS_HALTED) {
usb_osal_msleep(1);
timeout++;
if (timeout > 100) {
return -ETIMEDOUT;
}
}
#ifdef CONFIG_USB_EHCI_PORT_POWER
for (uint8_t port = 0; port < CONFIG_USBHOST_MAX_RHPORTS; port++) {
regval = EHCI_HCOR->portsc[port];
regval |= EHCI_PORTSC_PP;
EHCI_HCOR->portsc[port] = regval;
}
#endif
/* Enable EHCI interrupts. */
EHCI_HCOR->usbintr = EHCI_USBIE_INT | EHCI_USBIE_ERR | EHCI_USBIE_PCD | EHCI_USBIE_FATAL | EHCI_USBIE_IAA;
return 0;
}
uint16_t usbh_get_frame_number(void)
{
return (((EHCI_HCOR->frindex & EHCI_FRINDEX_MASK) >> 3) & 0x3ff);
}
int usbh_roothub_control(struct usb_setup_packet *setup, uint8_t *buf)
{
uint8_t nports;
uint8_t port;
uint32_t temp, status;
nports = CONFIG_USBHOST_MAX_RHPORTS;
port = setup->wIndex;
if (setup->bmRequestType & USB_REQUEST_RECIPIENT_DEVICE) {
switch (setup->bRequest) {
case HUB_REQUEST_CLEAR_FEATURE:
switch (setup->wValue) {
case HUB_FEATURE_HUB_C_LOCALPOWER:
break;
case HUB_FEATURE_HUB_C_OVERCURRENT:
break;
default:
return -EPIPE;
}
break;
case HUB_REQUEST_SET_FEATURE:
switch (setup->wValue) {
case HUB_FEATURE_HUB_C_LOCALPOWER:
break;
case HUB_FEATURE_HUB_C_OVERCURRENT:
break;
default:
return -EPIPE;
}
break;
case HUB_REQUEST_GET_DESCRIPTOR:
break;
case HUB_REQUEST_GET_STATUS:
memset(buf, 0, 4);
break;
default:
break;
}
} else if (setup->bmRequestType & USB_REQUEST_RECIPIENT_OTHER) {
switch (setup->bRequest) {
case HUB_REQUEST_CLEAR_FEATURE:
if (!port || port > nports) {
return -EPIPE;
}
switch (setup->wValue) {
case HUB_PORT_FEATURE_ENABLE:
EHCI_HCOR->portsc[port - 1] &= ~EHCI_PORTSC_PE;
break;
case HUB_PORT_FEATURE_SUSPEND:
case HUB_PORT_FEATURE_C_SUSPEND:
break;
case HUB_PORT_FEATURE_POWER:
#ifdef CONFIG_USB_EHCI_PORT_POWER
EHCI_HCOR->portsc[port - 1] &= ~EHCI_PORTSC_PP;
#endif
break;
case HUB_PORT_FEATURE_C_CONNECTION:
EHCI_HCOR->portsc[port - 1] |= EHCI_PORTSC_CSC;
break;
case HUB_PORT_FEATURE_C_ENABLE:
EHCI_HCOR->portsc[port - 1] |= EHCI_PORTSC_PEC;
break;
case HUB_PORT_FEATURE_C_OVER_CURREN:
EHCI_HCOR->portsc[port - 1] |= EHCI_PORTSC_OCC;
break;
case HUB_PORT_FEATURE_C_RESET:
break;
default:
return -EPIPE;
}
break;
case HUB_REQUEST_SET_FEATURE:
if (!port || port > nports) {
return -EPIPE;
}
switch (setup->wValue) {
case HUB_PORT_FEATURE_SUSPEND:
break;
case HUB_PORT_FEATURE_POWER:
#ifdef CONFIG_USB_EHCI_PORT_POWER
EHCI_HCOR->portsc[port - 1] |= EHCI_PORTSC_PP;
#endif
break;
case HUB_PORT_FEATURE_RESET:
usbh_reset_port(port);
break;
default:
return -EPIPE;
}
break;
case HUB_REQUEST_GET_STATUS:
if (!port || port > nports) {
return -EPIPE;
}
temp = EHCI_HCOR->portsc[port - 1];
status = 0;
if (temp & EHCI_PORTSC_CSC) {
status |= (1 << HUB_PORT_FEATURE_C_CONNECTION);
}
if (temp & EHCI_PORTSC_PEC) {
status |= (1 << HUB_PORT_FEATURE_C_ENABLE);
}
if (temp & EHCI_PORTSC_OCC) {
status |= (1 << HUB_PORT_FEATURE_C_OVER_CURREN);
}
if (temp & EHCI_PORTSC_CCS) {
status |= (1 << HUB_PORT_FEATURE_CONNECTION);
}
if (temp & EHCI_PORTSC_PE) {
status |= (1 << HUB_PORT_FEATURE_ENABLE);
if (usbh_get_port_speed(port) == USB_SPEED_LOW) {
status |= (1 << HUB_PORT_FEATURE_LOWSPEED);
} else if (usbh_get_port_speed(port) == USB_SPEED_HIGH) {
status |= (1 << HUB_PORT_FEATURE_HIGHSPEED);
}
}
if (temp & EHCI_PORTSC_SUSPEND) {
status |= (1 << HUB_PORT_FEATURE_SUSPEND);
}
if (temp & EHCI_PORTSC_OCA) {
status |= (1 << HUB_PORT_FEATURE_OVERCURRENT);
}
if (temp & EHCI_PORTSC_RESET) {
status |= (1 << HUB_PORT_FEATURE_RESET);
}
if (temp & EHCI_PORTSC_PP) {
status |= (1 << HUB_PORT_FEATURE_POWER);
}
memcpy(buf, &status, 4);
break;
default:
break;
}
}
return 0;
}
int usbh_ep_pipe_reconfigure(usbh_pipe_t pipe, uint8_t dev_addr, uint8_t ep_mps, uint8_t mult)
{
struct ehci_pipe *ppipe = (struct ehci_pipe *)pipe;
ppipe->dev_addr = dev_addr;
ppipe->ep_mps = ep_mps;
ppipe->mult = mult;
return 0;
}
int usbh_pipe_alloc(usbh_pipe_t *pipe, const struct usbh_endpoint_cfg *ep_cfg)
{
struct ehci_pipe *ppipe;
usb_osal_sem_t waitsem;
ppipe = ehci_pipe_alloc();
if (ppipe == NULL) {
return -ENOMEM;
}
/* store variables */
waitsem = ppipe->waitsem;
memset(ppipe, 0, sizeof(struct ehci_pipe));
ppipe->ep_addr = ep_cfg->ep_addr;
ppipe->ep_type = ep_cfg->ep_type;
ppipe->ep_mps = ep_cfg->ep_mps;
ppipe->ep_interval = ep_cfg->ep_interval;
ppipe->mult = ep_cfg->mult;
ppipe->speed = ep_cfg->hport->speed;
ppipe->dev_addr = ep_cfg->hport->dev_addr;
ppipe->hport = ep_cfg->hport;
#ifdef CONFIG_USB_EHCI_ISO
if ((ppipe->speed == USB_SPEED_HIGH) && (ppipe->ep_type == USB_ENDPOINT_TYPE_ISOCHRONOUS)) {
if (ep_cfg->ep_interval == 0x01) { /* transfer interval 1 mf */
ppipe->mf_unmask = 0xff;
ppipe->mf_valid = 8;
} else if (ep_cfg->ep_interval == 0x02) { /* transfer interval 2 mf */
ppipe->mf_unmask = 0x55;
ppipe->mf_valid = 4;
} else if (ep_cfg->ep_interval == 0x03) { /* transfer interval 4 mf */
ppipe->mf_unmask = 0x44;
ppipe->mf_valid = 2;
} else if (ep_cfg->ep_interval == 0x04) { /* transfer interval 8 mf */
ppipe->mf_unmask = 0x01;
ppipe->mf_valid = 1;
}
}
#endif
/* restore variable */
ppipe->inuse = true;
ppipe->waitsem = waitsem;
*pipe = (usbh_pipe_t)ppipe;
return 0;
}
int usbh_pipe_free(usbh_pipe_t pipe)
{
struct usbh_urb *urb;
size_t flags;
struct ehci_pipe *ppipe = (struct ehci_pipe *)pipe;
if (!ppipe) {
return -EINVAL;
}
urb = ppipe->urb;
if (urb) {
usbh_kill_urb(urb);
}
flags = usb_osal_enter_critical_section();
ehci_pipe_free(ppipe);
usb_osal_leave_critical_section(flags);
return 0;
}
int usbh_submit_urb(struct usbh_urb *urb)
{
struct ehci_pipe *pipe;
struct ehci_qh_hw *qh = NULL;
size_t flags;
int ret = 0;
if (!urb) {
return -EINVAL;
}
pipe = urb->pipe;
if (!pipe) {
return -EINVAL;
}
if (!pipe->hport->connected) {
return -ENODEV;
}
if (pipe->urb && (pipe->ep_type != USB_ENDPOINT_TYPE_ISOCHRONOUS)) {
return -EBUSY;
}
flags = usb_osal_enter_critical_section();
pipe->waiter = false;
pipe->xfrd = 0;
pipe->qh = NULL;
pipe->urb = urb;
urb->errorcode = -EBUSY;
urb->actual_length = 0;
if (urb->timeout > 0) {
pipe->waiter = true;
}
usb_osal_leave_critical_section(flags);
switch (pipe->ep_type) {
case USB_ENDPOINT_TYPE_CONTROL:
qh = ehci_control_pipe_init(pipe, urb->setup, urb->transfer_buffer, urb->transfer_buffer_length);
if (qh == NULL) {
return -ENOMEM;
}
break;
case USB_ENDPOINT_TYPE_BULK:
qh = ehci_bulk_pipe_init(pipe, urb->transfer_buffer, urb->transfer_buffer_length);
if (qh == NULL) {
return -ENOMEM;
}
break;
case USB_ENDPOINT_TYPE_INTERRUPT:
qh = ehci_intr_pipe_init(pipe, urb->transfer_buffer, urb->transfer_buffer_length);
if (qh == NULL) {
return -ENOMEM;
}
break;
case USB_ENDPOINT_TYPE_ISOCHRONOUS:
#ifdef CONFIG_USB_EHCI_ISO
ehci_iso_pipe_init(pipe, urb);
#endif
break;
default:
break;
}
if (urb->timeout > 0) {
/* wait until timeout or sem give */
ret = usb_osal_sem_take(pipe->waitsem, urb->timeout);
if (ret < 0) {
goto errout_timeout;
}
ret = urb->errorcode;
}
return ret;
errout_timeout:
/* Timeout will run here */
pipe->waiter = false;
usbh_kill_urb(urb);
return ret;
}
int usbh_kill_urb(struct usbh_urb *urb)
{
struct ehci_pipe *pipe;
struct ehci_qh_hw *qh = NULL;
size_t flags;
if (!urb) {
return -EINVAL;
}
pipe = urb->pipe;
if (!pipe) {
return -EINVAL;
}
flags = usb_osal_enter_critical_section();
EHCI_HCOR->usbcmd &= ~(EHCI_USBCMD_PSEN | EHCI_USBCMD_ASEN);
if ((pipe->ep_type == USB_ENDPOINT_TYPE_CONTROL) || (pipe->ep_type == USB_ENDPOINT_TYPE_BULK)) {
qh = EHCI_ADDR2QH(g_async_qh_head.hw.hlp);
while ((qh != &g_async_qh_head) && qh) {
if (qh == pipe->qh) {
ehci_kill_qh(&g_async_qh_head, qh);
}
qh = EHCI_ADDR2QH(qh->hw.hlp);
}
} else if (pipe->ep_type == USB_ENDPOINT_TYPE_INTERRUPT) {
qh = EHCI_ADDR2QH(g_periodic_qh_head[EHCI_PERIOIDIC_QH_NUM - 1].hw.hlp);
while (qh) {
if (qh == pipe->qh) {
if (pipe->speed == USB_SPEED_HIGH) {
ehci_kill_qh(ehci_get_periodic_qhead(pipe->ep_interval), qh);
} else {
ehci_kill_qh(ehci_get_periodic_qhead(pipe->ep_interval * 8), qh);
}
}
qh = EHCI_ADDR2QH(qh->hw.hlp);
}
} else {
#ifdef CONFIG_USB_EHCI_ISO
ehci_remove_itd_urb(urb);
#endif
}
EHCI_HCOR->usbcmd |= (EHCI_USBCMD_PSEN | EHCI_USBCMD_ASEN);
pipe->qh = NULL;
pipe->urb = NULL;
if (pipe->waiter) {
pipe->waiter = false;
urb->errorcode = -ESHUTDOWN;
//usb_osal_sem_give(pipe->waitsem);
}
usb_osal_leave_critical_section(flags);
return 0;
}
static void ehci_scan_async_list(void)
{
struct ehci_qh_hw *qh;
struct ehci_pipe *pipe;
qh = EHCI_ADDR2QH(g_async_qh_head.hw.hlp);
while ((qh != &g_async_qh_head) && qh) {
pipe = qh->pipe;
if (pipe) {
ehci_check_qh(&g_async_qh_head, qh, pipe);
}
qh = EHCI_ADDR2QH(qh->hw.hlp);
}
}
static void ehci_scan_periodic_list(void)
{
struct ehci_qh_hw *qh;
struct ehci_pipe *pipe;
qh = EHCI_ADDR2QH(g_periodic_qh_head[EHCI_PERIOIDIC_QH_NUM - 1].hw.hlp);
while (qh) {
pipe = qh->pipe;
if (pipe) {
if (pipe->speed == USB_SPEED_HIGH) {
ehci_check_qh(ehci_get_periodic_qhead(pipe->ep_interval), qh, pipe);
} else {
ehci_check_qh(ehci_get_periodic_qhead(pipe->ep_interval * 8), qh, pipe);
}
}
qh = EHCI_ADDR2QH(qh->hw.hlp);
}
}
void USBH_IRQHandler(void)
{
uint32_t usbsts;
usbsts = EHCI_HCOR->usbsts & EHCI_HCOR->usbintr;
EHCI_HCOR->usbsts = usbsts;
if (usbsts & EHCI_USBSTS_INT) {
ehci_scan_async_list();
ehci_scan_periodic_list();
#ifdef CONFIG_USB_EHCI_ISO
ehci_scan_isochronous_list();
#endif
}
if (usbsts & EHCI_USBSTS_ERR) {
ehci_scan_async_list();
ehci_scan_periodic_list();
#ifdef CONFIG_USB_EHCI_ISO
ehci_scan_isochronous_list();
#endif
}
if (usbsts & EHCI_USBSTS_PCD) {
for (int port = 0; port < CONFIG_USBHOST_MAX_RHPORTS; port++) {
uint32_t portsc = EHCI_HCOR->portsc[port];
if (portsc & EHCI_PORTSC_CSC) {
if ((portsc & EHCI_PORTSC_CCS) == EHCI_PORTSC_CCS) {
} else {
for (uint8_t index = 0; index < CONFIG_USB_EHCI_QH_NUM; index++) {
g_ehci_hcd.ehci_qh_used[index] = false;
}
for (uint8_t index = 0; index < CONFIG_USB_EHCI_QTD_NUM; index++) {
g_ehci_hcd.ehci_qtd_used[index] = false;
}
for (uint8_t index = 0; index < CONFIG_USB_EHCI_ITD_NUM; index++) {
g_ehci_hcd.ehci_itd_used[index] = false;
}
}
usbh_roothub_thread_wakeup(port + 1);
}
}
}
if (usbsts & EHCI_USBSTS_IAA) {
}
if (usbsts & EHCI_USBSTS_FATAL) {
}
}
Reference in New Issue View Git Blame Copy Permalink