OpenHarmony：全流程讲解如何编写Watchdog平台驱动以及应用程序-开源基础软件社区-51C...

struct WatchdogMethod {
    int32_t (*getStatus)(struct WatchdogCntlr *wdt, int32_t *status);
    int32_t (*setTimeout)(struct WatchdogCntlr *wdt, uint32_t seconds);
    int32_t (*getTimeout)(struct WatchdogCntlr *wdt, uint32_t *seconds);
    int32_t (*start)(struct WatchdogCntlr *wdt);
    int32_t (*stop)(struct WatchdogCntlr *wdt);
    int32_t (*feed)(struct WatchdogCntlr *wdt);
    int32_t (*getPriv)(struct WatchdogCntlr *wdt);  // 【可选】如果WatchdogCntlr中的priv成员存在，则按需实例化
    void (*releasePriv)(struct WatchdogCntlr *wdt); // 【可选】
};

struct HdfDriverEntry g_hdfWdtchdog = {
    .moduleVersion = 1,
    .moduleName = "HDF_PLATFORM_WATCHDOG",		// 【必要且与HCS文件中里面的moduleName匹配】
    .Bind = HdfWdtBind,							// 见Bind参考
    .Init = HdfWdtInit,							// 见Init参考
    .Release = HdfWdtRelease,					// 见Release参考
};

HDF_INIT(g_hdfWdtchdog);						// 调用HDF_INIT将驱动入口注册到HDF框架中

device_watchdog :: device {									// 设备节点
    device0 :: deviceNode {									// 驱动的DeviceNode节点	
        policy = 2;											// policy字段是驱动服务发布的策略,如果需要面向用户态，则为2
        priority = 20;										// 驱动启动优先级
        permission = 0644;									// 驱动创建设备节点权限
        moduleName = "HDF_PLATFORM_WATCHDOG";				// 【必要】用于指定驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
        serviceName = "HDF_PLATFORM_WATCHDOG_0";			// 【必要】驱动对外发布服务的名称，必须唯一。
        deviceMatchAttr = "rockchip_rk3568_watchdog_0";		// 【必要】用于配置控制器私有数据，必须和驱动私有数据配置表watchdog_config.hcs中的match_attr值保持一致。
    }
}

root {
    platform {
        watchdog_config {
            template watchdog_device {
                serviceName = "HDF_PLATFORM_WATCHDOG_0";
                match_attr = "";
                id = 0;
            }

            device_0x12050000 :: watchdog_device {
                id = 0;
                match_attr = "rockchip_rk3568_watchdog_0";
            }
        }
    }
}

// 钩子函数实例化
static struct WatchdogMethod g_wdtMethod = {
    .getStatus = WdtAdapterGetStatus,		// 获取看门狗状态
    .start = WdtAdapterStart,				// 启动看门狗
    .stop = WdtAdapterStop,					// 停止看门狗
    .setTimeout = WdtAdapterSetTimeout,		// 设置看门狗超时时间
    .getTimeout = WdtAdapterGetTimeout,		// 获取看门狗超时时间
    .feed = WdtAdapterFeed,					// 喂狗函数
    .getPriv = WdtOpenFile,
    .releasePriv = WdtAdapterClose,
};

DevHandle WatchdogOpen(int16_t wdtId, DevHandle *handle);

void WatchdogClose(DevHandle handle);

int32_t WatchdogStart(DevHandle handle);

int32_t WatchdogStop(DevHandle handle);

int32_t WatchdogSetTimeout(DevHandle *handle, uint32_t seconds);

int32_t WatchdogGetTimeout(DevHandle *handle, uint32_t *seconds);

int32_t WatchdogGetStatus(DevHandle handle, int32_t *status); 

int32_t WatchdogFeed(DevHandle handle);

wdt: watchdog@fe600000 {
    compatible = "snps,dw-wdt";
    reg = <0x0 0xfe600000 0x0 0x100>;
    clocks = <&cru TCLK_WDT_NS>, <&cru PCLK_WDT_NS>;
    clock-names = "tclk", "pclk";
    interrupts = <GIC_SPI 149 IRQ_TYPE_LEVEL_HIGH>;
    status = "okay";
};

CONFIG_DRIVERS_HDF_PLATFORM_WATCHDOG=y

device_watchdog :: device {
    device0 :: deviceNode {
        policy = 2;
        priority = 20;
        permission = 0644;
        moduleName = "HDF_PLATFORM_WATCHDOG";
        serviceName = "HDF_PLATFORM_WATCHDOG_0";
        deviceMatchAttr = "rockchip_rk3568_watchdog_0";
    }
}

root {
    platform {
        watchdog_config {
            template watchdog_device {
                serviceName = "HDF_PLATFORM_WATCHDOG_0";
                match_attr = "";
                id = 0;
            }

            device_0x12050000 :: watchdog_device {
                id = 0;
                match_attr = "rockchip_rk3568_watchdog_0";
            }
        }
    }
}

struct HdfDriverEntry g_hdfWdtchdog = {
    .moduleVersion = 1,
    .moduleName = "HDF_PLATFORM_WATCHDOG",
    .Bind = HdfWdtBind,
    .Init = HdfWdtInit,
    .Release = HdfWdtRelease,
};

HDF_INIT(g_hdfWdtchdog);

#include "watchdog_if.h"                 // watchdog标准接口头文件

// 打开看门狗设备
ret = WatchdogOpen(m_watchdog_id, handle);
if (ret != 0) {
    PRINT_ERROR("WatchdogOpen failed and ret = %d\n", ret);
    goto out;
}
if (handle == NULL) {
    PRINT_ERROR("WatchdogOpen failed and handle is null\n");
    goto out;
}
......

// 设置超时时间
ret = WatchdogSetTimeout(handle, m_watchdog_timeout);
if (ret != 0) {
    PRINT_ERROR("WatchdogSetTimeout failed and ret = %d\n", ret);
    goto out;
}
printf("WatchdogSetTimeout Successful and Watchdog timeout = %d\n", m_watchdog_timeout);

// 获取超时时间
ret = WatchdogGetTimeout(handle, &timeout);
if (ret != 0) {
    PRINT_ERROR("WatchdogGetTimeout failed and ret = %d\n", ret);
    goto out;
}
printf("WatchdogGetTimeout Successful and Watchdog timeout = %d\n", timeout);

// 启动看门狗
ret = WatchdogStart(handle);
if (ret != 0) {
    PRINT_ERROR("WatchdogStart failed and ret = %d\n", ret);
    goto out;
}

// 获取看门狗状态，是否启动
status = WATCHDOG_STOP;
ret = WatchdogGetStatus(handle, &status);
if (ret != 0) {
    PRINT_ERROR("WatchdogGetStatus failed and ret = %d\n", ret);
    goto out;
}
printf("WatchdogGetStatus Successful and Watchdog status = %d, WATCHDOG_START = %d, WATCHDOG_STOP = %d\n",
    status, WATCHDOG_START, WATCHDOG_STOP);

// 喂狗
for (i = 0; i < m_watchdog_feed_count; i++) {
    sleep(m_watchdog_feed);
    printf("Watchdog: feed number = %d and feed time = %d\n", i, m_watchdog_feed);
    ret = WatchdogFeed(handle);
    if (ret != 0) {
        PRINT_ERROR("WatchdogFeed failed and ret = %d\n", ret);
        goto out;
    }
}

// 停止喂狗
ret = WatchdogStop(handle);
if (ret != 0) {
    PRINT_ERROR("WatchdogStop failed and ret = %d\n", ret);
    goto out;
}

WatchdogClose(handle);

import("//build/ohos.gni")
import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni")

print("samples: compile rk3568_watchdog_test")
ohos_executable("rk3568_watchdog_test") {
  sources = [ "watchdog_test.c" ]
  include_dirs = [
    "$hdf_framework_path/include",
    "$hdf_framework_path/include/core",
    "$hdf_framework_path/include/osal",
    "$hdf_framework_path/include/platform",
    "$hdf_framework_path/include/utils",
    "$hdf_uhdf_path/osal/include",
    "$hdf_uhdf_path/ipc/include",
    "//base/hiviewdfx/hilog/interfaces/native/kits/include",
    "//third_party/bounds_checking_function/include",
  ]

  deps = [
    "$hdf_uhdf_path/platform:libhdf_platform",
    "$hdf_uhdf_path/utils:libhdf_utils",
    "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog",
  ]

  cflags = [
    "-Wall",
    "-Wextra",
    "-Werror",
    "-Wno-format",
    "-Wno-format-extra-args",
  ]

  part_name = "product_rk3568"
  install_enable = true
}

"b10_platform_device_watchdog/app:rk3568_watchdog_test"

hb set -root .
hb set
# 选择lockzhiner下的rk3568编译分支。
hb build -f

# rk3568_Watchdog_test
Watchdog Params:
    watchdog id = 0
    watchdog timeout sec = 5
    watchdog feed sec = 1
    watchdog feed count = 5
../../vendor/lockzhiner/rk3568/samples/b10_platform_device_watchdog/app/watchdog_test.c, main, 121, error: WatchdogOpen failed and ret = -16
WatchdogClose Successful
#

/**
 * @brief Enumerates HDF return value types.
 */
typedef enum {
    HDF_SUCCESS  = 0, /**< The operation is successful. */
    HDF_FAILURE = -1, /**< Failed to invoke the OS underlying function. */
    HDF_ERR_NOT_SUPPORT = -2, /**< Not supported. */
    HDF_ERR_INVALID_PARAM = -3, /**< Invalid parameter. */
    HDF_ERR_INVALID_OBJECT = -4, /**< Invalid object. */
    HDF_ERR_MALLOC_FAIL    = -6, /**< Memory allocation fails. */
    HDF_ERR_TIMEOUT        = -7, /**< Timeout occurs. */
    HDF_ERR_THREAD_CREATE_FAIL = -10, /**< Failed to create a thread. */
    HDF_ERR_QUEUE_FULL  = -15, /**< The queue is full. */
    HDF_ERR_DEVICE_BUSY = -16, /**< The device is busy. */
    HDF_ERR_IO          = -17, /**< I/O error. */
    HDF_ERR_BAD_FD      = -18, /**< Incorrect file descriptor. */
    HDF_ERR_NOPERM      = -19, /**< No permission. */
	......
} HDF_STATUS;