add rtc and watchdog driver for hc32f4a0 on XiZi_IIOT from Wu_zhen

it is OK

APP_Framework/Applications/app_test/test_rtc.c

@@ -11,16 +11,19 @@ void TestRTC(int argc,char *argv[])
     }
     
     if(argc>1){
-        
         int times = atoi(argv[1]);
         printf("Time will be printf %d times\n",times);
+
         struct RtcDrvConfigureParam rtc_para;
+        time_t my_time=0;
+
         rtc_para.rtc_operation_cmd = OPER_RTC_SET_TIME;
-        *(rtc_para.time) = 0;
+        rtc_para.time = &my_time;
 
         struct PrivIoctlCfg ioctl_cfg;
         ioctl_cfg.ioctl_driver_type = RTC_TYPE;
         ioctl_cfg.args =  (void *)&rtc_para;
+
         PrivIoctl(rtc_fd,0,&ioctl_cfg);
 
         rtc_para.rtc_operation_cmd = OPER_RTC_GET_TIME;

APP_Framework/Framework/knowing/kpu/Kconfig

@@ -1,6 +1,6 @@
 menuconfig USING_KPU_PROCESSING
     bool "kpu model processing"
-    default y
+    default n
 if USING_KPU_PROCESSING
         source "$APP_DIR/Framework/knowing/kpu/yolov2/Kconfig"
         source "$APP_DIR/Framework/knowing/kpu/yolov2_json/Kconfig"

APP_Framework/Framework/knowing/kpu/Makefile

@@ -1,3 +1,7 @@
-SRC_DIR := k210_yolov2_detect_procedure yolov2 yolov2_json
+SRC_DIR := 
+
+ifeq ($(CONFIG_USING_KPU_PROCESSING),y)
+	SRC_DIR += k210_yolov2_detect_procedure yolov2 yolov2_json
+endif
 
 include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_IIoT/arch/arm/cortex-m4/hc32f4a0/interrupt.c

@@ -20,6 +20,7 @@
 
 #include <xs_base.h>
 #include <xs_isr.h>
+#include <hc32f4xx.h>
 
 x_base __attribute__((naked)) DisableLocalInterrupt()
 {
@@ -36,6 +37,9 @@ void __attribute__((naked)) EnableLocalInterrupt(x_base level)
 
 int32 ArchEnableHwIrq(uint32 irq_num)
 {
+    NVIC_ClearPendingIRQ(irq_num);
+    NVIC_SetPriority(irq_num, 0);
+    NVIC_EnableIRQ(irq_num);
     return EOK;
 }
 

Ubiquitous/XiZi_IIoT/arch/arm/cortex-m4/hc32f4a0/interrupt_vector.S

@@ -61,22 +61,22 @@ InterruptVectors:
                 .long       SysTick_Handler                    /*  -1 SysTick Handler */
 
                 /* Interrupts */
-                .long       IRQ000_Handler
+                .long       IsrEntry
-                .long       IRQ001_Handler
+                .long       IsrEntry
-                .long       IRQ002_Handler
+                .long       IsrEntry
-                .long       IRQ003_Handler
+                .long       IsrEntry
-                .long       IRQ004_Handler
+                .long       IsrEntry
-                .long       IRQ005_Handler
+                .long       IsrEntry
-                .long       IRQ006_Handler
+                .long       IsrEntry
-                .long       IRQ007_Handler
+                .long       IsrEntry
-                .long       IRQ008_Handler
+                .long       IsrEntry
-                .long       IRQ009_Handler
+                .long       IsrEntry
-                .long       IRQ010_Handler
+                .long       IsrEntry
-                .long       IRQ011_Handler
+                .long       IsrEntry
-                .long       IRQ012_Handler
+                .long       IsrEntry
-                .long       IRQ013_Handler
+                .long       IsrEntry
-                .long       IRQ014_Handler
+                .long       IsrEntry
-                .long       IRQ015_Handler
+                .long       IsrEntry
                 .long       IRQ016_Handler
                 .long       IRQ017_Handler
                 .long       IRQ018_Handler

Ubiquitous/XiZi_IIoT/board/hc32f4a0/board.c

@@ -54,8 +54,17 @@ Modification:
 #include <connect_usb.h>
 #endif
 
+#ifdef BSP_USING_RTC
+#include <connect_rtc.h>
+#endif
+
+#ifdef BSP_USING_WDT
+#include <connect_wdt.h>
+#endif
+
 extern void entry(void);
 extern int HwUsartInit();
+extern int HwWdtInit();
 
 /* Peripheral register WE/WP selection */
 #define LL_PERIPH_SEL                   (LL_PERIPH_GPIO | LL_PERIPH_FCG | LL_PERIPH_PWC_CLK_RMU | \
@@ -167,6 +176,12 @@ struct InitSequenceDesc _board_init[] =
 #endif
 #ifdef BSP_USING_USB
 	{ "usb", HwUsbHostInit },
+#endif
+#ifdef BSP_USING_RTC
+	{ "rtc", HwRtcInit },
+#endif
+#ifdef BSP_USING_WDT
+	{ "wdt", HwWdtInit },
 #endif
     { " NONE ", NONE },
 };

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/Kconfig

@@ -53,3 +53,19 @@ menuconfig BSP_USING_USB
     if BSP_USING_USB
         source "$BSP_DIR/third_party_driver/usb/Kconfig"
     endif
+
+menuconfig BSP_USING_RTC
+    bool "Using RTC device"
+    default n
+    select RESOURCES_RTC
+    if BSP_USING_RTC
+        source "$BSP_DIR/third_party_driver/rtc/Kconfig"
+    endif
+
+menuconfig BSP_USING_WDT
+    bool "Using WDT device"
+    default n
+    select RESOURCES_WDT
+    if BSP_USING_WDT
+        source "$BSP_DIR/third_party_driver/watchdog/Kconfig"
+    endif

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/Makefile

@@ -28,4 +28,12 @@ ifeq ($(CONFIG_BSP_USING_USB),y)
   SRC_DIR += usb
 endif
 
+ifeq ($(CONFIG_BSP_USING_RTC),y)
+  SRC_DIR += rtc
+endif
+
+ifeq ($(CONFIG_BSP_USING_WDT),y)
+  SRC_DIR += watchdog
+endif
+
 include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/common/hc32_ll_driver/src/Makefile

@@ -24,4 +24,12 @@ ifeq ($(CONFIG_BSP_USING_USB),y)
   SRC_FILES += hc32_ll_usb.c
 endif
 
+ifeq ($(CONFIG_BSP_USING_RTC),y)
+  SRC_FILES += hc32_ll_rtc.c
+endif
+
+ifeq ($(CONFIG_BSP_USING_WDT),y)
+  SRC_FILES += hc32_ll_wdt.c
+endif
+
 include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/gpio/connect_gpio.c

@@ -33,9 +33,9 @@ Modification:
 
 #include <connect_gpio.h>
 
-#define GPIO_PIN_INDEX(pin)             ((uint8_t)((pin) & 0x0F))
-
 #define ITEM_NUM(items)                 sizeof(items) / sizeof(items[0])
+#define IRQ_INT(callback)
+#define INTSEL_REG              (uint32_t)(&CM_INTC->SEL0)                       
 
 #ifndef HC32_PIN_CONFIG
 #define HC32_PIN_CONFIG(pin, callback, config)                                 \
@@ -48,6 +48,8 @@ Modification:
 
 #define __HC32_PIN(index, gpio_port, gpio_pin) { 0, GPIO_PORT_##gpio_port, GPIO_PIN_##gpio_pin}
 #define __HC32_PIN_DEFAULT                     {-1, 0, 0}
+#define MAX_PIN_INDEX 15
+#define INT_VECTOR_OFFSET 16
 
 struct PinIndex
 {
@@ -294,6 +296,17 @@ struct PinIrqHdr pin_irq_hdr_tab[] =
     {-1, 0, NONE, NONE}
 };
 
+static int GpioPinIndex(uint16_t pin){
+    int ret = 0;
+    for(;ret<=MAX_PIN_INDEX;ret++){ //ret must be 16-bit 
+        if((0x0001U<<ret)&pin){
+            KPrintf("the int pin is %d\n",ret);
+            return ret;
+        }
+    };
+    return -1;
+}
+
 static void PinIrqHandler(uint16_t pinbit)
 {
     int32_t irqindex = -1;
@@ -418,6 +431,7 @@ static int32 GpioConfigMode(int mode, const struct PinIndex* index)
         break;
     case GPIO_CFG_INPUT:
         stcGpioInit.u16PinDir   = PIN_DIR_IN;
+        stcGpioInit.u16ExtInt = PIN_EXTINT_ON;
         break;
     case GPIO_CFG_INPUT_PULLUP:
         stcGpioInit.u16PinDir   = PIN_DIR_IN;
@@ -434,8 +448,7 @@ static int32 GpioConfigMode(int mode, const struct PinIndex* index)
     default:
         break;
     }
-
+    GPIO_Init(index->port, index->pin, &stcGpioInit);
-    GPIO_Init(index->pin, index->pin, &stcGpioInit);
 }
 
 static int32 GpioIrqRegister(int32 pin, int32 mode, void (*hdr)(void *args), void *args)
@@ -443,7 +456,9 @@ static int32 GpioIrqRegister(int32 pin, int32 mode, void (*hdr)(void *args), voi
     const struct PinIndex *index = GetPin(pin);
     int32 irqindex = -1;
 
-    irqindex = GPIO_PIN_INDEX(index->pin);
+    stc_extint_init_t stcExtIntInit;
+
+    irqindex = GpioPinIndex(index->pin); // start from 0
     if (irqindex >= ITEM_NUM(pin_irq_map)) {
         return -ENONESYS;
     }
@@ -465,8 +480,31 @@ static int32 GpioIrqRegister(int32 pin, int32 mode, void (*hdr)(void *args), voi
     pin_irq_hdr_tab[irqindex].hdr = hdr;
     pin_irq_hdr_tab[irqindex].mode = mode;
     pin_irq_hdr_tab[irqindex].args = args;
-    CriticalAreaUnLock(level);
 
+    /* Extint config */
+    EXTINT_StructInit(&stcExtIntInit);
+    switch (mode)
+    {
+    case GPIO_IRQ_EDGE_RISING:
+        stcExtIntInit.u32Edge = EXTINT_TRIG_RISING;
+        break;
+    case GPIO_IRQ_EDGE_FALLING:
+        stcExtIntInit.u32Edge = EXTINT_TRIG_FALLING;
+        break;
+    case GPIO_IRQ_EDGE_BOTH:
+        stcExtIntInit.u32Edge = EXTINT_TRIG_BOTH;
+        break;
+    case GPIO_IRQ_LEVEL_LOW:
+        stcExtIntInit.u32Edge = EXTINT_TRIG_LOW;
+        break;
+    }
+    EXTINT_Init(index->pin, &stcExtIntInit);   
+
+    __IO uint32_t *INTC_SELx = (__IO uint32_t *)(INTSEL_REG + (4U * (uint32_t)(irqindex)));
+    WRITE_REG32(*INTC_SELx, irqindex);
+    isrManager.done->registerIrq(irqindex+INT_VECTOR_OFFSET, (void(*)(int vector,void *))hdr, args);
+
+    CriticalAreaUnLock(level);
     return EOK;
 }
 
@@ -475,7 +513,7 @@ static uint32 GpioIrqFree(x_base pin)
     const struct PinIndex* index = GetPin(pin);
     int32 irqindex = -1;
 
-    irqindex = GPIO_PIN_INDEX(index->pin);
+    irqindex = GpioPinIndex(index->pin);
     if (irqindex >= ITEM_NUM(pin_irq_map)) {
         return -ENONESYS;
     }
@@ -485,6 +523,7 @@ static uint32 GpioIrqFree(x_base pin)
         CriticalAreaUnLock(level);
         return EOK;
     }
+    isrManager.done->freeIrq(pin_irq_hdr_tab[irqindex].pin);
     pin_irq_hdr_tab[irqindex].pin  = -1;
     pin_irq_hdr_tab[irqindex].hdr  = NONE;
     pin_irq_hdr_tab[irqindex].mode = 0;
@@ -509,9 +548,8 @@ static int32 GpioIrqEnable(x_base pin)
     struct Hc32PinIrqMap *irq_map;
     const struct PinIndex* index = GetPin(pin);
     int32 irqindex = -1;
-    stc_extint_init_t stcExtIntInit;
 
-    irqindex = GPIO_PIN_INDEX(index->pin);
+    irqindex = GpioPinIndex(index->pin);
     if (irqindex >= ITEM_NUM(pin_irq_map)) {
         return -ENONESYS;
     }
@@ -522,28 +560,11 @@ static int32 GpioIrqEnable(x_base pin)
         return -ENONESYS;
     }
 
-    /* Extint config */
+    GpioIrqConfig(index->port, index->pin, PIN_EXTINT_ON);
-    EXTINT_StructInit(&stcExtIntInit);
+    isrManager.done->enableIrq(GpioPinIndex(index->pin));
-    switch (pin_irq_hdr_tab[irqindex].mode)
-    {
-    case GPIO_IRQ_EDGE_RISING:
-        stcExtIntInit.u32Edge = EXTINT_TRIG_RISING;
-        break;
-    case GPIO_IRQ_EDGE_FALLING:
-        stcExtIntInit.u32Edge = EXTINT_TRIG_FALLING;
-        break;
-    case GPIO_IRQ_EDGE_BOTH:
-        stcExtIntInit.u32Edge = EXTINT_TRIG_BOTH;
-        break;
-    case GPIO_IRQ_LEVEL_LOW:
-        stcExtIntInit.u32Edge = EXTINT_TRIG_LOW;
-        break;
-    }
-    EXTINT_Init(index->pin, &stcExtIntInit);
-    NVIC_EnableIRQ(irq_map->irq_config.irq_num);
-    GpioIrqConfig(index->pin, index->pin, PIN_EXTINT_ON);
 
     CriticalAreaUnLock(level);
+    KPrintf("port%d,pin%04x has enable\n",index->port, index->pin);
     return EOK;
 }
 
@@ -554,8 +575,8 @@ static int32 GpioIrqDisable(x_base pin)
 
     x_base level = CriticalAreaLock();
 
-    GpioIrqConfig(index->pin, index->pin, PIN_EXTINT_OFF);
+    GpioIrqConfig(index->port, index->pin, PIN_EXTINT_OFF);
-    NVIC_DisableIRQ(irq_map->irq_config.irq_num);
+    isrManager.done->disableIrq(GpioPinIndex(index->pin));
 
     CriticalAreaUnLock(level);
     return EOK;
@@ -637,9 +658,9 @@ uint32 Hc32PinWrite(void *dev, struct BusBlockWriteParam *write_param)
     NULL_PARAM_CHECK(index);
 
     if (GPIO_LOW == pinstat->val) {
-        GPIO_ResetPins(index->pin, index->pin);
+        GPIO_ResetPins(index->port, index->pin);
     } else {
-        GPIO_SetPins(index->pin, index->pin);
+        GPIO_SetPins(index->port, index->pin);
     }
 
     return EOK;
@@ -653,7 +674,7 @@ uint32 Hc32PinRead(void *dev, struct BusBlockReadParam *read_param)
     const struct PinIndex* index = GetPin(pinstat->pin);
     NULL_PARAM_CHECK(index);
     
-    if(GPIO_ReadInputPins(index->pin, index->pin) == PIN_RESET) {
+    if(GPIO_ReadInputPins(index->port, index->pin) == PIN_RESET) {
         pinstat->val = GPIO_LOW;
     } else {
         pinstat->val = GPIO_HIGH;

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/include/connect_rtc.h

@@ -0,0 +1,37 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+ 
+/**
+* @file connect_rtc.h
+* @brief define hc32f4a0-board rtc function and struct
+* @version 3.0
+* @author AIIT XUOS Lab
+* @date 2023-02-02
+*/
+
+#ifndef CONNECT_I2C_H
+#define CONNECT_I2C_H
+
+#include <device.h>
+#include <hc32_ll_rtc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int HwRtcInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/include/connect_wdt.h

@@ -0,0 +1,37 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+ 
+/**
+* @file connect_wdt.h
+* @brief define hc32f4a0-board watchdog function and struct
+* @version 3.0
+* @author AIIT XUOS Lab
+* @date 2023-02-02
+*/
+
+#ifndef CONNECT_I2C_H
+#define CONNECT_I2C_H
+
+#include <device.h>
+#include <hc32_ll_wdt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int HwWdtInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/rtc/Kconfig

@@ -0,0 +1,11 @@
+if BSP_USING_RTC
+    config RTC_BUS_NAME
+        string "rtc bus name"
+        default "rtc"
+    config RTC_DRV_NAME
+        string "rtc bus driver name"
+        default "rtc_drv"
+    config RTC_DEVICE_NAME
+            string "rtc bus device name"
+            default "rtc_dev"     
+endif

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/rtc/Makefile

@@ -0,0 +1,2 @@
+SRC_FILES := connect_rtc.c
+include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/rtc/connect_rtc.c

@@ -0,0 +1,185 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file connect_rtc.c
+* @brief support aiit-hc32f4a0-board rtc function and register to bus framework
+* @version 1.0 
+* @author AIIT XUOS Lab
+* @date 2023-02-02
+*/
+
+#include <connect_rtc.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <time.h>
+
+static uint32 RtcConfigure(void *drv, struct BusConfigureInfo *configure_info)
+{
+    NULL_PARAM_CHECK(drv);
+
+    struct RtcDriver *rtc_drv = (struct RtcDriver *)drv;
+    struct RtcDrvConfigureParam *drv_param = (struct RtcDrvConfigureParam *)configure_info->private_data;
+
+    int cmd = drv_param->rtc_operation_cmd;
+    time_t *time = drv_param->time;
+
+    switch (cmd)
+    {
+        case OPER_RTC_GET_TIME:
+        {
+            struct tm ct;
+            stc_rtc_date_t rtc_date;
+            stc_rtc_time_t rtc_time;
+
+            // rtc_timer_get(&year, &month, &day, &hour, &minute, &second);
+            RTC_GetDate(RTC_DATA_FMT_DEC, &rtc_date);
+            RTC_GetTime(RTC_DATA_FMT_DEC, &rtc_time);
+
+            ct.tm_year = rtc_date.u8Year ;
+            ct.tm_mon = rtc_date.u8Month ;
+            ct.tm_mday = rtc_date.u8Day;
+            ct.tm_wday = rtc_date.u8Weekday;
+
+            ct.tm_hour = rtc_time.u8Hour;
+            ct.tm_min = rtc_time.u8Minute;
+            ct.tm_sec = rtc_time.u8Second;
+
+            *time = mktime(&ct);
+        }
+        break;
+        case OPER_RTC_SET_TIME:
+        {
+            struct tm *ct;
+            stc_rtc_date_t rtc_date;
+            stc_rtc_time_t rtc_time;
+            x_base lock;
+
+            lock = CriticalAreaLock();
+            ct = localtime(time);
+            rtc_date.u8Year = ct->tm_year ;
+            rtc_date.u8Month = ct->tm_mon ;
+            rtc_date.u8Day = ct->tm_mday;
+            rtc_date.u8Weekday = ct->tm_wday;
+            rtc_time.u8Hour = ct->tm_hour;
+            rtc_time.u8Minute = ct->tm_min;
+            rtc_time.u8Second = ct->tm_sec;
+            CriticalAreaUnLock(lock);
+
+            RTC_SetDate(RTC_DATA_FMT_DEC, &rtc_date);
+            RTC_SetTime(RTC_DATA_FMT_DEC, &rtc_time);
+        }
+        break;
+    }
+    return EOK;
+}
+
+/*manage the rtc device operations*/
+static const struct RtcDevDone dev_done =
+{
+    .open = NONE,
+    .close = NONE,
+    .write = NONE,
+    .read = NONE,
+};
+
+static int BoardRtcBusInit(struct RtcBus *rtc_bus, struct RtcDriver *rtc_driver)
+{
+    x_err_t ret = EOK;
+
+    /*Init the rtc bus */
+    ret = RtcBusInit(rtc_bus, RTC_BUS_NAME);
+    if (EOK != ret) {
+        KPrintf("HwRtcInit RtcBusInit error %d\n", ret);
+        return ERROR;
+    }
+
+    /*Init the rtc driver*/
+    ret = RtcDriverInit(rtc_driver, RTC_DRV_NAME);
+    if (EOK != ret) {
+        KPrintf("HwRtcInit RtcDriverInit error %d\n", ret);
+        return ERROR;
+    }
+
+    /*Attach the rtc driver to the rtc bus*/
+    ret = RtcDriverAttachToBus(RTC_DRV_NAME, RTC_BUS_NAME);
+    if (EOK != ret) {
+        KPrintf("HwRtcInit RtcDriverAttachToBus error %d\n", ret);
+        return ERROR;
+    } 
+
+    return ret;
+}
+
+/*Attach the rtc device to the rtc bus*/
+static int BoardRtcDevBend(void)
+{
+    x_err_t ret = EOK;
+
+    static struct RtcHardwareDevice rtc_device;
+    memset(&rtc_device, 0, sizeof(struct RtcHardwareDevice));
+
+    rtc_device.dev_done = &(dev_done);
+
+    ret = RtcDeviceRegister(&rtc_device, NONE, RTC_DEVICE_NAME);
+    if (EOK != ret) {
+        KPrintf("HwRtcInit RtcDeviceInit device %s error %d\n", RTC_DEVICE_NAME, ret);
+        return ERROR;
+    }  
+
+    ret = RtcDeviceAttachToBus(RTC_DEVICE_NAME, RTC_BUS_NAME);
+    if (EOK != ret) {
+        KPrintf("HwRtcInit RtcDeviceAttachToBus device %s error %d\n", RTC_DEVICE_NAME, ret);
+        return ERROR;
+    }  
+
+    return  ret;
+}
+
+
+int HwRtcInit(void)
+{
+    x_err_t ret = EOK;
+
+    static struct RtcBus rtc_bus;
+    memset(&rtc_bus, 0, sizeof(struct RtcBus));
+
+    static struct RtcDriver rtc_driver;
+    memset(&rtc_driver, 0, sizeof(struct RtcDriver));
+    
+    rtc_driver.configure = &(RtcConfigure);
+
+    ret = BoardRtcBusInit(&rtc_bus, &rtc_driver);
+    if (EOK != ret) {
+        KPrintf("HwRtcInit error ret %u\n", ret);
+        return ERROR;
+    }
+
+    ret = BoardRtcDevBend();
+    if (EOK != ret) {
+        KPrintf("HwRtcInit error ret %u\n", ret);
+    }
+    
+    stc_rtc_init_t stcRtcInit;
+    /* Configure structure initialization */
+    (void)RTC_StructInit(&stcRtcInit);
+
+    /* Configuration RTC structure */
+    stcRtcInit.u8ClockSrc  = RTC_CLK_SRC_XTAL32;
+    stcRtcInit.u8HourFormat= RTC_HOUR_FMT_24H;
+    stcRtcInit.u8IntPeriod = RTC_INT_PERIOD_PER_SEC;
+    (void)RTC_Init(&stcRtcInit);
+
+    RTC_Cmd(LL_RTC_ENABLE);
+
+    return ret;
+}

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/watchdog/Kconfig

@@ -0,0 +1,15 @@
+if BSP_USING_WDT
+    config WDT_BUS_NAME_0
+        string "watchdog bus 0 name"
+        default "wdt0"
+
+    config WDT_DRIVER_NAME_0
+        string "watchdog driver 0 name"
+        default "wdt0_drv"
+
+    config WDT_0_DEVICE_NAME_0
+        string "watchdog device 0 name"
+        default "wdt0_dev0"
+endif
+
+

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/watchdog/Makefile

@@ -0,0 +1,3 @@
+SRC_FILES := connect_wdt.c
+
+include $(KERNEL_ROOT)/compiler.mk

Ubiquitous/XiZi_IIoT/board/hc32f4a0/third_party_driver/watchdog/connect_wdt.c

@@ -0,0 +1,145 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file connect_wdt.c
+* @brief support hc32f4a0-board watchdog function and register to bus framework
+* @version 1.0 
+* @author AIIT XUOS Lab
+* @date 2023-02-02
+*/
+
+#include <connect_wdt.h>
+
+#define WDT_COUNT_CYCLE 65536U
+
+static uint32 WdtOpen(void *dev)
+{
+    NULL_PARAM_CHECK(dev);
+
+    stc_wdt_init_t stcWdtInit;
+    stcWdtInit.u32CountPeriod   = WDT_CNT_PERIOD65536;
+    stcWdtInit.u32ClockDiv      = WDT_CLK_DIV1024;
+    stcWdtInit.u32RefreshRange  = WDT_RANGE_0TO25PCT;
+    stcWdtInit.u32LPMCount      = WDT_LPM_CNT_STOP;
+    stcWdtInit.u32ExceptionType = WDT_EXP_TYPE_RST;
+    (void)WDT_Init(&stcWdtInit);
+    return EOK;
+}
+
+static uint32 WdtConfigure(void *drv, struct BusConfigureInfo *args)
+{
+    NULL_PARAM_CHECK(drv);
+    NULL_PARAM_CHECK(args);
+
+    stc_wdt_init_t stcWdtInit;
+
+    int period_option = *((int*)args->private_data);
+    if(period_option<=256){
+        period_option = WDT_CNT_PERIOD256;
+    }else if(period_option<=4096){
+        period_option = WDT_CNT_PERIOD4096;
+    }else if(period_option<=16384){
+        period_option = WDT_CNT_PERIOD16384;
+    }else{
+        period_option = WDT_CNT_PERIOD65536;
+    }
+
+    switch (args->configure_cmd)
+    {
+        case OPER_WDT_SET_TIMEOUT:
+        stcWdtInit.u32CountPeriod    = period_option;
+        stcWdtInit.u32ClockDiv       = WDT_CLK_DIV1024;
+        stcWdtInit.u32RefreshRange   = WDT_RANGE_0TO25PCT;
+        stcWdtInit.u32LPMCount       = WDT_LPM_CNT_STOP;
+        stcWdtInit.u32ExceptionType  = WDT_EXP_TYPE_RST;
+        if (WDT_Init(&stcWdtInit) != 0) {
+            return ERROR;
+        }
+        /* the chip SDK's feature:to start up watchdog counter, feed dog first after initialization*/
+        WDT_FeedDog();
+        break;
+        case OPER_WDT_KEEPALIVE:
+            /* must wait for count lower than 25%(division by 4) for a feed as RefreshRange is set as 0TO25PCT*/
+            if (WDT_GetCountValue() < WDT_COUNT_CYCLE/4){  
+                WDT_FeedDog();
+            }
+            break;
+        default:
+            return ERROR;
+    }
+    return EOK;
+}
+
+static const struct WdtDevDone dev_done =
+{
+    WdtOpen,
+    NONE,
+    NONE,
+    NONE,
+};
+
+/**
+ * @description: Watchdog function
+ * @return success: EOK, failure: other
+ */
+int StartWatchdog(void)
+{
+    //add feed watchdog task function
+
+    return EOK;
+}
+
+int HwWdtInit(void)
+{
+    x_err_t ret = EOK;
+
+    static struct WdtBus wdt0;
+
+    ret = WdtBusInit(&wdt0, WDT_BUS_NAME_0);
+    if (ret != EOK) {
+        KPrintf("Watchdog bus init error %d\n", ret);
+        return ERROR;
+    }
+
+    static struct WdtDriver drv0;
+    drv0.configure = WdtConfigure;
+    
+    ret = WdtDriverInit(&drv0, WDT_DRIVER_NAME_0);
+    if (ret != EOK) {
+        KPrintf("Watchdog driver init error %d\n", ret);
+        return ERROR;
+    }
+
+    ret = WdtDriverAttachToBus(WDT_DRIVER_NAME_0, WDT_BUS_NAME_0);
+    if (ret != EOK) {
+        KPrintf("Watchdog driver attach error %d\n", ret);
+        return ERROR;
+    }
+
+    static struct WdtHardwareDevice dev0;
+    dev0.dev_done = &dev_done;
+
+    ret = WdtDeviceRegister(&dev0, WDT_0_DEVICE_NAME_0);
+    if (ret != EOK) {
+        KPrintf("Watchdog device register error %d\n", ret);
+        return ERROR;
+    }
+
+    ret = WdtDeviceAttachToBus(WDT_0_DEVICE_NAME_0, WDT_BUS_NAME_0);
+    if (ret != EOK) {
+        KPrintf("Watchdog device register error %d\n", ret);
+        return ERROR;
+    }
+
+    return ret;
+}