267 lines
7.6 KiB
C
267 lines
7.6 KiB
C
#include "usb_config.h"
|
|
#include "usb/scsi.h"
|
|
#include "irq.h"
|
|
#include "system/spinlock.h"
|
|
#include "app_config.h"
|
|
|
|
#define LOG_TAG_CONST USB
|
|
#define LOG_TAG "[USB]"
|
|
#define LOG_ERROR_ENABLE
|
|
#define LOG_DEBUG_ENABLE
|
|
#define LOG_INFO_ENABLE
|
|
/* #define LOG_DUMP_ENABLE */
|
|
#define LOG_CLI_ENABLE
|
|
#include "debug.h"
|
|
|
|
#define SET_INTERRUPT ___interrupt
|
|
|
|
#if TCFG_UDISK_ENABLE || TCFG_HID_HOST_ENABLE || TCFG_AOA_ENABLE || TCFG_ADB_ENABLE || TCFG_HOST_AUDIO_ENABLE || \
|
|
TCFG_HOST_UVC_ENABLE || TCFG_HOST_WIRELESS_ENABLE
|
|
|
|
#if TCFG_HOST_UVC_ENABLE
|
|
#define MAX_HOST_EP_RX 5
|
|
#define MAX_HOST_EP_TX 5
|
|
#elif TCFG_HID_HOST_ENABLE || TCFG_HOST_AUDIO_ENABLE
|
|
#define MAX_HOST_EP_RX 4
|
|
#define MAX_HOST_EP_TX 4
|
|
#elif TCFG_HOST_WIRELESS_ENABLE
|
|
#define MAX_HOST_EP_RX 3
|
|
#define MAX_HOST_EP_TX 3
|
|
#else
|
|
#define MAX_HOST_EP_RX 2
|
|
#define MAX_HOST_EP_TX 2 //ep0 & ep1(msd)
|
|
#endif
|
|
|
|
struct host_var_t {
|
|
struct usb_ep_addr_t host_ep_addr;
|
|
usb_h_interrupt usb_h_interrupt_rx[MAX_HOST_EP_RX];
|
|
usb_h_interrupt usb_h_interrupt_tx[MAX_HOST_EP_TX];
|
|
struct usb_host_device *dev_at_ep[MAX_HOST_EP_RX];
|
|
};
|
|
static struct host_var_t *host_var[USB_MAX_HW_NUM];// SEC(.usb_h_bss);
|
|
static spinlock_t lock[USB_MAX_HW_NUM];
|
|
|
|
static void usb_h_isr(const usb_dev usb_id)
|
|
{
|
|
u32 intr_usb, intr_usbe;
|
|
u32 intr_tx, intr_txe;
|
|
u32 intr_rx, intr_rxe;
|
|
|
|
__asm__ volatile("ssync");
|
|
|
|
usb_read_intr(usb_id, &intr_usb, &intr_tx, &intr_rx);
|
|
usb_read_intre(usb_id, &intr_usbe, &intr_txe, &intr_rxe);
|
|
struct usb_host_device *host_dev = NULL;
|
|
|
|
/* r_printf("usb_h_isr %x %x %x %x",host_dev,intr_usb,intr_tx,intr_rx); */
|
|
intr_usb &= intr_usbe;
|
|
intr_tx &= intr_txe;
|
|
intr_rx &= intr_rxe;
|
|
|
|
if (intr_usb & INTRUSB_SUSPEND) {
|
|
log_error("usb suspend");
|
|
}
|
|
if (intr_usb & INTRUSB_RESET_BABBLE) {
|
|
log_error("usb reset");
|
|
}
|
|
if (intr_usb & INTRUSB_RESUME) {
|
|
log_error("usb resume");
|
|
}
|
|
|
|
if (intr_tx & BIT(0)) {
|
|
spin_lock(&lock[usb_id]);
|
|
if (host_var[usb_id] && host_var[usb_id]->usb_h_interrupt_tx[0]) {
|
|
host_dev = host_var[usb_id]->dev_at_ep[0];
|
|
host_var[usb_id]->usb_h_interrupt_tx[0](host_dev, 0);
|
|
}
|
|
spin_unlock(&lock[usb_id]);
|
|
}
|
|
|
|
for (int i = 1; i < MAX_HOST_EP_TX; i++) {
|
|
if (intr_tx & BIT(i)) {
|
|
spin_lock(&lock[usb_id]);
|
|
if (host_var[usb_id] && host_var[usb_id]->usb_h_interrupt_tx[i]) {
|
|
host_dev = host_var[usb_id]->dev_at_ep[i];
|
|
host_var[usb_id]->usb_h_interrupt_tx[i](host_dev, i);
|
|
}
|
|
spin_unlock(&lock[usb_id]);
|
|
}
|
|
}
|
|
|
|
for (int i = 1; i < MAX_HOST_EP_RX; i++) {
|
|
if (intr_rx & BIT(i)) {
|
|
spin_lock(&lock[usb_id]);
|
|
if (host_var[usb_id] && host_var[usb_id]->usb_h_interrupt_rx[i]) {
|
|
host_dev = host_var[usb_id]->dev_at_ep[i];
|
|
host_var[usb_id]->usb_h_interrupt_rx[i](host_dev, i);
|
|
}
|
|
spin_unlock(&lock[usb_id]);
|
|
}
|
|
}
|
|
|
|
__asm__ volatile("csync");
|
|
}
|
|
|
|
SET_INTERRUPT
|
|
static void usb0_h_isr(void)
|
|
{
|
|
usb_h_isr(0);
|
|
}
|
|
|
|
SET_INTERRUPT
|
|
static void usb1_h_isr(void)
|
|
{
|
|
usb_h_isr(1);
|
|
}
|
|
|
|
__attribute__((always_inline_when_const_args))
|
|
u32 usb_h_set_intr_hander(const usb_dev usb_id, u32 ep, usb_h_interrupt hander)
|
|
{
|
|
spin_lock(&lock[usb_id]);
|
|
if (ep & USB_DIR_IN) {
|
|
if (host_var[usb_id]) {
|
|
host_var[usb_id]->usb_h_interrupt_rx[ep & 0xf] = hander;
|
|
}
|
|
} else {
|
|
if (host_var[usb_id]) {
|
|
host_var[usb_id]->usb_h_interrupt_tx[ep] = hander;
|
|
}
|
|
}
|
|
spin_unlock(&lock[usb_id]);
|
|
return 0;
|
|
}
|
|
|
|
void usb_h_isr_reg(const usb_dev usb_id, u8 priority, u8 cpu_id)
|
|
{
|
|
if (usb_id == 0) {
|
|
request_irq(IRQ_USB_CTRL_IDX, priority, usb0_h_isr, 0);
|
|
#if USB_MAX_HW_NUM > 1
|
|
} else if (usb_id == 1) {
|
|
request_irq(IRQ_USB1_CTRL_IDX, priority, usb1_h_isr, 1);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void usb_h_isr_unreg(const usb_dev usb_id, u8 cpu_id)
|
|
{
|
|
if (usb_id == 0) {
|
|
unrequest_irq(IRQ_USB_CTRL_IDX, 0);
|
|
#if USB_MAX_HW_NUM > 1
|
|
} else if (usb_id == 1) {
|
|
unrequest_irq(IRQ_USB1_CTRL_IDX, 1);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#if (USB_H_MALLOC_ENABLE == 0)
|
|
#if TCFG_ADB_ENABLE && TCFG_AOA_ENABLE && TCFG_HID_HOST_ENABLE
|
|
static u8 ep0_dma[USB_MAX_HW_NUM][64 + 4] __attribute__((aligned(4)));
|
|
static u8 ep1_dma[USB_MAX_HW_NUM][64 * 2 + 4] __attribute__((aligned(4)));
|
|
static u8 ep2_dma[USB_MAX_HW_NUM][64 * 2 + 4] __attribute__((aligned(4)));
|
|
static u8 ep3_dma[USB_MAX_HW_NUM][64 * 2 + 4] __attribute__((aligned(4)));
|
|
static u8 ep4_dma[USB_MAX_HW_NUM][64 * 2 + 4] __attribute__((aligned(4)));
|
|
#else
|
|
static u8 msd_h_dma_buffer[2][64 + 4] __attribute__((aligned(4))) SEC(.usb_h_dma);
|
|
#endif
|
|
|
|
__attribute__((always_inline_when_const_args))
|
|
void *usb_h_get_ep_buffer(const usb_dev usb_id, u32 ep)
|
|
{
|
|
#if TCFG_ADB_ENABLE && TCFG_AOA_ENABLE && TCFG_HID_HOST_ENABLE
|
|
u8 dir = !!(ep & USB_DIR_IN);
|
|
u8 *p = NULL;
|
|
switch (ep & 0xf) {
|
|
case 0:
|
|
p = &ep0_dma[usb_id][0];
|
|
break;
|
|
case 1:
|
|
p = &ep1_dma[usb_id][dir * 64];
|
|
break;
|
|
case 2:
|
|
p = &ep2_dma[usb_id][dir * 64];
|
|
break;
|
|
case 3:
|
|
p = &ep3_dma[usb_id][dir * 64];
|
|
break;
|
|
case 4:
|
|
p = &ep4_dma[usb_id][dir * 64];
|
|
break;
|
|
}
|
|
return p;
|
|
#else
|
|
return msd_h_dma_buffer;
|
|
#endif
|
|
}
|
|
#endif //(USB_H_MALLOC_ENABLE == 0)
|
|
|
|
extern void *usb_epbuf_alloc(const usb_dev usb_id, u32 size);
|
|
extern void usb_epbuf_free(const usb_dev usb_id, void *buf);
|
|
|
|
void *usb_h_alloc_ep_buffer(const usb_dev usb_id, u32 ep, u32 dma_size)
|
|
{
|
|
u8 *ep_buffer = NULL;
|
|
#if USB_H_MALLOC_ENABLE
|
|
ep_buffer = usb_epbuf_alloc(usb_id, dma_size);
|
|
#else
|
|
ep_buffer = usb_h_get_ep_buffer(usb_id, ep);
|
|
#endif
|
|
ASSERT(ep_buffer, "%s() ep_buffer = NULL!!!, usb_id = %d, ep = %x, dma_size = %d\n", __func__, usb_id, ep, dma_size);
|
|
log_info("usb%d host, ep = %x, dma_size = %d, ep_buffer = %x\n", usb_id, ep, dma_size, ep_buffer);
|
|
return ep_buffer;
|
|
}
|
|
|
|
void usb_h_free_ep_buffer(const usb_dev usb_id, void *buf)
|
|
{
|
|
#if USB_H_MALLOC_ENABLE
|
|
usb_epbuf_free(usb_id, buf);
|
|
#endif
|
|
log_info("usb%d host free ep buffer %x\n", usb_id, (u32)buf);
|
|
}
|
|
|
|
void usb_h_set_ep_isr(struct usb_host_device *host_dev, u32 ep, usb_h_interrupt hander, void *p)
|
|
{
|
|
if (host_dev) {
|
|
usb_dev usb_id = host_device2id(host_dev);
|
|
spin_lock(&lock[usb_id]);
|
|
if (host_var[usb_id]) {
|
|
host_var[usb_id]->dev_at_ep[ep & 0xf] = p;
|
|
}
|
|
spin_unlock(&lock[usb_id]);
|
|
usb_h_set_intr_hander(usb_id, ep, hander);
|
|
}
|
|
}
|
|
|
|
void usb_host_config(usb_dev usb_id)
|
|
{
|
|
if (!host_var[usb_id]) {
|
|
host_var[usb_id] = zalloc(sizeof(struct host_var_t));
|
|
}
|
|
|
|
ASSERT(host_var[usb_id], "host_var_t");
|
|
|
|
/* g_printf("%s() %x %x", __func__, host_var[usb_id], &(host_var[usb_id]->host_ep_addr)); */
|
|
usb_var_init(usb_id, &(host_var[usb_id]->host_ep_addr));
|
|
}
|
|
|
|
void usb_host_free(usb_dev usb_id)
|
|
{
|
|
struct host_var_t *__host_var = NULL;
|
|
|
|
g_printf("%s() %x", __func__, host_var[usb_id]);
|
|
|
|
usb_h_isr_unreg(usb_id, 0);
|
|
|
|
spin_lock(&lock[usb_id]);
|
|
if (host_var[usb_id]) {
|
|
memset(host_var[usb_id]->usb_h_interrupt_rx, 0, sizeof(usb_h_interrupt) * MAX_HOST_EP_RX);
|
|
memset(host_var[usb_id]->usb_h_interrupt_tx, 0, sizeof(usb_h_interrupt) * MAX_HOST_EP_TX);
|
|
__host_var = host_var[usb_id];
|
|
/* usb_var_release(usb_id); */ //释放可能有异步问题
|
|
/* host_var[usb_id] = NULL; */ //释放可能有异步问题
|
|
}
|
|
spin_unlock(&lock[usb_id]);
|
|
|
|
/* free(__host_var); */ //释放可能有异步问题
|
|
}
|
|
#endif
|