2 * RTC subsystem, dev interface
4 * Copyright (C) 2005 Tower Technologies
5 * Author: Alessandro Zummo <a.zummo@towertech.it>
7 * based on arch/arm/common/rtctime.c
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/module.h>
15 #include <linux/rtc.h>
17 static struct class *rtc_dev_class
;
18 static dev_t rtc_devt
;
20 #define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
22 static int rtc_dev_open(struct inode
*inode
, struct file
*file
)
25 struct rtc_device
*rtc
= container_of(inode
->i_cdev
,
26 struct rtc_device
, char_dev
);
27 const struct rtc_class_ops
*ops
= rtc
->ops
;
29 /* We keep the lock as long as the device is in use
30 * and return immediately if busy
32 if (!(mutex_trylock(&rtc
->char_lock
)))
35 file
->private_data
= &rtc
->class_dev
;
37 err
= ops
->open
? ops
->open(rtc
->class_dev
.dev
) : 0;
39 spin_lock_irq(&rtc
->irq_lock
);
41 spin_unlock_irq(&rtc
->irq_lock
);
46 /* something has gone wrong, release the lock */
47 mutex_unlock(&rtc
->char_lock
);
51 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
53 * Routine to poll RTC seconds field for change as often as possible,
54 * after first RTC_UIE use timer to reduce polling
56 static void rtc_uie_task(struct work_struct
*work
)
58 struct rtc_device
*rtc
=
59 container_of(work
, struct rtc_device
, uie_task
);
64 err
= rtc_read_time(&rtc
->class_dev
, &tm
);
65 spin_lock_irq(&rtc
->irq_lock
);
66 if (rtc
->stop_uie_polling
|| err
) {
67 rtc
->uie_task_active
= 0;
68 } else if (rtc
->oldsecs
!= tm
.tm_sec
) {
69 num
= (tm
.tm_sec
+ 60 - rtc
->oldsecs
) % 60;
70 rtc
->oldsecs
= tm
.tm_sec
;
71 rtc
->uie_timer
.expires
= jiffies
+ HZ
- (HZ
/10);
72 rtc
->uie_timer_active
= 1;
73 rtc
->uie_task_active
= 0;
74 add_timer(&rtc
->uie_timer
);
75 } else if (schedule_work(&rtc
->uie_task
) == 0) {
76 rtc
->uie_task_active
= 0;
78 spin_unlock_irq(&rtc
->irq_lock
);
80 rtc_update_irq(&rtc
->class_dev
, num
, RTC_UF
| RTC_IRQF
);
83 static void rtc_uie_timer(unsigned long data
)
85 struct rtc_device
*rtc
= (struct rtc_device
*)data
;
88 spin_lock_irqsave(&rtc
->irq_lock
, flags
);
89 rtc
->uie_timer_active
= 0;
90 rtc
->uie_task_active
= 1;
91 if ((schedule_work(&rtc
->uie_task
) == 0))
92 rtc
->uie_task_active
= 0;
93 spin_unlock_irqrestore(&rtc
->irq_lock
, flags
);
96 static void clear_uie(struct rtc_device
*rtc
)
98 spin_lock_irq(&rtc
->irq_lock
);
99 if (rtc
->irq_active
) {
100 rtc
->stop_uie_polling
= 1;
101 if (rtc
->uie_timer_active
) {
102 spin_unlock_irq(&rtc
->irq_lock
);
103 del_timer_sync(&rtc
->uie_timer
);
104 spin_lock_irq(&rtc
->irq_lock
);
105 rtc
->uie_timer_active
= 0;
107 if (rtc
->uie_task_active
) {
108 spin_unlock_irq(&rtc
->irq_lock
);
109 flush_scheduled_work();
110 spin_lock_irq(&rtc
->irq_lock
);
114 spin_unlock_irq(&rtc
->irq_lock
);
117 static int set_uie(struct rtc_device
*rtc
)
122 err
= rtc_read_time(&rtc
->class_dev
, &tm
);
125 spin_lock_irq(&rtc
->irq_lock
);
126 if (!rtc
->irq_active
) {
128 rtc
->stop_uie_polling
= 0;
129 rtc
->oldsecs
= tm
.tm_sec
;
130 rtc
->uie_task_active
= 1;
131 if (schedule_work(&rtc
->uie_task
) == 0)
132 rtc
->uie_task_active
= 0;
135 spin_unlock_irq(&rtc
->irq_lock
);
138 #endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */
141 rtc_dev_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
143 struct rtc_device
*rtc
= to_rtc_device(file
->private_data
);
145 DECLARE_WAITQUEUE(wait
, current
);
149 if (count
!= sizeof(unsigned int) && count
< sizeof(unsigned long))
152 add_wait_queue(&rtc
->irq_queue
, &wait
);
154 __set_current_state(TASK_INTERRUPTIBLE
);
156 spin_lock_irq(&rtc
->irq_lock
);
157 data
= rtc
->irq_data
;
159 spin_unlock_irq(&rtc
->irq_lock
);
165 if (file
->f_flags
& O_NONBLOCK
) {
169 if (signal_pending(current
)) {
175 set_current_state(TASK_RUNNING
);
176 remove_wait_queue(&rtc
->irq_queue
, &wait
);
179 /* Check for any data updates */
180 if (rtc
->ops
->read_callback
)
181 data
= rtc
->ops
->read_callback(rtc
->class_dev
.dev
,
184 if (sizeof(int) != sizeof(long) &&
185 count
== sizeof(unsigned int))
186 ret
= put_user(data
, (unsigned int __user
*)buf
) ?:
187 sizeof(unsigned int);
189 ret
= put_user(data
, (unsigned long __user
*)buf
) ?:
190 sizeof(unsigned long);
195 static unsigned int rtc_dev_poll(struct file
*file
, poll_table
*wait
)
197 struct rtc_device
*rtc
= to_rtc_device(file
->private_data
);
200 poll_wait(file
, &rtc
->irq_queue
, wait
);
202 data
= rtc
->irq_data
;
204 return (data
!= 0) ? (POLLIN
| POLLRDNORM
) : 0;
207 static int rtc_dev_ioctl(struct inode
*inode
, struct file
*file
,
208 unsigned int cmd
, unsigned long arg
)
211 struct class_device
*class_dev
= file
->private_data
;
212 struct rtc_device
*rtc
= to_rtc_device(class_dev
);
213 const struct rtc_class_ops
*ops
= rtc
->ops
;
215 struct rtc_wkalrm alarm
;
216 void __user
*uarg
= (void __user
*) arg
;
218 /* check that the calles has appropriate permissions
219 * for certain ioctls. doing this check here is useful
220 * to avoid duplicate code in each driver.
225 if (!capable(CAP_SYS_TIME
))
230 if (arg
> rtc
->max_user_freq
&& !capable(CAP_SYS_RESOURCE
))
235 if (!capable(CAP_SYS_RESOURCE
))
240 /* avoid conflicting IRQ users */
241 if (cmd
== RTC_PIE_ON
|| cmd
== RTC_PIE_OFF
|| cmd
== RTC_IRQP_SET
) {
242 spin_lock(&rtc
->irq_task_lock
);
245 spin_unlock(&rtc
->irq_task_lock
);
251 /* try the driver's ioctl interface */
253 err
= ops
->ioctl(class_dev
->dev
, cmd
, arg
);
254 if (err
!= -ENOIOCTLCMD
)
258 /* if the driver does not provide the ioctl interface
259 * or if that particular ioctl was not implemented
260 * (-ENOIOCTLCMD), we will try to emulate here.
265 err
= rtc_read_alarm(class_dev
, &alarm
);
269 if (copy_to_user(uarg
, &alarm
.time
, sizeof(tm
)))
274 if (copy_from_user(&alarm
.time
, uarg
, sizeof(tm
)))
279 alarm
.time
.tm_mday
= -1;
280 alarm
.time
.tm_mon
= -1;
281 alarm
.time
.tm_year
= -1;
282 alarm
.time
.tm_wday
= -1;
283 alarm
.time
.tm_yday
= -1;
284 alarm
.time
.tm_isdst
= -1;
285 err
= rtc_set_alarm(class_dev
, &alarm
);
289 err
= rtc_read_time(class_dev
, &tm
);
293 if (copy_to_user(uarg
, &tm
, sizeof(tm
)))
298 if (copy_from_user(&tm
, uarg
, sizeof(tm
)))
301 err
= rtc_set_time(class_dev
, &tm
);
307 * There were no RTC clocks before 1900.
319 err
= put_user(rtc_epoch
, (unsigned long __user
*)uarg
);
323 if (copy_from_user(&alarm
, uarg
, sizeof(alarm
)))
326 err
= rtc_set_alarm(class_dev
, &alarm
);
330 err
= rtc_read_alarm(class_dev
, &alarm
);
334 if (copy_to_user(uarg
, &alarm
, sizeof(alarm
)))
338 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
354 static int rtc_dev_release(struct inode
*inode
, struct file
*file
)
356 struct rtc_device
*rtc
= to_rtc_device(file
->private_data
);
358 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
361 if (rtc
->ops
->release
)
362 rtc
->ops
->release(rtc
->class_dev
.dev
);
364 mutex_unlock(&rtc
->char_lock
);
368 static int rtc_dev_fasync(int fd
, struct file
*file
, int on
)
370 struct rtc_device
*rtc
= to_rtc_device(file
->private_data
);
371 return fasync_helper(fd
, file
, on
, &rtc
->async_queue
);
374 static struct file_operations rtc_dev_fops
= {
375 .owner
= THIS_MODULE
,
377 .read
= rtc_dev_read
,
378 .poll
= rtc_dev_poll
,
379 .ioctl
= rtc_dev_ioctl
,
380 .open
= rtc_dev_open
,
381 .release
= rtc_dev_release
,
382 .fasync
= rtc_dev_fasync
,
385 /* insertion/removal hooks */
387 static int rtc_dev_add_device(struct class_device
*class_dev
,
388 struct class_interface
*class_intf
)
391 struct rtc_device
*rtc
= to_rtc_device(class_dev
);
393 if (rtc
->id
>= RTC_DEV_MAX
) {
394 dev_err(class_dev
->dev
, "too many RTCs\n");
398 mutex_init(&rtc
->char_lock
);
399 spin_lock_init(&rtc
->irq_lock
);
400 init_waitqueue_head(&rtc
->irq_queue
);
401 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
402 INIT_WORK(&rtc
->uie_task
, rtc_uie_task
);
403 setup_timer(&rtc
->uie_timer
, rtc_uie_timer
, (unsigned long)rtc
);
406 cdev_init(&rtc
->char_dev
, &rtc_dev_fops
);
407 rtc
->char_dev
.owner
= rtc
->owner
;
409 if (cdev_add(&rtc
->char_dev
, MKDEV(MAJOR(rtc_devt
), rtc
->id
), 1)) {
410 dev_err(class_dev
->dev
,
411 "failed to add char device %d:%d\n",
412 MAJOR(rtc_devt
), rtc
->id
);
416 rtc
->rtc_dev
= class_device_create(rtc_dev_class
, NULL
,
417 MKDEV(MAJOR(rtc_devt
), rtc
->id
),
418 class_dev
->dev
, "rtc%d", rtc
->id
);
419 if (IS_ERR(rtc
->rtc_dev
)) {
420 dev_err(class_dev
->dev
, "cannot create rtc_dev device\n");
421 err
= PTR_ERR(rtc
->rtc_dev
);
425 dev_info(class_dev
->dev
, "rtc intf: dev (%d:%d)\n",
426 MAJOR(rtc
->rtc_dev
->devt
),
427 MINOR(rtc
->rtc_dev
->devt
));
433 cdev_del(&rtc
->char_dev
);
437 static void rtc_dev_remove_device(struct class_device
*class_dev
,
438 struct class_interface
*class_intf
)
440 struct rtc_device
*rtc
= to_rtc_device(class_dev
);
443 dev_dbg(class_dev
->dev
, "removing char %d:%d\n",
444 MAJOR(rtc
->rtc_dev
->devt
),
445 MINOR(rtc
->rtc_dev
->devt
));
447 class_device_unregister(rtc
->rtc_dev
);
448 cdev_del(&rtc
->char_dev
);
452 /* interface registration */
454 static struct class_interface rtc_dev_interface
= {
455 .add
= &rtc_dev_add_device
,
456 .remove
= &rtc_dev_remove_device
,
459 static int __init
rtc_dev_init(void)
463 rtc_dev_class
= class_create(THIS_MODULE
, "rtc-dev");
464 if (IS_ERR(rtc_dev_class
))
465 return PTR_ERR(rtc_dev_class
);
467 err
= alloc_chrdev_region(&rtc_devt
, 0, RTC_DEV_MAX
, "rtc");
469 printk(KERN_ERR
"%s: failed to allocate char dev region\n",
471 goto err_destroy_class
;
474 err
= rtc_interface_register(&rtc_dev_interface
);
476 printk(KERN_ERR
"%s: failed to register the interface\n",
478 goto err_unregister_chrdev
;
483 err_unregister_chrdev
:
484 unregister_chrdev_region(rtc_devt
, RTC_DEV_MAX
);
487 class_destroy(rtc_dev_class
);
492 static void __exit
rtc_dev_exit(void)
494 class_interface_unregister(&rtc_dev_interface
);
495 class_destroy(rtc_dev_class
);
496 unregister_chrdev_region(rtc_devt
, RTC_DEV_MAX
);
499 subsys_initcall(rtc_dev_init
);
500 module_exit(rtc_dev_exit
);
502 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
503 MODULE_DESCRIPTION("RTC class dev interface");
504 MODULE_LICENSE("GPL");