新闻中心

EEPW首页 > 嵌入式系统 > 设计应用 > ARM-Linux驱动--Watch Dog Timer(看门狗)驱动分析

ARM-Linux驱动--Watch Dog Timer(看门狗)驱动分析

作者： 时间：2016-11-20 来源：网络
收藏
硬件平台：FL2440

内核版本：2.6.28

本文引用地址：https://www.eepw.com.cn/article/201611/318869.htm

主机平台：Ubuntu 11,04

内核版本：2.6.39

1、看门狗驱动的原理

下图是看门狗驱动的原理图

可以看出，PCLK是系统时钟，经过8位的预分频，然后再被分频（16、32、64、128）然后产生计数脉冲，进行计数，当计数器WTCNT加到0或减到0，然后产生中断，或引起系统复位。所以要隔一段时间，重置WTCNT的值，防止WTCNT减到0，称之“喂狗”。

2、驱动分析

下面是自己的驱动分析，如有理解错误，请指正

注，为了尽量是驱动容易理解，这个驱动暂时将有关电源管理的功能删除了，等理解透彻再完善

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #include
  9. #include
  10. #includeinterrupt.h>
  11. #include
  12. #include
  13. #include
  15. #include
  17. #include
  19. #undefS3C_VA_WATCHDOG
  20. #defineS3C_VA_WATCHDOG(0)
  22. #include
  24. #definePFX"s3c2410-wdt:"
  26. #defineCONFIG_S3C2410_WATCHDOG_ATBOOT(0)
  27. #defineCONFIG_S3C2410_WATCHDOG_DEFAULT_TIME(15)
  29. staticintnowayout=WATCHDOG_NOWAYOUT;
  30. staticinttmr_margin=CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME;
  31. staticinttmr_atboot=CONFIG_S3C2410_WATCHDOG_ATBOOT;
  32. staticintsoft_noboot=1;//设置默认为执行中断
  33. staticintdebug;
  34. staticintcount;//用于计数，控制LED灯的亮灭
  36. module_param(tmr_margin,int,0);
  37. module_param(tmr_atboot,int,0);
  38. module_param(nowayout,int,0);
  39. module_param(soft_noboot,int,0);
  40. module_param(debug,int,0);
  42. MODULE_PARM_DESC(tmr_margin,"Watchdogtmr_margininseconds.default="
  43. __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME)")");
  44. MODULE_PARM_DESC(tmr_atboot,
  45. "Watchdogisstartedatboottimeifsetto1,default="
  46. __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_ATBOOT));
  47. MODULE_PARM_DESC(nowayout,"Watchdogcannotbestoppedoncestarted(default="
  48. __MODULE_STRING(WATCHDOG_NOWAYOUT)")");
  49. MODULE_PARM_DESC(soft_noboot,"Watchdogaction,setto1toignorereboots,0to
  50. reboot(defaultdependsonONLY_TESTING)");
  51. MODULE_PARM_DESC(debug,"Watchdogdebug,setto>1fordebug,(default0)");
  54. typedefenumclose_state
  55. {
  56. CLOSE_STATE_NOT,
  57. CLOSE_STATE_ALLOW=0x4021
  58. }close_state_t;
  60. staticunsignedlongopen_lock;
  61. staticstructdevice*wdt_dev;/*platformdeviceattachedto*/
  62. staticstructresource*wdt_mem;//用来保存IO端口占用的内存资源
  63. staticstructresource*wdt_irq;//保存wdt中断号
  64. staticstructclk*wdt_clock;//保存从平台获取的watchdog时钟
  65. staticvoid__iomem*wdt_base;//经过ioremap后的内存基地址
  66. staticunsignedintwdt_count;//保存向WTCNT写的计数值
  67. staticclose_state_tallow_close;
  68. staticDEFINE_SPINLOCK(wdt_lock);//定义一个自旋锁，用于资源的互斥访问
  70. /*watchdogcontrolroutines*/
  72. #defineDBG(msg...)do{
  73. if(debug)
  74. printk(KERN_INFOmsg);
  75. }while(0)
  77. /*functions*/
  79. //喂狗函数，实际上是将wdt_count写入WTCNT寄存器
  80. staticvoids3c2410wdt_keepalive(void)
  81. {
  82. spin_lock(&wdt_lock);//给资源上锁
  83. writel(wdt_count,wdt_base+S3C2410_WTCNT);//写WTCNT寄存器
  84. spin_unlock(&wdt_lock);//解锁资源,下同
  85. }
  87. staticvoid__s3c2410wdt_stop(void)
  88. {
  89. unsignedlongwtcon;
  91. wtcon=readl(wdt_base+S3C2410_WTCON);
  92. wtcon&=~(S3C2410_WTCON_ENABLE|S3C2410_WTCON_RSTEN);
  93. writel(wtcon,wdt_base+S3C2410_WTCON);//设备看门狗使能无效、复位功能无效
  94. }
  95. //停止watchdog计时
  96. staticvoids3c2410wdt_stop(void)
  97. {
  98. spin_lock(&wdt_lock);
  99. __s3c2410wdt_stop();
  100. spin_unlock(&wdt_lock);
  101. }
  103. //启动watchdog计时
  104. staticvoids3c2410wdt_start(void)
  105. {
  106. unsignedlongwtcon;
  108. spin_lock(&wdt_lock);
  110. __s3c2410wdt_stop();
  112. wtcon=readl(wdt_base+S3C2410_WTCON);
  113. wtcon|=S3C2410_WTCON_ENABLE|S3C2410_WTCON_DIV128;//看门狗定时器使能、时钟除数因子128
  115. if(soft_noboot)//使用参数soft_noboot来选择看门狗到时是重启还是执行中断函数
  116. {
  117. wtcon|=S3C2410_WTCON_INTEN;//中断使能
  118. wtcon&=~S3C2410_WTCON_RSTEN;//复位功能无效
  119. }
  120. else
  121. {
  122. wtcon&=~S3C2410_WTCON_INTEN;//中断不使能
  123. wtcon|=S3C2410_WTCON_RSTEN;//复位功能有效
  124. }
  126. writel(wdt_count,wdt_base+S3C2410_WTDAT);//将wdt_count写入WTDAT
  127. writel(wdt_count,wdt_base+S3C2410_WTCNT);//将wdt_count写入WTCNT
  128. writel(wtcon,wdt_base+S3C2410_WTCON);//设置WTCON
  129. spin_unlock(&wdt_lock);
  130. }
  132. //设置WatchDog周期timeout
  133. staticints3c2410wdt_set_heartbeat(inttimeout)
  134. {
  135. unsignedintfreq=clk_get_rate(wdt_clock);
  136. unsignedintcount;
  137. unsignedintdivisor=1;
  138. unsignedlongwtcon;
  140. if(timeout<1)
  141. return-EINVAL;
  143. freq/=128;
  144. count=timeout*freq;
  146. /*ifthecountisbiggerthanthewatchdogregister,
  147. thenworkoutwhatweneedtodo(andif)wecan
  148. actuallymakethisvalue
  149. */
  150. //如果计时的时间过大，则适当加大预分频值
  151. if(count>=0x10000)
  152. {
  153. for(divisor=1;divisor<=0x100;divisor++)
  154. {
  155. if((count/divisor)<0x10000)
  156. break;
  157. }
  158. //若预分频最大仍不能满足计时周期，则报错
  159. if((count/divisor)>=0x10000)
  160. {
  161. dev_err(wdt_dev,"timeout%dtoobign",timeout);
  162. return-EINVAL;
  163. }
  164. }
  166. tmr_margin=timeout;
  168. count/=divisor;
  169. wdt_count=count;
  171. /*updatethepre-scaler*/
  172. wtcon=readl(wdt_base+S3C2410_WTCON);
  173. wtcon&=~S3C2410_WTCON_PRESCALE_MASK;
  174. wtcon|=S3C2410_WTCON_PRESCALE(divisor-1);
  176. writel(count,wdt_base+S3C2410_WTDAT);//是指WTDAT寄存器
  177. writel(wtcon,wdt_base+S3C2410_WTCON);//设置预分频值
  179. return0;
  180. }
  182. /*
  183. */dev/watchdoghandling
  184. */
  186. staticints3c2410wdt_open(structinode*inode,structfile*file)
  187. {
  188. if(test_and_set_bit(0,&open_lock))//测试并设置open_lock第0位为1
  189. return-EBUSY;
  190. if(nowayout)
  191. __module_get(THIS_MODULE);
  193. allow_close=CLOSE_STATE_NOT;
  195. /*startthetimer*/
  196. s3c2410wdt_start();//启动watchdog
  197. returnnonseekable_open(inode,file);
  198. }
  200. staticints3c2410wdt_release(structinode*inode,structfile*file)
  201. {
  202. /*
  203. *Shutoffthetimer.
  204. *Lockitinifitsamoduleandwesetnowayout
  205. */
  207. if(allow_close==CLOSE_STATE_ALLOW)
  208. s3c2410wdt_stop();
  209. else
  210. {
  211. dev_err(wdt_dev,"Unexpectedclose,notstoppingwatchdogn");
  212. s3c2410wdt_keepalive();
  213. }
  214. allow_close=CLOSE_STATE_NOT;
  215. clear_bit(0,&open_lock);//清楚open_lock第0位
  216. return0;
  217. }
  219. staticssize_ts3c2410wdt_write(structfile*file,constchar__user*data,
  220. size_tlen,loff_t*ppos)
  221. {
  222. /*
  223. *Refreshthetimer.
  224. */
  225. if(len)
  226. {
  227. if(!nowayout)
  228. {
  229. size_ti;
  230. /*Incaseitwassetlongago*/
  231. allow_close=CLOSE_STATE_NOT;
  233. for(i=0;i!=len;i++)
  234. {
  235. charc;
  236. if(get_user(c,data+i))//从用户空间copy数据
  237. return-EFAULT;
  238. if(c==V)//当输入V时，关闭watchdog
  239. allow_close=CLOSE_STATE_ALLOW;
  240. }
  241. }
  242. //注意：这里要手动喂狗一次?!
  243. s3c2410wdt_keepalive();//由于将allow_close设置成CLOSE_STATE_ALLOW后，当release时无法再次喂狗
  244. }
  245. returnlen;
  246. }
  248. #defineOPTIONSWDIOF_SETTIMEOUT|WDIOF_KEEPALIVEPING|WDIOF_MAGICCLOSE
  250. staticconststructwatchdog_infos3c2410_wdt_ident=
  251. {
  252. .options=OPTIONS,
  253. .firmware_version=0,
  254. .identity="S3C2410Watchdog",
  255. };
  257. //IO控制接口函数
  258. staticlongs3c2410wdt_ioctl(structfile*file,unsignedintcmd,
  259. unsignedlongarg)
  260. {
  261. void__user*argp=(void__user*)arg;
  262. int__user*p=argp;
  263. intnew_margin;
  265. switch(cmd){
  266. caseWDIOC_GETSUPPORT:
  267. returncopy_to_user(argp,&s3c2410_wdt_ident,
  268. sizeof(s3c2410_wdt_ident))?-EFAULT:0;
  269. caseWDIOC_GETSTATUS:
  270. caseWDIOC_GETBOOTSTATUS:
  271. returnput_user(0,p);
  272. caseWDIOC_KEEPALIVE:
  273. s3c2410wdt_keepalive();
  274. return0;
  275. caseWDIOC_SETTIMEOUT:
  276. if(get_user(new_margin,p))
  277. return-EFAULT;
  278. if(s3c2410wdt_set_heartbeat(new_margin))
  279. return-EINVAL;
  280. s3c2410wdt_keepalive();
  281. returnput_user(tmr_margin,p);
  282. caseWDIOC_GETTIMEOUT:
  283. returnput_user(tmr_margin,p);
  284. default:
  285. return-ENOTTY;
  286. }
  287. }
  289. /*kernelinterface*/
  291. //文件操作结构体
  292. staticconststructfile_operationss3c2410wdt_fops=
  293. {
  294. .owner=THIS_MODULE,
  295. .llseek=no_llseek,//屏蔽seek操作
  296. .write=s3c2410wdt_write,//写方法
  297. .unlocked_ioctl=s3c2410wdt_ioctl,//控制方法
  298. .open=s3c2410wdt_open,//代开设备方法
  299. .release=s3c2410wdt_release,//关闭设备方法
  300. };
  302. staticstructmiscdevices3c2410wdt_miscdev=
  303. {
  304. .minor=WATCHDOG_MINOR,
  305. .name="watchdog",
  306. .fops=&s3c2410wdt_fops,
  307. };
  309. /*interrupthandlercode*/
  311. staticirqreturn_ts3c2410wdt_irq(intirqno,void*param)
  312. {
  313. //dev_info(wdt_dev,"watchdogtimerexpired(irq)n");
  314. s3c2410_gpio_setpin(S3C2410_GPB10,(count++)%2);
  315. s3c2410wdt_keepalive();
  316. returnIRQ_HANDLED;
  317. }
  318. /*deviceinterface*/
  320. //注册设备时执行
  321. staticints3c2410wdt_probe(structplatform_device*pdev)
  322. {
  323. structresource*res;
  324. structdevice*dev;
  325. unsignedintwtcon;
  326. intstarted=0;
  327. intret;
  328. intsize;
  330. dev=&pdev->dev;
  331. wdt_dev=&pdev->dev;
  333. /*getthememoryregionforthewatchdogtimer*/
  334. //获取IO端口资源，这里IORESOURCE_MEM和平台设备中资源的定义一致
  335. res=platform_get_resource(pdev,IORESOURCE_MEM,0);
  336. if(res==NULL){
  337. dev_err(dev,"nomemoryresourcespecifiedn");
  338. return-ENOENT;
  339. }
  341. size=(res->end-res->start)+1;
  342. //申请内存空间
  343. wdt_mem=request_mem_region(res->start,size,pdev->name);
  344. if(wdt_mem==NULL){
  345. dev_err(dev,"failedtogetmemoryregionn");
  346. ret=-ENOENT;
  347. gotoerr_req;
  348. }
  349. //地址映射，wdt_base为基地址
  350. wdt_base=ioremap(res->start,size);
  351. if(wdt_base==NULL){
  352. dev_err(dev,"failedtoioremap()regionn");
  353. ret=-EINVAL;
  354. gotoerr_req;
  355. }
  357. DBG("probe:mappedwdt_base=%pn",wdt_base);
  358. //从平台设备中获取中断号
  359. wdt_irq=platform_get_resource(pdev,IORESOURCE_IRQ,0);
  360. if(wdt_irq==NULL){
  361. dev_err(dev,"noirqresourcespecifiedn");
  362. ret=-ENOENT;
  363. gotoerr_map;
  364. }
  365. //注册中断，中断处理函数s3c2410wdt_irq()
  366. ret=request_irq(wdt_irq->start,s3c2410wdt_irq,0,pdev->name,pdev);
  367. if(ret!=0){
  368. dev_err(dev,"failedtoinstallirq(%d)n",ret);
  369. gotoerr_map;
  370. }
  371. //获取系统时钟
  372. wdt_clock=clk_get(&pdev->dev,"watchdog");
  373. if(IS_ERR(wdt_clock)){
  374. dev_err(dev,"failedtofindwatchdogclocksourcen");
  375. ret=PTR_ERR(wdt_clock);
  376. gotoerr_irq;
  377. }
  378. //使能时钟
  379. clk_enable(wdt_clock);
  381. /*seeifwecanactuallysettherequestedtimermargin,andif
  382. *not,trythedefaultvalue*/
  384. if(s3c2410wdt_set_heartbeat(tmr_margin))
  385. {//这里第一次设置计时周期为tmr_margin，如果设置不成功，则重新设置为默认值
  386. started=s3c2410wdt_set_heartbeat(
  387. CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
  389. if(started==0)
  390. dev_info(dev,
  391. "tmr_marginvalueoutofrange,default%dusedn",
  392. CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
  393. else
  394. dev_info(dev,"defaulttimervalueisoutofrange,cannotstartn");
  395. }
  396. //注册设备
  397. ret=misc_register(&s3c2410wdt_miscdev);
  398. if(ret)
  399. {
  400. dev_err(dev,"cannotregistermiscdevonminor=%d(%d)n",
  401. WATCHDOG_MINOR,ret);
  402. gotoerr_clk;
  403. }
  405. if(tmr_atboot&&started==0)
  406. {
  407. dev_info(dev,"startingwatchdogtimern");
  408. s3c2410wdt_start();//启动看门狗
  409. }
  410. elseif(!tmr_atboot)
  411. {
  412. /*ifwerenotenablingthewatchdog,thenensureitis
  413. *disabledifithasbeenleftrunningfromthebootloader
  414. *orothersource*/
  415. s3c2410wdt_stop();
  416. }
  418. /*printoutastatementofreadiness*/
  420. wtcon=readl(wdt_base+S3C2410_WTCON);
  422. dev_info(dev,"watchdog%sactive,reset%sabled,irq%sabledn",
  423. (wtcon&S3C2410_WTCON_ENABLE)?"":"in",
  424. (wtcon&S3C2410_WTCON_RSTEN)?"":"dis",
  425. (wtcon&S3C2410_WTCON_INTEN)?"":"en");
  426. //设置GPB10端口为输出端口，用于点亮LED10
  427. s3c2410_gpio_cfgpin(S3C2410_GPB10,S3C2410_GPB10_OUTP);
  428. return0;
  430. //出错跳转表，异常处理
  432. err_clk:
  433. clk_disable(wdt_clock);
  434. clk_put(wdt_clock);
  436. err_irq:
  437. free_irq(wdt_irq->start,pdev);
  439. err_map:
  440. iounmap(wdt_base);
  442. err_req:
  443. release_resource(wdt_mem);
  444. kfree(wdt_mem);
  446. returnret;
  447. }
  449. //设备移除函数，释放资源和映射
  450. staticints3c2410wdt_remove(structplatform_device*dev)
  451. {
  452. release_resource(wdt_mem);
  453. kfree(wdt_mem);
  454. wdt_mem=NULL;
  456. free_irq(wdt_irq->start,dev);
  457. wdt_irq=NULL;
  459. clk_disable(wdt_clock);
  460. clk_put(wdt_clock);
  461. wdt_clock=NULL;
  463. iounmap(wdt_base);
  464. misc_deregister(&s3c2410wdt_miscdev);
  465. return0;
  466. }
  468. //关闭看门狗
  469. staticvoids3c2410wdt_shutdown(structplatform_device*dev)
  470. {
  471. s3c2410wdt_stop();
  472. }
  474. //定义平台设备驱动
  475. staticstructplatform_drivers3c2410wdt_driver={
  476. .probe=s3c2410wdt_probe,
  477. .remove=s3c2410wdt_remove,
  478. .shutdown=s3c2410wdt_shutdown,
  479. .driver={
  480. .owner=THIS_MODULE,
  481. .name="s3c2410-wdt",//该名称参照内核源码中该资源的名称，两者必须一致
  482. },
  483. };
  486. staticcharbanner[]__initdata=
  487. KERN_INFO"S3C2410WatchdogTimer,(c)2004SimtecElectronicsn";
  489. //驱动安装时执行
  490. staticint__initwatchdog_init(void)
  491. {
  492. printk(banner);
  493. returnplatform_driver_register(&s3c2410wdt_driver);//注册设备
  494. }
  496. //驱动移除是执行
  497. staticvoid__exitwatchdog_exit(void)
  498. {
  499. platform_driver_unregister(&s3c2410wdt_driver);//移除设备
  500. }
  502. module_init(watchdog_init);
  503. module_exit(watchdog_exit);
  505. MODULE_AUTHOR("YanMing");
  506. MODULE_DESCRIPTION("S3C2410WatchdogDeviceDriver");
  507. MODULE_LICENSE("GPL");
  508. MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

设置默认不是重启机器，而是执行中断函数，当不喂狗，计数器减到0，点亮LED，然后喂狗，重新计数。

关键词： ARMLinux驱动看门

评论


相关推荐

技术专区

关闭