Merge pull request #342 from hathach/class-driver-id

add subclass and protocol for matching driver id

13 files changed, 123 insertions, 100 deletions

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 14b9a3153..04c73da78 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -223,11 +223,11 @@ void cdcd_reset(uint8_t rhport)
 bool cdcd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
 {
   // Only support ACM subclass
-  TU_ASSERT ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
+  TU_VERIFY ( TUSB_CLASS_CDC                           == itf_desc->bInterfaceClass &&
+              CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
 
-  // Only support AT commands, no protocol and vendor specific commands.
-  TU_ASSERT(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||
-            itf_desc->bInterfaceProtocol == 0xff);
+  // Note: 0xFF can be used with RNDIS
+  TU_VERIFY(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA));
 
   // Find available interface
   cdcd_interface_t * p_cdc = NULL;
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 595e7fd62..5e45e8f6b 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -86,7 +86,7 @@ bool tuh_cdc_serial_is_mounted(uint8_t dev_addr)
 {
   // TODO consider all AT Command as serial candidate
   return tuh_cdc_mounted(dev_addr)                                         &&
-      (CDC_COMM_PROTOCOL_ATCOMMAND <= cdch_data[dev_addr-1].itf_protocol) &&
+      (CDC_COMM_PROTOCOL_NONE <= cdch_data[dev_addr-1].itf_protocol) &&
       (cdch_data[dev_addr-1].itf_protocol <= CDC_COMM_PROTOCOL_ATCOMMAND_CDMA);
 }
 
diff --git a/src/class/dfu/dfu_rt_device.c b/src/class/dfu/dfu_rt_device.c
index ad1871dad..0ef5fe63f 100644
--- a/src/class/dfu/dfu_rt_device.c
+++ b/src/class/dfu/dfu_rt_device.c
@@ -61,8 +61,8 @@ bool dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
   (void) rhport;
 
   // Ensure this is DFU Runtime
-  TU_ASSERT(itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS);
-  TU_ASSERT(itf_desc->bInterfaceProtocol == DFU_PROTOCOL_RT);
+  TU_VERIFY(itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS);
+  TU_VERIFY(itf_desc->bInterfaceProtocol == DFU_PROTOCOL_RT);
 
   uint8_t const * p_desc = tu_desc_next( itf_desc );
   (*p_length) = sizeof(tusb_desc_interface_t);
diff --git a/src/class/dfu/dfu_rt_device.h b/src/class/dfu/dfu_rt_device.h
index 4348a0f3a..294d993e3 100644
--- a/src/class/dfu/dfu_rt_device.h
+++ b/src/class/dfu/dfu_rt_device.h
@@ -58,7 +58,7 @@ typedef enum
 //--------------------------------------------------------------------+
 
 // Invoked when received new data
-TU_ATTR_WEAK void tud_dfu_rt_reboot_to_dfu(void);
+TU_ATTR_WEAK void tud_dfu_rt_reboot_to_dfu(void); // TODO rename to _cb convention
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
index 7cb35f1ce..cbdc5bece 100644
--- a/src/class/hid/hid_device.c
+++ b/src/class/hid/hid_device.c
@@ -160,6 +160,8 @@ void hidd_reset(uint8_t rhport)
 
 bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_len)
 {
+  TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
+
   uint8_t const *p_desc = (uint8_t const *) desc_itf;
 
   // Find available interface
diff --git a/src/class/midi/midi_device.c b/src/class/midi/midi_device.c
index ae6e3afe1..6eb522380 100644
--- a/src/class/midi/midi_device.c
+++ b/src/class/midi/midi_device.c
@@ -253,21 +253,31 @@ void midid_reset(uint8_t rhport)
   }
 }
 
-bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length)
+bool midid_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_length)
 {
-  // For now handle the audio control interface as well.
-  if ( AUDIO_SUBCLASS_CONTROL == p_interface_desc->bInterfaceSubClass) {
-    uint8_t const * p_desc = tu_desc_next ( (uint8_t const *) p_interface_desc );
-    (*p_length) = sizeof(tusb_desc_interface_t);
 
-    // Skip over the class specific descriptor.
-    (*p_length) += tu_desc_len(p_desc);
+  // 1st Interface is Audio Control v1
+  TU_VERIFY(TUSB_CLASS_AUDIO       == desc_itf->bInterfaceClass    &&
+            AUDIO_SUBCLASS_CONTROL == desc_itf->bInterfaceSubClass &&
+            AUDIO_PROTOCOL_V1      == desc_itf->bInterfaceProtocol);
+
+  uint16_t drv_len = tu_desc_len(desc_itf);
+  uint8_t const * p_desc = tu_desc_next(desc_itf);
+
+  // Skip Class Specific descriptors
+  while ( TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc) )
+  {
+    drv_len += tu_desc_len(p_desc);
     p_desc = tu_desc_next(p_desc);
-    return true;
   }
 
-  TU_VERIFY(AUDIO_SUBCLASS_MIDI_STREAMING == p_interface_desc->bInterfaceSubClass &&
-            AUDIO_PROTOCOL_V1 == p_interface_desc->bInterfaceProtocol );
+  // 2nd Interface is MIDI Streaming
+  TU_VERIFY(TUSB_DESC_INTERFACE == tu_desc_type(p_desc));
+  tusb_desc_interface_t const * desc_midi = (tusb_desc_interface_t const *) p_desc;
+
+  TU_VERIFY(TUSB_CLASS_AUDIO              == desc_midi->bInterfaceClass    &&
+            AUDIO_SUBCLASS_MIDI_STREAMING == desc_midi->bInterfaceSubClass &&
+            AUDIO_PROTOCOL_V1             == desc_midi->bInterfaceProtocol );
 
   // Find available interface
   midid_interface_t * p_midi = NULL;
@@ -280,13 +290,15 @@ bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc,
     }
   }
 
-  p_midi->itf_num  = p_interface_desc->bInterfaceNumber;
+  p_midi->itf_num  = desc_midi->bInterfaceNumber;
 
-  uint8_t const * p_desc = tu_desc_next( (uint8_t const *) p_interface_desc );
-  (*p_length) = sizeof(tusb_desc_interface_t);
+  // next descriptor
+  drv_len += tu_desc_len(p_desc);
+  p_desc = tu_desc_next(p_desc);
 
+  // Find and open endpoint descriptors
   uint8_t found_endpoints = 0;
-  while (found_endpoints < p_interface_desc->bNumEndpoints)
+  while (found_endpoints < desc_midi->bNumEndpoints)
   {
     if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
     {
@@ -298,14 +310,16 @@ bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc,
             p_midi->ep_out = ep_addr;
         }
 
-        (*p_length) += p_desc[DESC_OFFSET_LEN];
+        drv_len += p_desc[DESC_OFFSET_LEN];
         p_desc = tu_desc_next(p_desc);
         found_endpoints += 1;
     }
-    (*p_length) += p_desc[DESC_OFFSET_LEN];
+    drv_len += p_desc[DESC_OFFSET_LEN];
     p_desc = tu_desc_next(p_desc);
   }
 
+  *p_length = drv_len;
+
   // Prepare for incoming data
   TU_ASSERT( usbd_edpt_xfer(rhport, p_midi->ep_out, p_midi->epout_buf, CFG_TUD_MIDI_EPSIZE), false);
 
diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index 06cc9dbb6..68f5587fd 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -157,7 +157,8 @@ void mscd_reset(uint8_t rhport)
 bool mscd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_len)
 {
   // only support SCSI's BOT protocol
-  TU_ASSERT(MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&
+  TU_VERIFY(TUSB_CLASS_MSC    == itf_desc->bInterfaceClass &&
+            MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&
             MSC_PROTOCOL_BOT  == itf_desc->bInterfaceProtocol);
 
   mscd_interface_t * p_msc = &_mscd_itf;
diff --git a/src/class/net/net_device.c b/src/class/net/net_device.c
index 777d0da98..8d0cb5d37 100644
--- a/src/class/net/net_device.c
+++ b/src/class/net/net_device.c
@@ -130,13 +130,22 @@ void netd_reset(uint8_t rhport)
 
 bool netd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
 {
-  // sanity check the descriptor
-  _netd_itf.ecm_mode = (CDC_COMM_SUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL == itf_desc->bInterfaceSubClass);
-  TU_VERIFY ( (TUD_RNDIS_ITF_SUBCLASS == itf_desc->bInterfaceSubClass) || _netd_itf.ecm_mode );
+  bool const is_rndis = (TUD_RNDIS_ITF_CLASS    == itf_desc->bInterfaceClass    &&
+                         TUD_RNDIS_ITF_SUBCLASS == itf_desc->bInterfaceSubClass &&
+                         TUD_RNDIS_ITF_PROTOCOL == itf_desc->bInterfaceProtocol);
+
+  bool const is_ecm = (TUSB_CLASS_CDC                                      == itf_desc->bInterfaceClass &&
+                       CDC_COMM_SUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL == itf_desc->bInterfaceSubClass &&
+                       0x00                                                == itf_desc->bInterfaceProtocol);
+
+  TU_VERIFY ( is_rndis || is_ecm );
 
   // confirm interface hasn't already been allocated
   TU_ASSERT(0 == _netd_itf.ep_notif);
 
+  // sanity check the descriptor
+  _netd_itf.ecm_mode = is_ecm;
+
   //------------- Management Interface -------------//
   _netd_itf.itf_num = itf_desc->bInterfaceNumber;
 
@@ -165,6 +174,8 @@ bool netd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t
 
 bool netd_open_data(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
 {
+  TU_VERIFY(TUSB_CLASS_CDC_DATA == itf_desc->bInterfaceClass);
+
   // confirm interface hasn't already been allocated
   TU_ASSERT(0 == _netd_itf.ep_in);
 
diff --git a/src/class/usbtmc/usbtmc_device.c b/src/class/usbtmc/usbtmc_device.c
index 92d8d34ef..abe26ced3 100644
--- a/src/class/usbtmc/usbtmc_device.c
+++ b/src/class/usbtmc/usbtmc_device.c
@@ -263,17 +263,19 @@ void usbtmcd_init_cb(void)
 bool usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length)
 {
   (void)rhport;
-  TU_ASSERT(usbtmc_state.state == STATE_CLOSED);
   uint8_t const * p_desc;
   uint8_t found_endpoints = 0;
 
+  TU_VERIFY(itf_desc->bInterfaceClass    == TUD_USBTMC_APP_CLASS);
+  TU_VERIFY(itf_desc->bInterfaceSubClass == TUD_USBTMC_APP_SUBCLASS);
+
 #ifndef NDEBUG
-  TU_ASSERT(itf_desc->bInterfaceClass == TUD_USBTMC_APP_CLASS);
-  TU_ASSERT(itf_desc->bInterfaceSubClass == TUD_USBTMC_APP_SUBCLASS);
   // Only 2 or 3 endpoints are allowed for USBTMC.
   TU_ASSERT((itf_desc->bNumEndpoints == 2) || (itf_desc->bNumEndpoints ==3));
 #endif
 
+  TU_ASSERT(usbtmc_state.state == STATE_CLOSED);
+
   // Interface
   (*p_length) = 0u;
   p_desc = (uint8_t const *) itf_desc;
diff --git a/src/class/vendor/vendor_device.c b/src/class/vendor/vendor_device.c
index 8db5005f4..7f2fe9793 100644
--- a/src/class/vendor/vendor_device.c
+++ b/src/class/vendor/vendor_device.c
@@ -168,6 +168,8 @@ void vendord_reset(uint8_t rhport)
 
 bool vendord_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_len)
 {
+  TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass);
+
   // Find available interface
   vendord_interface_t* p_vendor = NULL;
   for(uint8_t i=0; i<CFG_TUD_VENDOR; i++)
diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index c37c19bad..70d0db942 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -139,6 +139,7 @@ typedef enum
   TUSB_REQ_RCPT_OTHER
 } tusb_request_recipient_t;
 
+// https://www.usb.org/defined-class-codes
 typedef enum
 {
   TUSB_CLASS_UNSPECIFIED          = 0    ,
@@ -178,6 +179,12 @@ typedef enum
 
 typedef enum
 {
+  APP_SUBCLASS_USBTMC = 0x03,
+  APP_SUBCLASS_DFU_RUNTIME = 0x01
+} app_subclass_type_t;
+
+typedef enum
+{
   DEVICE_CAPABILITY_WIRELESS_USB               = 0x01,
   DEVICE_CAPABILITY_USB20_EXTENSION            = 0x02,
   DEVICE_CAPABILITY_SUPERSPEED_USB             = 0x03,
diff --git a/src/device/usbd.c b/src/device/usbd.c
index 651cbbc7d..4587a2cc7 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -73,8 +73,17 @@ enum { DRVID_INVALID = 0xFFu };
 //--------------------------------------------------------------------+
 // Class Driver
 //--------------------------------------------------------------------+
-typedef struct {
-  uint8_t class_code;
+#if CFG_TUSB_DEBUG >= 2
+  #define DRIVER_NAME(_name)    .name = _name,
+#else
+  #define DRIVER_NAME(_name)
+#endif
+
+typedef struct
+{
+  #if CFG_TUSB_DEBUG >= 2
+  char const* name;
+  #endif
 
   void (* init             ) (void);
   void (* reset            ) (uint8_t rhport);
@@ -89,7 +98,7 @@ static usbd_class_driver_t const _usbd_driver[] =
 {
   #if CFG_TUD_CDC
   {
-      .class_code       = TUSB_CLASS_CDC,
+      DRIVER_NAME("CDC")
       .init             = cdcd_init,
       .reset            = cdcd_reset,
       .open             = cdcd_open,
@@ -102,7 +111,7 @@ static usbd_class_driver_t const _usbd_driver[] =
 
   #if CFG_TUD_MSC
   {
-      .class_code       = TUSB_CLASS_MSC,
+      DRIVER_NAME("MSC")
       .init             = mscd_init,
       .reset            = mscd_reset,
       .open             = mscd_open,
@@ -115,7 +124,7 @@ static usbd_class_driver_t const _usbd_driver[] =
 
   #if CFG_TUD_HID
   {
-      .class_code       = TUSB_CLASS_HID,
+      DRIVER_NAME("HID")
       .init             = hidd_init,
       .reset            = hidd_reset,
       .open             = hidd_open,
@@ -128,7 +137,7 @@ static usbd_class_driver_t const _usbd_driver[] =
 
   #if CFG_TUD_MIDI
   {
-      .class_code       = TUSB_CLASS_AUDIO,
+      DRIVER_NAME("MIDI")
       .init             = midid_init,
       .open             = midid_open,
       .reset            = midid_reset,
@@ -141,7 +150,7 @@ static usbd_class_driver_t const _usbd_driver[] =
 
   #if CFG_TUD_VENDOR
   {
-      .class_code       = TUSB_CLASS_VENDOR_SPECIFIC,
+      DRIVER_NAME("VENDOR")
       .init             = vendord_init,
       .reset            = vendord_reset,
       .open             = vendord_open,
@@ -153,12 +162,8 @@ static usbd_class_driver_t const _usbd_driver[] =
   #endif
 
   #if CFG_TUD_USBTMC
-  // Presently USBTMC is the only defined class with the APP_SPECIFIC class code.
-  // We maybe need to add subclass codes here, or a callback to ask if a driver can
-  // handle a particular interface.
   {
-      .class_code       = TUD_USBTMC_APP_CLASS,
-    //.subclass_code    = TUD_USBTMC_APP_SUBCLASS
+      DRIVER_NAME("TMC")
       .init             = usbtmcd_init_cb,
       .reset            = usbtmcd_reset_cb,
       .open             = usbtmcd_open_cb,
@@ -171,8 +176,7 @@ static usbd_class_driver_t const _usbd_driver[] =
 
   #if CFG_TUD_DFU_RT
   {
-      .class_code       = TUD_DFU_APP_CLASS,
-    //.subclass_code    = TUD_DFU_APP_SUBCLASS
+      DRIVER_NAME("DFU-RT")
       .init             = dfu_rtd_init,
       .reset            = dfu_rtd_reset,
       .open             = dfu_rtd_open,
@@ -186,7 +190,7 @@ static usbd_class_driver_t const _usbd_driver[] =
   #if CFG_TUD_NET
   /* RNDIS management interface */
   {
-      .class_code       = TUD_RNDIS_ITF_CLASS,
+      DRIVER_NAME("RNDIS")
       .init             = netd_init,
       .reset            = netd_reset,
       .open             = netd_open,
@@ -195,9 +199,10 @@ static usbd_class_driver_t const _usbd_driver[] =
       .xfer_cb          = netd_xfer_cb,
       .sof              = NULL,
   },
+
   /* CDC-ECM management interface */
   {
-      .class_code       = TUSB_CLASS_CDC,
+      DRIVER_NAME("CDC-ECM")
       .init             = netd_init,
       .reset            = netd_reset,
       .open             = netd_open,
@@ -206,9 +211,10 @@ static usbd_class_driver_t const _usbd_driver[] =
       .xfer_cb          = netd_xfer_cb,
       .sof              = NULL,
   },
+
   /* RNDIS/CDC-ECM data interface */
   {
-      .class_code       = TUSB_CLASS_CDC_DATA,
+      DRIVER_NAME("CDC-DATA")
       .init             = netd_init_data,
       .reset            = NULL,
       .open             = netd_open_data,
@@ -262,32 +268,6 @@ static char const* const _usbd_event_str[DCD_EVENT_COUNT] =
   "FUNC_CALL"
 };
 
-// must be same driver order as usbd_class_drivers[]
-static char const* const _usbd_driver_str[USBD_CLASS_DRIVER_COUNT] =
-{
-  #if CFG_TUD_CDC
-    "CDC",
-  #endif
-  #if CFG_TUD_MSC
-    "MSC",
-  #endif
-  #if CFG_TUD_HID
-    "HID",
-  #endif
-  #if CFG_TUD_MIDI
-    "MIDI",
-  #endif
-  #if CFG_TUD_VENDOR
-    "Vendor",
-  #endif
-  #if CFG_TUD_USBTMC
-    "USBTMC"
-  #endif
-  #if CFG_TUD_NET
-    "NET"
-  #endif
-};
-
 static char const* const _tusb_std_request_str[] =
 {
   "Get Status"        ,
@@ -344,7 +324,7 @@ bool tud_init (void)
   // Init class drivers
   for (uint8_t i = 0; i < USBD_CLASS_DRIVER_COUNT; i++)
   {
-    TU_LOG2("%s init\r\n", _usbd_driver_str[i]);
+    TU_LOG2("%s init\r\n", _usbd_driver[i].name);
     _usbd_driver[i].init();
   }
 
@@ -453,7 +433,7 @@ void tud_task (void)
           uint8_t const drv_id = _usbd_dev.ep2drv[epnum][ep_dir];
           TU_ASSERT(drv_id < USBD_CLASS_DRIVER_COUNT,);
 
-          TU_LOG2("  %s xfer callback\r\n", _usbd_driver_str[drv_id]);
+          TU_LOG2("  %s xfer callback\r\n", _usbd_driver[drv_id].name);
           _usbd_driver[drv_id].xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
         }
       }
@@ -498,7 +478,7 @@ static bool invoke_class_control(uint8_t rhport, uint8_t drvid, tusb_control_req
   TU_ASSERT(_usbd_driver[drvid].control_request);
 
   usbd_control_set_complete_callback(_usbd_driver[drvid].control_complete);
-  TU_LOG2("  %s control request\r\n", _usbd_driver_str[drvid]);
+  TU_LOG2("  %s control request\r\n", _usbd_driver[drvid].name);
   return _usbd_driver[drvid].control_request(rhport, request);
 }
 
@@ -755,28 +735,32 @@ static bool process_set_config(uint8_t rhport, uint8_t cfg_num)
     {
       TU_ASSERT( TUSB_DESC_INTERFACE == tu_desc_type(p_desc) );
 
-      tusb_desc_interface_t* desc_itf = (tusb_desc_interface_t*) p_desc;
+      tusb_desc_interface_t const * desc_itf = (tusb_desc_interface_t const*) p_desc;
 
-      // Check if class is supported
       uint8_t drv_id;
+      uint16_t drv_len;
+
       for (drv_id = 0; drv_id < USBD_CLASS_DRIVER_COUNT; drv_id++)
       {
-        if ( _usbd_driver[drv_id].class_code == desc_itf->bInterfaceClass ) break;
-      }
-      TU_ASSERT( drv_id < USBD_CLASS_DRIVER_COUNT );
+        usbd_class_driver_t const *driver = &_usbd_driver[drv_id];
 
-      // Interface number must not be used already TODO alternate interface
-      TU_ASSERT( DRVID_INVALID == _usbd_dev.itf2drv[desc_itf->bInterfaceNumber] );
-      _usbd_dev.itf2drv[desc_itf->bInterfaceNumber] = drv_id;
+        drv_len = 0;
+        if ( driver->open(rhport, desc_itf, &drv_len) )
+        {
+          // Interface number must not be used already TODO alternate interface
+          TU_ASSERT( DRVID_INVALID == _usbd_dev.itf2drv[desc_itf->bInterfaceNumber] );
+          TU_LOG2("  %s open\r\n", _usbd_driver[drv_id].name);
+          _usbd_dev.itf2drv[desc_itf->bInterfaceNumber] = drv_id;
+          break;
+        }
+      }
 
-      uint16_t itf_len=0;
-      TU_LOG2("  %s open\r\n", _usbd_driver_str[drv_id]);
-      TU_ASSERT( _usbd_driver[drv_id].open(rhport, desc_itf, &itf_len) );
-      TU_ASSERT( itf_len >= sizeof(tusb_desc_interface_t) );
+      // Assert if cannot find supported driver
+      TU_ASSERT( drv_id < USBD_CLASS_DRIVER_COUNT && drv_len >= sizeof(tusb_desc_interface_t) );
 
-      mark_interface_endpoint(_usbd_dev.ep2drv, p_desc, itf_len, drv_id);
+      mark_interface_endpoint(_usbd_dev.ep2drv, p_desc, drv_len, drv_id); // TODO refactor
 
-      p_desc += itf_len; // next interface
+      p_desc += drv_len; // next interface
     }
   }
 
diff --git a/src/device/usbd.h b/src/device/usbd.h
index dbc94bc35..acefb6943 100644
--- a/src/device/usbd.h
+++ b/src/device/usbd.h
@@ -183,9 +183,9 @@ TU_ATTR_WEAK bool tud_vendor_control_complete_cb(uint8_t rhport, tusb_control_re
 // Interface number, string index, EP notification address and size, EP data address (out, in) and size.
 #define TUD_CDC_DESCRIPTOR(_itfnum, _stridx, _ep_notif, _ep_notif_size, _epout, _epin, _epsize) \
   /* Interface Associate */\
-  8, TUSB_DESC_INTERFACE_ASSOCIATION, _itfnum, 2, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_ATCOMMAND, 0,\
+  8, TUSB_DESC_INTERFACE_ASSOCIATION, _itfnum, 2, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_NONE, 0,\
   /* CDC Control Interface */\
-  9, TUSB_DESC_INTERFACE, _itfnum, 0, 1, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_ATCOMMAND, _stridx,\
+  9, TUSB_DESC_INTERFACE, _itfnum, 0, 1, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_NONE, _stridx,\
   /* CDC Header */\
   5, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_HEADER, U16_TO_U8S_LE(0x0120),\
   /* CDC Call */\
@@ -291,23 +291,23 @@ TU_ATTR_WEAK bool tud_vendor_control_complete_cb(uint8_t rhport, tusb_control_re
 //   Interface number, number of endpoints, EP string index, USB_TMC_PROTOCOL*, bulk-out endpoint ID,
 //   bulk-in endpoint ID
 #define TUD_USBTMC_IF_DESCRIPTOR(_itfnum, _bNumEndpoints, _stridx, _itfProtocol) \
-/* Interface */ \
+  /* Interface */ \
   0x09, TUSB_DESC_INTERFACE, _itfnum, 0x00, _bNumEndpoints, TUD_USBTMC_APP_CLASS, TUD_USBTMC_APP_SUBCLASS, _itfProtocol, _stridx
 
 #define TUD_USBTMC_IF_DESCRIPTOR_LEN 9u
 
 #define TUD_USBTMC_BULK_DESCRIPTORS(_epout, _epin, _bulk_epsize) \
-/* Endpoint Out */ \
-7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_bulk_epsize), 0u, \
-/* Endpoint In */ \
-7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_bulk_epsize), 0u
+  /* Endpoint Out */ \
+  7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_bulk_epsize), 0u, \
+  /* Endpoint In */ \
+  7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_bulk_epsize), 0u
 
 #define TUD_USBTMC_BULK_DESCRIPTORS_LEN (7u+7u)
 
 /* optional interrupt endpoint */ \
 // _int_pollingInterval : for LS/FS, expressed in frames (1ms each). 16 may be a good number?
 #define TUD_USBTMC_INT_DESCRIPTOR(_ep_interrupt, _ep_interrupt_size, _int_pollingInterval ) \
-7, TUSB_DESC_ENDPOINT, _ep_interrupt, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_ep_interrupt_size), 0x16
+  7, TUSB_DESC_ENDPOINT, _ep_interrupt, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_ep_interrupt_size), 0x16
 
 #define TUD_USBTMC_INT_DESCRIPTOR_LEN (7u)
 
@@ -377,7 +377,7 @@ TU_ATTR_WEAK bool tud_vendor_control_complete_cb(uint8_t rhport, tusb_control_re
   #define TUD_RNDIS_ITF_PROTOCOL 0xFF /* CDC_COMM_PROTOCOL_MICROSOFT_RNDIS */
 #else
   /* Windows 7+ */
-  #define TUD_RNDIS_ITF_CLASS    0xE0
+  #define TUD_RNDIS_ITF_CLASS    TUSB_CLASS_WIRELESS_CONTROLLER
   #define TUD_RNDIS_ITF_SUBCLASS 0x01
   #define TUD_RNDIS_ITF_PROTOCOL 0x03
 #endif