V2.31

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/.cproject

@@ -14,7 +14,7 @@
 				</extensions>
 			</storageModule>
 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe,org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release" cleanCommand="${cross_rm} -rf" description="" id="ilg.gnumcueclipse.managedbuild.cross.riscv.config.elf.release.1008047074" name="obj" parent="ilg.gnumcueclipse.managedbuild.cross.riscv.config.elf.release">
+				<configuration artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe,org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.release" cleanCommand="${cross_rm} -rf" description="" id="ilg.gnumcueclipse.managedbuild.cross.riscv.config.elf.release.1008047074" name="obj" parent="ilg.gnumcueclipse.managedbuild.cross.riscv.config.elf.release" postbuildStep=" ${cross_prefix}${cross_objcopy}${cross_suffix} -O ihex &quot;${ProjName}.elf&quot; &quot;${ProjName}.hex&quot; &amp;&amp; ${cross_prefix}${cross_objcopy}${cross_suffix} -O binary &quot;${ProjName}.elf&quot; &quot;${ProjName}.bin&quot;">
 					<folderInfo id="ilg.gnumcueclipse.managedbuild.cross.riscv.config.elf.release.1008047074." name="/" resourcePath="">
 						<toolChain id="ilg.gnumcueclipse.managedbuild.cross.riscv.toolchain.elf.release.231146001" name="RISC-V Cross GCC" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.toolchain.elf.release">
 							<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.addtools.createflash.1311852988" name="Create flash image" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.addtools.createflash" useByScannerDiscovery="false" value="true" valueType="boolean"/>
@@ -46,7 +46,7 @@
 							<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.warnings.unused.1961191588" name="Warn on various unused elements (-Wunused)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.warnings.unused" useByScannerDiscovery="true" value="true" valueType="boolean"/>
 							<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.warnings.uninitialized.929829166" name="Warn on uninitialized variables (-Wuninitialized)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.warnings.uninitialized" useByScannerDiscovery="true" value="true" valueType="boolean"/>
 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="ilg.gnumcueclipse.managedbuild.cross.riscv.targetPlatform.1944008784" isAbstract="false" osList="all" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.targetPlatform"/>
-							<builder buildPath="${workspace_loc:/ADC_DMA}/obj" id="ilg.gnumcueclipse.managedbuild.cross.riscv.builder.1421508906" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="GNU Make 构建器" parallelBuildOn="true" parallelizationNumber="optimal" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.builder"/>
+							<builder buildPath="${workspace_loc:/ADC_DMA}/obj" id="ilg.gnumcueclipse.managedbuild.cross.riscv.builder.1421508906" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.builder"/>
 							<tool id="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.assembler.1244756189" name="GNU RISC-V Cross Assembler" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.assembler">
 								<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.assembler.usepreprocessor.1692176068" name="Use preprocessor" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.assembler.usepreprocessor" useByScannerDiscovery="false" value="false" valueType="boolean"/>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.assembler.include.paths.1034038285" name="Include paths (-I)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.assembler.include.paths" useByScannerDiscovery="true" valueType="includePath">
@@ -57,6 +57,8 @@
 							<tool id="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.c.compiler.1731377187" name="GNU RISC-V Cross C Compiler" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.c.compiler">
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.c.compiler.include.paths.1567947810" name="Include paths (-I)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.c.compiler.include.paths" useByScannerDiscovery="true" valueType="includePath">
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/Debug}&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/CONFIG}&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/USBLIB/USB-Driver/inc}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/Core}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/User}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/Peripheral/inc}&quot;"/>
@@ -95,7 +97,7 @@
 							</tool>
 							<tool id="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.archiver.1292785366" name="GNU RISC-V Cross Archiver" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.archiver"/>
 							<tool id="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.createflash.1801165667" name="GNU RISC-V Cross Create Flash Image" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.createflash">
-								<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createflash.choice.1335632361" name="Output file format (-O)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createflash.choice" useByScannerDiscovery="false" value="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createflash.choice.binary" valueType="enumerated"/>
+								<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createflash.choice.1335632361" name="Output file format (-O)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createflash.choice" useByScannerDiscovery="false" value="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createflash.choice.ihexAndbinary" valueType="enumerated"/>
 							</tool>
 							<tool id="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.createlisting.1356766765" name="GNU RISC-V Cross Create Listing" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.tool.createlisting">
 								<option id="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createlisting.source.2052761852" name="Display source (--source|-S)" superClass="ilg.gnumcueclipse.managedbuild.cross.riscv.option.createlisting.source" useByScannerDiscovery="false" value="false" valueType="boolean"/>

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/.project

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <projectDescription>
-  <name>ADC_DMA</name>
+  <name>CH32V20x_APP</name>
   <comment/>
   <projects/>
   <buildSpec>

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/.template

@@ -13,4 +13,4 @@ Series=CH32V203
 Description=ROM(byte): 64K, SRAM(byte): 20K, CHIP PINS: 32, GPIO PORTS: 27.\nWCH CH32V2 series of mainstream MCUs covers the needs of a large variety of applications in the industrial,medical and consumer markets. High performance with first-class peripherals and low-power,low-voltage operation is paired with a high level of integration at accessible prices with a simple architecture and easy-to-use tools.
 
 PeripheralVersion=1.0
-MCU=CH32V203RBT6
+MCU=CH32V203RBT

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/hw_config.c

@@ -0,0 +1,157 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : hw_config.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : USB configuration file.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+#include "usb_prop.h"
+#include "usb_desc.h"
+#include "usb_istr.h"
+#include "hw_config.h"
+#include "usb_pwr.h"  
+#include "string.h"	
+#include "stdarg.h"		 
+#include "stdio.h"	
+
+
+void USBWakeUp_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
+void USB_LP_CAN1_RX0_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
+
+/*******************************************************************************
+ * @fn        USBWakeUp_IRQHandler
+ *
+ * @brief     This function handles USB wake up exception.
+ *
+ * @return    None
+ */
+void USBWakeUp_IRQHandler(void) 
+{
+	EXTI_ClearITPendingBit(EXTI_Line18);
+} 
+
+/*******************************************************************************
+ * @fn           USBWakeUp_IRQHandler
+ *
+ * @brief  T     his function handles USB exception.
+ *
+ * @return None
+ */
+void USB_LP_CAN1_RX0_IRQHandler(void) 
+{
+	USB_Istr();
+} 
+
+/*******************************************************************************
+ * @fn        Set_USBConfig
+ *
+ * @brief     Set_USBConfig .
+ *
+ * @return    None
+ */
+void Set_USBConfig( )
+{
+	RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_Div2);
+	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE);	 		 
+}
+
+/*******************************************************************************
+ * @fn        Enter_LowPowerMode
+ *
+ * @brief     Enter low power mode.
+ *
+ * @return    None
+ */
+void Enter_LowPowerMode(void)
+{  
+	bDeviceState=SUSPENDED;
+} 
+
+/*******************************************************************************
+ * @fn         Leave_LowPowerMode
+ *
+ * @brief      Leave low power mode.
+ *
+ * @return     None
+ */
+void Leave_LowPowerMode(void)
+{
+	DEVICE_INFO *pInfo=&Device_Info;
+	if (pInfo->Current_Configuration!=0)bDeviceState=CONFIGURED; 
+	else bDeviceState = ATTACHED; 
+} 
+
+/*******************************************************************************
+ * @fn         USB_Interrupts_Config
+ *
+ * @brief      Configrate USB interrupt.
+ *
+ * @return     None
+ */
+void USB_Interrupts_Config(void)
+{ 
+	NVIC_InitTypeDef NVIC_InitStructure;
+	EXTI_InitTypeDef EXTI_InitStructure;
+
+	EXTI_ClearITPendingBit(EXTI_Line18);
+	EXTI_InitStructure.EXTI_Line = EXTI_Line18; 
+	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
+	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;	
+	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
+	EXTI_Init(&EXTI_InitStructure); 	 
+
+	NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;	
+	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
+	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
+	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
+	NVIC_Init(&NVIC_InitStructure);
+	
+	NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;  
+	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
+	NVIC_Init(&NVIC_InitStructure);   
+}	
+
+/*******************************************************************************
+ * @fn         USB_Port_Set
+ *
+ * @brief      Set USB IO port.
+ *
+ * @param      NewState: DISABLE or ENABLE.
+ *             Pin_In_IPU: Enables or Disables intenal pull-up resistance.
+ *
+ * @return     None
+ */
+void USB_Port_Set(FunctionalState NewState, FunctionalState Pin_In_IPU)
+{
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
+
+	if(NewState) {
+		_SetCNTR(_GetCNTR()&(~(1<<1)));
+		GPIOA->CFGHR&=0XFFF00FFF;
+		GPIOA->OUTDR&=~(3<<11);	//PA11/12=0
+        GPIOA->CFGHR|=0X00044000; //float
+	}
+	else
+	{	  
+		_SetCNTR(_GetCNTR()|(1<<1));  
+		GPIOA->CFGHR&=0XFFF00FFF;
+		GPIOA->OUTDR&=~(3<<11);	//PA11/12=0
+		GPIOA->CFGHR|=0X00033000;	// LOW
+	}
+	
+	if(Pin_In_IPU) (EXTEN->EXTEN_CTR) |= EXTEN_USBD_PU_EN; 
+	else (EXTEN->EXTEN_CTR) &= ~EXTEN_USBD_PU_EN;
+}  
+
+
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/hw_config.h

@@ -0,0 +1,38 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : hw_config.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Configuration file for USB.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __HW_CONFIG_H
+#define __HW_CONFIG_H
+
+#include "usb_type.h" 
+ 
+#ifdef	DEBUG
+#define printf_usb(X...) printf(X)
+#else
+#define printf_usb(X...)
+#endif 
+
+
+void Set_USBConfig(void);
+void Enter_LowPowerMode(void);
+void Leave_LowPowerMode(void);
+void USB_Interrupts_Config(void);
+void USB_Port_Set(FunctionalState NewState, FunctionalState Pin_In_IPU);
+
+#endif /* __HW_CONFIG_H */ 
+
+
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_conf.h

@@ -0,0 +1,77 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_conf.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB configration firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_CONF_H
+#define __USB_CONF_H
+
+
+#define EP_NUM                          (5)
+
+/* Buffer Description Table */
+/* buffer table base address */
+/* buffer table base address */
+#define BTABLE_ADDRESS      (0x00)
+
+/* EP0  */
+/* rx/tx buffer base address */
+#define ENDP0_RXADDR        (0x40)
+#define ENDP0_TXADDR        (0x80)
+
+/* EP1  */
+/* tx buffer base address */
+#define ENDP1_TXADDR        (0xC0)
+#define ENDP1_RXADDR        (ENDP1_TXADDR + 0x10)
+#define ENDP2_TXADDR        (ENDP1_RXADDR + 0x10)
+#define ENDP2_RXADDR        (ENDP2_TXADDR + 0x10)
+
+/* ISTR events */
+/* IMR_MSK */
+/* mask defining which events has to be handled */
+/* by the device application software */
+#define IMR_MSK (CNTR_CTRM  | CNTR_WKUPM | CNTR_SUSPM | CNTR_ERRM  | CNTR_SOFM \
+                 | CNTR_ESOFM | CNTR_RESETM )
+
+/*#define CTR_CALLBACK*/
+/*#define DOVR_CALLBACK*/
+/*#define ERR_CALLBACK*/
+/*#define WKUP_CALLBACK*/
+/*#define SUSP_CALLBACK*/
+/*#define RESET_CALLBACK*/
+#define SOF_CALLBACK
+/*#define ESOF_CALLBACK*/
+
+
+/* CTR service routines */
+/* associated to defined endpoints */
+#define  EP1_IN_Callback   NOP_Process
+//#define  EP2_IN_Callback   NOP_Process
+#define  EP3_IN_Callback   NOP_Process
+#define  EP4_IN_Callback   NOP_Process
+#define  EP5_IN_Callback   NOP_Process
+#define  EP6_IN_Callback   NOP_Process
+#define  EP7_IN_Callback   NOP_Process
+
+#define  EP1_OUT_Callback   NOP_Process
+//#define  EP2_OUT_Callback   NOP_Process
+#define  EP3_OUT_Callback   NOP_Process
+#define  EP4_OUT_Callback   NOP_Process
+#define  EP5_OUT_Callback   NOP_Process
+#define  EP6_OUT_Callback   NOP_Process
+#define  EP7_OUT_Callback   NOP_Process
+
+#endif /* __USB_CONF_H */
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_desc.c

@@ -0,0 +1,68 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_desc.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Descriptors for Virtual Com Port Demo.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+#include "usb_desc.h"
+#include "iap.h"
+#define DevEP0SIZE  0x40
+
+/* USB Device Descriptors */
+const uint8_t  USBD_DeviceDescriptor[] = { 
+    0x12, 0x01, 0x10, 0x01,
+    0xFF, 0x80, 0x55, DevEP0SIZE,
+    0x48, 0x43, 0xe0, 0x55,  //USB MODULE
+    (u8)Version_Num, (u8)(Version_Num>>8),
+    0x00, 0x00,0x00, 0x01
+};
+
+/* USB Configration Descriptors */
+const uint8_t  USBD_ConfigDescriptor[] = { 
+    0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32,
+    0x09, 0x04, 0x00, 0x00, 0x02, 0xFF, 0x80, 0x55, 0x00,
+    0x07, 0x05, 0x82, 0x02, 0x40, 0x00, 0x00,
+    0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00
+};
+
+/* USB String Descriptors */
+const uint8_t USBD_StringLangID[USBD_SIZE_STRING_LANGID] = {
+    USBD_SIZE_STRING_LANGID,
+    USB_STRING_DESCRIPTOR_TYPE,
+    0x09,
+    0x04
+};
+
+/* USB Device String Vendor */
+const uint8_t USBD_StringVendor[USBD_SIZE_STRING_VENDOR] = {
+    USBD_SIZE_STRING_VENDOR,
+    USB_STRING_DESCRIPTOR_TYPE,
+    'W', 0, 'C', 0, 'H', 0, 'I', 0, 'C', 0, 'r', 0, 'o', 0, 'e', 0,
+    'l', 0, 'e', 0, 'c', 0, 't', 0, 'r', 0, 'o', 0, 'n', 0, 'i', 0,
+    'c', 0, 's', 0
+};
+
+/* USB Device String Product */
+const uint8_t USBD_StringProduct[USBD_SIZE_STRING_PRODUCT] = {
+    USBD_SIZE_STRING_PRODUCT,
+    USB_STRING_DESCRIPTOR_TYPE,
+    'W', 0, 'C', 0, 'H', 0, '3', 0, '2', 0, ' ', 0, 'V', 0, 'i', 0,
+    'r', 0, 't', 0, 'u', 0, 'a', 0, 'l', 0, ' ', 0, 'C', 0, 'O', 0,
+    'M', 0, ' ', 0, 'P', 0, 'o', 0, 'r', 0, 't', 0, ' ', 0, ' ', 0
+};
+
+/* USB Device String Serial */
+uint8_t USBD_StringSerial[USBD_SIZE_STRING_SERIAL] = {
+    USBD_SIZE_STRING_SERIAL,
+    USB_STRING_DESCRIPTOR_TYPE,
+    'W', 0, 'C', 0, 'H', 0, '3', 0, '2', 0
+};
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_desc.h

@@ -0,0 +1,54 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_desc.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB description firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_DESC_H
+#define __USB_DESC_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+	 
+#include "ch32v20x.h"
+	 
+#define Version_Num   0x0100   //V0100
+#define USB_DEVICE_DESCRIPTOR_TYPE              0x01
+#define USB_CONFIGURATION_DESCRIPTOR_TYPE       0x02
+#define USB_STRING_DESCRIPTOR_TYPE              0x03
+#define USB_INTERFACE_DESCRIPTOR_TYPE           0x04
+#define USB_ENDPOINT_DESCRIPTOR_TYPE            0x05
+
+#define USBD_DATA_SIZE               64
+#define USBD_INT_SIZE                8
+       
+#define USBD_SIZE_DEVICE_DESC        18
+#define USBD_SIZE_CONFIG_DESC        0x20
+#define USBD_SIZE_STRING_LANGID      4
+#define USBD_SIZE_STRING_VENDOR      38
+#define USBD_SIZE_STRING_PRODUCT     50
+#define USBD_SIZE_STRING_SERIAL      26
+
+#define STANDARD_ENDPOINT_DESC_SIZE             0x09
+
+
+extern const uint8_t USBD_DeviceDescriptor[USBD_SIZE_DEVICE_DESC];
+extern const uint8_t USBD_ConfigDescriptor[USBD_SIZE_CONFIG_DESC];
+                    
+extern const uint8_t USBD_StringLangID [USBD_SIZE_STRING_LANGID];
+extern const uint8_t USBD_StringVendor [USBD_SIZE_STRING_VENDOR];
+extern const uint8_t USBD_StringProduct[USBD_SIZE_STRING_PRODUCT];
+extern uint8_t USBD_StringSerial [USBD_SIZE_STRING_SERIAL];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __USB_DESC_H */

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_endp.c

@@ -0,0 +1,79 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_endp.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Endpoint routines
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+#include "usb_desc.h"
+#include "usb_mem.h"
+#include "hw_config.h"
+#include "usb_istr.h"
+#include "usb_pwr.h"
+
+/* Interval between sending IN packets in frame number (1 frame = 1ms) */
+#define IN_FRAME_INTERVAL             5
+
+
+u8 EP2_Rx_Buffer[USBD_DATA_SIZE];
+u16 EP2_Rx_Cnt=0;
+
+u8 EP2_Tx_Buffer[2];
+u16 EP2_Tx_Cnt=0;
+
+u8 EP2_IN_Flag = 0;
+u8 EP2_OUT_Flag = 0;
+
+/*********************************************************************
+ * @fn      EP2_IN_Callback
+ *
+ * @brief   Endpoint 2 IN.
+ *
+ * @return  none
+ */
+void EP2_IN_Callback (void)
+{ 
+    EP2_IN_Flag = 0;
+    SetEPTxStatus(ENDP2, EP_TX_NAK);
+}
+
+/*********************************************************************
+ * @fn      EP2_OUT_Callback
+ *
+ * @brief   Endpoint 2 OUT.
+ *
+ * @return  none
+ */
+void EP2_OUT_Callback(void)
+{
+    EP2_OUT_Flag = 1;
+}
+
+/*********************************************************************
+ * @fn      SOF_Callback
+ *
+ * @brief   SOF call back.
+ *
+ * @return  none
+ */
+void SOF_Callback(void)
+{
+    static uint32_t FrameCount = 0;
+
+    if(bDeviceState == CONFIGURED)
+    {
+        if (FrameCount++ == IN_FRAME_INTERVAL)
+        {
+            FrameCount = 0;
+            //Handle_USBAsynchXfer();
+        }
+    }
+}
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_istr.c

@@ -0,0 +1,196 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_istr.c
+ * Author             : WCH
+ * Version            : V1.0.1
+ * Date               : 2022/12/28
+ * Description        : ISTR events interrupt service routines
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+#include "usb_prop.h"
+#include "usb_pwr.h"
+#include "usb_istr.h"
+
+uint16_t Ep0RxBlks;
+
+/* Private variables */
+__IO uint16_t wIstr;  
+__IO uint8_t bIntPackSOF = 0;  
+__IO uint32_t esof_counter =0;
+__IO uint32_t wCNTR=0;
+
+/* function pointers to non-control endpoints service routines */
+void (*pEpInt_IN[7])(void) ={
+	EP1_IN_Callback,
+	EP2_IN_Callback,
+	EP3_IN_Callback,
+	EP4_IN_Callback,
+	EP5_IN_Callback,
+	EP6_IN_Callback,
+	EP7_IN_Callback,
+};
+
+void (*pEpInt_OUT[7])(void) ={
+	EP1_OUT_Callback,
+	EP2_OUT_Callback,
+	EP3_OUT_Callback,
+	EP4_OUT_Callback,
+	EP5_OUT_Callback,
+	EP6_OUT_Callback,
+	EP7_OUT_Callback,
+};
+
+/*******************************************************************************
+ * @fn        USB_Istr
+ *
+ * @brief     ISTR events interrupt service routine
+ *
+ * @return    None.
+ */
+void USB_Istr(void)
+{
+  uint32_t i=0;
+  __IO uint32_t EP[8];
+  if ((*_pEPRxCount(0) & 0xFC00 )!= Ep0RxBlks)
+  {
+    *_pEPRxCount(0) |= (Ep0RxBlks & 0xFC00);
+  }
+  wIstr = _GetISTR();
+#if (IMR_MSK & ISTR_SOF)
+  if (wIstr & ISTR_SOF & wInterrupt_Mask)
+  {
+    _SetISTR((uint16_t)CLR_SOF);
+    bIntPackSOF++;
+
+#ifdef SOF_CALLBACK
+    SOF_Callback();
+		
+#endif
+  }
+#endif
+ 
+  
+#if (IMR_MSK & ISTR_CTR)
+  if (wIstr & ISTR_CTR & wInterrupt_Mask)
+  {
+    CTR_LP();
+#ifdef CTR_CALLBACK
+    CTR_Callback();
+#endif
+  }
+#endif
+ 
+#if (IMR_MSK & ISTR_RESET)
+  if (wIstr & ISTR_RESET & wInterrupt_Mask)
+  {
+    _SetISTR((uint16_t)CLR_RESET);
+    Device_Property.Reset();
+    
+#ifdef RESET_CALLBACK
+    RESET_Callback();
+#endif
+  }
+#endif
+
+#if (IMR_MSK & ISTR_DOVR)
+  if (wIstr & ISTR_DOVR & wInterrupt_Mask)
+  {
+    _SetISTR((uint16_t)CLR_DOVR);
+#ifdef DOVR_CALLBACK
+    DOVR_Callback();
+#endif
+  }
+#endif
+
+#if (IMR_MSK & ISTR_ERR)
+  if (wIstr & ISTR_ERR & wInterrupt_Mask)
+  {
+    _SetISTR((uint16_t)CLR_ERR);
+#ifdef ERR_CALLBACK
+    ERR_Callback();
+#endif
+  }
+#endif
+
+#if (IMR_MSK & ISTR_WKUP)
+  if (wIstr & ISTR_WKUP & wInterrupt_Mask)
+  {
+    _SetISTR((uint16_t)CLR_WKUP);
+    Resume(RESUME_EXTERNAL);
+#ifdef WKUP_CALLBACK
+    WKUP_Callback();
+#endif
+  }
+#endif
+#if (IMR_MSK & ISTR_SUSP)
+  if (wIstr & ISTR_SUSP & wInterrupt_Mask)
+  {
+    if (fSuspendEnabled)
+    {
+      Suspend();
+    }
+    else
+    {
+      Resume(RESUME_LATER);
+    }
+    _SetISTR((uint16_t)CLR_SUSP);
+#ifdef SUSP_CALLBACK
+    SUSP_Callback();
+#endif
+  }
+#endif
+
+#if (IMR_MSK & ISTR_ESOF)
+  if (wIstr & ISTR_ESOF & wInterrupt_Mask)
+  {
+    _SetISTR((uint16_t)CLR_ESOF);
+    
+    if ((_GetFNR()&FNR_RXDP)!=0)
+    {
+      esof_counter ++;
+      
+      if ((esof_counter >3)&&((_GetCNTR()&CNTR_FSUSP)==0))
+      {           
+
+        wCNTR = _GetCNTR(); 
+      
+        for (i=0;i<8;i++) EP[i] = _GetENDPOINT(i);
+      
+        wCNTR|=CNTR_FRES;
+        _SetCNTR(wCNTR);
+ 
+        wCNTR&=~CNTR_FRES;
+        _SetCNTR(wCNTR);
+      
+        while((_GetISTR()&ISTR_RESET) == 0);
+  
+        _SetISTR((uint16_t)CLR_RESET);
+   
+        for (i=0;i<8;i++)
+        _SetENDPOINT(i, EP[i]);
+      
+        esof_counter = 0;
+      }
+    }
+    else
+    {
+        esof_counter = 0;
+    }
+    
+    Resume(RESUME_ESOF); 
+
+#ifdef ESOF_CALLBACK
+    ESOF_Callback();
+#endif
+  }
+#endif
+} /* USB_Istr */
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_istr.h

@@ -0,0 +1,77 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_istr.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file includes the peripherals header files in the 
+ *                      user application.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_ISTR_H
+#define __USB_ISTR_H
+
+#include "usb_conf.h"
+
+
+void USB_Istr(void);
+void EP1_IN_Callback(void);
+void EP2_IN_Callback(void);
+void EP3_IN_Callback(void);
+void EP4_IN_Callback(void);
+void EP5_IN_Callback(void);
+void EP6_IN_Callback(void);
+void EP7_IN_Callback(void);
+
+void EP1_OUT_Callback(void);
+void EP2_OUT_Callback(void);
+void EP3_OUT_Callback(void);
+void EP4_OUT_Callback(void);
+void EP5_OUT_Callback(void);
+void EP6_OUT_Callback(void);
+void EP7_OUT_Callback(void);
+
+#ifdef CTR_CALLBACK
+void CTR_Callback(void);
+#endif
+
+#ifdef DOVR_CALLBACK
+void DOVR_Callback(void);
+#endif
+
+#ifdef ERR_CALLBACK
+void ERR_Callback(void);
+#endif
+
+#ifdef WKUP_CALLBACK
+void WKUP_Callback(void);
+#endif
+
+#ifdef SUSP_CALLBACK
+void SUSP_Callback(void);
+#endif
+
+#ifdef RESET_CALLBACK
+void RESET_Callback(void);
+#endif
+
+#ifdef SOF_CALLBACK
+void SOF_Callback(void);
+#endif
+
+#ifdef ESOF_CALLBACK
+void ESOF_Callback(void);
+#endif
+
+
+#endif /*__USB_ISTR_H*/
+
+
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_prop.c

@@ -0,0 +1,315 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_prop.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : All processing related to Virtual Com Port Demo
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+#include "usb_conf.h"
+#include "usb_prop.h"
+#include "usb_desc.h"
+#include "usb_pwr.h"
+#include "hw_config.h"
+
+uint8_t Request = 0;
+
+DEVICE Device_Table =
+{
+    EP_NUM,
+    1
+};
+
+DEVICE_PROP Device_Property =
+{
+    USBD_init,
+    USBD_Reset,
+    USBD_Status_In,
+    USBD_Status_Out,
+    USBD_Data_Setup,
+    USBD_NoData_Setup,
+    USBD_Get_Interface_Setting,
+    USBD_GetDeviceDescriptor,
+    USBD_GetConfigDescriptor,
+    USBD_GetStringDescriptor,
+    0,
+    0x40
+};
+
+USER_STANDARD_REQUESTS User_Standard_Requests =
+{
+    USBD_GetConfiguration,
+    USBD_SetConfiguration,
+    USBD_GetInterface,
+    USBD_SetInterface,
+    USBD_GetStatus,
+    USBD_ClearFeature,
+    USBD_SetEndPointFeature,
+    USBD_SetDeviceFeature,
+    USBD_SetDeviceAddress
+};
+
+ONE_DESCRIPTOR Device_Descriptor =
+{
+    (uint8_t*)USBD_DeviceDescriptor,
+    USBD_SIZE_DEVICE_DESC
+};
+
+ONE_DESCRIPTOR Config_Descriptor =
+{
+    (uint8_t*)USBD_ConfigDescriptor,
+    USBD_SIZE_CONFIG_DESC
+};
+
+ONE_DESCRIPTOR String_Descriptor[4] =
+{
+    {(uint8_t*)USBD_StringLangID, USBD_SIZE_STRING_LANGID},
+    {(uint8_t*)USBD_StringVendor, USBD_SIZE_STRING_VENDOR},
+    {(uint8_t*)USBD_StringProduct,USBD_SIZE_STRING_PRODUCT},
+    {(uint8_t*)USBD_StringSerial, USBD_SIZE_STRING_SERIAL}
+};
+
+/*********************************************************************
+ * @fn      USBD_SetConfiguration.
+ *
+ * @brief   Update the device state to configured.
+ *
+ * @return  none
+ */
+void USBD_SetConfiguration(void)
+{
+  DEVICE_INFO *pInfo = &Device_Info;
+
+  if (pInfo->Current_Configuration != 0)
+  {
+    bDeviceState = CONFIGURED;
+  }
+}
+
+/*********************************************************************
+ * @fn      USBD_SetDeviceAddress.
+ *
+ * @brief   Update the device state to addressed.
+ *
+ * @return  none
+ */
+void USBD_SetDeviceAddress (void)
+{
+  bDeviceState = ADDRESSED;
+}
+
+/*********************************************************************
+ * @fn      USBD_Status_In.
+ *
+ * @brief   USBD Status In Routine.
+ *
+ * @return  none.
+ */
+void USBD_Status_In(void)
+{
+ 
+}
+
+/*********************************************************************
+ * @fn      USBD_Status_Out
+ *
+ * @brief   USBD Status OUT Routine.
+ *
+ * @return  none.
+ */
+void USBD_Status_Out(void)
+{
+    
+}
+
+/*********************************************************************
+ * @fn      USB_init.
+ *
+ * @brief   init routine.
+ *
+ * @return  none.
+ */
+void USBD_init(void)
+{
+  uint8_t   i;
+    
+  pInformation->Current_Configuration = 0;
+  PowerOn();
+  for (i=0;i<8;i++) _SetENDPOINT(i,_GetENDPOINT(i) & 0x7F7F & EPREG_MASK);//all clear
+  _SetISTR((uint16_t)0x00FF);//all clear
+  USB_SIL_Init();
+  bDeviceState = UNCONNECTED;
+}
+
+/*********************************************************************
+ * @fn      USBD_Reset
+ *
+ * @brief   Virtual_Com_Port Mouse reset routine
+ *
+ * @return  none.
+ */
+void USBD_Reset(void)
+{
+  pInformation->Current_Configuration = 0;
+  pInformation->Current_Feature = USBD_ConfigDescriptor[7];
+  pInformation->Current_Interface = 0;
+
+  SetBTABLE(BTABLE_ADDRESS);
+
+  //EP0
+  SetEPType(ENDP0, EP_CONTROL);
+  SetEPTxStatus(ENDP0, EP_TX_STALL);
+  SetEPRxAddr(ENDP0, ENDP0_RXADDR);
+  SetEPTxAddr(ENDP0, ENDP0_TXADDR);
+  Clear_Status_Out(ENDP0);
+  SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
+  SetEPRxValid(ENDP0);
+  _ClearDTOG_RX(ENDP0);
+  _ClearDTOG_TX(ENDP0);
+
+  //EP2
+  SetEPType(ENDP2, EP_BULK);
+  SetEPTxAddr(ENDP2, ENDP2_TXADDR);
+  SetEPRxAddr(ENDP2, ENDP2_RXADDR);
+  SetEPRxCount(ENDP2, USBD_DATA_SIZE);
+  SetEPRxStatus(ENDP2, EP_RX_VALID);
+  SetEPTxStatus(ENDP2, EP_TX_NAK);
+  _ClearDTOG_RX(ENDP2);
+  _ClearDTOG_TX(ENDP2);
+
+  SetDeviceAddress(0);
+
+  bDeviceState = ATTACHED;
+}
+
+/*********************************************************************
+ * @fn      USBD_GetDeviceDescriptor.
+ *
+ * @brief   Gets the device descriptor.
+ *
+ * @param   Length.
+ *
+ * @return  The address of the device descriptor.
+ */
+uint8_t *USBD_GetDeviceDescriptor(uint16_t Length)
+{
+  return Standard_GetDescriptorData(Length, &Device_Descriptor);
+}
+
+/*********************************************************************
+ * @fn      USBD_GetConfigDescriptor.
+ *
+ * @brief   get the configuration descriptor.
+ *
+ * @param   Length.
+ *
+ * @return  The address of the configuration descriptor.
+ */
+uint8_t *USBD_GetConfigDescriptor(uint16_t Length)
+{
+  return Standard_GetDescriptorData(Length, &Config_Descriptor);
+}
+
+/*********************************************************************
+ * @fn      USBD_GetStringDescriptor
+ *
+ * @brief   Gets the string descriptors according to the needed index
+ *
+ * @param   Length.
+ *
+ * @return  The address of the string descriptors.
+ */
+uint8_t *USBD_GetStringDescriptor(uint16_t Length)
+{
+  uint8_t wValue0 = pInformation->USBwValue0;
+
+  if (wValue0 > 4)
+  {
+    return NULL;
+  }
+  else
+  {
+    return Standard_GetDescriptorData(Length, &String_Descriptor[wValue0]);
+  }
+}
+
+/*********************************************************************
+ * @fn      USBD_Get_Interface_Setting.
+ *
+ * @brief   test the interface and the alternate setting according to the
+ *          supported one.
+ * @param   Interface - interface number.
+ *          AlternateSetting - Alternate Setting number.
+ *
+ * @return  none
+ */
+RESULT USBD_Get_Interface_Setting(uint8_t Interface, uint8_t AlternateSetting)
+{
+  if (AlternateSetting > 0)
+  {
+    return USB_UNSUPPORT;
+  }
+  else if (Interface > 1)
+  {
+    return USB_UNSUPPORT;
+  }
+
+  return USB_SUCCESS;
+}
+
+/*********************************************************************
+ * @fn      USBD_Data_Setup
+ *
+ * @brief   handle the data class specific requests
+ *
+ * @return  USB_UNSUPPORT or USB_SUCCESS.
+ */
+RESULT USBD_Data_Setup(uint8_t RequestNo)
+{
+
+  return USB_SUCCESS;
+}
+
+/*********************************************************************
+ * @fn      USBD_NoData_Setup.
+ *
+ * @brief   handle the no data class specific requests.
+ *
+ * @return  USB_UNSUPPORT or USB_SUCCESS.
+ */
+RESULT USBD_NoData_Setup(uint8_t RequestNo)
+{
+  return USB_SUCCESS;
+}
+
+/*********************************************************************
+ * @fn      Virtual_Com_Port_GetLineCoding.
+ *
+ * @brief   send the linecoding structure to the PC host.
+ *
+ * @return  Linecoding structure base address.
+ */
+uint8_t *Virtual_Com_Port_GetLineCoding(uint16_t Length)
+{
+  return 0;
+}
+
+/*********************************************************************
+ * @fn      Virtual_Com_Port_SetLineCoding.
+ *
+ * @brief   Set the linecoding structure fields.
+ *
+ * @return  Linecoding structure base address.
+ */
+uint8_t *Virtual_Com_Port_SetLineCoding(uint16_t Length)
+{
+  return 0;
+}
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_prop.h

@@ -0,0 +1,61 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_prop.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : All processing related to Virtual COM Port Demo (Endpoint 0) 
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#ifndef __usb_prop_H
+#define __usb_prop_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ch32v20x.h"
+
+#define USBD_GetConfiguration          NOP_Process
+//#define USBD_SetConfiguration          NOP_Process
+#define USBD_GetInterface              NOP_Process
+#define USBD_SetInterface              NOP_Process
+#define USBD_GetStatus                 NOP_Process
+#define USBD_ClearFeature              NOP_Process
+#define USBD_SetEndPointFeature        NOP_Process
+#define USBD_SetDeviceFeature          NOP_Process
+//#define USBD_SetDeviceAddress          NOP_Process
+
+#define SEND_ENCAPSULATED_COMMAND   0x00
+#define GET_ENCAPSULATED_RESPONSE   0x01
+#define SET_COMM_FEATURE            0x02
+#define GET_COMM_FEATURE            0x03
+#define CLEAR_COMM_FEATURE          0x04
+#define SET_LINE_CODING             0x20
+#define GET_LINE_CODING             0x21
+#define SET_CONTROL_LINE_STATE      0x22
+#define SEND_BREAK                  0x23
+
+void USBD_init(void);
+void USBD_Reset(void);
+void USBD_SetConfiguration(void);
+void USBD_SetDeviceAddress(void);
+void USBD_Status_In(void);
+void USBD_Status_Out(void);
+RESULT USBD_Data_Setup(uint8_t);
+RESULT USBD_NoData_Setup(uint8_t);
+RESULT USBD_Get_Interface_Setting(uint8_t Interface, uint8_t AlternateSetting);
+uint8_t *USBD_GetDeviceDescriptor(uint16_t);
+uint8_t *USBD_GetConfigDescriptor(uint16_t);
+uint8_t *USBD_GetStringDescriptor(uint16_t);
+
+uint8_t *USBD_GetLineCoding(uint16_t Length);
+uint8_t *USBD_SetLineCoding(uint16_t Length);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __usb_prop_H */
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_pwr.c

@@ -0,0 +1,215 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_pwr.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Connection/disconnection & power management
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+#include "usb_conf.h"
+#include "usb_pwr.h"
+#include "hw_config.h"
+
+__IO uint32_t bDeviceState = UNCONNECTED; 
+__IO bool fSuspendEnabled = TRUE;  
+__IO uint32_t EP[8];
+
+struct
+{
+  __IO RESUME_STATE eState;
+  __IO uint8_t bESOFcnt;
+}
+ResumeS;
+
+__IO uint32_t remotewakeupon=0;
+
+/*******************************************************************************
+ * @fn      PowerOn
+ *
+ * @brief   Enable power on.
+ *
+ * @return  USB_SUCCESS.
+ */
+RESULT PowerOn(void)
+{
+  uint16_t wRegVal;
+
+  wRegVal = CNTR_FRES;
+  _SetCNTR(wRegVal);
+  wInterrupt_Mask = 0;
+  _SetCNTR(wInterrupt_Mask);
+  _SetISTR(0);
+  wInterrupt_Mask = CNTR_RESETM | CNTR_SUSPM | CNTR_WKUPM;
+  _SetCNTR(wInterrupt_Mask);
+  
+  return USB_SUCCESS;
+}
+
+/*******************************************************************************
+ * @fn      PowerOff
+ *
+ * @brief   handles switch-off conditions
+ *
+ * @return  USB_SUCCESS.
+ */
+RESULT PowerOff()
+{
+  _SetCNTR(CNTR_FRES); 
+  _SetISTR(0); 
+  _SetCNTR(CNTR_FRES + CNTR_PDWN);
+
+  return USB_SUCCESS;
+}
+
+/*******************************************************************************
+ * @fn        Suspend
+ *
+ * @brief     sets suspend mode operating conditions
+ *
+ * @return    USB_SUCCESS.
+ */
+void Suspend(void)
+{
+	uint32_t i =0;
+	uint16_t wCNTR; 
+
+	wCNTR = _GetCNTR();  
+  for (i=0;i<8;i++) EP[i] = _GetENDPOINT(i);
+	
+	wCNTR|=CNTR_RESETM;
+	_SetCNTR(wCNTR);
+	
+	wCNTR|=CNTR_FRES;
+	_SetCNTR(wCNTR);
+	
+	wCNTR&=~CNTR_FRES;
+	_SetCNTR(wCNTR);
+
+	while((_GetISTR()&ISTR_RESET) == 0);
+	
+	_SetISTR((uint16_t)CLR_RESET);
+	
+	for (i=0;i<8;i++)
+	_SetENDPOINT(i, EP[i]);
+	
+	wCNTR |= CNTR_FSUSP;
+	_SetCNTR(wCNTR);
+	
+	wCNTR = _GetCNTR();
+	wCNTR |= CNTR_LPMODE;
+	_SetCNTR(wCNTR);
+
+	Enter_LowPowerMode();
+}
+
+/*******************************************************************************
+ * @fn       Resume_Init
+ *
+ * @brief    Handles wake-up restoring normal operations
+ *
+ * @return   USB_SUCCESS.
+ */
+void Resume_Init(void)
+{
+  uint16_t wCNTR;
+  
+  wCNTR = _GetCNTR();
+  wCNTR &= (~CNTR_LPMODE);
+  _SetCNTR(wCNTR);      
+  Leave_LowPowerMode();
+  _SetCNTR(IMR_MSK);
+}
+
+/*******************************************************************************
+ * @fn       Resume
+ *
+ * @brief    This is the state machine handling resume operations and
+ *                 timing sequence. The control is based on the Resume structure
+ *                 variables and on the ESOF interrupt calling this subroutine
+ *                 without changing machine state.
+ *
+ * @param    a state machine value (RESUME_STATE)
+ *                  RESUME_ESOF doesn't change ResumeS.eState allowing
+ *                  decrementing of the ESOF counter in different states.
+ *
+ * @return  None.
+ */
+void Resume(RESUME_STATE eResumeSetVal)
+{
+  uint16_t wCNTR;
+
+  if (eResumeSetVal != RESUME_ESOF)
+	{
+   ResumeS.eState = eResumeSetVal;
+	}
+	
+  switch (ResumeS.eState)
+  {
+    case RESUME_EXTERNAL:
+      if (remotewakeupon ==0)
+      {
+        Resume_Init();
+        ResumeS.eState = RESUME_OFF;
+      }
+      else 
+      {
+        ResumeS.eState = RESUME_ON;
+      }
+      break;
+			
+    case RESUME_INTERNAL:
+      Resume_Init();
+      ResumeS.eState = RESUME_START;
+      remotewakeupon = 1;
+      break;
+		
+    case RESUME_LATER:
+      ResumeS.bESOFcnt = 2;
+      ResumeS.eState = RESUME_WAIT;
+      break;
+		
+    case RESUME_WAIT:
+      ResumeS.bESOFcnt--;
+      if (ResumeS.bESOFcnt == 0)
+        ResumeS.eState = RESUME_START;
+      break;
+			
+    case RESUME_START:
+      wCNTR = _GetCNTR();
+      wCNTR |= CNTR_RESUME;
+      _SetCNTR(wCNTR);
+      ResumeS.eState = RESUME_ON;
+      ResumeS.bESOFcnt = 10;
+      break;
+		
+    case RESUME_ON:    
+      ResumeS.bESOFcnt--;
+      if (ResumeS.bESOFcnt == 0)
+      {
+        wCNTR = _GetCNTR();
+        wCNTR &= (~CNTR_RESUME);
+        _SetCNTR(wCNTR);
+        ResumeS.eState = RESUME_OFF;
+        remotewakeupon = 0;
+      }
+      break;
+			
+    case RESUME_OFF:
+			
+    case RESUME_ESOF:
+			
+    default:
+      ResumeS.eState = RESUME_OFF;
+      break;
+  }
+}
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/CONFIG/usb_pwr.h

@@ -0,0 +1,62 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_pwr.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Connection/disconnection & power management header 
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_PWR_H
+#define __USB_PWR_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+	 
+#include "ch32v20x.h"
+typedef enum _RESUME_STATE
+{
+  RESUME_EXTERNAL,
+  RESUME_INTERNAL,
+  RESUME_LATER,
+  RESUME_WAIT,
+  RESUME_START,
+  RESUME_ON,
+  RESUME_OFF,
+  RESUME_ESOF
+} RESUME_STATE;
+
+typedef enum _DEVICE_STATE
+{
+  UNCONNECTED,
+  ATTACHED,
+  POWERED,
+  SUSPENDED,
+  ADDRESSED,
+  CONFIGURED
+} DEVICE_STATE;
+
+
+void Suspend(void);
+void Resume_Init(void);
+void Resume(RESUME_STATE eResumeSetVal);
+RESULT PowerOn(void);
+RESULT PowerOff(void);
+
+extern  __IO uint32_t bDeviceState; /* USB device status */
+extern __IO bool fSuspendEnabled;  /* true when suspend is possible */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /*__USB_PWR_H*/
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_core.h

@@ -0,0 +1,191 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_core.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB cor firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_CORE_H
+#define __USB_CORE_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include "ch32v20x.h"
+
+	 
+typedef enum _CONTROL_STATE
+{
+  WAIT_SETUP,       /* 0 */
+  SETTING_UP,       /* 1 */
+  IN_DATA,          /* 2 */
+  OUT_DATA,         /* 3 */
+  LAST_IN_DATA,     /* 4 */
+  LAST_OUT_DATA,    /* 5 */
+  WAIT_STATUS_IN,   /* 7 */
+  WAIT_STATUS_OUT,  /* 8 */
+  STALLED,          /* 9 */
+  PAUSE             /* 10 */
+} CONTROL_STATE;    /* The state machine states of a control pipe */
+
+typedef struct OneDescriptor
+{
+  uint8_t *Descriptor;
+  uint16_t Descriptor_Size;
+}
+ONE_DESCRIPTOR, *PONE_DESCRIPTOR;
+
+typedef enum _RESULT
+{
+  USB_SUCCESS = 0,    /* Process successfully */
+  USB_ERROR,
+  USB_UNSUPPORT,
+  USB_NOT_READY       /* The process has not been finished, endpoint will be
+                         NAK to further request */
+} RESULT;
+
+
+/* Definitions for endpoint level */
+typedef struct _ENDPOINT_INFO
+{
+  uint16_t  Usb_wLength;
+  uint16_t  Usb_wOffset;
+  uint16_t  PacketSize;
+  uint8_t   *(*CopyData)(uint16_t Length);
+}ENDPOINT_INFO;
+
+/* Definitions for device level */
+typedef struct _DEVICE
+{
+  uint8_t Total_Endpoint;     /* Number of endpoints that are used */
+  uint8_t Total_Configuration;/* Number of configuration available */
+}
+DEVICE;
+
+typedef union
+{
+  uint16_t w;
+  struct BW
+  {
+    uint8_t bb1;
+    uint8_t bb0;
+  }
+  bw;
+} uint16_t_uint8_t;
+
+typedef struct _DEVICE_INFO
+{
+  uint8_t USBbmRequestType;       /* bmRequestType */
+  uint8_t USBbRequest;            /* bRequest */
+  uint16_t_uint8_t USBwValues;         /* wValue */
+  uint16_t_uint8_t USBwIndexs;         /* wIndex */
+  uint16_t_uint8_t USBwLengths;        /* wLength */
+
+  uint8_t ControlState;           /* of type CONTROL_STATE */
+  uint8_t Current_Feature;
+  uint8_t Current_Configuration;   /* Selected configuration */
+  uint8_t Current_Interface;       /* Selected interface of current configuration */
+  uint8_t Current_AlternateSetting;/* Selected Alternate Setting of current
+                                     interface*/
+
+  ENDPOINT_INFO Ctrl_Info;
+}DEVICE_INFO;
+
+typedef struct _DEVICE_PROP
+{
+  void (*Init)(void);        /* Initialize the device */
+  void (*Reset)(void);       /* Reset routine of this device */
+  void (*Process_Status_IN)(void);
+  void (*Process_Status_OUT)(void);
+
+  RESULT (*Class_Data_Setup)(uint8_t RequestNo);
+
+  RESULT (*Class_NoData_Setup)(uint8_t RequestNo);
+
+  RESULT  (*Class_Get_Interface_Setting)(uint8_t Interface, uint8_t AlternateSetting);
+
+  uint8_t* (*GetDeviceDescriptor)(uint16_t Length);
+  uint8_t* (*GetConfigDescriptor)(uint16_t Length);
+  uint8_t* (*GetStringDescriptor)(uint16_t Length);
+
+  void* RxEP_buffer;
+   
+  uint8_t MaxPacketSize;
+
+}DEVICE_PROP;
+
+typedef struct _USER_STANDARD_REQUESTS
+{
+  void (*User_GetConfiguration)(void);       /* Get Configuration */
+  void (*User_SetConfiguration)(void);       /* Set Configuration */
+  void (*User_GetInterface)(void);           /* Get Interface */
+  void (*User_SetInterface)(void);           /* Set Interface */
+  void (*User_GetStatus)(void);              /* Get Status */
+  void (*User_ClearFeature)(void);           /* Clear Feature */
+  void (*User_SetEndPointFeature)(void);     /* Set Endpoint Feature */
+  void (*User_SetDeviceFeature)(void);       /* Set Device Feature */
+  void (*User_SetDeviceAddress)(void);       /* Set Device Address */
+}
+USER_STANDARD_REQUESTS;
+
+
+#define Type_Recipient (pInformation->USBbmRequestType & (REQUEST_TYPE | RECIPIENT))
+
+#define Usb_rLength Usb_wLength
+#define Usb_rOffset Usb_wOffset
+
+#define USBwValue USBwValues.w
+#define USBwValue0 USBwValues.bw.bb0
+#define USBwValue1 USBwValues.bw.bb1
+#define USBwIndex USBwIndexs.w
+#define USBwIndex0 USBwIndexs.bw.bb0
+#define USBwIndex1 USBwIndexs.bw.bb1
+#define USBwLength USBwLengths.w
+#define USBwLength0 USBwLengths.bw.bb0
+#define USBwLength1 USBwLengths.bw.bb1
+
+
+uint8_t Setup0_Process(void);
+uint8_t Post0_Process(void);
+uint8_t Out0_Process(void);
+uint8_t In0_Process(void);
+
+RESULT Standard_SetEndPointFeature(void);
+RESULT Standard_SetDeviceFeature(void);
+
+uint8_t *Standard_GetConfiguration(uint16_t Length);
+RESULT Standard_SetConfiguration(void);
+uint8_t *Standard_GetInterface(uint16_t Length);
+RESULT Standard_SetInterface(void);
+uint8_t *Standard_GetDescriptorData(uint16_t Length, PONE_DESCRIPTOR pDesc);
+
+uint8_t *Standard_GetStatus(uint16_t Length);
+RESULT Standard_ClearFeature(void);
+void SetDeviceAddress(uint8_t);
+void NOP_Process(void);
+
+extern DEVICE_PROP Device_Property;
+extern  USER_STANDARD_REQUESTS User_Standard_Requests;
+extern  DEVICE  Device_Table;
+extern DEVICE_INFO Device_Info;
+
+/* cells saving status during interrupt servicing */
+extern __IO uint16_t SaveRState;
+extern __IO uint16_t SaveTState;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __USB_CORE_H */
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_def.h

@@ -0,0 +1,82 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_def.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB definition firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_DEF_H
+#define __USB_DEF_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include "ch32v20x.h"
+
+typedef enum _RECIPIENT_TYPE
+{
+  DEVICE_RECIPIENT,     
+  INTERFACE_RECIPIENT,  
+  ENDPOINT_RECIPIENT,   
+  OTHER_RECIPIENT
+} RECIPIENT_TYPE;
+
+typedef enum _STANDARD_REQUESTS
+{
+  GET_STATUS = 0,
+  CLEAR_FEATURE,
+  RESERVED1,
+  SET_FEATURE,
+  RESERVED2,
+  SET_ADDRESS,
+  GET_DESCRIPTOR,
+  SET_DESCRIPTOR,
+  GET_CONFIGURATION,
+  SET_CONFIGURATION,
+  GET_INTERFACE,
+  SET_INTERFACE,
+  TOTAL_sREQUEST,  
+  SYNCH_FRAME = 12
+} STANDARD_REQUESTS;
+
+/* Definition of "USBwValue" */
+typedef enum _DESCRIPTOR_TYPE
+{
+  DEVICE_DESCRIPTOR = 1,
+  CONFIG_DESCRIPTOR,
+  STRING_DESCRIPTOR,
+  INTERFACE_DESCRIPTOR,
+  ENDPOINT_DESCRIPTOR
+} DESCRIPTOR_TYPE;
+
+/* Feature selector of a SET_FEATURE or CLEAR_FEATURE */
+typedef enum _FEATURE_SELECTOR
+{
+  ENDPOINT_STALL,
+  DEVICE_REMOTE_WAKEUP
+} FEATURE_SELECTOR;
+
+/* Definition of "USBbmRequestType" */
+#define REQUEST_TYPE      0x60  
+#define STANDARD_REQUEST  0x00  
+#define CLASS_REQUEST     0x20 
+#define VENDOR_REQUEST    0x40  
+#define RECIPIENT         0x1F  
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __USB_DEF_H */
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_init.h

@@ -0,0 +1,42 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_init.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB Initialization firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_INIT_H
+#define __USB_INIT_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+	 
+#include "ch32v20x.h"
+
+	 
+void USB_Init(void);
+extern uint8_t	EPindex;
+extern DEVICE_INFO*	pInformation;
+extern DEVICE_PROP*	pProperty;
+extern USER_STANDARD_REQUESTS *pUser_Standard_Requests;
+extern uint16_t	SaveState ;
+extern uint16_t wInterrupt_Mask;
+
+#ifdef __cplusplus
+}
+
+#endif
+
+
+#endif /* __USB_INIT_H */
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_int.h

@@ -0,0 +1,25 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_int.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB Endpoint firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_INT_H
+#define __USB_INT_H
+
+void CTR_LP(void);
+void CTR_HP(void);
+
+#endif /* __USB_INT_H */
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_lib.h

@@ -0,0 +1,30 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_lib.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Library configuration file for USB.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_LIB_H
+#define __USB_LIB_H
+
+#include "hw_config.h"
+#include "usb_type.h"
+#include "usb_regs.h"
+#include "usb_def.h"
+#include "usb_core.h"
+#include "usb_init.h"
+#include "usb_sil.h"
+#include "usb_mem.h"
+#include "usb_int.h"
+//#include "ch32f20x_usb.h"
+
+#endif /* __USB_LIB_H */
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_mem.h

@@ -0,0 +1,36 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_mem.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB Initialization firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_MEM_H
+#define __USB_MEM_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include "ch32v20x.h"
+
+void UserToPMABufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes);
+void PMAToUserBufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /*__USB_MEM_H*/
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_regs.h

@@ -0,0 +1,675 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_regs.h
+ * Author             : WCH
+ * Version            : V1.0.1
+ * Date               : 2022/12/28
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB cell registers firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_REGS_H
+#define __USB_REGS_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include "ch32v20x.h"
+	 
+typedef enum _EP_DBUF_DIR
+{
+  EP_DBUF_ERR,
+  EP_DBUF_OUT,
+  EP_DBUF_IN
+}EP_DBUF_DIR;
+
+/* endpoint buffer number */
+enum EP_BUF_NUM
+{
+  EP_NOBUF,
+  EP_BUF0,
+  EP_BUF1
+};
+
+extern uint16_t Ep0RxBlks;
+
+#define RegBase  (0x40005C00L)  
+#define PMAAddr  (0x40006000L)  
+
+/******************************************************************************/
+/*                         General registers                                  */
+/******************************************************************************/
+
+/* Control register */
+#define CNTLR    ((__IO unsigned *)(RegBase + 0x40))
+/* Interrupt status register */
+#define ISTR    ((__IO unsigned *)(RegBase + 0x44))
+/* Frame number register */
+#define FNR     ((__IO unsigned *)(RegBase + 0x48))
+/* Device address register */
+#define DADDR   ((__IO unsigned *)(RegBase + 0x4C))
+/* Buffer Table address register */
+#define BTABLE  ((__IO unsigned *)(RegBase + 0x50))
+/******************************************************************************/
+/*                         Endpoint registers                                 */
+/******************************************************************************/
+#define EP0REG  ((__IO unsigned *)(RegBase)) /* endpoint 0 register address */
+
+/* Endpoint Addresses (w/direction) */
+#define EP0_OUT     ((uint8_t)0x00)  
+#define EP0_IN      ((uint8_t)0x80) 
+#define EP1_OUT     ((uint8_t)0x01)  
+#define EP1_IN      ((uint8_t)0x81)  
+#define EP2_OUT     ((uint8_t)0x02)  
+#define EP2_IN      ((uint8_t)0x82)  
+#define EP3_OUT     ((uint8_t)0x03)  
+#define EP3_IN      ((uint8_t)0x83) 
+#define EP4_OUT     ((uint8_t)0x04)  
+#define EP4_IN      ((uint8_t)0x84)
+#define EP5_OUT     ((uint8_t)0x05)  
+#define EP5_IN      ((uint8_t)0x85)
+#define EP6_OUT     ((uint8_t)0x06)  
+#define EP6_IN      ((uint8_t)0x86)
+#define EP7_OUT     ((uint8_t)0x07)  
+#define EP7_IN      ((uint8_t)0x87)
+
+/* endpoints enumeration */
+#define ENDP0       ((uint8_t)0)
+#define ENDP1       ((uint8_t)1)
+#define ENDP2       ((uint8_t)2)
+#define ENDP3       ((uint8_t)3)
+#define ENDP4       ((uint8_t)4)
+#define ENDP5       ((uint8_t)5)
+#define ENDP6       ((uint8_t)6)
+#define ENDP7       ((uint8_t)7)
+
+/******************************************************************************/
+/*                       ISTR interrupt events                                */
+/******************************************************************************/
+#define ISTR_CTR    (0x8000) /* Correct TRansfer (clear-only bit) */
+#define ISTR_DOVR   (0x4000) /* DMA OVeR/underrun (clear-only bit) */
+#define ISTR_ERR    (0x2000) /* ERRor (clear-only bit) */
+#define ISTR_WKUP   (0x1000) /* WaKe UP (clear-only bit) */
+#define ISTR_SUSP   (0x0800) /* SUSPend (clear-only bit) */
+#define ISTR_RESET  (0x0400) /* RESET (clear-only bit) */
+#define ISTR_SOF    (0x0200) /* Start Of Frame (clear-only bit) */
+#define ISTR_ESOF   (0x0100) /* Expected Start Of Frame (clear-only bit) */
+
+
+#define ISTR_DIR    (0x0010)  /* DIRection of transaction (read-only bit)  */
+#define ISTR_EP_ID  (0x000F)  /* EndPoint IDentifier (read-only bit)  */
+
+#define CLR_CTR    (~ISTR_CTR)   /* clear Correct TRansfer bit */
+#define CLR_DOVR   (~ISTR_DOVR)  /* clear DMA OVeR/underrun bit*/
+#define CLR_ERR    (~ISTR_ERR)   /* clear ERRor bit */
+#define CLR_WKUP   (~ISTR_WKUP)  /* clear WaKe UP bit     */
+#define CLR_SUSP   (~ISTR_SUSP)  /* clear SUSPend bit     */
+#define CLR_RESET  (~ISTR_RESET) /* clear RESET bit      */
+#define CLR_SOF    (~ISTR_SOF)   /* clear Start Of Frame bit   */
+#define CLR_ESOF   (~ISTR_ESOF)  /* clear Expected Start Of Frame bit */
+
+/******************************************************************************/
+/*             CNTR control register bits definitions                         */
+/******************************************************************************/
+#define CNTR_CTRM   (0x8000) /* Correct TRansfer Mask */
+#define CNTR_DOVRM  (0x4000) /* DMA OVeR/underrun Mask */
+#define CNTR_ERRM   (0x2000) /* ERRor Mask */
+#define CNTR_WKUPM  (0x1000) /* WaKe UP Mask */
+#define CNTR_SUSPM  (0x0800) /* SUSPend Mask */
+#define CNTR_RESETM (0x0400) /* RESET Mask   */
+#define CNTR_SOFM   (0x0200) /* Start Of Frame Mask */
+#define CNTR_ESOFM  (0x0100) /* Expected Start Of Frame Mask */
+
+
+#define CNTR_RESUME (0x0010) /* RESUME request */
+#define CNTR_FSUSP  (0x0008) /* Force SUSPend */
+#define CNTR_LPMODE (0x0004) /* Low-power MODE */
+#define CNTR_PDWN   (0x0002) /* Power DoWN */
+#define CNTR_FRES   (0x0001) /* Force USB RESet */
+
+/******************************************************************************/
+/*                FNR Frame Number Register bit definitions                   */
+/******************************************************************************/
+#define FNR_RXDP    (0x8000) /* status of D+ data line */
+#define FNR_RXDM    (0x4000) /* status of D- data line */
+#define FNR_LCK     (0x2000) /* LoCKed */
+#define FNR_LSOF    (0x1800) /* Lost SOF */
+#define FNR_FN      (0x07FF) /* Frame Number */
+/******************************************************************************/
+/*               DADDR Device ADDRess bit definitions                         */
+/******************************************************************************/
+#define DADDR_EF    (0x80)
+#define DADDR_ADD   (0x7F)
+/******************************************************************************/
+/*                            Endpoint register                               */
+/******************************************************************************/
+/* bit positions */
+#define EP_CTR_RX      (0x8000) /* EndPoint Correct TRansfer RX */
+#define EP_DTOG_RX     (0x4000) /* EndPoint Data TOGGLE RX */
+#define EPRX_STAT      (0x3000) /* EndPoint RX STATus bit field */
+#define EP_SETUP       (0x0800) /* EndPoint SETUP */
+#define EP_T_FIELD     (0x0600) /* EndPoint TYPE */
+#define EP_KIND        (0x0100) /* EndPoint KIND */
+#define EP_CTR_TX      (0x0080) /* EndPoint Correct TRansfer TX */
+#define EP_DTOG_TX     (0x0040) /* EndPoint Data TOGGLE TX */
+#define EPTX_STAT      (0x0030) /* EndPoint TX STATus bit field */
+#define EPADDR_FIELD   (0x000F) /* EndPoint ADDRess FIELD */
+
+/* EndPoint REGister MASK (no toggle fields) */
+#define EPREG_MASK     (EP_CTR_RX|EP_SETUP|EP_T_FIELD|EP_KIND|EP_CTR_TX|EPADDR_FIELD)
+
+/* EP_TYPE[1:0] EndPoint TYPE */
+#define EP_TYPE_MASK   (0x0600) /* EndPoint TYPE Mask */
+#define EP_BULK        (0x0000) /* EndPoint BULK */
+#define EP_CONTROL     (0x0200) /* EndPoint CONTROL */
+#define EP_ISOCHRONOUS (0x0400) /* EndPoint ISOCHRONOUS */
+#define EP_INTERRUPT   (0x0600) /* EndPoint INTERRUPT */
+#define EP_T_MASK      (~EP_T_FIELD & EPREG_MASK)
+
+
+/* EP_KIND EndPoint KIND */
+#define EPKIND_MASK    (~EP_KIND & EPREG_MASK)
+
+/* STAT_TX[1:0] STATus for TX transfer */
+#define EP_TX_DIS      (0x0000) /* EndPoint TX DISabled */
+#define EP_TX_STALL    (0x0010) /* EndPoint TX STALLed */
+#define EP_TX_NAK      (0x0020) /* EndPoint TX NAKed */
+#define EP_TX_VALID    (0x0030) /* EndPoint TX VALID */
+#define EPTX_DTOG1     (0x0010) /* EndPoint TX Data TOGgle bit1 */
+#define EPTX_DTOG2     (0x0020) /* EndPoint TX Data TOGgle bit2 */
+#define EPTX_DTOGMASK  (EPTX_STAT|EPREG_MASK)
+
+/* STAT_RX[1:0] STATus for RX transfer */
+#define EP_RX_DIS      (0x0000) /* EndPoint RX DISabled */
+#define EP_RX_STALL    (0x1000) /* EndPoint RX STALLed */
+#define EP_RX_NAK      (0x2000) /* EndPoint RX NAKed */
+#define EP_RX_VALID    (0x3000) /* EndPoint RX VALID */
+#define EPRX_DTOG1     (0x1000) /* EndPoint RX Data TOGgle bit1 */
+#define EPRX_DTOG2     (0x2000) /* EndPoint RX Data TOGgle bit1 */
+#define EPRX_DTOGMASK  (EPRX_STAT|EPREG_MASK)
+
+/* SetCNTR */
+#define _SetCNTR(wRegValue)  (*CNTLR   = (uint16_t)wRegValue)
+
+/* SetISTR */
+#define _SetISTR(wRegValue)  (*ISTR   = (uint16_t)wRegValue)
+
+/* SetDADDR */
+#define _SetDADDR(wRegValue) (*DADDR  = (uint16_t)wRegValue)
+
+/* SetBTABLE */
+#define _SetBTABLE(wRegValue)(*BTABLE = (uint16_t)(wRegValue & 0xFFF8))
+
+/* GetCNTR */
+#define _GetCNTR()   ((uint16_t) *CNTLR)
+
+/* GetISTR */
+#define _GetISTR()   ((uint16_t) *ISTR)
+
+/* GetFNR */
+#define _GetFNR()    ((uint16_t) *FNR)
+
+/* GetDADDR */
+#define _GetDADDR()  ((uint16_t) *DADDR)
+
+/* GetBTABLE */
+#define _GetBTABLE() ((uint16_t) *BTABLE)
+
+/* SetENDPOINT */
+#define _SetENDPOINT(bEpNum,wRegValue)  (*(EP0REG + bEpNum)= \
+    (uint16_t)wRegValue)
+
+/* GetENDPOINT */
+#define _GetENDPOINT(bEpNum)        ((uint16_t)(*(EP0REG + bEpNum)))
+
+#define _SetEPType(bEpNum,wType) (_SetENDPOINT(bEpNum,\
+                                  ((_GetENDPOINT(bEpNum) & EP_T_MASK) | wType )))
+
+#define _GetEPType(bEpNum) (_GetENDPOINT(bEpNum) & EP_T_FIELD)
+
+/*******************************************************************************
+* Macro Name     : SetEPTxStatus
+* Description    : sets the status for tx transfer (bits STAT_TX[1:0]).
+* Input          : bEpNum: Endpoint Number. 
+*                  wState: new state
+* Return         : None.
+*******************************************************************************/
+#define _SetEPTxStatus(bEpNum,wState) {\
+    register uint16_t _wRegVal;       \
+    _wRegVal = _GetENDPOINT(bEpNum) & EPTX_DTOGMASK;\
+    /* toggle first bit ? */     \
+    if((EPTX_DTOG1 & wState)!= 0)      \
+      _wRegVal ^= EPTX_DTOG1;        \
+    /* toggle second bit ?  */         \
+    if((EPTX_DTOG2 & wState)!= 0)      \
+      _wRegVal ^= EPTX_DTOG2;        \
+    _SetENDPOINT(bEpNum, (_wRegVal | EP_CTR_RX|EP_CTR_TX));    \
+    while( ( _GetENDPOINT(bEpNum) & EPTX_STAT ) != wState ) \
+    { \
+        _SetENDPOINT(bEpNum, (_wRegVal | EP_CTR_RX|EP_CTR_TX));    \
+    }; \
+  } /* _SetEPTxStatus */
+
+/*******************************************************************************
+* Macro Name     : SetEPRxStatus
+* Description    : sets the status for rx transfer (bits STAT_TX[1:0])
+* Input          : bEpNum: Endpoint Number. 
+*                  wState: new state.
+* Return         : None.
+*******************************************************************************/
+#define _SetEPRxStatus(bEpNum,wState) {\
+    register uint16_t _wRegVal;   \
+    \
+    _wRegVal = _GetENDPOINT(bEpNum) & EPRX_DTOGMASK;\
+    /* toggle first bit ? */  \
+    if((EPRX_DTOG1 & wState)!= 0) \
+      _wRegVal ^= EPRX_DTOG1;  \
+    /* toggle second bit ? */  \
+    if((EPRX_DTOG2 & wState)!= 0) \
+      _wRegVal ^= EPRX_DTOG2;  \
+    _SetENDPOINT(bEpNum, (_wRegVal | EP_CTR_RX|EP_CTR_TX)); \
+    while( ( _GetENDPOINT(bEpNum) & EPRX_STAT ) != wState ) \
+    { \
+        _SetENDPOINT(bEpNum, (_wRegVal | EP_CTR_RX|EP_CTR_TX)); \
+    } \
+  } /* _SetEPRxStatus */
+
+/*******************************************************************************
+* Macro Name     : SetEPRxTxStatus
+* Description    : sets the status for rx & tx (bits STAT_TX[1:0] & STAT_RX[1:0])
+* Input          : bEpNum: Endpoint Number. 
+*                  wStaterx: new state.
+*                  wStatetx: new state.
+* Output         : None.
+* Return         : None.
+*******************************************************************************/
+#define _SetEPRxTxStatus(bEpNum,wStaterx,wStatetx) {\
+    register uint32_t _wRegVal_T, _wRegVal_R;   \
+    \
+    _wRegVal_T = _GetENDPOINT(bEpNum) & EPTX_DTOGMASK;  \
+    _wRegVal_R = _GetENDPOINT(bEpNum) & EPRX_DTOGMASK;  \
+    /* toggle first bit ? */  \
+    if((EPRX_DTOG1 & wStaterx)!= 0) \
+      _wRegVal_R ^= EPRX_DTOG1;  \
+    /* toggle second bit ? */  \
+    if((EPRX_DTOG2 & wStaterx)!= 0) \
+      _wRegVal_R ^= EPRX_DTOG2;  \
+    /* toggle first bit ? */   \
+    if((EPTX_DTOG1 & wStatetx)!= 0) \
+      _wRegVal_T ^= EPTX_DTOG1;  \
+    /* toggle second bit ?  */ \
+    if((EPTX_DTOG2 & wStatetx)!= 0) \
+      _wRegVal_T ^= EPTX_DTOG2;  \
+    _SetENDPOINT(bEpNum, _wRegVal_T |_wRegVal_R | EP_CTR_RX | EP_CTR_TX);  \
+    while( ( _GetENDPOINT(bEpNum) & EPTX_STAT ) != wStatetx ) \
+    { \
+        _SetENDPOINT(bEpNum, _wRegVal_T | EP_CTR_RX | EP_CTR_TX);  \
+    } \
+    while( ( _GetENDPOINT(bEpNum) & EPRX_STAT ) != wStaterx ) \
+    { \
+        _SetENDPOINT(bEpNum, _wRegVal_R | EP_CTR_RX | EP_CTR_TX);  \
+    } \
+  } /* _SetEPRxTxStatus */
+  
+/*******************************************************************************
+* Macro Name     : GetEPTxStatus / GetEPRxStatus 
+* Description    : gets the status for tx/rx transfer (bits STAT_TX[1:0]
+*                  /STAT_RX[1:0])
+* Input          : bEpNum: Endpoint Number. 
+* Return         : status .
+*******************************************************************************/
+#define _GetEPTxStatus(bEpNum) ((uint16_t)_GetENDPOINT(bEpNum) & EPTX_STAT)
+
+#define _GetEPRxStatus(bEpNum) ((uint16_t)_GetENDPOINT(bEpNum) & EPRX_STAT)
+
+/*******************************************************************************
+* Macro Name     : SetEPTxValid / SetEPRxValid 
+* Description    : sets directly the VALID tx/rx-status into the enpoint register
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _SetEPTxValid(bEpNum)     (_SetEPTxStatus(bEpNum, EP_TX_VALID))
+
+#define _SetEPRxValid(bEpNum)     (_SetEPRxStatus(bEpNum, EP_RX_VALID))
+
+/*******************************************************************************
+* Macro Name     : GetTxStallStatus / GetRxStallStatus.
+* Description    : checks stall condition in an endpoint.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : TRUE = endpoint in stall condition.
+*******************************************************************************/
+#define _GetTxStallStatus(bEpNum) (_GetEPTxStatus(bEpNum) \
+                                   == EP_TX_STALL)
+#define _GetRxStallStatus(bEpNum) (_GetEPRxStatus(bEpNum) \
+                                   == EP_RX_STALL)
+
+/*******************************************************************************
+* Macro Name     : SetEP_KIND / ClearEP_KIND.
+* Description    : set & clear EP_KIND bit.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _SetEP_KIND(bEpNum)    (_SetENDPOINT(bEpNum, \
+                                (EP_CTR_RX|EP_CTR_TX|((_GetENDPOINT(bEpNum) | EP_KIND) & EPREG_MASK))))
+#define _ClearEP_KIND(bEpNum)  (_SetENDPOINT(bEpNum, \
+                                (EP_CTR_RX|EP_CTR_TX|(_GetENDPOINT(bEpNum) & EPKIND_MASK))))
+
+/*******************************************************************************
+* Macro Name     : Set_Status_Out / Clear_Status_Out.
+* Description    : Sets/clears directly STATUS_OUT bit in the endpoint register.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _Set_Status_Out(bEpNum)    _SetEP_KIND(bEpNum)
+#define _Clear_Status_Out(bEpNum)  _ClearEP_KIND(bEpNum)
+
+/*******************************************************************************
+* Macro Name     : SetEPDoubleBuff / ClearEPDoubleBuff.
+* Description    : Sets/clears directly EP_KIND bit in the endpoint register.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _SetEPDoubleBuff(bEpNum)   _SetEP_KIND(bEpNum)
+#define _ClearEPDoubleBuff(bEpNum) _ClearEP_KIND(bEpNum)
+
+/*******************************************************************************
+* Macro Name     : ClearEP_CTR_RX / ClearEP_CTR_TX.
+* Description    : Clears bit CTR_RX / CTR_TX in the endpoint register.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _ClearEP_CTR_RX(bEpNum)   (_SetENDPOINT(bEpNum,\
+                                   _GetENDPOINT(bEpNum) & 0x7FFF & EPREG_MASK))
+#define _ClearEP_CTR_TX(bEpNum)   (_SetENDPOINT(bEpNum,\
+                                   _GetENDPOINT(bEpNum) & 0xFF7F & EPREG_MASK))
+
+/*******************************************************************************
+* Macro Name     : ToggleDTOG_RX / ToggleDTOG_TX .
+* Description    : Toggles DTOG_RX / DTOG_TX bit in the endpoint register.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _ToggleDTOG_RX(bEpNum)    (_SetENDPOINT(bEpNum, \
+                                   EP_CTR_RX|EP_CTR_TX|EP_DTOG_RX | (_GetENDPOINT(bEpNum) & EPREG_MASK)))
+#define _ToggleDTOG_TX(bEpNum)    (_SetENDPOINT(bEpNum, \
+                                   EP_CTR_RX|EP_CTR_TX|EP_DTOG_TX | (_GetENDPOINT(bEpNum) & EPREG_MASK)))
+
+/*******************************************************************************
+* Macro Name     : ClearDTOG_RX / ClearDTOG_TX.
+* Description    : Clears DTOG_RX / DTOG_TX bit in the endpoint register.
+* Input          : bEpNum: Endpoint Number. 
+* Return         : None.
+*******************************************************************************/
+#define _ClearDTOG_RX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_RX) != 0)\
+    _ToggleDTOG_RX(bEpNum)
+#define _ClearDTOG_TX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_TX) != 0)\
+    _ToggleDTOG_TX(bEpNum)
+/*******************************************************************************
+* Macro Name     : SetEPAddress.
+* Description    : Sets address in an endpoint register.
+* Input          : bEpNum: Endpoint Number.
+*                  bAddr: Address. 
+* Return         : None.
+*******************************************************************************/
+#define _SetEPAddress(bEpNum,bAddr) _SetENDPOINT(bEpNum,\
+    EP_CTR_RX|EP_CTR_TX|(_GetENDPOINT(bEpNum) & EPREG_MASK) | bAddr)
+
+/*******************************************************************************
+* Macro Name     : GetEPAddress.
+* Description    : Gets address in an endpoint register.
+* Input          : bEpNum: Endpoint Number.
+* Return         : None.
+*******************************************************************************/
+#define _GetEPAddress(bEpNum) ((uint8_t)(_GetENDPOINT(bEpNum) & EPADDR_FIELD))
+
+#define _pEPTxAddr(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8  )*2 + PMAAddr))
+#define _pEPTxCount(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8+2)*2 + PMAAddr))
+#define _pEPRxAddr(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8+4)*2 + PMAAddr))
+#define _pEPRxCount(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8+6)*2 + PMAAddr))
+
+/*******************************************************************************
+* Macro Name     : SetEPTxAddr / SetEPRxAddr.
+* Description    : sets address of the tx/rx buffer.
+* Input          : bEpNum: Endpoint Number.
+*                  wAddr: address to be set (must be word aligned).
+* Return         : None.
+*******************************************************************************/
+#define _SetEPTxAddr(bEpNum,wAddr) (*_pEPTxAddr(bEpNum) = ((wAddr >> 1) << 1))
+#define _SetEPRxAddr(bEpNum,wAddr) (*_pEPRxAddr(bEpNum) = ((wAddr >> 1) << 1))
+
+/*******************************************************************************
+* Macro Name     : GetEPTxAddr / GetEPRxAddr.
+* Description    : Gets address of the tx/rx buffer.
+* Input          : bEpNum: Endpoint Number.
+* Return         : address of the buffer.
+*******************************************************************************/
+#define _GetEPTxAddr(bEpNum) ((uint16_t)*_pEPTxAddr(bEpNum))
+#define _GetEPRxAddr(bEpNum) ((uint16_t)*_pEPRxAddr(bEpNum))
+
+/*******************************************************************************
+* Macro Name     : SetEPCountRxReg.
+* Description    : Sets counter of rx buffer with no. of blocks.
+* Input          : pdwReg: pointer to counter.
+*                  wCount: Counter.
+* Return         : None.
+*******************************************************************************/
+#define _BlocksOf32(dwReg,wCount,wNBlocks) {\
+    wNBlocks = wCount >> 5;\
+    if((wCount & 0x1f) == 0)\
+      wNBlocks--;\
+    *pdwReg = (uint32_t)((wNBlocks << 10) | 0x8000);\
+  }/* _BlocksOf32 */
+
+#define _BlocksOf2(dwReg,wCount,wNBlocks) {\
+    wNBlocks = wCount >> 1;\
+    if((wCount & 0x1) != 0)\
+      wNBlocks++;\
+    *pdwReg = (uint32_t)(wNBlocks << 10);\
+  }/* _BlocksOf2 */
+
+#define _SetEPCountRxReg(dwReg,wCount)  {\
+    uint16_t wNBlocks;\
+    if(wCount > 62){_BlocksOf32(dwReg,wCount,wNBlocks);}\
+    else {_BlocksOf2(dwReg,wCount,wNBlocks);}\
+  }/* _SetEPCountRxReg */
+
+#define _GetNumBlock(wCount,wValue)  {\
+    uint16_t wNBlocks;\
+    if(wCount > 62){\
+      wNBlocks = wCount >> 5;\
+      if((wCount & 0x1f) == 0) wNBlocks--;\
+      wValue = (uint32_t)((wNBlocks << 10) | 0x8000);\
+    }\
+    else {wNBlocks = wCount >> 1;\
+      if((wCount & 0x1) != 0) wNBlocks++;\
+      wValue = (uint32_t)(wNBlocks << 10);\
+    }\
+}
+
+#define _SetEPRxDblBuf0Count(bEpNum,wCount) {\
+    uint32_t *pdwReg = _pEPTxCount(bEpNum); \
+    _SetEPCountRxReg(pdwReg, wCount);\
+  }
+
+/*******************************************************************************
+* Macro Name     : SetEPTxCount / SetEPRxCount.
+* Description    : sets counter for the tx/rx buffer.
+* Input          : bEpNum: endpoint number.
+*                  wCount: Counter value.
+* Return         : None.
+*******************************************************************************/
+#define _SetEPTxCount(bEpNum,wCount) (*_pEPTxCount(bEpNum) = wCount)
+#define _SetEPRxCount(bEpNum,wCount) {\
+    uint32_t *pdwReg = _pEPRxCount(bEpNum); \
+    _SetEPCountRxReg(pdwReg, wCount);\
+    if (bEpNum == ENDP0) \
+      _GetNumBlock(Device_Property.MaxPacketSize,Ep0RxBlks);\
+  }
+
+/*******************************************************************************
+* Macro Name     : GetEPTxCount / GetEPRxCount.
+* Description    : gets counter of the tx buffer.
+* Input          : bEpNum: endpoint number.
+* Return         : Counter value.
+*******************************************************************************/
+#define _GetEPTxCount(bEpNum)((uint16_t)(*_pEPTxCount(bEpNum)) & 0x3ff)
+#define _GetEPRxCount(bEpNum)((uint16_t)(*_pEPRxCount(bEpNum)) & 0x3ff)
+
+/*******************************************************************************
+* Macro Name     : SetEPDblBuf0Addr / SetEPDblBuf1Addr.
+* Description    : Sets buffer 0/1 address in a double buffer endpoint.
+* Input          : bEpNum: endpoint number.
+*                : wBuf0Addr: buffer 0 address.
+* Output         : None.
+* Return         : None.
+*******************************************************************************/
+#define _SetEPDblBuf0Addr(bEpNum,wBuf0Addr) {_SetEPTxAddr(bEpNum, wBuf0Addr);}
+#define _SetEPDblBuf1Addr(bEpNum,wBuf1Addr) {_SetEPRxAddr(bEpNum, wBuf1Addr);}
+
+/*******************************************************************************
+* Macro Name     : SetEPDblBuffAddr.
+* Description    : Sets addresses in a double buffer endpoint.
+* Input          : bEpNum: endpoint number.
+*                : wBuf0Addr: buffer 0 address.
+*                : wBuf1Addr = buffer 1 address.
+* Return         : None.
+*******************************************************************************/
+#define _SetEPDblBuffAddr(bEpNum,wBuf0Addr,wBuf1Addr) { \
+    _SetEPDblBuf0Addr(bEpNum, wBuf0Addr);\
+    _SetEPDblBuf1Addr(bEpNum, wBuf1Addr);\
+  } /* _SetEPDblBuffAddr */
+
+/*******************************************************************************
+* Macro Name     : GetEPDblBuf0Addr / GetEPDblBuf1Addr.
+* Description    : Gets buffer 0/1 address of a double buffer endpoint.
+* Input          : bEpNum: endpoint number.
+* Return         : None.
+*******************************************************************************/
+#define _GetEPDblBuf0Addr(bEpNum) (_GetEPTxAddr(bEpNum))
+#define _GetEPDblBuf1Addr(bEpNum) (_GetEPRxAddr(bEpNum))
+
+/*******************************************************************************
+* Macro Name     : SetEPDblBuffCount / SetEPDblBuf0Count / SetEPDblBuf1Count.
+* Description    : Gets buffer 0/1 address of a double buffer endpoint.
+* Input          : bEpNum: endpoint number.
+*                : bDir: endpoint dir  EP_DBUF_OUT = OUT 
+*                                      EP_DBUF_IN  = IN 
+*                : wCount: Counter value    
+* Return         : None.
+*******************************************************************************/
+#define _SetEPDblBuf0Count(bEpNum, bDir, wCount)  { \
+    if(bDir == EP_DBUF_OUT)\
+      /* OUT endpoint */ \
+    {_SetEPRxDblBuf0Count(bEpNum,wCount);} \
+    else if(bDir == EP_DBUF_IN)\
+      /* IN endpoint */ \
+      *_pEPTxCount(bEpNum) = (uint32_t)wCount;  \
+  } /* SetEPDblBuf0Count*/
+
+#define _SetEPDblBuf1Count(bEpNum, bDir, wCount)  { \
+    if(bDir == EP_DBUF_OUT)\
+      /* OUT endpoint */ \
+    {_SetEPRxCount(bEpNum,wCount);}\
+    else if(bDir == EP_DBUF_IN)\
+      /* IN endpoint */\
+      *_pEPRxCount(bEpNum) = (uint32_t)wCount; \
+  } /* SetEPDblBuf1Count */
+
+#define _SetEPDblBuffCount(bEpNum, bDir, wCount) {\
+    _SetEPDblBuf0Count(bEpNum, bDir, wCount); \
+    _SetEPDblBuf1Count(bEpNum, bDir, wCount); \
+  } /* _SetEPDblBuffCount  */
+
+/*******************************************************************************
+* Macro Name     : GetEPDblBuf0Count / GetEPDblBuf1Count.
+* Description    : Gets buffer 0/1 rx/tx counter for double buffering.
+* Input          : bEpNum: endpoint number.
+* Return         : None.
+*******************************************************************************/
+#define _GetEPDblBuf0Count(bEpNum) (_GetEPTxCount(bEpNum))
+#define _GetEPDblBuf1Count(bEpNum) (_GetEPRxCount(bEpNum))
+
+	
+extern __IO uint16_t wIstr;  /* ISTR register last read value */
+
+
+void SetCNTR(uint16_t /*wRegValue*/);
+void SetISTR(uint16_t /*wRegValue*/);
+void SetDADDR(uint16_t /*wRegValue*/);
+void SetBTABLE(uint16_t /*wRegValue*/);
+void SetBTABLE(uint16_t /*wRegValue*/);
+uint16_t GetCNTR(void);
+uint16_t GetISTR(void);
+uint16_t GetFNR(void);
+uint16_t GetDADDR(void);
+uint16_t GetBTABLE(void);
+void SetENDPOINT(uint8_t /*bEpNum*/, uint16_t /*wRegValue*/);
+uint16_t GetENDPOINT(uint8_t /*bEpNum*/);
+void SetEPType(uint8_t /*bEpNum*/, uint16_t /*wType*/);
+uint16_t GetEPType(uint8_t /*bEpNum*/);
+void SetEPTxStatus(uint8_t /*bEpNum*/, uint16_t /*wState*/);
+void SetEPRxStatus(uint8_t /*bEpNum*/, uint16_t /*wState*/);
+void SetDouBleBuffEPStall(uint8_t /*bEpNum*/, uint8_t bDir);
+uint16_t GetEPTxStatus(uint8_t /*bEpNum*/);
+uint16_t GetEPRxStatus(uint8_t /*bEpNum*/);
+void SetEPTxValid(uint8_t /*bEpNum*/);
+void SetEPRxValid(uint8_t /*bEpNum*/);
+uint16_t GetTxStallStatus(uint8_t /*bEpNum*/);
+uint16_t GetRxStallStatus(uint8_t /*bEpNum*/);
+void SetEP_KIND(uint8_t /*bEpNum*/);
+void ClearEP_KIND(uint8_t /*bEpNum*/);
+void Set_Status_Out(uint8_t /*bEpNum*/);
+void Clear_Status_Out(uint8_t /*bEpNum*/);
+void SetEPDoubleBuff(uint8_t /*bEpNum*/);
+void ClearEPDoubleBuff(uint8_t /*bEpNum*/);
+void ClearEP_CTR_RX(uint8_t /*bEpNum*/);
+void ClearEP_CTR_TX(uint8_t /*bEpNum*/);
+void ToggleDTOG_RX(uint8_t /*bEpNum*/);
+void ToggleDTOG_TX(uint8_t /*bEpNum*/);
+void ClearDTOG_RX(uint8_t /*bEpNum*/);
+void ClearDTOG_TX(uint8_t /*bEpNum*/);
+void SetEPAddress(uint8_t /*bEpNum*/, uint8_t /*bAddr*/);
+uint8_t GetEPAddress(uint8_t /*bEpNum*/);
+void SetEPTxAddr(uint8_t /*bEpNum*/, uint16_t /*wAddr*/);
+void SetEPRxAddr(uint8_t /*bEpNum*/, uint16_t /*wAddr*/);
+uint16_t GetEPTxAddr(uint8_t /*bEpNum*/);
+uint16_t GetEPRxAddr(uint8_t /*bEpNum*/);
+void SetEPCountRxReg(uint32_t * /*pdwReg*/, uint16_t /*wCount*/);
+void SetEPTxCount(uint8_t /*bEpNum*/, uint16_t /*wCount*/);
+void SetEPRxCount(uint8_t /*bEpNum*/, uint16_t /*wCount*/);
+uint16_t GetEPTxCount(uint8_t /*bEpNum*/);
+uint16_t GetEPRxCount(uint8_t /*bEpNum*/);
+void SetEPDblBuf0Addr(uint8_t /*bEpNum*/, uint16_t /*wBuf0Addr*/);
+void SetEPDblBuf1Addr(uint8_t /*bEpNum*/, uint16_t /*wBuf1Addr*/);
+void SetEPDblBuffAddr(uint8_t /*bEpNum*/, uint16_t /*wBuf0Addr*/, uint16_t /*wBuf1Addr*/);
+uint16_t GetEPDblBuf0Addr(uint8_t /*bEpNum*/);
+uint16_t GetEPDblBuf1Addr(uint8_t /*bEpNum*/);
+void SetEPDblBuffCount(uint8_t /*bEpNum*/, uint8_t /*bDir*/, uint16_t /*wCount*/);
+void SetEPDblBuf0Count(uint8_t /*bEpNum*/, uint8_t /*bDir*/, uint16_t /*wCount*/);
+void SetEPDblBuf1Count(uint8_t /*bEpNum*/, uint8_t /*bDir*/, uint16_t /*wCount*/);
+uint16_t GetEPDblBuf0Count(uint8_t /*bEpNum*/);
+uint16_t GetEPDblBuf1Count(uint8_t /*bEpNum*/);
+EP_DBUF_DIR GetEPDblBufDir(uint8_t /*bEpNum*/);
+void FreeUserBuffer(uint8_t bEpNum/*bEpNum*/, uint8_t bDir);
+uint16_t ToWord(uint8_t, uint8_t);
+uint16_t ByteSwap(uint16_t);
+
+#ifdef __cplusplus
+}
+
+#endif
+
+#endif /* __USB_REGS_H */
+
+
+
+
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_sil.h

@@ -0,0 +1,36 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_sil.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB Simplified Interface Layer firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_SIL_H
+#define __USB_SIL_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include "ch32v20x.h"
+
+uint32_t USB_SIL_Init(void);
+uint32_t USB_SIL_Write(uint8_t bEpAddr, uint8_t* pBufferPointer, uint32_t wBufferSize);
+uint32_t USB_SIL_Read(uint8_t bEpAddr, uint8_t* pBufferPointer);
+	 
+#ifdef __cplusplus
+}
+
+#endif
+
+#endif /* __USB_SIL_H */
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/inc/usb_type.h

@@ -0,0 +1,33 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_type.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : This file contains all the functions prototypes for the  
+ *                      USB types firmware library.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#ifndef __USB_TYPE_H
+#define __USB_TYPE_H
+#include "debug.h"
+#include "usb_conf.h"
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+typedef enum
+{
+  FALSE = 0, TRUE  = !FALSE
+}
+bool;
+
+#endif /* __USB_TYPE_H */
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/src/usb_core.c

@@ -0,0 +1,954 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_core.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Standard protocol processing (USB v2.0)
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+
+/* Global define */
+#define ValBit(VAR,Place)    (VAR & (1 << Place))
+#define SetBit(VAR,Place)    (VAR |= (1 << Place))
+#define ClrBit(VAR,Place)    (VAR &= ((1 << Place) ^ 255))
+#define Send0LengthData() { _SetEPTxCount(ENDP0, 0); \
+    vSetEPTxStatus(EP_TX_VALID); \
+  }
+
+#define vSetEPRxStatus(st) (SaveRState = st)
+#define vSetEPTxStatus(st) (SaveTState = st)
+
+#define USB_StatusIn() Send0LengthData()
+#define USB_StatusOut() vSetEPRxStatus(EP_RX_VALID)
+
+#define StatusInfo0 StatusInfo.bw.bb1 
+#define StatusInfo1 StatusInfo.bw.bb0
+
+uint16_t_uint8_t StatusInfo;
+
+bool Data_Mul_MaxPacketSize = FALSE;
+
+static void DataStageOut(void);
+static void DataStageIn(void);
+static void NoData_Setup0(void);
+static void Data_Setup0(void);
+
+/*********************************************************************
+ * @fn      Standard_GetConfiguration
+ *
+ * @brief   Return the current configuration variable address.
+ *
+ * @param   Length - How many bytes are needed.
+ *
+ * @return  Return 1 - if the request is invalid when "Length" is 0.
+ *          Return "Buffer" if the "Length" is not 0.
+ */
+uint8_t *Standard_GetConfiguration(uint16_t Length)
+{
+  if (Length == 0)
+  {
+    pInformation->Ctrl_Info.Usb_wLength = sizeof(pInformation->Current_Configuration);
+    return 0;
+  }
+  pUser_Standard_Requests->User_GetConfiguration();
+	
+  return (uint8_t *)&pInformation->Current_Configuration;
+}
+
+/*********************************************************************
+ * @fn      Standard_SetConfiguration
+ *
+ * @brief   This routine is called to set the configuration value
+ *          Then each class should configure device itself.
+ *
+ * @param   None.
+ *
+ * @return  Return USB_SUCCESS - if the request is performed.
+ *          Return USB_UNSUPPORT - if the request is invalid.
+ */
+RESULT Standard_SetConfiguration(void)
+{
+  if ((pInformation->USBwValue0 <=
+      Device_Table.Total_Configuration) && (pInformation->USBwValue1 == 0)
+      && (pInformation->USBwIndex == 0)) 
+  {
+    pInformation->Current_Configuration = pInformation->USBwValue0;
+    pUser_Standard_Requests->User_SetConfiguration();
+    return USB_SUCCESS;
+  }
+  else
+  {
+    return USB_UNSUPPORT;
+  }
+}
+
+/*********************************************************************
+ * @fn      Standard_GetInterface
+ *
+ * @brief   Return the Alternate Setting of the current interface.
+ *
+ * @param   Length - How many bytes are needed.
+ *
+ * @return  Return 0 - if the request is invalid when "Length" is 0.
+ *          Return "Buffer" if the "Length" is not 0.
+ */
+uint8_t *Standard_GetInterface(uint16_t Length)
+{
+  if (Length == 0)
+  {
+    pInformation->Ctrl_Info.Usb_wLength = sizeof(pInformation->Current_AlternateSetting);
+    return 0;
+  }
+  pUser_Standard_Requests->User_GetInterface();
+	
+  return (uint8_t *)&pInformation->Current_AlternateSetting;
+}
+
+/*********************************************************************
+ * @fn      Standard_SetInterface
+ *
+ * @brief   This routine is called to set the interface.
+ *          Then each class should configure the interface them self.
+ *
+ * @param   None
+ *
+ * @return  Return USB_SUCCESS - if the request is performed.
+ *          Return USB_UNSUPPORT - if the request is invalid.
+ */
+RESULT Standard_SetInterface(void)
+{
+  RESULT Re;
+  Re = (*pProperty->Class_Get_Interface_Setting)(pInformation->USBwIndex0, pInformation->USBwValue0);
+
+  if (pInformation->Current_Configuration != 0)
+  {
+    if ((Re != USB_SUCCESS) || (pInformation->USBwIndex1 != 0)
+        || (pInformation->USBwValue1 != 0))
+    {
+      return  USB_UNSUPPORT;
+    }
+    else if (Re == USB_SUCCESS)
+    {
+      pUser_Standard_Requests->User_SetInterface();
+      pInformation->Current_Interface = pInformation->USBwIndex0;
+      pInformation->Current_AlternateSetting = pInformation->USBwValue0;
+      return USB_SUCCESS;
+    }
+  }
+
+  return USB_UNSUPPORT;
+}
+
+/*********************************************************************
+ * @fn      Standard_GetStatus
+ *
+ * @brief   Copy the device request data to "StatusInfo buffer".
+ *
+ * @param   Length - How many bytes are needed.
+ *
+ * @return  Return 0 - if the request is at end of data block,
+ *          or is invalid when "Length" is 0.
+ */
+uint8_t *Standard_GetStatus(uint16_t Length)
+{
+  if (Length == 0)
+  {
+    pInformation->Ctrl_Info.Usb_wLength = 2;
+    return 0;
+  }
+  StatusInfo.w = 0;
+
+  if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+  {
+    uint8_t Feature = pInformation->Current_Feature;
+
+    if (ValBit(Feature, 5))
+    {
+      SetBit(StatusInfo0, 1);
+    }
+    else
+    {
+      ClrBit(StatusInfo0, 1);
+    }      
+    if (ValBit(Feature, 6))
+    {
+      SetBit(StatusInfo0, 0);
+    }
+    else 
+    {
+      ClrBit(StatusInfo0, 0);
+    }
+  }
+  else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+  {
+    return (uint8_t *)&StatusInfo;
+  }
+  else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+  {
+    uint8_t Related_Endpoint;
+    uint8_t wIndex0 = pInformation->USBwIndex0;
+
+    Related_Endpoint = (wIndex0 & 0x0f);
+    if (ValBit(wIndex0, 7))
+    {
+      if (_GetTxStallStatus(Related_Endpoint))
+      {
+        SetBit(StatusInfo0, 0); 
+      }
+    }
+    else
+    {
+      if (_GetRxStallStatus(Related_Endpoint))
+      {
+        SetBit(StatusInfo0, 0); 
+      }
+    }
+
+  }
+  else
+  {
+    return NULL;
+  }
+  pUser_Standard_Requests->User_GetStatus();
+	
+  return (uint8_t *)&StatusInfo;
+}
+
+/*********************************************************************
+ * @fn      Standard_ClearFeature
+ *
+ * @brief   Clear or disable a specific feature.
+ *
+ * @return  Return USB_SUCCESS - if the request is performed.
+ *          Return USB_UNSUPPORT - if the request is invalid.
+ */
+RESULT Standard_ClearFeature(void)
+{
+  uint32_t     Type_Rec = Type_Recipient;
+  uint32_t     Status;
+	
+  if (Type_Rec == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+  {
+    ClrBit(pInformation->Current_Feature, 5);
+    return USB_SUCCESS;
+  }
+  else if (Type_Rec == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+  {
+    DEVICE* pDev;
+    uint32_t Related_Endpoint;
+    uint32_t wIndex0;
+    uint32_t rEP;
+
+    if ((pInformation->USBwValue != ENDPOINT_STALL)
+        || (pInformation->USBwIndex1 != 0))
+    {
+      return USB_UNSUPPORT;
+    }
+
+    pDev = &Device_Table;
+    wIndex0 = pInformation->USBwIndex0;
+    rEP = wIndex0 & ~0x80;
+    Related_Endpoint = ENDP0 + rEP;
+
+    if (ValBit(pInformation->USBwIndex0, 7))
+    {
+      Status = _GetEPTxStatus(Related_Endpoint);
+    }
+    else
+    {
+      Status = _GetEPRxStatus(Related_Endpoint);
+    }
+
+    if ((rEP >= pDev->Total_Endpoint) || (Status == 0)
+        || (pInformation->Current_Configuration == 0))
+    {
+      return USB_UNSUPPORT;
+    }
+
+    if (wIndex0 & 0x80)
+    {
+      if (_GetTxStallStatus(Related_Endpoint ))
+      {
+        ClearDTOG_TX(Related_Endpoint);
+        SetEPTxStatus(Related_Endpoint, EP_TX_VALID);
+      }
+    }
+    else
+    {
+      if (_GetRxStallStatus(Related_Endpoint))
+      {
+        if (Related_Endpoint == ENDP0)
+        {
+          SetEPRxCount(Related_Endpoint, Device_Property.MaxPacketSize);
+          _SetEPRxStatus(Related_Endpoint, EP_RX_VALID);
+        }
+        else
+        {
+          ClearDTOG_RX(Related_Endpoint);
+          _SetEPRxStatus(Related_Endpoint, EP_RX_VALID);
+        }
+      }
+    }
+    pUser_Standard_Requests->User_ClearFeature();
+    return USB_SUCCESS;
+  }
+
+  return USB_UNSUPPORT;
+}
+
+/*********************************************************************
+ * @fn      Standard_SetEndPointFeature
+ *
+ * @brief   Set or enable a specific feature of EndPoint
+ *
+ * @return  Return USB_SUCCESS - if the request is performed.
+ *          Return USB_UNSUPPORT - if the request is invalid.
+ */
+RESULT Standard_SetEndPointFeature(void)
+{
+  uint32_t    wIndex0;
+  uint32_t    Related_Endpoint;
+  uint32_t    rEP;
+  uint32_t    Status;
+
+  wIndex0 = pInformation->USBwIndex0;
+  rEP = wIndex0 & ~0x80;
+  Related_Endpoint = ENDP0 + rEP;
+
+  if (ValBit(pInformation->USBwIndex0, 7))
+  {
+    Status = _GetEPTxStatus(Related_Endpoint);
+  }
+  else
+  {
+    Status = _GetEPRxStatus(Related_Endpoint);
+  }
+
+  if (Related_Endpoint >= Device_Table.Total_Endpoint
+      || pInformation->USBwValue != 0 || Status == 0
+      || pInformation->Current_Configuration == 0)
+  {
+    return USB_UNSUPPORT;
+  }
+  else
+  {
+    if (wIndex0 & 0x80)
+    {
+      _SetEPTxStatus(Related_Endpoint, EP_TX_STALL);
+    }
+    else
+    {
+      _SetEPRxStatus(Related_Endpoint, EP_RX_STALL);
+    }
+  }
+  pUser_Standard_Requests->User_SetEndPointFeature();
+	
+  return USB_SUCCESS;
+}
+
+/*********************************************************************
+ * @fn      Standard_SetDeviceFeature
+ *
+ * @brief   Set or enable a specific feature of Device.
+ *
+ * @return  Return USB_SUCCESS - if the request is performed.
+ *          Return USB_UNSUPPORT - if the request is invalid.
+ */
+RESULT Standard_SetDeviceFeature(void)
+{
+  SetBit(pInformation->Current_Feature, 5);
+  pUser_Standard_Requests->User_SetDeviceFeature();
+	
+  return USB_SUCCESS;
+}
+
+/*********************************************************************
+ * @fn      Standard_GetDescriptorData
+ *
+ * @brief   This routine is used for the descriptors resident in Flash
+ *        or RAM pDesc can be in either Flash or RAM
+ *        The purpose of this routine is to have a versatile way to
+ *        response descriptors request. It allows user to generate
+ *        certain descriptors with software or read descriptors from
+ *        external storage part by part.
+ *
+ * @param   Length - Length of the data in this transfer.
+ *          pDesc - A pointer points to descriptor struct.
+ *            The structure gives the initial address of the descriptor and
+ *        its original size.
+ *
+ * @return  Address of a part of the descriptor pointed by the Usb_
+ *        wOffset The buffer pointed by this address contains at least 
+ *        Length bytes.
+ */
+uint8_t *Standard_GetDescriptorData(uint16_t Length, ONE_DESCRIPTOR *pDesc)
+{
+  uint32_t  wOffset;
+
+  wOffset = pInformation->Ctrl_Info.Usb_wOffset;
+	
+  if (Length == 0)
+  {
+    pInformation->Ctrl_Info.Usb_wLength = pDesc->Descriptor_Size - wOffset;
+    return 0;
+  }
+
+  return pDesc->Descriptor + wOffset;
+}
+
+/*********************************************************************
+ * @fn      DataStageOut
+ *
+ * @brief   Data stage of a Control Write Transfer.
+ *
+ * @return  none
+ */
+void DataStageOut(void)
+{
+  ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
+  uint32_t save_rLength;
+
+  save_rLength = pEPinfo->Usb_rLength;
+
+  if (pEPinfo->CopyData && save_rLength)
+  {
+    uint8_t *Buffer;
+    uint32_t Length;
+
+    Length = pEPinfo->PacketSize;
+		
+    if (Length > save_rLength)
+    {
+      Length = save_rLength;
+    }
+
+    Buffer = (*pEPinfo->CopyData)(Length);
+    pEPinfo->Usb_rLength -= Length;
+    pEPinfo->Usb_rOffset += Length;
+    PMAToUserBufferCopy(Buffer, GetEPRxAddr(ENDP0), Length);
+  }
+
+  if (pEPinfo->Usb_rLength != 0)
+  {
+    vSetEPRxStatus(EP_RX_VALID);
+    SetEPTxCount(ENDP0, 0);
+    vSetEPTxStatus(EP_TX_VALID);
+  }
+	
+  if (pEPinfo->Usb_rLength >= pEPinfo->PacketSize)
+  {
+    pInformation->ControlState = OUT_DATA;
+  }
+  else
+  {
+    if (pEPinfo->Usb_rLength > 0)
+    {
+      pInformation->ControlState = LAST_OUT_DATA;
+    }
+    else if (pEPinfo->Usb_rLength == 0)
+    {
+      pInformation->ControlState = WAIT_STATUS_IN;
+      USB_StatusIn();
+    }
+  }
+}
+
+/*********************************************************************
+ * @fn      DataStageIn
+ *
+ * @brief   Data stage of a Control Read Transfer.
+ *
+ * @return  none
+ */
+void DataStageIn(void)
+{
+  ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
+  uint32_t save_wLength = pEPinfo->Usb_wLength;
+  uint32_t ControlState = pInformation->ControlState;
+
+  uint8_t *DataBuffer;
+  uint32_t Length;
+
+  if ((save_wLength == 0) && (ControlState == LAST_IN_DATA))
+  {
+    if(Data_Mul_MaxPacketSize == TRUE)
+    {
+      Send0LengthData();
+      ControlState = LAST_IN_DATA;
+      Data_Mul_MaxPacketSize = FALSE;
+    }
+    else 
+    {
+      ControlState = WAIT_STATUS_OUT;
+      vSetEPTxStatus(EP_TX_STALL);
+ 
+    }
+		
+    goto Expect_Status_Out;
+  }
+
+  Length = pEPinfo->PacketSize;
+  ControlState = (save_wLength <= Length) ? LAST_IN_DATA : IN_DATA;
+
+  if (Length > save_wLength)
+  {
+    Length = save_wLength;
+  }
+
+  DataBuffer = (*pEPinfo->CopyData)(Length);
+  
+  UserToPMABufferCopy(DataBuffer, GetEPTxAddr(ENDP0), Length);
+
+  SetEPTxCount(ENDP0, Length);
+
+  pEPinfo->Usb_wLength -= Length;
+  pEPinfo->Usb_wOffset += Length;
+  vSetEPTxStatus(EP_TX_VALID);
+
+  USB_StatusOut();
+
+Expect_Status_Out:
+  pInformation->ControlState = ControlState;
+}
+
+/*********************************************************************
+ * @fn      NoData_Setup0
+ *
+ * @brief   Proceed the processing of setup request without data stage.
+ *
+ * @return  none
+ */
+void NoData_Setup0(void)
+{
+  RESULT Result = USB_UNSUPPORT;
+  uint32_t RequestNo = pInformation->USBbRequest;
+  uint32_t ControlState;
+
+  if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+  {
+    if (RequestNo == SET_CONFIGURATION)
+    {
+      Result = Standard_SetConfiguration();
+    }
+    else if (RequestNo == SET_ADDRESS)
+    {
+      if ((pInformation->USBwValue0 > 127) || (pInformation->USBwValue1 != 0)
+          || (pInformation->USBwIndex != 0)
+          || (pInformation->Current_Configuration != 0))
+      {
+        ControlState = STALLED;
+        goto exit_NoData_Setup0;
+      }
+      else
+      {
+        Result = USB_SUCCESS;
+      }
+    }
+    else if (RequestNo == SET_FEATURE)
+    {
+      if ((pInformation->USBwValue0 == DEVICE_REMOTE_WAKEUP) \
+          && (pInformation->USBwIndex == 0))
+      {
+        Result = Standard_SetDeviceFeature();
+      }
+      else
+      {
+        Result = USB_UNSUPPORT;
+      }
+    }
+    else if (RequestNo == CLEAR_FEATURE)
+    {
+      if (pInformation->USBwValue0 == DEVICE_REMOTE_WAKEUP
+          && pInformation->USBwIndex == 0
+          && ValBit(pInformation->Current_Feature, 5))
+      {
+        Result = Standard_ClearFeature();
+      }
+      else
+      {
+        Result = USB_UNSUPPORT;
+      }
+    }
+
+  }
+  else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+  {
+    if (RequestNo == SET_INTERFACE)
+    {
+      Result = Standard_SetInterface();
+    }
+  }
+
+  else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+  {
+    if (RequestNo == CLEAR_FEATURE)
+    {
+      Result = Standard_ClearFeature();
+    }
+    else if (RequestNo == SET_FEATURE)
+    {
+      Result = Standard_SetEndPointFeature();
+    }
+  }
+  else
+  {
+    Result = USB_UNSUPPORT;
+  }
+
+  if (Result != USB_SUCCESS)
+  {
+    Result = (*pProperty->Class_NoData_Setup)(RequestNo);
+    if (Result == USB_NOT_READY)
+    {
+      ControlState = PAUSE;
+      goto exit_NoData_Setup0;
+    }
+  }
+
+  if (Result != USB_SUCCESS)
+  {
+    ControlState = STALLED;
+    goto exit_NoData_Setup0;
+  }
+
+  ControlState = WAIT_STATUS_IN;
+
+  USB_StatusIn();
+
+exit_NoData_Setup0:
+  pInformation->ControlState = ControlState;
+  return;
+}
+
+/*********************************************************************
+ * @fn      Data_Setup0
+ *
+ * @brief   Proceed the processing of setup request with data stage.
+ *
+ * @return  none
+ */
+void Data_Setup0(void)
+{
+  uint8_t *(*CopyRoutine)(uint16_t);
+  RESULT Result;
+  uint32_t Request_No = pInformation->USBbRequest;
+  uint32_t Related_Endpoint, Reserved;
+  uint32_t wOffset, Status;
+
+  CopyRoutine = NULL;
+  wOffset = 0;
+	
+  if (Request_No == GET_DESCRIPTOR)
+  {
+    if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+    {
+      uint8_t wValue1 = pInformation->USBwValue1;
+      if (wValue1 == DEVICE_DESCRIPTOR)
+      {
+        CopyRoutine = pProperty->GetDeviceDescriptor;
+      }
+      else if (wValue1 == CONFIG_DESCRIPTOR)
+      {
+        CopyRoutine = pProperty->GetConfigDescriptor;
+      }
+      else if (wValue1 == STRING_DESCRIPTOR)
+      {
+        CopyRoutine = pProperty->GetStringDescriptor;
+      } 
+    }
+  }
+  else if ((Request_No == GET_STATUS) && (pInformation->USBwValue == 0)
+           && (pInformation->USBwLength == 0x0002)
+           && (pInformation->USBwIndex1 == 0))
+  {
+  
+    if ((Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+        && (pInformation->USBwIndex == 0))
+    {
+      CopyRoutine = Standard_GetStatus;
+    }
+    else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+    {
+      if (((*pProperty->Class_Get_Interface_Setting)(pInformation->USBwIndex0, 0) == USB_SUCCESS)
+          && (pInformation->Current_Configuration != 0))
+      {
+        CopyRoutine = Standard_GetStatus;
+      }
+    }
+    else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+    {
+      Related_Endpoint = (pInformation->USBwIndex0 & 0x0f);
+      Reserved = pInformation->USBwIndex0 & 0x70;
+
+      if (ValBit(pInformation->USBwIndex0, 7))
+      {
+        Status = _GetEPTxStatus(Related_Endpoint);
+      }
+      else
+      {
+        Status = _GetEPRxStatus(Related_Endpoint);
+      }
+
+      if ((Related_Endpoint < Device_Table.Total_Endpoint) && (Reserved == 0)
+          && (Status != 0))
+      {
+        CopyRoutine = Standard_GetStatus;
+      }
+    }
+
+  }
+  else if (Request_No == GET_CONFIGURATION)
+  {
+    if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+    {
+      CopyRoutine = Standard_GetConfiguration;
+    }
+  }
+  else if (Request_No == GET_INTERFACE)
+  {
+    if ((Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+        && (pInformation->Current_Configuration != 0) && (pInformation->USBwValue == 0)
+        && (pInformation->USBwIndex1 == 0) && (pInformation->USBwLength == 0x0001)
+        && ((*pProperty->Class_Get_Interface_Setting)(pInformation->USBwIndex0, 0) == USB_SUCCESS))
+    {
+      CopyRoutine = Standard_GetInterface;
+    }
+
+  }
+  
+  if (CopyRoutine)
+  {
+    pInformation->Ctrl_Info.Usb_wOffset = wOffset;
+    pInformation->Ctrl_Info.CopyData = CopyRoutine;
+    (*CopyRoutine)(0);
+    Result = USB_SUCCESS;
+  }
+  else
+  {
+    Result = (*pProperty->Class_Data_Setup)(pInformation->USBbRequest);
+		
+    if (Result == USB_NOT_READY)
+    {
+      pInformation->ControlState = PAUSE;
+      return;
+    }
+  }
+
+  if (pInformation->Ctrl_Info.Usb_wLength == 0xFFFF)
+  {
+    pInformation->ControlState = PAUSE;
+    return;
+  }
+	
+  if ((Result == USB_UNSUPPORT) || (pInformation->Ctrl_Info.Usb_wLength == 0))
+  {
+    pInformation->ControlState = STALLED;
+    return;
+  }
+
+  if (ValBit(pInformation->USBbmRequestType, 7))
+  {
+    __IO uint32_t wLength = pInformation->USBwLength;
+    if (pInformation->Ctrl_Info.Usb_wLength > wLength)
+    {
+      pInformation->Ctrl_Info.Usb_wLength = wLength;
+    } 
+    else if (pInformation->Ctrl_Info.Usb_wLength < pInformation->USBwLength)
+    {
+      if (pInformation->Ctrl_Info.Usb_wLength < pProperty->MaxPacketSize)
+      {
+        Data_Mul_MaxPacketSize = FALSE;
+      }
+      else if ((pInformation->Ctrl_Info.Usb_wLength % pProperty->MaxPacketSize) == 0)
+      {
+        Data_Mul_MaxPacketSize = TRUE;
+      }
+    }   
+
+    pInformation->Ctrl_Info.PacketSize = pProperty->MaxPacketSize;
+    DataStageIn();
+  }
+  else
+  {
+    pInformation->ControlState = OUT_DATA;
+    vSetEPRxStatus(EP_RX_VALID); 
+  }
+
+  return;
+}
+
+/*********************************************************************
+ * @fn      Setup0_Process
+ *
+ * @brief   Get the device request data and dispatch to individual process.
+ *
+ * @return  Post0_Process.
+ */
+uint8_t Setup0_Process(void)
+{
+  union
+  {
+    uint8_t* b;
+    uint16_t* w;
+  } pBuf;
+  uint16_t offset = 1;
+  
+  pBuf.b = PMAAddr + (uint8_t *)(_GetEPRxAddr(ENDP0) * 2); /* *2 for 32 bits addr */
+
+  if (pInformation->ControlState != PAUSE)
+  {
+    pInformation->USBbmRequestType = *pBuf.b++; /* bmRequestType */
+    pInformation->USBbRequest = *pBuf.b++; /* bRequest */
+    pBuf.w += offset;  /* word not accessed because of 32 bits addressing */
+    pInformation->USBwValue = ByteSwap(*pBuf.w++); /* wValue */
+    pBuf.w += offset;  /* word not accessed because of 32 bits addressing */
+    pInformation->USBwIndex  = ByteSwap(*pBuf.w++); /* wIndex */
+    pBuf.w += offset;  /* word not accessed because of 32 bits addressing */
+    pInformation->USBwLength = *pBuf.w; /* wLength */
+  }
+  pInformation->ControlState = SETTING_UP;
+	
+  if (pInformation->USBwLength == 0)
+  {
+    NoData_Setup0();
+  }
+  else
+  {
+    Data_Setup0();
+  }
+  return Post0_Process();
+}
+
+/*********************************************************************
+ * @fn      In0_Process
+ *
+ * @brief   Process the IN token on all default endpoint.
+ *
+ * @return  none
+ */
+uint8_t In0_Process(void)
+{
+  uint32_t ControlState = pInformation->ControlState;
+
+  if ((ControlState == IN_DATA) || (ControlState == LAST_IN_DATA))
+  {
+    DataStageIn();
+    ControlState = pInformation->ControlState;
+  }
+  else if (ControlState == WAIT_STATUS_IN)
+  {
+    if ((pInformation->USBbRequest == SET_ADDRESS) &&
+        (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT)))
+    {
+      SetDeviceAddress(pInformation->USBwValue0);
+      pUser_Standard_Requests->User_SetDeviceAddress();
+    }
+    (*pProperty->Process_Status_IN)();
+    ControlState = STALLED;
+  }
+  else
+  {
+    ControlState = STALLED;
+  }
+
+  pInformation->ControlState = ControlState;
+
+  return Post0_Process();
+}
+
+/*********************************************************************
+ * @fn      Out0_Process
+ *
+ * @brief   Process the OUT token on all default endpoint.
+ *
+ * @return  none
+ */
+uint8_t Out0_Process(void)
+{
+  uint32_t ControlState = pInformation->ControlState;
+
+  if ((ControlState == IN_DATA) || (ControlState == LAST_IN_DATA))
+  {
+    ControlState = STALLED;
+  }
+  else if ((ControlState == OUT_DATA) || (ControlState == LAST_OUT_DATA))
+  {
+    DataStageOut();
+    ControlState = pInformation->ControlState; 
+  }
+  else if (ControlState == WAIT_STATUS_OUT)
+  {
+    (*pProperty->Process_Status_OUT)();
+    ControlState = STALLED;
+  }
+  else
+  {
+    ControlState = STALLED;
+  }
+
+  pInformation->ControlState = ControlState;
+
+  return Post0_Process();
+}
+
+/*********************************************************************
+ * @fn      Post0_Process
+ *
+ * @brief   Stall the Endpoint 0 in case of error.
+ *
+ * @return  0 - if the control State is in PAUSE
+ *          1 - if not.
+ */
+uint8_t Post0_Process(void)
+{  
+  SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
+
+  if (pInformation->ControlState == STALLED)
+  {
+    vSetEPRxStatus(EP_RX_STALL);
+    vSetEPTxStatus(EP_TX_STALL);
+  }
+
+  return (pInformation->ControlState == PAUSE);
+}
+
+/*********************************************************************
+ * @fn      SetDeviceAddress
+ *
+ * @brief   Set the device and all the used Endpoints addresses.
+ *
+ * @param   Val - device address.
+ *
+ * @return  none
+ */
+void SetDeviceAddress(uint8_t Val)
+{
+  uint32_t i;
+  uint32_t nEP = Device_Table.Total_Endpoint;
+	
+  for (i = 0; i < nEP; i++)
+  {
+    _SetEPAddress((uint8_t)i, (uint8_t)i);
+  } 
+	
+  _SetDADDR(Val | DADDR_EF); 
+}
+
+/*********************************************************************
+ * @fn      NOP_Process
+ *
+ * @brief   No operation function.
+ *
+ * @return  none
+ */
+void NOP_Process(void)
+{
+}
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/src/usb_init.c

@@ -0,0 +1,42 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_init.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Initialization routines & global variables
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+
+uint8_t	EPindex;
+DEVICE_INFO *pInformation;
+DEVICE_PROP *pProperty;
+uint16_t	SaveState ;
+uint16_t  wInterrupt_Mask;
+DEVICE_INFO	Device_Info;
+USER_STANDARD_REQUESTS  *pUser_Standard_Requests;
+
+/*******************************************************************************
+ * @fn        USB_Init
+ *
+ * @brief     USB system initialization
+ *
+ * @return    None.
+ *
+ */
+void USB_Init(void)
+{
+  pInformation = &Device_Info;
+  pInformation->ControlState = 2;
+  pProperty = &Device_Property;
+  pUser_Standard_Requests = &User_Standard_Requests;
+  pProperty->Init();
+}
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/src/usb_int.c

@@ -0,0 +1,133 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_int.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Endpoint CTR (Low and High) interrupt's service routines
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+
+/* Private variables */
+__IO uint16_t SaveRState;
+__IO uint16_t SaveTState;
+
+/* Extern variables */
+extern void (*pEpInt_IN[7])(void);    /*  Handles IN  interrupts   */
+extern void (*pEpInt_OUT[7])(void);   /*  Handles OUT interrupts   */
+
+/*******************************************************************************
+ * @fn       CTR_LP.
+ *
+ * @brief    Low priority Endpoint Correct Transfer interrupt's service
+ *                  routine.
+ *
+ * @return  None.
+ */
+void CTR_LP(void)
+{
+  __IO uint16_t wEPVal = 0;
+	
+  while (((wIstr = _GetISTR()) & ISTR_CTR) != 0)
+  {
+    EPindex = (uint8_t)(wIstr & ISTR_EP_ID);
+		
+    if (EPindex == 0)
+    {
+	    SaveRState = _GetENDPOINT(ENDP0);
+	    SaveTState = SaveRState & EPTX_STAT;
+	    SaveRState &=  EPRX_STAT;	
+
+	    _SetEPRxTxStatus(ENDP0,EP_RX_NAK,EP_TX_NAK);
+			
+      if ((wIstr & ISTR_DIR) == 0)
+      {
+        _ClearEP_CTR_TX(ENDP0);
+        In0_Process();
+
+        _SetEPRxTxStatus(ENDP0,SaveRState,SaveTState);
+				
+				return;
+      }
+      else
+      {
+        wEPVal = _GetENDPOINT(ENDP0);
+        
+        if ((wEPVal &EP_SETUP) != 0)
+        {
+          _ClearEP_CTR_RX(ENDP0);
+          Setup0_Process();
+		      _SetEPRxTxStatus(ENDP0,SaveRState,SaveTState);
+					
+          return;
+        }
+        else if ((wEPVal & EP_CTR_RX) != 0)
+        {
+          _ClearEP_CTR_RX(ENDP0);
+          Out0_Process();
+		     _SetEPRxTxStatus(ENDP0,SaveRState,SaveTState);
+					
+          return;
+        }
+      }
+    }
+    else
+    {
+      wEPVal = _GetENDPOINT(EPindex);
+      if ((wEPVal & EP_CTR_RX) != 0)
+      {
+        _ClearEP_CTR_RX(EPindex);
+        (*pEpInt_OUT[EPindex-1])();
+      } 
+
+      if ((wEPVal & EP_CTR_TX) != 0)
+      {
+        _ClearEP_CTR_TX(EPindex);     
+        (*pEpInt_IN[EPindex-1])();
+      }
+    }
+  }
+}
+
+/*******************************************************************************
+ * @fn        CTR_HP.
+ *
+ * @brief     High Priority Endpoint Correct Transfer interrupt's service 
+ *                  routine.
+ *
+ * @return    None.
+ */
+void CTR_HP(void)
+{
+  uint32_t wEPVal = 0;
+
+  while (((wIstr = _GetISTR()) & ISTR_CTR) != 0)
+  {
+    _SetISTR((uint16_t)CLR_CTR); 
+    EPindex = (uint8_t)(wIstr & ISTR_EP_ID);   
+    wEPVal = _GetENDPOINT(EPindex);
+		
+    if ((wEPVal & EP_CTR_RX) != 0)
+    {
+      _ClearEP_CTR_RX(EPindex); 
+      (*pEpInt_OUT[EPindex-1])();
+    } 
+    else if ((wEPVal & EP_CTR_TX) != 0)
+    {
+      _ClearEP_CTR_TX(EPindex);   
+      (*pEpInt_IN[EPindex-1])();
+    } 
+  }
+}
+
+
+
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/src/usb_mem.c

@@ -0,0 +1,74 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_mem.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Utility functions for memory transfers to/from PMA
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+
+
+/*******************************************************************************
+ * @fn           UserToPMABufferCopy
+ *
+ * @brief        Copy a buffer from user memory area to packet memory area (PMA)
+ *
+ * @param        pbUsrBuf: pointer to user memory area.
+ *                  wPMABufAddr: address into PMA.
+ *                  wNBytes: no. of bytes to be copied.
+ *
+ * @param        None	.
+ */
+void UserToPMABufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+{
+  uint32_t n = (wNBytes + 1) >> 1;   
+  uint32_t i, temp1, temp2;
+  uint16_t *pdwVal;
+  pdwVal = (uint16_t *)(wPMABufAddr * 2 + PMAAddr);
+	
+  for (i = n; i != 0; i--)
+  {
+    temp1 = (uint16_t) * pbUsrBuf;
+    pbUsrBuf++;
+    temp2 = temp1 | (uint16_t) * pbUsrBuf << 8;
+    *pdwVal++ = temp2;
+    pdwVal++;
+    pbUsrBuf++;
+  }
+}
+
+/*******************************************************************************
+ * @fn          PMAToUserBufferCopy
+ *
+ * @brief       Copy a buffer from user memory area to packet memory area (PMA)
+ *
+ * @param       pbUsrBuf: pointer to user memory area.
+ *                  wPMABufAddr: address into PMA.
+ *                  wNBytes:  no. of bytes to be copied.
+ *
+ * @param       None. 
+ */
+void PMAToUserBufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+{
+  uint32_t n = (wNBytes + 1) >> 1;
+  uint32_t i;
+  uint32_t *pdwVal;
+	
+  pdwVal = (uint32_t *)(wPMABufAddr * 2 + PMAAddr);
+	
+  for (i = n; i != 0; i--)
+  {
+    *(uint16_t*)pbUsrBuf++ = *pdwVal++;
+    pbUsrBuf++;
+  } 
+}
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/src/usb_regs.c

@@ -0,0 +1,852 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_regs.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Interface functions to USB cell registers
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+
+/*******************************************************************************
+ * @fn         SetCNTR.
+ *
+ * @brief      Set the CNTR register value.
+ *
+ * @param      wRegValue: new register value.
+ *
+ * @return     None.
+ */
+void SetCNTR(uint16_t wRegValue)
+{
+  _SetCNTR(wRegValue);
+}
+
+/*******************************************************************************
+ * @fn         GetCNTR.
+ *
+ * @brief      returns the CNTR register value.
+ *
+ * @param      None.
+ *
+ * @return     CNTR register Value.
+ */
+uint16_t GetCNTR(void)
+{
+  return(_GetCNTR());
+}
+
+/*******************************************************************************
+ * @fn        SetISTR.
+ *
+ * @brief     Set the ISTR register value.
+ *
+ * @param     wRegValue: new register value.
+ *
+ * @return    None.
+ */
+void SetISTR(uint16_t wRegValue)
+{
+  _SetISTR(wRegValue);
+}
+
+/*******************************************************************************
+ * @fn        GetISTR
+ *
+ * @brief     Returns the ISTR register value.
+ *
+ * @param     None.
+ *
+ * @return   ISTR register Value
+ */
+uint16_t GetISTR(void)
+{
+  return(_GetISTR());
+}
+
+/*******************************************************************************
+ * @fn        GetFNR
+ *
+ * @brief     Returns the FNR register value.
+ *
+ * @param    None.
+ *
+ * @return    FNR register Value
+ */
+uint16_t GetFNR(void)
+{
+  return(_GetFNR());
+}
+
+/*******************************************************************************
+ * @fn        SetDADDR
+ *
+ * @brief     Set the DADDR register value.
+ *
+ * @param     wRegValue: new register value.
+ * 
+ * @return   None.
+ */
+void SetDADDR(uint16_t wRegValue)
+{
+  _SetDADDR(wRegValue);
+}
+
+/*******************************************************************************
+ * @fn          GetDADDR
+ *
+ * @brief       Returns the DADDR register value.
+ *
+ * @return     DADDR register Value
+ *
+ */
+uint16_t GetDADDR(void)
+{
+  return(_GetDADDR());
+}
+
+/*******************************************************************************
+ * @fn       SetBTABLE
+ *
+ * @brief    Set the BTABLE.
+ *
+ * @param    wRegValue: New register value.
+ *
+ * @return   None.
+ */
+void SetBTABLE(uint16_t wRegValue)
+{
+  _SetBTABLE(wRegValue);
+}
+
+/*******************************************************************************
+ * @fn      GetBTABLE.
+ *
+ * @param   Returns the BTABLE register value.
+ *
+ * @return  BTABLE address.
+ */
+uint16_t GetBTABLE(void)
+{
+  return(_GetBTABLE());
+}
+
+/*******************************************************************************
+ * @fn        SetENDPOINT
+ *
+ * @brief     Set the Endpoint register value.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *                  wRegValue.
+ *
+ * @return   None.
+ */
+void SetENDPOINT(uint8_t bEpNum, uint16_t wRegValue)
+{
+  _SetENDPOINT(bEpNum, wRegValue);
+}
+
+/*******************************************************************************
+ * @fn        GetENDPOINT
+ *
+ * @brief     Return the Endpoint register value.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return   Endpoint register value.
+ */
+uint16_t GetENDPOINT(uint8_t bEpNum)
+{
+  return(_GetENDPOINT(bEpNum));
+}
+
+/*******************************************************************************
+ * @fn       SetEPType
+ *
+ * @brief    sets the type in the endpoint register.
+ *
+ * @param    bEpNum: Endpoint Number. 
+ *                  wType: type definition.
+ *
+ * @return   None.
+ */
+void SetEPType(uint8_t bEpNum, uint16_t wType)
+{
+  _SetEPType(bEpNum, wType);
+}
+
+/*******************************************************************************
+ * @fn        GetEPType
+ *
+ * @brief     Returns the endpoint type.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return    Endpoint Type
+ */
+uint16_t GetEPType(uint8_t bEpNum)
+{
+  return(_GetEPType(bEpNum));
+}
+
+/*******************************************************************************
+ * @fn       SetEPTxStatus
+ *
+ * @brief    Set the status of Tx endpoint.
+ *
+ * @param    bEpNum: Endpoint Number. 
+ *                  wState: new state.
+ *
+ * @return    None.
+ */
+void SetEPTxStatus(uint8_t bEpNum, uint16_t wState)
+{
+  _SetEPTxStatus(bEpNum, wState);
+}
+
+/*******************************************************************************
+ * @fn         SetEPRxStatus
+ *
+ * @brief      Set the status of Rx endpoint.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *                  wState: new state.
+ *
+ * @return    None.
+ */
+void SetEPRxStatus(uint8_t bEpNum, uint16_t wState)
+{
+  _SetEPRxStatus(bEpNum, wState);
+}
+
+/*******************************************************************************
+ * @fn        SetDouBleBuffEPStall
+ *
+ * @brief     sets the status for Double Buffer Endpoint to STALL
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *                  bDir: Endpoint direction.
+ *
+ * @return   None.
+ */
+void SetDouBleBuffEPStall(uint8_t bEpNum, uint8_t bDir)
+{
+  uint16_t Endpoint_DTOG_Status;
+	
+  Endpoint_DTOG_Status = GetENDPOINT(bEpNum);
+	
+  if (bDir == EP_DBUF_OUT)
+  { 
+    _SetENDPOINT(bEpNum, Endpoint_DTOG_Status & ~EPRX_DTOG1);
+  }
+  else if (bDir == EP_DBUF_IN)
+  { 
+    _SetENDPOINT(bEpNum, Endpoint_DTOG_Status & ~EPTX_DTOG1);
+  }
+}
+
+/*******************************************************************************
+ * @fn       GetEPTxStatus
+ *
+ * @brief    Returns the endpoint Tx status.
+ *
+ * @param   bEpNum: Endpoint Number. 
+ *
+ * @return  Endpoint TX Status
+ */
+uint16_t GetEPTxStatus(uint8_t bEpNum)
+{
+  return(_GetEPTxStatus(bEpNum));
+}
+
+/*******************************************************************************
+ * @fn       GetEPRxStatus
+ *
+ * @brief    Returns the endpoint Rx status.
+ *
+ * @param    bEpNum: Endpoint Number. 
+ *
+ * @return   Endpoint RX Status
+ */
+uint16_t GetEPRxStatus(uint8_t bEpNum)
+{
+  return(_GetEPRxStatus(bEpNum));
+}
+
+/*******************************************************************************
+ * @fn       SetEPTxValid
+ *
+ * @brief    Valid the endpoint Tx Status.
+ *
+ * @param    bEpNum: Endpoint Number.  
+ *
+ * @return   None.
+ */
+void SetEPTxValid(uint8_t bEpNum)
+{
+  _SetEPTxStatus(bEpNum, EP_TX_VALID);
+}
+
+/*******************************************************************************
+ * @fn         SetEPRxValid
+ *
+ * @brief      Valid the endpoint Rx Status.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *
+ * @return    None.
+ */
+void SetEPRxValid(uint8_t bEpNum)
+{
+  _SetEPRxStatus(bEpNum, EP_RX_VALID);
+}
+
+/*******************************************************************************
+ * @fn       SetEP_KIND
+ *
+ * @brief    Clear the EP_KIND bit.
+ *
+ * @param    bEpNum: Endpoint Number. 
+ *
+ * @return   None.
+ */
+void SetEP_KIND(uint8_t bEpNum)
+{
+  _SetEP_KIND(bEpNum);
+}
+
+/*******************************************************************************
+ * @fn       ClearEP_KIND
+ *
+ * @brief    set the  EP_KIND bit.
+ *
+ * @param    bEpNum: Endpoint Number. 
+ * 
+ * @return  None.
+ */
+void ClearEP_KIND(uint8_t bEpNum)
+{
+  _ClearEP_KIND(bEpNum);
+}
+/*******************************************************************************
+ * @fn      Clear_Status_Out
+ *
+ * @brief   Clear the Status Out of the related Endpoint
+ *
+ * @param   bEpNum: Endpoint Number. 
+ *
+ * @return  None.
+ */
+void Clear_Status_Out(uint8_t bEpNum)
+{
+  _ClearEP_KIND(bEpNum);
+}
+/*******************************************************************************
+ * @fn       Set_Status_Out
+ *
+ * @brief   Set the Status Out of the related Endpoint
+ *
+ * @param   bEpNum: Endpoint Number. 
+ *
+ * @return  None.
+ */
+void Set_Status_Out(uint8_t bEpNum)
+{
+  _SetEP_KIND(bEpNum);
+}
+/*******************************************************************************
+ * @fn       SetEPDoubleBuff
+ *
+ * @brief    Enable the double buffer feature for the endpoint. 
+ *
+ * @param    bEpNum: Endpoint Number. 
+ *
+ * @return   None.
+ */
+void SetEPDoubleBuff(uint8_t bEpNum)
+{
+  _SetEP_KIND(bEpNum);
+}
+/*******************************************************************************
+ * @fn      ClearEPDoubleBuff
+ *
+ * @brief  Disable the double buffer feature for the endpoint. 
+ *
+ * @param  bEpNum: Endpoint Number. 
+ *
+ * @return None.
+ */
+void ClearEPDoubleBuff(uint8_t bEpNum)
+{
+  _ClearEP_KIND(bEpNum);
+}
+/*******************************************************************************
+ * @fn      GetTxStallStatus
+ *
+ * @brief    Returns the Stall status of the Tx endpoint.
+ *
+ * @param   bEpNum: Endpoint Number. 
+ *
+ * @return  Tx Stall status.
+ */
+uint16_t GetTxStallStatus(uint8_t bEpNum)
+{
+  return(_GetTxStallStatus(bEpNum));
+}
+/*******************************************************************************
+ * @fn       GetRxStallStatus
+ *
+ * @brief    Returns the Stall status of the Rx endpoint. 
+ *
+ * @param   bEpNum: Endpoint Number. 
+ *
+ * @return  Rx Stall status.
+ */
+uint16_t GetRxStallStatus(uint8_t bEpNum)
+{
+  return(_GetRxStallStatus(bEpNum));
+}
+/*******************************************************************************
+ * @fn      ClearEP_CTR_RX
+ *
+ * @brief   Clear the CTR_RX bit.
+ *
+ * @param   bEpNum: Endpoint Number. 
+ *
+ * @return  None.
+ */
+void ClearEP_CTR_RX(uint8_t bEpNum)
+{
+  _ClearEP_CTR_RX(bEpNum);
+}
+/*******************************************************************************
+ * @fn         ClearEP_CTR_TX
+ *
+ * @brief      Clear the CTR_TX bit.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *
+ * @return     None.
+ */
+void ClearEP_CTR_TX(uint8_t bEpNum)
+{
+  _ClearEP_CTR_TX(bEpNum);
+}
+/*******************************************************************************
+ * @fn        ToggleDTOG_RX
+ *
+ * @brief     Toggle the DTOG_RX bit.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return    None.
+ */
+void ToggleDTOG_RX(uint8_t bEpNum)
+{
+  _ToggleDTOG_RX(bEpNum);
+}
+/*******************************************************************************
+ * @fn        ToggleDTOG_TX
+ *
+ * @brief     Toggle the DTOG_TX bit.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *
+ * @return   None.
+ */
+void ToggleDTOG_TX(uint8_t bEpNum)
+{
+  _ToggleDTOG_TX(bEpNum);
+}
+/*******************************************************************************
+ * @fn        ClearDTOG_RX.
+ *  
+ * @brief      Clear the DTOG_RX bit.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *
+ * @return     None.
+ */
+void ClearDTOG_RX(uint8_t bEpNum)
+{
+  _ClearDTOG_RX(bEpNum);
+}
+/*******************************************************************************
+ * @fn         ClearDTOG_TX.
+ *
+ * @brief      Clear the DTOG_TX bit.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *
+ * @return     None.
+ */
+void ClearDTOG_TX(uint8_t bEpNum)
+{
+  _ClearDTOG_TX(bEpNum);
+}
+/*******************************************************************************
+ * @fn        SetEPAddress
+ *
+ * @brief     Set the endpoint address.
+ *
+ * @param    bEpNum: Endpoint Number.
+ *                  bAddr: New endpoint address.
+ *
+ * @return     None.
+ */
+void SetEPAddress(uint8_t bEpNum, uint8_t bAddr)
+{
+  _SetEPAddress(bEpNum, bAddr);
+}
+/*******************************************************************************
+ * @fn        GetEPAddress
+ *
+ * @brief     Get the endpoint address.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return    Endpoint address.
+ */
+uint8_t GetEPAddress(uint8_t bEpNum)
+{
+  return(_GetEPAddress(bEpNum));
+}
+/*******************************************************************************
+ * @fn        SetEPTxAddr
+ *
+ * @brief     Set the endpoint Tx buffer address.
+ *
+ * @param      bEpNum: Endpoint Number.
+ *                  wAddr: new address. 
+ *
+ * @return   None.
+ */
+void SetEPTxAddr(uint8_t bEpNum, uint16_t wAddr)
+{
+  _SetEPTxAddr(bEpNum, wAddr);
+}
+/*******************************************************************************
+ * @fn        SetEPRxAddr
+ *
+ * @brief     Set the endpoint Rx buffer address.
+ *
+ * @param    bEpNum: Endpoint Number.
+ *                  wAddr: new address.
+ *
+ * @return  None.
+ */
+void SetEPRxAddr(uint8_t bEpNum, uint16_t wAddr)
+{
+  _SetEPRxAddr(bEpNum, wAddr);
+}
+/*******************************************************************************
+ * @fn      GetEPTxAddr
+ *
+ * @brief  Returns the endpoint Tx buffer address.
+ *
+ * @param  bEpNum: Endpoint Number. 
+ *
+ * @return Rx buffer address. 
+ */
+uint16_t GetEPTxAddr(uint8_t bEpNum)
+{
+  return(_GetEPTxAddr(bEpNum));
+}
+/*******************************************************************************
+ * @fn          GetEPRxAddr.
+ *
+ * @brief       Returns the endpoint Rx buffer address.
+ *
+ * @param       bEpNum: Endpoint Number. 
+ *
+ * @returnRx   buffer address.
+ */
+uint16_t GetEPRxAddr(uint8_t bEpNum)
+{
+  return(_GetEPRxAddr(bEpNum));
+}
+/*******************************************************************************
+ * @fn        SetEPTxCount.
+ *
+ * @brief     Set the Tx count.
+ *
+ * @param     bEpNum: Endpoint Number.
+ *                  wCount: new count value.
+ *
+ * @return    None.
+ */
+void SetEPTxCount(uint8_t bEpNum, uint16_t wCount)
+{
+  _SetEPTxCount(bEpNum, wCount);
+}
+/*******************************************************************************
+ * @fn          SetEPCountRxReg.
+ *
+ * @brief       Set the Count Rx Register value.
+ *
+ * @param       *pdwReg: point to the register.
+ *                  wCount: the new register value.
+ *
+ * @return      None.
+ */
+void SetEPCountRxReg(uint32_t *pdwReg, uint16_t wCount)
+{
+  _SetEPCountRxReg(dwReg, wCount);
+}
+/*******************************************************************************
+ * @fn        SetEPRxCount
+ *
+ * @brief     Set the Rx count.
+ *
+ * @param      bEpNum: Endpoint Number. 
+ *                    wCount: the new count value.
+ *
+ * @return    None.
+ */
+void SetEPRxCount(uint8_t bEpNum, uint16_t wCount)
+{
+  _SetEPRxCount(bEpNum, wCount);
+}
+/*******************************************************************************
+ * @fn       GetEPTxCount
+ *
+ * @brief    Get the Tx count.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return    Tx count value.
+ */
+uint16_t GetEPTxCount(uint8_t bEpNum)
+{
+  return(_GetEPTxCount(bEpNum));
+}
+/*******************************************************************************
+ * @fn        GetEPRxCount
+ * 
+ * @brief    Get the Rx count.
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return    Rx count value.
+ */
+uint16_t GetEPRxCount(uint8_t bEpNum)
+{
+  return(_GetEPRxCount(bEpNum));
+}
+/*******************************************************************************
+ * @fn        SetEPDblBuffAddr
+ *
+ * @brief     Set the addresses of the buffer 0 and 1.
+ *
+ * @param      bEpNum: Endpoint Number.  
+ *                  wBuf0Addr: new address of buffer 0. 
+ *                  wBuf1Addr: new address of buffer 1.
+ *
+ * @return    None.
+ */
+void SetEPDblBuffAddr(uint8_t bEpNum, uint16_t wBuf0Addr, uint16_t wBuf1Addr)
+{
+  _SetEPDblBuffAddr(bEpNum, wBuf0Addr, wBuf1Addr);
+}
+/*******************************************************************************
+ * @fn       SetEPDblBuf0Addr
+ *
+ * @brief    Set the Buffer 1 address.
+ *
+ * @param     bEpNum: Endpoint Number
+ *                  wBuf0Addr: new address.
+ *
+ * @return    None.
+ */
+void SetEPDblBuf0Addr(uint8_t bEpNum, uint16_t wBuf0Addr)
+{
+  _SetEPDblBuf0Addr(bEpNum, wBuf0Addr);
+}
+/*******************************************************************************
+ * @fn       SetEPDblBuf1Addr
+ *
+ * @brief    Set the Buffer 1 address.
+ *
+ * @param    bEpNum: Endpoint Number
+ *                  wBuf1Addr: new address.
+ *
+ * @return   None.
+ */
+void SetEPDblBuf1Addr(uint8_t bEpNum, uint16_t wBuf1Addr)
+{
+  _SetEPDblBuf1Addr(bEpNum, wBuf1Addr);
+}
+/*******************************************************************************
+ * @fn       GetEPDblBuf0Addr
+ *
+ * @brief     Returns the address of the Buffer 0.
+ *
+ * @param     bEpNum: Endpoint Number.
+ *
+ * @return   None.
+ */
+uint16_t GetEPDblBuf0Addr(uint8_t bEpNum)
+{
+  return(_GetEPDblBuf0Addr(bEpNum));
+}
+/*******************************************************************************
+ * @fn       GetEPDblBuf1Addr
+ *
+ * @brief    Returns the address of the Buffer 1.
+ *
+ * @param    bEpNum: Endpoint Number.
+ *
+ * @return   Address of the Buffer 1.
+ */
+uint16_t GetEPDblBuf1Addr(uint8_t bEpNum)
+{
+  return(_GetEPDblBuf1Addr(bEpNum));
+}
+/*******************************************************************************
+ * @fn           SetEPDblBuffCount
+ *
+ * @brief        Set the number of bytes for a double Buffer 
+ *                  endpoint.
+ *
+ * @param       bEpNum,bDir, wCount
+ *
+ * @return     None.
+ */
+void SetEPDblBuffCount(uint8_t bEpNum, uint8_t bDir, uint16_t wCount)
+{
+  _SetEPDblBuffCount(bEpNum, bDir, wCount);
+}
+/*******************************************************************************
+ * @fn    SetEPDblBuf0Count
+ *
+ * @brief  Set the number of bytes in the buffer 0 of a double Buffer 
+ *                   endpoint.
+ *
+ * @param  bEpNum, bDir,  wCount
+ *
+ * @return  None.
+ */
+void SetEPDblBuf0Count(uint8_t bEpNum, uint8_t bDir, uint16_t wCount)
+{
+  _SetEPDblBuf0Count(bEpNum, bDir, wCount);
+}
+/*******************************************************************************
+ * @fn       SetEPDblBuf1Count
+ *
+ * @brief   Set the number of bytes in the buffer 0 of a double Buffer 
+*                  endpoint.
+ *
+ * @param    bEpNum,  bDir,  wCount
+ *
+ * @return   None.
+ */
+void SetEPDblBuf1Count(uint8_t bEpNum, uint8_t bDir, uint16_t wCount)
+{
+  _SetEPDblBuf1Count(bEpNum, bDir, wCount);
+}
+/*******************************************************************************
+ * @fn     GetEPDblBuf0Count
+ *
+ * @brief  Returns the number of byte received in the buffer 0 of a double
+ *                  Buffer endpoint.
+ *
+ * @param  bEpNum: Endpoint Number.
+ *
+ * @return Endpoint Buffer 0 count
+ */
+uint16_t GetEPDblBuf0Count(uint8_t bEpNum)
+{
+  return(_GetEPDblBuf0Count(bEpNum));
+}
+/*******************************************************************************
+ * @fn   GetEPDblBuf1Count
+ *
+ * @brief  Returns the number of data received in the buffer 1 of a double
+ *                  Buffer endpoint.
+ *
+ * @param bEpNum: Endpoint Number.
+ *
+ * @return Endpoint Buffer 1 count.
+ */
+uint16_t GetEPDblBuf1Count(uint8_t bEpNum)
+{
+  return(_GetEPDblBuf1Count(bEpNum));
+}
+/*******************************************************************************
+ * @fn       GetEPDblBufDir
+ *
+ * @brief    gets direction of the double buffered endpoint
+ *
+ * @param     bEpNum: Endpoint Number. 
+ *
+ * @return   EP_DBUF_OUT, EP_DBUF_IN,
+ *                  EP_DBUF_ERR if the endpoint counter not yet programmed.
+ */
+EP_DBUF_DIR GetEPDblBufDir(uint8_t bEpNum)
+{
+  if ((uint16_t)(*_pEPRxCount(bEpNum) & 0xFC00) != 0)
+    return(EP_DBUF_OUT);
+  else if (((uint16_t)(*_pEPTxCount(bEpNum)) & 0x03FF) != 0)
+    return(EP_DBUF_IN);
+  else
+    return(EP_DBUF_ERR);
+}
+/*******************************************************************************
+ * @fn         FreeUserBuffer
+ *
+ * @brief      free buffer used from the application realizing it to the line
+                   toggles bit SW_BUF in the double buffered endpoint register
+ *
+ * @param      bEpNum, bDir
+ *
+ * @return    None.
+ */
+void FreeUserBuffer(uint8_t bEpNum, uint8_t bDir)
+{
+  if (bDir == EP_DBUF_OUT)
+  {
+    _ToggleDTOG_TX(bEpNum);
+  }
+  else if (bDir == EP_DBUF_IN)
+  { 
+    _ToggleDTOG_RX(bEpNum);
+  }
+}
+
+/*******************************************************************************
+ * @fn        ToWord
+ *
+ * @brief     merge two byte in a word.
+ *
+ * @param      bh: byte high, bl: bytes low.
+ *
+ * @return   resulted word.
+ */
+uint16_t ToWord(uint8_t bh, uint8_t bl)
+{
+  uint16_t wRet;
+  wRet = (uint16_t)bl | ((uint16_t)bh << 8);
+	
+  return(wRet);
+}
+/*******************************************************************************
+ * @fn         ByteSwap
+ *  
+ * @brief     Swap two byte in a word.
+ *
+ * @param     wSwW: word to Swap.
+ *
+ * @return    resulted word.
+ */
+uint16_t ByteSwap(uint16_t wSwW)
+{
+  uint8_t bTemp;
+  uint16_t wRet;
+  bTemp = (uint8_t)(wSwW & 0xff);
+  wRet =  (wSwW >> 8) | ((uint16_t)bTemp << 8);
+	
+  return(wRet);
+}

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/USBLIB/USB-Driver/src/usb_sil.c

@@ -0,0 +1,77 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : usb_sil.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/08/08
+ * Description        : Simplified Interface Layer for Global Initialization and 
+ *			           Endpoint  Rea/Write operations.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/ 
+#include "usb_lib.h"
+
+
+/*******************************************************************************
+ * @fn         USB_SIL_Init
+ *
+ * @brief      Initialize the USB Device IP and the Endpoint 0.
+ *
+ * @return   Status.
+ */
+uint32_t USB_SIL_Init(void)
+{
+  _SetISTR(0);
+  wInterrupt_Mask = IMR_MSK;
+  _SetCNTR(wInterrupt_Mask);
+	
+  return 0;
+}
+
+/*******************************************************************************
+ * @fn                USB_SIL_Write
+ *
+ * @brief           Write a buffer of data to a selected endpoint.
+ *
+ * @param          bEpAddr: The address of the non control endpoint.
+ *                  pBufferPointer: The pointer to the buffer of data to be written
+ *                     to the endpoint.
+ *                  wBufferSize: Number of data to be written (in bytes).
+ *
+ * @return         Status.
+ */
+uint32_t USB_SIL_Write(uint8_t bEpAddr, uint8_t* pBufferPointer, uint32_t wBufferSize)
+{
+  UserToPMABufferCopy(pBufferPointer, GetEPTxAddr(bEpAddr & 0x7F), wBufferSize);
+  SetEPTxCount((bEpAddr & 0x7F), wBufferSize);
+  
+  return 0;
+}
+
+/*******************************************************************************
+ * @fn       USB_SIL_Read
+ *
+ * @brief     Write a buffer of data to a selected endpoint.
+ *
+ * @param    bEpAddr: The address of the non control endpoint.
+ *                  pBufferPointer: The pointer to which will be saved the 
+ *             received data buffer.
+ *
+ * @return     Number of received data (in Bytes).
+ */
+uint32_t USB_SIL_Read(uint8_t bEpAddr, uint8_t* pBufferPointer)
+{
+  uint32_t DataLength = 0;
+
+  DataLength = GetEPRxCount(bEpAddr & 0x7F); 
+  PMAToUserBufferCopy(pBufferPointer, GetEPRxAddr(bEpAddr & 0x7F), DataLength);
+
+  return DataLength;
+}
+
+
+
+
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/ch32v20x_usbfs_device.c

@@ -0,0 +1,578 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : ch32v20x_usbfs_device.c
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2024/01/06
+ * Description        : This file provides all the USBFS firmware functions.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#include "ch32v20x_usbfs_device.h"
+#include "iap.h"
+/* Global define */
+/* OTH */
+#define pMySetupReqPakHD        ((PUSB_SETUP_REQ)EP0_DatabufHD)
+#define RepDescSize             62
+#define DevEP0SIZE              0x40
+#define PID_OUT                 0
+#define PID_SOF                 1
+#define PID_IN                  2
+#define PID_SETUP               3
+#define Version_Num   0x0100   //V0100
+u8 EP2_Tx_Buffer[2];
+/******************************************************************************/
+/* Endpoint Buffer */
+__attribute__ ((aligned(4))) UINT8 EP0_DatabufHD[64]; //ep0(64)
+__attribute__ ((aligned(4))) UINT8 EP2_DatabufHD[64+64];  //ep2_out(64)+ep2_in(64)
+
+PUINT8  pEP0_RAM_Addr;                       //ep0(64)
+PUINT8  pEP2_RAM_Addr;                       //ep2_out(64)+ep2_in(64)
+
+
+const UINT8 *pDescr;
+
+volatile UINT16 USBFS_Dev_SetupReqLen = 0x00;
+volatile UINT8  USBFS_Dev_Config = 0x00;
+volatile UINT8  USBFS_Dev_Address = 0x00;
+volatile UINT8  USBFS_Dev_SleepStatus = 0x00;
+volatile UINT8   DevConfig;
+volatile UINT8   SetupReqCode;
+volatile UINT16  SetupReqLen;
+/******************************************************************************/
+/* Device Descriptor */
+const UINT8 MyDevDescrHD[] = { 0x12, 0x01, 0x10, 0x01, 0xFF, 0x80, 0x55,
+        DevEP0SIZE, 0x48, 0x43, 0xe0, 0x55,  //USB MODULE
+        (u8) Version_Num, (u8) (Version_Num >> 8),
+        0x00, 0x00, 0x00, 0x01 };
+
+/* Configration Descriptor */
+const UINT8 MyCfgDescrHD[] = { 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80,
+        0x32, 0x09, 0x04, 0x00, 0x00, 0x02, 0xFF, 0x80, 0x55, 0x00, 0x07, 0x05,
+        0x82, 0x02, 0x40, 0x00, 0x00, 0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00 };
+
+void USBFS_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
+
+/*********************************************************************
+ * @fn      USBFSD_DeviceInit
+ *
+ * @brief   Initializes USB device.
+ *
+ * @return  none
+ */
+void USBDeviceInit( void )
+{
+    USBFSD->BASE_CTRL = 0x00;
+
+    USBFSD->UEP2_3_MOD = USBFS_UEP2_RX_EN|USBFS_UEP2_TX_EN;
+    USBFSD->UEP0_DMA = (UINT32)pEP0_RAM_Addr;
+    USBFSD->UEP2_DMA = (UINT32)pEP2_RAM_Addr;
+
+    USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_RES_ACK;
+    USBFSD->UEP1_RX_CTRL = USBFS_UEP_R_RES_NAK;
+    USBFSD->UEP2_RX_CTRL = USBFS_UEP_R_RES_ACK;
+    USBFSD->UEP3_RX_CTRL = USBFS_UEP_R_RES_NAK;
+    USBFSD->UEP4_RX_CTRL = USBFS_UEP_R_RES_NAK;
+    USBFSD->UEP5_RX_CTRL = USBFS_UEP_R_RES_NAK;
+    USBFSD->UEP6_RX_CTRL = USBFS_UEP_R_RES_NAK;
+    USBFSD->UEP7_RX_CTRL = USBFS_UEP_R_RES_NAK;
+
+    USBFSD->UEP2_TX_LEN = 8;
+    USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_RES_NAK;
+    USBFSD->UEP2_TX_CTRL = USBFS_UEP_T_RES_ACK|USBFS_UEP_AUTO_TOG;
+
+    USBFSD->INT_FG = 0xFF;
+    USBFSD->INT_EN = USBFS_UIE_SUSPEND | USBFS_UIE_BUS_RST | USBFS_UIE_TRANSFER;
+    USBFSD->DEV_ADDR = 0x00;
+
+    USBFSD->BASE_CTRL = USBFS_UC_DEV_PU_EN | USBFS_UC_INT_BUSY | USBFS_UC_DMA_EN;
+    USBFSD->UDEV_CTRL = USBFS_UD_PD_DIS|USBFS_UD_PORT_EN;
+}
+
+/*********************************************************************
+ * @fn      USBFS_RCC_Init
+ *
+ * @brief   Initializes the usbfs clock configuration.
+ *
+ * @return  none
+ */
+void USBFS_RCC_Init(void)
+{
+    RCC_ClocksTypeDef RCC_ClocksStatus={0};
+    RCC_GetClocksFreq(&RCC_ClocksStatus);
+    if( RCC_ClocksStatus.SYSCLK_Frequency == 144000000 )
+    {
+        RCC_USBCLKConfig( RCC_USBCLKSource_PLLCLK_Div3 );
+    }
+    else if( RCC_ClocksStatus.SYSCLK_Frequency == 96000000 ) 
+    {
+        RCC_USBCLKConfig( RCC_USBCLKSource_PLLCLK_Div2 );
+    }
+    else if( RCC_ClocksStatus.SYSCLK_Frequency == 48000000 ) 
+    {
+        RCC_USBCLKConfig( RCC_USBCLKSource_PLLCLK_Div1 );
+    }
+#if defined(CH32V20x_D8W) || defined(CH32V20x_D8)
+    else if ( RCC_ClocksStatus.SYSCLK_Frequency == 240000000 && RCC_USB5PRE_JUDGE() == SET )
+    {
+        RCC_USBCLKConfig( RCC_USBCLKSource_PLLCLK_Div5 );
+    }
+#endif
+    RCC_AHBPeriphClockCmd( RCC_AHBPeriph_USBFS, ENABLE );
+}
+
+/*********************************************************************
+ * @fn      USBFS_Init
+ *
+ * @brief   Initializes the USB full speed device.
+ *
+ * @return  none
+ */
+void USBFS_Init( void )
+{
+    pEP0_RAM_Addr = EP0_DatabufHD;
+    pEP2_RAM_Addr = EP2_DatabufHD;
+    USBFS_RCC_Init( );
+    Delay_Us(100);
+    USBDeviceInit( );
+    NVIC_EnableIRQ( USBFS_IRQn );
+}
+
+/*********************************************************************
+ * @fn      USBFS_IRQHandler
+ *
+ * @brief   This function handles OTG_FS exception.
+ *
+ * @return  none
+ */
+void USBFS_IRQHandler( void )
+{
+    UINT8  len, chtype;
+    UINT8  intflag, errflag = 0;
+
+    intflag = USBFSD->INT_FG;
+
+    if( intflag & USBFS_UIF_TRANSFER )
+    {
+        switch ( USBFSD->INT_ST & USBFS_UIS_TOKEN_MASK )
+        {
+        /* SETUP */
+            case USBFS_UIS_TOKEN_SETUP:
+
+                USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_NAK;
+                USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_TOG|USBFS_UEP_R_RES_ACK;
+                SetupReqLen  = pSetupReqPakHD->wLength;
+                SetupReqCode = pSetupReqPakHD->bRequest;
+                chtype = pSetupReqPakHD->bRequestType;
+                len = 0;
+                errflag = 0;
+
+                if ( ( pSetupReqPakHD->bRequestType & USB_REQ_TYP_MASK ) != USB_REQ_TYP_STANDARD )
+                {
+                    if( pSetupReqPakHD->bRequestType & 0x40 )
+                    {
+                        switch( pSetupReqPakHD->bRequest )
+                        {
+                            default:
+                                errflag = 0xFF;
+                                break;
+                        }
+                    }
+                    else if( pSetupReqPakHD->bRequestType & 0x20 )
+                    {
+                        switch( pSetupReqPakHD->bRequest )
+                        {
+                        case 0x01: //GetReport
+                            break;
+                        case 0x02: //GetIdle
+                            break;
+                        case 0x03: //GetProtocol
+                            break;
+                        case 0x09: //SetReport
+                            break;
+                        case 0x0A: //SetIdle
+                            break;
+                        case 0x0B: //SetProtocol
+                            break;
+                        default:
+                            errflag = 0xFF;
+                            break;
+                        }
+                    }
+
+                    if( errflag != 0xFF )
+                    {
+                        if( SetupReqLen > len )
+                        {
+                            SetupReqLen = len;
+                        }
+                        len = ( USBFS_Dev_SetupReqLen >= DevEP0SIZE ) ? DevEP0SIZE : USBFS_Dev_SetupReqLen;
+                        memcpy( EP0_DatabufHD, pDescr, len );
+                        pDescr += len;
+                    }
+                }
+                else
+                {
+                    switch( SetupReqCode )
+                    {
+                        case USB_GET_DESCRIPTOR:
+                        {
+                            switch( ((pSetupReqPakHD->wValue)>>8) )
+                            {
+                                case USB_DESCR_TYP_DEVICE:
+                                    pDescr = MyDevDescrHD;
+                                    len = MyDevDescrHD[0];
+                                    break;
+
+                                case USB_DESCR_TYP_CONFIG:
+                                    pDescr = MyCfgDescrHD;
+                                    len = MyCfgDescrHD[2];
+                                    break;
+
+                                case USB_DESCR_TYP_STRING:
+                                    switch( (pSetupReqPakHD->wValue)&0xff )
+                                    {
+                                        case 0:
+
+                                            break;
+
+                                        case 1:
+
+                                            break;
+
+                                        case 2:
+
+                                            break;
+
+                                        case 3:
+
+                                            break;
+
+                                        default:
+                                            errflag = 0xFF;
+                                            break;
+                                    }
+                                    break;
+
+                                case USB_DESCR_TYP_REPORT:
+
+                                    break;
+
+                                case USB_DESCR_TYP_QUALIF:
+
+                                    break;
+
+                                default :
+                                    errflag = 0xff;
+                                    break;
+
+                            }
+
+                            if( SetupReqLen>len )   SetupReqLen = len;
+                            len = (SetupReqLen >= DevEP0SIZE) ? DevEP0SIZE : SetupReqLen;
+                            memcpy( pEP0_DataBuf, pDescr, len );
+                            pDescr += len;
+                        }
+                            break;
+
+                        case USB_SET_ADDRESS:
+                            SetupReqLen = (pSetupReqPakHD->wValue)&0xff;
+                            break;
+
+                        case USB_GET_CONFIGURATION:
+                            pEP0_DataBuf[0] = DevConfig;
+                            if ( SetupReqLen > 1 ) SetupReqLen = 1;
+                            break;
+
+                        case USB_SET_CONFIGURATION:
+                            DevConfig = (pSetupReqPakHD->wValue)&0xff;
+                            break;
+
+                        case USB_CLEAR_FEATURE:
+                            if ( ( pSetupReqPakHD->bRequestType & USB_REQ_RECIP_MASK ) == USB_REQ_RECIP_ENDP )
+                            {
+                                switch( (pSetupReqPakHD->wIndex)&0xff )
+                                {
+                                case 0x82:
+                                    USBFSD->UEP2_TX_CTRL = (USBFSD->UEP2_TX_CTRL & ~( USBFS_UEP_T_TOG|USBFS_UEP_T_RES_MASK )) | USBFS_UEP_T_RES_NAK;
+                                    break;
+
+                                case 0x02:
+                                    USBFSD->UEP2_RX_CTRL = (USBFSD->UEP2_RX_CTRL & ~( USBFS_UEP_R_TOG|USBFS_UEP_R_RES_MASK )) | USBFS_UEP_R_RES_ACK;
+                                    break;
+
+                                case 0x81:
+                                    USBFSD->UEP1_TX_CTRL = (USBFSD->UEP1_TX_CTRL & ~( USBFS_UEP_T_TOG|USBFS_UEP_T_RES_MASK )) | USBFS_UEP_T_RES_NAK;
+                                    break;
+
+                                case 0x01:
+                                    USBFSD->UEP1_RX_CTRL = (USBFSD->UEP1_RX_CTRL & ~( USBFS_UEP_R_TOG|USBFS_UEP_R_RES_MASK )) | USBFS_UEP_R_RES_ACK;
+                                    break;
+
+                                default:
+                                    errflag = 0xFF;
+                                    break;
+
+                                }
+                            }
+                            else    errflag = 0xFF;
+                            break;
+
+                        case USB_SET_FEATURE:
+                            if( ( pMySetupReqPakHD->bRequestType & 0x1F ) == 0x00 )
+                            {
+                                if( pMySetupReqPakHD->wValue == 0x01 )
+                                {
+                                    if( MyCfgDescrHD[ 7 ] & 0x20 )
+                                    {
+                                        USBFS_Dev_SleepStatus = 0x01;
+                                    }
+                                    else
+                                    {
+                                        errflag = 0xFF;
+                                    }
+                                }
+                                else
+                                {
+                                    errflag = 0xFF;
+                                }
+                            }
+                            else if( ( pMySetupReqPakHD->bRequestType & 0x1F ) == 0x02 )
+                            {
+                                if( pMySetupReqPakHD->wValue == 0x00 )
+                                {
+                                    switch( ( pMySetupReqPakHD->wIndex ) & 0xff )
+                                    {
+                                        case 0x82:
+                                            USBFSD->UEP2_TX_CTRL = ( USBFSD->UEP2_TX_CTRL &= ~USBFS_UEP_T_RES_MASK ) | USBFS_UEP_T_RES_STALL;
+                                            break;
+
+                                        case 0x02:
+                                            USBFSD->UEP2_RX_CTRL = ( USBFSD->UEP2_RX_CTRL &= ~USBFS_UEP_R_RES_MASK ) | USBFS_UEP_R_RES_STALL;
+                                            break;
+
+                                        default:
+                                            errflag = 0xFF;
+                                            break;
+                                    }
+                                }
+                                else
+                                {
+                                    errflag = 0xFF;
+                                }
+                            }
+                            else
+                            {
+                                errflag = 0xFF;
+                            }
+                            break;
+
+                        case USB_GET_INTERFACE:
+                            pEP0_DataBuf[0] = 0x00;
+                            if ( SetupReqLen > 1 ) SetupReqLen = 1;
+                            break;
+
+                        case USB_SET_INTERFACE:
+                            EP0_DatabufHD[ 0 ] = 0x00;
+                            if( USBFS_Dev_SetupReqLen > 1 )
+                            {
+                                USBFS_Dev_SetupReqLen = 1;
+                            }
+                            break;
+
+                        case USB_GET_STATUS:
+                            EP0_DatabufHD[ 0 ] = 0x00;
+                            EP0_DatabufHD[ 1 ] = 0x00;
+                            if( pMySetupReqPakHD->wIndex == 0x81 )
+                            {
+                                if( ( USBFSD->UEP1_TX_CTRL & USBFS_UEP_T_RES_MASK ) == USBFS_UEP_T_RES_STALL )
+                                {
+                                    EP0_DatabufHD[ 0 ] = 0x01;
+                                }
+                            }
+                            else if( pMySetupReqPakHD->wIndex == 0x01 )
+                            {
+                                if( ( USBFSD->UEP1_RX_CTRL & USBFS_UEP_R_RES_MASK ) == USBFS_UEP_R_RES_STALL )
+                                {
+                                    EP0_DatabufHD[ 0 ] = 0x01;
+                                }
+                            }
+                            else if( pMySetupReqPakHD->wIndex == 0x82 )
+                            {
+                                if( ( USBFSD->UEP2_TX_CTRL & USBFS_UEP_T_RES_MASK ) == USBFS_UEP_T_RES_STALL )
+                                {
+                                    EP0_DatabufHD[ 0 ] = 0x01;
+                                }
+                            }
+                            else if( pMySetupReqPakHD->wIndex == 0x02 )
+                            {
+                                if( ( USBFSD->UEP2_RX_CTRL & USBFS_UEP_R_RES_MASK ) == USBFS_UEP_R_RES_STALL )
+                                {
+                                    EP0_DatabufHD[ 0 ] = 0x01;
+                                }
+                            }
+                            if( USBFS_Dev_SetupReqLen > 2 )
+                            {
+                                USBFS_Dev_SetupReqLen = 2;
+                            }
+                            break;
+
+                        default:
+                            errflag = 0xff;
+                            break;
+                    }
+                }
+                if( errflag == 0xff)
+                {
+                    USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_STALL;
+                    USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_TOG|USBFS_UEP_R_RES_STALL;
+                }
+                else
+                {
+                    if( chtype & 0x80 )
+                    {
+                        len = (SetupReqLen>DevEP0SIZE) ? DevEP0SIZE : SetupReqLen;
+                        SetupReqLen -= len;
+                    }
+                    else  len = 0;
+
+                    USBFSD->UEP0_TX_LEN  = len;
+                    USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_ACK;
+                    USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_TOG|USBFS_UEP_R_RES_ACK;
+                }
+                break;
+
+            case USBFS_UIS_TOKEN_IN:
+                switch ( USBFSD->INT_ST & ( USBFS_UIS_TOKEN_MASK | USBFS_UIS_ENDP_MASK ) )
+                {
+                    case USBFS_UIS_TOKEN_IN:
+                        switch( SetupReqCode )
+                        {
+                            case USB_GET_DESCRIPTOR:
+                                    len = SetupReqLen >= DevEP0SIZE ? DevEP0SIZE : SetupReqLen;
+                                    memcpy( pEP0_DataBuf, pDescr, len );
+                                    SetupReqLen -= len;
+                                    pDescr += len;
+                                    USBFSD->UEP0_TX_LEN   = len;
+                                    USBFSD->UEP0_TX_CTRL ^= USBFS_UEP_T_TOG;
+                                    break;
+
+                            case USB_SET_ADDRESS:
+                                    USBFSD->DEV_ADDR = (USBFSD->DEV_ADDR&USBFS_UDA_GP_BIT) | SetupReqLen;
+                                    USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_RES_NAK;
+                                    USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_RES_ACK;
+                                    break;
+
+                            default:
+                                    USBFSD->UEP0_TX_LEN = 0;
+                                    USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_RES_NAK;
+                                    USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_RES_ACK;
+                                    break;
+
+                        }
+                        break;
+
+
+                case USBFS_UIS_TOKEN_IN | 2:
+
+                    USBFSD->UEP2_TX_CTRL ^= USBFS_UEP_T_TOG;
+                    USBFSD->UEP2_TX_CTRL = (USBFSD->UEP2_TX_CTRL & ~USBFS_UEP_T_RES_MASK) | USBFS_UEP_T_RES_NAK;
+                    break;
+                default :
+                    break;
+
+                }
+                break;
+
+            case USBFS_UIS_TOKEN_OUT:
+                switch ( USBFSD->INT_ST & ( USBFS_UIS_TOKEN_MASK | USBFS_UIS_ENDP_MASK ) )
+                {
+                    case USBFS_UIS_TOKEN_OUT:
+                            len = USBFSD->RX_LEN;
+                            break;
+
+                    case USBFS_UIS_TOKEN_OUT | 2:
+                        if ( USBFSD->INT_ST & USBFS_UIS_TOG_OK )
+                        {
+                            USBFSD->UEP2_RX_CTRL ^= USBFS_UEP_R_TOG;
+                            len = USBFSD->RX_LEN;
+                            DevEP2_OUT_Deal( len );
+                        }
+                        break;
+                }
+
+                break;
+
+            default :
+                break;
+
+        }
+
+        USBFSD->INT_FG = USBFS_UIF_TRANSFER;
+    }
+    else if( intflag & USBFS_UIF_BUS_RST )
+    {
+        USBFSD->DEV_ADDR = 0;
+        USBFSD->UEP0_RX_CTRL = USBFS_UEP_R_RES_ACK;
+        USBFSD->UEP2_RX_CTRL = USBFS_UEP_R_RES_ACK;
+        USBFSD->UEP0_TX_CTRL = USBFS_UEP_T_RES_NAK;
+        USBFSD->UEP2_TX_CTRL = USBFS_UEP_T_RES_NAK;
+        USBFSD->INT_FG |= USBFS_UIF_BUS_RST;
+    }
+    else if( intflag & USBFS_UIF_SUSPEND )
+    {
+        if ( USBFSD->MIS_ST & USBFS_UMS_SUSPEND ) {;}
+        else{;}
+        USBFSD->INT_FG = USBFS_UIF_SUSPEND;
+    }
+    else
+    {
+        USBFSD->INT_FG = intflag;
+    }
+}
+
+
+/*********************************************************************
+ * @fn      DevEP2_IN_Deal
+ *
+ * @brief   Device endpoint2 IN.
+ *
+ * @param   l - IN length(<64B)
+ *
+ * @return  none
+ */
+void DevEP2_IN_Deal( UINT8 l )
+{
+    USBFSD->UEP2_TX_LEN = l;
+    USBFSD->UEP2_TX_CTRL = (USBFSD->UEP2_TX_CTRL & ~USBFS_UEP_T_RES_MASK)| USBFS_UEP_T_RES_ACK;
+}
+
+/*********************************************************************
+ * @fn      DevEP2_OUT_Deal
+ *
+ * @brief   Deal device Endpoint 2 OUT.
+ *
+ * @param   l - Data length.
+ *
+ * @return  none
+ */
+void DevEP2_OUT_Deal( UINT8 l )
+{
+    UINT8 s ,EP2_Tx_Cnt;
+
+    memcpy(EP2_Rx_Buffer, pEP2_OUT_DataBuf, l);
+    s = RecData_Deal();
+    if (s != ERR_End) {
+        EP2_Tx_Buffer[0] = 0x00;
+        if (s == ERR_ERROR)
+        {
+            pEP2_IN_DataBuf[1] = 0x01;
+        }
+        else
+            pEP2_IN_DataBuf[1] = 0x00;
+        EP2_Tx_Cnt = 2;
+        DevEP2_IN_Deal(EP2_Tx_Cnt);
+    }
+}
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/ch32v20x_usbfs_device.h

@@ -0,0 +1,716 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : ch32v20x_usbfs_device.h
+ * Author             : WCH
+ * Version            : V1.0.0
+ * Date               : 2021/06/06
+ * Description        : This file provides all the USBFS firmware functions.
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#ifndef __CH32V20x_USBFS_DEVICE_H_
+#define __CH32V20x_USBFS_DEVICE_H_
+
+#include "debug.h"
+#include "string.h"
+
+#ifndef NULL
+#define NULL                    0
+#endif
+
+#ifndef VOID
+#define VOID                    void
+#endif
+#ifndef CONST
+#define CONST                   const
+#endif
+#ifndef BOOL
+typedef unsigned char           BOOL;
+#endif
+#ifndef BOOLEAN
+typedef unsigned char           BOOLEAN;
+#endif
+#ifndef CHAR
+typedef char                    CHAR;
+#endif
+#ifndef INT8
+typedef char                    INT8;
+#endif
+#ifndef INT16
+typedef short                   INT16;
+#endif
+#ifndef INT32
+typedef long                    INT32;
+#endif
+#ifndef UINT8
+typedef unsigned char           UINT8;
+#endif
+#ifndef UINT16
+typedef unsigned short          UINT16;
+#endif
+#ifndef UINT32
+typedef unsigned long           UINT32;
+#endif
+#ifndef UINT8V
+typedef unsigned char volatile  UINT8V;
+#endif
+#ifndef UINT16V
+typedef unsigned short volatile UINT16V;
+#endif
+#ifndef UINT32V
+typedef unsigned long volatile  UINT32V;
+#endif
+
+#ifndef PVOID
+typedef void                    *PVOID;
+#endif
+#ifndef PCHAR
+typedef char                    *PCHAR;
+#endif
+#ifndef PCHAR
+typedef const char              *PCCHAR;
+#endif
+#ifndef PINT8
+typedef char                    *PINT8;
+#endif
+#ifndef PINT16
+typedef short                   *PINT16;
+#endif
+#ifndef PINT32
+typedef long                    *PINT32;
+#endif
+#ifndef PUINT8
+typedef unsigned char           *PUINT8;
+#endif
+#ifndef PUINT16
+typedef unsigned short          *PUINT16;
+#endif
+#ifndef PUINT32
+typedef unsigned long           *PUINT32;
+#endif
+#ifndef PUINT8V
+typedef volatile unsigned char  *PUINT8V;
+#endif
+#ifndef PUINT16V
+typedef volatile unsigned short *PUINT16V;
+#endif
+#ifndef PUINT32V
+typedef volatile unsigned long  *PUINT32V;
+#endif
+
+
+/* USB constant and structure define */
+
+/* USB PID */
+#ifndef USB_PID_SETUP
+#define USB_PID_NULL            0x00    /* reserved PID */
+#define USB_PID_SOF             0x05
+#define USB_PID_SETUP           0x0D
+#define USB_PID_IN              0x09
+#define USB_PID_OUT             0x01
+#define USB_PID_ACK             0x02
+#define USB_PID_NAK             0x0A
+#define USB_PID_STALL           0x0E
+#define USB_PID_DATA0           0x03
+#define USB_PID_DATA1           0x0B
+#define USB_PID_PRE             0x0C
+#endif
+
+/* USB standard device request code */
+#ifndef USB_GET_DESCRIPTOR
+#define USB_GET_STATUS          0x00
+#define USB_CLEAR_FEATURE       0x01
+#define USB_SET_FEATURE         0x03
+#define USB_SET_ADDRESS         0x05
+#define USB_GET_DESCRIPTOR      0x06
+#define USB_SET_DESCRIPTOR      0x07
+#define USB_GET_CONFIGURATION   0x08
+#define USB_SET_CONFIGURATION   0x09
+#define USB_GET_INTERFACE       0x0A
+#define USB_SET_INTERFACE       0x0B
+#define USB_SYNCH_FRAME         0x0C
+#endif
+
+/* USB hub class request code */
+#ifndef HUB_GET_DESCRIPTOR
+#define HUB_GET_STATUS          0x00
+#define HUB_CLEAR_FEATURE       0x01
+#define HUB_GET_STATE           0x02
+#define HUB_SET_FEATURE         0x03
+#define HUB_GET_DESCRIPTOR      0x06
+#define HUB_SET_DESCRIPTOR      0x07
+#endif
+
+/* USB HID class request code */
+#ifndef HID_GET_REPORT
+#define HID_GET_REPORT          0x01
+#define HID_GET_IDLE            0x02
+#define HID_GET_PROTOCOL        0x03
+#define HID_SET_REPORT          0x09
+#define HID_SET_IDLE            0x0A
+#define HID_SET_PROTOCOL        0x0B
+#endif
+
+/* Bit define for USB request type */
+#ifndef USB_REQ_TYP_MASK
+#define USB_REQ_TYP_IN          0x80            /* control IN, device to host */
+#define USB_REQ_TYP_OUT         0x00            /* control OUT, host to device */
+#define USB_REQ_TYP_READ        0x80            /* control read, device to host */
+#define USB_REQ_TYP_WRITE       0x00            /* control write, host to device */
+#define USB_REQ_TYP_MASK        0x60            /* bit mask of request type */
+#define USB_REQ_TYP_STANDARD    0x00
+#define USB_REQ_TYP_CLASS       0x20
+#define USB_REQ_TYP_VENDOR      0x40
+#define USB_REQ_TYP_RESERVED    0x60
+#define USB_REQ_RECIP_MASK      0x1F            /* bit mask of request recipient */
+#define USB_REQ_RECIP_DEVICE    0x00
+#define USB_REQ_RECIP_INTERF    0x01
+#define USB_REQ_RECIP_ENDP      0x02
+#define USB_REQ_RECIP_OTHER     0x03
+#endif
+
+/* USB request type for hub class request */
+#ifndef HUB_GET_HUB_DESCRIPTOR
+#define HUB_CLEAR_HUB_FEATURE   0x20
+#define HUB_CLEAR_PORT_FEATURE  0x23
+#define HUB_GET_BUS_STATE       0xA3
+#define HUB_GET_HUB_DESCRIPTOR  0xA0
+#define HUB_GET_HUB_STATUS      0xA0
+#define HUB_GET_PORT_STATUS     0xA3
+#define HUB_SET_HUB_DESCRIPTOR  0x20
+#define HUB_SET_HUB_FEATURE     0x20
+#define HUB_SET_PORT_FEATURE    0x23
+#endif
+
+/* Hub class feature selectors */
+#ifndef HUB_PORT_RESET
+#define HUB_C_HUB_LOCAL_POWER   0
+#define HUB_C_HUB_OVER_CURRENT  1
+#define HUB_PORT_CONNECTION     0
+#define HUB_PORT_ENABLE         1
+#define HUB_PORT_SUSPEND        2
+#define HUB_PORT_OVER_CURRENT   3
+#define HUB_PORT_RESET          4
+#define HUB_PORT_POWER          8
+#define HUB_PORT_LOW_SPEED      9
+#define HUB_C_PORT_CONNECTION   16
+#define HUB_C_PORT_ENABLE       17
+#define HUB_C_PORT_SUSPEND      18
+#define HUB_C_PORT_OVER_CURRENT 19
+#define HUB_C_PORT_RESET        20
+#endif
+
+/* USB descriptor type */
+#ifndef USB_DESCR_TYP_DEVICE
+#define USB_DESCR_TYP_DEVICE    0x01
+#define USB_DESCR_TYP_CONFIG    0x02
+#define USB_DESCR_TYP_STRING    0x03
+#define USB_DESCR_TYP_INTERF    0x04
+#define USB_DESCR_TYP_ENDP      0x05
+#define USB_DESCR_TYP_QUALIF    0x06
+#define USB_DESCR_TYP_SPEED     0x07
+#define USB_DESCR_TYP_OTG       0x09
+#define USB_DESCR_TYP_BOS       0X0F
+#define USB_DESCR_TYP_HID       0x21
+#define USB_DESCR_TYP_REPORT    0x22
+#define USB_DESCR_TYP_PHYSIC    0x23
+#define USB_DESCR_TYP_CS_INTF   0x24
+#define USB_DESCR_TYP_CS_ENDP   0x25
+#define USB_DESCR_TYP_HUB       0x29
+#endif
+
+/* USB device class */
+#ifndef USB_DEV_CLASS_HUB
+#define USB_DEV_CLASS_RESERVED  0x00
+#define USB_DEV_CLASS_AUDIO     0x01
+#define USB_DEV_CLASS_COMMUNIC  0x02
+#define USB_DEV_CLASS_HID       0x03
+#define USB_DEV_CLASS_MONITOR   0x04
+#define USB_DEV_CLASS_PHYSIC_IF 0x05
+#define USB_DEV_CLASS_POWER     0x06
+#define USB_DEV_CLASS_PRINTER   0x07
+#define USB_DEV_CLASS_STORAGE   0x08
+#define USB_DEV_CLASS_HUB       0x09
+#define USB_DEV_CLASS_VEN_SPEC  0xFF
+#endif
+
+/* USB endpoint type and attributes */
+#ifndef USB_ENDP_TYPE_MASK
+#define USB_ENDP_DIR_MASK       0x80
+#define USB_ENDP_ADDR_MASK      0x0F
+#define USB_ENDP_TYPE_MASK      0x03
+#define USB_ENDP_TYPE_CTRL      0x00
+#define USB_ENDP_TYPE_ISOCH     0x01
+#define USB_ENDP_TYPE_BULK      0x02
+#define USB_ENDP_TYPE_INTER     0x03
+#endif
+
+#ifndef USB_DEVICE_ADDR
+#define USB_DEVICE_ADDR             0x02
+#endif
+#ifndef DEFAULT_ENDP0_SIZE
+#define DEFAULT_ENDP0_SIZE      8       /* default maximum packet size for endpoint 0 */
+#endif
+#ifndef MAX_PACKET_SIZE
+#define MAX_PACKET_SIZE         64      /* maximum packet size */
+#endif
+#ifndef USB_BO_CBW_SIZE
+#define USB_BO_CBW_SIZE             0x1F
+#define USB_BO_CSW_SIZE             0x0D
+#endif
+#ifndef USB_BO_CBW_SIG0
+#define USB_BO_CBW_SIG0         0x55
+#define USB_BO_CBW_SIG1         0x53
+#define USB_BO_CBW_SIG2         0x42
+#define USB_BO_CBW_SIG3         0x43
+#define USB_BO_CSW_SIG0         0x55
+#define USB_BO_CSW_SIG1         0x53
+#define USB_BO_CSW_SIG2         0x42
+#define USB_BO_CSW_SIG3         0x53
+#endif
+
+#ifndef __PACKED
+#define __PACKED            __attribute__((packed))
+#endif
+
+typedef struct __PACKED _USB_SETUP_REQ {
+    UINT8 bRequestType;
+    UINT8 bRequest;
+    UINT16 wValue;
+    UINT16 wIndex;
+    UINT16 wLength;
+} USB_SETUP_REQ, *PUSB_SETUP_REQ;
+
+
+typedef struct __PACKED _USB_DEVICE_DESCR {
+    UINT8 bLength;
+    UINT8 bDescriptorType;
+    UINT16 bcdUSB;
+    UINT8 bDeviceClass;
+    UINT8 bDeviceSubClass;
+    UINT8 bDeviceProtocol;
+    UINT8 bMaxPacketSize0;
+    UINT16 idVendor;
+    UINT16 idProduct;
+    UINT16 bcdDevice;
+    UINT8 iManufacturer;
+    UINT8 iProduct;
+    UINT8 iSerialNumber;
+    UINT8 bNumConfigurations;
+} USB_DEV_DESCR, *PUSB_DEV_DESCR;
+
+
+typedef struct __PACKED _USB_CONFIG_DESCR {
+    UINT8 bLength;
+    UINT8 bDescriptorType;
+    UINT16 wTotalLength;
+    UINT8 bNumInterfaces;
+    UINT8 bConfigurationValue;
+    UINT8 iConfiguration;
+    UINT8 bmAttributes;
+    UINT8 MaxPower;
+} USB_CFG_DESCR, *PUSB_CFG_DESCR;
+
+
+typedef struct __PACKED _USB_INTERF_DESCR {
+    UINT8 bLength;
+    UINT8 bDescriptorType;
+    UINT8 bInterfaceNumber;
+    UINT8 bAlternateSetting;
+    UINT8 bNumEndpoints;
+    UINT8 bInterfaceClass;
+    UINT8 bInterfaceSubClass;
+    UINT8 bInterfaceProtocol;
+    UINT8 iInterface;
+} USB_ITF_DESCR, *PUSB_ITF_DESCR;
+
+
+typedef struct __PACKED _USB_ENDPOINT_DESCR {
+    UINT8 bLength;
+    UINT8 bDescriptorType;
+    UINT8 bEndpointAddress;
+    UINT8 bmAttributes;
+    UINT16 wMaxPacketSize;
+    UINT8 bInterval;
+} USB_ENDP_DESCR, *PUSB_ENDP_DESCR;
+
+
+typedef struct __PACKED _USB_CONFIG_DESCR_LONG {
+    USB_CFG_DESCR   cfg_descr;
+    USB_ITF_DESCR   itf_descr;
+    USB_ENDP_DESCR  endp_descr[1];
+} USB_CFG_DESCR_LONG, *PUSB_CFG_DESCR_LONG;
+
+
+typedef struct __PACKED _USB_HUB_DESCR {
+    UINT8 bDescLength;
+    UINT8 bDescriptorType;
+    UINT8 bNbrPorts;
+    UINT8 wHubCharacteristicsL;
+    UINT8 wHubCharacteristicsH;
+    UINT8 bPwrOn2PwrGood;
+    UINT8 bHubContrCurrent;
+    UINT8 DeviceRemovable;
+    UINT8 PortPwrCtrlMask;
+} USB_HUB_DESCR, *PUSB_HUB_DESCR;
+
+
+typedef struct __PACKED _USB_HID_DESCR {
+    UINT8 bLength;
+    UINT8 bDescriptorType;
+    UINT16 bcdHID;
+    UINT8 bCountryCode;
+    UINT8 bNumDescriptors;
+    UINT8 bDescriptorTypeX;
+    UINT8 wDescriptorLengthL;
+    UINT8 wDescriptorLengthH;
+} USB_HID_DESCR, *PUSB_HID_DESCR;
+
+
+typedef struct __PACKED _UDISK_BOC_CBW {/* command of BulkOnly USB-FlashDisk */
+    UINT32 mCBW_Sig;
+    UINT32 mCBW_Tag;
+    UINT32 mCBW_DataLen;                /* uppest byte of data length, always is 0 */
+    UINT8 mCBW_Flag;                    /* transfer direction and etc. */
+    UINT8 mCBW_LUN;
+    UINT8 mCBW_CB_Len;                  /* length of command block */
+    UINT8 mCBW_CB_Buf[16];              /* command block buffer */
+} UDISK_BOC_CBW, *PXUDISK_BOC_CBW;
+
+
+typedef struct __PACKED _UDISK_BOC_CSW {/* status of BulkOnly USB-FlashDisk */
+    UINT32 mCBW_Sig;
+    UINT32 mCBW_Tag;
+    UINT32 mCSW_Residue;                /* return: remainder bytes */         /* uppest byte of remainder length, always is 0 */
+    UINT8 mCSW_Status;                  /* return: result status */
+} UDISK_BOC_CSW, *PXUDISK_BOC_CSW;
+
+
+#define USE_SYS_CLK        0
+//#define USBFS_HOST         0
+//#define USB_OTG            0
+
+/******************************************************************************/
+/* USBFSD DEVICE USB_CONTROL */
+/* BASE USB_CTRL */
+#define   USBFS_BASE_CTRL       (USBFSD->BASE_CTRL)  // USB base control
+#define     USBFS_UC_HOST_MODE     0x80      // enable USB host mode: 0=device mode, 1=host mode
+#define     USBFS_UC_LOW_SPEED     0x40      // enable USB low speed: 0=12Mbps, 1=1.5Mbps
+#define     USBFS_UC_DEV_PU_EN     0x20      // USB device enable and internal pullup resistance enable
+#define     USBFS_UC_SYS_CTRL1     0x20      // USB system control high bit
+#define     USBFS_UC_SYS_CTRL0     0x10      // USB system control low bit
+#define     USBFS_UC_SYS_CTRL_MASK 0x30      // bit mask of USB system control
+// UC_HOST_MODE & UC_SYS_CTRL1 & UC_SYS_CTRL0: USB system control
+//   0 00: disable USB device and disable internal pullup resistance
+//   0 01: enable USB device and disable internal pullup resistance, need external pullup resistance
+//   0 1x: enable USB device and enable internal pullup resistance
+//   1 00: enable USB host and normal status
+//   1 01: enable USB host and force UDP/UDM output SE0 state
+//   1 10: enable USB host and force UDP/UDM output J state
+//   1 11: enable USB host and force UDP/UDM output resume or K state
+#define     USBFS_UC_INT_BUSY      0x08      // enable automatic responding busy for device mode or automatic pause for host mode during interrupt flag UIF_TRANSFER valid
+#define     USBFS_UC_RESET_SIE     0x04      // force reset USB SIE, need software clear
+#define     USBFS_UC_CLR_ALL       0x02      // force clear FIFO and count of USB
+#define     USBFS_UC_DMA_EN        0x01      // DMA enable and DMA interrupt enable for USB
+/* DEVICE USB_CTRL */
+#define   USBFS_UDEV_CTRL        (USBFSD->UDEV_CTRL)  // USB device physical prot control
+#define     USBFS_UD_PD_DIS        0x80      // disable USB UDP/UDM pulldown resistance: 0=enable pulldown, 1=disable
+#define     USBFS_UD_DP_PIN        0x20      // ReadOnly: indicate current UDP pin level
+#define     USBFS_UD_DM_PIN        0x10      // ReadOnly: indicate current UDM pin level
+#define     USBFS_UD_LOW_SPEED     0x04      // enable USB physical port low speed: 0=full speed, 1=low speed
+#define     USBFS_UD_GP_BIT        0x02      // general purpose bit
+#define     USBFS_UD_PORT_EN       0x01      // enable USB physical port I/O: 0=disable, 1=enable
+/* USB INT EN */
+#define   USBFS_INT_EN           (USBFSD->INT_EN)    // USB interrupt enable
+#define     USBFS_UIE_DEV_NAK      0x40      // enable interrupt for NAK responded for USB device mode
+#define     USBFS_UIE_FIFO_OV      0x10      // enable interrupt for FIFO overflow
+#define     USBFS_UIE_HST_SOF      0x08      // enable interrupt for host SOF timer action for USB host mode
+#define     USBFS_UIE_SUSPEND      0x04      // enable interrupt for USB suspend or resume event
+#define     USBFS_UIE_TRANSFER     0x02      // enable interrupt for USB transfer completion
+#define     USBFS_UIE_DETECT       0x01      // enable interrupt for USB device detected event for USB host mode
+#define     USBFS_UIE_BUS_RST      0x01      // enable interrupt for USB bus reset event for USB device mode
+/* USB_DEV_ADDR */
+#define   USBFS_DEV_ADDR         (USBFSD->DEV_ADDR)   // USB device address
+#define     USBFS_UDA_GP_BIT       0x80      // general purpose bit
+#define     USBFS_USB_ADDR_MASK    0x7F      // bit mask for USB device address
+/* USBFSD DEVICE USB_STATUS */
+/* USB_MIS_ST */
+#define   USBFS_MIS_ST           (USBFSD->MIS_ST)     // USB miscellaneous status
+#define     USBFS_UMS_SOF_PRES     0x80      // RO, indicate host SOF timer presage status
+#define     USBFS_UMS_SOF_ACT      0x40      // RO, indicate host SOF timer action status for USB host
+#define     USBFS_UMS_SIE_FREE     0x20      // RO, indicate USB SIE free status
+#define     USBFS_UMS_R_FIFO_RDY   0x10      // RO, indicate USB receiving FIFO ready status (not empty)
+#define     USBFS_UMS_BUS_RESET    0x08      // RO, indicate USB bus reset status
+#define     USBFS_UMS_SUSPEND      0x04      // RO, indicate USB suspend status
+#define     USBFS_UMS_DM_LEVEL     0x02      // RO, indicate UDM level saved at device attached to USB host
+#define     USBFS_UMS_DEV_ATTACH   0x01      // RO, indicate device attached status on USB host
+/* USB_INT_FG */
+#define   USBFS_INT_FG           (USBFSD->INT_FG)    // USB interrupt flag
+#define     USBFS_U_IS_NAK         0x80    // RO, indicate current USB transfer is NAK received
+#define     USBFS_U_TOG_OK         0x40    // RO, indicate current USB transfer toggle is OK
+#define     USBFS_U_SIE_FREE       0x20    // RO, indicate USB SIE free status
+#define     USBFS_UIF_FIFO_OV      0x10    // FIFO overflow interrupt flag for USB, direct bit address clear or write 1 to clear
+#define     USBFS_UIF_HST_SOF      0x08    // host SOF timer interrupt flag for USB host, direct bit address clear or write 1 to clear
+#define     USBFS_UIF_SUSPEND      0x04    // USB suspend or resume event interrupt flag, direct bit address clear or write 1 to clear
+#define     USBFS_UIF_TRANSFER     0x02    // USB transfer completion interrupt flag, direct bit address clear or write 1 to clear
+#define     USBFS_UIF_DETECT       0x01    // device detected event interrupt flag for USB host mode, direct bit address clear or write 1 to clear
+#define     USBFS_UIF_BUS_RST      0x01    // bus reset event interrupt flag for USB device mode, direct bit address clear or write 1 to clear
+/* USB_INT_ST */
+#define   USBFS_INT_ST           (USBFSD->INT_ST)    // USB interrupt flag
+#define     USBFS_UIS_IS_SETUP     0x80      // RO, indicate current USB transfer is setup received for USB device mode
+#define     USBFS_UIS_IS_NAK       0x80      // RO, indicate current USB transfer is NAK received for USB device mode
+#define     USBFS_UIS_TOG_OK       0x40      // RO, indicate current USB transfer toggle is OK
+#define     USBFS_UIS_TOKEN1       0x20      // RO, current token PID code bit 1 received for USB device mode
+#define     USBFS_UIS_TOKEN0       0x10      // RO, current token PID code bit 0 received for USB device mode
+#define     USBFS_UIS_TOKEN_MASK   0x30      // RO, bit mask of current token PID code received for USB device mode
+#define     USBFS_UIS_TOKEN_OUT    0x00
+#define     USBFS_UIS_TOKEN_IN     0x20
+#define     USBFS_UIS_TOKEN_SETUP  0x30
+// UIS_TOKEN1 & UIS_TOKEN0: current token PID code received for USB device mode
+//   00: OUT token PID received
+//   10: IN token PID received
+//   11: SETUP token PID received
+#define     USBFS_UIS_ENDP_MASK    0x0F      // RO, bit mask of current transfer endpoint number for USB device mode
+/* USB_RX_LEN */
+#define   USBFS_RX_LEN        (USBFSD->Rx_Len)      // USB receiving length
+/* USB_BUF_MOD */
+#define   USBFS_UEP4_1_MOD    (USBFSD->UEP4_1_MOD)  // endpoint 4/1 mode
+#define     USBFS_UEP1_RX_EN       0x80      // enable USB endpoint 1 receiving (OUT)
+#define     USBFS_UEP1_TX_EN       0x40      // enable USB endpoint 1 transmittal (IN)
+#define     USBFS_UEP1_BUF_MOD     0x10      // buffer mode of USB endpoint 1
+// UEPn_RX_EN & UEPn_TX_EN & UEPn_BUF_MOD: USB endpoint 1/2/3 buffer mode, buffer start address is UEPn_DMA
+//   0 0 x:  disable endpoint and disable buffer
+//   1 0 0:  64 bytes buffer for receiving (OUT endpoint)
+//   1 0 1:  dual 64 bytes buffer by toggle bit bUEP_R_TOG selection for receiving (OUT endpoint), total=128bytes
+//   0 1 0:  64 bytes buffer for transmittal (IN endpoint)
+//   0 1 1:  dual 64 bytes buffer by toggle bit bUEP_T_TOG selection for transmittal (IN endpoint), total=128bytes
+//   1 1 0:  64 bytes buffer for receiving (OUT endpoint) + 64 bytes buffer for transmittal (IN endpoint), total=128bytes
+//   1 1 1:  dual 64 bytes buffer by bUEP_R_TOG selection for receiving (OUT endpoint) + dual 64 bytes buffer by bUEP_T_TOG selection for transmittal (IN endpoint), total=256bytes
+#define     USBFS_UEP4_RX_EN       0x08      // enable USB endpoint 4 receiving (OUT)
+#define     USBFS_UEP4_TX_EN       0x04      // enable USB endpoint 4 transmittal (IN)
+// UEP4_RX_EN & UEP4_TX_EN: USB endpoint 4 buffer mode, buffer start address is UEP0_DMA
+//   0 0:  single 64 bytes buffer for endpoint 0 receiving & transmittal (OUT & IN endpoint)
+//   1 0:  single 64 bytes buffer for endpoint 0 receiving & transmittal (OUT & IN endpoint) + 64 bytes buffer for endpoint 4 receiving (OUT endpoint), total=128bytes
+//   0 1:  single 64 bytes buffer for endpoint 0 receiving & transmittal (OUT & IN endpoint) + 64 bytes buffer for endpoint 4 transmittal (IN endpoint), total=128bytes
+//   1 1:  single 64 bytes buffer for endpoint 0 receiving & transmittal (OUT & IN endpoint)
+//           + 64 bytes buffer for endpoint 4 receiving (OUT endpoint) + 64 bytes buffer for endpoint 4 transmittal (IN endpoint), total=192bytes
+
+#define  USBFS_UEP2_3_MOD     (USBFSD->UEP2_3_MOD)  // endpoint 2/3 mode
+#define     USBFS_UEP3_RX_EN       0x80      // enable USB endpoint 3 receiving (OUT)
+#define     USBFS_UEP3_TX_EN       0x40      // enable USB endpoint 3 transmittal (IN)
+#define     USBFS_UEP3_BUF_MOD     0x10      // buffer mode of USB endpoint 3
+#define     USBFS_UEP2_RX_EN       0x08      // enable USB endpoint 2 receiving (OUT)
+#define     USBFS_UEP2_TX_EN       0x04      // enable USB endpoint 2 transmittal (IN)
+#define     USBFS_UEP2_BUF_MOD     0x01      // buffer mode of USB endpoint 2
+
+#define  USBFS_UEP5_6_MOD     (USBFSD->UEP5_6_MOD)  // endpoint 5/6 mode
+#define     USBFS_UEP6_RX_EN       0x80      // enable USB endpoint 6 receiving (OUT)
+#define     USBFS_UEP6_TX_EN       0x40      // enable USB endpoint 6 transmittal (IN)
+#define     USBFS_UEP6_BUF_MOD     0x10      // buffer mode of USB endpoint 6
+#define     USBFS_UEP5_RX_EN       0x08      // enable USB endpoint 5 receiving (OUT)
+#define     USBFS_UEP5_TX_EN       0x04      // enable USB endpoint 5 transmittal (IN)
+#define     USBFS_UEP5_BUF_MOD     0x01      // buffer mode of USB endpoint 5
+
+#define  USBFS_UEP7_MOD       (USBFSD->UEP7_MOD)  // endpoint 7 mode
+#define     USBFS_UEP7_RX_EN       0x08      // enable USB endpoint 7 receiving (OUT)
+#define     USBFS_UEP7_TX_EN       0x04      // enable USB endpoint 7 transmittal (IN)
+#define     USBFS_UEP7_BUF_MOD     0x01      // buffer mode of USB endpoint 7
+/* USB_DMA */
+#define  USBFS_UEP0_DMA       (USBFSD->UEP0_DMA) // endpoint 0 DMA buffer address
+//#define  USBFS_UEP1_DMA       (USBFSD->UEP1_DMA) // endpoint 1 DMA buffer address
+#define  USBFS_UEP2_DMA       (USBFSD->UEP2_DMA) // endpoint 2 DMA buffer address
+//#define  USBFS_UEP3_DMA       (USBFSD->UEP3_DMA) // endpoint 3 DMA buffer address
+//#define  USBFS_UEP4_DMA       (USBFSD->UEP4_DMA) // endpoint 4 DMA buffer address
+//#define  USBFS_UEP5_DMA       (USBFSD->UEP5_DMA) // endpoint 5 DMA buffer address
+//#define  USBFS_UEP6_DMA       (USBFSD->UEP6_DMA) // endpoint 6 DMA buffer address
+//#define  USBFS_UEP7_DMA       (USBFSD->UEP7_DMA) // endpoint 7 DMA buffer address
+/* USB_EP_CTRL */
+#define  USBFS_UEP0_T_LEN     (USBFSD->UEP0_TX_LEN)   // endpoint 0 transmittal length
+#define  USBFS_UEP0_TX_CTRL   (USBFSD->UEP0_TX_CTRL)  // endpoint 0 control
+#define  USBFS_UEP0_RX_CTRL   (USBFSD->UEP0_RX_CTRL)  // endpoint 0 control
+
+//#define  USBFS_UEP1_T_LEN     (USBFSD->UEP1_TX_LEN)   // endpoint 1 transmittal length
+//#define  USBFS_UEP1_TX_CTRL   (USBFSD->UEP1_TX_CTRL)  // endpoint 1 control
+//#define  USBFS_UEP1_RX_CTRL   (USBFSD->UEP1_RX_CTRL)  // endpoint 1 control
+
+#define  USBFS_UEP2_T_LEN     (USBFSD->UEP2_TX_LEN)   // endpoint 2 transmittal length
+#define  USBFS_UEP2_TX_CTRL   (USBFSD->UEP2_TX_CTRL)  // endpoint 2 control
+#define  USBFS_UEP2_RX_CTRL   (USBFSD->UEP2_RX_CTRL)  // endpoint 2 control
+
+//#define  USBFS_UEP3_T_LEN     (USBFSD->UEP3_TX_LEN)   // endpoint 3 transmittal length
+//#define  USBFS_UEP3_TX_CTRL   (USBFSD->UEP3_TX_CTRL)  // endpoint 3 control
+//#define  USBFS_UEP3_RX_CTRL   (USBFSD->UEP3_RX_CTRL)  // endpoint 3 control
+//
+//#define  USBFS_UEP4_T_LEN     (USBFSD->UEP4_TX_LEN)   // endpoint 4 transmittal length
+//#define  USBFS_UEP4_TX_CTRL   (USBFSD->UEP4_TX_CTRL)  // endpoint 4 control
+//#define  USBFS_UEP4_RX_CTRL   (USBFSD->UEP4_RX_CTRL)  // endpoint 4 control
+//
+//#define  USBFS_UEP5_T_LEN     (USBFSD->UEP5_TX_LEN)   // endpoint 5 transmittal length
+//#define  USBFS_UEP5_TX_CTRL   (USBFSD->UEP5_TX_CTRL)  // endpoint 5 control
+//#define  USBFS_UEP5_RX_CTRL   (USBFSD->UEP5_RX_CTRL)  // endpoint 5 control
+//
+//#define  USBFS_UEP6_T_LEN     (USBFSD->UEP6_TX_LEN)   // endpoint 6 transmittal length
+//#define  USBFS_UEP6_TX_CTRL   (USBFSD->UEP6_TX_CTRL)  // endpoint 6 control
+//#define  USBFS_UEP6_RX_CTRL   (USBFSD->UEP6_RX_CTRL)  // endpoint 6 control
+//
+//#define  USBFS_UEP7_T_LEN     (USBFSD->UEP7_TX_LEN)   // endpoint 7 transmittal length
+//#define  USBFS_UEP7_TX_CTRL   (USBFSD->UEP7_TX_CTRL)  // endpoint 7 control
+//#define  USBFS_UEP7_RX_CTRL   (USBFSD->UEP7_RX_CTRL)  // endpoint 7 control
+
+#define     USBFS_UEP_AUTO_TOG     0x08      // enable automatic toggle after successful transfer completion on endpoint 1/2/3: 0=manual toggle, 1=automatic toggle
+#define     USBFS_UEP_R_TOG        0x04      // expected data toggle flag of USB endpoint X receiving (OUT): 0=DATA0, 1=DATA1
+#define     USBFS_UEP_T_TOG        0x04      // prepared data toggle flag of USB endpoint X transmittal (IN): 0=DATA0, 1=DATA1
+
+#define     USBFS_UEP_R_RES1       0x02      // handshake response type high bit for USB endpoint X receiving (OUT)
+#define     USBFS_UEP_R_RES0       0x01      // handshake response type low bit for USB endpoint X receiving (OUT)
+#define     USBFS_UEP_R_RES_MASK   0x03      // bit mask of handshake response type for USB endpoint X receiving (OUT)
+#define     USBFS_UEP_R_RES_ACK    0x00
+#define     USBFS_UEP_R_RES_TOUT   0x01
+#define     USBFS_UEP_R_RES_NAK    0x02
+#define     USBFS_UEP_R_RES_STALL  0x03
+// RB_UEP_R_RES1 & RB_UEP_R_RES0: handshake response type for USB endpoint X receiving (OUT)
+//   00: ACK (ready)
+//   01: no response, time out to host, for non-zero endpoint isochronous transactions
+//   10: NAK (busy)
+//   11: STALL (error)
+#define     USBFS_UEP_T_RES1       0x02      // handshake response type high bit for USB endpoint X transmittal (IN)
+#define     USBFS_UEP_T_RES0       0x01      // handshake response type low bit for USB endpoint X transmittal (IN)
+#define     USBFS_UEP_T_RES_MASK   0x03      // bit mask of handshake response type for USB endpoint X transmittal (IN)
+#define     USBFS_UEP_T_RES_ACK    0x00
+#define     USBFS_UEP_T_RES_TOUT   0x01
+#define     USBFS_UEP_T_RES_NAK    0x02
+#define     USBFS_UEP_T_RES_STALL  0x03
+// bUEP_T_RES1 & bUEP_T_RES0: handshake response type for USB endpoint X transmittal (IN)
+//   00: DATA0 or DATA1 then expecting ACK (ready)
+//   01: DATA0 or DATA1 then expecting no response, time out from host, for non-zero endpoint isochronous transactions
+//   10: NAK (busy)
+//   11: TALL (error)
+
+#ifdef  USBFS_HOST
+/* USBFSD HOST CONTROL&CFG */
+/* HOST USB_CTRL */
+#define  USBFS_UHOST_CTRL       (USBFSD->UDEV_CTRL) // USB host physical prot control
+#define     USBFS_UH_PD_DIS        0x80      // disable USB UDP/UDM pulldown resistance: 0=enable pulldown, 1=disable
+#define     USBFS_UH_DP_PIN        0x20      // ReadOnly: indicate current UDP pin level
+#define     USBFS_UH_DM_PIN        0x10      // ReadOnly: indicate current UDM pin level
+#define     USBFS_UH_LOW_SPEED     0x04      // enable USB port low speed: 0=full speed, 1=low speed
+#define     USBFS_UH_BUS_RESET     0x02      // control USB bus reset: 0=normal, 1=force bus reset
+#define     USBFS_UH_PORT_EN       0x01      // enable USB port: 0=disable, 1=enable port, automatic disabled if USB device detached
+/* USB_INT_ST */
+#define     USBFS_UIS_H_RES_MASK   0x0F      // RO, bit mask of current transfer handshake response for USB host mode: 0000=no response, time out from device, others=handshake response PID received
+/* USB_BUF_MOD */
+#define  USBFS_UH_EP_MOD        USBFS_UEP2_3_MOD               //host endpoint mode
+#define    USBFS__UH_EP_TX_EN      0x40      // enable USB host OUT endpoint transmittal
+#define    USBFS__UH_EP_TBUF_MOD   0x10      // buffer mode of USB host OUT endpoint
+// UH_EP_TX_EN & UH_EP_TBUF_MOD: USB host OUT endpoint buffer mode, buffer start address is UH_TX_DMA
+//   0 x:  disable endpoint and disable buffer
+//   1 0:  64 bytes buffer for transmittal (OUT endpoint)
+//   1 1:  dual 64 bytes buffer by toggle bit bUH_T_TOG selection for transmittal (OUT endpoint), total=128bytes
+#define    USBFS_UH_EP_RX_EN      0x08      // enable USB host IN endpoint receiving
+#define    USBFS_UH_EP_RBUF_MOD   0x01      // buffer mode of USB host IN endpoint
+// UH_EP_RX_EN & UH_EP_RBUF_MOD: USB host IN endpoint buffer mode, buffer start address is UH_RX_DMA
+//   0 x:  disable endpoint and disable buffer
+//   1 0:  64 bytes buffer for receiving (IN endpoint)
+//   1 1:  dual 64 bytes buffer by toggle bit bUH_R_TOG selection for receiving (IN endpoint), total=128bytes
+/* USB_DMA */
+#define  USBFS_UH_RX_DMA       USBFS_UEP2_DMA                // host rx endpoint buffer high address
+#define  USBFS_UH_TX_DMA       USBFS_UEP3_DMA                // host tx endpoint buffer high address
+/* USB_HOST_SETUP  */
+#define  USBFS_UH_SETUP        (*((PUINT16V)(0x50000036))) // host aux setup
+#define     USBFS_UH_PRE_PID_EN    0x0400      // USB host PRE PID enable for low speed device via hub
+#define     USBFS_UH_SOF_EN        0x04        // USB host automatic SOF enable
+#define  USBFS_UH_EP_PID        USBFS_UEP2_T_LEN               // host endpoint and PID
+#define     USBFS_UH_TOKEN_MASK    0xF0        // bit mask of token PID for USB host transfer
+#define     USBFS_UH_ENDP_MASK     0x0F        // bit mask of endpoint number for USB host transfer
+
+#define  USBFS_UH_RX_CTRL       USBFS_UEP2_RX_CTRL             // host receiver endpoint control
+#define     USBFS_UH_R_AUTO_TOG    0x08      // enable automatic toggle after successful transfer completion: 0=manual toggle, 1=automatic toggle
+#define     USBFS_UH_R_TOG         0x04      // expected data toggle flag of host receiving (IN): 0=DATA0, 1=DATA1
+#define     USBFS_UH_R_RES         0x01      // prepared handshake response type for host receiving (IN): 0=ACK (ready), 1=no response, time out to device, for isochronous transactions
+
+#define  USBFS_UH_RX_CTRL       USBFS_UEP2_RX_CTRL             // host receiver endpoint control
+#define     USBFS_UH_R_AUTO_TOG    0x08      // enable automatic toggle after successful transfer completion: 0=manual toggle, 1=automatic toggle
+#define     USBFS_UH_R_TOG         0x04      // expected data toggle flag of host receiving (IN): 0=DATA0, 1=DATA1
+#define     USBFS_UH_R_RES         0x01      // prepared handshake response type for host receiving (IN): 0=ACK (ready), 1=no response, time out to device, for isochronous transactions
+#define  USBFS_UH_TX_LEN        USBFS_UEP3_T_LEN               // host transmittal endpoint transmittal length
+
+#define  USBFS_UH_TX_CTRL       USBFS_UEP3_TX_CTRL             // host transmittal endpoint control
+#define     USBFS_UH_T_AUTO_TOG    0x08      // enable automatic toggle after successful transfer completion: 0=manual toggle, 1=automatic toggle
+#define     USBFS_UH_T_TOG         0x04      // prepared data toggle flag of host transmittal (SETUP/OUT): 0=DATA0, 1=DATA1
+#define     USBFS_UH_T_RES         0x01      // expected handshake response type for host transmittal (SETUP/OUT): 0=ACK (ready), 1=no response, time out from device, for isochronous transactions
+#endif
+#ifdef USB_OTG
+#define  USB_OTG_CR          (USBFSD->OTG_CR)  // usb otg control
+#define     USB_OTG_CR_SESS           0x20
+#define     USB_OTG_CR_VBUS           0x10
+#define     USB_OTG_CR_OTG_EN         0x08
+#define     USB_OTG_CR_IDPU           0x04
+#define     USB_OTG_CR_CHARGEVBUS     0x02
+#define     USB_OTG_CR_DISCHARGEVBUS  0x01
+
+#define  USB_OTG_SR          (USBFSD->OTG_CR)
+#define     USB_OTG_SR_VBUS_VLD       0x01
+#define     USB_OTG_SR_SESS_VLD       0x02
+#define     USB_OTG_SR_SESS_END       0x04
+#define     USB_OTG_SR_ID_DIG         0x08
+#endif
+
+
+#ifndef  USBHS_EXIST
+#define USB_48M_CLK_SRC_MASK   (1<<31)
+#define USB_48M_CLK_SRC_SYS    (0<<31)
+#define USB_48M_CLK_SRC_PHY    (1<<31)
+
+#define USBHS_PLL_ALIVE        (1<<30)
+
+#define USBHS_PLL_CKREF_MASK   (3<<28)
+#define USBHS_PLL_CKREF_3M     (0<<28)
+#define USBHS_PLL_CKREF_4M     (1<<28)
+#define USBHS_PLL_CKREF_8M     (2<<28)
+#define USBHS_PLL_CKREF_5M     (3<<28)
+
+#define USBHS_PLL_SRC_MASK     (1<<27)
+#define USBHS_PLL_SRC_HSE      (0<<27)
+#define USBHS_PLL_SRC_HSI      (1<<27)
+
+#define USBHS_PLL_SRC_PRE_MASK (7<<24)
+#define USBHS_PLL_SRC_PRE_DIV1 (0<<24)
+#define USBHS_PLL_SRC_PRE_DIV2 (1<<24)
+#define USBHS_PLL_SRC_PRE_DIV3 (2<<24)
+#define USBHS_PLL_SRC_PRE_DIV4 (3<<24)
+#define USBHS_PLL_SRC_PRE_DIV5 (4<<24)
+#define USBHS_PLL_SRC_PRE_DIV6 (5<<24)
+#define USBHS_PLL_SRC_PRE_DIV7 (6<<24)
+
+
+#define DEF_USB_FS_EP_SIZE      64
+#endif
+
+
+#define RCC_USBFS_CLK_DIV_1   (0<<22)
+#define RCC_USBFS_CLK_DIV_2   (1<<22)
+#define RCC_USBFS_CLK_DIV_3   (2<<22)
+#define RCC_USBFS_CLK_SRC     (1<<31)
+
+
+extern PUINT8  pEP0_RAM_Addr;                                                  //ep0(64)
+extern PUINT8  pEP2_RAM_Addr;                                                  //ep2_out(64)+ep2_in(64)
+
+extern volatile UINT8  USBFS_Endp1_Down_Flag;
+
+#define pSetupReqPakHD      ((PUSB_SETUP_REQ)pEP0_RAM_Addr)
+#define pEP0_DataBuf        (pEP0_RAM_Addr)
+#define pEP2_OUT_DataBuf    (pEP2_RAM_Addr)
+#define pEP2_IN_DataBuf     (pEP2_RAM_Addr+64)
+
+#define EP2_GetINSta()      (R8_UEP2_CTRL&UEP_T_RES_NAK)
+
+
+extern void DevEP2_OUT_Deal( UINT8 l );
+extern void DevEP2_IN_Deal( UINT8 l );
+extern void USBDeviceInit( void );
+extern void USBFS_Init( void );
+
+
+#endif

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/flash.c

@@ -0,0 +1,28 @@
+/********************************** (C) COPYRIGHT  *******************************
+ * File Name          : iap.c
+ * Author             : WCH
+ * Version            : V1.0.1
+ * Date               : 2025/01/23
+ * Description        : CH32V203  fast program
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#include "flash.h"
+#include "string.h"
+
+u32 Verify_buf[32];
+
+/*********************************************************************
+ * @fn      CH32_IAP_Program
+ *
+ * @brief   adr - the date address
+ *          buf - the date buffer
+ *
+ * @return  none
+ */
+void CH32_IAP_Program(u32 adr, u32* buf)
+{
+    FLASH_ProgramPage_Fast(adr, buf);
+}

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/flash.h

@@ -0,0 +1,20 @@
+/********************************** (C) COPYRIGHT  *******************************
+ * File Name          : falsh.h
+ * Author             : WCH
+ * Version            : V1.0.1
+ * Date               : 2025/01/23
+ * Description        :
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#ifndef __FLASH_H
+#define __FLASH_H
+
+#include "ch32v20x_it.h"
+#include "stdio.h"
+
+void CH32_IAP_Program(u32 adr, u32* buf);
+
+#endif

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/iap.c

@@ -0,0 +1,260 @@
+/********************************** (C) COPYRIGHT  *******************************
+ * File Name          : iap.c
+ * Author             : WCH
+ * Version            : V1.0.2
+ * Date               : 2025/10/27
+ * Description        : IAP
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#include "iap.h"
+#include "string.h"
+#include "flash.h"
+#include "core_riscv.h"
+#include "usb_istr.h"
+#include "usb_lib.h"
+/******************************************************************************/
+
+#define USBD_DATA_SIZE               64
+iapfun jump2app;
+vu32 Program_addr = FLASH_Base;
+vu32 Verify_addr = FLASH_Base;
+u32 User_APP_Addr_offset = 0x5000;
+vu8 Verify_Star_flag = 0;
+u8 Fast_Program_Buf[390];
+vu32 CodeLen = 0;
+vu8 End_Flag = 0;
+u8 EP2_Rx_Buffer[USBD_DATA_SIZE+4];
+#define  isp_cmd_t   ((isp_cmd  *)EP2_Rx_Buffer)
+
+/*********************************************************************
+ * @fn      RecData_Deal
+ *
+ * @brief   UART-USB deal data
+ *
+ * @return  ERR_ERROR - ERROR
+ *          ERR_SUCCESS - SUCCESS
+ *          ERR_End - End
+ */
+u8 RecData_Deal(void)
+{
+     u8 s;
+
+     switch ( isp_cmd_t->other.buf[0]) {
+     case CMD_IAP_ERASE:
+         s = ERR_ERROR;
+         break;
+
+     case CMD_IAP_PROM:
+         s = ERR_ERROR;
+         break;
+
+     case CMD_IAP_VERIFY:
+         s = ERR_ERROR;
+         break;
+
+     case CMD_IAP_END:
+         s = ERR_ERROR;
+         break;
+
+     case CMD_JUMP_IAP:
+         FLASH_Unlock_Fast();
+         FLASH_ProgramWord(CalAddr, 0x5aa55aa5);
+         FLASH->CTLR |= ((uint32_t)0x00008000);
+         FLASH->CTLR |= ((uint32_t)0x00000080);
+
+         s = ERR_SUCCESS;
+         break;
+
+     default:
+         s = ERR_ERROR;
+         break;
+     }
+     return s;
+ }
+
+/*********************************************************************
+ * @fn      EP2_RecData_Deal
+ *
+ * @brief   EP2 out date deal
+ *
+ * @return  none
+ */
+void EP2_IN_Tx_Deal(void)
+{
+    UserToPMABufferCopy(EP2_Tx_Buffer, ENDP2_TXADDR, EP2_Tx_Cnt);
+    SetEPTxCount(ENDP2, EP2_Tx_Cnt);
+    SetEPTxValid(ENDP2);
+}
+
+/*********************************************************************
+ * @fn      EP2_RecData_Deal
+ *
+ * @brief   EP2 out date deal
+ *
+ * @return  none
+ */
+void EP2_RecData_Deal(void)
+{
+    u8 s;
+
+    if(EP2_OUT_Flag){
+        EP2_OUT_Flag = 0;
+        EP2_Rx_Cnt = USB_SIL_Read(EP2_OUT, EP2_Rx_Buffer);
+
+        s = RecData_Deal();
+
+        if(s!=ERR_End){
+            EP2_Tx_Buffer[0] = 0x00;
+            if(s==ERR_ERROR) EP2_Tx_Buffer[1] = 0x01;    //err
+            else EP2_Tx_Buffer[1] = 0x00;
+            EP2_Tx_Cnt = 2;
+            EP2_IN_Tx_Deal();
+        }
+
+        SetEPRxStatus(ENDP2, EP_RX_VALID);
+    }
+
+}
+
+/*********************************************************************
+ * @fn      USART3_CFG
+ *
+ * @brief   baudrate:UART3 baudrate
+ *
+ * @return  none
+ */
+void USART3_CFG(u32 baudrate)
+{
+    GPIO_InitTypeDef GPIO_InitStructure = {0};
+    USART_InitTypeDef USART_InitStructure = {0};
+
+    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);
+    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
+    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
+    GPIO_Init(GPIOB, &GPIO_InitStructure);
+
+    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
+    GPIO_Init(GPIOB, &GPIO_InitStructure);
+
+    USART_InitStructure.USART_BaudRate = baudrate;
+    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
+    USART_InitStructure.USART_StopBits = USART_StopBits_1;
+    USART_InitStructure.USART_Parity = USART_Parity_No;
+    USART_InitStructure.USART_HardwareFlowControl =
+    USART_HardwareFlowControl_None;
+    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
+
+    USART_Init(USART3, &USART_InitStructure);
+    USART_Cmd(USART3, ENABLE);
+}
+
+/*********************************************************************
+ * @fn      UART3_SendData
+ *
+ * @brief   USART3 send date
+ *
+ * @param   pbuf - Packet to be sent
+ *          num - the number of date
+ *
+ * @return  none
+ */
+void UART3_SendData(u8 data)
+{
+    while(USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
+    USART_SendData(USART3, data);
+
+}
+
+/*********************************************************************
+ * @fn      Uart3_Rx
+ *
+ * @brief   Uart3 receive date
+ *
+ * @return  none
+ */
+u8 Uart3_Rx(void)
+{
+    while( USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == RESET);
+    return USART_ReceiveData( USART3);
+}
+
+/*********************************************************************
+ * @fn      UART_Rx_Deal
+ *
+ * @brief   UART Rx data deal
+ *
+ * @return  none
+ */
+void UART_Rx_Deal(void)
+{
+    u8 i, s;
+    u16 Data_add = 0;
+
+    if (Uart3_Rx() == Uart_Sync_Head1)
+    {
+        if (Uart3_Rx() == Uart_Sync_Head2)
+        {
+            isp_cmd_t->UART.Cmd = Uart3_Rx();
+            Data_add += isp_cmd_t->UART.Cmd;
+            isp_cmd_t->UART.Len = Uart3_Rx();
+            Data_add += isp_cmd_t->UART.Len;
+
+            if(isp_cmd_t->UART.Cmd == CMD_IAP_ERASE ||isp_cmd_t->UART.Cmd == CMD_IAP_VERIFY)
+            {
+                isp_cmd_t->other.buf[2] = Uart3_Rx();
+                Data_add += isp_cmd_t->other.buf[2];
+                isp_cmd_t->other.buf[3] = Uart3_Rx();
+                Data_add += isp_cmd_t->other.buf[3];
+                isp_cmd_t->other.buf[4] = Uart3_Rx();
+                Data_add += isp_cmd_t->other.buf[4];
+                isp_cmd_t->other.buf[5] = Uart3_Rx();
+                Data_add += isp_cmd_t->other.buf[5];
+            }
+            if ((isp_cmd_t->other.buf[0] == CMD_IAP_PROM) || (isp_cmd_t->other.buf[0] == CMD_IAP_VERIFY))
+            {
+                for (i = 0; i < isp_cmd_t->UART.Len; i++) {
+                    isp_cmd_t->UART.data[i] = Uart3_Rx();
+                    Data_add += isp_cmd_t->UART.data[i];
+                }
+            }
+            if (Uart3_Rx() == (uint8_t)(Data_add & 0xFF))
+            {
+                if(Uart3_Rx() == (uint8_t)(Data_add >>8))
+                {
+                    if (Uart3_Rx() == Uart_Sync_Head2)
+                    {
+                        if (Uart3_Rx() == Uart_Sync_Head1)
+                        {
+                            s = RecData_Deal();
+
+                            if (s != ERR_End)
+                            {
+                                UART3_SendData(Uart_Sync_Head1);
+                                UART3_SendData(Uart_Sync_Head2);
+                                UART3_SendData(0x00);
+                                if (s == ERR_ERROR)
+                                {
+                                    UART3_SendData(0x01);
+                                }
+                                else
+                                {
+                                    UART3_SendData(0x00);
+                                }
+                                UART3_SendData(Uart_Sync_Head2);
+                                UART3_SendData(Uart_Sync_Head1);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/iap.h

@@ -0,0 +1,85 @@
+/********************************** (C) COPYRIGHT  *******************************
+ * File Name          : iap.h
+ * Author             : WCH
+ * Version            : V1.0.1
+ * Date               : 2025/01/09
+ * Description        : IAP
+*********************************************************************************
+* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
+* Attention: This software (modified or not) and binary are used for 
+* microcontroller manufactured by Nanjing Qinheng Microelectronics.
+*******************************************************************************/
+#ifndef __IAP_H
+#define __IAP_H
+
+#include "ch32v20x.h"
+#include "stdio.h"
+#include "ch32v20x_usbfs_device.h"
+
+#define USBD_DATA_SIZE    64
+#define FLASH_Base        0x08005000
+
+#define Uart_Sync_Head1   0xaa
+#define Uart_Sync_Head2   0x55
+
+#define CMD_IAP_PROM      0x80
+#define CMD_IAP_ERASE     0x81
+#define CMD_IAP_VERIFY    0x82
+#define CMD_IAP_END       0x83
+#define CMD_JUMP_IAP      0x84
+
+#define ERR_SUCCESS       0x00
+#define ERR_ERROR         0x01
+#define ERR_End           0x02
+
+#define CalAddr           (0x08038000-4)
+#define CheckNum          (0x5aa55aa5)
+
+typedef union __attribute__ ((aligned(4)))_ISP_CMD {
+
+struct{
+
+    u8 Cmd;
+    u8 Len;
+    u8 data[64];
+}UART;
+
+struct{
+    u8 Cmd;
+    u8 Len;
+    u8 data[62];
+}program;
+
+struct{
+    u8 Cmd;
+    u8 Len;
+    u8 addr[4];
+    u8 data[56];
+}verify;
+
+struct{
+    u8 buf[64+4];
+}other;
+
+} isp_cmd;
+
+typedef void (*iapfun)(void);
+extern u32 Program_Verify_addr;
+extern u32 User_APP_Addr_offset;
+extern u8 EP2_IN_Flag;
+extern u8 EP2_OUT_Flag;
+extern u16 EP2_Rx_Cnt;
+extern u8 EP2_Tx_Buffer[2];
+extern u16 EP2_Tx_Cnt;
+extern u8 EP2_Rx_Buffer[USBD_DATA_SIZE+4];
+
+u8 RecData_Deal(void);
+void EP2_RecData_Deal(void);
+void EP2_IN_Tx_Deal(void);
+void USART3_CFG(u32 baudrate);
+
+void UART_Rx_Deal(void);
+
+#endif
+
+

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/main.c

@@ -1,8 +1,8 @@
 /********************************** (C) COPYRIGHT *******************************
  * File Name          : main.c
  * Author             : WCH
- * Version            : V1.0.0
- * Date               : 2021/06/06
+ * Version            : V1.0.2
+ * Date               : 2025/10/27
  * Description        : Main program body.
  *********************************************************************************
  * Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
@@ -11,18 +11,25 @@
  *******************************************************************************/
 
 /*
- *@Note
- *ADC uses DMA sampling routine:
- *ADC channel 1 (PA1), the rule group channel obtains ADC conversion data
- *for 1024 consecutive times through DMA.
- *
+ * APP routine: this routine support USB and UART mode,
+ * and you can choose the command method to jump to the IAP .
+ * Key  parameters: CalAddr - address in flash(same in IAP), note that this address needs to be unused.
+ *                  CheckNum - The value of 'CalAddr' that needs to be modified.
+ * Tips :the routine need IAP software version 1.50.
  */
 
 #include "debug.h"
+#include "ch32v20x_usbfs_device.h"
+#include "iap.h"
+#include "usb_istr.h"
+#include "usb_desc.h"
+#include "usb_lib.h"
+#include "hw_config.h"
+#include "usb_pwr.h"
 
 /* Global Variable */
 u16 TxBuf[1024];
-s16 Calibrattion_Val = 0;
+vs16 Calibrattion_Val = 0;
 
 /*********************************************************************
  * @fn      ADC_Function_Init
@@ -157,6 +164,43 @@ u16 Get_ConversionVal(s16 val)
     return (val + Calibrattion_Val);
 }
 
+/*********************************************************************
+ * @fn      APP_2_IAP
+ *
+ * @brief   APP_2_IAP program.
+ *
+ * @return  none
+ */
+void APP_2_IAP(void)
+{
+    NVIC_SystemReset();
+    while(1){
+    }
+}
+
+/*********************************************************************
+ * @fn      USART3_IT_CFG
+ *
+ * @brief   USART3 IT config program.
+ *
+ * @return  none
+ */
+void USART3_IT_CFG(void)
+{
+    NVIC_InitTypeDef  NVIC_InitStructure = {0};
+
+    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
+    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
+
+    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
+    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
+    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
+    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
+    NVIC_Init(&NVIC_InitStructure);
+
+    USART_Cmd(USART3, ENABLE);
+}
+
 /*********************************************************************
  * @fn      main
  *
@@ -186,17 +230,47 @@ int main(void)
     Delay_Ms(50);
     ADC_SoftwareStartConvCmd(ADC1, DISABLE);
 
-    for(i = 0; i < 1024; i++){
+    for(i = 0; i < 64; i++){
         printf("%04d\r\n", Get_ConversionVal(TxBuf[i]));
         Delay_Ms(10);
     }
 
-    while(1);
+    //USB-USART ENABLE
+    Set_USBConfig();
+    USB_Init();
+    USB_Port_Set(DISABLE, DISABLE);
+    Delay_Ms(700);
+    USB_Port_Set(ENABLE, ENABLE);
+    USB_Interrupts_Config();
+
+    USBFS_Init();
+    USART3_CFG(460800);
+    USART3_IT_CFG();
+
+    while(1)
+    {
+        EP2_RecData_Deal();
+        if(*(vu32 *)CalAddr == CheckNum)
+        {
+             Delay_Ms(10);
+             APP_2_IAP();
+             while(1);
+        }
+    }
 }
 
+void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
+/*********************************************************************
+ * @fn      USART3_IRQHandler
+ *
+ * @brief   This function handles USART3 global interrupt request.
+ *
+ * @return  none
+ */
+void USART3_IRQHandler(void)
+{
+    if( USART_GetFlagStatus(USART3, USART_FLAG_RXNE) != RESET){
 
-
-
-
-
-
+        UART_Rx_Deal();
+    }
+}

EVT/EXAM/IAP/USB_UART/CH32V20x_APP/User/system_ch32v20x.c

@@ -4,7 +4,7 @@
  * Version            : V1.0.0
  * Date               : 2021/06/06
  * Description        : CH32V20x Device Peripheral Access Layer System Source File.
- *                      For HSE = 32Mhz (CH32V208x/CH32V203RBT6)
+ *                      For HSE = 32Mhz (CH32V208x/CH32V203RBT)
  *                      For HSE = 8Mhz (other CH32V203x)
 *********************************************************************************
 * Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.