nihilazo
/
rockbox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rockbox/firmware/target/arm/tms320dm320/sansa-connect/tnetv105_usb_drv.c

1520 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_nonblocking() 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_legacy_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_nonblocking(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_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 New Issue View Git Blame Copy Permalink