1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Watchdog for the 7101 PMU version found in the ALi M1535 chipsets 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/module.h> 9 #include <linux/moduleparam.h> 10 #include <linux/types.h> 11 #include <linux/miscdevice.h> 12 #include <linux/watchdog.h> 13 #include <linux/ioport.h> 14 #include <linux/notifier.h> 15 #include <linux/reboot.h> 16 #include <linux/init.h> 17 #include <linux/fs.h> 18 #include <linux/pci.h> 19 #include <linux/uaccess.h> 20 #include <linux/io.h> 21 22 #define WATCHDOG_NAME "ALi_M1535" 23 #define WATCHDOG_TIMEOUT 60 /* 60 sec default timeout */ 24 25 /* internal variables */ 26 static unsigned long ali_is_open; 27 static char ali_expect_release; 28 static struct pci_dev *ali_pci; 29 static u32 ali_timeout_bits; /* stores the computed timeout */ 30 static DEFINE_SPINLOCK(ali_lock); /* Guards the hardware */ 31 32 /* module parameters */ 33 static int timeout = WATCHDOG_TIMEOUT; 34 module_param(timeout, int, 0); 35 MODULE_PARM_DESC(timeout, 36 "Watchdog timeout in seconds. (0 < timeout < 18000, default=" 37 __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); 38 39 static bool nowayout = WATCHDOG_NOWAYOUT; 40 module_param(nowayout, bool, 0); 41 MODULE_PARM_DESC(nowayout, 42 "Watchdog cannot be stopped once started (default=" 43 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 44 45 /* 46 * ali_start - start watchdog countdown 47 * 48 * Starts the timer running providing the timer has a counter 49 * configuration set. 50 */ 51 52 static void ali_start(void) 53 { 54 u32 val; 55 56 spin_lock(&ali_lock); 57 58 pci_read_config_dword(ali_pci, 0xCC, &val); 59 val &= ~0x3F; /* Mask count */ 60 val |= (1 << 25) | ali_timeout_bits; 61 pci_write_config_dword(ali_pci, 0xCC, val); 62 63 spin_unlock(&ali_lock); 64 } 65 66 /* 67 * ali_stop - stop the timer countdown 68 * 69 * Stop the ALi watchdog countdown 70 */ 71 72 static void ali_stop(void) 73 { 74 u32 val; 75 76 spin_lock(&ali_lock); 77 78 pci_read_config_dword(ali_pci, 0xCC, &val); 79 val &= ~0x3F; /* Mask count to zero (disabled) */ 80 val &= ~(1 << 25); /* and for safety mask the reset enable */ 81 pci_write_config_dword(ali_pci, 0xCC, val); 82 83 spin_unlock(&ali_lock); 84 } 85 86 /* 87 * ali_keepalive - send a keepalive to the watchdog 88 * 89 * Send a keepalive to the timer (actually we restart the timer). 90 */ 91 92 static void ali_keepalive(void) 93 { 94 ali_start(); 95 } 96 97 /* 98 * ali_settimer - compute the timer reload value 99 * @t: time in seconds 100 * 101 * Computes the timeout values needed 102 */ 103 104 static int ali_settimer(int t) 105 { 106 if (t < 0) 107 return -EINVAL; 108 else if (t < 60) 109 ali_timeout_bits = t|(1 << 6); 110 else if (t < 3600) 111 ali_timeout_bits = (t / 60)|(1 << 7); 112 else if (t < 18000) 113 ali_timeout_bits = (t / 300)|(1 << 6)|(1 << 7); 114 else 115 return -EINVAL; 116 117 timeout = t; 118 return 0; 119 } 120 121 /* 122 * /dev/watchdog handling 123 */ 124 125 /* 126 * ali_write - writes to ALi watchdog 127 * @file: file from VFS 128 * @data: user address of data 129 * @len: length of data 130 * @ppos: pointer to the file offset 131 * 132 * Handle a write to the ALi watchdog. Writing to the file pings 133 * the watchdog and resets it. Writing the magic 'V' sequence allows 134 * the next close to turn off the watchdog. 135 */ 136 137 static ssize_t ali_write(struct file *file, const char __user *data, 138 size_t len, loff_t *ppos) 139 { 140 /* See if we got the magic character 'V' and reload the timer */ 141 if (len) { 142 if (!nowayout) { 143 size_t i; 144 145 /* note: just in case someone wrote the 146 magic character five months ago... */ 147 ali_expect_release = 0; 148 149 /* scan to see whether or not we got 150 the magic character */ 151 for (i = 0; i != len; i++) { 152 char c; 153 if (get_user(c, data + i)) 154 return -EFAULT; 155 if (c == 'V') 156 ali_expect_release = 42; 157 } 158 } 159 160 /* someone wrote to us, we should reload the timer */ 161 ali_start(); 162 } 163 return len; 164 } 165 166 /* 167 * ali_ioctl - handle watchdog ioctls 168 * @file: VFS file pointer 169 * @cmd: ioctl number 170 * @arg: arguments to the ioctl 171 * 172 * Handle the watchdog ioctls supported by the ALi driver. Really 173 * we want an extension to enable irq ack monitoring and the like 174 */ 175 176 static long ali_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 177 { 178 void __user *argp = (void __user *)arg; 179 int __user *p = argp; 180 static const struct watchdog_info ident = { 181 .options = WDIOF_KEEPALIVEPING | 182 WDIOF_SETTIMEOUT | 183 WDIOF_MAGICCLOSE, 184 .firmware_version = 0, 185 .identity = "ALi M1535 WatchDog Timer", 186 }; 187 188 switch (cmd) { 189 case WDIOC_GETSUPPORT: 190 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; 191 192 case WDIOC_GETSTATUS: 193 case WDIOC_GETBOOTSTATUS: 194 return put_user(0, p); 195 case WDIOC_SETOPTIONS: 196 { 197 int new_options, retval = -EINVAL; 198 199 if (get_user(new_options, p)) 200 return -EFAULT; 201 if (new_options & WDIOS_DISABLECARD) { 202 ali_stop(); 203 retval = 0; 204 } 205 if (new_options & WDIOS_ENABLECARD) { 206 ali_start(); 207 retval = 0; 208 } 209 return retval; 210 } 211 case WDIOC_KEEPALIVE: 212 ali_keepalive(); 213 return 0; 214 case WDIOC_SETTIMEOUT: 215 { 216 int new_timeout; 217 if (get_user(new_timeout, p)) 218 return -EFAULT; 219 if (ali_settimer(new_timeout)) 220 return -EINVAL; 221 ali_keepalive(); 222 } 223 fallthrough; 224 case WDIOC_GETTIMEOUT: 225 return put_user(timeout, p); 226 default: 227 return -ENOTTY; 228 } 229 } 230 231 /* 232 * ali_open - handle open of ali watchdog 233 * @inode: inode from VFS 234 * @file: file from VFS 235 * 236 * Open the ALi watchdog device. Ensure only one person opens it 237 * at a time. Also start the watchdog running. 238 */ 239 240 static int ali_open(struct inode *inode, struct file *file) 241 { 242 /* /dev/watchdog can only be opened once */ 243 if (test_and_set_bit(0, &ali_is_open)) 244 return -EBUSY; 245 246 /* Activate */ 247 ali_start(); 248 return stream_open(inode, file); 249 } 250 251 /* 252 * ali_release - close an ALi watchdog 253 * @inode: inode from VFS 254 * @file: file from VFS 255 * 256 * Close the ALi watchdog device. Actual shutdown of the timer 257 * only occurs if the magic sequence has been set. 258 */ 259 260 static int ali_release(struct inode *inode, struct file *file) 261 { 262 /* 263 * Shut off the timer. 264 */ 265 if (ali_expect_release == 42) 266 ali_stop(); 267 else { 268 pr_crit("Unexpected close, not stopping watchdog!\n"); 269 ali_keepalive(); 270 } 271 clear_bit(0, &ali_is_open); 272 ali_expect_release = 0; 273 return 0; 274 } 275 276 /* 277 * ali_notify_sys - System down notifier 278 * 279 * Notifier for system down 280 */ 281 282 283 static int ali_notify_sys(struct notifier_block *this, 284 unsigned long code, void *unused) 285 { 286 if (code == SYS_DOWN || code == SYS_HALT) 287 ali_stop(); /* Turn the WDT off */ 288 return NOTIFY_DONE; 289 } 290 291 /* 292 * Data for PCI driver interface 293 * 294 * This data only exists for exporting the supported 295 * PCI ids via MODULE_DEVICE_TABLE. We do not actually 296 * register a pci_driver, because someone else might one day 297 * want to register another driver on the same PCI id. 298 */ 299 300 static const struct pci_device_id ali_pci_tbl[] __used = { 301 { PCI_VENDOR_ID_AL, 0x1533, PCI_ANY_ID, PCI_ANY_ID,}, 302 { PCI_VENDOR_ID_AL, 0x1535, PCI_ANY_ID, PCI_ANY_ID,}, 303 { 0, }, 304 }; 305 MODULE_DEVICE_TABLE(pci, ali_pci_tbl); 306 307 /* 308 * ali_find_watchdog - find a 1535 and 7101 309 * 310 * Scans the PCI hardware for a 1535 series bridge and matching 7101 311 * watchdog device. This may be overtight but it is better to be safe 312 */ 313 314 static int __init ali_find_watchdog(void) 315 { 316 struct pci_dev *pdev; 317 u32 wdog; 318 319 /* Check for a 1533/1535 series bridge */ 320 pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x1535, NULL); 321 if (pdev == NULL) 322 pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x1533, NULL); 323 if (pdev == NULL) 324 return -ENODEV; 325 pci_dev_put(pdev); 326 327 /* Check for the a 7101 PMU */ 328 pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x7101, NULL); 329 if (pdev == NULL) 330 return -ENODEV; 331 332 if (pci_enable_device(pdev)) { 333 pci_dev_put(pdev); 334 return -EIO; 335 } 336 337 ali_pci = pdev; 338 339 /* 340 * Initialize the timer bits 341 */ 342 pci_read_config_dword(pdev, 0xCC, &wdog); 343 344 /* Timer bits */ 345 wdog &= ~0x3F; 346 /* Issued events */ 347 wdog &= ~((1 << 27)|(1 << 26)|(1 << 25)|(1 << 24)); 348 /* No monitor bits */ 349 wdog &= ~((1 << 16)|(1 << 13)|(1 << 12)|(1 << 11)|(1 << 10)|(1 << 9)); 350 351 pci_write_config_dword(pdev, 0xCC, wdog); 352 353 return 0; 354 } 355 356 /* 357 * Kernel Interfaces 358 */ 359 360 static const struct file_operations ali_fops = { 361 .owner = THIS_MODULE, 362 .llseek = no_llseek, 363 .write = ali_write, 364 .unlocked_ioctl = ali_ioctl, 365 .compat_ioctl = compat_ptr_ioctl, 366 .open = ali_open, 367 .release = ali_release, 368 }; 369 370 static struct miscdevice ali_miscdev = { 371 .minor = WATCHDOG_MINOR, 372 .name = "watchdog", 373 .fops = &ali_fops, 374 }; 375 376 static struct notifier_block ali_notifier = { 377 .notifier_call = ali_notify_sys, 378 }; 379 380 /* 381 * watchdog_init - module initialiser 382 * 383 * Scan for a suitable watchdog and if so initialize it. Return an error 384 * if we cannot, the error causes the module to unload 385 */ 386 387 static int __init watchdog_init(void) 388 { 389 int ret; 390 391 /* Check whether or not the hardware watchdog is there */ 392 if (ali_find_watchdog() != 0) 393 return -ENODEV; 394 395 /* Check that the timeout value is within it's range; 396 if not reset to the default */ 397 if (timeout < 1 || timeout >= 18000) { 398 timeout = WATCHDOG_TIMEOUT; 399 pr_info("timeout value must be 0 < timeout < 18000, using %d\n", 400 timeout); 401 } 402 403 /* Calculate the watchdog's timeout */ 404 ali_settimer(timeout); 405 406 ret = register_reboot_notifier(&ali_notifier); 407 if (ret != 0) { 408 pr_err("cannot register reboot notifier (err=%d)\n", ret); 409 goto out; 410 } 411 412 ret = misc_register(&ali_miscdev); 413 if (ret != 0) { 414 pr_err("cannot register miscdev on minor=%d (err=%d)\n", 415 WATCHDOG_MINOR, ret); 416 goto unreg_reboot; 417 } 418 419 pr_info("initialized. timeout=%d sec (nowayout=%d)\n", 420 timeout, nowayout); 421 422 out: 423 return ret; 424 unreg_reboot: 425 unregister_reboot_notifier(&ali_notifier); 426 goto out; 427 } 428 429 /* 430 * watchdog_exit - module de-initialiser 431 * 432 * Called while unloading a successfully installed watchdog module. 433 */ 434 435 static void __exit watchdog_exit(void) 436 { 437 /* Stop the timer before we leave */ 438 ali_stop(); 439 440 /* Deregister */ 441 misc_deregister(&ali_miscdev); 442 unregister_reboot_notifier(&ali_notifier); 443 pci_dev_put(ali_pci); 444 } 445 446 module_init(watchdog_init); 447 module_exit(watchdog_exit); 448 449 MODULE_AUTHOR("Alan Cox"); 450 MODULE_DESCRIPTION("ALi M1535 PMU Watchdog Timer driver"); 451 MODULE_LICENSE("GPL"); 452