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