moving edpt_stream API into common tusb.c

5 files changed, 239 insertions, 146 deletions

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 2f3406378..54d81dc0d 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -42,56 +42,23 @@
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
-typedef struct {
-  tu_fifo_t ff;
-
-  // mutex: read if ep rx, write if e tx
-  OSAL_MUTEX_DEF(ff_mutex);
-
-  // TODO xfer_fifo can skip this buffer
-  uint8_t* ep_buf;
-  uint16_t ep_bufsize;
-  uint8_t ep_addr;
-}tu_edpt_stream_t;
-
-bool tu_edpt_stream_init(tu_edpt_stream_t* s, bool use_wr_mutex, bool overwritable,
-                         void* ff_buf, uint16_t ff_bufsize,
-                         uint8_t* ep_buf, uint16_t ep_bufsize)
-{
-  osal_mutex_t new_mutex = osal_mutex_create(&s->ff_mutex);
-  (void) new_mutex;
-  (void) use_wr_mutex;
-
-  tu_fifo_config(&s->ff, ff_buf, ff_bufsize, 1, overwritable);
-  tu_fifo_config_mutex(&s->ff, use_wr_mutex ? new_mutex : NULL, use_wr_mutex ? NULL : new_mutex);
-
-  s->ep_buf = ep_buf;
-  s->ep_bufsize = ep_bufsize;
-
-  return true;
-}
-
-bool tu_edpt_stream_clear(tu_edpt_stream_t* s)
-{
-  return tu_fifo_clear(&s->ff);
-}
 
-bool tu_edpt_stream_write_zlp_if_needed(uint8_t daddr, 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)
 {
-  uint16_t const bulk_packet_size = (tuh_speed_get(daddr) == TUSB_SPEED_HIGH) ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
+  uint16_t const bulk_packet_size = (s->ep_speed == TUSB_SPEED_HIGH) ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
 
   // ZLP condition: no pending data, last transferred bytes is multiple of packet size
   TU_VERIFY( !tu_fifo_count(&s->ff) && last_xferred_bytes && (0 == (last_xferred_bytes & (bulk_packet_size-1))) );
 
-  if ( usbh_edpt_claim(daddr, s->ep_addr) )
+  if ( usbh_edpt_claim(s->daddr, s->ep_addr) )
   {
-    TU_ASSERT( usbh_edpt_xfer(daddr, s->ep_addr, NULL, 0) );
+    TU_ASSERT( usbh_edpt_xfer(s->daddr, s->ep_addr, NULL, 0) );
   }
 
   return true;
 }
 
-uint32_t tu_edpt_stream_write_xfer(uint8_t daddr, tu_edpt_stream_t* s)
+uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t* s)
 {
   // skip if no data
   TU_VERIFY( tu_fifo_count(&s->ff), 0 );
@@ -99,7 +66,7 @@ uint32_t tu_edpt_stream_write_xfer(uint8_t daddr, tu_edpt_stream_t* s)
   // Claim the endpoint
   // uint8_t const rhport = 0;
   // TU_VERIFY( usbd_edpt_claim(rhport, p_cdc->ep_in), 0 );
-  TU_VERIFY( usbh_edpt_claim(daddr, s->ep_addr) );
+  TU_VERIFY( usbh_edpt_claim(s->daddr, s->ep_addr) );
 
   // Pull data from FIFO -> EP buf
   uint16_t const count = tu_fifo_read_n(&s->ff, s->ep_buf, s->ep_bufsize);
@@ -107,7 +74,7 @@ uint32_t tu_edpt_stream_write_xfer(uint8_t daddr, tu_edpt_stream_t* s)
   if ( count )
   {
     //TU_ASSERT( usbd_edpt_xfer(rhport, p_cdc->ep_in, p_cdc->epin_buf, count), 0 );
-    TU_ASSERT( usbh_edpt_xfer(daddr, s->ep_addr, s->ep_buf, count), 0 );
+    TU_ASSERT( usbh_edpt_xfer(s->daddr, s->ep_addr, s->ep_buf, count), 0 );
     return count;
   }else
   {
@@ -115,93 +82,28 @@ uint32_t tu_edpt_stream_write_xfer(uint8_t daddr, tu_edpt_stream_t* s)
     // Note: data is dropped if terminal is not connected
     //usbd_edpt_release(rhport, p_cdc->ep_in);
 
-    usbh_edpt_release(daddr, s->ep_addr);
+    usbh_edpt_release(s->daddr, s->ep_addr);
     return 0;
   }
 }
 
-uint32_t tu_edpt_stream_write(uint8_t daddr, tu_edpt_stream_t* s, void const *buffer, uint32_t bufsize)
-{
-  uint16_t ret = tu_fifo_write_n(&s->ff, buffer, (uint16_t) bufsize);
-
-  // flush if queue more than packet size
-  uint16_t const bulk_packet_size = (tuh_speed_get(daddr) == TUSB_SPEED_HIGH) ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
-  if ( (tu_fifo_count(&s->ff) >= bulk_packet_size)
-      /* || ((CFG_TUD_CDC_TX_BUFSIZE < BULK_PACKET_SIZE) && tu_fifo_full(&p_cdc->tx_ff)) */ )
-  {
-    tu_edpt_stream_write_xfer(daddr, s);
-  }
-
-  return ret;
-}
-
-void tu_edpt_stream_read_xfer_complete(tu_edpt_stream_t* s, uint32_t xferred_bytes)
-{
-  tu_fifo_write_n(&s->ff, s->ep_buf, (uint16_t) xferred_bytes);
-}
-
-uint32_t tu_edpt_stream_read_xfer(uint8_t daddr, tu_edpt_stream_t* s)
+uint32_t tu_edpt_stream_write(tu_edpt_stream_t* s, void const *buffer, uint32_t bufsize)
 {
-  uint16_t available = tu_fifo_remaining(&s->ff);
+  TU_VERIFY(bufsize); // TODO support ZLP
 
-  // Prepare for incoming data but only allow what we can store in the ring buffer.
-  // TODO Actually we can still carry out the transfer, keeping count of received bytes
-  // and slowly move it to the FIFO when read().
-  // This pre-check reduces endpoint claiming
-  uint16_t const bulk_packet_size = (tuh_speed_get(daddr) == TUSB_SPEED_HIGH) ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
-  TU_VERIFY(available >= bulk_packet_size);
-
-  // claim endpoint
-  TU_VERIFY(usbh_edpt_claim(daddr, s->ep_addr), 0);
-
-  // fifo can be changed before endpoint is claimed
-  available = tu_fifo_remaining(&s->ff);
-
-  if ( available >= bulk_packet_size )
-  {
-    // multiple of packet size limit by ep bufsize
-    uint16_t count = (uint16_t) (available & (bulk_packet_size -1));
-    count = tu_min16(count, s->ep_bufsize);
+  uint16_t ret = tu_fifo_write_n(&s->ff, buffer, (uint16_t) bufsize);
 
-    TU_ASSERT( usbh_edpt_xfer(daddr, s->ep_addr, s->ep_buf, count), 0 );
-    return count;
-  }else
+  // flush if fifo has more than packet size or
+  // in rare case: fifo depth is configured too small (which never reach packet size)
+  uint16_t const bulk_packet_size = (s->ep_speed == TUSB_SPEED_HIGH) ? TUSB_EPSIZE_BULK_HS : TUSB_EPSIZE_BULK_FS;
+  if ( (tu_fifo_count(&s->ff) >= bulk_packet_size) || ( tu_fifo_depth(&s->ff) < bulk_packet_size) )
   {
-    // Release endpoint since we don't make any transfer
-    usbh_edpt_release(daddr, s->ep_addr);
-    return 0;
+    tu_edpt_stream_write_xfer(s);
   }
-}
-
-uint32_t tu_edpt_stream_read(uint8_t daddr, tu_edpt_stream_t* s, void* buffer, uint32_t bufsize)
-{
-  uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t) bufsize);
-  tu_edpt_stream_read_xfer(daddr, s);
-  return num_read;
-}
-
-uint32_t tu_edpt_stream_read_available(tu_edpt_stream_t* s)
-{
-  return (uint32_t) tu_fifo_count(&s->ff);
-}
-
-uint32_t tu_edpt_stream_write_available(tu_edpt_stream_t* s)
-{
-  return (uint32_t) tu_fifo_remaining(&s->ff);
-}
 
-bool tu_edpt_stream_read_clear(uint8_t daddr, tu_edpt_stream_t* s)
-{
-  bool ret = tu_fifo_clear(&s->ff);
-  tu_edpt_stream_read_xfer(daddr, s);
   return ret;
 }
 
-bool tu_edpt_stream_write_clear(tu_edpt_stream_t* s)
-{
-  return tu_fifo_clear(&s->ff);
-}
-
 typedef struct {
   uint8_t daddr;
   uint8_t bInterfaceNumber;
@@ -326,7 +228,7 @@ 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)
@@ -334,7 +236,7 @@ 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)
@@ -342,7 +244,7 @@ bool tuh_cdc_write_clear(uint8_t idx)
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
-  return tu_edpt_stream_write_clear(&p_cdc->stream.tx);
+  return tu_edpt_stream_clear(&p_cdc->stream.tx);
 }
 
 uint32_t tuh_cdc_write_available(uint8_t idx)
@@ -358,7 +260,7 @@ 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)
@@ -374,7 +276,9 @@ bool tuh_cdc_read_clear (uint8_t idx)
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
-  return tu_edpt_stream_read_clear(p_cdc->daddr, &p_cdc->stream.rx);
+  bool ret = tu_edpt_stream_clear(&p_cdc->stream.rx);
+  tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
+  return ret;
 }
 
 //--------------------------------------------------------------------+
@@ -452,13 +356,13 @@ void cdch_init(void)
   {
     cdch_interface_t* p_cdc = &cdch_data[i];
 
-    tu_edpt_stream_init(&p_cdc->stream.tx, true, false,
-                        p_cdc->stream.tx_ff_buf, CFG_TUH_CDC_TX_BUFSIZE,
-                        p_cdc->stream.tx_ep_buf, CFG_TUH_CDC_TX_EPSIZE);
+    tu_edpt_stream_init(&p_cdc->stream.tx, true, true, false,
+                          p_cdc->stream.tx_ff_buf, CFG_TUH_CDC_TX_BUFSIZE,
+                          p_cdc->stream.tx_ep_buf, CFG_TUH_CDC_TX_EPSIZE);
 
-    tu_edpt_stream_init(&p_cdc->stream.rx, false, false,
-                        p_cdc->stream.rx_ff_buf, CFG_TUH_CDC_RX_BUFSIZE,
-                        p_cdc->stream.rx_ep_buf, CFG_TUH_CDC_RX_EPSIZE);
+    tu_edpt_stream_init(&p_cdc->stream.rx, true, false, false,
+                          p_cdc->stream.rx_ff_buf, CFG_TUH_CDC_RX_BUFSIZE,
+                          p_cdc->stream.rx_ep_buf, CFG_TUH_CDC_RX_EPSIZE);
   }
 }
 
@@ -475,8 +379,6 @@ void cdch_close(uint8_t daddr)
       //tu_memclr(p_cdc, sizeof(cdch_interface_t));
       p_cdc->daddr = 0;
       p_cdc->bInterfaceNumber = 0;
-      tu_edpt_stream_clear(&p_cdc->stream.tx);
-      tu_edpt_stream_clear(&p_cdc->stream.rx);
     }
   }
 }
@@ -495,23 +397,22 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
     // invoke tx complete callback to possibly refill tx fifo
     if (tuh_cdc_tx_complete_cb) tuh_cdc_tx_complete_cb(idx);
 
-    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 needed
       // xferred_bytes is multiple of EP Packet size and not zero
-      tu_edpt_stream_write_zlp_if_needed(daddr, &p_cdc->stream.tx, xferred_bytes);
+      tu_edpt_stream_write_zlp_if_needed(&p_cdc->stream.tx, xferred_bytes);
     }
   }
   else if ( ep_addr == p_cdc->stream.rx.ep_addr )
   {
-    // skip if ZLP
-    if (xferred_bytes) tu_edpt_stream_read_xfer_complete(&p_cdc->stream.rx, xferred_bytes);
+    tu_edpt_stream_read_xfer_complete(&p_cdc->stream.rx, xferred_bytes);
 
     // invoke receive callback
     if (tuh_cdc_rx_cb)  tuh_cdc_rx_cb(idx);
 
     // 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
@@ -527,7 +428,7 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
 // Enumeration
 //--------------------------------------------------------------------+
 
-bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t max_len)
+bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len)
 {
   (void) rhport;
 
@@ -542,7 +443,7 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   cdch_interface_t * p_cdc = find_new_itf();
   TU_VERIFY(p_cdc);
 
-  p_cdc->daddr              = dev_addr;
+  p_cdc->daddr              = daddr;
   p_cdc->bInterfaceNumber   = itf_desc->bInterfaceNumber;
   p_cdc->bInterfaceSubClass = itf_desc->bInterfaceSubClass;
   p_cdc->bInterfaceProtocol = itf_desc->bInterfaceProtocol;
@@ -569,7 +470,7 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
     TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
     tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) p_desc;
 
-    TU_ASSERT( tuh_edpt_open(dev_addr, desc_ep) );
+    TU_ASSERT( tuh_edpt_open(daddr, desc_ep) );
     p_cdc->ep_notif = desc_ep->bEndpointAddress;
 
     p_desc = tu_desc_next(p_desc);
@@ -589,14 +490,14 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
       TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType &&
                 TUSB_XFER_BULK     == desc_ep->bmAttributes.xfer);
 
-      TU_ASSERT(tuh_edpt_open(dev_addr, desc_ep));
+      TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
 
       if ( tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN )
       {
-        p_cdc->stream.rx.ep_addr = desc_ep->bEndpointAddress;
+        tu_edpt_stream_open(&p_cdc->stream.rx, daddr, desc_ep);
       }else
       {
-        p_cdc->stream.tx.ep_addr = desc_ep->bEndpointAddress;
+        tu_edpt_stream_open(&p_cdc->stream.tx, daddr, desc_ep);
       }
 
       p_desc = tu_desc_next(p_desc);
@@ -616,7 +517,7 @@ static void config_cdc_complete(uint8_t daddr, uint8_t itf_num)
 
     // Prepare for incoming data
     cdch_interface_t* p_cdc = get_itf(idx);
-    tu_edpt_stream_read_xfer(daddr, &p_cdc->stream.rx);
+    tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
   }
 
   // notify usbh that driver enumeration is complete
diff --git a/src/common/tusb_private.h b/src/common/tusb_private.h
index b34506f65..01078eed3 100644
--- a/src/common/tusb_private.h
+++ b/src/common/tusb_private.h
@@ -28,6 +28,8 @@
 #ifndef _TUSB_PRIVATE_H_
 #define _TUSB_PRIVATE_H_
 
+// Internal Helper used by Host and Device Stack
+
 #ifdef __cplusplus
  extern "C" {
 #endif
@@ -39,8 +41,31 @@ typedef struct TU_ATTR_PACKED
   volatile uint8_t claimed : 1;
 }tu_edpt_state_t;
 
+typedef struct {
+  bool is_host; // host or device most
+  union {
+      uint8_t daddr;
+      uint8_t rhport;
+      uint8_t hwid;
+  };
+  uint8_t ep_addr;
+  uint8_t ep_speed;
+
+  uint16_t ep_packetsize;
+  uint16_t ep_bufsize;
+
+  // TODO xfer_fifo can skip this buffer
+  uint8_t* ep_buf;
+
+  tu_fifo_t ff;
+
+  // mutex: read if ep rx, write if e tx
+  OSAL_MUTEX_DEF(ff_mutex);
+
+}tu_edpt_stream_t;
+
 //--------------------------------------------------------------------+
-// Internal Helper used by Host and Device Stack
+// Endpoint
 //--------------------------------------------------------------------+
 
 // Check if endpoint descriptor is valid per USB specs
@@ -58,6 +83,71 @@ bool tu_edpt_claim(tu_edpt_state_t* ep_state, osal_mutex_t mutex);
 // Release an endpoint with provided mutex
 bool tu_edpt_release(tu_edpt_state_t* ep_state, osal_mutex_t mutex);
 
+//--------------------------------------------------------------------+
+// Endpoint Stream
+//--------------------------------------------------------------------+
+
+// Init an stream, should only called once
+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);
+
+// Open an stream for an endpoint
+// hwid is either device address (host mode) or rhport (device mode)
+TU_ATTR_ALWAYS_INLINE static inline
+void tu_edpt_stream_open(tu_edpt_stream_t* s, uint8_t hwid, tusb_desc_endpoint_t const *desc_ep)
+{
+  tu_fifo_clear(&s->ff);
+  s->hwid = hwid;
+  s->ep_addr = desc_ep->bEndpointAddress;
+  s->ep_packetsize = tu_edpt_packet_size(desc_ep);
+}
+
+// Clear fifo
+TU_ATTR_ALWAYS_INLINE static inline
+bool tu_edpt_stream_clear(tu_edpt_stream_t* s)
+{
+  return tu_fifo_clear(&s->ff);
+}
+
+//------------- Write -------------//
+
+// Write to stream
+uint32_t tu_edpt_stream_write(tu_edpt_stream_t* s, void const *buffer, uint32_t bufsize);
+
+// Start an usb transfer if endpoint is not busy
+uint32_t tu_edpt_stream_write_xfer(tu_edpt_stream_t* s);
+
+// Get the number of bytes available for writing
+TU_ATTR_ALWAYS_INLINE static inline
+uint32_t tu_edpt_stream_write_available(tu_edpt_stream_t* s)
+{
+  return (uint32_t) tu_fifo_remaining(&s->ff);
+}
+
+
+//------------- Read -------------//
+
+// Read from stream
+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(tu_edpt_stream_t* s);
+
+// Must be called in the transfer complete callback
+TU_ATTR_ALWAYS_INLINE static inline
+void tu_edpt_stream_read_xfer_complete(tu_edpt_stream_t* s, uint32_t xferred_bytes)
+{
+  tu_fifo_write_n(&s->ff, s->ep_buf, (uint16_t) xferred_bytes);
+}
+
+// Get the number of bytes available for reading
+TU_ATTR_ALWAYS_INLINE static inline
+uint32_t tu_edpt_stream_read_available(tu_edpt_stream_t* s)
+{
+  return (uint32_t) tu_fifo_count(&s->ff);
+}
+
+
 #ifdef __cplusplus
  }
 #endif
diff --git a/src/host/usbh.c b/src/host/usbh.c
index 36fc5fded..f0ca7be2e 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -30,7 +30,6 @@
 
 #include "host/hcd.h"
 #include "tusb.h"
-#include "common/tusb_private.h"
 #include "host/usbh_classdriver.h"
 #include "hub.h"
 
diff --git a/src/host/usbh_classdriver.h b/src/host/usbh_classdriver.h
index 7f72560c3..be9811641 100644
--- a/src/host/usbh_classdriver.h
+++ b/src/host/usbh_classdriver.h
@@ -29,6 +29,7 @@
 
 #include "osal/osal.h"
 #include "common/tusb_fifo.h"
+#include "common/tusb_private.h"
 
 #ifdef __cplusplus
  extern "C" {
diff --git a/src/tusb.c b/src/tusb.c
index f4380f89c..05e0d4c1f 100644
--- a/src/tusb.c
+++ b/src/tusb.c
@@ -31,11 +31,18 @@
 #include "tusb.h"
 #include "common/tusb_private.h"
 
-// TODO clean up
 #if CFG_TUD_ENABLED
 #include "device/usbd_pvt.h"
 #endif
 
+#if CFG_TUH_ENABLED
+#include "host/usbh_classdriver.h"
+#endif
+
+//--------------------------------------------------------------------+
+// Public API
+//--------------------------------------------------------------------+
+
 bool tusb_init(void)
 {
 #if CFG_TUD_ENABLED && defined(TUD_OPT_RHPORT)
@@ -67,7 +74,7 @@ bool tusb_inited(void)
 }
 
 //--------------------------------------------------------------------+
-// Internal Helper for both Host and Device stack
+// Endpoint Helper for both Host and Device stack
 //--------------------------------------------------------------------+
 
 bool tu_edpt_claim(tu_edpt_state_t* ep_state, osal_mutex_t mutex)
@@ -196,9 +203,104 @@ uint16_t tu_desc_get_interface_total_len(tusb_desc_interface_t const* desc_itf,
   return len;
 }
 
-/*------------------------------------------------------------------*/
-/* Debug
- *------------------------------------------------------------------*/
+//--------------------------------------------------------------------+
+// 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)
+{
+  osal_mutex_t new_mutex = osal_mutex_create(&s->ff_mutex);
+  (void) new_mutex;
+  (void) is_tx;
+
+  s->is_host = is_host;
+  tu_fifo_config(&s->ff, ff_buf, ff_bufsize, 1, overwritable);
+  tu_fifo_config_mutex(&s->ff, is_tx ? new_mutex : NULL, is_tx ? NULL : new_mutex);
+
+  s->ep_buf = ep_buf;
+  s->ep_bufsize = ep_bufsize;
+
+  return true;
+}
+
+//------------- Stream Write -------------//
+
+//------------- Stream Read -------------//
+
+uint32_t tu_edpt_stream_read_xfer(tu_edpt_stream_t* s)
+{
+  uint16_t available = tu_fifo_remaining(&s->ff);
+
+  // Prepare for incoming data but only allow what we can store in the ring buffer.
+  // TODO Actually we can still carry out the transfer, keeping count of received bytes
+  // and slowly move it to the FIFO when read().
+  // This pre-check reduces endpoint claiming
+  TU_VERIFY(available >= s->ep_packetsize);
+
+  // claim endpoint
+  if (s->is_host)
+  {
+    #if CFG_TUH_ENABLED
+    TU_VERIFY(usbh_edpt_claim(s->daddr, s->ep_addr), 0);
+    #endif
+  }else
+  {
+    #if CFG_TUD_ENABLED
+    TU_VERIFY(usbd_edpt_claim(s->rhport, s->ep_addr), 0);
+    #endif
+  }
+
+  // get available again since fifo can be changed before endpoint is claimed
+  available = tu_fifo_remaining(&s->ff);
+
+  if ( available >= s->ep_packetsize )
+  {
+    // multiple of packet size limit by ep bufsize
+    uint16_t count = (uint16_t) (available & (s->ep_packetsize -1));
+    count = tu_min16(count, s->ep_bufsize);
+
+    if (s->is_host)
+    {
+      #if CFG_TUH_ENABLED
+      TU_ASSERT( usbh_edpt_xfer(s->daddr, s->ep_addr, s->ep_buf, count), 0 );
+      #endif
+    }else
+    {
+      #if CFG_TUD_ENABLED
+      TU_ASSERT( usbd_edpt_xfer(s->rhport, s->ep_addr, s->ep_buf, count), 0 );
+      #endif
+    }
+    return count;
+  }else
+  {
+    // Release endpoint since we don't make any transfer
+    if (s->is_host)
+    {
+      #if CFG_TUH_ENABLED
+      usbh_edpt_release(s->daddr, s->ep_addr);
+      #endif
+    }else
+    {
+      #if CFG_TUD_ENABLED
+      usbd_edpt_release(s->rhport, s->ep_addr);
+      #endif
+    }
+
+    return 0;
+  }
+}
+
+uint32_t tu_edpt_stream_read(tu_edpt_stream_t* s, void* buffer, uint32_t bufsize)
+{
+  uint32_t num_read = tu_fifo_read_n(&s->ff, buffer, (uint16_t) bufsize);
+  tu_edpt_stream_read_xfer(s);
+  return num_read;
+}
+
+//--------------------------------------------------------------------+
+// Debug
+//--------------------------------------------------------------------+
 #if CFG_TUSB_DEBUG
 #include <ctype.h>