chentianya/GD32_Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加GD32H7的CMake工程

Browse Source
This commit is contained in:
chentianya
2026-07-23 19:44:30 +08:00
commit d07f065b1c
202 changed files with 204039 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Firmware/GD32H7xx_usbhs_library/device/class/dfu/Include/dfu_core.h
+174
View File
@@ -0,0 +1,174 @@
/*!
\file dfu_core.h
\brief the header file of USB DFU device class core functions
\version 2025-01-24, V1.4.0, firmware for GD32H7xx
*/
/*
Copyright (c) 2025, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
#ifndef DFU_CORE_H
#define DFU_CORE_H
#include "usbd_enum.h"
/* DFU class code */
#define USB_DFU_CLASS 0xFEU
/* DFU subclass code */
#define USB_DFU_SUBCLASS_UPGRADE 0x01U
/* DFU protocol code */
#define USB_DFU_PROTOCL_RUNTIME 0x01U /*!< runtime interface protocol */
#define USB_DFU_PROTOCL_DFU 0x02U /*!< DFU interface protocol */
/* manifestation state */
#define MANIFEST_COMPLETE 0x00U /*!< manifest complete state */
#define MANIFEST_IN_PROGRESS 0x01U /*!< manifest in progress state */
/* DFU attributes code */
#define USB_DFU_CAN_DOWNLOAD 0x01U /*!< download attribute */
#define USB_DFU_CAN_UPLOAD 0x02U /*!< upload attribute */
#define USB_DFU_MANIFEST_TOLERANT 0x04U /*!< manifest tolerant attribute */
#define USB_DFU_WILL_DETACH 0x08U /*!< detach attribute */
/* special commands with download request */
#define GET_COMMANDS 0x00U /*!< get command request */
#define SET_ADDRESS_POINTER 0x21U /*!< set address pointer request */
#define ERASE 0x41U /*!< erase request */
/* memory operation command */
#define CMD_ERASE 0U /*!< erase command */
#define CMD_WRITE 1U /*!< write command */
#define _BYTE1(x) (uint8_t)((x) & 0xFFU) /*!< addressing cycle 1st byte */
#define _BYTE2(x) (uint8_t)(((x) & 0xFF00U) >> 8) /*!< addressing cycle 2nd byte */
#define _BYTE3(x) (uint8_t)(((x) & 0xFF0000U) >> 16) /*!< addressing cycle 3rd byte */
#define FLASH_ERASE_TIMEOUT 60U /*!< erase flash timeout */
#define FLASH_WRITE_TIMEOUT 80U /*!< write flash timeout */
/* bit detach capable = bit 3 in bmAttributes field */
#define DFU_DETACH_MASK (uint8_t)(0x10U)
#define USB_SERIAL_STR_LEN 0x06U
#define USB_DFU_CONFIG_DESC_SIZE 27U
#define DFU_DESC_TYPE 0x21U
/* DFU device state defines */
typedef enum {
STATE_APP_IDLE = 0x00U, /*!< DFU APP idle state */
STATE_APP_DETACH, /*!< DFU APP detach state */
STATE_DFU_IDLE, /*!< idle state */
STATE_DFU_DNLOAD_SYNC, /*!< download synchronous state */
STATE_DFU_DNBUSY, /*!< download busy state */
STATE_DFU_DNLOAD_IDLE, /*!< download idle state */
STATE_DFU_MANIFEST_SYNC, /*!< manifest synchronous state */
STATE_DFU_MANIFEST, /*!< manifest state */
STATE_DFU_MANIFEST_WAIT_RESET, /*!< manifest wait reset state */
STATE_DFU_UPLOAD_IDLE, /*!< upload idle state */
STATE_DFU_ERROR /*!< DFU error state */
} dfu_state;
/* DFU device status defines */
typedef enum {
STATUS_OK = 0x00U, /*!< no error status */
STATUS_ERR_TARGET, /*!< trigger error status */
STATUS_ERR_FILE, /*!< file error status */
STATUS_ERR_WRITE, /*!< write error status */
STATUS_ERR_ERASE, /*!< erase error status */
STATUS_ERR_CHECK_ERASED, /*!< check erased error status */
STATUS_ERR_PROG, /*!< program error status */
STATUS_ERR_VERIFY, /*!< verify error status */
STATUS_ERR_ADDRESS, /*!< address error status */
STATUS_ERR_NOTDONE, /*!< not done error status */
STATUS_ERR_FIRMWARE, /*!< firmware error status */
STATUS_ERR_VENDOR, /*!< vendor error status */
STATUS_ERR_USBR, /*!< USB reset error status */
STATUS_ERR_POR, /*!< power error status */
STATUS_ERR_UNKNOWN, /*!< unknown error status */
STATUS_ERR_STALLEDPKT /*!< stalled pocket error status */
} dfu_status;
/* DFU class-specific requests */
typedef enum {
DFU_DETACH = 0U, /*!< detach request */
DFU_DNLOAD, /*!< download request */
DFU_UPLOAD, /*!< upload request */
DFU_GETSTATUS, /*!< get status request */
DFU_CLRSTATUS, /*!< clear status request */
DFU_GETSTATE, /*!< get state request */
DFU_ABORT, /*!< abort request */
DFU_REQ_MAX /*!< maximum request */
} dfu_requests;
#pragma pack(1)
/* USB DFU function descriptor structure */
typedef struct {
usb_desc_header header; /*!< descriptor header, including type and size */
uint8_t bmAttributes; /*!< DFU attributes */
uint16_t wDetachTimeOut; /*!< time, in milliseconds, that the device will wait after receipt of the DFU_DETACH request. If */
uint16_t wTransferSize; /*!< maximum number of bytes that the device can accept per control-write transaction */
uint16_t bcdDFUVersion; /*!< numeric expression identifying the version of the DFU Specification release. */
} usb_desc_dfu_func;
#pragma pack()
/* USB configuration descriptor structure */
typedef struct {
usb_desc_config config; /*!< configuration descriptor */
usb_desc_itf dfu_itf; /*!< DFU interface descriptor */
usb_desc_dfu_func dfu_func; /*!< DFU function descriptor */
} usb_dfu_desc_config_set;
/* USB DFU handler structure */
typedef struct {
uint8_t bStatus; /*!< DFU device current status */
uint8_t bwPollTimeout0; /*!< DFU device polling timeout 0 */
uint8_t bwPollTimeout1; /*!< DFU device polling timeout 1 */
uint8_t bwPollTimeout2; /*!< DFU device polling timeout 2 */
uint8_t bState; /*!< DFU device current state */
uint8_t iString; /*!< DFU device string */
uint8_t manifest_state; /*!< DFU device current manifest state */
uint32_t data_len; /*!< DFU device data transfer length */
uint16_t block_num; /*!< memory block number */
uint32_t base_addr; /*!< memory base address */
uint8_t buf[TRANSFER_SIZE]; /*!< data transfer buff */
} usbd_dfu_handler;
typedef void (*app_func)(void);
extern usb_desc dfu_desc;
extern usb_class_core dfu_class;
#endif /* DFU_CORE_H */
Firmware/GD32H7xx_usbhs_library/device/class/dfu/Include/dfu_mem.h
+83
View File
@@ -0,0 +1,83 @@
/*!
\file dfu_mal.h
\brief USB DFU device media access layer header file
\version 2025-01-24, V1.4.0, firmware for GD32H7xx
*/
/*
Copyright (c) 2025, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
#ifndef DFU_MEM_H
#define DFU_MEM_H
#include "usbd_conf.h"
#define _1ST_BYTE(x) (uint8_t)((x) & 0xFFU) /*!< addressing cycle 1st byte */
#define _2ND_BYTE(x) (uint8_t)(((x) & 0xFF00U) >> 8) /*!< addressing cycle 2nd byte */
#define _3RD_BYTE(x) (uint8_t)(((x) & 0xFF0000U) >> 16) /*!< addressing cycle 3rd byte */
#define POLLING_TIMEOUT_SET(x) buffer[0] = _1ST_BYTE(x); \
buffer[1] = _2ND_BYTE(x); \
buffer[2] = _3RD_BYTE(x);
/* USB DFU property structure */
typedef struct _dfu_mem_prop {
const uint8_t* pstr_desc; /*!< string descriptor pointer */
uint8_t (*mem_init)(void);
uint8_t (*mem_deinit)(void);
uint8_t (*mem_erase)(uint32_t addr);
uint8_t (*mem_write)(uint8_t *buf, uint32_t addr, uint32_t len);
uint8_t *(*mem_read)(uint8_t *buf, uint32_t addr, uint32_t len);
uint8_t (*mem_checkaddr)(uint32_t addr);
const uint32_t erase_timeout; /*!< memory erase timeout */
const uint32_t write_timeout; /*!< memory write timeout */
} dfu_mem_prop;
/* memory status */
typedef enum {
MEM_OK = 0U, /*!< memory OK status */
MEM_FAIL /*!< memory fail status */
} mem_status;
/* function declarations */
/* initialize the memory media */
uint8_t dfu_mem_init(void);
/* deinitialize the memory media */
uint8_t dfu_mem_deinit(void);
/* erase a memory sector */
uint8_t dfu_mem_erase(uint32_t addr);
/* write data to sectors of memory */
uint8_t dfu_mem_write(uint8_t *buf, uint32_t addr, uint32_t len);
/* read data from sectors of memory */
uint8_t* dfu_mem_read(uint8_t *buf, uint32_t addr, uint32_t len);
/* get the status of a given memory and store in buffer */
uint8_t dfu_mem_getstatus(uint32_t addr, uint8_t cmd, uint8_t *buffer);
#endif /* DFU_MEM_H */
Firmware/GD32H7xx_usbhs_library/device/class/dfu/Source/dfu_core.c
+642
View File
@@ -0,0 +1,642 @@
/*!
\file dfu_core.c
\brief USB DFU device class core functions
\version 2025-01-24, V1.4.0, firmware for GD32H7xx
*/
/*
Copyright (c) 2025, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
#include "dfu_core.h"
#include "dfu_mem.h"
#include "drv_usb_hw.h"
#include <string.h>
#define USBD_VID 0x28E9U
#define USBD_PID 0x0189U
/* local function prototypes ('static') */
static uint8_t dfu_init(usb_dev *udev, uint8_t config_index);
static uint8_t dfu_deinit(usb_dev *udev, uint8_t config_index);
static uint8_t dfu_req_handler(usb_dev *udev, usb_req *req);
static uint8_t dfu_ctlx_in(usb_dev *udev);
static void dfu_detach(usb_dev *udev, usb_req *req);
static void dfu_dnload(usb_dev *udev, usb_req *req);
static void dfu_upload(usb_dev *udev, usb_req *req);
static void dfu_getstatus(usb_dev *udev, usb_req *req);
static void dfu_clrstatus(usb_dev *udev, usb_req *req);
static void dfu_getstate(usb_dev *udev, usb_req *req);
static void dfu_abort(usb_dev *udev, usb_req *req);
static void dfu_mode_leave(usb_dev *udev);
static uint8_t dfu_getstatus_complete(usb_dev *udev);
static void (*dfu_request_process[])(usb_dev *udev, usb_req *req) = {
[DFU_DETACH] = dfu_detach,
[DFU_DNLOAD] = dfu_dnload,
[DFU_UPLOAD] = dfu_upload,
[DFU_GETSTATUS] = dfu_getstatus,
[DFU_CLRSTATUS] = dfu_clrstatus,
[DFU_GETSTATE] = dfu_getstate,
[DFU_ABORT] = dfu_abort
};
/* note:it should use the c99 standard when compiling the below codes */
/* USB standard device descriptor */
const __ALIGN_BEGIN usb_desc_dev dfu_dev_desc __ALIGN_END = {
.header =
{
.bLength = USB_DEV_DESC_LEN,
.bDescriptorType = USB_DESCTYPE_DEV
},
.bcdUSB = 0x0200U,
.bDeviceClass = 0x00U,
.bDeviceSubClass = 0x00U,
.bDeviceProtocol = 0x00U,
.bMaxPacketSize0 = USB_FS_EP0_MAX_LEN,
.idVendor = USBD_VID,
.idProduct = USBD_PID,
.bcdDevice = 0x0100U,
.iManufacturer = STR_IDX_MFC,
.iProduct = STR_IDX_PRODUCT,
.iSerialNumber = STR_IDX_SERIAL,
.bNumberConfigurations = USBD_CFG_MAX_NUM
};
/* USB device configuration descriptor */
const __ALIGN_BEGIN usb_dfu_desc_config_set dfu_config_desc __ALIGN_END = {
.config =
{
.header =
{
.bLength = sizeof(usb_desc_config),
.bDescriptorType = USB_DESCTYPE_CONFIG
},
.wTotalLength = USB_DFU_CONFIG_DESC_SIZE,
.bNumInterfaces = 0x01U,
.bConfigurationValue = 0x01U,
.iConfiguration = 0x00U,
.bmAttributes = 0x80U,
.bMaxPower = 0x32U
},
.dfu_itf =
{
.header =
{
.bLength = sizeof(usb_desc_itf),
.bDescriptorType = USB_DESCTYPE_ITF
},
.bInterfaceNumber = 0x00U,
.bAlternateSetting = 0x00U,
.bNumEndpoints = 0x00U,
.bInterfaceClass = USB_DFU_CLASS,
.bInterfaceSubClass = USB_DFU_SUBCLASS_UPGRADE,
.bInterfaceProtocol = USB_DFU_PROTOCL_DFU,
.iInterface = 0x05U
},
.dfu_func =
{
.header =
{
.bLength = sizeof(usb_desc_dfu_func),
.bDescriptorType = DFU_DESC_TYPE
},
.bmAttributes = USB_DFU_CAN_DOWNLOAD | USB_DFU_CAN_UPLOAD | USB_DFU_WILL_DETACH,
.wDetachTimeOut = 0x00FFU,
.wTransferSize = TRANSFER_SIZE,
.bcdDFUVersion = 0x011AU,
},
};
/* USB language ID Descriptor */
static const __ALIGN_BEGIN usb_desc_LANGID usbd_language_id_desc __ALIGN_END = {
.header = {
.bLength = sizeof(usb_desc_LANGID),
.bDescriptorType = USB_DESCTYPE_STR
},
.wLANGID = ENG_LANGID
};
/* USB manufacture string */
static const __ALIGN_BEGIN usb_desc_str manufacturer_string __ALIGN_END = {
.header =
{
.bLength = USB_STRING_LEN(10U),
.bDescriptorType = USB_DESCTYPE_STR,
},
.unicode_string = {'G', 'i', 'g', 'a', 'D', 'e', 'v', 'i', 'c', 'e'}
};
/* USB product string */
static const __ALIGN_BEGIN usb_desc_str product_string __ALIGN_END = {
.header =
{
.bLength = USB_STRING_LEN(12U),
.bDescriptorType = USB_DESCTYPE_STR,
},
.unicode_string = {'G', 'D', '3', '2', '-', 'U', 'S', 'B', '_', 'D', 'F', 'U'}
};
/* USBD serial string */
static __ALIGN_BEGIN usb_desc_str serial_string __ALIGN_END = {
.header =
{
.bLength = USB_STRING_LEN(2U),
.bDescriptorType = USB_DESCTYPE_STR,
}
};
/* USB configure string */
static const __ALIGN_BEGIN usb_desc_str config_string __ALIGN_END = {
.header =
{
.bLength = USB_STRING_LEN(15U),
.bDescriptorType = USB_DESCTYPE_STR,
},
.unicode_string = {'G', 'D', '3', '2', ' ', 'U', 'S', 'B', ' ', 'C', 'O', 'N', 'F', 'I', 'G'}
};
static const __ALIGN_BEGIN usb_desc_str interface_string __ALIGN_END = {
.header =
{
.bLength = USB_STRING_LEN(44U),
.bDescriptorType = USB_DESCTYPE_STR,
},
.unicode_string = {'@', 'I', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'F', 'l', 'a', 's', 'h', ' ', '/', '0', 'x', '0', '8', '0', '0',
'0', '0', '0', '0', '/', '1', '6', '*', '0', '0', '1', 'K', 'a', ',', '4', '8', '*', '0', '0', '1', 'K', 'g'
}
};
void *const usbd_dfu_strings[] = {
[STR_IDX_LANGID] = (uint8_t *)&usbd_language_id_desc,
[STR_IDX_MFC] = (uint8_t *)&manufacturer_string,
[STR_IDX_PRODUCT] = (uint8_t *)&product_string,
[STR_IDX_SERIAL] = (uint8_t *)&serial_string,
[STR_IDX_CONFIG] = (uint8_t *)&config_string,
[STR_IDX_ITF] = (uint8_t *)&interface_string
};
usb_desc dfu_desc = {
.dev_desc = (uint8_t *)&dfu_dev_desc,
.config_desc = (uint8_t *)&dfu_config_desc,
.strings = usbd_dfu_strings
};
usb_class_core dfu_class = {
.init = dfu_init,
.deinit = dfu_deinit,
.req_proc = dfu_req_handler,
.ctlx_in = dfu_ctlx_in
};
/*!
\brief initialize the DFU device
\param[in] udev: pointer to USB device instance
\param[in] config_index: configuration index
\param[out] none
\retval USB device operation status
*/
static uint8_t dfu_init(usb_dev *udev, uint8_t config_index)
{
static usbd_dfu_handler dfu_handler;
/* unlock the internal flash */
dfu_mem_init();
memset((void *)&dfu_handler, 0U, sizeof(usbd_dfu_handler));
dfu_handler.base_addr = APP_LOADED_ADDR;
dfu_handler.manifest_state = MANIFEST_COMPLETE;
dfu_handler.bState = STATE_DFU_IDLE;
dfu_handler.bStatus = STATUS_OK;
udev->dev.class_data[USBD_DFU_INTERFACE] = (void *)&dfu_handler;
return USBD_OK;
}
/*!
\brief de-initialize the DFU device
\param[in] udev: pointer to USB device instance
\param[in] config_index: configuration index
\param[out] none
\retval USB device operation status
*/
static uint8_t dfu_deinit(usb_dev *udev, uint8_t config_index)
{
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
/* restore device default state */
memset(udev->dev.class_data[USBD_DFU_INTERFACE], 0U, sizeof(usbd_dfu_handler));
dfu->bState = STATE_DFU_IDLE;
dfu->bStatus = STATUS_OK;
/* deinit the memory */
dfu_mem_deinit();
return USBD_OK;
}
/*!
\brief handle the DFU class-specific requests
\param[in] udev: pointer to USB device instance
\param[in] req: device class-specific request
\param[out] none
\retval USB device operation status
*/
static uint8_t dfu_req_handler(usb_dev *udev, usb_req *req)
{
if(req->bRequest < DFU_REQ_MAX) {
dfu_request_process[req->bRequest](udev, req);
} else {
return USBD_FAIL;
}
return USBD_OK;
}
/*!
\brief handle data stage
\param[in] udev: pointer to USB device instance
\param[out] none
\retval USB device operation status
*/
static uint8_t dfu_ctlx_in(usb_dev *udev)
{
dfu_getstatus_complete(udev);
return USBD_OK;
}
/*!
\brief leave DFU mode and reset device to jump to user loaded code
\param[in] udev: pointer to USB device instance
\param[out] none
\retval none
*/
static void dfu_mode_leave(usb_dev *udev)
{
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
dfu->manifest_state = MANIFEST_COMPLETE;
if(dfu_config_desc.dfu_func.bmAttributes & 0x04U) {
dfu->bState = STATE_DFU_MANIFEST_SYNC;
} else {
dfu->bState = STATE_DFU_MANIFEST_WAIT_RESET;
/* deinit the memory */
dfu_mem_deinit();
/* generate system reset to allow jumping to the user code */
NVIC_SystemReset();
}
}
/*!
\brief handle data IN stage in control endpoint 0
\param[in] udev: pointer to USB device instance
\param[out] none
\retval USB device operation status
*/
static uint8_t dfu_getstatus_complete(usb_dev *udev)
{
uint32_t addr;
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
if(STATE_DFU_DNBUSY == dfu->bState) {
/* decode the special command */
if(0U == dfu->block_num) {
if(1U == dfu->data_len) {
if(GET_COMMANDS == dfu->buf[0]) {
/* no operation */
}
} else if(5U == dfu->data_len) {
if(SET_ADDRESS_POINTER == dfu->buf[0]) {
/* set flash operation address */
dfu->base_addr = *(uint32_t *)(dfu->buf + 1U);
} else if(ERASE == dfu->buf[0]) {
dfu->base_addr = *(uint32_t *)(dfu->buf + 1U);
dfu_mem_erase(dfu->base_addr);
} else {
/* no operation */
}
} else {
/* no operation */
}
} else if(dfu->block_num > 1U) { /* regular download command */
/* decode the required address */
addr = (dfu->block_num - 2U) * TRANSFER_SIZE + dfu->base_addr;
dfu_mem_write(dfu->buf, addr, dfu->data_len);
dfu->block_num = 0U;
} else {
/* no operation */
}
dfu->data_len = 0U;
/* update the device state and poll timeout */
dfu->bState = STATE_DFU_DNLOAD_SYNC;
return USBD_OK;
} else if(STATE_DFU_MANIFEST == dfu->bState) { /* manifestation in progress */
/* start leaving DFU mode */
dfu_mode_leave(udev);
} else {
/* no operation */
}
return USBD_OK;
}
/*!
\brief handle the DFU_DETACH request
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none.
*/
static void dfu_detach(usb_dev *udev, usb_req *req)
{
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
switch(dfu->bState) {
case STATE_DFU_IDLE:
case STATE_DFU_DNLOAD_SYNC:
case STATE_DFU_DNLOAD_IDLE:
case STATE_DFU_MANIFEST_SYNC:
case STATE_DFU_UPLOAD_IDLE:
dfu->bStatus = STATUS_OK;
dfu->bState = STATE_DFU_IDLE;
dfu->iString = 0U; /* iString */
dfu->block_num = 0U;
dfu->data_len = 0U;
break;
default:
break;
}
/* check the detach capability in the DFU functional descriptor */
if(dfu_config_desc.dfu_func.wDetachTimeOut & DFU_DETACH_MASK) {
usbd_disconnect(udev);
usbd_connect(udev);
} else {
/* wait for the period of time specified in detach request */
usb_mdelay(4U);
}
}
/*!
\brief handle the DFU_DNLOAD request
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none
*/
static void dfu_dnload(usb_dev *udev, usb_req *req)
{
usb_transc *transc = &udev->dev.transc_out[0];
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
switch(dfu->bState) {
case STATE_DFU_IDLE:
case STATE_DFU_DNLOAD_IDLE:
if(req->wLength > 0U) {
/* update the global length and block number */
dfu->block_num = req->wValue;
dfu->data_len = req->wLength;
dfu->bState = STATE_DFU_DNLOAD_SYNC;
transc->remain_len = dfu->data_len;
transc->xfer_buf = dfu->buf;
} else {
dfu->manifest_state = MANIFEST_IN_PROGRESS;
dfu->bState = STATE_DFU_MANIFEST_SYNC;
}
break;
default:
break;
}
}
/*!
\brief handles the DFU_UPLOAD request.
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none
*/
static void dfu_upload(usb_dev *udev, usb_req *req)
{
uint8_t *phy_addr = NULL;
uint32_t addr = 0U;
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
usb_transc *transc = &udev->dev.transc_in[0];
if(req->wLength <= 0U) {
dfu->bState = STATE_DFU_IDLE;
return;
}
switch(dfu->bState) {
case STATE_DFU_IDLE:
case STATE_DFU_UPLOAD_IDLE:
/* update the global length and block number */
dfu->block_num = req->wValue;
dfu->data_len = req->wLength;
/* DFU get command */
if(0U == dfu->block_num) {
/* update the state machine */
dfu->bState = (dfu->data_len > 3U) ? STATE_DFU_IDLE : STATE_DFU_UPLOAD_IDLE;
/* store the values of all supported commands */
dfu->buf[0] = GET_COMMANDS;
dfu->buf[1] = SET_ADDRESS_POINTER;
dfu->buf[2] = ERASE;
/* send the status data over EP0 */
transc->xfer_buf = &(dfu->buf[0]);
transc->remain_len = 3U;
} else if(dfu->block_num > 1U) {
dfu->bState = STATE_DFU_UPLOAD_IDLE;
/* change is accelerated */
addr = (dfu->block_num - 2U) * TRANSFER_SIZE + dfu->base_addr;
/* read the physical address where data are stored */
phy_addr = dfu_mem_read(dfu->buf, addr, dfu->data_len);
/* send the status data over EP0 */
transc->xfer_buf = phy_addr;
transc->remain_len = dfu->data_len;
} else {
dfu->bState = STATUS_ERR_STALLEDPKT;
}
break;
default:
dfu->data_len = 0U;
dfu->block_num = 0U;
break;
}
}
/*!
\brief handle the DFU_GETSTATUS request
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none
*/
static void dfu_getstatus(usb_dev *udev, usb_req *req)
{
usb_transc *transc = &udev->dev.transc_in[0];
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
switch(dfu->bState) {
case STATE_DFU_DNLOAD_SYNC:
if(0U != dfu->data_len) {
dfu->bState = STATE_DFU_DNBUSY;
if(0U == dfu->block_num) {
if(ERASE == dfu->buf[0]) {
dfu_mem_getstatus(dfu->base_addr, CMD_ERASE, (uint8_t *)&dfu->bwPollTimeout0);
} else {
dfu_mem_getstatus(dfu->base_addr, CMD_WRITE, (uint8_t *)&dfu->bwPollTimeout0);
}
}
} else {
dfu->bState = STATE_DFU_DNLOAD_IDLE;
}
break;
case STATE_DFU_MANIFEST_SYNC:
if(MANIFEST_IN_PROGRESS == dfu->manifest_state) {
dfu->bState = STATE_DFU_MANIFEST;
dfu->bwPollTimeout0 = 1U;
} else if((MANIFEST_COMPLETE == dfu->manifest_state) && \
(dfu_config_desc.dfu_func.bmAttributes & 0x04U)) {
dfu->bState = STATE_DFU_IDLE;
dfu->bwPollTimeout0 = 0U;
} else {
/* no operation */
}
break;
default:
break;
}
/* send the status data of DFU interface to host over EP0 */
transc->xfer_buf = (uint8_t *)&(dfu->bStatus);
transc->remain_len = 6U;
}
/*!
\brief handle the DFU_CLRSTATUS request
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none
*/
static void dfu_clrstatus(usb_dev *udev, usb_req *req)
{
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
if(STATE_DFU_ERROR == dfu->bState) {
dfu->bStatus = STATUS_OK;
dfu->bState = STATE_DFU_IDLE;
} else {
/* state error */
dfu->bStatus = STATUS_ERR_UNKNOWN;
dfu->bState = STATE_DFU_ERROR;
}
dfu->iString = 0U; /* iString: index = 0 */
}
/*!
\brief handle the DFU_GETSTATE request
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none
*/
static void dfu_getstate(usb_dev *udev, usb_req *req)
{
usb_transc *transc = &udev->dev.transc_in[0];
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
/* send the current state of the DFU interface to host */
transc->xfer_buf = &(dfu->bState);
transc->remain_len = 1U;
}
/*!
\brief handle the DFU_ABORT request
\param[in] udev: pointer to USB device instance
\param[in] req: DFU class request
\param[out] none
\retval none
*/
static void dfu_abort(usb_dev *udev, usb_req *req)
{
usbd_dfu_handler *dfu = (usbd_dfu_handler *)udev->dev.class_data[USBD_DFU_INTERFACE];
switch(dfu->bState) {
case STATE_DFU_IDLE:
case STATE_DFU_DNLOAD_SYNC:
case STATE_DFU_DNLOAD_IDLE:
case STATE_DFU_MANIFEST_SYNC:
case STATE_DFU_UPLOAD_IDLE:
dfu->bStatus = STATUS_OK;
dfu->bState = STATE_DFU_IDLE;
dfu->iString = 0U; /* iString: index = 0 */
dfu->block_num = 0U;
dfu->data_len = 0U;
break;
default:
break;
}
}
Firmware/GD32H7xx_usbhs_library/device/class/dfu/Source/dfu_mem.c
+216
View File
@@ -0,0 +1,216 @@
/*!
\file dfu_mal.c
\brief USB DFU device media access layer functions
\version 2025-01-24, V1.4.0, firmware for GD32H7xx
*/
/*
Copyright (c) 2025, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
#include "dfu_mem.h"
#include "flash_if.h"
#include <stdio.h>
extern struct {
uint8_t buf[TRANSFER_SIZE];
uint16_t data_len;
uint16_t block_num;
uint32_t base_addr;
} prog;
dfu_mem_prop *mem_tab[MAX_USED_MEMORY_MEDIA] = {
&dfu_flash_cb
};
/* The list of memory interface string descriptor pointers. This list
can be updated whenever a memory has to be added or removed */
const uint8_t *usbd_dfu_strdesc[MAX_USED_MEMORY_MEDIA] = {
(const uint8_t *)FLASH_IF_STRING
};
static uint8_t dfu_mem_checkaddr(uint32_t addr);
/*!
\brief initialize the memory media
\param[in] none
\param[out] none
\retval MEM_OK
*/
uint8_t dfu_mem_init(void)
{
uint32_t mem_index = 0U;
/* initialize all supported memory medias */
for(mem_index = 0U; mem_index < MAX_USED_MEMORY_MEDIA; mem_index++) {
/* check if the memory media exists */
if(NULL != mem_tab[mem_index]->mem_init) {
mem_tab[mem_index]->mem_init();
}
}
return MEM_OK;
}
/*!
\brief deinitialize the memory media
\param[in] none
\param[out] none
\retval MEM_OK
*/
uint8_t dfu_mem_deinit(void)
{
uint32_t mem_index = 0U;
/* deinitialize all supported memory medias */
for(mem_index = 0U; mem_index < MAX_USED_MEMORY_MEDIA; mem_index++) {
/* check if the memory media exists */
if(NULL != mem_tab[mem_index]->mem_deinit) {
mem_tab[mem_index]->mem_deinit();
}
}
return MEM_OK;
}
/*!
\brief erase a memory sector
\param[in] addr: memory sector address/code
\param[out] none
\retval MEM_OK
*/
uint8_t dfu_mem_erase(uint32_t addr)
{
uint32_t mem_index = dfu_mem_checkaddr(addr);
if(mem_index < MAX_USED_MEMORY_MEDIA) {
/* check if the operation is supported */
if(NULL != mem_tab[mem_index]->mem_erase) {
return mem_tab[mem_index]->mem_erase(addr);
} else {
return MEM_FAIL;
}
} else {
return MEM_FAIL;
}
}
/*!
\brief write data to sectors of memory
\param[in] buf: the data buffer to be write
\param[in] addr: memory sector address/code
\param[in] len: data length
\param[out] none
\retval MEM_OK
*/
uint8_t dfu_mem_write(uint8_t *buf, uint32_t addr, uint32_t len)
{
uint32_t mem_index = dfu_mem_checkaddr(addr);
if (mem_index < MAX_USED_MEMORY_MEDIA) {
/* check if the operation is supported */
if(NULL != mem_tab[mem_index]->mem_write) {
return mem_tab[mem_index]->mem_write(buf, addr, len);
} else {
return MEM_FAIL;
}
} else {
return MEM_FAIL;
}
}
/*!
\brief read data from sectors of memory
\param[in] buf: the data buffer to be write
\param[in] addr: memory sector address/code
\param[in] len: data length
\param[out] none
\retval pointer to buffer
*/
uint8_t *dfu_mem_read(uint8_t *buf, uint32_t addr, uint32_t len)
{
uint32_t mem_index = 0U;
if(mem_index < MAX_USED_MEMORY_MEDIA) {
/* check if the operation is supported */
if(NULL != mem_tab[mem_index]->mem_read) {
return mem_tab[mem_index]->mem_read(buf, addr, len);
} else {
return buf;
}
} else {
return buf;
}
}
/*!
\brief get the status of a given memory and store in buffer
\param[in] addr: memory sector address/code
\param[in] cmd: 0 for erase and 1 for write
\param[in] buffer: pointer to the buffer where the status data will be stored
\param[out] none
\retval MEM_OK if all operations are OK, MEM_FAIL else
*/
uint8_t dfu_mem_getstatus(uint32_t addr, uint8_t cmd, uint8_t *buffer)
{
uint32_t mem_index = dfu_mem_checkaddr(addr);
if(mem_index < MAX_USED_MEMORY_MEDIA) {
if(cmd & 0x01U) {
POLLING_TIMEOUT_SET(mem_tab[mem_index]->write_timeout);
} else {
POLLING_TIMEOUT_SET(mem_tab[mem_index]->erase_timeout);
}
return MEM_OK;
} else {
return MEM_FAIL;
}
}
/*!
\brief check the address is supported
\param[in] addr: memory sector address/code
\param[out] none
\retval index of the addressed memory
*/
static uint8_t dfu_mem_checkaddr(uint32_t addr)
{
uint8_t mem_index = 0U;
/* check with all supported memories */
for(mem_index = 0U; mem_index < MAX_USED_MEMORY_MEDIA; mem_index++) {
/* if the check address is supported, return the memory index */
if(MEM_OK == mem_tab[mem_index]->mem_checkaddr(addr)) {
return mem_index;
}
}
/* if there is no memory found, return MAX_USED_MEMORY_MEDIA */
return (MAX_USED_MEMORY_MEDIA);
}