新聞中心

EEPW首頁 > 嵌入式系統(tǒng) > 設(shè)計應(yīng)用 > ARM-Linux驅(qū)動--Watch Dog Timer(看門狗)驅(qū)動分析

ARM-Linux驅(qū)動--Watch Dog Timer(看門狗)驅(qū)動分析

作者： 時間：2016-11-20 來源：網(wǎng)絡(luò) 收藏
硬件平臺：FL2440

內(nèi)核版本：2.6.28

本文引用地址：http://butianyuan.cn/article/201611/318869.htm

主機平臺：Ubuntu 11,04

內(nèi)核版本：2.6.39

1、看門狗驅(qū)動的原理

下圖是看門狗驅(qū)動的原理圖

可以看出，PCLK是系統(tǒng)時鐘，經(jīng)過8位的預(yù)分頻，然后再被分頻（16、32、64、128）然后產(chǎn)生計數(shù)脈沖，進行計數(shù)，當計數(shù)器WTCNT加到0或減到0，然后產(chǎn)生中斷，或引起系統(tǒng)復(fù)位。所以要隔一段時間，重置WTCNT的值，防止WTCNT減到0，稱之“喂狗”。

2、驅(qū)動分析

下面是自己的驅(qū)動分析，如有理解錯誤，請指正

注，為了盡量是驅(qū)動容易理解，這個驅(qū)動暫時將有關(guān)電源管理的功能刪除了，等理解透徹再完善

  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;//設(shè)置默認為執(zhí)行中斷
  33. staticintdebug;
  34. staticintcount;//用于計數(shù)，控制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端口占用的內(nèi)存資源
  63. staticstructresource*wdt_irq;//保存wdt中斷號
  64. staticstructclk*wdt_clock;//保存從平臺獲取的watchdog時鐘
  65. staticvoid__iomem*wdt_base;//經(jīng)過ioremap后的內(nèi)存基地址
  66. staticunsignedintwdt_count;//保存向WTCNT寫的計數(shù)值
  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. //喂狗函數(shù)，實際上是將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);//設(shè)備看門狗使能無效、復(fù)位功能無效
  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;//看門狗定時器使能、時鐘除數(shù)因子128
  115. if(soft_noboot)//使用參數(shù)soft_noboot來選擇看門狗到時是重啟還是執(zhí)行中斷函數(shù)
  116. {
  117. wtcon|=S3C2410_WTCON_INTEN;//中斷使能
  118. wtcon&=~S3C2410_WTCON_RSTEN;//復(fù)位功能無效
  119. }
  120. else
  121. {
  122. wtcon&=~S3C2410_WTCON_INTEN;//中斷不使能
  123. wtcon|=S3C2410_WTCON_RSTEN;//復(fù)位功能有效
  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);//設(shè)置WTCON
  129. spin_unlock(&wdt_lock);
  130. }
  132. //設(shè)置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. //如果計時的時間過大，則適當加大預(yù)分頻值
  151. if(count>=0x10000)
  152. {
  153. for(divisor=1;divisor<=0x100;divisor++)
  154. {
  155. if((count/divisor)<0x10000)
  156. break;
  157. }
  158. //若預(yù)分頻最大仍不能滿足計時周期，則報錯
  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);//設(shè)置預(yù)分頻值
  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))//測試并設(shè)置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數(shù)據(jù)
  237. return-EFAULT;
  238. if(c==V)//當輸入V時，關(guān)閉watchdog
  239. allow_close=CLOSE_STATE_ALLOW;
  240. }
  241. }
  242. //注意：這里要手動喂狗一次?!
  243. s3c2410wdt_keepalive();//由于將allow_close設(shè)置成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控制接口函數(shù)
  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. //文件操作結(jié)構(gòu)體
  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,//代開設(shè)備方法
  299. .release=s3c2410wdt_release,//關(guān)閉設(shè)備方法
  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. //注冊設(shè)備時執(zhí)行
  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和平臺設(shè)備中資源的定義一致
  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. //申請內(nèi)存空間
  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. //從平臺設(shè)備中獲取中斷號
  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. //注冊中斷，中斷處理函數(shù)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. //獲取系統(tǒng)時鐘
  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. {//這里第一次設(shè)置計時周期為tmr_margin，如果設(shè)置不成功，則重新設(shè)置為默認值
  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. //注冊設(shè)備
  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. //設(shè)置GPB10端口為輸出端口，用于點亮LED10
  427. s3c2410_gpio_cfgpin(S3C2410_GPB10,S3C2410_GPB10_OUTP);
  428. return0;
  430. //出錯跳轉(zhuǎn)表，異常處理
  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. //設(shè)備移除函數(shù)，釋放資源和映射
  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. //關(guān)閉看門狗
  469. staticvoids3c2410wdt_shutdown(structplatform_device*dev)
  470. {
  471. s3c2410wdt_stop();
  472. }
  474. //定義平臺設(shè)備驅(qū)動
  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",//該名稱參照內(nèi)核源碼中該資源的名稱，兩者必須一致
  482. },
  483. };
  486. staticcharbanner[]__initdata=
  487. KERN_INFO"S3C2410WatchdogTimer,(c)2004SimtecElectronicsn";
  489. //驅(qū)動安裝時執(zhí)行
  490. staticint__initwatchdog_init(void)
  491. {
  492. printk(banner);
  493. returnplatform_driver_register(&s3c2410wdt_driver);//注冊設(shè)備
  494. }
  496. //驅(qū)動移除是執(zhí)行
  497. staticvoid__exitwatchdog_exit(void)
  498. {
  499. platform_driver_unregister(&s3c2410wdt_driver);//移除設(shè)備
  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);

設(shè)置默認不是重啟機器，而是執(zhí)行中斷函數(shù)，當不喂狗，計數(shù)器減到0，點亮LED，然后喂狗，重新計數(shù)。

關(guān)鍵詞： ARMLinux驅(qū)動看門

評論


技術(shù)專區(qū)

關(guān)閉