URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [watchdog/] [alim7101_wdt.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 *      ALi M7101 PMU Computer Watchdog Timer driver
 *
 *      Based on w83877f_wdt.c by Scott Jennings <linuxdrivers@oro.net>
 *      and the Cobalt kernel WDT timer driver by Tim Hockin
 *                                            <thockin@cobaltnet.com>
 *
 *      (c)2002 Steve Hill <steve@navaho.co.uk>
 *
 *  This WDT driver is different from most other Linux WDT
 *  drivers in that the driver will ping the watchdog by itself,
 *  because this particular WDT has a very short timeout (1.6
 *  seconds) and it would be insane to count on any userspace
 *  daemon always getting scheduled within that time frame.
 *
 *  Additions:
 *   Aug 23, 2004 - Added use_gpio module parameter for use on revision a1d PMUs
 *                  found on very old cobalt hardware.
 *                  -- Mike Waychison <michael.waychison@sun.com>
 */
 
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/timer.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/ioport.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/pci.h>
 
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>
 
#define OUR_NAME "alim7101_wdt"
#define PFX OUR_NAME ": "
 
#define WDT_ENABLE 0x9C
#define WDT_DISABLE 0x8C
 
#define ALI_7101_WDT    0x92
#define ALI_7101_GPIO   0x7D
#define ALI_7101_GPIO_O 0x7E
#define ALI_WDT_ARM     0x01
 
/*
 * We're going to use a 1 second timeout.
 * If we reset the watchdog every ~250ms we should be safe.  */
 
#define WDT_INTERVAL (HZ/4+1)
 
/*
 * We must not require too good response from the userspace daemon.
 * Here we require the userspace daemon to send us a heartbeat
 * char to /dev/watchdog every 30 seconds.
 */
 
#define WATCHDOG_TIMEOUT 30            /* 30 sec default timeout */
static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
module_param(timeout, int, 0);
MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
static int use_gpio = 0; /* Use the pic (for a1d revision alim7101) */
module_param(use_gpio, int, 0);
MODULE_PARM_DESC(use_gpio, "Use the gpio watchdog.  (required by old cobalt boards)");
 
static void wdt_timer_ping(unsigned long);
static DEFINE_TIMER(timer, wdt_timer_ping, 0, 1);
static unsigned long next_heartbeat;
static unsigned long wdt_is_open;
static char wdt_expect_close;
static struct pci_dev *alim7101_pmu;
 
static int nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, int, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
/*
 *      Whack the dog
 */
 
static void wdt_timer_ping(unsigned long data)
{
        /* If we got a heartbeat pulse within the WDT_US_INTERVAL
         * we agree to ping the WDT
         */
        char    tmp;
 
        if(time_before(jiffies, next_heartbeat))
        {
                /* Ping the WDT (this is actually a disarm/arm sequence) */
                pci_read_config_byte(alim7101_pmu, 0x92, &tmp);
                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp | ALI_WDT_ARM));
                if (use_gpio) {
                        pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);
                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp
                                        | 0x20);
                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp
                                        & ~0x20);
                }
        } else {
                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
        }
        /* Re-set the timer interval */
        mod_timer(&timer, jiffies + WDT_INTERVAL);
}
 
/*
 * Utility routines
 */
 
static void wdt_change(int writeval)
{
        char    tmp;
 
        pci_read_config_byte(alim7101_pmu, ALI_7101_WDT, &tmp);
        if (writeval == WDT_ENABLE) {
                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp | ALI_WDT_ARM));
                if (use_gpio) {
                        pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);
                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp & ~0x20);
                }
 
        } else {
                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
                if (use_gpio) {
                        pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);
                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp | 0x20);
                }
        }
}
 
static void wdt_startup(void)
{
        next_heartbeat = jiffies + (timeout * HZ);
 
        /* We must enable before we kick off the timer in case the timer
           occurs as we ping it */
 
        wdt_change(WDT_ENABLE);
 
        /* Start the timer */
        mod_timer(&timer, jiffies + WDT_INTERVAL);
 
        printk(KERN_INFO PFX "Watchdog timer is now enabled.\n");
}
 
static void wdt_turnoff(void)
{
        /* Stop the timer */
        del_timer_sync(&timer);
        wdt_change(WDT_DISABLE);
        printk(KERN_INFO PFX "Watchdog timer is now disabled...\n");
}
 
static void wdt_keepalive(void)
{
        /* user land ping */
        next_heartbeat = jiffies + (timeout * HZ);
}
 
/*
 * /dev/watchdog handling
 */
 
static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
{
        /* See if we got the magic character 'V' and reload the timer */
        if(count) {
                if (!nowayout) {
                        size_t ofs;
 
                        /* note: just in case someone wrote the magic character
                         * five months ago... */
                        wdt_expect_close = 0;
 
                        /* now scan */
                        for (ofs = 0; ofs != count; ofs++) {
                                char c;
                                if (get_user(c, buf+ofs))
                                        return -EFAULT;
                                if (c == 'V')
                                        wdt_expect_close = 42;
                        }
                }
                /* someone wrote to us, we should restart timer */
                wdt_keepalive();
        }
        return count;
}
 
static int fop_open(struct inode * inode, struct file * file)
{
        /* Just in case we're already talking to someone... */
        if(test_and_set_bit(0, &wdt_is_open))
                return -EBUSY;
        /* Good, fire up the show */
        wdt_startup();
        return nonseekable_open(inode, file);
}
 
static int fop_close(struct inode * inode, struct file * file)
{
        if(wdt_expect_close == 42)
                wdt_turnoff();
        else {
                /* wim: shouldn't there be a: del_timer(&timer); */
                printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");
        }
        clear_bit(0, &wdt_is_open);
        wdt_expect_close = 0;
        return 0;
}
 
static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
        void __user *argp = (void __user *)arg;
        int __user *p = argp;
        static struct watchdog_info ident =
        {
                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
                .firmware_version = 1,
                .identity = "ALiM7101",
        };
 
        switch(cmd)
        {
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                case WDIOC_GETSTATUS:
                case WDIOC_GETBOOTSTATUS:
                        return put_user(0, p);
                case WDIOC_KEEPALIVE:
                        wdt_keepalive();
                        return 0;
                case WDIOC_SETOPTIONS:
                {
                        int new_options, retval = -EINVAL;
 
                        if(get_user(new_options, p))
                                return -EFAULT;
 
                        if(new_options & WDIOS_DISABLECARD) {
                                wdt_turnoff();
                                retval = 0;
                        }
 
                        if(new_options & WDIOS_ENABLECARD) {
                                wdt_startup();
                                retval = 0;
                        }
 
                        return retval;
                }
                case WDIOC_SETTIMEOUT:
                {
                        int new_timeout;
 
                        if(get_user(new_timeout, p))
                                return -EFAULT;
 
                        if(new_timeout < 1 || new_timeout > 3600) /* arbitrary upper limit */
                                return -EINVAL;
 
                        timeout = new_timeout;
                        wdt_keepalive();
                        /* Fall through */
                }
                case WDIOC_GETTIMEOUT:
                        return put_user(timeout, p);
                default:
                        return -ENOTTY;
        }
}
 
static const struct file_operations wdt_fops = {
        .owner=         THIS_MODULE,
        .llseek=        no_llseek,
        .write=         fop_write,
        .open=          fop_open,
        .release=       fop_close,
        .ioctl=         fop_ioctl,
};
 
static struct miscdevice wdt_miscdev = {
        .minor=WATCHDOG_MINOR,
        .name="watchdog",
        .fops=&wdt_fops,
};
 
/*
 *      Notifier for system down
 */
 
static int wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
{
        if (code==SYS_DOWN || code==SYS_HALT)
                wdt_turnoff();
 
        if (code==SYS_RESTART) {
                /*
                 * Cobalt devices have no way of rebooting themselves other than
                 * getting the watchdog to pull reset, so we restart the watchdog on
                 * reboot with no heartbeat
                 */
                wdt_change(WDT_ENABLE);
                printk(KERN_INFO PFX "Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second.\n");
        }
        return NOTIFY_DONE;
}
 
/*
 *      The WDT needs to learn about soft shutdowns in order to
 *      turn the timebomb registers off.
 */
 
static struct notifier_block wdt_notifier=
{
        .notifier_call = wdt_notify_sys,
};
 
static void __exit alim7101_wdt_unload(void)
{
        wdt_turnoff();
        /* Deregister */
        misc_deregister(&wdt_miscdev);
        unregister_reboot_notifier(&wdt_notifier);
        pci_dev_put(alim7101_pmu);
}
 
static int __init alim7101_wdt_init(void)
{
        int rc = -EBUSY;
        struct pci_dev *ali1543_south;
        char tmp;
 
        printk(KERN_INFO PFX "Steve Hill <steve@navaho.co.uk>.\n");
        alim7101_pmu = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
                NULL);
        if (!alim7101_pmu) {
                printk(KERN_INFO PFX "ALi M7101 PMU not present - WDT not set\n");
                return -EBUSY;
        }
 
        /* Set the WDT in the PMU to 1 second */
        pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, 0x02);
 
        ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
                NULL);
        if (!ali1543_south) {
                printk(KERN_INFO PFX "ALi 1543 South-Bridge not present - WDT not set\n");
                goto err_out;
        }
        pci_read_config_byte(ali1543_south, 0x5e, &tmp);
        pci_dev_put(ali1543_south);
        if ((tmp & 0x1e) == 0x00) {
                if (!use_gpio) {
                        printk(KERN_INFO PFX "Detected old alim7101 revision 'a1d'.  If this is a cobalt board, set the 'use_gpio' module parameter.\n");
                        goto err_out;
                }
                nowayout = 1;
        } else if ((tmp & 0x1e) != 0x12 && (tmp & 0x1e) != 0x00) {
                printk(KERN_INFO PFX "ALi 1543 South-Bridge does not have the correct revision number (???1001?) - WDT not set\n");
                goto err_out;
        }
 
        if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
        {
                timeout = WATCHDOG_TIMEOUT;
                printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",
                        timeout);
        }
 
        rc = misc_register(&wdt_miscdev);
        if (rc) {
                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
                        wdt_miscdev.minor, rc);
                goto err_out;
        }
 
        rc = register_reboot_notifier(&wdt_notifier);
        if (rc) {
                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
                        rc);
                goto err_out_miscdev;
        }
 
        if (nowayout) {
                __module_get(THIS_MODULE);
        }
 
        printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. timeout=%d sec (nowayout=%d)\n",
                timeout, nowayout);
        return 0;
 
err_out_miscdev:
        misc_deregister(&wdt_miscdev);
err_out:
        pci_dev_put(alim7101_pmu);
        return rc;
}
 
module_init(alim7101_wdt_init);
module_exit(alim7101_wdt_unload);
 
static struct pci_device_id alim7101_pci_tbl[] __devinitdata = {
        { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533) },
        { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101) },
        { }
};
 
MODULE_DEVICE_TABLE(pci, alim7101_pci_tbl);
 
MODULE_AUTHOR("Steve Hill");
MODULE_DESCRIPTION("ALi M7101 PMU Computer Watchdog Timer driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [watchdog/] [alim7101_wdt.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* ALi M7101 PMU Computer Watchdog Timer driver`
3			`*`
4			`* Based on w83877f_wdt.c by Scott Jennings <linuxdrivers@oro.net>`
5			`* and the Cobalt kernel WDT timer driver by Tim Hockin`
6			`* <thockin@cobaltnet.com>`
7			`*`
8			`* (c)2002 Steve Hill <steve@navaho.co.uk>`
9			`*`
10			`* This WDT driver is different from most other Linux WDT`
11			`* drivers in that the driver will ping the watchdog by itself,`
12			`* because this particular WDT has a very short timeout (1.6`
13			`* seconds) and it would be insane to count on any userspace`
14			`* daemon always getting scheduled within that time frame.`
15			`*`
16			`* Additions:`
17			`* Aug 23, 2004 - Added use_gpio module parameter for use on revision a1d PMUs`
18			`* found on very old cobalt hardware.`
19			`* -- Mike Waychison <michael.waychison@sun.com>`
20			`*/`
21
22			`#include <linux/module.h>`
23			`#include <linux/moduleparam.h>`
24			`#include <linux/types.h>`
25			`#include <linux/timer.h>`
26			`#include <linux/miscdevice.h>`
27			`#include <linux/watchdog.h>`
28			`#include <linux/ioport.h>`
29			`#include <linux/notifier.h>`
30			`#include <linux/reboot.h>`
31			`#include <linux/init.h>`
32			`#include <linux/fs.h>`
33			`#include <linux/pci.h>`
34
35			`#include <asm/io.h>`
36			`#include <asm/uaccess.h>`
37			`#include <asm/system.h>`
38
39			`#define OUR_NAME "alim7101_wdt"`
40			`#define PFX OUR_NAME ": "`
41
42			`#define WDT_ENABLE 0x9C`
43			`#define WDT_DISABLE 0x8C`
44
45			`#define ALI_7101_WDT 0x92`
46			`#define ALI_7101_GPIO 0x7D`
47			`#define ALI_7101_GPIO_O 0x7E`
48			`#define ALI_WDT_ARM 0x01`
49
50			`/*`
51			`* We're going to use a 1 second timeout.`
52			`* If we reset the watchdog every ~250ms we should be safe. */`
53
54			`#define WDT_INTERVAL (HZ/4+1)`
55
56			`/*`
57			`* We must not require too good response from the userspace daemon.`
58			`* Here we require the userspace daemon to send us a heartbeat`
59			`* char to /dev/watchdog every 30 seconds.`
60			`*/`
61
62			`#define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */`
63			`static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */`
64			`module_param(timeout, int, 0);`
65			`MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");`
66
67			`static int use_gpio = 0; /* Use the pic (for a1d revision alim7101) */`
68			`module_param(use_gpio, int, 0);`
69			`MODULE_PARM_DESC(use_gpio, "Use the gpio watchdog. (required by old cobalt boards)");`
70
71			`static void wdt_timer_ping(unsigned long);`
72			`static DEFINE_TIMER(timer, wdt_timer_ping, 0, 1);`
73			`static unsigned long next_heartbeat;`
74			`static unsigned long wdt_is_open;`
75			`static char wdt_expect_close;`
76			`static struct pci_dev *alim7101_pmu;`
77
78			`static int nowayout = WATCHDOG_NOWAYOUT;`
79			`module_param(nowayout, int, 0);`
80			`MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="`
81			`__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");`
82
83			`/*`
84			`* Whack the dog`
85			`*/`
86
87			`static void wdt_timer_ping(unsigned long data)`
88			`{`
89			`/* If we got a heartbeat pulse within the WDT_US_INTERVAL`
90			`* we agree to ping the WDT`
91			`*/`
92			`char tmp;`
93
94			`if(time_before(jiffies, next_heartbeat))`
95			`{`
96			`/* Ping the WDT (this is actually a disarm/arm sequence) */`
97			`pci_read_config_byte(alim7101_pmu, 0x92, &tmp);`
98			`pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));`
99			`pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp \| ALI_WDT_ARM));`
100			`if (use_gpio) {`
101			`pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);`
102			`pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp`
103			`\| 0x20);`
104			`pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp`
105			`& ~0x20);`
106			`}`
107			`} else {`
108			`printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");`
109			`}`
110			`/* Re-set the timer interval */`
111			`mod_timer(&timer, jiffies + WDT_INTERVAL);`
112			`}`
113
114			`/*`
115			`* Utility routines`
116			`*/`
117
118			`static void wdt_change(int writeval)`
119			`{`
120			`char tmp;`
121
122			`pci_read_config_byte(alim7101_pmu, ALI_7101_WDT, &tmp);`
123			`if (writeval == WDT_ENABLE) {`
124			`pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp \| ALI_WDT_ARM));`
125			`if (use_gpio) {`
126			`pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);`
127			`pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp & ~0x20);`
128			`}`
129
130			`} else {`
131			`pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));`
132			`if (use_gpio) {`
133			`pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);`
134			`pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp \| 0x20);`
135			`}`
136			`}`
137			`}`
138
139			`static void wdt_startup(void)`
140			`{`
141			`next_heartbeat = jiffies + (timeout * HZ);`
142
143			`/* We must enable before we kick off the timer in case the timer`
144			`occurs as we ping it */`
145
146			`wdt_change(WDT_ENABLE);`
147
148			`/* Start the timer */`
149			`mod_timer(&timer, jiffies + WDT_INTERVAL);`
150
151			`printk(KERN_INFO PFX "Watchdog timer is now enabled.\n");`
152			`}`
153
154			`static void wdt_turnoff(void)`
155			`{`
156			`/* Stop the timer */`
157			`del_timer_sync(&timer);`
158			`wdt_change(WDT_DISABLE);`
159			`printk(KERN_INFO PFX "Watchdog timer is now disabled...\n");`
160			`}`
161
162			`static void wdt_keepalive(void)`
163			`{`
164			`/* user land ping */`
165			`next_heartbeat = jiffies + (timeout * HZ);`
166			`}`
167
168			`/*`
169			`* /dev/watchdog handling`
170			`*/`
171
172			`static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)`
173			`{`
174			`/* See if we got the magic character 'V' and reload the timer */`
175			`if(count) {`
176			`if (!nowayout) {`
177			`size_t ofs;`
178
179			`/* note: just in case someone wrote the magic character`
180			`* five months ago... */`
181			`wdt_expect_close = 0;`
182
183			`/* now scan */`
184			`for (ofs = 0; ofs != count; ofs++) {`
185			`char c;`
186			`if (get_user(c, buf+ofs))`
187			`return -EFAULT;`
188			`if (c == 'V')`
189			`wdt_expect_close = 42;`
190			`}`
191			`}`
192			`/* someone wrote to us, we should restart timer */`
193			`wdt_keepalive();`
194			`}`
195			`return count;`
196			`}`
197
198			`static int fop_open(struct inode * inode, struct file * file)`
199			`{`
200			`/* Just in case we're already talking to someone... */`
201			`if(test_and_set_bit(0, &wdt_is_open))`
202			`return -EBUSY;`
203			`/* Good, fire up the show */`
204			`wdt_startup();`
205			`return nonseekable_open(inode, file);`
206			`}`
207
208			`static int fop_close(struct inode * inode, struct file * file)`
209			`{`
210			`if(wdt_expect_close == 42)`
211			`wdt_turnoff();`
212			`else {`
213			`/* wim: shouldn't there be a: del_timer(&timer); */`
214			`printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");`
215			`}`
216			`clear_bit(0, &wdt_is_open);`
217			`wdt_expect_close = 0;`
218			`return 0;`
219			`}`
220
221			`static int fop_ioctl(struct inode inode, struct file file, unsigned int cmd, unsigned long arg)`
222			`{`
223			`void __user argp = (void __user )arg;`
224			`int __user *p = argp;`
225			`static struct watchdog_info ident =`
226			`{`
227			`.options = WDIOF_KEEPALIVEPING \| WDIOF_SETTIMEOUT \| WDIOF_MAGICCLOSE,`
228			`.firmware_version = 1,`
229			`.identity = "ALiM7101",`
230			`};`
231
232			`switch(cmd)`
233			`{`
234			`case WDIOC_GETSUPPORT:`
235			`return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;`
236			`case WDIOC_GETSTATUS:`
237			`case WDIOC_GETBOOTSTATUS:`
238			`return put_user(0, p);`
239			`case WDIOC_KEEPALIVE:`
240			`wdt_keepalive();`
241			`return 0;`
242			`case WDIOC_SETOPTIONS:`
243			`{`
244			`int new_options, retval = -EINVAL;`
245
246			`if(get_user(new_options, p))`
247			`return -EFAULT;`
248
249			`if(new_options & WDIOS_DISABLECARD) {`
250			`wdt_turnoff();`
251			`retval = 0;`
252			`}`
253
254			`if(new_options & WDIOS_ENABLECARD) {`
255			`wdt_startup();`
256			`retval = 0;`
257			`}`
258
259			`return retval;`
260			`}`
261			`case WDIOC_SETTIMEOUT:`
262			`{`
263			`int new_timeout;`
264
265			`if(get_user(new_timeout, p))`
266			`return -EFAULT;`
267
268			`if(new_timeout < 1 \|\| new_timeout > 3600) /* arbitrary upper limit */`
269			`return -EINVAL;`
270
271			`timeout = new_timeout;`
272			`wdt_keepalive();`
273			`/* Fall through */`
274			`}`
275			`case WDIOC_GETTIMEOUT:`
276			`return put_user(timeout, p);`
277			`default:`
278			`return -ENOTTY;`
279			`}`
280			`}`
281
282			`static const struct file_operations wdt_fops = {`
283			`.owner= THIS_MODULE,`
284			`.llseek= no_llseek,`
285			`.write= fop_write,`
286			`.open= fop_open,`
287			`.release= fop_close,`
288			`.ioctl= fop_ioctl,`
289			`};`
290
291			`static struct miscdevice wdt_miscdev = {`
292			`.minor=WATCHDOG_MINOR,`
293			`.name="watchdog",`
294			`.fops=&wdt_fops,`
295			`};`
296
297			`/*`
298			`* Notifier for system down`
299			`*/`
300
301			`static int wdt_notify_sys(struct notifier_block this, unsigned long code, void unused)`
302			`{`
303			`if (code==SYS_DOWN \|\| code==SYS_HALT)`
304			`wdt_turnoff();`
305
306			`if (code==SYS_RESTART) {`
307			`/*`
308			`* Cobalt devices have no way of rebooting themselves other than`
309			`* getting the watchdog to pull reset, so we restart the watchdog on`
310			`* reboot with no heartbeat`
311			`*/`
312			`wdt_change(WDT_ENABLE);`
313			`printk(KERN_INFO PFX "Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second.\n");`
314			`}`
315			`return NOTIFY_DONE;`
316			`}`
317
318			`/*`
319			`* The WDT needs to learn about soft shutdowns in order to`
320			`* turn the timebomb registers off.`
321			`*/`
322
323			`static struct notifier_block wdt_notifier=`
324			`{`
325			`.notifier_call = wdt_notify_sys,`
326			`};`
327
328			`static void __exit alim7101_wdt_unload(void)`
329			`{`
330			`wdt_turnoff();`
331			`/* Deregister */`
332			`misc_deregister(&wdt_miscdev);`
333			`unregister_reboot_notifier(&wdt_notifier);`
334			`pci_dev_put(alim7101_pmu);`
335			`}`
336
337			`static int __init alim7101_wdt_init(void)`
338			`{`
339			`int rc = -EBUSY;`
340			`struct pci_dev *ali1543_south;`
341			`char tmp;`
342
343			`printk(KERN_INFO PFX "Steve Hill <steve@navaho.co.uk>.\n");`
344			`alim7101_pmu = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,`
345			`NULL);`
346			`if (!alim7101_pmu) {`
347			`printk(KERN_INFO PFX "ALi M7101 PMU not present - WDT not set\n");`
348			`return -EBUSY;`
349			`}`
350
351			`/* Set the WDT in the PMU to 1 second */`
352			`pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, 0x02);`
353
354			`ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,`
355			`NULL);`
356			`if (!ali1543_south) {`
357			`printk(KERN_INFO PFX "ALi 1543 South-Bridge not present - WDT not set\n");`
358			`goto err_out;`
359			`}`
360			`pci_read_config_byte(ali1543_south, 0x5e, &tmp);`
361			`pci_dev_put(ali1543_south);`
362			`if ((tmp & 0x1e) == 0x00) {`
363			`if (!use_gpio) {`
364			`printk(KERN_INFO PFX "Detected old alim7101 revision 'a1d'. If this is a cobalt board, set the 'use_gpio' module parameter.\n");`
365			`goto err_out;`
366			`}`
367			`nowayout = 1;`
368			`} else if ((tmp & 0x1e) != 0x12 && (tmp & 0x1e) != 0x00) {`
369			`printk(KERN_INFO PFX "ALi 1543 South-Bridge does not have the correct revision number (???1001?) - WDT not set\n");`
370			`goto err_out;`
371			`}`
372
373			`if(timeout < 1 \|\| timeout > 3600) /* arbitrary upper limit */`
374			`{`
375			`timeout = WATCHDOG_TIMEOUT;`
376			`printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",`
377			`timeout);`
378			`}`
379
380			`rc = misc_register(&wdt_miscdev);`
381			`if (rc) {`
382			`printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",`
383			`wdt_miscdev.minor, rc);`
384			`goto err_out;`
385			`}`
386
387			`rc = register_reboot_notifier(&wdt_notifier);`
388			`if (rc) {`
389			`printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",`
390			`rc);`
391			`goto err_out_miscdev;`
392			`}`
393
394			`if (nowayout) {`
395			`__module_get(THIS_MODULE);`
396			`}`
397
398			`printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. timeout=%d sec (nowayout=%d)\n",`
399			`timeout, nowayout);`
400			`return 0;`
401
402			`err_out_miscdev:`
403			`misc_deregister(&wdt_miscdev);`
404			`err_out:`
405			`pci_dev_put(alim7101_pmu);`
406			`return rc;`
407			`}`
408
409			`module_init(alim7101_wdt_init);`
410			`module_exit(alim7101_wdt_unload);`
411
412			`static struct pci_device_id alim7101_pci_tbl[] __devinitdata = {`
413			`{ PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533) },`
414			`{ PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101) },`
415			`{ }`
416			`};`
417
418			`MODULE_DEVICE_TABLE(pci, alim7101_pci_tbl);`
419
420			`MODULE_AUTHOR("Steve Hill");`
421			`MODULE_DESCRIPTION("ALi M7101 PMU Computer Watchdog Timer driver");`
422			`MODULE_LICENSE("GPL");`
423			`MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);`