plat/st/common/usb_dfu.c - trusted-firmware-a - Git at Google

 /*
  * Copyright (c) 2021, STMicroelectronics - All Rights Reserved
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */

 #include <errno.h>
 #include <string.h>

 #include <common/debug.h>

 #include <platform_def.h>
 #include <usb_dfu.h>

 /* Device states as defined in DFU spec */
 #define STATE_APP_IDLE			0
 #define STATE_APP_DETACH		1
 #define STATE_DFU_IDLE			2
 #define STATE_DFU_DNLOAD_SYNC		3
 #define STATE_DFU_DNLOAD_BUSY		4
 #define STATE_DFU_DNLOAD_IDLE		5
 #define STATE_DFU_MANIFEST_SYNC		6
 #define STATE_DFU_MANIFEST		7
 #define STATE_DFU_MANIFEST_WAIT_RESET	8
 #define STATE_DFU_UPLOAD_IDLE		9
 #define STATE_DFU_ERROR			10

 /* DFU errors */
 #define DFU_ERROR_NONE			0x00
 #define DFU_ERROR_TARGET		0x01
 #define DFU_ERROR_FILE			0x02
 #define DFU_ERROR_WRITE			0x03
 #define DFU_ERROR_ERASE			0x04
 #define DFU_ERROR_CHECK_ERASED		0x05
 #define DFU_ERROR_PROG			0x06
 #define DFU_ERROR_VERIFY		0x07
 #define DFU_ERROR_ADDRESS		0x08
 #define DFU_ERROR_NOTDONE		0x09
 #define DFU_ERROR_FIRMWARE		0x0A
 #define DFU_ERROR_VENDOR		0x0B
 #define DFU_ERROR_USB			0x0C
 #define DFU_ERROR_POR			0x0D
 #define DFU_ERROR_UNKNOWN		0x0E
 #define DFU_ERROR_STALLEDPKT		0x0F

 /* DFU request */
 #define DFU_DETACH			0
 #define DFU_DNLOAD			1
 #define DFU_UPLOAD			2
 #define DFU_GETSTATUS			3
 #define DFU_CLRSTATUS			4
 #define DFU_GETSTATE			5
 #define DFU_ABORT			6

 static bool usb_dfu_detach_req;

 /*
  * usb_dfu_init
  *         Initialize the DFU interface
  * pdev: device instance
  * cfgidx: Configuration index
  * return: status
  */
 static uint8_t usb_dfu_init(struct usb_handle *pdev, uint8_t cfgidx)
 {
 	(void)pdev;
 	(void)cfgidx;

 	/* Nothing to do in this stage */
 	return USBD_OK;
 }

 /*
  * usb_dfu_de_init
  *         De-Initialize the DFU layer
  * pdev: device instance
  * cfgidx: Configuration index
  * return: status
  */
 static uint8_t usb_dfu_de_init(struct usb_handle *pdev, uint8_t cfgidx)
 {
 	(void)pdev;
 	(void)cfgidx;

 	/* Nothing to do in this stage */
 	return USBD_OK;
 }

 /*
  * usb_dfu_data_in
  *         handle data IN Stage
  * pdev: device instance
  * epnum: endpoint index
  * return: status
  */
 static uint8_t usb_dfu_data_in(struct usb_handle *pdev, uint8_t epnum)
 {
 	(void)pdev;
 	(void)epnum;

 	return USBD_OK;
 }

 /*
  * usb_dfu_ep0_rx_ready
  *         handle EP0 Rx Ready event
  * pdev: device
  * return: status
  */
 static uint8_t usb_dfu_ep0_rx_ready(struct usb_handle *pdev)
 {
 	(void)pdev;

 	return USBD_OK;
 }

 /*
  * usb_dfu_ep0_tx_ready
  *         handle EP0 TRx Ready event
  * pdev: device instance
  * return: status
  */
 static uint8_t usb_dfu_ep0_tx_ready(struct usb_handle *pdev)
 {
 	(void)pdev;

 	return USBD_OK;
 }

 /*
  * usb_dfu_sof
  *         handle SOF event
  * pdev: device instance
  * return: status
  */
 static uint8_t usb_dfu_sof(struct usb_handle *pdev)
 {
 	(void)pdev;

 	return USBD_OK;
 }

 /*
  * usb_dfu_iso_in_incomplete
  *         handle data ISO IN Incomplete event
  * pdev: device instance
  * epnum: endpoint index
  * return: status
  */
 static uint8_t usb_dfu_iso_in_incomplete(struct usb_handle *pdev, uint8_t epnum)
 {
 	(void)pdev;
 	(void)epnum;

 	return USBD_OK;
 }

 /*
  * usb_dfu_iso_out_incomplete
  *         handle data ISO OUT Incomplete event
  * pdev: device instance
  * epnum: endpoint index
  * return: status
  */
 static uint8_t usb_dfu_iso_out_incomplete(struct usb_handle *pdev,
 					  uint8_t epnum)
 {
 	(void)pdev;
 	(void)epnum;

 	return USBD_OK;
 }

 /*
  * usb_dfu_data_out
  *         handle data OUT Stage
  * pdev: device instance
  * epnum: endpoint index
  * return: status
  */
 static uint8_t usb_dfu_data_out(struct usb_handle *pdev, uint8_t epnum)
 {
 	(void)pdev;
 	(void)epnum;

 	return USBD_OK;
 }

 /*
  * usb_dfu_detach
  *         Handles the DFU DETACH request.
  * pdev: device instance
  * req: pointer to the request structure.
  */
 static void usb_dfu_detach(struct usb_handle *pdev, struct usb_setup_req *req)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	INFO("Receive DFU Detach\n");

 	if ((hdfu->dev_state == STATE_DFU_IDLE) ||
 	    (hdfu->dev_state == STATE_DFU_DNLOAD_SYNC) ||
 	    (hdfu->dev_state == STATE_DFU_DNLOAD_IDLE) ||
 	    (hdfu->dev_state == STATE_DFU_MANIFEST_SYNC) ||
 	    (hdfu->dev_state == STATE_DFU_UPLOAD_IDLE)) {
 		/* Update the state machine */
 		hdfu->dev_state = STATE_DFU_IDLE;
 		hdfu->dev_status = DFU_ERROR_NONE;
 	}

 	usb_dfu_detach_req = true;
 }

 /*
  * usb_dfu_download
  *         Handles the DFU DNLOAD request.
  * pdev: device instance
  * req: pointer to the request structure
  */
 static void usb_dfu_download(struct usb_handle *pdev, struct usb_setup_req *req)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;
 	uintptr_t data_ptr;
 	uint32_t length;
 	int ret;

 	/* Data setup request */
 	if (req->length > 0) {
 		/* Unsupported state */
 		if ((hdfu->dev_state != STATE_DFU_IDLE) &&
 		    (hdfu->dev_state != STATE_DFU_DNLOAD_IDLE)) {
 			/* Call the error management function (command will be nacked) */
 			usb_core_ctl_error(pdev);
 			return;
 		}

 		/* Get the data address */
 		length = req->length;
 		ret = hdfu->callback->download(hdfu->alt_setting, &data_ptr,
 					       &length, pdev->user_data);
 		if (ret == 0U) {
 			/* Update the state machine */
 			hdfu->dev_state = STATE_DFU_DNLOAD_SYNC;
 			/* Start the transfer */
 			usb_core_receive_ep0(pdev, (uint8_t *)data_ptr, length);
 		} else {
 			usb_core_ctl_error(pdev);
 		}
 	} else {
 		/* End of DNLOAD operation*/
 		if (hdfu->dev_state != STATE_DFU_DNLOAD_IDLE) {
 			/* Call the error management function (command will be nacked) */
 			usb_core_ctl_error(pdev);
 			return;
 		}
 		/* End of DNLOAD operation*/
 		hdfu->dev_state = STATE_DFU_MANIFEST_SYNC;
 		ret = hdfu->callback->manifestation(hdfu->alt_setting, pdev->user_data);
 		if (ret == 0U) {
 			hdfu->dev_state = STATE_DFU_MANIFEST_SYNC;
 		} else {
 			usb_core_ctl_error(pdev);
 		}
 	}
 }

 /*
  * usb_dfu_upload
  *         Handles the DFU UPLOAD request.
  * pdev: instance
  * req: pointer to the request structure
  */
 static void usb_dfu_upload(struct usb_handle *pdev, struct usb_setup_req *req)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;
 	uintptr_t data_ptr;
 	uint32_t length;
 	int ret;

 	/* Data setup request */
 	if (req->length == 0) {
 		/* No Data setup request */
 		hdfu->dev_state = STATE_DFU_IDLE;
 		return;
 	}

 	/* Unsupported state */
 	if ((hdfu->dev_state != STATE_DFU_IDLE) && (hdfu->dev_state != STATE_DFU_UPLOAD_IDLE)) {
 		ERROR("UPLOAD : Unsupported State\n");
 		/* Call the error management function (command will be nacked) */
 		usb_core_ctl_error(pdev);
 		return;
 	}

 	/* Update the data address */
 	length = req->length;
 	ret = hdfu->callback->upload(hdfu->alt_setting, &data_ptr, &length, pdev->user_data);
 	if (ret == 0U) {
 		/* Short frame */
 		hdfu->dev_state = (req->length > length) ? STATE_DFU_IDLE : STATE_DFU_UPLOAD_IDLE;

 		/* Start the transfer */
 		usb_core_transmit_ep0(pdev, (uint8_t *)data_ptr, length);
 	} else {
 		ERROR("UPLOAD : bad block %i on alt %i\n", req->value, req->index);
 		hdfu->dev_state = STATE_DFU_ERROR;
 		hdfu->dev_status = DFU_ERROR_STALLEDPKT;

 		/* Call the error management function (command will be nacked) */
 		usb_core_ctl_error(pdev);
 	}
 }

 /*
  * usb_dfu_get_status
  *         Handles the DFU GETSTATUS request.
  * pdev: instance
  */
 static void usb_dfu_get_status(struct usb_handle *pdev)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	hdfu->status[0] = hdfu->dev_status;	/* bStatus */
 	hdfu->status[1] = 0;			/* bwPollTimeout[3] */
 	hdfu->status[2] = 0;
 	hdfu->status[3] = 0;
 	hdfu->status[4] = hdfu->dev_state;	/* bState */
 	hdfu->status[5] = 0;			/* iString */

 	/* next step */
 	switch (hdfu->dev_state) {
 	case STATE_DFU_DNLOAD_SYNC:
 		hdfu->dev_state = STATE_DFU_DNLOAD_IDLE;
 		break;
 	case STATE_DFU_MANIFEST_SYNC:
 		/* the device is 'ManifestationTolerant' */
 		hdfu->status[4] = STATE_DFU_MANIFEST;
 		hdfu->status[1] = 1U; /* bwPollTimeout = 1ms */
 		hdfu->dev_state = STATE_DFU_IDLE;
 		break;

 	default:
 		break;
 	}

 	/* Start the transfer */
 	usb_core_transmit_ep0(pdev, (uint8_t *)&hdfu->status[0], sizeof(hdfu->status));
 }

 /*
  * usb_dfu_clear_status
  *         Handles the DFU CLRSTATUS request.
  * pdev: device instance
  */
 static void usb_dfu_clear_status(struct usb_handle *pdev)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	if (hdfu->dev_state == STATE_DFU_ERROR) {
 		hdfu->dev_state = STATE_DFU_IDLE;
 		hdfu->dev_status = DFU_ERROR_NONE;
 	} else {
 		/* State Error */
 		hdfu->dev_state = STATE_DFU_ERROR;
 		hdfu->dev_status = DFU_ERROR_UNKNOWN;
 	}
 }

 /*
  * usb_dfu_get_state
  *         Handles the DFU GETSTATE request.
  * pdev: device instance
  */
 static void usb_dfu_get_state(struct usb_handle *pdev)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	/* Return the current state of the DFU interface */
 	usb_core_transmit_ep0(pdev, &hdfu->dev_state, 1);
 }

 /*
  * usb_dfu_abort
  *         Handles the DFU ABORT request.
  * pdev: device instance
  */
 static void usb_dfu_abort(struct usb_handle *pdev)
 {
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	if ((hdfu->dev_state == STATE_DFU_IDLE) ||
 	    (hdfu->dev_state == STATE_DFU_DNLOAD_SYNC) ||
 	    (hdfu->dev_state == STATE_DFU_DNLOAD_IDLE) ||
 	    (hdfu->dev_state == STATE_DFU_MANIFEST_SYNC) ||
 	    (hdfu->dev_state == STATE_DFU_UPLOAD_IDLE)) {
 		hdfu->dev_state = STATE_DFU_IDLE;
 		hdfu->dev_status = DFU_ERROR_NONE;
 	}
 }

 /*
  * usb_dfu_setup
  *         Handle the DFU specific requests
  * pdev: instance
  * req: usb requests
  * return: status
  */
 static uint8_t usb_dfu_setup(struct usb_handle *pdev, struct usb_setup_req *req)
 {
 	uint8_t *pbuf = NULL;
 	uint16_t len = 0U;
 	uint8_t ret = USBD_OK;
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	switch (req->bm_request & USB_REQ_TYPE_MASK) {
 	case USB_REQ_TYPE_CLASS:
 		switch (req->b_request) {
 		case DFU_DNLOAD:
 			usb_dfu_download(pdev, req);
 			break;

 		case DFU_UPLOAD:
 			usb_dfu_upload(pdev, req);
 			break;

 		case DFU_GETSTATUS:
 			usb_dfu_get_status(pdev);
 			break;

 		case DFU_CLRSTATUS:
 			usb_dfu_clear_status(pdev);
 			break;

 		case DFU_GETSTATE:
 			usb_dfu_get_state(pdev);
 			break;

 		case DFU_ABORT:
 			usb_dfu_abort(pdev);
 			break;

 		case DFU_DETACH:
 			usb_dfu_detach(pdev, req);
 			break;

 		default:
 			ERROR("unknown request %x on alternate %i\n",
 			      req->b_request, hdfu->alt_setting);
 			usb_core_ctl_error(pdev);
 			ret = USBD_FAIL;
 			break;
 		}
 		break;
 	case USB_REQ_TYPE_STANDARD:
 		switch (req->b_request) {
 		case USB_REQ_GET_DESCRIPTOR:
 			if (HIBYTE(req->value) == DFU_DESCRIPTOR_TYPE) {
 				pbuf = pdev->desc->get_config_desc(&len);
 				/* DFU descriptor at the end of the USB */
 				pbuf += len - 9U;
 				len = 9U;
 				len = MIN(len, req->length);
 			}

 			/* Start the transfer */
 			usb_core_transmit_ep0(pdev, pbuf, len);

 			break;

 		case USB_REQ_GET_INTERFACE:
 			/* Start the transfer */
 			usb_core_transmit_ep0(pdev, (uint8_t *)&hdfu->alt_setting, 1U);
 			break;

 		case USB_REQ_SET_INTERFACE:
 			hdfu->alt_setting = LOBYTE(req->value);
 			break;

 		default:
 			usb_core_ctl_error(pdev);
 			ret = USBD_FAIL;
 			break;
 		}
 	default:
 		break;
 	}

 	return ret;
 }

 static const struct usb_class usb_dfu = {
 	.init = usb_dfu_init,
 	.de_init = usb_dfu_de_init,
 	.setup = usb_dfu_setup,
 	.ep0_tx_sent = usb_dfu_ep0_tx_ready,
 	.ep0_rx_ready = usb_dfu_ep0_rx_ready,
 	.data_in = usb_dfu_data_in,
 	.data_out = usb_dfu_data_out,
 	.sof = usb_dfu_sof,
 	.iso_in_incomplete = usb_dfu_iso_in_incomplete,
 	.iso_out_incomplete = usb_dfu_iso_out_incomplete,
 };

 void usb_dfu_register(struct usb_handle *pdev, struct usb_dfu_handle *phandle)
 {
 	pdev->class = (struct usb_class *)&usb_dfu;
 	pdev->class_data = phandle;

 	phandle->dev_state = STATE_DFU_IDLE;
 	phandle->dev_status = DFU_ERROR_NONE;
 }

 int usb_dfu_loop(struct usb_handle *pdev, const struct usb_dfu_media *pmedia)
 {
 	uint32_t it_count;
 	enum usb_status ret;
 	struct usb_dfu_handle *hdfu = (struct usb_dfu_handle *)pdev->class_data;

 	hdfu->callback = pmedia;
 	usb_dfu_detach_req = false;
 	/* Continue to handle USB core IT to assure complete data transmission */
 	it_count = 100U;

 	/* DFU infinite loop until DETACH_REQ */
 	while (it_count != 0U) {
 		ret = usb_core_handle_it(pdev);
 		if (ret != USBD_OK) {
 			return -EIO;
 		}

 		/* Detach request received */
 		if (usb_dfu_detach_req) {
 			it_count--;
 		}
 	}

 	return 0;
 }
	/*
	* Copyright (c) 2021, STMicroelectronics - All Rights Reserved
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	#include <errno.h>
	#include <string.h>

	#include <common/debug.h>

	#include <platform_def.h>
	#include <usb_dfu.h>

	/* Device states as defined in DFU spec */
	#define STATE_APP_IDLE 0
	#define STATE_APP_DETACH 1
	#define STATE_DFU_IDLE 2
	#define STATE_DFU_DNLOAD_SYNC 3
	#define STATE_DFU_DNLOAD_BUSY 4
	#define STATE_DFU_DNLOAD_IDLE 5
	#define STATE_DFU_MANIFEST_SYNC 6
	#define STATE_DFU_MANIFEST 7
	#define STATE_DFU_MANIFEST_WAIT_RESET 8
	#define STATE_DFU_UPLOAD_IDLE 9
	#define STATE_DFU_ERROR 10

	/* DFU errors */
	#define DFU_ERROR_NONE 0x00
	#define DFU_ERROR_TARGET 0x01
	#define DFU_ERROR_FILE 0x02
	#define DFU_ERROR_WRITE 0x03
	#define DFU_ERROR_ERASE 0x04
	#define DFU_ERROR_CHECK_ERASED 0x05
	#define DFU_ERROR_PROG 0x06
	#define DFU_ERROR_VERIFY 0x07
	#define DFU_ERROR_ADDRESS 0x08
	#define DFU_ERROR_NOTDONE 0x09
	#define DFU_ERROR_FIRMWARE 0x0A
	#define DFU_ERROR_VENDOR 0x0B
	#define DFU_ERROR_USB 0x0C
	#define DFU_ERROR_POR 0x0D
	#define DFU_ERROR_UNKNOWN 0x0E
	#define DFU_ERROR_STALLEDPKT 0x0F

	/* DFU request */
	#define DFU_DETACH 0
	#define DFU_DNLOAD 1
	#define DFU_UPLOAD 2
	#define DFU_GETSTATUS 3
	#define DFU_CLRSTATUS 4
	#define DFU_GETSTATE 5
	#define DFU_ABORT 6

	static bool usb_dfu_detach_req;

	/*
	* usb_dfu_init
	* Initialize the DFU interface
	* pdev: device instance
	* cfgidx: Configuration index
	* return: status
	*/
	static uint8_t usb_dfu_init(struct usb_handle *pdev, uint8_t cfgidx)
	{
	(void)pdev;
	(void)cfgidx;

	/* Nothing to do in this stage */
	return USBD_OK;
	}

	/*
	* usb_dfu_de_init
	* De-Initialize the DFU layer
	* pdev: device instance
	* cfgidx: Configuration index
	* return: status
	*/
	static uint8_t usb_dfu_de_init(struct usb_handle *pdev, uint8_t cfgidx)
	{
	(void)pdev;
	(void)cfgidx;

	/* Nothing to do in this stage */
	return USBD_OK;
	}

	/*
	* usb_dfu_data_in
	* handle data IN Stage
	* pdev: device instance
	* epnum: endpoint index
	* return: status
	*/
	static uint8_t usb_dfu_data_in(struct usb_handle *pdev, uint8_t epnum)
	{
	(void)pdev;
	(void)epnum;

	return USBD_OK;
	}

	/*
	* usb_dfu_ep0_rx_ready
	* handle EP0 Rx Ready event
	* pdev: device
	* return: status
	*/
	static uint8_t usb_dfu_ep0_rx_ready(struct usb_handle *pdev)
	{
	(void)pdev;

	return USBD_OK;
	}

	/*
	* usb_dfu_ep0_tx_ready
	* handle EP0 TRx Ready event
	* pdev: device instance
	* return: status
	*/
	static uint8_t usb_dfu_ep0_tx_ready(struct usb_handle *pdev)
	{
	(void)pdev;

	return USBD_OK;
	}

	/*
	* usb_dfu_sof
	* handle SOF event
	* pdev: device instance
	* return: status
	*/
	static uint8_t usb_dfu_sof(struct usb_handle *pdev)
	{
	(void)pdev;

	return USBD_OK;
	}

	/*
	* usb_dfu_iso_in_incomplete
	* handle data ISO IN Incomplete event
	* pdev: device instance
	* epnum: endpoint index
	* return: status
	*/
	static uint8_t usb_dfu_iso_in_incomplete(struct usb_handle *pdev, uint8_t epnum)
	{
	(void)pdev;
	(void)epnum;

	return USBD_OK;
	}

	/*
	* usb_dfu_iso_out_incomplete
	* handle data ISO OUT Incomplete event
	* pdev: device instance
	* epnum: endpoint index
	* return: status
	*/
	static uint8_t usb_dfu_iso_out_incomplete(struct usb_handle *pdev,
	uint8_t epnum)
	{
	(void)pdev;
	(void)epnum;

	return USBD_OK;
	}

	/*
	* usb_dfu_data_out
	* handle data OUT Stage
	* pdev: device instance
	* epnum: endpoint index
	* return: status
	*/
	static uint8_t usb_dfu_data_out(struct usb_handle *pdev, uint8_t epnum)
	{
	(void)pdev;
	(void)epnum;

	return USBD_OK;
	}

	/*
	* usb_dfu_detach
	* Handles the DFU DETACH request.
	* pdev: device instance
	* req: pointer to the request structure.
	*/
	static void usb_dfu_detach(struct usb_handle pdev, struct usb_setup_req req)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	INFO("Receive DFU Detach\n");

	if ((hdfu->dev_state == STATE_DFU_IDLE) \|\|
	(hdfu->dev_state == STATE_DFU_DNLOAD_SYNC) \|\|
	(hdfu->dev_state == STATE_DFU_DNLOAD_IDLE) \|\|
	(hdfu->dev_state == STATE_DFU_MANIFEST_SYNC) \|\|
	(hdfu->dev_state == STATE_DFU_UPLOAD_IDLE)) {
	/* Update the state machine */
	hdfu->dev_state = STATE_DFU_IDLE;
	hdfu->dev_status = DFU_ERROR_NONE;
	}

	usb_dfu_detach_req = true;
	}

	/*
	* usb_dfu_download
	* Handles the DFU DNLOAD request.
	* pdev: device instance
	* req: pointer to the request structure
	*/
	static void usb_dfu_download(struct usb_handle pdev, struct usb_setup_req req)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;
	uintptr_t data_ptr;
	uint32_t length;
	int ret;

	/* Data setup request */
	if (req->length > 0) {
	/* Unsupported state */
	if ((hdfu->dev_state != STATE_DFU_IDLE) &&
	(hdfu->dev_state != STATE_DFU_DNLOAD_IDLE)) {
	/* Call the error management function (command will be nacked) */
	usb_core_ctl_error(pdev);
	return;
	}

	/* Get the data address */
	length = req->length;
	ret = hdfu->callback->download(hdfu->alt_setting, &data_ptr,
	&length, pdev->user_data);
	if (ret == 0U) {
	/* Update the state machine */
	hdfu->dev_state = STATE_DFU_DNLOAD_SYNC;
	/* Start the transfer */
	usb_core_receive_ep0(pdev, (uint8_t *)data_ptr, length);
	} else {
	usb_core_ctl_error(pdev);
	}
	} else {
	/* End of DNLOAD operation*/
	if (hdfu->dev_state != STATE_DFU_DNLOAD_IDLE) {
	/* Call the error management function (command will be nacked) */
	usb_core_ctl_error(pdev);
	return;
	}
	/* End of DNLOAD operation*/
	hdfu->dev_state = STATE_DFU_MANIFEST_SYNC;
	ret = hdfu->callback->manifestation(hdfu->alt_setting, pdev->user_data);
	if (ret == 0U) {
	hdfu->dev_state = STATE_DFU_MANIFEST_SYNC;
	} else {
	usb_core_ctl_error(pdev);
	}
	}
	}

	/*
	* usb_dfu_upload
	* Handles the DFU UPLOAD request.
	* pdev: instance
	* req: pointer to the request structure
	*/
	static void usb_dfu_upload(struct usb_handle pdev, struct usb_setup_req req)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;
	uintptr_t data_ptr;
	uint32_t length;
	int ret;

	/* Data setup request */
	if (req->length == 0) {
	/* No Data setup request */
	hdfu->dev_state = STATE_DFU_IDLE;
	return;
	}

	/* Unsupported state */
	if ((hdfu->dev_state != STATE_DFU_IDLE) && (hdfu->dev_state != STATE_DFU_UPLOAD_IDLE)) {
	ERROR("UPLOAD : Unsupported State\n");
	/* Call the error management function (command will be nacked) */
	usb_core_ctl_error(pdev);
	return;
	}

	/* Update the data address */
	length = req->length;
	ret = hdfu->callback->upload(hdfu->alt_setting, &data_ptr, &length, pdev->user_data);
	if (ret == 0U) {
	/* Short frame */
	hdfu->dev_state = (req->length > length) ? STATE_DFU_IDLE : STATE_DFU_UPLOAD_IDLE;

	/* Start the transfer */
	usb_core_transmit_ep0(pdev, (uint8_t *)data_ptr, length);
	} else {
	ERROR("UPLOAD : bad block %i on alt %i\n", req->value, req->index);
	hdfu->dev_state = STATE_DFU_ERROR;
	hdfu->dev_status = DFU_ERROR_STALLEDPKT;

	/* Call the error management function (command will be nacked) */
	usb_core_ctl_error(pdev);
	}
	}

	/*
	* usb_dfu_get_status
	* Handles the DFU GETSTATUS request.
	* pdev: instance
	*/
	static void usb_dfu_get_status(struct usb_handle *pdev)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	hdfu->status[0] = hdfu->dev_status; /* bStatus */
	hdfu->status[1] = 0; /* bwPollTimeout[3] */
	hdfu->status[2] = 0;
	hdfu->status[3] = 0;
	hdfu->status[4] = hdfu->dev_state; /* bState */
	hdfu->status[5] = 0; /* iString */

	/* next step */
	switch (hdfu->dev_state) {
	case STATE_DFU_DNLOAD_SYNC:
	hdfu->dev_state = STATE_DFU_DNLOAD_IDLE;
	break;
	case STATE_DFU_MANIFEST_SYNC:
	/* the device is 'ManifestationTolerant' */
	hdfu->status[4] = STATE_DFU_MANIFEST;
	hdfu->status[1] = 1U; /* bwPollTimeout = 1ms */
	hdfu->dev_state = STATE_DFU_IDLE;
	break;

	default:
	break;
	}

	/* Start the transfer */
	usb_core_transmit_ep0(pdev, (uint8_t *)&hdfu->status[0], sizeof(hdfu->status));
	}

	/*
	* usb_dfu_clear_status
	* Handles the DFU CLRSTATUS request.
	* pdev: device instance
	*/
	static void usb_dfu_clear_status(struct usb_handle *pdev)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	if (hdfu->dev_state == STATE_DFU_ERROR) {
	hdfu->dev_state = STATE_DFU_IDLE;
	hdfu->dev_status = DFU_ERROR_NONE;
	} else {
	/* State Error */
	hdfu->dev_state = STATE_DFU_ERROR;
	hdfu->dev_status = DFU_ERROR_UNKNOWN;
	}
	}

	/*
	* usb_dfu_get_state
	* Handles the DFU GETSTATE request.
	* pdev: device instance
	*/
	static void usb_dfu_get_state(struct usb_handle *pdev)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	/* Return the current state of the DFU interface */
	usb_core_transmit_ep0(pdev, &hdfu->dev_state, 1);
	}

	/*
	* usb_dfu_abort
	* Handles the DFU ABORT request.
	* pdev: device instance
	*/
	static void usb_dfu_abort(struct usb_handle *pdev)
	{
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	if ((hdfu->dev_state == STATE_DFU_IDLE) \|\|
	(hdfu->dev_state == STATE_DFU_DNLOAD_SYNC) \|\|
	(hdfu->dev_state == STATE_DFU_DNLOAD_IDLE) \|\|
	(hdfu->dev_state == STATE_DFU_MANIFEST_SYNC) \|\|
	(hdfu->dev_state == STATE_DFU_UPLOAD_IDLE)) {
	hdfu->dev_state = STATE_DFU_IDLE;
	hdfu->dev_status = DFU_ERROR_NONE;
	}
	}

	/*
	* usb_dfu_setup
	* Handle the DFU specific requests
	* pdev: instance
	* req: usb requests
	* return: status
	*/
	static uint8_t usb_dfu_setup(struct usb_handle pdev, struct usb_setup_req req)
	{
	uint8_t *pbuf = NULL;
	uint16_t len = 0U;
	uint8_t ret = USBD_OK;
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	switch (req->bm_request & USB_REQ_TYPE_MASK) {
	case USB_REQ_TYPE_CLASS:
	switch (req->b_request) {
	case DFU_DNLOAD:
	usb_dfu_download(pdev, req);
	break;

	case DFU_UPLOAD:
	usb_dfu_upload(pdev, req);
	break;

	case DFU_GETSTATUS:
	usb_dfu_get_status(pdev);
	break;

	case DFU_CLRSTATUS:
	usb_dfu_clear_status(pdev);
	break;

	case DFU_GETSTATE:
	usb_dfu_get_state(pdev);
	break;

	case DFU_ABORT:
	usb_dfu_abort(pdev);
	break;

	case DFU_DETACH:
	usb_dfu_detach(pdev, req);
	break;

	default:
	ERROR("unknown request %x on alternate %i\n",
	req->b_request, hdfu->alt_setting);
	usb_core_ctl_error(pdev);
	ret = USBD_FAIL;
	break;
	}
	break;
	case USB_REQ_TYPE_STANDARD:
	switch (req->b_request) {
	case USB_REQ_GET_DESCRIPTOR:
	if (HIBYTE(req->value) == DFU_DESCRIPTOR_TYPE) {
	pbuf = pdev->desc->get_config_desc(&len);
	/* DFU descriptor at the end of the USB */
	pbuf += len - 9U;
	len = 9U;
	len = MIN(len, req->length);
	}

	/* Start the transfer */
	usb_core_transmit_ep0(pdev, pbuf, len);

	break;

	case USB_REQ_GET_INTERFACE:
	/* Start the transfer */
	usb_core_transmit_ep0(pdev, (uint8_t *)&hdfu->alt_setting, 1U);
	break;

	case USB_REQ_SET_INTERFACE:
	hdfu->alt_setting = LOBYTE(req->value);
	break;

	default:
	usb_core_ctl_error(pdev);
	ret = USBD_FAIL;
	break;
	}
	default:
	break;
	}

	return ret;
	}

	static const struct usb_class usb_dfu = {
	.init = usb_dfu_init,
	.de_init = usb_dfu_de_init,
	.setup = usb_dfu_setup,
	.ep0_tx_sent = usb_dfu_ep0_tx_ready,
	.ep0_rx_ready = usb_dfu_ep0_rx_ready,
	.data_in = usb_dfu_data_in,
	.data_out = usb_dfu_data_out,
	.sof = usb_dfu_sof,
	.iso_in_incomplete = usb_dfu_iso_in_incomplete,
	.iso_out_incomplete = usb_dfu_iso_out_incomplete,
	};

	void usb_dfu_register(struct usb_handle pdev, struct usb_dfu_handle phandle)
	{
	pdev->class = (struct usb_class *)&usb_dfu;
	pdev->class_data = phandle;

	phandle->dev_state = STATE_DFU_IDLE;
	phandle->dev_status = DFU_ERROR_NONE;
	}

	int usb_dfu_loop(struct usb_handle pdev, const struct usb_dfu_media pmedia)
	{
	uint32_t it_count;
	enum usb_status ret;
	struct usb_dfu_handle hdfu = (struct usb_dfu_handle )pdev->class_data;

	hdfu->callback = pmedia;
	usb_dfu_detach_req = false;
	/* Continue to handle USB core IT to assure complete data transmission */
	it_count = 100U;

	/* DFU infinite loop until DETACH_REQ */
	while (it_count != 0U) {
	ret = usb_core_handle_it(pdev);
	if (ret != USBD_OK) {
	return -EIO;
	}

	/* Detach request received */
	if (usb_dfu_detach_req) {
	it_count--;
	}
	}

	return 0;
	}