GNU Linux-libre 4.9.328-gnu1
[releases.git] / drivers / watchdog / bcm7038_wdt.c
1 /*
2  * Copyright (C) 2015 Broadcom Corporation
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <linux/clk.h>
16 #include <linux/init.h>
17 #include <linux/io.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/platform_device.h>
21 #include <linux/pm.h>
22 #include <linux/watchdog.h>
23
24 #define WDT_START_1             0xff00
25 #define WDT_START_2             0x00ff
26 #define WDT_STOP_1              0xee00
27 #define WDT_STOP_2              0x00ee
28
29 #define WDT_TIMEOUT_REG         0x0
30 #define WDT_CMD_REG             0x4
31
32 #define WDT_MIN_TIMEOUT         1 /* seconds */
33 #define WDT_DEFAULT_TIMEOUT     30 /* seconds */
34 #define WDT_DEFAULT_RATE        27000000
35
36 struct bcm7038_watchdog {
37         void __iomem            *base;
38         struct watchdog_device  wdd;
39         u32                     rate;
40         struct clk              *clk;
41 };
42
43 static bool nowayout = WATCHDOG_NOWAYOUT;
44
45 static void bcm7038_wdt_set_timeout_reg(struct watchdog_device *wdog)
46 {
47         struct bcm7038_watchdog *wdt = watchdog_get_drvdata(wdog);
48         u32 timeout;
49
50         timeout = wdt->rate * wdog->timeout;
51
52         writel(timeout, wdt->base + WDT_TIMEOUT_REG);
53 }
54
55 static int bcm7038_wdt_ping(struct watchdog_device *wdog)
56 {
57         struct bcm7038_watchdog *wdt = watchdog_get_drvdata(wdog);
58
59         writel(WDT_START_1, wdt->base + WDT_CMD_REG);
60         writel(WDT_START_2, wdt->base + WDT_CMD_REG);
61
62         return 0;
63 }
64
65 static int bcm7038_wdt_start(struct watchdog_device *wdog)
66 {
67         bcm7038_wdt_set_timeout_reg(wdog);
68         bcm7038_wdt_ping(wdog);
69
70         return 0;
71 }
72
73 static int bcm7038_wdt_stop(struct watchdog_device *wdog)
74 {
75         struct bcm7038_watchdog *wdt = watchdog_get_drvdata(wdog);
76
77         writel(WDT_STOP_1, wdt->base + WDT_CMD_REG);
78         writel(WDT_STOP_2, wdt->base + WDT_CMD_REG);
79
80         return 0;
81 }
82
83 static int bcm7038_wdt_set_timeout(struct watchdog_device *wdog,
84                                    unsigned int t)
85 {
86         /* Can't modify timeout value if watchdog timer is running */
87         bcm7038_wdt_stop(wdog);
88         wdog->timeout = t;
89         bcm7038_wdt_start(wdog);
90
91         return 0;
92 }
93
94 static unsigned int bcm7038_wdt_get_timeleft(struct watchdog_device *wdog)
95 {
96         struct bcm7038_watchdog *wdt = watchdog_get_drvdata(wdog);
97         u32 time_left;
98
99         time_left = readl(wdt->base + WDT_CMD_REG);
100
101         return time_left / wdt->rate;
102 }
103
104 static struct watchdog_info bcm7038_wdt_info = {
105         .identity       = "Broadcom BCM7038 Watchdog Timer",
106         .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
107                                 WDIOF_MAGICCLOSE
108 };
109
110 static const struct watchdog_ops bcm7038_wdt_ops = {
111         .owner          = THIS_MODULE,
112         .start          = bcm7038_wdt_start,
113         .stop           = bcm7038_wdt_stop,
114         .set_timeout    = bcm7038_wdt_set_timeout,
115         .get_timeleft   = bcm7038_wdt_get_timeleft,
116 };
117
118 static int bcm7038_wdt_probe(struct platform_device *pdev)
119 {
120         struct device *dev = &pdev->dev;
121         struct bcm7038_watchdog *wdt;
122         struct resource *res;
123         int err;
124
125         wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
126         if (!wdt)
127                 return -ENOMEM;
128
129         platform_set_drvdata(pdev, wdt);
130
131         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
132         wdt->base = devm_ioremap_resource(dev, res);
133         if (IS_ERR(wdt->base))
134                 return PTR_ERR(wdt->base);
135
136         wdt->clk = devm_clk_get(dev, NULL);
137         /* If unable to get clock, use default frequency */
138         if (!IS_ERR(wdt->clk)) {
139                 clk_prepare_enable(wdt->clk);
140                 wdt->rate = clk_get_rate(wdt->clk);
141                 /* Prevent divide-by-zero exception */
142                 if (!wdt->rate)
143                         wdt->rate = WDT_DEFAULT_RATE;
144         } else {
145                 wdt->rate = WDT_DEFAULT_RATE;
146                 wdt->clk = NULL;
147         }
148
149         wdt->wdd.info           = &bcm7038_wdt_info;
150         wdt->wdd.ops            = &bcm7038_wdt_ops;
151         wdt->wdd.min_timeout    = WDT_MIN_TIMEOUT;
152         wdt->wdd.timeout        = WDT_DEFAULT_TIMEOUT;
153         wdt->wdd.max_timeout    = 0xffffffff / wdt->rate;
154         wdt->wdd.parent         = dev;
155         watchdog_set_drvdata(&wdt->wdd, wdt);
156
157         err = watchdog_register_device(&wdt->wdd);
158         if (err) {
159                 dev_err(dev, "Failed to register watchdog device\n");
160                 clk_disable_unprepare(wdt->clk);
161                 return err;
162         }
163
164         dev_info(dev, "Registered BCM7038 Watchdog\n");
165
166         return 0;
167 }
168
169 static int bcm7038_wdt_remove(struct platform_device *pdev)
170 {
171         struct bcm7038_watchdog *wdt = platform_get_drvdata(pdev);
172
173         if (!nowayout)
174                 bcm7038_wdt_stop(&wdt->wdd);
175
176         watchdog_unregister_device(&wdt->wdd);
177         clk_disable_unprepare(wdt->clk);
178
179         return 0;
180 }
181
182 #ifdef CONFIG_PM_SLEEP
183 static int bcm7038_wdt_suspend(struct device *dev)
184 {
185         struct bcm7038_watchdog *wdt = dev_get_drvdata(dev);
186
187         if (watchdog_active(&wdt->wdd))
188                 return bcm7038_wdt_stop(&wdt->wdd);
189
190         return 0;
191 }
192
193 static int bcm7038_wdt_resume(struct device *dev)
194 {
195         struct bcm7038_watchdog *wdt = dev_get_drvdata(dev);
196
197         if (watchdog_active(&wdt->wdd))
198                 return bcm7038_wdt_start(&wdt->wdd);
199
200         return 0;
201 }
202 #endif
203
204 static SIMPLE_DEV_PM_OPS(bcm7038_wdt_pm_ops, bcm7038_wdt_suspend,
205                          bcm7038_wdt_resume);
206
207 static void bcm7038_wdt_shutdown(struct platform_device *pdev)
208 {
209         struct bcm7038_watchdog *wdt = platform_get_drvdata(pdev);
210
211         if (watchdog_active(&wdt->wdd))
212                 bcm7038_wdt_stop(&wdt->wdd);
213 }
214
215 static const struct of_device_id bcm7038_wdt_match[] = {
216         { .compatible = "brcm,bcm7038-wdt" },
217         {},
218 };
219
220 static struct platform_driver bcm7038_wdt_driver = {
221         .probe          = bcm7038_wdt_probe,
222         .remove         = bcm7038_wdt_remove,
223         .shutdown       = bcm7038_wdt_shutdown,
224         .driver         = {
225                 .name           = "bcm7038-wdt",
226                 .of_match_table = bcm7038_wdt_match,
227                 .pm             = &bcm7038_wdt_pm_ops,
228         }
229 };
230 module_platform_driver(bcm7038_wdt_driver);
231
232 module_param(nowayout, bool, 0);
233 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
234         __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
235 MODULE_LICENSE("GPL v2");
236 MODULE_DESCRIPTION("Driver for Broadcom 7038 SoCs Watchdog");
237 MODULE_AUTHOR("Justin Chen");