Skip to content

Commit 8a5c118

Browse files
hathachhathach
committed
TUD_EPBUF_TYPE_DEF usbtmc_device.c and vendor_device.c
1 parent 1533e69 commit 8a5c118

File tree

2 files changed

+70
-59
lines changed

2 files changed

+70
-59
lines changed

‎src/class/usbtmc/usbtmc_device.c‎

Lines changed: 34 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -131,14 +131,6 @@ typedef struct
131131
uint8_t ep_int_in;
132132
uint32_t ep_bulk_in_wMaxPacketSize;
133133
uint32_t ep_bulk_out_wMaxPacketSize;
134-
// IN buffer is only used for first packet, not the remainder
135-
// in order to deal with prepending header
136-
CFG_TUSB_MEM_ALIGN uint8_t ep_bulk_in_buf[USBTMCD_BUFFER_SIZE];
137-
// OUT buffer receives one packet at a time
138-
CFG_TUSB_MEM_ALIGN uint8_t ep_bulk_out_buf[USBTMCD_BUFFER_SIZE];
139-
// Buffer int msg to ensure alignment and placement correctness
140-
CFG_TUSB_MEM_ALIGN uint8_t ep_int_in_buf[CFG_TUD_USBTMC_INT_EP_SIZE];
141-
142134
uint32_t transfer_size_remaining; // also used for requested length for bulk IN.
143135
uint32_t transfer_size_sent; // To keep track of data bytes that have been queued in FIFO (not header bytes)
144136

@@ -150,11 +142,23 @@ typedef struct
150142
usbtmc_capabilities_specific_t const * capabilities;
151143
} usbtmc_interface_state_t;
152144

153-
CFG_TUD_MEM_SECTION tu_static usbtmc_interface_state_t usbtmc_state =
154-
{
155-
.itf_id = 0xFF,
145+
typedef struct {
146+
// IN buffer is only used for first packet, not the remainder in order to deal with prepending header
147+
TUD_EPBUF_DEF(epin, USBTMCD_BUFFER_SIZE);
148+
149+
// OUT buffer receives one packet at a time
150+
TUD_EPBUF_DEF(epout, USBTMCD_BUFFER_SIZE);
151+
152+
// Buffer int msg
153+
TUD_EPBUF_DEF(epnotif, CFG_TUD_USBTMC_INT_EP_SIZE);
154+
} usbtmc_epbuf_t;
155+
156+
static usbtmc_interface_state_t usbtmc_state = {
157+
.itf_id = 0xFF,
156158
};
157159

160+
CFG_TUD_MEM_SECTION static usbtmc_epbuf_t usbtmc_epbuf;
161+
158162
// We need all headers to fit in a single packet in this implementation, 32 bytes will fit all standard USBTMC headers
159163
TU_VERIFY_STATIC(USBTMCD_BUFFER_SIZE >= 32u,"USBTMC dev buffer size too small");
160164

@@ -205,7 +209,7 @@ bool tud_usbtmc_transmit_dev_msg_data(
205209
bool endOfMessage,
206210
bool usingTermChar)
207211
{
208-
const unsigned int txBufLen = sizeof(usbtmc_state.ep_bulk_in_buf);
212+
const unsigned int txBufLen = USBTMCD_BUFFER_SIZE;
209213

210214
#ifndef NDEBUG
211215
TU_ASSERT(len > 0u);
@@ -220,7 +224,7 @@ bool tud_usbtmc_transmit_dev_msg_data(
220224
#endif
221225

222226
TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED);
223-
usbtmc_msg_dev_dep_msg_in_header_t *hdr = (usbtmc_msg_dev_dep_msg_in_header_t*)usbtmc_state.ep_bulk_in_buf;
227+
usbtmc_msg_dev_dep_msg_in_header_t *hdr = (usbtmc_msg_dev_dep_msg_in_header_t*)usbtmc_epbuf.epin;
224228
tu_varclr(hdr);
225229
hdr->header.MsgID = USBTMC_MSGID_DEV_DEP_MSG_IN;
226230
hdr->header.bTag = usbtmc_state.lastBulkInTag;
@@ -235,15 +239,15 @@ bool tud_usbtmc_transmit_dev_msg_data(
235239
len : (txBufLen - headerLen);
236240
const size_t packetLen = headerLen + dataLen;
237241

238-
memcpy((uint8_t*)(usbtmc_state.ep_bulk_in_buf) + headerLen, data, dataLen);
242+
memcpy((uint8_t*)(usbtmc_epbuf.epin) + headerLen, data, dataLen);
239243
usbtmc_state.transfer_size_remaining = len - dataLen;
240244
usbtmc_state.transfer_size_sent = dataLen;
241245
usbtmc_state.devInBuffer = (uint8_t const*) data + (dataLen);
242246

243247
bool stateChanged =
244248
atomicChangeState(STATE_TX_REQUESTED, (packetLen >= txBufLen) ? STATE_TX_INITIATED : STATE_TX_SHORTED);
245249
TU_VERIFY(stateChanged);
246-
TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf, (uint16_t)packetLen));
250+
TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t)packetLen));
247251
return true;
248252
}
249253

@@ -255,8 +259,8 @@ bool tud_usbtmc_transmit_notification_data(const void * data, size_t len)
255259
#endif
256260
TU_VERIFY(usbd_edpt_busy(usbtmc_state.rhport, usbtmc_state.ep_int_in));
257261

258-
TU_VERIFY(tu_memcpy_s(usbtmc_state.ep_int_in_buf, sizeof(usbtmc_state.ep_int_in_buf), data, len) == 0);
259-
TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_int_in, usbtmc_state.ep_int_in_buf, (uint16_t)len));
262+
TU_VERIFY(tu_memcpy_s(usbtmc_epbuf.epnotif, CFG_TUD_USBTMC_INT_EP_SIZE, data, len) == 0);
263+
TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_int_in, usbtmc_epbuf.epnotif, (uint16_t)len));
260264
return true;
261265
}
262266

@@ -396,7 +400,7 @@ bool tud_usbtmc_start_bus_read(void)
396400
default:
397401
return false;
398402
}
399-
TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_out, usbtmc_state.ep_bulk_out_buf, (uint16_t)usbtmc_state.ep_bulk_out_wMaxPacketSize));
403+
TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_out, usbtmc_epbuf.epout, (uint16_t)usbtmc_state.ep_bulk_out_wMaxPacketSize));
400404
return true;
401405
}
402406

@@ -501,7 +505,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
501505
case STATE_IDLE:
502506
{
503507
TU_VERIFY(xferred_bytes >= sizeof(usbtmc_msg_generic_t));
504-
msg = (usbtmc_msg_generic_t*)(usbtmc_state.ep_bulk_out_buf);
508+
msg = (usbtmc_msg_generic_t*)(usbtmc_epbuf.epout);
505509
uint8_t invInvTag = (uint8_t)~(msg->header.bTagInverse);
506510
TU_VERIFY(msg->header.bTag == invInvTag);
507511
TU_VERIFY(msg->header.bTag != 0x00);
@@ -536,7 +540,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
536540
return true;
537541
}
538542
case STATE_RCV:
539-
if(!handle_devMsgOut(rhport, usbtmc_state.ep_bulk_out_buf, xferred_bytes, xferred_bytes))
543+
if(!handle_devMsgOut(rhport, usbtmc_epbuf.epout, xferred_bytes, xferred_bytes))
540544
{
541545
usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
542546
return false;
@@ -565,24 +569,23 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
565569
break;
566570

567571
case STATE_TX_INITIATED:
568-
if(usbtmc_state.transfer_size_remaining >= sizeof(usbtmc_state.ep_bulk_in_buf))
572+
if(usbtmc_state.transfer_size_remaining >= USBTMCD_BUFFER_SIZE)
569573
{
570574
// Copy buffer to ensure alignment correctness
571-
memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, sizeof(usbtmc_state.ep_bulk_in_buf));
572-
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in,
573-
usbtmc_state.ep_bulk_in_buf, sizeof(usbtmc_state.ep_bulk_in_buf)));
574-
usbtmc_state.devInBuffer += sizeof(usbtmc_state.ep_bulk_in_buf);
575-
usbtmc_state.transfer_size_remaining -= sizeof(usbtmc_state.ep_bulk_in_buf);
576-
usbtmc_state.transfer_size_sent += sizeof(usbtmc_state.ep_bulk_in_buf);
575+
memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, USBTMCD_BUFFER_SIZE);
576+
TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, USBTMCD_BUFFER_SIZE));
577+
usbtmc_state.devInBuffer += USBTMCD_BUFFER_SIZE;
578+
usbtmc_state.transfer_size_remaining -= USBTMCD_BUFFER_SIZE;
579+
usbtmc_state.transfer_size_sent += USBTMCD_BUFFER_SIZE;
577580
}
578581
else // last packet
579582
{
580583
size_t packetLen = usbtmc_state.transfer_size_remaining;
581-
memcpy(usbtmc_state.ep_bulk_in_buf, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
584+
memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
582585
usbtmc_state.transfer_size_sent += sizeof(usbtmc_state.transfer_size_remaining);
583586
usbtmc_state.transfer_size_remaining = 0;
584587
usbtmc_state.devInBuffer = NULL;
585-
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf, (uint16_t)packetLen) );
588+
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t)packetLen) );
586589
if(((packetLen % usbtmc_state.ep_bulk_in_wMaxPacketSize) != 0) || (packetLen == 0 ))
587590
{
588591
usbtmc_state.state = STATE_TX_SHORTED;
@@ -592,7 +595,7 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
592595

593596
case STATE_ABORTING_BULK_IN:
594597
// need to send short packet (ZLP?)
595-
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,(uint16_t)0u));
598+
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin,(uint16_t)0u));
596599
usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
597600
return true;
598601

@@ -744,7 +747,7 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
744747
if(usbtmc_state.transfer_size_sent == 0)
745748
{
746749
// Send short packet, nothing is in the buffer yet
747-
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_state.ep_bulk_in_buf,(uint16_t)0u));
750+
TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin,(uint16_t)0u));
748751
usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
749752
}
750753
TU_VERIFY(tud_usbtmc_initiate_abort_bulk_in_cb(&(rsp.USBTMC_status)));

‎src/class/vendor/vendor_device.c‎

Lines changed: 36 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -40,16 +40,12 @@ typedef struct {
4040
uint8_t itf_num;
4141

4242
/*------------- From this point, data is not cleared by bus reset -------------*/
43-
// Endpoint Transfer buffer
44-
CFG_TUD_MEM_ALIGN uint8_t epout_buf[CFG_TUD_VENDOR_EPSIZE];
45-
CFG_TUD_MEM_ALIGN uint8_t epin_buf[CFG_TUD_VENDOR_EPSIZE];
46-
4743
struct {
4844
tu_edpt_stream_t stream;
4945
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
5046
uint8_t ff_buf[CFG_TUD_VENDOR_TX_BUFSIZE];
5147
#endif
52-
}tx;
48+
} tx;
5349

5450
struct {
5551
tu_edpt_stream_t stream;
@@ -60,10 +56,17 @@ typedef struct {
6056

6157
} vendord_interface_t;
6258

63-
CFG_TUD_MEM_SECTION static vendord_interface_t _vendord_itf[CFG_TUD_VENDOR];
64-
6559
#define ITF_MEM_RESET_SIZE (offsetof(vendord_interface_t, itf_num) + sizeof(((vendord_interface_t *)0)->itf_num))
6660

61+
static vendord_interface_t _vendord_itf[CFG_TUD_VENDOR];
62+
63+
typedef struct {
64+
TUD_EPBUF_DEF(epout, CFG_TUD_VENDOR_EPSIZE);
65+
TUD_EPBUF_DEF(epin, CFG_TUD_VENDOR_EPSIZE);
66+
} vendord_epbuf_t;
67+
68+
CFG_TUD_MEM_SECTION static vendord_epbuf_t _vendord_epbuf[CFG_TUD_VENDOR];
69+
6770
//--------------------------------------------------------------------
6871
// Application API
6972
//--------------------------------------------------------------------
@@ -94,15 +97,15 @@ bool tud_vendor_n_peek(uint8_t itf, uint8_t* u8) {
9497
uint32_t tud_vendor_n_read (uint8_t itf, void* buffer, uint32_t bufsize) {
9598
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
9699
vendord_interface_t* p_itf = &_vendord_itf[itf];
97-
uint8_t const rhport = 0;
100+
const uint8_t rhport = 0;
98101

99102
return tu_edpt_stream_read(rhport, &p_itf->rx.stream, buffer, bufsize);
100103
}
101104

102105
void tud_vendor_n_read_flush (uint8_t itf) {
103106
TU_VERIFY(itf < CFG_TUD_VENDOR, );
104107
vendord_interface_t* p_itf = &_vendord_itf[itf];
105-
uint8_t const rhport = 0;
108+
const uint8_t rhport = 0;
106109

107110
tu_edpt_stream_clear(&p_itf->rx.stream);
108111
tu_edpt_stream_read_xfer(rhport, &p_itf->rx.stream);
@@ -111,26 +114,26 @@ void tud_vendor_n_read_flush (uint8_t itf) {
111114
//--------------------------------------------------------------------+
112115
// Write API
113116
//--------------------------------------------------------------------+
114-
uint32_t tud_vendor_n_write (uint8_t itf, void const* buffer, uint32_t bufsize) {
117+
uint32_t tud_vendor_n_write (uint8_t itf, const void* buffer, uint32_t bufsize) {
115118
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
116119
vendord_interface_t* p_itf = &_vendord_itf[itf];
117-
uint8_t const rhport = 0;
120+
const uint8_t rhport = 0;
118121

119122
return tu_edpt_stream_write(rhport, &p_itf->tx.stream, buffer, (uint16_t) bufsize);
120123
}
121124

122125
uint32_t tud_vendor_n_write_flush (uint8_t itf) {
123126
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
124127
vendord_interface_t* p_itf = &_vendord_itf[itf];
125-
uint8_t const rhport = 0;
128+
const uint8_t rhport = 0;
126129

127130
return tu_edpt_stream_write_xfer(rhport, &p_itf->tx.stream);
128131
}
129132

130133
uint32_t tud_vendor_n_write_available (uint8_t itf) {
131134
TU_VERIFY(itf < CFG_TUD_VENDOR, 0);
132135
vendord_interface_t* p_itf = &_vendord_itf[itf];
133-
uint8_t const rhport = 0;
136+
const uint8_t rhport = 0;
134137

135138
return tu_edpt_stream_write_available(rhport, &p_itf->tx.stream);
136139
}
@@ -143,6 +146,7 @@ void vendord_init(void) {
143146

144147
for(uint8_t i=0; i<CFG_TUD_VENDOR; i++) {
145148
vendord_interface_t* p_itf = &_vendord_itf[i];
149+
vendord_epbuf_t* p_epbuf = &_vendord_epbuf[i];
146150

147151
uint8_t* rx_ff_buf =
148152
#if CFG_TUD_VENDOR_RX_BUFSIZE > 0
@@ -153,7 +157,7 @@ void vendord_init(void) {
153157

154158
tu_edpt_stream_init(&p_itf->rx.stream, false, false, false,
155159
rx_ff_buf, CFG_TUD_VENDOR_RX_BUFSIZE,
156-
p_itf->epout_buf, CFG_TUD_VENDOR_EPSIZE);
160+
p_epbuf->epout, CFG_TUD_VENDOR_EPSIZE);
157161

158162
uint8_t* tx_ff_buf =
159163
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
@@ -164,7 +168,7 @@ void vendord_init(void) {
164168

165169
tu_edpt_stream_init(&p_itf->tx.stream, false, true, false,
166170
tx_ff_buf, CFG_TUD_VENDOR_TX_BUFSIZE,
167-
p_itf->epin_buf, CFG_TUD_VENDOR_EPSIZE);
171+
p_epbuf->epin, CFG_TUD_VENDOR_EPSIZE);
168172
}
169173
}
170174

@@ -190,7 +194,7 @@ void vendord_reset(uint8_t rhport) {
190194
}
191195
}
192196

193-
uint16_t vendord_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t max_len) {
197+
uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint16_t max_len) {
194198
TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == desc_itf->bInterfaceClass, 0);
195199
const uint8_t* p_desc = tu_desc_next(desc_itf);
196200
const uint8_t* desc_end = p_desc + max_len;
@@ -237,35 +241,39 @@ uint16_t vendord_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, ui
237241
bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
238242
(void) result;
239243

240-
uint8_t itf = 0;
241-
vendord_interface_t* p_itf = _vendord_itf;
244+
uint8_t itf;
245+
vendord_interface_t* p_vendor;
242246

243-
for ( ; ; itf++, p_itf++) {
244-
if (itf >= CFG_TUD_VENDOR) return false;
245-
if ((ep_addr == p_itf->rx.stream.ep_addr) || (ep_addr == p_itf->tx.stream.ep_addr)) break;
247+
for (itf = 0; itf < CFG_TUD_VENDOR; itf++) {
248+
p_vendor = &_vendord_itf[itf];
249+
if ((ep_addr == p_vendor->rx.stream.ep_addr) || (ep_addr == p_vendor->tx.stream.ep_addr)) {
250+
break;
251+
}
246252
}
253+
TU_VERIFY(itf < CFG_TUD_VENDOR);
254+
vendord_epbuf_t* p_epbuf = &_vendord_epbuf[itf];
247255

248-
if ( ep_addr == p_itf->rx.stream.ep_addr ) {
256+
if ( ep_addr == p_vendor->rx.stream.ep_addr ) {
249257
// Received new data: put into stream's fifo
250-
tu_edpt_stream_read_xfer_complete(&p_itf->rx.stream, xferred_bytes);
258+
tu_edpt_stream_read_xfer_complete(&p_vendor->rx.stream, xferred_bytes);
251259

252260
// Invoked callback if any
253261
if (tud_vendor_rx_cb) {
254-
tud_vendor_rx_cb(itf, p_itf->epout_buf, (uint16_t) xferred_bytes);
262+
tud_vendor_rx_cb(itf, p_epbuf->epout, (uint16_t) xferred_bytes);
255263
}
256264

257-
tu_edpt_stream_read_xfer(rhport, &p_itf->rx.stream);
258-
} else if ( ep_addr == p_itf->tx.stream.ep_addr ) {
265+
tu_edpt_stream_read_xfer(rhport, &p_vendor->rx.stream);
266+
} else if ( ep_addr == p_vendor->tx.stream.ep_addr ) {
259267
// Send complete
260268
if (tud_vendor_tx_cb) {
261269
tud_vendor_tx_cb(itf, (uint16_t) xferred_bytes);
262270
}
263271

264272
#if CFG_TUD_VENDOR_TX_BUFSIZE > 0
265273
// try to send more if possible
266-
if ( 0 == tu_edpt_stream_write_xfer(rhport, &p_itf->tx.stream) ) {
274+
if ( 0 == tu_edpt_stream_write_xfer(rhport, &p_vendor->tx.stream) ) {
267275
// If there is no data left, a ZLP should be sent if xferred_bytes is multiple of EP Packet size and not zero
268-
tu_edpt_stream_write_zlp_if_needed(rhport, &p_itf->tx.stream, xferred_bytes);
276+
tu_edpt_stream_write_zlp_if_needed(rhport, &p_vendor->tx.stream, xferred_bytes);
269277
}
270278
#endif
271279
}

0 commit comments

Comments
 (0)