drivers/watchdog/hpwdt.c

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