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 <linux/of.h>
  28 #include <mach/bridge-regs.h>
  29
  30 /*
  31  * Watchdog timer block registers.
  32  */
  33 #define TIMER_CTRL              0x0000
  34 #define WDT_EN                  0x0010
  35 #define WDT_VAL                 0x0024
  36
  37 #define WDT_MAX_CYCLE_COUNT     0xffffffff
  38 #define WDT_IN_USE              0
  39 #define WDT_OK_TO_CLOSE         1
  40
  41 #define WDT_RESET_OUT_EN        BIT(1)
  42 #define WDT_INT_REQ             BIT(3)
  43
  44 static bool nowayout = WATCHDOG_NOWAYOUT;
  45 static int heartbeat = -1;              /* module parameter (seconds) */
  46 static unsigned int wdt_max_duration;   /* (seconds) */
  47 static struct clk *clk;
  48 static unsigned int wdt_tclk;
  49 static void __iomem *wdt_reg;
  50 static DEFINE_SPINLOCK(wdt_lock);
  51
  52 static int orion_wdt_ping(struct watchdog_device *wdt_dev)
  53 {
  54         spin_lock(&wdt_lock);
  55
  56         /* Reload watchdog duration */
  57         writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
  58
  59         spin_unlock(&wdt_lock);
  60         return 0;
  61 }
  62
  63 static int orion_wdt_start(struct watchdog_device *wdt_dev)
  64 {
  65         u32 reg;
  66
  67         spin_lock(&wdt_lock);
  68
  69         /* Set watchdog duration */
  70         writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
  71
  72         /* Clear watchdog timer interrupt */
  73         reg = readl(BRIDGE_CAUSE);
  74         reg &= ~WDT_INT_REQ;
  75         writel(reg, BRIDGE_CAUSE);
  76
  77         /* Enable watchdog timer */
  78         reg = readl(wdt_reg + TIMER_CTRL);
  79         reg |= WDT_EN;
  80         writel(reg, wdt_reg + TIMER_CTRL);
  81
  82         /* Enable reset on watchdog */
  83         reg = readl(RSTOUTn_MASK);
  84         reg |= WDT_RESET_OUT_EN;
  85         writel(reg, RSTOUTn_MASK);
  86
  87         spin_unlock(&wdt_lock);
  88         return 0;
  89 }
  90
  91 static int orion_wdt_stop(struct watchdog_device *wdt_dev)
  92 {
  93         u32 reg;
  94
  95         spin_lock(&wdt_lock);
  96
  97         /* Disable reset on watchdog */
  98         reg = readl(RSTOUTn_MASK);
  99         reg &= ~WDT_RESET_OUT_EN;
 100         writel(reg, RSTOUTn_MASK);
 101
 102         /* Disable watchdog timer */
 103         reg = readl(wdt_reg + TIMER_CTRL);
 104         reg &= ~WDT_EN;
 105         writel(reg, wdt_reg + TIMER_CTRL);
 106
 107         spin_unlock(&wdt_lock);
 108         return 0;
 109 }
 110
 111 static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
 112 {
 113         unsigned int time_left;
 114
 115         spin_lock(&wdt_lock);
 116         time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
 117         spin_unlock(&wdt_lock);
 118
 119         return time_left;
 120 }
 121
 122 static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
 123                                  unsigned int timeout)
 124 {
 125         wdt_dev->timeout = timeout;
 126         return 0;
 127 }
 128
 129 static const struct watchdog_info orion_wdt_info = {
 130         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 131         .identity = "Orion Watchdog",
 132 };
 133
 134 static const struct watchdog_ops orion_wdt_ops = {
 135         .owner = THIS_MODULE,
 136         .start = orion_wdt_start,
 137         .stop = orion_wdt_stop,
 138         .ping = orion_wdt_ping,
 139         .set_timeout = orion_wdt_set_timeout,
 140         .get_timeleft = orion_wdt_get_timeleft,
 141 };
 142
 143 static struct watchdog_device orion_wdt = {
 144         .info = &orion_wdt_info,
 145         .ops = &orion_wdt_ops,
 146         .min_timeout = 1,
 147 };
 148
 149 static int orion_wdt_probe(struct platform_device *pdev)
 150 {
 151         struct resource *res;
 152         int ret;
 153
 154         clk = devm_clk_get(&pdev->dev, NULL);
 155         if (IS_ERR(clk)) {
 156                 dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
 157                 return -ENODEV;
 158         }
 159         clk_prepare_enable(clk);
 160         wdt_tclk = clk_get_rate(clk);
 161
 162         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 163         if (!res)
 164                 return -ENODEV;
 165         wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 166         if (!wdt_reg)
 167                 return -ENOMEM;
 168
 169         wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
 170
 171         orion_wdt.timeout = wdt_max_duration;
 172         orion_wdt.max_timeout = wdt_max_duration;
 173         watchdog_init_timeout(&orion_wdt, heartbeat, &pdev->dev);
 174
 175         watchdog_set_nowayout(&orion_wdt, nowayout);
 176         ret = watchdog_register_device(&orion_wdt);
 177         if (ret) {
 178                 clk_disable_unprepare(clk);
 179                 return ret;
 180         }
 181
 182         pr_info("Initial timeout %d sec%s\n",
 183                 orion_wdt.timeout, nowayout ? ", nowayout" : "");
 184         return 0;
 185 }
 186
 187 static int orion_wdt_remove(struct platform_device *pdev)
 188 {
 189         watchdog_unregister_device(&orion_wdt);
 190         clk_disable_unprepare(clk);
 191         return 0;
 192 }
 193
 194 static void orion_wdt_shutdown(struct platform_device *pdev)
 195 {
 196         orion_wdt_stop(&orion_wdt);
 197 }
 198
 199 static const struct of_device_id orion_wdt_of_match_table[] = {
 200         { .compatible = "marvell,orion-wdt", },
 201         {},
 202 };
 203 MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table);
 204
 205 static struct platform_driver orion_wdt_driver = {
 206         .probe          = orion_wdt_probe,
 207         .remove         = orion_wdt_remove,
 208         .shutdown       = orion_wdt_shutdown,
 209         .driver         = {
 210                 .owner  = THIS_MODULE,
 211                 .name   = "orion_wdt",
 212                 .of_match_table = of_match_ptr(orion_wdt_of_match_table),
 213         },
 214 };
 215
 216 module_platform_driver(orion_wdt_driver);
 217
 218 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
 219 MODULE_DESCRIPTION("Orion Processor Watchdog");
 220
 221 module_param(heartbeat, int, 0);
 222 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
 223
 224 module_param(nowayout, bool, 0);
 225 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 226                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 227
 228 MODULE_LICENSE("GPL");
 229 MODULE_ALIAS("platform:orion_wdt");
 230 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);