drivers/watchdog/hpwdt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *      HPE WatchDog Driver
   4  *      based on
   5  *
   6  *      SoftDog 0.05:   A Software Watchdog Device
   7  *
   8  *      (c) Copyright 2018 Hewlett Packard Enterprise Development LP
   9  *      Thomas Mingarelli <thomas.mingarelli@hpe.com>
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/device.h>
  15 #include <linux/io.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/pci.h>
  20 #include <linux/pci_ids.h>
  21 #include <linux/types.h>
  22 #include <linux/watchdog.h>
  23 #ifdef CONFIG_HPWDT_NMI_DECODING
  24 #include <asm/nmi.h>
  25 #endif
  26 #include <linux/crash_dump.h>
  27
  28 #define HPWDT_VERSION                   "2.0.4"
  29 #define SECS_TO_TICKS(secs)             ((secs) * 1000 / 128)
  30 #define TICKS_TO_SECS(ticks)            ((ticks) * 128 / 1000)
  31 #define HPWDT_MAX_TICKS                 65535
  32 #define HPWDT_MAX_TIMER                 TICKS_TO_SECS(HPWDT_MAX_TICKS)
  33 #define DEFAULT_MARGIN                  30
  34 #define PRETIMEOUT_SEC                  9
  35
  36 static unsigned int soft_margin = DEFAULT_MARGIN;       /* in seconds */
  37 static bool nowayout = WATCHDOG_NOWAYOUT;
  38 static bool pretimeout = IS_ENABLED(CONFIG_HPWDT_NMI_DECODING);
  39 static int kdumptimeout = -1;
  40
  41 static void __iomem *pci_mem_addr;              /* the PCI-memory address */
  42 static unsigned long __iomem *hpwdt_nmistat;
  43 static unsigned long __iomem *hpwdt_timer_reg;
  44 static unsigned long __iomem *hpwdt_timer_con;
  45
  46 static const struct pci_device_id hpwdt_devices[] = {
  47         { PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xB203) },   /* iLO2 */
  48         { PCI_DEVICE(PCI_VENDOR_ID_HP, 0x3306) },       /* iLO3 */
  49         { PCI_DEVICE(PCI_VENDOR_ID_HP_3PAR, 0x0389) },  /* PCtrl */
  50         {0},                    /* terminate list */
  51 };
  52 MODULE_DEVICE_TABLE(pci, hpwdt_devices);
  53
  54 static const struct pci_device_id hpwdt_blacklist[] = {
  55         { PCI_DEVICE_SUB(PCI_VENDOR_ID_HP, 0x3306, PCI_VENDOR_ID_HP, 0x1979) }, /* auxilary iLO */
  56         { PCI_DEVICE_SUB(PCI_VENDOR_ID_HP, 0x3306, PCI_VENDOR_ID_HP_3PAR, 0x0289) },  /* CL */
  57         {0},                    /* terminate list */
  58 };
  59
  60 static struct watchdog_device hpwdt_dev;
  61 /*
  62  *      Watchdog operations
  63  */
  64 static int hpwdt_hw_is_running(void)
  65 {
  66         return ioread8(hpwdt_timer_con) & 0x01;
  67 }
  68
  69 static int hpwdt_start(struct watchdog_device *wdd)
  70 {
  71         int control = 0x81 | (pretimeout ? 0x4 : 0);
  72         int reload = SECS_TO_TICKS(min(wdd->timeout, wdd->max_hw_heartbeat_ms/1000));
  73
  74         dev_dbg(wdd->parent, "start watchdog 0x%08x:0x%08x:0x%02x\n", wdd->timeout, reload, control);
  75         iowrite16(reload, hpwdt_timer_reg);
  76         iowrite8(control, hpwdt_timer_con);
  77
  78         return 0;
  79 }
  80
  81 static void hpwdt_stop(void)
  82 {
  83         unsigned long data;
  84
  85         pr_debug("stop  watchdog\n");
  86
  87         data = ioread8(hpwdt_timer_con);
  88         data &= 0xFE;
  89         iowrite8(data, hpwdt_timer_con);
  90 }
  91
  92 static int hpwdt_stop_core(struct watchdog_device *wdd)
  93 {
  94         hpwdt_stop();
  95
  96         return 0;
  97 }
  98
  99 static void hpwdt_ping_ticks(int val)
 100 {
 101         val = min(val, HPWDT_MAX_TICKS);
 102         iowrite16(val, hpwdt_timer_reg);
 103 }
 104
 105 static int hpwdt_ping(struct watchdog_device *wdd)
 106 {
 107         int reload = SECS_TO_TICKS(min(wdd->timeout, wdd->max_hw_heartbeat_ms/1000));
 108
 109         dev_dbg(wdd->parent, "ping  watchdog 0x%08x:0x%08x\n", wdd->timeout, reload);
 110         hpwdt_ping_ticks(reload);
 111
 112         return 0;
 113 }
 114
 115 static unsigned int hpwdt_gettimeleft(struct watchdog_device *wdd)
 116 {
 117         return TICKS_TO_SECS(ioread16(hpwdt_timer_reg));
 118 }
 119
 120 static int hpwdt_settimeout(struct watchdog_device *wdd, unsigned int val)
 121 {
 122         dev_dbg(wdd->parent, "set_timeout = %d\n", val);
 123
 124         wdd->timeout = val;
 125         if (val <= wdd->pretimeout) {
 126                 dev_dbg(wdd->parent, "pretimeout < timeout. Setting to zero\n");
 127                 wdd->pretimeout = 0;
 128                 pretimeout = false;
 129                 if (watchdog_active(wdd))
 130                         hpwdt_start(wdd);
 131         }
 132         hpwdt_ping(wdd);
 133
 134         return 0;
 135 }
 136
 137 #ifdef CONFIG_HPWDT_NMI_DECODING
 138 static int hpwdt_set_pretimeout(struct watchdog_device *wdd, unsigned int req)
 139 {
 140         unsigned int val = 0;
 141
 142         dev_dbg(wdd->parent, "set_pretimeout = %d\n", req);
 143         if (req) {
 144                 val = PRETIMEOUT_SEC;
 145                 if (val >= wdd->timeout)
 146                         return -EINVAL;
 147         }
 148
 149         if (val != req)
 150                 dev_dbg(wdd->parent, "Rounding pretimeout to: %d\n", val);
 151
 152         wdd->pretimeout = val;
 153         pretimeout = !!val;
 154
 155         if (watchdog_active(wdd))
 156                 hpwdt_start(wdd);
 157
 158         return 0;
 159 }
 160
 161 static int hpwdt_my_nmi(void)
 162 {
 163         return ioread8(hpwdt_nmistat) & 0x6;
 164 }
 165
 166 /*
 167  *      NMI Handler
 168  */
 169 static int hpwdt_pretimeout(unsigned int ulReason, struct pt_regs *regs)
 170 {
 171         unsigned int mynmi = hpwdt_my_nmi();
 172         static char panic_msg[] =
 173                 "00: An NMI occurred. Depending on your system the reason "
 174                 "for the NMI is logged in any one of the following resources:\n"
 175                 "1. Integrated Management Log (IML)\n"
 176                 "2. OA Syslog\n"
 177                 "3. OA Forward Progress Log\n"
 178                 "4. iLO Event Log";
 179
 180         if (ulReason == NMI_UNKNOWN && !mynmi)
 181                 return NMI_DONE;
 182
 183         if (kdumptimeout < 0)
 184                 hpwdt_stop();
 185         else if (kdumptimeout == 0)
 186                 ;
 187         else {
 188                 unsigned int val = max((unsigned int)kdumptimeout, hpwdt_dev.timeout);
 189                 hpwdt_ping_ticks(SECS_TO_TICKS(val));
 190         }
 191
 192         hex_byte_pack(panic_msg, mynmi);
 193         nmi_panic(regs, panic_msg);
 194
 195         return NMI_HANDLED;
 196 }
 197 #endif /* CONFIG_HPWDT_NMI_DECODING */
 198
 199
 200 static const struct watchdog_info ident = {
 201         .options = WDIOF_PRETIMEOUT    |
 202                    WDIOF_SETTIMEOUT    |
 203                    WDIOF_KEEPALIVEPING |
 204                    WDIOF_MAGICCLOSE,
 205         .identity = "HPE iLO2+ HW Watchdog Timer",
 206 };
 207
 208 /*
 209  *      Kernel interfaces
 210  */
 211
 212 static const struct watchdog_ops hpwdt_ops = {
 213         .owner          = THIS_MODULE,
 214         .start          = hpwdt_start,
 215         .stop           = hpwdt_stop_core,
 216         .ping           = hpwdt_ping,
 217         .set_timeout    = hpwdt_settimeout,
 218         .get_timeleft   = hpwdt_gettimeleft,
 219 #ifdef CONFIG_HPWDT_NMI_DECODING
 220         .set_pretimeout = hpwdt_set_pretimeout,
 221 #endif
 222 };
 223
 224 static struct watchdog_device hpwdt_dev = {
 225         .info           = &ident,
 226         .ops            = &hpwdt_ops,
 227         .min_timeout    = 1,
 228         .timeout        = DEFAULT_MARGIN,
 229         .pretimeout     = PRETIMEOUT_SEC,
 230         .max_hw_heartbeat_ms    = HPWDT_MAX_TIMER * 1000,
 231 };
 232
 233
 234 /*
 235  *      Init & Exit
 236  */
 237
 238 static int hpwdt_init_nmi_decoding(struct pci_dev *dev)
 239 {
 240 #ifdef CONFIG_HPWDT_NMI_DECODING
 241         int retval;
 242         /*
 243          * Only one function can register for NMI_UNKNOWN
 244          */
 245         retval = register_nmi_handler(NMI_UNKNOWN, hpwdt_pretimeout, 0, "hpwdt");
 246         if (retval)
 247                 goto error;
 248         retval = register_nmi_handler(NMI_SERR, hpwdt_pretimeout, 0, "hpwdt");
 249         if (retval)
 250                 goto error1;
 251         retval = register_nmi_handler(NMI_IO_CHECK, hpwdt_pretimeout, 0, "hpwdt");
 252         if (retval)
 253                 goto error2;
 254
 255         dev_info(&dev->dev,
 256                 "HPE Watchdog Timer Driver: NMI decoding initialized\n");
 257
 258         return 0;
 259
 260 error2:
 261         unregister_nmi_handler(NMI_SERR, "hpwdt");
 262 error1:
 263         unregister_nmi_handler(NMI_UNKNOWN, "hpwdt");
 264 error:
 265         dev_warn(&dev->dev,
 266                 "Unable to register a die notifier (err=%d).\n",
 267                 retval);
 268         return retval;
 269 #endif  /* CONFIG_HPWDT_NMI_DECODING */
 270         return 0;
 271 }
 272
 273 static void hpwdt_exit_nmi_decoding(void)
 274 {
 275 #ifdef CONFIG_HPWDT_NMI_DECODING
 276         unregister_nmi_handler(NMI_UNKNOWN, "hpwdt");
 277         unregister_nmi_handler(NMI_SERR, "hpwdt");
 278         unregister_nmi_handler(NMI_IO_CHECK, "hpwdt");
 279 #endif
 280 }
 281
 282 static int hpwdt_init_one(struct pci_dev *dev,
 283                                         const struct pci_device_id *ent)
 284 {
 285         int retval;
 286
 287         /*
 288          * First let's find out if we are on an iLO2+ server. We will
 289          * not run on a legacy ASM box.
 290          * So we only support the G5 ProLiant servers and higher.
 291          */
 292         if (dev->subsystem_vendor != PCI_VENDOR_ID_HP &&
 293             dev->subsystem_vendor != PCI_VENDOR_ID_HP_3PAR) {
 294                 dev_warn(&dev->dev,
 295                         "This server does not have an iLO2+ ASIC.\n");
 296                 return -ENODEV;
 297         }
 298
 299         if (pci_match_id(hpwdt_blacklist, dev)) {
 300                 dev_dbg(&dev->dev, "Not supported on this device\n");
 301                 return -ENODEV;
 302         }
 303
 304         if (pci_enable_device(dev)) {
 305                 dev_warn(&dev->dev,
 306                         "Not possible to enable PCI Device: 0x%x:0x%x.\n",
 307                         ent->vendor, ent->device);
 308                 return -ENODEV;
 309         }
 310
 311         pci_mem_addr = pci_iomap(dev, 1, 0x80);
 312         if (!pci_mem_addr) {
 313                 dev_warn(&dev->dev,
 314                         "Unable to detect the iLO2+ server memory.\n");
 315                 retval = -ENOMEM;
 316                 goto error_pci_iomap;
 317         }
 318         hpwdt_nmistat   = pci_mem_addr + 0x6e;
 319         hpwdt_timer_reg = pci_mem_addr + 0x70;
 320         hpwdt_timer_con = pci_mem_addr + 0x72;
 321
 322         /* Have the core update running timer until user space is ready */
 323         if (hpwdt_hw_is_running()) {
 324                 dev_info(&dev->dev, "timer is running\n");
 325                 set_bit(WDOG_HW_RUNNING, &hpwdt_dev.status);
 326         }
 327
 328         /* Initialize NMI Decoding functionality */
 329         retval = hpwdt_init_nmi_decoding(dev);
 330         if (retval != 0)
 331                 goto error_init_nmi_decoding;
 332
 333         watchdog_stop_on_unregister(&hpwdt_dev);
 334         watchdog_set_nowayout(&hpwdt_dev, nowayout);
 335         watchdog_init_timeout(&hpwdt_dev, soft_margin, NULL);
 336
 337         if (is_kdump_kernel()) {
 338                 pretimeout = false;
 339                 kdumptimeout = 0;
 340         }
 341
 342         if (pretimeout && hpwdt_dev.timeout <= PRETIMEOUT_SEC) {
 343                 dev_warn(&dev->dev, "timeout <= pretimeout. Setting pretimeout to zero\n");
 344                 pretimeout = false;
 345         }
 346         hpwdt_dev.pretimeout = pretimeout ? PRETIMEOUT_SEC : 0;
 347         kdumptimeout = min(kdumptimeout, HPWDT_MAX_TIMER);
 348
 349         hpwdt_dev.parent = &dev->dev;
 350         retval = watchdog_register_device(&hpwdt_dev);
 351         if (retval < 0)
 352                 goto error_wd_register;
 353
 354         dev_info(&dev->dev, "HPE Watchdog Timer Driver: Version: %s\n",
 355                                 HPWDT_VERSION);
 356         dev_info(&dev->dev, "timeout: %d seconds (nowayout=%d)\n",
 357                                 hpwdt_dev.timeout, nowayout);
 358         dev_info(&dev->dev, "pretimeout: %s.\n",
 359                                 pretimeout ? "on" : "off");
 360         dev_info(&dev->dev, "kdumptimeout: %d.\n", kdumptimeout);
 361
 362         return 0;
 363
 364 error_wd_register:
 365         hpwdt_exit_nmi_decoding();
 366 error_init_nmi_decoding:
 367         pci_iounmap(dev, pci_mem_addr);
 368 error_pci_iomap:
 369         pci_disable_device(dev);
 370         return retval;
 371 }
 372
 373 static void hpwdt_exit(struct pci_dev *dev)
 374 {
 375         watchdog_unregister_device(&hpwdt_dev);
 376         hpwdt_exit_nmi_decoding();
 377         pci_iounmap(dev, pci_mem_addr);
 378         pci_disable_device(dev);
 379 }
 380
 381 static int hpwdt_suspend(struct device *dev)
 382 {
 383         if (watchdog_active(&hpwdt_dev))
 384                 hpwdt_stop();
 385
 386         return 0;
 387 }
 388
 389 static int hpwdt_resume(struct device *dev)
 390 {
 391         if (watchdog_active(&hpwdt_dev))
 392                 hpwdt_start(&hpwdt_dev);
 393
 394         return 0;
 395 }
 396
 397 static const struct dev_pm_ops hpwdt_pm_ops = {
 398         LATE_SYSTEM_SLEEP_PM_OPS(hpwdt_suspend, hpwdt_resume)
 399 };
 400
 401 static struct pci_driver hpwdt_driver = {
 402         .name = "hpwdt",
 403         .id_table = hpwdt_devices,
 404         .probe = hpwdt_init_one,
 405         .remove = hpwdt_exit,
 406
 407         .driver = {
 408                 .name = "hpwdt",
 409                 .pm = &hpwdt_pm_ops,
 410         }
 411 };
 412
 413 MODULE_AUTHOR("Tom Mingarelli");
 414 MODULE_DESCRIPTION("hpe watchdog driver");
 415 MODULE_LICENSE("GPL");
 416 MODULE_VERSION(HPWDT_VERSION);
 417
 418 module_param(soft_margin, int, 0);
 419 MODULE_PARM_DESC(soft_margin, "Watchdog timeout in seconds");
 420
 421 module_param_named(timeout, soft_margin, int, 0);
 422 MODULE_PARM_DESC(timeout, "Alias of soft_margin");
 423
 424 module_param(nowayout, bool, 0);
 425 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 426                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 427
 428 module_param(kdumptimeout, int, 0444);
 429 MODULE_PARM_DESC(kdumptimeout, "Timeout applied for crash kernel transition in seconds");
 430
 431 #ifdef CONFIG_HPWDT_NMI_DECODING
 432 module_param(pretimeout, bool, 0);
 433 MODULE_PARM_DESC(pretimeout, "Watchdog pretimeout enabled");
 434 #endif
 435
 436 module_pci_driver(hpwdt_driver);