moparisthebest/USBHost_t36
1
0
Fork 0
mirror of https://github.com/gdsports/USBHost_t36 synced 2024-11-24 01:52:23 -05:00
Code Issues Releases Wiki Activity
62fbf401d2
USBHost_t36/midi.cpp

570 lines
16 KiB
C++
Raw Blame History

/* USB EHCI Host for Teensy 3.6
* Copyright 2017 Paul Stoffregen (paul@pjrc.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <Arduino.h>
#include "USBHost_t36.h" // Read this header first for key info
#define print USBHost::print_
#define println USBHost::println_
void MIDIDevice::init()
{
contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));
contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));
contribute_String_Buffers(mystring_bufs, sizeof(mystring_bufs)/sizeof(strbuf_t));
handleNoteOff = NULL;
handleNoteOn = NULL;
handleVelocityChange = NULL;
handleControlChange = NULL;
handleProgramChange = NULL;
handleAfterTouch = NULL;
handlePitchChange = NULL;
handleSysExPartial = NULL;
handleSysExComplete = NULL;
handleTimeCodeQuarterFrame = NULL;
handleSongPosition = NULL;
handleSongSelect = NULL;
handleTuneRequest = NULL;
handleClock = NULL;
handleStart = NULL;
handleContinue = NULL;
handleStop = NULL;
handleActiveSensing = NULL;
handleSystemReset = NULL;
handleRealTimeSystem = NULL;
rx_head = 0;
rx_tail = 0;
rxpipe = NULL;
txpipe = NULL;
driver_ready_for_device(this);
}
// Audio Class-Specific Descriptor Types (audio 1.0, page 99)
// CS_UNDEFINED 0x20
// CS_DEVICE 0x21
// CS_CONFIGURATION 0x22
// CS_STRING 0x23
// CS_INTERFACE 0x24
// CS_ENDPOINT 0x25
// MS Class-Specific Interface Descriptor Subtypes (midi 1.0, page 36)
// MS_DESCRIPTOR_UNDEFINED 0x00
// MS_HEADER 0x01
// MIDI_IN_JACK 0x02
// MIDI_OUT_JACK 0x03
// ELEMENT 0x04
// MS Class-Specific Endpoint Descriptor Subtypes (midi 1.0, page 36)
// DESCRIPTOR_UNDEFINED 0x00
// MS_GENERAL 0x01
// MS MIDI IN and OUT Jack types (midi 1.0, page 36)
// JACK_TYPE_UNDEFINED 0x00
// EMBEDDED 0x01
// EXTERNAL 0x02
// Endpoint Control Selectors (midi 1.0, page 36)
// EP_CONTROL_UNDEFINED 0x00
// ASSOCIATION_CONTROL 0x01
bool MIDIDevice::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)
{
// only claim at interface level
if (type != 1) return false;
println("MIDIDevice claim this=", (uint32_t)this, HEX);
println("len = ", len);
const uint8_t *p = descriptors;
const uint8_t *end = p + len;
if (p[0] != 9 || p[1] != 4) return false; // interface descriptor
//println(" bInterfaceClass=", p[5]);
//println(" bInterfaceSubClass=", p[6]);
if (p[5] != 1) return false; // bInterfaceClass: 1 = Audio class
if (p[6] != 3) return false; // bInterfaceSubClass: 3 = MIDI
p += 9;
println(" Interface is MIDI");
rx_ep = 0;
tx_ep = 0;
while (p < end) {
len = *p;
if (len < 4) return false; // all audio desc are at least 4 bytes
if (p + len > end) return false; // reject if beyond end of data
uint32_t type = p[1];
print("type: ", type);
println(", len: ", len);
if (type == 4 || type == 11) break; // interface or IAD, not for us
if (type == 0x24) { // 0x24 = Audio CS_INTERFACE, audio 1.0, page 99
uint32_t subtype = p[2];
//println("subtype: ", subtype);
if (subtype == 1) {
// Interface Header, midi 1.0, page 21
println(" MIDI Header (ignored)");
} else if (subtype == 2) {
// MIDI IN Jack, midi 1.0, page 22
println(" MIDI IN Jack (ignored)");
} else if (subtype == 3) {
// MIDI OUT Jack, midi 1.0, page 22
println(" MIDI OUT Jack (ignored)");
} else if (subtype == 4) {
// Element Descriptor, midi 1.0, page 23-24
println(" MIDI Element (ignored)");
} else {
return false; // unknown
}
} else if (type == 5) {
// endpoint descriptor
if (p[0] < 7) return false; // at least 7 bytes
if (p[3] != 2 && p[3] != 3) return false; // must be bulk or interrupt type
println(" MIDI Endpoint: ", p[2], HEX);
switch (p[2] & 0xF0) {
case 0x80:
// IN endpoint
if (rx_ep == 0) {
rx_ep = p[2] & 0x0F;
rx_ep_type = p[3];
rx_size = p[4] | (p[5] << 8);
println(" rx_size = ", rx_size);
}
break;
case 0x00:
// OUT endpoint
if (tx_ep == 0) {
tx_ep = p[2];
tx_ep_type = p[3];
tx_size = p[4] | (p[5] << 8);
println(" tx_size = ", tx_size);
}
break;
default:
return false;
}
} else if (type == 37) {
// MIDI endpoint info, midi 1.0: 6.2.2, page 26
println(" MIDI Endpoint Jack Association (ignored)");
} else {
return false; // unknown
}
p += len;
}
// if an IN endpoint was found, create its pipe
if (rx_ep && rx_size <= MAX_PACKET_SIZE) {
rxpipe = new_Pipe(dev, rx_ep_type, rx_ep, 1, rx_size);
if (rxpipe) {
rxpipe->callback_function = rx_callback;
queue_Data_Transfer(rxpipe, rx_buffer, rx_size, this);
rx_packet_queued = true;
}
} else {
rxpipe = NULL;
}
// if an OUT endpoint was found, create its pipe
if (tx_ep && tx_size <= MAX_PACKET_SIZE) {
txpipe = new_Pipe(dev, tx_ep_type, tx_ep, 0, tx_size);
if (txpipe) {
txpipe->callback_function = tx_callback;
tx1_count = 0;
tx2_count = 0;
}
} else {
txpipe = NULL;
}
rx_head = 0;
rx_tail = 0;
msg_channel = 0;
msg_type = 0;
msg_data1 = 0;
msg_data2 = 0;
msg_sysex_len = 0;
// claim if either pipe created
return (rxpipe || txpipe);
}
void MIDIDevice::rx_callback(const Transfer_t *transfer)
{
if (transfer->driver) {
((MIDIDevice *)(transfer->driver))->rx_data(transfer);
}
}
void MIDIDevice::tx_callback(const Transfer_t *transfer)
{
if (transfer->driver) {
((MIDIDevice *)(transfer->driver))->tx_data(transfer);
}
}
void MIDIDevice::rx_data(const Transfer_t *transfer)
{
println("MIDIDevice Receive");
print(" MIDI Data: ");
uint32_t len = (transfer->length - ((transfer->qtd.token >> 16) & 0x7FFF)) >> 2;
print_hexbytes(transfer->buffer, len * 4);
uint32_t head = rx_head;
uint32_t tail = rx_tail;
for (uint32_t i=0; i < len; i++) {
uint32_t msg = rx_buffer[i];
if (msg) {
if (++head >= RX_QUEUE_SIZE) head = 0;
rx_queue[head] = msg;
}
}
rx_head = head;
rx_tail = tail;
uint32_t avail = (head < tail) ? tail - head - 1 : RX_QUEUE_SIZE - 1 - head + tail;
//println("rx_size = ", rx_size);
println("avail = ", avail);
if (avail >= (uint32_t)(rx_size>>2)) {
// enough space to accept another full packet
println("queue another receive packet");
queue_Data_Transfer(rxpipe, rx_buffer, rx_size, this);
rx_packet_queued = true;
} else {
// queue can't accept another packet's data, so leave
// the data waiting on the device until we can accept it
println("wait to receive more packets");
rx_packet_queued = false;
}
}
void MIDIDevice::tx_data(const Transfer_t *transfer)
{
println("MIDIDevice transmit complete");
print(" MIDI Data: ");
print_hexbytes(transfer->buffer, tx_size);
if (transfer->buffer == tx_buffer1) {
tx1_count = 0;
} else if (transfer->buffer == tx_buffer2) {
tx2_count = 0;
}
}
void MIDIDevice::disconnect()
{
// should rx_queue be cleared?
// as-is, the user can still read MIDI messages
// which arrived before the device disconnected.
rxpipe = NULL;
txpipe = NULL;
}
void MIDIDevice::write_packed(uint32_t data)
{
if (!txpipe) return;
uint32_t tx_max = tx_size / 4;
while (1) {
uint32_t tx1 = tx1_count;
uint32_t tx2 = tx2_count;
if (tx1 < tx_max && (tx2 == 0 || tx2 >= tx_max)) {
// use tx_buffer1
tx_buffer1[tx1++] = data;
tx1_count = tx1;
if (tx1 >= tx_max) {
queue_Data_Transfer(txpipe, tx_buffer1, tx_max*4, this);
} else {
// TODO: start a timer, rather than sending the buffer
// before it's full, to make best use of bandwidth
tx1_count = tx_max;
queue_Data_Transfer(txpipe, tx_buffer1, tx_max*4, this);
}
return;
}
if (tx2 < tx_max) {
// use tx_buffer2
tx_buffer2[tx2++] = data;
tx2_count = tx2;
if (tx2 >= tx_max) {
queue_Data_Transfer(txpipe, tx_buffer2, tx_max*4, this);
} else {
// TODO: start a timer, rather than sending the buffer
// before it's full, to make best use of bandwidth
tx2_count = tx_max;
queue_Data_Transfer(txpipe, tx_buffer2, tx_max*4, this);
}
return;
}
}
}
void MIDIDevice::send_sysex_buffer_has_term(const uint8_t *data, uint32_t length, uint8_t cable)
{
cable = (cable & 0x0F) << 4;
while (length > 3) {
write_packed(0x04 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));
data += 3;
length -= 3;
}
if (length == 3) {
write_packed(0x07 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));
} else if (length == 2) {
write_packed(0x06 | cable | (data[0] << 8) | (data[1] << 16));
} else if (length == 1) {
write_packed(0x05 | cable | (data[0] << 8));
}
}
void MIDIDevice::send_sysex_add_term_bytes(const uint8_t *data, uint32_t length, uint8_t cable)
{
cable = (cable & 0x0F) << 4;
if (length == 0) {
write_packed(0x06 | cable | (0xF0 << 8) | (0xF7 << 16));
return;
} else if (length == 1) {
write_packed(0x07 | cable | (0xF0 << 8) | (data[0] << 16) | (0xF7 << 24));
return;
} else {
write_packed(0x04 | cable | (0xF0 << 8) | (data[0] << 16) | (data[1] << 24));
data += 2;
length -= 2;
}
while (length >= 3) {
write_packed(0x04 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));
data += 3;
length -= 3;
}
if (length == 2) {
write_packed(0x07 | cable | (data[0] << 8) | (data[1] << 16) | (0xF7 << 24));
} else if (length == 1) {
write_packed(0x06 | cable | (data[0] << 8) | (0xF7 << 16));
} else {
write_packed(0x05 | cable | (0xF7 << 8));
}
}
bool MIDIDevice::read(uint8_t channel)
{
uint32_t n, head, tail, avail, ch, type1, type2, b1;
head = rx_head;
tail = rx_tail;
if (head == tail) return false;
if (++tail >= RX_QUEUE_SIZE) tail = 0;
n = rx_queue[tail];
rx_tail = tail;
if (!rx_packet_queued && rxpipe) {
avail = (head < tail) ? tail - head - 1 : RX_QUEUE_SIZE - 1 - head + tail;
if (avail >= (uint32_t)(rx_size>>2)) {
__disable_irq();
queue_Data_Transfer(rxpipe, rx_buffer, rx_size, this);
__enable_irq();
}
}
println("read: ", n, HEX);
type1 = n & 15;
type2 = (n >> 12) & 15;
b1 = (n >> 8) & 0xFF;
ch = (b1 & 15) + 1;
msg_cable = (n >> 4) & 15;
if (type1 >= 0x08 && type1 <= 0x0E) {
if (channel && channel != ch) {
// ignore other channels when user wants single channel read
return false;
}
if (type1 == 0x08 && type2 == 0x08) {
msg_type = 0x80; // 0x80 = Note off
if (handleNoteOff) {
(*handleNoteOff)(ch, (n >> 16), (n >> 24));
}
} else
if (type1 == 0x09 && type2 == 0x09) {
if ((n >> 24) > 0) {
msg_type = 0x90; // 0x90 = Note on
if (handleNoteOn) {
(*handleNoteOn)(ch, (n >> 16), (n >> 24));
}
} else {
msg_type = 0x80; // 0x80 = Note off
if (handleNoteOff) {
(*handleNoteOff)(ch, (n >> 16), (n >> 24));
}
}
} else
if (type1 == 0x0A && type2 == 0x0A) {
msg_type = 0xA0; // 0xA0 = AfterTouchPoly
if (handleVelocityChange) {
(*handleVelocityChange)(ch, (n >> 16), (n >> 24));
}
} else
if (type1 == 0x0B && type2 == 0x0B) {
msg_type = 0xB0; // 0xB0 = Control Change
if (handleControlChange) {
(*handleControlChange)(ch, (n >> 16), (n >> 24));
}
} else
if (type1 == 0x0C && type2 == 0x0C) {
msg_type = 0xC0; // 0xC0 = Program Change
if (handleProgramChange) {
(*handleProgramChange)(ch, (n >> 16));
}
} else
if (type1 == 0x0D && type2 == 0x0D) {
msg_type = 0xD0; // 0xD0 = After Touch
if (handleAfterTouch) {
(*handleAfterTouch)(ch, (n >> 16));
}
} else
if (type1 == 0x0E && type2 == 0x0E) {
msg_type = 0xE0; // 0xE0 = Pitch Bend
if (handlePitchChange) {
int value = ((n >> 16) & 0x7F) | ((n >> 17) & 0x3F80);
value -= 8192; // 0 to 16383 --> -8192 to +8191
(*handlePitchChange)(ch, value);
}
} else {
return false;
}
return_message:
msg_channel = ch;
msg_data1 = (n >> 16);
msg_data2 = (n >> 24);
return true;
}
if (type1 == 0x02 || type1 == 0x03 || (type1 == 0x05 && b1 >= 0xF1 && b1 != 0xF7)) {
// system common or system realtime message
system_common_or_realtime:
switch (b1) {
case 0xF1: // usbMIDI.TimeCodeQuarterFrame
if (handleTimeCodeQuarterFrame) {
(*handleTimeCodeQuarterFrame)(n >> 16);
}
break;
case 0xF2: // usbMIDI.SongPosition
if (handleSongPosition) {
(*handleSongPosition)(((n >> 16) & 0x7F) | ((n >> 17) & 0x3F80));
}
break;
case 0xF3: // usbMIDI.SongSelect
if (handleSongSelect) {
(*handleSongSelect)(n >> 16);
}
break;
case 0xF6: // usbMIDI.TuneRequest
if (handleTuneRequest) {
(*handleTuneRequest)();
}
break;
case 0xF8: // usbMIDI.Clock
if (handleClock) {
(*handleClock)();
} else if (handleRealTimeSystem) {
(*handleRealTimeSystem)(0xF8);
}
break;
case 0xFA: // usbMIDI.Start
if (handleStart) {
(*handleStart)();
} else if (handleRealTimeSystem) {
(*handleRealTimeSystem)(0xFA);
}
break;
case 0xFB: // usbMIDI.Continue
if (handleContinue) {
(*handleContinue)();
} else if (handleRealTimeSystem) {
(*handleRealTimeSystem)(0xFB);
}
break;
case 0xFC: // usbMIDI.Stop
if (handleStop) {
(*handleStop)();
} else if (handleRealTimeSystem) {
(*handleRealTimeSystem)(0xFC);
}
break;
case 0xFE: // usbMIDI.ActiveSensing
if (handleActiveSensing) {
(*handleActiveSensing)();
} else if (handleRealTimeSystem) {
(*handleRealTimeSystem)(0xFE);
}
break;
case 0xFF: // usbMIDI.SystemReset
if (handleSystemReset) {
(*handleSystemReset)();
} else if (handleRealTimeSystem) {
(*handleRealTimeSystem)(0xFF);
}
break;
default:
return false; // unknown message, ignore it
}
msg_type = b1;
goto return_message;
}
if (type1 == 0x04) {
sysex_byte(n >> 8);
sysex_byte(n >> 16);
sysex_byte(n >> 24);
return false;
}
if (type1 >= 0x05 && type1 <= 0x07) {
sysex_byte(b1);
// allow for buggy devices which use code 5 to transmit 1 byte at a time
// https://forum.pjrc.com/threads/43450?p=164596&viewfull=1#post164596
if (type1 == 0x05 && b1 != 0xF7) return false;
if (type1 >= 0x06) sysex_byte(n >> 16);
if (type1 == 0x07) sysex_byte(n >> 24);
uint16_t len = msg_sysex_len;
msg_data1 = len;
msg_data2 = len >> 8;
msg_sysex_len = 0;
msg_type = 0xF0; // 0xF0 = SystemExclusive
if (handleSysExPartial) {
(*handleSysExPartial)(msg_sysex, len, 1);
} else if (handleSysExComplete) {
(*handleSysExComplete)(msg_sysex, len);
}
return true;
}
if (type1 == 0x0F) {
if (b1 >= 0xF8) {
goto system_common_or_realtime;
}
if (b1 == 0xF0 || msg_sysex_len > 0) {
// Is this really needed? Mac OS-X does this, but do any devices?
sysex_byte(b1);
}
}
return false;
}
void MIDIDevice::sysex_byte(uint8_t b)
{
if (handleSysExPartial && msg_sysex_len >= SYSEX_MAX_LEN) {
// when buffer is full, send another chunk to partial handler.
(*handleSysExPartial)(msg_sysex, msg_sysex_len, 0);
msg_sysex_len = 0;
}
if (msg_sysex_len < SYSEX_MAX_LEN) {
msg_sysex[msg_sysex_len++] = b;
}
}
Reference in New Issue View Git Blame Copy Permalink