2410看门狗驱动程序
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/timer.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/clk.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/arch-s3c2410/map.h>
#undef S3C24XX_VA_WATCHDOG
#define S3C24XX_VA_WATCHDOG (0)
#include <asm/arch-s3c2410/regs-watchdog.h>
#define PFX "s3c2410-wdt: "
#define CONFIG_S3C2410_WATCHDOG_ATBOOT (0)
#define CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME (15)
static int nowayout = WATCHDOG_NOWAYOUT;//CONFIG_WATCHDOG_NOWAYOUT’设为‘Y’, 缺省情况下watchdog启动后不能被停止
static int tmr_margin = CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME;
static int tmr_atboot = CONFIG_S3C2410_WATCHDOG_ATBOOT;//要想上电使能看门狗必须该为1,使用默认值
static int soft_noboot = 0;//该为1时，看门狗为一般定时器
static int debug = 0;//调式模式
module_param(tmr_margin, int, 0);//0表示该参数不存在读写权限，故而在sys/module/paraments目录
module_param(tmr_atboot, int, 0);
module_param(nowayout, int, 0);
module_param(soft_noboot, int, 0);
module_param(debug, int, 0);
MODULE_PARM_DESC(tmr_margin, "Watchdog tmr_margin in seconds. default=" __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME) ")");//参数描述
MODULE_PARM_DESC(tmr_atboot, "Watchdog is started at boot time if set to 1, default=" __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_ATBOOT));
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
MODULE_PARM_DESC(soft_noboot, "Watchdog action, set to 1 to ignore reboots, 0 to reboot (default depends on ONLY_TESTING)");
MODULE_PARM_DESC(debug, "Watchdog debug, set to >1 for debug, (default 0)");
typedef enum close_state {
CLOSE_STATE_NOT,
CLOSE_STATE_ALLOW=0x4021
} close_state_t;
static DECLARE_MUTEX(open_lock);
static struct resource *wdt_mem;
static struct resource *wdt_irq;
static struct clk *wdt_clock;
static void __iomem *wdt_base;
static unsigned int wdt_count;
static close_state_t allow_close;
/* watchdog control routines */
#define DBG(msg...) do { /
if (debug) /
printk(KERN_INFO msg); /
} while(0)
/* functions */
static int s3c2410wdt_keepalive(void)//喂狗
{
writel(wdt_count, wdt_base + S3C2410_WTCNT);
return 0;
}
static int s3c2410wdt_stop(void)
{
unsigned long wtcon;
wtcon = readl(wdt_base + S3C2410_WTCON);
wtcon &= ~(S3C2410_WTCON_ENABLE | S3C2410_WTCON_RSTEN);
writel(wtcon, wdt_base + S3C2410_WTCON);
return 0;
}
static int s3c2410wdt_start(void)
{
unsigned long wtcon;
s3c2410wdt_stop();
wtcon = readl(wdt_base + S3C2410_WTCON);
wtcon |= S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128;
if (soft_noboot) {
wtcon |= S3C2410_WTCON_INTEN;//该为1时，看门狗为一般定时器产生中断
wtcon &= ~S3C2410_WTCON_RSTEN;//重启无效
} else {
wtcon &= ~S3C2410_WTCON_INTEN;//默认为可复位
wtcon |= S3C2410_WTCON_RSTEN;
}
DBG("%s: wdt_count=0x%08x, wtcon=%08lx/n",
__FUNCTION__, wdt_count, wtcon);
writel(wdt_count, wdt_base + S3C2410_WTDAT);
writel(wdt_count, wdt_base + S3C2410_WTCNT);
writel(wtcon, wdt_base + S3C2410_WTCON);
return 0;
}
static int s3c2410wdt_set_heartbeat(int timeout)//将Prescaler Value=0，将WTDAT清零
{
unsigned int freq = clk_get_rate(wdt_clock);
unsigned int count;
unsigned int divisor = 1;
unsigned long wtcon;
if (timeout < 1)
return -EINVAL;
freq /= 128;//0
count = timeout * freq;//0
DBG("%s: count=%d, timeout=%d, freq=%d/n",
__FUNCTION__, 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) {//count值超过65536
for (divisor = 1; divisor <= 0x100; divisor++) {
if ((count / divisor) < 0x10000)
break;
}
if ((count / divisor) >= 0x10000) {
printk(KERN_ERR PFX "timeout %d too big/n", timeout);
return -EINVAL;
}
}
tmr_margin = timeout;
DBG("%s: timeout=%d, divisor=%d, count=%d (%08x)/n",
__FUNCTION__, timeout, divisor, count, count/divisor);
count /= divisor;//0
wdt_count = count;//0
/* update the pre-scaler */
wtcon = readl(wdt_base + S3C2410_WTCON);
wtcon &= ~S3C2410_WTCON_PRESCALE_MASK;
wtcon |= S3C2410_WTCON_PRESCALE(divisor-1);//Prescaler Value=0
writel(count, wdt_base + S3C2410_WTDAT);//将WTDAT清零
writel(wtcon, wdt_base + S3C2410_WTCON);//Prescaler Value=0
return 0;
}
/*
* /dev/watchdog handling
*/
static int s3c2410wdt_open(struct inode *inode, struct file *file)
{
if(down_trylock(&open_lock))//非阻塞
return -EBUSY;
if (nowayout) {//内核配置CONFIG_WATCHDOG_NOWAYOUT
__module_get(THIS_MODULE);//模块使用次数加1
} else {
allow_close = CLOSE_STATE_ALLOW;//不配置CONFIG_WATCHDOG_NOWAYOUT，在close中可关闭看门狗
}
/* start the timer */
s3c2410wdt_start();
return nonseekable_open(inode, file);//标识了给定的 filp 为不可移位的; 不允许调用lseek
}
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 (allow_close == CLOSE_STATE_ALLOW) {
s3c2410wdt_stop();//不配置CONFIG_WATCHDOG_NOWAYOUT，可以关闭
} else {
printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!/n");
s3c2410wdt_keepalive();
}
allow_close = CLOSE_STATE_NOT;
up(&open_lock);
return 0;
}
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) {//不配置CONFIG_WATCHDOG_NOWAYOUT
size_t i;
/* In case it was set long ago */
allow_close = CLOSE_STATE_NOT;
for (i = 0; i != len; i++) {
char c;
if (get_user(c, data + i))
return -EFAULT;
if (c == 'V')//写入字符 V容许关闭看门狗，但前提还是不配置CONFIG_WATCHDOG_NOWAYOUT
allow_close = CLOSE_STATE_ALLOW;
}
}
s3c2410wdt_keepalive();//喂狗
}
return len;
}
#define OPTIONS WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE //处理命令
static struct watchdog_info s3c2410_wdt_ident = {
.options = OPTIONS,
.firmware_version = 0,
.identity = "S3C2410 Watchdog",
};
static int s3c2410wdt_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
void __user *argp = (void __user *)arg;
int __user *p = argp;
int new_margin;
switch (cmd) {
default:
return -ENOIOCTLCMD;
case WDIOC_GETSUPPORT://获取看门狗信息
return copy_to_user(argp, &s3c2410_wdt_ident,
sizeof(s3c2410_wdt_ident)) ? -EFAULT : 0;//此时读入argp中，即应用程序的第3个参数地址中
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))//设置到tcn中
return -EINVAL;
s3c2410wdt_keepalive();//喂狗
return put_user(tmr_margin, p);
case WDIOC_GETTIMEOUT://读取默认溢出时间（秒）
return put_user(tmr_margin, p);
}
}
/* kernel interface */
static struct file_operations s3c2410wdt_fops = {//应用程序调用，只有一层驱动较rtc简单一些
.owner = THIS_MODULE,
.llseek = no_llseek,//定义为不可移文件
.write = s3c2410wdt_write,
.ioctl = s3c2410wdt_ioctl,
.open = s3c2410wdt_open,
.release = s3c2410wdt_release,
};
static struct miscdevice s3c2410wdt_miscdev = {
.minor = WATCHDOG_MINOR,//静态给与
.name = "watchdog",
.fops = &s3c2410wdt_fops,
};
/* interrupt handler code */
static irqreturn_t s3c2410wdt_irq(int irqno, void *param,//中断只是在禁止复位时才有效
struct pt_regs *regs)
{
printk(KERN_INFO PFX "Watchdog timer expired!/n");
s3c2410wdt_keepalive();//喂狗
return IRQ_HANDLED;
}
/* device interface */
static int s3c2410wdt_probe(struct platform_device *pdev)//设置Prescaler Value 清零WTDAT 注册杂项设备
{
struct resource *res;
int started = 0;
int ret;
int size;
DBG("%s: probe=%p/n", __FUNCTION__, pdev);
/* get the memory region for the watchdog timer */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);//在数珠中查找resource地址，第一个IORESOURCE_MEM
if (res == NULL) {
printk(KERN_INFO PFX "failed to get memory region resouce/n");
return -ENOENT;
}
size = (res->end-res->start)+1;
wdt_mem = request_mem_region(res->start, size, pdev->name);//申请IO内存
if (wdt_mem == NULL) {
printk(KERN_INFO PFX "failed to get memory region/n");
return -ENOENT;
}
wdt_base = ioremap(res->start, size);//动态映射虚拟地址
if (wdt_base == 0) {
printk(KERN_INFO PFX "failed to ioremap() region/n");
return -EINVAL;
}
DBG("probe: mapped wdt_base=%p/n", wdt_base);
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);//在数珠中查找resource地址，第一个IORESOURCE_IRQ
if (res == NULL) {
printk(KERN_INFO PFX "failed to get irq resource/n");
return -ENOENT;
}
ret = request_irq(res->start, s3c2410wdt_irq, 0, pdev->name, pdev);//申请中断资源
if (ret != 0) {
printk(KERN_INFO PFX "failed to install irq (%d)/n", ret);
return ret;
}
wdt_clock = clk_get(&pdev->dev, "watchdog");//从clock链表中获取watchdog clk结构体
if (wdt_clock == NULL) {
printk(KERN_INFO PFX "failed to find watchdog clock source/n");
return -ENOENT;
}
clk_enable(wdt_clock);//打开看门狗clk
/* 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) {
printk(KERN_INFO PFX "tmr_margin value out of range, default %d used/n",
CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
} else {
printk(KERN_INFO PFX "default timer value is out of range, cannot start/n");
}
}
ret = misc_register(&s3c2410wdt_miscdev);//注册
if (ret) {
printk (KERN_ERR PFX "cannot register miscdev on minor=%d (%d)/n",
WATCHDOG_MINOR, ret);
return ret;
}
if (tmr_atboot && started == 0) {//要使用看门狗必须将模块参数tmr_atboot改为1
printk(KERN_INFO PFX "Starting Watchdog Timer/n");
s3c2410wdt_start();
}
return 0;
}
static int s3c2410wdt_remove(struct platform_device *dev)
{
if (wdt_mem != NULL) {
//iounmap(wdt_base);应该加上
release_resource(wdt_mem);//注销IO内存
kfree(wdt_mem);//释放内存
wdt_mem = NULL;
}
if (wdt_irq != NULL) {
free_irq(wdt_irq->start, dev);//释放中断源
wdt_irq = NULL;
}
if (wdt_clock != NULL) {
clk_disable(wdt_clock);//关闭wdt clock
clk_put(wdt_clock);//使用次数减1
wdt_clock = NULL;
}
misc_deregister(&s3c2410wdt_miscdev);
return 0;
}
static void s3c2410wdt_shutdown(struct platform_device *dev)
{
s3c2410wdt_stop();
}
#ifdef CONFIG_PM
static unsigned long wtcon_save;
static unsigned long wtdat_save;
static int s3c2410wdt_suspend(struct platform_device *dev, pm_message_t state)
{
/* Save watchdog state, and turn it off. */
wtcon_save = readl(wdt_base + S3C2410_WTCON);
wtdat_save = readl(wdt_base + S3C2410_WTDAT);
/* Note that WTCNT doesn't need to be saved. */
s3c2410wdt_stop();
return 0;
}
static int s3c2410wdt_resume(struct platform_device *dev)
{
/* Restore watchdog state. */
writel(wtdat_save, wdt_base + S3C2410_WTDAT);
writel(wtdat_save, wdt_base + S3C2410_WTCNT); /* Reset count */
writel(wtcon_save, wdt_base + S3C2410_WTCON);
printk(KERN_INFO PFX "watchdog %sabled/n",
(wtcon_save & S3C2410_WTCON_ENABLE) ? "en" : "dis");
return 0;
｝
#else
#define s3c2410wdt_suspend NULL
#define s3c2410wdt_resume NULL
#endif /* CONFIG_PM */
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 = "s3c2410-wdt",
},
};
static char banner[] __initdata = KERN_INFO "S3C2410 Watchdog Timer, (c) 2004 Simtec Electronics/n";
static int __init watchdog_init(void)
{
printk(banner);
return platform_driver_register(&s3c2410wdt_driver);//注册平台设备
}
static void __exit watchdog_exit(void)
{
platform_driver_unregister(&s3c2410wdt_driver);
}
module_init(watchdog_init);
module_exit(watchdog_exit);
MODULE_AUTHOR("Ben Dooks <[email protected]>, "
"Dimitry Andric <[email protected]>");
MODULE_DESCRIPTION("S3C2410 Watchdog Device Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);}
平台设备watchdog
看门狗不像RTC有一个忽略硬件的公共层，其只有一层结构即杂项设备结构，应用层直接与杂项设备文件打交道。其开发流程与RTC类似，只是有几个参数需要注意。
nowayout：与CONFIG_WATCHDOG_NOWAYOUT配置相关，其一旦配置应用层调用close函数将不能关闭看门狗；
tmr_margin：默认的喂狗时间；
tmr_atboot：要想系统一上电自动使能看门狗，就为1。最好使用0，由于我们想通过open函数来打开看门狗；
soft_noboot：为1时看门狗将作为一般的中断定时器使用，为0时作为可复位电路的看门狗，默认为0；
应用程序中调用open打开看门狗后，如果再写入非”V”调用close将不能关闭看门狗。即只有写入”V”后才能关闭看门狗设备。可以参考wdt_test.c文件。