Merge pull request #20 from hathach/devlocal

Host stack rework

9 files changed, 239 insertions, 268 deletions

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 040c8d4f4..d477a0d23 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"

 

@@ -236,8 +234,7 @@ tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface
   if ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL != p_interface_desc->bInterfaceSubClass) return TUSB_ERROR_CDC_UNSUPPORTED_SUBCLASS;

 

   // 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 ||

+  if ( !(tu_within(CDC_COMM_PROTOCOL_NONE, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||

          p_interface_desc->bInterfaceProtocol == 0xff ) )

   {

     return TUSB_ERROR_CDC_UNSUPPORTED_PROTOCOL;

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 0a3661878..159a13990 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,35 +134,33 @@ 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 = descriptor_next ( (uint8_t const *) 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;

     }

 

@@ -179,18 +169,20 @@ tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   }

 

   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;

+

+    TU_ASSERT( hcd_edpt_open(rhport, dev_addr, ep_desc) );

+    p_cdc->ep_notif = ep_desc->bEndpointAddress;

 

     (*p_length) += p_desc[DESC_OFFSET_LEN];

     p_desc = descriptor_next(p_desc);

-

-    TU_ASSERT(pipehandle_is_valid(p_cdc->pipe_notification), TUSB_ERROR_HCD_OPEN_PIPE_FAILED);

   }

 

   //------------- 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);

@@ -198,46 +190,50 @@ tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
     // 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 ( 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 );

     }

   }

 

+  // 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/custom/custom_host.c b/src/class/custom/custom_host.c
index 9f0b70afb..e840a2829 100644
--- a/src/class/custom/custom_host.c
+++ b/src/class/custom/custom_host.c
@@ -38,7 +38,7 @@
 
 #include "tusb_option.h"
 
-#if (MODE_HOST_SUPPORTED && CFG_TUSB_HOST_CUSTOM_CLASS)
+#if (TUSB_OPT_HOST_ENABLED && CFG_TUSB_HOST_CUSTOM_CLASS)
 
 #define _TINY_USB_SOURCE_FILE_
 
@@ -121,7 +121,7 @@ tusb_error_t cush_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
 
     pipe_handle_t * p_pipe_hdl =  ( p_endpoint->bEndpointAddress &  TUSB_DIR_IN_MASK ) ?
                          &custom_interface[dev_addr-1].pipe_in : &custom_interface[dev_addr-1].pipe_out;
-    *p_pipe_hdl = hcd_pipe_open(dev_addr, p_endpoint, TUSB_CLASS_VENDOR_SPECIFIC);
+    *p_pipe_hdl = hcd_edpt_open(dev_addr, p_endpoint, TUSB_CLASS_VENDOR_SPECIFIC);
     TU_ASSERT ( pipehandle_is_valid(*p_pipe_hdl), TUSB_ERROR_HCD_OPEN_PIPE_FAILED );
 
     p_desc = descriptor_next(p_desc);
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 6aa0748df..1e44055ec 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -38,7 +38,7 @@
 

 #include "tusb_option.h"

 

-#if (MODE_HOST_SUPPORTED && HOST_CLASS_HID)

+#if (TUSB_OPT_HOST_ENABLED && HOST_CLASS_HID)

 

 #define _TINY_USB_SOURCE_FILE_

 //--------------------------------------------------------------------+

@@ -54,20 +54,19 @@
 //--------------------------------------------------------------------+

 // HID Interface common functions

 //--------------------------------------------------------------------+

-static inline tusb_error_t hidh_interface_open(uint8_t dev_addr, uint8_t interface_number, tusb_desc_endpoint_t const *p_endpoint_desc, hidh_interface_info_t *p_hid)

+static inline bool hidh_interface_open(uint8_t dev_addr, uint8_t interface_number, tusb_desc_endpoint_t const *p_endpoint_desc, hidh_interface_info_t *p_hid)

 {

-  p_hid->pipe_hdl         = hcd_pipe_open(dev_addr, p_endpoint_desc, TUSB_CLASS_HID);

+  p_hid->pipe_hdl         = hcd_edpt_open(dev_addr, p_endpoint_desc, TUSB_CLASS_HID);

   p_hid->report_size      = p_endpoint_desc->wMaxPacketSize.size; // TODO get size from report descriptor

   p_hid->interface_number = interface_number;

 

-  TU_ASSERT (pipehandle_is_valid(p_hid->pipe_hdl), TUSB_ERROR_HCD_FAILED);

+  TU_ASSERT (pipehandle_is_valid(p_hid->pipe_hdl));

 

-  return TUSB_ERROR_NONE;

+  return true;

 }

 

 static inline void hidh_interface_close(hidh_interface_info_t *p_hid)

 {

-  (void) hcd_pipe_close(p_hid->pipe_hdl);

   tu_memclr(p_hid, sizeof(hidh_interface_info_t));

 }

 

@@ -78,7 +77,7 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
   // TODO change to use is configured function

   TU_ASSERT (TUSB_DEVICE_STATE_CONFIGURED == tuh_device_get_state(dev_addr), TUSB_ERROR_DEVICE_NOT_READY);

   TU_VERIFY (report, TUSB_ERROR_INVALID_PARA);

-  TU_ASSSERT (!hcd_pipe_is_busy(p_hid->pipe_hdl), TUSB_ERROR_INTERFACE_IS_BUSY);

+  TU_ASSERT (!hcd_edpt_busy(p_hid->pipe_hdl), TUSB_ERROR_INTERFACE_IS_BUSY);

 

   TU_ASSERT_ERR( hcd_pipe_xfer(p_hid->pipe_hdl, report, p_hid->report_size, true) ) ;

 

@@ -88,8 +87,9 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
 //--------------------------------------------------------------------+

 // KEYBOARD

 //--------------------------------------------------------------------+

-#if CFG_TUSB_HOST_HID_KEYBOARD

+#if CFG_TUH_HID_KEYBOARD

 

+#if 0

 #define EXPAND_KEYCODE_TO_ASCII(keycode, ascii, shift_modified)  \

   [0][keycode] = ascii,\

   [1][keycode] = shift_modified,\

@@ -99,8 +99,9 @@ uint8_t const hid_keycode_to_ascii_tbl[2][128] =
 {

     HID_KEYCODE_TABLE(EXPAND_KEYCODE_TO_ASCII)

 };

+#endif

 

-STATIC_VAR hidh_interface_info_t keyboardh_data[CFG_TUSB_HOST_DEVICE_MAX]; // does not have addr0, index = dev_address-1

+static hidh_interface_info_t keyboardh_data[CFG_TUSB_HOST_DEVICE_MAX]; // does not have addr0, index = dev_address-1

 

 //------------- KEYBOARD PUBLIC API (parameter validation required) -------------//

 bool  tuh_hid_keyboard_is_mounted(uint8_t dev_addr)

@@ -116,7 +117,7 @@ tusb_error_t tuh_hid_keyboard_get_report(uint8_t dev_addr, void* p_report)
 bool tuh_hid_keyboard_is_busy(uint8_t dev_addr)

 {

   return  tuh_hid_keyboard_is_mounted(dev_addr) &&

-          hcd_pipe_is_busy( keyboardh_data[dev_addr-1].pipe_hdl );

+          hcd_edpt_busy( keyboardh_data[dev_addr-1].pipe_hdl );

 }

 

 #endif

@@ -124,7 +125,7 @@ bool tuh_hid_keyboard_is_busy(uint8_t dev_addr)
 //--------------------------------------------------------------------+

 // MOUSE

 //--------------------------------------------------------------------+

-#if CFG_TUSB_HOST_HID_MOUSE

+#if CFG_TUH_HID_MOUSE

 

 STATIC_VAR hidh_interface_info_t mouseh_data[CFG_TUSB_HOST_DEVICE_MAX]; // does not have addr0, index = dev_address-1

 

@@ -137,7 +138,7 @@ bool tuh_hid_mouse_is_mounted(uint8_t dev_addr)
 bool tuh_hid_mouse_is_busy(uint8_t dev_addr)

 {

   return  tuh_hid_mouse_is_mounted(dev_addr) &&

-          hcd_pipe_is_busy( mouseh_data[dev_addr-1].pipe_hdl );

+          hcd_edpt_busy( mouseh_data[dev_addr-1].pipe_hdl );

 }

 

 tusb_error_t tuh_hid_mouse_get_report(uint8_t dev_addr, void * report)

@@ -163,11 +164,11 @@ tusb_error_t tuh_hid_mouse_get_report(uint8_t dev_addr, void * report)
 //--------------------------------------------------------------------+

 void hidh_init(void)

 {

-#if CFG_TUSB_HOST_HID_KEYBOARD

+#if CFG_TUH_HID_KEYBOARD

   tu_memclr(&keyboardh_data, sizeof(hidh_interface_info_t)*CFG_TUSB_HOST_DEVICE_MAX);

 #endif

 

-#if CFG_TUSB_HOST_HID_MOUSE

+#if CFG_TUH_HID_MOUSE

   tu_memclr(&mouseh_data, sizeof(hidh_interface_info_t)*CFG_TUSB_HOST_DEVICE_MAX);

 #endif

 

@@ -180,9 +181,8 @@ void hidh_init(void)
 CFG_TUSB_MEM_SECTION uint8_t report_descriptor[256];

 #endif

 

-tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length)

+bool hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length)

 {

-  tusb_error_t error;

   uint8_t const *p_desc = (uint8_t const *) p_interface_desc;

 

   //------------- HID descriptor -------------//

@@ -195,16 +195,15 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   tusb_desc_endpoint_t const * p_endpoint_desc = (tusb_desc_endpoint_t const *) p_desc;

   TU_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint_desc->bDescriptorType, TUSB_ERROR_INVALID_PARA);

 

-  OSAL_SUBTASK_BEGIN

-

   //------------- SET IDLE (0) request -------------//

-  STASK_INVOKE(

-    usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),

-                               HID_REQ_CONTROL_SET_IDLE, 0, p_interface_desc->bInterfaceNumber,

-                               0, NULL ),

-    error

-  );

-	(void) error; // skip if set idle is failed

+  tusb_control_request_t request = {

+        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },

+        .bRequest = HID_REQ_CONTROL_SET_IDLE,

+        .wValue = 0, // idle_rate = 0

+        .wIndex = p_interface_desc->bInterfaceNumber,

+        .wLength = 0

+  };

+  TU_ASSERT( usbh_control_xfer( dev_addr, &request, NULL ) );

 

 #if 0

   //------------- Get Report Descriptor TODO HID parser -------------//

@@ -222,40 +221,42 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
 

   if ( HID_SUBCLASS_BOOT == p_interface_desc->bInterfaceSubClass )

   {

-    #if CFG_TUSB_HOST_HID_KEYBOARD

+    #if CFG_TUH_HID_KEYBOARD

     if ( HID_PROTOCOL_KEYBOARD == p_interface_desc->bInterfaceProtocol)

     {

-      STASK_ASSERT_ERR ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &keyboardh_data[dev_addr-1]) );

+      TU_ASSERT( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &keyboardh_data[dev_addr-1]) );

       tuh_hid_keyboard_mounted_cb(dev_addr);

     } else

     #endif

 

-    #if CFG_TUSB_HOST_HID_MOUSE

+    #if CFG_TUH_HID_MOUSE

     if ( HID_PROTOCOL_MOUSE == p_interface_desc->bInterfaceProtocol)

     {

-      STASK_ASSERT_ERR ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &mouseh_data[dev_addr-1]) );

+      TU_ASSERT ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &mouseh_data[dev_addr-1]) );

       tuh_hid_mouse_mounted_cb(dev_addr);

     } else

     #endif

 

     {

-      STASK_RETURN(TUSB_ERROR_HIDH_NOT_SUPPORTED_PROTOCOL); // exit & restart task

+      // TUSB_ERROR_HIDH_NOT_SUPPORTED_PROTOCOL

+      return false;

     }

   }else

   {

-    STASK_RETURN(TUSB_ERROR_HIDH_NOT_SUPPORTED_SUBCLASS); // exit & restart task

+    // TUSB_ERROR_HIDH_NOT_SUPPORTED_SUBCLASS

+    return false;

   }

 

   *p_length = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + sizeof(tusb_desc_endpoint_t);

 

-  OSAL_SUBTASK_END

+  return true;

 }

 

 void hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)

 {

   (void) xferred_bytes; // TODO may need to use this para later

 

-#if CFG_TUSB_HOST_HID_KEYBOARD

+#if CFG_TUH_HID_KEYBOARD

   if ( pipehandle_is_equal(pipe_hdl, keyboardh_data[pipe_hdl.dev_addr-1].pipe_hdl) )

   {

     tuh_hid_keyboard_isr(pipe_hdl.dev_addr, event);

@@ -263,7 +264,7 @@ void hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_byte
   }

 #endif

 

-#if CFG_TUSB_HOST_HID_MOUSE

+#if CFG_TUH_HID_MOUSE

   if ( pipehandle_is_equal(pipe_hdl, mouseh_data[pipe_hdl.dev_addr-1].pipe_hdl) )

   {

     tuh_hid_mouse_isr(pipe_hdl.dev_addr, event);

@@ -278,7 +279,7 @@ void hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_byte
 

 void hidh_close(uint8_t dev_addr)

 {

-#if CFG_TUSB_HOST_HID_KEYBOARD

+#if CFG_TUH_HID_KEYBOARD

   if ( pipehandle_is_valid( keyboardh_data[dev_addr-1].pipe_hdl ) )

   {

     hidh_interface_close(&keyboardh_data[dev_addr-1]);

@@ -286,7 +287,7 @@ void hidh_close(uint8_t dev_addr)
   }

 #endif

 

-#if CFG_TUSB_HOST_HID_MOUSE

+#if CFG_TUH_HID_MOUSE

   if( pipehandle_is_valid( mouseh_data[dev_addr-1].pipe_hdl ) )

   {

     hidh_interface_close(&mouseh_data[dev_addr-1]);

diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index cb0230e8a..7336f5ada 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -215,10 +215,10 @@ typedef struct {
   uint8_t interface_number;

 }hidh_interface_info_t;

 

-void         hidh_init(void);

-tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

-void         hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

-void         hidh_close(uint8_t dev_addr);

+void hidh_init(void);

+bool hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

+void hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

+void hidh_close(uint8_t dev_addr);

 

 #endif

 

diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index baef7ff44..2c9b2dec7 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -38,7 +38,7 @@
 

 #include "tusb_option.h"

 

-#if MODE_HOST_SUPPORTED & CFG_TUSB_HOST_MSC

+#if TUSB_OPT_HOST_ENABLED & CFG_TUH_MSC

 

 #define _TINY_USB_SOURCE_FILE_

 

@@ -51,13 +51,14 @@
 //--------------------------------------------------------------------+

 // MACRO CONSTANT TYPEDEF

 //--------------------------------------------------------------------+

-CFG_TUSB_MEM_SECTION STATIC_VAR msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX];

+CFG_TUSB_MEM_SECTION static msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX];

 

 //------------- Initalization Data -------------//

+static osal_semaphore_def_t msch_sem_def;

 static osal_semaphore_t msch_sem_hdl;

 

 // buffer used to read scsi information when mounted, largest response data currently is inquiry

-CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4) STATIC_VAR uint8_t msch_buffer[sizeof(scsi_inquiry_data_t)];

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4) static uint8_t msch_buffer[sizeof(scsi_inquiry_resp_t)];

 

 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

@@ -75,7 +76,7 @@ bool tuh_msc_is_mounted(uint8_t dev_addr)
 bool tuh_msc_is_busy(uint8_t dev_addr)

 {

   return  msch_data[dev_addr-1].is_initialized &&

-          hcd_pipe_is_busy(msch_data[dev_addr-1].bulk_in);

+          hcd_edpt_busy(dev_addr, msch_data[dev_addr-1].ep_in);

 }

 

 uint8_t const* tuh_msc_get_vendor_name(uint8_t dev_addr)

@@ -109,23 +110,22 @@ static inline void msc_cbw_add_signature(msc_cbw_t *p_cbw, uint8_t lun)
   p_cbw->lun        = lun;

 }

 

-static tusb_error_t msch_command_xfer(msch_interface_t * p_msch, void* p_buffer) ATTR_WARN_UNUSED_RESULT;

-static tusb_error_t msch_command_xfer(msch_interface_t * p_msch, void* p_buffer)

+static tusb_error_t msch_command_xfer(uint8_t dev_addr, msch_interface_t * p_msch, void* p_buffer)

 {

   if ( NULL != p_buffer)

   { // there is data phase

     if (p_msch->cbw.dir & TUSB_DIR_IN_MASK)

     {

-      TU_ASSERT_ERR( hcd_pipe_xfer(p_msch->bulk_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t), false) );

-      TU_ASSERT_ERR( hcd_pipe_queue_xfer(p_msch->bulk_in , p_buffer, p_msch->cbw.xfer_bytes) );

+      TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t), false), TUSB_ERROR_FAILED );

+      TU_ASSERT( hcd_pipe_queue_xfer(dev_addr, p_msch->ep_in , p_buffer, p_msch->cbw.total_bytes), TUSB_ERROR_FAILED );

     }else

     {

-      TU_ASSERT_ERR( hcd_pipe_queue_xfer(p_msch->bulk_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t)) );

-      TU_ASSERT_ERR( hcd_pipe_xfer(p_msch->bulk_out , p_buffer, p_msch->cbw.xfer_bytes, false) );

+      TU_ASSERT( hcd_pipe_queue_xfer(dev_addr, p_msch->ep_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t)), TUSB_ERROR_FAILED );

+      TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_out , p_buffer, p_msch->cbw.total_bytes, false), TUSB_ERROR_FAILED );

     }

   }

 

-  TU_ASSERT_ERR( hcd_pipe_xfer(p_msch->bulk_in , (uint8_t*) &p_msch->csw, sizeof(msc_csw_t), true) );

+  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_in , (uint8_t*) &p_msch->csw, sizeof(msc_csw_t), true), TUSB_ERROR_FAILED);

 

   return TUSB_ERROR_NONE;

 }

@@ -136,7 +136,7 @@ tusb_error_t tusbh_msc_inquiry(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
 

   //------------- Command Block Wrapper -------------//

   msc_cbw_add_signature(&p_msch->cbw, lun);

-  p_msch->cbw.xfer_bytes = sizeof(scsi_inquiry_data_t);

+  p_msch->cbw.total_bytes = sizeof(scsi_inquiry_resp_t);

   p_msch->cbw.dir        = TUSB_DIR_IN_MASK;

   p_msch->cbw.cmd_len    = sizeof(scsi_inquiry_t);

 

@@ -144,12 +144,12 @@ tusb_error_t tusbh_msc_inquiry(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
   scsi_inquiry_t cmd_inquiry =

   {

       .cmd_code     = SCSI_CMD_INQUIRY,

-      .alloc_length = sizeof(scsi_inquiry_data_t)

+      .alloc_length = sizeof(scsi_inquiry_resp_t)

   };

 

   memcpy(p_msch->cbw.command, &cmd_inquiry, p_msch->cbw.cmd_len);

 

-  TU_ASSERT_ERR ( msch_command_xfer(p_msch, p_data) );

+  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_data) );

 

   return TUSB_ERROR_NONE;

 }

@@ -160,7 +160,7 @@ tusb_error_t tusbh_msc_read_capacity10(uint8_t dev_addr, uint8_t lun, uint8_t *p
 

   //------------- Command Block Wrapper -------------//

   msc_cbw_add_signature(&p_msch->cbw, lun);

-  p_msch->cbw.xfer_bytes = sizeof(scsi_read_capacity10_data_t);

+  p_msch->cbw.total_bytes = sizeof(scsi_read_capacity10_resp_t);

   p_msch->cbw.dir        = TUSB_DIR_IN_MASK;

   p_msch->cbw.cmd_len    = sizeof(scsi_read_capacity10_t);

 

@@ -174,7 +174,7 @@ tusb_error_t tusbh_msc_read_capacity10(uint8_t dev_addr, uint8_t lun, uint8_t *p
 

   memcpy(p_msch->cbw.command, &cmd_read_capacity10, p_msch->cbw.cmd_len);

 

-  TU_ASSERT_ERR ( msch_command_xfer(p_msch, p_data) );

+  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_data) );

 

   return TUSB_ERROR_NONE;

 }

@@ -186,7 +186,7 @@ tusb_error_t tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_dat
   msch_interface_t* p_msch = &msch_data[dev_addr-1];

 

   //------------- Command Block Wrapper -------------//

-  p_msch->cbw.xfer_bytes = 18;

+  p_msch->cbw.total_bytes = 18;

   p_msch->cbw.dir        = TUSB_DIR_IN_MASK;

   p_msch->cbw.cmd_len    = sizeof(scsi_request_sense_t);

 

@@ -199,7 +199,7 @@ tusb_error_t tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_dat
 

   memcpy(p_msch->cbw.command, &cmd_request_sense, p_msch->cbw.cmd_len);

 

-  TU_ASSERT_ERR ( msch_command_xfer(p_msch, p_data) );

+  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_data) );

 

   return TUSB_ERROR_NONE;

 }

@@ -211,7 +211,7 @@ tusb_error_t tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  msc_csw_t *
   //------------- Command Block Wrapper -------------//

   msc_cbw_add_signature(&p_msch->cbw, lun);

 

-  p_msch->cbw.xfer_bytes = 0; // Number of bytes

+  p_msch->cbw.total_bytes = 0; // Number of bytes

   p_msch->cbw.dir        = TUSB_DIR_OUT;

   p_msch->cbw.cmd_len    = sizeof(scsi_test_unit_ready_t);

 

@@ -225,8 +225,8 @@ tusb_error_t tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  msc_csw_t *
   memcpy(p_msch->cbw.command, &cmd_test_unit_ready, p_msch->cbw.cmd_len);

 

   // TODO MSCH refractor test uinit ready

-  TU_ASSERT_ERR( hcd_pipe_xfer(p_msch->bulk_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t), false) );

-  TU_ASSERT_ERR( hcd_pipe_xfer(p_msch->bulk_in , (uint8_t*) p_csw, sizeof(msc_csw_t), true) );

+  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t), false), TUSB_ERROR_FAILED );

+  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_in , (uint8_t*) p_csw, sizeof(msc_csw_t), true), TUSB_ERROR_FAILED );

 

   return TUSB_ERROR_NONE;

 }

@@ -238,7 +238,7 @@ tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
   //------------- Command Block Wrapper -------------//

   msc_cbw_add_signature(&p_msch->cbw, lun);

 

-  p_msch->cbw.xfer_bytes = p_msch->block_size*block_count; // Number of bytes

+  p_msch->cbw.total_bytes = p_msch->block_size*block_count; // Number of bytes

   p_msch->cbw.dir        = TUSB_DIR_IN_MASK;

   p_msch->cbw.cmd_len    = sizeof(scsi_read10_t);

 

@@ -247,12 +247,12 @@ tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
   {

       .cmd_code    = SCSI_CMD_READ_10,

       .lba         = __n2be(lba),

-      .block_count = u16_le2be(block_count)

+      .block_count = tu_u16_le2be(block_count)

   };

 

   memcpy(p_msch->cbw.command, &cmd_read10, p_msch->cbw.cmd_len);

 

-  TU_ASSERT_ERR ( msch_command_xfer(p_msch, p_buffer));

+  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_buffer));

 

   return TUSB_ERROR_NONE;

 }

@@ -264,7 +264,7 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
   //------------- Command Block Wrapper -------------//

   msc_cbw_add_signature(&p_msch->cbw, lun);

 

-  p_msch->cbw.xfer_bytes = p_msch->block_size*block_count; // Number of bytes

+  p_msch->cbw.total_bytes = p_msch->block_size*block_count; // Number of bytes

   p_msch->cbw.dir        = TUSB_DIR_OUT;

   p_msch->cbw.cmd_len    = sizeof(scsi_write10_t);

 

@@ -273,12 +273,12 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
   {

       .cmd_code    = SCSI_CMD_WRITE_10,

       .lba         = __n2be(lba),

-      .block_count = u16_le2be(block_count)

+      .block_count = tu_u16_le2be(block_count)

   };

 

   memcpy(p_msch->cbw.command, &cmd_write10, p_msch->cbw.cmd_len);

 

-  TU_ASSERT_ERR ( msch_command_xfer(p_msch, (void*) p_buffer));

+  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, (void*) p_buffer));

 

   return TUSB_ERROR_NONE;

 }

@@ -289,133 +289,130 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
 void msch_init(void)

 {

   tu_memclr(msch_data, sizeof(msch_interface_t)*CFG_TUSB_HOST_DEVICE_MAX);

-  msch_sem_hdl = osal_semaphore_create(1, 0);

+  msch_sem_hdl = osal_semaphore_create(&msch_sem_def);

 }

 

-tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length)

+bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length)

 {

-  tusb_error_t error;

+  TU_VERIFY (MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&

+             MSC_PROTOCOL_BOT  == itf_desc->bInterfaceProtocol);

 

-  OSAL_SUBTASK_BEGIN

-

-  if (! ( MSC_SUBCLASS_SCSI == p_interface_desc->bInterfaceSubClass &&

-          MSC_PROTOCOL_BOT  == p_interface_desc->bInterfaceProtocol ) )

-  {

-    return TUSB_ERROR_MSC_UNSUPPORTED_PROTOCOL;

-  }

+  msch_interface_t* p_msc = &msch_data[dev_addr-1];

 

   //------------- Open Data Pipe -------------//

-  tusb_desc_endpoint_t const *p_endpoint;

-  p_endpoint = (tusb_desc_endpoint_t const *) descriptor_next( (uint8_t const*) p_interface_desc );

+  tusb_desc_endpoint_t const * ep_desc = (tusb_desc_endpoint_t const *) descriptor_next( (uint8_t const*) itf_desc );

 

   for(uint32_t i=0; i<2; i++)

   {

-    STASK_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType);

-    STASK_ASSERT(TUSB_XFER_BULK == p_endpoint->bmAttributes.xfer);

+    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 ) ?

-        &msch_data[dev_addr-1].bulk_in : &msch_data[dev_addr-1].bulk_out;

+    TU_ASSERT(hcd_edpt_open(rhport, dev_addr, ep_desc));

 

-    (*p_pipe_hdl) = hcd_pipe_open(dev_addr, p_endpoint, TUSB_CLASS_MSC);

-    STASK_ASSERT( pipehandle_is_valid(*p_pipe_hdl) );

+    if ( edpt_dir(ep_desc->bEndpointAddress) ==  TUSB_DIR_IN )

+    {

+      p_msc->ep_in = ep_desc->bEndpointAddress;

+    }else

+    {

+      p_msc->ep_out = ep_desc->bEndpointAddress;

+    }

 

-    p_endpoint = (tusb_desc_endpoint_t const *) descriptor_next( (uint8_t const*)  p_endpoint );

+    ep_desc = (tusb_desc_endpoint_t const *) descriptor_next( (uint8_t const*)  ep_desc );

   }

 

-  msch_data[dev_addr-1].interface_number = p_interface_desc->bInterfaceNumber;

+  p_msc->itf_numr = itf_desc->bInterfaceNumber;

   (*p_length) += sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t);

 

-

   //------------- Get Max Lun -------------//

-  STASK_INVOKE(

-    usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),

-                               MSC_REQ_GET_MAX_LUN, 0, msch_data[dev_addr-1].interface_number,

-                               1, msch_buffer ),

-    error

-  );

-

-  STASK_ASSERT( TUSB_ERROR_NONE == error /* && TODO STALL means zero */);

-  msch_data[dev_addr-1].max_lun = msch_buffer[0];

+  tusb_control_request_t request = {

+        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_IN },

+        .bRequest = MSC_REQ_GET_MAX_LUN,

+        .wValue = 0,

+        .wIndex = p_msc->itf_numr,

+        .wLength = 1

+  };

+  // TODO STALL means zero

+  TU_ASSERT( usbh_control_xfer( dev_addr, &request, msch_buffer ) );

+  p_msc->max_lun = msch_buffer[0];

 

 #if 0

   //------------- Reset -------------//

-  STASK_INVOKE(

-    usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),

-                               MSC_REQ_RESET, 0, msch_data[dev_addr-1].interface_number,

-                               0, NULL ),

-    error

-  );

+  request = (tusb_control_request_t) {

+        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },

+        .bRequest = MSC_REQ_RESET,

+        .wValue = 0,

+        .wIndex = p_msc->itf_numr,

+        .wLength = 0

+  };

+  TU_ASSERT( usbh_control_xfer( dev_addr, &request, NULL ) );

 #endif

 

   enum { SCSI_XFER_TIMEOUT = 2000 };

   //------------- SCSI Inquiry -------------//

   tusbh_msc_inquiry(dev_addr, 0, msch_buffer);

-  osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-  STASK_ASSERT_ERR(error);

+  TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT) );

 

-  memcpy(msch_data[dev_addr-1].vendor_id , ((scsi_inquiry_data_t*) msch_buffer)->vendor_id , 8);

-  memcpy(msch_data[dev_addr-1].product_id, ((scsi_inquiry_data_t*) msch_buffer)->product_id, 16);

+  memcpy(p_msc->vendor_id , ((scsi_inquiry_resp_t*) msch_buffer)->vendor_id , 8);

+  memcpy(p_msc->product_id, ((scsi_inquiry_resp_t*) msch_buffer)->product_id, 16);

 

   //------------- SCSI Read Capacity 10 -------------//

   tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);

-  osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-  STASK_ASSERT_ERR(error);

+  TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));

 

   // NOTE: my toshiba thumb-drive stall the first Read Capacity and require the sequence

   // Read Capacity --> Stalled --> Clear Stall --> Request Sense --> Read Capacity (2) to work

-  if ( hcd_pipe_is_stalled(msch_data[dev_addr-1].bulk_in) )

-  { // clear stall TODO abstract clear stall function

-    STASK_INVOKE(

-      usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_ENDPOINT),

-                                 TUSB_REQ_CLEAR_FEATURE, 0, hcd_pipe_get_endpoint_addr(msch_data[dev_addr-1].bulk_in),

-                                 0, NULL ),

-      error

-    );

-    STASK_ASSERT_ERR(error);

+  if ( hcd_edpt_stalled(dev_addr, p_msc->ep_in) )

+  {

+    // clear stall TODO abstract clear stall function

+    request = (tusb_control_request_t) {

+      .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_ENDPOINT, .type = TUSB_REQ_TYPE_STANDARD, .direction = TUSB_DIR_OUT },

+          .bRequest = TUSB_REQ_CLEAR_FEATURE,

+          .wValue = 0,

+          .wIndex = p_msc->ep_in,

+          .wLength = 0

+    };

 

-    hcd_pipe_clear_stall(msch_data[dev_addr-1].bulk_in);

-    osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error); // wait for SCSI status

-    STASK_ASSERT_ERR(error);

+    TU_ASSERT(usbh_control_xfer( dev_addr, &request, NULL ));

+

+    hcd_edpt_clear_stall(dev_addr, p_msc->ep_in);

+    TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT) ); // wait for SCSI status

 

     //------------- SCSI Request Sense -------------//

     (void) tuh_msc_request_sense(dev_addr, 0, msch_buffer);

-    osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-    STASK_ASSERT_ERR(error);

+    TU_ASSERT(osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));

 

     //------------- Re-read SCSI Read Capactity -------------//

     tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);

-    osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-    STASK_ASSERT_ERR(error);

+    TU_ASSERT(osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));

   }

 

-  msch_data[dev_addr-1].last_lba   = __be2n( ((scsi_read_capacity10_data_t*)msch_buffer)->last_lba );

-  msch_data[dev_addr-1].block_size = (uint16_t) __be2n( ((scsi_read_capacity10_data_t*)msch_buffer)->block_size );

+  p_msc->last_lba   = __be2n( ((scsi_read_capacity10_resp_t*)msch_buffer)->last_lba );

+  p_msc->block_size = (uint16_t) __be2n( ((scsi_read_capacity10_resp_t*)msch_buffer)->block_size );

+

+  p_msc->is_initialized = true;

 

-  msch_data[dev_addr-1].is_initialized = true;

   tuh_msc_mounted_cb(dev_addr);

 

-  OSAL_SUBTASK_END

+  return true;

 }

 

-void msch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)

+void msch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)

 {

-  if ( pipehandle_is_equal(pipe_hdl, msch_data[pipe_hdl.dev_addr-1].bulk_in) )

+  msch_interface_t* p_msc = &msch_data[dev_addr-1];

+  if ( ep_addr == p_msc->ep_in )

   {

-    if (msch_data[pipe_hdl.dev_addr-1].is_initialized)

+    if (p_msc->is_initialized)

     {

-      tuh_msc_isr(pipe_hdl.dev_addr, event, xferred_bytes);

+      tuh_msc_isr(dev_addr, event, xferred_bytes);

     }else

     { // still initializing under open subtask

-      osal_semaphore_post(msch_sem_hdl);

+      osal_semaphore_post(msch_sem_hdl, true);

     }

   }

 }

 

 void msch_close(uint8_t dev_addr)

 {

-  (void) hcd_pipe_close(msch_data[dev_addr-1].bulk_in);

-  (void) hcd_pipe_close(msch_data[dev_addr-1].bulk_out);

-

   tu_memclr(&msch_data[dev_addr-1], sizeof(msch_interface_t));

   osal_semaphore_reset(msch_sem_hdl);

 

diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index a408bbeaf..968d221b4 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -187,9 +187,11 @@ void tuh_msc_isr(uint8_t dev_addr, xfer_result_t event, uint32_t xferred_bytes);
 //--------------------------------------------------------------------+

 #ifdef _TINY_USB_SOURCE_FILE_

 

-typedef struct {

-  pipe_handle_t bulk_in, bulk_out;

-  uint8_t  interface_number;

+typedef struct

+{

+  uint8_t itf_numr;

+  uint8_t  ep_in;

+  uint8_t  ep_out;

 

   uint8_t  max_lun;

   uint16_t block_size;

@@ -203,10 +205,11 @@ typedef struct {
   msc_csw_t csw;

 }msch_interface_t;

 

-void         msch_init(void);

-tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

-void         msch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

-void         msch_close(uint8_t dev_addr);

+void msch_init(void);

+bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);

+void msch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);

+void msch_close(uint8_t dev_addr);

+

 #endif

 

 #ifdef __cplusplus