Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/drivers/char/genrtc.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 12927 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 12927 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | /* |
2 | * Real Time Clock interface for |
3 | * - q40 and other m68k machines, |
4 | * - HP PARISC machines |
5 | * - PowerPC machines |
6 | * emulate some RTC irq capabilities in software |
7 | * |
8 | * Copyright (C) 1999 Richard Zidlicky |
9 | * |
10 | * based on Paul Gortmaker's rtc.c device and |
11 | * Sam Creasey Generic rtc driver |
12 | * |
13 | * This driver allows use of the real time clock (built into |
14 | * nearly all computers) from user space. It exports the /dev/rtc |
15 | * interface supporting various ioctl() and also the /proc/dev/rtc |
16 | * pseudo-file for status information. |
17 | * |
18 | * The ioctls can be used to set the interrupt behaviour where |
19 | * supported. |
20 | * |
21 | * The /dev/rtc interface will block on reads until an interrupt |
22 | * has been received. If a RTC interrupt has already happened, |
23 | * it will output an unsigned long and then block. The output value |
24 | * contains the interrupt status in the low byte and the number of |
25 | * interrupts since the last read in the remaining high bytes. The |
26 | * /dev/rtc interface can also be used with the select(2) call. |
27 | * |
28 | * This program is free software; you can redistribute it and/or |
29 | * modify it under the terms of the GNU General Public License |
30 | * as published by the Free Software Foundation; either version |
31 | * 2 of the License, or (at your option) any later version. |
32 | * |
33 | |
34 | * 1.01 fix for 2.3.X rz@linux-m68k.org |
35 | * 1.02 merged with code from genrtc.c rz@linux-m68k.org |
36 | * 1.03 make it more portable zippel@linux-m68k.org |
37 | * 1.04 removed useless timer code rz@linux-m68k.org |
38 | * 1.05 portable RTC_UIE emulation rz@linux-m68k.org |
39 | * 1.06 set_rtc_time can return an error trini@kernel.crashing.org |
40 | * 1.07 ported to HP PARISC (hppa) Helge Deller <deller@gmx.de> |
41 | */ |
42 | |
43 | #define RTC_VERSION "1.07" |
44 | |
45 | #include <linux/module.h> |
46 | #include <linux/config.h> |
47 | #include <linux/errno.h> |
48 | #include <linux/miscdevice.h> |
49 | #include <linux/fcntl.h> |
50 | |
51 | #include <linux/rtc.h> |
52 | #include <linux/init.h> |
53 | #include <linux/poll.h> |
54 | #include <linux/proc_fs.h> |
55 | #include <linux/workqueue.h> |
56 | |
57 | #include <asm/uaccess.h> |
58 | #include <asm/system.h> |
59 | #include <asm/rtc.h> |
60 | |
61 | /* |
62 | * We sponge a minor off of the misc major. No need slurping |
63 | * up another valuable major dev number for this. If you add |
64 | * an ioctl, make sure you don't conflict with SPARC's RTC |
65 | * ioctls. |
66 | */ |
67 | |
68 | static DECLARE_WAIT_QUEUE_HEAD(gen_rtc_wait); |
69 | |
70 | /* |
71 | * Bits in gen_rtc_status. |
72 | */ |
73 | |
74 | #define RTC_IS_OPEN 0x01 /* means /dev/rtc is in use */ |
75 | |
76 | static unsigned char gen_rtc_status; /* bitmapped status byte. */ |
77 | static unsigned long gen_rtc_irq_data; /* our output to the world */ |
78 | |
79 | /* months start at 0 now */ |
80 | static unsigned char days_in_mo[] = |
81 | {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; |
82 | |
83 | static int irq_active; |
84 | |
85 | #ifdef CONFIG_GEN_RTC_X |
86 | static struct work_struct genrtc_task; |
87 | static struct timer_list timer_task; |
88 | |
89 | static unsigned int oldsecs; |
90 | static int lostint; |
91 | static unsigned long tt_exp; |
92 | |
93 | static void gen_rtc_timer(unsigned long data); |
94 | |
95 | static volatile int stask_active; /* schedule_work */ |
96 | static volatile int ttask_active; /* timer_task */ |
97 | static int stop_rtc_timers; /* don't requeue tasks */ |
98 | static DEFINE_SPINLOCK(gen_rtc_lock); |
99 | |
100 | static void gen_rtc_interrupt(unsigned long arg); |
101 | |
102 | /* |
103 | * Routine to poll RTC seconds field for change as often as possible, |
104 | * after first RTC_UIE use timer to reduce polling |
105 | */ |
106 | static void genrtc_troutine(void *data) |
107 | { |
108 | unsigned int tmp = get_rtc_ss(); |
109 | |
110 | if (stop_rtc_timers) { |
111 | stask_active = 0; |
112 | return; |
113 | } |
114 | |
115 | if (oldsecs != tmp){ |
116 | oldsecs = tmp; |
117 | |
118 | timer_task.function = gen_rtc_timer; |
119 | timer_task.expires = jiffies + HZ - (HZ/10); |
120 | tt_exp=timer_task.expires; |
121 | ttask_active=1; |
122 | stask_active=0; |
123 | add_timer(&timer_task); |
124 | |
125 | gen_rtc_interrupt(0); |
126 | } else if (schedule_work(&genrtc_task) == 0) |
127 | stask_active = 0; |
128 | } |
129 | |
130 | static void gen_rtc_timer(unsigned long data) |
131 | { |
132 | lostint = get_rtc_ss() - oldsecs ; |
133 | if (lostint<0) |
134 | lostint = 60 - lostint; |
135 | if (time_after(jiffies, tt_exp)) |
136 | printk(KERN_INFO "genrtc: timer task delayed by %ld jiffies\n", |
137 | jiffies-tt_exp); |
138 | ttask_active=0; |
139 | stask_active=1; |
140 | if ((schedule_work(&genrtc_task) == 0)) |
141 | stask_active = 0; |
142 | } |
143 | |
144 | /* |
145 | * call gen_rtc_interrupt function to signal an RTC_UIE, |
146 | * arg is unused. |
147 | * Could be invoked either from a real interrupt handler or |
148 | * from some routine that periodically (eg 100HZ) monitors |
149 | * whether RTC_SECS changed |
150 | */ |
151 | static void gen_rtc_interrupt(unsigned long arg) |
152 | { |
153 | /* We store the status in the low byte and the number of |
154 | * interrupts received since the last read in the remainder |
155 | * of rtc_irq_data. */ |
156 | |
157 | gen_rtc_irq_data += 0x100; |
158 | gen_rtc_irq_data &= ~0xff; |
159 | gen_rtc_irq_data |= RTC_UIE; |
160 | |
161 | if (lostint){ |
162 | printk("genrtc: system delaying clock ticks?\n"); |
163 | /* increment count so that userspace knows something is wrong */ |
164 | gen_rtc_irq_data += ((lostint-1)<<8); |
165 | lostint = 0; |
166 | } |
167 | |
168 | wake_up_interruptible(&gen_rtc_wait); |
169 | } |
170 | |
171 | /* |
172 | * Now all the various file operations that we export. |
173 | */ |
174 | static ssize_t gen_rtc_read(struct file *file, char __user *buf, |
175 | size_t count, loff_t *ppos) |
176 | { |
177 | DECLARE_WAITQUEUE(wait, current); |
178 | unsigned long data; |
179 | ssize_t retval; |
180 | |
181 | if (count != sizeof (unsigned int) && count != sizeof (unsigned long)) |
182 | return -EINVAL; |
183 | |
184 | if (file->f_flags & O_NONBLOCK && !gen_rtc_irq_data) |
185 | return -EAGAIN; |
186 | |
187 | add_wait_queue(&gen_rtc_wait, &wait); |
188 | retval = -ERESTARTSYS; |
189 | |
190 | while (1) { |
191 | set_current_state(TASK_INTERRUPTIBLE); |
192 | data = xchg(&gen_rtc_irq_data, 0); |
193 | if (data) |
194 | break; |
195 | if (signal_pending(current)) |
196 | goto out; |
197 | schedule(); |
198 | } |
199 | |
200 | /* first test allows optimizer to nuke this case for 32-bit machines */ |
201 | if (sizeof (int) != sizeof (long) && count == sizeof (unsigned int)) { |
202 | unsigned int uidata = data; |
203 | retval = put_user(uidata, (unsigned long __user *)buf); |
204 | } |
205 | else { |
206 | retval = put_user(data, (unsigned long __user *)buf); |
207 | } |
208 | if (!retval) |
209 | retval = sizeof(unsigned long); |
210 | out: |
211 | current->state = TASK_RUNNING; |
212 | remove_wait_queue(&gen_rtc_wait, &wait); |
213 | |
214 | return retval; |
215 | } |
216 | |
217 | static unsigned int gen_rtc_poll(struct file *file, |
218 | struct poll_table_struct *wait) |
219 | { |
220 | poll_wait(file, &gen_rtc_wait, wait); |
221 | if (gen_rtc_irq_data != 0) |
222 | return POLLIN | POLLRDNORM; |
223 | return 0; |
224 | } |
225 | |
226 | #endif |
227 | |
228 | /* |
229 | * Used to disable/enable interrupts, only RTC_UIE supported |
230 | * We also clear out any old irq data after an ioctl() that |
231 | * meddles with the interrupt enable/disable bits. |
232 | */ |
233 | |
234 | static inline void gen_clear_rtc_irq_bit(unsigned char bit) |
235 | { |
236 | #ifdef CONFIG_GEN_RTC_X |
237 | stop_rtc_timers = 1; |
238 | if (ttask_active){ |
239 | del_timer_sync(&timer_task); |
240 | ttask_active = 0; |
241 | } |
242 | while (stask_active) |
243 | schedule(); |
244 | |
245 | spin_lock(&gen_rtc_lock); |
246 | irq_active = 0; |
247 | spin_unlock(&gen_rtc_lock); |
248 | #endif |
249 | } |
250 | |
251 | static inline int gen_set_rtc_irq_bit(unsigned char bit) |
252 | { |
253 | #ifdef CONFIG_GEN_RTC_X |
254 | spin_lock(&gen_rtc_lock); |
255 | if ( !irq_active ) { |
256 | irq_active = 1; |
257 | stop_rtc_timers = 0; |
258 | lostint = 0; |
259 | INIT_WORK(&genrtc_task, genrtc_troutine, NULL); |
260 | oldsecs = get_rtc_ss(); |
261 | init_timer(&timer_task); |
262 | |
263 | stask_active = 1; |
264 | if (schedule_work(&genrtc_task) == 0){ |
265 | stask_active = 0; |
266 | } |
267 | } |
268 | spin_unlock(&gen_rtc_lock); |
269 | gen_rtc_irq_data = 0; |
270 | return 0; |
271 | #else |
272 | return -EINVAL; |
273 | #endif |
274 | } |
275 | |
276 | static int gen_rtc_ioctl(struct inode *inode, struct file *file, |
277 | unsigned int cmd, unsigned long arg) |
278 | { |
279 | struct rtc_time wtime; |
280 | struct rtc_pll_info pll; |
281 | void __user *argp = (void __user *)arg; |
282 | |
283 | switch (cmd) { |
284 | |
285 | case RTC_PLL_GET: |
286 | if (get_rtc_pll(&pll)) |
287 | return -EINVAL; |
288 | else |
289 | return copy_to_user(argp, &pll, sizeof pll) ? -EFAULT : 0; |
290 | |
291 | case RTC_PLL_SET: |
292 | if (!capable(CAP_SYS_TIME)) |
293 | return -EACCES; |
294 | if (copy_from_user(&pll, argp, sizeof(pll))) |
295 | return -EFAULT; |
296 | return set_rtc_pll(&pll); |
297 | |
298 | case RTC_UIE_OFF: /* disable ints from RTC updates. */ |
299 | gen_clear_rtc_irq_bit(RTC_UIE); |
300 | return 0; |
301 | |
302 | case RTC_UIE_ON: /* enable ints for RTC updates. */ |
303 | return gen_set_rtc_irq_bit(RTC_UIE); |
304 | |
305 | case RTC_RD_TIME: /* Read the time/date from RTC */ |
306 | /* this doesn't get week-day, who cares */ |
307 | memset(&wtime, 0, sizeof(wtime)); |
308 | get_rtc_time(&wtime); |
309 | |
310 | return copy_to_user(argp, &wtime, sizeof(wtime)) ? -EFAULT : 0; |
311 | |
312 | case RTC_SET_TIME: /* Set the RTC */ |
313 | { |
314 | int year; |
315 | unsigned char leap_yr; |
316 | |
317 | if (!capable(CAP_SYS_TIME)) |
318 | return -EACCES; |
319 | |
320 | if (copy_from_user(&wtime, argp, sizeof(wtime))) |
321 | return -EFAULT; |
322 | |
323 | year = wtime.tm_year + 1900; |
324 | leap_yr = ((!(year % 4) && (year % 100)) || |
325 | !(year % 400)); |
326 | |
327 | if ((wtime.tm_mon < 0 || wtime.tm_mon > 11) || (wtime.tm_mday < 1)) |
328 | return -EINVAL; |
329 | |
330 | if (wtime.tm_mday < 0 || wtime.tm_mday > |
331 | (days_in_mo[wtime.tm_mon] + ((wtime.tm_mon == 1) && leap_yr))) |
332 | return -EINVAL; |
333 | |
334 | if (wtime.tm_hour < 0 || wtime.tm_hour >= 24 || |
335 | wtime.tm_min < 0 || wtime.tm_min >= 60 || |
336 | wtime.tm_sec < 0 || wtime.tm_sec >= 60) |
337 | return -EINVAL; |
338 | |
339 | return set_rtc_time(&wtime); |
340 | } |
341 | } |
342 | |
343 | return -EINVAL; |
344 | } |
345 | |
346 | /* |
347 | * We enforce only one user at a time here with the open/close. |
348 | * Also clear the previous interrupt data on an open, and clean |
349 | * up things on a close. |
350 | */ |
351 | |
352 | static int gen_rtc_open(struct inode *inode, struct file *file) |
353 | { |
354 | if (gen_rtc_status & RTC_IS_OPEN) |
355 | return -EBUSY; |
356 | |
357 | gen_rtc_status |= RTC_IS_OPEN; |
358 | gen_rtc_irq_data = 0; |
359 | irq_active = 0; |
360 | |
361 | return 0; |
362 | } |
363 | |
364 | static int gen_rtc_release(struct inode *inode, struct file *file) |
365 | { |
366 | /* |
367 | * Turn off all interrupts once the device is no longer |
368 | * in use and clear the data. |
369 | */ |
370 | |
371 | gen_clear_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE); |
372 | |
373 | gen_rtc_status &= ~RTC_IS_OPEN; |
374 | return 0; |
375 | } |
376 | |
377 | |
378 | #ifdef CONFIG_PROC_FS |
379 | |
380 | /* |
381 | * Info exported via "/proc/rtc". |
382 | */ |
383 | |
384 | static int gen_rtc_proc_output(char *buf) |
385 | { |
386 | char *p; |
387 | struct rtc_time tm; |
388 | unsigned int flags; |
389 | struct rtc_pll_info pll; |
390 | |
391 | p = buf; |
392 | |
393 | flags = get_rtc_time(&tm); |
394 | |
395 | p += sprintf(p, |
396 | "rtc_time\t: %02d:%02d:%02d\n" |
397 | "rtc_date\t: %04d-%02d-%02d\n" |
398 | "rtc_epoch\t: %04u\n", |
399 | tm.tm_hour, tm.tm_min, tm.tm_sec, |
400 | tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, 1900); |
401 | |
402 | tm.tm_hour = tm.tm_min = tm.tm_sec = 0; |
403 | |
404 | p += sprintf(p, "alarm\t\t: "); |
405 | if (tm.tm_hour <= 24) |
406 | p += sprintf(p, "%02d:", tm.tm_hour); |
407 | else |
408 | p += sprintf(p, "**:"); |
409 | |
410 | if (tm.tm_min <= 59) |
411 | p += sprintf(p, "%02d:", tm.tm_min); |
412 | else |
413 | p += sprintf(p, "**:"); |
414 | |
415 | if (tm.tm_sec <= 59) |
416 | p += sprintf(p, "%02d\n", tm.tm_sec); |
417 | else |
418 | p += sprintf(p, "**\n"); |
419 | |
420 | p += sprintf(p, |
421 | "DST_enable\t: %s\n" |
422 | "BCD\t\t: %s\n" |
423 | "24hr\t\t: %s\n" |
424 | "square_wave\t: %s\n" |
425 | "alarm_IRQ\t: %s\n" |
426 | "update_IRQ\t: %s\n" |
427 | "periodic_IRQ\t: %s\n" |
428 | "periodic_freq\t: %ld\n" |
429 | "batt_status\t: %s\n", |
430 | (flags & RTC_DST_EN) ? "yes" : "no", |
431 | (flags & RTC_DM_BINARY) ? "no" : "yes", |
432 | (flags & RTC_24H) ? "yes" : "no", |
433 | (flags & RTC_SQWE) ? "yes" : "no", |
434 | (flags & RTC_AIE) ? "yes" : "no", |
435 | irq_active ? "yes" : "no", |
436 | (flags & RTC_PIE) ? "yes" : "no", |
437 | 0L /* freq */, |
438 | (flags & RTC_BATT_BAD) ? "bad" : "okay"); |
439 | if (!get_rtc_pll(&pll)) |
440 | p += sprintf(p, |
441 | "PLL adjustment\t: %d\n" |
442 | "PLL max +ve adjustment\t: %d\n" |
443 | "PLL max -ve adjustment\t: %d\n" |
444 | "PLL +ve adjustment factor\t: %d\n" |
445 | "PLL -ve adjustment factor\t: %d\n" |
446 | "PLL frequency\t: %ld\n", |
447 | pll.pll_value, |
448 | pll.pll_max, |
449 | pll.pll_min, |
450 | pll.pll_posmult, |
451 | pll.pll_negmult, |
452 | pll.pll_clock); |
453 | return p - buf; |
454 | } |
455 | |
456 | static int gen_rtc_read_proc(char *page, char **start, off_t off, |
457 | int count, int *eof, void *data) |
458 | { |
459 | int len = gen_rtc_proc_output (page); |
460 | if (len <= off+count) *eof = 1; |
461 | *start = page + off; |
462 | len -= off; |
463 | if (len>count) len = count; |
464 | if (len<0) len = 0; |
465 | return len; |
466 | } |
467 | |
468 | static int __init gen_rtc_proc_init(void) |
469 | { |
470 | struct proc_dir_entry *r; |
471 | |
472 | r = create_proc_read_entry("driver/rtc", 0, NULL, gen_rtc_read_proc, NULL); |
473 | if (!r) |
474 | return -ENOMEM; |
475 | return 0; |
476 | } |
477 | #else |
478 | static inline int gen_rtc_proc_init(void) { return 0; } |
479 | #endif /* CONFIG_PROC_FS */ |
480 | |
481 | |
482 | /* |
483 | * The various file operations we support. |
484 | */ |
485 | |
486 | static struct file_operations gen_rtc_fops = { |
487 | .owner = THIS_MODULE, |
488 | #ifdef CONFIG_GEN_RTC_X |
489 | .read = gen_rtc_read, |
490 | .poll = gen_rtc_poll, |
491 | #endif |
492 | .ioctl = gen_rtc_ioctl, |
493 | .open = gen_rtc_open, |
494 | .release = gen_rtc_release, |
495 | }; |
496 | |
497 | static struct miscdevice rtc_gen_dev = |
498 | { |
499 | .minor = RTC_MINOR, |
500 | .name = "rtc", |
501 | .fops = &gen_rtc_fops, |
502 | }; |
503 | |
504 | static int __init rtc_generic_init(void) |
505 | { |
506 | int retval; |
507 | |
508 | printk(KERN_INFO "Generic RTC Driver v%s\n", RTC_VERSION); |
509 | |
510 | retval = misc_register(&rtc_gen_dev); |
511 | if (retval < 0) |
512 | return retval; |
513 | |
514 | retval = gen_rtc_proc_init(); |
515 | if (retval) { |
516 | misc_deregister(&rtc_gen_dev); |
517 | return retval; |
518 | } |
519 | |
520 | return 0; |
521 | } |
522 | |
523 | static void __exit rtc_generic_exit(void) |
524 | { |
525 | remove_proc_entry ("driver/rtc", NULL); |
526 | misc_deregister(&rtc_gen_dev); |
527 | } |
528 | |
529 | |
530 | module_init(rtc_generic_init); |
531 | module_exit(rtc_generic_exit); |
532 | |
533 | MODULE_AUTHOR("Richard Zidlicky"); |
534 | MODULE_LICENSE("GPL"); |
535 | MODULE_ALIAS_MISCDEV(RTC_MINOR); |