内核驱动 （五）看门狗

尽管在linux系统中，对于S3C2440开发板来说，默认是已经配置了看门狗定时器，如：

Device Drivers --->         [*] Watchdog Timer Support --->                 [*] Disable watchdog shutdown on close (NEW) //如果选中， 用户一旦 open 看门狗设备，用户就没法关闭看门狗                 <*> S3C2410 Watchdog

但看门狗定时器是没有打开的，所以我们会在启动系统的时候，看到如下信息提示：

下面就具体分析一下看门狗定时器。
在Mach-Louis210.c文件中已经添加了看门狗定时器这个平台设备：

static struct platform_device *Louis210_devices[]__initdata = {
    ……
    &s3c_device_wdt,
    ……
};

而这个平台设备的具体定义是在arch/arm/plat-samsung目录下的Devs.c文件内给出的：

static struct resource s3c_wdt_resource[] = {
	[0] = DEFINE_RES_MEM(S3C_PA_WDT, SZ_1K),
	[1] = DEFINE_RES_IRQ(IRQ_WDT),
};

struct platform_device s3c_device_wdt = {
	.name		= "s5pv210-wdt",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(s3c_wdt_resource),
	.resource	= s3c_wdt_resource,
};

该平台设备所对应的平台驱动定义在drivers/watchdog目录下的S3c2410_wdt.c文件内：

static struct platform_driver s3c2410wdt_driver = {
	.probe		= s3c2410wdt_probe,
	.remove		= s3c2410wdt_remove,
	.shutdown	= s3c2410wdt_shutdown,
	.suspend	= s3c2410wdt_suspend,
	.resume		= s3c2410wdt_resume,
	.driver		= {
		.owner	= THIS_MODULE,
		.name	= "s5pv210-wdt",
		.of_match_table	= of_match_ptr(s3c2410_wdt_match),
	},
};

在S3c2410_wdt.c文件内的开始处，定义了几个很重要的变量：

#define CONFIG_S3C2410_WATCHDOG_ATBOOT		(1)//(0)
#define CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME	(15)    //定时器会溢出时间，系统会复位
#define CONFIG_S3C2410_WATCHDOG_INTEN		(0)    //add by Louis,与CONFIG_S3C2410_WATCHDOG_ATBOOT冲突

static bool nowayout	= WATCHDOG_NOWAYOUT;    //是否允许关闭看门狗定时器，1允许，0不允许
static int tmr_margin;  //喂狗的最长时间间隔，上电默认时间间隔为 CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME
static int tmr_atboot	= CONFIG_S3C2410_WATCHDOG_ATBOOT;   //表示系统启动后是否使能看门狗，1表示使能，0表示关闭
static int soft_noboot = CONFIG_S3C2410_WATCHDOG_INTEN; //表示是否把看门狗当作一般的定时器来用，是否发出中断信号
static int debug;

在S3c2410_wdt.c文件内，还定义了一个重要的结构：

static struct watchdog_device s3c2410_wdd = {
	.info = &s3c2410_wdt_ident,
	.ops = &s3c2410wdt_ops,
	.timeout = CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME,
};

其中.ops指向的是s3c2410wdt_ops结构：

static struct watchdog_ops s3c2410wdt_ops = {
	.owner = THIS_MODULE,
	.start = s3c2410wdt_start,    开启看门狗
	.stop = s3c2410wdt_stop,      关闭看门狗
	.ping = s3c2410wdt_keepalive, 用于喂狗
	.set_timeout = s3c2410wdt_set_heartbeat,   设置看门狗定时时间间隔，即喂狗时间
};

下面就重点介绍一下s3c2410wdt_probe函数：

static int s3c2410wdt_probe(struct platform_device *pdev)
{
	struct device *dev;
	unsigned int wtcon;
	int started = 0;
	int ret;

	DBG("%s: probe=%p\n", __func__, pdev);

	dev = &pdev->dev;
	wdt_dev = &pdev->dev;

    /* 获取看门狗平台设备所使用的内存映射空间 */
	wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (wdt_mem == NULL) {
		dev_err(dev, "no memory resource specified\n");
		return -ENOENT;
	}

    /* 获取看门狗平台设备所使用的中断号 */
	wdt_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (wdt_irq == NULL) {
		dev_err(dev, "no irq resource specified\n");
		ret = -ENOENT;
		goto err;
	}

	/* get the memory region for the watchdog timer */
    /* 获取内存基地址 */
	wdt_base = devm_ioremap_resource(dev, wdt_mem);
	if (IS_ERR(wdt_base)) {
		ret = PTR_ERR(wdt_base);
		goto err;
	}

	DBG("probe: mapped wdt_base=%p\n", wdt_base);

    /* 从平台时钟队列中获取看门狗的时钟 */
	wdt_clock = devm_clk_get(dev, "watchdog");
	if (IS_ERR(wdt_clock)) {
		dev_err(dev, "failed to find watchdog clock source\n");
		ret = PTR_ERR(wdt_clock);
		goto err;
	}

    /* 使能看门狗时钟 */
	clk_prepare_enable(wdt_clock);

    /* 注册CPU频率 */
	ret = s3c2410wdt_cpufreq_register();
	if (ret < 0) {
		pr_err("failed to register cpufreq\n");
		goto err_clk;
	}

	/* see if we can actually set the requested timer margin, and if
	 * not, try the default value */

	watchdog_init_timeout(&s3c2410_wdd, tmr_margin,  &pdev->dev);

    /* 设置看门狗定时器的溢出时间间隔 */
	if (s3c2410wdt_set_heartbeat(&s3c2410_wdd, s3c2410_wdd.timeout)) {
		started = s3c2410wdt_set_heartbeat(&s3c2410_wdd,
					CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);

		if (started == 0)
			dev_info(dev,
			   "tmr_margin value out of range, default %d used\n",
			       CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
		else
			dev_info(dev, "default timer value is out of range, "
							"cannot start\n");
	}

    /* 申请看门狗定时器中断，因为看门狗定时器也可以当一般的定时器中断使用 */
	ret = devm_request_irq(dev, wdt_irq->start, s3c2410wdt_irq, 0,
				pdev->name, pdev);
	if (ret != 0) {
		dev_err(dev, "failed to install irq (%d)\n", ret);
		goto err_cpufreq;
	}
    
    /* 由nowayout的值设置看门狗的属性 */
	watchdog_set_nowayout(&s3c2410_wdd, nowayout);

    /* 注册看门狗设备 */
	ret = watchdog_register_device(&s3c2410_wdd);
	if (ret) {
		dev_err(dev, "cannot register watchdog (%d)\n", ret);
		goto err_cpufreq;
	}

    /* 由tmr_atboot的值来决定是否开启看门狗定时器 */
	if (tmr_atboot && started == 0) {
		dev_info(dev, "starting watchdog timer\n");
		s3c2410wdt_start(&s3c2410_wdd);
	} else if (!tmr_atboot) {
		/* if we're not enabling the watchdog, then ensure it is
		 * disabled if it has been left running from the bootloader
		 * or other source */

		s3c2410wdt_stop(&s3c2410_wdd);
	}

	/* print out a statement of readiness */
    /* 打印出看门狗的状态信息，即系统启动时显示的看门狗信息 */
	wtcon = readl(wdt_base + S3C2410_WTCON);

	dev_info(dev, "watchdog %sactive, reset %sabled, irq %sabled\n",
		 (wtcon & S3C2410_WTCON_ENABLE) ?  "" : "in",   //看门狗是否启动
		 (wtcon & S3C2410_WTCON_RSTEN) ? "en" : "dis",  //看门狗是否允许发生复位信号
		 (wtcon & S3C2410_WTCON_INTEN) ? "en" : "dis"); //看门狗是否允许发出中断信号（soft_noboot决定是否打开）

	return 0;

 err_cpufreq:
	s3c2410wdt_cpufreq_deregister();

 err_clk:
	clk_disable_unprepare(wdt_clock);
	wdt_clock = NULL;

 err:
	wdt_irq = NULL;
	wdt_mem = NULL;
	return ret;
}

注册函数 watchdog_register_device()

int watchdog_register_device(struct watchdog_device *wdd)
{
	int ret, id, devno;

	if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
		return -EINVAL;

	/* Mandatory operations need to be supported */
	if (wdd->ops->start == NULL || wdd->ops->stop == NULL)
		return -EINVAL;

	watchdog_check_min_max_timeout(wdd);

	/*
	 * Note: now that all watchdog_device data has been verified, we
	 * will not check this anymore in other functions. If data gets
	 * corrupted in a later stage then we expect a kernel panic!
	 */

	mutex_init(&wdd->lock);
	id = ida_simple_get(&watchdog_ida, 0, MAX_DOGS, GFP_KERNEL);
	if (id < 0)
		return id;
	wdd->id = id;
    
    /* 函数内注册混杂设备，生成/dev/watchdog文件 */
	ret = watchdog_dev_register(wdd);   
	if (ret) {
		ida_simple_remove(&watchdog_ida, id);
		if (!(id == 0 && ret == -EBUSY))
			return ret;

		/* Retry in case a legacy watchdog module exists */
		id = ida_simple_get(&watchdog_ida, 1, MAX_DOGS, GFP_KERNEL);
		if (id < 0)
			return id;
		wdd->id = id;

		ret = watchdog_dev_register(wdd);
		if (ret) {
			ida_simple_remove(&watchdog_ida, id);
			return ret;
		}
	}

	devno = wdd->cdev.dev;
    
    /* 生成/dev/watchdog0文件 */
	wdd->dev = device_create(watchdog_class, wdd->parent, devno,
					NULL, "watchdog%d", wdd->id);
	if (IS_ERR(wdd->dev)) {
		watchdog_dev_unregister(wdd);
		ida_simple_remove(&watchdog_ida, id);
		ret = PTR_ERR(wdd->dev);
		return ret;
	}

	return 0;
}

从上面的介绍中可以看出，s3c2410wdt_probe函数中最重要的部分是调用watchdog_register_device函数用以注册看门狗。watchdog_register_device函数在drivers/watchdog目录下的Watchdog_core.c文件内。而watchdog_register_device函数最重要的作用是调用watchdog_dev_register函数，它在drivers/watchdog目录下的Watchdog_dev.c文件内，即把看门狗设备注册成一个混杂设备。

看门狗定时器的杂项设备结构为：

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

watchdog_fops结构为：

static const struct file_operations watchdog_fops = {
	.owner		= THIS_MODULE,
	.write		= watchdog_write,
	.unlocked_ioctl	= watchdog_ioctl,
	.open		= watchdog_open,
	.release	= watchdog_release,
};

在打开看门狗的函数watchdog_open内，调用了watchdog_start函数，而在watchdog_start函数中最终是调用的S3c2410_wdt.c文件中的s3c2410wdt_start函数来实现看门狗的开启。在写看门狗函数函数watchdog_write内，调用了watchdog_ping函数，而在watchdog_ping函数中最终是调用的S3c2410_wdt.c文件中的s3c2410wdt_keepalive函数来实现喂狗。在控制看门狗函数watchdog_ioctl内，实现了对看门狗的不同操作，如写看门狗、获得看门狗的状态、设置看门狗的定时时间等。

下面我们就开启看门狗的功能，并写一段应用程序来实现喂狗以防止系统复位。
开启看门狗，只需要在S3c2410_wdt.c文件内把CONFIG_S3C2410_WATCHDOG_ATBOOT改为1即可,
开启看门狗定时器中断，只需要在S3c2410_wdt.c文件内把CONFIG_S3C2410_WATCHDOG_INTEN改为1即可：

重新编译Linux后，在启动系统的过程中，则会打印下列信息：

这时，如果我们不实现喂狗功能的话，系统就会不断的复位重启。
下面就是实现喂狗的应用程序：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <linux/watchdog.h>

int main(int argc, char **argv)
{
    int fd;
    fd = open("/dev/watchdog",O_RDONLY);

    if(fd < 0){
        perror("/dev/watchdog");
        return -1;
    }

    for(;;){
        ioctl(fd, WDIOC_KEEPALIVE);
        sleep(5);
    }

    close(fd);
    return 0;
}

我们把上面程序编译成wdt文件，然后把它复制到根文件系统的bin目录下，再修改根文件系统的etc/init.d/rcS文件，在该文件的最后添加wdt &一句，即实现了在后台喂狗的功能。下面是rcS文件的内容：

#!/bin/sh
#This is the first script called by init process
mount -a
mkdir /dev/pts
mount -t devpts devpts /dev/pts
echo /sbin/mdev > /proc/sys/kernel/hotplug
mdev -s
wdt &

#/usr/sbin/vsftpd &
/usr/local/sbin/sshd
#/usr/local/libexec/sftp-server

/usr/sbin/telnetd &
/usr/sbin/vsftpd &

#cat /root/test/test.img > /dev/fb0

最后再重新编译根文件系统并烧写到开发板上。此时系统虽然开启了看门狗功能，但由于后台不断在喂狗，所以系统仍然可以正常运行。

其他函数

s3c2410wdt_start()

static int s3c2410wdt_start(struct watchdog_device *wdd)
{
	unsigned long wtcon;

	spin_lock(&wdt_lock);   //避免不多线程同时访问临界资源

	__s3c2410wdt_stop();    //先停止看门狗便于设置

	wtcon = readl(wdt_base + S3C2410_WTCON);
	wtcon |= S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128;
    /* 第5位允许看门狗工作          第3、4位设置为11，使用4相分频*/
    
	if (soft_noboot) {    //看门狗设置为定时器使用          
		wtcon |= S3C2410_WTCON_INTEN;   //使能中断
		wtcon &= ~S3C2410_WTCON_RSTEN;  //不允许发送复位信号
	} else {    //看门狗作为复位器使用
		wtcon &= ~S3C2410_WTCON_INTEN;  //禁止发出中断
		wtcon |= S3C2410_WTCON_RSTEN;   //允许发出复位信号
	}

	DBG("%s: wdt_count=0x%08x, wtcon=%08lx\n",
	    __func__, wdt_count, wtcon);

	writel(wdt_count, wdt_base + S3C2410_WTDAT);    //数据寄存器
	writel(wdt_count, wdt_base + S3C2410_WTCNT);    //计数寄存器
	writel(wtcon, wdt_base + S3C2410_WTCON);        //控制寄存器
	spin_unlock(&wdt_lock); //自旋锁解锁

	return 0;
}

s3c2410wdt_set_heartbeat()

static int s3c2410wdt_set_heartbeat(struct watchdog_device *wdd, unsigned timeout)
{
	unsigned long freq = clk_get_rate(wdt_clock);   //得到看门狗的时钟频率PCLK
	unsigned int count;         //将填入WTCNT的计数值
	unsigned int divisor = 1;   //要填入WTCON[15:8]的预分频系数
	unsigned long wtcon;        //暂存WTCON的值

	if (timeout < 1)    //看门狗的复位时间不能小于1s
		return -EINVAL;

	freq /= 128;    //看门狗默认使用128的4相分频
	count = timeout * freq; //计数值 = 秒*频率（每秒时钟滴答）

	DBG("%s: count=%d, timeout=%d, freq=%lu\n",
	    __func__, count, timeout, freq);

	/* if the count is bigger than the watchdog register,
	   then work out what we need to do (and if) we can
	   actually make this value
	*/

	if (count >= 0x10000) { //最终填入的计数值不能大于WTCNT的范围，
	                        //WTCNT是一个16位寄存器，其最大为0x10000
		for (divisor = 1; divisor <= 0x100; divisor++) {//从1到256，寻找一个合适的预分频系数
			if ((count / divisor) < 0x10000)    //找到则退出
				break;
		}

		if ((count / divisor) >= 0x10000) {//经过预分频和4相分频的计数值仍大于0x10000,
		                                   //则复位时间太长，看门狗不支持
			dev_err(wdt_dev, "timeout %d too big\n", timeout);
			return -EINVAL;
		}
	}

	DBG("%s: timeout=%d, divisor=%d, count=%d (%08x)\n",
	    __func__, timeout, divisor, count, count/divisor);

	count /= divisor;   //分频后最终的计数值
	wdt_count = count;

	/* update the pre-scaler */
	wtcon = readl(wdt_base + S3C2410_WTCON);
	wtcon &= ~S3C2410_WTCON_PRESCALE_MASK;  //将WTCNT的高8位清高
	wtcon |= S3C2410_WTCON_PRESCALE(divisor-1); //填入预分频系数

	writel(count, wdt_base + S3C2410_WTDAT);
	writel(wtcon, wdt_base + S3C2410_WTCON);

	wdd->timeout = (count * divisor) / freq;

	return 0;
}

watchdog_ioctl()

static long watchdog_ioctl(struct file *file, unsigned int cmd,
							unsigned long arg)
{
	struct watchdog_device *wdd = file->private_data;
	void __user *argp = (void __user *)arg;
	int __user *p = argp;
	unsigned int val;
	int err;

	err = watchdog_ioctl_op(wdd, cmd, arg);
	if (err != -ENOIOCTLCMD)
		return err;

	switch (cmd) {
	case WDIOC_GETSUPPORT:  //获取看门狗设备信息，在watchdog_info结构体中
		return copy_to_user(argp, wdd->info,
			sizeof(struct watchdog_info)) ? -EFAULT : 0;
	case WDIOC_GETSTATUS:   //和下面一个，获取看门狗状态，一般返回0
		err = watchdog_get_status(wdd, &val);
		if (err == -ENODEV)
			return err;
		return put_user(val, p);
	case WDIOC_GETBOOTSTATUS:
		return put_user(wdd->bootstatus, p);
	case WDIOC_SETOPTIONS:
		if (get_user(val, p))
			return -EFAULT;
		if (val & WDIOS_DISABLECARD) {
			err = watchdog_stop(wdd);
			if (err < 0)
				return err;
		}
		if (val & WDIOS_ENABLECARD) {
			err = watchdog_start(wdd);
			if (err < 0)
				return err;
		}
		return 0;
	case WDIOC_KEEPALIVE:   //对看门狗进行喂狗操作
		if (!(wdd->info->options & WDIOF_KEEPALIVEPING))
			return -EOPNOTSUPP;
		watchdog_ping(wdd);
		return 0;
	case WDIOC_SETTIMEOUT:  //用来设置看门狗的新超时时间，并返回旧超时时间，
	//使用get_user()函数从用户空间获得超时时间，并使用watchdog_set_timeout
	//函数设置新的超时时间，通过put_user()函数返回旧的超时时间
		if (get_user(val, p))
			return -EFAULT;
		err = watchdog_set_timeout(wdd, val);
		if (err < 0)
			return err;
		/* If the watchdog is active then we send a keepalive ping
		 * to make sure that the watchdog keep's running (and if
		 * possible that it takes the new timeout) */
		watchdog_ping(wdd);
		/* Fall */
	case WDIOC_GETTIMEOUT:  //获取当前的超时时间
		/* timeout == 0 means that we don't know the timeout */
		if (wdd->timeout == 0)
			return -EOPNOTSUPP;
		return put_user(wdd->timeout, p);
	case WDIOC_GETTIMELEFT:
		err = watchdog_get_timeleft(wdd, &val);
		if (err)
			return err;
		return put_user(val, p);
	default:
		return -ENOTTY;
	}
}