欢迎访问电子工程网!   登录 | 免费注册 ]   

yd2763132的个人空间 http://www.eechina.com/space-uid-36266.html [收藏] [复制] [分享] [RSS]

博客

2410看门狗驱动程序

已有 387 次阅读2011-5-12 19:53 |个人分类:linux| 关键词:

#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 <ben@simtec.co.uk>, "
       "Dimitry Andric <dimitry.andric@tomtom.com>");
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文件。
 
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/yd4330152763132/archive/2010/02/01/5275728.aspx

路过

鸡蛋

鲜花

握手

雷人

评论 (0 个评论)

facelist

您需要登录后才可以评论 登录 | 立即注册

回顶部