Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * RTC subsystem, dev interface
4 : : *
5 : : * Copyright (C) 2005 Tower Technologies
6 : : * Author: Alessandro Zummo <a.zummo@towertech.it>
7 : : *
8 : : * based on arch/arm/common/rtctime.c
9 : : */
10 : :
11 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 : :
13 : : #include <linux/compat.h>
14 : : #include <linux/module.h>
15 : : #include <linux/rtc.h>
16 : : #include <linux/sched/signal.h>
17 : : #include "rtc-core.h"
18 : :
19 : : static dev_t rtc_devt;
20 : :
21 : : #define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
22 : :
23 : 0 : static int rtc_dev_open(struct inode *inode, struct file *file)
24 : : {
25 : 0 : struct rtc_device *rtc = container_of(inode->i_cdev,
26 : : struct rtc_device, char_dev);
27 : :
28 [ # # ]: 0 : if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
29 : : return -EBUSY;
30 : :
31 : 0 : file->private_data = rtc;
32 : :
33 : 0 : spin_lock_irq(&rtc->irq_lock);
34 : 0 : rtc->irq_data = 0;
35 : 0 : spin_unlock_irq(&rtc->irq_lock);
36 : :
37 : 0 : return 0;
38 : : }
39 : :
40 : : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
41 : : /*
42 : : * Routine to poll RTC seconds field for change as often as possible,
43 : : * after first RTC_UIE use timer to reduce polling
44 : : */
45 : : static void rtc_uie_task(struct work_struct *work)
46 : : {
47 : : struct rtc_device *rtc =
48 : : container_of(work, struct rtc_device, uie_task);
49 : : struct rtc_time tm;
50 : : int num = 0;
51 : : int err;
52 : :
53 : : err = rtc_read_time(rtc, &tm);
54 : :
55 : : spin_lock_irq(&rtc->irq_lock);
56 : : if (rtc->stop_uie_polling || err) {
57 : : rtc->uie_task_active = 0;
58 : : } else if (rtc->oldsecs != tm.tm_sec) {
59 : : num = (tm.tm_sec + 60 - rtc->oldsecs) % 60;
60 : : rtc->oldsecs = tm.tm_sec;
61 : : rtc->uie_timer.expires = jiffies + HZ - (HZ / 10);
62 : : rtc->uie_timer_active = 1;
63 : : rtc->uie_task_active = 0;
64 : : add_timer(&rtc->uie_timer);
65 : : } else if (schedule_work(&rtc->uie_task) == 0) {
66 : : rtc->uie_task_active = 0;
67 : : }
68 : : spin_unlock_irq(&rtc->irq_lock);
69 : : if (num)
70 : : rtc_handle_legacy_irq(rtc, num, RTC_UF);
71 : : }
72 : :
73 : : static void rtc_uie_timer(struct timer_list *t)
74 : : {
75 : : struct rtc_device *rtc = from_timer(rtc, t, uie_timer);
76 : : unsigned long flags;
77 : :
78 : : spin_lock_irqsave(&rtc->irq_lock, flags);
79 : : rtc->uie_timer_active = 0;
80 : : rtc->uie_task_active = 1;
81 : : if ((schedule_work(&rtc->uie_task) == 0))
82 : : rtc->uie_task_active = 0;
83 : : spin_unlock_irqrestore(&rtc->irq_lock, flags);
84 : : }
85 : :
86 : : static int clear_uie(struct rtc_device *rtc)
87 : : {
88 : : spin_lock_irq(&rtc->irq_lock);
89 : : if (rtc->uie_irq_active) {
90 : : rtc->stop_uie_polling = 1;
91 : : if (rtc->uie_timer_active) {
92 : : spin_unlock_irq(&rtc->irq_lock);
93 : : del_timer_sync(&rtc->uie_timer);
94 : : spin_lock_irq(&rtc->irq_lock);
95 : : rtc->uie_timer_active = 0;
96 : : }
97 : : if (rtc->uie_task_active) {
98 : : spin_unlock_irq(&rtc->irq_lock);
99 : : flush_scheduled_work();
100 : : spin_lock_irq(&rtc->irq_lock);
101 : : }
102 : : rtc->uie_irq_active = 0;
103 : : }
104 : : spin_unlock_irq(&rtc->irq_lock);
105 : : return 0;
106 : : }
107 : :
108 : : static int set_uie(struct rtc_device *rtc)
109 : : {
110 : : struct rtc_time tm;
111 : : int err;
112 : :
113 : : err = rtc_read_time(rtc, &tm);
114 : : if (err)
115 : : return err;
116 : : spin_lock_irq(&rtc->irq_lock);
117 : : if (!rtc->uie_irq_active) {
118 : : rtc->uie_irq_active = 1;
119 : : rtc->stop_uie_polling = 0;
120 : : rtc->oldsecs = tm.tm_sec;
121 : : rtc->uie_task_active = 1;
122 : : if (schedule_work(&rtc->uie_task) == 0)
123 : : rtc->uie_task_active = 0;
124 : : }
125 : : rtc->irq_data = 0;
126 : : spin_unlock_irq(&rtc->irq_lock);
127 : : return 0;
128 : : }
129 : :
130 : : int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled)
131 : : {
132 : : if (enabled)
133 : : return set_uie(rtc);
134 : : else
135 : : return clear_uie(rtc);
136 : : }
137 : : EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul);
138 : :
139 : : #endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */
140 : :
141 : : static ssize_t
142 : 0 : rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
143 : : {
144 : 0 : struct rtc_device *rtc = file->private_data;
145 : :
146 [ # # ]: 0 : DECLARE_WAITQUEUE(wait, current);
147 : 0 : unsigned long data;
148 : 0 : ssize_t ret;
149 : :
150 [ # # ]: 0 : if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
151 : : return -EINVAL;
152 : :
153 : 0 : add_wait_queue(&rtc->irq_queue, &wait);
154 : 0 : do {
155 : 0 : __set_current_state(TASK_INTERRUPTIBLE);
156 : :
157 : 0 : spin_lock_irq(&rtc->irq_lock);
158 : 0 : data = rtc->irq_data;
159 : 0 : rtc->irq_data = 0;
160 : 0 : spin_unlock_irq(&rtc->irq_lock);
161 : :
162 [ # # ]: 0 : if (data != 0) {
163 : : ret = 0;
164 : : break;
165 : : }
166 [ # # ]: 0 : if (file->f_flags & O_NONBLOCK) {
167 : : ret = -EAGAIN;
168 : : break;
169 : : }
170 [ # # ]: 0 : if (signal_pending(current)) {
171 : : ret = -ERESTARTSYS;
172 : : break;
173 : : }
174 : 0 : schedule();
175 : 0 : } while (1);
176 : 0 : set_current_state(TASK_RUNNING);
177 : 0 : remove_wait_queue(&rtc->irq_queue, &wait);
178 : :
179 [ # # ]: 0 : if (ret == 0) {
180 [ # # ]: 0 : if (sizeof(int) != sizeof(long) &&
181 : : count == sizeof(unsigned int))
182 [ # # ]: 0 : ret = put_user(data, (unsigned int __user *)buf) ?:
183 : : sizeof(unsigned int);
184 : : else
185 [ # # ]: 0 : ret = put_user(data, (unsigned long __user *)buf) ?:
186 : : sizeof(unsigned long);
187 : : }
188 : : return ret;
189 : : }
190 : :
191 : 0 : static __poll_t rtc_dev_poll(struct file *file, poll_table *wait)
192 : : {
193 : 0 : struct rtc_device *rtc = file->private_data;
194 : 0 : unsigned long data;
195 : :
196 [ # # ]: 0 : poll_wait(file, &rtc->irq_queue, wait);
197 : :
198 : 0 : data = rtc->irq_data;
199 : :
200 [ # # ]: 0 : return (data != 0) ? (EPOLLIN | EPOLLRDNORM) : 0;
201 : : }
202 : :
203 : 0 : static long rtc_dev_ioctl(struct file *file,
204 : : unsigned int cmd, unsigned long arg)
205 : : {
206 : 0 : int err = 0;
207 : 0 : struct rtc_device *rtc = file->private_data;
208 : 0 : const struct rtc_class_ops *ops = rtc->ops;
209 : 0 : struct rtc_time tm;
210 : 0 : struct rtc_wkalrm alarm;
211 : 0 : void __user *uarg = (void __user *)arg;
212 : :
213 : 0 : err = mutex_lock_interruptible(&rtc->ops_lock);
214 [ # # ]: 0 : if (err)
215 : 0 : return err;
216 : :
217 : : /* check that the calling task has appropriate permissions
218 : : * for certain ioctls. doing this check here is useful
219 : : * to avoid duplicate code in each driver.
220 : : */
221 [ # # # # ]: 0 : switch (cmd) {
222 : 0 : case RTC_EPOCH_SET:
223 : : case RTC_SET_TIME:
224 [ # # ]: 0 : if (!capable(CAP_SYS_TIME))
225 : : err = -EACCES;
226 : : break;
227 : :
228 : 0 : case RTC_IRQP_SET:
229 [ # # # # ]: 0 : if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
230 : : err = -EACCES;
231 : : break;
232 : :
233 : 0 : case RTC_PIE_ON:
234 [ # # # # ]: 0 : if (rtc->irq_freq > rtc->max_user_freq &&
235 : 0 : !capable(CAP_SYS_RESOURCE))
236 : : err = -EACCES;
237 : : break;
238 : : }
239 : :
240 : 0 : if (err)
241 : 0 : goto done;
242 : :
243 : : /*
244 : : * Drivers *SHOULD NOT* provide ioctl implementations
245 : : * for these requests. Instead, provide methods to
246 : : * support the following code, so that the RTC's main
247 : : * features are accessible without using ioctls.
248 : : *
249 : : * RTC and alarm times will be in UTC, by preference,
250 : : * but dual-booting with MS-Windows implies RTCs must
251 : : * use the local wall clock time.
252 : : */
253 : :
254 [ # # # # : 0 : switch (cmd) {
# # # # #
# # # # #
# ]
255 : 0 : case RTC_ALM_READ:
256 : 0 : mutex_unlock(&rtc->ops_lock);
257 : :
258 : 0 : err = rtc_read_alarm(rtc, &alarm);
259 [ # # ]: 0 : if (err < 0)
260 : 0 : return err;
261 : :
262 [ # # ]: 0 : if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
263 : 0 : err = -EFAULT;
264 : 0 : return err;
265 : :
266 : 0 : case RTC_ALM_SET:
267 : 0 : mutex_unlock(&rtc->ops_lock);
268 : :
269 [ # # ]: 0 : if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
270 : : return -EFAULT;
271 : :
272 : 0 : alarm.enabled = 0;
273 : 0 : alarm.pending = 0;
274 : 0 : alarm.time.tm_wday = -1;
275 : 0 : alarm.time.tm_yday = -1;
276 : 0 : alarm.time.tm_isdst = -1;
277 : :
278 : : /* RTC_ALM_SET alarms may be up to 24 hours in the future.
279 : : * Rather than expecting every RTC to implement "don't care"
280 : : * for day/month/year fields, just force the alarm to have
281 : : * the right values for those fields.
282 : : *
283 : : * RTC_WKALM_SET should be used instead. Not only does it
284 : : * eliminate the need for a separate RTC_AIE_ON call, it
285 : : * doesn't have the "alarm 23:59:59 in the future" race.
286 : : *
287 : : * NOTE: some legacy code may have used invalid fields as
288 : : * wildcards, exposing hardware "periodic alarm" capabilities.
289 : : * Not supported here.
290 : : */
291 : : {
292 : 0 : time64_t now, then;
293 : :
294 : 0 : err = rtc_read_time(rtc, &tm);
295 [ # # ]: 0 : if (err < 0)
296 : 0 : return err;
297 : 0 : now = rtc_tm_to_time64(&tm);
298 : :
299 : 0 : alarm.time.tm_mday = tm.tm_mday;
300 : 0 : alarm.time.tm_mon = tm.tm_mon;
301 : 0 : alarm.time.tm_year = tm.tm_year;
302 : 0 : err = rtc_valid_tm(&alarm.time);
303 [ # # ]: 0 : if (err < 0)
304 : 0 : return err;
305 : 0 : then = rtc_tm_to_time64(&alarm.time);
306 : :
307 : : /* alarm may need to wrap into tomorrow */
308 [ # # ]: 0 : if (then < now) {
309 : 0 : rtc_time64_to_tm(now + 24 * 60 * 60, &tm);
310 : 0 : alarm.time.tm_mday = tm.tm_mday;
311 : 0 : alarm.time.tm_mon = tm.tm_mon;
312 : 0 : alarm.time.tm_year = tm.tm_year;
313 : : }
314 : : }
315 : :
316 : 0 : return rtc_set_alarm(rtc, &alarm);
317 : :
318 : 0 : case RTC_RD_TIME:
319 : 0 : mutex_unlock(&rtc->ops_lock);
320 : :
321 : 0 : err = rtc_read_time(rtc, &tm);
322 [ # # ]: 0 : if (err < 0)
323 : 0 : return err;
324 : :
325 [ # # ]: 0 : if (copy_to_user(uarg, &tm, sizeof(tm)))
326 : 0 : err = -EFAULT;
327 : 0 : return err;
328 : :
329 : 0 : case RTC_SET_TIME:
330 : 0 : mutex_unlock(&rtc->ops_lock);
331 : :
332 [ # # ]: 0 : if (copy_from_user(&tm, uarg, sizeof(tm)))
333 : : return -EFAULT;
334 : :
335 : 0 : return rtc_set_time(rtc, &tm);
336 : :
337 : 0 : case RTC_PIE_ON:
338 : 0 : err = rtc_irq_set_state(rtc, 1);
339 : 0 : break;
340 : :
341 : 0 : case RTC_PIE_OFF:
342 : 0 : err = rtc_irq_set_state(rtc, 0);
343 : 0 : break;
344 : :
345 : 0 : case RTC_AIE_ON:
346 : 0 : mutex_unlock(&rtc->ops_lock);
347 : 0 : return rtc_alarm_irq_enable(rtc, 1);
348 : :
349 : 0 : case RTC_AIE_OFF:
350 : 0 : mutex_unlock(&rtc->ops_lock);
351 : 0 : return rtc_alarm_irq_enable(rtc, 0);
352 : :
353 : 0 : case RTC_UIE_ON:
354 : 0 : mutex_unlock(&rtc->ops_lock);
355 : 0 : return rtc_update_irq_enable(rtc, 1);
356 : :
357 : 0 : case RTC_UIE_OFF:
358 : 0 : mutex_unlock(&rtc->ops_lock);
359 : 0 : return rtc_update_irq_enable(rtc, 0);
360 : :
361 : 0 : case RTC_IRQP_SET:
362 : 0 : err = rtc_irq_set_freq(rtc, arg);
363 : 0 : break;
364 : : case RTC_IRQP_READ:
365 : 0 : err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
366 : 0 : break;
367 : :
368 : 0 : case RTC_WKALM_SET:
369 : 0 : mutex_unlock(&rtc->ops_lock);
370 [ # # ]: 0 : if (copy_from_user(&alarm, uarg, sizeof(alarm)))
371 : : return -EFAULT;
372 : :
373 : 0 : return rtc_set_alarm(rtc, &alarm);
374 : :
375 : 0 : case RTC_WKALM_RD:
376 : 0 : mutex_unlock(&rtc->ops_lock);
377 : 0 : err = rtc_read_alarm(rtc, &alarm);
378 [ # # ]: 0 : if (err < 0)
379 : 0 : return err;
380 : :
381 [ # # ]: 0 : if (copy_to_user(uarg, &alarm, sizeof(alarm)))
382 : 0 : err = -EFAULT;
383 : 0 : return err;
384 : :
385 : 0 : default:
386 : : /* Finally try the driver's ioctl interface */
387 [ # # ]: 0 : if (ops->ioctl) {
388 : 0 : err = ops->ioctl(rtc->dev.parent, cmd, arg);
389 [ # # ]: 0 : if (err == -ENOIOCTLCMD)
390 : 0 : err = -ENOTTY;
391 : : } else {
392 : : err = -ENOTTY;
393 : : }
394 : : break;
395 : : }
396 : :
397 : 0 : done:
398 : 0 : mutex_unlock(&rtc->ops_lock);
399 : 0 : return err;
400 : : }
401 : :
402 : : #ifdef CONFIG_COMPAT
403 : : #define RTC_IRQP_SET32 _IOW('p', 0x0c, __u32)
404 : : #define RTC_IRQP_READ32 _IOR('p', 0x0b, __u32)
405 : : #define RTC_EPOCH_SET32 _IOW('p', 0x0e, __u32)
406 : :
407 : 0 : static long rtc_dev_compat_ioctl(struct file *file,
408 : : unsigned int cmd, unsigned long arg)
409 : : {
410 : 0 : struct rtc_device *rtc = file->private_data;
411 [ # # # # ]: 0 : void __user *uarg = compat_ptr(arg);
412 : :
413 [ # # # # ]: 0 : switch (cmd) {
414 : : case RTC_IRQP_READ32:
415 : 0 : return put_user(rtc->irq_freq, (__u32 __user *)uarg);
416 : :
417 : 0 : case RTC_IRQP_SET32:
418 : : /* arg is a plain integer, not pointer */
419 : 0 : return rtc_dev_ioctl(file, RTC_IRQP_SET, arg);
420 : :
421 : 0 : case RTC_EPOCH_SET32:
422 : : /* arg is a plain integer, not pointer */
423 : 0 : return rtc_dev_ioctl(file, RTC_EPOCH_SET, arg);
424 : : }
425 : :
426 : 0 : return rtc_dev_ioctl(file, cmd, (unsigned long)uarg);
427 : : }
428 : : #endif
429 : :
430 : 0 : static int rtc_dev_fasync(int fd, struct file *file, int on)
431 : : {
432 : 0 : struct rtc_device *rtc = file->private_data;
433 : :
434 : 0 : return fasync_helper(fd, file, on, &rtc->async_queue);
435 : : }
436 : :
437 : 0 : static int rtc_dev_release(struct inode *inode, struct file *file)
438 : : {
439 : 0 : struct rtc_device *rtc = file->private_data;
440 : :
441 : : /* We shut down the repeating IRQs that userspace enabled,
442 : : * since nothing is listening to them.
443 : : * - Update (UIE) ... currently only managed through ioctls
444 : : * - Periodic (PIE) ... also used through rtc_*() interface calls
445 : : *
446 : : * Leave the alarm alone; it may be set to trigger a system wakeup
447 : : * later, or be used by kernel code, and is a one-shot event anyway.
448 : : */
449 : :
450 : : /* Keep ioctl until all drivers are converted */
451 : 0 : rtc_dev_ioctl(file, RTC_UIE_OFF, 0);
452 : 0 : rtc_update_irq_enable(rtc, 0);
453 : 0 : rtc_irq_set_state(rtc, 0);
454 : :
455 : 0 : clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
456 : 0 : return 0;
457 : : }
458 : :
459 : : static const struct file_operations rtc_dev_fops = {
460 : : .owner = THIS_MODULE,
461 : : .llseek = no_llseek,
462 : : .read = rtc_dev_read,
463 : : .poll = rtc_dev_poll,
464 : : .unlocked_ioctl = rtc_dev_ioctl,
465 : : #ifdef CONFIG_COMPAT
466 : : .compat_ioctl = rtc_dev_compat_ioctl,
467 : : #endif
468 : : .open = rtc_dev_open,
469 : : .release = rtc_dev_release,
470 : : .fasync = rtc_dev_fasync,
471 : : };
472 : :
473 : : /* insertion/removal hooks */
474 : :
475 : 13 : void rtc_dev_prepare(struct rtc_device *rtc)
476 : : {
477 [ + - ]: 13 : if (!rtc_devt)
478 : : return;
479 : :
480 [ + - ]: 13 : if (rtc->id >= RTC_DEV_MAX) {
481 : : dev_dbg(&rtc->dev, "too many RTC devices\n");
482 : : return;
483 : : }
484 : :
485 : 13 : rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
486 : :
487 : : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
488 : : INIT_WORK(&rtc->uie_task, rtc_uie_task);
489 : : timer_setup(&rtc->uie_timer, rtc_uie_timer, 0);
490 : : #endif
491 : :
492 : 13 : cdev_init(&rtc->char_dev, &rtc_dev_fops);
493 : 13 : rtc->char_dev.owner = rtc->owner;
494 : : }
495 : :
496 : 13 : void __init rtc_dev_init(void)
497 : : {
498 : 13 : int err;
499 : :
500 : 13 : err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
501 [ - + ]: 13 : if (err < 0)
502 : 0 : pr_err("failed to allocate char dev region\n");
503 : 13 : }
504 : :
505 : 0 : void __exit rtc_dev_exit(void)
506 : : {
507 [ # # ]: 0 : if (rtc_devt)
508 : 0 : unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
509 : 0 : }
|
