add rtc wdt timer for xidatong-riscv64 board

2022-10-18 10:01:39 +08:00
parent 9c15e587c4
commit f2e633348a
21 changed files with 2675 additions and 0 deletions
@@ -0,0 +1,34 @@
+menuconfig BSP_USING_WDT0
+bool "Using watchdog 0 "
+default n
+if BSP_USING_WDT0
+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
+
+menuconfig BSP_USING_WDT1
+bool "Using watchdog 1 "
+default n
+if BSP_USING_WDT1
+config WDT_BUS_NAME_1
+    string "watchdog bus 1 name"
+    default "wdt1"
+
+config WDT_DRIVER_NAME_1
+    string "watchdog driver 1 name"
+    default "wdt1_drv"
+
+config WDT_1_DEVICE_NAME_1
+    string "watchdog device 1 name"
+    default "wdt1_dev1"
+endif
+
@@ -0,0 +1,6 @@
+SRC_FILES := wdt.c connect_wdt.c
+
+
+
+
+include $(KERNEL_ROOT)/compiler.mk
@@ -0,0 +1,176 @@
+/*
+* 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 aiit-riscv64-board watchdog function and register to bus framework
+* @version 1.0 
+* @author AIIT XUOS Lab
+* @date 2021-04-25
+*/
+
+#include <connect_wdt.h>
+#include <wdt.h>
+
+static uint32 WdtOpen(void *dev)
+{
+    NULL_PARAM_CHECK(dev);
+    
+    wdt_device_number_t id;
+    struct WdtHardwareDevice *wdt = (struct WdtHardwareDevice *)dev;
+    id = *(wdt_device_number_t *)wdt->private_data;
+
+    wdt_init(id, 4095, NONE, NONE);
+    return EOK;
+}
+
+static uint32 WdtConfigure(void *drv, struct BusConfigureInfo *args)
+{
+    NULL_PARAM_CHECK(drv);
+    NULL_PARAM_CHECK(args);
+
+    struct WdtDriver *wdt = (struct WdtDriver *)drv;
+    wdt_device_number_t id = *(wdt_device_number_t *)wdt->private_data;
+
+    switch (args->configure_cmd)
+    {
+        case OPER_WDT_SET_TIMEOUT:
+            if (wdt_init(id, (uint64_t)*(int *)args->private_data, NONE, NONE) == 0) {
+                return ERROR;
+            }
+            break;
+        case OPER_WDT_KEEPALIVE:
+            wdt_feed(id);
+            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)
+{
+    wdt_device_number_t id;
+
+    x_err_t ret = EOK;
+
+#ifdef BSP_USING_WDT0
+    {
+        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;
+        id = WDT_DEVICE_0;
+        drv0.private_data = &id;
+        
+        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;
+        dev0.private_data = &id;
+
+        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;
+        }
+    }
+#endif
+
+#ifdef BSP_USING_WDT1
+    {
+        static struct WdtBus wdt1;
+
+        ret = WdtBusInit(&wdt1, WDT_BUS_NAME_1);
+        if (ret != EOK) {
+            KPrintf("Watchdog bus init error %d\n", ret);
+            return ERROR;
+        }
+
+        static struct WdtDriver drv1;
+        drv1.configure = WdtConfigure;
+        id = WDT_DEVICE_1;
+        drv1.private_data = &id;
+        
+        ret = WdtDriverInit(&drv1, WDT_DRIVER_NAME_1);
+        if (ret != EOK) {
+            KPrintf("Watchdog driver init error %d\n", ret);
+            return ERROR;
+        }
+
+        ret = WdtDriverAttachToBus(WDT_DRIVER_NAME_1, WDT_BUS_NAME_1);
+        if (ret != EOK) {
+            KPrintf("Watchdog driver attach error %d\n", ret);
+            return ERROR;
+        }
+
+        static struct WdtHardwareDevice dev1;
+        dev1.dev_done = &dev_done;
+        dev1.private_data = &id;
+
+        ret = WdtDeviceRegister(&dev1, WDT_1_DEVICE_NAME_1);
+        if (ret != EOK) {
+            KPrintf("Watchdog device register error %d\n", ret);
+            return ERROR;
+        }
+
+        ret = WdtDeviceAttachToBus(WDT_1_DEVICE_NAME_1, WDT_BUS_NAME_1);
+        if (ret != EOK) {
+            KPrintf("Watchdog device register error %d\n", ret);
+            return ERROR;
+        }
+    }
+#endif
+
+    return ret;
+}
@@ -0,0 +1,125 @@
+/* Copyright 2018 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+* @file wdt.c
+* @brief add from Canaan k210 SDK
+*                https://canaan-creative.com/developer
+* @version 1.0 
+* @author AIIT XUOS Lab
+* @date 2021-04-25
+*/
+
+#include <math.h>
+#include <platform.h>
+#include <plic.h>
+#include <stddef.h>
+#include <sysctl.h>
+#include <utils.h>
+#include <wdt.h>
+
+volatile wdt_t *const wdt[2] =
+{
+    (volatile wdt_t *)WDT0_BASE_ADDR,
+    (volatile wdt_t *)WDT1_BASE_ADDR
+};
+
+static void wdt_enable(wdt_device_number_t id)
+{
+    wdt[id]->crr = WDT_CRR_MASK;
+    wdt[id]->cr |= WDT_CR_ENABLE;
+}
+
+static void wdt_disable(wdt_device_number_t id)
+{
+    wdt[id]->crr = WDT_CRR_MASK;
+    wdt[id]->cr &= (~WDT_CR_ENABLE);
+}
+
+static void wdt_set_timeout(wdt_device_number_t id, uint8_t timeout)
+{
+    wdt[id]->torr = WDT_TORR_TOP(timeout);
+}
+
+static void wdt_response_mode(wdt_device_number_t id, uint8_t mode)
+{
+    wdt[id]->cr &= (~WDT_CR_RMOD_MASK);
+    wdt[id]->cr |= mode;
+}
+
+static uint64_t wdt_get_pclk(wdt_device_number_t id)
+{
+    return id ? SysctlClockGetFreq(SYSCTL_CLOCK_WDT1) : SysctlClockGetFreq(SYSCTL_CLOCK_WDT0);
+}
+
+static uint8_t wdt_get_top(wdt_device_number_t id, uint64_t timeout_ms)
+{
+    uint64_t wdt_clk = wdt_get_pclk(id);
+    uint64_t ret = (timeout_ms * wdt_clk / 1000) >> 16;
+    if (ret)
+        ret = (uint32_t)log2(ret);
+    if (ret > 0xf)
+        ret = 0xf;
+    return (uint8_t)ret;
+}
+
+void wdt_feed(wdt_device_number_t id)
+{
+    wdt[id]->crr = WDT_CRR_MASK;
+}
+
+void wdt_clear_interrupt(wdt_device_number_t id)
+{
+    wdt[id]->eoi = wdt[id]->eoi;
+}
+
+void wdt_start(wdt_device_number_t id, uint64_t time_out_ms, plic_irq_callback_t on_irq)
+{
+    sysctl_reset(id ? SYSCTL_RESET_WDT1 : SYSCTL_RESET_WDT0);
+    sysctl_clock_set_threshold(id ? SYSCTL_THRESHOLD_WDT1 : SYSCTL_THRESHOLD_WDT0, 0);
+    sysctl_clock_enable(id ? SYSCTL_CLOCK_WDT1 : SYSCTL_CLOCK_WDT0);
+
+    plic_set_priority(id ? IRQN_WDT1_INTERRUPT : IRQN_WDT0_INTERRUPT, 1);
+    plic_irq_enable(id ? IRQN_WDT1_INTERRUPT : IRQN_WDT0_INTERRUPT);
+    plic_irq_register(id ? IRQN_WDT1_INTERRUPT : IRQN_WDT0_INTERRUPT, on_irq, NULL);
+
+    wdt_response_mode(id, WDT_CR_RMOD_INTERRUPT);
+    uint8_t m_top = wdt_get_top(id, time_out_ms);
+    wdt_set_timeout(id, m_top);
+    wdt_enable(id);
+}
+
+uint32_t wdt_init(wdt_device_number_t id, uint64_t time_out_ms, plic_irq_callback_t on_irq, void *ctx)
+{
+    sysctl_reset(id ? SYSCTL_RESET_WDT1 : SYSCTL_RESET_WDT0);
+    sysctl_clock_set_threshold(id ? SYSCTL_THRESHOLD_WDT1 : SYSCTL_THRESHOLD_WDT0, 0);
+    sysctl_clock_enable(id ? SYSCTL_CLOCK_WDT1 : SYSCTL_CLOCK_WDT0);
+
+    plic_set_priority(id ? IRQN_WDT1_INTERRUPT : IRQN_WDT0_INTERRUPT, 1);
+    plic_irq_enable(id ? IRQN_WDT1_INTERRUPT : IRQN_WDT0_INTERRUPT);
+    plic_irq_register(id ? IRQN_WDT1_INTERRUPT : IRQN_WDT0_INTERRUPT, on_irq, ctx);
+
+    wdt_response_mode(id, WDT_CR_RMOD_INTERRUPT);
+    uint8_t m_top = wdt_get_top(id, time_out_ms);
+    wdt_set_timeout(id, m_top);
+    wdt_enable(id);
+    return (1UL << (m_top + 16 + 1)) * 1000UL / wdt_get_pclk(id);
+}
+
+void wdt_stop(wdt_device_number_t id)
+{
+    wdt_disable(id);
+}
+