[add] 添加 RTC、WDT 驱动

5 files changed, 482 insertions, 141 deletions

diff --git a/bsp/ra6m4-cpk/drivers/Kconfig b/bsp/ra6m4-cpk/drivers/Kconfig
index 17e127473d..a5ead99ad5 100644
--- a/bsp/ra6m4-cpk/drivers/Kconfig
+++ b/bsp/ra6m4-cpk/drivers/Kconfig
@@ -73,6 +73,28 @@ menu "Hardware Drivers Config"
                     endif
             endif
 
+        config BSP_USING_WDT
+            bool "Enable Watchdog Timer"
+            select RT_USING_WDT
+            default n
+
+        menuconfig BSP_USING_ONCHIP_RTC
+            bool "Enable RTC"
+            select RT_USING_RTC
+            default n
+            if BSP_USING_ONCHIP_RTC
+                choice
+                    prompt "Select clock source"
+                    default BSP_RTC_USING_LSE
+
+                    config BSP_RTC_USING_LSE
+                        bool "RTC USING LSE"
+
+                    config BSP_RTC_USING_LSI
+                        bool "RTC USING LSI"
+                endchoice
+            endif
+
     endmenu
 
     menu "Board extended module Drivers"
diff --git a/bsp/ra6m4-cpk/drivers/SConscript b/bsp/ra6m4-cpk/drivers/SConscript
index 1548e88ee0..2cbe93510a 100644
--- a/bsp/ra6m4-cpk/drivers/SConscript
+++ b/bsp/ra6m4-cpk/drivers/SConscript
@@ -22,6 +22,9 @@ if GetDepend(['RT_USING_PIN']):
 if GetDepend(['RT_USING_WDT']):
     src += ['drv_wdt.c']
 
+if GetDepend(['BSP_USING_ONCHIP_RTC']):
+    src += ['drv_rtc.c']
+
 if GetDepend(['RT_USING_I2C', 'RT_USING_I2C_BITOPS']):
     if GetDepend('BSP_USING_I2C0') or GetDepend('BSP_USING_I2C1'):
         src += ['drv_soft_i2c.c']
diff --git a/bsp/ra6m4-cpk/drivers/drv_gpio.c b/bsp/ra6m4-cpk/drivers/drv_gpio.c
index aa4a769ff1..fa2a2f2151 100644
--- a/bsp/ra6m4-cpk/drivers/drv_gpio.c
+++ b/bsp/ra6m4-cpk/drivers/drv_gpio.c
@@ -14,94 +14,94 @@
 
 #define DBG_TAG              "drv.gpio"
 #ifdef DRV_DEBUG
-#define DBG_LVL               DBG_LOG
+    #define DBG_LVL               DBG_LOG
 #else
-#define DBG_LVL               DBG_INFO
+    #define DBG_LVL               DBG_INFO
 #endif /* DRV_DEBUG */
 
 #ifdef R_ICU_H
 static rt_base_t ra_pin_get_irqx(rt_uint32_t pin)
 {
-    switch(pin)
+    switch (pin)
     {
-        case BSP_IO_PORT_04_PIN_00:
-        case BSP_IO_PORT_02_PIN_06:
-        case BSP_IO_PORT_01_PIN_05:
-            return 0;
+    case BSP_IO_PORT_04_PIN_00:
+    case BSP_IO_PORT_02_PIN_06:
+    case BSP_IO_PORT_01_PIN_05:
+        return 0;
 
-        case BSP_IO_PORT_02_PIN_05:
-        case BSP_IO_PORT_01_PIN_01:
-        case BSP_IO_PORT_01_PIN_04:
-            return 1;
+    case BSP_IO_PORT_02_PIN_05:
+    case BSP_IO_PORT_01_PIN_01:
+    case BSP_IO_PORT_01_PIN_04:
+        return 1;
 
-        case BSP_IO_PORT_02_PIN_03:
-        case BSP_IO_PORT_01_PIN_00:
-        case BSP_IO_PORT_02_PIN_13:
-            return 2;
+    case BSP_IO_PORT_02_PIN_03:
+    case BSP_IO_PORT_01_PIN_00:
+    case BSP_IO_PORT_02_PIN_13:
+        return 2;
 
-        case BSP_IO_PORT_02_PIN_02:
-        case BSP_IO_PORT_01_PIN_10:
-        case BSP_IO_PORT_02_PIN_12:
-            return 3;
+    case BSP_IO_PORT_02_PIN_02:
+    case BSP_IO_PORT_01_PIN_10:
+    case BSP_IO_PORT_02_PIN_12:
+        return 3;
 
-        case BSP_IO_PORT_04_PIN_02:
-        case BSP_IO_PORT_01_PIN_11:
-        case BSP_IO_PORT_04_PIN_11:
-            return 4;
+    case BSP_IO_PORT_04_PIN_02:
+    case BSP_IO_PORT_01_PIN_11:
+    case BSP_IO_PORT_04_PIN_11:
+        return 4;
 
-        case BSP_IO_PORT_04_PIN_01:
-        case BSP_IO_PORT_03_PIN_02:
-        case BSP_IO_PORT_04_PIN_10:
-            return 5;
+    case BSP_IO_PORT_04_PIN_01:
+    case BSP_IO_PORT_03_PIN_02:
+    case BSP_IO_PORT_04_PIN_10:
+        return 5;
 
-        case BSP_IO_PORT_03_PIN_01:
-        case BSP_IO_PORT_00_PIN_00:
-        case BSP_IO_PORT_04_PIN_09:
-            return 6;
+    case BSP_IO_PORT_03_PIN_01:
+    case BSP_IO_PORT_00_PIN_00:
+    case BSP_IO_PORT_04_PIN_09:
+        return 6;
 
-        case BSP_IO_PORT_00_PIN_01:
-        case BSP_IO_PORT_04_PIN_08:
-            return 7;
+    case BSP_IO_PORT_00_PIN_01:
+    case BSP_IO_PORT_04_PIN_08:
+        return 7;
 
-        case BSP_IO_PORT_00_PIN_02:
-        case BSP_IO_PORT_03_PIN_05:
-        case BSP_IO_PORT_04_PIN_15:
-            return 8;
+    case BSP_IO_PORT_00_PIN_02:
+    case BSP_IO_PORT_03_PIN_05:
+    case BSP_IO_PORT_04_PIN_15:
+        return 8;
 
-        case BSP_IO_PORT_00_PIN_04:
-        case BSP_IO_PORT_03_PIN_04:
-        case BSP_IO_PORT_04_PIN_14:
-            return 9;
+    case BSP_IO_PORT_00_PIN_04:
+    case BSP_IO_PORT_03_PIN_04:
+    case BSP_IO_PORT_04_PIN_14:
+        return 9;
 
-        case BSP_IO_PORT_00_PIN_05:
-        case BSP_IO_PORT_07_PIN_09:
-            return 10;
+    case BSP_IO_PORT_00_PIN_05:
+    case BSP_IO_PORT_07_PIN_09:
+        return 10;
 
-        case BSP_IO_PORT_05_PIN_01:
-        case BSP_IO_PORT_00_PIN_06:
-        case BSP_IO_PORT_07_PIN_08:
-            return 11;
+    case BSP_IO_PORT_05_PIN_01:
+    case BSP_IO_PORT_00_PIN_06:
+    case BSP_IO_PORT_07_PIN_08:
+        return 11;
 
-        case BSP_IO_PORT_05_PIN_02:
-        case BSP_IO_PORT_00_PIN_08:
-            return 12;
+    case BSP_IO_PORT_05_PIN_02:
+    case BSP_IO_PORT_00_PIN_08:
+        return 12;
 
-        case BSP_IO_PORT_00_PIN_15:
-        case BSP_IO_PORT_00_PIN_09:
-            return 13;
+    case BSP_IO_PORT_00_PIN_15:
+    case BSP_IO_PORT_00_PIN_09:
+        return 13;
 
-        case BSP_IO_PORT_04_PIN_03:
-        case BSP_IO_PORT_05_PIN_12:
-        case BSP_IO_PORT_05_PIN_05:
-            return 14;
+    case BSP_IO_PORT_04_PIN_03:
+    case BSP_IO_PORT_05_PIN_12:
+    case BSP_IO_PORT_05_PIN_05:
+        return 14;
 
-        case BSP_IO_PORT_04_PIN_04:
-        case BSP_IO_PORT_05_PIN_11:
-        case BSP_IO_PORT_05_PIN_06:
-            return 15;
+    case BSP_IO_PORT_04_PIN_04:
+    case BSP_IO_PORT_05_PIN_11:
+    case BSP_IO_PORT_05_PIN_06:
+        return 15;
 
-        default  :
-            return -1;
+    default  :
+        return -1;
     }
 }
 
@@ -209,34 +209,34 @@ static void ra_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode)
         return;
     }
 
-    switch(mode)
+    switch (mode)
     {
-        case PIN_MODE_OUTPUT:
-            err = R_IOPORT_PinCfg(&g_ioport_ctrl, pin, BSP_IO_DIRECTION_OUTPUT);
-            if (err != FSP_SUCCESS)
-            {
-                LOG_E("PIN_MODE_OUTPUT configuration failed");
-                return;
-            }
-            break;
+    case PIN_MODE_OUTPUT:
+        err = R_IOPORT_PinCfg(&g_ioport_ctrl, pin, BSP_IO_DIRECTION_OUTPUT);
+        if (err != FSP_SUCCESS)
+        {
+            LOG_E("PIN_MODE_OUTPUT configuration failed");
+            return;
+        }
+        break;
 
-        case PIN_MODE_INPUT:
-            err = R_IOPORT_PinCfg(&g_ioport_ctrl, pin, BSP_IO_DIRECTION_INPUT);
-            if (err != FSP_SUCCESS)
-            {
-                LOG_E("PIN_MODE_INPUT configuration failed");
-                return;
-            }
-            break;
+    case PIN_MODE_INPUT:
+        err = R_IOPORT_PinCfg(&g_ioport_ctrl, pin, BSP_IO_DIRECTION_INPUT);
+        if (err != FSP_SUCCESS)
+        {
+            LOG_E("PIN_MODE_INPUT configuration failed");
+            return;
+        }
+        break;
 
-        case PIN_MODE_OUTPUT_OD:
-            err = R_IOPORT_PinCfg(&g_ioport_ctrl, pin, IOPORT_CFG_NMOS_ENABLE);
-            if (err != FSP_SUCCESS)
-            {
-                LOG_E("PIN_MODE_OUTPUT_OD configuration failed");
-                return;
-            }
-            break;
+    case PIN_MODE_OUTPUT_OD:
+        err = R_IOPORT_PinCfg(&g_ioport_ctrl, pin, IOPORT_CFG_NMOS_ENABLE);
+        if (err != FSP_SUCCESS)
+        {
+            LOG_E("PIN_MODE_OUTPUT_OD configuration failed");
+            return;
+        }
+        break;
     }
 }
 
@@ -269,12 +269,12 @@ static rt_err_t ra_pin_irq_enable(struct rt_device *device, rt_base_t pin, rt_ui
 #ifdef R_ICU_H
     rt_err_t err;
     rt_int32_t irqx = ra_pin_get_irqx(pin);
-    if(PIN_IRQ_ENABLE == enabled)
+    if (PIN_IRQ_ENABLE == enabled)
     {
-        if(0 <= irqx && irqx < sizeof(pin_irq_map) / sizeof(pin_irq_map[0]))
+        if (0 <= irqx && irqx < sizeof(pin_irq_map) / sizeof(pin_irq_map[0]))
         {
-            err = R_ICU_ExternalIrqOpen((external_irq_ctrl_t * const)pin_irq_map[irqx].irq_ctrl, 
-                        (external_irq_cfg_t const * const)pin_irq_map[irqx].irq_cfg);
+            err = R_ICU_ExternalIrqOpen((external_irq_ctrl_t *const)pin_irq_map[irqx].irq_ctrl,
+                                        (external_irq_cfg_t const * const)pin_irq_map[irqx].irq_cfg);
             /* Handle error */
             if (FSP_SUCCESS != err)
             {
@@ -282,8 +282,8 @@ static rt_err_t ra_pin_irq_enable(struct rt_device *device, rt_base_t pin, rt_ui
                 LOG_E("\r\n**R_ICU_ExternalIrqOpen API FAILED**\r\n");
                 return -RT_ERROR;
             }
-            
-            err = R_ICU_ExternalIrqEnable((external_irq_ctrl_t * const)pin_irq_map[irqx].irq_ctrl);
+
+            err = R_ICU_ExternalIrqEnable((external_irq_ctrl_t *const)pin_irq_map[irqx].irq_ctrl);
             /* Handle error */
             if (FSP_SUCCESS != err)
             {
@@ -293,16 +293,16 @@ static rt_err_t ra_pin_irq_enable(struct rt_device *device, rt_base_t pin, rt_ui
             }
         }
     }
-    else if(PIN_IRQ_DISABLE == enabled)
+    else if (PIN_IRQ_DISABLE == enabled)
     {
-        err = R_ICU_ExternalIrqDisable((external_irq_ctrl_t * const)pin_irq_map[irqx].irq_ctrl);
+        err = R_ICU_ExternalIrqDisable((external_irq_ctrl_t *const)pin_irq_map[irqx].irq_ctrl);
         if (FSP_SUCCESS != err)
         {
             /* ICU Disable failure message */
             LOG_E("\r\n**R_ICU_ExternalIrqDisable API FAILED**\r\n");
             return -RT_ERROR;
         }
-        err = R_ICU_ExternalIrqClose((external_irq_ctrl_t * const)pin_irq_map[irqx].irq_ctrl);
+        err = R_ICU_ExternalIrqClose((external_irq_ctrl_t *const)pin_irq_map[irqx].irq_ctrl);
         if (FSP_SUCCESS != err)
         {
             /* ICU Close failure message */
@@ -317,31 +317,31 @@ static rt_err_t ra_pin_irq_enable(struct rt_device *device, rt_base_t pin, rt_ui
 }
 
 static rt_err_t ra_pin_attach_irq(struct rt_device *device, rt_int32_t pin,
-                                     rt_uint32_t mode, void (*hdr)(void *args), void *args)
+                                  rt_uint32_t mode, void (*hdr)(void *args), void *args)
 {
 #ifdef R_ICU_H
     rt_int32_t irqx = ra_pin_get_irqx(pin);
-    if(0 <= irqx && irqx < (sizeof(pin_irq_map) / sizeof(pin_irq_map[0])))
-    {
-    int level = rt_hw_interrupt_disable();
-    if (pin_irq_hdr_tab[irqx].pin == irqx &&
-        pin_irq_hdr_tab[irqx].hdr == hdr &&
-        pin_irq_hdr_tab[irqx].mode == mode &&
-        pin_irq_hdr_tab[irqx].args == args)
-    {
-        rt_hw_interrupt_enable(level);
-        return RT_EOK;
-    }
-    if(pin_irq_hdr_tab[irqx].pin != -1)
+    if (0 <= irqx && irqx < (sizeof(pin_irq_map) / sizeof(pin_irq_map[0])))
     {
+        int level = rt_hw_interrupt_disable();
+        if (pin_irq_hdr_tab[irqx].pin == irqx &&
+                pin_irq_hdr_tab[irqx].hdr == hdr &&
+                pin_irq_hdr_tab[irqx].mode == mode &&
+                pin_irq_hdr_tab[irqx].args == args)
+        {
+            rt_hw_interrupt_enable(level);
+            return RT_EOK;
+        }
+        if (pin_irq_hdr_tab[irqx].pin != -1)
+        {
+            rt_hw_interrupt_enable(level);
+            return RT_EBUSY;
+        }
+        pin_irq_hdr_tab[irqx].pin = irqx;
+        pin_irq_hdr_tab[irqx].hdr = hdr;
+        pin_irq_hdr_tab[irqx].mode = mode;
+        pin_irq_hdr_tab[irqx].args = args;
         rt_hw_interrupt_enable(level);
-        return RT_EBUSY;
-    }
-    pin_irq_hdr_tab[irqx].pin = irqx;
-    pin_irq_hdr_tab[irqx].hdr = hdr;
-    pin_irq_hdr_tab[irqx].mode = mode;
-    pin_irq_hdr_tab[irqx].args = args;
-    rt_hw_interrupt_enable(level);
     }
     else return -RT_ERROR;
     return RT_EOK;
@@ -354,7 +354,7 @@ static rt_err_t ra_pin_dettach_irq(struct rt_device *device, rt_int32_t pin)
 {
 #ifdef R_ICU_H
     rt_int32_t irqx = ra_pin_get_irqx(pin);
-    if(0 <= irqx && irqx < sizeof(pin_irq_map) / sizeof(pin_irq_map[0]))
+    if (0 <= irqx && irqx < sizeof(pin_irq_map) / sizeof(pin_irq_map[0]))
     {
         int level = rt_hw_interrupt_disable();
         if (pin_irq_hdr_tab[irqx].pin == -1)
@@ -381,16 +381,16 @@ static rt_err_t ra_pin_dettach_irq(struct rt_device *device, rt_int32_t pin)
 static rt_base_t ra_pin_get(const char *name)
 {
     int pin_number = -1, port = -1, pin = -1;
-    if(rt_strlen(name) != 4)
+    if (rt_strlen(name) != 4)
         return -1;
-    if(name[0] == 'P')
+    if (name[0] == 'P')
     {
-        if('0' <= (int)name[1] && (int)name[1] <= '9')
+        if ('0' <= (int)name[1] && (int)name[1] <= '9')
         {
             port = ((int)name[1] - 48) * 16 * 16;
-            if('0' <= (int)name[2] && (int)name[2] <= '9')
+            if ('0' <= (int)name[2] && (int)name[2] <= '9')
             {
-                if('0' <= (int)name[3] && (int)name[3] <= '9')
+                if ('0' <= (int)name[3] && (int)name[3] <= '9')
                 {
                     pin = ((int)name[2] - 48) * 10;
                     pin += (int)name[3] - 48;
@@ -428,7 +428,7 @@ int rt_hw_pin_init(void)
 void irq0_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(0 == pin_irq_hdr_tab[0].pin)
+    if (0 == pin_irq_hdr_tab[0].pin)
     {
         pin_irq_hdr_tab[0].hdr(pin_irq_hdr_tab[0].args);
     }
@@ -438,7 +438,7 @@ void irq0_callback(external_irq_callback_args_t *p_args)
 void irq1_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(1 == pin_irq_hdr_tab[1].pin)
+    if (1 == pin_irq_hdr_tab[1].pin)
     {
         pin_irq_hdr_tab[1].hdr(pin_irq_hdr_tab[1].args);
     }
@@ -448,7 +448,7 @@ void irq1_callback(external_irq_callback_args_t *p_args)
 void irq2_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(2 == pin_irq_hdr_tab[2].pin)
+    if (2 == pin_irq_hdr_tab[2].pin)
     {
         pin_irq_hdr_tab[2].hdr(pin_irq_hdr_tab[2].args);
     }
@@ -458,7 +458,7 @@ void irq2_callback(external_irq_callback_args_t *p_args)
 void irq3_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(3 == pin_irq_hdr_tab[3].pin)
+    if (3 == pin_irq_hdr_tab[3].pin)
     {
         pin_irq_hdr_tab[3].hdr(pin_irq_hdr_tab[3].args);
     }
@@ -468,7 +468,7 @@ void irq3_callback(external_irq_callback_args_t *p_args)
 void irq4_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(4 == pin_irq_hdr_tab[4].pin)
+    if (4 == pin_irq_hdr_tab[4].pin)
     {
         pin_irq_hdr_tab[4].hdr(pin_irq_hdr_tab[4].args);
     }
@@ -478,7 +478,7 @@ void irq4_callback(external_irq_callback_args_t *p_args)
 void irq5_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(5 == pin_irq_hdr_tab[5].pin)
+    if (5 == pin_irq_hdr_tab[5].pin)
     {
         pin_irq_hdr_tab[5].hdr(pin_irq_hdr_tab[5].args);
     }
@@ -488,7 +488,7 @@ void irq5_callback(external_irq_callback_args_t *p_args)
 void irq6_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(6 == pin_irq_hdr_tab[6].pin)
+    if (6 == pin_irq_hdr_tab[6].pin)
     {
         pin_irq_hdr_tab[6].hdr(pin_irq_hdr_tab[6].args);
     }
@@ -498,7 +498,7 @@ void irq6_callback(external_irq_callback_args_t *p_args)
 void irq7_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(7 == pin_irq_hdr_tab[7].pin)
+    if (7 == pin_irq_hdr_tab[7].pin)
     {
         pin_irq_hdr_tab[7].hdr(pin_irq_hdr_tab[7].args);
     }
@@ -508,7 +508,7 @@ void irq7_callback(external_irq_callback_args_t *p_args)
 void irq8_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(8 == pin_irq_hdr_tab[8].pin)
+    if (8 == pin_irq_hdr_tab[8].pin)
     {
         pin_irq_hdr_tab[8].hdr(pin_irq_hdr_tab[8].args);
     }
@@ -518,7 +518,7 @@ void irq8_callback(external_irq_callback_args_t *p_args)
 void irq9_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(9 == pin_irq_hdr_tab[9].pin)
+    if (9 == pin_irq_hdr_tab[9].pin)
     {
         pin_irq_hdr_tab[9].hdr(pin_irq_hdr_tab[9].args);
     }
@@ -528,7 +528,7 @@ void irq9_callback(external_irq_callback_args_t *p_args)
 void irq10_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(10 == pin_irq_hdr_tab[10].pin)
+    if (10 == pin_irq_hdr_tab[10].pin)
     {
         pin_irq_hdr_tab[10].hdr(pin_irq_hdr_tab[10].args);
     }
@@ -538,7 +538,7 @@ void irq10_callback(external_irq_callback_args_t *p_args)
 void irq11_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(11 == pin_irq_hdr_tab[11].pin)
+    if (11 == pin_irq_hdr_tab[11].pin)
     {
         pin_irq_hdr_tab[11].hdr(pin_irq_hdr_tab[11].args);
     }
@@ -548,7 +548,7 @@ void irq11_callback(external_irq_callback_args_t *p_args)
 void irq12_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(12 == pin_irq_hdr_tab[12].pin)
+    if (12 == pin_irq_hdr_tab[12].pin)
     {
         pin_irq_hdr_tab[12].hdr(pin_irq_hdr_tab[12].args);
     }
@@ -558,7 +558,7 @@ void irq12_callback(external_irq_callback_args_t *p_args)
 void irq13_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(13 == pin_irq_hdr_tab[13].pin)
+    if (13 == pin_irq_hdr_tab[13].pin)
     {
         pin_irq_hdr_tab[13].hdr(pin_irq_hdr_tab[13].args);
     }
@@ -568,7 +568,7 @@ void irq13_callback(external_irq_callback_args_t *p_args)
 void irq14_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(14 == pin_irq_hdr_tab[14].pin)
+    if (14 == pin_irq_hdr_tab[14].pin)
     {
         pin_irq_hdr_tab[14].hdr(pin_irq_hdr_tab[14].args);
     }
@@ -578,7 +578,7 @@ void irq14_callback(external_irq_callback_args_t *p_args)
 void irq15_callback(external_irq_callback_args_t *p_args)
 {
     rt_interrupt_enter();
-    if(15 == pin_irq_hdr_tab[15].pin)
+    if (15 == pin_irq_hdr_tab[15].pin)
     {
         pin_irq_hdr_tab[15].hdr(pin_irq_hdr_tab[15].args);
     }
diff --git a/bsp/ra6m4-cpk/drivers/drv_rtc.c b/bsp/ra6m4-cpk/drivers/drv_rtc.c
new file mode 100644
index 0000000000..342d598587
--- /dev/null
+++ b/bsp/ra6m4-cpk/drivers/drv_rtc.c
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-08-14     Mr.Tiger     first version
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "board.h"
+#include <sys/time.h>
+#include "hal_data.h"
+
+#ifdef BSP_USING_ONCHIP_RTC
+
+#define DBG_TAG              "drv.rtc"
+#ifdef DRV_DEBUG
+    #define DBG_LVL               DBG_LOG
+#else
+    #define DBG_LVL               DBG_INFO
+#endif /* DRV_DEBUG */
+#include <rtdbg.h>
+
+static rt_err_t ra_rtc_init(void)
+{
+    rt_err_t result = RT_EOK;
+
+    if (R_RTC_Open(&g_rtc_ctrl, &g_rtc_cfg) != RT_EOK)
+    {
+        LOG_E("rtc init failed.");
+        result = -RT_ERROR;
+    }
+
+    return result;
+}
+
+static time_t get_rtc_timestamp(void)
+{
+    struct tm tm_new = {0};
+    rtc_time_t g_current_time = {0};
+
+    R_RTC_CalendarTimeGet(&g_rtc_ctrl, &g_current_time);
+
+    tm_new.tm_year  = g_current_time.tm_year;
+    tm_new.tm_mon   = g_current_time.tm_mon;
+    tm_new.tm_mday  = g_current_time.tm_mday;
+
+    tm_new.tm_hour  = g_current_time.tm_hour;
+    tm_new.tm_min   = g_current_time.tm_min;
+    tm_new.tm_sec   = g_current_time.tm_sec;
+
+    tm_new.tm_wday  = g_current_time.tm_wday;
+    tm_new.tm_yday  = g_current_time.tm_yday;
+    tm_new.tm_isdst = g_current_time.tm_isdst;
+
+    return timegm(&tm_new);
+}
+
+static rt_err_t ra_get_secs(void *args)
+{
+    *(rt_uint32_t *)args = get_rtc_timestamp();
+    LOG_D("RTC: get rtc_time %x\n", *(rt_uint32_t *)args);
+
+    return RT_EOK;
+}
+
+static rt_err_t set_rtc_time_stamp(time_t time_stamp)
+{
+    struct tm *p_tm;
+    rtc_time_t g_current_time = {0};
+    p_tm = gmtime(&time_stamp);
+    if (p_tm->tm_year < 100)
+    {
+        return -RT_ERROR;
+    }
+
+    g_current_time.tm_sec    = p_tm->tm_sec ;
+    g_current_time.tm_min    = p_tm->tm_min ;
+    g_current_time.tm_hour   = p_tm->tm_hour;
+
+    g_current_time.tm_mday   = p_tm->tm_mday;
+    g_current_time.tm_mon    = p_tm->tm_mon;
+    g_current_time.tm_year   = p_tm->tm_year;
+
+    g_current_time.tm_wday   = p_tm->tm_wday;
+    g_current_time.tm_yday   = p_tm->tm_yday;
+
+    if (R_RTC_CalendarTimeSet(&g_rtc_ctrl, &g_current_time) != FSP_SUCCESS)
+    {
+        LOG_E("set rtc time failed.");
+        return -RT_ERROR;
+    }
+
+    return RT_EOK;
+}
+
+static rt_err_t ra_set_secs(void *args)
+{
+
+    rt_err_t result = RT_EOK;
+
+    if (set_rtc_time_stamp(*(rt_uint32_t *)args))
+    {
+        result = -RT_ERROR;
+    }
+    LOG_D("RTC: set rtc_time %x\n", *(rt_uint32_t *)args);
+
+    return result;
+}
+
+static rt_err_t ra_get_alarm(void *arg)
+{
+    rt_err_t result = RT_EOK;
+    struct rt_rtc_wkalarm *wkalarm = (struct rt_rtc_wkalarm *)arg;
+    rtc_alarm_time_t alarm_time_get =
+    {
+        .sec_match        =  RT_FALSE,
+        .min_match        =  RT_FALSE,
+        .hour_match       =  RT_FALSE,
+        .mday_match       =  RT_FALSE,
+        .mon_match        =  RT_FALSE,
+        .year_match       =  RT_FALSE,
+        .dayofweek_match  =  RT_FALSE,
+    };
+
+    if (RT_EOK == R_RTC_CalendarAlarmGet(&g_rtc_ctrl, &alarm_time_get))
+    {
+        wkalarm->tm_hour = alarm_time_get.time.tm_hour;
+        wkalarm->tm_min  = alarm_time_get.time.tm_min;
+        wkalarm->tm_sec  = alarm_time_get.time.tm_sec;
+    }
+    else
+    {
+        LOG_E("Calendar alarm Get failed.");
+    }
+
+    return result;
+}
+
+static rt_err_t ra_set_alarm(void *arg)
+{
+    rt_err_t result = RT_EOK;
+    struct rt_rtc_wkalarm *wkalarm = (struct rt_rtc_wkalarm *)arg;
+    rtc_alarm_time_t alarm_time_set =
+    {
+        .sec_match        =  RT_TRUE,
+        .min_match        =  RT_TRUE,
+        .hour_match       =  RT_TRUE,
+        .mday_match       =  RT_FALSE,
+        .mon_match        =  RT_FALSE,
+        .year_match       =  RT_FALSE,
+        .dayofweek_match  =  RT_FALSE,
+    };
+
+    alarm_time_set.time.tm_hour = wkalarm->tm_hour;
+    alarm_time_set.time.tm_min  = wkalarm->tm_min;
+    alarm_time_set.time.tm_sec  = wkalarm->tm_sec;
+    if (1 == wkalarm->enable)
+    {
+        if (RT_EOK != R_RTC_CalendarAlarmSet(&g_rtc_ctrl, &alarm_time_set))
+        {
+            LOG_E("Calendar alarm Set failed.");
+            result = -RT_ERROR;
+        }
+    }
+    else
+    {
+        alarm_time_set.sec_match        =  RT_FALSE;
+        alarm_time_set.min_match        =  RT_FALSE;
+        alarm_time_set.hour_match       =  RT_FALSE;
+        if (RT_EOK != R_RTC_CalendarAlarmSet(&g_rtc_ctrl, &alarm_time_set))
+        {
+            LOG_E("Calendar alarm Stop failed.");
+            result = -RT_ERROR;
+        }
+    }
+    return result;
+}
+
+static rt_device_t ra_device;
+
+void rtc_callback(rtc_callback_args_t *p_args)
+{
+    if (RTC_EVENT_ALARM_IRQ == p_args->event)
+    {
+        rt_alarm_update(ra_device, 1);
+    }
+}
+
+static const struct rt_rtc_ops ra_rtc_ops =
+{
+    .init      = ra_rtc_init,
+    .get_secs  = ra_get_secs,
+    .set_secs  = ra_set_secs,
+    .set_alarm = ra_set_alarm,
+    .get_alarm = ra_get_alarm,
+};
+
+static rt_rtc_dev_t ra_rtc_dev;
+
+static int rt_hw_rtc_init(void)
+{
+    rt_err_t result;
+
+    ra_rtc_dev.ops = &ra_rtc_ops;
+
+    result = rt_hw_rtc_register(&ra_rtc_dev, "rtc", RT_DEVICE_FLAG_RDWR, RT_NULL);
+    if (result != RT_EOK)
+    {
+        LOG_E("rtc register err code: %d", result);
+        return result;
+    }
+    LOG_D("rtc init success");
+
+    return RT_EOK;
+}
+INIT_DEVICE_EXPORT(rt_hw_rtc_init);
+#endif
\ No newline at end of file
diff --git a/bsp/ra6m4-cpk/drivers/drv_wdt.c b/bsp/ra6m4-cpk/drivers/drv_wdt.c
new file mode 100644
index 0000000000..280c1444bf
--- /dev/null
+++ b/bsp/ra6m4-cpk/drivers/drv_wdt.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-08-20     Mr.Tiger     first version
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <rthw.h>
+#include <drv_common.h>
+#include <drv_config.h>
+#include <hal_data.h>
+
+#ifdef RT_USING_WDT
+
+//#define DRV_DEBUG
+#define LOG_TAG             "drv.wdt"
+#include <rtdbg.h>
+
+static struct rt_watchdog_device ra_wdt_dev;
+static struct rt_watchdog_ops ops;
+
+static rt_err_t wdt_init(rt_watchdog_t *wdt)
+{
+    return RT_EOK;
+}
+
+static rt_err_t wdt_control(rt_watchdog_t *wdt, int cmd, void *arg)
+{
+    struct st_wdt_timeout_values *wdt_value = {0};
+    switch (cmd)
+    {
+        /* feed the watchdog */
+    case RT_DEVICE_CTRL_WDT_KEEPALIVE:
+        if(R_WDT_Refresh(&g_wdt_ctrl) != FSP_SUCCESS)
+        {
+            LOG_E("watch dog keepalive fail.");
+        }
+        break;
+        /* set watchdog timeout */
+    case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
+        /**< set*/
+//        g_wdt_cfg.timeout = *(rt_uint32_t *)arg;
+        break;
+    case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
+        wdt_value = (struct st_wdt_timeout_values *)arg;
+        if(R_WDT_TimeoutGet(&g_wdt_ctrl,wdt_value) != FSP_SUCCESS)
+        {
+            LOG_E("wdt get timeout failed.");
+            return -RT_ERROR;
+        }
+        break;
+    case RT_DEVICE_CTRL_WDT_START:
+        if(R_WDT_Open(&g_wdt_ctrl, &g_wdt_cfg) == FSP_SUCCESS)
+        {
+            if(R_WDT_Refresh(&g_wdt_ctrl) != FSP_SUCCESS)
+            {
+                LOG_E("wdt start failed.");
+                return -RT_ERROR;
+            }
+        }
+        else
+        {
+            LOG_E("wdt start failed.");
+            return -RT_ERROR;
+        }
+        break;
+    default:
+        LOG_W("This command is not supported.");
+        return -RT_ERROR;
+    }
+    return RT_EOK;
+}
+
+int rt_wdt_init(void)
+{
+    ops.init = &wdt_init;
+    ops.control = &wdt_control;
+    ra_wdt_dev.ops = &ops;
+    /* register watchdog device */
+    if (rt_hw_watchdog_register(&ra_wdt_dev, "wdt", RT_DEVICE_FLAG_DEACTIVATE, RT_NULL) != RT_EOK)
+    {
+        LOG_E("wdt device register failed.");
+        return -RT_ERROR;
+    }
+    LOG_D("wdt device register success.");
+    return RT_EOK;
+}
+INIT_BOARD_EXPORT(rt_wdt_init);
+
+#endif /* RT_USING_WDT */