refactor usbh_class_driver_t's open() to return number of driver len instead of bool. help to simplify parsing configuration

10 files changed, 295 insertions, 629 deletions

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 28abbf098..ff1a8338d 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -41,13 +41,14 @@
 #include "serial/pl2303.h"
 
 // Level where CFG_TUSB_DEBUG must be at least for this driver is logged
-#ifndef CFG_TUH_CDC_LOG_LEVEL
-  #define CFG_TUH_CDC_LOG_LEVEL   2
-#endif
+  #ifndef CFG_TUH_CDC_LOG_LEVEL
+    #define CFG_TUH_CDC_LOG_LEVEL 2
+  #endif
 
-#define TU_LOG_DRV(...)                 TU_LOG(CFG_TUH_CDC_LOG_LEVEL, __VA_ARGS__)
-#define TU_LOG_CDC(_cdc, _format, ...)  TU_LOG_DRV("[:%u:%u] CDCh %s " _format "\r\n", _cdc->daddr, _cdc->bInterfaceNumber, \
-                                                    serial_drivers[_cdc->serial_drid].name, ##__VA_ARGS__)
+  #define TU_LOG_DRV(...) TU_LOG(CFG_TUH_CDC_LOG_LEVEL, __VA_ARGS__)
+  #define TU_LOG_CDC(_cdc, _format, ...)                                                \
+    TU_LOG_DRV("[:%u:%u] CDCh %s " _format "\r\n", _cdc->daddr, _cdc->bInterfaceNumber, \
+               serial_drivers[_cdc->serial_drid].name, ##__VA_ARGS__)
 
 //--------------------------------------------------------------------+
 // Host CDC Interface
@@ -113,63 +114,59 @@ static void cdch_set_line_coding_stage1_baudrate_complete(tuh_xfer_t *xfer);
 static void cdch_set_line_coding_stage2_data_format_complete(tuh_xfer_t *xfer);
 
 //------------- ACM prototypes -------------//
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
-static bool acm_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-static void acm_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-
-static bool acm_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_control_line_state(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static uint16_t acm_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+static bool     acm_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void     acm_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static bool     acm_set_line_coding(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     acm_set_control_line_state(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
-//------------- FTDI prototypes -------------//
-#if CFG_TUH_CDC_FTDI
+  //------------- FTDI prototypes -------------//
+  #if CFG_TUH_CDC_FTDI
 static uint16_t const ftdi_vid_pid_list[][2] = {CFG_TUH_CDC_FTDI_VID_PID_LIST};
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len);
-static bool ftdi_proccess_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-static void ftdi_internal_control_complete(cdch_interface_t* p_cdc, tuh_xfer_t *xfer);
 
-static bool ftdi_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-#endif
+static uint16_t ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+static bool     ftdi_proccess_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void     ftdi_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static bool     ftdi_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     ftdi_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     ftdi_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  #endif
 
-//------------- CP210X prototypes -------------//
-#if CFG_TUH_CDC_CP210X
+  //------------- CP210X prototypes -------------//
+  #if CFG_TUH_CDC_CP210X
 static uint16_t const cp210x_vid_pid_list[][2] = {CFG_TUH_CDC_CP210X_VID_PID_LIST};
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
-static bool cp210x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-static void cp210x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-
-static bool cp210x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-#endif
+static uint16_t cp210x_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+static bool     cp210x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void     cp210x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static bool     cp210x_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     cp210x_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     cp210x_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  #endif
 
-//------------- CH34x prototypes -------------//
-#if CFG_TUH_CDC_CH34X
+  //------------- CH34x prototypes -------------//
+  #if CFG_TUH_CDC_CH34X
 static uint16_t const ch34x_vid_pid_list[][2] = {CFG_TUH_CDC_CH34X_VID_PID_LIST};
 
-static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
-static bool ch34x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-static void ch34x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-
-static bool ch34x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-#endif
+static uint16_t ch34x_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+static bool     ch34x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void     ch34x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static bool     ch34x_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     ch34x_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     ch34x_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  #endif
 
-//------------- PL2303 prototypes -------------//
-#if CFG_TUH_CDC_PL2303
+  //------------- PL2303 prototypes -------------//
+  #if CFG_TUH_CDC_PL2303
 static uint16_t const pl2303_vid_pid_list[][2] = {CFG_TUH_CDC_PL2303_VID_PID_LIST};
 static const pl2303_type_data_t pl2303_type_data[PL2303_TYPE_COUNT] = {PL2303_TYPE_DATA};
 
-static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
-static bool pl2303_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-static void pl2303_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
-
-static bool pl2303_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool pl2303_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-#endif
+static uint16_t pl2303_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+static bool     pl2303_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void     pl2303_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static bool     pl2303_set_line_coding(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool     pl2303_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  #endif
 
 //------------- Common -------------//
 enum {
@@ -197,11 +194,12 @@ enum {
 typedef bool (*serial_driver_func_t)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 typedef struct {
-  uint16_t const (*vid_pid_list)[2];
-  uint16_t const vid_pid_count;
-  bool (*const open)(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len);
-  bool (*const process_set_config)(cdch_interface_t * p_cdc, tuh_xfer_t * xfer);
-  void (*const request_complete)(cdch_interface_t * p_cdc, tuh_xfer_t * xfer); // internal request complete handler to update line state
+  const uint16_t (*vid_pid_list)[2];
+  const uint16_t vid_pid_count;
+  uint16_t (*const open)(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+  bool (*const process_set_config)(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+  // internal request complete handler to update line state
+  void (*const request_complete)(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
 
   serial_driver_func_t set_control_line_state, set_baudrate, set_data_format, set_line_coding;
 
@@ -731,11 +729,10 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
 //--------------------------------------------------------------------+
 static bool open_ep_stream_pair(cdch_interface_t *p_cdc, tusb_desc_endpoint_t const *desc_ep) {
   for (size_t i = 0; i < 2; i++) {
-    TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType &&
-              TUSB_XFER_BULK == desc_ep->bmAttributes.xfer);
+    TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType && TUSB_XFER_BULK == desc_ep->bmAttributes.xfer, 0);
     TU_ASSERT(tuh_edpt_open(p_cdc->daddr, desc_ep));
-    tu_edpt_stream_t *stream =
-      (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) ? &p_cdc->stream.rx : &p_cdc->stream.tx;
+    const uint8_t     ep_dir = tu_edpt_dir(desc_ep->bEndpointAddress);
+    tu_edpt_stream_t *stream = (ep_dir == TUSB_DIR_IN) ? &p_cdc->stream.rx : &p_cdc->stream.tx;
     tu_edpt_stream_open(stream, p_cdc->daddr, desc_ep);
     tu_edpt_stream_clear(stream);
 
@@ -745,8 +742,8 @@ static bool open_ep_stream_pair(cdch_interface_t *p_cdc, tusb_desc_endpoint_t co
   return true;
 }
 
-bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
-  (void) rhport;
+uint16_t cdch_open(uint8_t rhport, uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
+  (void)rhport;
   // For CDC: only support ACM subclass
   // Note: Protocol 0xFF can be RNDIS device
   if (TUSB_CLASS_CDC == itf_desc->bInterfaceClass &&
@@ -755,15 +752,15 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_d
   } else if (SERIAL_DRIVER_COUNT > 1 &&
              TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass) {
     uint16_t vid, pid;
-    TU_VERIFY(tuh_vid_pid_get(daddr, &vid, &pid));
+    TU_VERIFY(tuh_vid_pid_get(daddr, &vid, &pid), 0);
 
-    for (size_t dr = 1; dr < SERIAL_DRIVER_COUNT; dr++) {
-      const cdch_serial_driver_t *driver = &serial_drivers[dr];
+    for (size_t drv = 1; drv < SERIAL_DRIVER_COUNT; drv++) {
+      const cdch_serial_driver_t *driver = &serial_drivers[drv];
       for (size_t i = 0; i < driver->vid_pid_count; i++) {
         if (driver->vid_pid_list[i][0] == vid && driver->vid_pid_list[i][1] == pid) {
-          const bool ret = driver->open(daddr, itf_desc, max_len);
+          const uint16_t drv_len = driver->open(daddr, itf_desc, max_len);
           TU_LOG_DRV("[:%u:%u] CDCh %s open %s\r\n", daddr, itf_desc->bInterfaceNumber, driver->name, ret ? "OK" : "FAILED");
-          return ret;
+          return drv_len;
         }
       }
     }
@@ -771,7 +768,7 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_d
     // not supported class
   }
 
-  return false;
+  return 0;
 }
 
 bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
@@ -1012,19 +1009,19 @@ enum {
   CONFIG_ACM_COMPLETE = 0
 };
 
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
-  uint8_t const *p_desc_end = ((uint8_t const *) itf_desc) + max_len;
+static uint16_t acm_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
+  const uint8_t *p_desc   = (const uint8_t *)itf_desc;
+  const uint8_t *desc_end = p_desc + max_len;
 
   cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
-
+  TU_VERIFY(p_cdc, 0);
   p_cdc->serial_drid = SERIAL_DRIVER_ACM;
 
   //------------- Control Interface -------------//
-  uint8_t const *p_desc = tu_desc_next(itf_desc);
+  p_desc = tu_desc_next(p_desc);
 
   // Communication Functional Descriptors
-  while ((p_desc < p_desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
+  while ((p_desc < desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
     if (CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc)) {
       // save ACM bmCapabilities
       p_cdc->acm.capability = ((cdc_desc_func_acm_t const *) p_desc)->bmCapabilities;
@@ -1035,26 +1032,27 @@ static bool acm_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint1
 
   // Open notification endpoint of control interface if any
   if (itf_desc->bNumEndpoints == 1) {
-    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(daddr, desc_ep));
+    TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc), 0);
+    const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)p_desc;
+    TU_ASSERT(tuh_edpt_open(daddr, desc_ep), 0);
     p_cdc->ep_notif = desc_ep->bEndpointAddress;
 
     p_desc = tu_desc_next(p_desc);
   }
 
   //------------- Data Interface (if any) -------------//
-  if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
-      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass)) {
-    // next to endpoint descriptor
-    p_desc = tu_desc_next(p_desc);
+  if (TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) {
+    const tusb_desc_interface_t *data_itf = (const tusb_desc_interface_t *)p_desc;
+    if (data_itf->bInterfaceClass == TUSB_CLASS_CDC_DATA) {
+      p_desc = tu_desc_next(p_desc); // next to endpoint descriptor
 
-    // data endpoints expected to be in pairs
-    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const *) p_desc));
+      // data endpoints expected to be in pairs
+      TU_ASSERT(open_ep_stream_pair(p_cdc, (const tusb_desc_endpoint_t *)p_desc), 0);
+      p_desc += data_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t);
+    }
   }
 
-  return true;
+  return (uint16_t)((uintptr_t)p_desc - (uintptr_t)itf_desc);
 }
 
 static bool acm_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
@@ -1187,28 +1185,29 @@ enum {
   CONFIG_FTDI_COMPLETE
 };
 
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
+static uint16_t ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
   // FTDI Interface includes 1 vendor interface + 2 bulk endpoints
   TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff &&
-            itf_desc->bNumEndpoints == 2);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2 * sizeof(tusb_desc_endpoint_t) <= max_len);
+              itf_desc->bNumEndpoints == 2,
+            0);
+  const uint16_t drv_len = sizeof(tusb_desc_interface_t) + itf_desc->bNumEndpoints * sizeof(tusb_desc_endpoint_t);
+  TU_VERIFY(drv_len <= max_len, 0);
 
   cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
+  TU_VERIFY(p_cdc, 0);
 
   p_cdc->serial_drid = SERIAL_DRIVER_FTDI;
 
   // endpoint pair
-  tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+  const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)tu_desc_next(itf_desc);
 
-  /*
-   * NOTE: Some customers have programmed FT232R/FT245R devices
-   * with an endpoint size of 0 - not good.
-   */
-  TU_ASSERT(desc_ep->wMaxPacketSize != 0);
+  /* NOTE: Some users have programmed FT232R/FT245R devices
+   * with an endpoint size of 0 !!! */
+  TU_ASSERT(desc_ep->wMaxPacketSize != 0, 0);
 
-  // data endpoints expected to be in pairs
-  return open_ep_stream_pair(p_cdc, desc_ep);
+  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep), 0);
+
+  return drv_len;
 }
 
 static bool ftdi_proccess_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
@@ -1579,21 +1578,22 @@ enum {
   CONFIG_CP210X_COMPLETE
 };
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+static uint16_t cp210x_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
   // CP210x Interface includes 1 vendor interface + 2 bulk endpoints
-  TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2 * sizeof(tusb_desc_endpoint_t) <= max_len);
+  TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2, 0);
+  const uint16_t drv_len = sizeof(tusb_desc_interface_t) + itf_desc->bNumEndpoints * sizeof(tusb_desc_endpoint_t);
+  TU_VERIFY(drv_len <= max_len, 0);
 
   cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
+  TU_VERIFY(p_cdc, 0);
 
   p_cdc->serial_drid = SERIAL_DRIVER_CP210X;
 
-  // endpoint pair
-  tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
-
   // data endpoints expected to be in pairs
-  return open_ep_stream_pair(p_cdc, desc_ep);
+  const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)tu_desc_next(itf_desc);
+  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
+
+  return drv_len;
 }
 
 static bool cp210x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
@@ -1753,29 +1753,29 @@ enum {
   CONFIG_CH34X_COMPLETE
 };
 
-static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
+static uint16_t ch34x_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
   // CH34x Interface includes 1 vendor interface + 2 bulk + 1 interrupt endpoints
-  TU_VERIFY(itf_desc->bNumEndpoints == 3);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
+  TU_VERIFY(itf_desc->bNumEndpoints == 3, 0);
+  const uint16_t drv_len = sizeof(tusb_desc_interface_t) + itf_desc->bNumEndpoints * sizeof(tusb_desc_endpoint_t);
+  TU_VERIFY(drv_len <= max_len, 0);
 
   cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
+  TU_VERIFY(p_cdc, 0);
 
   p_cdc->serial_drid = SERIAL_DRIVER_CH34X;
 
-  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+  const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)tu_desc_next(itf_desc);
 
   // data endpoints expected to be in pairs
-  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
-  desc_ep += 2;
+  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep), 0);
+  desc_ep = (const tusb_desc_endpoint_t *)((uintptr_t)desc_ep + 2 * sizeof(tusb_desc_endpoint_t));
 
   // Interrupt endpoint: not used for now
-  TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(desc_ep) &&
-            TUSB_XFER_INTERRUPT == desc_ep->bmAttributes.xfer);
-  TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+  TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(desc_ep) && TUSB_XFER_INTERRUPT == desc_ep->bmAttributes.xfer, 0);
+  TU_ASSERT(tuh_edpt_open(daddr, desc_ep), 0);
   p_cdc->ep_notif = desc_ep->bEndpointAddress;
 
-  return true;
+  return drv_len;
 }
 
 static bool ch34x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
@@ -2089,13 +2089,14 @@ enum {
   CONFIG_PL2303_COMPLETE
 };
 
-static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+static uint16_t pl2303_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
   // PL2303 Interface includes 1 vendor interface + 1 interrupt endpoints + 2 bulk
-  TU_VERIFY(itf_desc->bNumEndpoints == 3);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
+  TU_VERIFY(itf_desc->bNumEndpoints == 3, 0);
+  const uint16_t drv_len = sizeof(tusb_desc_interface_t) + itf_desc->bNumEndpoints * sizeof(tusb_desc_endpoint_t);
+  TU_VERIFY(drv_len <= max_len, 0);
 
   cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
+  TU_VERIFY(p_cdc, 0);
 
   p_cdc->serial_drid = SERIAL_DRIVER_PL2303;
   p_cdc->pl2303.quirks = 0;
@@ -2104,16 +2105,15 @@ static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, ui
   tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
 
   // Interrupt endpoint: not used for now
-  TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(desc_ep) &&
-            TUSB_XFER_INTERRUPT == desc_ep->bmAttributes.xfer);
-  TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+  TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(desc_ep) && TUSB_XFER_INTERRUPT == desc_ep->bmAttributes.xfer, 0);
+  TU_ASSERT(tuh_edpt_open(daddr, desc_ep), 0);
   p_cdc->ep_notif = desc_ep->bEndpointAddress;
   desc_ep += 1;
 
   // data endpoints expected to be in pairs
-  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
+  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep), 0);
 
-  return true;
+  return drv_len;
 }
 
 static bool pl2303_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index e8637beac..57919c7ff 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -30,7 +30,7 @@
 #include "cdc.h"
 
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif
 
 //--------------------------------------------------------------------+
@@ -39,22 +39,22 @@
 
 // RX FIFO size
 #ifndef CFG_TUH_CDC_RX_BUFSIZE
-#define CFG_TUH_CDC_RX_BUFSIZE TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_CDC_RX_BUFSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 // RX Endpoint size
 #ifndef CFG_TUH_CDC_RX_EPSIZE
-#define CFG_TUH_CDC_RX_EPSIZE  TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_CDC_RX_EPSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 // TX FIFO size
 #ifndef CFG_TUH_CDC_TX_BUFSIZE
-#define CFG_TUH_CDC_TX_BUFSIZE TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_CDC_TX_BUFSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 // TX Endpoint size
 #ifndef CFG_TUH_CDC_TX_EPSIZE
-#define CFG_TUH_CDC_TX_EPSIZE  TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_CDC_TX_EPSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 //--------------------------------------------------------------------+
@@ -67,7 +67,7 @@ uint8_t tuh_cdc_itf_get_index(uint8_t daddr, uint8_t itf_num);
 
 // Get Interface information
 // return true if index is correct and interface is currently mounted
-bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t* info);
+bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t *info);
 
 // Check if an interface is mounted
 bool tuh_cdc_mounted(uint8_t idx);
@@ -75,7 +75,7 @@ bool tuh_cdc_mounted(uint8_t idx);
 // Get local (cached) line state
 // This function should return correct values if tuh_cdc_set_control_line_state() / tuh_cdc_get_control_line_state()
 // are invoked previously or CFG_TUH_CDC_LINE_STATE_ON_ENUM is defined.
-bool tuh_cdc_get_control_line_state_local(uint8_t idx, uint16_t* line_state);
+bool tuh_cdc_get_control_line_state_local(uint8_t idx, uint16_t *line_state);
 
 // Get current DTR status
 TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_get_dtr(uint8_t idx) {
@@ -100,7 +100,7 @@ TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_connected(uint8_t idx) {
 // This function should return correct values if tuh_cdc_set_line_coding() / tuh_cdc_get_line_coding()
 // are invoked previously or CFG_TUH_CDC_LINE_CODING_ON_ENUM is defined.
 // NOTE: This function does not make any USB transfer request to device.
-bool tuh_cdc_get_line_coding_local(uint8_t idx, cdc_line_coding_t* line_coding);
+bool tuh_cdc_get_line_coding_local(uint8_t idx, cdc_line_coding_t *line_coding);
 
 #define tuh_cdc_get_local_line_coding tuh_cdc_get_line_coding_local // backward compatibility
 
@@ -112,7 +112,7 @@ bool tuh_cdc_get_line_coding_local(uint8_t idx, cdc_line_coding_t* line_coding);
 uint32_t tuh_cdc_write_available(uint8_t idx);
 
 // Write to cdc interface
-uint32_t tuh_cdc_write(uint8_t idx, void const* buffer, uint32_t bufsize);
+uint32_t tuh_cdc_write(uint8_t idx, const void *buffer, uint32_t bufsize);
 
 // Force sending data if possible, return number of forced bytes
 uint32_t tuh_cdc_write_flush(uint8_t idx);
@@ -128,13 +128,13 @@ bool tuh_cdc_write_clear(uint8_t idx);
 uint32_t tuh_cdc_read_available(uint8_t idx);
 
 // Read from cdc interface
-uint32_t tuh_cdc_read (uint8_t idx, void* buffer, uint32_t bufsize);
+uint32_t tuh_cdc_read(uint8_t idx, void *buffer, uint32_t bufsize);
 
 // Get a byte from RX FIFO without removing it
-bool tuh_cdc_peek(uint8_t idx, uint8_t* ch);
+bool tuh_cdc_peek(uint8_t idx, uint8_t *ch);
 
 // Clear the received FIFO
-bool tuh_cdc_read_clear (uint8_t idx);
+bool tuh_cdc_read_clear(uint8_t idx);
 
 //--------------------------------------------------------------------+
 // Control Request API
@@ -149,16 +149,18 @@ bool tuh_cdc_read_clear (uint8_t idx);
 bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 // Request to Set DTR
-TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_dtr(uint8_t idx, bool dtr_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdc_line_control_state_t line_state = { .dtr = dtr_state };
-  line_state.rts = tuh_cdc_get_rts(idx);
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_dtr(uint8_t idx, bool dtr_state, tuh_xfer_cb_t complete_cb,
+                                                         uintptr_t user_data) {
+  cdc_line_control_state_t line_state = {.dtr = dtr_state};
+  line_state.rts                      = tuh_cdc_get_rts(idx);
   return tuh_cdc_set_control_line_state(idx, line_state.value, complete_cb, user_data);
 }
 
 // Request to Set RTS
-TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_rts(uint8_t idx, bool rts_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdc_line_control_state_t line_state = { .rts = rts_state };
-  line_state.dtr = tuh_cdc_get_dtr(idx);
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_rts(uint8_t idx, bool rts_state, tuh_xfer_cb_t complete_cb,
+                                                         uintptr_t user_data) {
+  cdc_line_control_state_t line_state = {.rts = rts_state};
+  line_state.dtr                      = tuh_cdc_get_dtr(idx);
   return tuh_cdc_set_control_line_state(idx, line_state.value, complete_cb, user_data);
 }
 
@@ -166,11 +168,13 @@ TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_rts(uint8_t idx, bool rts_s
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 // Request to set data format
-bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
+                             tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 // Request to Set Line Coding = baudrate + data format
 // Note: only implemented by ACM and CH34x, not supported by FTDI and CP210x yet
-bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+bool tuh_cdc_set_line_coding(uint8_t idx, const cdc_line_coding_t *line_coding, tuh_xfer_cb_t complete_cb,
+                             uintptr_t user_data);
 
 // Request to Get Line Coding (ACM only)
 // Should only use if tuh_cdc_set_line_coding() / tuh_cdc_get_line_coding() never got invoked and
@@ -179,11 +183,13 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding,
 
 // Connect by set both DTR, RTS
 TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_connect(uint8_t idx, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  return tuh_cdc_set_control_line_state(idx, CDC_CONTROL_LINE_STATE_DTR | CDC_CONTROL_LINE_STATE_RTS, complete_cb, user_data);
+  return tuh_cdc_set_control_line_state(idx, CDC_CONTROL_LINE_STATE_DTR | CDC_CONTROL_LINE_STATE_RTS, complete_cb,
+                                        user_data);
 }
 
 // Disconnect by clear both DTR, RTS
-TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_disconnect(uint8_t idx, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_disconnect(uint8_t idx, tuh_xfer_cb_t complete_cb,
+                                                            uintptr_t user_data) {
   return tuh_cdc_set_control_line_state(idx, 0x00, complete_cb, user_data);
 }
 
@@ -192,7 +198,8 @@ TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_disconnect(uint8_t idx, tuh_xfe
 // Each Function will make a USB control transfer request to/from device the function will block until request is
 // complete. The function will return the transfer request result
 //--------------------------------------------------------------------+
-TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_control_line_state_sync(uint8_t idx, uint16_t line_state) {
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_control_line_state_sync(uint8_t  idx,
+                                                                                           uint16_t line_state) {
   TU_API_SYNC(tuh_cdc_set_control_line_state, idx, line_state);
 }
 
@@ -208,11 +215,13 @@ TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_baudrate_sync
   TU_API_SYNC(tuh_cdc_set_baudrate, idx, baudrate);
 }
 
-TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_data_format_sync(uint8_t idx, uint8_t stop_bits, uint8_t parity, uint8_t data_bits) {
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_data_format_sync(uint8_t idx, uint8_t stop_bits,
+                                                                                    uint8_t parity, uint8_t data_bits) {
   TU_API_SYNC(tuh_cdc_set_data_format, idx, stop_bits, parity, data_bits);
 }
 
-TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_line_coding_sync(uint8_t idx, cdc_line_coding_t const* line_coding) {
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t
+tuh_cdc_set_line_coding_sync(uint8_t idx, const cdc_line_coding_t *line_coding) {
   TU_API_SYNC(tuh_cdc_set_line_coding, idx, line_coding);
 }
 
@@ -244,15 +253,15 @@ extern void tuh_cdc_tx_complete_cb(uint8_t idx);
 //--------------------------------------------------------------------+
 // Internal Class Driver API
 //--------------------------------------------------------------------+
-bool cdch_init       (void);
-bool cdch_deinit     (void);
-bool cdch_open       (uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
-bool cdch_set_config (uint8_t dev_addr, uint8_t itf_num);
-bool cdch_xfer_cb    (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
-void cdch_close      (uint8_t dev_addr);
+bool     cdch_init(void);
+bool     cdch_deinit(void);
+uint16_t cdch_open(uint8_t rhport, uint8_t dev_addr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+bool     cdch_set_config(uint8_t dev_addr, uint8_t itf_num);
+bool     cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+void     cdch_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
- }
+}
 #endif
 
 #endif /* TUSB_CDC_HOST_H_ */
diff --git a/src/class/cdc/cdc_rndis_host.c b/src/class/cdc/cdc_rndis_host.c
deleted file mode 100644
index e975ea440..000000000
--- a/src/class/cdc/cdc_rndis_host.c
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2019 Ha Thach (tinyusb.org)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- * This file is part of the TinyUSB stack.
- */
-
-#include "tusb_option.h"
-
-#if (CFG_TUH_ENABLED && CFG_TUH_CDC && CFG_TUH_CDC_RNDIS)
-
-//--------------------------------------------------------------------+
-// INCLUDE
-//--------------------------------------------------------------------+
-#include "common/tusb_common.h"
-#include "cdc_host.h"
-#include "cdc_rndis_host.h"
-
-#if 0  // TODO remove subtask related macros later
-// Sub Task
-#define OSAL_SUBTASK_BEGIN
-#define OSAL_SUBTASK_END                    return TUSB_ERROR_NONE;
-
-#define STASK_RETURN(_error)                return _error;
-#define STASK_INVOKE(_subtask, _status)     (_status) = _subtask
-#define STASK_ASSERT(_cond)                 TU_VERIFY(_cond, TUSB_ERROR_OSAL_TASK_FAILED)
-#endif
-
-//--------------------------------------------------------------------+
-// MACRO CONSTANT TYPEDEF
-//--------------------------------------------------------------------+
-#define RNDIS_MSG_PAYLOAD_MAX   (1024*4)
-
-CFG_TUH_MEM_SECTION static uint8_t msg_notification[CFG_TUH_DEVICE_MAX][8];
-CFG_TUH_MEM_SECTION CFG_TUH_MEM_ALIGN static uint8_t msg_payload[RNDIS_MSG_PAYLOAD_MAX];
-
-static rndish_data_t rndish_data[CFG_TUH_DEVICE_MAX];
-
-// TODO Microsoft requires message length for any get command must be at least 4096 bytes
-
-//--------------------------------------------------------------------+
-// INTERNAL OBJECT & FUNCTION DECLARATION
-//--------------------------------------------------------------------+
-static tusb_error_t rndis_body_subtask(void);
-static tusb_error_t send_message_get_response_subtask( uint8_t dev_addr, cdch_data_t *p_cdc,
-                                                       uint8_t * p_mess, uint32_t mess_length,
-                                                       uint8_t *p_response );
-
-//--------------------------------------------------------------------+
-// APPLICATION API
-//--------------------------------------------------------------------+
-tusb_error_t tusbh_cdc_rndis_get_mac_addr(uint8_t dev_addr, uint8_t mac_address[6])
-{
-  TU_ASSERT( tusbh_cdc_rndis_is_mounted(dev_addr),  TUSB_ERROR_CDCH_DEVICE_NOT_MOUNTED);
-  TU_VERIFY( mac_address,  TUSB_ERROR_INVALID_PARA);
-
-  memcpy(mac_address, rndish_data[dev_addr-1].mac_address, 6);
-
-  return TUSB_ERROR_NONE;
-}
-
-//--------------------------------------------------------------------+
-// IMPLEMENTATION
-//--------------------------------------------------------------------+
-
-// To enable the TASK_ASSERT style (quick return on false condition) in a real RTOS, a task must act as a wrapper
-// and is used mainly to call subtasks. Within a subtask return statement can be called freely, the task with
-// forever loop cannot have any return at all.
-OSAL_TASK_FUNCTION(cdch_rndis_task) (void* param;)
-{
-  OSAL_TASK_BEGIN
-  rndis_body_subtask();
-  OSAL_TASK_END
-}
-
-static tusb_error_t rndis_body_subtask(void)
-{
-  static uint8_t relative_addr;
-
-  OSAL_SUBTASK_BEGIN
-
-  for (relative_addr = 0; relative_addr < CFG_TUH_DEVICE_MAX; relative_addr++)
-  {
-
-  }
-
-  tusb_time_delay_ms_api(100);
-
-  OSAL_SUBTASK_END
-}
-
-//--------------------------------------------------------------------+
-// RNDIS-CDC Driver API
-//--------------------------------------------------------------------+
-void rndish_init(void)
-{
-  tu_memclr(rndish_data, sizeof(rndish_data_t)*CFG_TUH_DEVICE_MAX);
-
-  //------------- Task creation -------------//
-
-  //------------- semaphore creation for notification pipe -------------//
-  for(uint8_t i=0; i<CFG_TUH_DEVICE_MAX; i++)
-  {
-    rndish_data[i].sem_notification_hdl = osal_semaphore_create( OSAL_SEM_REF(rndish_data[i].semaphore_notification) );
-  }
-}
-
-void rndish_close(uint8_t dev_addr)
-{
-  osal_semaphore_reset( rndish_data[dev_addr-1].sem_notification_hdl );
-//  tu_memclr(&rndish_data[dev_addr-1], sizeof(rndish_data_t)); TODO need to move semaphore & its handle out before memclr
-}
-
-
-static rndis_msg_initialize_t const msg_init =
-{
-    .type          = RNDIS_MSG_INITIALIZE,
-    .length        = sizeof(rndis_msg_initialize_t),
-    .request_id    = 1, // TODO should use some magic number
-    .major_version = 1,
-    .minor_version = 0,
-    .max_xfer_size = 0x4000 // TODO mimic windows
-};
-
-static rndis_msg_query_t const msg_query_permanent_addr =
-{
-    .type          = RNDIS_MSG_QUERY,
-    .length        = sizeof(rndis_msg_query_t)+6,
-    .request_id    = 1,
-    .oid           = RNDIS_OID_802_3_PERMANENT_ADDRESS,
-    .buffer_length = 6,
-    .buffer_offset = 20,
-};
-
-static rndis_msg_set_t const msg_set_packet_filter =
-{
-    .type          = RNDIS_MSG_SET,
-    .length        = sizeof(rndis_msg_set_t)+4,
-    .request_id    = 1,
-    .oid           = RNDIS_OID_GEN_CURRENT_PACKET_FILTER,
-    .buffer_length = 4,
-    .buffer_offset = 20,
-};
-
-tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc)
-{
-  tusb_error_t error;
-
-  OSAL_SUBTASK_BEGIN
-
-  //------------- Message Initialize -------------//
-  memcpy(msg_payload, &msg_init, sizeof(rndis_msg_initialize_t));
-  STASK_INVOKE(
-      send_message_get_response_subtask( dev_addr, p_cdc,
-                                         msg_payload, sizeof(rndis_msg_initialize_t),
-                                         msg_payload),
-      error
-  );
-  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
-
-  // TODO currently not support multiple data packets per xfer
-  rndis_msg_initialize_cmplt_t * const p_init_cmpt = (rndis_msg_initialize_cmplt_t *) msg_payload;
-  STASK_ASSERT(p_init_cmpt->type == RNDIS_MSG_INITIALIZE_CMPLT && p_init_cmpt->status == RNDIS_STATUS_SUCCESS &&
-                 p_init_cmpt->max_packet_per_xfer == 1 && p_init_cmpt->max_xfer_size <= RNDIS_MSG_PAYLOAD_MAX);
-  rndish_data[dev_addr-1].max_xfer_size = p_init_cmpt->max_xfer_size;
-
-  //------------- Message Query 802.3 Permanent Address -------------//
-  memcpy(msg_payload, &msg_query_permanent_addr, sizeof(rndis_msg_query_t));
-  tu_memclr(msg_payload + sizeof(rndis_msg_query_t), 6); // 6 bytes for MAC address
-
-  STASK_INVOKE(
-      send_message_get_response_subtask( dev_addr, p_cdc,
-                                         msg_payload, sizeof(rndis_msg_query_t) + 6,
-                                         msg_payload),
-      error
-  );
-  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
-
-  rndis_msg_query_cmplt_t * const p_query_cmpt = (rndis_msg_query_cmplt_t *) msg_payload;
-  STASK_ASSERT(p_query_cmpt->type == RNDIS_MSG_QUERY_CMPLT && p_query_cmpt->status == RNDIS_STATUS_SUCCESS);
-  memcpy(rndish_data[dev_addr-1].mac_address, msg_payload + 8 + p_query_cmpt->buffer_offset, 6);
-
-  //------------- Set OID_GEN_CURRENT_PACKET_FILTER to (DIRECTED | MULTICAST | BROADCAST) -------------//
-  memcpy(msg_payload, &msg_set_packet_filter, sizeof(rndis_msg_set_t));
-  tu_memclr(msg_payload + sizeof(rndis_msg_set_t), 4); // 4 bytes for filter flags
-  ((rndis_msg_set_t*) msg_payload)->oid_buffer[0] = (RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_MULTICAST | RNDIS_PACKET_TYPE_BROADCAST);
-
-  STASK_INVOKE(
-      send_message_get_response_subtask( dev_addr, p_cdc,
-                                         msg_payload, sizeof(rndis_msg_set_t) + 4,
-                                         msg_payload),
-      error
-  );
-  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
-
-  rndis_msg_set_cmplt_t * const p_set_cmpt = (rndis_msg_set_cmplt_t *) msg_payload;
-  STASK_ASSERT(p_set_cmpt->type == RNDIS_MSG_SET_CMPLT && p_set_cmpt->status == RNDIS_STATUS_SUCCESS);
-
-  tusbh_cdc_rndis_mounted_cb(dev_addr);
-
-  OSAL_SUBTASK_END
-}
-
-void rndish_xfer_isr(cdch_data_t *p_cdc, pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)
-{
-  if ( pipehandle_is_equal(pipe_hdl, p_cdc->pipe_notification) )
-  {
-    osal_semaphore_post( rndish_data[pipe_hdl.dev_addr-1].sem_notification_hdl );
-  }
-}
-
-//--------------------------------------------------------------------+
-// INTERNAL & HELPER
-//--------------------------------------------------------------------+
-static tusb_error_t send_message_get_response_subtask( uint8_t dev_addr, cdch_data_t *p_cdc,
-                                                       uint8_t * p_mess, uint32_t mess_length,
-                                                       uint8_t *p_response)
-{
-  tusb_error_t error;
-
-  OSAL_SUBTASK_BEGIN
-
-  //------------- Send RNDIS Control Message -------------//
-  STASK_INVOKE(
-      usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),
-                                 CDC_REQUEST_SEND_ENCAPSULATED_COMMAND, 0, p_cdc->interface_number,
-                                 mess_length, p_mess),
-      error
-  );
-  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
-
-  //------------- waiting for Response Available notification -------------//
-  (void) usbh_edpt_xfer(p_cdc->pipe_notification, msg_notification[dev_addr-1], 8);
-  osal_semaphore_wait(rndish_data[dev_addr-1].sem_notification_hdl, OSAL_TIMEOUT_NORMAL, &error);
-  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
-  STASK_ASSERT(msg_notification[dev_addr-1][0] == 1);
-
-  //------------- Get RNDIS Message Initialize Complete -------------//
-  STASK_INVOKE(
-    usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),
-                               CDC_REQUEST_GET_ENCAPSULATED_RESPONSE, 0, p_cdc->interface_number,
-                               RNDIS_MSG_PAYLOAD_MAX, p_response),
-    error
-  );
-  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
-
-  OSAL_SUBTASK_END
-}
-
-//static tusb_error_t send_process_msg_initialize_subtask(uint8_t dev_addr, cdch_data_t *p_cdc)
-//{
-//  tusb_error_t error;
-//
-//  OSAL_SUBTASK_BEGIN
-//
-//  *((rndis_msg_initialize_t*) msg_payload) = (rndis_msg_initialize_t)
-//                                            {
-//                                                .type          = RNDIS_MSG_INITIALIZE,
-//                                                .length        = sizeof(rndis_msg_initialize_t),
-//                                                .request_id    = 1, // TODO should use some magic number
-//                                                .major_version = 1,
-//                                                .minor_version = 0,
-//                                                .max_xfer_size = 0x4000 // TODO mimic windows
-//                                            };
-//
-//
-//
-//  OSAL_SUBTASK_END
-//}
-#endif
diff --git a/src/class/cdc/cdc_rndis_host.h b/src/class/cdc/cdc_rndis_host.h
deleted file mode 100644
index e70d27f79..000000000
--- a/src/class/cdc/cdc_rndis_host.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2019 Ha Thach (tinyusb.org)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- * This file is part of the TinyUSB stack.
- */
-
-/** \ingroup CDC_RNDIS
- * \defgroup CDC_RNSID_Host Host
- *  @{ */
-
-#ifndef TUSB_CDC_RNDIS_HOST_H_
-#define TUSB_CDC_RNDIS_HOST_H_
-
-#include "common/tusb_common.h"
-#include "host/usbh.h"
-#include "cdc_rndis.h"
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-//--------------------------------------------------------------------+
-// INTERNAL RNDIS-CDC Driver API
-//--------------------------------------------------------------------+
-typedef struct {
-  OSAL_SEM_DEF(semaphore_notification);
-  osal_semaphore_handle_t sem_notification_hdl;  // used to wait on notification pipe
-  uint32_t max_xfer_size; // got from device's msg initialize complete
-  uint8_t mac_address[6];
-}rndish_data_t;
-
-void rndish_init(void);
-bool 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);
-
-#ifdef __cplusplus
- }
-#endif
-
-#endif /* TUSB_CDC_RNDIS_HOST_H_ */
-
-/** @} */
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index fe9a90d33..98f9bf80b 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -512,19 +512,18 @@ void hidh_close(uint8_t daddr) {
 //--------------------------------------------------------------------+
 // Enumeration
 //--------------------------------------------------------------------+
-
-bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const* desc_itf, uint16_t max_len) {
+uint16_t hidh_open(uint8_t rhport, uint8_t daddr, const tusb_desc_interface_t *desc_itf, uint16_t max_len) {
   (void) rhport;
   (void) max_len;
 
-  TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
+  TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass, 0);
   TU_LOG_DRV("[%u] HID opening Interface %u\r\n", daddr, desc_itf->bInterfaceNumber);
 
   // len = interface + hid + n*endpoints
-  uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) +
-                                       desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
-  TU_ASSERT(max_len >= drv_len);
-  uint8_t const* p_desc = (uint8_t const*) desc_itf;
+  const uint16_t drv_len = (uint16_t)(sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) +
+                                      desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
+  TU_ASSERT(drv_len <= max_len, 0);
+  const uint8_t *p_desc = (const uint8_t *)desc_itf;
 
   // HID descriptor: mostly right after interface descriptor, in some rare case it might be after endpoint descriptors
   p_desc = tu_desc_next(p_desc);
@@ -536,20 +535,20 @@ bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const* desc_
   } else {
     // HID after endpoint
     desc_hid = (const tusb_hid_descriptor_hid_t *)(p_desc + sizeof(tusb_desc_endpoint_t) * desc_itf->bNumEndpoints);
-    TU_ASSERT(tu_desc_type(desc_hid) == HID_DESC_TYPE_HID);
+    TU_ASSERT(tu_desc_type(desc_hid) == HID_DESC_TYPE_HID, 0);
   }
 
   // Allocate new interface
   hidh_interface_t *p_hid = find_new_itf();
-  TU_ASSERT(p_hid); // not enough interface, try to increase CFG_TUH_HID
+  TU_ASSERT(p_hid, 0); // not enough interface, try to increase CFG_TUH_HID
   p_hid->daddr   = daddr;
   p_hid->itf_num = desc_itf->bInterfaceNumber;
 
   // Endpoint Descriptors
   for (uint8_t i = 0; i < desc_itf->bNumEndpoints; i++) {
     const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)p_desc;
-    TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType);
-    TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+    TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType, 0);
+    TU_ASSERT(tuh_edpt_open(daddr, desc_ep), 0);
 
     if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
       p_hid->ep_in = desc_ep->bEndpointAddress;
@@ -573,7 +572,7 @@ bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const* desc_
     p_hid->itf_protocol = desc_itf->bInterfaceProtocol;
   }
 
-  return true;
+  return drv_len;
 }
 
 //--------------------------------------------------------------------+
diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index 87f0e7dc9..d7a415485 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -39,22 +39,22 @@ extern "C" {
 
 // TODO Highspeed interrupt can be up to 512 bytes
 #ifndef CFG_TUH_HID_EPIN_BUFSIZE
-#define CFG_TUH_HID_EPIN_BUFSIZE 64
+  #define CFG_TUH_HID_EPIN_BUFSIZE 64
 #endif
 
 #ifndef CFG_TUH_HID_EPOUT_BUFSIZE
-#define CFG_TUH_HID_EPOUT_BUFSIZE 64
+  #define CFG_TUH_HID_EPOUT_BUFSIZE 64
 #endif
 
 
 typedef struct {
-  uint8_t report_id;
-  uint8_t usage;
+  uint8_t  report_id;
+  uint8_t  usage;
   uint16_t usage_page;
 
   // TODO still use the endpoint size for now
-//  uint8_t in_len;      // length of IN report
-//  uint8_t out_len;     // length of OUT report
+  //  uint8_t in_len;      // length of IN report
+  //  uint8_t out_len;     // length of OUT report
 } tuh_hid_report_info_t;
 
 //--------------------------------------------------------------------+
@@ -68,10 +68,10 @@ uint8_t tuh_hid_itf_get_count(uint8_t dev_addr);
 uint8_t tuh_hid_itf_get_total_count(void);
 
 // backward compatible rename
-#define tuh_hid_instance_count    tuh_hid_itf_get_count
+#define tuh_hid_instance_count tuh_hid_itf_get_count
 
 // Get Interface information
-bool tuh_hid_itf_get_info(uint8_t daddr, uint8_t idx, tuh_itf_info_t* itf_info);
+bool tuh_hid_itf_get_info(uint8_t daddr, uint8_t idx, tuh_itf_info_t *itf_info);
 
 // Get Interface index from device address + interface number
 // return TUSB_INDEX_INVALID_8 (0xFF) if not found
@@ -85,8 +85,8 @@ bool tuh_hid_mounted(uint8_t dev_addr, uint8_t idx);
 
 // Parse report descriptor into array of report_info struct and return number of reports.
 // For complicated report, application should write its own parser.
-TU_ATTR_UNUSED uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* reports_info_arr, uint8_t arr_count,
-                                                       uint8_t const* desc_report, uint16_t desc_len);
+TU_ATTR_UNUSED uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t *reports_info_arr, uint8_t arr_count,
+                                                       const uint8_t *desc_report, uint16_t desc_len);
 
 //--------------------------------------------------------------------+
 // Control Endpoint API
@@ -107,12 +107,13 @@ bool tuh_hid_set_protocol(uint8_t dev_addr, uint8_t idx, uint8_t protocol);
 
 // Get Report using control endpoint
 // report_type is either Input, Output or Feature, (value from hid_report_type_t)
-bool tuh_hid_get_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, void* report, uint16_t len);
+bool tuh_hid_get_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, void *report,
+                        uint16_t len);
 
 // Set Report using control endpoint
 // report_type is either Input, Output or Feature, (value from hid_report_type_t)
-bool tuh_hid_set_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type,
-                        void* report, uint16_t len);
+bool tuh_hid_set_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, void *report,
+                        uint16_t len);
 
 //--------------------------------------------------------------------+
 // Interrupt Endpoint API
@@ -133,8 +134,9 @@ bool tuh_hid_receive_abort(uint8_t dev_addr, uint8_t idx);
 bool tuh_hid_send_ready(uint8_t dev_addr, uint8_t idx);
 
 // Send report using interrupt endpoint
-// If report_id > 0 (composite), it will be sent as 1st byte, then report contents. Otherwise only report content is sent.
-bool tuh_hid_send_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, const void* report, uint16_t len);
+// If report_id > 0 (composite), it will be sent as 1st byte, then report contents. Otherwise only report content is
+// sent.
+bool tuh_hid_send_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, const void *report, uint16_t len);
 
 //--------------------------------------------------------------------+
 // Callbacks (Weak is optional)
@@ -145,25 +147,27 @@ bool tuh_hid_send_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, const
 // can be used to parse common/simple enough descriptor.
 // Note: if report descriptor length > CFG_TUH_ENUMERATION_BUFSIZE, it will be skipped
 // therefore report_desc = NULL, desc_len = 0
-void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report_desc, uint16_t desc_len);
+void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t idx, const uint8_t *report_desc, uint16_t desc_len);
 
 // Invoked when device with hid interface is un-mounted
 void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t idx);
 
 // Invoked when received report from device via interrupt endpoint
 // Note: if there is report ID (composite), it is 1st byte of report
-void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report, uint16_t len);
+void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t idx, const uint8_t *report, uint16_t len);
 
 // Invoked when sent report to device successfully via interrupt endpoint
-void tuh_hid_report_sent_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report, uint16_t len);
+void tuh_hid_report_sent_cb(uint8_t dev_addr, uint8_t idx, const uint8_t *report, uint16_t len);
 
 // Invoked when Get Report to device via either control endpoint
 // len = 0 indicate there is error in the transfer e.g stalled response
-void tuh_hid_get_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len);
+void tuh_hid_get_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type,
+                                    uint16_t len);
 
 // Invoked when Sent Report to device via either control endpoint
 // len = 0 indicate there is error in the transfer e.g stalled response
-void tuh_hid_set_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len);
+void tuh_hid_set_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type,
+                                    uint16_t len);
 
 // Invoked when Set Protocol request is complete
 void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t protocol);
@@ -171,12 +175,12 @@ void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t pro
 //--------------------------------------------------------------------+
 // Internal Class Driver API
 //--------------------------------------------------------------------+
-bool hidh_init(void);
-bool hidh_deinit(void);
-bool hidh_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const* desc_itf, uint16_t max_len);
-bool hidh_set_config(uint8_t dev_addr, uint8_t itf_num);
-bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
-void hidh_close(uint8_t dev_addr);
+bool     hidh_init(void);
+bool     hidh_deinit(void);
+uint16_t hidh_open(uint8_t rhport, uint8_t dev_addr, const tusb_desc_interface_t *desc_itf, uint16_t max_len);
+bool     hidh_set_config(uint8_t dev_addr, uint8_t itf_num);
+bool     hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
+void     hidh_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
 }
diff --git a/src/class/midi/midi_host.c b/src/class/midi/midi_host.c
index b4f5ac445..5548a0ba8 100644
--- a/src/class/midi/midi_host.c
+++ b/src/class/midi/midi_host.c
@@ -192,15 +192,16 @@ bool midih_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint
 //--------------------------------------------------------------------+
 // Enumeration
 //--------------------------------------------------------------------+
-bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t max_len) {
+uint16_t midih_open(uint8_t rhport, uint8_t dev_addr, const tusb_desc_interface_t *desc_itf, uint16_t max_len) {
   (void) rhport;
 
-  TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass);
-  const uint8_t *p_end = ((const uint8_t *) desc_itf) + max_len;
-  const uint8_t *p_desc = (const uint8_t *) desc_itf;
+  TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass, 0);
+  const uint8_t *desc_start = (const uint8_t *)desc_itf;
+  const uint8_t *p_desc     = desc_start;
+  const uint8_t *desc_end   = desc_start + max_len;
 
   const uint8_t idx = find_new_midi_index();
-  TU_VERIFY(idx < CFG_TUH_MIDI);
+  TU_VERIFY(idx < CFG_TUH_MIDI, 0);
   midih_interface_t *p_midi = &_midi_host[idx];
   p_midi->itf_count = 0;
 
@@ -217,29 +218,30 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
   // driver after parsing the audio control interface and then resume parsing
   // the streaming audio interface.
   if (AUDIO_SUBCLASS_CONTROL == desc_itf->bInterfaceSubClass) {
-    TU_VERIFY(max_len > 2*sizeof(tusb_desc_interface_t) + sizeof(midi10_desc_cs_ac_interface_t));
-
+    TU_VERIFY(max_len > 2 * sizeof(tusb_desc_interface_t) + sizeof(midi10_desc_cs_ac_interface_t), 0);
     p_desc = tu_desc_next(p_desc);
     TU_VERIFY(tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE &&
-              tu_desc_subtype(p_desc) == AUDIO10_CS_AC_INTERFACE_HEADER);
+                tu_desc_subtype(p_desc) == AUDIO10_CS_AC_INTERFACE_HEADER,
+              0);
     desc_cb.desc_audio_control = desc_itf;
 
     p_desc = tu_desc_next(p_desc);
     desc_itf = (const tusb_desc_interface_t *)p_desc;
     p_midi->itf_count = 1;
     // skip non-interface and non-midi streaming descriptors
-    while (tu_desc_in_bounds(p_desc, p_end) &&
-      (desc_itf->bDescriptorType != TUSB_DESC_INTERFACE || (desc_itf->bInterfaceClass == TUSB_CLASS_AUDIO && desc_itf->bInterfaceSubClass != AUDIO_SUBCLASS_MIDI_STREAMING))) {
+    while (tu_desc_in_bounds(p_desc, desc_end) && (desc_itf->bDescriptorType != TUSB_DESC_INTERFACE ||
+                                                   (desc_itf->bInterfaceClass == TUSB_CLASS_AUDIO &&
+                                                    desc_itf->bInterfaceSubClass != AUDIO_SUBCLASS_MIDI_STREAMING))) {
       if (desc_itf->bDescriptorType == TUSB_DESC_INTERFACE && desc_itf->bAlternateSetting == 0) {
         p_midi->itf_count++;
       }
       p_desc = tu_desc_next(p_desc);
-      desc_itf = (tusb_desc_interface_t const *)p_desc;
+      desc_itf = (const tusb_desc_interface_t *)p_desc;
     }
-    TU_VERIFY(p_desc < p_end); // TODO: If MIDI interface comes after Audio Streaming, then max_len did not include the MIDI interface descriptor
-    TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass);
+    TU_VERIFY(p_desc < desc_end, 0);
+    TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass, 0);
   }
-  TU_VERIFY(AUDIO_SUBCLASS_MIDI_STREAMING == desc_itf->bInterfaceSubClass);
+  TU_VERIFY(AUDIO_SUBCLASS_MIDI_STREAMING == desc_itf->bInterfaceSubClass, 0);
 
   TU_LOG_DRV("MIDI opening Interface %u (addr = %u)\r\n", desc_itf->bInterfaceNumber, dev_addr);
   p_midi->bInterfaceNumber = desc_itf->bInterfaceNumber;
@@ -250,7 +252,7 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
   p_desc = tu_desc_next(p_desc); // next to CS Header
 
   bool found_new_interface = false;
-  while (tu_desc_in_bounds(p_desc, p_end) && !found_new_interface) {
+  while (tu_desc_in_bounds(p_desc, desc_end) && !found_new_interface) {
     switch (tu_desc_type(p_desc)) {
       case TUSB_DESC_INTERFACE:
         found_new_interface = true;
@@ -287,8 +289,9 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
 
       case TUSB_DESC_ENDPOINT: {
         const tusb_desc_endpoint_t *p_ep = (const tusb_desc_endpoint_t *) p_desc;
+
         p_desc = tu_desc_next(p_desc); // next to CS endpoint
-        TU_VERIFY(p_desc < p_end && tu_desc_next(p_desc) <= p_end);
+        TU_VERIFY(tu_desc_in_bounds(p_desc, desc_end), 0);
         const midi_desc_cs_endpoint_t *p_csep = (const midi_desc_cs_endpoint_t *) p_desc;
 
         TU_LOG_DRV("  Endpoint and CS_Endpoint descriptor %02x\r\n", p_ep->bEndpointAddress);
@@ -302,7 +305,7 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
           desc_cb.desc_epin      = p_ep;
           ep_stream              = &p_midi->ep_stream.rx;
         }
-        TU_ASSERT(tuh_edpt_open(dev_addr, p_ep));
+        TU_ASSERT(tuh_edpt_open(dev_addr, p_ep), 0);
         tu_edpt_stream_open(ep_stream, dev_addr, p_ep);
         tu_edpt_stream_clear(ep_stream);
 
@@ -313,12 +316,12 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
     }
     p_desc = tu_desc_next(p_desc);
   }
-  desc_cb.desc_midi_total_len = (uint16_t) ((uintptr_t)p_desc - (uintptr_t) desc_itf);
+  desc_cb.desc_midi_total_len = (uint16_t)((uintptr_t)p_desc - (uintptr_t)desc_start);
 
   p_midi->daddr = dev_addr;
   tuh_midi_descriptor_cb(idx, &desc_cb);
 
-  return true;
+  return desc_cb.desc_midi_total_len;
 }
 
 bool midih_set_config(uint8_t dev_addr, uint8_t itf_num) {
diff --git a/src/class/midi/midi_host.h b/src/class/midi/midi_host.h
index 06554a03d..8a8dccab4 100644
--- a/src/class/midi/midi_host.h
+++ b/src/class/midi/midi_host.h
@@ -31,45 +31,45 @@
 #include "midi.h"
 
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif
 
 //--------------------------------------------------------------------+
 // Class Driver Configuration
 //--------------------------------------------------------------------+
 #ifndef CFG_TUH_MIDI_RX_BUFSIZE
-#define CFG_TUH_MIDI_RX_BUFSIZE TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_MIDI_RX_BUFSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 #ifndef CFG_TUH_MIDI_TX_BUFSIZE
-#define CFG_TUH_MIDI_TX_BUFSIZE TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_MIDI_TX_BUFSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 #ifndef CFG_TUH_MIDI_EP_BUFSIZE
-#define CFG_TUH_MIDI_EP_BUFSIZE TUH_EPSIZE_BULK_MPS
+  #define CFG_TUH_MIDI_EP_BUFSIZE TUH_EPSIZE_BULK_MPS
 #endif
 
 // Enable the MIDI stream read/write API. Some library can work with raw USB MIDI packet
 // Disable this can save driver footprint.
 #ifndef CFG_TUH_MIDI_STREAM_API
-#define CFG_TUH_MIDI_STREAM_API 1
+  #define CFG_TUH_MIDI_STREAM_API 1
 #endif
 
 //--------------------------------------------------------------------+
 // Application Types
 //--------------------------------------------------------------------+
 typedef struct {
-  const tusb_desc_interface_t* desc_audio_control;
-  const tusb_desc_interface_t* desc_midi; // start of whole midi interface descriptor
-  uint16_t desc_midi_total_len;
+  const tusb_desc_interface_t *desc_audio_control;
+  const tusb_desc_interface_t *desc_midi; // start of whole midi interface descriptor
+  uint16_t                     desc_midi_total_len;
 
-  const uint8_t* desc_header;
-  const uint8_t* desc_element;
-  const tusb_desc_endpoint_t* desc_epin;  // endpoint IN descriptor, CS_ENDPOINT is right after
-  const tusb_desc_endpoint_t* desc_epout; // endpoint OUT descriptor, CS_ENDPOINT is right after
+  const uint8_t              *desc_header;
+  const uint8_t              *desc_element;
+  const tusb_desc_endpoint_t *desc_epin;  // endpoint IN descriptor, CS_ENDPOINT is right after
+  const tusb_desc_endpoint_t *desc_epout; // endpoint OUT descriptor, CS_ENDPOINT is right after
 
-  uint8_t jack_num;
-  const uint8_t* desc_jack[32]; // list of jack descriptors (embedded + external)
+  uint8_t        jack_num;
+  const uint8_t *desc_jack[32];           // list of jack descriptors (embedded + external)
 } tuh_midi_descriptor_cb_t;
 
 typedef struct {
@@ -92,7 +92,7 @@ uint8_t tuh_midi_itf_get_index(uint8_t daddr, uint8_t itf_num);
 
 // Get Interface information
 // return true if index is correct and interface is currently mounted
-bool tuh_midi_itf_get_info(uint8_t idx, tuh_itf_info_t* info);
+bool tuh_midi_itf_get_info(uint8_t idx, tuh_itf_info_t *info);
 
 // return the number of virtual midi cables on the device's IN endpoint
 uint8_t tuh_midi_get_rx_cable_count(uint8_t idx);
@@ -115,24 +115,22 @@ uint32_t tuh_midi_write_flush(uint8_t idx);
 
 // Read all available MIDI packets from the connected device
 // Return number of bytes read (always multiple of 4)
-uint32_t tuh_midi_packet_read_n(uint8_t idx, uint8_t* buffer, uint32_t bufsize);
+uint32_t tuh_midi_packet_read_n(uint8_t idx, uint8_t *buffer, uint32_t bufsize);
 
 // Read a raw MIDI packet from the connected device
 // Return true if a packet was returned
-TU_ATTR_ALWAYS_INLINE static inline
-bool tuh_midi_packet_read (uint8_t idx, uint8_t packet[4]) {
- return 4 == tuh_midi_packet_read_n(idx, packet, 4);
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_midi_packet_read(uint8_t idx, uint8_t packet[4]) {
+  return 4 == tuh_midi_packet_read_n(idx, packet, 4);
 }
 
 // Write all 4-byte packets, data is locally buffered and only transferred when buffered bytes
 // reach the endpoint packet size or tuh_midi_write_flush() is called
-uint32_t tuh_midi_packet_write_n(uint8_t idx, const uint8_t* buffer, uint32_t bufsize);
+uint32_t tuh_midi_packet_write_n(uint8_t idx, const uint8_t *buffer, uint32_t bufsize);
 
 // Write a 4-bytes packet to the device.
 // Returns true if the packet was successfully queued.
-TU_ATTR_ALWAYS_INLINE static inline
-bool tuh_midi_packet_write (uint8_t idx, uint8_t const packet[4]) {
- return 4 == tuh_midi_packet_write_n(idx, packet, 4);
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_midi_packet_write(uint8_t idx, const uint8_t packet[4]) {
+  return 4 == tuh_midi_packet_write_n(idx, packet, 4);
 }
 
 //--------------------------------------------------------------------+
@@ -143,7 +141,7 @@ bool tuh_midi_packet_write (uint8_t idx, uint8_t const packet[4]) {
 // Queue a message to the device using stream API. data is locally buffered and only transferred when buffered bytes
 // reach the endpoint packet size or tuh_midi_write_flush() is called
 // Returns number of bytes was successfully queued.
-uint32_t tuh_midi_stream_write(uint8_t idx, uint8_t cable_num, uint8_t const *p_buffer, uint32_t bufsize);
+uint32_t tuh_midi_stream_write(uint8_t idx, uint8_t cable_num, const uint8_t *p_buffer, uint32_t bufsize);
 
 // Get the MIDI stream from the device. Set the value pointed
 // to by p_cable_num to the MIDI cable number intended to receive it.
@@ -162,10 +160,10 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
 
 // Invoked when MIDI interface is detected in enumeration. Application can copy/parse descriptor if needed.
 // Note: may be fired before tuh_midi_mount_cb(), therefore midi interface is not mounted/ready.
-void tuh_midi_descriptor_cb(uint8_t idx, const tuh_midi_descriptor_cb_t * desc_cb_data);
+void tuh_midi_descriptor_cb(uint8_t idx, const tuh_midi_descriptor_cb_t *desc_cb_data);
 
 // Invoked when device with MIDI interface is mounted.
-void tuh_midi_mount_cb(uint8_t idx, const tuh_midi_mount_cb_t* mount_cb_data);
+void tuh_midi_mount_cb(uint8_t idx, const tuh_midi_mount_cb_t *mount_cb_data);
 
 // Invoked when device with MIDI interface is un-mounted
 void tuh_midi_umount_cb(uint8_t idx);
@@ -179,12 +177,12 @@ void tuh_midi_tx_cb(uint8_t idx, uint32_t xferred_bytes);
 //--------------------------------------------------------------------+
 // Internal Class Driver API
 //--------------------------------------------------------------------+
-bool midih_init       (void);
-bool midih_deinit     (void);
-bool midih_open       (uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t max_len);
-bool midih_set_config (uint8_t dev_addr, uint8_t itf_num);
-bool midih_xfer_cb    (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
-void midih_close      (uint8_t daddr);
+bool     midih_init(void);
+bool     midih_deinit(void);
+uint16_t midih_open(uint8_t rhport, uint8_t dev_addr, const tusb_desc_interface_t *desc_itf, uint16_t max_len);
+bool     midih_set_config(uint8_t dev_addr, uint8_t itf_num);
+bool     midih_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
+void     midih_close(uint8_t daddr);
 
 #ifdef __cplusplus
 }
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index daff345c5..6a36c2820 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -379,22 +379,21 @@ static bool config_test_unit_ready_complete(uint8_t dev_addr, tuh_msc_complete_d
 static bool config_request_sense_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
 static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
 
-bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const* desc_itf, uint16_t max_len) {
+uint16_t msch_open(uint8_t rhport, uint8_t dev_addr, const tusb_desc_interface_t *desc_itf, uint16_t max_len) {
   (void) rhport;
-  TU_VERIFY (MSC_SUBCLASS_SCSI == desc_itf->bInterfaceSubClass &&
-             MSC_PROTOCOL_BOT == desc_itf->bInterfaceProtocol);
+  TU_VERIFY(MSC_SUBCLASS_SCSI == desc_itf->bInterfaceSubClass && MSC_PROTOCOL_BOT == desc_itf->bInterfaceProtocol, 0);
 
   // msc driver length is fixed
-  uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) +
-                                       desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
-  TU_ASSERT(drv_len <= max_len);
+  const uint16_t drv_len =
+    (uint16_t)(sizeof(tusb_desc_interface_t) + desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
+  TU_ASSERT(drv_len <= max_len, 0);
 
-  msch_interface_t* p_msc = get_itf(dev_addr);
-  tusb_desc_endpoint_t const* ep_desc = (tusb_desc_endpoint_t const*) tu_desc_next(desc_itf);
+  msch_interface_t           *p_msc   = get_itf(dev_addr);
+  const tusb_desc_endpoint_t *ep_desc = (const tusb_desc_endpoint_t *)tu_desc_next(desc_itf);
 
   for (uint32_t i = 0; i < 2; i++) {
-    TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType && TUSB_XFER_BULK == ep_desc->bmAttributes.xfer);
-    TU_ASSERT(tuh_edpt_open(dev_addr, ep_desc));
+    TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType && TUSB_XFER_BULK == ep_desc->bmAttributes.xfer, 0);
+    TU_ASSERT(tuh_edpt_open(dev_addr, ep_desc), 0);
 
     if (TUSB_DIR_IN == tu_edpt_dir(ep_desc->bEndpointAddress)) {
       p_msc->ep_in = ep_desc->bEndpointAddress;
@@ -407,7 +406,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const* de
 
   p_msc->itf_num = desc_itf->bInterfaceNumber;
 
-  return true;
+  return drv_len;
 }
 
 bool msch_set_config(uint8_t daddr, uint8_t itf_num) {
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index b5fd55547..5dc7c0b94 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -30,7 +30,7 @@
 #include "msc.h"
 
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif
 
 //--------------------------------------------------------------------+
@@ -38,17 +38,17 @@
 //--------------------------------------------------------------------+
 
 #ifndef CFG_TUH_MSC_MAXLUN
-#define CFG_TUH_MSC_MAXLUN  4
+  #define CFG_TUH_MSC_MAXLUN 4
 #endif
 
 typedef struct {
-  msc_cbw_t const* cbw; // SCSI command
-  msc_csw_t const* csw; // SCSI status
-  void* scsi_data;      // SCSI Data
-  uintptr_t user_arg;   // user argument
-}tuh_msc_complete_data_t;
+  const msc_cbw_t *cbw;       // SCSI command
+  const msc_csw_t *csw;       // SCSI status
+  void            *scsi_data; // SCSI Data
+  uintptr_t        user_arg;  // user argument
+} tuh_msc_complete_data_t;
 
-typedef bool (*tuh_msc_complete_cb_t)(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
+typedef bool (*tuh_msc_complete_cb_t)(uint8_t dev_addr, const tuh_msc_complete_data_t *cb_data);
 
 //--------------------------------------------------------------------+
 // Application API
@@ -74,12 +74,14 @@ uint32_t tuh_msc_get_block_size(uint8_t dev_addr, uint8_t lun);
 // Complete callback is invoked when SCSI op is complete.
 // return true if success, false if there is already pending operation.
 // NOTE: buffer must be accessible by USB/DMA controller, aligned correctly and multiple of cache line if enabled
-bool tuh_msc_scsi_command(uint8_t daddr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
+bool tuh_msc_scsi_command(uint8_t daddr, const msc_cbw_t *cbw, void *data, tuh_msc_complete_cb_t complete_cb,
+                          uintptr_t arg);
 
 // Perform SCSI Inquiry command
 // Complete callback is invoked when SCSI op is complete.
 // NOTE: response must be accessible by USB/DMA controller, aligned correctly and multiple of cache line if enabled
-bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
+bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t *response, tuh_msc_complete_cb_t complete_cb,
+                     uintptr_t arg);
 
 // Perform SCSI Test Unit Ready command
 // Complete callback is invoked when SCSI op is complete.
@@ -88,23 +90,27 @@ bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_
 // Perform SCSI Request Sense 10 command
 // Complete callback is invoked when SCSI op is complete.
 // NOTE: response must be accessible by USB/DMA controller, aligned correctly and multiple of cache line if enabled
-bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *response, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
+bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *response, tuh_msc_complete_cb_t complete_cb,
+                           uintptr_t arg);
 
 // Perform SCSI Read 10 command. Read n blocks starting from LBA to buffer
 // Complete callback is invoked when SCSI op is complete.
 // NOTE: buffer must be accessible by USB/DMA controller, aligned correctly and multiple of cache line if enabled
-bool tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * buffer, uint32_t lba, uint16_t block_count, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
+bool tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void *buffer, uint32_t lba, uint16_t block_count,
+                    tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
 
 // Perform SCSI Write 10 command. Write n blocks starting from LBA to device
 // Complete callback is invoked when SCSI op is complete.
 // NOTE: buffer must be accessible by USB/DMA controller, aligned correctly and multiple of cache line if enabled
-bool tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * buffer, uint32_t lba, uint16_t block_count, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
+bool tuh_msc_write10(uint8_t dev_addr, uint8_t lun, const void *buffer, uint32_t lba, uint16_t block_count,
+                     tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
 
 // Perform SCSI Read Capacity 10 command
 // Complete callback is invoked when SCSI op is complete.
 // Note: during enumeration, host stack already carried out this request. Application can retrieve capacity by
 // simply call tuh_msc_get_block_count() and tuh_msc_get_block_size()
-bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
+bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t *response,
+                           tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
 
 //------------- Application Callback -------------//
 
@@ -118,15 +124,15 @@ void tuh_msc_umount_cb(uint8_t dev_addr);
 // Internal Class Driver API
 //--------------------------------------------------------------------+
 
-bool msch_init       (void);
-bool msch_deinit     (void);
-bool msch_open       (uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t max_len);
-bool msch_set_config (uint8_t daddr, uint8_t itf_num);
-void msch_close      (uint8_t dev_addr);
-bool msch_xfer_cb    (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+bool     msch_init(void);
+bool     msch_deinit(void);
+uint16_t msch_open(uint8_t rhport, uint8_t dev_addr, const tusb_desc_interface_t *desc_itf, uint16_t max_len);
+bool     msch_set_config(uint8_t daddr, uint8_t itf_num);
+void     msch_close(uint8_t dev_addr);
+bool     msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 
 #ifdef __cplusplus
- }
+}
 #endif
 
 #endif