Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
orion_wdt.c
Go to the documentation of this file.
1 /*
2  * drivers/watchdog/orion_wdt.c
3  *
4  * Watchdog driver for Orion/Kirkwood processors
5  *
6  * Author: Sylver Bruneau <[email protected]>
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 static bool nowayout = WATCHDOG_NOWAYOUT;
42 static int heartbeat = -1; /* module parameter (seconds) */
43 static unsigned int wdt_max_duration; /* (seconds) */
44 static struct clk *clk;
45 static unsigned int wdt_tclk;
46 static void __iomem *wdt_reg;
47 static DEFINE_SPINLOCK(wdt_lock);
48 
49 static int orion_wdt_ping(struct watchdog_device *wdt_dev)
50 {
51  spin_lock(&wdt_lock);
52 
53  /* Reload watchdog duration */
54  writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
55 
56  spin_unlock(&wdt_lock);
57  return 0;
58 }
59 
60 static int orion_wdt_start(struct watchdog_device *wdt_dev)
61 {
62  u32 reg;
63 
64  spin_lock(&wdt_lock);
65 
66  /* Set watchdog duration */
67  writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
68 
69  /* Clear watchdog timer interrupt */
70  reg = readl(BRIDGE_CAUSE);
71  reg &= ~WDT_INT_REQ;
72  writel(reg, 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 = {
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 };
144 
145 static int __devinit orion_wdt_probe(struct platform_device *pdev)
146 {
147  struct resource *res;
148  int ret;
149 
150  clk = devm_clk_get(&pdev->dev, NULL);
151  if (IS_ERR(clk)) {
152  dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
153  return -ENODEV;
154  }
155  clk_prepare_enable(clk);
156  wdt_tclk = clk_get_rate(clk);
157 
158  res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
159  wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
160  if (!wdt_reg)
161  return -ENOMEM;
162 
163  wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
164 
165  if ((heartbeat < 1) || (heartbeat > wdt_max_duration))
166  heartbeat = wdt_max_duration;
167 
168  orion_wdt.timeout = heartbeat;
169  orion_wdt.min_timeout = 1;
170  orion_wdt.max_timeout = wdt_max_duration;
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  heartbeat, nowayout ? ", nowayout" : "");
181  return 0;
182 }
183 
184 static int __devexit 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[] __devinitdata = {
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 = __devexit_p(orion_wdt_remove),
205  .shutdown = orion_wdt_shutdown,
206  .driver = {
207  .owner = THIS_MODULE,
208  .name = "orion_wdt",
209  .of_match_table = of_match_ptr(orion_wdt_of_match_table),
210  },
211 };
212 
213 module_platform_driver(orion_wdt_driver);
214 
215 MODULE_AUTHOR("Sylver Bruneau <[email protected]>");
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="
224 
225 MODULE_LICENSE("GPL");