sc520_wdt.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447
  1. /*
  2. * AMD Elan SC520 processor Watchdog Timer driver
  3. *
  4. * Based on acquirewdt.c by Alan Cox,
  5. * and sbc60xxwdt.c by Jakob Oestergaard <jakob@unthought.net>
  6. *
  7. * This program is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License
  9. * as published by the Free Software Foundation; either version
  10. * 2 of the License, or (at your option) any later version.
  11. *
  12. * The authors do NOT admit liability nor provide warranty for
  13. * any of this software. This material is provided "AS-IS" in
  14. * the hope that it may be useful for others.
  15. *
  16. * (c) Copyright 2001 Scott Jennings <linuxdrivers@oro.net>
  17. * 9/27 - 2001 [Initial release]
  18. *
  19. * Additional fixes Alan Cox
  20. * - Fixed formatting
  21. * - Removed debug printks
  22. * - Fixed SMP built kernel deadlock
  23. * - Switched to private locks not lock_kernel
  24. * - Used ioremap/writew/readw
  25. * - Added NOWAYOUT support
  26. * 4/12 - 2002 Changes by Rob Radez <rob@osinvestor.com>
  27. * - Change comments
  28. * - Eliminate fop_llseek
  29. * - Change CONFIG_WATCHDOG_NOWAYOUT semantics
  30. * - Add KERN_* tags to printks
  31. * - fix possible wdt_is_open race
  32. * - Report proper capabilities in watchdog_info
  33. * - Add WDIOC_{GETSTATUS, GETBOOTSTATUS, SETTIMEOUT,
  34. * GETTIMEOUT, SETOPTIONS} ioctls
  35. * 09/8 - 2003 Changes by Wim Van Sebroeck <wim@iguana.be>
  36. * - cleanup of trailing spaces
  37. * - added extra printk's for startup problems
  38. * - use module_param
  39. * - made timeout (the emulated heartbeat) a module_param
  40. * - made the keepalive ping an internal subroutine
  41. * 3/27 - 2004 Changes by Sean Young <sean@mess.org>
  42. * - set MMCR_BASE to 0xfffef000
  43. * - CBAR does not need to be read
  44. * - removed debugging printks
  45. *
  46. * This WDT driver is different from most other Linux WDT
  47. * drivers in that the driver will ping the watchdog by itself,
  48. * because this particular WDT has a very short timeout (1.6
  49. * seconds) and it would be insane to count on any userspace
  50. * daemon always getting scheduled within that time frame.
  51. *
  52. * This driver uses memory mapped IO, and spinlock.
  53. */
  54. #include <linux/module.h>
  55. #include <linux/moduleparam.h>
  56. #include <linux/types.h>
  57. #include <linux/timer.h>
  58. #include <linux/miscdevice.h>
  59. #include <linux/watchdog.h>
  60. #include <linux/fs.h>
  61. #include <linux/ioport.h>
  62. #include <linux/notifier.h>
  63. #include <linux/reboot.h>
  64. #include <linux/init.h>
  65. #include <asm/io.h>
  66. #include <asm/uaccess.h>
  67. #include <asm/system.h>
  68. #define OUR_NAME "sc520_wdt"
  69. #define PFX OUR_NAME ": "
  70. /*
  71. * The AMD Elan SC520 timeout value is 492us times a power of 2 (0-7)
  72. *
  73. * 0: 492us 2: 1.01s 4: 4.03s 6: 16.22s
  74. * 1: 503ms 3: 2.01s 5: 8.05s 7: 32.21s
  75. *
  76. * We will program the SC520 watchdog for a timeout of 2.01s.
  77. * If we reset the watchdog every ~250ms we should be safe.
  78. */
  79. #define WDT_INTERVAL (HZ/4+1)
  80. /*
  81. * We must not require too good response from the userspace daemon.
  82. * Here we require the userspace daemon to send us a heartbeat
  83. * char to /dev/watchdog every 30 seconds.
  84. */
  85. #define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */
  86. static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
  87. module_param(timeout, int, 0);
  88. MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
  89. #ifdef CONFIG_WATCHDOG_NOWAYOUT
  90. static int nowayout = 1;
  91. #else
  92. static int nowayout = 0;
  93. #endif
  94. module_param(nowayout, int, 0);
  95. MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
  96. /*
  97. * AMD Elan SC520 - Watchdog Timer Registers
  98. */
  99. #define MMCR_BASE 0xfffef000 /* The default base address */
  100. #define OFFS_WDTMRCTL 0xCB0 /* Watchdog Timer Control Register */
  101. /* WDT Control Register bit definitions */
  102. #define WDT_EXP_SEL_01 0x0001 /* [01] Time-out = 496 us (with 33 Mhz clk). */
  103. #define WDT_EXP_SEL_02 0x0002 /* [02] Time-out = 508 ms (with 33 Mhz clk). */
  104. #define WDT_EXP_SEL_03 0x0004 /* [03] Time-out = 1.02 s (with 33 Mhz clk). */
  105. #define WDT_EXP_SEL_04 0x0008 /* [04] Time-out = 2.03 s (with 33 Mhz clk). */
  106. #define WDT_EXP_SEL_05 0x0010 /* [05] Time-out = 4.07 s (with 33 Mhz clk). */
  107. #define WDT_EXP_SEL_06 0x0020 /* [06] Time-out = 8.13 s (with 33 Mhz clk). */
  108. #define WDT_EXP_SEL_07 0x0040 /* [07] Time-out = 16.27s (with 33 Mhz clk). */
  109. #define WDT_EXP_SEL_08 0x0080 /* [08] Time-out = 32.54s (with 33 Mhz clk). */
  110. #define WDT_IRQ_FLG 0x1000 /* [12] Interrupt Request Flag */
  111. #define WDT_WRST_ENB 0x4000 /* [14] Watchdog Timer Reset Enable */
  112. #define WDT_ENB 0x8000 /* [15] Watchdog Timer Enable */
  113. static __u16 __iomem *wdtmrctl;
  114. static void wdt_timer_ping(unsigned long);
  115. static struct timer_list timer;
  116. static unsigned long next_heartbeat;
  117. static unsigned long wdt_is_open;
  118. static char wdt_expect_close;
  119. static spinlock_t wdt_spinlock;
  120. /*
  121. * Whack the dog
  122. */
  123. static void wdt_timer_ping(unsigned long data)
  124. {
  125. /* If we got a heartbeat pulse within the WDT_US_INTERVAL
  126. * we agree to ping the WDT
  127. */
  128. if(time_before(jiffies, next_heartbeat))
  129. {
  130. /* Ping the WDT */
  131. spin_lock(&wdt_spinlock);
  132. writew(0xAAAA, wdtmrctl);
  133. writew(0x5555, wdtmrctl);
  134. spin_unlock(&wdt_spinlock);
  135. /* Re-set the timer interval */
  136. timer.expires = jiffies + WDT_INTERVAL;
  137. add_timer(&timer);
  138. } else {
  139. printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
  140. }
  141. }
  142. /*
  143. * Utility routines
  144. */
  145. static void wdt_config(int writeval)
  146. {
  147. __u16 dummy;
  148. unsigned long flags;
  149. /* buy some time (ping) */
  150. spin_lock_irqsave(&wdt_spinlock, flags);
  151. dummy=readw(wdtmrctl); /* ensure write synchronization */
  152. writew(0xAAAA, wdtmrctl);
  153. writew(0x5555, wdtmrctl);
  154. /* unlock WDT = make WDT configuration register writable one time */
  155. writew(0x3333, wdtmrctl);
  156. writew(0xCCCC, wdtmrctl);
  157. /* write WDT configuration register */
  158. writew(writeval, wdtmrctl);
  159. spin_unlock_irqrestore(&wdt_spinlock, flags);
  160. }
  161. static int wdt_startup(void)
  162. {
  163. next_heartbeat = jiffies + (timeout * HZ);
  164. /* Start the timer */
  165. timer.expires = jiffies + WDT_INTERVAL;
  166. add_timer(&timer);
  167. /* Start the watchdog */
  168. wdt_config(WDT_ENB | WDT_WRST_ENB | WDT_EXP_SEL_04);
  169. printk(KERN_INFO PFX "Watchdog timer is now enabled.\n");
  170. return 0;
  171. }
  172. static int wdt_turnoff(void)
  173. {
  174. /* Stop the timer */
  175. del_timer(&timer);
  176. /* Stop the watchdog */
  177. wdt_config(0);
  178. printk(KERN_INFO PFX "Watchdog timer is now disabled...\n");
  179. return 0;
  180. }
  181. static int wdt_keepalive(void)
  182. {
  183. /* user land ping */
  184. next_heartbeat = jiffies + (timeout * HZ);
  185. return 0;
  186. }
  187. static int wdt_set_heartbeat(int t)
  188. {
  189. if ((t < 1) || (t > 3600)) /* arbitrary upper limit */
  190. return -EINVAL;
  191. timeout = t;
  192. return 0;
  193. }
  194. /*
  195. * /dev/watchdog handling
  196. */
  197. static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
  198. {
  199. /* See if we got the magic character 'V' and reload the timer */
  200. if(count) {
  201. if (!nowayout) {
  202. size_t ofs;
  203. /* note: just in case someone wrote the magic character
  204. * five months ago... */
  205. wdt_expect_close = 0;
  206. /* now scan */
  207. for(ofs = 0; ofs != count; ofs++) {
  208. char c;
  209. if (get_user(c, buf + ofs))
  210. return -EFAULT;
  211. if(c == 'V')
  212. wdt_expect_close = 42;
  213. }
  214. }
  215. /* Well, anyhow someone wrote to us, we should return that favour */
  216. wdt_keepalive();
  217. }
  218. return count;
  219. }
  220. static int fop_open(struct inode * inode, struct file * file)
  221. {
  222. nonseekable_open(inode, file);
  223. /* Just in case we're already talking to someone... */
  224. if(test_and_set_bit(0, &wdt_is_open))
  225. return -EBUSY;
  226. if (nowayout)
  227. __module_get(THIS_MODULE);
  228. /* Good, fire up the show */
  229. wdt_startup();
  230. return 0;
  231. }
  232. static int fop_close(struct inode * inode, struct file * file)
  233. {
  234. if(wdt_expect_close == 42) {
  235. wdt_turnoff();
  236. } else {
  237. printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
  238. wdt_keepalive();
  239. }
  240. clear_bit(0, &wdt_is_open);
  241. wdt_expect_close = 0;
  242. return 0;
  243. }
  244. static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
  245. unsigned long arg)
  246. {
  247. void __user *argp = (void __user *)arg;
  248. int __user *p = argp;
  249. static struct watchdog_info ident = {
  250. .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
  251. .firmware_version = 1,
  252. .identity = "SC520",
  253. };
  254. switch(cmd)
  255. {
  256. default:
  257. return -ENOIOCTLCMD;
  258. case WDIOC_GETSUPPORT:
  259. return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
  260. case WDIOC_GETSTATUS:
  261. case WDIOC_GETBOOTSTATUS:
  262. return put_user(0, p);
  263. case WDIOC_KEEPALIVE:
  264. wdt_keepalive();
  265. return 0;
  266. case WDIOC_SETOPTIONS:
  267. {
  268. int new_options, retval = -EINVAL;
  269. if(get_user(new_options, p))
  270. return -EFAULT;
  271. if(new_options & WDIOS_DISABLECARD) {
  272. wdt_turnoff();
  273. retval = 0;
  274. }
  275. if(new_options & WDIOS_ENABLECARD) {
  276. wdt_startup();
  277. retval = 0;
  278. }
  279. return retval;
  280. }
  281. case WDIOC_SETTIMEOUT:
  282. {
  283. int new_timeout;
  284. if(get_user(new_timeout, p))
  285. return -EFAULT;
  286. if(wdt_set_heartbeat(new_timeout))
  287. return -EINVAL;
  288. wdt_keepalive();
  289. /* Fall through */
  290. }
  291. case WDIOC_GETTIMEOUT:
  292. return put_user(timeout, p);
  293. }
  294. }
  295. static struct file_operations wdt_fops = {
  296. .owner = THIS_MODULE,
  297. .llseek = no_llseek,
  298. .write = fop_write,
  299. .open = fop_open,
  300. .release = fop_close,
  301. .ioctl = fop_ioctl,
  302. };
  303. static struct miscdevice wdt_miscdev = {
  304. .minor = WATCHDOG_MINOR,
  305. .name = "watchdog",
  306. .fops = &wdt_fops,
  307. };
  308. /*
  309. * Notifier for system down
  310. */
  311. static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
  312. void *unused)
  313. {
  314. if(code==SYS_DOWN || code==SYS_HALT)
  315. wdt_turnoff();
  316. return NOTIFY_DONE;
  317. }
  318. /*
  319. * The WDT needs to learn about soft shutdowns in order to
  320. * turn the timebomb registers off.
  321. */
  322. static struct notifier_block wdt_notifier = {
  323. .notifier_call = wdt_notify_sys,
  324. };
  325. static void __exit sc520_wdt_unload(void)
  326. {
  327. if (!nowayout)
  328. wdt_turnoff();
  329. /* Deregister */
  330. misc_deregister(&wdt_miscdev);
  331. unregister_reboot_notifier(&wdt_notifier);
  332. iounmap(wdtmrctl);
  333. }
  334. static int __init sc520_wdt_init(void)
  335. {
  336. int rc = -EBUSY;
  337. spin_lock_init(&wdt_spinlock);
  338. init_timer(&timer);
  339. timer.function = wdt_timer_ping;
  340. timer.data = 0;
  341. /* Check that the timeout value is within it's range ; if not reset to the default */
  342. if (wdt_set_heartbeat(timeout)) {
  343. wdt_set_heartbeat(WATCHDOG_TIMEOUT);
  344. printk(KERN_INFO PFX "timeout value must be 1<=timeout<=3600, using %d\n",
  345. WATCHDOG_TIMEOUT);
  346. }
  347. wdtmrctl = ioremap((unsigned long)(MMCR_BASE + OFFS_WDTMRCTL), 2);
  348. if (!wdtmrctl) {
  349. printk(KERN_ERR PFX "Unable to remap memory\n");
  350. rc = -ENOMEM;
  351. goto err_out_region2;
  352. }
  353. rc = register_reboot_notifier(&wdt_notifier);
  354. if (rc) {
  355. printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
  356. rc);
  357. goto err_out_ioremap;
  358. }
  359. rc = misc_register(&wdt_miscdev);
  360. if (rc) {
  361. printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
  362. WATCHDOG_MINOR, rc);
  363. goto err_out_notifier;
  364. }
  365. printk(KERN_INFO PFX "WDT driver for SC520 initialised. timeout=%d sec (nowayout=%d)\n",
  366. timeout,nowayout);
  367. return 0;
  368. err_out_notifier:
  369. unregister_reboot_notifier(&wdt_notifier);
  370. err_out_ioremap:
  371. iounmap(wdtmrctl);
  372. err_out_region2:
  373. return rc;
  374. }
  375. module_init(sc520_wdt_init);
  376. module_exit(sc520_wdt_unload);
  377. MODULE_AUTHOR("Scott and Bill Jennings");
  378. MODULE_DESCRIPTION("Driver for watchdog timer in AMD \"Elan\" SC520 uProcessor");
  379. MODULE_LICENSE("GPL");
  380. MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);