Merge pull request #56 from hathach/develop

refactor hid device, remove auto descriptor, update example

15 files changed, 239 insertions, 1088 deletions

diff --git a/src/class/cdc/cdc_device.h b/src/class/cdc/cdc_device.h
index 25c721e13..d7f89081c 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -95,6 +95,41 @@ ATTR_WEAK void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts);
 ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding);

 

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

+// Interface Descriptor Template

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

+

+// Length of template descriptor: 66 bytes

+#define TUD_CDC_DESC_LEN  (8+9+5+5+4+5+7+9+7+7)

+

+// CDC Descriptor Template

+// 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,\

+  /* CDC Control Interface */\

+  9, TUSB_DESC_INTERFACE, _itfnum, 0, 1, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL, CDC_COMM_PROTOCOL_ATCOMMAND, _stridx,\

+  /* CDC Header */\

+  5, TUSB_DESC_CLASS_SPECIFIC, CDC_FUNC_DESC_HEADER, U16_TO_U8S_LE(0x0120),\

+  /* CDC Call */\

+  5, TUSB_DESC_CLASS_SPECIFIC, CDC_FUNC_DESC_CALL_MANAGEMENT, 0, (_itfnum) + 1,\

+  /* CDC ACM: support line request */\

+  4, TUSB_DESC_CLASS_SPECIFIC, CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT, 2,\

+  /* CDC Union */\

+  5, TUSB_DESC_CLASS_SPECIFIC, CDC_FUNC_DESC_UNION, _itfnum, (_itfnum) + 1,\

+  /* Endpoint Notification */\

+  7, TUSB_DESC_ENDPOINT, _ep_notif, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_ep_notif_size), 16,\

+  /* CDC Data Interface */\

+  9, TUSB_DESC_INTERFACE, (_itfnum)+1, 0, 2, TUSB_CLASS_CDC_DATA, 0, 0, 0,\

+  /* Endpoint Out */\

+  7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0,\

+  /* Endpoint In */\

+  7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0

+

+

+/** @} */

+/** @} */

+

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

 // INTERNAL USBD-CLASS DRIVER API

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

 void cdcd_init               (void);

@@ -109,6 +144,3 @@ void cdcd_reset              (uint8_t rhport);
 #endif

 

 #endif /* _TUSB_CDC_DEVICE_H_ */

-

-/** @} */

-/** @} */

diff --git a/src/class/hid/hid.h b/src/class/hid/hid.h
index 8149f69f7..637f13295 100644
--- a/src/class/hid/hid.h
+++ b/src/class/hid/hid.h
@@ -179,7 +179,7 @@ typedef enum
 /// Standard HID Boot Protocol Keyboard Report.

 typedef struct ATTR_PACKED

 {

-  uint8_t modifier;   /**< Keyboard modifier byte, indicating pressed modifier keys (a combination of HID_KEYBOARD_MODIFER_* masks). */

+  uint8_t modifier;   /**< Keyboard modifier (KEYBOARD_MODIFER_* masks). */

   uint8_t reserved;   /**< Reserved for OEM use, always set to 0. */

   uint8_t keycode[6]; /**< Key codes of the currently pressed keys. */

 } hid_keyboard_report_t;

diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
index 5c81a1268..38ad99a35 100644
--- a/src/class/hid/hid_device.c
+++ b/src/class/hid/hid_device.c
@@ -39,61 +39,31 @@
 // MACRO CONSTANT TYPEDEF

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

 

-// Max report len is keyboard's one with 8 byte + 1 byte report id

-#define REPORT_BUFSIZE      12

-

-#define ITF_IDX_BOOT_KBD   0

-#define ITF_IDX_BOOT_MSE   ( ITF_IDX_BOOT_KBD + (CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT) )

-#define ITF_IDX_GENERIC    ( ITF_IDX_BOOT_MSE + (CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT) )

-#define ITF_COUNT          ( ITF_IDX_GENERIC + 1 )

+#ifndef CFG_TUD_HID_BUFSIZE

+#define CFG_TUD_HID_BUFSIZE     16

+#endif

 

 typedef struct

 {

   uint8_t itf_num;

   uint8_t ep_in;

+  uint8_t boot_protocol; // Boot mouse or keyboard

+  bool    boot_mode;

 

-  uint8_t idle_rate; // in unit of 4 ms TODO removed

-  bool    boot_protocol;

-

-  uint16_t desc_len;

-  uint8_t const * desc_report;

-

-  CFG_TUSB_MEM_ALIGN uint8_t report_buf[REPORT_BUFSIZE];

-

-  // callbacks

-  uint16_t (*get_report_cb) (uint8_t report_id, hid_report_type_t type, uint8_t* buffer, uint16_t reqlen);

-  void     (*set_report_cb) (uint8_t report_id, hid_report_type_t type, uint8_t const* buffer, uint16_t bufsize);

+  uint16_t reprot_desc_len;

+  uint8_t idle_rate;     // Idle Rate = 0 : only send report if there is changes, i.e skip duplication

+                         // Idle Rate > 0 : skip duplication, but send at least 1 report every idle rate (in unit of 4 ms).

+  uint8_t mouse_button;  // caching button for using with tud_hid_mouse_ API

 

+  CFG_TUSB_MEM_ALIGN uint8_t report_buf[CFG_TUD_HID_BUFSIZE];

 }hidd_interface_t;

 

-typedef struct

-{

-  uint8_t usage;      // HID_USAGE_*

-  uint8_t idle_rate;  // Idle Rate = 0 : only send report if there is changes, i.e skip duplication

-                      // Idle Rate > 0 : skip duplication, but send at least 1 report every idle rate (in unit of 4 ms).

-                      //                 If idle time is less than interrupt polling then use the polling.

-

-  uint8_t report_id;

-  uint8_t report_len;

-

-  hidd_interface_t* itf;

-} hidd_report_t ;

-

-CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[ITF_COUNT] = { { 0 } };

-

-

-#if CFG_TUD_HID_KEYBOARD

-static hidd_report_t _kbd_rpt;

-#endif

-

-#if CFG_TUD_HID_MOUSE

-static hidd_report_t _mse_rpt;

-#endif

+CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[CFG_TUD_HID];

 

 /*------------- Helpers -------------*/

 static inline hidd_interface_t* get_interface_by_itfnum(uint8_t itf_num)

 {

-  for (uint8_t i=0; i < ITF_COUNT; i++ )

+  for (uint8_t i=0; i < CFG_TUD_HID; i++ )

   {

     if ( itf_num == _hidd_itf[i].itf_num ) return &_hidd_itf[i];

   }

@@ -101,20 +71,22 @@ static inline hidd_interface_t* get_interface_by_itfnum(uint8_t itf_num)
   return NULL;

 }

 

-

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

-// HID GENERIC API

+// APPLICATION API

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

-bool tud_hid_generic_ready(void)

+bool tud_hid_ready(void)

 {

-  return tud_ready() && (_hidd_itf[ITF_IDX_GENERIC].ep_in != 0) && !dcd_edpt_busy(TUD_OPT_RHPORT, _hidd_itf[ITF_IDX_GENERIC].ep_in);

+  uint8_t itf = 0;

+  uint8_t const ep_in = _hidd_itf[itf].ep_in;

+  return tud_ready() && (ep_in != 0) && !dcd_edpt_busy(TUD_OPT_RHPORT, ep_in);

 }

 

-bool tud_hid_generic_report(uint8_t report_id, void const* report, uint8_t len)

+bool tud_hid_report(uint8_t report_id, void const* report, uint8_t len)

 {

-  TU_VERIFY( tud_hid_generic_ready() && (len < REPORT_BUFSIZE) );

+  TU_VERIFY( tud_hid_ready() && (len < CFG_TUD_HID_BUFSIZE) );

 

-  hidd_interface_t * p_hid = &_hidd_itf[ITF_IDX_GENERIC];

+  uint8_t itf = 0;

+  hidd_interface_t * p_hid = &_hidd_itf[itf];

 

   // If report id = 0, skip ID field

   if (report_id)

@@ -126,44 +98,24 @@ bool tud_hid_generic_report(uint8_t report_id, void const* report, uint8_t len)
     memcpy(p_hid->report_buf, report, len);

   }

 

-  // TODO idle rate

-  return dcd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->report_buf, len + ( report_id ? 1 : 0) );

+  // TODO skip duplication ? and or idle rate

+  return dcd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->report_buf, len + (report_id ? 1 : 0) );

 }

 

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

-// KEYBOARD APPLICATION API

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

-#if CFG_TUD_HID_KEYBOARD

-bool tud_hid_keyboard_ready(void)

+bool tud_hid_boot_mode(void)

 {

-  return (_kbd_rpt.itf != NULL) && !dcd_edpt_busy(TUD_OPT_RHPORT, _kbd_rpt.itf->ep_in);

+  uint8_t itf = 0;

+  return _hidd_itf[itf].boot_mode;

 }

 

-bool tud_hid_keyboard_is_boot_protocol(void)

-{

-  return (_kbd_rpt.itf != NULL) && _kbd_rpt.itf->boot_protocol;

-}

-

-static bool hidd_kbd_report(hid_keyboard_report_t const *p_report)

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

+// KEYBOARD API

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

+bool tud_hid_keyboard_report(uint8_t report_id, uint8_t modifier, uint8_t keycode[6])

 {

-  TU_VERIFY( tud_hid_keyboard_ready() );

-

-  hidd_interface_t * p_hid = _kbd_rpt.itf;

-

-  // only send report if there is changes, i.e skip duplication

-//  if ( _kbd_rpt.idle_rate == 0 )

-//  {

-//    if ( 0 == memcmp(p_hid->report_buf, p_report, sizeof(hid_keyboard_report_t)) ) return true;

-//  }

+  hid_keyboard_report_t report;

 

-  memcpy(p_hid->report_buf, p_report, sizeof(hid_keyboard_report_t));

-

-  return dcd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->report_buf, sizeof(hid_keyboard_report_t));

-}

-

-bool tud_hid_keyboard_keycode(uint8_t modifier, uint8_t keycode[6])

-{

-  hid_keyboard_report_t report = { .modifier = modifier };

+  report.modifier = modifier;

 

   if ( keycode )

   {

@@ -173,12 +125,12 @@ bool tud_hid_keyboard_keycode(uint8_t modifier, uint8_t keycode[6])
     tu_memclr(report.keycode, 6);

   }

 

-  return hidd_kbd_report(&report);

+  // TODO skip duplication ? and or idle rate

+  return tud_hid_report(report_id, &report, sizeof(report));

 }

 

 #if CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP

-

-bool tud_hid_keyboard_key_press(char ch)

+bool tud_hid_keyboard_key_press(uint8_t report_id, char ch)

 {

   uint8_t keycode[6] = { 0 };

   uint8_t modifier   = 0;

@@ -186,75 +138,47 @@ bool tud_hid_keyboard_key_press(char ch)
   if ( HID_ASCII_TO_KEYCODE[(uint8_t)ch].shift ) modifier = KEYBOARD_MODIFIER_LEFTSHIFT;

   keycode[0] = HID_ASCII_TO_KEYCODE[(uint8_t)ch].keycode;

 

-  return tud_hid_keyboard_keycode(modifier, keycode);

+  return tud_hid_keyboard_report(report_id, modifier, keycode);

 }

-

 #endif // CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP

 

-#endif // CFG_TUD_HID_KEYBOARD

-

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

 // MOUSE APPLICATION API

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

-#if CFG_TUD_HID_MOUSE

-

-bool tud_hid_mouse_ready(void)

-{

-  return (_mse_rpt.itf != NULL) && !dcd_edpt_busy(TUD_OPT_RHPORT, _mse_rpt.itf->ep_in);

-}

-

-bool tud_hid_mouse_is_boot_protocol(void)

-{

-  return (_mse_rpt.itf != NULL) && _mse_rpt.itf->boot_protocol;

-}

-

-static bool hidd_mouse_report(hid_mouse_report_t const *p_report)

-{

-  TU_VERIFY( tud_hid_mouse_ready() );

-

-  hidd_interface_t * p_hid = _mse_rpt.itf;

-// only send report if there is changes, i.e skip duplication

-  memcpy(p_hid->report_buf, p_report, sizeof(hid_mouse_report_t));

-

-  return dcd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->report_buf, sizeof(hid_mouse_report_t));

-}

-

-bool tud_hid_mouse_data(uint8_t buttons, int8_t x, int8_t y, int8_t scroll, int8_t pan)

+bool tud_hid_mouse_report(uint8_t report_id, uint8_t buttons, int8_t x, int8_t y, int8_t scroll, int8_t pan)

 {

+  (void) pan;

   hid_mouse_report_t report =

   {

-      .buttons = buttons,

-      .x       = x,

-      .y       = y,

-      .wheel   = scroll,

-//      .pan     = pan

+    .buttons = buttons,

+    .x       = x,

+    .y       = y,

+    .wheel   = scroll,

+    //.pan     = pan

   };

 

-  return hidd_mouse_report( &report );

+  uint8_t itf = 0;

+  _hidd_itf[itf].mouse_button = buttons;

+

+  return tud_hid_report(report_id, &report, sizeof(report));

 }

 

-bool tud_hid_mouse_move(int8_t x, int8_t y)

+bool tud_hid_mouse_move(uint8_t report_id, int8_t x, int8_t y)

 {

-  TU_VERIFY( tud_hid_mouse_ready() );

-

-  hidd_interface_t * p_hid = _mse_rpt.itf;

-  uint8_t prev_buttons = p_hid->report_buf[0];

+  uint8_t itf = 0;

+  uint8_t const button = _hidd_itf[itf].mouse_button;

 

-  return tud_hid_mouse_data(prev_buttons, x, y, 0, 0);

+  return tud_hid_mouse_report(report_id, button, x, y, 0, 0);

 }

 

-bool tud_hid_mouse_scroll(int8_t vertical, int8_t horizontal)

+bool tud_hid_mouse_scroll(uint8_t report_id, int8_t scroll, int8_t pan)

 {

-  TU_VERIFY( tud_hid_mouse_ready() );

-

-  hidd_interface_t * p_hid =  _mse_rpt.itf;

-  uint8_t prev_buttons = p_hid->report_buf[0];

+  uint8_t itf = 0;

+  uint8_t const button = _hidd_itf[itf].mouse_button;

 

-  return tud_hid_mouse_data(prev_buttons, 0, 0, vertical, horizontal);

+  return tud_hid_mouse_report(report_id, button, 0, 0, scroll, pan);

 }

 

-#endif // CFG_TUD_HID_MOUSE

-

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

 // USBD-CLASS API

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

@@ -267,23 +191,12 @@ void hidd_reset(uint8_t rhport)
 {

   (void) rhport;

   tu_memclr(_hidd_itf, sizeof(_hidd_itf));

-

-  #if CFG_TUD_HID_KEYBOARD

-  tu_varclr(&_kbd_rpt);

-  #endif

-

-  #if CFG_TUD_HID_MOUSE

-  tu_varclr(&_mse_rpt);

-  #endif

 }

 

 bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_len)

 {

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

 

-  // TODO support HID OUT Endpoint

-  TU_ASSERT(desc_itf->bNumEndpoints == 1);

-

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

   p_desc = tu_desc_next(p_desc);

   tusb_hid_descriptor_hid_t const *desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;

@@ -294,65 +207,18 @@ bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t
   tusb_desc_endpoint_t const *desc_edpt = (tusb_desc_endpoint_t const *) p_desc;

   TU_ASSERT(TUSB_DESC_ENDPOINT == desc_edpt->bDescriptorType);

 

-  hidd_interface_t * p_hid = NULL;

-

-  /*------------- Boot protocol only keyboard & mouse -------------*/

-  if (desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT)

-  {

-    TU_ASSERT(desc_itf->bInterfaceProtocol == HID_PROTOCOL_KEYBOARD || desc_itf->bInterfaceProtocol == HID_PROTOCOL_MOUSE);

-

-    #if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT

-    if (desc_itf->bInterfaceProtocol == HID_PROTOCOL_KEYBOARD)

-    {

-      p_hid = &_hidd_itf[ITF_IDX_BOOT_KBD];

-      p_hid->desc_report   = usbd_desc_set->hid_report.boot_keyboard;

-      p_hid->get_report_cb = tud_hid_keyboard_get_report_cb;

-      p_hid->set_report_cb = tud_hid_keyboard_set_report_cb;

-

-      hidd_report_t* report = &_kbd_rpt;

-      report->usage = HID_USAGE_DESKTOP_KEYBOARD;

-      report->report_id = 0;

-      report->report_len = 8;

-      report->itf = p_hid;

-    }

-    #endif

-

-    #if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT

-    if (desc_itf->bInterfaceProtocol == HID_PROTOCOL_MOUSE)

-    {

-      p_hid = &_hidd_itf[ITF_IDX_BOOT_MSE];

-      p_hid->desc_report   = usbd_desc_set->hid_report.boot_mouse;

-      p_hid->get_report_cb = tud_hid_mouse_get_report_cb;

-      p_hid->set_report_cb = tud_hid_mouse_set_report_cb;

-

-      hidd_report_t* report = &_mse_rpt;

-      report->usage = HID_USAGE_DESKTOP_MOUSE;

-      report->report_id = 0;

-      report->report_len = 4;

-      report->itf = p_hid;

-    }

-    #endif

-

-    TU_ASSERT(p_hid);

-    p_hid->boot_protocol = true; // default mode is BOOT

-  }

-  /*------------- Generic (multiple report) -------------*/

-  else

-  {

-    // TODO parse report ID for keyboard, mouse

-    p_hid = &_hidd_itf[ITF_IDX_GENERIC];

+  TU_ASSERT(dcd_edpt_open(rhport, desc_edpt));

 

-    p_hid->desc_report   = usbd_desc_set->hid_report.generic;

-    p_hid->get_report_cb = tud_hid_generic_get_report_cb;

-    p_hid->set_report_cb = tud_hid_generic_set_report_cb;

-  }

+  // TODO support multiple HID interface

+  uint8_t itf = 0;

+  hidd_interface_t * p_hid = &_hidd_itf[itf];

 

-  TU_ASSERT(p_hid->desc_report);

-  TU_ASSERT(dcd_edpt_open(rhport, desc_edpt));

+  if ( desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT ) p_hid->boot_protocol = desc_itf->bInterfaceProtocol;

 

+  p_hid->boot_mode = false; // default mode is REPORT

   p_hid->itf_num   = desc_itf->bInterfaceNumber;

   p_hid->ep_in     = desc_edpt->bEndpointAddress;

-  p_hid->desc_len  = desc_hid->wReportLength;

+  p_hid->reprot_desc_len  = desc_hid->wReportLength;

 

   *p_len = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + desc_itf->bNumEndpoints*sizeof(tusb_desc_endpoint_t);

 

@@ -375,7 +241,7 @@ bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_reque
 

     if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)

     {

-      usbd_control_xfer(rhport, p_request, (void *)p_hid->desc_report, p_hid->desc_len);

+      usbd_control_xfer(rhport, p_request, (void*) tud_desc_set.hid_report, p_hid->reprot_desc_len);

     }else

     {

       return false; // stall unsupported request

@@ -392,17 +258,9 @@ bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_reque
         uint8_t const report_type = tu_u16_high(p_request->wValue);

         uint8_t const report_id   = tu_u16_low(p_request->wValue);

 

-        uint16_t xferlen;

-        if ( p_hid->get_report_cb )

-        {

-          xferlen = p_hid->get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

-        }else

-        {

-          // For boot Interface only: re-use report_buf -> report has no change

-          xferlen = p_request->wLength;

-        }

-

+        uint16_t xferlen  = tud_hid_get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

         TU_ASSERT( xferlen > 0 );

+

         usbd_control_xfer(rhport, p_request, p_hid->report_buf, xferlen);

       }

       break;

@@ -424,13 +282,16 @@ bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_reque
 

       case HID_REQ_CONTROL_GET_PROTOCOL:

       {

-        uint8_t protocol = 1-p_hid->boot_protocol;   // 0 is Boot, 1 is Report protocol

+        uint8_t protocol = 1-p_hid->boot_mode;   // 0 is Boot, 1 is Report protocol

         usbd_control_xfer(rhport, p_request, &protocol, 1);

       }

       break;

 

       case HID_REQ_CONTROL_SET_PROTOCOL:

-        p_hid->boot_protocol = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol

+        p_hid->boot_mode = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol

+

+        if (tud_hid_mode_changed_cb) tud_hid_mode_changed_cb(p_hid->boot_mode);

+

         usbd_control_status(rhport, p_request);

       break;

 

@@ -459,10 +320,7 @@ bool hidd_control_request_complete(uint8_t rhport, tusb_control_request_t const
     uint8_t const report_type = tu_u16_high(p_request->wValue);

     uint8_t const report_id   = tu_u16_low(p_request->wValue);

 

-    if ( p_hid->set_report_cb )

-    {

-      p_hid->set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

-    }

+    tud_hid_set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

   }

 

   return true;

@@ -480,11 +338,8 @@ bool hidd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
 }

 

 

-/*------------------------------------------------------------------*/

-/* Ascii to Keycode

- *------------------------------------------------------------------*/

+//------------- Ascii to Keycode Lookup -------------//

 #if CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP

-

 const hid_ascii_to_keycode_entry_t HID_ASCII_TO_KEYCODE[128] =

 {

     {0, 0                     }, // 0x00 Null

@@ -619,7 +474,6 @@ const hid_ascii_to_keycode_entry_t HID_ASCII_TO_KEYCODE[128] =
     {1, HID_KEY_GRAVE         }, // 0x7E ~

     {0, HID_KEY_DELETE        }  // 0x7F Delete

 };

-

-#endif

+#endif // CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP

 

 #endif

diff --git a/src/class/hid/hid_device.h b/src/class/hid/hid_device.h
index 096daad18..c017a8227 100644
--- a/src/class/hid/hid_device.h
+++ b/src/class/hid/hid_device.h
@@ -42,47 +42,47 @@
 #define CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP 0

 #endif

 

-#if !CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT

-#error CFG_TUD_HID_KEYBOARD must be enabled

-#endif

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

+// Application API

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

 

-#if !CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT

-#error CFG_TUD_HID_MOUSE must be enabled

-#endif

+// Check if the interface is ready to use

+bool tud_hid_ready(void);

 

+// Check if current mode is Boot (true) or Report (false)

+bool tud_hid_boot_mode(void);

 

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

-// HID GENERIC API

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

-bool tud_hid_generic_ready(void);

-bool tud_hid_generic_report(uint8_t report_id, void const* report, uint8_t len);

+// Send report to host

+bool tud_hid_report(uint8_t report_id, void const* report, uint8_t len);

 

 /*------------- Callbacks (Weak is optional) -------------*/

-uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);

-void     tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);

+

+// Invoked when receiving GET_REPORT control request

+// Application must fill buffer report's content and return its length.

+// Return zero will cause the stack to STALL request

+uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);

+

+// Invoked when receiving SET_REPORT control request

+void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);

+

+// Invoked when host switch mode Boot <-> Report via SET_PROTOCOL request

+void tud_hid_mode_changed_cb(uint8_t boot_mode) ATTR_WEAK;

 

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

 // KEYBOARD API

+// Convenient helper to send keyboard report if application use standard/boot

+// layout report as defined by hid_keyboard_report_t

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

-#if CFG_TUD_HID_KEYBOARD

-/** \addtogroup ClassDriver_HID_Keyboard Keyboard

- *  @{ */

-/** \defgroup Keyboard_Device Device

- *  @{ */

 

-/** Check if the interface is ready to use

- * \returns true if ready, otherwise interface may not be mounted or still busy transferring data

- * \note    Application must not perform any action if the interface is not ready

- */

-bool tud_hid_keyboard_ready(void);

-bool tud_hid_keyboard_is_boot_protocol(void);

-

-bool tud_hid_keyboard_keycode(uint8_t modifier, uint8_t keycode[6]);

+bool tud_hid_keyboard_report(uint8_t report_id, uint8_t modifier, uint8_t keycode[6]);

 

-static inline bool tud_hid_keyboard_key_release(void) { return tud_hid_keyboard_keycode(0, NULL); }

+static inline bool tud_hid_keyboard_key_release(uint8_t report_id)

+{

+  return tud_hid_keyboard_report(report_id, 0, NULL);

+}

 

 #if CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP

-bool tud_hid_keyboard_key_press(char ch);

+bool tud_hid_keyboard_key_press(uint8_t report_id, char ch);

 

 typedef struct{

   uint8_t shift;

@@ -91,115 +91,59 @@ typedef struct{
 extern const hid_ascii_to_keycode_entry_t HID_ASCII_TO_KEYCODE[128];

 #endif

 

-#endif

-

-/*------------- Callbacks (Weak is optional) -------------*/

-

-/** Callback invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.

- * \param[in]   report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests

- * \param[out]  buffer data that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

- * \param[in]   reqlen  number of bytes that host requested

- * \retval      non-zero Actual number of bytes in the response's buffer.

- * \retval      zero  indicates the current request is not supported. Tinyusb device stack will reject the request by

- *              sending STALL in the data phase.

- * \note        After this callback, the request is silently executed by the tinyusb stack, thus

- *              the completion of this control request will not be reported to application.

- *              For Keyboard, USB host often uses this to turn on/off the LED for CAPLOCKS, NUMLOCK (\ref hid_keyboard_led_bm_t)

- */

-ATTR_WEAK uint16_t tud_hid_keyboard_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);

-

-/** Callback invoked when USB host request \ref HID_REQ_CONTROL_SET_REPORT.

- * \param[in]   report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests

- * \param[in]   buffer  containing the report's data

- * \param[in]   bufsize  number of bytes in the \a buffer

- * \note        By the time this callback is invoked, the USB control transfer is already completed in the hardware side.

- *              Application are free to handle data at its own will.

- */

-ATTR_WEAK void tud_hid_keyboard_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);

-

-

-//ATTR_WEAK void tud_hid_keyboard_set_protocol_cb(bool boot_protocol);

-

-/** @} */

-/** @} */

-

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

 // MOUSE API

+// Convenient helper to send mouse report if application use standard/boot

+// layout report as defined by hid_mouse_report_t

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

-#if CFG_TUD_HID_MOUSE

-/** \addtogroup ClassDriver_HID_Mouse Mouse

- *  @{ */

-/** \defgroup Mouse_Device Device

- *  @{ */

-

-/** \brief      Check if the interface is currently busy or not

- * \retval      true if the interface is busy meaning the stack is still transferring/waiting data from/to host

- * \retval      false if the interface is not busy meaning the stack successfully transferred data from/to host

- * \note        This function is primarily used for polling/waiting result after \ref tusbd_hid_mouse_send.

- */

-bool tud_hid_mouse_ready(void);

-bool tud_hid_mouse_is_boot_protocol(void);

-

-bool tud_hid_mouse_data(uint8_t buttons, int8_t x, int8_t y, int8_t scroll, int8_t pan);

 

-bool tud_hid_mouse_move(int8_t x, int8_t y);

-bool tud_hid_mouse_scroll(int8_t vertical, int8_t horizontal);

+bool tud_hid_mouse_report(uint8_t report_id, uint8_t buttons, int8_t x, int8_t y, int8_t scroll, int8_t pan);

+bool tud_hid_mouse_move(uint8_t report_id, int8_t x, int8_t y);

+bool tud_hid_mouse_scroll(uint8_t report_id, int8_t scroll, int8_t pan);

 

-static inline bool tud_hid_mouse_button_press(uint8_t buttons)

+static inline bool tud_hid_mouse_button_press(uint8_t report_id, uint8_t buttons)

 {

-  return tud_hid_mouse_data(buttons, 0, 0, 0, 0);

+  return tud_hid_mouse_report(report_id, buttons, 0, 0, 0, 0);

 }

 

-static inline bool tud_hid_mouse_button_release(void)

+static inline bool tud_hid_mouse_button_release(uint8_t report_id)

 {

-  return tud_hid_mouse_data(0, 0, 0, 0, 0);

+  return tud_hid_mouse_report(report_id, 0, 0, 0, 0, 0);

 }

 

-/*------------- Callbacks (Weak is optional) -------------*/

-

-/**

- * Callback function that is invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.

- * \param[in]   report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests

- * \param[out]  buffer  buffer that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

- * \param[in]   reqlen  number of bytes that host requested

- * \retval      non-zero Actual number of bytes in the response's buffer.

- * \retval      zero  indicates the current request is not supported. Tinyusb device stack will reject the request by

- *              sending STALL in the data phase.

- * \note        After this callback, the request is silently executed by the tinyusb stack, thus

- *              the completion of this control request will not be reported to application

- */

-ATTR_WEAK uint16_t tud_hid_mouse_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);

-

-/**

- * Callback function that is invoked when USB host request \ref HID_REQ_CONTROL_SET_REPORT.

- * \param[in]   report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests

- * \param[in]   buffer buffer containing the report's data

- * \param[in]   bufsize  number of bytes in the \a p_report_data

- * \note        By the time this callback is invoked, the USB control transfer is already completed in the hardware side.

- *              Application are free to handle data at its own will.

- */

-ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);

-

-//ATTR_WEAK void tud_hid_mouse_set_protocol_cb(bool boot_protocol);

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

+// Interface Descriptor Template

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

 

-#endif

+#define TUD_HID_DESC_LEN    (9 + 9 + 7)

 

+#define TUD_HID_DESCRIPTOR(_itfnum, _stridx, _boot_protocol, _report_desc_len, _epin, _epsize, _ep_interval) \

+  /* Interface */\

+  9, TUSB_DESC_INTERFACE, _itfnum, 0, 1, TUSB_CLASS_HID, (_boot_protocol) ? HID_SUBCLASS_BOOT : 0, _boot_protocol, _stridx,\

+  /* HID descriptor */\

+  9, HID_DESC_TYPE_HID, U16_TO_U8S_LE(0x0111), 0, 1, HID_DESC_TYPE_REPORT, U16_TO_U8S_LE(_report_desc_len),\

+  /* Endpoint descriptor */\

+  7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_epsize), _ep_interval

 

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

-// HID Report Descriptor Template

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

-/* These template should be used as follow

- * - Only 1 report : no parameter

- *      uint8_t report_desc[] = { ID_REPORT_DESC_KEYBOARD() };

+/* --------------------------------------------------------------------+

+ * HID Report Descriptor Template

+ *

+ * Convenient for declaring popular HID device (keyboard, mouse, consumer,

+ * gamepad etc...). Templates take "HID_REPORT_ID(n)," as input, leave

+ * empty if multiple reports is not used

+ *

+ * - Only 1 report: no parameter

+ *      uint8_t const report_desc[] = { HID_REPORT_DESC_KEYBOARD() };

  *

  * - Multiple Reports: "HID_REPORT_ID(ID)," must be passed to template

- *      uint8_t report_desc[] = {

- *          ID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(1) ,) ,

- *          HID_REPORT_DESC_MOUSE  ( HID_REPORT_ID(2) ,)

+ *      uint8_t const report_desc[] =

+ *      {

+ *          HID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(1), ) ,

+ *          HID_REPORT_DESC_MOUSE   ( HID_REPORT_ID(2), )

  *      };

- */

+ *--------------------------------------------------------------------*/

 

-/*------------- Keyboard Descriptor Template -------------*/

+// Keyboard Report Descriptor Template

 #define HID_REPORT_DESC_KEYBOARD(...) \

   HID_USAGE_PAGE ( HID_USAGE_PAGE_DESKTOP     )                    ,\

   HID_USAGE      ( HID_USAGE_DESKTOP_KEYBOARD )                    ,\

@@ -240,7 +184,7 @@ ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t
       HID_OUTPUT       ( HID_CONSTANT                            ) ,\

   HID_COLLECTION_END \

 

-/*------------- Mouse Descriptor Template -------------*/

+// Mouse Report Descriptor Template

 #define HID_REPORT_DESC_MOUSE(...) \

   HID_USAGE_PAGE ( HID_USAGE_PAGE_DESKTOP      )                    ,\

   HID_USAGE      ( HID_USAGE_DESKTOP_MOUSE     )                    ,\

@@ -280,7 +224,7 @@ ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t
     HID_COLLECTION_END                                              ,\

   HID_COLLECTION_END \

 

-//------------- Consumer Control Report Template -------------//

+// Consumer Control Report Descriptor Template

 #define HID_REPORT_DESC_CONSUMER(...) \

   HID_USAGE_PAGE ( HID_USAGE_PAGE_CONSUMER    )              ,\

   HID_USAGE      ( HID_USAGE_CONSUMER_CONTROL )              ,\

@@ -295,8 +239,8 @@ ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t
     HID_INPUT        ( HID_DATA | HID_ARRAY | HID_ABSOLUTE ) ,\

   HID_COLLECTION_END \

 

-//------------- System Control Report Template -------------//

-/* 0x00 - do nothing

+/* System Control Report Descriptor Template

+ * 0x00 - do nothing

  * 0x01 - Power Off

  * 0x02 - Standby

  * 0x04 - Wake Host

@@ -321,8 +265,8 @@ ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t
     HID_INPUT        ( HID_CONSTANT                        ) ,\

   HID_COLLECTION_END \

 

-//------------- Gamepad Report Template -------------//

-// Gamepad with 16 buttons and 2 joysticks

+// Gamepad Report Descriptor Template

+// with 16 buttons and 2 joysticks with following layout

 // | Button Map (2 bytes) |  X | Y | Z | Rz

 #define HID_REPORT_DESC_GAMEPAD(...) \

   HID_USAGE_PAGE ( HID_USAGE_PAGE_DESKTOP     )        ,\

@@ -351,15 +295,11 @@ ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t
     HID_INPUT        ( HID_DATA | HID_VARIABLE | HID_ABSOLUTE ) ,\

   HID_COLLECTION_END \

 

-

-

 /** @} */

 /** @} */

 

-

-

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

-// INTERNAL API

+// Internal Class Driver API

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

 void hidd_init(void);

 bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t *p_length);

diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index ace91b40a..a6b65557c 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -113,7 +113,6 @@ bool tud_msc_set_sense(uint8_t lun, uint8_t sense_key, uint8_t add_sense_code, u
   return true;

 }

 

-

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

 // USBD-CLASS API

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

diff --git a/src/class/msc/msc_device.h b/src/class/msc/msc_device.h
index 74be7e06d..b6cef78b6 100644
--- a/src/class/msc/msc_device.h
+++ b/src/class/msc/msc_device.h
@@ -31,6 +31,9 @@
 #include "device/usbd.h"

 #include "msc.h"

 

+#ifdef __cplusplus

+ extern "C" {

+#endif

 

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

 // Class Driver Configuration

@@ -44,7 +47,7 @@ TU_VERIFY_STATIC(CFG_TUD_MSC_BUFSIZE < UINT16_MAX, "Size is not correct");
 #endif

 

 #ifndef CFG_TUD_MSC_BUFSIZE

-  #error CFG_TUD_MSC_BUFSIZE must be defined, value of CFG_TUD_MSC_BLOCK_SZ should work well, the more the better

+  #error CFG_TUD_MSC_BUFSIZE must be defined, value of a block size should work well, the more the better

 #endif

 

 #ifndef CFG_TUD_MSC_VENDOR

@@ -59,10 +62,6 @@ TU_VERIFY_STATIC(CFG_TUD_MSC_BUFSIZE < UINT16_MAX, "Size is not correct");
   #error CFG_TUD_MSC_PRODUCT_REV 4-byte string must be defined

 #endif

 

-#ifdef __cplusplus

- extern "C" {

-#endif

-

 /** \addtogroup ClassDriver_MSC

  *  @{

  * \defgroup MSC_Device Device

@@ -133,7 +132,7 @@ void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_siz
  */

 int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize);

 

-/*------------- Optional callbacks : Could be used by application to free up resources -------------*/

+/*------------- Optional callbacks -------------*/

 

 // Invoked when Read10 command is complete

 ATTR_WEAK void tud_msc_read10_complete_cb(uint8_t lun);

@@ -147,6 +146,23 @@ ATTR_WEAK void tud_msc_scsi_complete_cb(uint8_t lun, uint8_t const scsi_cmd[16])
 // Hook to make a mass storage device read-only. TODO remove

 ATTR_WEAK bool tud_msc_is_writable_cb(uint8_t lun);

 

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

+// Interface Descriptor Template

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

+

+// Length of template descriptor: 23 bytes

+#define TUD_MSC_DESC_LEN    (9 + 7 + 7)

+

+// Interface Number, EP Out & EP In address

+#define TUD_MSC_DESCRIPTOR(_itfnum, _stridx, _epout, _epin, _epsize) \

+  /* Interface */\

+  9, TUSB_DESC_INTERFACE, _itfnum, 0, 2, TUSB_CLASS_MSC, MSC_SUBCLASS_SCSI, MSC_PROTOCOL_BOT, _stridx,\

+  /* Endpoint Out */\

+  7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0,\

+  /* Endpoint In */\

+  7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0

+

+

 /** @} */

 /** @} */

 

diff --git a/src/common/compiler/tusb_compiler_gcc.h b/src/common/compiler/tusb_compiler_gcc.h
index a3b84116f..bb2d0b56b 100644
--- a/src/common/compiler/tusb_compiler_gcc.h
+++ b/src/common/compiler/tusb_compiler_gcc.h
@@ -35,34 +35,25 @@
  extern "C" {
 #endif
 
-#define ALIGN_OF(x) __alignof__(x)
+#define ALIGN_OF(x)                __alignof__(x)
 
-/// This attribute specifies a minimum alignment for the variable or structure field, measured in bytes
+// Specifies a minimum alignment for the variable or structure field, measured in bytes
 #define ATTR_ALIGNED(Bytes)        __attribute__ ((aligned(Bytes)))
 
-/// Place variable in a specific section
+// Place variable in a specific section
 #define ATTR_SECTION(sec_name)      __attribute__ (( section(#sec_name) ))
 
-/// The packed attribute specifies that a variable or structure field should have
-/// the smallest possible alignment—one byte for a variable, and one bit for a field.
+// Packed struct/variable into smallest possible size
 #define ATTR_PACKED                __attribute__ ((packed))
 #define ATTR_PREPACKED
 
-/// This attribute inlines the function even if no optimization level is specified
-#define ATTR_ALWAYS_INLINE         __attribute__ ((always_inline))
-
-/// The deprecated attribute results in a warning if the function is used anywhere in the source file.
-/// This is useful when identifying functions that are expected to be removed in a future version of a program.
+// The deprecated attribute results in a warning if the function is used.
 #define ATTR_DEPRECATED(mess)      __attribute__ ((deprecated(mess)))
 
-/// The weak attribute causes the declaration to be emitted as a weak symbol rather than a global.
-/// This is primarily useful in defining library functions that can be overridden in user code
+// The weak attribute causes the declaration to be emitted as a weak symbol rather than a global.
 #define ATTR_WEAK                  __attribute__ ((weak))
 
-/// Warn if a caller of the function with this attribute does not use its return value.
-#define ATTR_WARN_UNUSED_RESULT    __attribute__ ((warn_unused_result))
-
-/// Function is meant to be possibly unused. GCC does not produce a warning for this function.
+// Function/Variable is meant to be possibly unused (thus no warning)
 #define ATTR_UNUSED                __attribute__ ((unused))
 
 // TODO mcu specific
diff --git a/src/common/compiler/tusb_compiler_iar.h b/src/common/compiler/tusb_compiler_iar.h
index 29bec875f..326a40031 100644
--- a/src/common/compiler/tusb_compiler_iar.h
+++ b/src/common/compiler/tusb_compiler_iar.h
@@ -36,12 +36,8 @@
 //#define ATTR_SECTION(section)      _Pragma((#section))

 #define ATTR_PREPACKED            __packed

 #define ATTR_PACKED

-

-#define ATTR_ALWAYS_INLINE

 #define ATTR_DEPRECATED(mess)

 #define ATTR_WEAK                 __weak

-

-#define ATTR_WARN_UNUSED_RESULT

 #define ATTR_UNUSED

 

 // built-in function to convert 32-bit Big-Endian to Little-Endian

@@ -52,6 +48,8 @@
 #define __n2be_16(u16)  ((uint16_t) __REV16(u16))

 #define __be2n_16(u16)  __n2be_16(u16)

 

+#error "IAR won't work due to '__packed' placement before struct"

+

 #ifdef __cplusplus

  }

 #endif

diff --git a/src/common/tusb_common.h b/src/common/tusb_common.h
index c877f0137..0b5a37922 100644
--- a/src/common/tusb_common.h
+++ b/src/common/tusb_common.h
@@ -113,7 +113,6 @@
 #include "tusb_option.h"

 #include "tusb_compiler.h"

 #include "tusb_verify.h"

-//#include "binary.h"

 #include "tusb_error.h"

 #include "tusb_timeout.h"

 #include "tusb_types.h"

diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index 3a4ddb4c3..7d57a7950 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -127,25 +127,23 @@ typedef enum
 

 typedef enum

 {

-  TUSB_CLASS_UNSPECIFIED          = 0    , ///< 0

-  TUSB_CLASS_AUDIO                = 1    , ///< 1

-  TUSB_CLASS_CDC                  = 2    , ///< 2

-  TUSB_CLASS_HID                  = 3    , ///< 3

-  TUSB_CLASS_RESERVED_4           = 4    , ///< 4

-  TUSB_CLASS_PHYSICAL             = 5    , ///< 5

-  TUSB_CLASS_IMAGE                = 6    , ///< 6

-  TUSB_CLASS_PRINTER              = 7    , ///< 7

-  TUSB_CLASS_MSC                  = 8    , ///< 8

-  TUSB_CLASS_HUB                  = 9    , ///< 9

-  TUSB_CLASS_CDC_DATA             = 10   , ///< 10

-  TUSB_CLASS_SMART_CARD           = 11   , ///< 11

-  TUSB_CLASS_RESERVED_12          = 12   , ///< 12

-  TUSB_CLASS_CONTENT_SECURITY     = 13   , ///< 13

-  TUSB_CLASS_VIDEO                = 14   , ///< 14

-  TUSB_CLASS_PERSONAL_HEALTHCARE  = 15   , ///< 15

-  TUSB_CLASS_AUDIO_VIDEO          = 16   , ///< 16

-

-  TUSB_CLASS_MAPPED_INDEX_START   = 17   , // TODO Map DIAGNOSTIC, WIRELESS_CONTROLLER, MISC, VENDOR_SPECIFIC to this to minimize the array

+  TUSB_CLASS_UNSPECIFIED          = 0    ,

+  TUSB_CLASS_AUDIO                = 1    ,

+  TUSB_CLASS_CDC                  = 2    ,

+  TUSB_CLASS_HID                  = 3    ,

+  TUSB_CLASS_RESERVED_4           = 4    ,

+  TUSB_CLASS_PHYSICAL             = 5    ,

+  TUSB_CLASS_IMAGE                = 6    ,

+  TUSB_CLASS_PRINTER              = 7    ,

+  TUSB_CLASS_MSC                  = 8    ,

+  TUSB_CLASS_HUB                  = 9    ,

+  TUSB_CLASS_CDC_DATA             = 10   ,

+  TUSB_CLASS_SMART_CARD           = 11   ,

+  TUSB_CLASS_RESERVED_12          = 12   ,

+  TUSB_CLASS_CONTENT_SECURITY     = 13   ,

+  TUSB_CLASS_VIDEO                = 14   ,

+  TUSB_CLASS_PERSONAL_HEALTHCARE  = 15   ,

+  TUSB_CLASS_AUDIO_VIDEO          = 16   ,

 

   TUSB_CLASS_DIAGNOSTIC           = 0xDC ,

   TUSB_CLASS_WIRELESS_CONTROLLER  = 0xE0 ,

diff --git a/src/device/usbd.c b/src/device/usbd.c
index cdbd6db5b..f02b21208 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -60,14 +60,6 @@ typedef struct {
 

 static usbd_device_t _usbd_dev = { 0 };

 

-// Auto descriptor is enabled, descriptor set point to auto generated one

-#if CFG_TUD_DESC_AUTO

-extern tud_desc_set_t const _usbd_auto_desc_set;

-tud_desc_set_t const* usbd_desc_set = &_usbd_auto_desc_set;

-#else

-tud_desc_set_t const* usbd_desc_set = &tud_desc_set;

-#endif

-

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

 // Class Driver

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

@@ -493,7 +485,7 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
 // This function parse configuration descriptor & open drivers accordingly

 static bool process_set_config(uint8_t rhport)

 {

-  tusb_desc_configuration_t const * desc_cfg = (tusb_desc_configuration_t const *) usbd_desc_set->config;

+  tusb_desc_configuration_t const * desc_cfg = (tusb_desc_configuration_t const *) tud_desc_set.config;

   TU_ASSERT(desc_cfg != NULL && desc_cfg->bDescriptorType == TUSB_DESC_CONFIGURATION);

 

   // Parse configuration descriptor

@@ -577,12 +569,12 @@ static void const* get_descriptor(tusb_control_request_t const * p_request, uint
   switch(desc_type)

   {

     case TUSB_DESC_DEVICE:

-      desc_data = (uint8_t const *) usbd_desc_set->device;

+      desc_data = (uint8_t const *) tud_desc_set.device;

       len       = sizeof(tusb_desc_device_t);

     break;

 

     case TUSB_DESC_CONFIGURATION:

-      desc_data = (uint8_t const *) usbd_desc_set->config;

+      desc_data = (uint8_t const *) tud_desc_set.config;

       len       = ((tusb_desc_configuration_t const*) desc_data)->wTotalLength;

     break;

 

diff --git a/src/device/usbd.h b/src/device/usbd.h
index 13c282e91..9525e2e6c 100644
--- a/src/device/usbd.h
+++ b/src/device/usbd.h
@@ -45,15 +45,11 @@ typedef struct {
   uint8_t const** string_arr;     ///< a array of pointers to string descriptors

   uint16_t        string_count;

 

-  struct {

-    uint8_t const* generic;

-    uint8_t const* boot_keyboard;

-    uint8_t const* boot_mouse;

-  } hid_report;

+  uint8_t const*  hid_report;

 

 }tud_desc_set_t;

 

-// Must be defined by application

+// Descriptor collection set, must be defined by application

 extern tud_desc_set_t tud_desc_set;

 

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

@@ -95,6 +91,13 @@ ATTR_WEAK void tud_suspend_cb(bool remote_wakeup_en);
 // Invoked when usb bus is resumed

 ATTR_WEAK void tud_resume_cb(void);

 

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

+// Interface Descriptor Template

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

+

+#define TUD_CONFIG_DESCRIPTOR(_itfcount, _stridx, _total_len, _attribute, _power_ma) \

+  9, TUSB_DESC_CONFIGURATION, U16_TO_U8S_LE(_total_len), _itfcount, 1, _stridx, TU_BIT(7) | _attribute, (_power_ma)/2

+

 #ifdef __cplusplus

  }

 #endif

diff --git a/src/device/usbd_auto_desc.c b/src/device/usbd_auto_desc.c
deleted file mode 100644
index e418cd23c..000000000
--- a/src/device/usbd_auto_desc.c
+++ /dev/null
@@ -1,648 +0,0 @@
-/* 
- * The MIT License (MIT)
- *
- * Copyright (c) 2018, hathach (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 TUSB_OPT_DEVICE_ENABLED && CFG_TUD_DESC_AUTO
-
-#include "tusb.h"
-
-//--------------------------------------------------------------------+
-// Auto Description Default Configure & Validation
-//--------------------------------------------------------------------+
-
-// If HID Generic interface is generated
-#define AUTO_DESC_HID_GENERIC    (CFG_TUD_HID && ((CFG_TUD_HID_KEYBOARD && !CFG_TUD_HID_KEYBOARD_BOOT) || \
-                                                (CFG_TUD_HID_MOUSE && !CFG_TUD_HID_MOUSE_BOOT)) )
-/*------------- VID/PID -------------*/
-#ifndef CFG_TUD_DESC_VID
-#define CFG_TUD_DESC_VID       0xCAFE
-#endif
-
-#ifndef CFG_TUD_DESC_PID
-
-/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug.
- * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC.
- *
- * Auto ProductID layout's Bitmap:
- *   [MSB]         HID Generic | Boot Mouse | Boot Keyboard | MSC | CDC          [LSB]
- */
-#define _PID_MAP(itf, n)      ( (CFG_TUD_##itf) << (n) )
-#define CFG_TUD_DESC_PID      (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \
-                               _PID_MAP(HID_KEYBOARD, 2) | _PID_MAP(HID_MOUSE, 3) | (AUTO_DESC_HID_GENERIC << 4) )
-#endif
-
-//--------------------------------------------------------------------+
-// Interface & Endpoint mapping
-//--------------------------------------------------------------------+
-
-/*------------- Interface Numbering -------------*/
-/* The order as follows: CDC, MSC, Boot Keyboard, Boot Mouse, HID Generic
- * If an interface is not enabled, the later will take its place */
-
-enum
-{
-#if CFG_TUD_CDC
-  ITF_NUM_CDC,
-  ITF_NUM_CDC_DATA,
-#endif
-
-#if CFG_TUD_MSC
-  ITF_NUM_MSC,
-#endif
-
-#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
-  ITF_NUM_HID_BOOT_KBD,
-#endif
-
-#if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT
-  ITF_NUM_HID_BOOT_MSE,
-#endif
-
-#if AUTO_DESC_HID_GENERIC
-  ITF_NUM_HID_GEN,
-#endif
-
-  ITF_NUM_TOTAL
-};
-
-enum
-{
-  ITF_STR_LANGUAGE = 0 ,
-  ITF_STR_MANUFACTURER ,
-  ITF_STR_PRODUCT      ,
-  ITF_STR_SERIAL       ,
-
-#if CFG_TUD_CDC
-  ITF_STR_CDC          ,
-#endif
-
-#if CFG_TUD_MSC
-  ITF_STR_MSC          ,
-#endif
-
-#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
-  ITF_STR_HID_BOOT_KBD,
-#endif
-
-#if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT
-  ITF_STR_HID_BOOT_MSE,
-#endif
-
-#if AUTO_DESC_HID_GENERIC
-  ITF_STR_HID_GEN,
-#endif
-};
-
-/*------------- Endpoint Numbering & Size -------------*/
-#define _EP_IN(x)               (0x80 | (x))
-#define _EP_OUT(x)              (x)
-
-// CDC
-#ifdef CFG_TUD_DESC_CDC_EPNUM_NOTIF
-  #define EP_CDC_NOTIF            _EP_IN (CFG_TUD_DESC_CDC_EPNUM_NOTIF)
-#else
-  #define EP_CDC_NOTIF            _EP_IN ( ITF_NUM_CDC+1 )
-#endif
-#define EP_CDC_NOTIF_SIZE       8
-
-#ifdef CFG_TUD_DESC_CDC_EPNUM
-  #define EP_CDC_OUT              _EP_OUT( CFG_TUD_DESC_CDC_EPNUM )
-  #define EP_CDC_IN               _EP_IN ( CFG_TUD_DESC_CDC_EPNUM )
-#else
-  #define EP_CDC_OUT              _EP_OUT( ITF_NUM_CDC+2 )
-  #define EP_CDC_IN               _EP_IN ( ITF_NUM_CDC+2 )
-#endif
-
-// Mass Storage
-#ifdef CFG_TUD_DESC_MSC_EPNUM
-  #define EP_MSC_OUT              _EP_OUT( CFG_TUD_DESC_MSC_EPNUM )
-  #define EP_MSC_IN               _EP_IN ( CFG_TUD_DESC_MSC_EPNUM )
-#else
-  #define EP_MSC_OUT              _EP_OUT( ITF_NUM_MSC+1 )
-  #define EP_MSC_IN               _EP_IN ( ITF_NUM_MSC+1 )
-#endif
-
-#if TUD_OPT_HIGH_SPEED
-#define EP_MSC_SIZE 512
-#else
-#define EP_MSC_SIZE 64
-#endif
-
-
-// HID Keyboard with boot protocol
-#ifdef CFG_TUD_DESC_HID_KEYBOARD_EPNUM
-  #define EP_HID_KBD_BOOT         _EP_IN ( CFG_TUD_DESC_HID_KEYBOARD_EPNUM )
-#else
-  #define EP_HID_KBD_BOOT         _EP_IN ( ITF_NUM_HID_BOOT_KBD+1 )
-#endif
-#define EP_HID_KBD_BOOT_SZ      8
-
-// HID Mouse with boot protocol
-#ifdef CFG_TUD_DESC_HID_MOUSE_EPNUM
-  #define EP_HID_MSE_BOOT         _EP_IN ( CFG_TUD_DESC_HID_MOUSE_EPNUM )
-#else
-  #define EP_HID_MSE_BOOT         _EP_IN ( ITF_NUM_HID_BOOT_MSE+1 )
-#endif
-#define EP_HID_MSE_BOOT_SZ      8
-
-// HID composite = keyboard + mouse + gamepad + etc ...
-#define EP_HID_GEN              _EP_IN ( ITF_NUM_HID_GEN+1 )
-#define EP_HID_GEN_SIZE         16
-
-
-//--------------------------------------------------------------------+
-// Auto generated HID Report Descriptors
-//--------------------------------------------------------------------+
-
-
-/*------------- Boot Protocol Report Descriptor -------------*/
-#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
-uint8_t const _desc_auto_hid_boot_kbd_report[] = { HID_REPORT_DESC_KEYBOARD() };
-#endif
-
-#if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT
-uint8_t const _desc_auto_hid_boot_mse_report[] = { HID_REPORT_DESC_MOUSE() };
-#endif
-
-
-/*------------- Generic (composite) Descriptor -------------*/
-#if AUTO_DESC_HID_GENERIC
-
-// Report ID: 0 if there is only 1 report
-// starting from 1 if there is multiple reports
-#define _REPORT_ID_KBD
-
-// TODO report ID
-uint8_t const _desc_auto_hid_generic_report[] =
-{
-#if CFG_TUD_HID_KEYBOARD && !CFG_TUD_HID_KEYBOARD_BOOT
-    HID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(1), ),
-#endif
-
-#if CFG_TUD_HID_MOUSE && !CFG_TUD_HID_MOUSE_BOOT
-    HID_REPORT_DESC_MOUSE( HID_REPORT_ID(2), )
-#endif
-
-};
-
-#endif // hid generic
-
-
-/*------------------------------------------------------------------*/
-/* Auto generated Device & Configuration descriptor
- *------------------------------------------------------------------*/
-
-// For highspeed device but currently in full speed mode
-//tusb_desc_device_qualifier_t _device_qual =
-//{
-//    .bLength = sizeof(tusb_desc_device_qualifier_t),
-//    .bDescriptorType = TUSB_DESC_DEVICE_QUALIFIER,
-//    .bcdUSB = 0x0200,
-//    .bDeviceClass =
-//};
-
-/*------------- Device Descriptor -------------*/
-tusb_desc_device_t const _desc_auto_device =
-{
-    .bLength            = sizeof(tusb_desc_device_t),
-    .bDescriptorType    = TUSB_DESC_DEVICE,
-    .bcdUSB             = 0x0200,
-
-  #if CFG_TUD_CDC
-    // Use Interface Association Descriptor (IAD) for CDC
-    // As required by USB Specs IAD's subclass must be common class (2) and protocol must be IAD (1)
-    .bDeviceClass       = TUSB_CLASS_MISC,
-    .bDeviceSubClass    = MISC_SUBCLASS_COMMON,
-    .bDeviceProtocol    = MISC_PROTOCOL_IAD,
-  #else
-    .bDeviceClass       = 0x00,
-    .bDeviceSubClass    = 0x00,
-    .bDeviceProtocol    = 0x00,
-  #endif
-
-    .bMaxPacketSize0    = CFG_TUD_ENDOINT0_SIZE,
-
-    .idVendor           = CFG_TUD_DESC_VID,
-    .idProduct          = CFG_TUD_DESC_PID,
-    .bcdDevice          = 0x0100,
-
-    .iManufacturer      = 0x01,
-    .iProduct           = 0x02,
-    .iSerialNumber      = 0x03,
-
-    .bNumConfigurations = 0x01
-};
-
-
-/*------------- Configuration Descriptor -------------*/
-typedef struct ATTR_PACKED
-{
-  tusb_desc_configuration_t           config;
-
-  //------------- CDC -------------//
-#if CFG_TUD_CDC
-  struct ATTR_PACKED
-  {
-    tusb_desc_interface_assoc_t       iad;
-
-    //CDC Control Interface
-    tusb_desc_interface_t             comm_itf;
-    cdc_desc_func_header_t            header;
-    cdc_desc_func_call_management_t   call;
-    cdc_desc_func_acm_t               acm;
-    cdc_desc_func_union_t             union_func;
-    tusb_desc_endpoint_t              ep_notif;
-
-    //CDC Data Interface
-    tusb_desc_interface_t             data_itf;
-    tusb_desc_endpoint_t              ep_out;
-    tusb_desc_endpoint_t              ep_in;
-  }cdc;
-#endif
-
-  //------------- Mass Storage -------------//
-#if CFG_TUD_MSC
-  struct ATTR_PACKED
-  {
-    tusb_desc_interface_t             itf;
-    tusb_desc_endpoint_t              ep_out;
-    tusb_desc_endpoint_t              ep_in;
-  } msc;
-#endif
-
-  //------------- HID -------------//
-#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
-  struct ATTR_PACKED
-  {
-    tusb_desc_interface_t             itf;
-    tusb_hid_descriptor_hid_t         hid_desc;
-    tusb_desc_endpoint_t              ep_in;
-  } hid_kbd_boot;
-#endif
-
-#if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT
-  struct ATTR_PACKED
-  {
-    tusb_desc_interface_t             itf;
-    tusb_hid_descriptor_hid_t         hid_desc;
-    tusb_desc_endpoint_t              ep_in;
-  } hid_mse_boot;
-#endif
-
-#if AUTO_DESC_HID_GENERIC
-
-  struct ATTR_PACKED
-  {
-    tusb_desc_interface_t             itf;
-    tusb_hid_descriptor_hid_t         hid_desc;
-    tusb_desc_endpoint_t              ep_in;
-
-    #if 0 //  CFG_TUD_HID_KEYBOARD
-    tusb_desc_endpoint_t              ep_out;
-    #endif
-  } hid_generic;
-
-#endif
-
-} desc_auto_cfg_t;
-
-desc_auto_cfg_t const _desc_auto_config_struct =
-{
-    .config =
-    {
-        .bLength             = sizeof(tusb_desc_configuration_t),
-        .bDescriptorType     = TUSB_DESC_CONFIGURATION,
-
-        .wTotalLength        = sizeof(desc_auto_cfg_t),
-        .bNumInterfaces      = ITF_NUM_TOTAL,
-
-        .bConfigurationValue = 1,
-        .iConfiguration      = 0x00,
-        .bmAttributes        = TU_BIT(7) | TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP,
-        .bMaxPower           = TUSB_DESC_CONFIG_POWER_MA(100)
-    },
-
-#if CFG_TUD_CDC
-    // IAD points to CDC Interfaces
-    .cdc =
-    {
-      .iad =
-      {
-          .bLength           = sizeof(tusb_desc_interface_assoc_t),
-          .bDescriptorType   = TUSB_DESC_INTERFACE_ASSOCIATION,
-
-          .bFirstInterface   = ITF_NUM_CDC,
-          .bInterfaceCount   = 2,
-
-          .bFunctionClass    = TUSB_CLASS_CDC,
-          .bFunctionSubClass = CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL,
-          .bFunctionProtocol = CDC_COMM_PROTOCOL_ATCOMMAND,
-          .iFunction         = 0
-      },
-
-      //------------- CDC Communication Interface -------------//
-      .comm_itf =
-      {
-          .bLength            = sizeof(tusb_desc_interface_t),
-          .bDescriptorType    = TUSB_DESC_INTERFACE,
-          .bInterfaceNumber   = ITF_NUM_CDC,
-          .bAlternateSetting  = 0,
-          .bNumEndpoints      = 1,
-          .bInterfaceClass    = TUSB_CLASS_CDC,
-          .bInterfaceSubClass = CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL,
-          .bInterfaceProtocol = CDC_COMM_PROTOCOL_ATCOMMAND,
-          .iInterface         = 4
-      },
-
-      .header =
-      {
-          .bLength            = sizeof(cdc_desc_func_header_t),
-          .bDescriptorType    = TUSB_DESC_CLASS_SPECIFIC,
-          .bDescriptorSubType = CDC_FUNC_DESC_HEADER,
-          .bcdCDC             = 0x0120
-      },
-
-      .call =
-      {
-          .bLength            = sizeof(cdc_desc_func_call_management_t),
-          .bDescriptorType    = TUSB_DESC_CLASS_SPECIFIC,
-          .bDescriptorSubType = CDC_FUNC_DESC_CALL_MANAGEMENT,
-          .bmCapabilities     = { 0 },
-          .bDataInterface     = ITF_NUM_CDC+1,
-      },
-
-      .acm =
-      {
-          .bLength            = sizeof(cdc_desc_func_acm_t),
-          .bDescriptorType    = TUSB_DESC_CLASS_SPECIFIC,
-          .bDescriptorSubType = CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT,
-          .bmCapabilities     = { // 0x02
-              .support_line_request = 1,
-          }
-      },
-
-      .union_func =
-      {
-          .bLength                  = sizeof(cdc_desc_func_union_t), // plus number of
-          .bDescriptorType          = TUSB_DESC_CLASS_SPECIFIC,
-          .bDescriptorSubType       = CDC_FUNC_DESC_UNION,
-          .bControlInterface        = ITF_NUM_CDC,
-          .bSubordinateInterface    = ITF_NUM_CDC+1,
-      },
-
-      .ep_notif =
-      {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_CDC_NOTIF,
-          .bmAttributes     = { .xfer = TUSB_XFER_INTERRUPT },
-          .wMaxPacketSize   = { .size = EP_CDC_NOTIF_SIZE },
-          .bInterval        = 0x10
-      },
-
-      //------------- CDC Data Interface -------------//
-      .data_itf =
-      {
-          .bLength            = sizeof(tusb_desc_interface_t),
-          .bDescriptorType    = TUSB_DESC_INTERFACE,
-          .bInterfaceNumber   = ITF_NUM_CDC+1,
-          .bAlternateSetting  = 0x00,
-          .bNumEndpoints      = 2,
-          .bInterfaceClass    = TUSB_CLASS_CDC_DATA,
-          .bInterfaceSubClass = 0,
-          .bInterfaceProtocol = 0,
-          .iInterface         = 0x00
-      },
-
-      .ep_out =
-      {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_CDC_OUT,
-          .bmAttributes     = { .xfer = TUSB_XFER_BULK },
-          .wMaxPacketSize   = { .size = CFG_TUD_CDC_EPSIZE },
-          .bInterval        = 0
-      },
-
-      .ep_in =
-      {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_CDC_IN,
-          .bmAttributes     = { .xfer = TUSB_XFER_BULK },
-          .wMaxPacketSize   = { .size = CFG_TUD_CDC_EPSIZE },
-          .bInterval        = 0
-      },
-    },
-#endif // cdc
-
-#if CFG_TUD_MSC
-    //------------- Mass Storage-------------//
-    .msc =
-    {
-      .itf =
-      {
-          .bLength            = sizeof(tusb_desc_interface_t),
-          .bDescriptorType    = TUSB_DESC_INTERFACE,
-          .bInterfaceNumber   = ITF_NUM_MSC,
-          .bAlternateSetting  = 0x00,
-          .bNumEndpoints      = 2,
-          .bInterfaceClass    = TUSB_CLASS_MSC,
-          .bInterfaceSubClass = MSC_SUBCLASS_SCSI,
-          .bInterfaceProtocol = MSC_PROTOCOL_BOT,
-          .iInterface         = 4 + CFG_TUD_CDC
-      },
-
-      .ep_out =
-      {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_MSC_OUT,
-          .bmAttributes     = { .xfer = TUSB_XFER_BULK },
-          .wMaxPacketSize   = { .size = EP_MSC_SIZE},
-          .bInterval        = 1
-      },
-
-      .ep_in =
-      {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_MSC_IN,
-          .bmAttributes     = { .xfer = TUSB_XFER_BULK },
-          .wMaxPacketSize   = { .size = EP_MSC_SIZE},
-          .bInterval        = 1
-      }
-    },
-#endif // msc
-
-#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
-    .hid_kbd_boot =
-    {
-        .itf =
-        {
-          .bLength            = sizeof(tusb_desc_interface_t),
-          .bDescriptorType    = TUSB_DESC_INTERFACE,
-          .bInterfaceNumber   = ITF_NUM_HID_BOOT_KBD,
-          .bAlternateSetting  = 0x00,
-          .bNumEndpoints      = 1,
-          .bInterfaceClass    = TUSB_CLASS_HID,
-          .bInterfaceSubClass = HID_SUBCLASS_BOOT,
-          .bInterfaceProtocol = HID_PROTOCOL_KEYBOARD,
-          .iInterface         = 0 //4 + CFG_TUD_CDC + CFG_TUD_MSC
-        },
-
-        .hid_desc =
-        {
-          .bLength         = sizeof(tusb_hid_descriptor_hid_t),
-          .bDescriptorType = HID_DESC_TYPE_HID,
-          .bcdHID          = 0x0111,
-          .bCountryCode    = HID_Local_NotSupported,
-          .bNumDescriptors = 1,
-          .bReportType     = HID_DESC_TYPE_REPORT,
-          .wReportLength   = sizeof(_desc_auto_hid_boot_kbd_report)
-        },
-
-        .ep_in =
-        {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_HID_KBD_BOOT,
-          .bmAttributes     = { .xfer = TUSB_XFER_INTERRUPT },
-          .wMaxPacketSize   = { .size = EP_HID_KBD_BOOT_SZ },
-          .bInterval        = 0x0A
-        }
-    },
-#endif // boot keyboard
-
-  //------------- HID Mouse -------------//
-#if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT
-    .hid_mse_boot =
-    {
-        .itf =
-        {
-          .bLength            = sizeof(tusb_desc_interface_t),
-          .bDescriptorType    = TUSB_DESC_INTERFACE,
-          .bInterfaceNumber   = ITF_NUM_HID_BOOT_MSE,
-          .bAlternateSetting  = 0x00,
-          .bNumEndpoints      = 1,
-          .bInterfaceClass    = TUSB_CLASS_HID,
-          .bInterfaceSubClass = HID_SUBCLASS_BOOT,
-          .bInterfaceProtocol = HID_PROTOCOL_MOUSE,
-          .iInterface         = 0 // 4 + CFG_TUD_CDC + CFG_TUD_MSC + CFG_TUD_HID_KEYBOARD
-        },
-
-        .hid_desc =
-        {
-          .bLength         = sizeof(tusb_hid_descriptor_hid_t),
-          .bDescriptorType = HID_DESC_TYPE_HID,
-          .bcdHID          = 0x0111,
-          .bCountryCode    = HID_Local_NotSupported,
-          .bNumDescriptors = 1,
-          .bReportType     = HID_DESC_TYPE_REPORT,
-          .wReportLength   = sizeof(_desc_auto_hid_boot_mse_report)
-        },
-
-        .ep_in =
-        {
-          .bLength          = sizeof(tusb_desc_endpoint_t),
-          .bDescriptorType  = TUSB_DESC_ENDPOINT,
-          .bEndpointAddress = EP_HID_MSE_BOOT,
-          .bmAttributes     = { .xfer = TUSB_XFER_INTERRUPT },
-          .wMaxPacketSize   = { .size = EP_HID_MSE_BOOT_SZ },
-          .bInterval        = 0x0A
-        },
-    },
-
-#endif // boot mouse
-
-#if AUTO_DESC_HID_GENERIC
-    //------------- HID Generic Multiple report -------------//
-    .hid_generic =
-    {
-        .itf =
-        {
-            .bLength            = sizeof(tusb_desc_interface_t),
-            .bDescriptorType    = TUSB_DESC_INTERFACE,
-            .bInterfaceNumber   = ITF_NUM_HID_GEN,
-            .bAlternateSetting  = 0x00,
-            .bNumEndpoints      = 1,
-            .bInterfaceClass    = TUSB_CLASS_HID,
-            .bInterfaceSubClass = 0,
-            .bInterfaceProtocol = 0,
-            .iInterface         = 0, // 4 + CFG_TUD_CDC + CFG_TUD_MSC,
-        },
-
-        .hid_desc =
-        {
-            .bLength           = sizeof(tusb_hid_descriptor_hid_t),
-            .bDescriptorType   = HID_DESC_TYPE_HID,
-            .bcdHID            = 0x0111,
-            .bCountryCode      = HID_Local_NotSupported,
-            .bNumDescriptors   = 1,
-            .bReportType       = HID_DESC_TYPE_REPORT,
-            .wReportLength     = sizeof(_desc_auto_hid_generic_report)
-        },
-
-        .ep_in =
-        {
-            .bLength          = sizeof(tusb_desc_endpoint_t),
-            .bDescriptorType  = TUSB_DESC_ENDPOINT,
-            .bEndpointAddress = EP_HID_GEN,
-            .bmAttributes     = { .xfer = TUSB_XFER_INTERRUPT },
-            .wMaxPacketSize   = { .size = EP_HID_GEN_SIZE },
-            .bInterval        = 0x0A
-        }
-    }
-#endif // hid generic
-};
-
-uint8_t const * const _desc_auto_config = (uint8_t const*) &_desc_auto_config_struct;
-
-tud_desc_set_t const _usbd_auto_desc_set =
-{
-    .device = &_desc_auto_device,
-    .config = &_desc_auto_config_struct,
-
-    .hid_report =
-    {
-#if AUTO_DESC_HID_GENERIC
-        .generic = _desc_auto_hid_generic_report,
-#else
-        .generic = NULL,
-#endif
-
-#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
-        .boot_keyboard = _desc_auto_hid_boot_kbd_report,
-#endif
-
-#if CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT
-        .boot_mouse = _desc_auto_hid_boot_mse_report
-#endif
-    }
-};
-
-#endif
diff --git a/src/device/usbd_pvt.h b/src/device/usbd_pvt.h
index dab67581f..8518ee209 100644
--- a/src/device/usbd_pvt.h
+++ b/src/device/usbd_pvt.h
@@ -33,9 +33,6 @@
  extern "C" {
 #endif
 
-// Either point to tud_desc_set or usbd_auto_desc_set depending on CFG_TUD_DESC_AUTO
-extern tud_desc_set_t const* usbd_desc_set;
-
 //--------------------------------------------------------------------+
 // INTERNAL API for stack management
 //--------------------------------------------------------------------+
diff --git a/src/tusb_option.h b/src/tusb_option.h
index 46d2186a0..cb6d573ea 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -157,10 +157,6 @@
     #define CFG_TUD_CTRL_BUFSIZE 256

   #endif

 

-  #ifndef CFG_TUD_DESC_AUTO

-    #define CFG_TUD_DESC_AUTO 0

-  #endif

-

   #ifndef CFG_TUD_CDC

     #define CFG_TUD_CDC            0

   #endif

@@ -169,22 +165,6 @@
     #define CFG_TUD_MSC          0

   #endif

 

-  #ifndef CFG_TUD_HID_KEYBOARD

-  #define CFG_TUD_HID_KEYBOARD        0

-  #endif

-

-  #ifndef CFG_TUD_HID_MOUSE

-  #define CFG_TUD_HID_MOUSE           0

-  #endif

-

-  #ifndef CFG_TUD_HID_KEYBOARD_BOOT

-    #define CFG_TUD_HID_KEYBOARD_BOOT 0

-  #endif

-

-  #ifndef CFG_TUD_HID_MOUSE_BOOT

-    #define CFG_TUD_HID_MOUSE_BOOT 0

-  #endif

-

 #endif // TUSB_OPT_DEVICE_ENABLED

 

 //--------------------------------------------------------------------