machzwd.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * MachZ ZF-Logic Watchdog Timer driver for Linux
  4. *
  5. * The author does NOT admit liability nor provide warranty for
  6. * any of this software. This material is provided "AS-IS" in
  7. * the hope that it may be useful for others.
  8. *
  9. * Author: Fernando Fuganti <fuganti@conectiva.com.br>
  10. *
  11. * Based on sbc60xxwdt.c by Jakob Oestergaard
  12. *
  13. * We have two timers (wd#1, wd#2) driven by a 32 KHz clock with the
  14. * following periods:
  15. * wd#1 - 2 seconds;
  16. * wd#2 - 7.2 ms;
  17. * After the expiration of wd#1, it can generate a NMI, SCI, SMI, or
  18. * a system RESET and it starts wd#2 that unconditionally will RESET
  19. * the system when the counter reaches zero.
  20. *
  21. * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
  22. * Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
  23. */
  24. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25. #include <linux/module.h>
  26. #include <linux/moduleparam.h>
  27. #include <linux/types.h>
  28. #include <linux/timer.h>
  29. #include <linux/jiffies.h>
  30. #include <linux/miscdevice.h>
  31. #include <linux/watchdog.h>
  32. #include <linux/fs.h>
  33. #include <linux/ioport.h>
  34. #include <linux/notifier.h>
  35. #include <linux/reboot.h>
  36. #include <linux/init.h>
  37. #include <linux/io.h>
  38. #include <linux/uaccess.h>
  39. /* ports */
  40. #define ZF_IOBASE 0x218
  41. #define INDEX 0x218
  42. #define DATA_B 0x219
  43. #define DATA_W 0x21A
  44. #define DATA_D 0x21A
  45. /* indexes */ /* size */
  46. #define ZFL_VERSION 0x02 /* 16 */
  47. #define CONTROL 0x10 /* 16 */
  48. #define STATUS 0x12 /* 8 */
  49. #define COUNTER_1 0x0C /* 16 */
  50. #define COUNTER_2 0x0E /* 8 */
  51. #define PULSE_LEN 0x0F /* 8 */
  52. /* controls */
  53. #define ENABLE_WD1 0x0001
  54. #define ENABLE_WD2 0x0002
  55. #define RESET_WD1 0x0010
  56. #define RESET_WD2 0x0020
  57. #define GEN_SCI 0x0100
  58. #define GEN_NMI 0x0200
  59. #define GEN_SMI 0x0400
  60. #define GEN_RESET 0x0800
  61. /* utilities */
  62. #define WD1 0
  63. #define WD2 1
  64. #define zf_writew(port, data) { outb(port, INDEX); outw(data, DATA_W); }
  65. #define zf_writeb(port, data) { outb(port, INDEX); outb(data, DATA_B); }
  66. #define zf_get_ZFL_version() zf_readw(ZFL_VERSION)
  67. static unsigned short zf_readw(unsigned char port)
  68. {
  69. outb(port, INDEX);
  70. return inw(DATA_W);
  71. }
  72. MODULE_AUTHOR("Fernando Fuganti <fuganti@conectiva.com.br>");
  73. MODULE_DESCRIPTION("MachZ ZF-Logic Watchdog driver");
  74. MODULE_LICENSE("GPL");
  75. static bool nowayout = WATCHDOG_NOWAYOUT;
  76. module_param(nowayout, bool, 0);
  77. MODULE_PARM_DESC(nowayout,
  78. "Watchdog cannot be stopped once started (default="
  79. __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  80. #define PFX "machzwd"
  81. static const struct watchdog_info zf_info = {
  82. .options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
  83. .firmware_version = 1,
  84. .identity = "ZF-Logic watchdog",
  85. };
  86. /*
  87. * action refers to action taken when watchdog resets
  88. * 0 = GEN_RESET
  89. * 1 = GEN_SMI
  90. * 2 = GEN_NMI
  91. * 3 = GEN_SCI
  92. * defaults to GEN_RESET (0)
  93. */
  94. static int action;
  95. module_param(action, int, 0);
  96. MODULE_PARM_DESC(action, "after watchdog resets, generate: "
  97. "0 = RESET(*) 1 = SMI 2 = NMI 3 = SCI");
  98. static void zf_ping(struct timer_list *unused);
  99. static int zf_action = GEN_RESET;
  100. static unsigned long zf_is_open;
  101. static char zf_expect_close;
  102. static DEFINE_SPINLOCK(zf_port_lock);
  103. static DEFINE_TIMER(zf_timer, zf_ping);
  104. static unsigned long next_heartbeat;
  105. /* timeout for user land heart beat (10 seconds) */
  106. #define ZF_USER_TIMEO (HZ*10)
  107. /* timeout for hardware watchdog (~500ms) */
  108. #define ZF_HW_TIMEO (HZ/2)
  109. /* number of ticks on WD#1 (driven by a 32KHz clock, 2s) */
  110. #define ZF_CTIMEOUT 0xffff
  111. #ifndef ZF_DEBUG
  112. #define dprintk(format, args...)
  113. #else
  114. #define dprintk(format, args...) \
  115. pr_debug(":%s:%d: " format, __func__, __LINE__ , ## args)
  116. #endif
  117. static inline void zf_set_status(unsigned char new)
  118. {
  119. zf_writeb(STATUS, new);
  120. }
  121. /* CONTROL register functions */
  122. static inline unsigned short zf_get_control(void)
  123. {
  124. return zf_readw(CONTROL);
  125. }
  126. static inline void zf_set_control(unsigned short new)
  127. {
  128. zf_writew(CONTROL, new);
  129. }
  130. /* WD#? counter functions */
  131. /*
  132. * Just set counter value
  133. */
  134. static inline void zf_set_timer(unsigned short new, unsigned char n)
  135. {
  136. switch (n) {
  137. case WD1:
  138. zf_writew(COUNTER_1, new);
  139. fallthrough;
  140. case WD2:
  141. zf_writeb(COUNTER_2, new > 0xff ? 0xff : new);
  142. default:
  143. return;
  144. }
  145. }
  146. /*
  147. * stop hardware timer
  148. */
  149. static void zf_timer_off(void)
  150. {
  151. unsigned int ctrl_reg = 0;
  152. unsigned long flags;
  153. /* stop internal ping */
  154. del_timer_sync(&zf_timer);
  155. spin_lock_irqsave(&zf_port_lock, flags);
  156. /* stop watchdog timer */
  157. ctrl_reg = zf_get_control();
  158. ctrl_reg |= (ENABLE_WD1|ENABLE_WD2); /* disable wd1 and wd2 */
  159. ctrl_reg &= ~(ENABLE_WD1|ENABLE_WD2);
  160. zf_set_control(ctrl_reg);
  161. spin_unlock_irqrestore(&zf_port_lock, flags);
  162. pr_info("Watchdog timer is now disabled\n");
  163. }
  164. /*
  165. * start hardware timer
  166. */
  167. static void zf_timer_on(void)
  168. {
  169. unsigned int ctrl_reg = 0;
  170. unsigned long flags;
  171. spin_lock_irqsave(&zf_port_lock, flags);
  172. zf_writeb(PULSE_LEN, 0xff);
  173. zf_set_timer(ZF_CTIMEOUT, WD1);
  174. /* user land ping */
  175. next_heartbeat = jiffies + ZF_USER_TIMEO;
  176. /* start the timer for internal ping */
  177. mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO);
  178. /* start watchdog timer */
  179. ctrl_reg = zf_get_control();
  180. ctrl_reg |= (ENABLE_WD1|zf_action);
  181. zf_set_control(ctrl_reg);
  182. spin_unlock_irqrestore(&zf_port_lock, flags);
  183. pr_info("Watchdog timer is now enabled\n");
  184. }
  185. static void zf_ping(struct timer_list *unused)
  186. {
  187. unsigned int ctrl_reg = 0;
  188. unsigned long flags;
  189. zf_writeb(COUNTER_2, 0xff);
  190. if (time_before(jiffies, next_heartbeat)) {
  191. dprintk("time_before: %ld\n", next_heartbeat - jiffies);
  192. /*
  193. * reset event is activated by transition from 0 to 1 on
  194. * RESET_WD1 bit and we assume that it is already zero...
  195. */
  196. spin_lock_irqsave(&zf_port_lock, flags);
  197. ctrl_reg = zf_get_control();
  198. ctrl_reg |= RESET_WD1;
  199. zf_set_control(ctrl_reg);
  200. /* ...and nothing changes until here */
  201. ctrl_reg &= ~(RESET_WD1);
  202. zf_set_control(ctrl_reg);
  203. spin_unlock_irqrestore(&zf_port_lock, flags);
  204. mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO);
  205. } else
  206. pr_crit("I will reset your machine\n");
  207. }
  208. static ssize_t zf_write(struct file *file, const char __user *buf, size_t count,
  209. loff_t *ppos)
  210. {
  211. /* See if we got the magic character */
  212. if (count) {
  213. /*
  214. * no need to check for close confirmation
  215. * no way to disable watchdog ;)
  216. */
  217. if (!nowayout) {
  218. size_t ofs;
  219. /*
  220. * note: just in case someone wrote the magic character
  221. * five months ago...
  222. */
  223. zf_expect_close = 0;
  224. /* now scan */
  225. for (ofs = 0; ofs != count; ofs++) {
  226. char c;
  227. if (get_user(c, buf + ofs))
  228. return -EFAULT;
  229. if (c == 'V') {
  230. zf_expect_close = 42;
  231. dprintk("zf_expect_close = 42\n");
  232. }
  233. }
  234. }
  235. /*
  236. * Well, anyhow someone wrote to us,
  237. * we should return that favour
  238. */
  239. next_heartbeat = jiffies + ZF_USER_TIMEO;
  240. dprintk("user ping at %ld\n", jiffies);
  241. }
  242. return count;
  243. }
  244. static long zf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  245. {
  246. void __user *argp = (void __user *)arg;
  247. int __user *p = argp;
  248. switch (cmd) {
  249. case WDIOC_GETSUPPORT:
  250. if (copy_to_user(argp, &zf_info, sizeof(zf_info)))
  251. return -EFAULT;
  252. break;
  253. case WDIOC_GETSTATUS:
  254. case WDIOC_GETBOOTSTATUS:
  255. return put_user(0, p);
  256. case WDIOC_KEEPALIVE:
  257. zf_ping(NULL);
  258. break;
  259. default:
  260. return -ENOTTY;
  261. }
  262. return 0;
  263. }
  264. static int zf_open(struct inode *inode, struct file *file)
  265. {
  266. if (test_and_set_bit(0, &zf_is_open))
  267. return -EBUSY;
  268. if (nowayout)
  269. __module_get(THIS_MODULE);
  270. zf_timer_on();
  271. return stream_open(inode, file);
  272. }
  273. static int zf_close(struct inode *inode, struct file *file)
  274. {
  275. if (zf_expect_close == 42)
  276. zf_timer_off();
  277. else {
  278. del_timer(&zf_timer);
  279. pr_err("device file closed unexpectedly. Will not stop the WDT!\n");
  280. }
  281. clear_bit(0, &zf_is_open);
  282. zf_expect_close = 0;
  283. return 0;
  284. }
  285. /*
  286. * Notifier for system down
  287. */
  288. static int zf_notify_sys(struct notifier_block *this, unsigned long code,
  289. void *unused)
  290. {
  291. if (code == SYS_DOWN || code == SYS_HALT)
  292. zf_timer_off();
  293. return NOTIFY_DONE;
  294. }
  295. static const struct file_operations zf_fops = {
  296. .owner = THIS_MODULE,
  297. .llseek = no_llseek,
  298. .write = zf_write,
  299. .unlocked_ioctl = zf_ioctl,
  300. .compat_ioctl = compat_ptr_ioctl,
  301. .open = zf_open,
  302. .release = zf_close,
  303. };
  304. static struct miscdevice zf_miscdev = {
  305. .minor = WATCHDOG_MINOR,
  306. .name = "watchdog",
  307. .fops = &zf_fops,
  308. };
  309. /*
  310. * The device needs to learn about soft shutdowns in order to
  311. * turn the timebomb registers off.
  312. */
  313. static struct notifier_block zf_notifier = {
  314. .notifier_call = zf_notify_sys,
  315. };
  316. static void __init zf_show_action(int act)
  317. {
  318. static const char * const str[] = { "RESET", "SMI", "NMI", "SCI" };
  319. pr_info("Watchdog using action = %s\n", str[act]);
  320. }
  321. static int __init zf_init(void)
  322. {
  323. int ret;
  324. pr_info("MachZ ZF-Logic Watchdog driver initializing\n");
  325. ret = zf_get_ZFL_version();
  326. if (!ret || ret == 0xffff) {
  327. pr_warn("no ZF-Logic found\n");
  328. return -ENODEV;
  329. }
  330. if (action <= 3 && action >= 0)
  331. zf_action = zf_action >> action;
  332. else
  333. action = 0;
  334. zf_show_action(action);
  335. if (!request_region(ZF_IOBASE, 3, "MachZ ZFL WDT")) {
  336. pr_err("cannot reserve I/O ports at %d\n", ZF_IOBASE);
  337. ret = -EBUSY;
  338. goto no_region;
  339. }
  340. ret = register_reboot_notifier(&zf_notifier);
  341. if (ret) {
  342. pr_err("can't register reboot notifier (err=%d)\n", ret);
  343. goto no_reboot;
  344. }
  345. ret = misc_register(&zf_miscdev);
  346. if (ret) {
  347. pr_err("can't misc_register on minor=%d\n", WATCHDOG_MINOR);
  348. goto no_misc;
  349. }
  350. zf_set_status(0);
  351. zf_set_control(0);
  352. return 0;
  353. no_misc:
  354. unregister_reboot_notifier(&zf_notifier);
  355. no_reboot:
  356. release_region(ZF_IOBASE, 3);
  357. no_region:
  358. return ret;
  359. }
  360. static void __exit zf_exit(void)
  361. {
  362. zf_timer_off();
  363. misc_deregister(&zf_miscdev);
  364. unregister_reboot_notifier(&zf_notifier);
  365. release_region(ZF_IOBASE, 3);
  366. }
  367. module_init(zf_init);
  368. module_exit(zf_exit);