Root/target/linux/adm5120/files/drivers/watchdog/adm5120_wdt.c

1/*
2 * ADM5120_WDT 0.01: Infineon ADM5120 SoC watchdog driver
3 * Copyright (c) Ondrej Zajicek <santiago@crfreenet.org>, 2007
4 *
5 * based on
6 *
7 * RC32434_WDT 0.01: IDT Interprise 79RC32434 watchdog driver
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 *
14 */
15#include <linux/module.h>
16#include <linux/types.h>
17#include <linux/fs.h>
18#include <linux/miscdevice.h>
19#include <linux/watchdog.h>
20#include <linux/irq.h>
21
22#include <asm/bootinfo.h>
23
24#include <asm/mach-adm5120/adm5120_info.h>
25#include <asm/mach-adm5120/adm5120_defs.h>
26#include <asm/mach-adm5120/adm5120_switch.h>
27
28#define DEFAULT_TIMEOUT 15 /* (secs) Default is 15 seconds */
29#define MAX_TIMEOUT 327
30/* Max is 327 seconds, counter is 15-bit integer, step is 10 ms */
31
32#define NAME "adm5120_wdt"
33#define VERSION "0.1"
34
35static int expect_close;
36static int access;
37static unsigned int timeout = DEFAULT_TIMEOUT;
38
39static int nowayout = WATCHDOG_NOWAYOUT;
40module_param(nowayout, int, 0);
41MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
42MODULE_LICENSE("GPL");
43
44
45static inline void wdt_set_timeout(void)
46{
47    u32 val = (1 << 31) | (((timeout * 100) & 0x7FFF) << 16);
48    SW_WRITE_REG(SWITCH_REG_WDOG0, val);
49}
50
51/*
52   It looks like WDOG0-register-write don't modify counter,
53   but WDOG0-register-read resets counter.
54*/
55
56static inline void wdt_reset_counter(void)
57{
58    SW_READ_REG(SWITCH_REG_WDOG0);
59}
60
61static inline void wdt_disable(void)
62{
63    SW_WRITE_REG(SWITCH_REG_WDOG0, 0x7FFF0000);
64}
65
66
67
68static int wdt_open(struct inode *inode, struct file *file)
69{
70    /* Allow only one person to hold it open */
71    if (access)
72        return -EBUSY;
73
74    if (nowayout)
75        __module_get(THIS_MODULE);
76
77    /* Activate timer */
78    wdt_reset_counter();
79    wdt_set_timeout();
80    printk(KERN_INFO NAME ": enabling watchdog timer\n");
81    access = 1;
82    return 0;
83}
84
85static int wdt_release(struct inode *inode, struct file *file)
86{
87    /*
88     * Shut off the timer.
89     * Lock it in if it's a module and we set nowayout
90     */
91    if (expect_close && (nowayout == 0)) {
92        wdt_disable();
93        printk(KERN_INFO NAME ": disabling watchdog timer\n");
94        module_put(THIS_MODULE);
95    } else
96        printk(KERN_CRIT NAME ": device closed unexpectedly. WDT will not stop!\n");
97
98    access = 0;
99    return 0;
100}
101
102static ssize_t wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
103{
104    /* Refresh the timer. */
105    if (len) {
106        if (!nowayout) {
107            size_t i;
108
109            /* In case it was set long ago */
110            expect_close = 0;
111
112            for (i = 0; i != len; i++) {
113                char c;
114                if (get_user(c, data + i))
115                    return -EFAULT;
116                if (c == 'V')
117                    expect_close = 1;
118            }
119        }
120        wdt_reset_counter();
121        return len;
122    }
123    return 0;
124}
125
126static int wdt_ioctl(struct inode *inode, struct file *file,
127    unsigned int cmd, unsigned long arg)
128{
129    int new_timeout;
130    static struct watchdog_info ident = {
131        .options = WDIOF_SETTIMEOUT |
132                    WDIOF_KEEPALIVEPING |
133                    WDIOF_MAGICCLOSE,
134        .firmware_version = 0,
135        .identity = "ADM5120_WDT Watchdog",
136    };
137    switch (cmd) {
138    default:
139        return -ENOTTY;
140    case WDIOC_GETSUPPORT:
141        if (copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)))
142            return -EFAULT;
143        return 0;
144    case WDIOC_GETSTATUS:
145    case WDIOC_GETBOOTSTATUS:
146        return put_user(0, (int *)arg);
147    case WDIOC_KEEPALIVE:
148        wdt_reset_counter();
149        return 0;
150    case WDIOC_SETTIMEOUT:
151        if (get_user(new_timeout, (int *)arg))
152            return -EFAULT;
153        if (new_timeout < 1)
154            return -EINVAL;
155        if (new_timeout > MAX_TIMEOUT)
156            return -EINVAL;
157        timeout = new_timeout;
158        wdt_set_timeout();
159        /* Fall */
160    case WDIOC_GETTIMEOUT:
161        return put_user(timeout, (int *)arg);
162    }
163}
164
165static const struct file_operations wdt_fops = {
166    .owner = THIS_MODULE,
167    .llseek = no_llseek,
168    .write = wdt_write,
169    .ioctl = wdt_ioctl,
170    .open = wdt_open,
171    .release = wdt_release,
172};
173
174static struct miscdevice wdt_miscdev = {
175    .minor = WATCHDOG_MINOR,
176    .name = "watchdog",
177    .fops = &wdt_fops,
178};
179
180static char banner[] __initdata = KERN_INFO NAME ": Watchdog Timer version " VERSION "\n";
181
182static int __init watchdog_init(void)
183{
184    int ret;
185
186    ret = misc_register(&wdt_miscdev);
187
188    if (ret)
189        return ret;
190
191    wdt_disable();
192    printk(banner);
193
194    return 0;
195}
196
197static void __exit watchdog_exit(void)
198{
199    misc_deregister(&wdt_miscdev);
200}
201
202module_init(watchdog_init);
203module_exit(watchdog_exit);
204

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive