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

Subversion Repositories test_project

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

Details | Compare with Previous | View Log


/*
 * mpc8xx_wdt.c - MPC8xx watchdog userspace interface
 *
 * Author: Florian Schirmer <jolt@tuxbox.org>
 *
 * 2002 (c) Florian Schirmer <jolt@tuxbox.org> This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 */
 
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/watchdog.h>
#include <asm/8xx_immap.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <syslib/m8xx_wdt.h>
 
static unsigned long wdt_opened;
static int wdt_status;
 
static void mpc8xx_wdt_handler_disable(void)
{
        volatile uint __iomem *piscr;
        piscr = (uint *)&((immap_t*)IMAP_ADDR)->im_sit.sit_piscr;
 
        if (!m8xx_has_internal_rtc)
                m8xx_wdt_stop_timer();
        else
                out_be32(piscr, in_be32(piscr) & ~(PISCR_PIE | PISCR_PTE));
 
        printk(KERN_NOTICE "mpc8xx_wdt: keep-alive handler deactivated\n");
}
 
static void mpc8xx_wdt_handler_enable(void)
{
        volatile uint __iomem *piscr;
        piscr = (uint *)&((immap_t*)IMAP_ADDR)->im_sit.sit_piscr;
 
        if (!m8xx_has_internal_rtc)
                m8xx_wdt_install_timer();
        else
                out_be32(piscr, in_be32(piscr) | PISCR_PIE | PISCR_PTE);
 
        printk(KERN_NOTICE "mpc8xx_wdt: keep-alive handler activated\n");
}
 
static int mpc8xx_wdt_open(struct inode *inode, struct file *file)
{
        if (test_and_set_bit(0, &wdt_opened))
                return -EBUSY;
 
        m8xx_wdt_reset();
        mpc8xx_wdt_handler_disable();
 
        return nonseekable_open(inode, file);
}
 
static int mpc8xx_wdt_release(struct inode *inode, struct file *file)
{
        m8xx_wdt_reset();
 
#if !defined(CONFIG_WATCHDOG_NOWAYOUT)
        mpc8xx_wdt_handler_enable();
#endif
 
        clear_bit(0, &wdt_opened);
 
        return 0;
}
 
static ssize_t mpc8xx_wdt_write(struct file *file, const char *data, size_t len,
                                loff_t * ppos)
{
        if (len)
                m8xx_wdt_reset();
 
        return len;
}
 
static int mpc8xx_wdt_ioctl(struct inode *inode, struct file *file,
                            unsigned int cmd, unsigned long arg)
{
        int timeout;
        static struct watchdog_info info = {
                .options = WDIOF_KEEPALIVEPING,
                .firmware_version = 0,
                .identity = "MPC8xx watchdog",
        };
 
        switch (cmd) {
        case WDIOC_GETSUPPORT:
                if (copy_to_user((void *)arg, &info, sizeof(info)))
                        return -EFAULT;
                break;
 
        case WDIOC_GETSTATUS:
        case WDIOC_GETBOOTSTATUS:
                if (put_user(wdt_status, (int *)arg))
                        return -EFAULT;
                wdt_status &= ~WDIOF_KEEPALIVEPING;
                break;
 
        case WDIOC_GETTEMP:
                return -EOPNOTSUPP;
 
        case WDIOC_SETOPTIONS:
                return -EOPNOTSUPP;
 
        case WDIOC_KEEPALIVE:
                m8xx_wdt_reset();
                wdt_status |= WDIOF_KEEPALIVEPING;
                break;
 
        case WDIOC_SETTIMEOUT:
                return -EOPNOTSUPP;
 
        case WDIOC_GETTIMEOUT:
                timeout = m8xx_wdt_get_timeout();
                if (put_user(timeout, (int *)arg))
                        return -EFAULT;
                break;
 
        default:
                return -ENOTTY;
        }
 
        return 0;
}
 
static const struct file_operations mpc8xx_wdt_fops = {
        .owner = THIS_MODULE,
        .llseek = no_llseek,
        .write = mpc8xx_wdt_write,
        .ioctl = mpc8xx_wdt_ioctl,
        .open = mpc8xx_wdt_open,
        .release = mpc8xx_wdt_release,
};
 
static struct miscdevice mpc8xx_wdt_miscdev = {
        .minor = WATCHDOG_MINOR,
        .name = "watchdog",
        .fops = &mpc8xx_wdt_fops,
};
 
static int __init mpc8xx_wdt_init(void)
{
        return misc_register(&mpc8xx_wdt_miscdev);
}
 
static void __exit mpc8xx_wdt_exit(void)
{
        misc_deregister(&mpc8xx_wdt_miscdev);
 
        m8xx_wdt_reset();
        mpc8xx_wdt_handler_enable();
}
 
module_init(mpc8xx_wdt_init);
module_exit(mpc8xx_wdt_exit);
 
MODULE_AUTHOR("Florian Schirmer <jolt@tuxbox.org>");
MODULE_DESCRIPTION("MPC8xx watchdog driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* mpc8xx_wdt.c - MPC8xx watchdog userspace interface`
3			`*`
4			`* Author: Florian Schirmer <jolt@tuxbox.org>`
5			`*`
6			`* 2002 (c) Florian Schirmer <jolt@tuxbox.org> This file is licensed under`
7			`* the terms of the GNU General Public License version 2. This program`
8			`* is licensed "as is" without any warranty of any kind, whether express`
9			`* or implied.`
10			`*/`
11
12			`#include <linux/fs.h>`
13			`#include <linux/init.h>`
14			`#include <linux/kernel.h>`
15			`#include <linux/miscdevice.h>`
16			`#include <linux/module.h>`
17			`#include <linux/watchdog.h>`
18			`#include <asm/8xx_immap.h>`
19			`#include <asm/uaccess.h>`
20			`#include <asm/io.h>`
21			`#include <syslib/m8xx_wdt.h>`
22
23			`static unsigned long wdt_opened;`
24			`static int wdt_status;`
25
26			`static void mpc8xx_wdt_handler_disable(void)`
27			`{`
28			`volatile uint __iomem *piscr;`
29			`piscr = (uint )&((immap_t)IMAP_ADDR)->im_sit.sit_piscr;`
30
31			`if (!m8xx_has_internal_rtc)`
32			`m8xx_wdt_stop_timer();`
33			`else`
34			`out_be32(piscr, in_be32(piscr) & ~(PISCR_PIE \| PISCR_PTE));`
35
36			`printk(KERN_NOTICE "mpc8xx_wdt: keep-alive handler deactivated\n");`
37			`}`
38
39			`static void mpc8xx_wdt_handler_enable(void)`
40			`{`
41			`volatile uint __iomem *piscr;`
42			`piscr = (uint )&((immap_t)IMAP_ADDR)->im_sit.sit_piscr;`
43
44			`if (!m8xx_has_internal_rtc)`
45			`m8xx_wdt_install_timer();`
46			`else`
47			`out_be32(piscr, in_be32(piscr) \| PISCR_PIE \| PISCR_PTE);`
48
49			`printk(KERN_NOTICE "mpc8xx_wdt: keep-alive handler activated\n");`
50			`}`
51
52			`static int mpc8xx_wdt_open(struct inode inode, struct file file)`
53			`{`
54			`if (test_and_set_bit(0, &wdt_opened))`
55			`return -EBUSY;`
56
57			`m8xx_wdt_reset();`
58			`mpc8xx_wdt_handler_disable();`
59
60			`return nonseekable_open(inode, file);`
61			`}`
62
63			`static int mpc8xx_wdt_release(struct inode inode, struct file file)`
64			`{`
65			`m8xx_wdt_reset();`
66
67			`#if !defined(CONFIG_WATCHDOG_NOWAYOUT)`
68			`mpc8xx_wdt_handler_enable();`
69			`#endif`
70
71			`clear_bit(0, &wdt_opened);`
72
73			`return 0;`
74			`}`
75
76			`static ssize_t mpc8xx_wdt_write(struct file file, const char data, size_t len,`
77			`loff_t * ppos)`
78			`{`
79			`if (len)`
80			`m8xx_wdt_reset();`
81
82			`return len;`
83			`}`
84
85			`static int mpc8xx_wdt_ioctl(struct inode inode, struct file file,`
86			`unsigned int cmd, unsigned long arg)`
87			`{`
88			`int timeout;`
89			`static struct watchdog_info info = {`
90			`.options = WDIOF_KEEPALIVEPING,`
91			`.firmware_version = 0,`
92			`.identity = "MPC8xx watchdog",`
93			`};`
94
95			`switch (cmd) {`
96			`case WDIOC_GETSUPPORT:`
97			`if (copy_to_user((void *)arg, &info, sizeof(info)))`
98			`return -EFAULT;`
99			`break;`
100
101			`case WDIOC_GETSTATUS:`
102			`case WDIOC_GETBOOTSTATUS:`
103			`if (put_user(wdt_status, (int *)arg))`
104			`return -EFAULT;`
105			`wdt_status &= ~WDIOF_KEEPALIVEPING;`
106			`break;`
107
108			`case WDIOC_GETTEMP:`
109			`return -EOPNOTSUPP;`
110
111			`case WDIOC_SETOPTIONS:`
112			`return -EOPNOTSUPP;`
113
114			`case WDIOC_KEEPALIVE:`
115			`m8xx_wdt_reset();`
116			`wdt_status \|= WDIOF_KEEPALIVEPING;`
117			`break;`
118
119			`case WDIOC_SETTIMEOUT:`
120			`return -EOPNOTSUPP;`
121
122			`case WDIOC_GETTIMEOUT:`
123			`timeout = m8xx_wdt_get_timeout();`
124			`if (put_user(timeout, (int *)arg))`
125			`return -EFAULT;`
126			`break;`
127
128			`default:`
129			`return -ENOTTY;`
130			`}`
131
132			`return 0;`
133			`}`
134
135			`static const struct file_operations mpc8xx_wdt_fops = {`
136			`.owner = THIS_MODULE,`
137			`.llseek = no_llseek,`
138			`.write = mpc8xx_wdt_write,`
139			`.ioctl = mpc8xx_wdt_ioctl,`
140			`.open = mpc8xx_wdt_open,`
141			`.release = mpc8xx_wdt_release,`
142			`};`
143
144			`static struct miscdevice mpc8xx_wdt_miscdev = {`
145			`.minor = WATCHDOG_MINOR,`
146			`.name = "watchdog",`
147			`.fops = &mpc8xx_wdt_fops,`
148			`};`
149
150			`static int __init mpc8xx_wdt_init(void)`
151			`{`
152			`return misc_register(&mpc8xx_wdt_miscdev);`
153			`}`
154
155			`static void __exit mpc8xx_wdt_exit(void)`
156			`{`
157			`misc_deregister(&mpc8xx_wdt_miscdev);`
158
159			`m8xx_wdt_reset();`
160			`mpc8xx_wdt_handler_enable();`
161			`}`
162
163			`module_init(mpc8xx_wdt_init);`
164			`module_exit(mpc8xx_wdt_exit);`
165
166			`MODULE_AUTHOR("Florian Schirmer <jolt@tuxbox.org>");`
167			`MODULE_DESCRIPTION("MPC8xx watchdog driver");`
168			`MODULE_LICENSE("GPL");`
169			`MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);`

Browse

Tools

Subversion Repositories test_project

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