source: trunk/target/linux/ar71xx/files/drivers/watchdog/ar71xx_wdt.c @ 26516

Last change on this file since 26516 was 26516, checked in by juhosg, 5 years ago

ar71xx: add support for the watchdog of the AR934x SoCs

Signed-off-by: Jaiganesh Narayanan <jnarayanan@…>

  • Property svn:eol-style set to native
File size: 6.3 KB
Line 
1/*
2 * Driver for the Atheros AR71xx SoC's built-in hardware watchdog timer.
3 *
4 * Copyright (C) 2010-2011 Jaiganesh Narayanan <jnarayanan@atheros.com>
5 * Copyright (C) 2008 Gabor Juhos <juhosg@openwrt.org>
6 * Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
7 *
8 * Parts of this file are based on Atheros 2.6.31 BSP
9 *
10 * This driver was based on: drivers/watchdog/ixp4xx_wdt.c
11 *      Author: Deepak Saxena <dsaxena@plexity.net>
12 *      Copyright 2004 (c) MontaVista, Software, Inc.
13 *
14 * which again was based on sa1100 driver,
15 *      Copyright (C) 2000 Oleg Drokin <green@crimea.edu>
16 *
17 * This program is free software; you can redistribute it and/or modify it
18 * under the terms of the GNU General Public License version 2 as published
19 * by the Free Software Foundation.
20 *
21 */
22
23#include <linux/bitops.h>
24#include <linux/errno.h>
25#include <linux/fs.h>
26#include <linux/init.h>
27#include <linux/kernel.h>
28#include <linux/miscdevice.h>
29#include <linux/module.h>
30#include <linux/moduleparam.h>
31#include <linux/platform_device.h>
32#include <linux/types.h>
33#include <linux/watchdog.h>
34#include <linux/delay.h>
35
36#include <asm/mach-ar71xx/ar71xx.h>
37
38#define DRV_NAME        "ar71xx-wdt"
39#define DRV_DESC        "Atheros AR71xx hardware watchdog driver"
40#define DRV_VERSION     "0.1.0"
41
42#define WDT_TIMEOUT     15      /* seconds */
43
44static int nowayout = WATCHDOG_NOWAYOUT;
45
46#ifdef CONFIG_WATCHDOG_NOWAYOUT
47module_param(nowayout, int, 0);
48MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
49                           "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
50#endif
51
52static unsigned long wdt_flags;
53
54#define WDT_FLAGS_BUSY          0
55#define WDT_FLAGS_EXPECT_CLOSE  1
56
57static int wdt_timeout = WDT_TIMEOUT;
58static int boot_status;
59static int max_timeout;
60static u32 wdt_clk_freq;
61
62static inline void ar71xx_wdt_keepalive(void)
63{
64        ar71xx_reset_wr(AR71XX_RESET_REG_WDOG, wdt_clk_freq * wdt_timeout);
65}
66
67static inline void ar71xx_wdt_enable(void)
68{
69        printk(KERN_DEBUG DRV_NAME ": enabling watchdog timer\n");
70        ar71xx_wdt_keepalive();
71        udelay(2);
72        ar71xx_reset_wr(AR71XX_RESET_REG_WDOG_CTRL, WDOG_CTRL_ACTION_FCR);
73}
74
75static inline void ar71xx_wdt_disable(void)
76{
77        printk(KERN_DEBUG DRV_NAME ": disabling watchdog timer\n");
78        ar71xx_reset_wr(AR71XX_RESET_REG_WDOG_CTRL, WDOG_CTRL_ACTION_NONE);
79}
80
81static int ar71xx_wdt_set_timeout(int val)
82{
83        if (val < 1 || val > max_timeout)
84                return -EINVAL;
85
86        wdt_timeout = val;
87        ar71xx_wdt_keepalive();
88
89        printk(KERN_DEBUG DRV_NAME ": timeout=%d secs\n", wdt_timeout);
90
91        return 0;
92}
93
94static int ar71xx_wdt_open(struct inode *inode, struct file *file)
95{
96        if (test_and_set_bit(WDT_FLAGS_BUSY, &wdt_flags))
97                return -EBUSY;
98
99        clear_bit(WDT_FLAGS_EXPECT_CLOSE, &wdt_flags);
100
101        ar71xx_wdt_enable();
102
103        return nonseekable_open(inode, file);
104}
105
106static int ar71xx_wdt_release(struct inode *inode, struct file *file)
107{
108        if (test_bit(WDT_FLAGS_EXPECT_CLOSE, &wdt_flags)) {
109                ar71xx_wdt_disable();
110        } else {
111                printk(KERN_CRIT DRV_NAME ": device closed unexpectedly, "
112                                        "watchdog timer will not stop!\n");
113        }
114
115        clear_bit(WDT_FLAGS_BUSY, &wdt_flags);
116        clear_bit(WDT_FLAGS_EXPECT_CLOSE, &wdt_flags);
117
118        return 0;
119}
120
121static ssize_t ar71xx_wdt_write(struct file *file, const char *data,
122                                size_t len, loff_t *ppos)
123{
124        if (len) {
125                if (!nowayout) {
126                        size_t i;
127
128                        clear_bit(WDT_FLAGS_EXPECT_CLOSE, &wdt_flags);
129
130                        for (i = 0; i != len; i++) {
131                                char c;
132
133                                if (get_user(c, data + i))
134                                        return -EFAULT;
135
136                                if (c == 'V')
137                                        set_bit(WDT_FLAGS_EXPECT_CLOSE,
138                                                &wdt_flags);
139                        }
140                }
141
142                ar71xx_wdt_keepalive();
143        }
144
145        return len;
146}
147
148static struct watchdog_info ar71xx_wdt_info = {
149        .options                = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
150                                  WDIOF_MAGICCLOSE | WDIOF_CARDRESET,
151        .firmware_version       = 0,
152        .identity               = "AR71XX watchdog",
153};
154
155static long ar71xx_wdt_ioctl(struct file *file,
156                            unsigned int cmd, unsigned long arg)
157{
158        int t;
159        int ret;
160
161        switch (cmd) {
162        case WDIOC_GETSUPPORT:
163                ret = copy_to_user((struct watchdog_info *)arg,
164                                   &ar71xx_wdt_info,
165                                   sizeof(ar71xx_wdt_info)) ? -EFAULT : 0;
166                break;
167
168        case WDIOC_GETSTATUS:
169                ret = put_user(0, (int *)arg) ? -EFAULT : 0;
170                break;
171
172        case WDIOC_GETBOOTSTATUS:
173                ret = put_user(boot_status, (int *)arg) ? -EFAULT : 0;
174                break;
175
176        case WDIOC_KEEPALIVE:
177                ar71xx_wdt_keepalive();
178                ret = 0;
179                break;
180
181        case WDIOC_SETTIMEOUT:
182                ret = get_user(t, (int *)arg) ? -EFAULT : 0;
183                if (ret)
184                        break;
185
186                ret = ar71xx_wdt_set_timeout(t);
187                if (ret)
188                        break;
189
190                /* fallthrough */
191        case WDIOC_GETTIMEOUT:
192                ret = put_user(wdt_timeout, (int *)arg) ? -EFAULT : 0;
193                break;
194
195        default:
196                ret = -ENOTTY;
197                break;
198        }
199
200        return ret;
201}
202
203static const struct file_operations ar71xx_wdt_fops = {
204        .owner          = THIS_MODULE,
205        .write          = ar71xx_wdt_write,
206        .unlocked_ioctl = ar71xx_wdt_ioctl,
207        .open           = ar71xx_wdt_open,
208        .release        = ar71xx_wdt_release,
209};
210
211static struct miscdevice ar71xx_wdt_miscdev = {
212        .minor = WATCHDOG_MINOR,
213        .name = "watchdog",
214        .fops = &ar71xx_wdt_fops,
215};
216
217static int __devinit ar71xx_wdt_probe(struct platform_device *pdev)
218{
219        int ret;
220
221        switch (ar71xx_soc) {
222        case AR71XX_SOC_AR9341:
223        case AR71XX_SOC_AR9342:
224        case AR71XX_SOC_AR9344:
225                wdt_clk_freq = ar934x_ref_freq;
226                break;
227
228        default:
229                wdt_clk_freq = ar71xx_ahb_freq;
230                break;
231        }
232
233        max_timeout = (0xfffffffful / wdt_clk_freq);
234        wdt_timeout = (max_timeout < WDT_TIMEOUT) ? max_timeout : WDT_TIMEOUT;
235
236        if (ar71xx_reset_rr(AR71XX_RESET_REG_WDOG_CTRL) & WDOG_CTRL_LAST_RESET)
237                boot_status = WDIOF_CARDRESET;
238
239        ret = misc_register(&ar71xx_wdt_miscdev);
240        if (ret)
241                goto err_out;
242
243        printk(KERN_INFO DRV_DESC " version " DRV_VERSION "\n");
244
245        printk(KERN_DEBUG DRV_NAME ": timeout=%d secs (max=%d)\n",
246                                        wdt_timeout, max_timeout);
247
248        return 0;
249
250err_out:
251        return ret;
252}
253
254static int __devexit ar71xx_wdt_remove(struct platform_device *pdev)
255{
256        misc_deregister(&ar71xx_wdt_miscdev);
257        return 0;
258}
259
260static struct platform_driver ar71xx_wdt_driver = {
261        .probe          = ar71xx_wdt_probe,
262        .remove         = __devexit_p(ar71xx_wdt_remove),
263        .driver         = {
264                .name   = DRV_NAME,
265                .owner  = THIS_MODULE,
266        },
267};
268
269static int __init ar71xx_wdt_init(void)
270{
271        return platform_driver_register(&ar71xx_wdt_driver);
272}
273module_init(ar71xx_wdt_init);
274
275static void __exit ar71xx_wdt_exit(void)
276{
277        platform_driver_unregister(&ar71xx_wdt_driver);
278}
279module_exit(ar71xx_wdt_exit);
280
281MODULE_DESCRIPTION(DRV_DESC);
282MODULE_VERSION(DRV_VERSION);
283MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org");
284MODULE_AUTHOR("Imre Kaloz <kaloz@openwrt.org");
285MODULE_LICENSE("GPL v2");
286MODULE_ALIAS("platform:" DRV_NAME);
287MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
Note: See TracBrowser for help on using the repository browser.