mini2440 watchdog支持

最新推荐文章于 2025-05-25 11:44:29 发布

mcgrady_tracy

最新推荐文章于 2025-05-25 11:44:29 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏： linux移植

本文链接：https://blog.youkuaiyun.com/mcgrady_tracy/article/details/37714731

linux移植专栏收录该内容

16 篇文章

订阅专栏

内核版本：linux-2.6.32.2 实验平台：mini2440

1. 平台设备定义：
s3c2440的watchdog平台设备定义如下（plat-s3c24xx/devs.c）：

/* Watchdog */

static struct resource s3c_wdt_resource[] = {
	[0] = {
		.start = S3C24XX_PA_WATCHDOG,
		.end   = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_WDT,
		.end   = IRQ_WDT,
		.flags = IORESOURCE_IRQ,
	}

};

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

EXPORT_SYMBOL(s3c_device_wdt);

现在我们将watchdog平台设备添加到mini2440_devices里面：

static struct platform_device *mini2440_devices[] __initdata = {
	/* ... */
	&s3c_device_wdt,
	/* ... */
};

2. 内核配置

    Device Drivers  --->
	[*] Watchdog Timer Support  --->
		<*>   S3C2410 Watchdog

3. s3c2440 watchdog驱动分析

3.1 watchdog 平台驱动注册
平台驱动定义如下：

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

在watchdog_init函数里面完成平台驱动的注册：

static int __init watchdog_init(void)
{
	/* ... */
	return platform_driver_register(&s3c2410wdt_driver);
}

注销在watchdog_exit函数里面：

static void __exit watchdog_exit(void)
{
	platform_driver_unregister(&s3c2410wdt_driver);
}

3.2 probe函数

首先是获取watchdog平台设备的IO地址资源，然后将这个物理地址映射成虚拟地址，这个虚拟地址的基地址保存在变量wdt_base中，代码如下：

        /* get the memory region for the watchdog timer */

        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (res == NULL) {
                dev_err(dev, "no memory resource specified\n");
                return -ENOENT;
        }

        size = (res->end - res->start) + 1;
        wdt_mem = request_mem_region(res->start, size, pdev->name);
        if (wdt_mem == NULL) {
                dev_err(dev, "failed to get memory region\n");
                ret = -ENOENT;
                goto err_req;
        }

        wdt_base = ioremap(res->start, size);
        if (wdt_base == NULL) {
                dev_err(dev, "failed to ioremap() region\n");
                ret = -EINVAL;
                goto err_req;
        }

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

然后是获取中断号资源信息并注册了一个中断处理函数，中断处理函数为s3c2410wdt_irq，代码如下：

        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_map;
        }

        ret = request_irq(wdt_irq->start, s3c2410wdt_irq, 0, pdev->name, pdev);
        if (ret != 0) {
                dev_err(dev, "failed to install irq (%d)\n", ret);
                goto err_map;
        }

获取watchdog的时钟源并启用它：

        wdt_clock = clk_get(&pdev->dev, "watchdog");
        if (IS_ERR(wdt_clock)) {
                dev_err(dev, "failed to find watchdog clock source\n");
                ret = PTR_ERR(wdt_clock);
                goto err_irq;
        }

        clk_enable(wdt_clock);

watchdog的时钟源是PCLK，此时假设它是50MHz。

接下来是设置watchdog的时钟：

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

        if (s3c2410wdt_set_heartbeat(tmr_margin)) {
                started = s3c2410wdt_set_heartbeat(
                                        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");
        }

watchdog的时钟源为PCLK，经预分频和128分频得到watchdog的时钟频率，而这个值是根据tmr_margin计算得来的，tmr_margin即超时时间，单位为秒，默认为15秒。

注册一个杂项设备，为应用程序提供接口：

        ret = misc_register(&s3c2410wdt_miscdev);
        if (ret) {
                dev_err(dev, "cannot register miscdev on minor=%d (%d)\n",
                        WATCHDOG_MINOR, ret);
                goto err_clk;
        }

根据tmr_atboot变量判断是否启动watchdog，如果为0，表示在执行probe函数时不启动watchdog，交由应用程序完成。如果为1，表示启动watchdog。

        if (tmr_atboot && started == 0) {
                dev_info(dev, "starting watchdog timer\n");
                s3c2410wdt_start();
        } 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();
        }

3.3 应用程序接口部分

杂项设备定义如下：

/* kernel interface */

static const struct file_operations s3c2410wdt_fops = {
	.owner          = THIS_MODULE,
	.llseek         = no_llseek,
	.write          = s3c2410wdt_write,
	.unlocked_ioctl = s3c2410wdt_ioctl,
	.open           = s3c2410wdt_open,
	.release        = s3c2410wdt_release,
};

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

3.3.1 open函数

/*
 *      /dev/watchdog handling
 */

static int s3c2410wdt_open(struct inode *inode, struct file *file)
{
	if (test_and_set_bit(0, &open_lock))
		return -EBUSY;

	if (nowayout)
		 __module_get(THIS_MODULE);

	expect_close = 0;

	/* start the timer */
	s3c2410wdt_start();
	return nonseekable_open(inode, file);
}

open函数用于启动watchdog。

s3c2410wdt_start代码如下：

static void s3c2410wdt_start(void)
{
	unsigned long wtcon;

	spin_lock(&wdt_lock);

	__s3c2410wdt_stop();

	wtcon = readl(wdt_base + S3C2410_WTCON);
	wtcon |= S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128;

	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);
}

首先调用 __s3c2410wdt_stop()函数停止watchdog，soft_noboot变量表示watchdog超时后是否交由软件来处理，如果为soft_noboot不为0，那么将使能中断和禁止watchdog超时产生复位信号，如果为0那么将禁止中断和使能watchdog超时产生复位信号。最后设置watchdog的WTDAT、WTCNT寄存器，使能watchdog定时器。

3.3.2 write函数

static ssize_t s3c2410wdt_write(struct file *file, const char __user *data,
		                size_t len, loff_t *ppos)
{
	/*
	 *      Refresh the timer.
	 */
	if (len) {
		if (!nowayout) {
			size_t i;

			/* In case it was set long ago */
			expect_close = 0;

			for (i = 0; i != len; i++) {
				char c;

				if (get_user(c, data + i))
					return -EFAULT;
				if (c == 'V')
					expect_close = 42;
			}
		}
		s3c2410wdt_keepalive();
	}
	return len;
}

nowayout表示应用程序在调用close系统调用时是否停止watchdog定时器，为0表示允许停止，否则不允许停止。最后调用s3c2410wdt_keepalive函数，俗称喂狗，代码如下：

static void s3c2410wdt_keepalive(void)
{
	spin_lock(&wdt_lock);
	writel(wdt_count, wdt_base + S3C2410_WTCNT);
	spin_unlock(&wdt_lock);
}

s3c2410wdt_keepalive函数即将WTCNT值设置为初始值。

3.3.3 ioctl函数

static long s3c2410wdt_ioctl(struct file *file, unsigned int cmd,
                                                        unsigned long arg)
{
        void __user *argp = (void __user *)arg;
        int __user *p = argp;
        int new_margin;

        switch (cmd) {
        case WDIOC_GETSUPPORT:
                return copy_to_user(argp, &s3c2410_wdt_ident,
                        sizeof(s3c2410_wdt_ident)) ? -EFAULT : 0;
        case WDIOC_GETSTATUS:
        case WDIOC_GETBOOTSTATUS:
                return put_user(0, p);
        case WDIOC_KEEPALIVE:
                s3c2410wdt_keepalive();
                return 0;
        case WDIOC_SETTIMEOUT:
                if (get_user(new_margin, p))
                        return -EFAULT;
                if (s3c2410wdt_set_heartbeat(new_margin))
                        return -EINVAL;
                s3c2410wdt_keepalive();
                return put_user(tmr_margin, p);
        case WDIOC_GETTIMEOUT:
                return put_user(tmr_margin, p);
        default:
                return -ENOTTY;
        }
}

ioctl有以下几个主要的命令：

OC_KEEPALIVE:		调用s3c2410wdt_keepalive函数进行喂狗操作。
WDIOC_SETTIMEOUT:	设置新的超时时间，并将老的超时时间（tmr_margin）返回。
WDIOC_GETTIMEOUT:	返回超时时间值。

3.3.4 release函数

static int s3c2410wdt_release(struct inode *inode, struct file *file)
{
	/*
	 *      Shut off the timer.
	 *      Lock it in if it's a module and we set nowayout
	 */

	if (expect_close == 42)
		s3c2410wdt_stop();
	else {
		dev_err(wdt_dev, "Unexpected close, not stopping watchdog\n");
		s3c2410wdt_keepalive();
	}
	expect_close = 0;
	clear_bit(0, &open_lock);
	return 0;
}

根据expect_close值决定是否停止watchdog定时器。

3.4 中断处理函数

/* interrupt handler code */

static irqreturn_t s3c2410wdt_irq(int irqno, void *param)
{
	dev_info(wdt_dev, "watchdog timer expired (irq)\n");

	s3c2410wdt_keepalive();
	return IRQ_HANDLED;
}

中断处理函数执行的喂狗操作。

4. watchdog实验

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(void)
{
	int fd;

	fd = open("/dev/watchdog", O_WRONLY);
	if (fd < 0)
		return -1;

	while (1);

	return 0;
}

在测试程序中，调用open函数之后将会启动watchdog，而由于没有执行任何的喂狗操作，系统将在15秒后重启。为了程序的正常运行，必须在15秒呢执行喂狗操作，例如：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

int main(void)
{
	int fd;
	char *food = "food";

	fd = open("/dev/watchdog", O_WRONLY);
	if (fd < 0)
		return -1;

	while (1) {
		write(fd, food, strlen(food));
		sleep(5);
	}

	return 0;
}

上面代码5秒钟执行一次喂狗操作，这样系统就不会在15秒后重启。