OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [mixcomwd.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1275 phoenix 
/*
2 
 * MixCom Watchdog: A Simple Hardware Watchdog Device
3 
 * Based on Softdog driver by Alan Cox and PC Watchdog driver by Ken Hollis
4 
 *
5 
 * Author: Gergely Madarasz <gorgo@itc.hu>
6 
 *
7 
 * Copyright (c) 1999 ITConsult-Pro Co. <info@itc.hu>
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 
 * Version 0.1 (99/04/15):
15 
 *              - first version
16 
 *
17 
 * Version 0.2 (99/06/16):
18 
 *              - added kernel timer watchdog ping after close
19 
 *                since the hardware does not support watchdog shutdown
20 
 *
21 
 * Version 0.3 (99/06/21):
22 
 *              - added WDIOC_GETSTATUS and WDIOC_GETSUPPORT ioctl calls
23 
 *
24 
 * Version 0.3.1 (99/06/22):
25 
 *              - allow module removal while internal timer is active,
26 
 *                print warning about probable reset
27 
 *
28 
 * Version 0.4 (99/11/15):
29 
 *              - support for one more type board
30 
 *
31 
 * Version 0.5 (2001/12/14) Matt Domsch <Matt_Domsch@dell.com>
32 
 *              - added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
33 
 *
34 
 */
35 
 
36 
#define VERSION "0.5"
37 
 
38 
#include <linux/module.h>
39 
#include <linux/config.h>
40 
#include <linux/types.h>
41 
#include <linux/kernel.h>
42 
#include <linux/fs.h>
43 
#include <linux/mm.h>
44 
#include <linux/miscdevice.h>
45 
#include <linux/ioport.h>
46 
#include <linux/watchdog.h>
47 
#include <linux/reboot.h>
48 
#include <linux/init.h>
49 
#include <linux/smp_lock.h>
50 
#include <asm/uaccess.h>
51 
#include <asm/io.h>
52 
 
53 
static int mixcomwd_ioports[] = { 0x180, 0x280, 0x380, 0x000 };
54 
 
55 
#define MIXCOM_WATCHDOG_OFFSET 0xc10
56 
#define MIXCOM_ID 0x11
57 
#define FLASHCOM_WATCHDOG_OFFSET 0x4
58 
#define FLASHCOM_ID 0x18
59 
 
60 
static long mixcomwd_opened; /* long req'd for setbit --RR */
61 
 
62 
static int watchdog_port;
63 
 
64 
static int mixcomwd_timer_alive;
65 
static struct timer_list mixcomwd_timer;
66 
static int expect_close = 0;
67 
 
68 
#ifdef CONFIG_WATCHDOG_NOWAYOUT
69 
static int nowayout = 1;
70 
#else
71 
static int nowayout = 0;
72 
#endif
73 
 
74 
MODULE_PARM(nowayout,"i");
75 
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
76 
 
77 
static void mixcomwd_ping(void)
78 
{
79 
        outb_p(55,watchdog_port);
80 
        return;
81 
}
82 
 
83 
static void mixcomwd_timerfun(unsigned long d)
84 
{
85 
        mixcomwd_ping();
86 
 
87 
        mod_timer(&mixcomwd_timer,jiffies+ 5*HZ);
88 
}
89 
 
90 
/*
91 
 *      Allow only one person to hold it open
92 
 */
93 
 
94 
static int mixcomwd_open(struct inode *inode, struct file *file)
95 
{
96 
        if(test_and_set_bit(0,&mixcomwd_opened)) {
97 
                return -EBUSY;
98 
        }
99 
        mixcomwd_ping();
100 
 
101 
        if (nowayout) {
102 
                MOD_INC_USE_COUNT;
103 
        }
104 
        if(mixcomwd_timer_alive) {
105 
                del_timer(&mixcomwd_timer);
106 
                mixcomwd_timer_alive=0;
107 
        }
108 
        return 0;
109 
}
110 
 
111 
static int mixcomwd_release(struct inode *inode, struct file *file)
112 
{
113 
 
114 
        lock_kernel();
115 
        if (expect_close) {
116 
                if(mixcomwd_timer_alive) {
117 
                        printk(KERN_ERR "mixcomwd: release called while internal timer alive");
118 
                        unlock_kernel();
119 
                        return -EBUSY;
120 
                }
121 
                init_timer(&mixcomwd_timer);
122 
                mixcomwd_timer.expires=jiffies + 5 * HZ;
123 
                mixcomwd_timer.function=mixcomwd_timerfun;
124 
                mixcomwd_timer.data=0;
125 
                mixcomwd_timer_alive=1;
126 
                add_timer(&mixcomwd_timer);
127 
        } else {
128 
                printk(KERN_CRIT "mixcomwd: WDT device closed unexpectedly.  WDT will not stop!\n");
129 
        }
130 
 
131 
        clear_bit(0,&mixcomwd_opened);
132 
        unlock_kernel();
133 
        return 0;
134 
}
135 
 
136 
 
137 
static ssize_t mixcomwd_write(struct file *file, const char *data, size_t len, loff_t *ppos)
138 
{
139 
        if (ppos != &file->f_pos) {
140 
                return -ESPIPE;
141 
        }
142 
 
143 
        if(len)
144 
        {
145 
                if (!nowayout) {
146 
                        size_t i;
147 
 
148 
                        /* In case it was set long ago */
149 
                        expect_close = 0;
150 
 
151 
                        for (i = 0; i != len; i++) {
152 
                                char c;
153 
                                if (get_user(c, data + i))
154 
                                        return -EFAULT;
155 
                                if (c == 'V')
156 
                                        expect_close = 1;
157 
                        }
158 
                }
159 
                mixcomwd_ping();
160 
                return 1;
161 
        }
162 
        return 0;
163 
}
164 
 
165 
static int mixcomwd_ioctl(struct inode *inode, struct file *file,
166 
        unsigned int cmd, unsigned long arg)
167 
{
168 
        int status;
169 
        static struct watchdog_info ident = {
170 
                WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
171 
                1, "MixCOM watchdog"
172 
        };
173 
 
174 
        switch(cmd)
175 
        {
176 
                case WDIOC_GETSTATUS:
177 
                        status=mixcomwd_opened;
178 
                        if (!nowayout) {
179 
                                status|=mixcomwd_timer_alive;
180 
                        }
181 
                        if (copy_to_user((int *)arg, &status, sizeof(int))) {
182 
                                return -EFAULT;
183 
                        }
184 
                        break;
185 
                case WDIOC_GETSUPPORT:
186 
                        if (copy_to_user((struct watchdog_info *)arg, &ident,
187 
                            sizeof(ident))) {
188 
                                return -EFAULT;
189 
                        }
190 
                        break;
191 
                case WDIOC_KEEPALIVE:
192 
                        mixcomwd_ping();
193 
                        break;
194 
                default:
195 
                        return -ENOTTY;
196 
        }
197 
        return 0;
198 
}
199 
 
200 
static struct file_operations mixcomwd_fops=
201 
{
202 
        owner:          THIS_MODULE,
203 
        write:          mixcomwd_write,
204 
        ioctl:          mixcomwd_ioctl,
205 
        open:           mixcomwd_open,
206 
        release:        mixcomwd_release,
207 
};
208 
 
209 
static struct miscdevice mixcomwd_miscdev=
210 
{
211 
        WATCHDOG_MINOR,
212 
        "watchdog",
213 
        &mixcomwd_fops
214 
};
215 
 
216 
static int __init mixcomwd_checkcard(int port)
217 
{
218 
        int id;
219 
 
220 
        if(check_region(port+MIXCOM_WATCHDOG_OFFSET,1)) {
221 
                return 0;
222 
        }
223 
 
224 
        id=inb_p(port + MIXCOM_WATCHDOG_OFFSET) & 0x3f;
225 
        if(id!=MIXCOM_ID) {
226 
                return 0;
227 
        }
228 
        return 1;
229 
}
230 
 
231 
static int __init flashcom_checkcard(int port)
232 
{
233 
        int id;
234 
 
235 
        if(check_region(port + FLASHCOM_WATCHDOG_OFFSET,1)) {
236 
                return 0;
237 
        }
238 
 
239 
        id=inb_p(port + FLASHCOM_WATCHDOG_OFFSET);
240 
        if(id!=FLASHCOM_ID) {
241 
                return 0;
242 
        }
243 
        return 1;
244 
 }
245 
 
246 
static int __init mixcomwd_init(void)
247 
{
248 
        int i;
249 
        int ret;
250 
        int found=0;
251 
 
252 
        for (i = 0; !found && mixcomwd_ioports[i] != 0; i++) {
253 
                if (mixcomwd_checkcard(mixcomwd_ioports[i])) {
254 
                        found = 1;
255 
                        watchdog_port = mixcomwd_ioports[i] + MIXCOM_WATCHDOG_OFFSET;
256 
                }
257 
        }
258 
 
259 
        /* The FlashCOM card can be set up at 0x300 -> 0x378, in 0x8 jumps */
260 
        for (i = 0x300; !found && i < 0x380; i+=0x8) {
261 
                if (flashcom_checkcard(i)) {
262 
                        found = 1;
263 
                        watchdog_port = i + FLASHCOM_WATCHDOG_OFFSET;
264 
                }
265 
        }
266 
 
267 
        if (!found) {
268 
                printk("mixcomwd: No card detected, or port not available.\n");
269 
                return -ENODEV;
270 
        }
271 
 
272 
        request_region(watchdog_port,1,"MixCOM watchdog");
273 
 
274 
        ret = misc_register(&mixcomwd_miscdev);
275 
        if (ret)
276 
                return ret;
277 
 
278 
        printk(KERN_INFO "MixCOM watchdog driver v%s, watchdog port at 0x%3x\n",VERSION,watchdog_port);
279 
 
280 
        return 0;
281 
}
282 
 
283 
static void __exit mixcomwd_exit(void)
284 
{
285 
        if (!nowayout) {
286 
                if(mixcomwd_timer_alive) {
287 
                        printk(KERN_WARNING "mixcomwd: I quit now, hardware will"
288 
                                " probably reboot!\n");
289 
                        del_timer(&mixcomwd_timer);
290 
                        mixcomwd_timer_alive=0;
291 
                }
292 
        }
293 
        release_region(watchdog_port,1);
294 
        misc_deregister(&mixcomwd_miscdev);
295 
}
296 
 
297 
module_init(mixcomwd_init);
298 
module_exit(mixcomwd_exit);
299 
 
300 
MODULE_LICENSE("GPL");
301 
EXPORT_NO_SYMBOLS;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.