clean up

3 files changed, 159 insertions, 182 deletions

diff --git a/examples/device/dfu/src/main.c b/examples/device/dfu/src/main.c
index 43e0af9a5..77632bf1a 100644
--- a/examples/device/dfu/src/main.c
+++ b/examples/device/dfu/src/main.c
@@ -23,7 +23,7 @@
  *
  */
 
- /*
+/*
   * After device is enumerated in dfu mode run the following commands
   *
   * To transfer firmware from host to device (best to test with text file)
@@ -48,21 +48,18 @@
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF PROTYPES
 //--------------------------------------------------------------------+
-const char* upload_image[2]=
-{
-  "Hello world from TinyUSB DFU! - Partition 0",
-  "Hello world from TinyUSB DFU! - Partition 1"
-};
+const char *upload_image[2] = {"Hello world from TinyUSB DFU! - Partition 0",
+                               "Hello world from TinyUSB DFU! - Partition 1"};
 
 /* Blink pattern
  * - 250 ms  : device not mounted
  * - 1000 ms : device mounted
  * - 2500 ms : device is suspended
  */
-enum  {
+enum {
   BLINK_NOT_MOUNTED = 250,
-  BLINK_MOUNTED = 1000,
-  BLINK_SUSPENDED = 2500,
+  BLINK_MOUNTED     = 1000,
+  BLINK_SUSPENDED   = 2500,
 };
 
 static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
@@ -70,21 +67,16 @@ static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
 void led_blinking_task(void);
 
 /*------------- MAIN -------------*/
-int main(void)
-{
+int main(void) {
   board_init();
 
   // init device stack on configured roothub port
-  tusb_rhport_init_t dev_init = {
-    .role = TUSB_ROLE_DEVICE,
-    .speed = TUSB_SPEED_AUTO
-  };
+  tusb_rhport_init_t dev_init = {.role = TUSB_ROLE_DEVICE, .speed = TUSB_SPEED_AUTO};
   tusb_init(BOARD_TUD_RHPORT, &dev_init);
 
   board_init_after_tusb();
 
-  while (1)
-  {
+  while (1) {
     tud_task(); // tinyusb device task
     led_blinking_task();
   }
@@ -95,29 +87,25 @@ int main(void)
 //--------------------------------------------------------------------+
 
 // Invoked when device is mounted
-void tud_mount_cb(void)
-{
+void tud_mount_cb(void) {
   blink_interval_ms = BLINK_MOUNTED;
 }
 
 // Invoked when device is unmounted
-void tud_umount_cb(void)
-{
+void tud_umount_cb(void) {
   blink_interval_ms = BLINK_NOT_MOUNTED;
 }
 
 // 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) remote_wakeup_en;
+void tud_suspend_cb(bool remote_wakeup_en) {
+  (void)remote_wakeup_en;
   blink_interval_ms = BLINK_SUSPENDED;
 }
 
 // Invoked when usb bus is resumed
-void tud_resume_cb(void)
-{
+void tud_resume_cb(void) {
   blink_interval_ms = tud_mounted() ? BLINK_MOUNTED : BLINK_NOT_MOUNTED;
 }
 
@@ -129,19 +117,17 @@ void tud_resume_cb(void)
 // Invoked right before tud_dfu_download_cb() (state=DFU_DNBUSY) or tud_dfu_manifest_cb() (state=DFU_MANIFEST)
 // Application return timeout in milliseconds (bwPollTimeout) for the next download/manifest operation.
 // During this period, USB host won't try to communicate with us.
-uint32_t tud_dfu_get_timeout_cb(uint8_t alt, uint8_t state)
-{
-  if ( state == DFU_DNBUSY )
-  {
+uint32_t tud_dfu_get_timeout_cb(uint8_t alt, uint8_t state) {
+  if (state == DFU_DNBUSY) {
     // For this example
     // - Atl0 Flash is fast : 1   ms
     // - Alt1 EEPROM is slow: 100 ms
     return (alt == 0) ? 1 : 100;
-  }
-  else if (state == DFU_MANIFEST)
-  {
+  } else if (state == DFU_MANIFEST) {
     // since we don't buffer entire image and do any flashing in manifest stage
     return 0;
+  } else {
+    // nothing to do
   }
 
   return 0;
@@ -150,15 +136,13 @@ uint32_t tud_dfu_get_timeout_cb(uint8_t alt, uint8_t state)
 // Invoked when received DFU_DNLOAD (wLength>0) following by DFU_GETSTATUS (state=DFU_DNBUSY) requests
 // This callback could be returned before flashing op is complete (async).
 // Once finished flashing, application must call tud_dfu_finish_flashing()
-void tud_dfu_download_cb(uint8_t alt, uint16_t block_num, uint8_t const* data, uint16_t length)
-{
-  (void) alt;
-  (void) block_num;
+void tud_dfu_download_cb(uint8_t alt, uint16_t block_num, const uint8_t *data, uint16_t length) {
+  (void)alt;
+  (void)block_num;
 
   //printf("\r\nReceived Alt %u BlockNum %u of length %u\r\n", alt, wBlockNum, length);
 
-  for(uint16_t i=0; i<length; i++)
-  {
+  for (uint16_t i = 0; i < length; i++) {
     printf("%c", data[i]);
   }
 
@@ -169,9 +153,8 @@ void tud_dfu_download_cb(uint8_t alt, uint16_t block_num, uint8_t const* data, u
 // Invoked when download process is complete, received DFU_DNLOAD (wLength=0) following by DFU_GETSTATUS (state=Manifest)
 // Application can do checksum, or actual flashing if buffered entire image previously.
 // Once finished flashing, application must call tud_dfu_finish_flashing()
-void tud_dfu_manifest_cb(uint8_t alt)
-{
-  (void) alt;
+void tud_dfu_manifest_cb(uint8_t alt) {
+  (void)alt;
   printf("Download completed, enter manifestation\r\n");
 
   // flashing op for manifest is complete without error
@@ -182,29 +165,28 @@ void tud_dfu_manifest_cb(uint8_t alt)
 // Invoked when received DFU_UPLOAD request
 // Application must populate data with up to length bytes and
 // Return the number of written bytes
-uint16_t tud_dfu_upload_cb(uint8_t alt, uint16_t block_num, uint8_t* data, uint16_t length)
-{
-  (void) block_num;
-  (void) length;
+uint16_t tud_dfu_upload_cb(uint8_t alt, uint16_t block_num, uint8_t *data, uint16_t length) {
+  (void)block_num;
+  (void)length;
 
-  TU_VERIFY(block_num == 0, 0); // for this example we only support single block upload
+  if (block_num != 0u) {
+    return 0; // for this example we only support single block upload
+  }
 
-  uint16_t const xfer_len = tu_min16((uint16_t) strlen(upload_image[alt]), length);
+  const uint16_t xfer_len = tu_min16((uint16_t)strlen(upload_image[alt]), length);
   memcpy(data, upload_image[alt], xfer_len);
 
   return xfer_len;
 }
 
 // Invoked when the Host has terminated a download or upload transfer
-void tud_dfu_abort_cb(uint8_t alt)
-{
-  (void) alt;
+void tud_dfu_abort_cb(uint8_t alt) {
+  (void)alt;
   printf("Host aborted transfer\r\n");
 }
 
 // Invoked when a DFU_DETACH request is received
-void tud_dfu_detach_cb(void)
-{
+void tud_dfu_detach_cb(void) {
   printf("Host detach, we should probably reboot\r\n");
 }
 
@@ -212,13 +194,14 @@ void tud_dfu_detach_cb(void)
 // BLINKING TASK + Indicator pulse
 //--------------------------------------------------------------------+
 
-void led_blinking_task(void)
-{
-  static uint32_t start_ms = 0;
-  static bool led_state = false;
+void led_blinking_task(void) {
+  static uint32_t start_ms  = 0;
+  static bool     led_state = false;
 
   // Blink every interval ms
-  if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
+  if (board_millis() - start_ms < blink_interval_ms) {
+    return; // not enough time
+  }
   start_ms += blink_interval_ms;
 
   board_led_write(led_state);
diff --git a/examples/device/dfu/src/usb_descriptors.c b/examples/device/dfu/src/usb_descriptors.c
index faacdae7f..e4291be2d 100644
--- a/examples/device/dfu/src/usb_descriptors.c
+++ b/examples/device/dfu/src/usb_descriptors.c
@@ -32,47 +32,45 @@
  * Auto ProductID layout's Bitmap:
  *   [MSB]         HID | MSC | CDC          [LSB]
  */
-#define PID_MAP(itf, n)  ((CFG_TUD_##itf) ? (1 << (n)) : 0)
-#define USB_PID           (0x4000 | PID_MAP(CDC, 0) | PID_MAP(MSC, 1) | PID_MAP(HID, 2) | \
-                           PID_MAP(MIDI, 3) | PID_MAP(VENDOR, 4) )
+#define PID_MAP(itf, n) ((CFG_TUD_##itf) ? (1 << (n)) : 0)
+#define USB_PID         (0x4000 | PID_MAP(CDC, 0) | PID_MAP(MSC, 1) | PID_MAP(HID, 2) | PID_MAP(MIDI, 3) | PID_MAP(VENDOR, 4))
 
 //--------------------------------------------------------------------+
 // Device Descriptors
 //--------------------------------------------------------------------+
-static tusb_desc_device_t const desc_device = {
-  .bLength = sizeof(tusb_desc_device_t),
-  .bDescriptorType = TUSB_DESC_DEVICE,
-  .bcdUSB = 0x0201,
+static const tusb_desc_device_t desc_device =
+  {.bLength         = sizeof(tusb_desc_device_t),
+   .bDescriptorType = TUSB_DESC_DEVICE,
+   .bcdUSB          = 0x0201,
 
 #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,
+   // 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,
+   .bDeviceClass    = 0x00,
+   .bDeviceSubClass = 0x00,
+   .bDeviceProtocol = 0x00,
 #endif
 
-  .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE,
+   .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE,
 
-  .idVendor = 0xCafe,
-  .idProduct = USB_PID,
-  .bcdDevice = 0x0100,
+   .idVendor  = 0xCafe,
+   .idProduct = USB_PID,
+   .bcdDevice = 0x0100,
 
-  .iManufacturer = 0x01,
-  .iProduct = 0x02,
-  .iSerialNumber = 0x03,
+   .iManufacturer = 0x01,
+   .iProduct      = 0x02,
+   .iSerialNumber = 0x03,
 
-  .bNumConfigurations = 0x01
-};
+   .bNumConfigurations = 0x01};
 
 // Invoked when received GET DEVICE DESCRIPTOR
 // Application return pointer to descriptor
-uint8_t const *tud_descriptor_device_cb(void) {
-  return (uint8_t const *) &desc_device;
+const uint8_t *tud_descriptor_device_cb(void) {
+  return (const uint8_t *)&desc_device;
 }
 
 //--------------------------------------------------------------------+
@@ -88,8 +86,7 @@ enum {
 };
 
 #define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_DFU_DESC_LEN(ALT_COUNT))
-
-#define FUNC_ATTRS (DFU_ATTR_CAN_UPLOAD | DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
+#define FUNC_ATTRS       (DFU_ATTR_CAN_UPLOAD | DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
 
 uint8_t const desc_configuration[] = {
   // Config number, interface count, string index, total length, attribute, power in mA
@@ -102,8 +99,8 @@ uint8_t const desc_configuration[] = {
 // Invoked when received GET CONFIGURATION DESCRIPTOR
 // Application return pointer to descriptor
 // Descriptor contents must exist long enough for transfer to complete
-uint8_t const *tud_descriptor_configuration_cb(uint8_t index) {
-  (void) index;// for multiple configurations
+const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
+  (void)index; // for multiple configurations
   return desc_configuration;
 }
 
@@ -112,83 +109,74 @@ uint8_t const *tud_descriptor_configuration_cb(uint8_t index) {
 //--------------------------------------------------------------------+
 
 /* Microsoft OS 2.0 registry property descriptor
-Per MS requirements https://msdn.microsoft.com/en-us/library/windows/hardware/hh450799(v=vs.85).aspx
-device should create DeviceInterfaceGUIDs. It can be done by driver and
-in case of real PnP solution device should expose MS "Microsoft OS 2.0
-registry property descriptor". Such descriptor can insert any record
-into Windows registry per device/configuration/interface. In our case it
-will insert "DeviceInterfaceGUIDs" multistring property.
-GUID is freshly generated and should be OK to use.
-https://developers.google.com/web/fundamentals/native-hardware/build-for-webusb/
-(Section Microsoft OS compatibility descriptors)
+  Per MS requirements https://msdn.microsoft.com/en-us/library/windows/hardware/hh450799(v=vs.85).aspx
+  device should create DeviceInterfaceGUIDs. It can be done by driver and
+  in case of real PnP solution device should expose MS "Microsoft OS 2.0
+  registry property descriptor". Such descriptor can insert any record
+  into Windows registry per device/configuration/interface. In our case it
+  will insert "DeviceInterfaceGUIDs" multistring property.
+  GUID is freshly generated and should be OK to use.
+  https://developers.google.com/web/fundamentals/native-hardware/build-for-webusb/
+  (Section Microsoft OS compatibility descriptors)
 */
 
-#define BOS_TOTAL_LEN (TUD_BOS_DESC_LEN + TUD_BOS_MICROSOFT_OS_DESC_LEN)
-
-#define MS_OS_20_DESC_LEN 0xA2
-
+#define BOS_TOTAL_LEN            (TUD_BOS_DESC_LEN + TUD_BOS_MICROSOFT_OS_DESC_LEN)
+#define MS_OS_20_DESC_LEN        0xA2
 #define VENDOR_REQUEST_MICROSOFT 1
 
 // BOS Descriptor is required for webUSB
-uint8_t const desc_bos[] =
-    {
-        // total length, number of device caps
-        TUD_BOS_DESCRIPTOR(BOS_TOTAL_LEN, 1),
+const uint8_t desc_bos[] = {
+  // total length, number of device caps
+  TUD_BOS_DESCRIPTOR(BOS_TOTAL_LEN, 1),
 
-        // Microsoft OS 2.0 descriptor
-        TUD_BOS_MS_OS_20_DESCRIPTOR(MS_OS_20_DESC_LEN, 1)};
+  // Microsoft OS 2.0 descriptor
+  TUD_BOS_MS_OS_20_DESCRIPTOR(MS_OS_20_DESC_LEN, 1)};
 
-uint8_t const *tud_descriptor_bos_cb(void) {
+const uint8_t *tud_descriptor_bos_cb(void) {
   return desc_bos;
 }
 
-uint8_t const desc_ms_os_20[] =
-    {
-        // Set header: length, type, windows version, total length
-        U16_TO_U8S_LE(0x000A), U16_TO_U8S_LE(MS_OS_20_SET_HEADER_DESCRIPTOR), U32_TO_U8S_LE(0x06030000), U16_TO_U8S_LE(MS_OS_20_DESC_LEN),
+const uint8_t desc_ms_os_20[] = {
+  // Set header: length, type, windows version, total length
+  U16_TO_U8S_LE(0x000A), U16_TO_U8S_LE(MS_OS_20_SET_HEADER_DESCRIPTOR), U32_TO_U8S_LE(0x06030000),
+  U16_TO_U8S_LE(MS_OS_20_DESC_LEN),
 
-        // MS OS 2.0 Compatible ID descriptor: length, type, compatible ID, sub compatible ID
-        U16_TO_U8S_LE(0x0014), U16_TO_U8S_LE(MS_OS_20_FEATURE_COMPATBLE_ID), 'W', 'I', 'N', 'U', 'S', 'B', 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,// sub-compatible
+  // MS OS 2.0 Compatible ID descriptor: length, type, compatible ID, sub compatible ID
+  U16_TO_U8S_LE(0x0014), U16_TO_U8S_LE(MS_OS_20_FEATURE_COMPATBLE_ID), 'W', 'I', 'N', 'U', 'S', 'B', 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sub-compatible
 
-        // MS OS 2.0 Registry property descriptor: length, type
-        U16_TO_U8S_LE(MS_OS_20_DESC_LEN - 0x0A - 0x14), U16_TO_U8S_LE(MS_OS_20_FEATURE_REG_PROPERTY),
-        U16_TO_U8S_LE(0x0007), U16_TO_U8S_LE(0x002A),// wPropertyDataType, wPropertyNameLength and PropertyName "DeviceInterfaceGUIDs\0" in UTF-16
-        'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00, 'c', 0x00, 'e', 0x00, 'I', 0x00, 'n', 0x00, 't', 0x00, 'e', 0x00,
-        'r', 0x00, 'f', 0x00, 'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, 'D', 0x00, 's', 0x00, 0x00, 0x00,
-        U16_TO_U8S_LE(0x0050),// wPropertyDataLength
-        //bPropertyData: {3E7E0711-DF3B-4158-A32F-E5951B2AB9A1}.
-        '{', 0x00, '3', 0x00, 'E', 0x00, '7', 0x00, 'E', 0x00, '0', 0x00, '7', 0x00, '1', 0x00, '1', 0x00, '-', 0x00,
-        'D', 0x00, 'F', 0x00, '3', 0x00, 'B', 0x00, '-', 0x00, '4', 0x00, '1', 0x00, '5', 0x00, '8', 0x00, '-', 0x00,
-        'A', 0x00, '3', 0x00, '2', 0x00, 'F', 0x00, '-', 0x00, 'E', 0x00, '5', 0x00, '9', 0x00, '5', 0x00, '1', 0x00,
-        'B', 0x00, '2', 0x00, 'A', 0x00, 'B', 0x00, '9', 0x00, 'A', 0x00, '1', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 0x00};
+  // MS OS 2.0 Registry property descriptor: length, type
+  U16_TO_U8S_LE(MS_OS_20_DESC_LEN - 0x0A - 0x14), U16_TO_U8S_LE(MS_OS_20_FEATURE_REG_PROPERTY),
+  U16_TO_U8S_LE(0x0007), U16_TO_U8S_LE(0x002A),// wPropertyDataType, wPropertyNameLength and PropertyName "DeviceInterfaceGUIDs\0" in UTF-16
+  'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00, 'c', 0x00, 'e', 0x00, 'I', 0x00, 'n', 0x00, 't', 0x00, 'e', 0x00,
+  'r', 0x00, 'f', 0x00, 'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, 'D', 0x00, 's', 0x00, 0x00, 0x00,
+  U16_TO_U8S_LE(0x0050),// wPropertyDataLength
+  //bPropertyData: {3E7E0711-DF3B-4158-A32F-E5951B2AB9A1}.
+  '{', 0x00, '3', 0x00, 'E', 0x00, '7', 0x00, 'E', 0x00, '0', 0x00, '7', 0x00, '1', 0x00, '1', 0x00, '-', 0x00,
+  'D', 0x00, 'F', 0x00, '3', 0x00, 'B', 0x00, '-', 0x00, '4', 0x00, '1', 0x00, '5', 0x00, '8', 0x00, '-', 0x00,
+  'A', 0x00, '3', 0x00, '2', 0x00, 'F', 0x00, '-', 0x00, 'E', 0x00, '5', 0x00, '9', 0x00, '5', 0x00, '1', 0x00,
+  'B', 0x00, '2', 0x00, 'A', 0x00, 'B', 0x00, '9', 0x00, 'A', 0x00, '1', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 0x00
+};
 
 TU_VERIFY_STATIC(sizeof(desc_ms_os_20) == MS_OS_20_DESC_LEN, "Incorrect size");
 
 // Invoked when a control transfer occurred on an interface of this class
 // Driver response accordingly to the request and the transfer stage (setup/data/ack)
 // return false to stall control endpoint (e.g unsupported request)
-bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const *request) {
+bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_request_t *request) {
   // nothing to with DATA & ACK stage
-  if (stage != CONTROL_STAGE_SETUP) return true;
-
-  switch (request->bmRequestType_bit.type) {
-    case TUSB_REQ_TYPE_VENDOR:
-      switch (request->bRequest) {
-        case VENDOR_REQUEST_MICROSOFT:
-          if (request->wIndex == 7) {
-            return tud_control_xfer(rhport, request, (void *) (uintptr_t) desc_ms_os_20, MS_OS_20_DESC_LEN);
-          } else {
-            return false;
-          }
+  if (stage != CONTROL_STAGE_SETUP) {
+    return true;
+  }
 
-        default:
-          break;
+  if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_VENDOR) {
+    if (request->bRequest == VENDOR_REQUEST_MICROSOFT) {
+      if (request->wIndex == 7) {
+        return tud_control_xfer(rhport, request, (void *)(uintptr_t)desc_ms_os_20, MS_OS_20_DESC_LEN);
+      } else {
+        return false;
       }
-      break;
-
-    default:
-      break;
+    }
   }
 
   // stall unknown request
@@ -208,21 +196,21 @@ enum {
 };
 
 // array of pointer to string descriptors
-static char const *string_desc_arr[] = {
-  (const char[]){0x09, 0x04},// 0: is supported language is English (0x0409)
-  "TinyUSB",                 // 1: Manufacturer
-  "TinyUSB Device",          // 2: Product
-  NULL,                      // 3: Serials will use unique ID if possible
-  "FLASH",                   // 4: DFU Partition 1
-  "EEPROM",                  // 5: DFU Partition 2
+static const char *string_desc_arr[] = {
+  (const char[]){0x09, 0x04}, // 0: is supported language is English (0x0409)
+  "TinyUSB",                  // 1: Manufacturer
+  "TinyUSB Device",           // 2: Product
+  NULL,                       // 3: Serials will use unique ID if possible
+  "FLASH",                    // 4: DFU Partition 1
+  "EEPROM",                   // 5: DFU Partition 2
 };
 
 static uint16_t _desc_str[32 + 1];
 
 // Invoked when received GET STRING DESCRIPTOR request
 // Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
-uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
-  (void) langid;
+const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
+  (void)langid;
   size_t chr_count;
 
   switch (index) {
@@ -246,8 +234,8 @@ uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
       const char *str = string_desc_arr[index];
 
       // Cap at max char
-      chr_count = strlen(str);
-      size_t const max_count = sizeof(_desc_str) / sizeof(_desc_str[0]) - 1; // -1 for string type
+      chr_count              = strlen(str);
+      const size_t max_count = sizeof(_desc_str) / sizeof(_desc_str[0]) - 1; // -1 for string type
       if (chr_count > max_count) {
         chr_count = max_count;
       }
@@ -260,7 +248,7 @@ uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
   }
 
   // first byte is length (including header), second byte is string type
-  _desc_str[0] = (uint16_t) ((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));
+  _desc_str[0] = (uint16_t)((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));
 
   return _desc_str;
 }
diff --git a/examples/device/dfu_runtime/src/usb_descriptors.c b/examples/device/dfu_runtime/src/usb_descriptors.c
index 6a0a46b94..8fa078da2 100644
--- a/examples/device/dfu_runtime/src/usb_descriptors.c
+++ b/examples/device/dfu_runtime/src/usb_descriptors.c
@@ -32,9 +32,8 @@
  * Auto ProductID layout's Bitmap:
  *   [MSB]         HID | MSC | CDC          [LSB]
  */
-#define PID_MAP(itf, n)  ((CFG_TUD_##itf) ? (1 << (n)) : 0)
-#define USB_PID           (0x4000 | PID_MAP(CDC, 0) | PID_MAP(MSC, 1) | PID_MAP(HID, 2) | \
-                           PID_MAP(MIDI, 3) | PID_MAP(VENDOR, 4) )
+#define PID_MAP(itf, n) ((CFG_TUD_##itf) ? (1 << (n)) : 0)
+#define USB_PID         (0x4000 | PID_MAP(CDC, 0) | PID_MAP(MSC, 1) | PID_MAP(HID, 2) | PID_MAP(MIDI, 3) | PID_MAP(VENDOR, 4))
 
 //--------------------------------------------------------------------+
 // Device Descriptors
@@ -108,33 +107,30 @@ uint8_t const *tud_descriptor_configuration_cb(uint8_t index) {
 //--------------------------------------------------------------------+
 
 /* Microsoft OS 2.0 registry property descriptor
-Per MS requirements https://msdn.microsoft.com/en-us/library/windows/hardware/hh450799(v=vs.85).aspx
-device should create DeviceInterfaceGUIDs. It can be done by driver and
-in case of real PnP solution device should expose MS "Microsoft OS 2.0
-registry property descriptor". Such descriptor can insert any record
-into Windows registry per device/configuration/interface. In our case it
-will insert "DeviceInterfaceGUIDs" multistring property.
-GUID is freshly generated and should be OK to use.
-https://developers.google.com/web/fundamentals/native-hardware/build-for-webusb/
-(Section Microsoft OS compatibility descriptors)
+  Per MS requirements https://msdn.microsoft.com/en-us/library/windows/hardware/hh450799(v=vs.85).aspx
+  device should create DeviceInterfaceGUIDs. It can be done by driver and
+  in case of real PnP solution device should expose MS "Microsoft OS 2.0
+  registry property descriptor". Such descriptor can insert any record
+  into Windows registry per device/configuration/interface. In our case it
+  will insert "DeviceInterfaceGUIDs" multistring property.
+  GUID is freshly generated and should be OK to use.
+  https://developers.google.com/web/fundamentals/native-hardware/build-for-webusb/
+  (Section Microsoft OS compatibility descriptors)
 */
 
 #define BOS_TOTAL_LEN (TUD_BOS_DESC_LEN + TUD_BOS_MICROSOFT_OS_DESC_LEN)
-
 #define MS_OS_20_DESC_LEN 0xA2
-
 #define VENDOR_REQUEST_MICROSOFT 1
 
 // BOS Descriptor is required for webUSB
-uint8_t const desc_bos[] = {
-    // total length, number of device caps
-    TUD_BOS_DESCRIPTOR(BOS_TOTAL_LEN, 1),
+const uint8_t desc_bos[] = {
+  // total length, number of device caps
+  TUD_BOS_DESCRIPTOR(BOS_TOTAL_LEN, 1),
 
-    // Microsoft OS 2.0 descriptor
-    TUD_BOS_MS_OS_20_DESCRIPTOR(MS_OS_20_DESC_LEN, 1)
-};
+  // Microsoft OS 2.0 descriptor
+  TUD_BOS_MS_OS_20_DESCRIPTOR(MS_OS_20_DESC_LEN, 1)};
 
-uint8_t const *tud_descriptor_bos_cb(void) {
+const uint8_t *tud_descriptor_bos_cb(void) {
   return desc_bos;
 }
 
@@ -170,6 +166,16 @@ bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_requ
     return true;
   }
 
+  if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_VENDOR) {
+    if (request->bRequest == VENDOR_REQUEST_MICROSOFT) {
+      if (request->wIndex == 7) {
+        return tud_control_xfer(rhport, request, (void *)(uintptr_t)desc_ms_os_20, MS_OS_20_DESC_LEN);
+      } else {
+        return false;
+      }
+    }
+  }
+
   switch (request->bmRequestType_bit.type) {
     case TUSB_REQ_TYPE_VENDOR:
       switch (request->bRequest) {
@@ -218,8 +224,8 @@ static uint16_t _desc_str[32 + 1];
 
 // Invoked when received GET STRING DESCRIPTOR request
 // Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
-uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
-  (void) langid;
+const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
+  (void)langid;
   size_t chr_count;
 
   switch (index) {
@@ -243,8 +249,8 @@ uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
       const char *str = string_desc_arr[index];
 
       // Cap at max char
-      chr_count = strlen(str);
-      size_t const max_count = sizeof(_desc_str) / sizeof(_desc_str[0]) - 1; // -1 for string type
+      chr_count              = strlen(str);
+      const size_t max_count = sizeof(_desc_str) / sizeof(_desc_str[0]) - 1; // -1 for string type
       if (chr_count > max_count) {
         chr_count = max_count;
       }
@@ -257,7 +263,7 @@ uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
   }
 
   // first byte is length (including header), second byte is string type
-  _desc_str[0] = (uint16_t) ((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));
+  _desc_str[0] = (uint16_t)((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));
 
   return _desc_str;
 }