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 = 0;
36static int access = 0;
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
78    /* Activate timer */
79    wdt_reset_counter();
80    wdt_set_timeout();
81    printk(KERN_INFO NAME ": enabling watchdog timer\n");
82    access = 1;
83    return 0;
84}
85
86static int wdt_release(struct inode *inode, struct file *file)
87{
88    /*
89     * Shut off the timer.
90     * Lock it in if it's a module and we set nowayout
91     */
92    if (expect_close && (nowayout == 0)) {
93        wdt_disable();
94        printk(KERN_INFO NAME ": disabling watchdog timer\n");
95        module_put(THIS_MODULE);
96    } else {
97        printk(KERN_CRIT NAME ": device closed unexpectedly. WDT will not stop!\n");
98    }
99    access = 0;
100    return 0;
101}
102
103static ssize_t wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
104{
105    /* Refresh the timer. */
106    if (len) {
107        if (!nowayout) {
108            size_t i;
109
110            /* In case it was set long ago */
111            expect_close = 0;
112
113            for (i = 0; i != len; i++) {
114                char c;
115                if (get_user(c, data + i))
116                    return -EFAULT;
117                if (c == 'V')
118                    expect_close = 1;
119            }
120        }
121        wdt_reset_counter();
122        return len;
123    }
124    return 0;
125}
126
127static int wdt_ioctl(struct inode *inode, struct file *file,
128    unsigned int cmd, unsigned long arg)
129{
130    int new_timeout;
131    static struct watchdog_info ident = {
132        .options = WDIOF_SETTIMEOUT |
133                    WDIOF_KEEPALIVEPING |
134                    WDIOF_MAGICCLOSE,
135        .firmware_version = 0,
136        .identity = "ADM5120_WDT Watchdog",
137    };
138    switch (cmd) {
139        default:
140            return -ENOTTY;
141        case WDIOC_GETSUPPORT:
142            if(copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)))
143                return -EFAULT;
144            return 0;
145        case WDIOC_GETSTATUS:
146        case WDIOC_GETBOOTSTATUS:
147            return put_user(0,(int *)arg);
148        case WDIOC_KEEPALIVE:
149            wdt_reset_counter();
150            return 0;
151        case WDIOC_SETTIMEOUT:
152            if (get_user(new_timeout, (int *)arg))
153                return -EFAULT;
154            if (new_timeout < 1)
155                return -EINVAL;
156            if (new_timeout > MAX_TIMEOUT)
157                return -EINVAL;
158            timeout = new_timeout;
159            wdt_set_timeout();
160            /* Fall */
161        case WDIOC_GETTIMEOUT:
162            return put_user(timeout, (int *)arg);
163    }
164}
165
166static struct file_operations wdt_fops = {
167    owner: THIS_MODULE,
168    llseek: no_llseek,
169    write: wdt_write,
170    ioctl: wdt_ioctl,
171    open: wdt_open,
172    release: wdt_release,
173};
174
175static struct miscdevice wdt_miscdev = {
176    minor: WATCHDOG_MINOR,
177    name: "watchdog",
178    fops: &wdt_fops,
179};
180
181static char banner[] __initdata = KERN_INFO NAME ": Watchdog Timer version " VERSION "\n";
182
183static int __init watchdog_init(void)
184{
185    int ret;
186
187    ret = misc_register(&wdt_miscdev);
188
189    if (ret)
190        return ret;
191
192    wdt_disable();
193    printk(banner);
194
195    return 0;
196}
197
198static void __exit watchdog_exit(void)
199{
200    misc_deregister(&wdt_miscdev);
201}
202
203module_init(watchdog_init);
204module_exit(watchdog_exit);
205

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