Merge branch 'master' of github.com:xmos-jmccarthy/tinyusb

13 files changed, 911 insertions, 68 deletions

diff --git a/src/class/dfu/dfu.h b/src/class/dfu/dfu.h
new file mode 100644
index 000000000..18de3bf99
--- /dev/null
+++ b/src/class/dfu/dfu.h
@@ -0,0 +1,118 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 XMOS LIMITED
+ *
+ * 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.
+ */
+
+#ifndef _TUSB_DFU_H_
+#define _TUSB_DFU_H_
+
+#include "common/tusb_common.h"
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+//--------------------------------------------------------------------+
+// Common Definitions
+//--------------------------------------------------------------------+
+// DFU Protocol
+typedef enum
+{
+  DFU_PROTOCOL_RT  = 0x01,
+  DFU_PROTOCOL_DFU = 0x02,
+} dfu_protocol_type_t;
+
+// DFU Descriptor Type
+typedef enum
+{
+  DFU_DESC_FUNCTIONAL = 0x21,
+} dfu_descriptor_type_t;
+
+// DFU Requests
+typedef enum {
+  DFU_REQUEST_DETACH         = 0,
+  DFU_REQUEST_DNLOAD         = 1,
+  DFU_REQUEST_UPLOAD         = 2,
+  DFU_REQUEST_GETSTATUS      = 3,
+  DFU_REQUEST_CLRSTATUS      = 4,
+  DFU_REQUEST_GETSTATE       = 5,
+  DFU_REQUEST_ABORT          = 6,
+} dfu_requests_t;
+
+// DFU States
+typedef enum {
+  APP_IDLE                   = 0,
+  APP_DETACH                 = 1,
+  DFU_IDLE                   = 2,
+  DFU_DNLOAD_SYNC            = 3,
+  DFU_DNBUSY                 = 4,
+  DFU_DNLOAD_IDLE            = 5,
+  DFU_MANIFEST_SYNC          = 6,
+  DFU_MANIFEST               = 7,
+  DFU_MANIFEST_WAIT_RESET    = 8,
+  DFU_UPLOAD_IDLE            = 9,
+  DFU_ERROR                  = 10,
+} dfu_state_t;
+
+// 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;
+
+#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)
+
+// DFU Status Request Payload
+typedef struct TU_ATTR_PACKED
+{
+  uint8_t bStatus;
+  uint8_t bwPollTimeout[3];
+  uint8_t bState;
+  uint8_t iString;
+} dfu_status_req_payload_t;
+
+TU_VERIFY_STATIC( sizeof(dfu_status_req_payload_t) == 6, "size is not correct");
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* _TUSB_DFU_H_ */
diff --git a/src/class/dfu/dfu_device.c b/src/class/dfu/dfu_device.c
new file mode 100644
index 000000000..da9f189aa
--- /dev/null
+++ b/src/class/dfu/dfu_device.c
@@ -0,0 +1,616 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 XMOS LIMITED
+ *
+ * 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_DFU_MODE)
+
+#include "dfu_device.h"
+#include "device/usbd_pvt.h"
+
+//--------------------------------------------------------------------+
+// MACRO CONSTANT TYPEDEF
+//--------------------------------------------------------------------+
+
+//--------------------------------------------------------------------+
+// INTERNAL OBJECT & FUNCTION DECLARATION
+//--------------------------------------------------------------------+
+typedef struct TU_ATTR_PACKED
+{
+    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];
+} dfu_state_ctx_t;
+
+// Only a single dfu state is allowed
+CFG_TUSB_MEM_SECTION static dfu_state_ctx_t _dfu_state_ctx;
+
+
+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);
+
+//--------------------------------------------------------------------+
+// Debug
+//--------------------------------------------------------------------+
+#if CFG_TUSB_DEBUG >= 2
+
+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_GETSTATUS      , .data = "GETSTATUS" },
+  { .key = DFU_REQUEST_CLRSTATUS      , .data = "CLRSTATUS" },
+  { .key = DFU_REQUEST_GETSTATE       , .data = "GETSTATE" },
+  { .key = DFU_REQUEST_ABORT          , .data = "ABORT" },
+};
+
+static tu_lookup_table_t const _dfu_request_table =
+{
+  .count = TU_ARRAY_SIZE(_dfu_request_lookup),
+  .items = _dfu_request_lookup
+};
+
+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" },
+};
+
+static tu_lookup_table_t const _dfu_state_table =
+{
+  .count = TU_ARRAY_SIZE(_dfu_state_lookup),
+  .items = _dfu_state_lookup
+};
+
+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" },
+};
+
+static tu_lookup_table_t const _dfu_status_table =
+{
+  .count = TU_ARRAY_SIZE(_dfu_status_lookup),
+  .items = _dfu_status_lookup
+};
+
+#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)
+{
+  _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();
+}
+
+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);
+
+  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) )
+  {
+    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;
+
+    drv_len += tu_desc_len(p_desc);
+    p_desc   = tu_desc_next(p_desc);
+  }
+
+  return drv_len;
+}
+
+// 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 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)
+  {
+    // 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 )
+    {
+      tud_control_status(rhport, request);
+      return true;
+    }
+  }
+
+  // Handle class request only from here
+  TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
+
+  switch (request->bRequest)
+  {
+    case DFU_REQUEST_DNLOAD:
+    {
+      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);
+  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
+
+  // 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;
+  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:
+        {
+          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 {
+            _dfu_state_ctx.state = DFU_ERROR;
+          }
+        }
+        break;
+
+        case DFU_REQUEST_UPLOAD:
+        {
+          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
+              }
+            }
+          }
+          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:
+          {
+            _dfu_state_ctx.state = DFU_ERROR;
+            return false;  // stall on all other requests
+          }
+          break;
+        }
+    }
+    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
+  }
+
+  return true;
+}
+
+
+#endif
diff --git a/src/class/dfu/dfu_device.h b/src/class/dfu/dfu_device.h
new file mode 100644
index 000000000..c45c436c5
--- /dev/null
+++ b/src/class/dfu/dfu_device.h
@@ -0,0 +1,84 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 XMOS LIMITED
+ *
+ * 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.
+ */
+
+#ifndef _TUSB_DFU_DEVICE_H_
+#define _TUSB_DFU_DEVICE_H_
+
+#include "common/tusb_common.h"
+#include "device/usbd.h"
+#include "dfu.h"
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+
+//--------------------------------------------------------------------+
+// 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);
+
+// 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 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 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);
+
+//--------------------------------------------------------------------+
+// Internal Class Driver API
+//--------------------------------------------------------------------+
+void     dfu_moded_init(void);
+void     dfu_moded_reset(uint8_t rhport);
+uint16_t dfu_moded_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+bool     dfu_moded_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
+
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* _TUSB_DFU_MODE_DEVICE_H_ */
diff --git a/src/class/dfu/dfu_rt_device.c b/src/class/dfu/dfu_rt_device.c
index 5700615be..faeae9b68 100644
--- a/src/class/dfu/dfu_rt_device.c
+++ b/src/class/dfu/dfu_rt_device.c
@@ -34,23 +34,10 @@
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
-typedef enum {
-  DFU_REQUEST_DETACH      = 0,
-  DFU_REQUEST_DNLOAD      = 1,
-  DFU_REQUEST_UPLOAD      = 2,
-  DFU_REQUEST_GETSTATUS   = 3,
-  DFU_REQUEST_CLRSTATUS   = 4,
-  DFU_REQUEST_GETSTATE    = 5,
-  DFU_REQUEST_ABORT       = 6,
-} dfu_requests_t;
 
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t status;
-  uint8_t poll_timeout[3];
-  uint8_t state;
-  uint8_t istring;
-} dfu_status_t;
+//--------------------------------------------------------------------+
+// INTERNAL OBJECT & FUNCTION DECLARATION
+//--------------------------------------------------------------------+
 
 //--------------------------------------------------------------------+
 // USBD Driver API
@@ -61,7 +48,7 @@ void dfu_rtd_init(void)
 
 void dfu_rtd_reset(uint8_t rhport)
 {
-  (void) rhport;
+    (void) rhport;
 }
 
 uint16_t dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len)
@@ -70,8 +57,8 @@ uint16_t dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, ui
   (void) max_len;
 
   // Ensure this is DFU Runtime
-  TU_VERIFY(itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS &&
-            itf_desc->bInterfaceProtocol == DFU_PROTOCOL_RT, 0);
+  TU_VERIFY((itf_desc->bInterfaceSubClass == TUD_DFU_APP_SUBCLASS) &&
+            (itf_desc->bInterfaceProtocol == DFU_PROTOCOL_RT), 0);
 
   uint8_t const * p_desc = tu_desc_next( itf_desc );
   uint16_t drv_len = sizeof(tusb_desc_interface_t);
@@ -90,7 +77,7 @@ uint16_t dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, ui
 // return false to stall control endpoint (e.g unsupported request)
 bool dfu_rtd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
 {
-  // nothing to do with DATA and ACK stage
+  // nothing to do with DATA or ACK stage
   if ( stage != CONTROL_STAGE_SETUP ) return true;
 
   TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
@@ -106,34 +93,34 @@ bool dfu_rtd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
   // Handle class request only from here
   TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
 
-  switch ( request->bRequest )
+  switch (request->bRequest)
   {
     case DFU_REQUEST_DETACH:
+    {
+      TU_LOG2("  DFU RT Request: DETACH\r\n");
       tud_control_status(rhport, request);
       tud_dfu_runtime_reboot_to_dfu_cb();
+    }
     break;
 
     case DFU_REQUEST_GETSTATUS:
     {
-      // status = OK, poll timeout = 0, state = app idle, istring = 0
-      uint8_t status_response[6] = { 0, 0, 0, 0, 0, 0 };
-      tud_control_xfer(rhport, request, status_response, sizeof(status_response));
+      TU_LOG2("  DFU RT Request: GETSTATUS\r\n");
+      dfu_status_req_payload_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));
     }
     break;
 
-    default: return false; // stall unsupported request
+    default:
+    {
+      TU_LOG2("  DFU RT Unexpected Request: %d\r\n", request->bRequest);
+      return false; // stall unsupported request
+    }
   }
 
   return true;
 }
 
-bool dfu_rtd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
-{
-  (void) rhport;
-  (void) ep_addr;
-  (void) result;
-  (void) xferred_bytes;
-  return true;
-}
-
 #endif
diff --git a/src/class/dfu/dfu_rt_device.h b/src/class/dfu/dfu_rt_device.h
index cff43d035..0e5fd005a 100644
--- a/src/class/dfu/dfu_rt_device.h
+++ b/src/class/dfu/dfu_rt_device.h
@@ -29,36 +29,17 @@
 
 #include "common/tusb_common.h"
 #include "device/usbd.h"
+#include "dfu.h"
 
 #ifdef __cplusplus
  extern "C" {
 #endif
 
-
-//--------------------------------------------------------------------+
-// Common Definitions
-//--------------------------------------------------------------------+
-
-// DFU Protocol
-typedef enum
-{
-  DFU_PROTOCOL_RT  = 1,
-  DFU_PROTOCOL_DFU = 2,
-} dfu_protocol_type_t;
-
-// DFU Descriptor Type
-typedef enum
-{
-  DFU_DESC_FUNCTIONAL = 0x21,
-} dfu_descriptor_type_t;
-
-
 //--------------------------------------------------------------------+
 // Application Callback API (weak is optional)
 //--------------------------------------------------------------------+
-
-// Invoked when received new data
-TU_ATTR_WEAK void tud_dfu_runtime_reboot_to_dfu_cb(void);
+// Invoked when a DFU_DETACH request is received and bitWillDetach is set
+void tud_dfu_runtime_reboot_to_dfu_cb(void);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
@@ -67,7 +48,6 @@ void     dfu_rtd_init(void);
 void     dfu_rtd_reset(uint8_t rhport);
 uint16_t dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
 bool     dfu_rtd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
-bool     dfu_rtd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 
 #ifdef __cplusplus
  }
diff --git a/src/class/vendor/vendor_device.c b/src/class/vendor/vendor_device.c
index ef1f5d2fe..5fc7dd569 100644
--- a/src/class/vendor/vendor_device.c
+++ b/src/class/vendor/vendor_device.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * The MIT License (MIT)
  *
  * Copyright (c) 2019 Ha Thach (tinyusb.org)
diff --git a/src/common/tusb_common.h b/src/common/tusb_common.h
index 2cc12c6be..88e85c9e0 100644
--- a/src/common/tusb_common.h
+++ b/src/common/tusb_common.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * The MIT License (MIT)
  *
  * Copyright (c) 2019 Ha Thach (tinyusb.org)
diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index ba3fe2c41..7703ebb7b 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -421,6 +421,29 @@ typedef struct TU_ATTR_PACKED
   char    url[];
 } tusb_desc_webusb_url_t;
 
+// DFU Functional Descriptor
+typedef struct TU_ATTR_PACKED
+{
+  uint8_t  bLength;
+  uint8_t  bDescriptorType;
+
+  union {
+    struct TU_ATTR_PACKED {
+      uint8_t bitCanDnload             : 1;
+      uint8_t bitCanUpload             : 1;
+      uint8_t bitManifestationTolerant : 1;
+      uint8_t bitWillDetach            : 1;
+      uint8_t reserved                 : 4;
+    } bmAttributes;
+
+    uint8_t bAttributes;
+  };
+
+  uint16_t wDetachTimeOut;
+  uint16_t wTransferSize;
+  uint16_t bcdDFUVersion;
+} tusb_desc_dfu_functional_t;
+
 /*------------------------------------------------------------------*/
 /* Types
  *------------------------------------------------------------------*/
diff --git a/src/device/usbd.c b/src/device/usbd.c
index 2853b619b..863add2c5 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * The MIT License (MIT)
  *
  * Copyright (c) 2019 Ha Thach (tinyusb.org)
@@ -182,7 +182,19 @@ static usbd_class_driver_t const _usbd_driver[] =
     .reset            = dfu_rtd_reset,
     .open             = dfu_rtd_open,
     .control_xfer_cb  = dfu_rtd_control_xfer_cb,
-    .xfer_cb          = dfu_rtd_xfer_cb,
+    .xfer_cb          = NULL,
+    .sof              = NULL
+  },
+  #endif
+
+  #if CFG_TUD_DFU_MODE
+  {
+    DRIVER_NAME("DFU-MODE")
+    .init             = dfu_moded_init,
+    .reset            = dfu_moded_reset,
+    .open             = dfu_moded_open,
+    .control_xfer_cb  = dfu_moded_control_xfer_cb,
+    .xfer_cb          = NULL,
     .sof              = NULL
   },
   #endif
@@ -1318,9 +1330,9 @@ bool usbd_edpt_stalled(uint8_t rhport, uint8_t ep_addr)
 
 /**
  * usbd_edpt_close will disable an endpoint.
- * 
+ *
  * In progress transfers on this EP may be delivered after this call.
- * 
+ *
  */
 void usbd_edpt_close(uint8_t rhport, uint8_t ep_addr)
 {
diff --git a/src/device/usbd.h b/src/device/usbd.h
index 7c50a6db0..9e94d8d90 100644
--- a/src/device/usbd.h
+++ b/src/device/usbd.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * The MIT License (MIT)
  *
  * Copyright (c) 2019 Ha Thach (tinyusb.org)
@@ -583,7 +583,7 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
 
 //------------- DFU Runtime -------------//
 #define TUD_DFU_APP_CLASS    (TUSB_CLASS_APPLICATION_SPECIFIC)
-#define TUD_DFU_APP_SUBCLASS 0x01u
+#define TUD_DFU_APP_SUBCLASS (APP_SUBCLASS_DFU_RUNTIME)
 
 // Length of template descriptr: 18 bytes
 #define TUD_DFU_RT_DESC_LEN (9 + 9)
@@ -596,6 +596,17 @@ 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)
+
+// 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, \
+  /* Function */ \
+  9, DFU_DESC_FUNCTIONAL, _attr, U16_TO_U8S_LE(_timeout), U16_TO_U8S_LE(_xfer_size), U16_TO_U8S_LE(0x0101)
+
 
 //------------- CDC-ECM -------------//
 
diff --git a/src/device/usbd_control.c b/src/device/usbd_control.c
index d15380199..724c652e6 100644
--- a/src/device/usbd_control.c
+++ b/src/device/usbd_control.c
@@ -107,7 +107,7 @@ bool tud_control_xfer(uint8_t rhport, tusb_control_request_t const * request, vo
   _ctrl_xfer.buffer        = (uint8_t*) buffer;
   _ctrl_xfer.total_xferred = 0U;
   _ctrl_xfer.data_len      = tu_min16(len, request->wLength);
-  
+
   if (request->wLength > 0U)
   {
     if(_ctrl_xfer.data_len > 0U)
diff --git a/src/tusb.h b/src/tusb.h
index cc82c440d..56504550c 100644
--- a/src/tusb.h
+++ b/src/tusb.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * The MIT License (MIT)
  *
  * Copyright (c) 2019 Ha Thach (tinyusb.org)
@@ -96,6 +96,10 @@
     #include "class/dfu/dfu_rt_device.h"
   #endif
 
+  #if CFG_TUD_DFU_MODE
+    #include "class/dfu/dfu_device.h"
+  #endif
+
   #if CFG_TUD_NET
     #include "class/net/net_device.h"
   #endif
diff --git a/src/tusb_option.h b/src/tusb_option.h
index b59c7cb22..0b8c5c1d0 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -241,7 +241,15 @@
 #endif
 
 #ifndef CFG_TUD_DFU_RUNTIME
-  #define CFG_TUD_DFU_RUNTIME          0
+  #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
 #endif
 
 #ifndef CFG_TUD_NET