mirror/tinyusb
3
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2026-02-14 12:25:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

add tud_vendor_n_read_discard(), refactor vendor device. Update webusb example for more robust

Browse Source
This commit is contained in:
hathach
2025-11-27 16:25:19 +07:00
parent 4ef0f61bde
commit f3dc2186ae
4 changed files with 167 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
examples/device/cdc_msc/src/main.c
View File

@ -124,6 +124,7 @@ void cdc_task(void) {
if ((btn_prev == 0u) && (btn != 0u)) {
uart_state.dsr ^= 1;
uart_state.dcd ^= 1;
tud_cdc_notify_uart_state(&uart_state);
}
btn_prev = btn;

54
examples/device/webusb_serial/src/main.c
View File

@ -101,7 +101,7 @@ int main(void) {
while (1) {
tud_task(); // tinyusb device task
cdc_task();
tud_cdc_write_flush();
led_blinking_task();
}
}
@ -116,13 +116,7 @@ static void echo_all(const uint8_t buf[], uint32_t count) {
// echo to cdc
if (tud_cdc_connected()) {
for (uint32_t i = 0; i < count; i++) {
tud_cdc_write_char(buf[i]);
if (buf[i] == '\r') {
tud_cdc_write_char('\n');
}
}
tud_cdc_write_flush();
tud_cdc_write(buf, count);
}
}
@ -162,7 +156,9 @@ void tud_resume_cb(void) {
// return false to stall control endpoint (e.g unsupported request)
bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const* request) {
// nothing to with DATA & ACK stage
if (stage != CONTROL_STAGE_SETUP) return true;
if (stage != CONTROL_STAGE_SETUP) {
return true;
}
switch (request->bmRequestType_bit.type) {
case TUSB_REQ_TYPE_VENDOR:
@ -215,33 +211,20 @@ bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_requ
return false;
}
void tud_vendor_rx_cb(uint8_t itf, uint8_t const* buffer, uint16_t bufsize) {
(void) itf;
void tud_vendor_rx_cb(uint8_t idx, const uint8_t *buffer, uint16_t bufsize) {
(void)idx;
// since we used data without pulling it from RX FIFO, we need to discard number of items used
#if CFG_TUD_VENDOR_RX_BUFSIZE > 0
tud_vendor_read_discard(bufsize);
#endif
echo_all(buffer, bufsize);
// if using RX buffered is enabled, we need to flush the buffer to make room for new data
#if CFG_TUD_VENDOR_RX_BUFSIZE > 0
tud_vendor_read_flush();
#endif
}
//--------------------------------------------------------------------+
// USB CDC
//--------------------------------------------------------------------+
void cdc_task(void) {
if (tud_cdc_connected()) {
// connected and there are data available
if (tud_cdc_available()) {
uint8_t buf[64];
uint32_t count = tud_cdc_read(buf, sizeof(buf));
// echo back to both web serial and cdc
echo_all(buf, count);
}
}
}
// Invoked when cdc when line state changed e.g connected/disconnected
void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
@ -255,8 +238,13 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
}
// Invoked when CDC interface received data from host
void tud_cdc_rx_cb(uint8_t itf) {
(void)itf;
void tud_cdc_rx_cb(uint8_t idx) {
(void)idx;
while (tud_cdc_available()) {
uint8_t buf[64];
const uint32_t count = tud_cdc_read(buf, sizeof(buf));
echo_all(buf, count); // echo back to both web serial and cdc
}
}
//--------------------------------------------------------------------+
@ -267,7 +255,9 @@ void led_blinking_task(void) {
static bool led_state = false;
// Blink every interval ms
if (board_millis() - start_ms < blink_interval_ms) return; // not enough time
if (board_millis() - start_ms < blink_interval_ms) {
return; // not enough time
}
start_ms += blink_interval_ms;
board_led_write(led_state);

204
src/class/vendor/vendor_device.c vendored
View File

@ -42,22 +42,20 @@ typedef struct {
/*------------- From this point, data is not cleared by bus reset -------------*/
struct {
tu_edpt_stream_t stream;
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
uint8_t ff_buf[CFG_TUD_VENDOR_TX_BUFSIZE];
#endif
} tx;
tu_edpt_stream_t tx;
tu_edpt_stream_t rx;
struct {
tu_edpt_stream_t stream;
#if CFG_TUD_VENDOR_RX_BUFSIZE > 0
uint8_t ff_buf[CFG_TUD_VENDOR_RX_BUFSIZE];
#endif
} rx;
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
uint8_t tx_ff_buf[CFG_TUD_VENDOR_TX_BUFSIZE];
#endif
#if CFG_TUD_VENDOR_RX_BUFSIZE > 0
uint8_t rx_ff_buf[CFG_TUD_VENDOR_RX_BUFSIZE];
#endif
} stream;
} vendord_interface_t;
#define ITF_MEM_RESET_SIZE (offsetof(vendord_interface_t, itf_num) + sizeof(((vendord_interface_t *)0)->itf_num))
#define ITF_MEM_RESET_SIZE (offsetof(vendord_interface_t, itf_num) + sizeof(((vendord_interface_t *)0)->itf_num))
static vendord_interface_t _vendord_itf[CFG_TUD_VENDOR];
@ -71,14 +69,14 @@ CFG_TUD_MEM_SECTION static vendord_epbuf_t _vendord_epbuf[CFG_TUD_VENDOR];
//--------------------------------------------------------------------+
// Weak stubs: invoked if no strong implementation is available
//--------------------------------------------------------------------+
TU_ATTR_WEAK void tud_vendor_rx_cb(uint8_t itf, uint8_t const* buffer, uint16_t bufsize) {
(void) itf;
TU_ATTR_WEAK void tud_vendor_rx_cb(uint8_t idx, const uint8_t *buffer, uint16_t bufsize) {
(void)idx;
(void) buffer;
(void) bufsize;
}
TU_ATTR_WEAK void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes) {
(void) itf;
TU_ATTR_WEAK void tud_vendor_tx_cb(uint8_t idx, uint32_t sent_bytes) {
(void)idx;
(void) sent_bytes;
}
@ -86,59 +84,65 @@ TU_ATTR_WEAK void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes) {
// Application API
//--------------------------------------------------------------------
bool tud_vendor_n_mounted(uint8_t itf) {
TU_VERIFY(itf < CFG_TUD_VENDOR);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return p_itf->rx.stream.ep_addr || p_itf->tx.stream.ep_addr;
bool tud_vendor_n_mounted(uint8_t idx) {
TU_VERIFY(idx < CFG_TUD_VENDOR);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return p_itf->stream.rx.ep_addr || p_itf->stream.tx.ep_addr;
}
//--------------------------------------------------------------------+
// Read API
//--------------------------------------------------------------------+
uint32_t tud_vendor_n_available(uint8_t itf) {
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return tu_edpt_stream_read_available(&p_itf->rx.stream);
uint32_t tud_vendor_n_available(uint8_t idx) {
TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_read_available(&p_itf->stream.rx);
}
bool tud_vendor_n_peek(uint8_t itf, uint8_t* u8) {
TU_VERIFY(itf < CFG_TUD_VENDOR);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return tu_edpt_stream_peek(&p_itf->rx.stream, u8);
bool tud_vendor_n_peek(uint8_t idx, uint8_t *u8) {
TU_VERIFY(idx < CFG_TUD_VENDOR);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_peek(&p_itf->stream.rx, u8);
}
uint32_t tud_vendor_n_read (uint8_t itf, void* buffer, uint32_t bufsize) {
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return tu_edpt_stream_read(p_itf->rhport, &p_itf->rx.stream, buffer, bufsize);
uint32_t tud_vendor_n_read(uint8_t idx, void *buffer, uint32_t bufsize) {
TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_read(p_itf->rhport, &p_itf->stream.rx, buffer, bufsize);
}
void tud_vendor_n_read_flush (uint8_t itf) {
TU_VERIFY(itf < CFG_TUD_VENDOR, );
vendord_interface_t* p_itf = &_vendord_itf[itf];
tu_edpt_stream_clear(&p_itf->rx.stream);
tu_edpt_stream_read_xfer(p_itf->rhport, &p_itf->rx.stream);
uint32_t tud_vendor_n_read_discard(uint8_t idx, uint32_t count) {
TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_discard(&p_itf->stream.rx, count);
}
void tud_vendor_n_read_flush(uint8_t idx) {
TU_VERIFY(idx < CFG_TUD_VENDOR, );
vendord_interface_t *p_itf = &_vendord_itf[idx];
tu_edpt_stream_clear(&p_itf->stream.rx);
tu_edpt_stream_read_xfer(p_itf->rhport, &p_itf->stream.rx);
}
//--------------------------------------------------------------------+
// Write API
//--------------------------------------------------------------------+
uint32_t tud_vendor_n_write (uint8_t itf, const void* buffer, uint32_t bufsize) {
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return tu_edpt_stream_write(p_itf->rhport, &p_itf->tx.stream, buffer, (uint16_t)bufsize);
uint32_t tud_vendor_n_write(uint8_t idx, const void *buffer, uint32_t bufsize) {
TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_write(p_itf->rhport, &p_itf->stream.tx, buffer, (uint16_t)bufsize);
}
uint32_t tud_vendor_n_write_flush (uint8_t itf) {
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return tu_edpt_stream_write_xfer(p_itf->rhport, &p_itf->tx.stream);
uint32_t tud_vendor_n_write_flush(uint8_t idx) {
TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_write_xfer(p_itf->rhport, &p_itf->stream.tx);
}
uint32_t tud_vendor_n_write_available (uint8_t itf) {
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
vendord_interface_t* p_itf = &_vendord_itf[itf];
return tu_edpt_stream_write_available(p_itf->rhport, &p_itf->tx.stream);
uint32_t tud_vendor_n_write_available(uint8_t idx) {
TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_itf = &_vendord_itf[idx];
return tu_edpt_stream_write_available(p_itf->rhport, &p_itf->stream.tx);
}
//--------------------------------------------------------------------+
@ -152,32 +156,30 @@ void vendord_init(void) {
vendord_epbuf_t* p_epbuf = &_vendord_epbuf[i];
#if CFG_TUD_VENDOR_RX_BUFSIZE > 0
uint8_t *rx_ff_buf = p_itf->rx.ff_buf;
uint8_t *rx_ff_buf = p_itf->stream.rx_ff_buf;
#else
uint8_t *rx_ff_buf = NULL;
#endif
tu_edpt_stream_init(&p_itf->rx.stream, false, false, false,
rx_ff_buf, CFG_TUD_VENDOR_RX_BUFSIZE,
p_epbuf->epout, CFG_TUD_VENDOR_EPSIZE);
tu_edpt_stream_init(&p_itf->stream.rx, false, false, false, rx_ff_buf, CFG_TUD_VENDOR_RX_BUFSIZE, p_epbuf->epout,
CFG_TUD_VENDOR_EPSIZE);
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
uint8_t *tx_ff_buf = p_itf->tx.ff_buf;
uint8_t *tx_ff_buf = p_itf->stream.tx_ff_buf;
#else
uint8_t* tx_ff_buf = NULL;
uint8_t *tx_ff_buf = NULL;
#endif
tu_edpt_stream_init(&p_itf->tx.stream, false, true, false,
tx_ff_buf, CFG_TUD_VENDOR_TX_BUFSIZE,
p_epbuf->epin, CFG_TUD_VENDOR_EPSIZE);
tu_edpt_stream_init(&p_itf->stream.tx, false, true, false, tx_ff_buf, CFG_TUD_VENDOR_TX_BUFSIZE, p_epbuf->epin,
CFG_TUD_VENDOR_EPSIZE);
}
}
bool vendord_deinit(void) {
for(uint8_t i=0; i<CFG_TUD_VENDOR; i++) {
vendord_interface_t* p_itf = &_vendord_itf[i];
tu_edpt_stream_deinit(&p_itf->rx.stream);
tu_edpt_stream_deinit(&p_itf->tx.stream);
tu_edpt_stream_deinit(&p_itf->stream.rx);
tu_edpt_stream_deinit(&p_itf->stream.tx);
}
return true;
}
@ -188,30 +190,42 @@ void vendord_reset(uint8_t rhport) {
for(uint8_t i=0; i<CFG_TUD_VENDOR; i++) {
vendord_interface_t* p_itf = &_vendord_itf[i];
tu_memclr(p_itf, ITF_MEM_RESET_SIZE);
tu_edpt_stream_clear(&p_itf->rx.stream);
tu_edpt_stream_close(&p_itf->rx.stream);
tu_edpt_stream_clear(&p_itf->tx.stream);
tu_edpt_stream_close(&p_itf->tx.stream);
tu_edpt_stream_clear(&p_itf->stream.rx);
tu_edpt_stream_close(&p_itf->stream.rx);
tu_edpt_stream_clear(&p_itf->stream.tx);
tu_edpt_stream_close(&p_itf->stream.tx);
}
}
uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint16_t max_len) {
// Find vendor interface by endpoint address
static uint8_t find_vendor_itf(uint8_t ep_addr) {
for (uint8_t idx = 0; idx < CFG_TUD_VENDOR; idx++) {
const vendord_interface_t *p_vendor = &_vendord_itf[idx];
if (ep_addr == 0) {
// find unused: require both ep == 0
if (p_vendor->stream.rx.ep_addr == 0 && p_vendor->stream.tx.ep_addr == 0) {
return idx;
}
} else if (ep_addr == p_vendor->stream.rx.ep_addr || ep_addr == p_vendor->stream.tx.ep_addr) {
return idx;
} else {
// nothing to do
}
}
return 0xff;
}
uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t *desc_itf, uint16_t max_len) {
TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == desc_itf->bInterfaceClass, 0);
const uint8_t* desc_end = (const uint8_t*)desc_itf + max_len;
const uint8_t* p_desc = tu_desc_next(desc_itf);
// Find available interface
vendord_interface_t* p_vendor = NULL;
uint8_t itf;
for(itf=0; itf<CFG_TUD_VENDOR; itf++) {
if (!tud_vendor_n_mounted(itf)) {
p_vendor = &_vendord_itf[itf];
break;
}
}
TU_VERIFY(p_vendor, 0);
const uint8_t idx = find_vendor_itf(0);
TU_ASSERT(idx < CFG_TUD_VENDOR, 0);
vendord_interface_t *p_vendor = &_vendord_itf[idx];
p_vendor->rhport = rhport;
p_vendor->itf_num = desc_itf->bInterfaceNumber;
@ -225,13 +239,13 @@ uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uin
// open endpoint stream, skip if already opened (multiple IN/OUT endpoints)
if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
tu_edpt_stream_t *stream_tx = &p_vendor->tx.stream;
tu_edpt_stream_t *stream_tx = &p_vendor->stream.tx;
if (stream_tx->ep_addr == 0) {
tu_edpt_stream_open(stream_tx, desc_ep);
tu_edpt_stream_write_xfer(rhport, stream_tx); // flush pending data
}
} else {
tu_edpt_stream_t *stream_rx = &p_vendor->rx.stream;
tu_edpt_stream_t *stream_rx = &p_vendor->stream.rx;
if (stream_rx->ep_addr == 0) {
tu_edpt_stream_open(stream_rx, desc_ep);
TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare for incoming data
@ -247,38 +261,30 @@ uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uin
bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
(void) result;
const uint8_t idx = find_vendor_itf(ep_addr);
TU_VERIFY(idx < CFG_TUD_VENDOR);
vendord_interface_t *p_vendor = &_vendord_itf[idx];
vendord_epbuf_t *p_epbuf = &_vendord_epbuf[idx];
uint8_t itf;
vendord_interface_t* p_vendor;
for (itf = 0; itf < CFG_TUD_VENDOR; itf++) {
p_vendor = &_vendord_itf[itf];
if ((ep_addr == p_vendor->rx.stream.ep_addr) || (ep_addr == p_vendor->tx.stream.ep_addr)) {
break;
}
}
TU_VERIFY(itf < CFG_TUD_VENDOR);
vendord_epbuf_t* p_epbuf = &_vendord_epbuf[itf];
if ( ep_addr == p_vendor->rx.stream.ep_addr ) {
if (ep_addr == p_vendor->stream.rx.ep_addr) {
// Received new data: put into stream's fifo
tu_edpt_stream_read_xfer_complete(&p_vendor->rx.stream, xferred_bytes);
tu_edpt_stream_read_xfer_complete(&p_vendor->stream.rx, xferred_bytes);
// Invoked callback if any
tud_vendor_rx_cb(itf, p_epbuf->epout, (uint16_t) xferred_bytes);
tud_vendor_rx_cb(idx, p_epbuf->epout, (uint16_t)xferred_bytes);
tu_edpt_stream_read_xfer(rhport, &p_vendor->rx.stream);
} else if ( ep_addr == p_vendor->tx.stream.ep_addr ) {
tu_edpt_stream_read_xfer(rhport, &p_vendor->stream.rx);
} else if (ep_addr == p_vendor->stream.tx.ep_addr) {
// Send complete
tud_vendor_tx_cb(itf, (uint16_t) xferred_bytes);
tud_vendor_tx_cb(idx, (uint16_t)xferred_bytes);
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
// try to send more if possible
if ( 0 == tu_edpt_stream_write_xfer(rhport, &p_vendor->tx.stream) ) {
if (0 == tu_edpt_stream_write_xfer(rhport, &p_vendor->stream.tx)) {
// If there is no data left, a ZLP should be sent if xferred_bytes is multiple of EP Packet size and not zero
tu_edpt_stream_write_zlp_if_needed(rhport, &p_vendor->tx.stream, xferred_bytes);
tu_edpt_stream_write_zlp_if_needed(rhport, &p_vendor->stream.tx, xferred_bytes);
}
#endif
#endif
}
return true;

75
src/class/vendor/vendor_device.h vendored
View File

@ -30,84 +30,87 @@
#include "common/tusb_common.h"
#ifndef CFG_TUD_VENDOR_EPSIZE
#define CFG_TUD_VENDOR_EPSIZE 64
#define CFG_TUD_VENDOR_EPSIZE 64
#endif
// RX FIFO can be disabled by setting this value to 0
#ifndef CFG_TUD_VENDOR_RX_BUFSIZE
#define CFG_TUD_VENDOR_RX_BUFSIZE 64
#define CFG_TUD_VENDOR_RX_BUFSIZE 64
#endif
// TX FIFO can be disabled by setting this value to 0
#ifndef CFG_TUD_VENDOR_TX_BUFSIZE
#define CFG_TUD_VENDOR_TX_BUFSIZE 64
#define CFG_TUD_VENDOR_TX_BUFSIZE 64
#endif
#ifdef __cplusplus
extern "C" {
extern "C" {
#endif
//--------------------------------------------------------------------+
// Application API (Multiple Interfaces) i.e CFG_TUD_VENDOR > 1
//--------------------------------------------------------------------+
bool tud_vendor_n_mounted (uint8_t itf);
uint32_t tud_vendor_n_available (uint8_t itf);
uint32_t tud_vendor_n_read (uint8_t itf, void* buffer, uint32_t bufsize);
bool tud_vendor_n_peek (uint8_t itf, uint8_t* ui8);
void tud_vendor_n_read_flush (uint8_t itf);
bool tud_vendor_n_mounted(uint8_t idx);
uint32_t tud_vendor_n_available(uint8_t idx);
bool tud_vendor_n_peek(uint8_t idx, uint8_t *ui8);
uint32_t tud_vendor_n_write (uint8_t itf, void const* buffer, uint32_t bufsize);
uint32_t tud_vendor_n_write_flush (uint8_t itf);
uint32_t tud_vendor_n_write_available (uint8_t itf);
uint32_t tud_vendor_n_read(uint8_t idx, void *buffer, uint32_t bufsize);
uint32_t tud_vendor_n_read_discard(uint8_t idx, uint32_t count);
void tud_vendor_n_read_flush(uint8_t idx);
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_n_write_str (uint8_t itf, char const* str);
uint32_t tud_vendor_n_write(uint8_t idx, const void *buffer, uint32_t bufsize);
uint32_t tud_vendor_n_write_flush(uint8_t idx);
uint32_t tud_vendor_n_write_available(uint8_t idx);
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_n_write_str(uint8_t idx, const char *str) {
return tud_vendor_n_write(idx, str, strlen(str));
}
// backward compatible
#define tud_vendor_n_flush(itf) tud_vendor_n_write_flush(itf)
#define tud_vendor_n_flush(idx) tud_vendor_n_write_flush(idx)
//--------------------------------------------------------------------+
// Application API (Single Port) i.e CFG_TUD_VENDOR = 1
//--------------------------------------------------------------------+
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_n_write_str(uint8_t itf, char const* str) {
return tud_vendor_n_write(itf, str, strlen(str));
}
TU_ATTR_ALWAYS_INLINE static inline bool tud_vendor_mounted(void) {
return tud_vendor_n_mounted(0);
return tud_vendor_n_mounted(0);
}
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_available(void) {
return tud_vendor_n_available(0);
return tud_vendor_n_available(0);
}
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_read(void* buffer, uint32_t bufsize) {
return tud_vendor_n_read(0, buffer, bufsize);
TU_ATTR_ALWAYS_INLINE static inline bool tud_vendor_peek(uint8_t *ui8) {
return tud_vendor_n_peek(0, ui8);
}
TU_ATTR_ALWAYS_INLINE static inline bool tud_vendor_peek(uint8_t* ui8) {
return tud_vendor_n_peek(0, ui8);
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_read(void *buffer, uint32_t bufsize) {
return tud_vendor_n_read(0, buffer, bufsize);
}
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_read_discard(uint32_t count) {
return tud_vendor_n_read_discard(0, count);
}
TU_ATTR_ALWAYS_INLINE static inline void tud_vendor_read_flush(void) {
tud_vendor_n_read_flush(0);
tud_vendor_n_read_flush(0);
}
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write(void const* buffer, uint32_t bufsize) {
return tud_vendor_n_write(0, buffer, bufsize);
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write(const void *buffer, uint32_t bufsize) {
return tud_vendor_n_write(0, buffer, bufsize);
}
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write_str(char const* str) {
return tud_vendor_n_write_str(0, str);
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write_str(const char *str) {
return tud_vendor_n_write_str(0, str);
}
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write_flush(void) {
return tud_vendor_n_write_flush(0);
return tud_vendor_n_write_flush(0);
}
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write_available(void) {
return tud_vendor_n_write_available(0);
return tud_vendor_n_write_available(0);
}
#endif
@ -119,9 +122,9 @@ TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write_available(void) {
//--------------------------------------------------------------------+
// Invoked when received new data
void tud_vendor_rx_cb(uint8_t itf, uint8_t const* buffer, uint16_t bufsize);
void tud_vendor_rx_cb(uint8_t idx, const uint8_t *buffer, uint16_t bufsize);
// Invoked when last rx transfer finished
void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes);
void tud_vendor_tx_cb(uint8_t idx, uint32_t sent_bytes);
//--------------------------------------------------------------------+
// Inline Functions
@ -134,11 +137,11 @@ void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes);
void vendord_init(void);
bool vendord_deinit(void);
void vendord_reset(uint8_t rhport);
uint16_t vendord_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t *idx_desc, uint16_t max_len);
bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
#ifdef __cplusplus
}
}
#endif
#endif /* TUSB_VENDOR_DEVICE_H_ */