Mirrors/pico-uart-bridge
1
0
Fork 0
mirror of https://github.com/Noltari/pico-uart-bridge.git synced 2025-05-14 08:12:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix ISRs, and USB descripters

Browse source
This commit is contained in:
Andrew J. Kroll 2024-04-14 19:36:53 -04:00
parent c8a4bc513f
commit cc42c66af4
2 changed files with 362 additions and 241 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

576
uart-bridge.c
View file

@ -1,6 +1,8 @@
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
/* /*
* Copyright 2021 Álvaro Fernández Rojas <noltari@gmail.com> * Copyright 2021 Álvaro Fernández Rojas <noltari@gmail.com>
* Cleanup/modifications Copyright 2023 Andrew J. Kroll <xxxajk at gmail>
*
*/ */
#include <hardware/irq.h> #include <hardware/irq.h>
@ -15,308 +17,404 @@
#define MIN(a, b) ((a > b) ? b : a) #define MIN(a, b) ((a > b) ? b : a)
#endif /* MIN */ #endif /* MIN */
#define LED_PIN 25 #define SYS_LED_ACTIVE 25
#define BUFFER_SIZE 2560 #define BUFFER_SIZE 2560
#define LED_TIMEOUT 10
#define UART0_TX 0
#define UART0_RX 1
#define UART0_LED_TX 19 // not used for UDPI
#define UART0_LED_RX 18
#define UART1_TX 4
#define UART1_RX 5
#define UART1_LED_TX 17
#define UART1_LED_RX 16
#define DEF_BIT_RATE 115200 #define DEF_BIT_RATE 115200
#define DEF_STOP_BITS 1 #define DEF_STOP_BITS 1
#define DEF_PARITY 0 #define DEF_PARITY 0
#define DEF_DATA_BITS 8 #define DEF_DATA_BITS 8
typedef struct { typedef struct {
uart_inst_t *const inst; uart_inst_t * const inst;
uint irq; uint irq;
void *irq_fn; void *irq_fn;
uint8_t tx_pin; uint8_t tx_pin;
uint8_t rx_pin; uint8_t rx_pin;
uint8_t tx_led;
uint8_t rx_led;
} uart_id_t; } uart_id_t;
typedef struct { typedef struct {
cdc_line_coding_t usb_lc; cdc_line_coding_t usb_lc;
cdc_line_coding_t uart_lc; cdc_line_coding_t uart_lc;
mutex_t lc_mtx; mutex_t lc_mtx;
uint8_t uart_buffer[BUFFER_SIZE]; uint8_t uart_buffer[BUFFER_SIZE];
uint32_t uart_pos; uint32_t uart_pos;
mutex_t uart_mtx; mutex_t uart_mtx;
uint8_t usb_buffer[BUFFER_SIZE]; uint8_t usb_buffer[BUFFER_SIZE];
uint32_t usb_pos; uint32_t usb_pos;
mutex_t usb_mtx; mutex_t usb_mtx;
volatile uint8_t countdown_LED_TX;
volatile uint8_t countdown_LED_RX;
critical_section_t spinlock_LED_TX;
critical_section_t spinlock_LED_RX;
} uart_data_t; } uart_data_t;
void uart0_irq_fn(void); void uart0_irq_fn(void);
void uart1_irq_fn(void); void uart1_irq_fn(void);
const uart_id_t UART_ID[CFG_TUD_CDC] = { const uart_id_t UART_ID[CFG_TUD_CDC] = {
{ {
.inst = uart0, .inst = uart0,
.irq = UART0_IRQ, .irq = UART0_IRQ,
.irq_fn = &uart0_irq_fn, .irq_fn = &uart0_irq_fn,
.tx_pin = 16, .tx_pin = UART0_TX,
.rx_pin = 17, .rx_pin = UART0_RX,
}, { .tx_led = UART0_LED_TX,
.inst = uart1, .rx_led = UART0_LED_RX,
.irq = UART1_IRQ, },
.irq_fn = &uart1_irq_fn, {
.tx_pin = 4, .inst = uart1,
.rx_pin = 5, .irq = UART1_IRQ,
} .irq_fn = &uart1_irq_fn,
.tx_pin = UART1_TX,
.rx_pin = UART1_RX,
.tx_led = UART1_LED_TX,
.rx_led = UART1_LED_RX,
}
}; };
uart_data_t UART_DATA[CFG_TUD_CDC]; uart_data_t UART_DATA[CFG_TUD_CDC];
struct repeating_timer stimulate;
volatile bool ready = false;
static inline uint databits_usb2uart(uint8_t data_bits) void init_led(uint8_t p) {
{ gpio_init(p);
switch (data_bits) { gpio_set_dir(p, GPIO_OUT);
case 5: gpio_put(p, 0);
return 5;
case 6:
return 6;
case 7:
return 7;
default:
return 8;
}
} }
static inline uart_parity_t parity_usb2uart(uint8_t usb_parity) static inline uint databits_usb2uart(uint8_t data_bits) {
{ switch(data_bits) {
switch (usb_parity) { case 5:
case 1: return 5;
return UART_PARITY_ODD; case 6:
case 2: return 6;
return UART_PARITY_EVEN; case 7:
default: return 7;
return UART_PARITY_NONE; default:
} return 8;
}
} }
static inline uint stopbits_usb2uart(uint8_t stop_bits) static inline uart_parity_t parity_usb2uart(uint8_t usb_parity) {
{ switch(usb_parity) {
switch (stop_bits) { case 1:
case 2: return UART_PARITY_ODD;
return 2; case 2:
default: return UART_PARITY_EVEN;
return 1; default:
} return UART_PARITY_NONE;
}
} }
void update_uart_cfg(uint8_t itf) static inline uint stopbits_usb2uart(uint8_t stop_bits) {
{ switch(stop_bits) {
const uart_id_t *ui = &UART_ID[itf]; case 2:
uart_data_t *ud = &UART_DATA[itf]; return 2;
default:
mutex_enter_blocking(&ud->lc_mtx); return 1;
}
if (ud->usb_lc.bit_rate != ud->uart_lc.bit_rate) {
uart_set_baudrate(ui->inst, ud->usb_lc.bit_rate);
ud->uart_lc.bit_rate = ud->usb_lc.bit_rate;
}
if ((ud->usb_lc.stop_bits != ud->uart_lc.stop_bits) ||
(ud->usb_lc.parity != ud->uart_lc.parity) ||
(ud->usb_lc.data_bits != ud->uart_lc.data_bits)) {
uart_set_format(ui->inst,
databits_usb2uart(ud->usb_lc.data_bits),
stopbits_usb2uart(ud->usb_lc.stop_bits),
parity_usb2uart(ud->usb_lc.parity));
ud->uart_lc.data_bits = ud->usb_lc.data_bits;
ud->uart_lc.parity = ud->usb_lc.parity;
ud->uart_lc.stop_bits = ud->usb_lc.stop_bits;
}
mutex_exit(&ud->lc_mtx);
} }
void usb_read_bytes(uint8_t itf) void update_uart_cfg(uint8_t itf) {
{ const uart_id_t *ui = &UART_ID[itf];
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
uint32_t len = tud_cdc_n_available(itf);
if (len && mutex_enter_blocking(&ud->lc_mtx);
mutex_try_enter(&ud->usb_mtx, NULL)) {
len = MIN(len, BUFFER_SIZE - ud->usb_pos);
if (len) {
uint32_t count;
count = tud_cdc_n_read(itf, &ud->usb_buffer[ud->usb_pos], len); if(ud->usb_lc.bit_rate != ud->uart_lc.bit_rate) {
ud->usb_pos += count; uart_set_baudrate(ui->inst, ud->usb_lc.bit_rate);
} ud->uart_lc.bit_rate = ud->usb_lc.bit_rate;
}
mutex_exit(&ud->usb_mtx); if((ud->usb_lc.stop_bits != ud->uart_lc.stop_bits) || (ud->usb_lc.parity != ud->uart_lc.parity) || (ud->usb_lc.data_bits != ud->uart_lc.data_bits)) {
} uart_set_format(ui->inst, databits_usb2uart(ud->usb_lc.data_bits), stopbits_usb2uart(ud->usb_lc.stop_bits), parity_usb2uart(ud->usb_lc.parity));
ud->uart_lc.data_bits = ud->usb_lc.data_bits;
ud->uart_lc.parity = ud->usb_lc.parity;
ud->uart_lc.stop_bits = ud->usb_lc.stop_bits;
}
mutex_exit(&ud->lc_mtx);
} }
void usb_write_bytes(uint8_t itf) void usb_read_bytes(uint8_t itf) {
{ uart_data_t *ud = &UART_DATA[itf];
uart_data_t *ud = &UART_DATA[itf]; uint32_t len = tud_cdc_n_available(itf);
if (ud->uart_pos && if(len && mutex_try_enter(&ud->usb_mtx, NULL)) {
mutex_try_enter(&ud->uart_mtx, NULL)) { len = MIN(len, BUFFER_SIZE - ud->usb_pos);
uint32_t count; if(len) {
uint32_t count;
count = tud_cdc_n_read(itf, &ud->usb_buffer[ud->usb_pos], len);
ud->usb_pos += count;
}
count = tud_cdc_n_write(itf, ud->uart_buffer, ud->uart_pos); mutex_exit(&ud->usb_mtx);
if (count < ud->uart_pos) }
memmove(ud->uart_buffer, &ud->uart_buffer[count],
ud->uart_pos - count);
ud->uart_pos -= count;
mutex_exit(&ud->uart_mtx);
if (count)
tud_cdc_n_write_flush(itf);
}
} }
void usb_cdc_process(uint8_t itf) void usb_write_bytes(uint8_t itf) {
{ uart_data_t *ud = &UART_DATA[itf];
uart_data_t *ud = &UART_DATA[itf];
mutex_enter_blocking(&ud->lc_mtx); if(ud->uart_pos) {
tud_cdc_n_get_line_coding(itf, &ud->usb_lc); if(mutex_try_enter(&ud->uart_mtx, NULL)) {
mutex_exit(&ud->lc_mtx); uint32_t count = tud_cdc_n_write(itf, ud->uart_buffer, ud->uart_pos);
// horrible! should use ring buffers!!
if(count < ud->uart_pos) {
memmove(ud->uart_buffer, &ud->uart_buffer[count], ud->uart_pos - count);
}
ud->uart_pos -= count;
mutex_exit(&ud->uart_mtx);
usb_read_bytes(itf); if(count)
usb_write_bytes(itf); tud_cdc_n_write_flush(itf);
}
}
} }
void core1_entry(void) void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms) {
{ const uart_id_t *ui = &UART_ID[itf];
tusb_init(); uart_data_t *ud = &UART_DATA[itf];
while (1) { // is mutex for tx even needed??
int itf; //mutex_enter_blocking(&ud->lc_mtx);
int con = 0;
tud_task(); if(duration_ms == 0xffff) {
uart_set_break(ui->inst, true);
for (itf = 0; itf < CFG_TUD_CDC; itf++) { } else if(duration_ms == 0x0000) {
if (tud_cdc_n_connected(itf)) { uart_set_break(ui->inst, false);
con = 1; } else {
usb_cdc_process(itf); // should be correct for non-compliant stacks?
} uart_set_break(ui->inst, true);
} sleep_ms(duration_ms);
uart_set_break(ui->inst, false);
gpio_put(LED_PIN, con); }
} //mutex_exit(&ud->lc_mtx);
} }
static inline void uart_read_bytes(uint8_t itf) void usb_cdc_process(uint8_t itf) {
{ uart_data_t *ud = &UART_DATA[itf];
uart_data_t *ud = &UART_DATA[itf];
const uart_id_t *ui = &UART_ID[itf];
if (uart_is_readable(ui->inst)) { mutex_enter_blocking(&ud->lc_mtx);
mutex_enter_blocking(&ud->uart_mtx); tud_cdc_n_get_line_coding(itf, &ud->usb_lc);
mutex_exit(&ud->lc_mtx);
while (uart_is_readable(ui->inst) && usb_read_bytes(itf);
(ud->uart_pos < BUFFER_SIZE)) { usb_write_bytes(itf);
ud->uart_buffer[ud->uart_pos] = uart_getc(ui->inst);
ud->uart_pos++;
}
mutex_exit(&ud->uart_mtx);
}
} }
void uart0_irq_fn(void) void core1_entry(void) {
{ tusb_init();
uart_read_bytes(0); ready = true;
while(1) {
int itf;
tud_task();
if(tud_ready()) { // we need to ignore DTR on the CDC side
gpio_put(SYS_LED_ACTIVE, 1);
for(itf = 0; itf < CFG_TUD_CDC; itf++) {
usb_cdc_process(itf);
}
} else {
gpio_put(SYS_LED_ACTIVE, 0);
}
}
} }
void uart1_irq_fn(void) void stimulate_status(uint8_t itf) {
{ const uart_id_t *ui = &UART_ID[itf];
uart_read_bytes(1); uart_data_t *ud = &UART_DATA[itf];
critical_section_enter_blocking(&ud->spinlock_LED_RX);
if(ud->countdown_LED_RX == LED_TIMEOUT) {
gpio_put(ui->rx_led, 1);
}
if(ud->countdown_LED_RX != 0) {
ud->countdown_LED_RX--;
if(ud->countdown_LED_RX == 0) {
gpio_put(ui->rx_led, 0);
}
}
critical_section_exit(&ud->spinlock_LED_RX);
critical_section_enter_blocking(&ud->spinlock_LED_TX);
if(ud->countdown_LED_TX == LED_TIMEOUT) {
gpio_put(ui->tx_led, 1);
}
if(ud->countdown_LED_TX != 0) {
ud->countdown_LED_TX--;
if(ud->countdown_LED_TX == 0) {
gpio_put(ui->tx_led, 0);
}
}
critical_section_exit(&ud->spinlock_LED_TX);
} }
void uart_write_bytes(uint8_t itf) bool update_status(struct repeating_timer *t) {
{ for(uint8_t itf = 0; itf < CFG_TUD_CDC; itf++) {
uart_data_t *ud = &UART_DATA[itf]; stimulate_status(itf);
}
if (ud->usb_pos && return true;
mutex_try_enter(&ud->usb_mtx, NULL)) {
const uart_id_t *ui = &UART_ID[itf];
uint32_t count = 0;
while (uart_is_writable(ui->inst) &&
count < ud->usb_pos) {
uart_putc_raw(ui->inst, ud->usb_buffer[count]);
count++;
}
if (count < ud->usb_pos)
memmove(ud->usb_buffer, &ud->usb_buffer[count],
ud->usb_pos - count);
ud->usb_pos -= count;
mutex_exit(&ud->usb_mtx);
}
} }
void init_uart_data(uint8_t itf) static inline void uart_read_bytes(uint8_t itf) {
{ uart_data_t *ud = &UART_DATA[itf];
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
uart_data_t *ud = &UART_DATA[itf];
/* Pinmux */ if(uart_is_readable(ui->inst)) {
gpio_set_function(ui->tx_pin, GPIO_FUNC_UART);
gpio_set_function(ui->rx_pin, GPIO_FUNC_UART);
/* USB CDC LC */ critical_section_enter_blocking(&ud->spinlock_LED_RX);
ud->usb_lc.bit_rate = DEF_BIT_RATE; ud->countdown_LED_RX = LED_TIMEOUT;
ud->usb_lc.data_bits = DEF_DATA_BITS; critical_section_exit(&ud->spinlock_LED_RX);
ud->usb_lc.parity = DEF_PARITY;
ud->usb_lc.stop_bits = DEF_STOP_BITS;
/* UART LC */ mutex_enter_blocking(&ud->uart_mtx);
ud->uart_lc.bit_rate = DEF_BIT_RATE;
ud->uart_lc.data_bits = DEF_DATA_BITS;
ud->uart_lc.parity = DEF_PARITY;
ud->uart_lc.stop_bits = DEF_STOP_BITS;
/* Buffer */ if(ud->uart_pos < BUFFER_SIZE) {
ud->uart_pos = 0; ud->uart_buffer[ud->uart_pos] = uart_getc(ui->inst);
ud->usb_pos = 0; ud->uart_pos++;
} else {
/* Mutex */ uart_getc(ui->inst); // drop it on the floor
mutex_init(&ud->lc_mtx); }
mutex_init(&ud->uart_mtx); mutex_exit(&ud->uart_mtx);
mutex_init(&ud->usb_mtx); }
/* UART start */
uart_init(ui->inst, ud->usb_lc.bit_rate);
uart_set_hw_flow(ui->inst, false, false);
uart_set_format(ui->inst, databits_usb2uart(ud->usb_lc.data_bits),
stopbits_usb2uart(ud->usb_lc.stop_bits),
parity_usb2uart(ud->usb_lc.parity));
uart_set_fifo_enabled(ui->inst, false);
/* UART RX Interrupt */
irq_set_exclusive_handler(ui->irq, ui->irq_fn);
irq_set_enabled(ui->irq, true);
uart_set_irq_enables(ui->inst, true, false);
} }
int main(void) void uart_write_bytes(uint8_t itf) {
{ uart_data_t *ud = &UART_DATA[itf];
int itf;
usbd_serial_init(); if(ud->usb_pos && mutex_try_enter(&ud->usb_mtx, NULL)) {
const uart_id_t *ui = &UART_ID[itf];
for (itf = 0; itf < CFG_TUD_CDC; itf++) // horrible! should use ring buffers!!
init_uart_data(itf); if(uart_is_writable(ui->inst)) { // && count < ud->usb_pos) {
critical_section_enter_blocking(&ud->spinlock_LED_TX);
gpio_init(LED_PIN); ud->countdown_LED_TX = LED_TIMEOUT;
gpio_set_dir(LED_PIN, GPIO_OUT); critical_section_exit(&ud->spinlock_LED_TX);
uart_putc_raw(ui->inst, ud->usb_buffer[0]);
multicore_launch_core1(core1_entry); if(ud->usb_pos > 1) {
memmove(ud->usb_buffer, &ud->usb_buffer[1], ud->usb_pos - 1);
while (1) { }
for (itf = 0; itf < CFG_TUD_CDC; itf++) { ud->usb_pos--;
update_uart_cfg(itf); }
uart_write_bytes(itf); mutex_exit(&ud->usb_mtx);
} }
} }
return 0; void uart0_irq_fn(void) {
uart_read_bytes(0);
}
void uart1_irq_fn(void) {
uart_read_bytes(1);
}
void init_uart_data(uint8_t itf) {
const uart_id_t *ui = &UART_ID[itf];
uart_data_t *ud = &UART_DATA[itf];
init_led(ui->tx_led);
init_led(ui->rx_led);
ud->countdown_LED_TX = 0;
ud->countdown_LED_RX = 0;
critical_section_init(&ud->spinlock_LED_TX);
critical_section_init(&ud->spinlock_LED_RX);
/* Pinmux */
gpio_set_function(ui->tx_pin, GPIO_FUNC_UART);
gpio_set_function(ui->rx_pin, GPIO_FUNC_UART);
gpio_pull_up(ui->rx_pin); // important missed detail, prevents connection glitches
/* USB CDC LC */
ud->usb_lc.bit_rate = DEF_BIT_RATE;
ud->usb_lc.data_bits = DEF_DATA_BITS;
ud->usb_lc.parity = DEF_PARITY;
ud->usb_lc.stop_bits = DEF_STOP_BITS;
/* UART LC */
ud->uart_lc.bit_rate = DEF_BIT_RATE;
ud->uart_lc.data_bits = DEF_DATA_BITS;
ud->uart_lc.parity = DEF_PARITY;
ud->uart_lc.stop_bits = DEF_STOP_BITS;
/* Buffer */
ud->uart_pos = 0;
ud->usb_pos = 0;
/* Mutex */
mutex_init(&ud->lc_mtx);
mutex_init(&ud->uart_mtx);
mutex_init(&ud->usb_mtx);
/* UART start */
uart_init(ui->inst, ud->usb_lc.bit_rate);
uart_set_hw_flow(ui->inst, false, false);
uart_set_format(ui->inst, databits_usb2uart(ud->usb_lc.data_bits),
stopbits_usb2uart(ud->usb_lc.stop_bits),
parity_usb2uart(ud->usb_lc.parity));
uart_set_fifo_enabled(ui->inst, false);
uart_set_translate_crlf(ui->inst, false);
/* UART RX Interrupt */
irq_set_exclusive_handler(ui->irq, ui->irq_fn);
}
void start_uarts() {
uint8_t itf;
for(itf = 0; itf < CFG_TUD_CDC; itf++) {
init_uart_data(itf);
}
// init led stimulator
add_repeating_timer_ms(1, update_status, NULL, &stimulate);
// enable ISRs
for(itf = 0; itf < CFG_TUD_CDC; itf++) {
const uart_id_t *ui = &UART_ID[itf];
irq_set_enabled(ui->irq, true);
uart_set_irq_enables(ui->inst, true, false);
}
}
int main(void) {
int itf;
set_sys_clock_khz(125000, false);
multicore_reset_core1();
init_led(SYS_LED_ACTIVE);
usbd_serial_init();
start_uarts();
multicore_launch_core1(core1_entry);
do {
sleep_us(1);
} while(!ready);
while(1) {
if(tud_ready()) {
for(itf = 0; itf < CFG_TUD_CDC; itf++) {
update_uart_cfg(itf);
uart_write_bytes(itf);
}
}
}
return 0;
} }

27
usb-descriptors.c
View file

@ -12,6 +12,29 @@
#include <hardware/flash.h> #include <hardware/flash.h>
#include <tusb.h> #include <tusb.h>
#define TUD_CDC_BRK_DESCRIPTOR(_itfnum, _stridx, _ep_notif, _ep_notif_size, _epout, _epin, _epsize) \
/* Interface Associate */\
8, TUSB_DESC_INTERFACE_ASSOCIATION, _itfnum, 2, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_NONE, 0,\
/* CDC Control Interface */\
9, TUSB_DESC_INTERFACE, _itfnum, 0, 1, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_NONE, _stridx,\
/* CDC Header */\
5, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_HEADER, U16_TO_U8S_LE(0x0120),\
/* CDC Call */\
5, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_CALL_MANAGEMENT, 0, (uint8_t)((_itfnum) + 1),\
/* CDC ACM: support line request */\
4, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT, 6,\
/* CDC Union */\
5, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_UNION, _itfnum, (uint8_t)((_itfnum) + 1),\
/* Endpoint Notification */\
7, TUSB_DESC_ENDPOINT, _ep_notif, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_ep_notif_size), 16,\
/* CDC Data Interface */\
9, TUSB_DESC_INTERFACE, (uint8_t)((_itfnum)+1), 0, 2, TUSB_CLASS_CDC_DATA, 0, 0, 0,\
/* Endpoint Out */\
7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0,\
/* Endpoint In */\
7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
#define DESC_STR_MAX 20 #define DESC_STR_MAX 20
#define USBD_VID 0x2E8A /* Raspberry Pi */ #define USBD_VID 0x2E8A /* Raspberry Pi */
@ -64,11 +87,11 @@ static const uint8_t usbd_desc_cfg[USBD_DESC_LEN] = {
TUD_CONFIG_DESCRIPTOR(1, USBD_ITF_MAX, USBD_STR_0, USBD_DESC_LEN, TUD_CONFIG_DESCRIPTOR(1, USBD_ITF_MAX, USBD_STR_0, USBD_DESC_LEN,
TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA),
TUD_CDC_DESCRIPTOR(USBD_ITF_CDC_0, USBD_STR_CDC, USBD_CDC_0_EP_CMD, TUD_CDC_BRK_DESCRIPTOR(USBD_ITF_CDC_0, USBD_STR_CDC, USBD_CDC_0_EP_CMD,
USBD_CDC_CMD_MAX_SIZE, USBD_CDC_0_EP_OUT, USBD_CDC_0_EP_IN, USBD_CDC_CMD_MAX_SIZE, USBD_CDC_0_EP_OUT, USBD_CDC_0_EP_IN,
USBD_CDC_IN_OUT_MAX_SIZE), USBD_CDC_IN_OUT_MAX_SIZE),
TUD_CDC_DESCRIPTOR(USBD_ITF_CDC_1, USBD_STR_CDC, USBD_CDC_1_EP_CMD, TUD_CDC_BRK_DESCRIPTOR(USBD_ITF_CDC_1, USBD_STR_CDC, USBD_CDC_1_EP_CMD,
USBD_CDC_CMD_MAX_SIZE, USBD_CDC_1_EP_OUT, USBD_CDC_1_EP_IN, USBD_CDC_CMD_MAX_SIZE, USBD_CDC_1_EP_OUT, USBD_CDC_1_EP_IN,
USBD_CDC_IN_OUT_MAX_SIZE), USBD_CDC_IN_OUT_MAX_SIZE),
}; };