|
|
@@ -0,0 +1,412 @@
|
|
|
+/**************************************************************************/
|
|
|
+/*!
|
|
|
+ @file cdc_device.c
|
|
|
+ @author hathach (tinyusb.org)
|
|
|
+
|
|
|
+ @section LICENSE
|
|
|
+
|
|
|
+ Software License Agreement (BSD License)
|
|
|
+
|
|
|
+ Copyright (c) 2013, hathach (tinyusb.org)
|
|
|
+ All rights reserved.
|
|
|
+
|
|
|
+ Redistribution and use in source and binary forms, with or without
|
|
|
+ modification, are permitted provided that the following conditions are met:
|
|
|
+ 1. Redistributions of source code must retain the above copyright
|
|
|
+ notice, this list of conditions and the following disclaimer.
|
|
|
+ 2. Redistributions in binary form must reproduce the above copyright
|
|
|
+ notice, this list of conditions and the following disclaimer in the
|
|
|
+ documentation and/or other materials provided with the distribution.
|
|
|
+ 3. Neither the name of the copyright holders nor the
|
|
|
+ names of its contributors may be used to endorse or promote products
|
|
|
+ derived from this software without specific prior written permission.
|
|
|
+
|
|
|
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
|
|
+ EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
|
|
|
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
+
|
|
|
+ This file is part of the tinyusb stack.
|
|
|
+*/
|
|
|
+/**************************************************************************/
|
|
|
+
|
|
|
+#include "tusb_option.h"
|
|
|
+
|
|
|
+#if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_MIDI)
|
|
|
+
|
|
|
+#define _TINY_USB_SOURCE_FILE_
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+// INCLUDE
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+#include "midi_device.h"
|
|
|
+#include "class/audio/audio.h"
|
|
|
+#include "device/usbd_pvt.h"
|
|
|
+
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+// MACRO CONSTANT TYPEDEF
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+typedef struct
|
|
|
+{
|
|
|
+ uint8_t itf_num;
|
|
|
+ uint8_t ep_in;
|
|
|
+ uint8_t ep_out;
|
|
|
+
|
|
|
+ // FIFO
|
|
|
+ tu_fifo_t rx_ff;
|
|
|
+ uint8_t rx_ff_buf[CFG_TUD_MIDI_RX_BUFSIZE];
|
|
|
+ osal_mutex_def_t rx_ff_mutex;
|
|
|
+
|
|
|
+ #if CFG_TUD_MIDI_TX_BUFSIZE % CFG_TUD_MIDI_EPSIZE != 0
|
|
|
+ #error "TX buffer size must be multiple of endpoint size."
|
|
|
+ #endif
|
|
|
+
|
|
|
+ // This is a ring buffer that aligns to word boundaries so that it can be transferred directly to
|
|
|
+ // the USB peripheral. There are three states to the data: free, transmitting and pending.
|
|
|
+ CFG_TUSB_MEM_ALIGN uint8_t tx_buf[CFG_TUD_MIDI_TX_BUFSIZE];
|
|
|
+ uint16_t tx_buf_len;
|
|
|
+ uint16_t first_free;
|
|
|
+ uint16_t pending_count;
|
|
|
+ uint16_t transmitting_count;
|
|
|
+
|
|
|
+ // We need to pack messages into words before queueing their transmission so buffer across write
|
|
|
+ // calls.
|
|
|
+ uint8_t message_buffer[4];
|
|
|
+ uint8_t message_buffer_length;
|
|
|
+ uint8_t message_target_length;
|
|
|
+
|
|
|
+ // Endpoint Transfer buffer
|
|
|
+ CFG_TUSB_MEM_ALIGN uint8_t epout_buf[CFG_TUD_MIDI_EPSIZE];
|
|
|
+
|
|
|
+} midid_interface_t;
|
|
|
+
|
|
|
+#define ITF_MEM_RESET_SIZE offsetof(midid_interface_t, rx_ff)
|
|
|
+
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+// INTERNAL OBJECT & FUNCTION DECLARATION
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+CFG_TUSB_ATTR_USBRAM midid_interface_t _midid_itf[CFG_TUD_MIDI];
|
|
|
+
|
|
|
+bool tud_midi_n_connected(uint8_t itf) {
|
|
|
+ midid_interface_t* midi = &_midid_itf[itf];
|
|
|
+ return midi->itf_num != 0;
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+// READ API
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+uint32_t tud_midi_n_available(uint8_t itf, uint8_t jack_id)
|
|
|
+{
|
|
|
+ return tu_fifo_count(&_midid_itf[itf].rx_ff);
|
|
|
+}
|
|
|
+
|
|
|
+char tud_midi_n_read_char(uint8_t itf, uint8_t jack_id)
|
|
|
+{
|
|
|
+ char ch;
|
|
|
+ return tu_fifo_read(&_midid_itf[itf].rx_ff, &ch) ? ch : (-1);
|
|
|
+}
|
|
|
+
|
|
|
+uint32_t tud_midi_n_read(uint8_t itf, uint8_t jack_id, void* buffer, uint32_t bufsize)
|
|
|
+{
|
|
|
+ return tu_fifo_read_n(&_midid_itf[itf].rx_ff, buffer, bufsize);
|
|
|
+}
|
|
|
+
|
|
|
+void tud_midi_n_read_flush (uint8_t itf, uint8_t jack_id)
|
|
|
+{
|
|
|
+ tu_fifo_clear(&_midid_itf[itf].rx_ff);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+void midi_rx_done_cb(midid_interface_t* midi, uint8_t const* buffer, uint32_t bufsize) {
|
|
|
+ if (bufsize % 4 != 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(uint32_t i=0; i<bufsize; i += 4) {
|
|
|
+ uint8_t header = buffer[i];
|
|
|
+ // uint8_t cable_number = (header & 0xf0) >> 4;
|
|
|
+ uint8_t code_index = header & 0x0f;
|
|
|
+ // We always copy over the first byte.
|
|
|
+ uint8_t count = 1;
|
|
|
+ // Ignore subsequent bytes based on the code.
|
|
|
+ if (code_index != 0x5 && code_index != 0xf) {
|
|
|
+ count = 2;
|
|
|
+ if (code_index != 0x2 && code_index != 0x6 && code_index != 0xc && code_index != 0xd) {
|
|
|
+ count = 3;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ tu_fifo_write_n(&midi->rx_ff, &buffer[i + 1], count);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+// WRITE API
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+
|
|
|
+uint16_t maybe_transmit(midid_interface_t* midi) {
|
|
|
+ if (midi->transmitting_count > 0 || midi->pending_count == 0) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ midi->transmitting_count = midi->pending_count;
|
|
|
+ uint16_t transmit_start_index;
|
|
|
+ // The pending zone wraps back to the end so we must do two transfers.
|
|
|
+ if (midi->pending_count > midi->first_free) {
|
|
|
+ midi->transmitting_count -= midi->first_free;
|
|
|
+ transmit_start_index = midi->tx_buf_len - midi->transmitting_count;
|
|
|
+ } else {
|
|
|
+ transmit_start_index = midi->first_free - midi->transmitting_count;
|
|
|
+
|
|
|
+ // We are transmitting up to first free so ensure it's word aligned for the next transmit.
|
|
|
+ uint8_t over_aligned = midi->first_free % sizeof(size_t);
|
|
|
+ if (over_aligned != 0) {
|
|
|
+ midi->first_free = (midi->first_free + (sizeof(size_t) - midi->first_free)) % midi->tx_buf_len;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ midi->pending_count -= midi->transmitting_count;
|
|
|
+
|
|
|
+ uint8_t* tx_start = midi->tx_buf + transmit_start_index;
|
|
|
+ if (!dcd_edpt_xfer(0, midi->ep_in, tx_start, midi->transmitting_count)) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ return midi->transmitting_count;
|
|
|
+}
|
|
|
+
|
|
|
+uint32_t tud_tx_buf_write_done_cb(midid_interface_t* midi, uint32_t bufsize) {
|
|
|
+ midi->transmitting_count -= bufsize;
|
|
|
+
|
|
|
+ uint16_t len = maybe_transmit(midi);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+uint32_t tud_tx_buf_write(midid_interface_t* midi, uint8_t const* buffer, uint32_t bufsize) {
|
|
|
+ uint32_t len;
|
|
|
+ int32_t last_free = midi->first_free - midi->pending_count - midi->transmitting_count;
|
|
|
+ if (last_free < 0) {
|
|
|
+ len = (last_free + midi->tx_buf_len) - midi->first_free;
|
|
|
+ } else {
|
|
|
+ len = midi->tx_buf_len - midi->first_free;
|
|
|
+ }
|
|
|
+ if (bufsize < len) {
|
|
|
+ len = bufsize;
|
|
|
+ }
|
|
|
+ memcpy(midi->tx_buf + midi->first_free, buffer, len);
|
|
|
+ // uint32_t remaining_bytes
|
|
|
+ // if (last_free > 0 && len < bufsize) {
|
|
|
+ // if ()
|
|
|
+ //
|
|
|
+ // }
|
|
|
+ midi->first_free = (midi->first_free + len) % midi->tx_buf_len;
|
|
|
+ midi->pending_count += len;
|
|
|
+
|
|
|
+ maybe_transmit(midi);
|
|
|
+ return len;
|
|
|
+}
|
|
|
+
|
|
|
+uint32_t tud_midi_n_write(uint8_t itf, uint8_t jack_id, uint8_t const* buffer, uint32_t bufsize)
|
|
|
+{
|
|
|
+ midid_interface_t* midi = &_midid_itf[itf];
|
|
|
+ if (midi->itf_num == 0) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ uint32_t i = 0;
|
|
|
+ while (i < bufsize) {
|
|
|
+ uint8_t data = buffer[i];
|
|
|
+ if (midi->message_buffer_length == 0) {
|
|
|
+ uint8_t msg = data >> 4;
|
|
|
+ midi->message_buffer[1] = data;
|
|
|
+ midi->message_buffer_length = 2;
|
|
|
+ // Check to see if we're still in a SysEx transmit.
|
|
|
+ if (midi->message_buffer[0] == 0x4) {
|
|
|
+ if (data == 0xf7) {
|
|
|
+ midi->message_buffer[0] = 0x5;
|
|
|
+ } else {
|
|
|
+ midi->message_buffer_length = 4;
|
|
|
+ }
|
|
|
+ } else if ((msg >= 0x8 && msg <= 0xB) || msg == 0xE) {
|
|
|
+ midi->message_buffer[0] = jack_id << 4 | msg;
|
|
|
+ midi->message_target_length = 4;
|
|
|
+ } else if (msg == 0xf) {
|
|
|
+ if (data == 0xf0) {
|
|
|
+ midi->message_buffer[0] = 0x4;
|
|
|
+ midi->message_target_length = 4;
|
|
|
+ } else if (data == 0xf1 || data == 0xf3) {
|
|
|
+ midi->message_buffer[0] = 0x2;
|
|
|
+ midi->message_target_length = 3;
|
|
|
+ } else if (data == 0xf2) {
|
|
|
+ midi->message_buffer[0] = 0x3;
|
|
|
+ midi->message_target_length = 4;
|
|
|
+ } else {
|
|
|
+ midi->message_buffer[0] = 0x5;
|
|
|
+ midi->message_target_length = 2;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // Pack individual bytes if we don't support packing them into words.
|
|
|
+ midi->message_buffer[0] = jack_id << 4 | 0xf;
|
|
|
+ midi->message_buffer[2] = 0;
|
|
|
+ midi->message_buffer[3] = 0;
|
|
|
+ midi->message_buffer_length = 2;
|
|
|
+ midi->message_target_length = 2;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ midi->message_buffer[midi->message_buffer_length] = data;
|
|
|
+ midi->message_buffer_length += 1;
|
|
|
+ // See if this byte ends a SysEx.
|
|
|
+ if (midi->message_buffer[0] == 0x4 && data == 0xf7) {
|
|
|
+ midi->message_buffer[0] = 0x4 + (midi->message_buffer_length - 1);
|
|
|
+ midi->message_target_length = midi->message_buffer_length;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (midi->message_buffer_length == midi->message_target_length) {
|
|
|
+ tud_tx_buf_write(midi, midi->message_buffer, 4);
|
|
|
+ midi->message_buffer_length = 0;
|
|
|
+ }
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------+
|
|
|
+// 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];
|
|
|
+
|
|
|
+ // config fifo
|
|
|
+ tu_fifo_config(&midi->rx_ff, midi->rx_ff_buf, CFG_TUD_MIDI_RX_BUFSIZE, 1, true);
|
|
|
+ #if CFG_FIFO_MUTEX
|
|
|
+ tu_fifo_config_mutex(&midi->rx_ff, osal_mutex_create(&midi->rx_ff_mutex));
|
|
|
+ #endif
|
|
|
+
|
|
|
+ midi->tx_buf_len = CFG_TUD_MIDI_TX_BUFSIZE;
|
|
|
+ midi->first_free = 0;
|
|
|
+ midi->pending_count = 0;
|
|
|
+ midi->transmitting_count = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void midid_reset(uint8_t rhport)
|
|
|
+{
|
|
|
+ (void) rhport;
|
|
|
+
|
|
|
+ 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);
|
|
|
+ midi->tx_buf_len = CFG_TUD_MIDI_TX_BUFSIZE;
|
|
|
+ midi->first_free = 0;
|
|
|
+ midi->pending_count = 0;
|
|
|
+ midi->transmitting_count = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length)
|
|
|
+{
|
|
|
+ // For now handle the audio control interface as well.
|
|
|
+ if ( AUDIO_SUBCLASS_AUDIO_CONTROL == p_interface_desc->bInterfaceSubClass) {
|
|
|
+ uint8_t const * p_desc = tu_desc_next ( (uint8_t const *) p_interface_desc );
|
|
|
+ (*p_length) = sizeof(tusb_desc_interface_t);
|
|
|
+
|
|
|
+ // Skip over the class specific descriptor.
|
|
|
+ (*p_length) += p_desc[DESC_OFFSET_LEN];
|
|
|
+ p_desc = tu_desc_next(p_desc);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( AUDIO_SUBCLASS_MIDI_STREAMING != p_interface_desc->bInterfaceSubClass ||
|
|
|
+ p_interface_desc->bInterfaceProtocol != AUDIO_PROTOCOL_V1 ) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Find available interface
|
|
|
+ midid_interface_t * p_midi = NULL;
|
|
|
+ for(uint8_t i=0; i<CFG_TUD_MIDI; i++)
|
|
|
+ {
|
|
|
+ if ( _midid_itf[i].ep_in == 0 && _midid_itf[i].ep_out == 0 )
|
|
|
+ {
|
|
|
+ p_midi = &_midid_itf[i];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ p_midi->itf_num = p_interface_desc->bInterfaceNumber;
|
|
|
+
|
|
|
+ uint8_t const * p_desc = tu_desc_next( (uint8_t const *) p_interface_desc );
|
|
|
+ (*p_length) = sizeof(tusb_desc_interface_t);
|
|
|
+
|
|
|
+ uint8_t found_endpoints = 0;
|
|
|
+ while (found_endpoints < p_interface_desc->bNumEndpoints) {
|
|
|
+ if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
|
|
|
+ {
|
|
|
+ TU_ASSERT( dcd_edpt_open(rhport, (tusb_desc_endpoint_t const *) p_desc), false);
|
|
|
+ uint8_t ep_addr = ((tusb_desc_endpoint_t const *) p_desc)->bEndpointAddress;
|
|
|
+ if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) {
|
|
|
+ p_midi->ep_in = ep_addr;
|
|
|
+ } else {
|
|
|
+ p_midi->ep_out = ep_addr;
|
|
|
+ }
|
|
|
+
|
|
|
+ (*p_length) += p_desc[DESC_OFFSET_LEN];
|
|
|
+ p_desc = tu_desc_next(p_desc);
|
|
|
+ found_endpoints += 1;
|
|
|
+ }
|
|
|
+ (*p_length) += p_desc[DESC_OFFSET_LEN];
|
|
|
+ p_desc = tu_desc_next(p_desc);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Prepare for incoming data
|
|
|
+ TU_ASSERT( dcd_edpt_xfer(rhport, p_midi->ep_out, p_midi->epout_buf, CFG_TUD_MIDI_EPSIZE), false);
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+bool midid_control_request_complete(uint8_t rhport, tusb_control_request_t const * p_request)
|
|
|
+{
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+bool midid_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
|
|
|
+{
|
|
|
+ //------------- Class Specific Request -------------//
|
|
|
+ if (p_request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) return false;
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+bool midid_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t result, uint32_t xferred_bytes)
|
|
|
+{
|
|
|
+ // TODO Support multiple interfaces
|
|
|
+ uint8_t const itf = 0;
|
|
|
+ midid_interface_t* p_midi = &_midid_itf[itf];
|
|
|
+
|
|
|
+ // receive new data
|
|
|
+ if ( edpt_addr == p_midi->ep_out )
|
|
|
+ {
|
|
|
+ midi_rx_done_cb(p_midi, p_midi->epout_buf, xferred_bytes);
|
|
|
+
|
|
|
+ // prepare for next
|
|
|
+ TU_ASSERT( dcd_edpt_xfer(rhport, p_midi->ep_out, p_midi->epout_buf, CFG_TUD_MIDI_EPSIZE), false );
|
|
|
+ } else if ( edpt_addr == p_midi->ep_in ) {
|
|
|
+ tud_tx_buf_write_done_cb(p_midi, xferred_bytes);
|
|
|
+ }
|
|
|
+
|
|
|
+ // nothing to do with in and notif endpoint
|
|
|
+
|
|
|
+ return TUSB_ERROR_NONE;
|
|
|
+}
|
|
|
+
|
|
|
+#endif
|
Scott Shawcroft