|
|
@@ -1,465 +1,313 @@
|
|
|
/*
|
|
|
- * Copyright (c) 2022, sakumisu
|
|
|
+ * Copyright (c) 2022 ~ 2026, sakumisu
|
|
|
*
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
|
*/
|
|
|
#include "usbd_core.h"
|
|
|
#include "usbd_dfu.h"
|
|
|
|
|
|
-/** Modify the following three parameters according to different platforms */
|
|
|
-#ifndef USBD_DFU_XFER_SIZE
|
|
|
-#define USBD_DFU_XFER_SIZE 1024
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef USBD_DFU_APP_DEFAULT_ADD
|
|
|
-#define USBD_DFU_APP_DEFAULT_ADD 0x8004000
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef FLASH_PROGRAM_TIME
|
|
|
-#define FLASH_PROGRAM_TIME 50
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef FLASH_ERASE_TIME
|
|
|
-#define FLASH_ERASE_TIME 50
|
|
|
-#endif
|
|
|
-
|
|
|
struct usbd_dfu_priv {
|
|
|
- struct dfu_info info;
|
|
|
- union {
|
|
|
- uint32_t d32[USBD_DFU_XFER_SIZE / 4U];
|
|
|
- uint8_t d8[USBD_DFU_XFER_SIZE];
|
|
|
- } buffer;
|
|
|
-
|
|
|
- uint32_t wblock_num;
|
|
|
- uint32_t wlength;
|
|
|
- uint32_t data_ptr;
|
|
|
- uint32_t alt_setting;
|
|
|
-
|
|
|
- uint8_t dev_status[6];
|
|
|
- uint8_t ReservedForAlign[2];
|
|
|
- uint8_t dev_state;
|
|
|
- uint8_t manif_state;
|
|
|
- uint8_t firmwar_flag;
|
|
|
+ uint8_t dfu_state;
|
|
|
} g_usbd_dfu;
|
|
|
|
|
|
-static void dfu_reset(void)
|
|
|
-{
|
|
|
- memset(&g_usbd_dfu, 0, sizeof(g_usbd_dfu));
|
|
|
-
|
|
|
- g_usbd_dfu.alt_setting = 0U;
|
|
|
- g_usbd_dfu.data_ptr = USBD_DFU_APP_DEFAULT_ADD;
|
|
|
- g_usbd_dfu.wblock_num = 0U;
|
|
|
- g_usbd_dfu.wlength = 0U;
|
|
|
-
|
|
|
- g_usbd_dfu.manif_state = DFU_MANIFEST_COMPLETE;
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[0] = DFU_STATUS_OK;
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = DFU_STATE_DFU_IDLE;
|
|
|
- g_usbd_dfu.dev_status[5] = 0U;
|
|
|
-}
|
|
|
-
|
|
|
-static uint16_t dfu_getstatus(uint32_t add, uint8_t cmd, uint8_t *buffer)
|
|
|
-{
|
|
|
- switch (cmd) {
|
|
|
- case DFU_MEDIA_PROGRAM:
|
|
|
- buffer[1] = (uint8_t)FLASH_PROGRAM_TIME;
|
|
|
- buffer[2] = (uint8_t)(FLASH_PROGRAM_TIME << 8);
|
|
|
- buffer[3] = 0;
|
|
|
- break;
|
|
|
-
|
|
|
- case DFU_MEDIA_ERASE:
|
|
|
- buffer[1] = (uint8_t)FLASH_ERASE_TIME;
|
|
|
- buffer[2] = (uint8_t)(FLASH_ERASE_TIME << 8);
|
|
|
- buffer[3] = 0;
|
|
|
- default:
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
- return (0);
|
|
|
-}
|
|
|
+const char *usbd_dfu_state_string[] = {
|
|
|
+ "APP_IDLE",
|
|
|
+ "APP_DETACH",
|
|
|
+ "DFU_IDLE",
|
|
|
+ "DFU_DNLOAD_SYNC",
|
|
|
+ "DFU_DNLOAD_BUSY",
|
|
|
+ "DFU_DNLOAD_IDLE",
|
|
|
+ "DFU_MANIFEST_SYNC",
|
|
|
+ "DFU_MANIFEST",
|
|
|
+ "DFU_MANIFEST_WAIT_RESET",
|
|
|
+ "DFU_UPLOAD_IDLE",
|
|
|
+ "DFU_ERROR"
|
|
|
+};
|
|
|
|
|
|
-static void dfu_request_detach(void)
|
|
|
+static int dfu_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
|
|
|
{
|
|
|
- if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_SYNC) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_MANIFEST_SYNC) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) {
|
|
|
- /* Update the state machine */
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE;
|
|
|
- g_usbd_dfu.dev_status[0] = DFU_STATUS_OK;
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U; /*bwPollTimeout=0ms*/
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- g_usbd_dfu.dev_status[5] = 0U; /*iString*/
|
|
|
- g_usbd_dfu.wblock_num = 0U;
|
|
|
- g_usbd_dfu.wlength = 0U;
|
|
|
- }
|
|
|
-}
|
|
|
+ USB_LOG_DBG("DFU Class request: "
|
|
|
+ "bRequest 0x%02x\r\n",
|
|
|
+ setup->bRequest);
|
|
|
|
|
|
-static void dfu_request_upload(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
|
|
|
-{
|
|
|
- struct usb_setup_packet *req = setup;
|
|
|
- uint32_t addr;
|
|
|
- /* Data setup request */
|
|
|
- if (req->wLength > 0U) {
|
|
|
- if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) || (g_usbd_dfu.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) {
|
|
|
- /* Update the global length and block number */
|
|
|
- g_usbd_dfu.wblock_num = req->wValue;
|
|
|
- g_usbd_dfu.wlength = MIN(req->wLength, USBD_DFU_XFER_SIZE);
|
|
|
-
|
|
|
- /* DFU Get Command */
|
|
|
- if (g_usbd_dfu.wblock_num == 0U) {
|
|
|
- /* Update the state machine */
|
|
|
- g_usbd_dfu.dev_state = (g_usbd_dfu.wlength > 3U) ? DFU_STATE_DFU_IDLE : DFU_STATE_DFU_UPLOAD_IDLE;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
-
|
|
|
- /* Store the values of all supported commands */
|
|
|
- g_usbd_dfu.buffer.d8[0] = DFU_CMD_GETCOMMANDS;
|
|
|
- g_usbd_dfu.buffer.d8[1] = DFU_CMD_SETADDRESSPOINTER;
|
|
|
- g_usbd_dfu.buffer.d8[2] = DFU_CMD_ERASE;
|
|
|
-
|
|
|
- /* Send the status data over EP0 */
|
|
|
- memcpy(*data, g_usbd_dfu.buffer.d8, 3);
|
|
|
- *len = 3;
|
|
|
- } else if (g_usbd_dfu.wblock_num > 1U) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_UPLOAD_IDLE;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
-
|
|
|
- addr = ((g_usbd_dfu.wblock_num - 2U) * USBD_DFU_XFER_SIZE) + g_usbd_dfu.data_ptr;
|
|
|
-
|
|
|
- /* Return the physical address where data are stored */
|
|
|
- dfu_read_flash((uint8_t *)addr, g_usbd_dfu.buffer.d8, g_usbd_dfu.wlength);
|
|
|
-
|
|
|
- /* Send the status data over EP0 */
|
|
|
- memcpy(*data, g_usbd_dfu.buffer.d8, g_usbd_dfu.wlength);
|
|
|
- *len = g_usbd_dfu.wlength;
|
|
|
- } else /* unsupported g_usbd_dfu.wblock_num */
|
|
|
- {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATUS_ERR_STALLEDPKT;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
-
|
|
|
- /* Call the error management function (command will be NAKed */
|
|
|
- USB_LOG_ERR("Dfu_request_upload unsupported g_usbd_dfu.wblock_num\r\n");
|
|
|
+ USB_LOG_DBG("dfu state:%s\r\n", usbd_dfu_state_string[g_usbd_dfu.dfu_state]);
|
|
|
+
|
|
|
+ switch (g_usbd_dfu.dfu_state) {
|
|
|
+ case DFU_STATE_APP_IDLE:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_DETACH:
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
}
|
|
|
- }
|
|
|
- /* Unsupported state */
|
|
|
- else {
|
|
|
- g_usbd_dfu.wlength = 0U;
|
|
|
- g_usbd_dfu.wblock_num = 0U;
|
|
|
-
|
|
|
- /* Call the error management function (command will be NAKed */
|
|
|
- USB_LOG_ERR("Dfu_request_upload unsupported state\r\n");
|
|
|
- }
|
|
|
- }
|
|
|
- /* No Data setup request */
|
|
|
- else {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static void dfu_request_dnload(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
|
|
|
-{
|
|
|
- /* Data setup request */
|
|
|
- struct usb_setup_packet *req = setup;
|
|
|
- if (req->wLength > 0U) {
|
|
|
- if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) || (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE)) {
|
|
|
- /* Update the global length and block number */
|
|
|
- g_usbd_dfu.wblock_num = req->wValue;
|
|
|
- g_usbd_dfu.wlength = MIN(req->wLength, USBD_DFU_XFER_SIZE);
|
|
|
-
|
|
|
- /* Update the state machine */
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_SYNC;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
-
|
|
|
- /*!< Data has received complete */
|
|
|
- memcpy((uint8_t *)g_usbd_dfu.buffer.d8, (uint8_t *)*data, g_usbd_dfu.wlength);
|
|
|
- /*!< Set flag = 1 Write the firmware to the flash in the next dfu_request_getstatus */
|
|
|
- g_usbd_dfu.firmwar_flag = 1;
|
|
|
- }
|
|
|
- /* Unsupported state */
|
|
|
- else {
|
|
|
- USB_LOG_ERR("Dfu_request_dnload unsupported state\r\n");
|
|
|
- }
|
|
|
- }
|
|
|
- /* 0 Data DNLOAD request */
|
|
|
- else {
|
|
|
- /* End of DNLOAD operation*/
|
|
|
- if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || (g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE)) {
|
|
|
- g_usbd_dfu.manif_state = DFU_MANIFEST_IN_PROGRESS;
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST_SYNC;
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- } else {
|
|
|
- /* Call the error management function (command will be NAKed */
|
|
|
- USB_LOG_ERR("Dfu_request_dnload End of DNLOAD operation but dev_state %02x \r\n", g_usbd_dfu.dev_state);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static int8_t dfu_getstatus_special_handler(void)
|
|
|
-{
|
|
|
- uint32_t addr;
|
|
|
- if (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_BUSY) {
|
|
|
- /* Decode the Special Command */
|
|
|
- if (g_usbd_dfu.wblock_num == 0U) {
|
|
|
- if (g_usbd_dfu.wlength == 1U) {
|
|
|
- if (g_usbd_dfu.buffer.d8[0] == DFU_CMD_GETCOMMANDS) {
|
|
|
- /* Nothing to do */
|
|
|
- }
|
|
|
- } else if (g_usbd_dfu.wlength == 5U) {
|
|
|
- if (g_usbd_dfu.buffer.d8[0] == DFU_CMD_SETADDRESSPOINTER) {
|
|
|
- g_usbd_dfu.data_ptr = g_usbd_dfu.buffer.d8[1];
|
|
|
- g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[2] << 8;
|
|
|
- g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[3] << 16;
|
|
|
- g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[4] << 24;
|
|
|
- } else if (g_usbd_dfu.buffer.d8[0] == DFU_CMD_ERASE) {
|
|
|
- g_usbd_dfu.data_ptr = g_usbd_dfu.buffer.d8[1];
|
|
|
- g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[2] << 8;
|
|
|
- g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[3] << 16;
|
|
|
- g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[4] << 24;
|
|
|
-
|
|
|
- USB_LOG_DBG("Erase start add %08x \r\n", g_usbd_dfu.data_ptr);
|
|
|
- /*!< Erase */
|
|
|
- dfu_erase_flash(g_usbd_dfu.data_ptr);
|
|
|
- } else {
|
|
|
+ break;
|
|
|
+ case DFU_STATE_APP_DETACH:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
return -1;
|
|
|
- }
|
|
|
- } else {
|
|
|
- /* Reset the global length and block number */
|
|
|
- g_usbd_dfu.wlength = 0U;
|
|
|
- g_usbd_dfu.wblock_num = 0U;
|
|
|
- /* Call the error management function (command will be NAKed) */
|
|
|
- USB_LOG_ERR("Reset the global length and block number\r\n");
|
|
|
}
|
|
|
- }
|
|
|
- /* Regular Download Command */
|
|
|
- else {
|
|
|
- if (g_usbd_dfu.wblock_num > 1U) {
|
|
|
- /* Decode the required address */
|
|
|
- addr = ((g_usbd_dfu.wblock_num - 2U) * USBD_DFU_XFER_SIZE) + g_usbd_dfu.data_ptr;
|
|
|
-
|
|
|
- /* Perform the write operation */
|
|
|
- /* Write flash */
|
|
|
- USB_LOG_DBG("Write start add %08x length %d\r\n", addr, g_usbd_dfu.wlength);
|
|
|
- dfu_write_flash(g_usbd_dfu.buffer.d8, (uint8_t *)addr, g_usbd_dfu.wlength);
|
|
|
+ break;
|
|
|
+ case DFU_STATE_DFU_IDLE:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_DNLOAD:
|
|
|
+ /* We received a DOWNLOAD command. Check the length field of the request. If it is 0,
|
|
|
+ we are done with the transfer. */
|
|
|
+ if (setup->wLength == 0) {
|
|
|
+ usbd_dfu_end_load();
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_MANIFEST_SYNC;
|
|
|
+ } else {
|
|
|
+ usbd_dfu_begin_load();
|
|
|
+ if (usbd_dfu_write(setup->wValue, *data, setup->wLength) < 0) {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_ERROR;
|
|
|
+ return -1;
|
|
|
+ } else {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_DNLOAD_SYNC;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_UPLOAD:
|
|
|
+ usbd_dfu_begin_load();
|
|
|
+
|
|
|
+ uint16_t actual_length;
|
|
|
+ if (usbd_dfu_read(setup->wValue, *data, setup->wLength, &actual_length) < 0) {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_ERROR;
|
|
|
+ return -1;
|
|
|
+ } else {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_UPLOAD_IDLE;
|
|
|
+ }
|
|
|
+ *len = actual_length;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_ABORT:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_IDLE;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- /* Reset the global length and block number */
|
|
|
- g_usbd_dfu.wlength = 0U;
|
|
|
- g_usbd_dfu.wblock_num = 0U;
|
|
|
-
|
|
|
- /* Update the state machine */
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_SYNC;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static void dfu_request_getstatus(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
|
|
|
-{
|
|
|
- /*!< Determine whether to leave DFU mode */
|
|
|
- if (g_usbd_dfu.manif_state == DFU_MANIFEST_IN_PROGRESS &&
|
|
|
- g_usbd_dfu.dev_state == DFU_STATE_DFU_MANIFEST_SYNC &&
|
|
|
- g_usbd_dfu.dev_status[1] == 0U &&
|
|
|
- g_usbd_dfu.dev_status[2] == 0U &&
|
|
|
- g_usbd_dfu.dev_status[3] == 0U &&
|
|
|
- g_usbd_dfu.dev_status[4] == g_usbd_dfu.dev_state) {
|
|
|
- g_usbd_dfu.manif_state = DFU_MANIFEST_COMPLETE;
|
|
|
-
|
|
|
- if ((0x0B & DFU_MANIFEST_MASK) != 0U) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST_SYNC;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- return;
|
|
|
- } else {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST_WAIT_RESET;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- /* Generate system reset to allow jumping to the user code */
|
|
|
- dfu_leave();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- switch (g_usbd_dfu.dev_state) {
|
|
|
+ break;
|
|
|
case DFU_STATE_DFU_DNLOAD_SYNC:
|
|
|
- if (g_usbd_dfu.wlength != 0U) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_BUSY;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
-
|
|
|
- if ((g_usbd_dfu.wblock_num == 0U) && (g_usbd_dfu.buffer.d8[0] == DFU_CMD_ERASE)) {
|
|
|
- dfu_getstatus(g_usbd_dfu.data_ptr, DFU_MEDIA_ERASE, g_usbd_dfu.dev_status);
|
|
|
- } else {
|
|
|
- dfu_getstatus(g_usbd_dfu.data_ptr, DFU_MEDIA_PROGRAM, g_usbd_dfu.dev_status);
|
|
|
- }
|
|
|
- } else /* (g_usbd_dfu.wlength==0)*/
|
|
|
- {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_IDLE;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_DNLOAD_BUSY;
|
|
|
+
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
}
|
|
|
break;
|
|
|
-
|
|
|
- case DFU_STATE_DFU_MANIFEST_SYNC:
|
|
|
- if (g_usbd_dfu.manif_state == DFU_MANIFEST_IN_PROGRESS) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 1U; /*bwPollTimeout = 1ms*/
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- } else {
|
|
|
- if ((g_usbd_dfu.manif_state == DFU_MANIFEST_COMPLETE) &&
|
|
|
- ((0x0B & DFU_MANIFEST_MASK) != 0U)) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE;
|
|
|
-
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U;
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- }
|
|
|
+ case DFU_STATE_DFU_DNLOAD_BUSY:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_DNLOAD_IDLE;
|
|
|
+
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
}
|
|
|
break;
|
|
|
-
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- /* Send the status data over EP0 */
|
|
|
- memcpy(*data, g_usbd_dfu.dev_status, 6);
|
|
|
- *len = 6;
|
|
|
-
|
|
|
- if (g_usbd_dfu.firmwar_flag == 1) {
|
|
|
- if (dfu_getstatus_special_handler() != 0) {
|
|
|
- USB_LOG_ERR("dfu_getstatus_special_handler error \r\n");
|
|
|
- }
|
|
|
- g_usbd_dfu.firmwar_flag = 0;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static void dfu_request_clrstatus(void)
|
|
|
-{
|
|
|
- if (g_usbd_dfu.dev_state == DFU_STATE_DFU_ERROR) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE;
|
|
|
- g_usbd_dfu.dev_status[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U; /* bwPollTimeout=0ms */
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* bState */
|
|
|
- g_usbd_dfu.dev_status[5] = 0U; /* iString */
|
|
|
- } else {
|
|
|
- /* State Error */
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_ERROR;
|
|
|
- g_usbd_dfu.dev_status[0] = DFU_STATUS_ERR_UNKNOWN; /* bStatus */
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U; /* bwPollTimeout=0ms */
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* bState */
|
|
|
- g_usbd_dfu.dev_status[5] = 0U; /* iString */
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static void dfu_request_getstate(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
|
|
|
-{
|
|
|
- /* Return the current state of the DFU interface */
|
|
|
- (*data)[0] = g_usbd_dfu.dev_state;
|
|
|
- *len = 1;
|
|
|
-}
|
|
|
-
|
|
|
-void dfu_request_abort(void)
|
|
|
-{
|
|
|
- if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_SYNC) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_MANIFEST_SYNC) ||
|
|
|
- (g_usbd_dfu.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) {
|
|
|
- g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE;
|
|
|
- g_usbd_dfu.dev_status[0] = DFU_STATUS_OK;
|
|
|
- g_usbd_dfu.dev_status[1] = 0U;
|
|
|
- g_usbd_dfu.dev_status[2] = 0U;
|
|
|
- g_usbd_dfu.dev_status[3] = 0U; /* bwPollTimeout=0ms */
|
|
|
- g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state;
|
|
|
- g_usbd_dfu.dev_status[5] = 0U; /* iString */
|
|
|
- g_usbd_dfu.wblock_num = 0U;
|
|
|
- g_usbd_dfu.wlength = 0U;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static int dfu_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
|
|
|
-{
|
|
|
- USB_LOG_DBG("DFU Class request: "
|
|
|
- "bRequest 0x%02x\r\n",
|
|
|
- setup->bRequest);
|
|
|
-
|
|
|
- switch (setup->bRequest) {
|
|
|
- case DFU_REQUEST_DETACH:
|
|
|
- dfu_request_detach();
|
|
|
- break;
|
|
|
- case DFU_REQUEST_DNLOAD:
|
|
|
- dfu_request_dnload(setup, data, len);
|
|
|
- break;
|
|
|
- case DFU_REQUEST_UPLOAD:
|
|
|
- dfu_request_upload(setup, data, len);
|
|
|
+ case DFU_STATE_DFU_DNLOAD_IDLE:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_DNLOAD:
|
|
|
+ /* We received a DOWNLOAD command. Check the length field of the request. If it is 0,
|
|
|
+ we are done with the transfer. */
|
|
|
+ if (setup->wLength == 0) {
|
|
|
+ usbd_dfu_end_load();
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_MANIFEST_SYNC;
|
|
|
+ } else {
|
|
|
+ if (usbd_dfu_write(setup->wValue, *data, setup->wLength) < 0) {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_ERROR;
|
|
|
+ return -1;
|
|
|
+ } else {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_DNLOAD_SYNC;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_ABORT:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_IDLE;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
break;
|
|
|
- case DFU_REQUEST_GETSTATUS:
|
|
|
- dfu_request_getstatus(setup, data, len);
|
|
|
+ case DFU_STATE_DFU_UPLOAD_IDLE:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_UPLOAD: {
|
|
|
+ uint16_t actual_length;
|
|
|
+ if (usbd_dfu_read(setup->wValue, *data, setup->wLength, &actual_length) < 0) {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_ERROR;
|
|
|
+ return -1;
|
|
|
+ } else {
|
|
|
+ if (actual_length < setup->wLength) {
|
|
|
+ usbd_dfu_end_load();
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_IDLE;
|
|
|
+ } else {
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_UPLOAD_IDLE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+ case DFU_REQUEST_ABORT:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_IDLE;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
break;
|
|
|
- case DFU_REQUEST_CLRSTATUS:
|
|
|
- dfu_request_clrstatus();
|
|
|
+ case DFU_STATE_DFU_MANIFEST_SYNC:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_MANIFEST_WAIT_RESET;
|
|
|
+
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
break;
|
|
|
- case DFU_REQUEST_GETSTATE:
|
|
|
- dfu_request_getstate(setup, data, len);
|
|
|
+ case DFU_STATE_DFU_MANIFEST_WAIT_RESET:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_GETSTATUS:
|
|
|
+
|
|
|
+ (*data)[0] = DFU_STATUS_OK; /* bStatus */
|
|
|
+ (*data)[1] = 0;
|
|
|
+ (*data)[2] = 0;
|
|
|
+ (*data)[3] = 0;
|
|
|
+ (*data)[4] = g_usbd_dfu.dfu_state;
|
|
|
+ (*data)[5] = 0; /* iString */
|
|
|
+ *len = 6;
|
|
|
+
|
|
|
+ usbd_dfu_reset();
|
|
|
+
|
|
|
+ break;
|
|
|
+ case DFU_REQUEST_GETSTATE:
|
|
|
+ (*data)[0] = g_usbd_dfu.dfu_state;
|
|
|
+ *len = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
break;
|
|
|
- case DFU_REQUEST_ABORT:
|
|
|
- dfu_request_abort();
|
|
|
+ case DFU_STATE_DFU_ERROR:
|
|
|
+ switch (setup->bRequest) {
|
|
|
+ case DFU_REQUEST_CLRSTATUS:
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_IDLE;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
break;
|
|
|
+
|
|
|
default:
|
|
|
- USB_LOG_WRN("Unhandled DFU Class bRequest 0x%02x\r\n", setup->bRequest);
|
|
|
+ USB_LOG_WRN("Invalid dfu state %s\r\n", usbd_dfu_state_string[g_usbd_dfu.dfu_state]);
|
|
|
return -1;
|
|
|
}
|
|
|
-
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
@@ -467,7 +315,7 @@ static void dfu_notify_handler(uint8_t busid, uint8_t event, void *arg)
|
|
|
{
|
|
|
switch (event) {
|
|
|
case USBD_EVENT_RESET:
|
|
|
- dfu_reset();
|
|
|
+ g_usbd_dfu.dfu_state = DFU_STATE_DFU_IDLE;
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
@@ -484,21 +332,29 @@ struct usbd_interface *usbd_dfu_init_intf(struct usbd_interface *intf)
|
|
|
return intf;
|
|
|
}
|
|
|
|
|
|
-__WEAK uint8_t *dfu_read_flash(uint8_t *src, uint8_t *dest, uint32_t len)
|
|
|
+uint8_t usbd_dfu_get_state(void)
|
|
|
{
|
|
|
- return dest;
|
|
|
+ return g_usbd_dfu.dfu_state;
|
|
|
}
|
|
|
|
|
|
-__WEAK uint16_t dfu_write_flash(uint8_t *src, uint8_t *dest, uint32_t len)
|
|
|
+__WEAK void usbd_dfu_begin_load(void)
|
|
|
{
|
|
|
- return 0;
|
|
|
}
|
|
|
|
|
|
-__WEAK uint16_t dfu_erase_flash(uint32_t add)
|
|
|
+__WEAK void usbd_dfu_end_load(void)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+__WEAK void usbd_dfu_reset(void)
|
|
|
{
|
|
|
- return 0;
|
|
|
}
|
|
|
|
|
|
-__WEAK void dfu_leave(void)
|
|
|
+__WEAK int usbd_dfu_write(uint16_t value, const uint8_t *data, uint16_t length)
|
|
|
{
|
|
|
+ return 0;
|
|
|
}
|
|
|
+
|
|
|
+__WEAK int usbd_dfu_read(uint16_t value, const uint8_t *data, uint16_t length, uint16_t *actual_length)
|
|
|
+{
|
|
|
+ return 0;
|
|
|
+}
|