Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us