drivers/watchdog/wdrtas.c

   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
  52 static bool 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                 pr_err("setting the watchdog to %i timeout failed: %li\n",
  97                        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                 pr_warn("could not get sp_spi watchdog timeout (%li). Continuing\n",
 132                         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_timer_keepalive - resets watchdog timer to keep system alive
 164  *
 165  * wdrtas_timer_keepalive restarts the watchdog timer by calling the
 166  * RTAS function event-scan and repeats these calls as long as there are
 167  * events available. All events will be dumped.
 168  */
 169 static void wdrtas_timer_keepalive(void)
 170 {
 171         long result;
 172
 173         do {
 174                 result = rtas_call(wdrtas_token_event_scan, 4, 1, NULL,
 175                                    RTAS_EVENT_SCAN_ALL_EVENTS, 0,
 176                                    (void *)__pa(wdrtas_logbuffer),
 177                                    WDRTAS_LOGBUFFER_LEN);
 178                 if (result < 0)
 179                         pr_err("event-scan failed: %li\n", result);
 180                 if (result == 0)
 181                         print_hex_dump(KERN_INFO, "dumping event, data: ",
 182                                 DUMP_PREFIX_OFFSET, 16, 1,
 183                                 wdrtas_logbuffer, WDRTAS_LOGBUFFER_LEN, false);
 184         } while (result == 0);
 185 }
 186
 187 /**
 188  * wdrtas_get_temperature - returns current temperature
 189  *
 190  * returns temperature or <0 on failures
 191  *
 192  * wdrtas_get_temperature returns the current temperature in Fahrenheit. It
 193  * uses the RTAS call get-sensor-state, token 3 to do so
 194  */
 195 static int wdrtas_get_temperature(void)
 196 {
 197         int result;
 198         int temperature = 0;
 199
 200         result = rtas_get_sensor(WDRTAS_THERMAL_SENSOR, 0, &temperature);
 201
 202         if (result < 0)
 203                 pr_warn("reading the thermal sensor failed: %i\n", result);
 204         else
 205                 temperature = ((temperature * 9) / 5) + 32; /* fahrenheit */
 206
 207         return temperature;
 208 }
 209
 210 /**
 211  * wdrtas_get_status - returns the status of the watchdog
 212  *
 213  * returns a bitmask of defines WDIOF_... as defined in
 214  * include/linux/watchdog.h
 215  */
 216 static int wdrtas_get_status(void)
 217 {
 218         return 0; /* TODO */
 219 }
 220
 221 /**
 222  * wdrtas_get_boot_status - returns the reason for the last boot
 223  *
 224  * returns a bitmask of defines WDIOF_... as defined in
 225  * include/linux/watchdog.h, indicating why the watchdog rebooted the system
 226  */
 227 static int wdrtas_get_boot_status(void)
 228 {
 229         return 0; /* TODO */
 230 }
 231
 232 /*** watchdog API and operations stuff */
 233
 234 /* wdrtas_write - called when watchdog device is written to
 235  * @file: file structure
 236  * @buf: user buffer with data
 237  * @len: amount to data written
 238  * @ppos: position in file
 239  *
 240  * returns the number of successfully processed characters, which is always
 241  * the number of bytes passed to this function
 242  *
 243  * wdrtas_write processes all the data given to it and looks for the magic
 244  * character 'V'. This character allows the watchdog device to be closed
 245  * properly.
 246  */
 247 static ssize_t wdrtas_write(struct file *file, const char __user *buf,
 248              size_t len, loff_t *ppos)
 249 {
 250         int i;
 251         char c;
 252
 253         if (!len)
 254                 goto out;
 255
 256         if (!wdrtas_nowayout) {
 257                 wdrtas_expect_close = 0;
 258                 /* look for 'V' */
 259                 for (i = 0; i < len; i++) {
 260                         if (get_user(c, buf + i))
 261                                 return -EFAULT;
 262                         /* allow to close device */
 263                         if (c == 'V')
 264                                 wdrtas_expect_close = WDRTAS_MAGIC_CHAR;
 265                 }
 266         }
 267
 268         wdrtas_timer_keepalive();
 269
 270 out:
 271         return len;
 272 }
 273
 274 /**
 275  * wdrtas_ioctl - ioctl function for the watchdog device
 276  * @file: file structure
 277  * @cmd: command for ioctl
 278  * @arg: argument pointer
 279  *
 280  * returns 0 on success, <0 on failure
 281  *
 282  * wdrtas_ioctl implements the watchdog API ioctls
 283  */
 284
 285 static long wdrtas_ioctl(struct file *file, unsigned int cmd,
 286                                                         unsigned long arg)
 287 {
 288         int __user *argp = (void __user *)arg;
 289         int i;
 290         static const struct watchdog_info wdinfo = {
 291                 .options = WDRTAS_SUPPORTED_MASK,
 292                 .firmware_version = 0,
 293                 .identity = "wdrtas",
 294         };
 295
 296         switch (cmd) {
 297         case WDIOC_GETSUPPORT:
 298                 if (copy_to_user(argp, &wdinfo, sizeof(wdinfo)))
 299                         return -EFAULT;
 300                 return 0;
 301
 302         case WDIOC_GETSTATUS:
 303                 i = wdrtas_get_status();
 304                 return put_user(i, argp);
 305
 306         case WDIOC_GETBOOTSTATUS:
 307                 i = wdrtas_get_boot_status();
 308                 return put_user(i, argp);
 309
 310         case WDIOC_GETTEMP:
 311                 if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE)
 312                         return -EOPNOTSUPP;
 313
 314                 i = wdrtas_get_temperature();
 315                 return put_user(i, argp);
 316
 317         case WDIOC_SETOPTIONS:
 318                 if (get_user(i, argp))
 319                         return -EFAULT;
 320                 if (i & WDIOS_DISABLECARD)
 321                         wdrtas_timer_stop();
 322                 if (i & WDIOS_ENABLECARD) {
 323                         wdrtas_timer_keepalive();
 324                         wdrtas_timer_start();
 325                 }
 326                 /* not implemented. Done by H8
 327                 if (i & WDIOS_TEMPPANIC) {
 328                 } */
 329                 return 0;
 330
 331         case WDIOC_KEEPALIVE:
 332                 wdrtas_timer_keepalive();
 333                 return 0;
 334
 335         case WDIOC_SETTIMEOUT:
 336                 if (get_user(i, argp))
 337                         return -EFAULT;
 338
 339                 if (wdrtas_set_interval(i))
 340                         return -EINVAL;
 341
 342                 wdrtas_timer_keepalive();
 343
 344                 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE)
 345                         wdrtas_interval = i;
 346                 else
 347                         wdrtas_interval = wdrtas_get_interval(i);
 348                 /* fallthrough */
 349
 350         case WDIOC_GETTIMEOUT:
 351                 return put_user(wdrtas_interval, argp);
 352
 353         default:
 354                 return -ENOTTY;
 355         }
 356 }
 357
 358 /**
 359  * wdrtas_open - open function of watchdog device
 360  * @inode: inode structure
 361  * @file: file structure
 362  *
 363  * returns 0 on success, -EBUSY if the file has been opened already, <0 on
 364  * other failures
 365  *
 366  * function called when watchdog device is opened
 367  */
 368 static int wdrtas_open(struct inode *inode, struct file *file)
 369 {
 370         /* only open once */
 371         if (atomic_inc_return(&wdrtas_miscdev_open) > 1) {
 372                 atomic_dec(&wdrtas_miscdev_open);
 373                 return -EBUSY;
 374         }
 375
 376         wdrtas_timer_start();
 377         wdrtas_timer_keepalive();
 378
 379         return nonseekable_open(inode, file);
 380 }
 381
 382 /**
 383  * wdrtas_close - close function of watchdog device
 384  * @inode: inode structure
 385  * @file: file structure
 386  *
 387  * returns 0 on success
 388  *
 389  * close function. Always succeeds
 390  */
 391 static int wdrtas_close(struct inode *inode, struct file *file)
 392 {
 393         /* only stop watchdog, if this was announced using 'V' before */
 394         if (wdrtas_expect_close == WDRTAS_MAGIC_CHAR)
 395                 wdrtas_timer_stop();
 396         else {
 397                 pr_warn("got unexpected close. Watchdog not stopped.\n");
 398                 wdrtas_timer_keepalive();
 399         }
 400
 401         wdrtas_expect_close = 0;
 402         atomic_dec(&wdrtas_miscdev_open);
 403         return 0;
 404 }
 405
 406 /**
 407  * wdrtas_temp_read - gives back the temperature in fahrenheit
 408  * @file: file structure
 409  * @buf: user buffer
 410  * @count: number of bytes to be read
 411  * @ppos: position in file
 412  *
 413  * returns always 1 or -EFAULT in case of user space copy failures, <0 on
 414  * other failures
 415  *
 416  * wdrtas_temp_read gives the temperature to the users by copying this
 417  * value as one byte into the user space buffer. The unit is Fahrenheit...
 418  */
 419 static ssize_t wdrtas_temp_read(struct file *file, char __user *buf,
 420                  size_t count, loff_t *ppos)
 421 {
 422         int temperature = 0;
 423
 424         temperature = wdrtas_get_temperature();
 425         if (temperature < 0)
 426                 return temperature;
 427
 428         if (copy_to_user(buf, &temperature, 1))
 429                 return -EFAULT;
 430
 431         return 1;
 432 }
 433
 434 /**
 435  * wdrtas_temp_open - open function of temperature device
 436  * @inode: inode structure
 437  * @file: file structure
 438  *
 439  * returns 0 on success, <0 on failure
 440  *
 441  * function called when temperature device is opened
 442  */
 443 static int wdrtas_temp_open(struct inode *inode, struct file *file)
 444 {
 445         return nonseekable_open(inode, file);
 446 }
 447
 448 /**
 449  * wdrtas_temp_close - close function of temperature device
 450  * @inode: inode structure
 451  * @file: file structure
 452  *
 453  * returns 0 on success
 454  *
 455  * close function. Always succeeds
 456  */
 457 static int wdrtas_temp_close(struct inode *inode, struct file *file)
 458 {
 459         return 0;
 460 }
 461
 462 /**
 463  * wdrtas_reboot - reboot notifier function
 464  * @nb: notifier block structure
 465  * @code: reboot code
 466  * @ptr: unused
 467  *
 468  * returns NOTIFY_DONE
 469  *
 470  * wdrtas_reboot stops the watchdog in case of a reboot
 471  */
 472 static int wdrtas_reboot(struct notifier_block *this,
 473                                         unsigned long code, void *ptr)
 474 {
 475         if (code == SYS_DOWN || code == SYS_HALT)
 476                 wdrtas_timer_stop();
 477
 478         return NOTIFY_DONE;
 479 }
 480
 481 /*** initialization stuff */
 482
 483 static const struct file_operations wdrtas_fops = {
 484         .owner          = THIS_MODULE,
 485         .llseek         = no_llseek,
 486         .write          = wdrtas_write,
 487         .unlocked_ioctl = wdrtas_ioctl,
 488         .open           = wdrtas_open,
 489         .release        = wdrtas_close,
 490 };
 491
 492 static struct miscdevice wdrtas_miscdev = {
 493         .minor =        WATCHDOG_MINOR,
 494         .name =         "watchdog",
 495         .fops =         &wdrtas_fops,
 496 };
 497
 498 static const struct file_operations wdrtas_temp_fops = {
 499         .owner          = THIS_MODULE,
 500         .llseek         = no_llseek,
 501         .read           = wdrtas_temp_read,
 502         .open           = wdrtas_temp_open,
 503         .release        = wdrtas_temp_close,
 504 };
 505
 506 static struct miscdevice wdrtas_tempdev = {
 507         .minor =        TEMP_MINOR,
 508         .name =         "temperature",
 509         .fops =         &wdrtas_temp_fops,
 510 };
 511
 512 static struct notifier_block wdrtas_notifier = {
 513         .notifier_call =        wdrtas_reboot,
 514 };
 515
 516 /**
 517  * wdrtas_get_tokens - reads in RTAS tokens
 518  *
 519  * returns 0 on success, <0 on failure
 520  *
 521  * wdrtas_get_tokens reads in the tokens for the RTAS calls used in
 522  * this watchdog driver. It tolerates, if "get-sensor-state" and
 523  * "ibm,get-system-parameter" are not available.
 524  */
 525 static int wdrtas_get_tokens(void)
 526 {
 527         wdrtas_token_get_sensor_state = rtas_token("get-sensor-state");
 528         if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE) {
 529                 pr_warn("couldn't get token for get-sensor-state. Trying to continue without temperature support.\n");
 530         }
 531
 532         wdrtas_token_get_sp = rtas_token("ibm,get-system-parameter");
 533         if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) {
 534                 pr_warn("couldn't get token for ibm,get-system-parameter. Trying to continue with a default timeout value of %i seconds.\n",
 535                         WDRTAS_DEFAULT_INTERVAL);
 536         }
 537
 538         wdrtas_token_set_indicator = rtas_token("set-indicator");
 539         if (wdrtas_token_set_indicator == RTAS_UNKNOWN_SERVICE) {
 540                 pr_err("couldn't get token for set-indicator. Terminating watchdog code.\n");
 541                 return -EIO;
 542         }
 543
 544         wdrtas_token_event_scan = rtas_token("event-scan");
 545         if (wdrtas_token_event_scan == RTAS_UNKNOWN_SERVICE) {
 546                 pr_err("couldn't get token for event-scan. Terminating watchdog code.\n");
 547                 return -EIO;
 548         }
 549
 550         return 0;
 551 }
 552
 553 /**
 554  * wdrtas_unregister_devs - unregisters the misc dev handlers
 555  *
 556  * wdrtas_register_devs unregisters the watchdog and temperature watchdog
 557  * misc devs
 558  */
 559 static void wdrtas_unregister_devs(void)
 560 {
 561         misc_deregister(&wdrtas_miscdev);
 562         if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE)
 563                 misc_deregister(&wdrtas_tempdev);
 564 }
 565
 566 /**
 567  * wdrtas_register_devs - registers the misc dev handlers
 568  *
 569  * returns 0 on success, <0 on failure
 570  *
 571  * wdrtas_register_devs registers the watchdog and temperature watchdog
 572  * misc devs
 573  */
 574 static int wdrtas_register_devs(void)
 575 {
 576         int result;
 577
 578         result = misc_register(&wdrtas_miscdev);
 579         if (result) {
 580                 pr_err("couldn't register watchdog misc device. Terminating watchdog code.\n");
 581                 return result;
 582         }
 583
 584         if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE) {
 585                 result = misc_register(&wdrtas_tempdev);
 586                 if (result) {
 587                         pr_warn("couldn't register watchdog temperature misc device. Continuing without temperature support.\n");
 588                         wdrtas_token_get_sensor_state = RTAS_UNKNOWN_SERVICE;
 589                 }
 590         }
 591
 592         return 0;
 593 }
 594
 595 /**
 596  * wdrtas_init - init function of the watchdog driver
 597  *
 598  * returns 0 on success, <0 on failure
 599  *
 600  * registers the file handlers and the reboot notifier
 601  */
 602 static int __init wdrtas_init(void)
 603 {
 604         if (wdrtas_get_tokens())
 605                 return -ENODEV;
 606
 607         if (wdrtas_register_devs())
 608                 return -ENODEV;
 609
 610         if (register_reboot_notifier(&wdrtas_notifier)) {
 611                 pr_err("could not register reboot notifier. Terminating watchdog code.\n");
 612                 wdrtas_unregister_devs();
 613                 return -ENODEV;
 614         }
 615
 616         if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE)
 617                 wdrtas_interval = WDRTAS_DEFAULT_INTERVAL;
 618         else
 619                 wdrtas_interval = wdrtas_get_interval(WDRTAS_DEFAULT_INTERVAL);
 620
 621         return 0;
 622 }
 623
 624 /**
 625  * wdrtas_exit - exit function of the watchdog driver
 626  *
 627  * unregisters the file handlers and the reboot notifier
 628  */
 629 static void __exit wdrtas_exit(void)
 630 {
 631         if (!wdrtas_nowayout)
 632                 wdrtas_timer_stop();
 633
 634         wdrtas_unregister_devs();
 635
 636         unregister_reboot_notifier(&wdrtas_notifier);
 637 }
 638
 639 module_init(wdrtas_init);
 640 module_exit(wdrtas_exit);