drivers/watchdog/bcm47xx_wdt.c

   1 /*
   2  *  Watchdog driver for Broadcom BCM47XX
   3  *
   4  *  Copyright (C) 2008 Aleksandar Radovanovic <biblbroks@sezampro.rs>
   5  *  Copyright (C) 2009 Matthieu CASTET <castet.matthieu@free.fr>
   6  *  Copyright (C) 2012-2013 Hauke Mehrtens <hauke@hauke-m.de>
   7  *
   8  *  This program is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU General Public License
  10  *  as published by the Free Software Foundation; either version
  11  *  2 of the License, or (at your option) any later version.
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/bcm47xx_wdt.h>
  17 #include <linux/bitops.h>
  18 #include <linux/errno.h>
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/moduleparam.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/types.h>
  24 #include <linux/watchdog.h>
  25 #include <linux/timer.h>
  26 #include <linux/jiffies.h>
  27
  28 #define DRV_NAME                "bcm47xx_wdt"
  29
  30 #define WDT_DEFAULT_TIME        30      /* seconds */
  31 #define WDT_SOFTTIMER_MAX       255     /* seconds */
  32 #define WDT_SOFTTIMER_THRESHOLD 60      /* seconds */
  33
  34 static int timeout = WDT_DEFAULT_TIME;
  35 static bool nowayout = WATCHDOG_NOWAYOUT;
  36
  37 module_param(timeout, int, 0);
  38 MODULE_PARM_DESC(timeout, "Watchdog time in seconds. (default="
  39                                 __MODULE_STRING(WDT_DEFAULT_TIME) ")");
  40
  41 module_param(nowayout, bool, 0);
  42 MODULE_PARM_DESC(nowayout,
  43                 "Watchdog cannot be stopped once started (default="
  44                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  45
  46 static inline struct bcm47xx_wdt *bcm47xx_wdt_get(struct watchdog_device *wdd)
  47 {
  48         return container_of(wdd, struct bcm47xx_wdt, wdd);
  49 }
  50
  51 static int bcm47xx_wdt_hard_keepalive(struct watchdog_device *wdd)
  52 {
  53         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
  54
  55         wdt->timer_set_ms(wdt, wdd->timeout * 1000);
  56
  57         return 0;
  58 }
  59
  60 static int bcm47xx_wdt_hard_start(struct watchdog_device *wdd)
  61 {
  62         return 0;
  63 }
  64
  65 static int bcm47xx_wdt_hard_stop(struct watchdog_device *wdd)
  66 {
  67         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
  68
  69         wdt->timer_set(wdt, 0);
  70
  71         return 0;
  72 }
  73
  74 static int bcm47xx_wdt_hard_set_timeout(struct watchdog_device *wdd,
  75                                         unsigned int new_time)
  76 {
  77         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
  78         u32 max_timer = wdt->max_timer_ms;
  79
  80         if (new_time < 1 || new_time > max_timer / 1000) {
  81                 pr_warn("timeout value must be 1<=x<=%d, using %d\n",
  82                         max_timer / 1000, new_time);
  83                 return -EINVAL;
  84         }
  85
  86         wdd->timeout = new_time;
  87         return 0;
  88 }
  89
  90 static int bcm47xx_wdt_restart(struct watchdog_device *wdd,
  91                                unsigned long action, void *data)
  92 {
  93         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
  94
  95         wdt->timer_set(wdt, 1);
  96
  97         return 0;
  98 }
  99
 100 static struct watchdog_ops bcm47xx_wdt_hard_ops = {
 101         .owner          = THIS_MODULE,
 102         .start          = bcm47xx_wdt_hard_start,
 103         .stop           = bcm47xx_wdt_hard_stop,
 104         .ping           = bcm47xx_wdt_hard_keepalive,
 105         .set_timeout    = bcm47xx_wdt_hard_set_timeout,
 106         .restart        = bcm47xx_wdt_restart,
 107 };
 108
 109 static void bcm47xx_wdt_soft_timer_tick(unsigned long data)
 110 {
 111         struct bcm47xx_wdt *wdt = (struct bcm47xx_wdt *)data;
 112         u32 next_tick = min(wdt->wdd.timeout * 1000, wdt->max_timer_ms);
 113
 114         if (!atomic_dec_and_test(&wdt->soft_ticks)) {
 115                 wdt->timer_set_ms(wdt, next_tick);
 116                 mod_timer(&wdt->soft_timer, jiffies + HZ);
 117         } else {
 118                 pr_crit("Watchdog will fire soon!!!\n");
 119         }
 120 }
 121
 122 static int bcm47xx_wdt_soft_keepalive(struct watchdog_device *wdd)
 123 {
 124         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
 125
 126         atomic_set(&wdt->soft_ticks, wdd->timeout);
 127
 128         return 0;
 129 }
 130
 131 static int bcm47xx_wdt_soft_start(struct watchdog_device *wdd)
 132 {
 133         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
 134
 135         bcm47xx_wdt_soft_keepalive(wdd);
 136         bcm47xx_wdt_soft_timer_tick((unsigned long)wdt);
 137
 138         return 0;
 139 }
 140
 141 static int bcm47xx_wdt_soft_stop(struct watchdog_device *wdd)
 142 {
 143         struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd);
 144
 145         del_timer_sync(&wdt->soft_timer);
 146         wdt->timer_set(wdt, 0);
 147
 148         return 0;
 149 }
 150
 151 static int bcm47xx_wdt_soft_set_timeout(struct watchdog_device *wdd,
 152                                         unsigned int new_time)
 153 {
 154         if (new_time < 1 || new_time > WDT_SOFTTIMER_MAX) {
 155                 pr_warn("timeout value must be 1<=x<=%d, using %d\n",
 156                         WDT_SOFTTIMER_MAX, new_time);
 157                 return -EINVAL;
 158         }
 159
 160         wdd->timeout = new_time;
 161         return 0;
 162 }
 163
 164 static const struct watchdog_info bcm47xx_wdt_info = {
 165         .identity       = DRV_NAME,
 166         .options        = WDIOF_SETTIMEOUT |
 167                                 WDIOF_KEEPALIVEPING |
 168                                 WDIOF_MAGICCLOSE,
 169 };
 170
 171 static struct watchdog_ops bcm47xx_wdt_soft_ops = {
 172         .owner          = THIS_MODULE,
 173         .start          = bcm47xx_wdt_soft_start,
 174         .stop           = bcm47xx_wdt_soft_stop,
 175         .ping           = bcm47xx_wdt_soft_keepalive,
 176         .set_timeout    = bcm47xx_wdt_soft_set_timeout,
 177         .restart        = bcm47xx_wdt_restart,
 178 };
 179
 180 static int bcm47xx_wdt_probe(struct platform_device *pdev)
 181 {
 182         int ret;
 183         bool soft;
 184         struct bcm47xx_wdt *wdt = dev_get_platdata(&pdev->dev);
 185
 186         if (!wdt)
 187                 return -ENXIO;
 188
 189         soft = wdt->max_timer_ms < WDT_SOFTTIMER_THRESHOLD * 1000;
 190
 191         if (soft) {
 192                 wdt->wdd.ops = &bcm47xx_wdt_soft_ops;
 193                 setup_timer(&wdt->soft_timer, bcm47xx_wdt_soft_timer_tick,
 194                             (long unsigned int)wdt);
 195         } else {
 196                 wdt->wdd.ops = &bcm47xx_wdt_hard_ops;
 197         }
 198
 199         wdt->wdd.info = &bcm47xx_wdt_info;
 200         wdt->wdd.timeout = WDT_DEFAULT_TIME;
 201         wdt->wdd.parent = &pdev->dev;
 202         ret = wdt->wdd.ops->set_timeout(&wdt->wdd, timeout);
 203         if (ret)
 204                 goto err_timer;
 205         watchdog_set_nowayout(&wdt->wdd, nowayout);
 206         watchdog_set_restart_priority(&wdt->wdd, 64);
 207         watchdog_stop_on_reboot(&wdt->wdd);
 208
 209         ret = watchdog_register_device(&wdt->wdd);
 210         if (ret)
 211                 goto err_timer;
 212
 213         dev_info(&pdev->dev, "BCM47xx Watchdog Timer enabled (%d seconds%s%s)\n",
 214                 timeout, nowayout ? ", nowayout" : "",
 215                 soft ? ", Software Timer" : "");
 216         return 0;
 217
 218 err_timer:
 219         if (soft)
 220                 del_timer_sync(&wdt->soft_timer);
 221
 222         return ret;
 223 }
 224
 225 static int bcm47xx_wdt_remove(struct platform_device *pdev)
 226 {
 227         struct bcm47xx_wdt *wdt = dev_get_platdata(&pdev->dev);
 228
 229         if (!wdt)
 230                 return -ENXIO;
 231
 232         watchdog_unregister_device(&wdt->wdd);
 233
 234         return 0;
 235 }
 236
 237 static struct platform_driver bcm47xx_wdt_driver = {
 238         .driver         = {
 239                 .name   = "bcm47xx-wdt",
 240         },
 241         .probe          = bcm47xx_wdt_probe,
 242         .remove         = bcm47xx_wdt_remove,
 243 };
 244
 245 module_platform_driver(bcm47xx_wdt_driver);
 246
 247 MODULE_AUTHOR("Aleksandar Radovanovic");
 248 MODULE_AUTHOR("Hauke Mehrtens <hauke@hauke-m.de>");
 249 MODULE_DESCRIPTION("Watchdog driver for Broadcom BCM47xx");
 250 MODULE_LICENSE("GPL");