len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-12-08 12:45:26 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
rockbox/firmware/target/arm/tms320dm320/sansa-connect/tnetv105_usb_drv.c
Tomasz Moń 663d846cf3 Sansa Connect: Disable endpoint double buffering 
Disabling double buffering results in expected CPPI TX behaviour. With
the double buffering enabled, sending single ZLP resulted in two ZLPs
being available. The two ZLPs is problematic because this causes Windows
to reset USB device after failed SCSI command.

The problematic sequence on Windows 10 was as follows:
  * Host sends SCSI Mode Sense(6) Informational Exceptions Control(0x1C)
  * Device sends ZLP
  * Device sends command failed response

With endpoint double buffering enabled the ZLP was read twice by host.
As host was expecting command response on the second read (and got ZLP
instead), host attempts recovery by resetting USB device and retrying.

Change-Id: I64e95998f429ffb7b14143d956b1f29d20218d14
2021-06-12 13:54:54 +00:00

1521 lines
41 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id: $
*
* Copyright (C) 2021 by Tomasz Moń
* Ported from Sansa Connect TNETV105 UDC Linux driver
* Copyright (c) 2005,2006 Zermatt Systems, Inc.
* Written by: Ben Bostwick
* Linux driver was modeled strongly after the pxa usb driver.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "system.h"
#include "kernel.h"
#include "panic.h"
#include "logf.h"
#include "usb.h"
#include "usb_drv.h"
#include "usb_core.h"
#include <string.h>
#include "tnetv105_usb_drv.h"
#include "tnetv105_cppi.h"
#ifdef SANSA_CONNECT
#define SDRAM_SIZE 0x04000000
static void set_tnetv_reset(bool high)
{
if (high)
{
IO_GIO_BITSET0 = (1 << 7);
}
else
{
IO_GIO_BITCLR0 = (1 << 7);
}
}
static bool is_tnetv_reset_high(void)
{
return (IO_GIO_BITSET0 & (1 << 7)) ? true : false;
}
#endif
static bool setup_is_set_address;
static cppi_info cppi;
static struct ep_runtime_t
{
int max_packet_size;
bool in_allocated;
bool out_allocated;
uint8_t *rx_buf; /* OUT */
int rx_remaining;
int rx_size;
uint8_t *tx_buf; /* IN */
int tx_remaining;
int tx_size;
volatile bool block; /* flag indicating that transfer is blocking */
struct semaphore complete; /* semaphore for blocking transfers */
}
ep_runtime[USB_NUM_ENDPOINTS];
static const struct
{
int type;
int hs_max_packet_size;
/* Not sure what xyoff[1] is for. Presumably it is double buffer, but how
* the double buffering works is not so clear from the Sansa Connect Linux
* kernel patch. As TNETV105 datasheet is not available, the values are
* simply taken from the Linux patch as potential constraints are unknown.
*
* Linux kernel has 9 endpoints:
* * 0: ep0
* * 1: ep1in-bulk
* * 2: ep2out-bulk
* * 3: ep3in-int
* * 4: ep4in-int
* * 5: ep1out-bulk
* * 6: ep2in-bulk
* * 7: ep3out-int
* * 8: ep4out-int
*/
uint16_t xyoff_in[2];
uint16_t xyoff_out[2];
}
ep_const_data[USB_NUM_ENDPOINTS] =
{
{
.type = USB_ENDPOINT_XFER_CONTROL,
.hs_max_packet_size = EP0_MAX_PACKET_SIZE,
/* Do not set xyoff as it likely does not apply here.
* Linux simply hardcodes the offsets when needed.
*/
},
{
.type = USB_ENDPOINT_XFER_BULK,
.hs_max_packet_size = EP1_MAX_PACKET_SIZE,
.xyoff_in = {EP1_XBUFFER_ADDRESS, EP1_YBUFFER_ADDRESS},
.xyoff_out = {EP5_XBUFFER_ADDRESS, EP5_YBUFFER_ADDRESS},
},
{
.type = USB_ENDPOINT_XFER_BULK,
.hs_max_packet_size = EP2_MAX_PACKET_SIZE,
.xyoff_in = {EP6_XBUFFER_ADDRESS, EP6_YBUFFER_ADDRESS},
.xyoff_out = {EP2_XBUFFER_ADDRESS, EP2_YBUFFER_ADDRESS},
},
{
.type = USB_ENDPOINT_XFER_INT,
.hs_max_packet_size = EP3_MAX_PACKET_SIZE,
.xyoff_in = {EP3_XBUFFER_ADDRESS, EP3_YBUFFER_ADDRESS},
.xyoff_out = {EP7_XBUFFER_ADDRESS, EP7_YBUFFER_ADDRESS},
},
{
.type = USB_ENDPOINT_XFER_INT,
.hs_max_packet_size = EP4_MAX_PACKET_SIZE,
.xyoff_in = {EP4_XBUFFER_ADDRESS, EP4_YBUFFER_ADDRESS},
.xyoff_out = {EP8_XBUFFER_ADDRESS, EP8_YBUFFER_ADDRESS},
},
};
#define VLYNQ_CTL_RESET_MASK 0x0001
#define VLYNQ_CTL_CLKDIR_MASK 0x8000
#define VLYNQ_STS_LINK_MASK 0x0001
#define DM320_VLYNQ_CTRL_RESET (1 << 0)
#define DM320_VLYNQ_CTRL_LOOP (1 << 1)
#define DM320_VLYNQ_CTRL_ADR_OPT (1 << 2)
#define DM320_VLYNQ_CTRL_INT_CFG (1 << 7)
#define DM320_VLYNQ_CTRL_INT_VEC_MASK (0x00001F00)
#define DM320_VLYNQ_CTRL_INT_EN (1 << 13)
#define DM320_VLYNQ_CTRL_INT_LOC (1 << 14)
#define DM320_VLYNQ_CTRL_CLKDIR (1 << 15)
#define DM320_VLYNQ_CTRL_CLKDIV_MASK (0x00070000)
#define DM320_VLYNQ_CTRL_PWR_MAN (1 << 31)
#define DM320_VLYNQ_STAT_LINK (1 << 0)
#define DM320_VLYNQ_STAT_MST_PEND (1 << 1)
#define DM320_VLYNQ_STAT_SLV_PEND (1 << 2)
#define DM320_VLYNQ_STAT_F0_NE (1 << 3)
#define DM320_VLYNQ_STAT_F1_NE (1 << 4)
#define DM320_VLYNQ_STAT_F2_NE (1 << 5)
#define DM320_VLYNQ_STAT_F3_NE (1 << 6)
#define DM320_VLYNQ_STAT_LOC_ERR (1 << 7)
#define DM320_VLYNQ_STAT_REM_ERR (1 << 8)
#define DM320_VLYNQ_STAT_FC_OUT (1 << 9)
#define DM320_VLYNQ_STAT_FC_IN (1 << 10)
#define MAX_PACKET(epn, speed) ((((speed) == USB_SPEED_HIGH) && (((epn) == 1) || ((epn) == 2))) ? USB_HIGH_SPEED_MAXPACKET : USB_FULL_SPEED_MAXPACKET)
#define VLYNQ_INTR_USB20 (1 << 0)
#define VLYNQ_INTR_CPPI (1 << 1)
static inline void set_vlynq_clock(bool enable)
{
if (enable)
{
IO_CLK_MOD2 |= (1 << 13);
}
else
{
IO_CLK_MOD2 &= ~(1 << 13);
}
}
static inline void set_vlynq_irq(bool enabled)
{
if (enabled)
{
/* Enable VLYNQ interrupt */
IO_INTC_EINT1 |= (1 << 0);
}
else
{
IO_INTC_EINT1 &= ~(1 << 0);
}
}
static int tnetv_hw_reset(void)
{
int timeout;
/* hold down the reset pin on the USB chip */
set_tnetv_reset(false);
/* Turn on VLYNQ clock. */
set_vlynq_clock(true);
/* now reset the VLYNQ module */
VL_CTRL |= (VLYNQ_CTL_CLKDIR_MASK | DM320_VLYNQ_CTRL_PWR_MAN);
VL_CTRL |= VLYNQ_CTL_RESET_MASK;
mdelay(10);
/* pull up the reset pin */
set_tnetv_reset(true);
/* take the VLYNQ out of reset */
VL_CTRL &= ~VLYNQ_CTL_RESET_MASK;
timeout = 0;
while (!(VL_STAT & VLYNQ_STS_LINK_MASK) && timeout++ < 50);
{
mdelay(40);
}
if (!(VL_STAT & VLYNQ_STS_LINK_MASK))
{
logf("ERROR: VLYNQ not initialized!\n");
return -1;
}
/* set up vlynq local map */
VL_TXMAP = DM320_VLYNQ_PADDR;
VL_RXMAPOF1 = CONFIG_SDRAM_START;
VL_RXMAPSZ1 = SDRAM_SIZE;
/* set up vlynq remote map for tnetv105 */
VL_TXMAP_R = 0x00000000;
VL_RXMAPOF1_R = 0x0C000000;
VL_RXMAPSZ1_R = 0x00030000;
/* clear TNETV gpio state */
tnetv_usb_reg_write(TNETV_V2USB_GPIO_FS, 0);
/* set USB_CHARGE_EN pin (gpio 1) - output, disable pullup */
tnetv_usb_reg_write(TNETV_V2USB_GPIO_DOUT, 0);
tnetv_usb_reg_write(TNETV_V2USB_GPIO_DIR, 0xffff);
return 0;
}
static int tnetv_xcvr_on(void)
{
return tnetv_hw_reset();
}
static void tnetv_xcvr_off(void)
{
/* turn off vlynq module clock */
set_vlynq_clock(false);
/* hold down the reset pin on the USB chip */
set_tnetv_reset(false);
}
/* Copy data from the usb data memory. The memory reads should be done 32 bits at a time.
* We do not assume that the dst data is aligned.
*/
static void tnetv_copy_from_data_mem(void *dst, const volatile uint32_t *sp, int size)
{
uint8_t *dp = (uint8_t *) dst;
uint32_t value;
while (size >= 4)
{
value = *sp++;
dp[0] = value;
dp[1] = value >> 8;
dp[2] = value >> 16;
dp[3] = value >> 24;
dp += 4;
size -= 4;
}
if (size)
{
value = sp[0];
switch (size)
{
case 3:
dp[2] = value >> 16;
case 2:
dp[1] = value >> 8;
case 1:
dp[0] = value;
break;
}
}
}
/* Copy data into the usb data memory. The memory writes must be done 32 bits at a time.
* We do not assume that the src data is aligned.
*/
static void tnetv_copy_to_data_mem(volatile uint32_t *dp, const void *src, int size)
{
const uint8_t *sp = (const uint8_t *) src;
uint32_t value;
while (size >= 4)
{
value = sp[0] | (sp[1] << 8) | (sp[2] << 16) | (sp[3] << 24);
*dp++ = value;
sp += 4;
size -= 4;
}
switch (size)
{
case 3:
value = sp[0] | (sp[1] << 8) | (sp[2] << 16);
*dp = value;
break;
case 2:
value = sp[0] | (sp[1] << 8);
*dp = value;
break;
case 1:
value = sp[0];
*dp = value;
break;
}
}
static void tnetv_init_endpoints(void)
{
UsbEp0CtrlType ep0Cfg;
UsbEp0ByteCntType ep0Cnt;
UsbEpCfgCtrlType epCfg;
UsbEpStartAddrType epStartAddr;
int ch, wd, epn;
ep0Cnt.val = 0;
ep0Cnt.f.out_ybuf_nak = 1;
ep0Cnt.f.out_xbuf_nak = 1;
ep0Cnt.f.in_ybuf_nak = 1;
ep0Cnt.f.in_xbuf_nak = 1;
tnetv_usb_reg_write(TNETV_USB_EP0_CNT, ep0Cnt.val);
/* Setup endpoint zero */
ep0Cfg.val = 0;
ep0Cfg.f.buf_size = EP0_BUF_SIZE_64; /* must be 64 bytes for USB 2.0 */
ep0Cfg.f.dbl_buf = 0;
ep0Cfg.f.in_en = 1;
ep0Cfg.f.in_int_en = 1;
ep0Cfg.f.out_en = 1;
ep0Cfg.f.out_int_en = 1;
tnetv_usb_reg_write(TNETV_USB_EP0_CFG, ep0Cfg.val);
/* disable cell dma */
tnetv_usb_reg_write(TNETV_USB_CELL_DMA_EN, 0);
/* turn off dma engines */
tnetv_usb_reg_write(TNETV_USB_TX_CTL, 0);
tnetv_usb_reg_write(TNETV_USB_RX_CTL, 0);
/* clear out DMA registers */
for (ch = 0; ch < TNETV_DMA_NUM_CHANNELS; ch++)
{
for (wd = 0; wd < TNETV_DMA_TX_NUM_WORDS; wd++)
{
tnetv_usb_reg_write(TNETV_DMA_TX_STATE(ch, wd), 0);
}
for (wd = 0; wd < TNETV_DMA_RX_NUM_WORDS; wd++)
{
tnetv_usb_reg_write(TNETV_DMA_RX_STATE(ch, wd), 0);
}
/* flush the free buf count */
while (tnetv_usb_reg_read(TNETV_USB_RX_FREE_BUF_CNT(ch)) != 0)
{
tnetv_usb_reg_write(TNETV_USB_RX_FREE_BUF_CNT(ch), 0xFFFF);
}
}
for (epn = 1; epn < USB_NUM_ENDPOINTS; epn++)
{
tnetv_usb_reg_write(TNETV_USB_EPx_ADR(epn),0);
tnetv_usb_reg_write(TNETV_USB_EPx_CFG(epn), 0);
tnetv_usb_reg_write(TNETV_USB_EPx_IN_CNT(epn), 0x80008000);
tnetv_usb_reg_write(TNETV_USB_EPx_OUT_CNT(epn), 0x80008000);
}
/* Setup the other endpoints */
for (epn = 1; epn < USB_NUM_ENDPOINTS; epn++)
{
epCfg.val = tnetv_usb_reg_read(TNETV_USB_EPx_CFG(epn));
epStartAddr.val = tnetv_usb_reg_read(TNETV_USB_EPx_ADR(epn));
/* Linux kernel enables dbl buf for both IN and OUT.
* For IN this is problematic when tnetv_cppi_send() is called
* to send single ZLP, it will actually send two ZLPs.
* Disable the dbl buf here as datasheet is not available and
* this results in working mass storage on Windows 10.
*/
epCfg.f.in_dbl_buf = 0;
epCfg.f.in_toggle_rst = 1;
epCfg.f.in_ack_int = 0;
epCfg.f.in_stall = 0;
epCfg.f.in_nak_int = 0;
epCfg.f.out_dbl_buf = 0;
epCfg.f.out_toggle_rst = 1;
epCfg.f.out_ack_int = 0;
epCfg.f.out_stall = 0;
epCfg.f.out_nak_int = 0;
/* buf_size is specified "in increments of 8 bytes" */
epCfg.f.in_buf_size = ep_const_data[epn].hs_max_packet_size >> 3;
epCfg.f.out_buf_size = ep_const_data[epn].hs_max_packet_size >> 3;
epStartAddr.f.xBuffStartAddrIn = ep_const_data[epn].xyoff_in[0] >> 4;
epStartAddr.f.yBuffStartAddrIn = ep_const_data[epn].xyoff_in[1] >> 4;
epStartAddr.f.xBuffStartAddrOut = ep_const_data[epn].xyoff_out[0] >> 4;
epStartAddr.f.yBuffStartAddrOut = ep_const_data[epn].xyoff_out[1] >> 4;
/* allocate memory for DMA */
tnetv_cppi_init_rcb(&cppi, (epn - 1));
/* set up DMA queue */
tnetv_cppi_init_tcb(&cppi, (epn - 1));
/* now write out the config to the TNETV (write enable bits last) */
tnetv_usb_reg_write(TNETV_USB_EPx_ADR(epn), epStartAddr.val);
tnetv_usb_reg_write(TNETV_USB_EPx_CFG(epn), epCfg.val);
tnetv_usb_reg_write(TNETV_USB_EPx_IN_CNT(epn), 0x80008000);
tnetv_usb_reg_write(TNETV_USB_EPx_OUT_CNT(epn), 0x80008000);
}
/* turn on dma engines */
tnetv_usb_reg_write(TNETV_USB_TX_CTL, 1);
tnetv_usb_reg_write(TNETV_USB_RX_CTL, 1);
/* enable cell dma */
tnetv_usb_reg_write(TNETV_USB_CELL_DMA_EN, (TNETV_USB_CELL_DMA_EN_RX | TNETV_USB_CELL_DMA_EN_TX));
}
static void tnetv_udc_enable_interrupts(void)
{
UsbCtrlType usb_ctl;
uint8_t tx_int_en, rx_int_en;
int ep, chan;
/* set up the system interrupts */
usb_ctl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usb_ctl.f.vbus_int_en = 1;
usb_ctl.f.reset_int_en = 1;
usb_ctl.f.suspend_int_en = 1;
usb_ctl.f.resume_int_en = 1;
usb_ctl.f.ep0_in_int_en = 1;
usb_ctl.f.ep0_out_int_en = 1;
usb_ctl.f.setup_int_en = 1;
usb_ctl.f.setupow_int_en = 1;
tnetv_usb_reg_write(TNETV_USB_CTRL, usb_ctl.val);
/* Enable the DMA endpoint interrupts */
tx_int_en = 0;
rx_int_en = 0;
for (ep = 1; ep < USB_NUM_ENDPOINTS; ep++)
{
chan = ep - 1;
rx_int_en |= (1 << chan); /* OUT */
tx_int_en |= (1 << chan); /* IN */
}
/* enable rx interrupts */
tnetv_usb_reg_write(TNETV_USB_RX_INT_EN, rx_int_en);
/* enable tx interrupts */
tnetv_usb_reg_write(TNETV_USB_TX_INT_EN, tx_int_en);
set_vlynq_irq(true);
}
static void tnetv_udc_disable_interrupts(void)
{
UsbCtrlType usb_ctl;
/* disable interrupts from linux */
set_vlynq_irq(false);
/* Disable Endpoint Interrupts */
tnetv_usb_reg_write(TNETV_USB_RX_INT_DIS, 0x3);
tnetv_usb_reg_write(TNETV_USB_TX_INT_DIS, 0x3);
/* Disable USB system interrupts */
usb_ctl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usb_ctl.f.vbus_int_en = 0;
usb_ctl.f.reset_int_en = 0;
usb_ctl.f.suspend_int_en = 0;
usb_ctl.f.resume_int_en = 0;
usb_ctl.f.ep0_in_int_en = 0;
usb_ctl.f.ep0_out_int_en = 0;
usb_ctl.f.setup_int_en = 0;
usb_ctl.f.setupow_int_en = 0;
tnetv_usb_reg_write(TNETV_USB_CTRL, usb_ctl.val);
}
static void tnetv_ep_halt(int epn, bool in)
{
if (in)
{
tnetv_usb_reg_write(TNETV_USB_EPx_IN_CNT(epn), 0x80008000);
}
else
{
tnetv_usb_reg_write(TNETV_USB_EPx_OUT_CNT(epn), 0x80008000);
}
}
/* Reset the TNETV usb2.0 controller and configure it to run in function mode */
static void tnetv_usb_reset(void)
{
uint32_t timeout = 0;
int wd;
int ch;
/* configure function clock */
tnetv_usb_reg_write(TNETV_V2USB_CLK_CFG, 0x80);
/* Reset the USB 2.0 function module */
tnetv_usb_reg_write(TNETV_V2USB_RESET, 0x01);
/* now poll the module ready register until the 2.0 controller finishes resetting */
while (!(tnetv_usb_reg_read(TNETV_USB_RESET_CMPL) & 0x1) && (timeout < 1000000))
{
timeout++;
}
if (!(tnetv_usb_reg_read(TNETV_USB_RESET_CMPL) & 0x1))
{
logf("tnetv105_udc: VLYNQ USB module reset failed!\n");
return;
}
/* turn off external clock */
tnetv_usb_reg_write(TNETV_V2USB_CLK_PERF, 0);
/* clear out USB data memory */
for (wd = 0; wd < TNETV_EP_DATA_SIZE; wd += 4)
{
tnetv_usb_reg_write(TNETV_EP_DATA_ADDR(wd), 0);
}
/* clear out DMA memory */
for (ch = 0; ch < TNETV_DMA_NUM_CHANNELS; ch++)
{
for (wd = 0; wd < TNETV_DMA_TX_NUM_WORDS; wd++)
{
tnetv_usb_reg_write(TNETV_DMA_TX_STATE(ch, wd), 0);
}
for (wd = 0; wd < TNETV_DMA_RX_NUM_WORDS; wd++)
{
tnetv_usb_reg_write(TNETV_DMA_RX_STATE(ch, wd), 0);
}
}
/* point VLYNQ interrupts at the pending register */
VL_INTPTR = DM320_VLYNQ_INTPND_PHY;
/* point VLYNQ remote interrupts at the pending register */
VL_INTPTR_R = 0;
/* clear out interrupt register */
VL_INTST |= 0xFFFFFFFF;
/* enable interrupts on remote device */
VL_CTRL_R |= (DM320_VLYNQ_CTRL_INT_EN);
VL_INTVEC30_R = 0x8180;
/* enable VLYNQ interrupts & set interrupts to trigger VLYNQ int */
VL_CTRL |= (DM320_VLYNQ_CTRL_INT_LOC | DM320_VLYNQ_CTRL_INT_CFG);
}
static int tnetv_ep_start_xmit(int epn, void *buf, int size)
{
UsbEp0ByteCntType ep0Cnt;
if (epn == 0)
{
/* Write the Control Data packet to the EP0 IN memory area */
tnetv_copy_to_data_mem(TNETV_EP_DATA_ADDR(EP0_INPKT_ADDRESS), buf, size);
/* start xmitting */
ep0Cnt.val = tnetv_usb_reg_read(TNETV_USB_EP0_CNT);
ep0Cnt.f.in_xbuf_cnt = size;
ep0Cnt.f.in_xbuf_nak = 0;
tnetv_usb_reg_write(TNETV_USB_EP0_CNT, ep0Cnt.val);
}
else
{
dma_addr_t buffer = (dma_addr_t)buf;
int send_zlp = 0;
if (size == 0)
{
/* Any address in SDRAM will do, contents do not matter */
buffer = CONFIG_SDRAM_START;
size = 1;
send_zlp = 1;
}
else
{
commit_discard_dcache_range(buf, size);
}
if ((buffer >= CONFIG_SDRAM_START) && (buffer + size < CONFIG_SDRAM_START + SDRAM_SIZE))
{
if (tnetv_cppi_send(&cppi, (epn - 1), buffer, size, send_zlp))
{
panicf("tnetv_cppi_send() failed");
}
}
else
{
panicf("USB xmit buf outside SDRAM %p", buf);
}
}
return 0;
}
static void tnetv_gadget_req_nuke(int epn, bool in)
{
struct ep_runtime_t *ep = &ep_runtime[epn];
uint32_t old_rx_int = 0;
uint32_t old_tx_int = 0;
int ch;
int flags;
/* don't nuke control ep */
if (epn == 0)
{
return;
}
flags = disable_irq_save();
/* save and disable interrupts before nuking request */
old_rx_int = tnetv_usb_reg_read(TNETV_USB_RX_INT_EN);
old_tx_int = tnetv_usb_reg_read(TNETV_USB_TX_INT_EN);
tnetv_usb_reg_write(TNETV_USB_RX_INT_DIS, 0x3);
tnetv_usb_reg_write(TNETV_USB_TX_INT_DIS, 0x3);
ch = epn - 1;
if (in)
{
tnetv_cppi_flush_tx_queue(&cppi, ch);
tnetv_usb_reg_write(TNETV_USB_EPx_IN_CNT(epn), 0x80008000);
if (ep->tx_remaining > 0)
{
usb_core_transfer_complete(epn, USB_DIR_IN, -1, 0);
}
ep->tx_buf = NULL;
ep->tx_remaining = 0;
ep->tx_size = 0;
if (ep->block)
{
semaphore_release(&ep->complete);
ep->block = false;
}
}
else
{
tnetv_cppi_flush_rx_queue(&cppi, ch);
tnetv_usb_reg_write(TNETV_USB_EPx_OUT_CNT(epn), 0x80008000);
if (ep->rx_remaining > 0)
{
usb_core_transfer_complete(epn, USB_DIR_OUT, -1, 0);
}
ep->rx_buf = NULL;
ep->rx_remaining = 0;
ep->rx_size = 0;
}
/* reenable any interrupts */
tnetv_usb_reg_write(TNETV_USB_RX_INT_EN, old_rx_int);
tnetv_usb_reg_write(TNETV_USB_TX_INT_EN, old_tx_int);
restore_irq(flags);
}
static int tnetv_gadget_ep_enable(int epn, bool in)
{
UsbEpCfgCtrlType epCfg;
int flags;
enum usb_device_speed speed;
if (epn == 0 || epn >= USB_NUM_ENDPOINTS)
{
return 0;
}
flags = disable_irq_save();
/* set the maxpacket for this endpoint based on the current speed */
speed = usb_drv_port_speed() ? USB_SPEED_HIGH : USB_SPEED_FULL;
ep_runtime[epn].max_packet_size = MAX_PACKET(epn, speed);
/* Enable the endpoint */
epCfg.val = tnetv_usb_reg_read(TNETV_USB_EPx_CFG(epn));
if (in)
{
epCfg.f.in_en = 1;
epCfg.f.in_stall = 0;
epCfg.f.in_toggle_rst = 1;
epCfg.f.in_buf_size = ep_runtime[epn].max_packet_size >> 3;
tnetv_usb_reg_write(TNETV_USB_EPx_IN_CNT(epn), 0x80008000);
}
else
{
epCfg.f.out_en = 1;
epCfg.f.out_stall = 0;
epCfg.f.out_toggle_rst = 1;
epCfg.f.out_buf_size = ep_runtime[epn].max_packet_size >> 3;
tnetv_usb_reg_write(TNETV_USB_EPx_OUT_CNT(epn), 0x80008000);
}
tnetv_usb_reg_write(TNETV_USB_EPx_CFG(epn), epCfg.val);
restore_irq(flags);
return 0;
}
static int tnetv_gadget_ep_disable(int epn, bool in)
{
UsbEpCfgCtrlType epCfg;
int flags;
if (epn == 0 || epn >= USB_NUM_ENDPOINTS)
{
return 0;
}
flags = disable_irq_save();
/* Disable the endpoint */
epCfg.val = tnetv_usb_reg_read(TNETV_USB_EPx_CFG(epn));
if (in)
{
epCfg.f.in_en = 0;
}
else
{
epCfg.f.out_en = 0;
}
tnetv_usb_reg_write(TNETV_USB_EPx_CFG(epn), epCfg.val);
/* Turn off the endpoint and unready it */
tnetv_ep_halt(epn, in);
restore_irq(flags);
/* Clear out all the pending requests */
tnetv_gadget_req_nuke(epn, in);
return 0;
}
/* TNETV udc goo
* Power up and enable the udc. This includes resetting the hardware, turn on the appropriate clocks
* and initializing things so that the first setup packet can be received.
*/
static void tnetv_udc_enable(void)
{
/* Enable M48XI crystal resonator */
IO_CLK_LPCTL1 &= ~(0x01);
/* Set GIO33 as CLKOUT1B */
IO_GIO_FSEL3 |= 0x0003;
if (tnetv_xcvr_on())
return;
tnetv_usb_reset();
/* BEN - RNDIS mode is assuming zlps after packets that are multiples of buffer endpoints
* zlps are not required by the spec and many controllers don't send them.
* set DMA to RNDIS mode (packet concatenation, less interrupts)
* tnetv_usb_reg_write(TNETV_USB_RNDIS_MODE, 0xFF);
*/
tnetv_usb_reg_write(TNETV_USB_RNDIS_MODE, 0);
tnetv_init_endpoints();
tnetv_udc_enable_interrupts();
}
static void tnetv_udc_disable(void)
{
tnetv_udc_disable_interrupts();
tnetv_hw_reset();
tnetv_xcvr_off();
/* Set GIO33 as normal output, drive it low */
IO_GIO_FSEL3 &= ~(0x0003);
IO_GIO_BITCLR2 = (1 << 1);
/* Disable M48XI crystal resonator */
IO_CLK_LPCTL1 |= 0x01;
}
static void tnetv_udc_handle_reset(void)
{
UsbCtrlType usbCtrl;
/* disable USB interrupts */
tnetv_udc_disable_interrupts();
usbCtrl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usbCtrl.f.func_addr = 0;
tnetv_usb_reg_write(TNETV_USB_CTRL, usbCtrl.val);
/* Reset endpoints */
tnetv_init_endpoints();
/* Re-enable interrupts */
tnetv_udc_enable_interrupts();
}
static void ep_write(int epn)
{
struct ep_runtime_t *ep = &ep_runtime[epn];
int tx_size;
if (epn == 0)
{
tx_size = MIN(ep->max_packet_size, ep->tx_remaining);
}
else
{
/* DMA takes care of splitting the buffer into packets,
* but only up to CPPI_MAX_FRAG. After the data is sent
* a single interrupt is generated. There appears to be
* splitting code in the tnetv_cppi_send() function but
* it is somewhat suspicious (it doesn't seem like it
* will work with requests larger than 2*CPPI_MAX_FRAG).
* Also, if tnetv_cppi_send() does the splitting, we will
* get an interrupt after CPPI_MAX_FRAG but before the
* full request is sent.
*
* CPPI_MAX_FRAG is multiple of both 64 and 512 so we
* don't have to worry about this split prematurely ending
* the transfer.
*/
tx_size = MIN(CPPI_MAX_FRAG, ep->tx_remaining);
}
tnetv_ep_start_xmit(epn, ep->tx_buf, tx_size);
ep->tx_remaining -= tx_size;
ep->tx_buf += tx_size;
}
static void in_interrupt(int epn)
{
struct ep_runtime_t *ep = &ep_runtime[epn];
if (ep->tx_remaining <= 0)
{
usb_core_transfer_complete(epn, USB_DIR_IN, 0, ep->tx_size);
/* release semaphore for blocking transfer */
if (ep->block)
{
semaphore_release(&ep->complete);
ep->tx_buf = NULL;
ep->tx_size = 0;
ep->tx_remaining = 0;
ep->block = false;
}
}
else if (ep->tx_buf)
{
ep_write(epn);
}
}
static void ep_read(int epn)
{
if (epn == 0)
{
UsbEp0ByteCntType ep0Cnt;
ep0Cnt.val = tnetv_usb_reg_read(TNETV_USB_EP0_CNT);
ep0Cnt.f.out_xbuf_nak = 0;
tnetv_usb_reg_write(TNETV_USB_EP0_CNT, ep0Cnt.val);
}
else
{
struct ep_runtime_t *ep = &ep_runtime[epn];
tnetv_cppi_rx_queue_add(&cppi, (epn - 1), 0, ep->rx_remaining);
}
}
static void out_interrupt(int epn)
{
struct ep_runtime_t *ep = &ep_runtime[epn];
int is_short;
int rcv_len;
if (epn == 0)
{
UsbEp0ByteCntType ep0Cnt;
/* get the length of the received data */
ep0Cnt.val = tnetv_usb_reg_read(TNETV_USB_EP0_CNT);
rcv_len = ep0Cnt.f.out_xbuf_cnt;
if (rcv_len > ep->rx_remaining)
{
rcv_len = ep->rx_remaining;
}
tnetv_copy_from_data_mem(ep->rx_buf, TNETV_EP_DATA_ADDR(EP0_OUTPKT_ADDRESS), rcv_len);
ep->rx_buf += rcv_len;
ep->rx_remaining -= rcv_len;
/* See if we are done */
is_short = rcv_len && (rcv_len < ep->max_packet_size);
if (is_short || (ep->rx_remaining == 0))
{
usb_core_transfer_complete(epn, USB_DIR_OUT, 0, ep->rx_size - ep->rx_remaining);
ep->rx_remaining = 0;
ep->rx_size = 0;
ep->rx_buf = 0;
return;
}
/* make sure nak is cleared only if we expect more data */
ep0Cnt.f.out_xbuf_nak = 0;
tnetv_usb_reg_write(TNETV_USB_EP0_CNT, ep0Cnt.val);
ep_read(epn);
}
else if (ep->rx_remaining > 0)
{
int ret, bytes_rcvd;
/* copy the data from the DMA buffers */
bytes_rcvd = ep->rx_remaining;
ret = tnetv_cppi_rx_int_recv(&cppi, (epn - 1), &bytes_rcvd, ep->rx_buf, ep->max_packet_size);
if (ret == 0 || ret == -EAGAIN)
{
ep->rx_buf += bytes_rcvd;
ep->rx_remaining -= bytes_rcvd;
}
/* complete the request if we got a short packet or an error
* make sure we don't complete a request with zero bytes.
*/
if ((ret == 0) && (ep->rx_remaining != ep->rx_size))
{
usb_core_transfer_complete(epn, USB_DIR_OUT, 0, ep->rx_size - ep->rx_remaining);
ep->rx_remaining = 0;
ep->rx_size = 0;
ep->rx_buf = 0;
}
}
}
static bool tnetv_handle_cppi(void)
{
int ret;
int ch;
uint32_t tx_intstatus;
uint32_t rx_intstatus;
uint32_t status;
int rcv_sched = 0;
rx_intstatus = tnetv_usb_reg_read(TNETV_USB_RX_INT_STATUS);
tx_intstatus = tnetv_usb_reg_read(TNETV_USB_TX_INT_STATUS);
/* handle any transmit interrupts */
status = tx_intstatus;
for (ch = 0; ch < CPPI_NUM_CHANNELS && status; ch++)
{
if (status & 0x1)
{
ret = tnetv_cppi_tx_int(&cppi, ch);
if (ret >= 0)
{
in_interrupt(ch + 1);
}
}
status = status >> 1;
}
rcv_sched = 0;
status = rx_intstatus;
for (ch = 0; ch < CPPI_NUM_CHANNELS; ch++)
{
if (status & 0x1 || tnetv_cppi_rx_int_recv_check(&cppi, ch))
{
ret = tnetv_cppi_rx_int(&cppi, ch);
if (ret < 0)
{
/* only an error if interrupt bit is set */
logf("CPPI Rx: failed to ACK int!\n");
}
else
{
if (tnetv_cppi_rx_int_recv_check(&cppi, ch))
{
out_interrupt(ch + 1);
}
}
}
if (tnetv_cppi_rx_int_recv_check(&cppi, ch))
{
rcv_sched = 1;
}
status = status >> 1;
}
rx_intstatus = tnetv_usb_reg_read(TNETV_USB_RX_INT_STATUS);
tx_intstatus = tnetv_usb_reg_read(TNETV_USB_TX_INT_STATUS);
if (rx_intstatus || tx_intstatus || rcv_sched)
{
/* Request calling again after short delay
* Needed when for example when OUT endpoint has pending
* data but the USB task did not call usb_drv_recv() yet.
*/
return true;
}
return false;
}
static int cppi_timeout_cb(struct timeout *tmo)
{
(void)tmo;
int flags = disable_irq_save();
bool requeue = tnetv_handle_cppi();
restore_irq(flags);
return requeue ? 1 : 0;
}
void VLYNQ(void) __attribute__ ((section(".icode")));
void VLYNQ(void)
{
UsbStatusType sysIntrStatus;
UsbStatusType sysIntClear;
UsbCtrlType usbCtrl;
volatile uint32_t *reg;
uint32_t vlynq_intr;
/* Clear interrupt */
IO_INTC_IRQ1 = (1 << 0);
/* clear out VLYNQ interrupt register */
vlynq_intr = VL_INTST;
if (vlynq_intr & VLYNQ_INTR_USB20)
{
VL_INTST = VLYNQ_INTR_USB20;
/* Examine system interrupt status */
sysIntrStatus.val = tnetv_usb_reg_read(TNETV_USB_STATUS);
if (sysIntrStatus.f.reset)
{
sysIntClear.val = 0;
sysIntClear.f.reset = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
tnetv_udc_handle_reset();
usb_core_bus_reset();
}
if (sysIntrStatus.f.suspend)
{
sysIntClear.val = 0;
sysIntClear.f.suspend = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
}
if (sysIntrStatus.f.resume)
{
sysIntClear.val = 0;
sysIntClear.f.resume = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
}
if (sysIntrStatus.f.vbus)
{
sysIntClear.val = 0;
sysIntClear.f.vbus = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
if (*((uint32_t *) TNETV_USB_IF_STATUS) & 0x40)
{
/* write out connect bit */
reg = (volatile uint32_t *) TNETV_USB_CTRL;
*reg |= 0x80;
/* write to wakeup bit in clock config */
reg = (volatile uint32_t *) TNETV_V2USB_CLK_WKUP;
*reg |= TNETV_V2USB_CLK_WKUP_VBUS;
}
else
{
/* clear out connect bit */
reg = (volatile uint32_t *) TNETV_USB_CTRL;
*reg &= ~0x80;
}
}
if (sysIntrStatus.f.setup_ow)
{
sysIntrStatus.f.setup_ow = 0;
sysIntClear.val = 0;
sysIntClear.f.setup_ow = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
}
if (sysIntrStatus.f.setup)
{
UsbEp0ByteCntType ep0Cnt;
static struct usb_ctrlrequest setup;
sysIntrStatus.f.setup = 0;
/* Copy setup packet into buffer */
tnetv_copy_from_data_mem(&setup, TNETV_EP_DATA_ADDR(EP0_OUTPKT_ADDRESS), sizeof(setup));
/* Determine next stage of the control message */
if (setup.bRequestType & USB_DIR_IN)
{
/* This is a control-read. Switch directions to send the response.
* set the dir bit before clearing the interrupt
*/
usbCtrl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usbCtrl.f.dir = 1;
tnetv_usb_reg_write(TNETV_USB_CTRL, usbCtrl.val);
}
else
{
/* This is a control-write. Remain using USB_DIR_OUT to receive the rest of the data.
* set the NAK bits according to supplement doc
*/
ep0Cnt.val = 0;
ep0Cnt.f.in_xbuf_nak = 1;
ep0Cnt.f.out_xbuf_nak = 1;
tnetv_usb_reg_write(TNETV_USB_EP0_CNT, ep0Cnt.val);
/* clear the dir bit before clearing the interrupt */
usbCtrl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usbCtrl.f.dir = 0;
tnetv_usb_reg_write(TNETV_USB_CTRL, usbCtrl.val);
}
/* Clear interrupt */
sysIntClear.val = 0;
sysIntClear.f.setup = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
if (((setup.bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) &&
(setup.bRequest == USB_REQ_SET_ADDRESS))
{
/* Rockbox USB core works according to USB specification, i.e.
* it first acknowledges the control transfer and then sets
* the address. However, Linux TNETV105 driver first sets the
* address and then acknowledges the transfer. At first,
* it seemed that Linux driver was wrong, but it seems that
* TNETV105 simply requires such order. It might be documented
* in the datasheet and thus there is no comment in the Linux
* driver about this.
*/
setup_is_set_address = true;
}
else
{
setup_is_set_address = false;
}
/* Process control packet */
usb_core_control_request(&setup);
}
if (sysIntrStatus.f.ep0_in_ack)
{
sysIntClear.val = 0;
sysIntClear.f.ep0_in_ack = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
in_interrupt(0);
}
if (sysIntrStatus.f.ep0_out_ack)
{
sysIntClear.val = 0;
sysIntClear.f.ep0_out_ack = 1;
tnetv_usb_reg_write(TNETV_USB_STATUS, sysIntClear.val);
out_interrupt(0);
}
}
if (vlynq_intr & VLYNQ_INTR_CPPI)
{
static struct timeout cppi_timeout;
VL_INTST = VLYNQ_INTR_CPPI;
if (tnetv_handle_cppi())
{
timeout_register(&cppi_timeout, cppi_timeout_cb, 1, 0);
}
}
}
void usb_charging_maxcurrent_change(int maxcurrent)
{
uint32_t wreg;
if (!is_tnetv_reset_high())
{
/* TNETV105 is in reset, it is not getting more than 100 mA */
return;
}
wreg = tnetv_usb_reg_read(TNETV_V2USB_GPIO_DOUT);
if (maxcurrent < 500)
{
/* set tnetv into low power mode */
tnetv_usb_reg_write(TNETV_V2USB_GPIO_DOUT, (wreg & ~0x2));
}
else
{
/* set tnetv into high power mode */
tnetv_usb_reg_write(TNETV_V2USB_GPIO_DOUT, (wreg | 0x2));
}
}
void usb_drv_init(void)
{
int epn;
memset(ep_runtime, 0, sizeof(ep_runtime));
ep_runtime[0].max_packet_size = EP0_MAX_PACKET_SIZE;
ep_runtime[0].in_allocated = true;
ep_runtime[0].out_allocated = true;
for (epn = 0; epn < USB_NUM_ENDPOINTS; epn++)
{
semaphore_init(&ep_runtime[epn].complete, 1, 0);
}
tnetv_cppi_init(&cppi);
tnetv_udc_enable();
}
void usb_drv_exit(void)
{
tnetv_udc_disable();
tnetv_cppi_cleanup(&cppi);
}
void usb_drv_stall(int endpoint, bool stall, bool in)
{
int epn = EP_NUM(endpoint);
if (epn == 0)
{
UsbEp0CtrlType ep0Ctrl;
ep0Ctrl.val = tnetv_usb_reg_read(TNETV_USB_EP0_CFG);
if (in)
{
ep0Ctrl.f.in_stall = stall ? 1 : 0;
}
else
{
ep0Ctrl.f.out_stall = stall ? 1 : 0;
}
tnetv_usb_reg_write(TNETV_USB_EP0_CFG, ep0Ctrl.val);
}
else
{
UsbEpCfgCtrlType epCfg;
epCfg.val = tnetv_usb_reg_read(TNETV_USB_EPx_CFG(epn));
if (in)
{
epCfg.f.in_stall = stall ? 1 : 0;
}
else
{
epCfg.f.out_stall = stall ? 1 : 0;
}
tnetv_usb_reg_write(TNETV_USB_EPx_CFG(epn), epCfg.val);
}
}
bool usb_drv_stalled(int endpoint, bool in)
{
int epn = EP_NUM(endpoint);
if (epn == 0)
{
UsbEp0CtrlType ep0Ctrl;
ep0Ctrl.val = tnetv_usb_reg_read(TNETV_USB_EP0_CFG);
if (in)
{
return ep0Ctrl.f.in_stall;
}
else
{
return ep0Ctrl.f.out_stall;
}
}
else
{
UsbEpCfgCtrlType epCfg;
epCfg.val = tnetv_usb_reg_read(TNETV_USB_EPx_CFG(epn));
if (in)
{
return epCfg.f.in_stall;
}
else
{
return epCfg.f.out_stall;
}
}
}
static int _usb_drv_send(int endpoint, void *ptr, int length, bool block)
{
int epn = EP_NUM(endpoint);
struct ep_runtime_t *ep;
int flags;
ep = &ep_runtime[epn];
flags = disable_irq_save();
ep->tx_buf = ptr;
ep->tx_remaining = ep->tx_size = length;
ep->block = block;
ep_write(epn);
restore_irq(flags);
/* wait for transfer to end */
if (block)
{
semaphore_wait(&ep->complete, TIMEOUT_BLOCK);
}
return 0;
}
int usb_drv_send(int endpoint, void* ptr, int length)
{
if ((EP_NUM(endpoint) == 0) && (length == 0))
{
if (setup_is_set_address)
{
/* usb_drv_set_address() will call us later */
return 0;
}
/* HACK: Do not wait for status stage ZLP
* This seems to be the only way to get through SET ADDRESS
* and retain ability to receive SETUP packets.
*/
return _usb_drv_send(endpoint, ptr, length, false);
}
return _usb_drv_send(endpoint, ptr, length, false);
}
int usb_drv_send_nonblocking(int endpoint, void* ptr, int length)
{
return _usb_drv_send(endpoint, ptr, length, false);
}
int usb_drv_recv(int endpoint, void* ptr, int length)
{
int epn = EP_NUM(endpoint);
struct ep_runtime_t *ep;
int flags;
ep = &ep_runtime[epn];
flags = disable_irq_save();
ep->rx_buf = ptr;
ep->rx_remaining = ep->rx_size = length;
ep_read(epn);
restore_irq(flags);
return 0;
}
void usb_drv_ack(struct usb_ctrlrequest* req);
void usb_drv_set_address(int address)
{
UsbCtrlType usbCtrl;
usbCtrl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usbCtrl.f.func_addr = address;
tnetv_usb_reg_write(TNETV_USB_CTRL, usbCtrl.val);
/* This seems to be the only working order */
setup_is_set_address = false;
usb_drv_send(EP_CONTROL, NULL, 0);
usb_drv_cancel_all_transfers();
}
/* return port speed FS=0, HS=1 */
int usb_drv_port_speed(void)
{
UsbCtrlType usbCtrl;
usbCtrl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
return usbCtrl.f.speed ? 1 : 0;
}
void usb_drv_cancel_all_transfers(void)
{
int epn;
if (setup_is_set_address)
{
return;
}
for (epn = 1; epn < USB_NUM_ENDPOINTS; epn++)
{
tnetv_gadget_req_nuke(epn, false);
tnetv_gadget_req_nuke(epn, true);
}
}
static const uint8_t TestPacket[] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
0xAA, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
0xEE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xBF, 0xDF,
0xEF, 0xF7, 0xFB, 0xFD, 0xFC, 0x7E, 0xBF, 0xDF,
0xEF, 0xF7, 0xFB, 0xFD, 0x7E
};
void usb_drv_set_test_mode(int mode)
{
UsbCtrlType usbCtrl;
if (mode == 4)
{
volatile uint32_t *reg;
UsbEp0ByteCntType ep0Cnt;
UsbEp0CtrlType ep0Cfg;
uint8_t *addr;
size_t i;
/* set up the xnak for ep0 */
reg = (volatile uint32_t *) TNETV_USB_EP0_CNT;
*reg &= ~0xFF;
/* Setup endpoint zero */
ep0Cfg.val = 0;
ep0Cfg.f.buf_size = EP0_BUF_SIZE_64; /* must be 64 bytes for USB 2.0 */
ep0Cfg.f.dbl_buf = 0;
ep0Cfg.f.in_en = 1;
ep0Cfg.f.in_int_en = 0;
ep0Cfg.f.out_en = 0;
ep0Cfg.f.out_int_en = 0;
tnetv_usb_reg_write(TNETV_USB_EP0_CFG, ep0Cfg.val);
addr = (uint8_t *) TNETV_EP_DATA_ADDR(EP0_INPKT_ADDRESS);
for (i = 0; i < sizeof(TestPacket); i++)
{
*addr++ = TestPacket[i];
}
/* start xmitting (only 53 bytes are used) */
ep0Cnt.val = 0;
ep0Cnt.f.in_xbuf_cnt = 53;
ep0Cnt.f.in_xbuf_nak = 0;
tnetv_usb_reg_write(TNETV_USB_EP0_CNT, ep0Cnt.val);
}
/* write the config */
usbCtrl.val = tnetv_usb_reg_read(TNETV_USB_CTRL);
usbCtrl.f.hs_test_mode = mode;
usbCtrl.f.dir = 1;
tnetv_usb_reg_write(TNETV_USB_CTRL, usbCtrl.val);
}
int usb_drv_request_endpoint(int type, int dir)
{
int epn;
for (epn = 1; epn < USB_NUM_ENDPOINTS; epn++)
{
if (type == ep_const_data[epn].type)
{
if ((dir == USB_DIR_IN) && (!ep_runtime[epn].in_allocated))
{
ep_runtime[epn].in_allocated = true;
tnetv_gadget_ep_enable(epn, true);
return epn | USB_DIR_IN;
}
if ((dir == USB_DIR_OUT) && (!ep_runtime[epn].out_allocated))
{
ep_runtime[epn].out_allocated = true;
tnetv_gadget_ep_enable(epn, false);
return epn | USB_DIR_OUT;
}
}
}
return -1;
}
void usb_drv_release_endpoint(int ep)
{
int epn = EP_NUM(ep);
if (EP_DIR(ep) == DIR_IN)
{
ep_runtime[epn].in_allocated = false;
tnetv_gadget_ep_disable(epn, true);
}
else
{
ep_runtime[epn].out_allocated = false;
tnetv_gadget_ep_disable(epn, false);
}
}
Reference in a new issue View git blame Copy permalink