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 #include <linux/fs.h> 30 #include <linux/init.h> 31 #include <linux/kernel.h> 32 #include <linux/miscdevice.h> 33 #include <linux/module.h> 34 #include <linux/notifier.h> 35 #include <linux/reboot.h> 36 #include <linux/types.h> 37 #include <linux/watchdog.h> 38 #include <linux/uaccess.h> 39 40 #include <asm/rtas.h> 41 42 #define WDRTAS_MAGIC_CHAR 42 43 #define WDRTAS_SUPPORTED_MASK (WDIOF_SETTIMEOUT | \ 44 WDIOF_MAGICCLOSE) 45 46 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>"); 47 MODULE_DESCRIPTION("RTAS watchdog driver"); 48 MODULE_LICENSE("GPL"); 49 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 50 MODULE_ALIAS_MISCDEV(TEMP_MINOR); 51 52 static int wdrtas_nowayout = WATCHDOG_NOWAYOUT; 53 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0); 54 static char wdrtas_expect_close; 55 56 static int wdrtas_interval; 57 58 #define WDRTAS_THERMAL_SENSOR 3 59 static int wdrtas_token_get_sensor_state; 60 #define WDRTAS_SURVEILLANCE_IND 9000 61 static int wdrtas_token_set_indicator; 62 #define WDRTAS_SP_SPI 28 63 static int wdrtas_token_get_sp; 64 static int wdrtas_token_event_scan; 65 66 #define WDRTAS_DEFAULT_INTERVAL 300 67 68 #define WDRTAS_LOGBUFFER_LEN 128 69 static char wdrtas_logbuffer[WDRTAS_LOGBUFFER_LEN]; 70 71 72 /*** watchdog access functions */ 73 74 /** 75 * wdrtas_set_interval - sets the watchdog interval 76 * @interval: new interval 77 * 78 * returns 0 on success, <0 on failures 79 * 80 * wdrtas_set_interval sets the watchdog keepalive interval by calling the 81 * RTAS function set-indicator (surveillance). The unit of interval is 82 * seconds. 83 */ 84 85 static int wdrtas_set_interval(int interval) 86 { 87 long result; 88 static int print_msg = 10; 89 90 /* rtas uses minutes */ 91 interval = (interval + 59) / 60; 92 93 result = rtas_call(wdrtas_token_set_indicator, 3, 1, NULL, 94 WDRTAS_SURVEILLANCE_IND, 0, interval); 95 if (result < 0 && print_msg) { 96 printk(KERN_ERR "wdrtas: setting the watchdog to %i " 97 "timeout failed: %li\n", interval, result); 98 print_msg--; 99 } 100 101 return result; 102 } 103 104 #define WDRTAS_SP_SPI_LEN 4 105 106 /** 107 * wdrtas_get_interval - returns the current watchdog interval 108 * @fallback_value: value (in seconds) to use, if the RTAS call fails 109 * 110 * returns the interval 111 * 112 * wdrtas_get_interval returns the current watchdog keepalive interval 113 * as reported by the RTAS function ibm,get-system-parameter. The unit 114 * of the return value is seconds. 115 */ 116 static int wdrtas_get_interval(int fallback_value) 117 { 118 long result; 119 char value[WDRTAS_SP_SPI_LEN]; 120 121 spin_lock(&rtas_data_buf_lock); 122 memset(rtas_data_buf, 0, WDRTAS_SP_SPI_LEN); 123 result = rtas_call(wdrtas_token_get_sp, 3, 1, NULL, 124 WDRTAS_SP_SPI, __pa(rtas_data_buf), 125 WDRTAS_SP_SPI_LEN); 126 127 memcpy(value, rtas_data_buf, WDRTAS_SP_SPI_LEN); 128 spin_unlock(&rtas_data_buf_lock); 129 130 if (value[0] != 0 || value[1] != 2 || value[3] != 0 || result < 0) { 131 printk(KERN_WARNING "wdrtas: could not get sp_spi watchdog " 132 "timeout (%li). Continuing\n", result); 133 return fallback_value; 134 } 135 136 /* rtas uses minutes */ 137 return ((int)value[2]) * 60; 138 } 139 140 /** 141 * wdrtas_timer_start - starts watchdog 142 * 143 * wdrtas_timer_start starts the watchdog by calling the RTAS function 144 * set-interval (surveillance) 145 */ 146 static void wdrtas_timer_start(void) 147 { 148 wdrtas_set_interval(wdrtas_interval); 149 } 150 151 /** 152 * wdrtas_timer_stop - stops watchdog 153 * 154 * wdrtas_timer_stop stops the watchdog timer by calling the RTAS function 155 * set-interval (surveillance) 156 */ 157 static void wdrtas_timer_stop(void) 158 { 159 wdrtas_set_interval(0); 160 } 161 162 /** 163 * wdrtas_log_scanned_event - logs an event we received during keepalive 164 * 165 * wdrtas_log_scanned_event prints a message to the log buffer dumping 166 * the results of the last event-scan call 167 */ 168 static void wdrtas_log_scanned_event(void) 169 { 170 int i; 171 172 for (i = 0; i < WDRTAS_LOGBUFFER_LEN; i += 16) 173 printk(KERN_INFO "wdrtas: dumping event (line %i/%i), data = " 174 "%02x %02x %02x %02x %02x %02x %02x %02x " 175 "%02x %02x %02x %02x %02x %02x %02x %02x\n", 176 (i / 16) + 1, (WDRTAS_LOGBUFFER_LEN / 16), 177 wdrtas_logbuffer[i + 0], wdrtas_logbuffer[i + 1], 178 wdrtas_logbuffer[i + 2], wdrtas_logbuffer[i + 3], 179 wdrtas_logbuffer[i + 4], wdrtas_logbuffer[i + 5], 180 wdrtas_logbuffer[i + 6], wdrtas_logbuffer[i + 7], 181 wdrtas_logbuffer[i + 8], wdrtas_logbuffer[i + 9], 182 wdrtas_logbuffer[i + 10], wdrtas_logbuffer[i + 11], 183 wdrtas_logbuffer[i + 12], wdrtas_logbuffer[i + 13], 184 wdrtas_logbuffer[i + 14], wdrtas_logbuffer[i + 15]); 185 } 186 187 /** 188 * wdrtas_timer_keepalive - resets watchdog timer to keep system alive 189 * 190 * wdrtas_timer_keepalive restarts the watchdog timer by calling the 191 * RTAS function event-scan and repeats these calls as long as there are 192 * events available. All events will be dumped. 193 */ 194 static void wdrtas_timer_keepalive(void) 195 { 196 long result; 197 198 do { 199 result = rtas_call(wdrtas_token_event_scan, 4, 1, NULL, 200 RTAS_EVENT_SCAN_ALL_EVENTS, 0, 201 (void *)__pa(wdrtas_logbuffer), 202 WDRTAS_LOGBUFFER_LEN); 203 if (result < 0) 204 printk(KERN_ERR "wdrtas: event-scan failed: %li\n", 205 result); 206 if (result == 0) 207 wdrtas_log_scanned_event(); 208 } while (result == 0); 209 } 210 211 /** 212 * wdrtas_get_temperature - returns current temperature 213 * 214 * returns temperature or <0 on failures 215 * 216 * wdrtas_get_temperature returns the current temperature in Fahrenheit. It 217 * uses the RTAS call get-sensor-state, token 3 to do so 218 */ 219 static int wdrtas_get_temperature(void) 220 { 221 int result; 222 int temperature = 0; 223 224 result = rtas_get_sensor(WDRTAS_THERMAL_SENSOR, 0, &temperature); 225 226 if (result < 0) 227 printk(KERN_WARNING "wdrtas: reading the thermal sensor " 228 "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 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 printk(KERN_WARNING "wdrtas: got unexpected close. Watchdog " 423 "not stopped.\n"); 424 wdrtas_timer_keepalive(); 425 } 426 427 wdrtas_expect_close = 0; 428 atomic_dec(&wdrtas_miscdev_open); 429 return 0; 430 } 431 432 /** 433 * wdrtas_temp_read - gives back the temperature in fahrenheit 434 * @file: file structure 435 * @buf: user buffer 436 * @count: number of bytes to be read 437 * @ppos: position in file 438 * 439 * returns always 1 or -EFAULT in case of user space copy failures, <0 on 440 * other failures 441 * 442 * wdrtas_temp_read gives the temperature to the users by copying this 443 * value as one byte into the user space buffer. The unit is Fahrenheit... 444 */ 445 static ssize_t wdrtas_temp_read(struct file *file, char __user *buf, 446 size_t count, loff_t *ppos) 447 { 448 int temperature = 0; 449 450 temperature = wdrtas_get_temperature(); 451 if (temperature < 0) 452 return temperature; 453 454 if (copy_to_user(buf, &temperature, 1)) 455 return -EFAULT; 456 457 return 1; 458 } 459 460 /** 461 * wdrtas_temp_open - open function of temperature device 462 * @inode: inode structure 463 * @file: file structure 464 * 465 * returns 0 on success, <0 on failure 466 * 467 * function called when temperature device is opened 468 */ 469 static int wdrtas_temp_open(struct inode *inode, struct file *file) 470 { 471 return nonseekable_open(inode, file); 472 } 473 474 /** 475 * wdrtas_temp_close - close function of temperature device 476 * @inode: inode structure 477 * @file: file structure 478 * 479 * returns 0 on success 480 * 481 * close function. Always succeeds 482 */ 483 static int wdrtas_temp_close(struct inode *inode, struct file *file) 484 { 485 return 0; 486 } 487 488 /** 489 * wdrtas_reboot - reboot notifier function 490 * @nb: notifier block structure 491 * @code: reboot code 492 * @ptr: unused 493 * 494 * returns NOTIFY_DONE 495 * 496 * wdrtas_reboot stops the watchdog in case of a reboot 497 */ 498 static int wdrtas_reboot(struct notifier_block *this, 499 unsigned long code, void *ptr) 500 { 501 if (code == SYS_DOWN || code == SYS_HALT) 502 wdrtas_timer_stop(); 503 504 return NOTIFY_DONE; 505 } 506 507 /*** initialization stuff */ 508 509 static const struct file_operations wdrtas_fops = { 510 .owner = THIS_MODULE, 511 .llseek = no_llseek, 512 .write = wdrtas_write, 513 .unlocked_ioctl = wdrtas_ioctl, 514 .open = wdrtas_open, 515 .release = wdrtas_close, 516 }; 517 518 static struct miscdevice wdrtas_miscdev = { 519 .minor = WATCHDOG_MINOR, 520 .name = "watchdog", 521 .fops = &wdrtas_fops, 522 }; 523 524 static const struct file_operations wdrtas_temp_fops = { 525 .owner = THIS_MODULE, 526 .llseek = no_llseek, 527 .read = wdrtas_temp_read, 528 .open = wdrtas_temp_open, 529 .release = wdrtas_temp_close, 530 }; 531 532 static struct miscdevice wdrtas_tempdev = { 533 .minor = TEMP_MINOR, 534 .name = "temperature", 535 .fops = &wdrtas_temp_fops, 536 }; 537 538 static struct notifier_block wdrtas_notifier = { 539 .notifier_call = wdrtas_reboot, 540 }; 541 542 /** 543 * wdrtas_get_tokens - reads in RTAS tokens 544 * 545 * returns 0 on success, <0 on failure 546 * 547 * wdrtas_get_tokens reads in the tokens for the RTAS calls used in 548 * this watchdog driver. It tolerates, if "get-sensor-state" and 549 * "ibm,get-system-parameter" are not available. 550 */ 551 static int wdrtas_get_tokens(void) 552 { 553 wdrtas_token_get_sensor_state = rtas_token("get-sensor-state"); 554 if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE) { 555 printk(KERN_WARNING "wdrtas: couldn't get token for " 556 "get-sensor-state. Trying to continue without " 557 "temperature support.\n"); 558 } 559 560 wdrtas_token_get_sp = rtas_token("ibm,get-system-parameter"); 561 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) { 562 printk(KERN_WARNING "wdrtas: couldn't get token for " 563 "ibm,get-system-parameter. Trying to continue with " 564 "a default timeout value of %i seconds.\n", 565 WDRTAS_DEFAULT_INTERVAL); 566 } 567 568 wdrtas_token_set_indicator = rtas_token("set-indicator"); 569 if (wdrtas_token_set_indicator == RTAS_UNKNOWN_SERVICE) { 570 printk(KERN_ERR "wdrtas: couldn't get token for " 571 "set-indicator. Terminating watchdog code.\n"); 572 return -EIO; 573 } 574 575 wdrtas_token_event_scan = rtas_token("event-scan"); 576 if (wdrtas_token_event_scan == RTAS_UNKNOWN_SERVICE) { 577 printk(KERN_ERR "wdrtas: couldn't get token for event-scan. " 578 "Terminating watchdog code.\n"); 579 return -EIO; 580 } 581 582 return 0; 583 } 584 585 /** 586 * wdrtas_unregister_devs - unregisters the misc dev handlers 587 * 588 * wdrtas_register_devs unregisters the watchdog and temperature watchdog 589 * misc devs 590 */ 591 static void wdrtas_unregister_devs(void) 592 { 593 misc_deregister(&wdrtas_miscdev); 594 if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE) 595 misc_deregister(&wdrtas_tempdev); 596 } 597 598 /** 599 * wdrtas_register_devs - registers the misc dev handlers 600 * 601 * returns 0 on success, <0 on failure 602 * 603 * wdrtas_register_devs registers the watchdog and temperature watchdog 604 * misc devs 605 */ 606 static int wdrtas_register_devs(void) 607 { 608 int result; 609 610 result = misc_register(&wdrtas_miscdev); 611 if (result) { 612 printk(KERN_ERR "wdrtas: couldn't register watchdog misc " 613 "device. Terminating watchdog code.\n"); 614 return result; 615 } 616 617 if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE) { 618 result = misc_register(&wdrtas_tempdev); 619 if (result) { 620 printk(KERN_WARNING "wdrtas: couldn't register " 621 "watchdog temperature misc device. Continuing " 622 "without temperature support.\n"); 623 wdrtas_token_get_sensor_state = RTAS_UNKNOWN_SERVICE; 624 } 625 } 626 627 return 0; 628 } 629 630 /** 631 * wdrtas_init - init function of the watchdog driver 632 * 633 * returns 0 on success, <0 on failure 634 * 635 * registers the file handlers and the reboot notifier 636 */ 637 static int __init wdrtas_init(void) 638 { 639 if (wdrtas_get_tokens()) 640 return -ENODEV; 641 642 if (wdrtas_register_devs()) 643 return -ENODEV; 644 645 if (register_reboot_notifier(&wdrtas_notifier)) { 646 printk(KERN_ERR "wdrtas: could not register reboot notifier. " 647 "Terminating watchdog code.\n"); 648 wdrtas_unregister_devs(); 649 return -ENODEV; 650 } 651 652 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) 653 wdrtas_interval = WDRTAS_DEFAULT_INTERVAL; 654 else 655 wdrtas_interval = wdrtas_get_interval(WDRTAS_DEFAULT_INTERVAL); 656 657 return 0; 658 } 659 660 /** 661 * wdrtas_exit - exit function of the watchdog driver 662 * 663 * unregisters the file handlers and the reboot notifier 664 */ 665 static void __exit wdrtas_exit(void) 666 { 667 if (!wdrtas_nowayout) 668 wdrtas_timer_stop(); 669 670 wdrtas_unregister_devs(); 671 672 unregister_reboot_notifier(&wdrtas_notifier); 673 } 674 675 module_init(wdrtas_init); 676 module_exit(wdrtas_exit); 677