Merge pull request #56 from hathach/develop

refactor hid device, remove auto descriptor, update example

32 files changed, 899 insertions, 1643 deletions

diff --git a/README.md b/README.md
index 7c39b9631..15d387197 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ TinyUSB is an open-source cross-platform USB Host/Device stack for embedded syst
 Support multiple device configurations by dynamically changing usb descriptors. Low power functions such as suspend, resume and remote wakeup. Following device classes are supported:
 
 - Communication Class (CDC)
-- Human Interface Device (HID): Keyboard, Mouse, Generic
+- Human Interface Device (HID): Keyboard, Mouse, Gamepad etc ...
 - Mass Storage Class (MSC)
 - Musical Instrument Digital Interface (MIDI)
 
diff --git a/examples/device/cdc_msc_hid/Makefile b/examples/device/cdc_msc_hid/Makefile
index a2156e1b1..fc89b0fa7 100644
--- a/examples/device/cdc_msc_hid/Makefile
+++ b/examples/device/cdc_msc_hid/Makefile
@@ -85,9 +85,8 @@ LIBS = -lgcc -lc -lm -lnosys
 
 EXAMPLE_SOURCE += \
 	src/main.c \
-	src/msc_app.c \
-	src/msc_disk_ram.c \
-	src/tusb_descriptors.c
+	src/msc_disk.c \
+	src/usb_descriptors.c
 
 SRC_C += $(addprefix $(CURRENT_PATH)/, $(EXAMPLE_SOURCE))
 
@@ -95,7 +94,6 @@ LIB_SOURCE += \
 	hw/bsp/$(BOARD)/board_$(BOARD).c \
 	src/common/tusb_fifo.c \
 	src/device/usbd.c \
-	src/device/usbd_auto_desc.c \
 	src/device/usbd_control.c \
 	src/class/msc/msc_device.c \
 	src/class/cdc/cdc_device.c \
diff --git a/examples/device/cdc_msc_hid/src/main.c b/examples/device/cdc_msc_hid/src/main.c
index 78e07910d..c5e7a3068 100644
--- a/examples/device/cdc_msc_hid/src/main.c
+++ b/examples/device/cdc_msc_hid/src/main.c
@@ -40,12 +40,18 @@
  * - 1000 ms : device mounted
  * - 2500 ms : device is suspended
  */
-static uint32_t blink_interval_ms = 250;
+enum  {
+  BLINK_NOT_MOUNTED = 250,
+  BLINK_MOUNTED = 1000,
+  BLINK_SUSPENDED = 2500,
+};
+
+static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
 
 void led_blinking_task(void);
 
-extern void virtual_com_task(void);
-extern void usb_hid_task(void);
+extern void cdc_task(void);
+extern void hid_task(void);
 
 /*------------- MAIN -------------*/
 int main(void)
@@ -62,11 +68,11 @@ int main(void)
     led_blinking_task();
 
 #if CFG_TUD_CDC
-    virtual_com_task();
+    cdc_task();
 #endif
 
 #if CFG_TUD_HID
-    usb_hid_task();
+    hid_task();
 #endif
   }
 
@@ -77,7 +83,7 @@ int main(void)
 // USB CDC
 //--------------------------------------------------------------------+
 #if CFG_TUD_CDC
-void virtual_com_task(void)
+void cdc_task(void)
 {
   if ( tud_cdc_connected() )
   {
@@ -126,7 +132,15 @@ void tud_cdc_rx_cb(uint8_t itf)
 // USB HID
 //--------------------------------------------------------------------+
 #if CFG_TUD_HID
-void usb_hid_task(void)
+
+// Must match with ID declared by HID Report Descriptor, better to be in header file
+enum
+{
+  REPORT_ID_KEYBOARD = 1,
+  REPORT_ID_MOUSE
+};
+
+void hid_task(void)
 {
   // Poll every 10ms
   const uint32_t interval_ms = 10;
@@ -137,6 +151,7 @@ void usb_hid_task(void)
 
   uint32_t const btn = board_button_read();
 
+  // Remote wakeup
   if ( tud_suspended() && btn )
   {
     // Wake up host if we are in suspend mode
@@ -144,43 +159,43 @@ void usb_hid_task(void)
     tud_remote_wakeup();
   }
 
-#if 0
+  /*------------- Mouse -------------*/
+  if ( tud_hid_ready() )
+  {
+    if ( btn )
+    {
+      int8_t const delta = 5;
+      tud_hid_mouse_move(REPORT_ID_MOUSE, delta, delta); // right + down
+
+      // delay a bit before attempt to send keyboard report
+      board_delay(2);
+    }
+  }
+
   /*------------- Keyboard -------------*/
-  if ( tud_hid_keyboard_ready() )
+  if ( tud_hid_ready() )
   {
+    // use to avoid send multiple consecutive zero report for keyboard
+    static bool has_key = false;
+
     if ( btn )
     {
       uint8_t keycode[6] = { 0 };
+      keycode[0] = HID_KEY_A;
 
-      for(uint8_t i=0; i < 6; i++)
-      {
-        if ( btn & (1 << i) ) keycode[i] = HID_KEY_A + i;
-      }
+      tud_hid_keyboard_report(REPORT_ID_KEYBOARD, 0, keycode);
 
-      tud_hid_keyboard_keycode(0, keycode);
+      has_key = true;
     }else
     {
-      // Null means all zeroes keycodes
-      tud_hid_keyboard_keycode(0, NULL);
+      // send empty key report if previously has key pressed
+      if (has_key) tud_hid_keyboard_key_release(REPORT_ID_KEYBOARD);
+      has_key = false;
     }
   }
-#endif
-
-#if 0
-  /*------------- Mouse -------------*/
-  if ( tud_hid_mouse_ready() )
-  {
-    enum { DELTA  = 5 };
-
-    if ( btn & 0x01 ) tud_hid_mouse_move(-DELTA,      0); // left
-    if ( btn & 0x02 ) tud_hid_mouse_move( DELTA,      0); // right
-    if ( btn & 0x04 ) tud_hid_mouse_move(  0   , -DELTA); // up
-    if ( btn & 0x08 ) tud_hid_mouse_move(  0   ,  DELTA); // down
-  }
-#endif
 }
 
-uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
+uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
 {
   // TODO not Implemented
   (void) report_id;
@@ -191,7 +206,7 @@ uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t repo
   return 0;
 }
 
-void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
+void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
 {
   // TODO not Implemented
   (void) report_id;
@@ -209,13 +224,13 @@ void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_t
 // Invoked when device is mounted
 void tud_mount_cb(void)
 {
-  blink_interval_ms = 1000;
+  blink_interval_ms = BLINK_MOUNTED;
 }
 
 // Invoked when device is unmounted
 void tud_umount_cb(void)
 {
-  blink_interval_ms = 250;
+  blink_interval_ms = BLINK_NOT_MOUNTED;
 }
 
 // Invoked when usb bus is suspended
@@ -224,13 +239,13 @@ void tud_umount_cb(void)
 void tud_suspend_cb(bool remote_wakeup_en)
 {
   (void) remote_wakeup_en;
-  blink_interval_ms = 2500;
+  blink_interval_ms = BLINK_SUSPENDED;
 }
 
 // Invoked when usb bus is resumed
 void tud_resume_cb(void)
 {
-  blink_interval_ms = 1000;
+  blink_interval_ms = BLINK_MOUNTED;
 }
 
 //--------------------------------------------------------------------+
diff --git a/examples/device/cdc_msc_hid/src/msc_app.c b/examples/device/cdc_msc_hid/src/msc_app.c
deleted file mode 100644
index d50af7810..000000000
--- a/examples/device/cdc_msc_hid/src/msc_app.c
+++ /dev/null
@@ -1,104 +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 "bsp/board.h"
-#include "tusb.h"
-
-#if CFG_TUD_MSC
-
-//--------------------------------------------------------------------+
-// MACRO CONSTANT TYPEDEF
-//--------------------------------------------------------------------+
-
-//--------------------------------------------------------------------+
-// tinyusb callbacks
-//--------------------------------------------------------------------+
-
-// Callback invoked when received an SCSI command not in built-in list below
-// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
-// - READ10 and WRITE10 has their own callbacks
-int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize)
-{
-  // read10 & write10 has their own callback and MUST not be handled here
-
-  void const* response = NULL;
-  uint16_t resplen = 0;
-
-  // most scsi handled is input
-  bool in_xfer = true;
-
-  switch (scsi_cmd[0])
-  {
-    case SCSI_CMD_TEST_UNIT_READY:
-      // Command that host uses to check our readiness before sending other commands
-      resplen = 0;
-    break;
-
-    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
-      // Host is about to read/write etc ... better not to disconnect disk
-      resplen = 0;
-    break;
-
-    case SCSI_CMD_START_STOP_UNIT:
-      // Host try to eject/safe remove/poweroff us. We could safely disconnect with disk storage, or go into lower power
-      /* scsi_start_stop_unit_t const * start_stop = (scsi_start_stop_unit_t const *) scsi_cmd;
-        // Start bit = 0 : low power mode, if load_eject = 1 : unmount disk storage as well
-        // Start bit = 1 : Ready mode, if load_eject = 1 : mount disk storage
-        start_stop->start;
-        start_stop->load_eject;
-       */
-       resplen = 0;
-    break;
-
-
-    default:
-      // Set Sense = Invalid Command Operation
-      tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
-
-      // negative means error -> tinyusb could stall and/or response with failed status
-      resplen = -1;
-    break;
-  }
-
-  // return resplen must not larger than bufsize
-  if ( resplen > bufsize ) resplen = bufsize;
-
-  if ( response && (resplen > 0) )
-  {
-    if(in_xfer)
-    {
-      memcpy(buffer, response, resplen);
-    }else
-    {
-      // SCSI output
-    }
-  }
-
-  return resplen;
-}
-
-
-#endif
diff --git a/examples/device/cdc_msc_hid/src/msc_disk_ram.c b/examples/device/cdc_msc_hid/src/msc_disk.c
index 72b703cac..8bcd056e3 100644
--- a/examples/device/cdc_msc_hid/src/msc_disk_ram.c
+++ b/examples/device/cdc_msc_hid/src/msc_disk.c
@@ -126,4 +126,67 @@ void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_siz
   *block_size  = DISK_BLOCK_SIZE;
 }
 
+// Callback invoked when received an SCSI command not in built-in list below
+// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
+// - READ10 and WRITE10 has their own callbacks
+int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize)
+{
+  // read10 & write10 has their own callback and MUST not be handled here
+
+  void const* response = NULL;
+  uint16_t resplen = 0;
+
+  // most scsi handled is input
+  bool in_xfer = true;
+
+  switch (scsi_cmd[0])
+  {
+    case SCSI_CMD_TEST_UNIT_READY:
+      // Command that host uses to check our readiness before sending other commands
+      resplen = 0;
+    break;
+
+    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+      // Host is about to read/write etc ... better not to disconnect disk
+      resplen = 0;
+    break;
+
+    case SCSI_CMD_START_STOP_UNIT:
+      // Host try to eject/safe remove/poweroff us. We could safely disconnect with disk storage, or go into lower power
+      /* scsi_start_stop_unit_t const * start_stop = (scsi_start_stop_unit_t const *) scsi_cmd;
+        // Start bit = 0 : low power mode, if load_eject = 1 : unmount disk storage as well
+        // Start bit = 1 : Ready mode, if load_eject = 1 : mount disk storage
+        start_stop->start;
+        start_stop->load_eject;
+       */
+       resplen = 0;
+    break;
+
+
+    default:
+      // Set Sense = Invalid Command Operation
+      tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
+
+      // negative means error -> tinyusb could stall and/or response with failed status
+      resplen = -1;
+    break;
+  }
+
+  // return resplen must not larger than bufsize
+  if ( resplen > bufsize ) resplen = bufsize;
+
+  if ( response && (resplen > 0) )
+  {
+    if(in_xfer)
+    {
+      memcpy(buffer, response, resplen);
+    }else
+    {
+      // SCSI output
+    }
+  }
+
+  return resplen;
+}
+
 #endif
diff --git a/examples/device/cdc_msc_hid/src/tusb_config.h b/examples/device/cdc_msc_hid/src/tusb_config.h
index 98a214d52..2614bcb6f 100644
--- a/examples/device/cdc_msc_hid/src/tusb_config.h
+++ b/examples/device/cdc_msc_hid/src/tusb_config.h
@@ -46,8 +46,8 @@
 #define CFG_TUSB_RHPORT0_MODE       OPT_MODE_DEVICE
 #endif
 
-#define CFG_TUSB_DEBUG              2
 #define CFG_TUSB_OS                 OPT_OS_NONE
+#define CFG_TUSB_DEBUG              2
 
 /* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
  * Tinyusb use follows macros to declare transferring memory so that they can be put
@@ -67,49 +67,17 @@
 //--------------------------------------------------------------------
 // DEVICE CONFIGURATION
 //--------------------------------------------------------------------
-#define CFG_TUD_ENDOINT0_SIZE       64
-
-/*------------- Descriptors -------------*/
-
-/* Enable auto generated descriptor, tinyusb will try its best to create
- * descriptor ( device, configuration, hid ) that matches enabled CFG_* in this file
- *
- * Note: All CFG_TUD_DESC_* are relevant only if CFG_TUD_DESC_AUTO is enabled
- */
-#define CFG_TUD_DESC_AUTO           1
-
-/* If USB VID/PID is not defined, tinyusb will use default value
- * Note: different class combination e.g CDC and (CDC + MSC) should have different
- * PID since Host OS will "remembered" device driver after the first plug */
-// #define CFG_TUD_DESC_VID          0xCAFE
-// #define CFG_TUD_DESC_PID          0x0001
 
-// LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number
-// Therefore we need to force endpoint number to correct type on lpc17xx
-#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX
-#define CFG_TUD_DESC_CDC_EPNUM_NOTIF      1
-#define CFG_TUD_DESC_CDC_EPNUM            2
-#define CFG_TUD_DESC_MSC_EPNUM            5
-#define CFG_TUD_DESC_HID_KEYBOARD_EPNUM   4
-#define CFG_TUD_DESC_HID_MOUSE_EPNUM      7
-#endif
+#define CFG_TUD_ENDOINT0_SIZE       64
 
 //------------- CLASS -------------//
 #define CFG_TUD_CDC                 1
 #define CFG_TUD_MSC                 1
+#define CFG_TUD_HID                 1
+
 #define CFG_TUD_MIDI                0
 #define CFG_TUD_CUSTOM_CLASS        0
 
-#define CFG_TUD_HID                 0
-#define CFG_TUD_HID_KEYBOARD        0
-#define CFG_TUD_HID_MOUSE           0
-
-/* Use Boot Protocol for Keyboard, Mouse. Enable this will create separated HID interface
- * require more IN endpoints. If disabled, they they are all packed into a single
- * multiple report interface called "Generic". */
-#define CFG_TUD_HID_KEYBOARD_BOOT   1
-#define CFG_TUD_HID_MOUSE_BOOT      1
-
 //--------------------------------------------------------------------
 // CDC
 //--------------------------------------------------------------------
@@ -121,6 +89,7 @@
 //--------------------------------------------------------------------
 // MSC
 //--------------------------------------------------------------------
+
 // Number of supported Logical Unit Number (At least 1)
 #define CFG_TUD_MSC_MAXLUN          1
 
@@ -140,14 +109,12 @@
 // HID
 //--------------------------------------------------------------------
 
-/* Use the HID_ASCII_TO_KEYCODE lookup if CFG_TUD_HID_KEYBOARD is enabled.
- * This will occupies 256 bytes of ROM. It will also enable the use of 2 extra APIs
+/* Use the HID_ASCII_TO_KEYCODE lookup
+ * This will occupies 256 bytes of ROM. It will also enable the use of extra APIs
  * - tud_hid_keyboard_send_char()
- * - tud_hid_keyboard_send_string()
  */
 #define CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP 1
 
-
 #ifdef __cplusplus
  }
 #endif
diff --git a/examples/device/cdc_msc_hid/src/tusb_descriptors.c b/examples/device/cdc_msc_hid/src/tusb_descriptors.c
deleted file mode 100644
index 866005e3f..000000000
--- a/examples/device/cdc_msc_hid/src/tusb_descriptors.c
+++ /dev/null
@@ -1,86 +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.h"
-
-//--------------------------------------------------------------------+
-// STRING DESCRIPTORS
-//--------------------------------------------------------------------+
-
-// array of pointer to string descriptors
-uint16_t const * const string_desc_arr [] =
-{
-    // 0: is supported language = English
-    TUD_DESC_STRCONV(0x0409),
-
-    // 1: Manufacturer
-    TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', '.', 'o', 'r', 'g'),
-
-    // 2: Product
-    TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', ' ', 'd', 'e', 'v', 'i', 'c', 'e'),
-
-    // 3: Serials TODO use chip ID
-    TUD_DESC_STRCONV('1', '2', '3', '4', '5', '6'),
-
-#if CFG_TUD_CDC
-    // 4: CDC Interface
-    TUD_DESC_STRCONV('t','u','s','b',' ','c','d','c'),
-#endif
-
-#if CFG_TUD_MSC
-    // 5: MSC Interface
-    TUD_DESC_STRCONV('t','u','s','b',' ','m','s','c'),
-#endif
-
-#if CFG_TUD_HID_KEYBOARD
-    // 6: Keyboard
-    TUD_DESC_STRCONV('t','u','s','b',' ','k','e','y','b','o','a','r','d'),
-#endif
-
-#if CFG_TUD_HID_MOUSE
-    // 7: Mouse
-    TUD_DESC_STRCONV('t','u','s','b',' ','m', 'o','u','s','e'),
-#endif
-
-};
-
-// tud_desc_set is required by tinyusb stack
-// since CFG_TUD_DESC_AUTO is enabled, we only need to set string_arr 
-tud_desc_set_t tud_desc_set =
-{
-    .device     = NULL,
-    .config     = NULL,
-
-    .string_arr   = (uint8_t const **) string_desc_arr,
-    .string_count = sizeof(string_desc_arr)/sizeof(string_desc_arr[0]),
-
-    .hid_report =
-    {
-        .generic       = NULL,
-        .boot_keyboard = NULL,
-        .boot_mouse    = NULL
-    }
-};
diff --git a/examples/device/cdc_msc_hid/src/usb_descriptors.c b/examples/device/cdc_msc_hid/src/usb_descriptors.c
new file mode 100644
index 000000000..28a4b28d1
--- /dev/null
+++ b/examples/device/cdc_msc_hid/src/usb_descriptors.c
@@ -0,0 +1,171 @@
+/* 
+ * 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.h"
+
+/* 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 | MSC | CDC          [LSB]
+ */
+#define _PID_MAP(itf, n)  ( (CFG_TUD_##itf) << (n) )
+#define USB_PID           (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) )
+
+//------------- Device Descriptors -------------//
+tusb_desc_device_t const desc_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           = 0xCafe,
+    .idProduct          = USB_PID,
+    .bcdDevice          = 0x0100,
+
+    .iManufacturer      = 0x01,
+    .iProduct           = 0x02,
+    .iSerialNumber      = 0x03,
+
+    .bNumConfigurations = 0x01
+};
+
+//------------- HID Report Descriptor -------------//
+enum
+{
+  REPORT_ID_KEYBOARD = 1,
+  REPORT_ID_MOUSE
+};
+
+uint8_t const desc_hid_report[] =
+{
+  HID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(REPORT_ID_KEYBOARD), ),
+  HID_REPORT_DESC_MOUSE   ( HID_REPORT_ID(REPORT_ID_MOUSE), )
+};
+
+//------------- Configuration Descriptor -------------//
+enum
+{
+  #if CFG_TUD_CDC
+    ITF_NUM_CDC = 0,
+    ITF_NUM_CDC_DATA,
+  #endif
+
+  #if CFG_TUD_MSC
+    ITF_NUM_MSC,
+  #endif
+
+  #if CFG_TUD_HID
+    ITF_NUM_HID,
+  #endif
+
+    ITF_NUM_TOTAL
+};
+
+enum
+{
+  CONFIG_DESC_LEN = sizeof(tusb_desc_configuration_t) + CFG_TUD_CDC*TUD_CDC_DESC_LEN + CFG_TUD_MSC*TUD_MSC_DESC_LEN + CFG_TUD_HID*TUD_HID_DESC_LEN
+};
+
+#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX
+  // LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number
+  // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In etc ...
+  // Note: since CDC EP ( 1 & 2), HID (4) are spot-on, thus we only need to force
+  // endpoint number for MSC to 5
+  #define EPNUM_MSC   0x05
+#else
+  #define EPNUM_MSC   0x03
+#endif
+
+uint8_t const desc_configuration[] =
+{
+  // Config: self-powered with remote wakeup support, max power up to 100 mA
+  TUD_CONFIG_DESCRIPTOR(ITF_NUM_TOTAL, 0, CONFIG_DESC_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+
+#if CFG_TUD_CDC
+  TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 4, 0x81, 8, 0x02, 0x82, 64),
+#endif
+
+#if CFG_TUD_MSC
+  TUD_MSC_DESCRIPTOR(ITF_NUM_MSC, 5, EPNUM_MSC, 0x80 | EPNUM_MSC, 64), // highspeed 512
+#endif
+
+#if CFG_TUD_HID
+  TUD_HID_DESCRIPTOR(ITF_NUM_HID, 6, HID_PROTOCOL_KEYBOARD, sizeof(desc_hid_report), 0x84, 16, 10)
+#endif
+};
+
+//------------- String Descriptors -------------//
+// array of pointer to string descriptors
+uint16_t const * const string_desc_arr [] =
+{
+  // 0: is supported language = English
+  TUD_DESC_STRCONV(0x0409),
+
+  // 1: Manufacturer
+  TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', '.', 'o', 'r', 'g'),
+
+  // 2: Product
+  TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', ' ', 'd', 'e', 'v', 'i', 'c', 'e'),
+
+  // 3: Serials, should use chip ID
+  TUD_DESC_STRCONV('1', '2', '3', '4', '5', '6'),
+
+  // 4: CDC Interface
+  TUD_DESC_STRCONV('t','u','s','b',' ','c','d','c'),
+
+  // 5: MSC Interface
+  TUD_DESC_STRCONV('t','u','s','b',' ','m','s','c'),
+
+  // 6: HID
+  TUD_DESC_STRCONV('t','u','s','b',' ','h','i','d')
+};
+
+// tud_desc_set is required by tinyusb stack
+tud_desc_set_t tud_desc_set =
+{
+    .device     = &desc_device,
+    .config     = desc_configuration,
+
+    .string_arr   = (uint8_t const **) string_desc_arr,
+    .string_count = sizeof(string_desc_arr)/sizeof(string_desc_arr[0]),
+
+    .hid_report = desc_hid_report,
+};
diff --git a/examples/device/cdc_msc_hid_freertos/ses/nrf5x/nrf5x.emProject b/examples/device/cdc_msc_hid_freertos/ses/nrf5x/nrf5x.emProject
index ad236ae66..ee387958e 100644
--- a/examples/device/cdc_msc_hid_freertos/ses/nrf5x/nrf5x.emProject
+++ b/examples/device/cdc_msc_hid_freertos/ses/nrf5x/nrf5x.emProject
@@ -20,7 +20,7 @@
       arm_target_interface_type="SWD"
       build_treat_warnings_as_errors="No"
       c_preprocessor_definitions="NRF52840_XXAA;__nRF_FAMILY;ARM_MATH_CM4;FLASH_PLACEMENT=1;CFG_TUSB_MCU=OPT_MCU_NRF5X"
-      c_user_include_directories="./;../../src;$(rootDir)/hw/cmsis/Include;$(rootDir)/hw;$(rootDir)/src;$(nrfxDir)/..;$(nrfxDir);$(nrfxDir)/mdk;$(nrfxDir)/hal;$(nrfxDir)/drivers/include;$(freertosDir)/Source/include;$(freertosDir)/Source/portable/GCC/ARM_CM4F"
+      c_user_include_directories="./;../../src;$(rootDir)/hw/cmsis/Include;$(rootDir)/hw;$(rootDir)/src;$(nrfxDir)/..;$(nrfxDir);$(nrfxDir)/mdk;$(nrfxDir)/hal;$(nrfxDir)/drivers/include;$(nrfxDir)/drivers/src;$(freertosDir)/Source/include;$(freertosDir)/Source/portable/GCC/ARM_CM4F"
       debug_register_definition_file="nrf52840_Registers.xml"
       debug_target_connection="J-Link"
       gcc_enable_all_warnings="Yes"
diff --git a/examples/device/cdc_msc_hid_freertos/src/main.c b/examples/device/cdc_msc_hid_freertos/src/main.c
index c4b970a81..2877cd382 100644
--- a/examples/device/cdc_msc_hid_freertos/src/main.c
+++ b/examples/device/cdc_msc_hid_freertos/src/main.c
@@ -24,9 +24,6 @@
  * This file is part of the TinyUSB stack.
  */
 
-//--------------------------------------------------------------------+
-// INCLUDE
-//--------------------------------------------------------------------+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -41,12 +38,22 @@
 #include "tusb.h"
 
 //--------------------------------------------------------------------+
-// MACRO CONSTANT TYPEDEF
+// MACRO CONSTANT TYPEDEF PROTYPES
 //--------------------------------------------------------------------+
 
-//--------------------------------------------------------------------+
-// INTERNAL OBJECT & FUNCTION DECLARATION
-//--------------------------------------------------------------------+
+/* Blink pattern
+ * - 250 ms  : device not mounted
+ * - 1000 ms : device mounted
+ * - 2500 ms : device is suspended
+ */
+enum  {
+  BLINK_NOT_MOUNTED = 250,
+  BLINK_MOUNTED = 1000,
+  BLINK_SUSPENDED = 2500,
+};
+
+TimerHandle_t blink_tm;
+
 void led_blinky_cb(TimerHandle_t xTimer);
 void usb_device_task(void* param);
 
@@ -56,8 +63,8 @@ int main(void)
   board_init();
 
   // soft timer for blinky
-  TimerHandle_t tm_hdl = xTimerCreate(NULL, pdMS_TO_TICKS(1000), true, NULL, led_blinky_cb);
-  xTimerStart(tm_hdl, 0);
+  blink_tm = xTimerCreate(NULL, pdMS_TO_TICKS(BLINK_NOT_MOUNTED), true, NULL, led_blinky_cb);
+  xTimerStart(blink_tm, 0);
 
   tusb_init();
 
@@ -71,7 +78,8 @@ int main(void)
 #endif
 
 #if CFG_TUD_HID
-  extern void usb_hid_task(void* params);
+  extern void hid_task(void* params);
+  xTaskCreate( hid_task, "hid", 256, NULL, configMAX_PRIORITIES-2, NULL);
 #endif
 
   vTaskStartScheduler();
@@ -130,6 +138,7 @@ void cdc_task(void* params)
   }
 }
 
+// Invoked when cdc when line state changed e.g connected/disconnected
 void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
 {
   (void) itf;
@@ -141,85 +150,134 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
     tud_cdc_write_str("\r\nTinyUSB CDC MSC HID device with FreeRTOS example\r\n");
   }
 }
+
+// Invoked when CDC interface received data from host
+void tud_cdc_rx_cb(uint8_t itf)
+{
+  (void) itf;
+}
+
 #endif
 
 //--------------------------------------------------------------------+
 // USB HID
 //--------------------------------------------------------------------+
 #if CFG_TUD_HID
-void usb_hid_task(void* params)
+
+// Must match with ID declared by HID Report Descriptor, better to be in header file
+enum
 {
-  (void) params;
+  REPORT_ID_KEYBOARD = 1,
+  REPORT_ID_MOUSE
+};
 
-  // Poll every 10ms
-  const uint32_t interval_ms = 10;
-  static uint32_t start_ms = 0;
+void hid_task(void* params)
+{
+  (void) params;
 
-  if ( board_millis() < start_ms + interval_ms) return; // not enough time
-  start_ms += interval_ms;
+  while (1)
+  {
+    // Poll every 10ms
+    vTaskDelay(pdMS_TO_TICKS(10));
 
-  uint32_t const btn = board_button_read();
+    uint32_t const btn = board_button_read();
 
-  /*------------- Keyboard -------------*/
-  if ( tud_hid_keyboard_ready() )
-  {
-    if ( btn )
+    // Remote wakeup
+    if ( tud_suspended() && btn )
     {
-      uint8_t keycode[6] = { 0 };
+      // Wake up host if we are in suspend mode
+      // and REMOTE_WAKEUP feature is enabled by host
+      tud_remote_wakeup();
+    }
 
-      for(uint8_t i=0; i < 6; i++)
+    /*------------- Mouse -------------*/
+    if ( tud_hid_ready() )
+    {
+      if ( btn )
       {
-        if ( btn & (1 << i) ) keycode[i] = HID_KEY_A + i;
+        int8_t const delta = 5;
+        tud_hid_mouse_move(REPORT_ID_MOUSE, delta, delta); // right + down
+
+        // delay a bit before attempt to send keyboard report
+        vTaskDelay(pdMS_TO_TICKS(2));
       }
+    }
 
-      tud_hid_keyboard_keycode(0, keycode);
-    }else
+    /*------------- Keyboard -------------*/
+    if ( tud_hid_ready() )
     {
-      // Null means all zeroes keycodes
-      tud_hid_keyboard_keycode(0, NULL);
-    }
-  }
+      // use to avoid send multiple consecutive zero report for keyboard
+      static bool has_key = false;
 
+      if ( btn )
+      {
+        uint8_t keycode[6] = { 0 };
+        keycode[0] = HID_KEY_A;
 
-  /*------------- Mouse -------------*/
-  if ( tud_hid_mouse_ready() )
-  {
-    enum { DELTA  = 5 };
+        tud_hid_keyboard_report(REPORT_ID_KEYBOARD, 0, keycode);
 
-    if ( btn & 0x01 ) tud_hid_mouse_move(-DELTA,      0); // left
-    if ( btn & 0x02 ) tud_hid_mouse_move( DELTA,      0); // right
-    if ( btn & 0x04 ) tud_hid_mouse_move(  0   , -DELTA); // up
-    if ( btn & 0x08 ) tud_hid_mouse_move(  0   ,  DELTA); // down
+        has_key = true;
+      }else
+      {
+        // send empty key report if previously has key pressed
+        if (has_key) tud_hid_keyboard_key_release(REPORT_ID_KEYBOARD);
+        has_key = false;
+      }
+    }
   }
 }
 
-uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
+uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
 {
   // TODO not Implemented
+  (void) report_id;
+  (void) report_type;
+  (void) buffer;
+  (void) reqlen;
+
   return 0;
 }
 
-void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
+void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
 {
   // TODO not Implemented
+  (void) report_id;
+  (void) report_type;
+  (void) buffer;
+  (void) bufsize;
 }
+
 #endif
 
 //--------------------------------------------------------------------+
-// tinyusb callbacks
+// Device callbacks
 //--------------------------------------------------------------------+
+
+// Invoked when device is mounted
 void tud_mount_cb(void)
 {
-
+  xTimerChangePeriod(blink_tm, pdMS_TO_TICKS(BLINK_MOUNTED), 0);
 }
 
+// Invoked when device is unmounted
 void tud_umount_cb(void)
 {
+  xTimerChangePeriod(blink_tm, pdMS_TO_TICKS(BLINK_NOT_MOUNTED), 0);
 }
 
-void tud_cdc_rx_cb(uint8_t itf)
+// Invoked when usb bus is suspended
+// remote_wakeup_en : if host allow us  to perform remote wakeup
+// Within 7ms, device must draw an average of current less than 2.5 mA from bus
+void tud_suspend_cb(bool remote_wakeup_en)
 {
-  (void) itf;
+  (void) remote_wakeup_en;
+  xTimerChangePeriod(blink_tm, pdMS_TO_TICKS(BLINK_SUSPENDED), 0);
+}
+
+// Invoked when usb bus is resumed
+void tud_resume_cb(void)
+{
+  xTimerChangePeriod(blink_tm, pdMS_TO_TICKS(BLINK_MOUNTED), 0);
 }
 
 //--------------------------------------------------------------------+
diff --git a/examples/device/cdc_msc_hid_freertos/src/msc_app.c b/examples/device/cdc_msc_hid_freertos/src/msc_app.c
deleted file mode 100644
index d50af7810..000000000
--- a/examples/device/cdc_msc_hid_freertos/src/msc_app.c
+++ /dev/null
@@ -1,104 +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 "bsp/board.h"
-#include "tusb.h"
-
-#if CFG_TUD_MSC
-
-//--------------------------------------------------------------------+
-// MACRO CONSTANT TYPEDEF
-//--------------------------------------------------------------------+
-
-//--------------------------------------------------------------------+
-// tinyusb callbacks
-//--------------------------------------------------------------------+
-
-// Callback invoked when received an SCSI command not in built-in list below
-// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
-// - READ10 and WRITE10 has their own callbacks
-int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize)
-{
-  // read10 & write10 has their own callback and MUST not be handled here
-
-  void const* response = NULL;
-  uint16_t resplen = 0;
-
-  // most scsi handled is input
-  bool in_xfer = true;
-
-  switch (scsi_cmd[0])
-  {
-    case SCSI_CMD_TEST_UNIT_READY:
-      // Command that host uses to check our readiness before sending other commands
-      resplen = 0;
-    break;
-
-    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
-      // Host is about to read/write etc ... better not to disconnect disk
-      resplen = 0;
-    break;
-
-    case SCSI_CMD_START_STOP_UNIT:
-      // Host try to eject/safe remove/poweroff us. We could safely disconnect with disk storage, or go into lower power
-      /* scsi_start_stop_unit_t const * start_stop = (scsi_start_stop_unit_t const *) scsi_cmd;
-        // Start bit = 0 : low power mode, if load_eject = 1 : unmount disk storage as well
-        // Start bit = 1 : Ready mode, if load_eject = 1 : mount disk storage
-        start_stop->start;
-        start_stop->load_eject;
-       */
-       resplen = 0;
-    break;
-
-
-    default:
-      // Set Sense = Invalid Command Operation
-      tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
-
-      // negative means error -> tinyusb could stall and/or response with failed status
-      resplen = -1;
-    break;
-  }
-
-  // return resplen must not larger than bufsize
-  if ( resplen > bufsize ) resplen = bufsize;
-
-  if ( response && (resplen > 0) )
-  {
-    if(in_xfer)
-    {
-      memcpy(buffer, response, resplen);
-    }else
-    {
-      // SCSI output
-    }
-  }
-
-  return resplen;
-}
-
-
-#endif
diff --git a/examples/device/cdc_msc_hid_freertos/src/msc_disk_ram.c b/examples/device/cdc_msc_hid_freertos/src/msc_disk.c
index 1906edb8b..8bcd056e3 100644
--- a/examples/device/cdc_msc_hid_freertos/src/msc_disk_ram.c
+++ b/examples/device/cdc_msc_hid_freertos/src/msc_disk.c
@@ -49,7 +49,7 @@ enum
 #ifdef DISK_READONLY
 const
 #endif
-static uint8_t msc_disk[DISK_BLOCK_NUM][DISK_BLOCK_SIZE] =
+uint8_t msc_disk[DISK_BLOCK_NUM][DISK_BLOCK_SIZE] =
 {
   //------------- Boot Sector -------------//
   // byte_per_sector    = DISK_BLOCK_SIZE; fat12_sector_num_16  = DISK_BLOCK_NUM;
@@ -82,7 +82,7 @@ static uint8_t msc_disk[DISK_BLOCK_NUM][DISK_BLOCK_SIZE] =
       // second entry is readme file
       'R' , 'E' , 'A' , 'D' , 'M' , 'E' , ' ' , ' ' , 'T' , 'X' , 'T' , 0x20, 0x00, 0xC6, 0x52, 0x6D,
       0x65, 0x43, 0x65, 0x43, 0x00, 0x00, 0x88, 0x6D, 0x65, 0x43, 0x02, 0x00,
-      sizeof(README_CONTENTS)-1, 0x00, 0x00, 0x00 // readme's filesize (4 Bytes)
+      sizeof(README_CONTENTS)-1, 0x00, 0x00, 0x00 // readme's files ize (4 Bytes)
   },
 
   //------------- Readme Content -------------//
@@ -96,7 +96,7 @@ int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buff
 {
   (void) lun;
 
-  uint8_t* addr = msc_disk[lba] + offset;
+  uint8_t const* addr = msc_disk[lba] + offset;
   memcpy(buffer, addr, bufsize);
 
   return bufsize;
@@ -111,6 +111,8 @@ int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t*
 #ifndef DISK_READONLY
   uint8_t* addr = msc_disk[lba] + offset;
   memcpy(addr, buffer, bufsize);
+#else
+  (void) lba; (void) offset; (void) buffer;
 #endif
 
   return bufsize;
@@ -124,4 +126,67 @@ void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_siz
   *block_size  = DISK_BLOCK_SIZE;
 }
 
+// Callback invoked when received an SCSI command not in built-in list below
+// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
+// - READ10 and WRITE10 has their own callbacks
+int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize)
+{
+  // read10 & write10 has their own callback and MUST not be handled here
+
+  void const* response = NULL;
+  uint16_t resplen = 0;
+
+  // most scsi handled is input
+  bool in_xfer = true;
+
+  switch (scsi_cmd[0])
+  {
+    case SCSI_CMD_TEST_UNIT_READY:
+      // Command that host uses to check our readiness before sending other commands
+      resplen = 0;
+    break;
+
+    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+      // Host is about to read/write etc ... better not to disconnect disk
+      resplen = 0;
+    break;
+
+    case SCSI_CMD_START_STOP_UNIT:
+      // Host try to eject/safe remove/poweroff us. We could safely disconnect with disk storage, or go into lower power
+      /* scsi_start_stop_unit_t const * start_stop = (scsi_start_stop_unit_t const *) scsi_cmd;
+        // Start bit = 0 : low power mode, if load_eject = 1 : unmount disk storage as well
+        // Start bit = 1 : Ready mode, if load_eject = 1 : mount disk storage
+        start_stop->start;
+        start_stop->load_eject;
+       */
+       resplen = 0;
+    break;
+
+
+    default:
+      // Set Sense = Invalid Command Operation
+      tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
+
+      // negative means error -> tinyusb could stall and/or response with failed status
+      resplen = -1;
+    break;
+  }
+
+  // return resplen must not larger than bufsize
+  if ( resplen > bufsize ) resplen = bufsize;
+
+  if ( response && (resplen > 0) )
+  {
+    if(in_xfer)
+    {
+      memcpy(buffer, response, resplen);
+    }else
+    {
+      // SCSI output
+    }
+  }
+
+  return resplen;
+}
+
 #endif
diff --git a/examples/device/cdc_msc_hid_freertos/src/tusb_config.h b/examples/device/cdc_msc_hid_freertos/src/tusb_config.h
index 6004caf8c..9444ca890 100644
--- a/examples/device/cdc_msc_hid_freertos/src/tusb_config.h
+++ b/examples/device/cdc_msc_hid_freertos/src/tusb_config.h
@@ -40,7 +40,12 @@
   #error CFG_TUSB_MCU must be defined
 #endif
 
+#if CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_LPC18XX
+#define CFG_TUSB_RHPORT0_MODE       (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED)
+#else
 #define CFG_TUSB_RHPORT0_MODE       OPT_MODE_DEVICE
+#endif
+
 #define CFG_TUSB_OS                 OPT_OS_FREERTOS
 #define CFG_TUSB_DEBUG              2
 
@@ -65,46 +70,13 @@
 
 #define CFG_TUD_ENDOINT0_SIZE       64
 
-/*------------- Descriptors -------------*/
-
-/* Enable auto generated descriptor, tinyusb will try its best to create
- * descriptor ( device, configuration, hid ) that matches enabled CFG_* in this file
- *
- * Note: All CFG_TUD_DESC_* are relevant only if CFG_TUD_DESC_AUTO is enabled
- */
-#define CFG_TUD_DESC_AUTO           1
-
-/* If USB VID/PID is not defined, tinyusb will use default value
- * Note: different class combination e.g CDC and (CDC + MSC) should have different
- * PID since Host OS will "remembered" device driver after the first plug */
-// #define CFG_TUD_DESC_VID          0xCAFE
-// #define CFG_TUD_DESC_PID          0x0001
-
-// LPC175x_6x's endpoint type (bulk/interrupt/iso) are fixed by its number
-// Therefor we need to force endpoint number to correct type on lpc17xx
-#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X
-#define CFG_TUD_DESC_CDC_EPNUM_NOTIF      1
-#define CFG_TUD_DESC_CDC_EPNUM            2
-#define CFG_TUD_DESC_MSC_EPNUM            5
-#define CFG_TUD_DESC_HID_KEYBOARD_EPNUM   4
-#define CFG_TUD_DESC_HID_MOUSE_EPNUM      7
-#endif
-
-
 //------------- CLASS -------------//
 #define CFG_TUD_CDC                 1
 #define CFG_TUD_MSC                 1
+#define CFG_TUD_HID                 1
 
-#define CFG_TUD_HID                 0
-#define CFG_TUD_HID_KEYBOARD        0
-#define CFG_TUD_HID_MOUSE           0
-
-/* Use Boot Protocol for Keyboard, Mouse. Enable this will create separated HID interface
- * require more IN endpoints. If disabled, they they are all packed into a single
- * multiple report interface called "Generic". */
-#define CFG_TUD_HID_KEYBOARD_BOOT   1
-#define CFG_TUD_HID_MOUSE_BOOT      1
-
+#define CFG_TUD_MIDI                0
+#define CFG_TUD_CUSTOM_CLASS        0
 
 //--------------------------------------------------------------------
 // CDC
@@ -137,10 +109,9 @@
 // HID
 //--------------------------------------------------------------------
 
-/* Use the HID_ASCII_TO_KEYCODE lookup if CFG_TUD_HID_KEYBOARD is enabled.
- * This will occupies 256 bytes of ROM. It will also enable the use of 2 extra APIs
+/* Use the HID_ASCII_TO_KEYCODE lookup
+ * This will occupies 256 bytes of ROM. It will also enable the use of extra APIs
  * - tud_hid_keyboard_send_char()
- * - tud_hid_keyboard_send_string()
  */
 #define CFG_TUD_HID_ASCII_TO_KEYCODE_LOOKUP 1
 
diff --git a/examples/device/cdc_msc_hid_freertos/src/tusb_descriptors.c b/examples/device/cdc_msc_hid_freertos/src/tusb_descriptors.c
deleted file mode 100644
index 866005e3f..000000000
--- a/examples/device/cdc_msc_hid_freertos/src/tusb_descriptors.c
+++ /dev/null
@@ -1,86 +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.h"
-
-//--------------------------------------------------------------------+
-// STRING DESCRIPTORS
-//--------------------------------------------------------------------+
-
-// array of pointer to string descriptors
-uint16_t const * const string_desc_arr [] =
-{
-    // 0: is supported language = English
-    TUD_DESC_STRCONV(0x0409),
-
-    // 1: Manufacturer
-    TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', '.', 'o', 'r', 'g'),
-
-    // 2: Product
-    TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', ' ', 'd', 'e', 'v', 'i', 'c', 'e'),
-
-    // 3: Serials TODO use chip ID
-    TUD_DESC_STRCONV('1', '2', '3', '4', '5', '6'),
-
-#if CFG_TUD_CDC
-    // 4: CDC Interface
-    TUD_DESC_STRCONV('t','u','s','b',' ','c','d','c'),
-#endif
-
-#if CFG_TUD_MSC
-    // 5: MSC Interface
-    TUD_DESC_STRCONV('t','u','s','b',' ','m','s','c'),
-#endif
-
-#if CFG_TUD_HID_KEYBOARD
-    // 6: Keyboard
-    TUD_DESC_STRCONV('t','u','s','b',' ','k','e','y','b','o','a','r','d'),
-#endif
-
-#if CFG_TUD_HID_MOUSE
-    // 7: Mouse
-    TUD_DESC_STRCONV('t','u','s','b',' ','m', 'o','u','s','e'),
-#endif
-
-};
-
-// tud_desc_set is required by tinyusb stack
-// since CFG_TUD_DESC_AUTO is enabled, we only need to set string_arr 
-tud_desc_set_t tud_desc_set =
-{
-    .device     = NULL,
-    .config     = NULL,
-
-    .string_arr   = (uint8_t const **) string_desc_arr,
-    .string_count = sizeof(string_desc_arr)/sizeof(string_desc_arr[0]),
-
-    .hid_report =
-    {
-        .generic       = NULL,
-        .boot_keyboard = NULL,
-        .boot_mouse    = NULL
-    }
-};
diff --git a/examples/device/cdc_msc_hid_freertos/src/usb_descriptors.c b/examples/device/cdc_msc_hid_freertos/src/usb_descriptors.c
new file mode 100644
index 000000000..28a4b28d1
--- /dev/null
+++ b/examples/device/cdc_msc_hid_freertos/src/usb_descriptors.c
@@ -0,0 +1,171 @@
+/* 
+ * 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.h"
+
+/* 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 | MSC | CDC          [LSB]
+ */
+#define _PID_MAP(itf, n)  ( (CFG_TUD_##itf) << (n) )
+#define USB_PID           (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) )
+
+//------------- Device Descriptors -------------//
+tusb_desc_device_t const desc_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           = 0xCafe,
+    .idProduct          = USB_PID,
+    .bcdDevice          = 0x0100,
+
+    .iManufacturer      = 0x01,
+    .iProduct           = 0x02,
+    .iSerialNumber      = 0x03,
+
+    .bNumConfigurations = 0x01
+};
+
+//------------- HID Report Descriptor -------------//
+enum
+{
+  REPORT_ID_KEYBOARD = 1,
+  REPORT_ID_MOUSE
+};
+
+uint8_t const desc_hid_report[] =
+{
+  HID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(REPORT_ID_KEYBOARD), ),
+  HID_REPORT_DESC_MOUSE   ( HID_REPORT_ID(REPORT_ID_MOUSE), )
+};
+
+//------------- Configuration Descriptor -------------//
+enum
+{
+  #if CFG_TUD_CDC
+    ITF_NUM_CDC = 0,
+    ITF_NUM_CDC_DATA,
+  #endif
+
+  #if CFG_TUD_MSC
+    ITF_NUM_MSC,
+  #endif
+
+  #if CFG_TUD_HID
+    ITF_NUM_HID,
+  #endif
+
+    ITF_NUM_TOTAL
+};
+
+enum
+{
+  CONFIG_DESC_LEN = sizeof(tusb_desc_configuration_t) + CFG_TUD_CDC*TUD_CDC_DESC_LEN + CFG_TUD_MSC*TUD_MSC_DESC_LEN + CFG_TUD_HID*TUD_HID_DESC_LEN
+};
+
+#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX
+  // LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number
+  // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In etc ...
+  // Note: since CDC EP ( 1 & 2), HID (4) are spot-on, thus we only need to force
+  // endpoint number for MSC to 5
+  #define EPNUM_MSC   0x05
+#else
+  #define EPNUM_MSC   0x03
+#endif
+
+uint8_t const desc_configuration[] =
+{
+  // Config: self-powered with remote wakeup support, max power up to 100 mA
+  TUD_CONFIG_DESCRIPTOR(ITF_NUM_TOTAL, 0, CONFIG_DESC_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+
+#if CFG_TUD_CDC
+  TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 4, 0x81, 8, 0x02, 0x82, 64),
+#endif
+
+#if CFG_TUD_MSC
+  TUD_MSC_DESCRIPTOR(ITF_NUM_MSC, 5, EPNUM_MSC, 0x80 | EPNUM_MSC, 64), // highspeed 512
+#endif
+
+#if CFG_TUD_HID
+  TUD_HID_DESCRIPTOR(ITF_NUM_HID, 6, HID_PROTOCOL_KEYBOARD, sizeof(desc_hid_report), 0x84, 16, 10)
+#endif
+};
+
+//------------- String Descriptors -------------//
+// array of pointer to string descriptors
+uint16_t const * const string_desc_arr [] =
+{
+  // 0: is supported language = English
+  TUD_DESC_STRCONV(0x0409),
+
+  // 1: Manufacturer
+  TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', '.', 'o', 'r', 'g'),
+
+  // 2: Product
+  TUD_DESC_STRCONV('t', 'i', 'n', 'y', 'u', 's', 'b', ' ', 'd', 'e', 'v', 'i', 'c', 'e'),
+
+  // 3: Serials, should use chip ID
+  TUD_DESC_STRCONV('1', '2', '3', '4', '5', '6'),
+
+  // 4: CDC Interface
+  TUD_DESC_STRCONV('t','u','s','b',' ','c','d','c'),
+
+  // 5: MSC Interface
+  TUD_DESC_STRCONV('t','u','s','b',' ','m','s','c'),
+
+  // 6: HID
+  TUD_DESC_STRCONV('t','u','s','b',' ','h','i','d')
+};
+
+// tud_desc_set is required by tinyusb stack
+tud_desc_set_t tud_desc_set =
+{
+    .device     = &desc_device,
+    .config     = desc_configuration,
+
+    .string_arr   = (uint8_t const **) string_desc_arr,
+    .string_count = sizeof(string_desc_arr)/sizeof(string_desc_arr[0]),
+
+    .hid_report = desc_hid_report,
+};
diff --git a/examples/host/cdc_msc_hid/src/main.c b/examples/host/cdc_msc_hid/src/main.c
index 4f31c6d3f..1c9a5ded2 100644
--- a/examples/host/cdc_msc_hid/src/main.c
+++ b/examples/host/cdc_msc_hid/src/main.c
@@ -37,8 +37,8 @@
 void print_greeting(void);
 void led_blinking_task(void);
 
-extern void virtual_com_task(void);
-extern void usb_hid_task(void);
+extern void cdc_task(void);
+extern void hid_task(void);
 
 /*------------- MAIN -------------*/
 int main(void)
@@ -56,11 +56,11 @@ int main(void)
     led_blinking_task();
 
 #if CFG_TUH_CDC
-    virtual_com_task();
+    cdc_task();
 #endif
 
 #if CFG_TUD_HID
-    usb_hid_task();
+    hid_task();
 #endif
   }
 
@@ -100,7 +100,7 @@ void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_i
   tuh_cdc_receive(dev_addr, serial_in_buffer, sizeof(serial_in_buffer), true); // waiting for next data
 }
 
-void virtual_com_task(void)
+void cdc_task(void)
 {
 
 }
@@ -111,7 +111,7 @@ void virtual_com_task(void)
 // USB HID
 //--------------------------------------------------------------------+
 #if CFG_TUH_HID_KEYBOARD
-void usb_hid_task(void)
+void hid_task(void)
 {
 
 }
diff --git a/hw/bsp/board.h b/hw/bsp/board.h
index 896a14c0c..c78f3708b 100644
--- a/hw/bsp/board.h
+++ b/hw/bsp/board.h
@@ -95,6 +95,12 @@ static inline void board_led_off(void)
   board_led_write(false);
 }
 
+static inline void board_delay(uint32_t ms)
+{
+  uint32_t start_ms = board_millis();
+  while( board_millis() < start_ms + ms) {}
+}
+
 static inline int8_t board_uart_getchar(void)
 {
   uint8_t c;
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

 

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