drivers/watchdog/kempld_wdt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Kontron PLD watchdog driver
   4  *
   5  * Copyright (c) 2010-2013 Kontron Europe GmbH
   6  * Author: Michael Brunner <michael.brunner@kontron.com>
   7  *
   8  * Note: From the PLD watchdog point of view timeout and pretimeout are
   9  *       defined differently than in the kernel.
  10  *       First the pretimeout stage runs out before the timeout stage gets
  11  *       active.
  12  *
  13  * Kernel/API:                     P-----| pretimeout
  14  *               |-----------------------T timeout
  15  * Watchdog:     |-----------------P       pretimeout_stage
  16  *                                 |-----T timeout_stage
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/moduleparam.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/watchdog.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/mfd/kempld.h>
  25
  26 #define KEMPLD_WDT_STAGE_TIMEOUT(x)     (0x1b + (x) * 4)
  27 #define KEMPLD_WDT_STAGE_CFG(x)         (0x18 + (x))
  28 #define STAGE_CFG_GET_PRESCALER(x)      (((x) & 0x30) >> 4)
  29 #define STAGE_CFG_SET_PRESCALER(x)      (((x) & 0x3) << 4)
  30 #define STAGE_CFG_PRESCALER_MASK        0x30
  31 #define STAGE_CFG_ACTION_MASK           0x7
  32 #define STAGE_CFG_ASSERT                (1 << 3)
  33
  34 #define KEMPLD_WDT_MAX_STAGES           2
  35 #define KEMPLD_WDT_KICK                 0x16
  36 #define KEMPLD_WDT_CFG                  0x17
  37 #define KEMPLD_WDT_CFG_ENABLE           0x10
  38 #define KEMPLD_WDT_CFG_ENABLE_LOCK      0x8
  39 #define KEMPLD_WDT_CFG_GLOBAL_LOCK      0x80
  40
  41 enum {
  42         ACTION_NONE = 0,
  43         ACTION_RESET,
  44         ACTION_NMI,
  45         ACTION_SMI,
  46         ACTION_SCI,
  47         ACTION_DELAY,
  48 };
  49
  50 enum {
  51         STAGE_TIMEOUT = 0,
  52         STAGE_PRETIMEOUT,
  53 };
  54
  55 enum {
  56         PRESCALER_21 = 0,
  57         PRESCALER_17,
  58         PRESCALER_12,
  59 };
  60
  61 static const u32 kempld_prescaler[] = {
  62         [PRESCALER_21] = (1 << 21) - 1,
  63         [PRESCALER_17] = (1 << 17) - 1,
  64         [PRESCALER_12] = (1 << 12) - 1,
  65         0,
  66 };
  67
  68 struct kempld_wdt_stage {
  69         unsigned int    id;
  70         u32             mask;
  71 };
  72
  73 struct kempld_wdt_data {
  74         struct kempld_device_data       *pld;
  75         struct watchdog_device          wdd;
  76         unsigned int                    pretimeout;
  77         struct kempld_wdt_stage         stage[KEMPLD_WDT_MAX_STAGES];
  78 #ifdef CONFIG_PM
  79         u8                              pm_status_store;
  80 #endif
  81 };
  82
  83 #define DEFAULT_TIMEOUT         30 /* seconds */
  84 #define DEFAULT_PRETIMEOUT      0
  85
  86 static unsigned int timeout = DEFAULT_TIMEOUT;
  87 module_param(timeout, uint, 0);
  88 MODULE_PARM_DESC(timeout,
  89         "Watchdog timeout in seconds. (>=0, default="
  90         __MODULE_STRING(DEFAULT_TIMEOUT) ")");
  91
  92 static unsigned int pretimeout = DEFAULT_PRETIMEOUT;
  93 module_param(pretimeout, uint, 0);
  94 MODULE_PARM_DESC(pretimeout,
  95         "Watchdog pretimeout in seconds. (>=0, default="
  96         __MODULE_STRING(DEFAULT_PRETIMEOUT) ")");
  97
  98 static bool nowayout = WATCHDOG_NOWAYOUT;
  99 module_param(nowayout, bool, 0);
 100 MODULE_PARM_DESC(nowayout,
 101         "Watchdog cannot be stopped once started (default="
 102         __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 103
 104 static int kempld_wdt_set_stage_action(struct kempld_wdt_data *wdt_data,
 105                                         struct kempld_wdt_stage *stage,
 106                                         u8 action)
 107 {
 108         struct kempld_device_data *pld = wdt_data->pld;
 109         u8 stage_cfg;
 110
 111         if (!stage || !stage->mask)
 112                 return -EINVAL;
 113
 114         kempld_get_mutex(pld);
 115         stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
 116         stage_cfg &= ~STAGE_CFG_ACTION_MASK;
 117         stage_cfg |= (action & STAGE_CFG_ACTION_MASK);
 118
 119         if (action == ACTION_RESET)
 120                 stage_cfg |= STAGE_CFG_ASSERT;
 121         else
 122                 stage_cfg &= ~STAGE_CFG_ASSERT;
 123
 124         kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg);
 125         kempld_release_mutex(pld);
 126
 127         return 0;
 128 }
 129
 130 static int kempld_wdt_set_stage_timeout(struct kempld_wdt_data *wdt_data,
 131                                         struct kempld_wdt_stage *stage,
 132                                         unsigned int timeout)
 133 {
 134         struct kempld_device_data *pld = wdt_data->pld;
 135         u32 prescaler;
 136         u64 stage_timeout64;
 137         u32 stage_timeout;
 138         u32 remainder;
 139         u8 stage_cfg;
 140
 141         prescaler = kempld_prescaler[PRESCALER_21];
 142
 143         if (!stage)
 144                 return -EINVAL;
 145
 146         stage_timeout64 = (u64)timeout * pld->pld_clock;
 147         remainder = do_div(stage_timeout64, prescaler);
 148         if (remainder)
 149                 stage_timeout64++;
 150
 151         if (stage_timeout64 > stage->mask)
 152                 return -EINVAL;
 153
 154         stage_timeout = stage_timeout64 & stage->mask;
 155
 156         kempld_get_mutex(pld);
 157         stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
 158         stage_cfg &= ~STAGE_CFG_PRESCALER_MASK;
 159         stage_cfg |= STAGE_CFG_SET_PRESCALER(PRESCALER_21);
 160         kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg);
 161         kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id),
 162                         stage_timeout);
 163         kempld_release_mutex(pld);
 164
 165         return 0;
 166 }
 167
 168 /*
 169  * kempld_get_mutex must be called prior to calling this function.
 170  */
 171 static unsigned int kempld_wdt_get_timeout(struct kempld_wdt_data *wdt_data,
 172                                                 struct kempld_wdt_stage *stage)
 173 {
 174         struct kempld_device_data *pld = wdt_data->pld;
 175         unsigned int timeout;
 176         u64 stage_timeout;
 177         u32 prescaler;
 178         u32 remainder;
 179         u8 stage_cfg;
 180
 181         if (!stage->mask)
 182                 return 0;
 183
 184         stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
 185         stage_timeout = kempld_read32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id));
 186         prescaler = kempld_prescaler[STAGE_CFG_GET_PRESCALER(stage_cfg)];
 187
 188         stage_timeout = (stage_timeout & stage->mask) * prescaler;
 189         remainder = do_div(stage_timeout, pld->pld_clock);
 190         if (remainder)
 191                 stage_timeout++;
 192
 193         timeout = stage_timeout;
 194         WARN_ON_ONCE(timeout != stage_timeout);
 195
 196         return timeout;
 197 }
 198
 199 static int kempld_wdt_set_timeout(struct watchdog_device *wdd,
 200                                         unsigned int timeout)
 201 {
 202         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 203         struct kempld_wdt_stage *pretimeout_stage;
 204         struct kempld_wdt_stage *timeout_stage;
 205         int ret;
 206
 207         timeout_stage = &wdt_data->stage[STAGE_TIMEOUT];
 208         pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
 209
 210         if (pretimeout_stage->mask && wdt_data->pretimeout > 0)
 211                 timeout = wdt_data->pretimeout;
 212
 213         ret = kempld_wdt_set_stage_action(wdt_data, timeout_stage,
 214                                                 ACTION_RESET);
 215         if (ret)
 216                 return ret;
 217         ret = kempld_wdt_set_stage_timeout(wdt_data, timeout_stage,
 218                                                 timeout);
 219         if (ret)
 220                 return ret;
 221
 222         wdd->timeout = timeout;
 223         return 0;
 224 }
 225
 226 static int kempld_wdt_set_pretimeout(struct watchdog_device *wdd,
 227                                         unsigned int pretimeout)
 228 {
 229         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 230         struct kempld_wdt_stage *pretimeout_stage;
 231         u8 action = ACTION_NONE;
 232         int ret;
 233
 234         pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
 235
 236         if (!pretimeout_stage->mask)
 237                 return -ENXIO;
 238
 239         if (pretimeout > wdd->timeout)
 240                 return -EINVAL;
 241
 242         if (pretimeout > 0)
 243                 action = ACTION_NMI;
 244
 245         ret = kempld_wdt_set_stage_action(wdt_data, pretimeout_stage,
 246                                                 action);
 247         if (ret)
 248                 return ret;
 249         ret = kempld_wdt_set_stage_timeout(wdt_data, pretimeout_stage,
 250                                                 wdd->timeout - pretimeout);
 251         if (ret)
 252                 return ret;
 253
 254         wdt_data->pretimeout = pretimeout;
 255         return 0;
 256 }
 257
 258 static void kempld_wdt_update_timeouts(struct kempld_wdt_data *wdt_data)
 259 {
 260         struct kempld_device_data *pld = wdt_data->pld;
 261         struct kempld_wdt_stage *pretimeout_stage;
 262         struct kempld_wdt_stage *timeout_stage;
 263         unsigned int pretimeout, timeout;
 264
 265         pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
 266         timeout_stage = &wdt_data->stage[STAGE_TIMEOUT];
 267
 268         kempld_get_mutex(pld);
 269         pretimeout = kempld_wdt_get_timeout(wdt_data, pretimeout_stage);
 270         timeout = kempld_wdt_get_timeout(wdt_data, timeout_stage);
 271         kempld_release_mutex(pld);
 272
 273         if (pretimeout)
 274                 wdt_data->pretimeout = timeout;
 275         else
 276                 wdt_data->pretimeout = 0;
 277
 278         wdt_data->wdd.timeout = pretimeout + timeout;
 279 }
 280
 281 static int kempld_wdt_start(struct watchdog_device *wdd)
 282 {
 283         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 284         struct kempld_device_data *pld = wdt_data->pld;
 285         u8 status;
 286         int ret;
 287
 288         ret = kempld_wdt_set_timeout(wdd, wdd->timeout);
 289         if (ret)
 290                 return ret;
 291
 292         kempld_get_mutex(pld);
 293         status = kempld_read8(pld, KEMPLD_WDT_CFG);
 294         status |= KEMPLD_WDT_CFG_ENABLE;
 295         kempld_write8(pld, KEMPLD_WDT_CFG, status);
 296         status = kempld_read8(pld, KEMPLD_WDT_CFG);
 297         kempld_release_mutex(pld);
 298
 299         /* Check if the watchdog was enabled */
 300         if (!(status & KEMPLD_WDT_CFG_ENABLE))
 301                 return -EACCES;
 302
 303         return 0;
 304 }
 305
 306 static int kempld_wdt_stop(struct watchdog_device *wdd)
 307 {
 308         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 309         struct kempld_device_data *pld = wdt_data->pld;
 310         u8 status;
 311
 312         kempld_get_mutex(pld);
 313         status = kempld_read8(pld, KEMPLD_WDT_CFG);
 314         status &= ~KEMPLD_WDT_CFG_ENABLE;
 315         kempld_write8(pld, KEMPLD_WDT_CFG, status);
 316         status = kempld_read8(pld, KEMPLD_WDT_CFG);
 317         kempld_release_mutex(pld);
 318
 319         /* Check if the watchdog was disabled */
 320         if (status & KEMPLD_WDT_CFG_ENABLE)
 321                 return -EACCES;
 322
 323         return 0;
 324 }
 325
 326 static int kempld_wdt_keepalive(struct watchdog_device *wdd)
 327 {
 328         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 329         struct kempld_device_data *pld = wdt_data->pld;
 330
 331         kempld_get_mutex(pld);
 332         kempld_write8(pld, KEMPLD_WDT_KICK, 'K');
 333         kempld_release_mutex(pld);
 334
 335         return 0;
 336 }
 337
 338 static long kempld_wdt_ioctl(struct watchdog_device *wdd, unsigned int cmd,
 339                                 unsigned long arg)
 340 {
 341         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 342         void __user *argp = (void __user *)arg;
 343         int ret = -ENOIOCTLCMD;
 344         int __user *p = argp;
 345         int new_value;
 346
 347         switch (cmd) {
 348         case WDIOC_SETPRETIMEOUT:
 349                 if (get_user(new_value, p))
 350                         return -EFAULT;
 351                 ret = kempld_wdt_set_pretimeout(wdd, new_value);
 352                 if (ret)
 353                         return ret;
 354                 ret = kempld_wdt_keepalive(wdd);
 355                 break;
 356         case WDIOC_GETPRETIMEOUT:
 357                 ret = put_user(wdt_data->pretimeout, (int __user *)arg);
 358                 break;
 359         }
 360
 361         return ret;
 362 }
 363
 364 static int kempld_wdt_probe_stages(struct watchdog_device *wdd)
 365 {
 366         struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
 367         struct kempld_device_data *pld = wdt_data->pld;
 368         struct kempld_wdt_stage *pretimeout_stage;
 369         struct kempld_wdt_stage *timeout_stage;
 370         u8 index, data, data_orig;
 371         u32 mask;
 372         int i, j;
 373
 374         pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
 375         timeout_stage = &wdt_data->stage[STAGE_TIMEOUT];
 376
 377         pretimeout_stage->mask = 0;
 378         timeout_stage->mask = 0;
 379
 380         for (i = 0; i < 3; i++) {
 381                 index = KEMPLD_WDT_STAGE_TIMEOUT(i);
 382                 mask = 0;
 383
 384                 kempld_get_mutex(pld);
 385                 /* Probe each byte individually. */
 386                 for (j = 0; j < 4; j++) {
 387                         data_orig = kempld_read8(pld, index + j);
 388                         kempld_write8(pld, index + j, 0x00);
 389                         data = kempld_read8(pld, index + j);
 390                         /* A failed write means this byte is reserved */
 391                         if (data != 0x00)
 392                                 break;
 393                         kempld_write8(pld, index + j, data_orig);
 394                         mask |= 0xff << (j * 8);
 395                 }
 396                 kempld_release_mutex(pld);
 397
 398                 /* Assign available stages to timeout and pretimeout */
 399                 if (!timeout_stage->mask) {
 400                         timeout_stage->mask = mask;
 401                         timeout_stage->id = i;
 402                 } else {
 403                         if (pld->feature_mask & KEMPLD_FEATURE_BIT_NMI) {
 404                                 pretimeout_stage->mask = timeout_stage->mask;
 405                                 timeout_stage->mask = mask;
 406                                 pretimeout_stage->id = timeout_stage->id;
 407                                 timeout_stage->id = i;
 408                         }
 409                         break;
 410                 }
 411         }
 412
 413         if (!timeout_stage->mask)
 414                 return -ENODEV;
 415
 416         return 0;
 417 }
 418
 419 static const struct watchdog_info kempld_wdt_info = {
 420         .identity       = "KEMPLD Watchdog",
 421         .options        = WDIOF_SETTIMEOUT |
 422                         WDIOF_KEEPALIVEPING |
 423                         WDIOF_MAGICCLOSE |
 424                         WDIOF_PRETIMEOUT
 425 };
 426
 427 static const struct watchdog_ops kempld_wdt_ops = {
 428         .owner          = THIS_MODULE,
 429         .start          = kempld_wdt_start,
 430         .stop           = kempld_wdt_stop,
 431         .ping           = kempld_wdt_keepalive,
 432         .set_timeout    = kempld_wdt_set_timeout,
 433         .ioctl          = kempld_wdt_ioctl,
 434 };
 435
 436 static int kempld_wdt_probe(struct platform_device *pdev)
 437 {
 438         struct kempld_device_data *pld = dev_get_drvdata(pdev->dev.parent);
 439         struct kempld_wdt_data *wdt_data;
 440         struct device *dev = &pdev->dev;
 441         struct watchdog_device *wdd;
 442         u8 status;
 443         int ret = 0;
 444
 445         wdt_data = devm_kzalloc(dev, sizeof(*wdt_data), GFP_KERNEL);
 446         if (!wdt_data)
 447                 return -ENOMEM;
 448
 449         wdt_data->pld = pld;
 450         wdd = &wdt_data->wdd;
 451         wdd->parent = dev;
 452
 453         kempld_get_mutex(pld);
 454         status = kempld_read8(pld, KEMPLD_WDT_CFG);
 455         kempld_release_mutex(pld);
 456
 457         /* Enable nowayout if watchdog is already locked */
 458         if (status & (KEMPLD_WDT_CFG_ENABLE_LOCK |
 459                         KEMPLD_WDT_CFG_GLOBAL_LOCK)) {
 460                 if (!nowayout)
 461                         dev_warn(dev,
 462                                  "Forcing nowayout - watchdog lock enabled!\n");
 463                 nowayout = true;
 464         }
 465
 466         wdd->info = &kempld_wdt_info;
 467         wdd->ops = &kempld_wdt_ops;
 468
 469         watchdog_set_drvdata(wdd, wdt_data);
 470         watchdog_set_nowayout(wdd, nowayout);
 471
 472         ret = kempld_wdt_probe_stages(wdd);
 473         if (ret)
 474                 return ret;
 475
 476         kempld_wdt_set_timeout(wdd, timeout);
 477         kempld_wdt_set_pretimeout(wdd, pretimeout);
 478
 479         /* Check if watchdog is already enabled */
 480         if (status & KEMPLD_WDT_CFG_ENABLE) {
 481                 /* Get current watchdog settings */
 482                 kempld_wdt_update_timeouts(wdt_data);
 483                 dev_info(dev, "Watchdog was already enabled\n");
 484         }
 485
 486         platform_set_drvdata(pdev, wdt_data);
 487         watchdog_stop_on_reboot(wdd);
 488         watchdog_stop_on_unregister(wdd);
 489         ret = devm_watchdog_register_device(dev, wdd);
 490         if (ret)
 491                 return ret;
 492
 493         dev_info(dev, "Watchdog registered with %ds timeout\n", wdd->timeout);
 494
 495         return 0;
 496 }
 497
 498 #ifdef CONFIG_PM
 499 /* Disable watchdog if it is active during suspend */
 500 static int kempld_wdt_suspend(struct platform_device *pdev,
 501                                 pm_message_t message)
 502 {
 503         struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev);
 504         struct kempld_device_data *pld = wdt_data->pld;
 505         struct watchdog_device *wdd = &wdt_data->wdd;
 506
 507         kempld_get_mutex(pld);
 508         wdt_data->pm_status_store = kempld_read8(pld, KEMPLD_WDT_CFG);
 509         kempld_release_mutex(pld);
 510
 511         kempld_wdt_update_timeouts(wdt_data);
 512
 513         if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE)
 514                 return kempld_wdt_stop(wdd);
 515
 516         return 0;
 517 }
 518
 519 /* Enable watchdog and configure it if necessary */
 520 static int kempld_wdt_resume(struct platform_device *pdev)
 521 {
 522         struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev);
 523         struct watchdog_device *wdd = &wdt_data->wdd;
 524
 525         /*
 526          * If watchdog was stopped before suspend be sure it gets disabled
 527          * again, for the case BIOS has enabled it during resume
 528          */
 529         if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE)
 530                 return kempld_wdt_start(wdd);
 531         else
 532                 return kempld_wdt_stop(wdd);
 533 }
 534 #else
 535 #define kempld_wdt_suspend      NULL
 536 #define kempld_wdt_resume       NULL
 537 #endif
 538
 539 static struct platform_driver kempld_wdt_driver = {
 540         .driver         = {
 541                 .name   = "kempld-wdt",
 542         },
 543         .probe          = kempld_wdt_probe,
 544         .suspend        = kempld_wdt_suspend,
 545         .resume         = kempld_wdt_resume,
 546 };
 547
 548 module_platform_driver(kempld_wdt_driver);
 549
 550 MODULE_DESCRIPTION("KEM PLD Watchdog Driver");
 551 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>");
 552 MODULE_LICENSE("GPL");