David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 1 | /* |
David Hardeman | abda5c8 | 2005-09-01 22:34:53 +0200 | [diff] [blame] | 2 | * i6300esb: Watchdog timer driver for Intel 6300ESB chipset |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 3 | * |
| 4 | * (c) Copyright 2004 Google Inc. |
Jan Engelhardt | 96de0e2 | 2007-10-19 23:21:04 +0200 | [diff] [blame] | 5 | * (c) Copyright 2005 David Härdeman <david@2gen.com> |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 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 | * |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 12 | * based on i810-tco.c which is in turn based on softdog.c |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 13 | * |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 14 | * The timer is implemented in the following I/O controller hubs: |
| 15 | * (See the intel documentation on http://developer.intel.com.) |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 16 | * 6300ESB chip : document number 300641-004 |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 17 | * |
| 18 | * 2004YYZZ Ross Biro |
| 19 | * Initial version 0.01 |
| 20 | * 2004YYZZ Ross Biro |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 21 | * Version 0.02 |
Jan Engelhardt | 96de0e2 | 2007-10-19 23:21:04 +0200 | [diff] [blame] | 22 | * 20050210 David Härdeman <david@2gen.com> |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 23 | * Ported driver to kernel 2.6 |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 24 | */ |
| 25 | |
| 26 | /* |
| 27 | * Includes, defines, variables, module parameters, ... |
| 28 | */ |
| 29 | |
| 30 | #include <linux/module.h> |
| 31 | #include <linux/types.h> |
| 32 | #include <linux/kernel.h> |
| 33 | #include <linux/fs.h> |
| 34 | #include <linux/mm.h> |
| 35 | #include <linux/miscdevice.h> |
| 36 | #include <linux/watchdog.h> |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 37 | #include <linux/init.h> |
| 38 | #include <linux/pci.h> |
| 39 | #include <linux/ioport.h> |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 40 | #include <linux/uaccess.h> |
| 41 | #include <linux/io.h> |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 42 | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 43 | /* Module and version information */ |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 44 | #define ESB_VERSION "0.05" |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 45 | #define ESB_MODULE_NAME "i6300ESB timer" |
| 46 | #define ESB_DRIVER_NAME ESB_MODULE_NAME ", v" ESB_VERSION |
| 47 | #define PFX ESB_MODULE_NAME ": " |
| 48 | |
David Hardeman | abda5c8 | 2005-09-01 22:34:53 +0200 | [diff] [blame] | 49 | /* PCI configuration registers */ |
| 50 | #define ESB_CONFIG_REG 0x60 /* Config register */ |
| 51 | #define ESB_LOCK_REG 0x68 /* WDT lock register */ |
| 52 | |
| 53 | /* Memory mapped registers */ |
Wim Van Sebroeck | bd4e6c1 | 2009-03-25 19:20:10 +0000 | [diff] [blame] | 54 | #define ESB_TIMER1_REG (BASEADDR + 0x00)/* Timer1 value after each reset */ |
| 55 | #define ESB_TIMER2_REG (BASEADDR + 0x04)/* Timer2 value after each reset */ |
| 56 | #define ESB_GINTSR_REG (BASEADDR + 0x08)/* General Interrupt Status Register */ |
| 57 | #define ESB_RELOAD_REG (BASEADDR + 0x0c)/* Reload register */ |
David Hardeman | abda5c8 | 2005-09-01 22:34:53 +0200 | [diff] [blame] | 58 | |
| 59 | /* Lock register bits */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 60 | #define ESB_WDT_FUNC (0x01 << 2) /* Watchdog functionality */ |
| 61 | #define ESB_WDT_ENABLE (0x01 << 1) /* Enable WDT */ |
| 62 | #define ESB_WDT_LOCK (0x01 << 0) /* Lock (nowayout) */ |
David Hardeman | abda5c8 | 2005-09-01 22:34:53 +0200 | [diff] [blame] | 63 | |
| 64 | /* Config register bits */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 65 | #define ESB_WDT_REBOOT (0x01 << 5) /* Enable reboot on timeout */ |
| 66 | #define ESB_WDT_FREQ (0x01 << 2) /* Decrement frequency */ |
Wim Van Sebroeck | 39f3be7 | 2010-03-08 11:02:38 +0000 | [diff] [blame] | 67 | #define ESB_WDT_INTTYPE (0x03 << 0) /* Interrupt type on timer1 timeout */ |
David Hardeman | abda5c8 | 2005-09-01 22:34:53 +0200 | [diff] [blame] | 68 | |
| 69 | /* Reload register bits */ |
Wim Van Sebroeck | 31838d9d | 2009-03-25 19:14:45 +0000 | [diff] [blame] | 70 | #define ESB_WDT_TIMEOUT (0x01 << 9) /* Watchdog timed out */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 71 | #define ESB_WDT_RELOAD (0x01 << 8) /* prevent timeout */ |
David Hardeman | abda5c8 | 2005-09-01 22:34:53 +0200 | [diff] [blame] | 72 | |
| 73 | /* Magic constants */ |
| 74 | #define ESB_UNLOCK1 0x80 /* Step 1 to unlock reset registers */ |
| 75 | #define ESB_UNLOCK2 0x86 /* Step 2 to unlock reset registers */ |
| 76 | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 77 | /* internal variables */ |
| 78 | static void __iomem *BASEADDR; |
Alexey Dobriyan | c7dfd0c | 2007-11-01 16:27:08 -0700 | [diff] [blame] | 79 | static DEFINE_SPINLOCK(esb_lock); /* Guards the hardware */ |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 80 | static unsigned long timer_alive; |
| 81 | static struct pci_dev *esb_pci; |
| 82 | static unsigned short triggered; /* The status of the watchdog upon boot */ |
| 83 | static char esb_expect_close; |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 84 | |
| 85 | /* We can only use 1 card due to the /dev/watchdog restriction */ |
| 86 | static int cards_found; |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 87 | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 88 | /* module parameters */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 89 | /* 30 sec default heartbeat (1 < heartbeat < 2*1023) */ |
| 90 | #define WATCHDOG_HEARTBEAT 30 |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 91 | static int heartbeat = WATCHDOG_HEARTBEAT; /* in seconds */ |
| 92 | module_param(heartbeat, int, 0); |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 93 | MODULE_PARM_DESC(heartbeat, |
| 94 | "Watchdog heartbeat in seconds. (1<heartbeat<2046, default=" |
| 95 | __MODULE_STRING(WATCHDOG_HEARTBEAT) ")"); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 96 | |
Naveen Gupta | 811f999 | 2005-08-21 13:02:41 +0200 | [diff] [blame] | 97 | static int nowayout = WATCHDOG_NOWAYOUT; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 98 | module_param(nowayout, int, 0); |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 99 | MODULE_PARM_DESC(nowayout, |
| 100 | "Watchdog cannot be stopped once started (default=" |
| 101 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 102 | |
| 103 | /* |
| 104 | * Some i6300ESB specific functions |
| 105 | */ |
| 106 | |
| 107 | /* |
| 108 | * Prepare for reloading the timer by unlocking the proper registers. |
| 109 | * This is performed by first writing 0x80 followed by 0x86 to the |
| 110 | * reload register. After this the appropriate registers can be written |
| 111 | * to once before they need to be unlocked again. |
| 112 | */ |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 113 | static inline void esb_unlock_registers(void) |
| 114 | { |
Wim Van Sebroeck | 39f3be7 | 2010-03-08 11:02:38 +0000 | [diff] [blame] | 115 | writew(ESB_UNLOCK1, ESB_RELOAD_REG); |
| 116 | writew(ESB_UNLOCK2, ESB_RELOAD_REG); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 117 | } |
| 118 | |
Wim Van Sebroeck | 3b9d49e | 2009-03-23 13:50:38 +0000 | [diff] [blame] | 119 | static int esb_timer_start(void) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 120 | { |
| 121 | u8 val; |
| 122 | |
Wim Van Sebroeck | 3b9d49e | 2009-03-23 13:50:38 +0000 | [diff] [blame] | 123 | spin_lock(&esb_lock); |
| 124 | esb_unlock_registers(); |
| 125 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 126 | /* Enable or Enable + Lock? */ |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 127 | val = ESB_WDT_ENABLE | (nowayout ? ESB_WDT_LOCK : 0x00); |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 128 | pci_write_config_byte(esb_pci, ESB_LOCK_REG, val); |
Wim Van Sebroeck | 3b9d49e | 2009-03-23 13:50:38 +0000 | [diff] [blame] | 129 | spin_unlock(&esb_lock); |
| 130 | return 0; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | static int esb_timer_stop(void) |
| 134 | { |
| 135 | u8 val; |
| 136 | |
| 137 | spin_lock(&esb_lock); |
| 138 | /* First, reset timers as suggested by the docs */ |
| 139 | esb_unlock_registers(); |
Naveen Gupta | ce2f50b | 2005-08-17 09:11:46 +0200 | [diff] [blame] | 140 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 141 | /* Then disable the WDT */ |
| 142 | pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x0); |
| 143 | pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val); |
| 144 | spin_unlock(&esb_lock); |
| 145 | |
| 146 | /* Returns 0 if the timer was disabled, non-zero otherwise */ |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 147 | return val & ESB_WDT_ENABLE; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | static void esb_timer_keepalive(void) |
| 151 | { |
| 152 | spin_lock(&esb_lock); |
| 153 | esb_unlock_registers(); |
Naveen Gupta | ce2f50b | 2005-08-17 09:11:46 +0200 | [diff] [blame] | 154 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 155 | /* FIXME: Do we need to flush anything here? */ |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 156 | spin_unlock(&esb_lock); |
| 157 | } |
| 158 | |
| 159 | static int esb_timer_set_heartbeat(int time) |
| 160 | { |
| 161 | u32 val; |
| 162 | |
| 163 | if (time < 0x1 || time > (2 * 0x03ff)) |
| 164 | return -EINVAL; |
| 165 | |
| 166 | spin_lock(&esb_lock); |
| 167 | |
| 168 | /* We shift by 9, so if we are passed a value of 1 sec, |
| 169 | * val will be 1 << 9 = 512, then write that to two |
| 170 | * timers => 2 * 512 = 1024 (which is decremented at 1KHz) |
| 171 | */ |
| 172 | val = time << 9; |
| 173 | |
| 174 | /* Write timer 1 */ |
| 175 | esb_unlock_registers(); |
| 176 | writel(val, ESB_TIMER1_REG); |
| 177 | |
| 178 | /* Write timer 2 */ |
| 179 | esb_unlock_registers(); |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 180 | writel(val, ESB_TIMER2_REG); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 181 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 182 | /* Reload */ |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 183 | esb_unlock_registers(); |
Naveen Gupta | ce2f50b | 2005-08-17 09:11:46 +0200 | [diff] [blame] | 184 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 185 | |
| 186 | /* FIXME: Do we need to flush everything out? */ |
| 187 | |
| 188 | /* Done */ |
| 189 | heartbeat = time; |
| 190 | spin_unlock(&esb_lock); |
| 191 | return 0; |
| 192 | } |
| 193 | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 194 | /* |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 195 | * /dev/watchdog handling |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 196 | */ |
| 197 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 198 | static int esb_open(struct inode *inode, struct file *file) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 199 | { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 200 | /* /dev/watchdog can only be opened once */ |
| 201 | if (test_and_set_bit(0, &timer_alive)) |
| 202 | return -EBUSY; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 203 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 204 | /* Reload and activate timer */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 205 | esb_timer_start(); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 206 | |
| 207 | return nonseekable_open(inode, file); |
| 208 | } |
| 209 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 210 | static int esb_release(struct inode *inode, struct file *file) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 211 | { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 212 | /* Shut off the timer. */ |
| 213 | if (esb_expect_close == 42) |
| 214 | esb_timer_stop(); |
| 215 | else { |
| 216 | printk(KERN_CRIT PFX |
| 217 | "Unexpected close, not stopping watchdog!\n"); |
| 218 | esb_timer_keepalive(); |
| 219 | } |
| 220 | clear_bit(0, &timer_alive); |
| 221 | esb_expect_close = 0; |
| 222 | return 0; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 223 | } |
| 224 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 225 | static ssize_t esb_write(struct file *file, const char __user *data, |
| 226 | size_t len, loff_t *ppos) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 227 | { |
| 228 | /* See if we got the magic character 'V' and reload the timer */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 229 | if (len) { |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 230 | if (!nowayout) { |
| 231 | size_t i; |
| 232 | |
| 233 | /* note: just in case someone wrote the magic character |
| 234 | * five months ago... */ |
| 235 | esb_expect_close = 0; |
| 236 | |
Wim Van Sebroeck | 143a2e5 | 2009-03-18 08:35:09 +0000 | [diff] [blame] | 237 | /* scan to see whether or not we got the |
| 238 | * magic character */ |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 239 | for (i = 0; i != len; i++) { |
| 240 | char c; |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 241 | if (get_user(c, data + i)) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 242 | return -EFAULT; |
| 243 | if (c == 'V') |
| 244 | esb_expect_close = 42; |
| 245 | } |
| 246 | } |
| 247 | |
| 248 | /* someone wrote to us, we should reload the timer */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 249 | esb_timer_keepalive(); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 250 | } |
| 251 | return len; |
| 252 | } |
| 253 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 254 | static long esb_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 255 | { |
| 256 | int new_options, retval = -EINVAL; |
| 257 | int new_heartbeat; |
| 258 | void __user *argp = (void __user *)arg; |
| 259 | int __user *p = argp; |
Wim Van Sebroeck | 42747d7 | 2009-12-26 18:55:22 +0000 | [diff] [blame] | 260 | static const struct watchdog_info ident = { |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 261 | .options = WDIOF_SETTIMEOUT | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 262 | WDIOF_KEEPALIVEPING | |
| 263 | WDIOF_MAGICCLOSE, |
Wim Van Sebroeck | 7944d3a | 2008-08-06 20:19:41 +0000 | [diff] [blame] | 264 | .firmware_version = 0, |
| 265 | .identity = ESB_MODULE_NAME, |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 266 | }; |
| 267 | |
| 268 | switch (cmd) { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 269 | case WDIOC_GETSUPPORT: |
| 270 | return copy_to_user(argp, &ident, |
| 271 | sizeof(ident)) ? -EFAULT : 0; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 272 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 273 | case WDIOC_GETSTATUS: |
Wim Van Sebroeck | 31838d9d | 2009-03-25 19:14:45 +0000 | [diff] [blame] | 274 | return put_user(0, p); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 275 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 276 | case WDIOC_GETBOOTSTATUS: |
| 277 | return put_user(triggered, p); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 278 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 279 | case WDIOC_SETOPTIONS: |
| 280 | { |
| 281 | if (get_user(new_options, p)) |
| 282 | return -EFAULT; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 283 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 284 | if (new_options & WDIOS_DISABLECARD) { |
| 285 | esb_timer_stop(); |
| 286 | retval = 0; |
| 287 | } |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 288 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 289 | if (new_options & WDIOS_ENABLECARD) { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 290 | esb_timer_start(); |
| 291 | retval = 0; |
| 292 | } |
| 293 | return retval; |
| 294 | } |
Wim Van Sebroeck | 0c06090 | 2008-07-18 11:41:17 +0000 | [diff] [blame] | 295 | case WDIOC_KEEPALIVE: |
| 296 | esb_timer_keepalive(); |
| 297 | return 0; |
| 298 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 299 | case WDIOC_SETTIMEOUT: |
| 300 | { |
| 301 | if (get_user(new_heartbeat, p)) |
| 302 | return -EFAULT; |
| 303 | if (esb_timer_set_heartbeat(new_heartbeat)) |
| 304 | return -EINVAL; |
| 305 | esb_timer_keepalive(); |
| 306 | /* Fall */ |
| 307 | } |
| 308 | case WDIOC_GETTIMEOUT: |
| 309 | return put_user(heartbeat, p); |
| 310 | default: |
| 311 | return -ENOTTY; |
| 312 | } |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 313 | } |
| 314 | |
| 315 | /* |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 316 | * Kernel Interfaces |
| 317 | */ |
| 318 | |
Arjan van de Ven | 62322d2 | 2006-07-03 00:24:21 -0700 | [diff] [blame] | 319 | static const struct file_operations esb_fops = { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 320 | .owner = THIS_MODULE, |
| 321 | .llseek = no_llseek, |
| 322 | .write = esb_write, |
| 323 | .unlocked_ioctl = esb_ioctl, |
| 324 | .open = esb_open, |
| 325 | .release = esb_release, |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 326 | }; |
| 327 | |
| 328 | static struct miscdevice esb_miscdev = { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 329 | .minor = WATCHDOG_MINOR, |
| 330 | .name = "watchdog", |
| 331 | .fops = &esb_fops, |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 332 | }; |
| 333 | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 334 | /* |
| 335 | * Data for PCI driver interface |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 336 | */ |
Wim Van Sebroeck | 4562f53 | 2011-02-21 12:16:44 +0000 | [diff] [blame^] | 337 | static DEFINE_PCI_DEVICE_TABLE(esb_pci_tbl) = { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 338 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_9), }, |
| 339 | { 0, }, /* End of list */ |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 340 | }; |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 341 | MODULE_DEVICE_TABLE(pci, esb_pci_tbl); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 342 | |
| 343 | /* |
| 344 | * Init & exit routines |
| 345 | */ |
| 346 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 347 | static unsigned char __devinit esb_getdevice(struct pci_dev *pdev) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 348 | { |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 349 | if (pci_enable_device(pdev)) { |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 350 | printk(KERN_ERR PFX "failed to enable device\n"); |
| 351 | goto err_devput; |
| 352 | } |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 353 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 354 | if (pci_request_region(pdev, 0, ESB_MODULE_NAME)) { |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 355 | printk(KERN_ERR PFX "failed to request region\n"); |
| 356 | goto err_disable; |
| 357 | } |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 358 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 359 | BASEADDR = pci_ioremap_bar(pdev, 0); |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 360 | if (BASEADDR == NULL) { |
| 361 | /* Something's wrong here, BASEADDR has to be set */ |
| 362 | printk(KERN_ERR PFX "failed to get BASEADDR\n"); |
| 363 | goto err_release; |
| 364 | } |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 365 | |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 366 | /* Done */ |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 367 | esb_pci = pdev; |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 368 | return 1; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 369 | |
| 370 | err_release: |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 371 | pci_release_region(pdev, 0); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 372 | err_disable: |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 373 | pci_disable_device(pdev); |
Naveen Gupta | 811f999 | 2005-08-21 13:02:41 +0200 | [diff] [blame] | 374 | err_devput: |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 375 | return 0; |
| 376 | } |
| 377 | |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 378 | static void __devinit esb_initdevice(void) |
| 379 | { |
| 380 | u8 val1; |
| 381 | u16 val2; |
| 382 | |
| 383 | /* |
| 384 | * Config register: |
| 385 | * Bit 5 : 0 = Enable WDT_OUTPUT |
| 386 | * Bit 2 : 0 = set the timer frequency to the PCI clock |
| 387 | * divided by 2^15 (approx 1KHz). |
| 388 | * Bits 1:0 : 11 = WDT_INT_TYPE Disabled. |
| 389 | * The watchdog has two timers, it can be setup so that the |
| 390 | * expiry of timer1 results in an interrupt and the expiry of |
| 391 | * timer2 results in a reboot. We set it to not generate |
| 392 | * any interrupts as there is not much we can do with it |
| 393 | * right now. |
| 394 | */ |
| 395 | pci_write_config_word(esb_pci, ESB_CONFIG_REG, 0x0003); |
| 396 | |
| 397 | /* Check that the WDT isn't already locked */ |
| 398 | pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val1); |
| 399 | if (val1 & ESB_WDT_LOCK) |
| 400 | printk(KERN_WARNING PFX "nowayout already set\n"); |
| 401 | |
| 402 | /* Set the timer to watchdog mode and disable it for now */ |
| 403 | pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x00); |
| 404 | |
| 405 | /* Check if the watchdog was previously triggered */ |
| 406 | esb_unlock_registers(); |
| 407 | val2 = readw(ESB_RELOAD_REG); |
| 408 | if (val2 & ESB_WDT_TIMEOUT) |
| 409 | triggered = WDIOF_CARDRESET; |
| 410 | |
| 411 | /* Reset WDT_TIMEOUT flag and timers */ |
| 412 | esb_unlock_registers(); |
| 413 | writew((ESB_WDT_TIMEOUT | ESB_WDT_RELOAD), ESB_RELOAD_REG); |
| 414 | |
| 415 | /* And set the correct timeout value */ |
| 416 | esb_timer_set_heartbeat(heartbeat); |
| 417 | } |
| 418 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 419 | static int __devinit esb_probe(struct pci_dev *pdev, |
| 420 | const struct pci_device_id *ent) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 421 | { |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 422 | int ret; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 423 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 424 | cards_found++; |
| 425 | if (cards_found == 1) |
| 426 | printk(KERN_INFO PFX "Intel 6300ESB WatchDog Timer Driver v%s\n", |
| 427 | ESB_VERSION); |
| 428 | |
| 429 | if (cards_found > 1) { |
| 430 | printk(KERN_ERR PFX "This driver only supports 1 device\n"); |
| 431 | return -ENODEV; |
| 432 | } |
| 433 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 434 | /* Check whether or not the hardware watchdog is there */ |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 435 | if (!esb_getdevice(pdev) || esb_pci == NULL) |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 436 | return -ENODEV; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 437 | |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 438 | /* Check that the heartbeat value is within it's range; |
| 439 | if not reset to the default */ |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 440 | if (heartbeat < 0x1 || heartbeat > 2 * 0x03ff) { |
| 441 | heartbeat = WATCHDOG_HEARTBEAT; |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 442 | printk(KERN_INFO PFX |
| 443 | "heartbeat value must be 1<heartbeat<2046, using %d\n", |
| 444 | heartbeat); |
| 445 | } |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 446 | |
Wim Van Sebroeck | fc8a9d8 | 2009-03-25 19:16:28 +0000 | [diff] [blame] | 447 | /* Initialize the watchdog and make sure it does not run */ |
| 448 | esb_initdevice(); |
| 449 | |
| 450 | /* Register the watchdog so that userspace has access to it */ |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 451 | ret = misc_register(&esb_miscdev); |
| 452 | if (ret != 0) { |
| 453 | printk(KERN_ERR PFX |
| 454 | "cannot register miscdev on minor=%d (err=%d)\n", |
| 455 | WATCHDOG_MINOR, ret); |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 456 | goto err_unmap; |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 457 | } |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 458 | printk(KERN_INFO PFX |
| 459 | "initialized (0x%p). heartbeat=%d sec (nowayout=%d)\n", |
| 460 | BASEADDR, heartbeat, nowayout); |
| 461 | return 0; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 462 | |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 463 | err_unmap: |
| 464 | iounmap(BASEADDR); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 465 | pci_release_region(esb_pci, 0); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 466 | pci_disable_device(esb_pci); |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 467 | esb_pci = NULL; |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 468 | return ret; |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 469 | } |
| 470 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 471 | static void __devexit esb_remove(struct pci_dev *pdev) |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 472 | { |
| 473 | /* Stop the timer before we leave */ |
| 474 | if (!nowayout) |
Alan Cox | 0829291 | 2008-05-19 14:05:57 +0100 | [diff] [blame] | 475 | esb_timer_stop(); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 476 | |
| 477 | /* Deregister */ |
| 478 | misc_deregister(&esb_miscdev); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 479 | iounmap(BASEADDR); |
| 480 | pci_release_region(esb_pci, 0); |
| 481 | pci_disable_device(esb_pci); |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 482 | esb_pci = NULL; |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 483 | } |
| 484 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 485 | static void esb_shutdown(struct pci_dev *pdev) |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 486 | { |
| 487 | esb_timer_stop(); |
| 488 | } |
| 489 | |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 490 | static struct pci_driver esb_driver = { |
| 491 | .name = ESB_MODULE_NAME, |
| 492 | .id_table = esb_pci_tbl, |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 493 | .probe = esb_probe, |
| 494 | .remove = __devexit_p(esb_remove), |
| 495 | .shutdown = esb_shutdown, |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 496 | }; |
| 497 | |
| 498 | static int __init watchdog_init(void) |
| 499 | { |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 500 | return pci_register_driver(&esb_driver); |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 501 | } |
| 502 | |
| 503 | static void __exit watchdog_cleanup(void) |
| 504 | { |
Wim Van Sebroeck | 2786095 | 2010-03-08 13:48:01 +0000 | [diff] [blame] | 505 | pci_unregister_driver(&esb_driver); |
Wim Van Sebroeck | 0426fd0 | 2009-03-19 19:02:44 +0000 | [diff] [blame] | 506 | printk(KERN_INFO PFX "Watchdog Module Unloaded.\n"); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 507 | } |
| 508 | |
| 509 | module_init(watchdog_init); |
| 510 | module_exit(watchdog_cleanup); |
| 511 | |
Jan Engelhardt | 96de0e2 | 2007-10-19 23:21:04 +0200 | [diff] [blame] | 512 | MODULE_AUTHOR("Ross Biro and David Härdeman"); |
David Hardeman | cc90ef0 | 2005-08-17 09:07:44 +0200 | [diff] [blame] | 513 | MODULE_DESCRIPTION("Watchdog driver for Intel 6300ESB chipsets"); |
| 514 | MODULE_LICENSE("GPL"); |
| 515 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); |