move hwid into edpt stream for consistent API

8 files changed, 139 insertions, 135 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
   }
diff --git a/src/common/tusb_private.h b/src/common/tusb_private.h
index 69e82cda1..5cea7b5a0 100644
--- a/src/common/tusb_private.h
+++ b/src/common/tusb_private.h
@@ -65,17 +65,17 @@ typedef struct TU_ATTR_PACKED {
 } tu_edpt_state_t;
 
 typedef struct {
-  bool is_host; // 1: host, 0: device
+  uint8_t  hwid;    // device: rhport, host: daddr
+  bool     is_host; // 1: host, 0: device
   uint8_t ep_addr;
-  uint16_t ep_bufsize;
+  uint16_t mps;
 
+  uint16_t ep_bufsize;
   uint8_t  *ep_buf; // set to NULL to use xfer_fifo when CFG_TUD_EDPT_DEDICATED_HWFIFO = 1
   tu_fifo_t ff;
-  uint16_t mps;
 
   // mutex: read if rx, otherwise write
   OSAL_MUTEX_DEF(ff_mutexdef);
-
 }tu_edpt_stream_t;
 
 //--------------------------------------------------------------------+
@@ -112,8 +112,8 @@ bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex);
 //--------------------------------------------------------------------+
 
 // Init an endpoint stream
-bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool overwritable,
-                         void* ff_buf, uint16_t ff_bufsize, uint8_t* ep_buf, uint16_t ep_bufsize);
+bool tu_edpt_stream_init(tu_edpt_stream_t *s, bool is_host, bool is_tx, bool overwritable, void *ff_buf,
+                         uint16_t ff_bufsize, uint8_t *ep_buf, uint16_t ep_bufsize);
 
 // Deinit an endpoint stream
 TU_ATTR_ALWAYS_INLINE static inline void tu_edpt_stream_deinit(tu_edpt_stream_t *s) {
@@ -129,7 +129,9 @@ TU_ATTR_ALWAYS_INLINE static inline void tu_edpt_stream_deinit(tu_edpt_stream_t
 }
 
 // Open an endpoint stream
-TU_ATTR_ALWAYS_INLINE static inline void tu_edpt_stream_open(tu_edpt_stream_t* s, tusb_desc_endpoint_t const *desc_ep) {
+TU_ATTR_ALWAYS_INLINE static inline void tu_edpt_stream_open(tu_edpt_stream_t *s, uint8_t hwid,
+                                                             const tusb_desc_endpoint_t *desc_ep) {
+  s->hwid    = hwid;
   s->ep_addr = desc_ep->bEndpointAddress;
   s->mps = tu_edpt_packet_size(desc_ep);
 }
@@ -155,27 +157,27 @@ TU_ATTR_ALWAYS_INLINE static inline bool tu_edpt_stream_empty(tu_edpt_stream_t *
 //--------------------------------------------------------------------+
 
 // Write to stream
-uint32_t tu_edpt_stream_write(uint8_t hwid, tu_edpt_stream_t* s, void const *buffer, uint32_t bufsize);
+uint32_t tu_edpt_stream_write(tu_edpt_stream_t *s, const void *buffer, uint32_t bufsize);
 
 // Start an usb transfer if endpoint is not busy. Return number of queued bytes
-uint32_t tu_edpt_stream_write_xfer(uint8_t hwid, tu_edpt_stream_t* s);
+uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t *s);
 
 // Start an zero-length packet if needed
-bool tu_edpt_stream_write_zlp_if_needed(uint8_t hwid, tu_edpt_stream_t* s, uint32_t last_xferred_bytes);
+bool tu_edpt_stream_write_zlp_if_needed(tu_edpt_stream_t *s, uint32_t last_xferred_bytes);
 
 // Get the number of bytes available for writing to FIFO
 // Note: if no fifo, return endpoint size if not busy, 0 otherwise
-uint32_t tu_edpt_stream_write_available(uint8_t hwid, tu_edpt_stream_t* s);
+uint32_t tu_edpt_stream_write_available(tu_edpt_stream_t *s);
 
 //--------------------------------------------------------------------+
 // Stream Read
 //--------------------------------------------------------------------+
 
 // Read from stream
-uint32_t tu_edpt_stream_read(uint8_t hwid, tu_edpt_stream_t* s, void* buffer, uint32_t bufsize);
+uint32_t tu_edpt_stream_read(tu_edpt_stream_t *s, void *buffer, uint32_t bufsize);
 
 // Start an usb transfer if endpoint is not busy
-uint32_t tu_edpt_stream_read_xfer(uint8_t hwid, tu_edpt_stream_t* s);
+uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t *s);
 
 // Complete read transfer by writing EP -> FIFO. Must be called in the transfer complete callback
 TU_ATTR_ALWAYS_INLINE static inline
diff --git a/src/device/usbd.c b/src/device/usbd.c
index 86cbcac26..80d9fee3e 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -503,9 +503,9 @@ bool tud_rhport_init(uint8_t rhport, const tusb_rhport_init_t* rh_init) {
     return true; // skip if already initialized
   }
   TU_ASSERT(rh_init);
-#if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL
+ #if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL
   char const* speed_str = 0;
-            switch (rh_init->speed) {
+  switch (rh_init->speed) {
     case TUSB_SPEED_HIGH:
       speed_str = "High";
     break;
@@ -651,7 +651,9 @@ void tud_task_ext(uint32_t timeout_ms, bool in_isr) {
     }
 
 #if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL
-    if (event.event_id == DCD_EVENT_SETUP_RECEIVED) TU_LOG_USBD("\r\n"); // extra line for setup
+    if (event.event_id == DCD_EVENT_SETUP_RECEIVED) {
+      TU_LOG_USBD("\r\n"); // extra line for setup
+    }
     TU_LOG_USBD("USBD %s ", event.event_id < DCD_EVENT_COUNT ? _usbd_event_str[event.event_id] : "CORRUPTED");
 #endif
 
@@ -1047,7 +1049,7 @@ static bool process_set_config(uint8_t rhport, uint8_t cfg_num) {
   while (p_desc < desc_end) {
     uint8_t assoc_itf_count = 1;
 
-    // Class will always starts with Interface Association (if any) and then Interface descriptor
+    // Class will always start with Interface Association (if any) and then Interface descriptor
     if (TUSB_DESC_INTERFACE_ASSOCIATION == tu_desc_type(p_desc)) {
       const tusb_desc_interface_assoc_t *desc_iad = (const tusb_desc_interface_assoc_t *)p_desc;
 
@@ -1136,9 +1138,7 @@ static bool process_set_config(uint8_t rhport, uint8_t cfg_num) {
         // bind all endpoints to found driver
         tu_edpt_bind_driver(_usbd_dev.ep2drv, desc_itf, drv_len, drv_id);
 
-        // next Interface
-        p_desc += drv_len;
-
+        p_desc += drv_len; // next Interface
         break; // exit driver find loop
       }
     }
diff --git a/src/tusb.c b/src/tusb.c
index fc1ef7e1a..14b388d04 100644
--- a/src/tusb.c
+++ b/src/tusb.c
@@ -336,8 +336,8 @@ uint16_t tu_desc_get_interface_total_len(tusb_desc_interface_t const* desc_itf,
 // Endpoint Stream Helper for both Host and Device stack
 //--------------------------------------------------------------------+
 
-bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool overwritable,
-                         void* ff_buf, uint16_t ff_bufsize, uint8_t* ep_buf, uint16_t ep_bufsize) {
+bool tu_edpt_stream_init(tu_edpt_stream_t *s, bool is_host, bool is_tx, bool overwritable, void *ff_buf,
+                         uint16_t ff_bufsize, uint8_t *ep_buf, uint16_t ep_bufsize) {
   (void) is_tx;
 
   #if CFG_TUSB_EDPT_STREAM_NO_FIFO_ENABLED == 0 // FIFO is required
@@ -362,45 +362,45 @@ bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool is_host, bool is_tx, bool ove
   return true;
 }
 
-static bool stream_claim(uint8_t hwid, tu_edpt_stream_t *s) {
+static bool stream_claim(tu_edpt_stream_t *s) {
   if (s->is_host) {
     #if CFG_TUH_ENABLED
-    return usbh_edpt_claim(hwid, s->ep_addr);
-    #endif
+    return usbh_edpt_claim(s->hwid, s->ep_addr);
+  #endif
   } else {
     #if CFG_TUD_ENABLED
-    return usbd_edpt_claim(hwid, s->ep_addr);
-    #endif
+    return usbd_edpt_claim(s->hwid, s->ep_addr);
+  #endif
   }
   return false;
 }
 
-static bool stream_xfer(uint8_t hwid, tu_edpt_stream_t *s, uint16_t count) {
+static bool stream_xfer(tu_edpt_stream_t *s, uint16_t count) {
   if (s->is_host) {
     #if CFG_TUH_ENABLED
-    return usbh_edpt_xfer(hwid, s->ep_addr, count ? s->ep_buf : NULL, count);
-    #endif
+    return usbh_edpt_xfer(s->hwid, s->ep_addr, count ? s->ep_buf : NULL, count);
+  #endif
   } else {
     #if CFG_TUD_ENABLED
     if (s->ep_buf == NULL) {
-      return usbd_edpt_xfer_fifo(hwid, s->ep_addr, &s->ff, count, false);
+      return usbd_edpt_xfer_fifo(s->hwid, s->ep_addr, &s->ff, count, false);
     } else {
-      return usbd_edpt_xfer(hwid, s->ep_addr, count ? s->ep_buf : NULL, count, false);
+      return usbd_edpt_xfer(s->hwid, s->ep_addr, count ? s->ep_buf : NULL, count, false);
     }
   #endif
   }
   return false;
 }
 
-static bool stream_release(uint8_t hwid, tu_edpt_stream_t *s) {
+static bool stream_release(tu_edpt_stream_t *s) {
   if (s->is_host) {
     #if CFG_TUH_ENABLED
-    return usbh_edpt_release(hwid, s->ep_addr);
-    #endif
+    return usbh_edpt_release(s->hwid, s->ep_addr);
+  #endif
   } else {
     #if CFG_TUD_ENABLED
-    return usbd_edpt_release(hwid, s->ep_addr);
-    #endif
+    return usbd_edpt_release(s->hwid, s->ep_addr);
+  #endif
   }
   return false;
 }
@@ -408,18 +408,18 @@ static bool stream_release(uint8_t hwid, tu_edpt_stream_t *s) {
 //--------------------------------------------------------------------+
 // Stream Write
 //--------------------------------------------------------------------+
-bool tu_edpt_stream_write_zlp_if_needed(uint8_t hwid, tu_edpt_stream_t* s, uint32_t last_xferred_bytes) {
+bool tu_edpt_stream_write_zlp_if_needed(tu_edpt_stream_t *s, uint32_t last_xferred_bytes) {
   // ZLP condition: no pending data, last transferred bytes is multiple of packet size
   TU_VERIFY(tu_fifo_empty(&s->ff) && last_xferred_bytes > 0 && (0 == (last_xferred_bytes & (s->mps - 1))));
-  TU_VERIFY(stream_claim(hwid, s));
-  TU_ASSERT(stream_xfer(hwid, s, 0));
+  TU_VERIFY(stream_claim(s));
+  TU_ASSERT(stream_xfer(s, 0));
   return true;
 }
 
-uint32_t tu_edpt_stream_write_xfer(uint8_t hwid, tu_edpt_stream_t* s) {
+uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t *s) {
   const uint16_t ff_count = tu_fifo_count(&s->ff);
   TU_VERIFY(ff_count > 0, 0); // skip if no data
-  TU_VERIFY(stream_claim(hwid, s), 0);
+  TU_VERIFY(stream_claim(s), 0);
 
   // Pull data from FIFO -> EP buf
   uint16_t count;
@@ -430,23 +430,23 @@ uint32_t tu_edpt_stream_write_xfer(uint8_t hwid, tu_edpt_stream_t* s) {
   }
 
   if (count > 0) {
-    TU_ASSERT(stream_xfer(hwid, s, count), 0);
+    TU_ASSERT(stream_xfer(s, count), 0);
     return count;
   } else {
     // Release endpoint since we don't make any transfer
     // Note: data is dropped if terminal is not connected
-    stream_release(hwid, s);
+    stream_release(s);
     return 0;
   }
 }
 
-uint32_t tu_edpt_stream_write(uint8_t hwid, tu_edpt_stream_t *s, const void *buffer, uint32_t bufsize) {
+uint32_t tu_edpt_stream_write(tu_edpt_stream_t *s, const void *buffer, uint32_t bufsize) {
   TU_VERIFY(bufsize > 0);
 
   #if CFG_TUSB_EDPT_STREAM_NO_FIFO_ENABLED
   if (0 == tu_fifo_depth(&s->ff)) {
     // non-fifo mode
-    TU_VERIFY(stream_claim(hwid, s), 0);
+    TU_VERIFY(stream_claim(s), 0);
     uint32_t xact_len;
     if (s->ep_buf != NULL) {
       // using ep buf
@@ -456,7 +456,7 @@ uint32_t tu_edpt_stream_write(uint8_t hwid, tu_edpt_stream_t *s, const void *buf
       // using hwfifo
       xact_len = bufsize;
     }
-    TU_ASSERT(stream_xfer(hwid, s, (uint16_t) xact_len), 0);
+    TU_ASSERT(stream_xfer(s, (uint16_t)xact_len), 0);
 
     return xact_len;
   } else
@@ -467,31 +467,30 @@ uint32_t tu_edpt_stream_write(uint8_t hwid, tu_edpt_stream_t *s, const void *buf
     // flush if fifo has more than packet size or
     // in rare case: fifo depth is configured too small (which never reach packet size)
     if ((tu_fifo_count(&s->ff) >= s->mps) || (tu_fifo_depth(&s->ff) < s->mps)) {
-      tu_edpt_stream_write_xfer(hwid, s);
+      tu_edpt_stream_write_xfer(s);
     }
     return ret;
   }
 }
 
-uint32_t tu_edpt_stream_write_available(uint8_t hwid, tu_edpt_stream_t *s) {
+uint32_t tu_edpt_stream_write_available(tu_edpt_stream_t *s) {
   #if CFG_TUSB_EDPT_STREAM_NO_FIFO_ENABLED
   if (0 == tu_fifo_depth(&s->ff)) {
     // non-fifo mode
     bool is_busy = true;
     if (s->is_host) {
       #if CFG_TUH_ENABLED
-      is_busy = usbh_edpt_busy(hwid, s->ep_addr);
-      #endif
+      is_busy = usbh_edpt_busy(s->hwid, s->ep_addr);
+    #endif
     } else {
       #if CFG_TUD_ENABLED
-      is_busy = usbd_edpt_busy(hwid, s->ep_addr);
-      #endif
+      is_busy = usbd_edpt_busy(s->hwid, s->ep_addr);
+    #endif
     }
     return is_busy ? 0 : s->ep_bufsize;
   } else
   #endif
   {
-    (void)hwid;
     return (uint32_t)tu_fifo_remaining(&s->ff);
   }
 }
@@ -499,13 +498,13 @@ uint32_t tu_edpt_stream_write_available(uint8_t hwid, tu_edpt_stream_t *s) {
 //--------------------------------------------------------------------+
 // Stream Read
 //--------------------------------------------------------------------+
-uint32_t tu_edpt_stream_read_xfer(uint8_t hwid, tu_edpt_stream_t *s) {
+uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t *s) {
   #if CFG_TUSB_EDPT_STREAM_NO_FIFO_ENABLED
   if (0 == tu_fifo_depth(&s->ff)) {
     // non-fifo mode: RX need ep buffer
     TU_VERIFY(s->ep_buf != NULL, 0);
-    TU_VERIFY(stream_claim(hwid, s), 0);
-    TU_ASSERT(stream_xfer(hwid, s, s->ep_bufsize), 0);
+    TU_VERIFY(stream_claim(s), 0);
+    TU_ASSERT(stream_xfer(s, s->ep_bufsize), 0);
     return s->ep_bufsize;
   } else
   #endif
@@ -517,7 +516,7 @@ uint32_t tu_edpt_stream_read_xfer(uint8_t hwid, tu_edpt_stream_t *s) {
     // and slowly move it to the FIFO when read().
     // This pre-check reduces endpoint claiming
     TU_VERIFY(available >= s->mps);
-    TU_VERIFY(stream_claim(hwid, s), 0);
+    TU_VERIFY(stream_claim(s), 0);
     available = tu_fifo_remaining(&s->ff); // re-get available since fifo can be changed
 
     if (available >= s->mps) {
@@ -526,19 +525,19 @@ uint32_t tu_edpt_stream_read_xfer(uint8_t hwid, tu_edpt_stream_t *s) {
       if (s->ep_buf != NULL) {
         count = tu_min16(count, s->ep_bufsize);
       }
-      TU_ASSERT(stream_xfer(hwid, s, count), 0);
+      TU_ASSERT(stream_xfer(s, count), 0);
       return count;
     } else {
       // Release endpoint since we don't make any transfer
-      stream_release(hwid, s);
+      stream_release(s);
       return 0;
     }
   }
 }
 
-uint32_t tu_edpt_stream_read(uint8_t hwid, tu_edpt_stream_t* s, void* buffer, uint32_t bufsize) {
+uint32_t tu_edpt_stream_read(tu_edpt_stream_t *s, void *buffer, uint32_t bufsize) {
   const uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t)bufsize);
-  tu_edpt_stream_read_xfer(hwid, s);
+  tu_edpt_stream_read_xfer(s);
   return num_read;
 }