v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / sbus / char / rtc.c
1 /* $Id: rtc.c,v 1.26 2001/03/14 09:30:31 davem Exp $
2  *
3  * Linux/SPARC Real Time Clock Driver
4  * Copyright (C) 1996 Thomas K. Dyas (tdyas@eden.rutgers.edu)
5  *
6  * This is a little driver that lets a user-level program access
7  * the SPARC Mostek real time clock chip. It is no use unless you
8  * use the modified clock utility.
9  *
10  * Get the modified clock utility from:
11  *   ftp://vger.kernel.org/pub/linux/Sparc/userland/clock.c
12  */
13
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/miscdevice.h>
18 #include <linux/slab.h>
19 #include <linux/fcntl.h>
20 #include <linux/poll.h>
21 #include <linux/init.h>
22 #include <linux/smp_lock.h>
23 #include <asm/mostek.h>
24 #include <asm/system.h>
25 #include <asm/uaccess.h>
26 #include <asm/rtc.h>
27
28 static int rtc_busy = 0;
29
30 /* Retrieve the current date and time from the real time clock. */
31 void get_rtc_time(struct rtc_time *t)
32 {
33         unsigned long regs = mstk48t02_regs;
34         u8 tmp;
35
36         spin_lock_irq(&mostek_lock);
37
38         tmp = mostek_read(regs + MOSTEK_CREG);
39         tmp |= MSTK_CREG_READ;
40         mostek_write(regs + MOSTEK_CREG, tmp);
41
42         t->sec = MSTK_REG_SEC(regs);
43         t->min = MSTK_REG_MIN(regs);
44         t->hour = MSTK_REG_HOUR(regs);
45         t->dow = MSTK_REG_DOW(regs);
46         t->dom = MSTK_REG_DOM(regs);
47         t->month = MSTK_REG_MONTH(regs);
48         t->year = MSTK_CVT_YEAR( MSTK_REG_YEAR(regs) );
49
50         tmp = mostek_read(regs + MOSTEK_CREG);
51         tmp &= ~MSTK_CREG_READ;
52         mostek_write(regs + MOSTEK_CREG, tmp);
53
54         spin_unlock_irq(&mostek_lock);
55 }
56
57 /* Set the current date and time inthe real time clock. */
58 void set_rtc_time(struct rtc_time *t)
59 {
60         unsigned long regs = mstk48t02_regs;
61         u8 tmp;
62
63         spin_lock_irq(&mostek_lock);
64
65         tmp = mostek_read(regs + MOSTEK_CREG);
66         tmp |= MSTK_CREG_WRITE;
67         mostek_write(regs + MOSTEK_CREG, tmp);
68
69         MSTK_SET_REG_SEC(regs,t->sec);
70         MSTK_SET_REG_MIN(regs,t->min);
71         MSTK_SET_REG_HOUR(regs,t->hour);
72         MSTK_SET_REG_DOW(regs,t->dow);
73         MSTK_SET_REG_DOM(regs,t->dom);
74         MSTK_SET_REG_MONTH(regs,t->month);
75         MSTK_SET_REG_YEAR(regs,t->year - MSTK_YEAR_ZERO);
76
77         tmp = mostek_read(regs + MOSTEK_CREG);
78         tmp &= ~MSTK_CREG_WRITE;
79         mostek_write(regs + MOSTEK_CREG, tmp);
80
81         spin_unlock_irq(&mostek_lock);
82 }
83
84 static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
85         unsigned long arg)
86 {
87         struct rtc_time rtc_tm;
88
89         switch (cmd)
90         {
91         case RTCGET:
92                 get_rtc_time(&rtc_tm);
93
94                 if (copy_to_user((struct rtc_time*)arg, &rtc_tm, sizeof(struct rtc_time)))
95                         return -EFAULT;
96
97                 return 0;
98
99
100         case RTCSET:
101                 if (!capable(CAP_SYS_TIME))
102                         return -EPERM;
103
104                 if (copy_from_user(&rtc_tm, (struct rtc_time*)arg, sizeof(struct rtc_time)))
105                         return -EFAULT;
106
107                 set_rtc_time(&rtc_tm);
108
109                 return 0;
110
111         default:
112                 return -EINVAL;
113         }
114 }
115
116 static int rtc_open(struct inode *inode, struct file *file)
117 {
118         int ret;
119
120         spin_lock_irq(&mostek_lock);
121         if (rtc_busy) {
122                 ret = -EBUSY;
123         } else {
124                 rtc_busy = 1;
125                 ret = 0;
126         }
127         spin_unlock_irq(&mostek_lock);
128
129         return ret;
130 }
131
132 static int rtc_release(struct inode *inode, struct file *file)
133 {
134         rtc_busy = 0;
135
136         return 0;
137 }
138
139 static struct file_operations rtc_fops = {
140         owner:          THIS_MODULE,
141         llseek:         no_llseek,
142         ioctl:          rtc_ioctl,
143         open:           rtc_open,
144         release:        rtc_release,
145 };
146
147 static struct miscdevice rtc_dev = { RTC_MINOR, "rtc", &rtc_fops };
148
149 EXPORT_NO_SYMBOLS;
150
151 static int __init rtc_sun_init(void)
152 {
153         int error;
154
155         /* It is possible we are being driven by some other RTC chip
156          * and thus another RTC driver is handling things.
157          */
158         if (mstk48t02_regs == 0)
159                 return -ENODEV;
160
161         error = misc_register(&rtc_dev);
162         if (error) {
163                 printk(KERN_ERR "rtc: unable to get misc minor for Mostek\n");
164                 return error;
165         }
166
167         return 0;
168 }
169
170 static void __exit rtc_sun_cleanup(void)
171 {
172         misc_deregister(&rtc_dev);
173 }
174
175 module_init(rtc_sun_init);
176 module_exit(rtc_sun_cleanup);