diff --git a/examples/device/dfu/.skip.MCU_SAMD11 b/examples/device/dfu/.skip.MCU_SAMD11
deleted file mode 100644
index e69de29bb..000000000
diff --git a/examples/device/dfu/src/main.c b/examples/device/dfu/src/main.c
index 1c09066a8..5c8464526 100644
--- a/examples/device/dfu/src/main.c
+++ b/examples/device/dfu/src/main.c
@@ -26,13 +26,15 @@
  /*
   * After device is enumerated in dfu mode run the following commands
   *
-  * To transfer firmware from host to device:
+  * To transfer firmware from host to device (best to test with text file)
   *
-  * $ dfu-util -D [filename]
+  * $ dfu-util -d cafe -a 0 -D [filename]
+  * $ dfu-util -d cafe -a 1 -D [filename]
   *
   * To transfer firmware from device to host:
   *
-  * $ dfu-util -U [filename]
+  * $ dfu-util -d cafe -a 0 -U [filename]
+  * $ dfu-util -d cafe -a 1 -U [filename]
   *
   */
 
@@ -43,22 +45,21 @@
 #include "bsp/board.h"
 #include "tusb.h"
 
-
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF PROTYPES
 //--------------------------------------------------------------------+
-#ifndef DFU_VERBOSE
-#define DFU_VERBOSE 0
-#endif
+const char* upload_image[2]=
+{
+  "Hello world from TinyUSB DFU! - Partition 0",
+  "Hello world from TinyUSB DFU! - Partition 1"
+};
 
 /* Blink pattern
- * - 1000 ms : device should reboot
  * - 250 ms  : device not mounted
  * - 1000 ms : device mounted
  * - 2500 ms : device is suspended
  */
 enum  {
-  BLINK_DFU_MODE = 100,
   BLINK_NOT_MOUNTED = 250,
   BLINK_MOUNTED = 1000,
   BLINK_SUSPENDED = 2500,
@@ -115,58 +116,89 @@ void tud_resume_cb(void)
   blink_interval_ms = BLINK_MOUNTED;
 }
 
-// Invoked on DFU_DETACH request to reboot to the bootloader
-void tud_dfu_runtime_reboot_to_dfu_cb(void)
+//--------------------------------------------------------------------+
+// DFU callbacks
+// Note: alt is used as the partition number, in order to support multiple partitions like FLASH, EEPROM, etc.
+//--------------------------------------------------------------------+
+
+// 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)
 {
-  blink_interval_ms = BLINK_DFU_MODE;
+  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)
+  {
+    // since we don't buffer entire image and do any flashing in manifest stage
+    return 0;
+  }
+
+  return 0;
 }
 
-//--------------------------------------------------------------------+
-// Class callbacks
-//--------------------------------------------------------------------+
-bool tud_dfu_firmware_valid_check_cb(void)
+// 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)
 {
-  printf("    Firmware check\r\n");
-  return true;
-}
+  (void) alt;
+  (void) block_num;
 
-void tud_dfu_req_dnload_data_cb(uint16_t wBlockNum, uint8_t* data, uint16_t length)
-{
-  (void) data;
-  printf("    Received BlockNum %u of length %u\r\n", wBlockNum, length);
+  //printf("\r\nReceived Alt %u BlockNum %u of length %u\r\n", alt, wBlockNum, length);
 
-#if DFU_VERBOSE
   for(uint16_t i=0; i<length; i++)
   {
-    printf("    [%u][%u]: %x\r\n", wBlockNum, i, (uint8_t)data[i]);
+    printf("%c", data[i]);
   }
-#endif
 
-  tud_dfu_dnload_complete();
+  // flashing op for download complete without error
+  tud_dfu_finish_flashing(DFU_STATUS_OK);
 }
 
-bool tud_dfu_device_data_done_check_cb(void)
+// 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)
 {
-  printf("    Host said no more data... Returning true\r\n");
-  return true;
+  (void) alt;
+  printf("Download completed, enter manifestation\r\n");
+
+  // flashing op for manifest is complete without error
+  // Application can perform checksum, should it fail, use appropriate status such as errVERIFY.
+  tud_dfu_finish_flashing(DFU_STATUS_OK);
 }
 
-void tud_dfu_abort_cb(void)
-{
-  printf("    Host aborted transfer\r\n");
-}
-
-#define UPLOAD_SIZE (29)
-const uint8_t upload_test[UPLOAD_SIZE] = "Hello world from TinyUSB DFU!";
-
-uint16_t tud_dfu_req_upload_data_cb(uint16_t block_num, uint8_t* data, uint16_t length)
+// 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;
 
-  memcpy(data, upload_test, UPLOAD_SIZE);
+  uint16_t const xfer_len = (uint16_t) strlen(upload_image[alt]);
+  memcpy(data, upload_image[alt], xfer_len);
 
-  return UPLOAD_SIZE;
+  return xfer_len;
+}
+
+// Invoked when the Host has terminated a download or upload transfer
+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)
+{
+  printf("Host detach, we should probably reboot\r\n");
 }
 
 //--------------------------------------------------------------------+
diff --git a/examples/device/dfu/src/tusb_config.h b/examples/device/dfu/src/tusb_config.h
index 90e90b2e4..66e357021 100644
--- a/examples/device/dfu/src/tusb_config.h
+++ b/examples/device/dfu/src/tusb_config.h
@@ -76,12 +76,11 @@
 #define CFG_TUD_ENDPOINT0_SIZE    64
 #endif
 
-#define CFG_TUD_DFU_TRANSFER_BUFFER_SIZE    4096
-
 //------------- CLASS -------------//
+#define CFG_TUD_DFU    1
 
-#define CFG_TUD_DFU_RUNTIME 0
-#define CFG_TUD_DFU_MODE    1
+// DFU buffer size, it has to be set to the buffer size used in TUD_DFU_DESCRIPTOR
+#define CFG_TUD_DFU_XFER_BUFSIZE    512
 
 #ifdef __cplusplus
  }
diff --git a/examples/device/dfu/src/usb_descriptors.c b/examples/device/dfu/src/usb_descriptors.c
index 8ad64354b..1cfe29c53 100644
--- a/examples/device/dfu/src/usb_descriptors.c
+++ b/examples/device/dfu/src/usb_descriptors.c
@@ -81,23 +81,26 @@ uint8_t const * tud_descriptor_device_cb(void)
 // Configuration Descriptor
 //--------------------------------------------------------------------+
 
+// Number of Alternate Interface (each for 1 flash partition)
+#define ALT_COUNT   2
+
 enum
 {
   ITF_NUM_DFU_MODE,
   ITF_NUM_TOTAL
 };
 
-#define CONFIG_TOTAL_LEN    (TUD_CONFIG_DESC_LEN + TUD_DFU_MODE_DESC_LEN)
+#define CONFIG_TOTAL_LEN    (TUD_CONFIG_DESC_LEN + TUD_DFU_DESC_LEN(ALT_COUNT))
 
-#define FUNC_ATTRS (DFU_FUNC_ATTR_CAN_UPLOAD_BITMASK | DFU_FUNC_ATTR_CAN_DOWNLOAD_BITMASK)
+#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
   TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
 
-  // Interface number, string index, attributes, detach timeout, transfer size */
-  TUD_DFU_MODE_DESCRIPTOR(ITF_NUM_DFU_MODE, 0, FUNC_ATTRS, 1000, CFG_TUD_DFU_TRANSFER_BUFFER_SIZE),
+  // Interface number, Alternate count, starting string index, attributes, detach timeout, transfer size
+  TUD_DFU_DESCRIPTOR(ITF_NUM_DFU_MODE, ALT_COUNT, 4, FUNC_ATTRS, 1000, CFG_TUD_DFU_XFER_BUFSIZE),
 };
 
 // Invoked when received GET CONFIGURATION DESCRIPTOR
@@ -120,7 +123,8 @@ char const* string_desc_arr [] =
   "TinyUSB",                     // 1: Manufacturer
   "TinyUSB Device",              // 2: Product
   "123456",                      // 3: Serials, should use chip ID
-  "TinyUSB DFU",                 // 4: DFU
+  "FLASH",                       // 4: DFU Partition 1
+  "EEPROM",                      // 5: DFU Partition 2
 };
 
 static uint16_t _desc_str[32];
diff --git a/examples/device/midi_test/src/main.c b/examples/device/midi_test/src/main.c
index 9e0e82a10..193748477 100644
--- a/examples/device/midi_test/src/main.c
+++ b/examples/device/midi_test/src/main.c
@@ -134,7 +134,7 @@ void midi_task(void)
   uint8_t packet[4];
   while ( tud_midi_available() ) tud_midi_packet_read(packet);
 
-  // send note every 1000 ms
+  // send note periodically
   if (board_millis() - start_ms < 286) return; // not enough time
   start_ms += 286;
 
diff --git a/hw/bsp/samd11/family.mk b/hw/bsp/samd11/family.mk
index 70120ec94..032d11b98 100644
--- a/hw/bsp/samd11/family.mk
+++ b/hw/bsp/samd11/family.mk
@@ -3,7 +3,6 @@ DEPS_SUBMODULES += hw/mcu/microchip
 include $(TOP)/$(BOARD_PATH)/board.mk
 
 CFLAGS += \
-	-flto \
   -mthumb \
   -mabi=aapcs \
   -mcpu=cortex-m0plus \
diff --git a/src/class/dfu/dfu.h b/src/class/dfu/dfu.h
index 18de3bf99..114c827b8 100644
--- a/src/class/dfu/dfu.h
+++ b/src/class/dfu/dfu.h
@@ -36,6 +36,7 @@
 //--------------------------------------------------------------------+
 // Common Definitions
 //--------------------------------------------------------------------+
+
 // DFU Protocol
 typedef enum
 {
@@ -77,28 +78,28 @@ typedef enum {
 
 // DFU Status
 typedef enum {
-  DFU_STATUS_OK              = 0x00,
-  DFU_STATUS_ERRTARGET       = 0x01,
-  DFU_STATUS_ERRFILE         = 0x02,
-  DFU_STATUS_ERRWRITE        = 0x03,
-  DFU_STATUS_ERRERASE        = 0x04,
-  DFU_STATUS_ERRCHECK_ERASED = 0x05,
-  DFU_STATUS_ERRPROG         = 0x06,
-  DFU_STATUS_ERRVERIFY       = 0x07,
-  DFU_STATUS_ERRADDRESS      = 0x08,
-  DFU_STATUS_ERRNOTDONE      = 0x09,
-  DFU_STATUS_ERRFIRMWARE     = 0x0A,
-  DFU_STATUS_ERRVENDOR       = 0x0B,
-  DFU_STATUS_ERRUSBR         = 0x0C,
-  DFU_STATUS_ERRPOR          = 0x0D,
-  DFU_STATUS_ERRUNKNOWN      = 0x0E,
-  DFU_STATUS_ERRSTALLEDPKT   = 0x0F,
-} dfu_device_status_t;
+  DFU_STATUS_OK               = 0x00,
+  DFU_STATUS_ERR_TARGET       = 0x01,
+  DFU_STATUS_ERR_FILE         = 0x02,
+  DFU_STATUS_ERR_WRITE        = 0x03,
+  DFU_STATUS_ERR_ERASE        = 0x04,
+  DFU_STATUS_ERR_CHECK_ERASED = 0x05,
+  DFU_STATUS_ERR_PROG         = 0x06,
+  DFU_STATUS_ERR_VERIFY       = 0x07,
+  DFU_STATUS_ERR_ADDRESS      = 0x08,
+  DFU_STATUS_ERR_NOTDONE      = 0x09,
+  DFU_STATUS_ERR_FIRMWARE     = 0x0A,
+  DFU_STATUS_ERR_VENDOR       = 0x0B,
+  DFU_STATUS_ERR_USBR         = 0x0C,
+  DFU_STATUS_ERR_POR          = 0x0D,
+  DFU_STATUS_ERR_UNKNOWN      = 0x0E,
+  DFU_STATUS_ERR_STALLEDPKT   = 0x0F,
+} dfu_status_t;
 
-#define DFU_FUNC_ATTR_CAN_DOWNLOAD_BITMASK              (1 << 0)
-#define DFU_FUNC_ATTR_CAN_UPLOAD_BITMASK                (1 << 1)
-#define DFU_FUNC_ATTR_MANIFESTATION_TOLERANT_BITMASK    (1 << 2)
-#define DFU_FUNC_ATTR_WILL_DETACH_BITMASK               (1 << 3)
+#define DFU_ATTR_CAN_DOWNLOAD              (1u << 0)
+#define DFU_ATTR_CAN_UPLOAD                (1u << 1)
+#define DFU_ATTR_MANIFESTATION_TOLERANT    (1u << 2)
+#define DFU_ATTR_WILL_DETACH               (1u << 3)
 
 // DFU Status Request Payload
 typedef struct TU_ATTR_PACKED
@@ -107,9 +108,9 @@ typedef struct TU_ATTR_PACKED
   uint8_t bwPollTimeout[3];
   uint8_t bState;
   uint8_t iString;
-} dfu_status_req_payload_t;
+} dfu_status_response_t;
 
-TU_VERIFY_STATIC( sizeof(dfu_status_req_payload_t) == 6, "size is not correct");
+TU_VERIFY_STATIC( sizeof(dfu_status_response_t) == 6, "size is not correct");
 
 #ifdef __cplusplus
  }
diff --git a/src/class/dfu/dfu_device.c b/src/class/dfu/dfu_device.c
index c696d70a2..ad87092e0 100644
--- a/src/class/dfu/dfu_device.c
+++ b/src/class/dfu/dfu_device.c
@@ -26,7 +26,7 @@
 
 #include "tusb_option.h"
 
-#if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_DFU_MODE)
+#if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_DFU)
 
 #include "device/usbd.h"
 #include "device/usbd_pvt.h"
@@ -40,24 +40,34 @@
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
-typedef struct TU_ATTR_PACKED
+typedef struct
 {
-    dfu_device_status_t status;
-    dfu_state_t state;
-    uint8_t attrs;
-    bool blk_transfer_in_proc;
-    CFG_TUSB_MEM_ALIGN uint8_t transfer_buf[CFG_TUD_DFU_TRANSFER_BUFFER_SIZE];
+  uint8_t attrs;
+  uint8_t alt;
+
+  dfu_state_t state;
+  dfu_status_t status;
+
+  bool flashing_in_progress;
+  uint16_t block;
+  uint16_t length;
+
+  CFG_TUSB_MEM_ALIGN uint8_t transfer_buf[CFG_TUD_DFU_XFER_BUFSIZE];
 } dfu_state_ctx_t;
 
 // Only a single dfu state is allowed
-CFG_TUSB_MEM_SECTION static dfu_state_ctx_t _dfu_state_ctx;
+CFG_TUSB_MEM_SECTION static dfu_state_ctx_t _dfu_ctx;
 
+static void reset_state(void)
+{
+  _dfu_ctx.state = DFU_IDLE;
+  _dfu_ctx.status = DFU_STATUS_OK;
+  _dfu_ctx.flashing_in_progress = false;
+}
 
-static void dfu_req_dnload_setup(uint8_t rhport, tusb_control_request_t const * request);
-static void dfu_req_getstatus_reply(uint8_t rhport, tusb_control_request_t const * request);
-static uint16_t dfu_req_upload(uint8_t rhport, tusb_control_request_t const * request, uint16_t block_num, uint16_t wLength);
-static void dfu_req_dnload_reply(uint8_t rhport, tusb_control_request_t const * request);
-static bool dfu_state_machine(uint8_t rhport, tusb_control_request_t const * request);
+static bool reply_getstatus(uint8_t rhport, tusb_control_request_t const * request, dfu_state_t state, dfu_status_t status, uint32_t timeout);
+static bool process_download_get_status(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
+static bool process_manifest_get_status(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
 
 //--------------------------------------------------------------------+
 // Debug
@@ -66,13 +76,13 @@ static bool dfu_state_machine(uint8_t rhport, tusb_control_request_t const * req
 
 static tu_lookup_entry_t const _dfu_request_lookup[] =
 {
-  { .key = DFU_REQUEST_DETACH         , .data = "DETACH" },
-  { .key = DFU_REQUEST_DNLOAD         , .data = "DNLOAD" },
-  { .key = DFU_REQUEST_UPLOAD         , .data = "UPLOAD" },
+  { .key = DFU_REQUEST_DETACH         , .data = "DETACH"    },
+  { .key = DFU_REQUEST_DNLOAD         , .data = "DNLOAD"    },
+  { .key = DFU_REQUEST_UPLOAD         , .data = "UPLOAD"    },
   { .key = DFU_REQUEST_GETSTATUS      , .data = "GETSTATUS" },
   { .key = DFU_REQUEST_CLRSTATUS      , .data = "CLRSTATUS" },
-  { .key = DFU_REQUEST_GETSTATE       , .data = "GETSTATE" },
-  { .key = DFU_REQUEST_ABORT          , .data = "ABORT" },
+  { .key = DFU_REQUEST_GETSTATE       , .data = "GETSTATE"  },
+  { .key = DFU_REQUEST_ABORT          , .data = "ABORT"     },
 };
 
 static tu_lookup_table_t const _dfu_request_table =
@@ -83,17 +93,17 @@ static tu_lookup_table_t const _dfu_request_table =
 
 static tu_lookup_entry_t const _dfu_state_lookup[] =
 {
-  { .key = APP_IDLE                   , .data = "APP_IDLE" },
-  { .key = APP_DETACH                 , .data = "APP_DETACH" },
-  { .key = DFU_IDLE                   , .data = "DFU_IDLE" },
-  { .key = DFU_DNLOAD_SYNC            , .data = "DFU_DNLOAD_SYNC" },
-  { .key = DFU_DNBUSY                 , .data = "DFU_DNBUSY" },
-  { .key = DFU_DNLOAD_IDLE            , .data = "DFU_DNLOAD_IDLE" },
-  { .key = DFU_MANIFEST_SYNC          , .data = "DFU_MANIFEST_SYNC" },
-  { .key = DFU_MANIFEST               , .data = "DFU_MANIFEST" },
-  { .key = DFU_MANIFEST_WAIT_RESET    , .data = "DFU_MANIFEST_WAIT_RESET" },
-  { .key = DFU_UPLOAD_IDLE            , .data = "DFU_UPLOAD_IDLE" },
-  { .key = DFU_ERROR                  , .data = "DFU_ERROR" },
+  { .key = APP_IDLE                   , .data = "APP_IDLE"                },
+  { .key = APP_DETACH                 , .data = "APP_DETACH"              },
+  { .key = DFU_IDLE                   , .data = "IDLE"                },
+  { .key = DFU_DNLOAD_SYNC            , .data = "DNLOAD_SYNC"         },
+  { .key = DFU_DNBUSY                 , .data = "DNBUSY"              },
+  { .key = DFU_DNLOAD_IDLE            , .data = "DNLOAD_IDLE"         },
+  { .key = DFU_MANIFEST_SYNC          , .data = "MANIFEST_SYNC"       },
+  { .key = DFU_MANIFEST               , .data = "MANIFEST"            },
+  { .key = DFU_MANIFEST_WAIT_RESET    , .data = "MANIFEST_WAIT_RESET" },
+  { .key = DFU_UPLOAD_IDLE            , .data = "UPLOAD_IDLE"         },
+  { .key = DFU_ERROR                  , .data = "ERROR"               },
 };
 
 static tu_lookup_table_t const _dfu_state_table =
@@ -104,22 +114,22 @@ static tu_lookup_table_t const _dfu_state_table =
 
 static tu_lookup_entry_t const _dfu_status_lookup[] =
 {
-  { .key = DFU_STATUS_OK              , .data = "OK" },
-  { .key = DFU_STATUS_ERRTARGET       , .data = "errTARGET" },
-  { .key = DFU_STATUS_ERRFILE         , .data = "errFILE" },
-  { .key = DFU_STATUS_ERRWRITE        , .data = "errWRITE" },
-  { .key = DFU_STATUS_ERRERASE        , .data = "errERASE" },
-  { .key = DFU_STATUS_ERRCHECK_ERASED , .data = "errCHECK_ERASED" },
-  { .key = DFU_STATUS_ERRPROG         , .data = "errPROG" },
-  { .key = DFU_STATUS_ERRVERIFY       , .data = "errVERIFY" },
-  { .key = DFU_STATUS_ERRADDRESS      , .data = "errADDRESS" },
-  { .key = DFU_STATUS_ERRNOTDONE      , .data = "errNOTDONE" },
-  { .key = DFU_STATUS_ERRFIRMWARE     , .data = "errFIRMWARE" },
-  { .key = DFU_STATUS_ERRVENDOR       , .data = "errVENDOR" },
-  { .key = DFU_STATUS_ERRUSBR         , .data = "errUSBR" },
-  { .key = DFU_STATUS_ERRPOR          , .data = "errPOR" },
-  { .key = DFU_STATUS_ERRUNKNOWN      , .data = "errUNKNOWN" },
-  { .key = DFU_STATUS_ERRSTALLEDPKT   , .data = "errSTALLEDPKT" },
+  { .key = DFU_STATUS_OK               , .data = "OK"              },
+  { .key = DFU_STATUS_ERR_TARGET       , .data = "errTARGET"       },
+  { .key = DFU_STATUS_ERR_FILE         , .data = "errFILE"         },
+  { .key = DFU_STATUS_ERR_WRITE        , .data = "errWRITE"        },
+  { .key = DFU_STATUS_ERR_ERASE        , .data = "errERASE"        },
+  { .key = DFU_STATUS_ERR_CHECK_ERASED , .data = "errCHECK_ERASED" },
+  { .key = DFU_STATUS_ERR_PROG         , .data = "errPROG"         },
+  { .key = DFU_STATUS_ERR_VERIFY       , .data = "errVERIFY"       },
+  { .key = DFU_STATUS_ERR_ADDRESS      , .data = "errADDRESS"      },
+  { .key = DFU_STATUS_ERR_NOTDONE      , .data = "errNOTDONE"      },
+  { .key = DFU_STATUS_ERR_FIRMWARE     , .data = "errFIRMWARE"     },
+  { .key = DFU_STATUS_ERR_VENDOR       , .data = "errVENDOR"       },
+  { .key = DFU_STATUS_ERR_USBR         , .data = "errUSBR"         },
+  { .key = DFU_STATUS_ERR_POR          , .data = "errPOR"          },
+  { .key = DFU_STATUS_ERR_UNKNOWN      , .data = "errUNKNOWN"      },
+  { .key = DFU_STATUS_ERR_STALLEDPKT   , .data = "errSTALLEDPKT"   },
 };
 
 static tu_lookup_table_t const _dfu_status_table =
@@ -130,57 +140,59 @@ static tu_lookup_table_t const _dfu_status_table =
 
 #endif
 
-#define dfu_debug_print_context()                                              \
-{                                                                              \
-  TU_LOG2("  DFU at State: %s\r\n         Status: %s\r\n",                     \
-          tu_lookup_find(&_dfu_state_table, _dfu_state_ctx.state),        \
-          tu_lookup_find(&_dfu_status_table, _dfu_state_ctx.status) );    \
-}
-
 //--------------------------------------------------------------------+
 // USBD Driver API
 //--------------------------------------------------------------------+
-void dfu_moded_init(void)
-{
-  _dfu_state_ctx.state = DFU_IDLE;
-  _dfu_state_ctx.status = DFU_STATUS_OK;
-  _dfu_state_ctx.attrs = 0;
-  _dfu_state_ctx.blk_transfer_in_proc = false;
-
-  dfu_debug_print_context();
-}
-
 void dfu_moded_reset(uint8_t rhport)
 {
   (void) rhport;
 
-  _dfu_state_ctx.state = DFU_IDLE;
-  _dfu_state_ctx.status = DFU_STATUS_OK;
-  _dfu_state_ctx.blk_transfer_in_proc = false;
-  dfu_debug_print_context();
+  _dfu_ctx.attrs = 0;
+  _dfu_ctx.alt = 0;
+
+  reset_state();
+}
+
+void dfu_moded_init(void)
+{
+  dfu_moded_reset(0);
 }
 
 uint16_t dfu_moded_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len)
 {
   (void) rhport;
-  (void) max_len;
 
-  // Ensure this is DFU Mode
-  TU_VERIFY((itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS) &&
-            (itf_desc->bInterfaceProtocol == DFU_PROTOCOL_DFU), 0);
+  //------------- Interface (with Alt) descriptor -------------//
+  uint8_t const itf_num = itf_desc->bInterfaceNumber;
+  uint8_t alt_count = 0;
 
-  uint8_t const * p_desc = tu_desc_next( itf_desc );
-  uint16_t drv_len = sizeof(tusb_desc_interface_t);
-
-  if ( TUSB_DESC_FUNCTIONAL == tu_desc_type(p_desc) )
+  uint16_t drv_len = 0;
+  while(itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS && itf_desc->bInterfaceProtocol == DFU_PROTOCOL_DFU)
   {
-    tusb_desc_dfu_functional_t const *dfu_desc = (tusb_desc_dfu_functional_t const *)p_desc;
-    _dfu_state_ctx.attrs = (uint8_t)dfu_desc->bAttributes;
+    TU_ASSERT(max_len > drv_len, 0);
 
-    drv_len += tu_desc_len(p_desc);
-    p_desc   = tu_desc_next(p_desc);
+    // Alternate must have the same interface number
+    TU_ASSERT(itf_desc->bInterfaceNumber == itf_num, 0);
+
+    // Alt should increase by one every time
+    TU_ASSERT(itf_desc->bAlternateSetting == alt_count, 0);
+    alt_count++;
+
+    drv_len += tu_desc_len(itf_desc);
+    itf_desc = (tusb_desc_interface_t const *) tu_desc_next(itf_desc);
   }
 
+  //------------- DFU Functional descriptor -------------//
+  tusb_desc_dfu_functional_t const *func_desc = (tusb_desc_dfu_functional_t const *) itf_desc;
+  TU_ASSERT(tu_desc_type(func_desc) == TUSB_DESC_FUNCTIONAL, 0);
+  drv_len += sizeof(tusb_desc_dfu_functional_t);
+
+  _dfu_ctx.attrs = func_desc->bAttributes;
+
+  // CFG_TUD_DFU_XFER_BUFSIZE has to be set to the buffer size used in TUD_DFU_DESCRIPTOR
+  uint16_t const transfer_size = tu_le16toh( tu_unaligned_read16(&func_desc->wTransferSize) );
+  TU_ASSERT(transfer_size <= CFG_TUD_DFU_XFER_BUFSIZE, drv_len);
+
   return drv_len;
 }
 
@@ -189,434 +201,258 @@ uint16_t dfu_moded_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
 // return false to stall control endpoint (e.g unsupported request)
 bool dfu_moded_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
 {
-  // nothing to do with DATA stage
-  if ( stage == CONTROL_STAGE_DATA ) return true;
-
   TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
 
-  if(stage == CONTROL_STAGE_SETUP)
+  TU_LOG2("  DFU State  : %s, Status: %s\r\n", tu_lookup_find(&_dfu_state_table, _dfu_ctx.state), tu_lookup_find(&_dfu_status_table, _dfu_ctx.status));
+
+  if ( request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD )
   {
-    // dfu-util will try to claim the interface with SET_INTERFACE request before sending DFU request
-    if ( TUSB_REQ_TYPE_STANDARD == request->bmRequestType_bit.type &&
-         TUSB_REQ_SET_INTERFACE == request->bRequest )
+    // Standard request include GET/SET_INTERFACE
+    switch ( request->bRequest )
     {
-      tud_control_status(rhport, request);
-      return true;
+      case TUSB_REQ_SET_INTERFACE:
+        if ( stage == CONTROL_STAGE_SETUP )
+        {
+          // Switch Alt interface and reset state machine
+          _dfu_ctx.alt = (uint8_t) request->wValue;
+          reset_state();
+          return tud_control_status(rhport, request);
+        }
+      break;
+
+      case TUSB_REQ_GET_INTERFACE:
+        if(stage == CONTROL_STAGE_SETUP)
+        {
+          return tud_control_xfer(rhport, request, &_dfu_ctx.alt, 1);
+        }
+      break;
+
+      // unsupported request
+      default: return false;
     }
   }
-
-  // Handle class request only from here
-  TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
-
-  switch (request->bRequest)
+  else if ( request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS )
   {
-    case DFU_REQUEST_DNLOAD:
+    TU_LOG2("  DFU Request: %s\r\n", tu_lookup_find(&_dfu_request_table, request->bRequest));
+
+    // Class request
+    switch ( request->bRequest )
     {
-      if ( (stage == CONTROL_STAGE_ACK)
-           && ((_dfu_state_ctx.attrs & DFU_FUNC_ATTR_CAN_DOWNLOAD_BITMASK) != 0)
-           && (_dfu_state_ctx.state == DFU_DNLOAD_SYNC))
-      {
-        dfu_req_dnload_reply(rhport, request);
-        return true;
-      }
-    } // fallthrough
-    case DFU_REQUEST_DETACH:
-    case DFU_REQUEST_UPLOAD:
-    case DFU_REQUEST_GETSTATUS:
-    case DFU_REQUEST_CLRSTATUS:
-    case DFU_REQUEST_GETSTATE:
-    case DFU_REQUEST_ABORT:
-    {
-      if(stage == CONTROL_STAGE_SETUP)
-      {
-        return dfu_state_machine(rhport, request);
-      }
-    }
-    break;
-
-    default:
-    {
-      TU_LOG2("  DFU Nonstandard Request: %u\r\n", request->bRequest);
-      return false; // stall unsupported request
-    }
-    break;
-  }
-
-  return true;
-}
-
-static uint16_t dfu_req_upload(uint8_t rhport, tusb_control_request_t const * request, uint16_t block_num, uint16_t wLength)
-{
-  TU_VERIFY( wLength <= CFG_TUD_DFU_TRANSFER_BUFFER_SIZE, 0);
-  uint16_t retval = tud_dfu_req_upload_data_cb(block_num, (uint8_t *)_dfu_state_ctx.transfer_buf, wLength);
-  tud_control_xfer(rhport, request, _dfu_state_ctx.transfer_buf, retval);
-  return retval;
-}
-
-static void dfu_req_getstatus_reply(uint8_t rhport, tusb_control_request_t const * request)
-{
-  dfu_status_req_payload_t resp;
-
-  resp.bStatus = _dfu_state_ctx.status;
-  memset((uint8_t *)&resp.bwPollTimeout, 0x00, 3);
-  resp.bState = _dfu_state_ctx.state;
-  resp.iString = 0;
-
-  tud_control_xfer(rhport, request, &resp, sizeof(dfu_status_req_payload_t));
-}
-
-static void dfu_req_getstate_reply(uint8_t rhport, tusb_control_request_t const * request)
-{
-  tud_control_xfer(rhport, request, &_dfu_state_ctx.state, 1);
-}
-
-static void dfu_req_dnload_setup(uint8_t rhport, tusb_control_request_t const * request)
-{
-  // TODO: add "zero" copy mode so the buffer we read into can be provided by the user
-  // if they wish, there still will be the internal control buffer copy to this buffer
-  // but this mode would provide zero copy from the class driver to the application
-
-  TU_VERIFY( request->wLength <= CFG_TUD_DFU_TRANSFER_BUFFER_SIZE, );
-  // setup for data phase
-  tud_control_xfer(rhport, request, _dfu_state_ctx.transfer_buf, request->wLength);
-}
-
-static void dfu_req_dnload_reply(uint8_t rhport, tusb_control_request_t const * request)
-{
-  (void) rhport;
-  TU_VERIFY( request->wLength <= CFG_TUD_DFU_TRANSFER_BUFFER_SIZE, );
-  tud_dfu_req_dnload_data_cb(request->wValue, (uint8_t *)_dfu_state_ctx.transfer_buf, request->wLength);
-  _dfu_state_ctx.blk_transfer_in_proc = false;
-}
-
-void tud_dfu_dnload_complete(void)
-{
-  if (_dfu_state_ctx.state == DFU_DNBUSY)
-  {
-    _dfu_state_ctx.state = DFU_DNLOAD_SYNC;
-  } else if (_dfu_state_ctx.state == DFU_MANIFEST)
-  {
-    _dfu_state_ctx.state = ((_dfu_state_ctx.attrs & DFU_FUNC_ATTR_MANIFESTATION_TOLERANT_BITMASK) != 0)
-                           ? DFU_MANIFEST_WAIT_RESET : DFU_MANIFEST_SYNC;
-  }
-}
-
-static bool dfu_state_machine(uint8_t rhport, tusb_control_request_t const * request)
-{
-  TU_LOG2("  DFU Request: %s\r\n", tu_lookup_find(&_dfu_request_table, request->bRequest));
-  TU_LOG2("  DFU State Machine: %s\r\n", tu_lookup_find(&_dfu_state_table, _dfu_state_ctx.state));
-
-  switch (_dfu_state_ctx.state)
-  {
-    case DFU_IDLE:
-    {
-      switch (request->bRequest)
-      {
-        case DFU_REQUEST_DNLOAD:
+      case DFU_REQUEST_DETACH:
+        if ( stage == CONTROL_STAGE_SETUP )
         {
-          if( ((_dfu_state_ctx.attrs & DFU_FUNC_ATTR_CAN_DOWNLOAD_BITMASK) != 0)
-              && (request->wLength > 0) )
+          tud_control_status(rhport, request);
+        }
+        else if ( stage == CONTROL_STAGE_ACK )
+        {
+          if ( tud_dfu_detach_cb ) tud_dfu_detach_cb();
+        }
+      break;
+
+      case DFU_REQUEST_CLRSTATUS:
+        if ( stage == CONTROL_STAGE_SETUP )
+        {
+          reset_state();
+          tud_control_status(rhport, request);
+        }
+      break;
+
+      case DFU_REQUEST_GETSTATE:
+        if ( stage == CONTROL_STAGE_SETUP )
+        {
+          tud_control_xfer(rhport, request, &_dfu_ctx.state, 1);
+        }
+      break;
+
+      case DFU_REQUEST_ABORT:
+        if ( stage == CONTROL_STAGE_SETUP )
+        {
+          reset_state();
+          tud_control_status(rhport, request);
+        }
+        else if ( stage == CONTROL_STAGE_ACK )
+        {
+          if ( tud_dfu_abort_cb ) tud_dfu_abort_cb(_dfu_ctx.alt);
+        }
+      break;
+
+      case DFU_REQUEST_UPLOAD:
+        if ( stage == CONTROL_STAGE_SETUP )
+        {
+          TU_VERIFY(_dfu_ctx.attrs & DFU_ATTR_CAN_UPLOAD);
+          TU_VERIFY(tud_dfu_upload_cb);
+          TU_VERIFY(request->wLength <= CFG_TUD_DFU_XFER_BUFSIZE);
+
+          uint16_t const xfer_len = tud_dfu_upload_cb(_dfu_ctx.alt, request->wValue, _dfu_ctx.transfer_buf, request->wLength);
+
+          return tud_control_xfer(rhport, request, _dfu_ctx.transfer_buf, xfer_len);
+        }
+      break;
+
+      case DFU_REQUEST_DNLOAD:
+        if ( stage == CONTROL_STAGE_SETUP )
+        {
+          TU_VERIFY(_dfu_ctx.attrs & DFU_ATTR_CAN_DOWNLOAD);
+          TU_VERIFY(_dfu_ctx.state == DFU_IDLE || _dfu_ctx.state == DFU_DNLOAD_IDLE);
+          TU_VERIFY(request->wLength <= CFG_TUD_DFU_XFER_BUFSIZE);
+
+          // set to true for both download and manifest
+          _dfu_ctx.flashing_in_progress = true;
+
+          // save block and length for flashing
+          _dfu_ctx.block  = request->wValue;
+          _dfu_ctx.length = request->wLength;
+
+          if ( request->wLength )
           {
-            _dfu_state_ctx.state = DFU_DNLOAD_SYNC;
-            _dfu_state_ctx.blk_transfer_in_proc = true;
-            dfu_req_dnload_setup(rhport, request);
-          } else {
-            _dfu_state_ctx.state = DFU_ERROR;
+            // Download with payload -> transition to DOWNLOAD SYNC
+            _dfu_ctx.state = DFU_DNLOAD_SYNC;
+            return tud_control_xfer(rhport, request, _dfu_ctx.transfer_buf, request->wLength);
+          }
+          else
+          {
+            // Download is complete -> transition to MANIFEST SYNC
+            _dfu_ctx.state = DFU_MANIFEST_SYNC;
+            return tud_control_status(rhport, request);
           }
         }
-        break;
+      break;
 
-        case DFU_REQUEST_UPLOAD:
+      case DFU_REQUEST_GETSTATUS:
+        switch ( _dfu_ctx.state )
         {
-          if( ((_dfu_state_ctx.attrs & DFU_FUNC_ATTR_CAN_UPLOAD_BITMASK) != 0) )
-          {
-            _dfu_state_ctx.state = DFU_UPLOAD_IDLE;
-            dfu_req_upload(rhport, request, request->wValue, request->wLength);
-          } else {
-            _dfu_state_ctx.state = DFU_ERROR;
-          }
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATUS:
-        {
-          dfu_req_getstatus_reply(rhport, request);
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATE:
-        {
-          dfu_req_getstate_reply(rhport, request);
-        }
-        break;
-
-        case DFU_REQUEST_ABORT:
-        {
-          ; // do nothing, but don't stall so continue on
-        }
-        break;
-
-        default:
-        {
-          _dfu_state_ctx.state = DFU_ERROR;
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_DNLOAD_SYNC:
-    {
-      switch (request->bRequest)
-      {
-        case DFU_REQUEST_GETSTATUS:
-        {
-          if ( _dfu_state_ctx.blk_transfer_in_proc )
-          {
-            _dfu_state_ctx.state = DFU_DNBUSY;
-            dfu_req_getstatus_reply(rhport, request);
-          } else {
-            _dfu_state_ctx.state = DFU_DNLOAD_IDLE;
-            dfu_req_getstatus_reply(rhport, request);
-          }
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATE:
-        {
-          dfu_req_getstate_reply(rhport, request);
-        }
-        break;
-
-        default:
-        {
-          _dfu_state_ctx.state = DFU_ERROR;
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_DNBUSY:
-    {
-      switch (request->bRequest)
-      {
-        default:
-        {
-          _dfu_state_ctx.state = DFU_ERROR;
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_DNLOAD_IDLE:
-    {
-        switch (request->bRequest)
-        {
-          case DFU_REQUEST_DNLOAD:
-          {
-            if( ((_dfu_state_ctx.attrs & DFU_FUNC_ATTR_CAN_DOWNLOAD_BITMASK) != 0)
-                && (request->wLength > 0) )
-            {
-              _dfu_state_ctx.state = DFU_DNLOAD_SYNC;
-              _dfu_state_ctx.blk_transfer_in_proc = true;
-              dfu_req_dnload_setup(rhport, request);
-            } else {
-              if ( tud_dfu_device_data_done_check_cb() )
-              {
-                _dfu_state_ctx.state = DFU_MANIFEST_SYNC;
-                tud_control_status(rhport, request);
-              } else {
-                _dfu_state_ctx.state = DFU_ERROR;
-                return false;  // stall
-              }
-            }
-          }
+          case DFU_DNLOAD_SYNC:
+            return process_download_get_status(rhport, stage, request);
           break;
 
-          case DFU_REQUEST_GETSTATUS:
-          {
-            dfu_req_getstatus_reply(rhport, request);
-          }
-          break;
-
-          case DFU_REQUEST_GETSTATE:
-          {
-            dfu_req_getstate_reply(rhport, request);
-          }
-          break;
-
-          case DFU_REQUEST_ABORT:
-          {
-            if ( tud_dfu_abort_cb )
-            {
-              tud_dfu_abort_cb();
-            }
-            _dfu_state_ctx.state = DFU_IDLE;
-          }
+          case DFU_MANIFEST_SYNC:
+            return process_manifest_get_status(rhport, stage, request);
           break;
 
           default:
-          {
-            _dfu_state_ctx.state = DFU_ERROR;
-            return false;  // stall on all other requests
-          }
+            if ( stage == CONTROL_STAGE_SETUP ) return reply_getstatus(rhport, request, _dfu_ctx.state, _dfu_ctx.status, 0);
           break;
         }
+      break;
+
+      default: return false; // stall unsupported request
     }
-    break;
-
-    case DFU_MANIFEST_SYNC:
-    {
-      switch (request->bRequest)
-      {
-        case DFU_REQUEST_GETSTATUS:
-        {
-          if ((_dfu_state_ctx.attrs & DFU_FUNC_ATTR_MANIFESTATION_TOLERANT_BITMASK) != 0)
-          {
-            _dfu_state_ctx.state = DFU_MANIFEST;
-            dfu_req_getstatus_reply(rhport, request);
-          } else {
-            if ( tud_dfu_firmware_valid_check_cb() )
-            {
-              _dfu_state_ctx.state = DFU_IDLE;
-            }
-            dfu_req_getstatus_reply(rhport, request);
-          }
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATE:
-        {
-          dfu_req_getstate_reply(rhport, request);
-        }
-        break;
-
-        default:
-        {
-          _dfu_state_ctx.state = DFU_ERROR;
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_MANIFEST:
-    {
-      switch (request->bRequest)
-      {
-        default:
-        {
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_MANIFEST_WAIT_RESET:
-    {
-      // technically we should never even get here, but we will handle it just in case
-      TU_LOG2("  DFU was in DFU_MANIFEST_WAIT_RESET and got unexpected request: %u\r\n", request->bRequest);
-      switch (request->bRequest)
-      {
-        default:
-        {
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_UPLOAD_IDLE:
-    {
-      switch (request->bRequest)
-      {
-        case DFU_REQUEST_UPLOAD:
-        {
-          if (dfu_req_upload(rhport, request, request->wValue, request->wLength) != request->wLength)
-          {
-            _dfu_state_ctx.state = DFU_IDLE;
-          }
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATUS:
-        {
-          dfu_req_getstatus_reply(rhport, request);
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATE:
-        {
-          dfu_req_getstate_reply(rhport, request);
-        }
-        break;
-
-        case DFU_REQUEST_ABORT:
-        {
-          if (tud_dfu_abort_cb)
-          {
-            tud_dfu_abort_cb();
-          }
-          _dfu_state_ctx.state = DFU_IDLE;
-        }
-        break;
-
-        default:
-        {
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    case DFU_ERROR:
-    {
-      switch (request->bRequest)
-      {
-        case DFU_REQUEST_GETSTATUS:
-        {
-          dfu_req_getstatus_reply(rhport, request);
-        }
-        break;
-
-        case DFU_REQUEST_CLRSTATUS:
-        {
-          _dfu_state_ctx.state = DFU_IDLE;
-        }
-        break;
-
-        case DFU_REQUEST_GETSTATE:
-        {
-          dfu_req_getstate_reply(rhport, request);
-        }
-        break;
-
-        default:
-        {
-          return false;  // stall on all other requests
-        }
-        break;
-      }
-    }
-    break;
-
-    default:
-      _dfu_state_ctx.state = DFU_ERROR;
-      TU_LOG2("  DFU ERROR: Unexpected state\r\nStalling control pipe\r\n");
-      return false;  // Unexpected state, stall and change to error
+  }else
+  {
+    return false; // unsupported request
   }
 
   return true;
 }
 
+void tud_dfu_finish_flashing(uint8_t status)
+{
+  _dfu_ctx.flashing_in_progress = false;
+
+  if ( status == DFU_STATUS_OK )
+  {
+    if (_dfu_ctx.state == DFU_DNBUSY)
+    {
+      _dfu_ctx.state = DFU_DNLOAD_SYNC;
+    }
+    else if (_dfu_ctx.state == DFU_MANIFEST)
+    {
+      _dfu_ctx.state = (_dfu_ctx.attrs & DFU_ATTR_MANIFESTATION_TOLERANT)
+                               ? DFU_MANIFEST_SYNC : DFU_MANIFEST_WAIT_RESET;
+    }
+  }
+  else
+  {
+    // failed while flashing, move to dfuError
+    _dfu_ctx.state = DFU_ERROR;
+    _dfu_ctx.status = status;
+  }
+}
+
+static bool process_download_get_status(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
+{
+  if ( stage == CONTROL_STAGE_SETUP )
+  {
+    // only transition to next state on CONTROL_STAGE_ACK
+    dfu_state_t next_state;
+    uint32_t timeout;
+
+    if ( _dfu_ctx.flashing_in_progress )
+    {
+      next_state = DFU_DNBUSY;
+      timeout = tud_dfu_get_timeout_cb(_dfu_ctx.alt, (uint8_t) next_state);
+    }
+    else
+    {
+      next_state = DFU_DNLOAD_IDLE;
+      timeout = 0;
+    }
+
+    return reply_getstatus(rhport, request, next_state, _dfu_ctx.status, timeout);
+  }
+  else if ( stage == CONTROL_STAGE_ACK )
+  {
+    if ( _dfu_ctx.flashing_in_progress )
+    {
+      _dfu_ctx.state = DFU_DNBUSY;
+      tud_dfu_download_cb(_dfu_ctx.alt, _dfu_ctx.block, _dfu_ctx.transfer_buf, _dfu_ctx.length);
+    }else
+    {
+      _dfu_ctx.state = DFU_DNLOAD_IDLE;
+    }
+  }
+
+  return true;
+}
+
+static bool process_manifest_get_status(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
+{
+  if ( stage == CONTROL_STAGE_SETUP )
+  {
+    // only transition to next state on CONTROL_STAGE_ACK
+    dfu_state_t next_state;
+    uint32_t timeout;
+
+    if ( _dfu_ctx.flashing_in_progress )
+    {
+      next_state = DFU_MANIFEST;
+      timeout = tud_dfu_get_timeout_cb(_dfu_ctx.alt, next_state);
+    }
+    else
+    {
+      next_state = DFU_IDLE;
+      timeout = 0;
+    }
+
+    return reply_getstatus(rhport, request, next_state, _dfu_ctx.status, timeout);
+  }
+  else if ( stage == CONTROL_STAGE_ACK )
+  {
+    if ( _dfu_ctx.flashing_in_progress )
+    {
+      _dfu_ctx.state = DFU_MANIFEST;
+      tud_dfu_manifest_cb(_dfu_ctx.alt);
+    }
+    else
+    {
+      _dfu_ctx.state = DFU_IDLE;
+    }
+  }
+
+  return true;
+}
+
+static bool reply_getstatus(uint8_t rhport, tusb_control_request_t const * request, dfu_state_t state, dfu_status_t status, uint32_t timeout)
+{
+  dfu_status_response_t resp;
+  resp.bStatus          = (uint8_t) status;
+  resp.bwPollTimeout[0] = TU_U32_BYTE0(timeout);
+  resp.bwPollTimeout[1] = TU_U32_BYTE1(timeout);
+  resp.bwPollTimeout[2] = TU_U32_BYTE2(timeout);
+  resp.bState           = (uint8_t) state;
+  resp.iString          = 0;
+
+  return tud_control_xfer(rhport, request, &resp, sizeof(dfu_status_response_t));
+}
 
 #endif
diff --git a/src/class/dfu/dfu_device.h b/src/class/dfu/dfu_device.h
index 9a09a46b1..fecf8596f 100644
--- a/src/class/dfu/dfu_device.h
+++ b/src/class/dfu/dfu_device.h
@@ -33,38 +33,54 @@
   extern "C" {
 #endif
 
+//--------------------------------------------------------------------+
+// Class Driver Default Configure & Validation
+//--------------------------------------------------------------------+
+
+#if !defined(CFG_TUD_DFU_XFER_BUFSIZE)
+  #error "CFG_TUD_DFU_XFER_BUFSIZE must be defined, it has to be set to the buffer size used in TUD_DFU_DESCRIPTOR"
+#endif
+
+//--------------------------------------------------------------------+
+// Application API
+//--------------------------------------------------------------------+
+
+// Must be called when the application is done with flashing started by
+// tud_dfu_download_cb() and tud_dfu_manifest_cb().
+// status is DFU_STATUS_OK if successful, any other error status will cause state to enter dfuError
+void tud_dfu_finish_flashing(uint8_t status);
 
 //--------------------------------------------------------------------+
 // Application Callback API (weak is optional)
 //--------------------------------------------------------------------+
-// Invoked during DFU_MANIFEST_SYNC get status request to check if firmware
-// is valid
-bool tud_dfu_firmware_valid_check_cb(void);
 
-// Invoked when a DFU_DNLOAD request is received
-// This callback takes the wBlockNum chunk of length length and provides it
-// to the application at the data pointer.  This data is only valid for this
-// call, so the app must use it not or copy it.
-void tud_dfu_req_dnload_data_cb(uint16_t wBlockNum, uint8_t* data, uint16_t length);
+// Note: alt is used as the partition number, in order to support multiple partitions like FLASH, EEPROM, etc.
 
-// Must be called when the application is done using the last block of data
-// provided by tud_dfu_req_dnload_data_cb
-void tud_dfu_dnload_complete(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);
 
-// Invoked during the last DFU_DNLOAD request, signifying that the host believes
-// it is done transmitting data.
-// Return true if the application agrees there is no more data
-// Return false if the device disagrees, which will stall the pipe, and the Host
-//              should initiate a recovery procedure
-bool tud_dfu_device_data_done_check_cb(void);
+// 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);
+
+// 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);
+
+// Invoked when received DFU_UPLOAD request
+// Application must populate data with up to length bytes and
+// Return the number of written bytes
+TU_ATTR_WEAK uint16_t tud_dfu_upload_cb(uint8_t alt, uint16_t block_num, uint8_t* data, uint16_t length);
+
+// Invoked when a DFU_DETACH request is received
+TU_ATTR_WEAK void tud_dfu_detach_cb(void);
 
 // Invoked when the Host has terminated a download or upload transfer
-TU_ATTR_WEAK void tud_dfu_abort_cb(void);
-
-// Invoked when a DFU_UPLOAD request is received
-// This callback must populate data with up to length bytes
-// Return the number of bytes to write
-uint16_t tud_dfu_req_upload_data_cb(uint16_t block_num, uint8_t* data, uint16_t length);
+TU_ATTR_WEAK void tud_dfu_abort_cb(uint8_t alt);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
diff --git a/src/class/dfu/dfu_rt_device.c b/src/class/dfu/dfu_rt_device.c
index 07e6f30f3..afee2aa1f 100644
--- a/src/class/dfu/dfu_rt_device.c
+++ b/src/class/dfu/dfu_rt_device.c
@@ -108,10 +108,10 @@ bool dfu_rtd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
     case DFU_REQUEST_GETSTATUS:
     {
       TU_LOG2("  DFU RT Request: GETSTATUS\r\n");
-      dfu_status_req_payload_t resp;
+      dfu_status_response_t resp;
       // Status = OK, Poll timeout is ignored during RT, State = APP_IDLE, IString = 0
-      memset(&resp, 0x00, sizeof(dfu_status_req_payload_t));
-      tud_control_xfer(rhport, request, &resp, sizeof(dfu_status_req_payload_t));
+      memset(&resp, 0x00, sizeof(dfu_status_response_t));
+      tud_control_xfer(rhport, request, &resp, sizeof(dfu_status_response_t));
     }
     break;
 
diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index ec58a3181..eab67ebd5 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -449,7 +449,7 @@ typedef struct TU_ATTR_PACKED
 /*------------------------------------------------------------------*/
 /* Types
  *------------------------------------------------------------------*/
-typedef struct TU_ATTR_PACKED{
+typedef struct TU_ATTR_PACKED {
   union {
     struct TU_ATTR_PACKED {
       uint8_t recipient :  5; ///< Recipient type tusb_request_recipient_t.
diff --git a/src/device/usbd.c b/src/device/usbd.c
index b724c73e8..0e24bf40e 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -188,9 +188,9 @@ static usbd_class_driver_t const _usbd_driver[] =
   },
   #endif
 
-  #if CFG_TUD_DFU_MODE
+  #if CFG_TUD_DFU
   {
-    DRIVER_NAME("DFU-MODE")
+    DRIVER_NAME("DFU")
     .init             = dfu_moded_init,
     .reset            = dfu_moded_reset,
     .open             = dfu_moded_open,
diff --git a/src/device/usbd.h b/src/device/usbd.h
index 9500ad70c..1405f6917 100644
--- a/src/device/usbd.h
+++ b/src/device/usbd.h
@@ -602,17 +602,51 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
   /* Function */ \
   9, DFU_DESC_FUNCTIONAL, _attr, U16_TO_U8S_LE(_timeout), U16_TO_U8S_LE(_xfer_size), U16_TO_U8S_LE(0x0101)
 
-// Length of template descriptr: 18 bytes
-#define TUD_DFU_MODE_DESC_LEN (9 + 9)
+// Length of template descriptor: 9 bytes + number of alternatives * 9
+#define TUD_DFU_DESC_LEN(_alt_count)    (9 + (_alt_count) * 9)
 
-// DFU runtime descriptor
-// Interface number, string index, attributes, detach timeout, transfer size
-#define TUD_DFU_MODE_DESCRIPTOR(_itfnum, _stridx, _attr, _timeout, _xfer_size) \
-  /* Interface */ \
-  9, TUSB_DESC_INTERFACE, _itfnum, 0, 0, TUD_DFU_APP_CLASS, TUD_DFU_APP_SUBCLASS, DFU_PROTOCOL_DFU, _stridx, \
+// Interface number, Alternate count, starting string index, attributes, detach timeout, transfer size
+// Note: Alternate count must be numberic or macro, string index is increased by one for each Alt interface
+#define TUD_DFU_DESCRIPTOR(_itfnum, _alt_count, _stridx, _attr, _timeout, _xfer_size) \
+  TU_XSTRCAT(_TUD_DFU_ALT_,_alt_count)(_itfnum, 0, _stridx), \
   /* Function */ \
   9, DFU_DESC_FUNCTIONAL, _attr, U16_TO_U8S_LE(_timeout), U16_TO_U8S_LE(_xfer_size), U16_TO_U8S_LE(0x0101)
 
+#define _TUD_DFU_ALT(_itfnum, _alt, _stridx) \
+  /* Interface */ \
+  9, TUSB_DESC_INTERFACE, _itfnum, _alt, 0, TUD_DFU_APP_CLASS, TUD_DFU_APP_SUBCLASS, DFU_PROTOCOL_DFU, _stridx
+
+#define _TUD_DFU_ALT_1(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx)
+
+#define _TUD_DFU_ALT_2(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_1(_itfnum, _alt_count+1, _stridx+1)
+
+#define _TUD_DFU_ALT_3(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_2(_itfnum, _alt_count+1, _stridx+1)
+
+#define _TUD_DFU_ALT_4(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_3(_itfnum, _alt_count+1, _stridx+1)
+
+#define _TUD_DFU_ALT_5(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_4(_itfnum, _alt_count+1, _stridx+1)
+
+#define _TUD_DFU_ALT_6(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_5(_itfnum, _alt_count+1, _stridx+1)
+
+#define _TUD_DFU_ALT_7(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_6(_itfnum, _alt_count+1, _stridx+1)
+
+#define _TUD_DFU_ALT_8(_itfnum, _alt_count, _stridx) \
+  _TUD_DFU_ALT(_itfnum, _alt_count, _stridx),      \
+  _TUD_DFU_ALT_7(_itfnum, _alt_count+1, _stridx+1)
+
 
 //------------- CDC-ECM -------------//
 
diff --git a/src/tusb.h b/src/tusb.h
index 2b1d7483a..b52f8839a 100644
--- a/src/tusb.h
+++ b/src/tusb.h
@@ -96,7 +96,7 @@
     #include "class/dfu/dfu_rt_device.h"
   #endif
 
-  #if CFG_TUD_DFU_MODE
+  #if CFG_TUD_DFU
     #include "class/dfu/dfu_device.h"
   #endif
 
diff --git a/src/tusb_option.h b/src/tusb_option.h
index dfac46374..6651eb83d 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -246,12 +246,8 @@
   #define CFG_TUD_DFU_RUNTIME     0
 #endif
 
-#ifndef CFG_TUD_DFU_MODE
-  #define CFG_TUD_DFU_MODE        0
-#endif
-
-#ifndef CFG_TUD_DFU_TRANSFER_BUFFER_SIZE
-  #define CFG_TUD_DFU_TRANSFER_BUFFER_SIZE  64
+#ifndef CFG_TUD_DFU
+  #define CFG_TUD_DFU             0
 #endif
 
 #ifndef CFG_TUD_NET