1 /* 2 * FIXME: add wdrtas_get_status and wdrtas_get_boot_status as soon as 3 * RTAS calls are available 4 */ 5 6 /* 7 * RTAS watchdog driver 8 * 9 * (C) Copyright IBM Corp. 2005 10 * device driver to exploit watchdog RTAS functions 11 * 12 * Authors : Utz Bacher <utz.bacher@de.ibm.com> 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2, or (at your option) 17 * any later version. 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 27 */ 28 29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 30 31 #include <linux/fs.h> 32 #include <linux/init.h> 33 #include <linux/kernel.h> 34 #include <linux/miscdevice.h> 35 #include <linux/module.h> 36 #include <linux/notifier.h> 37 #include <linux/reboot.h> 38 #include <linux/types.h> 39 #include <linux/watchdog.h> 40 #include <linux/uaccess.h> 41 42 #include <asm/rtas.h> 43 44 #define WDRTAS_MAGIC_CHAR 42 45 #define WDRTAS_SUPPORTED_MASK (WDIOF_SETTIMEOUT | \ 46 WDIOF_MAGICCLOSE) 47 48 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>"); 49 MODULE_DESCRIPTION("RTAS watchdog driver"); 50 MODULE_LICENSE("GPL"); 51 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 52 MODULE_ALIAS_MISCDEV(TEMP_MINOR); 53 54 static bool wdrtas_nowayout = WATCHDOG_NOWAYOUT; 55 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0); 56 static char wdrtas_expect_close; 57 58 static int wdrtas_interval; 59 60 #define WDRTAS_THERMAL_SENSOR 3 61 static int wdrtas_token_get_sensor_state; 62 #define WDRTAS_SURVEILLANCE_IND 9000 63 static int wdrtas_token_set_indicator; 64 #define WDRTAS_SP_SPI 28 65 static int wdrtas_token_get_sp; 66 static int wdrtas_token_event_scan; 67 68 #define WDRTAS_DEFAULT_INTERVAL 300 69 70 #define WDRTAS_LOGBUFFER_LEN 128 71 static char wdrtas_logbuffer[WDRTAS_LOGBUFFER_LEN]; 72 73 74 /*** watchdog access functions */ 75 76 /** 77 * wdrtas_set_interval - sets the watchdog interval 78 * @interval: new interval 79 * 80 * returns 0 on success, <0 on failures 81 * 82 * wdrtas_set_interval sets the watchdog keepalive interval by calling the 83 * RTAS function set-indicator (surveillance). The unit of interval is 84 * seconds. 85 */ 86 87 static int wdrtas_set_interval(int interval) 88 { 89 long result; 90 static int print_msg = 10; 91 92 /* rtas uses minutes */ 93 interval = (interval + 59) / 60; 94 95 result = rtas_call(wdrtas_token_set_indicator, 3, 1, NULL, 96 WDRTAS_SURVEILLANCE_IND, 0, interval); 97 if (result < 0 && print_msg) { 98 pr_err("setting the watchdog to %i timeout failed: %li\n", 99 interval, result); 100 print_msg--; 101 } 102 103 return result; 104 } 105 106 #define WDRTAS_SP_SPI_LEN 4 107 108 /** 109 * wdrtas_get_interval - returns the current watchdog interval 110 * @fallback_value: value (in seconds) to use, if the RTAS call fails 111 * 112 * returns the interval 113 * 114 * wdrtas_get_interval returns the current watchdog keepalive interval 115 * as reported by the RTAS function ibm,get-system-parameter. The unit 116 * of the return value is seconds. 117 */ 118 static int wdrtas_get_interval(int fallback_value) 119 { 120 long result; 121 char value[WDRTAS_SP_SPI_LEN]; 122 123 spin_lock(&rtas_data_buf_lock); 124 memset(rtas_data_buf, 0, WDRTAS_SP_SPI_LEN); 125 result = rtas_call(wdrtas_token_get_sp, 3, 1, NULL, 126 WDRTAS_SP_SPI, __pa(rtas_data_buf), 127 WDRTAS_SP_SPI_LEN); 128 129 memcpy(value, rtas_data_buf, WDRTAS_SP_SPI_LEN); 130 spin_unlock(&rtas_data_buf_lock); 131 132 if (value[0] != 0 || value[1] != 2 || value[3] != 0 || result < 0) { 133 pr_warn("could not get sp_spi watchdog timeout (%li). Continuing\n", 134 result); 135 return fallback_value; 136 } 137 138 /* rtas uses minutes */ 139 return ((int)value[2]) * 60; 140 } 141 142 /** 143 * wdrtas_timer_start - starts watchdog 144 * 145 * wdrtas_timer_start starts the watchdog by calling the RTAS function 146 * set-interval (surveillance) 147 */ 148 static void wdrtas_timer_start(void) 149 { 150 wdrtas_set_interval(wdrtas_interval); 151 } 152 153 /** 154 * wdrtas_timer_stop - stops watchdog 155 * 156 * wdrtas_timer_stop stops the watchdog timer by calling the RTAS function 157 * set-interval (surveillance) 158 */ 159 static void wdrtas_timer_stop(void) 160 { 161 wdrtas_set_interval(0); 162 } 163 164 /** 165 * wdrtas_log_scanned_event - logs an event we received during keepalive 166 * 167 * wdrtas_log_scanned_event prints a message to the log buffer dumping 168 * the results of the last event-scan call 169 */ 170 static void wdrtas_log_scanned_event(void) 171 { 172 int i; 173 174 for (i = 0; i < WDRTAS_LOGBUFFER_LEN; i += 16) 175 pr_info("dumping event (line %i/%i), data = " 176 "%02x %02x %02x %02x %02x %02x %02x %02x " 177 "%02x %02x %02x %02x %02x %02x %02x %02x\n", 178 (i / 16) + 1, (WDRTAS_LOGBUFFER_LEN / 16), 179 wdrtas_logbuffer[i + 0], wdrtas_logbuffer[i + 1], 180 wdrtas_logbuffer[i + 2], wdrtas_logbuffer[i + 3], 181 wdrtas_logbuffer[i + 4], wdrtas_logbuffer[i + 5], 182 wdrtas_logbuffer[i + 6], wdrtas_logbuffer[i + 7], 183 wdrtas_logbuffer[i + 8], wdrtas_logbuffer[i + 9], 184 wdrtas_logbuffer[i + 10], wdrtas_logbuffer[i + 11], 185 wdrtas_logbuffer[i + 12], wdrtas_logbuffer[i + 13], 186 wdrtas_logbuffer[i + 14], wdrtas_logbuffer[i + 15]); 187 } 188 189 /** 190 * wdrtas_timer_keepalive - resets watchdog timer to keep system alive 191 * 192 * wdrtas_timer_keepalive restarts the watchdog timer by calling the 193 * RTAS function event-scan and repeats these calls as long as there are 194 * events available. All events will be dumped. 195 */ 196 static void wdrtas_timer_keepalive(void) 197 { 198 long result; 199 200 do { 201 result = rtas_call(wdrtas_token_event_scan, 4, 1, NULL, 202 RTAS_EVENT_SCAN_ALL_EVENTS, 0, 203 (void *)__pa(wdrtas_logbuffer), 204 WDRTAS_LOGBUFFER_LEN); 205 if (result < 0) 206 pr_err("event-scan failed: %li\n", result); 207 if (result == 0) 208 wdrtas_log_scanned_event(); 209 } while (result == 0); 210 } 211 212 /** 213 * wdrtas_get_temperature - returns current temperature 214 * 215 * returns temperature or <0 on failures 216 * 217 * wdrtas_get_temperature returns the current temperature in Fahrenheit. It 218 * uses the RTAS call get-sensor-state, token 3 to do so 219 */ 220 static int wdrtas_get_temperature(void) 221 { 222 int result; 223 int temperature = 0; 224 225 result = rtas_get_sensor(WDRTAS_THERMAL_SENSOR, 0, &temperature); 226 227 if (result < 0) 228 pr_warn("reading the thermal sensor failed: %i\n", result); 229 else 230 temperature = ((temperature * 9) / 5) + 32; /* fahrenheit */ 231 232 return temperature; 233 } 234 235 /** 236 * wdrtas_get_status - returns the status of the watchdog 237 * 238 * returns a bitmask of defines WDIOF_... as defined in 239 * include/linux/watchdog.h 240 */ 241 static int wdrtas_get_status(void) 242 { 243 return 0; /* TODO */ 244 } 245 246 /** 247 * wdrtas_get_boot_status - returns the reason for the last boot 248 * 249 * returns a bitmask of defines WDIOF_... as defined in 250 * include/linux/watchdog.h, indicating why the watchdog rebooted the system 251 */ 252 static int wdrtas_get_boot_status(void) 253 { 254 return 0; /* TODO */ 255 } 256 257 /*** watchdog API and operations stuff */ 258 259 /* wdrtas_write - called when watchdog device is written to 260 * @file: file structure 261 * @buf: user buffer with data 262 * @len: amount to data written 263 * @ppos: position in file 264 * 265 * returns the number of successfully processed characters, which is always 266 * the number of bytes passed to this function 267 * 268 * wdrtas_write processes all the data given to it and looks for the magic 269 * character 'V'. This character allows the watchdog device to be closed 270 * properly. 271 */ 272 static ssize_t wdrtas_write(struct file *file, const char __user *buf, 273 size_t len, loff_t *ppos) 274 { 275 int i; 276 char c; 277 278 if (!len) 279 goto out; 280 281 if (!wdrtas_nowayout) { 282 wdrtas_expect_close = 0; 283 /* look for 'V' */ 284 for (i = 0; i < len; i++) { 285 if (get_user(c, buf + i)) 286 return -EFAULT; 287 /* allow to close device */ 288 if (c == 'V') 289 wdrtas_expect_close = WDRTAS_MAGIC_CHAR; 290 } 291 } 292 293 wdrtas_timer_keepalive(); 294 295 out: 296 return len; 297 } 298 299 /** 300 * wdrtas_ioctl - ioctl function for the watchdog device 301 * @file: file structure 302 * @cmd: command for ioctl 303 * @arg: argument pointer 304 * 305 * returns 0 on success, <0 on failure 306 * 307 * wdrtas_ioctl implements the watchdog API ioctls 308 */ 309 310 static long wdrtas_ioctl(struct file *file, unsigned int cmd, 311 unsigned long arg) 312 { 313 int __user *argp = (void __user *)arg; 314 int i; 315 static const struct watchdog_info wdinfo = { 316 .options = WDRTAS_SUPPORTED_MASK, 317 .firmware_version = 0, 318 .identity = "wdrtas", 319 }; 320 321 switch (cmd) { 322 case WDIOC_GETSUPPORT: 323 if (copy_to_user(argp, &wdinfo, sizeof(wdinfo))) 324 return -EFAULT; 325 return 0; 326 327 case WDIOC_GETSTATUS: 328 i = wdrtas_get_status(); 329 return put_user(i, argp); 330 331 case WDIOC_GETBOOTSTATUS: 332 i = wdrtas_get_boot_status(); 333 return put_user(i, argp); 334 335 case WDIOC_GETTEMP: 336 if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE) 337 return -EOPNOTSUPP; 338 339 i = wdrtas_get_temperature(); 340 return put_user(i, argp); 341 342 case WDIOC_SETOPTIONS: 343 if (get_user(i, argp)) 344 return -EFAULT; 345 if (i & WDIOS_DISABLECARD) 346 wdrtas_timer_stop(); 347 if (i & WDIOS_ENABLECARD) { 348 wdrtas_timer_keepalive(); 349 wdrtas_timer_start(); 350 } 351 /* not implemented. Done by H8 352 if (i & WDIOS_TEMPPANIC) { 353 } */ 354 return 0; 355 356 case WDIOC_KEEPALIVE: 357 wdrtas_timer_keepalive(); 358 return 0; 359 360 case WDIOC_SETTIMEOUT: 361 if (get_user(i, argp)) 362 return -EFAULT; 363 364 if (wdrtas_set_interval(i)) 365 return -EINVAL; 366 367 wdrtas_timer_keepalive(); 368 369 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) 370 wdrtas_interval = i; 371 else 372 wdrtas_interval = wdrtas_get_interval(i); 373 /* fallthrough */ 374 375 case WDIOC_GETTIMEOUT: 376 return put_user(wdrtas_interval, argp); 377 378 default: 379 return -ENOTTY; 380 } 381 } 382 383 /** 384 * wdrtas_open - open function of watchdog device 385 * @inode: inode structure 386 * @file: file structure 387 * 388 * returns 0 on success, -EBUSY if the file has been opened already, <0 on 389 * other failures 390 * 391 * function called when watchdog device is opened 392 */ 393 static int wdrtas_open(struct inode *inode, struct file *file) 394 { 395 /* only open once */ 396 if (atomic_inc_return(&wdrtas_miscdev_open) > 1) { 397 atomic_dec(&wdrtas_miscdev_open); 398 return -EBUSY; 399 } 400 401 wdrtas_timer_start(); 402 wdrtas_timer_keepalive(); 403 404 return nonseekable_open(inode, file); 405 } 406 407 /** 408 * wdrtas_close - close function of watchdog device 409 * @inode: inode structure 410 * @file: file structure 411 * 412 * returns 0 on success 413 * 414 * close function. Always succeeds 415 */ 416 static int wdrtas_close(struct inode *inode, struct file *file) 417 { 418 /* only stop watchdog, if this was announced using 'V' before */ 419 if (wdrtas_expect_close == WDRTAS_MAGIC_CHAR) 420 wdrtas_timer_stop(); 421 else { 422 pr_warn("got unexpected close. Watchdog not stopped.\n"); 423 wdrtas_timer_keepalive(); 424 } 425 426 wdrtas_expect_close = 0; 427 atomic_dec(&wdrtas_miscdev_open); 428 return 0; 429 } 430 431 /** 432 * wdrtas_temp_read - gives back the temperature in fahrenheit 433 * @file: file structure 434 * @buf: user buffer 435 * @count: number of bytes to be read 436 * @ppos: position in file 437 * 438 * returns always 1 or -EFAULT in case of user space copy failures, <0 on 439 * other failures 440 * 441 * wdrtas_temp_read gives the temperature to the users by copying this 442 * value as one byte into the user space buffer. The unit is Fahrenheit... 443 */ 444 static ssize_t wdrtas_temp_read(struct file *file, char __user *buf, 445 size_t count, loff_t *ppos) 446 { 447 int temperature = 0; 448 449 temperature = wdrtas_get_temperature(); 450 if (temperature < 0) 451 return temperature; 452 453 if (copy_to_user(buf, &temperature, 1)) 454 return -EFAULT; 455 456 return 1; 457 } 458 459 /** 460 * wdrtas_temp_open - open function of temperature device 461 * @inode: inode structure 462 * @file: file structure 463 * 464 * returns 0 on success, <0 on failure 465 * 466 * function called when temperature device is opened 467 */ 468 static int wdrtas_temp_open(struct inode *inode, struct file *file) 469 { 470 return nonseekable_open(inode, file); 471 } 472 473 /** 474 * wdrtas_temp_close - close function of temperature device 475 * @inode: inode structure 476 * @file: file structure 477 * 478 * returns 0 on success 479 * 480 * close function. Always succeeds 481 */ 482 static int wdrtas_temp_close(struct inode *inode, struct file *file) 483 { 484 return 0; 485 } 486 487 /** 488 * wdrtas_reboot - reboot notifier function 489 * @nb: notifier block structure 490 * @code: reboot code 491 * @ptr: unused 492 * 493 * returns NOTIFY_DONE 494 * 495 * wdrtas_reboot stops the watchdog in case of a reboot 496 */ 497 static int wdrtas_reboot(struct notifier_block *this, 498 unsigned long code, void *ptr) 499 { 500 if (code == SYS_DOWN || code == SYS_HALT) 501 wdrtas_timer_stop(); 502 503 return NOTIFY_DONE; 504 } 505 506 /*** initialization stuff */ 507 508 static const struct file_operations wdrtas_fops = { 509 .owner = THIS_MODULE, 510 .llseek = no_llseek, 511 .write = wdrtas_write, 512 .unlocked_ioctl = wdrtas_ioctl, 513 .open = wdrtas_open, 514 .release = wdrtas_close, 515 }; 516 517 static struct miscdevice wdrtas_miscdev = { 518 .minor = WATCHDOG_MINOR, 519 .name = "watchdog", 520 .fops = &wdrtas_fops, 521 }; 522 523 static const struct file_operations wdrtas_temp_fops = { 524 .owner = THIS_MODULE, 525 .llseek = no_llseek, 526 .read = wdrtas_temp_read, 527 .open = wdrtas_temp_open, 528 .release = wdrtas_temp_close, 529 }; 530 531 static struct miscdevice wdrtas_tempdev = { 532 .minor = TEMP_MINOR, 533 .name = "temperature", 534 .fops = &wdrtas_temp_fops, 535 }; 536 537 static struct notifier_block wdrtas_notifier = { 538 .notifier_call = wdrtas_reboot, 539 }; 540 541 /** 542 * wdrtas_get_tokens - reads in RTAS tokens 543 * 544 * returns 0 on success, <0 on failure 545 * 546 * wdrtas_get_tokens reads in the tokens for the RTAS calls used in 547 * this watchdog driver. It tolerates, if "get-sensor-state" and 548 * "ibm,get-system-parameter" are not available. 549 */ 550 static int wdrtas_get_tokens(void) 551 { 552 wdrtas_token_get_sensor_state = rtas_token("get-sensor-state"); 553 if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE) { 554 pr_warn("couldn't get token for get-sensor-state. Trying to continue without temperature support.\n"); 555 } 556 557 wdrtas_token_get_sp = rtas_token("ibm,get-system-parameter"); 558 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) { 559 pr_warn("couldn't get token for ibm,get-system-parameter. Trying to continue with a default timeout value of %i seconds.\n", 560 WDRTAS_DEFAULT_INTERVAL); 561 } 562 563 wdrtas_token_set_indicator = rtas_token("set-indicator"); 564 if (wdrtas_token_set_indicator == RTAS_UNKNOWN_SERVICE) { 565 pr_err("couldn't get token for set-indicator. Terminating watchdog code.\n"); 566 return -EIO; 567 } 568 569 wdrtas_token_event_scan = rtas_token("event-scan"); 570 if (wdrtas_token_event_scan == RTAS_UNKNOWN_SERVICE) { 571 pr_err("couldn't get token for event-scan. Terminating watchdog code.\n"); 572 return -EIO; 573 } 574 575 return 0; 576 } 577 578 /** 579 * wdrtas_unregister_devs - unregisters the misc dev handlers 580 * 581 * wdrtas_register_devs unregisters the watchdog and temperature watchdog 582 * misc devs 583 */ 584 static void wdrtas_unregister_devs(void) 585 { 586 misc_deregister(&wdrtas_miscdev); 587 if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE) 588 misc_deregister(&wdrtas_tempdev); 589 } 590 591 /** 592 * wdrtas_register_devs - registers the misc dev handlers 593 * 594 * returns 0 on success, <0 on failure 595 * 596 * wdrtas_register_devs registers the watchdog and temperature watchdog 597 * misc devs 598 */ 599 static int wdrtas_register_devs(void) 600 { 601 int result; 602 603 result = misc_register(&wdrtas_miscdev); 604 if (result) { 605 pr_err("couldn't register watchdog misc device. Terminating watchdog code.\n"); 606 return result; 607 } 608 609 if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE) { 610 result = misc_register(&wdrtas_tempdev); 611 if (result) { 612 pr_warn("couldn't register watchdog temperature misc device. Continuing without temperature support.\n"); 613 wdrtas_token_get_sensor_state = RTAS_UNKNOWN_SERVICE; 614 } 615 } 616 617 return 0; 618 } 619 620 /** 621 * wdrtas_init - init function of the watchdog driver 622 * 623 * returns 0 on success, <0 on failure 624 * 625 * registers the file handlers and the reboot notifier 626 */ 627 static int __init wdrtas_init(void) 628 { 629 if (wdrtas_get_tokens()) 630 return -ENODEV; 631 632 if (wdrtas_register_devs()) 633 return -ENODEV; 634 635 if (register_reboot_notifier(&wdrtas_notifier)) { 636 pr_err("could not register reboot notifier. Terminating watchdog code.\n"); 637 wdrtas_unregister_devs(); 638 return -ENODEV; 639 } 640 641 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) 642 wdrtas_interval = WDRTAS_DEFAULT_INTERVAL; 643 else 644 wdrtas_interval = wdrtas_get_interval(WDRTAS_DEFAULT_INTERVAL); 645 646 return 0; 647 } 648 649 /** 650 * wdrtas_exit - exit function of the watchdog driver 651 * 652 * unregisters the file handlers and the reboot notifier 653 */ 654 static void __exit wdrtas_exit(void) 655 { 656 if (!wdrtas_nowayout) 657 wdrtas_timer_stop(); 658 659 wdrtas_unregister_devs(); 660 661 unregister_reboot_notifier(&wdrtas_notifier); 662 } 663 664 module_init(wdrtas_init); 665 module_exit(wdrtas_exit); 666