move hwid into edpt stream for consistent API

5 files changed, 76 insertions, 73 deletions

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index dfdee8bd4..8ea4080cc 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -203,7 +203,7 @@ uint32_t tud_cdc_n_available(uint8_t itf) {
 uint32_t tud_cdc_n_read(uint8_t itf, void* buffer, uint32_t bufsize) {
   TU_VERIFY(itf < CFG_TUD_CDC, 0);
   cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
-  return tu_edpt_stream_read(p_cdc->rhport, &p_cdc->rx_stream, buffer, bufsize);
+  return tu_edpt_stream_read(&p_cdc->rx_stream, buffer, bufsize);
 }
 
 bool tud_cdc_n_peek(uint8_t itf, uint8_t *chr) {
@@ -215,7 +215,7 @@ void tud_cdc_n_read_flush(uint8_t itf) {
   TU_VERIFY(itf < CFG_TUD_CDC, );
   cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
   tu_edpt_stream_clear(&p_cdc->rx_stream);
-  tu_edpt_stream_read_xfer(p_cdc->rhport, &p_cdc->rx_stream);
+  tu_edpt_stream_read_xfer(&p_cdc->rx_stream);
 }
 
 //--------------------------------------------------------------------+
@@ -224,19 +224,19 @@ void tud_cdc_n_read_flush(uint8_t itf) {
 uint32_t tud_cdc_n_write(uint8_t itf, const void* buffer, uint32_t bufsize) {
   TU_VERIFY(itf < CFG_TUD_CDC, 0);
   cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
-  return tu_edpt_stream_write(p_cdc->rhport, &p_cdc->tx_stream, buffer, bufsize);
+  return tu_edpt_stream_write(&p_cdc->tx_stream, buffer, bufsize);
 }
 
 uint32_t tud_cdc_n_write_flush(uint8_t itf) {
   TU_VERIFY(itf < CFG_TUD_CDC, 0);
   cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
-  return tu_edpt_stream_write_xfer(p_cdc->rhport, &p_cdc->tx_stream);
+  return tu_edpt_stream_write_xfer(&p_cdc->tx_stream);
 }
 
 uint32_t tud_cdc_n_write_available(uint8_t itf) {
   TU_VERIFY(itf < CFG_TUD_CDC, 0);
   cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
-  return tu_edpt_stream_write_available(p_cdc->rhport, &p_cdc->tx_stream);
+  return tu_edpt_stream_write_available(&p_cdc->tx_stream);
 }
 
 bool tud_cdc_n_write_clear(uint8_t itf) {
@@ -269,14 +269,14 @@ void cdcd_init(void) {
     uint8_t *epin_buf  = _cdcd_epbuf[i].epin;
   #endif
 
-    tu_edpt_stream_init(&p_cdc->rx_stream, false, false, false, p_cdc->rx_ff_buf, CFG_TUD_CDC_RX_BUFSIZE,
-                        epout_buf, CFG_TUD_CDC_EP_BUFSIZE);
+    tu_edpt_stream_init(&p_cdc->rx_stream, false, false, false, p_cdc->rx_ff_buf, CFG_TUD_CDC_RX_BUFSIZE, epout_buf,
+                        CFG_TUD_CDC_EP_BUFSIZE);
 
     // TX fifo can be configured to change to overwritable if not connected (DTR bit not set). Without DTR we do not
     // know if data is actually polled by terminal. This way the most current data is prioritized.
     // Default: is overwritable
-    tu_edpt_stream_init(&p_cdc->tx_stream, false, true, _cdcd_cfg.tx_overwritabe_if_not_connected,
-                        p_cdc->tx_ff_buf, CFG_TUD_CDC_TX_BUFSIZE, epin_buf, CFG_TUD_CDC_EP_BUFSIZE);
+    tu_edpt_stream_init(&p_cdc->tx_stream, false, true, _cdcd_cfg.tx_overwritabe_if_not_connected, p_cdc->tx_ff_buf,
+                        CFG_TUD_CDC_TX_BUFSIZE, epin_buf, CFG_TUD_CDC_EP_BUFSIZE);
   }
 }
 
@@ -351,20 +351,20 @@ uint16_t cdcd_open(uint8_t rhport, const tusb_desc_interface_t* itf_desc, uint16
         if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
           tu_edpt_stream_t *stream_tx = &p_cdc->tx_stream;
 
-          tu_edpt_stream_open(stream_tx, desc_ep);
+          tu_edpt_stream_open(stream_tx, rhport, desc_ep);
           if (_cdcd_cfg.tx_persistent) {
-            tu_edpt_stream_write_xfer(rhport, stream_tx); // flush pending data
+            tu_edpt_stream_write_xfer(stream_tx); // flush pending data
           } else {
             tu_edpt_stream_clear(stream_tx);
           }
         } else {
           tu_edpt_stream_t *stream_rx = &p_cdc->rx_stream;
 
-          tu_edpt_stream_open(stream_rx, desc_ep);
+          tu_edpt_stream_open(stream_rx, rhport, desc_ep);
           if (!_cdcd_cfg.rx_persistent) {
             tu_edpt_stream_clear(stream_rx);
           }
-          TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare for incoming data
+          TU_ASSERT(tu_edpt_stream_read_xfer(stream_rx) > 0, 0); // prepare for incoming data
         }
       }
 
@@ -460,6 +460,7 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
 }
 
 bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
+  (void)rhport;
   (void)result;
 
   uint8_t itf = find_cdc_itf(ep_addr);
@@ -510,7 +511,7 @@ bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
       tud_cdc_rx_cb(itf);
     }
 
-    tu_edpt_stream_read_xfer(rhport, stream_rx); // prepare for more data
+    tu_edpt_stream_read_xfer(stream_rx); // prepare for more data
   }
 
   // Data sent to host, we continue to fetch from tx fifo to send.
@@ -518,9 +519,9 @@ bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
   if (ep_addr == stream_tx->ep_addr) {
     tud_cdc_tx_complete_cb(itf); // invoke callback to possibly refill tx fifo
 
-    if (0 == tu_edpt_stream_write_xfer(rhport, stream_tx)) {
+    if (0 == tu_edpt_stream_write_xfer(stream_tx)) {
       // If there is no data left, a ZLP should be sent if needed
-      tu_edpt_stream_write_zlp_if_needed(rhport, stream_tx, xferred_bytes);
+      tu_edpt_stream_write_zlp_if_needed(stream_tx, xferred_bytes);
     }
   }
 
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index e069d9f71..28abbf098 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -470,13 +470,13 @@ bool tuh_cdc_get_line_coding_local(uint8_t idx, cdc_line_coding_t * line_coding)
 uint32_t tuh_cdc_write(uint8_t idx, void const * buffer, uint32_t bufsize) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-  return tu_edpt_stream_write(p_cdc->daddr, &p_cdc->stream.tx, buffer, bufsize);
+  return tu_edpt_stream_write(&p_cdc->stream.tx, buffer, bufsize);
 }
 
 uint32_t tuh_cdc_write_flush(uint8_t idx) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-  return tu_edpt_stream_write_xfer(p_cdc->daddr, &p_cdc->stream.tx);
+  return tu_edpt_stream_write_xfer(&p_cdc->stream.tx);
 }
 
 bool tuh_cdc_write_clear(uint8_t idx) {
@@ -489,7 +489,7 @@ bool tuh_cdc_write_clear(uint8_t idx) {
 uint32_t tuh_cdc_write_available(uint8_t idx) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-  return tu_edpt_stream_write_available(p_cdc->daddr, &p_cdc->stream.tx);
+  return tu_edpt_stream_write_available(&p_cdc->stream.tx);
 }
 
 //--------------------------------------------------------------------+
@@ -499,7 +499,7 @@ uint32_t tuh_cdc_write_available(uint8_t idx) {
 uint32_t tuh_cdc_read (uint8_t idx, void * buffer, uint32_t bufsize) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-  return tu_edpt_stream_read(p_cdc->daddr, &p_cdc->stream.rx, buffer, bufsize);
+  return tu_edpt_stream_read(&p_cdc->stream.rx, buffer, bufsize);
 }
 
 uint32_t tuh_cdc_read_available(uint8_t idx) {
@@ -519,7 +519,7 @@ bool tuh_cdc_read_clear (uint8_t idx) {
   TU_VERIFY(p_cdc);
 
   tu_edpt_stream_clear(&p_cdc->stream.rx);
-  (void)tu_edpt_stream_read_xfer(p_cdc->daddr, &p_cdc->stream.rx);
+  (void)tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
   return true;
 }
 
@@ -693,10 +693,10 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
   if (ep_addr == p_cdc->stream.tx.ep_addr) {
     tuh_cdc_tx_complete_cb(idx); // invoke transmit complete callback
 
-    if (0 == tu_edpt_stream_write_xfer(daddr, &p_cdc->stream.tx)) {
+    if (0 == tu_edpt_stream_write_xfer(&p_cdc->stream.tx)) {
       // If there is no data left, a ZLP should be sent if:
       // - xferred_bytes is multiple of EP Packet size and not zero
-      (void)tu_edpt_stream_write_zlp_if_needed(daddr, &p_cdc->stream.tx, xferred_bytes);
+      (void)tu_edpt_stream_write_zlp_if_needed(&p_cdc->stream.tx, xferred_bytes);
     }
   } else if (ep_addr == p_cdc->stream.rx.ep_addr) {
     #if CFG_TUH_CDC_FTDI
@@ -716,7 +716,7 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
     }
 
     // prepare for next transfer if needed
-    tu_edpt_stream_read_xfer(daddr, &p_cdc->stream.rx);
+    tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
   } else if (ep_addr == p_cdc->ep_notif) {
     // TODO handle notification endpoint
   } else {
@@ -736,7 +736,7 @@ static bool open_ep_stream_pair(cdch_interface_t *p_cdc, tusb_desc_endpoint_t co
     TU_ASSERT(tuh_edpt_open(p_cdc->daddr, desc_ep));
     tu_edpt_stream_t *stream =
       (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) ? &p_cdc->stream.rx : &p_cdc->stream.tx;
-    tu_edpt_stream_open(stream, desc_ep);
+    tu_edpt_stream_open(stream, p_cdc->daddr, desc_ep);
     tu_edpt_stream_clear(stream);
 
     desc_ep = (const tusb_desc_endpoint_t *)tu_desc_next(desc_ep);
@@ -799,7 +799,7 @@ static void set_config_complete(cdch_interface_t *p_cdc, bool success) {
     p_cdc->mounted = true;
     tuh_cdc_mount_cb(idx);
     // Prepare for incoming data
-    tu_edpt_stream_read_xfer(p_cdc->daddr, &p_cdc->stream.rx);
+    tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
   } else {
     // clear the interface entry
     p_cdc->daddr = 0;
diff --git a/src/class/midi/midi_device.c b/src/class/midi/midi_device.c
index 8d1dc7d4a..e0a5aa9c3 100644
--- a/src/class/midi/midi_device.c
+++ b/src/class/midi/midi_device.c
@@ -172,7 +172,7 @@ 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;
   TU_VERIFY(tu_edpt_stream_is_opened(ep_str));
-  return 4 == tu_edpt_stream_read(p_midi->rhport, ep_str, packet, 4);
+  return 4 == tu_edpt_stream_read(ep_str, packet, 4);
 }
 
 uint32_t tud_midi_n_packet_read_n(uint8_t itf, uint8_t packets[], uint32_t max_packets) {
@@ -180,7 +180,7 @@ uint32_t tud_midi_n_packet_read_n(uint8_t itf, uint8_t packets[], uint32_t max_p
   tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.rx;
   TU_VERIFY(tu_edpt_stream_is_opened(ep_str), 0);
 
-  const uint32_t num_read = tu_edpt_stream_read(p_midi->rhport, ep_str, packets, 4u * max_packets);
+  const uint32_t num_read = tu_edpt_stream_read(ep_str, packets, 4u * max_packets);
   return num_read >> 2u;
 }
 
@@ -195,7 +195,7 @@ uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t *
 
   uint32_t i = 0;
   while (i < bufsize) {
-    if (tu_edpt_stream_write_available(p_midi->rhport, ep_str) < 4) {
+    if (tu_edpt_stream_write_available(ep_str) < 4) {
       break;
     }
 
@@ -268,7 +268,7 @@ uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t *
         stream->buffer[idx] = 0;
       }
 
-      const uint32_t count = tu_edpt_stream_write(p_midi->rhport, ep_str, 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;
@@ -278,7 +278,7 @@ uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t *
     }
   }
 
-  (void)tu_edpt_stream_write_xfer(p_midi->rhport, ep_str);
+  (void)tu_edpt_stream_write_xfer(ep_str);
 
   return i;
 }
@@ -288,9 +288,9 @@ bool tud_midi_n_packet_write (uint8_t itf, const uint8_t packet[4]) {
   tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.tx;
   TU_VERIFY(tu_edpt_stream_is_opened(ep_str));
 
-  TU_VERIFY(tu_edpt_stream_write_available(p_midi->rhport, ep_str) >= 4);
-  TU_VERIFY(tu_edpt_stream_write(p_midi->rhport, ep_str, packet, 4) > 0);
-  (void)tu_edpt_stream_write_xfer(p_midi->rhport, ep_str);
+  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;
 }
@@ -300,11 +300,11 @@ uint32_t tud_midi_n_packet_write_n(uint8_t itf, const uint8_t packets[], uint32_
   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(p_midi->rhport, ep_str);
+  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(p_midi->rhport, ep_str, packets, n_bytes);
-  (void)tu_edpt_stream_write_xfer(p_midi->rhport, ep_str);
+  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;
 }
@@ -411,13 +411,13 @@ uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t *desc_itf, uint1
 
       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, desc_ep);
+        tu_edpt_stream_open(stream_tx, rhport, desc_ep);
         tu_edpt_stream_clear(stream_tx);
       } else {
         tu_edpt_stream_t *stream_rx = &p_midi->ep_stream.rx;
-        tu_edpt_stream_open(stream_rx, desc_ep);
+        tu_edpt_stream_open(stream_rx, rhport, desc_ep);
         tu_edpt_stream_clear(stream_rx);
-        TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare to receive data
+        TU_ASSERT(tu_edpt_stream_read_xfer(stream_rx) > 0, 0);         // prepare to receive data
       }
 
       p_desc = tu_desc_next(p_desc);                                   // skip CS Endpoint descriptor
@@ -439,6 +439,7 @@ bool midid_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_req
 }
 
 bool midid_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
+  (void)rhport;
   (void)result;
 
   uint8_t idx = find_midi_itf(ep_addr);
@@ -454,12 +455,12 @@ bool midid_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32
       tu_edpt_stream_read_xfer_complete(ep_st_rx, xferred_bytes);
       tud_midi_rx_cb(idx);                      // invoke callback
     }
-    tu_edpt_stream_read_xfer(rhport, ep_st_rx); // prepare for next data
+    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(rhport, ep_st_tx)) {
+    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(rhport, ep_st_tx, xferred_bytes);
+      (void)tu_edpt_stream_write_zlp_if_needed(ep_st_tx, xferred_bytes);
     }
   } else {
     return false;
diff --git a/src/class/midi/midi_host.c b/src/class/midi/midi_host.c
index 07062875c..b4f5ac445 100644
--- a/src/class/midi/midi_host.c
+++ b/src/class/midi/midi_host.c
@@ -175,14 +175,14 @@ bool midih_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint
       tuh_midi_rx_cb(idx, xferred_bytes);
     }
 
-    tu_edpt_stream_read_xfer(dev_addr, ep_str_rx); // prepare for next transfer
+    tu_edpt_stream_read_xfer(ep_str_rx); // prepare for next transfer
   } else if (ep_addr == ep_str_tx->ep_addr) {
     tuh_midi_tx_cb(idx, xferred_bytes);
 
-    if (0 == tu_edpt_stream_write_xfer(dev_addr, ep_str_tx)) {
+    if (0 == tu_edpt_stream_write_xfer(ep_str_tx)) {
       // If there is no data left, a ZLP should be sent if
       // xferred_bytes is multiple of EP size and not zero
-      tu_edpt_stream_write_zlp_if_needed(dev_addr, ep_str_tx, xferred_bytes);
+      tu_edpt_stream_write_zlp_if_needed(ep_str_tx, xferred_bytes);
     }
   }
 
@@ -303,7 +303,7 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
           ep_stream              = &p_midi->ep_stream.rx;
         }
         TU_ASSERT(tuh_edpt_open(dev_addr, p_ep));
-        tu_edpt_stream_open(ep_stream, p_ep);
+        tu_edpt_stream_open(ep_stream, dev_addr, p_ep);
         tu_edpt_stream_clear(ep_stream);
 
         break;
@@ -335,7 +335,7 @@ bool midih_set_config(uint8_t dev_addr, uint8_t itf_num) {
   };
   tuh_midi_mount_cb(idx, &mount_cb_data);
 
-  tu_edpt_stream_read_xfer(dev_addr, &p_midi->ep_stream.rx); // prepare for incoming data
+  tu_edpt_stream_read_xfer(&p_midi->ep_stream.rx); // prepare for incoming data
 
   // No special config things to do for MIDI
   usbh_driver_set_config_complete(dev_addr, p_midi->bInterfaceNumber);
@@ -414,7 +414,7 @@ uint32_t tuh_midi_read_available(uint8_t idx) {
 uint32_t tuh_midi_write_flush(uint8_t idx) {
   TU_VERIFY(idx < CFG_TUH_MIDI);
   midih_interface_t *p_midi = &_midi_host[idx];
-  return tu_edpt_stream_write_xfer(p_midi->daddr, &p_midi->ep_stream.tx);
+  return tu_edpt_stream_write_xfer(&p_midi->ep_stream.tx);
 }
 
 //--------------------------------------------------------------------+
@@ -427,7 +427,7 @@ uint32_t tuh_midi_packet_read_n(uint8_t idx, uint8_t* buffer, uint32_t bufsize)
   uint32_t count4 = tu_min32(bufsize, tu_edpt_stream_read_available(&p_midi->ep_stream.rx));
   count4 = tu_align4(count4); // round down to multiple of 4
   TU_VERIFY(count4 > 0, 0);
-  return tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, buffer, count4);
+  return tu_edpt_stream_read(&p_midi->ep_stream.rx, buffer, count4);
 }
 
 uint32_t tuh_midi_packet_write_n(uint8_t idx, const uint8_t* buffer, uint32_t bufsize) {
@@ -436,7 +436,7 @@ uint32_t tuh_midi_packet_write_n(uint8_t idx, const uint8_t* buffer, uint32_t bu
 
   const uint32_t bufsize4 = tu_align4(bufsize);
   TU_VERIFY(bufsize4 > 0, 0);
-  return tu_edpt_stream_write(p_midi->daddr, &p_midi->ep_stream.tx, buffer, bufsize4);
+  return tu_edpt_stream_write(&p_midi->ep_stream.tx, buffer, bufsize4);
 }
 
 //--------------------------------------------------------------------+
@@ -450,8 +450,8 @@ uint32_t tuh_midi_stream_write(uint8_t idx, uint8_t cable_num, uint8_t const *bu
   midi_driver_stream_t *stream = &p_midi->stream_write;
 
   uint32_t byte_count = 0;
-  while ((byte_count < bufsize) && (tu_edpt_stream_write_available(p_midi->daddr, &p_midi->ep_stream.tx) >= 4)) {
-    uint8_t const data = buffer[byte_count];
+  while ((byte_count < bufsize) && (tu_edpt_stream_write_available(&p_midi->ep_stream.tx) >= 4)) {
+    const uint8_t data = buffer[byte_count];
     byte_count++;
     if (data >= MIDI_STATUS_SYSREAL_TIMING_CLOCK) {
       // real-time messages need to be sent right away
@@ -460,7 +460,7 @@ uint32_t tuh_midi_stream_write(uint8_t idx, uint8_t cable_num, uint8_t const *bu
       streamrt.buffer[1] = data;
       streamrt.index = 2;
       streamrt.total = 2;
-      uint32_t const count = tu_edpt_stream_write(p_midi->daddr, &p_midi->ep_stream.tx, streamrt.buffer, 4);
+      const uint32_t count = tu_edpt_stream_write(&p_midi->ep_stream.tx, streamrt.buffer, 4);
       TU_ASSERT(count == 4, byte_count); // Check FIFO overflown, since we already check fifo remaining. It is probably race condition
     } else if (stream->index == 0) {
       //------------- New event packet -------------//
@@ -529,7 +529,7 @@ uint32_t tuh_midi_stream_write(uint8_t idx, uint8_t cable_num, uint8_t const *bu
       }
       TU_LOG3_MEM(stream->buffer, 4, 2);
 
-      const uint32_t count = tu_edpt_stream_write(p_midi->daddr, &p_midi->ep_stream.tx, stream->buffer, 4);
+      const uint32_t count = tu_edpt_stream_write(&p_midi->ep_stream.tx, stream->buffer, 4);
 
       // complete current event packet, reset stream
       stream->index = 0;
@@ -551,7 +551,7 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
     return 0;
   }
   *p_cable_num = (one_byte >> 4) & 0xf;
-  uint32_t nread = tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
+  uint32_t nread = tu_edpt_stream_read(&p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
   static uint16_t cable_sysex_in_progress;// bit i is set if received MIDI_STATUS_SYSEX_START but not MIDI_STATUS_SYSEX_END
   while (nread == 4 && bytes_buffered < bufsize) {
     *p_cable_num = (p_midi->stream_read.buffer[0] >> 4) & 0x0f;
@@ -579,7 +579,7 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
         }
         else {
           // bad packet discard
-          nread = tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
+          nread = tu_edpt_stream_read(&p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
           continue;
         }
       } else if (status < MIDI_STATUS_SYSEX_START) {
@@ -626,7 +626,7 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
     }
     else {
       // bad packet discard
-      nread = tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
+      nread = tu_edpt_stream_read(&p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
       continue;
     }
 
@@ -639,7 +639,7 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
       uint8_t new_cable = (one_byte >> 4) & 0xf;
       if (new_cable == *p_cable_num) {
         // still on the same cable. Continue reading the stream
-        nread = tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
+        nread = tu_edpt_stream_read(&p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
       }
     }
   }
diff --git a/src/class/vendor/vendor_device.c b/src/class/vendor/vendor_device.c
index eb78a13c4..9972911e0 100644
--- a/src/class/vendor/vendor_device.c
+++ b/src/class/vendor/vendor_device.c
@@ -119,14 +119,14 @@ bool tud_vendor_n_peek(uint8_t idx, uint8_t *u8) {
 uint32_t tud_vendor_n_read(uint8_t idx, void *buffer, uint32_t bufsize) {
   TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
   vendord_interface_t *p_itf = &_vendord_itf[idx];
-  return tu_edpt_stream_read(p_itf->rhport, &p_itf->stream.rx, buffer, bufsize);
+  return tu_edpt_stream_read(&p_itf->stream.rx, buffer, bufsize);
 }
 
 void tud_vendor_n_read_flush(uint8_t idx) {
   TU_VERIFY(idx < CFG_TUD_VENDOR, );
   vendord_interface_t *p_itf = &_vendord_itf[idx];
   tu_edpt_stream_clear(&p_itf->stream.rx);
-  tu_edpt_stream_read_xfer(p_itf->rhport, &p_itf->stream.rx);
+  tu_edpt_stream_read_xfer(&p_itf->stream.rx);
 }
 #endif
 
@@ -134,7 +134,7 @@ void tud_vendor_n_read_flush(uint8_t idx) {
 bool tud_vendor_n_read_xfer(uint8_t idx) {
   TU_VERIFY(idx < CFG_TUD_VENDOR);
   vendord_interface_t *p_itf = &_vendord_itf[idx];
-  return tu_edpt_stream_read_xfer(p_itf->rhport, &p_itf->stream.rx);
+  return tu_edpt_stream_read_xfer(&p_itf->stream.rx);
 }
 #endif
 
@@ -145,20 +145,20 @@ bool tud_vendor_n_read_xfer(uint8_t idx) {
 uint32_t tud_vendor_n_write(uint8_t idx, const void *buffer, uint32_t bufsize) {
   TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
   vendord_interface_t *p_itf = &_vendord_itf[idx];
-  return tu_edpt_stream_write(p_itf->rhport, &p_itf->stream.tx, buffer, (uint16_t)bufsize);
+  return tu_edpt_stream_write(&p_itf->stream.tx, buffer, (uint16_t)bufsize);
 }
 
 #if CFG_TUD_VENDOR_TX_BUFSIZE > 0
 uint32_t tud_vendor_n_write_flush(uint8_t idx) {
   TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
   vendord_interface_t *p_itf = &_vendord_itf[idx];
-  return tu_edpt_stream_write_xfer(p_itf->rhport, &p_itf->stream.tx);
+  return tu_edpt_stream_write_xfer(&p_itf->stream.tx);
 }
 
 uint32_t tud_vendor_n_write_available(uint8_t idx) {
   TU_VERIFY(idx < CFG_TUD_VENDOR, 0);
   vendord_interface_t *p_itf = &_vendord_itf[idx];
-  return tu_edpt_stream_write_available(p_itf->rhport, &p_itf->stream.tx);
+  return tu_edpt_stream_write_available(&p_itf->stream.tx);
 }
 #endif
 
@@ -270,15 +270,15 @@ uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t *desc_itf, uin
       if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
         tu_edpt_stream_t *stream_tx = &p_vendor->stream.tx;
         if (stream_tx->ep_addr == 0) {
-          tu_edpt_stream_open(stream_tx, desc_ep);
-          tu_edpt_stream_write_xfer(rhport, stream_tx); // flush pending data
+          tu_edpt_stream_open(stream_tx, rhport, desc_ep);
+          tu_edpt_stream_write_xfer(stream_tx); // flush pending data
         }
       } else {
         tu_edpt_stream_t *stream_rx = &p_vendor->stream.rx;
         if (stream_rx->ep_addr == 0) {
-          tu_edpt_stream_open(stream_rx, desc_ep);
+          tu_edpt_stream_open(stream_rx, rhport, desc_ep);
   #if CFG_TUD_VENDOR_RX_MANUAL_XFER == 0
-          TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare for incoming data
+          TU_ASSERT(tu_edpt_stream_read_xfer(stream_rx) > 0, 0); // prepare for incoming data
   #endif
         }
       }
@@ -291,7 +291,8 @@ uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t *desc_itf, uin
 }
 
 bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
-  (void) result;
+  (void)rhport;
+  (void)result;
   const uint8_t idx = find_vendor_itf(ep_addr);
   TU_VERIFY(idx < CFG_TUD_VENDOR);
   vendord_interface_t *p_vendor = &_vendord_itf[idx];
@@ -310,7 +311,7 @@ bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
   #endif
 
   #if CFG_TUD_VENDOR_RX_MANUAL_XFER == 0
-    tu_edpt_stream_read_xfer(rhport, &p_vendor->stream.rx); // prepare next data
+    tu_edpt_stream_read_xfer(&p_vendor->stream.rx); // prepare next data
   #endif
   } else if (ep_addr == p_vendor->stream.tx.ep_addr) {
     // Send complete
@@ -318,9 +319,9 @@ bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
 
   #if CFG_TUD_VENDOR_TX_BUFSIZE > 0
     // try to send more if possible
-    if (0 == tu_edpt_stream_write_xfer(rhport, &p_vendor->stream.tx)) {
+    if (0 == tu_edpt_stream_write_xfer(&p_vendor->stream.tx)) {
       // If there is no data left, a ZLP should be sent if xferred_bytes is multiple of EP Packet size and not zero
-      tu_edpt_stream_write_zlp_if_needed(rhport, &p_vendor->stream.tx, xferred_bytes);
+      tu_edpt_stream_write_zlp_if_needed(&p_vendor->stream.tx, xferred_bytes);
     }
   #endif
   }