Embedded/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-01-31 05:52:55 +08:00
Code Issues Packages Projects Releases Wiki Activity
tinyusb/src/portable/renesas/usba/dcd_usba.c

849 lines
23 KiB
C
Raw Normal View History

added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
/*
* The MIT License (MIT)
*
* Copyright (c) 2020 Koji Kitayama
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* This file is part of the TinyUSB stack.
*/
#include "tusb_option.h"
#if TUSB_OPT_DEVICE_ENABLED && ( CFG_TUSB_MCU == OPT_MCU_RX63X )
#include "device/dcd.h"
#include "iodefine.h"
//--------------------------------------------------------------------+
// MACRO TYPEDEF CONSTANT ENUM DECLARATION
//--------------------------------------------------------------------+
#define SYSTEM_PRCR_PRC1 (1<<1)
#define SYSTEM_PRCR_PRKEY (0xA5u<<8)
#define USB_FIFOSEL_TX ((uint16_t)(1u<<5))
#define USB_FIFOSEL_MBW_8 ((uint16_t)(0u<<10))
#define USB_FIFOSEL_MBW_16 ((uint16_t)(1u<<10))
#define USB_IS0_CTSQ ((uint16_t)(7u))
#define USB_IS0_DVSQ ((uint16_t)(7u<<4))
#define USB_IS0_VALID ((uint16_t)(1u<<3))
#define USB_IS0_BRDY ((uint16_t)(1u<<8))
#define USB_IS0_NRDY ((uint16_t)(1u<<9))
#define USB_IS0_BEMP ((uint16_t)(1u<<10))
#define USB_IS0_CTRT ((uint16_t)(1u<<11))
#define USB_IS0_DVST ((uint16_t)(1u<<12))
#define USB_IS0_SOFR ((uint16_t)(1u<<13))
#define USB_IS0_RESM ((uint16_t)(1u<<14))
#define USB_IS0_VBINT ((uint16_t)(1u<<15))
#define USB_IS1_SACK ((uint16_t)(1u<<4))
#define USB_IS1_SIGN ((uint16_t)(1u<<5))
#define USB_IS1_EOFERR ((uint16_t)(1u<<6))
#define USB_IS1_ATTCH ((uint16_t)(1u<<11))
#define USB_IS1_DTCH ((uint16_t)(1u<<12))
#define USB_IS1_BCHG ((uint16_t)(1u<<14))
#define USB_IS1_OVRCR ((uint16_t)(1u<<15))
#define USB_IS0_CTSQ_MSK (7u)
#define USB_IS0_CTSQ_SETUP (1u)
#define USB_IS0_DVSQ_DEF (1u<<4)
#define USB_IS0_DVSQ_ADDR (2u<<4)
#define USB_IS0_DVSQ_SUSP (4u<<4)
#define USB_PIPECTR_PID_NAK (0u)
#define USB_PIPECTR_PID_BUF (1u)
#define USB_PIPECTR_PID_STALL (2u)
#define USB_PIPECTR_CCPL (1u<<2)
#define USB_PIPECTR_SQMON (1u<<6)
#define USB_PIPECTR_SQCLR (1u<<8)
#define USB_PIPECTR_ACLRM (1u<<9)
update for gr_citurs
2021-03-24 00:53:55 +09:00
#define USB_PIPECTR_INBUFM (1u<<14)
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
#define USB_PIPECTR_BSTS (1u<<15)
#define USB_FIFOCTR_DTLN (0x1FF)
#define USB_FIFOCTR_FRDY (1u<<13)
#define USB_FIFOCTR_BCLR (1u<<14)
#define USB_FIFOCTR_BVAL (1u<<15)
#define USB_PIPECFG_SHTNAK (1u<<7)
#define USB_PIPECFG_DBLB (1u<<9)
#define USB_PIPECFG_BULK (1u<<14)
#define USB_PIPECFG_ISO (3u<<14)
#define USB_PIPECFG_INT (2u<<14)
#define FIFO_REQ_CLR (1u)
#define FIFO_COMPLETE (1u<<1)
typedef struct {
union {
struct {
uint16_t : 8;
uint16_t TRCLR: 1;
uint16_t TRENB: 1;
uint16_t : 0;
};
uint16_t TRE;
};
uint16_t TRN;
} reg_pipetre_t;
typedef union {
struct {
volatile uint16_t u8: 8;
volatile uint16_t : 0;
};
volatile uint16_t u16;
} hw_fifo_t;
typedef struct TU_ATTR_PACKED
{
uintptr_t addr;
uint16_t length;
uint16_t remaining;
struct {
uint32_t ep : 8;
uint32_t data: 1;
uint32_t : 0;
};
} pipe_state_t;
typedef struct
{
pipe_state_t pipe[9];
uint8_t ep[2][16]; /* index for pipe number */
} dcd_data_t;
//--------------------------------------------------------------------+
// INTERNAL OBJECT & FUNCTION DECLARATION
//--------------------------------------------------------------------+
CFG_TUSB_MEM_SECTION static dcd_data_t _dcd;
static uint32_t disable_interrupt(void)
{
uint32_t pswi;
pswi = __builtin_rx_mvfc(0) & 0x010000;
__builtin_rx_clrpsw('I');
return pswi;
}
static void enable_interrupt(uint32_t pswi)
{
__builtin_rx_mvtc(0, __builtin_rx_mvfc(0) | pswi);
}
static unsigned find_pipe(unsigned xfer)
{
switch (xfer) {
case TUSB_XFER_ISOCHRONOUS:
for (int i = 1; i <= 2; ++i) {
if (0 == _dcd.pipe[i].ep) return i;
}
break;
case TUSB_XFER_BULK:
for (int i = 3; i <= 5; ++i) {
if (0 == _dcd.pipe[i].ep) return i;
}
for (int i = 1; i <= 1; ++i) {
if (0 == _dcd.pipe[i].ep) return i;
}
break;
case TUSB_XFER_INTERRUPT:
for (int i = 6; i <= 9; ++i) {
if (0 == _dcd.pipe[i].ep) return i;
}
break;
default:
/* No support for control transfer */
break;
}
return 0;
}
static volatile uint16_t* get_pipectr(unsigned num)
{
volatile uint16_t *ctr = NULL;
if (num) {
ctr = (volatile uint16_t*)&USB0.PIPE1CTR.WORD;
ctr += num - 1;
} else {
ctr = (volatile uint16_t*)&USB0.DCPCTR.WORD;
}
return ctr;
}
static volatile reg_pipetre_t* get_pipetre(unsigned num)
{
volatile reg_pipetre_t* tre = NULL;
if ((1 <= num) && (num <= 5)) {
tre = (volatile reg_pipetre_t*)&USB0.PIPE1TRE.WORD;
tre += num - 1;
}
return tre;
}
static volatile uint16_t* ep_addr_to_pipectr(uint8_t rhport, unsigned ep_addr)
{
(void)rhport;
volatile uint16_t *ctr = NULL;
const unsigned epn = ep_addr & 0xFu;
if (epn) {
const unsigned dir = (ep_addr & TUSB_DIR_IN_MASK) ? TUSB_DIR_IN : TUSB_DIR_OUT;
const unsigned num = _dcd.ep[dir][epn];
if (num) {
ctr = (volatile uint16_t*)&USB0.PIPE1CTR.WORD;
ctr += num - 1;
}
} else {
ctr = (volatile uint16_t*)&USB0.DCPCTR.WORD;
}
return ctr;
}
update for gr_citurs
2021-03-24 00:53:55 +09:00
static unsigned wait_for_pipe_ready(void)
{
unsigned ctr;
do {
ctr = USB0.D0FIFOCTR.WORD;
} while (!(ctr & USB_FIFOCTR_FRDY));
return ctr;
}
static unsigned select_pipe(unsigned num, unsigned attr)
{
USB0.PIPESEL.WORD = num;
USB0.D0FIFOSEL.WORD = num | attr;
while (!(USB0.D0FIFOSEL.BIT.CURPIPE != num)) ;
return wait_for_pipe_ready();
}
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
/* 1 less than 64 bytes were written
* 2 no bytes were written
update for gr_citurs
2021-03-24 00:53:55 +09:00
* 0 mps bytes were written */
static int write_fifo(volatile void *fifo, pipe_state_t* pipe, unsigned mps, unsigned ofs)
{
unsigned rem = pipe->remaining - ofs;
if (!rem) return 2;
unsigned len = (rem < mps) ? rem: mps;
hw_fifo_t *reg = (hw_fifo_t*)fifo;
uintptr_t addr = pipe->addr + pipe->length - rem;
if (addr & 1u) {
/* addr is not 2-byte aligned */
reg->u8 = *(const uint8_t *)addr;
++addr;
--len;
}
while (len >= 2) {
reg->u16 = *(const uint16_t *)addr;
addr += 2;
len -= 2;
}
if (len) {
reg->u8 = *(const uint8_t *)addr;
++addr;
}
if (rem < mps) return 1;
return 0;
}
#if 1
static int write_fifo2(volatile void *fifo, pipe_state_t* pipe, unsigned mps)
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
{
unsigned rem = pipe->remaining;
if (!rem) return 2;
unsigned len = (rem < mps) ? rem: mps;
update for gr_citurs
2021-03-24 00:53:55 +09:00
pipe->remaining = rem - len;
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
hw_fifo_t *reg = (hw_fifo_t*)fifo;
uintptr_t addr = pipe->addr + pipe->length - rem;
if (addr & 1u) {
/* addr is not 2-byte aligned */
reg->u8 = *(const uint8_t *)addr;
++addr;
--len;
}
while (len >= 2) {
reg->u16 = *(const uint16_t *)addr;
addr += 2;
len -= 2;
}
if (len) {
reg->u8 = *(const uint8_t *)addr;
++addr;
}
if (rem < mps) return 1;
return 0;
}
update for gr_citurs
2021-03-24 00:53:55 +09:00
#endif
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
/* 1 if the number of bytes read is less than 64 bytes
* 0 otherwise */
static int read_fifo(volatile void *fifo, pipe_state_t* pipe, unsigned mps, size_t len)
{
unsigned rem = pipe->remaining;
if (!rem) return 2;
if (rem < len) len = rem;
pipe->remaining = rem - len;
hw_fifo_t *reg = (hw_fifo_t*)fifo;
uintptr_t addr = pipe->addr;
while (len--) {
*(uint8_t *)addr = reg->u8;
++addr;
}
pipe->addr = addr;
if (rem < mps) return 1;
return 0;
}
static void process_setup_packet(uint8_t rhport)
{
uint16_t setup_packet[4];
if (0 == (USB0.INTSTS0.WORD & USB_IS0_VALID)) return;
USB0.CFIFOCTR.WORD = USB_FIFOCTR_BCLR;
setup_packet[0] = USB0.USBREQ.WORD;
setup_packet[1] = USB0.USBVAL;
setup_packet[2] = USB0.USBINDX;
setup_packet[3] = USB0.USBLENG;
USB0.INTSTS0.WORD = ~USB_IS0_VALID;
dcd_event_setup_received(rhport, (const uint8_t*)&setup_packet[0], true);
// TU_LOG1("S\r\n");
}
static void process_status_completion(uint8_t rhport)
{
uint8_t ep_addr;
/* Check the data stage direction */
if (USB0.CFIFOSEL.WORD & USB_FIFOSEL_TX) {
/* IN transfer. */
ep_addr = tu_edpt_addr(0, TUSB_DIR_IN);
} else {
/* OUT transfer. */
ep_addr = tu_edpt_addr(0, TUSB_DIR_OUT);
}
dcd_event_xfer_complete(rhport, ep_addr, 0, XFER_RESULT_SUCCESS, true);
// TU_LOG1("C\r\n");
}
static bool process_edpt0_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes)
{
(void)rhport;
pipe_state_t *pipe = &_dcd.pipe[0];
/* set fifo direction */
if (ep_addr) { /* IN */
USB0.CFIFOSEL.WORD = USB_FIFOSEL_TX | USB_FIFOSEL_MBW_16;
while (!(USB0.CFIFOSEL.WORD & USB_FIFOSEL_TX)) ;
} else { /* OUT */
USB0.CFIFOSEL.WORD = USB_FIFOSEL_MBW_8;
while (USB0.CFIFOSEL.WORD & USB_FIFOSEL_TX) ;
}
if (total_bytes) {
pipe->addr = (uintptr_t)buffer;
pipe->length = total_bytes;
pipe->remaining = total_bytes;
pipe->data = USB0.DCPCTR.BIT.SQMON;
if (ep_addr) { /* IN */
TU_ASSERT(USB0.DCPCTR.BIT.BSTS && (USB0.USBREQ.WORD & 0x80));
update for gr_citurs
2021-03-24 00:53:55 +09:00
if (write_fifo(&USB0.CFIFO.WORD, pipe, 64, 0)) {
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
USB0.CFIFOCTR.WORD = USB_FIFOCTR_BVAL;
}
}
USB0.DCPCTR.WORD = USB_PIPECTR_PID_BUF;
// TU_LOG1("X %x %d\r\n", ep_addr, total_bytes);
} else {
/* ZLP */
update for gr_citurs
2021-03-24 00:53:55 +09:00
pipe->addr = 0;
pipe->length = 0;
pipe->remaining = 0;
pipe->data = USB0.DCPCTR.BIT.SQMON;
USB0.DCPCTR.WORD = USB_PIPECTR_CCPL | USB_PIPECTR_PID_BUF;
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
// TU_LOG1("Z %x\r\n", USB0.DCPCTR.WORD);
}
return true;
}
static void process_edpt0_bemp(uint8_t rhport)
{
pipe_state_t *pipe = &_dcd.pipe[0];
unsigned data = pipe->data;
if (USB0.DCPCTR.BIT.SQMON == data) {
TU_LOG1("W %x\r\n", USB0.DCPCTR.WORD);
/* retry transfer */
update for gr_citurs
2021-03-24 00:53:55 +09:00
int r = write_fifo(&USB0.CFIFO.WORD, &_dcd.pipe[0], 64, 0);
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
if (r) USB0.CFIFOCTR.WORD = USB_FIFOCTR_BVAL;
return;
}
const unsigned rem = pipe->remaining;
if (rem > 64) {
pipe->remaining = rem - 64;
pipe->data = data ^ 1;
TU_LOG1("Y %d %x\r\n", rem - 64, USB0.DCPCTR.WORD);
update for gr_citurs
2021-03-24 00:53:55 +09:00
int r = write_fifo(&USB0.CFIFO.WORD, &_dcd.pipe[0], 64, 0);
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
if (r) USB0.CFIFOCTR.WORD = USB_FIFOCTR_BVAL;
return;
}
pipe->addr = 0;
pipe->remaining = 0;
dcd_event_xfer_complete(rhport, tu_edpt_addr(0, TUSB_DIR_IN),
pipe->length, XFER_RESULT_SUCCESS, true);
// TU_LOG1("c\r\n");
}
static void process_edpt0_brdy(uint8_t rhport)
{
size_t len = USB0.CFIFOCTR.BIT.DTLN;
int cplt = read_fifo(&USB0.CFIFO.WORD, &_dcd.pipe[0], 64, len);
if (cplt || (len < 64)) {
if (2 != cplt) {
USB0.CFIFOCTR.WORD = USB_FIFOCTR_BCLR;
}
dcd_event_xfer_complete(rhport, tu_edpt_addr(0, TUSB_DIR_OUT),
_dcd.pipe[0].length - _dcd.pipe[0].remaining,
XFER_RESULT_SUCCESS, true);
// TU_LOG1("c\r\n");
}
}
static bool process_pipe_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes)
{
(void)rhport;
const unsigned epn = ep_addr & 0xFu;
const unsigned dir = (ep_addr & TUSB_DIR_IN_MASK) ? TUSB_DIR_IN : TUSB_DIR_OUT;
const unsigned num = _dcd.ep[dir][epn];
TU_ASSERT(num);
pipe_state_t *pipe = &_dcd.pipe[num];
pipe->addr = (uintptr_t)buffer;
pipe->length = total_bytes;
pipe->remaining = total_bytes;
USB0.PIPESEL.WORD = num;
const unsigned mps = USB0.PIPEMAXP.WORD;
if (dir) { /* IN */
USB0.D0FIFOSEL.WORD = num | USB_FIFOSEL_MBW_16;
while (!(USB0.D0FIFOSEL.BIT.CURPIPE != num)) ;
update for gr_citurs
2021-03-24 00:53:55 +09:00
#if 0
unsigned ofs = 0;
if (USB0.PIPECFG.BIT.DBLB && (total_bytes > mps)) {
write_fifo(&USB0.D0FIFO.WORD, pipe, mps, 0);
}
if (write_fifo(&USB0.D0FIFO.WORD, pipe, mps, ofs)) {
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
USB0.D0FIFOCTR.WORD = USB_FIFOCTR_BVAL;
}
update for gr_citurs
2021-03-24 00:53:55 +09:00
#else
if (USB0.PIPECFG.BIT.DBLB && (total_bytes > mps)) {
write_fifo2(&USB0.D0FIFO.WORD, pipe, mps);
wait_for_pipe_ready();
}
if (write_fifo2(&USB0.D0FIFO.WORD, pipe, mps)) {
USB0.D0FIFOCTR.WORD = USB_FIFOCTR_BVAL;
}
#endif
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
USB0.D0FIFOSEL.WORD = 0;
} else {
volatile reg_pipetre_t *pt = get_pipetre(num);
if (pt) {
volatile uint16_t *ctr = get_pipectr(num);
if (*ctr & 0x3) *ctr = USB_PIPECTR_PID_NAK;
pt->TRE = 1u << 8;
pt->TRN = (total_bytes + mps - 1) / mps;
pt->TRENB = 1;
*ctr = USB_PIPECTR_PID_BUF;
}
}
TU_LOG1("X %x %d\r\n", ep_addr, total_bytes);
return true;
}
update for gr_citurs
2021-03-24 00:53:55 +09:00
#if 0
static void process_pipe_bemp(uint8_t rhport, unsigned num)
{
pipe_state_t *pipe = &_dcd.pipe[num];
unsigned rem = pipe->remaining;
USB0.PIPESEL.WORD = num;
const unsigned mps = USB0.PIPEMAXP.WORD;
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
update for gr_citurs
2021-03-24 00:53:55 +09:00
if (rem > mps) {
rem -= mps;
pipe->remaining = rem;
if (USB0.PIPECFG.BIT.DBLB) {
if (rem > mps) {
unsigned ctr = select_pipe(num, USB_FIFOSEL_MBW_16);
int r = write_fifo(&USB0.D0FIFO.WORD, pipe, mps, mps);
if (r) USB0.D0FIFOCTR.WORD = USB_FIFOCTR_BVAL;
USB0.D0FIFOSEL.WORD = 0;
TU_LOG1("< %d %x %x %d\r\n", rem, ctr, *get_pipectr(num), r);
}
} else {
unsigned ctr = select_pipe(num, USB_FIFOSEL_MBW_16);
int r = write_fifo(&USB0.D0FIFO.WORD, pipe, mps, 0);
if (r) USB0.D0FIFOCTR.WORD = USB_FIFOCTR_BVAL;
USB0.D0FIFOSEL.WORD = 0;
TU_LOG1("< %d %x %x %d\r\n", rem, ctr, *get_pipectr(num), r);
}
return;
}
pipe->addr = 0;
pipe->remaining = 0;
USB0.D0FIFOSEL.WORD = 0;
dcd_event_xfer_complete(rhport, pipe->ep, pipe->length,
XFER_RESULT_SUCCESS, true);
TU_LOG1("cE\r\n");
}
#else
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
static void process_pipe_bemp(uint8_t rhport, unsigned num)
{
pipe_state_t *pipe = &_dcd.pipe[num];
const unsigned rem = pipe->remaining;
update for gr_citurs
2021-03-24 00:53:55 +09:00
if (rem) {
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
USB0.PIPESEL.WORD = num;
const unsigned mps = USB0.PIPEMAXP.WORD;
update for gr_citurs
2021-03-24 00:53:55 +09:00
unsigned ctr = select_pipe(num, USB_FIFOSEL_MBW_16);
int r = write_fifo2(&USB0.D0FIFO.WORD, pipe, mps);
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
if (r) USB0.D0FIFOCTR.WORD = USB_FIFOCTR_BVAL;
USB0.D0FIFOSEL.WORD = 0;
update for gr_citurs
2021-03-24 00:53:55 +09:00
TU_LOG1("< %d %x %x %d\r\n", rem, ctr, *get_pipectr(num), r);
return;
}
if (*get_pipectr(num) & USB_PIPECTR_INBUFM) {
TU_LOG1("< SKIP\r\n");
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
return;
}
pipe->addr = 0;
pipe->remaining = 0;
update for gr_citurs
2021-03-24 00:53:55 +09:00
USB0.D0FIFOSEL.WORD = 0;
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
dcd_event_xfer_complete(rhport, pipe->ep, pipe->length,
XFER_RESULT_SUCCESS, true);
update for gr_citurs
2021-03-24 00:53:55 +09:00
TU_LOG1("cE\r\n");
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
}
update for gr_citurs
2021-03-24 00:53:55 +09:00
#endif
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
static void process_pipe_brdy(uint8_t rhport, unsigned num)
{
update for gr_citurs
2021-03-24 00:53:55 +09:00
const unsigned ctr = select_pipe(num, USB_FIFOSEL_MBW_8);
const unsigned len = ctr & USB_FIFOCTR_DTLN;
const unsigned mps = USB0.PIPEMAXP.WORD;
pipe_state_t *pipe = &_dcd.pipe[num];
// TU_LOG1("> %d %x %x\r\n", num, USB0.D0FIFOSEL.WORD, ctr);
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
int cplt = read_fifo(&USB0.D0FIFO.WORD, pipe, mps, len);
if (cplt || (len < mps)) {
if (2 != cplt) {
USB0.D0FIFO.WORD = USB_FIFOCTR_BCLR;
}
USB0.D0FIFOSEL.WORD = 0;
dcd_event_xfer_complete(rhport, pipe->ep,
pipe->length - pipe->remaining,
XFER_RESULT_SUCCESS, true);
update for gr_citurs
2021-03-24 00:53:55 +09:00
// TU_LOG1("c\r\n");
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
} else {
USB0.D0FIFOSEL.WORD = 0;
}
}
static void process_bus_reset(uint8_t rhport)
{
USB0.BEMPENB.WORD = 1;
USB0.BRDYENB.WORD = 1;
USB0.CFIFOCTR.WORD = USB_FIFOCTR_BCLR;
USB0.D0FIFOSEL.WORD = 0;
USB0.D1FIFOSEL.WORD = 0;
volatile uint16_t *ctr = (volatile uint16_t*)((uintptr_t)(&USB0.PIPE1CTR.WORD));
volatile uint16_t *tre = (volatile uint16_t*)((uintptr_t)(&USB0.PIPE1TRE.WORD));
for (int i = 1; i <= 5; ++i) {
USB0.PIPESEL.WORD = i;
USB0.PIPECFG.WORD = 0;
*ctr = USB_PIPECTR_ACLRM;
*ctr = 0;
++ctr;
*tre = (1u<<8);
tre += 2;
}
for (int i = 6; i <= 9; ++i) {
USB0.PIPESEL.WORD = i;
USB0.PIPECFG.WORD = 0;
*ctr = USB_PIPECTR_ACLRM;
*ctr = 0;
++ctr;
}
tu_varclr(&_dcd);
dcd_event_bus_reset(rhport, TUSB_SPEED_FULL, true);
TU_LOG1("R\r\n");
}
static void process_set_address(uint8_t rhport)
{
const uint32_t addr = USB0.USBADDR.BIT.USBADDR;
if (!addr) return;
const tusb_control_request_t setup_packet = {
.bmRequestType = 0,
.bRequest = 5,
.wValue = addr,
.wIndex = 0,
.wLength = 0,
};
dcd_event_setup_received(rhport, (const uint8_t*)&setup_packet, true);
}
/*------------------------------------------------------------------*/
/* Device API
*------------------------------------------------------------------*/
void dcd_init(uint8_t rhport)
{
(void)rhport;
/* Enable USB0 */
uint32_t pswi = disable_interrupt();
SYSTEM.PRCR.WORD = SYSTEM_PRCR_PRKEY | SYSTEM_PRCR_PRC1;
MSTP(USB0) = 0;
SYSTEM.PRCR.WORD = SYSTEM_PRCR_PRKEY;
enable_interrupt(pswi);
USB0.SYSCFG.BIT.SCKE = 1;
while (!USB0.SYSCFG.BIT.SCKE) ;
USB0.SYSCFG.BIT.DRPD = 0;
USB0.SYSCFG.BIT.DCFM = 0;
USB0.SYSCFG.BIT.USBE = 1;
IR(USB0, USBI0) = 0;
/* Setup default control pipe */
USB0.DCPMAXP.BIT.MXPS = 64;
USB0.INTENB0.WORD = USB_IS0_VBINT | USB_IS0_BRDY | USB_IS0_BEMP | USB_IS0_DVST | USB_IS0_CTRT;
USB0.BEMPENB.WORD = 1;
USB0.BRDYENB.WORD = 1;
TU_LOG1("INIT\r\n");
if (USB0.INTSTS0.BIT.VBSTS) {
dcd_connect(rhport);
}
}
void dcd_int_enable(uint8_t rhport)
{
(void)rhport;
IEN(USB0, USBI0) = 1;
}
void dcd_int_disable(uint8_t rhport)
{
(void)rhport;
IEN(USB0, USBI0) = 0;
}
void dcd_set_address(uint8_t rhport, uint8_t dev_addr)
{
(void)rhport;
(void)dev_addr;
}
void dcd_remote_wakeup(uint8_t rhport)
{
(void)rhport;
/* TODO */
}
void dcd_connect(uint8_t rhport)
{
(void)rhport;
USB0.SYSCFG.BIT.DPRPU = 1;
}
void dcd_disconnect(uint8_t rhport)
{
(void)rhport;
USB0.SYSCFG.BIT.DPRPU = 0;
}
//--------------------------------------------------------------------+
// Endpoint API
//--------------------------------------------------------------------+
bool dcd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * ep_desc)
{
(void)rhport;
const unsigned ep_addr = ep_desc->bEndpointAddress;
const unsigned epn = ep_addr & 0xFu;
const unsigned dir = (ep_addr & TUSB_DIR_IN_MASK) ? TUSB_DIR_IN : TUSB_DIR_OUT;
const unsigned xfer = ep_desc->bmAttributes.xfer;
const unsigned mps = ep_desc->wMaxPacketSize.size;
if (xfer == TUSB_XFER_ISOCHRONOUS && mps > 256) {
update for gr_citurs
2021-03-24 00:53:55 +09:00
/* USBa supports up to 256 bytes */
added dcd for Renesas USBa
2021-03-07 14:53:21 +09:00
return false;
}
const unsigned num = find_pipe(xfer);
if (!num) return false;
_dcd.pipe[num].ep = ep_addr;
_dcd.ep[dir][epn] = num;
/* setup pipe */
USB0.PIPESEL.WORD = num;
USB0.PIPEMAXP.WORD = mps;
volatile uint16_t *ctr = get_pipectr(num);
*ctr = USB_PIPECTR_ACLRM;
*ctr = 0;
unsigned cfg = (dir << 4) | epn;
if (xfer == TUSB_XFER_BULK) {
cfg |= USB_PIPECFG_BULK | USB_PIPECFG_SHTNAK | USB_PIPECFG_DBLB;
} else if (xfer == TUSB_XFER_INTERRUPT) {
cfg |= USB_PIPECFG_INT;
} else {
cfg |= USB_PIPECFG_ISO | USB_PIPECFG_DBLB;
}
USB0.PIPECFG.WORD = cfg;
if (dir) {
USB0.BEMPENB.WORD |= 1u << num;
*ctr = USB_PIPECTR_PID_BUF;
} else {
USB0.BRDYENB.WORD |= 1u << num;
if (xfer != TUSB_XFER_BULK) {
*ctr = USB_PIPECTR_PID_BUF;
}
}
TU_LOG1("O %d %x %x\r\n", USB0.PIPESEL.WORD, USB0.PIPECFG.WORD, USB0.PIPEMAXP.WORD);
return true;
}
void dcd_edpt_close(uint8_t rhport, uint8_t ep_addr)
{
(void)rhport;
const unsigned epn = ep_addr & 0xFu;
const unsigned dir = (ep_addr & TUSB_DIR_IN_MASK) ? TUSB_DIR_IN : TUSB_DIR_OUT;
const unsigned num = _dcd.ep[dir][epn];
USB0.BEMPENB.WORD &= ~(1u << num);
USB0.BRDYENB.WORD &= ~(1u << num);
volatile uint16_t *ctr = get_pipectr(num);
*ctr = 0;
USB0.PIPESEL.WORD = num;
USB0.PIPECFG.WORD = 0;
_dcd.pipe[num].ep = 0;
_dcd.ep[dir][epn] = 0;
}
bool dcd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes)
{
bool r;
const unsigned epn = ep_addr & 0xFu;
dcd_int_disable(rhport);
if (0 == epn) {
r = process_edpt0_xfer(rhport, ep_addr, buffer, total_bytes);
} else {
r = process_pipe_xfer(rhport, ep_addr, buffer, total_bytes);
}
dcd_int_enable(rhport);
return r;
}
void dcd_edpt_stall(uint8_t rhport, uint8_t ep_addr)
{
volatile uint16_t *ctr = ep_addr_to_pipectr(rhport, ep_addr);
if (!ctr) return;
dcd_int_disable(rhport);
const uint32_t pid = *ctr & 0x3;
*ctr = pid | USB_PIPECTR_PID_STALL;
*ctr = USB_PIPECTR_PID_STALL;
dcd_int_enable(rhport);
}
void dcd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr)
{
volatile uint16_t *ctr = ep_addr_to_pipectr(rhport, ep_addr);
if (!ctr) return;
dcd_int_disable(rhport);
*ctr = USB_PIPECTR_SQCLR;
if (ep_addr & TUSB_DIR_IN_MASK) {
*ctr = USB_PIPECTR_PID_BUF;
} else {
/* TODO */
}
dcd_int_enable(rhport);
}
//--------------------------------------------------------------------+
// ISR
//--------------------------------------------------------------------+
void dcd_int_handler(uint8_t rhport)
{
(void)rhport;
unsigned is0 = USB0.INTSTS0.WORD;
/* clear bits except VALID */
USB0.INTSTS0.WORD = USB_IS0_VALID;
if (is0 & USB_IS0_VBINT) {
if (USB0.INTSTS0.BIT.VBSTS) {
dcd_connect(rhport);
} else {
dcd_disconnect(rhport);
}
}
if (is0 & USB_IS0_DVST) {
switch (is0 & USB_IS0_DVSQ) {
case USB_IS0_DVSQ_DEF:
process_bus_reset(rhport);
break;
case USB_IS0_DVSQ_ADDR:
process_set_address(rhport);
break;
default:
break;
}
}
if (is0 & USB_IS0_CTRT) {
if (is0 & USB_IS0_CTSQ_SETUP) {
/* A setup packet has been received. */
process_setup_packet(rhport);
} else if (0 == (is0 & USB_IS0_CTSQ_MSK)) {
/* A ZLP has been sent/received. */
process_status_completion(rhport);
}
}
if (is0 & USB_IS0_BEMP) {
const unsigned m = USB0.BEMPENB.WORD;
unsigned s = USB0.BEMPSTS.WORD & m;
USB0.BEMPSTS.WORD = 0;
if (s & 1) {
process_edpt0_bemp(rhport);
s &= ~1;
}
while (s) {
const unsigned num = __builtin_ctz(s);
process_pipe_bemp(rhport, num);
s &= ~(1<<num);
}
}
if (is0 & USB_IS0_BRDY) {
const unsigned m = USB0.BRDYENB.WORD;
unsigned s = USB0.BRDYSTS.WORD & m;
USB0.BRDYSTS.WORD = 0;
if (s & 1) {
process_edpt0_brdy(rhport);
s &= ~1;
}
while (s) {
const unsigned num = __builtin_ctz(s);
process_pipe_brdy(rhport, num);
s &= ~(1<<num);
}
}
}
#endif
Reference in New Issue Copy Permalink