MT7620_看门狗（Watchdog）驱动

一、硬件平台： MT7620（A9内核）

二、软件平台：

       1、Ubuntu 12.04 

       2、MT7620 SDK软件开发包（MediaTek_ApSoC_SDK_4320_20150414.tar.bz2）

三、功能简介

       对于看门狗以及其他的一些驱动，本人建议编译成模块，采用.ko 文件挂载，如此方便移植和维护。而且与内核分离开，可以节省编译时间，提高效率。

四、修改内容

       对于MT7620 软件SDK 开发包，已经含有看门狗驱动。但是，内核看门狗驱动源码，默认没有设置看门狗超时时间的接口，故需要修改代码，增加相应的接口。

五、看门狗程序

       1、看门狗头文件

       本程序与为SDK开发包源码一致，原始的SDK代码为   " ..\RT288x_SDK\source\linux-2.6.36.x\drivers\watchdog\ralink_wdt.h "

       头文件名称 watchdog_driver.h

#include <asm/rt2880/rt_mmap.h>

#ifndef _RALINK_WDT_WANTED
#define _RALINK_WDT_WANTED

#define PHYS_TO_K1(physaddr) KSEG1ADDR(physaddr)
#define sysRegRead(phys) (*(volatile unsigned int *)PHYS_TO_K1(phys))
#define sysRegWrite(phys, val)  ((*(volatile unsigned int *)PHYS_TO_K1(phys)) = (val))

#define SYSCFG      RALINK_SYSCTL_BASE + 0x10  /* System Configuration Register */
#define SYSCFG1     RALINK_SYSCTL_BASE + 0x14  /* System Configuration Register1 */
#define GPIOMODE    RALINK_SYSCTL_BASE + 0x60  
#define CLKCFG      RALINK_SYSCTL_BASE + 0x30  /* Clock Configuration Register */
#define TMRSTAT     (RALINK_TIMER_BASE)  /* Timer Status Register */

#if defined (CONFIG_RALINK_RT6855A)
#define TMR1CTL     (TMRSTAT + 0x0)  /* WDG Timer Control */
#define TMR1LOAD    (TMRSTAT + 0x2C) /* WDG Timer Load Value Register */
#define TMR1VAL     (TMRSTAT + 0x30) /* WDG Timer Current Value Register */
#define RLDWDOG     (TMRSTAT + 0x38) /* Reload Watchdog */
#elif defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628) 
#define TMR0CTL     (TMRSTAT + 0x10)  /* Timer0 Control */
#define TMR0LOAD    (TMRSTAT + 0x14)  /* Timer0 Load Value */
#define TMR0VAL     (TMRSTAT + 0x18)  /* Timer0 Counter Value */
#define TMR1CTL     (TMRSTAT + 0x20)  /* WDG Timer Control */
#define TMR1LOAD    (TMRSTAT + 0x24)  /* WDG Timer Load Value */
#define TMR1VAL     (TMRSTAT + 0x28)  /* WDG Timer Counter Value */
#define TMR2CTL     (TMRSTAT + 0x30)  /* Timer1 Control */
#define TMR2LOAD    (TMRSTAT + 0x34)  /* Timer1 Load Value */
#define TMR2VAL     (TMRSTAT + 0x38)  /* Timer1 Counter Value */
#else
#define TMR1CTL     (TMRSTAT + 0x28)  /* Timer1 Control */
#define TMR1LOAD    (TMRSTAT + 0x20)  /* Timer1 Load Value */
#define TMR1VAL     (TMRSTAT + 0x24)  /* Timer1 Counter Value */
#endif

#define INTENA      (RALINK_INTCL_BASE + 0x34)  /* Interrupt Enable */

enum timer_mode {
    FREE_RUNNING,
    PERIODIC,
    TIMEOUT,
    WATCHDOG
};

enum timer_clock_freq {
    SYS_CLK,          /* System clock     */
    SYS_CLK_DIV4,     /* System clock /4  */
    SYS_CLK_DIV8,     /* System clock /8  */
    SYS_CLK_DIV16,    /* System clock /16 */
    SYS_CLK_DIV32,    /* System clock /32 */
    SYS_CLK_DIV64,    /* System clock /64 */
    SYS_CLK_DIV128,   /* System clock /128 */
    SYS_CLK_DIV256,   /* System clock /256 */
    SYS_CLK_DIV512,   /* System clock /512 */
    SYS_CLK_DIV1024,  /* System clock /1024 */
    SYS_CLK_DIV2048,  /* System clock /2048 */
    SYS_CLK_DIV4096,  /* System clock /4096 */
    SYS_CLK_DIV8192,  /* System clock /8192 */
    SYS_CLK_DIV16384, /* System clock /16384 */
    SYS_CLK_DIV32768, /* System clock /32768 */
    SYS_CLK_DIV65536  /* System clock /65536 */
};

#endif

        2、看门狗程序，参考SDK开发包中的 “ ..\RT288x_SDK\source\linux-2.6.36.x\drivers\watchdog\ralink_wdt.c ” 文件

        文件名称为 watchdog_driver.c

        

// 本程序参考SDK开发包文件
// ..\RT288x_SDK\source\linux-2.6.36.x\drivers\watchdog\ralink_wdt.c

#include <linux/version.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <asm/sgi/mc.h>
#include "watchdog_driver.h"

static int RaWdgAlive;
static int WdgLoadValue;
extern u32 get_surfboard_sysclk(void);

// modify ：sky.houfei
#define WATCHDOG_TIMEOUT 90		/* 90 sec default timeout */
static int s_timeout = WATCHDOG_TIMEOUT;

#ifdef CONFIG_WATCHDOG_NOWAYOUT
static int nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, int, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
#endif

void SetWdgTimerEbl(unsigned int timer, unsigned int ebl)
{
    unsigned int result;

    result=sysRegRead(timer);

    if(ebl==1){
#if defined (CONFIG_RALINK_RT6855A)
        result |= (1<<25) | (1<<5);
#else
        result |= (1<<7);
#endif
    }else {
#if defined (CONFIG_RALINK_RT6855A)
        result &= ~((1<<25)|(1<<5));
#else
        result &= ~(1<<7);
#endif
    }

    sysRegWrite(timer,result);

  //timer1 used for watchdog timer
#if defined (CONFIG_RALINK_TIMER_WDG_RESET_OUTPUT)

#if defined (CONFIG_RALINK_RT2880)
    if(timer==TMR1CTL) {
        result=sysRegRead(CLKCFG);

        if(ebl==1){
            result |= (1<<9); /* SRAM_CS_N is used as wdg reset */
        }else {
            result &= ~(1<<9); /* SRAM_CS_N is used as normal func */
        }

        sysRegWrite(CLKCFG,result);
    }
#elif defined (CONFIG_RALINK_RT3052) || defined (CONFIG_RALINK_RT2883)
    if(timer==TMR1CTL) {
        //the last 4bits in SYSCFG are write only
        result=sysRegRead(SYSCFG);

        if(ebl==1){
            result |= (1<<2); /* SRAM_CS_MODE is used as wdg reset */
        }else {
            result &= ~(1<<2); /* SRAM_CS_MODE is used as wdg reset */
        }

        sysRegWrite(SYSCFG,result);
    }
#elif defined (CONFIG_RALINK_RT3883)
    if(timer==TMR1CTL) {
        result=sysRegRead(SYSCFG1);

        if(ebl==1){
            result |= (1<<2); /* GPIO2 as watch dog reset */
        }else {
            result &= ~(1<<2);
        }

        sysRegWrite(SYSCFG1,result);
    }
#elif defined (CONFIG_RALINK_RT3352)
    if(timer==TMR1CTL) {
	//GPIOMODE[22:21]
	//2'b00:SPI_CS1
	//2'b01:WDG reset output
	//2'b10:GPIO mode
        result=sysRegRead(GPIOMODE); //GPIOMODE[22:21]
	result &= ~(0x3<<21);

        if(ebl==1){
            result |= (0x1<<21); /* SPI_CS1 as watch dog reset */
        }else {
            //result |= (0x0<<21); //SPI_CS1
            result |= (0x2<<21); //GPIO_mode
        }

        sysRegWrite(GPIOMODE,result);
    }
#elif defined (CONFIG_RALINK_RT5350)
    if(timer==TMR1CTL) {
	/*
	 * GPIOMODE[22:21]
	 * 2'b00:SPI_CS1
	 * 2'b01:WDG reset output
	 * 2'b10:GPIO mode
	 */
        result=sysRegRead(GPIOMODE); 
	result &= ~(0x3<<21);

        if(ebl==1){
            result |= (0x1<<21);
        }else {
	    //result |= (0x0<<21); //SPI_CS1
	    result |= (0x2<<21); //GPIO mode
	} 
        
	sysRegWrite(GPIOMODE,result);

    }
#elif defined (CONFIG_RALINK_MT7620)

    if(timer==TMR1CTL) {
        result=sysRegRead(GPIOMODE);
	/*
	 * GPIOMODE[22:21] WDT_GPIO_MODE
	 * 2'b00:Normal
	 * 2'b01:REFCLK0
	 * 2'b10:GPIO Mode
	 */
	result &= ~(0x3<<21);

        if(ebl==1){
            result |= (0x0<<21);
        }else {
	    result |= (0x2<<21); //GPIO
	    //result |= (0x1<<21); //REFCLK0
        }
        sysRegWrite(GPIOMODE,result);
    }
#elif defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628) 

    if(timer==TMR1CTL) {
        result=sysRegRead(GPIOMODE);
	/*
	 * GPIOMODE[22:21] WDT_GPIO_MODE
	 * 2'b00:Normal
	 * 2'b01:REFCLK0
	 * 2'b10:GPIO Mode
	 */
	result &= ~(0x3<<21);

        if(ebl==1){
            result |= (0x0<<21);
        }else {
	    result |= (0x2<<21); //GPIO
	    //result |= (0x1<<21); //REFCLK0
        }
        sysRegWrite(GPIOMODE,result);
    }
#endif
#endif
}

#if defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628)
void SetWdgTimerClock(int prescale)
{
    unsigned int result;

    result=sysRegRead(TMR1CTL);
    result &= 0x0000FFFF;
    result |= (prescale << 16); //unit = 1u
    sysRegWrite(TMR1CTL, result);
}
void SetTimerMode(unsigned int timer, enum timer_mode mode)
{
}
#else
void SetTimerMode(unsigned int timer, enum timer_mode mode)
{
    unsigned int result;

    result=sysRegRead(timer);
    result &= ~(0x3<<4); //watchdog mode
    result=result | (mode << 4);
    sysRegWrite(timer,result);
}

void SetWdgTimerClock(unsigned int timer, enum timer_clock_freq prescale)
{
    unsigned int result;

    result=sysRegRead(timer);
    result &= ~0xF;
    result=result | (prescale&0xF);
    sysRegWrite(timer,result);
}
#endif

static void RaWdgStart(void)
{
#if defined (CONFIG_RALINK_RT6855A)
    int HwConf;
#endif

    printk(KERN_INFO "Started WatchDog Timer.\n");

    SetTimerMode(TMR1CTL,WATCHDOG);
#if defined (CONFIG_RALINK_RT2880) || defined (CONFIG_RALINK_RT2883) || \
    defined (CONFIG_RALINK_RT3052) || defined (CONFIG_RALINK_RT3883)
    /*
     * For user easy configuration, We assume the unit of watch dog timer is 1s,
     * so we need to calculate the TMR1LOAD value.
     *
     * Unit= 1/(SysClk/65536), 1 Sec = (SysClk)/65536
     *
     */
    SetWdgTimerClock(TMR1CTL,SYS_CLK_DIV65536);
    WdgLoadValue = s_timeout * (get_surfboard_sysclk()/65536);
#elif defined (CONFIG_RALINK_RT6855A)
    HwConf = sysRegRead(RALINK_SYSCTL_BASE + 0x8c);
    if(((HwConf >> 24) & 0x3) == 0) { //SDR
            WdgLoadValue =  s_timeout * (140 * 1000 * 1000 / 2);
    }else {
            if(((HwConf >> 26) & 0x1) == 0) {
                     WdgLoadValue =  s_timeout * (233 * 1000 * 1000 / 2);
            }else {
                     WdgLoadValue =  s_timeout * (175 * 1000 * 1000 / 2);
            }
    }
    sysRegWrite(TMR1LOAD,  WdgLoadValue);
#elif defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628)
    SetWdgTimerClock(1000); // 1 msec
    WdgLoadValue = s_timeout * 1000;
    sysRegWrite(TMR1LOAD,  WdgLoadValue);
#else
    SetWdgTimerClock(TMR1CTL,SYS_CLK_DIV65536);
    WdgLoadValue = s_timeout * (40000000/65536); //fixed at 40Mhz
#endif
    
    sysRegWrite(TMR1LOAD, WdgLoadValue);
    SetWdgTimerEbl(TMR1CTL,1);
}

static void RaWdgStop(void)
{
	SetWdgTimerEbl(TMR1CTL,0);

	printk(KERN_INFO "Stopped WatchDog Timer.\n");
}

static void RaWdgReload(void)
{
#if defined (CONFIG_RALINK_RT6855A)
	 sysRegWrite(RLDWDOG, 1);
#elif defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628)
	 sysRegWrite(TMRSTAT, (1 << 9)); //WDTRST
#else
	 sysRegWrite(TMR1LOAD, WdgLoadValue);
#endif
}

// add by sky.houfei
// 设置WatchDog周期timeout
static int RaWdgSetHeartbeat(int timeout)
{
#if defined (CONFIG_RALINK_RT6855A)
    int HwConf;
#endif

	if (timeout > 107)
	{
		printk("Warn! The timeout value is > 107 second, the max value is 107.Set failed\n");
	}
    SetTimerMode(TMR1CTL,WATCHDOG);
	s_timeout = timeout;
#if defined (CONFIG_RALINK_RT2880) || defined (CONFIG_RALINK_RT2883) || \
    defined (CONFIG_RALINK_RT3052) || defined (CONFIG_RALINK_RT3883)
    /*
     * For user easy configuration, We assume the unit of watch dog timer is 1s,
     * so we need to calculate the TMR1LOAD value.
     *
     * Unit= 1/(SysClk/65536), 1 Sec = (SysClk)/65536
     *
     */
    SetWdgTimerClock(TMR1CTL,SYS_CLK_DIV65536);
    WdgLoadValue = s_timeout * (get_surfboard_sysclk()/65536);
#elif defined (CONFIG_RALINK_RT6855A)
    HwConf = sysRegRead(RALINK_SYSCTL_BASE + 0x8c);
    if(((HwConf >> 24) & 0x3) == 0) { //SDR
            WdgLoadValue =  s_timeout * (140 * 1000 * 1000 / 2);
    }else {
            if(((HwConf >> 26) & 0x1) == 0) {
                     WdgLoadValue =  s_timeout * (233 * 1000 * 1000 / 2);
            }else {
                     WdgLoadValue =  s_timeout * (175 * 1000 * 1000 / 2);
            }
    }
    sysRegWrite(TMR1LOAD,  WdgLoadValue);
#elif defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628)
    SetWdgTimerClock(1000); // 1 msec
    WdgLoadValue = s_timeout * 1000;
    sysRegWrite(TMR1LOAD,  WdgLoadValue);
#else
    SetWdgTimerClock(TMR1CTL,SYS_CLK_DIV65536);
    WdgLoadValue = s_timeout * (40000000/65536); //fixed at 40Mhz
#endif
    
    sysRegWrite(TMR1LOAD, WdgLoadValue);
    SetWdgTimerEbl(TMR1CTL,1);

	return 0;
}

/*
 *	Allow only one person to hold it open
 */
static int ralink_open(struct inode *inode, struct file *file)
{
	if (RaWdgAlive)
		return -EBUSY;

#ifdef CONFIG_WATCHDOG_NOWAYOUT
	if (nowayout)
		__module_get(THIS_MODULE);
#endif

	/* Activate timer */
	RaWdgStart();
	RaWdgAlive = 1;

	return nonseekable_open(inode, file);
}

static int ralink_release(struct inode *inode, struct file *file)
{
	/* Shut off the timer.
	 * Lock it in if it's a module and we defined ...NOWAYOUT */
#ifdef CONFIG_WATCHDOG_NOWAYOUT
	if (!nowayout)
		RaWdgStop();		/* Turn the WDT off */
#endif

	RaWdgAlive = 0;

	return 0;
}

static ssize_t ralink_write(struct file *file, const char *data, size_t len, loff_t *ppos)
{
	/* Refresh the timer. */
	if (len) {
		RaWdgReload();
	}
	return len;
}

static struct watchdog_info ident = {
    .options		= WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
    .identity		= "Ralink Hardware WatchDog",
};

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
long ralink_ioctl (struct file *filp, unsigned int cmd, unsigned long arg)
#else
static int ralink_ioctl(struct inode *inode, struct file *file,
	unsigned int cmd, unsigned long arg)
#endif
{
	int options, retval = -EINVAL;
	void __user *argp = (void __user *)arg;
	int __user *p = argp;
	int new_margin;

	switch (cmd) {
		default:
			return -ENOTTY;
		case WDIOC_GETSUPPORT:
			if (copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)))
				return -EFAULT;
			return 0;
		case WDIOC_GETSTATUS:
		case WDIOC_GETBOOTSTATUS:
			return put_user(0,(int *)arg);
		case WDIOC_KEEPALIVE:
			RaWdgReload();
			return 0;
		case WDIOC_GETTIMEOUT:
			return put_user(s_timeout,(int *)arg);
			
        // add by sky.houfei
        // 增加设置超时时间功能
		case WDIOC_SETTIMEOUT:
			if (get_user(new_margin, p))
			{
				return -EFAULT;
			}
			if (RaWdgSetHeartbeat(new_margin))
			{
				return -EINVAL;
			}
			RaWdgReload();
			return put_user(s_timeout, p);
		case WDIOC_SETOPTIONS:
		{
			if (get_user(options, (int *)arg))
				return -EFAULT;

			if (options & WDIOS_DISABLECARD) {
				RaWdgStop();
				retval = 0;
			}

			if (options & WDIOS_ENABLECARD) {
				RaWdgStart();
				retval = 0;
			}

			return retval;
		}
	}
}

static int ralink_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
{
	if (code == SYS_DOWN || code == SYS_HALT)
		RaWdgStop();		/* Turn the WDT off */

	return NOTIFY_DONE;
}

static const struct file_operations ralink_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.write		= ralink_write,
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
	.unlocked_ioctl = ralink_ioctl,
#else
	.ioctl		= ralink_ioctl,
#endif
	.open		= ralink_open,
	.release	= ralink_release,
};

static struct miscdevice ralink_miscdev = {
	.minor		= WATCHDOG_MINOR,
	.name		= "watchdog",
	.fops		= &ralink_fops,
};

static struct notifier_block ralink_notifier = {
	.notifier_call = ralink_notify_sys,
};

static char banner[] __initdata =
	KERN_INFO "Ralink APSoC Hardware Watchdog Timer\n";

static int __init watchdog_init(void)
{
	int ret;

	ret = register_reboot_notifier(&ralink_notifier);
	if (ret) {
		printk(KERN_ERR "cannot register reboot notifier (err=%d)\n",
			ret);
		return ret;
	}

	ret = misc_register(&ralink_miscdev);
	if (ret) {
		printk(KERN_ERR "cannot register miscdev on minor=%d (err=%d)\n",
			WATCHDOG_MINOR, ret);
		unregister_reboot_notifier(&ralink_notifier);
		return ret;
	}

	printk(banner);

	return 0;
}

static void __exit watchdog_exit(void)
{
	RaWdgStop();
	misc_deregister(&ralink_miscdev);
	unregister_reboot_notifier(&ralink_notifier);
}

module_init(watchdog_init);
module_exit(watchdog_exit);

MODULE_AUTHOR("sky.houfei");
MODULE_DESCRIPTION("Ralink APSoC Hardware Watchdog Timer");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

        3、驱动 makefile

        文件名：MakeFile

        make 命令，其中 “ /home/sky/RT288x_SDK/source/linux-2.6.36.x/  ”为内核包的路径。

make MIPSLINUXDIR=/home/sky/RT288x_SDK/source/linux-2.6.36.x/

       make clean 命令，其中 “ /home/sky/RT288x_SDK/source/linux-2.6.36.x/  ”为内核包的路径。

make MIPSLINUXDIR=/home/sky/RT288x_SDK/source/linux-2.6.36.x/ clean

       MakeFile 内容如下：

obj-m = watchdog_driver.o

#K_DIR = /home/sky/RT288x_SDK/source/linux-2.6.36.x/

PWD=$(shell pwd)

all:
	make  ARCH=mips CROSS_COMPILE="/opt/buildroot-gcc463/usr/bin"/mipsel-linux-  -C $(MIPSLINUXDIR)  M=$(PWD) modules
	
clean:
	make  ARCH=mips CROSS_COMPILE="/opt/buildroot-gcc463/usr/bin"/mipsel-linux-  -C $(MIPSLINUXDIR)  M=$(PWD) clean
	rm -f watchdog_driver.ko
  
#make command:
#make MIPSLINUXDIR=/home/sky/RT288x_SDK/source/linux-2.6.36.x/
#make MIPSLINUXDIR=/home/sky/RT288x_SDK/source/linux-2.6.36.x/ clean

       4、看门狗应用程序

        程序名称：watchdog_app.c

/*
 * Watchdog Driver Test Program
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/watchdog.h>


#define DEV  "/dev/watchdog"

static int s_watchdogFd;

/*
* @brief 看门狗使能。
*/
static void Watchdog_Start(void)
{
	int i = WDIOS_ENABLECARD;

	ioctl(s_watchdogFd,WDIOC_SETOPTIONS,&i);
}


/*
* @brief 看门狗禁止。
*/
static void Watchdog_Stop(void)
{
	int i = WDIOS_DISABLECARD;

	ioctl(s_watchdogFd, WDIOC_SETOPTIONS, &i);
}


/*
* @brief 喂狗程序。
*/
static void Watchdog_Feed(void)
{
    int dummy;

    ioctl(s_watchdogFd, WDIOC_KEEPALIVE, &dummy);
}

/*
* @brief 设置看门狗复位时间。
* @param[in] time, unsigned int, 复位时间，单位为秒。
*/
static void Watchdog_TimeoutSet(int time)
{
	ioctl(s_watchdogFd, WDIOC_SETTIMEOUT, &time);
}


/*
* @brief 获取看门狗复位时间。
* @return time, int，复位定时时间，单位为秒。
*/
static int Watchdog_TimeoutGet(void)
{
	int time = 0;

	ioctl(s_watchdogFd, WDIOC_GETTIMEOUT, &time);
	return time;
}


int main(int argc, char *argv[])
{
    int flags;  
	int count = 0;
	int i = 0;

    s_watchdogFd = open(DEV, O_RDWR);

    if (s_watchdogFd == -1) 
	{
		fprintf(stderr, "Watchdog device not enabled.\n");
		fprintf(stderr, "Can not find the file /dev/watchdog.\n");
		fflush(stderr);
		exit(-1);
    }

    // 读看门狗溢出时间
    i = Watchdog_TimeoutGet(); 
    printf("watchdog get timer = %d\n", i);	

    // 设置看门狗溢出时间
    i = 5;	// 复位时间5秒
    Watchdog_TimeoutSet(i);
    printf("watchdog set timer = %d\n", i);
	
    // 读看门狗溢出时间
    i = Watchdog_TimeoutGet(); 
    printf("watchdog get timer = %d\n", i);

    // 功能说明：
    // 1、前面10秒喂狗，看门狗不会复位，用于验证喂狗功能是否正常。
    // 2、第11 秒关闭看门狗，用于验证看门狗关闭是否正常（如果不能关闭，则5秒达到看门狗超时后，自动复位）。
    // 3、第30秒 看门狗使能，用于验证看门狗使能是否正常，此时不喂狗，5秒后自动复位。
    //  如果验证看门狗是否正常，直接把 喂狗、开启、关闭看门狗代码注释即可。
    while(1) 
    {
		count++;
		if (count < 10)
		{
			Watchdog_Feed();      // 喂狗程序
		}
		else if (count == 11)
		{
			Watchdog_Stop();   // 停止看门狗功能
		}
		else if (count == 30)
		{
			Watchdog_Start();   // 开启看门狗功能
		}
		sleep(1);
		printf("count = %d\n", count);
    }
}