change API to take index instead of dev address, this allow to support more than 1 midi per device.

src/class/midi/midi_host.h

@@ -76,22 +76,26 @@ typedef struct {
 } tuh_midi_descriptor_cb_t;
 
 // Check if MIDI interface is mounted
-bool tuh_midi_mounted(uint8_t dev_addr);
+bool tuh_midi_mounted(uint8_t idx);
+
+// Get Interface index from device address + interface number
+// return TUSB_INDEX_INVALID_8 (0xFF) if not found
+uint8_t tuh_midi_itf_get_index(uint8_t daddr, uint8_t itf_num);
 
 // return the number of virtual midi cables on the device's IN endpoint
-uint8_t tuh_midi_get_num_rx_cables(uint8_t dev_addr);
+uint8_t tuh_midi_get_num_rx_cables(uint8_t idx);
 
 // return the number of virtual midi cables on the device's OUT endpoint
-uint8_t tuh_midi_get_num_tx_cables(uint8_t dev_addr);
+uint8_t tuh_midi_get_num_tx_cables(uint8_t idx);
 
 // return the raw number of bytes available.
 // Note: this is related but not the same as number of stream bytes available.
-uint32_t tuh_midi_read_available(uint8_t dev_addr);
+uint32_t tuh_midi_read_available(uint8_t idx);
 
 // Send any queued packets to the device if the host hardware is able to do it
 // Returns the number of bytes flushed to the host hardware or 0 if
 // the host hardware is busy or there is nothing in queue to send.
-uint32_t tuh_midi_write_flush( uint8_t dev_addr);
+uint32_t tuh_midi_write_flush(uint8_t idx);
 
 //--------------------------------------------------------------------+
 // Packet API
@@ -99,24 +103,24 @@ uint32_t tuh_midi_write_flush( uint8_t dev_addr);
 
 // Read all available MIDI packets from the connected device
 // Return number of bytes read (always multiple of 4)
-uint32_t tuh_midi_packet_read_n(uint8_t dev_addr, uint8_t* buffer, uint32_t bufsize);
+uint32_t tuh_midi_packet_read_n(uint8_t idx, uint8_t* buffer, uint32_t bufsize);
 
 // Read a raw MIDI packet from the connected device
 // Return true if a packet was returned
 TU_ATTR_ALWAYS_INLINE static inline
-bool tuh_midi_packet_read (uint8_t dev_addr, uint8_t packet[4]) {
- return 4 == tuh_midi_packet_read_n(dev_addr, packet, 4);
+bool tuh_midi_packet_read (uint8_t idx, uint8_t packet[4]) {
+ return 4 == tuh_midi_packet_read_n(idx, packet, 4);
 }
 
 // Write all 4-byte packets, data is locally buffered and only transferred when buffered bytes
 // reach the endpoint packet size or tuh_midi_write_flush() is called
-uint32_t tuh_midi_packet_write_n(uint8_t dev_addr, const uint8_t* buffer, uint32_t bufsize);
+uint32_t tuh_midi_packet_write_n(uint8_t idx, const uint8_t* buffer, uint32_t bufsize);
 
 // Write a 4-bytes packet to the device.
 // Returns true if the packet was successfully queued.
 TU_ATTR_ALWAYS_INLINE static inline
-bool tuh_midi_packet_write (uint8_t dev_addr, uint8_t const packet[4]) {
- return 4 == tuh_midi_packet_write_n(dev_addr, packet, 4);
+bool tuh_midi_packet_write (uint8_t idx, uint8_t const packet[4]) {
+ return 4 == tuh_midi_packet_write_n(idx, packet, 4);
 }
 
 //--------------------------------------------------------------------+
@@ -127,7 +131,7 @@ bool tuh_midi_packet_write (uint8_t dev_addr, uint8_t const packet[4]) {
 // Queue a message to the device using stream API. data is locally buffered and only transferred when buffered bytes
 // reach the endpoint packet size or tuh_midi_write_flush() is called
 // Returns number of bytes was successfully queued.
-uint32_t tuh_midi_stream_write (uint8_t dev_addr, uint8_t cable_num, uint8_t const* p_buffer, uint32_t bufsize);
+uint32_t tuh_midi_stream_write(uint8_t idx, uint8_t cable_num, uint8_t const *p_buffer, uint32_t bufsize);
 
 // Get the MIDI stream from the device. Set the value pointed
 // to by p_cable_num to the MIDI cable number intended to receive it.
@@ -136,7 +140,7 @@ uint32_t tuh_midi_stream_write (uint8_t dev_addr, uint8_t cable_num, uint8_t con
 // Note that this function ignores the CIN field of the MIDI packet
 // because a number of commercial devices out there do not encode
 // it properly.
-uint32_t tuh_midi_stream_read (uint8_t dev_addr, uint8_t *p_cable_num, uint8_t *p_buffer, uint16_t bufsize);
+uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buffer, uint16_t bufsize);
 
 #endif
 
@@ -146,16 +150,16 @@ uint32_t tuh_midi_stream_read (uint8_t dev_addr, uint8_t *p_cable_num, uint8_t *
 
 // Invoked when MIDI interface is detected in enumeration. Application can copy/parse descriptor if needed.
 // Note: may be fired before tuh_midi_mount_cb(), therefore midi interface is not mounted/ready.
-TU_ATTR_WEAK void tuh_midi_descriptor_cb(uint8_t dev_addr, tuh_midi_descriptor_cb_t const* desc_cb);
+TU_ATTR_WEAK void tuh_midi_descriptor_cb(uint8_t idx, const tuh_midi_descriptor_cb_t * desc_cb);
 
 // Invoked when device with MIDI interface is mounted.
-TU_ATTR_WEAK void tuh_midi_mount_cb(uint8_t dev_addr, uint8_t num_cables_rx, uint16_t num_cables_tx);
+TU_ATTR_WEAK void tuh_midi_mount_cb(uint8_t idx, uint8_t num_cables_rx, uint16_t num_cables_tx);
 
 // Invoked when device with MIDI interface is un-mounted
-TU_ATTR_WEAK void tuh_midi_umount_cb(uint8_t dev_addr);
+TU_ATTR_WEAK void tuh_midi_umount_cb(uint8_t idx);
 
-TU_ATTR_WEAK void tuh_midi_rx_cb(uint8_t dev_addr, uint32_t num_packets);
-TU_ATTR_WEAK void tuh_midi_tx_cb(uint8_t dev_addr);
+TU_ATTR_WEAK void tuh_midi_rx_cb(uint8_t idx, uint32_t num_packets);
+TU_ATTR_WEAK void tuh_midi_tx_cb(uint8_t idx);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
@@ -165,7 +169,7 @@ bool midih_deinit     (void);
 bool midih_open       (uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t max_len);
 bool midih_set_config (uint8_t dev_addr, uint8_t itf_num);
 bool midih_xfer_cb    (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
-void midih_close      (uint8_t dev_addr);
+void midih_close      (uint8_t daddr);
 
 #ifdef __cplusplus
 }