summaryrefslogtreecommitdiff
path: root/src/class/midi/midi_device.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/class/midi/midi_device.c')
-rw-r--r--src/class/midi/midi_device.c609
1 files changed, 310 insertions, 299 deletions
diff --git a/src/class/midi/midi_device.c b/src/class/midi/midi_device.c
index 7dac7c4a5..de4ff5dd8 100644
--- a/src/class/midi/midi_device.c
+++ b/src/class/midi/midi_device.c
@@ -26,7 +26,7 @@
#include "tusb_option.h"
-#if (CFG_TUD_ENABLED && CFG_TUD_MIDI)
+#if CFG_TUD_ENABLED && CFG_TUD_MIDI
//--------------------------------------------------------------------+
// INCLUDE
@@ -37,12 +37,18 @@
#include "midi_device.h"
//--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_midi_rx_cb(uint8_t itf) {
+ (void)itf;
+}
+
+//--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+
typedef struct {
+ uint8_t rhport;
uint8_t itf_num;
- uint8_t ep_in;
- uint8_t ep_out;
// For Stream read()/write() API
// Messages are always 4 bytes long, queue them for reading and writing so the
@@ -51,134 +57,98 @@ typedef struct {
midi_driver_stream_t stream_read;
/*------------- From this point, data is not cleared by bus reset -------------*/
- // FIFO
- tu_fifo_t rx_ff;
- tu_fifo_t tx_ff;
- uint8_t rx_ff_buf[CFG_TUD_MIDI_RX_BUFSIZE];
- uint8_t tx_ff_buf[CFG_TUD_MIDI_TX_BUFSIZE];
+ // Endpoint stream
+ struct {
+ tu_edpt_stream_t tx;
+ tu_edpt_stream_t rx;
- #if CFG_FIFO_MUTEX
- osal_mutex_def_t rx_ff_mutex;
- osal_mutex_def_t tx_ff_mutex;
- #endif
+ uint8_t rx_ff_buf[CFG_TUD_MIDI_RX_BUFSIZE];
+ uint8_t tx_ff_buf[CFG_TUD_MIDI_TX_BUFSIZE];
+ } ep_stream;
} midid_interface_t;
-#define ITF_MEM_RESET_SIZE offsetof(midid_interface_t, rx_ff)
+#define ITF_MEM_RESET_SIZE offsetof(midid_interface_t, ep_stream)
-// Endpoint Transfer buffer
-CFG_TUD_MEM_SECTION static struct {
- TUD_EPBUF_DEF(epin, CFG_TUD_MIDI_EP_BUFSIZE);
- TUD_EPBUF_DEF(epout, CFG_TUD_MIDI_EP_BUFSIZE);
-} _midid_epbuf[CFG_TUD_MIDI];
-
-//--------------------------------------------------------------------+
-// INTERNAL OBJECT & FUNCTION DECLARATION
-//--------------------------------------------------------------------+
static midid_interface_t _midid_itf[CFG_TUD_MIDI];
-bool tud_midi_n_mounted (uint8_t itf) {
- midid_interface_t* midi = &_midid_itf[itf];
- return midi->ep_in && midi->ep_out;
-}
-
-static void _prep_out_transaction(uint8_t idx) {
- const uint8_t rhport = 0;
- midid_interface_t* p_midi = &_midid_itf[idx];
- uint16_t available = tu_fifo_remaining(&p_midi->rx_ff);
-
- // Prepare for incoming data but only allow what we can store in the ring buffer.
- // TODO Actually we can still carry out the transfer, keeping count of received bytes
- // and slowly move it to the FIFO when read().
- // This pre-check reduces endpoint claiming
- TU_VERIFY(available >= CFG_TUD_MIDI_EP_BUFSIZE, );
-
- // claim endpoint
- TU_VERIFY(usbd_edpt_claim(rhport, p_midi->ep_out), );
-
- // fifo can be changed before endpoint is claimed
- available = tu_fifo_remaining(&p_midi->rx_ff);
-
- if ( available >= CFG_TUD_MIDI_EP_BUFSIZE ) {
- usbd_edpt_xfer(rhport, p_midi->ep_out, _midid_epbuf[idx].epout, CFG_TUD_MIDI_EP_BUFSIZE);
- }else
- {
- // Release endpoint since we don't make any transfer
- usbd_edpt_release(rhport, p_midi->ep_out);
- }
-}
+ #if CFG_TUD_EDPT_DEDICATED_HWFIFO == 0
+// Endpoint Transfer buffer: not used if dedicated hw FIFO is available
+typedef struct {
+ TUD_EPBUF_DEF(epin, CFG_TUD_MIDI_TX_EPSIZE);
+ TUD_EPBUF_DEF(epout, CFG_TUD_MIDI_RX_EPSIZE);
+} midid_epbuf_t;
+CFG_TUD_MEM_SECTION static midid_epbuf_t _midid_epbuf[CFG_TUD_MIDI];
+ #endif
//--------------------------------------------------------------------+
-// Weak stubs: invoked if no strong implementation is available
+// INTERNAL OBJECT & FUNCTION DECLARATION
//--------------------------------------------------------------------+
-TU_ATTR_WEAK void tud_midi_rx_cb(uint8_t itf) {
- (void) itf;
+bool tud_midi_n_mounted (uint8_t itf) {
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ const bool tx_opened = tu_edpt_stream_is_opened(&p_midi->ep_stream.tx);
+ const bool rx_opened = tu_edpt_stream_is_opened(&p_midi->ep_stream.rx);
+ return tx_opened && rx_opened;
}
//--------------------------------------------------------------------+
// READ API
//--------------------------------------------------------------------+
-uint32_t tud_midi_n_available(uint8_t itf, uint8_t cable_num)
-{
+uint32_t tud_midi_n_available(uint8_t itf, uint8_t cable_num) {
(void) cable_num;
-
- midid_interface_t* midi = &_midid_itf[itf];
- const midi_driver_stream_t* stream = &midi->stream_read;
+ const midid_interface_t *p_midi = &_midid_itf[itf];
+ const midi_driver_stream_t *stream = &p_midi->stream_read;
+ const tu_edpt_stream_t *ep_str = &p_midi->ep_stream.rx;
// when using with packet API stream total & index are both zero
- return tu_fifo_count(&midi->rx_ff) + (uint8_t) (stream->total - stream->index);
+ return tu_edpt_stream_read_available(ep_str) + (uint8_t)(stream->total - stream->index);
}
-uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void* buffer, uint32_t bufsize)
-{
+uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void *buffer, uint32_t bufsize) {
(void) cable_num;
- TU_VERIFY(bufsize, 0);
-
- uint8_t* buf8 = (uint8_t*) buffer;
+ TU_VERIFY(buffer != NULL && bufsize > 0, 0);
- midid_interface_t* midi = &_midid_itf[itf];
- midi_driver_stream_t* stream = &midi->stream_read;
+ uint8_t *buf8 = (uint8_t *)buffer;
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ midi_driver_stream_t *stream = &p_midi->stream_read;
uint32_t total_read = 0;
- while( bufsize )
- {
+ while (bufsize > 0) {
// Get new packet from fifo, then set packet expected bytes
- if ( stream->total == 0 )
- {
- // return if there is no more data from fifo
- if ( !tud_midi_n_packet_read(itf, stream->buffer) ) return total_read;
+ if (stream->total == 0) {
+ if (!tud_midi_n_packet_read(itf, stream->buffer)) {
+ return total_read; // return if there is no more data from fifo
+ }
- uint8_t const code_index = stream->buffer[0] & 0x0f;
+ const uint8_t code_index = stream->buffer[0] & 0x0f;
// MIDI 1.0 Table 4-1: Code Index Number Classifications
- switch(code_index)
- {
+ switch (code_index) {
case MIDI_CIN_MISC:
case MIDI_CIN_CABLE_EVENT:
// These are reserved and unused, possibly issue somewhere, skip this packet
return 0;
- break;
case MIDI_CIN_SYSEX_END_1BYTE:
case MIDI_CIN_1BYTE_DATA:
stream->total = 1;
- break;
+ break;
case MIDI_CIN_SYSCOM_2BYTE :
case MIDI_CIN_SYSEX_END_2BYTE :
case MIDI_CIN_PROGRAM_CHANGE :
case MIDI_CIN_CHANNEL_PRESSURE :
stream->total = 2;
- break;
+ break;
default:
stream->total = 3;
- break;
+ break;
}
}
// Copy data up to bufsize
- uint8_t const count = (uint8_t) tu_min32(stream->total - stream->index, bufsize);
+ const uint8_t count = (uint8_t)tu_min32((uint32_t)(stream->total - stream->index), bufsize);
// Skip the header (1st byte) in the buffer
TU_VERIFY(0 == tu_memcpy_s(buf8, bufsize, stream->buffer + 1 + stream->index, count));
@@ -189,8 +159,7 @@ uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void* buffer, ui
bufsize -= count;
// complete current event packet, reset stream
- if ( stream->total == stream->index )
- {
+ if (stream->total == stream->index) {
stream->index = 0;
stream->total = 0;
}
@@ -199,150 +168,206 @@ uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void* buffer, ui
return total_read;
}
-bool tud_midi_n_packet_read (uint8_t itf, uint8_t packet[4])
-{
- midid_interface_t* midi = &_midid_itf[itf];
- TU_VERIFY(midi->ep_out);
+// Note: this function shares stream->buffer with tud_midi_n_stream_read().
+// Do not mix calls to both functions on the same interface.
+uint32_t tud_midi_n_demux_stream_read(uint8_t itf, uint8_t *p_cable_num, void *buffer, uint32_t bufsize) {
+ TU_VERIFY(p_cable_num != NULL && buffer != NULL && bufsize > 0, 0);
- const uint32_t num_read = tu_fifo_read_n(&midi->rx_ff, packet, 4);
- _prep_out_transaction(itf);
- return (num_read == 4);
-}
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ midi_driver_stream_t *stream = &p_midi->stream_read;
+ tu_edpt_stream_t *ep_str = &p_midi->ep_stream.rx;
-//--------------------------------------------------------------------+
-// WRITE API
-//--------------------------------------------------------------------+
+ uint8_t *buf8 = (uint8_t *)buffer;
+ uint32_t total_read = 0;
-static uint32_t write_flush(uint8_t idx) {
- midid_interface_t* midi = &_midid_itf[idx];
+ // Initialize to invalid cable so callers can detect "no data" even when
+ // the return value is 0.
+ *p_cable_num = 0xff;
- if (!tu_fifo_count(&midi->tx_ff)) {
- return 0; // No data to send
+ // If there are leftover bytes from a previous partial read, return them first
+ if (stream->total > 0) {
+ *p_cable_num = (stream->buffer[0] >> 4) & 0x0f;
+ const uint8_t count = (uint8_t)tu_min32((uint32_t)(stream->total - stream->index), bufsize);
+ TU_VERIFY(0 == tu_memcpy_s(buf8, bufsize, stream->buffer + 1 + stream->index, count));
+
+ total_read += count;
+ stream->index += count;
+ buf8 += count;
+ bufsize -= count;
+
+ if (stream->total == stream->index) {
+ stream->index = 0;
+ stream->total = 0;
+ }
+
+ if (bufsize == 0) {
+ return total_read;
+ }
}
- const uint8_t rhport = 0;
+ while (bufsize > 0) {
+ // Peek at next packet header to get cable number without consuming
+ uint8_t one_byte;
+ if (!tu_edpt_stream_peek(ep_str, &one_byte)) {
+ break;
+ }
+
+ const uint8_t next_cable = (one_byte >> 4) & 0x0f;
+
+ // Stop if cable changed (covers both leftover-originated reads and
+ // freshly consumed packets — total_read > 0 in either case)
+ if (total_read > 0 && next_cable != *p_cable_num) {
+ break;
+ }
+ *p_cable_num = next_cable;
+
+ // Consume the packet
+ if (!tud_midi_n_packet_read(itf, stream->buffer)) {
+ break;
+ }
+
+ const uint8_t code_index = stream->buffer[0] & 0x0f;
+ uint8_t msg_bytes;
+
+ // MIDI 1.0 Table 4-1: Code Index Number Classifications
+ switch (code_index) {
+ case MIDI_CIN_MISC:
+ case MIDI_CIN_CABLE_EVENT:
+ // Reserved and unused, skip this packet
+ continue;
+
+ case MIDI_CIN_SYSEX_END_1BYTE:
+ case MIDI_CIN_1BYTE_DATA:
+ msg_bytes = 1;
+ break;
+
+ case MIDI_CIN_SYSCOM_2BYTE:
+ case MIDI_CIN_SYSEX_END_2BYTE:
+ case MIDI_CIN_PROGRAM_CHANGE:
+ case MIDI_CIN_CHANNEL_PRESSURE:
+ msg_bytes = 2;
+ break;
+
+ default:
+ msg_bytes = 3;
+ break;
+ }
- // skip if previous transfer not complete
- TU_VERIFY( usbd_edpt_claim(rhport, midi->ep_in), 0 );
+ const uint8_t count = (uint8_t)tu_min32((uint32_t)msg_bytes, bufsize);
+ TU_VERIFY(0 == tu_memcpy_s(buf8, bufsize, stream->buffer + 1, count));
- uint16_t count = tu_fifo_read_n(&midi->tx_ff, _midid_epbuf[idx].epin, CFG_TUD_MIDI_EP_BUFSIZE);
+ total_read += count;
+ buf8 += count;
+ bufsize -= count;
- if (count) {
- TU_ASSERT( usbd_edpt_xfer(rhport, midi->ep_in, _midid_epbuf[idx].epin, count), 0 );
- return count;
- }else {
- // Release endpoint since we don't make any transfer
- usbd_edpt_release(rhport, midi->ep_in);
- return 0;
+ if (count < msg_bytes) {
+ // Output buffer full, save remaining for next call
+ stream->total = msg_bytes;
+ stream->index = count;
+ }
}
+
+ return total_read;
}
-uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t* buffer, uint32_t bufsize)
-{
- midid_interface_t* midi = &_midid_itf[itf];
- TU_VERIFY(midi->ep_in, 0);
+bool tud_midi_n_packet_read(uint8_t itf, uint8_t packet[4]) {
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ tu_edpt_stream_t *ep_str = &p_midi->ep_stream.rx;
+ return 4 == tu_edpt_stream_read(ep_str, packet, 4);
+}
- midi_driver_stream_t* stream = &midi->stream_write;
+uint32_t tud_midi_n_packet_read_n(uint8_t itf, uint8_t packets[], uint32_t max_packets) {
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ tu_edpt_stream_t *ep_str = &p_midi->ep_stream.rx;
+ const uint32_t num_read = tu_edpt_stream_read(ep_str, packets, 4u * max_packets);
+ return num_read >> 2u;
+}
+
+//--------------------------------------------------------------------+
+// WRITE API
+//--------------------------------------------------------------------+
+uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t *buffer, uint32_t bufsize) {
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ midi_driver_stream_t *stream = &p_midi->stream_write;
+ tu_edpt_stream_t *ep_str = &p_midi->ep_stream.tx;
+ TU_VERIFY(tu_edpt_stream_is_opened(ep_str), 0);
uint32_t i = 0;
- while ( (i < bufsize) && (tu_fifo_remaining(&midi->tx_ff) >= 4) )
- {
+ while (i < bufsize) {
+ if (tu_edpt_stream_write_available(ep_str) < 4) {
+ break;
+ }
+
const uint8_t data = buffer[i];
i++;
- if ( stream->index == 0 )
- {
+ if (stream->index == 0) {
//------------- New event packet -------------//
const uint8_t msg = data >> 4;
- stream->index = 2;
+ stream->index = 2;
stream->buffer[1] = data;
// Check to see if we're still in a SysEx transmit.
- if ( ((stream->buffer[0]) & 0xF) == MIDI_CIN_SYSEX_START )
- {
- if ( data == MIDI_STATUS_SYSEX_END )
- {
- stream->buffer[0] = (uint8_t) ((cable_num << 4) | MIDI_CIN_SYSEX_END_1BYTE);
- stream->total = 2;
- }
- else
- {
+ if (((stream->buffer[0]) & 0xF) == MIDI_CIN_SYSEX_START) {
+ if (data == MIDI_STATUS_SYSEX_END) {
+ stream->buffer[0] = (uint8_t)((cable_num << 4) | MIDI_CIN_SYSEX_END_1BYTE);
+ stream->total = 2;
+ } else {
stream->total = 4;
}
- }
- else if ( (msg >= 0x8 && msg <= 0xB) || msg == 0xE )
- {
+ } else if ((msg >= 0x8 && msg <= 0xB) || msg == 0xE) {
// Channel Voice Messages
- stream->buffer[0] = (uint8_t) ((cable_num << 4) | msg);
- stream->total = 4;
- }
- else if ( msg == 0xC || msg == 0xD)
- {
+ stream->buffer[0] = (uint8_t)((cable_num << 4) | msg);
+ stream->total = 4;
+ } else if (msg == 0xC || msg == 0xD) {
// Channel Voice Messages, two-byte variants (Program Change and Channel Pressure)
- stream->buffer[0] = (uint8_t) ((cable_num << 4) | msg);
- stream->total = 3;
- }
- else if ( msg == 0xf )
- {
+ stream->buffer[0] = (uint8_t)((cable_num << 4) | msg);
+ stream->total = 3;
+ } else if (msg == 0xf) {
// System message
- if ( data == MIDI_STATUS_SYSEX_START )
- {
+ if (data == MIDI_STATUS_SYSEX_START) {
stream->buffer[0] = MIDI_CIN_SYSEX_START;
- stream->total = 4;
- }
- else if ( data == MIDI_STATUS_SYSCOM_TIME_CODE_QUARTER_FRAME || data == MIDI_STATUS_SYSCOM_SONG_SELECT )
- {
+ stream->total = 4;
+ } else if (data == MIDI_STATUS_SYSCOM_TIME_CODE_QUARTER_FRAME || data == MIDI_STATUS_SYSCOM_SONG_SELECT) {
stream->buffer[0] = MIDI_CIN_SYSCOM_2BYTE;
- stream->total = 3;
- }
- else if ( data == MIDI_STATUS_SYSCOM_SONG_POSITION_POINTER )
- {
+ stream->total = 3;
+ } else if (data == MIDI_STATUS_SYSCOM_SONG_POSITION_POINTER) {
stream->buffer[0] = MIDI_CIN_SYSCOM_3BYTE;
- stream->total = 4;
- }
- else
- {
+ stream->total = 4;
+ } else {
stream->buffer[0] = MIDI_CIN_SYSEX_END_1BYTE;
- stream->total = 2;
+ stream->total = 2;
}
stream->buffer[0] |= (uint8_t)(cable_num << 4);
- }
- else
- {
+ } else {
// Pack individual bytes if we don't support packing them into words.
- stream->buffer[0] = (uint8_t) (cable_num << 4 | 0xf);
+ stream->buffer[0] = (uint8_t)(cable_num << 4 | 0xf);
stream->buffer[2] = 0;
stream->buffer[3] = 0;
- stream->index = 2;
- stream->total = 2;
+ stream->total = 2; // index already set to 2
}
- }
- else
- {
+ } else {
//------------- On-going (buffering) packet -------------//
-
TU_ASSERT(stream->index < 4, i);
stream->buffer[stream->index] = data;
stream->index++;
// See if this byte ends a SysEx.
- if ( (stream->buffer[0] & 0xF) == MIDI_CIN_SYSEX_START && data == MIDI_STATUS_SYSEX_END )
- {
- stream->buffer[0] = (uint8_t) ((cable_num << 4) | (MIDI_CIN_SYSEX_START + (stream->index - 1)));
- stream->total = stream->index;
+ if ((stream->buffer[0] & 0xF) == MIDI_CIN_SYSEX_START && data == MIDI_STATUS_SYSEX_END) {
+ stream->buffer[0] = (uint8_t)((cable_num << 4) | (MIDI_CIN_SYSEX_START + (stream->index - 1)));
+ stream->total = stream->index;
}
}
// Send out packet
- if ( stream->index == stream->total )
- {
+ if (stream->index == stream->total) {
// zeroes unused bytes
for (uint8_t idx = stream->total; idx < 4; idx++) {
stream->buffer[idx] = 0;
}
- const uint16_t count = tu_fifo_write_n(&midi->tx_ff, stream->buffer, 4);
+ const uint32_t count = tu_edpt_stream_write(ep_str, stream->buffer, 4);
// complete current event packet, reset stream
stream->index = stream->total = 0;
@@ -352,98 +377,107 @@ uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t*
}
}
- write_flush(itf);
+ (void)tu_edpt_stream_write_xfer(ep_str);
return i;
}
bool tud_midi_n_packet_write (uint8_t itf, const uint8_t packet[4]) {
- midid_interface_t* midi = &_midid_itf[itf];
- TU_VERIFY(midi->ep_in);
-
- if (tu_fifo_remaining(&midi->tx_ff) < 4) {
- return false;
- }
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ tu_edpt_stream_t *ep_str = &p_midi->ep_stream.tx;
+ TU_VERIFY(tu_edpt_stream_is_opened(ep_str));
- tu_fifo_write_n(&midi->tx_ff, packet, 4);
- write_flush(itf);
+ TU_VERIFY(tu_edpt_stream_write_available(ep_str) >= 4);
+ TU_VERIFY(tu_edpt_stream_write(ep_str, packet, 4) > 0);
+ (void)tu_edpt_stream_write_xfer(ep_str);
return true;
}
+uint32_t tud_midi_n_packet_write_n(uint8_t itf, const uint8_t packets[], uint32_t n_packets) {
+ midid_interface_t *p_midi = &_midid_itf[itf];
+ tu_edpt_stream_t *ep_str = &p_midi->ep_stream.tx;
+ TU_VERIFY(tu_edpt_stream_is_opened(ep_str), 0);
+
+ uint32_t n_bytes = tu_edpt_stream_write_available(ep_str);
+ n_bytes = tu_min32(tu_align4(n_bytes), n_packets << 2u);
+
+ const uint32_t n_write = tu_edpt_stream_write(ep_str, packets, n_bytes);
+ (void)tu_edpt_stream_write_xfer(ep_str);
+
+ return n_write >> 2u;
+}
+
//--------------------------------------------------------------------+
// USBD Driver API
//--------------------------------------------------------------------+
void midid_init(void) {
tu_memclr(_midid_itf, sizeof(_midid_itf));
-
for (uint8_t i = 0; i < CFG_TUD_MIDI; i++) {
- midid_interface_t* midi = &_midid_itf[i];
+ midid_interface_t *p_midi = &_midid_itf[i];
- // config fifo
- tu_fifo_config(&midi->rx_ff, midi->rx_ff_buf, CFG_TUD_MIDI_RX_BUFSIZE, 1, false); // true, true
- tu_fifo_config(&midi->tx_ff, midi->tx_ff_buf, CFG_TUD_MIDI_TX_BUFSIZE, 1, false); // OBVS.
+ #if CFG_TUD_EDPT_DEDICATED_HWFIFO
+ uint8_t *epout_buf = NULL;
+ uint8_t *epin_buf = NULL;
+ #else
+ midid_epbuf_t *p_epbuf = &_midid_epbuf[i];
+ uint8_t *epout_buf = p_epbuf->epout;
+ uint8_t *epin_buf = p_epbuf->epin;
+ #endif
- #if CFG_FIFO_MUTEX
- osal_mutex_t mutex_rd = osal_mutex_create(&midi->rx_ff_mutex);
- osal_mutex_t mutex_wr = osal_mutex_create(&midi->tx_ff_mutex);
- TU_ASSERT(mutex_wr != NULL && mutex_wr != NULL, );
+ tu_edpt_stream_init(&p_midi->ep_stream.rx, false, false, false, p_midi->ep_stream.rx_ff_buf,
+ CFG_TUD_MIDI_RX_BUFSIZE, epout_buf);
- tu_fifo_config_mutex(&midi->rx_ff, NULL, mutex_rd);
- tu_fifo_config_mutex(&midi->tx_ff, mutex_wr, NULL);
- #endif
+ tu_edpt_stream_init(&p_midi->ep_stream.tx, false, true, false, p_midi->ep_stream.tx_ff_buf, CFG_TUD_MIDI_TX_BUFSIZE,
+ epin_buf);
}
}
bool midid_deinit(void) {
- #if CFG_FIFO_MUTEX
- for(uint8_t i=0; i<CFG_TUD_MIDI; i++) {
- midid_interface_t* midi = &_midid_itf[i];
- osal_mutex_t mutex_rd = midi->rx_ff.mutex_rd;
- osal_mutex_t mutex_wr = midi->tx_ff.mutex_wr;
-
- if (mutex_rd) {
- osal_mutex_delete(mutex_rd);
- tu_fifo_config_mutex(&midi->rx_ff, NULL, NULL);
- }
-
- if (mutex_wr) {
- osal_mutex_delete(mutex_wr);
- tu_fifo_config_mutex(&midi->tx_ff, NULL, NULL);
- }
+ for (uint8_t i = 0; i < CFG_TUD_MIDI; i++) {
+ midid_interface_t *p_midi = &_midid_itf[i];
+ tu_edpt_stream_deinit(&p_midi->ep_stream.rx);
+ tu_edpt_stream_deinit(&p_midi->ep_stream.tx);
}
- #endif
-
return true;
}
-void midid_reset(uint8_t rhport)
-{
- (void) rhport;
+void midid_reset(uint8_t rhport) {
+ (void)rhport;
+ for (uint8_t i = 0; i < CFG_TUD_MIDI; i++) {
+ midid_interface_t *p_midi = &_midid_itf[i];
+ tu_memclr(p_midi, ITF_MEM_RESET_SIZE);
+
+ tu_edpt_stream_clear(&p_midi->ep_stream.rx);
+ tu_edpt_stream_close(&p_midi->ep_stream.rx);
+
+ tu_edpt_stream_clear(&p_midi->ep_stream.tx);
+ tu_edpt_stream_close(&p_midi->ep_stream.tx);
+ }
+}
- for(uint8_t i=0; i<CFG_TUD_MIDI; i++)
- {
- midid_interface_t* midi = &_midid_itf[i];
- tu_memclr(midi, ITF_MEM_RESET_SIZE);
- tu_fifo_clear(&midi->rx_ff);
- tu_fifo_clear(&midi->tx_ff);
+TU_ATTR_ALWAYS_INLINE static inline uint8_t find_midi_itf(uint8_t ep_addr) {
+ for (uint8_t idx = 0; idx < CFG_TUD_MIDI; idx++) {
+ const midid_interface_t *p_midi = &_midid_itf[idx];
+ if (ep_addr == p_midi->ep_stream.rx.ep_addr || ep_addr == p_midi->ep_stream.tx.ep_addr) {
+ return idx;
+ }
}
+ return TUSB_INDEX_INVALID_8;
}
-uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint16_t max_len) {
- uint16_t drv_len = 0;
- uint8_t const * p_desc = (uint8_t const *)desc_itf;
+uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t *desc_itf, uint16_t max_len) {
+ const uint8_t *p_desc = (const uint8_t *)desc_itf;
+ const uint8_t *desc_end = p_desc + max_len;
// 1st Interface is Audio Control v1 (optional)
if (TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass &&
AUDIO_SUBCLASS_CONTROL == desc_itf->bInterfaceSubClass &&
AUDIO_FUNC_PROTOCOL_CODE_UNDEF == desc_itf->bInterfaceProtocol) {
- drv_len = tu_desc_len(desc_itf);
p_desc = tu_desc_next(desc_itf);
// Skip Class Specific descriptors
- while (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc) && drv_len <= max_len) {
- drv_len += tu_desc_len(p_desc);
- p_desc = tu_desc_next(p_desc);
+ while (tu_desc_in_bounds(p_desc, desc_end) && TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc)) {
+ p_desc = tu_desc_next(p_desc);
}
}
@@ -451,59 +485,48 @@ uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint1
TU_VERIFY(TUSB_DESC_INTERFACE == tu_desc_type(p_desc), 0);
const tusb_desc_interface_t* desc_midi = (const tusb_desc_interface_t*) p_desc;
- TU_VERIFY(TUSB_CLASS_AUDIO == desc_midi->bInterfaceClass &&
- AUDIO_SUBCLASS_MIDI_STREAMING == desc_midi->bInterfaceSubClass &&
- AUDIO_FUNC_PROTOCOL_CODE_UNDEF == desc_midi->bInterfaceProtocol, 0);
+ TU_VERIFY(TUSB_CLASS_AUDIO == desc_midi->bInterfaceClass &&
+ AUDIO_SUBCLASS_MIDI_STREAMING == desc_midi->bInterfaceSubClass &&
+ AUDIO_FUNC_PROTOCOL_CODE_UNDEF == desc_midi->bInterfaceProtocol,
+ 0);
- // Find available interface
- midid_interface_t * p_midi = NULL;
- uint8_t idx;
- for(idx=0; idx<CFG_TUD_MIDI; idx++) {
- if ( _midid_itf[idx].ep_in == 0 && _midid_itf[idx].ep_out == 0 ) {
- p_midi = &_midid_itf[idx];
- break;
- }
- }
- TU_ASSERT(p_midi);
+ uint8_t idx = find_midi_itf(0); // find unused interface
+ TU_ASSERT(idx < CFG_TUD_MIDI, 0);
+ midid_interface_t *p_midi = &_midid_itf[idx];
+ p_midi->rhport = rhport;
p_midi->itf_num = desc_midi->bInterfaceNumber;
(void) p_midi->itf_num;
- // next descriptor
- drv_len += tu_desc_len(p_desc);
- p_desc = tu_desc_next(p_desc);
+ p_desc = tu_desc_next(p_desc);
// Find and open endpoint descriptors
- uint8_t found_endpoints = 0;
- while ( (found_endpoints < desc_midi->bNumEndpoints) && (drv_len <= max_len) )
- {
- if ( TUSB_DESC_ENDPOINT == tu_desc_type(p_desc) )
- {
- TU_ASSERT(usbd_edpt_open(rhport, (const tusb_desc_endpoint_t*) p_desc), 0);
- uint8_t ep_addr = ((const tusb_desc_endpoint_t*) p_desc)->bEndpointAddress;
+ uint8_t found_ep = 0;
+ while ((found_ep < desc_midi->bNumEndpoints) && tu_desc_in_bounds(p_desc, desc_end)) {
+ if (TUSB_DESC_ENDPOINT == tu_desc_type(p_desc)) {
+ const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)p_desc;
+ TU_ASSERT(usbd_edpt_open(rhport, desc_ep), 0);
+ const uint8_t ep_addr = ((const tusb_desc_endpoint_t *)p_desc)->bEndpointAddress;
- if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN)
- {
- p_midi->ep_in = ep_addr;
+ if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) {
+ tu_edpt_stream_t *stream_tx = &p_midi->ep_stream.tx;
+ tu_edpt_stream_open(stream_tx, rhport, desc_ep, CFG_TUD_MIDI_TX_EPSIZE);
+ tu_edpt_stream_clear(stream_tx);
} else {
- p_midi->ep_out = ep_addr;
+ tu_edpt_stream_t *stream_rx = &p_midi->ep_stream.rx;
+ tu_edpt_stream_open(stream_rx, rhport, desc_ep, tu_edpt_packet_size(desc_ep));
+ tu_edpt_stream_clear(stream_rx);
+ TU_ASSERT(tu_edpt_stream_read_xfer(stream_rx) > 0, 0); // prepare to receive data
}
- // Class Specific MIDI Stream endpoint descriptor
- drv_len += tu_desc_len(p_desc);
- p_desc = tu_desc_next(p_desc);
-
- found_endpoints += 1;
+ p_desc = tu_desc_next(p_desc); // skip CS Endpoint descriptor
+ found_ep++;
}
- drv_len += tu_desc_len(p_desc);
- p_desc = tu_desc_next(p_desc);
+ p_desc = tu_desc_next(p_desc);
}
- // Prepare for incoming data
- _prep_out_transaction(idx);
-
- return drv_len;
+ return (uint16_t)(p_desc - (const uint8_t *)desc_itf);
}
// Invoked when a control transfer occurred on an interface of this class
@@ -514,44 +537,32 @@ bool midid_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_req
return false; // driver doesn't support any request yet
}
-bool midid_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
-{
- (void) result;
- (void) rhport;
-
- uint8_t idx;
- midid_interface_t* p_midi;
+bool midid_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
+ (void)rhport;
+ (void)result;
- // Identify which interface to use
- for (idx = 0; idx < CFG_TUD_MIDI; idx++) {
- p_midi = &_midid_itf[idx];
- if ((ep_addr == p_midi->ep_out) || (ep_addr == p_midi->ep_in)) {
- break;
- }
- }
+ uint8_t idx = find_midi_itf(ep_addr);
TU_ASSERT(idx < CFG_TUD_MIDI);
+ midid_interface_t *p_midi = &_midid_itf[idx];
- // receive new data
- if (ep_addr == p_midi->ep_out) {
- tu_fifo_write_n(&p_midi->rx_ff, _midid_epbuf[idx].epout, (uint16_t)xferred_bytes);
-
- // invoke receive callback if available
- tud_midi_rx_cb(idx);
+ tu_edpt_stream_t *ep_st_rx = &p_midi->ep_stream.rx;
+ tu_edpt_stream_t *ep_st_tx = &p_midi->ep_stream.tx;
- // prepare for next
- // TODO for now ep_out is not used by public API therefore there is no race condition,
- // and does not need to claim like ep_in
- _prep_out_transaction(idx);
- } else if (ep_addr == p_midi->ep_in) {
- if (0 == write_flush(idx)) {
- // If there is no data left, a ZLP should be sent if
- // xferred_bytes is multiple of EP size and not zero
- if (!tu_fifo_count(&p_midi->tx_ff) && xferred_bytes && (0 == (xferred_bytes % CFG_TUD_MIDI_EP_BUFSIZE))) {
- if (usbd_edpt_claim(rhport, p_midi->ep_in)) {
- usbd_edpt_xfer(rhport, p_midi->ep_in, NULL, 0);
- }
- }
+ if (ep_addr == ep_st_rx->ep_addr) {
+ // Received new data: put into stream's fifo
+ if (result == XFER_RESULT_SUCCESS) {
+ tu_edpt_stream_read_xfer_complete(ep_st_rx, xferred_bytes);
+ tud_midi_rx_cb(idx); // invoke callback
}
+ tu_edpt_stream_read_xfer(ep_st_rx); // prepare for next data
+ } else if (ep_addr == ep_st_tx->ep_addr && result == XFER_RESULT_SUCCESS) {
+ // sent complete: try to send more if possible
+ if (0 == tu_edpt_stream_write_xfer(ep_st_tx)) {
+ // If there is no data left, a ZLP should be sent if needed
+ (void)tu_edpt_stream_write_zlp_if_needed(ep_st_tx, xferred_bytes);
+ }
+ } else {
+ return false;
}
return true;
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-23 23:43:45 +0000