drivers/watchdog/orion_wdt.c

   1 /*
   2  * drivers/watchdog/orion_wdt.c
   3  *
   4  * Watchdog driver for Orion/Kirkwood processors
   5  *
   6  * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
   7  *
   8  * This file is licensed under  the terms of the GNU General Public
   9  * License version 2. This program is licensed "as is" without any
  10  * warranty of any kind, whether express or implied.
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/module.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/miscdevice.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/watchdog.h>
  22 #include <linux/init.h>
  23 #include <linux/io.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/clk.h>
  26 #include <linux/err.h>
  27 #include <mach/bridge-regs.h>
  28
  29 /*
  30  * Watchdog timer block registers.
  31  */
  32 #define TIMER_CTRL              0x0000
  33 #define WDT_EN                  0x0010
  34 #define WDT_VAL                 0x0024
  35
  36 #define WDT_MAX_CYCLE_COUNT     0xffffffff
  37 #define WDT_IN_USE              0
  38 #define WDT_OK_TO_CLOSE         1
  39
  40 static bool nowayout = WATCHDOG_NOWAYOUT;
  41 static int heartbeat = -1;              /* module parameter (seconds) */
  42 static unsigned int wdt_max_duration;   /* (seconds) */
  43 static struct clk *clk;
  44 static unsigned int wdt_tclk;
  45 static void __iomem *wdt_reg;
  46 static DEFINE_SPINLOCK(wdt_lock);
  47
  48 static int orion_wdt_ping(struct watchdog_device *wdt_dev)
  49 {
  50         spin_lock(&wdt_lock);
  51
  52         /* Reload watchdog duration */
  53         writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
  54
  55         spin_unlock(&wdt_lock);
  56         return 0;
  57 }
  58
  59 static int orion_wdt_start(struct watchdog_device *wdt_dev)
  60 {
  61         u32 reg;
  62
  63         spin_lock(&wdt_lock);
  64
  65         /* Set watchdog duration */
  66         writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
  67
  68         /* Clear watchdog timer interrupt */
  69         reg = readl(BRIDGE_CAUSE);
  70         reg &= ~WDT_INT_REQ;
  71         writel(reg, BRIDGE_CAUSE);
  72
  73         /* Enable watchdog timer */
  74         reg = readl(wdt_reg + TIMER_CTRL);
  75         reg |= WDT_EN;
  76         writel(reg, wdt_reg + TIMER_CTRL);
  77
  78         /* Enable reset on watchdog */
  79         reg = readl(RSTOUTn_MASK);
  80         reg |= WDT_RESET_OUT_EN;
  81         writel(reg, RSTOUTn_MASK);
  82
  83         spin_unlock(&wdt_lock);
  84         return 0;
  85 }
  86
  87 static int orion_wdt_stop(struct watchdog_device *wdt_dev)
  88 {
  89         u32 reg;
  90
  91         spin_lock(&wdt_lock);
  92
  93         /* Disable reset on watchdog */
  94         reg = readl(RSTOUTn_MASK);
  95         reg &= ~WDT_RESET_OUT_EN;
  96         writel(reg, RSTOUTn_MASK);
  97
  98         /* Disable watchdog timer */
  99         reg = readl(wdt_reg + TIMER_CTRL);
 100         reg &= ~WDT_EN;
 101         writel(reg, wdt_reg + TIMER_CTRL);
 102
 103         spin_unlock(&wdt_lock);
 104         return 0;
 105 }
 106
 107 static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
 108 {
 109         unsigned int time_left;
 110
 111         spin_lock(&wdt_lock);
 112         time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
 113         spin_unlock(&wdt_lock);
 114
 115         return time_left;
 116 }
 117
 118 static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
 119                                  unsigned int timeout)
 120 {
 121         wdt_dev->timeout = timeout;
 122         return 0;
 123 }
 124
 125 static const struct watchdog_info orion_wdt_info = {
 126         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 127         .identity = "Orion Watchdog",
 128 };
 129
 130 static const struct watchdog_ops orion_wdt_ops = {
 131         .owner = THIS_MODULE,
 132         .start = orion_wdt_start,
 133         .stop = orion_wdt_stop,
 134         .ping = orion_wdt_ping,
 135         .set_timeout = orion_wdt_set_timeout,
 136         .get_timeleft = orion_wdt_get_timeleft,
 137 };
 138
 139 static struct watchdog_device orion_wdt = {
 140         .info = &orion_wdt_info,
 141         .ops = &orion_wdt_ops,
 142 };
 143
 144 static int __devinit orion_wdt_probe(struct platform_device *pdev)
 145 {
 146         struct resource *res;
 147         int ret;
 148
 149         clk = devm_clk_get(&pdev->dev, NULL);
 150         if (IS_ERR(clk)) {
 151                 dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
 152                 return -ENODEV;
 153         }
 154         clk_prepare_enable(clk);
 155         wdt_tclk = clk_get_rate(clk);
 156
 157         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 158         wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 159         if (!wdt_reg)
 160                 return -ENOMEM;
 161
 162         wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
 163
 164         if ((heartbeat < 1) || (heartbeat > wdt_max_duration))
 165                 heartbeat = wdt_max_duration;
 166
 167         orion_wdt.timeout = heartbeat;
 168         orion_wdt.min_timeout = 1;
 169         orion_wdt.max_timeout = wdt_max_duration;
 170
 171         watchdog_set_nowayout(&orion_wdt, nowayout);
 172         ret = watchdog_register_device(&orion_wdt);
 173         if (ret) {
 174                 clk_disable_unprepare(clk);
 175                 return ret;
 176         }
 177
 178         pr_info("Initial timeout %d sec%s\n",
 179                 heartbeat, nowayout ? ", nowayout" : "");
 180         return 0;
 181 }
 182
 183 static int __devexit orion_wdt_remove(struct platform_device *pdev)
 184 {
 185         watchdog_unregister_device(&orion_wdt);
 186         clk_disable_unprepare(clk);
 187         return 0;
 188 }
 189
 190 static void orion_wdt_shutdown(struct platform_device *pdev)
 191 {
 192         orion_wdt_stop(&orion_wdt);
 193 }
 194
 195 static struct platform_driver orion_wdt_driver = {
 196         .probe          = orion_wdt_probe,
 197         .remove         = __devexit_p(orion_wdt_remove),
 198         .shutdown       = orion_wdt_shutdown,
 199         .driver         = {
 200                 .owner  = THIS_MODULE,
 201                 .name   = "orion_wdt",
 202         },
 203 };
 204
 205 module_platform_driver(orion_wdt_driver);
 206
 207 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
 208 MODULE_DESCRIPTION("Orion Processor Watchdog");
 209
 210 module_param(heartbeat, int, 0);
 211 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
 212
 213 module_param(nowayout, bool, 0);
 214 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 215                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 216
 217 MODULE_LICENSE("GPL");
 218 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);