6 files changed, 136 insertions, 163 deletions
diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index b68a6a7ff..b8678c1c4 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -41,9 +41,7 @@
 #if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_CDC)
 
 #define _TINY_USB_SOURCE_FILE_
-//--------------------------------------------------------------------+
-// INCLUDE
-//--------------------------------------------------------------------+
+
 #include "cdc_device.h"
 #include "device/usbd_pvt.h"
 
@@ -95,7 +93,7 @@ CFG_TUSB_MEM_SECTION static cdcd_interface_t _cdcd_itf[CFG_TUD_CDC];
 bool tud_cdc_n_connected(uint8_t itf)
 {
   // DTR (bit 0) active  is considered as connected
-  return BIT_TEST_(_cdcd_itf[itf].line_state, 0);
+  return TU_BIT_TEST(_cdcd_itf[itf].line_state, 0);
 }
 
 uint8_t tud_cdc_n_get_line_state (uint8_t itf)
@@ -231,17 +229,14 @@ void cdcd_reset(uint8_t rhport)
   }
 }
 
-tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length)
+bool cdcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
 {
-  if ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL != p_interface_desc->bInterfaceSubClass) return TUSB_ERROR_CDC_UNSUPPORTED_SUBCLASS;
+  // Only support ACM subclass
+  TU_ASSERT ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
 
   // Only support AT commands, no protocol and vendor specific commands.
-  if ( !(tu_within(CDC_COMM_PROTOCOL_ATCOMMAND, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||
-         p_interface_desc->bInterfaceProtocol == CDC_COMM_PROTOCOL_NONE ||
-         p_interface_desc->bInterfaceProtocol == 0xff ) )
-  {
-    return TUSB_ERROR_CDC_UNSUPPORTED_PROTOCOL;
-  }
+  TU_ASSERT(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||
+            itf_desc->bInterfaceProtocol == 0xff);
 
   // Find available interface
   cdcd_interface_t * p_cdc = NULL;
@@ -253,55 +248,59 @@ tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface
       break;
     }
   }
+  TU_ASSERT(p_cdc);
 
   //------------- Control Interface -------------//
-  p_cdc->itf_num  = p_interface_desc->bInterfaceNumber;
+  p_cdc->itf_num = itf_desc->bInterfaceNumber;
 
-  uint8_t const * p_desc = descriptor_next ( (uint8_t const *) p_interface_desc );
+  uint8_t const * p_desc = tu_desc_next( itf_desc );
   (*p_length) = sizeof(tusb_desc_interface_t);
 
   // Communication Functional Descriptors
-  while( TUSB_DESC_CLASS_SPECIFIC == p_desc[DESC_OFFSET_TYPE] )
+  while ( TUSB_DESC_CLASS_SPECIFIC == tu_desc_type(p_desc) )
   {
-    (*p_length) += p_desc[DESC_OFFSET_LEN];
-    p_desc = descriptor_next(p_desc);
+    (*p_length) += tu_desc_len(p_desc);
+    p_desc = tu_desc_next(p_desc);
   }
 
-  if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
-  { // notification endpoint if any
-    TU_ASSERT( dcd_edpt_open(rhport, (tusb_desc_endpoint_t const *) p_desc), TUSB_ERROR_DCD_OPEN_PIPE_FAILED);
+  if ( TUSB_DESC_ENDPOINT == tu_desc_type(p_desc) )
+  {
+    // notification endpoint if any
+    TU_ASSERT( dcd_edpt_open(rhport, (tusb_desc_endpoint_t const *) p_desc) );
 
     p_cdc->ep_notif = ((tusb_desc_endpoint_t const *) p_desc)->bEndpointAddress;
 
     (*p_length) += p_desc[DESC_OFFSET_LEN];
-    p_desc = descriptor_next(p_desc);
+    p_desc = tu_desc_next(p_desc);
   }
 
   //------------- Data Interface (if any) -------------//
   if ( (TUSB_DESC_INTERFACE == p_desc[DESC_OFFSET_TYPE]) &&
        (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )
   {
-    // next to endpoint descritpor
-    (*p_length) += p_desc[DESC_OFFSET_LEN];
-    p_desc = descriptor_next(p_desc);
+    // next to endpoint descriptor
+    (*p_length) += tu_desc_len(p_desc);
+    p_desc = tu_desc_next(p_desc);
 
     // Open endpoint pair with usbd helper
     tusb_desc_endpoint_t const *p_desc_ep = (tusb_desc_endpoint_t const *) p_desc;
-    TU_ASSERT_ERR( usbd_open_edpt_pair(rhport, p_desc_ep, TUSB_XFER_BULK, &p_cdc->ep_out, &p_cdc->ep_in) );
+    TU_ASSERT( usbd_open_edpt_pair(rhport, p_desc_ep, TUSB_XFER_BULK, &p_cdc->ep_out, &p_cdc->ep_in) );
 
     (*p_length) += 2*sizeof(tusb_desc_endpoint_t);
   }
 
   // Prepare for incoming data
-  TU_ASSERT( dcd_edpt_xfer(rhport, p_cdc->ep_out, p_cdc->epout_buf, CFG_TUD_CDC_EPSIZE), TUSB_ERROR_DCD_EDPT_XFER);
+  TU_ASSERT( dcd_edpt_xfer(rhport, p_cdc->ep_out, p_cdc->epout_buf, CFG_TUD_CDC_EPSIZE) );
 
-  return TUSB_ERROR_NONE;
+  return true;
 }
 
 // Invoked when class request DATA stage is finished.
 // return false to stall control endpoint (e.g Host send non-sense DATA)
 bool cdcd_control_request_complete(uint8_t rhport, tusb_control_request_t const * request)
 {
+  (void) rhport;
+
   //------------- Class Specific Request -------------//
   TU_VERIFY (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
 
@@ -347,9 +346,10 @@ bool cdcd_control_request(uint8_t rhport, tusb_control_request_t const * request
       //        This signal corresponds to V.24 signal 105 and RS-232 signal RTS (Request to Send)
       p_cdc->line_state = (uint8_t) request->wValue;
 
-      // Invoke callback
-      if ( tud_cdc_line_state_cb) tud_cdc_line_state_cb(itf, BIT_TEST_(request->wValue, 0), BIT_TEST_(request->wValue, 1));
       usbd_control_status(rhport, request);
+
+      // Invoke callback
+      if ( tud_cdc_line_state_cb) tud_cdc_line_state_cb(itf, TU_BIT_TEST(request->wValue, 0), TU_BIT_TEST(request->wValue, 1));
     break;
 
     default: return false; // stall unsupported request
@@ -358,8 +358,10 @@ bool cdcd_control_request(uint8_t rhport, tusb_control_request_t const * request
   return true;
 }
 
-tusb_error_t cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
 {
+  (void) result;
+
   // TODO Support multiple interfaces
   uint8_t const itf = 0;
   cdcd_interface_t* p_cdc = &_cdcd_itf[itf];
@@ -367,29 +369,27 @@ tusb_error_t cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event,
   // receive new data
   if ( ep_addr == p_cdc->ep_out )
   {
-    char const wanted = p_cdc->wanted_char;
-
     for(uint32_t i=0; i<xferred_bytes; i++)
     {
       tu_fifo_write(&p_cdc->rx_ff, &p_cdc->epout_buf[i]);
 
       // Check for wanted char and invoke callback if needed
-      if ( tud_cdc_rx_wanted_cb && ( wanted != -1 ) && ( wanted == p_cdc->epout_buf[i] ) )
+      if ( tud_cdc_rx_wanted_cb && ( ((signed char) p_cdc->wanted_char) != -1 ) && ( p_cdc->wanted_char == p_cdc->epout_buf[i] ) )
       {
-        tud_cdc_rx_wanted_cb(itf, wanted);
+        tud_cdc_rx_wanted_cb(itf, p_cdc->wanted_char);
       }
     }
 
     // invoke receive callback (if there is still data)
     if (tud_cdc_rx_cb && tu_fifo_count(&p_cdc->rx_ff) ) tud_cdc_rx_cb(itf);
 
-    // prepare for next
-    TU_ASSERT( dcd_edpt_xfer(rhport, p_cdc->ep_out, p_cdc->epout_buf, CFG_TUD_CDC_EPSIZE), TUSB_ERROR_DCD_EDPT_XFER );
+    // prepare for incoming data
+    TU_ASSERT( dcd_edpt_xfer(rhport, p_cdc->ep_out, p_cdc->epout_buf, CFG_TUD_CDC_EPSIZE) );
   }
 
   // nothing to do with in and notif endpoint
 
-  return TUSB_ERROR_NONE;
+  return true;
 }
 
 #endif
diff --git a/src/class/cdc/cdc_device.h b/src/class/cdc/cdc_device.h
index ad1100e9c..5ee649c4b 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -112,12 +112,12 @@ ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_li
 //--------------------------------------------------------------------+
 #ifdef _TINY_USB_SOURCE_FILE_
 
-void         cdcd_init               (void);
-tusb_error_t cdcd_open               (uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);
+void cdcd_init               (void);
+bool cdcd_open               (uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);
 bool cdcd_control_request (uint8_t rhport, tusb_control_request_t const * p_request);
 bool cdcd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);
-tusb_error_t cdcd_xfer_cb            (uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes);
-void         cdcd_reset              (uint8_t rhport);
+bool cdcd_xfer_cb            (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
+void cdcd_reset              (uint8_t rhport);
 
 #endif
 
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 0a3661878..d6767d0a7 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -38,100 +38,92 @@
 
 #include "tusb_option.h"
 
-#if (MODE_HOST_SUPPORTED && CFG_TUSB_HOST_CDC)
+#if (TUSB_OPT_HOST_ENABLED && CFG_TUH_CDC)
 
 #define _TINY_USB_SOURCE_FILE_
 
-//--------------------------------------------------------------------+
-// INCLUDE
-//--------------------------------------------------------------------+
 #include "common/tusb_common.h"
 #include "cdc_host.h"
 
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
+typedef struct {
+  uint8_t itf_num;
+  uint8_t itf_protocol;
 
-//--------------------------------------------------------------------+
-// INTERNAL OBJECT & FUNCTION DECLARATION
-//--------------------------------------------------------------------+
-STATIC_VAR cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX]; // TODO to be static
+  uint8_t ep_notif;
+  uint8_t ep_in;
+  uint8_t ep_out;
 
-static inline cdc_pipeid_t get_app_pipeid(pipe_handle_t pipe_hdl)
-{
-  cdch_data_t const * p_cdc = &cdch_data[pipe_hdl.dev_addr-1];
+  cdc_acm_capability_t acm_capability;
 
-  return pipehandle_is_equal( pipe_hdl, p_cdc->pipe_notification ) ? CDC_PIPE_NOTIFICATION :
-         pipehandle_is_equal( pipe_hdl, p_cdc->pipe_in           ) ? CDC_PIPE_DATA_IN      :
-         pipehandle_is_equal( pipe_hdl, p_cdc->pipe_out          ) ? CDC_PIPE_DATA_OUT     : CDC_PIPE_ERROR;
-}
+} cdch_data_t;
 
+//--------------------------------------------------------------------+
+// INTERNAL OBJECT & FUNCTION DECLARATION
+//--------------------------------------------------------------------+
+static cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX];
 
-static inline bool tusbh_cdc_is_mounted(uint8_t dev_addr)
+bool tuh_cdc_mounted(uint8_t dev_addr)
 {
-// FIXME cannot use mounted class flag as at the point _open_sublass is called, the flag is not set yet
-#ifdef _TEST_
- return (tusbh_device_get_mounted_class_flag(dev_addr) & BIT_(TUSB_CLASS_CDC)) != 0;
-#else
-  return pipehandle_is_valid(cdch_data[dev_addr-1].pipe_in) &&
-      pipehandle_is_valid(cdch_data[dev_addr-1].pipe_out);
-#endif
+  cdch_data_t* cdc = &cdch_data[dev_addr-1];
+  return cdc->ep_in && cdc->ep_out;
 }
 
 bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)
 {
-  if ( !tusbh_cdc_is_mounted(dev_addr) ) return false;
+  if ( !tuh_cdc_mounted(dev_addr) ) return false;
 
   cdch_data_t const * p_cdc = &cdch_data[dev_addr-1];
 
   switch (pipeid)
   {
     case CDC_PIPE_NOTIFICATION:
-      return hcd_pipe_is_busy( p_cdc->pipe_notification );
+      return hcd_edpt_busy(dev_addr, p_cdc->ep_notif );
 
     case CDC_PIPE_DATA_IN:
-      return hcd_pipe_is_busy( p_cdc->pipe_in );
+      return hcd_edpt_busy(dev_addr, p_cdc->ep_in );
 
     case CDC_PIPE_DATA_OUT:
-      return hcd_pipe_is_busy( p_cdc->pipe_out );
+      return hcd_edpt_busy(dev_addr, p_cdc->ep_out );
 
     default:
       return false;
   }
 }
 
-
 //--------------------------------------------------------------------+
 // APPLICATION API (parameter validation needed)
 //--------------------------------------------------------------------+
 bool tuh_cdc_serial_is_mounted(uint8_t dev_addr)
 {
   // TODO consider all AT Command as serial candidate
-  return tusbh_cdc_is_mounted(dev_addr)                                         &&
-      (CDC_COMM_PROTOCOL_ATCOMMAND <= cdch_data[dev_addr-1].interface_protocol) &&
-      (cdch_data[dev_addr-1].interface_protocol <= CDC_COMM_PROTOCOL_ATCOMMAND_CDMA);
+  return tuh_cdc_mounted(dev_addr)                                         &&
+      (CDC_COMM_PROTOCOL_ATCOMMAND <= cdch_data[dev_addr-1].itf_protocol) &&
+      (cdch_data[dev_addr-1].itf_protocol <= CDC_COMM_PROTOCOL_ATCOMMAND_CDMA);
 }
 
-tusb_error_t tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length, bool is_notify)
+bool tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length, bool is_notify)
 {
-  TU_ASSERT( tusbh_cdc_is_mounted(dev_addr),  TUSB_ERROR_CDCH_DEVICE_NOT_MOUNTED);
-  TU_ASSERT( p_data != NULL && length, TUSB_ERROR_INVALID_PARA);
+  TU_VERIFY( tuh_cdc_mounted(dev_addr) );
+  TU_VERIFY( p_data != NULL && length, TUSB_ERROR_INVALID_PARA);
 
-  pipe_handle_t pipe_out = cdch_data[dev_addr-1].pipe_out;
-  if ( hcd_pipe_is_busy(pipe_out) ) return TUSB_ERROR_INTERFACE_IS_BUSY;
+  uint8_t const ep_out = cdch_data[dev_addr-1].ep_out;
+  if ( hcd_edpt_busy(dev_addr, ep_out) ) return false;
 
-  return hcd_pipe_xfer( pipe_out, (void *) p_data, length, is_notify);
+  return hcd_pipe_xfer(dev_addr, ep_out, (void *) p_data, length, is_notify);
 }
 
-tusb_error_t tuh_cdc_receive(uint8_t dev_addr, void * p_buffer, uint32_t length, bool is_notify)
+bool tuh_cdc_receive(uint8_t dev_addr, void * p_buffer, uint32_t length, bool is_notify)
 {
-  TU_ASSERT( tusbh_cdc_is_mounted(dev_addr),  TUSB_ERROR_CDCH_DEVICE_NOT_MOUNTED);
-  TU_ASSERT( p_buffer != NULL && length, TUSB_ERROR_INVALID_PARA);
+  TU_VERIFY( tuh_cdc_mounted(dev_addr) );
+  TU_VERIFY( p_buffer != NULL && length, TUSB_ERROR_INVALID_PARA);
 
-  pipe_handle_t pipe_in = cdch_data[dev_addr-1].pipe_in;
-  if ( hcd_pipe_is_busy(pipe_in) ) return TUSB_ERROR_INTERFACE_IS_BUSY;
+  uint8_t const ep_in = cdch_data[dev_addr-1].ep_in;
+  if ( hcd_edpt_busy(dev_addr, ep_in) ) return false;
 
-  return hcd_pipe_xfer( pipe_in, p_buffer, length, is_notify);
+  return hcd_pipe_xfer(dev_addr, ep_in, p_buffer, length, is_notify);
 }
 
 //--------------------------------------------------------------------+
@@ -142,102 +134,106 @@ void cdch_init(void)
   tu_memclr(cdch_data, sizeof(cdch_data_t)*CFG_TUSB_HOST_DEVICE_MAX);
 }
 
-tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length)
+bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length)
 {
-  OSAL_SUBTASK_BEGIN
-  // TODO change following assert to subtask_assert
-
-  if ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL != p_interface_desc->bInterfaceSubClass) return TUSB_ERROR_CDC_UNSUPPORTED_SUBCLASS;
+  // Only support ACM
+  TU_VERIFY( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
 
-  if ( !(tu_within(CDC_COMM_PROTOCOL_ATCOMMAND, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||
-         0xff == p_interface_desc->bInterfaceProtocol) )
-  {
-    return TUSB_ERROR_CDC_UNSUPPORTED_PROTOCOL;
-  }
+  // Only support AT commands, no protocol and vendor specific commands.
+  TU_VERIFY(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||
+            0xff == itf_desc->bInterfaceProtocol);
 
   uint8_t const * p_desc;
   cdch_data_t * p_cdc;
 
-  p_desc = descriptor_next ( (uint8_t const *) p_interface_desc );
-  p_cdc  = &cdch_data[dev_addr-1]; // non-static variable cannot be used after OS service call
+  p_desc = tu_desc_next(itf_desc);
+  p_cdc  = &cdch_data[dev_addr-1];
 
-  p_cdc->interface_number   = p_interface_desc->bInterfaceNumber;
-  p_cdc->interface_protocol = p_interface_desc->bInterfaceProtocol; // TODO 0xff is consider as rndis candidate, other is virtual Com
+  p_cdc->itf_num   = itf_desc->bInterfaceNumber;
+  p_cdc->itf_protocol = itf_desc->bInterfaceProtocol; // TODO 0xff is consider as rndis candidate, other is virtual Com
 
   //------------- Communication Interface -------------//
   (*p_length) = sizeof(tusb_desc_interface_t);
 
+  // Communication Functional Descriptors
   while( TUSB_DESC_CLASS_SPECIFIC == p_desc[DESC_OFFSET_TYPE] )
-  { // Communication Functional Descriptors
+  {
     if ( CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc) )
-    { // save ACM bmCapabilities
+    {
+      // save ACM bmCapabilities
       p_cdc->acm_capability = ((cdc_desc_func_acm_t const *) p_desc)->bmCapabilities;
     }
 
     (*p_length) += p_desc[DESC_OFFSET_LEN];
-    p_desc = descriptor_next(p_desc);
+    p_desc = tu_desc_next(p_desc);
   }
 
   if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
-  { // notification endpoint if any
-    p_cdc->pipe_notification = hcd_pipe_open(dev_addr, (tusb_desc_endpoint_t const *) p_desc, TUSB_CLASS_CDC);
+  {
+    // notification endpoint
+    tusb_desc_endpoint_t const * ep_desc = (tusb_desc_endpoint_t const *) p_desc;
 
-    (*p_length) += p_desc[DESC_OFFSET_LEN];
-    p_desc = descriptor_next(p_desc);
+    TU_ASSERT( hcd_edpt_open(rhport, dev_addr, ep_desc) );
+    p_cdc->ep_notif = ep_desc->bEndpointAddress;
 
-    TU_ASSERT(pipehandle_is_valid(p_cdc->pipe_notification), TUSB_ERROR_HCD_OPEN_PIPE_FAILED);
+    (*p_length) += p_desc[DESC_OFFSET_LEN];
+    p_desc = tu_desc_next(p_desc);
   }
 
   //------------- Data Interface (if any) -------------//
   if ( (TUSB_DESC_INTERFACE == p_desc[DESC_OFFSET_TYPE]) &&
-       (TUSB_CLASS_CDC_DATA      == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )
+       (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )
   {
     (*p_length) += p_desc[DESC_OFFSET_LEN];
-    p_desc = descriptor_next(p_desc);
+    p_desc = tu_desc_next(p_desc);
 
     // data endpoints expected to be in pairs
     for(uint32_t i=0; i<2; i++)
     {
-      tusb_desc_endpoint_t const *p_endpoint = (tusb_desc_endpoint_t const *) p_desc;
-      TU_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType, TUSB_ERROR_USBH_DESCRIPTOR_CORRUPTED);
-      TU_ASSERT(TUSB_XFER_BULK == p_endpoint->bmAttributes.xfer, TUSB_ERROR_USBH_DESCRIPTOR_CORRUPTED);
+      tusb_desc_endpoint_t const *ep_desc = (tusb_desc_endpoint_t const *) p_desc;
+      TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType);
+      TU_ASSERT(TUSB_XFER_BULK == ep_desc->bmAttributes.xfer);
 
-      pipe_handle_t * p_pipe_hdl =  ( p_endpoint->bEndpointAddress &  TUSB_DIR_IN_MASK ) ?
-          &p_cdc->pipe_in : &p_cdc->pipe_out;
+      TU_ASSERT(hcd_edpt_open(rhport, dev_addr, ep_desc));
 
-      (*p_pipe_hdl) = hcd_pipe_open(dev_addr, p_endpoint, TUSB_CLASS_CDC);
-      TU_ASSERT ( pipehandle_is_valid(*p_pipe_hdl), TUSB_ERROR_HCD_OPEN_PIPE_FAILED );
+      if ( tu_edpt_dir(ep_desc->bEndpointAddress) ==  TUSB_DIR_IN )
+      {
+        p_cdc->ep_in = ep_desc->bEndpointAddress;
+      }else
+      {
+        p_cdc->ep_out = ep_desc->bEndpointAddress;
+      }
 
       (*p_length) += p_desc[DESC_OFFSET_LEN];
-      p_desc = descriptor_next( p_desc );
+      p_desc = tu_desc_next( p_desc );
     }
   }
 
+  // FIXME move to seperate API : connect
+  tusb_control_request_t request =
   {
-    // FIXME mounted class flag is not set yet
-    tuh_cdc_mounted_cb(dev_addr);
-  }
+    .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },
+    .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,
+    .wValue = 0x03, // dtr on, cst on
+    .wIndex = p_cdc->itf_num,
+    .wLength = 0
+  };
+
+  TU_ASSERT( usbh_control_xfer(dev_addr, &request, NULL) );
 
-  OSAL_SUBTASK_END
+  return true;
 }
 
-void cdch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)
+void cdch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
-  tuh_cdc_xfer_isr( pipe_hdl.dev_addr, event, get_app_pipeid(pipe_hdl), xferred_bytes );
+  (void) ep_addr;
+  tuh_cdc_xfer_isr( dev_addr, event, 0, xferred_bytes );
 }
 
 void cdch_close(uint8_t dev_addr)
 {
   cdch_data_t * p_cdc = &cdch_data[dev_addr-1];
-
-  (void) hcd_pipe_close(p_cdc->pipe_notification);
-  (void) hcd_pipe_close(p_cdc->pipe_in);
-  (void) hcd_pipe_close(p_cdc->pipe_out);
-
   tu_memclr(p_cdc, sizeof(cdch_data_t));
-
-  tuh_cdc_unmounted_cb(dev_addr);
-
 }
 
 #endif
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index 0b863bb61..5388a8f60 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -62,7 +62,7 @@
  * \retval      true if device supports
  * \retval      false if device does not support or is not mounted
  */
-bool tuh_cdc_serial_is_mounted(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
+bool tuh_cdc_serial_is_mounted(uint8_t dev_addr);
 
 /** \brief      Check if the interface is currently busy or not
  * \param[in]   dev_addr device address
@@ -73,7 +73,7 @@ bool tuh_cdc_serial_is_mounted(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESU
  *              can be scheduled. User needs to make sure the corresponding interface is mounted
  *              (by \ref tuh_cdc_serial_is_mounted) before calling this function.
  */
-bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)  ATTR_PURE ATTR_WARN_UNUSED_RESULT;
+bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid);
 
 /** \brief 			Perform USB OUT transfer to device
  * \param[in]		dev_addr	device address
@@ -86,7 +86,7 @@ bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)  ATTR_PURE ATTR_WARN
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the
  *              interface's callback function. \a p_data must be declared with \ref CFG_TUSB_MEM_SECTION.
  */
-tusb_error_t tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length, bool is_notify);
+bool tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length, bool is_notify);
 
 /** \brief 			Perform USB IN transfer to get data from device
  * \param[in]		dev_addr	device address
@@ -99,22 +99,11 @@ tusb_error_t tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the
  *              interface's callback function. \a p_data must be declared with \ref CFG_TUSB_MEM_SECTION.
  */
-tusb_error_t tuh_cdc_receive(uint8_t dev_addr, void * p_buffer, uint32_t length, bool is_notify);
+bool tuh_cdc_receive(uint8_t dev_addr, void * p_buffer, uint32_t length, bool is_notify);
 
 //--------------------------------------------------------------------+
 // CDC APPLICATION CALLBACKS
 //--------------------------------------------------------------------+
-/** \brief 			Callback function that will be invoked when a device with CDC Abstract Control Model interface is mounted
- * \param[in]	  dev_addr Address of newly mounted device
- * \note        This callback should be used by Application to set-up interface-related data
- */
-void tuh_cdc_mounted_cb(uint8_t dev_addr);
-
-/** \brief 			Callback function that will be invoked when a device with CDC Abstract Control Model interface is unmounted
- * \param[in] 	dev_addr Address of newly unmounted device
- * \note        This callback should be used by Application to tear-down interface-related data
- */
-void tuh_cdc_unmounted_cb(uint8_t dev_addr);
 
 /** \brief      Callback function that is invoked when an transferring event occurred
  * \param[in]		dev_addr	Address of device
@@ -137,22 +126,10 @@ void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_i
 //--------------------------------------------------------------------+
 #ifdef _TINY_USB_SOURCE_FILE_
 
-typedef struct {
-  uint8_t interface_number;
-  uint8_t interface_protocol;
-
-  cdc_acm_capability_t acm_capability;
-
-  pipe_handle_t pipe_notification, pipe_out, pipe_in;
-
-} cdch_data_t;
-
-extern cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX]; // TODO consider to move to cdch internal header file
-
-void         cdch_init(void);
-tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;
-void         cdch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);
-void         cdch_close(uint8_t dev_addr);
+void cdch_init(void);
+bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
+void cdch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+void cdch_close(uint8_t dev_addr);
 
 #endif
 
diff --git a/src/class/cdc/cdc_rndis_host.c b/src/class/cdc/cdc_rndis_host.c
index 89ea3b32f..ae61bf8b5 100644
--- a/src/class/cdc/cdc_rndis_host.c
+++ b/src/class/cdc/cdc_rndis_host.c
@@ -38,7 +38,7 @@
 
 #include "tusb_option.h"
 
-#if (MODE_HOST_SUPPORTED && CFG_TUSB_HOST_CDC && CFG_TUSB_HOST_CDC_RNDIS)
+#if (TUSB_OPT_HOST_ENABLED && CFG_TUH_CDC && CFG_TUH_CDC_RNDIS)
 
 #define _TINY_USB_SOURCE_FILE_
 
diff --git a/src/class/cdc/cdc_rndis_host.h b/src/class/cdc/cdc_rndis_host.h
index 3b92d3f23..730df2e23 100644
--- a/src/class/cdc/cdc_rndis_host.h
+++ b/src/class/cdc/cdc_rndis_host.h
@@ -64,7 +64,7 @@ typedef struct {
 }rndish_data_t;
 
 void rndish_init(void);
-tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc) ATTR_WARN_UNUSED_RESULT;
+tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc);
 void rndish_xfer_isr(cdch_data_t *p_cdc, pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);
 void rndish_close(uint8_t dev_addr);