rtc: add BSM parameter
[linux-2.6-microblaze.git] / drivers / rtc / dev.c
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 static int rtc_dev_open(struct inode *inode, struct file *file)
24 {
25         struct rtc_device *rtc = container_of(inode->i_cdev,
26                                         struct rtc_device, char_dev);
27
28         if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
29                 return -EBUSY;
30
31         file->private_data = rtc;
32
33         spin_lock_irq(&rtc->irq_lock);
34         rtc->irq_data = 0;
35         spin_unlock_irq(&rtc->irq_lock);
36
37         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 rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
143 {
144         struct rtc_device *rtc = file->private_data;
145
146         DECLARE_WAITQUEUE(wait, current);
147         unsigned long data;
148         ssize_t ret;
149
150         if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
151                 return -EINVAL;
152
153         add_wait_queue(&rtc->irq_queue, &wait);
154         do {
155                 __set_current_state(TASK_INTERRUPTIBLE);
156
157                 spin_lock_irq(&rtc->irq_lock);
158                 data = rtc->irq_data;
159                 rtc->irq_data = 0;
160                 spin_unlock_irq(&rtc->irq_lock);
161
162                 if (data != 0) {
163                         ret = 0;
164                         break;
165                 }
166                 if (file->f_flags & O_NONBLOCK) {
167                         ret = -EAGAIN;
168                         break;
169                 }
170                 if (signal_pending(current)) {
171                         ret = -ERESTARTSYS;
172                         break;
173                 }
174                 schedule();
175         } while (1);
176         set_current_state(TASK_RUNNING);
177         remove_wait_queue(&rtc->irq_queue, &wait);
178
179         if (ret == 0) {
180                 if (sizeof(int) != sizeof(long) &&
181                     count == sizeof(unsigned int))
182                         ret = put_user(data, (unsigned int __user *)buf) ?:
183                                 sizeof(unsigned int);
184                 else
185                         ret = put_user(data, (unsigned long __user *)buf) ?:
186                                 sizeof(unsigned long);
187         }
188         return ret;
189 }
190
191 static __poll_t rtc_dev_poll(struct file *file, poll_table *wait)
192 {
193         struct rtc_device *rtc = file->private_data;
194         unsigned long data;
195
196         poll_wait(file, &rtc->irq_queue, wait);
197
198         data = rtc->irq_data;
199
200         return (data != 0) ? (EPOLLIN | EPOLLRDNORM) : 0;
201 }
202
203 static long rtc_dev_ioctl(struct file *file,
204                           unsigned int cmd, unsigned long arg)
205 {
206         int err = 0;
207         struct rtc_device *rtc = file->private_data;
208         const struct rtc_class_ops *ops = rtc->ops;
209         struct rtc_time tm;
210         struct rtc_wkalrm alarm;
211         struct rtc_param param;
212         void __user *uarg = (void __user *)arg;
213
214         err = mutex_lock_interruptible(&rtc->ops_lock);
215         if (err)
216                 return err;
217
218         /* check that the calling task has appropriate permissions
219          * for certain ioctls. doing this check here is useful
220          * to avoid duplicate code in each driver.
221          */
222         switch (cmd) {
223         case RTC_EPOCH_SET:
224         case RTC_SET_TIME:
225         case RTC_PARAM_SET:
226                 if (!capable(CAP_SYS_TIME))
227                         err = -EACCES;
228                 break;
229
230         case RTC_IRQP_SET:
231                 if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
232                         err = -EACCES;
233                 break;
234
235         case RTC_PIE_ON:
236                 if (rtc->irq_freq > rtc->max_user_freq &&
237                     !capable(CAP_SYS_RESOURCE))
238                         err = -EACCES;
239                 break;
240         }
241
242         if (err)
243                 goto done;
244
245         /*
246          * Drivers *SHOULD NOT* provide ioctl implementations
247          * for these requests.  Instead, provide methods to
248          * support the following code, so that the RTC's main
249          * features are accessible without using ioctls.
250          *
251          * RTC and alarm times will be in UTC, by preference,
252          * but dual-booting with MS-Windows implies RTCs must
253          * use the local wall clock time.
254          */
255
256         switch (cmd) {
257         case RTC_ALM_READ:
258                 mutex_unlock(&rtc->ops_lock);
259
260                 err = rtc_read_alarm(rtc, &alarm);
261                 if (err < 0)
262                         return err;
263
264                 if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
265                         err = -EFAULT;
266                 return err;
267
268         case RTC_ALM_SET:
269                 mutex_unlock(&rtc->ops_lock);
270
271                 if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
272                         return -EFAULT;
273
274                 alarm.enabled = 0;
275                 alarm.pending = 0;
276                 alarm.time.tm_wday = -1;
277                 alarm.time.tm_yday = -1;
278                 alarm.time.tm_isdst = -1;
279
280                 /* RTC_ALM_SET alarms may be up to 24 hours in the future.
281                  * Rather than expecting every RTC to implement "don't care"
282                  * for day/month/year fields, just force the alarm to have
283                  * the right values for those fields.
284                  *
285                  * RTC_WKALM_SET should be used instead.  Not only does it
286                  * eliminate the need for a separate RTC_AIE_ON call, it
287                  * doesn't have the "alarm 23:59:59 in the future" race.
288                  *
289                  * NOTE:  some legacy code may have used invalid fields as
290                  * wildcards, exposing hardware "periodic alarm" capabilities.
291                  * Not supported here.
292                  */
293                 {
294                         time64_t now, then;
295
296                         err = rtc_read_time(rtc, &tm);
297                         if (err < 0)
298                                 return err;
299                         now = rtc_tm_to_time64(&tm);
300
301                         alarm.time.tm_mday = tm.tm_mday;
302                         alarm.time.tm_mon = tm.tm_mon;
303                         alarm.time.tm_year = tm.tm_year;
304                         err  = rtc_valid_tm(&alarm.time);
305                         if (err < 0)
306                                 return err;
307                         then = rtc_tm_to_time64(&alarm.time);
308
309                         /* alarm may need to wrap into tomorrow */
310                         if (then < now) {
311                                 rtc_time64_to_tm(now + 24 * 60 * 60, &tm);
312                                 alarm.time.tm_mday = tm.tm_mday;
313                                 alarm.time.tm_mon = tm.tm_mon;
314                                 alarm.time.tm_year = tm.tm_year;
315                         }
316                 }
317
318                 return rtc_set_alarm(rtc, &alarm);
319
320         case RTC_RD_TIME:
321                 mutex_unlock(&rtc->ops_lock);
322
323                 err = rtc_read_time(rtc, &tm);
324                 if (err < 0)
325                         return err;
326
327                 if (copy_to_user(uarg, &tm, sizeof(tm)))
328                         err = -EFAULT;
329                 return err;
330
331         case RTC_SET_TIME:
332                 mutex_unlock(&rtc->ops_lock);
333
334                 if (copy_from_user(&tm, uarg, sizeof(tm)))
335                         return -EFAULT;
336
337                 return rtc_set_time(rtc, &tm);
338
339         case RTC_PIE_ON:
340                 err = rtc_irq_set_state(rtc, 1);
341                 break;
342
343         case RTC_PIE_OFF:
344                 err = rtc_irq_set_state(rtc, 0);
345                 break;
346
347         case RTC_AIE_ON:
348                 mutex_unlock(&rtc->ops_lock);
349                 return rtc_alarm_irq_enable(rtc, 1);
350
351         case RTC_AIE_OFF:
352                 mutex_unlock(&rtc->ops_lock);
353                 return rtc_alarm_irq_enable(rtc, 0);
354
355         case RTC_UIE_ON:
356                 mutex_unlock(&rtc->ops_lock);
357                 return rtc_update_irq_enable(rtc, 1);
358
359         case RTC_UIE_OFF:
360                 mutex_unlock(&rtc->ops_lock);
361                 return rtc_update_irq_enable(rtc, 0);
362
363         case RTC_IRQP_SET:
364                 err = rtc_irq_set_freq(rtc, arg);
365                 break;
366         case RTC_IRQP_READ:
367                 err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
368                 break;
369
370         case RTC_WKALM_SET:
371                 mutex_unlock(&rtc->ops_lock);
372                 if (copy_from_user(&alarm, uarg, sizeof(alarm)))
373                         return -EFAULT;
374
375                 return rtc_set_alarm(rtc, &alarm);
376
377         case RTC_WKALM_RD:
378                 mutex_unlock(&rtc->ops_lock);
379                 err = rtc_read_alarm(rtc, &alarm);
380                 if (err < 0)
381                         return err;
382
383                 if (copy_to_user(uarg, &alarm, sizeof(alarm)))
384                         err = -EFAULT;
385                 return err;
386
387         case RTC_PARAM_GET:
388                 if (copy_from_user(&param, uarg, sizeof(param))) {
389                         mutex_unlock(&rtc->ops_lock);
390                         return -EFAULT;
391                 }
392
393                 switch(param.param) {
394                         long offset;
395                 case RTC_PARAM_FEATURES:
396                         if (param.index != 0)
397                                 err = -EINVAL;
398                         param.uvalue = rtc->features[0];
399                         break;
400
401                 case RTC_PARAM_CORRECTION:
402                         mutex_unlock(&rtc->ops_lock);
403                         if (param.index != 0)
404                                 return -EINVAL;
405                         err = rtc_read_offset(rtc, &offset);
406                         mutex_lock(&rtc->ops_lock);
407                         if (err == 0)
408                                 param.svalue = offset;
409                         break;
410
411                 default:
412                         if (rtc->ops->param_get)
413                                 err = rtc->ops->param_get(rtc->dev.parent, &param);
414                         else
415                                 err = -EINVAL;
416                 }
417
418                 if (!err)
419                         if (copy_to_user(uarg, &param, sizeof(param)))
420                                 err = -EFAULT;
421
422                 break;
423
424         case RTC_PARAM_SET:
425                 if (copy_from_user(&param, uarg, sizeof(param))) {
426                         mutex_unlock(&rtc->ops_lock);
427                         return -EFAULT;
428                 }
429
430                 switch(param.param) {
431                 case RTC_PARAM_FEATURES:
432                         err = -EINVAL;
433                         break;
434
435                 case RTC_PARAM_CORRECTION:
436                         mutex_unlock(&rtc->ops_lock);
437                         if (param.index != 0)
438                                 return -EINVAL;
439                         return rtc_set_offset(rtc, param.svalue);
440
441                 default:
442                         if (rtc->ops->param_set)
443                                 err = rtc->ops->param_set(rtc->dev.parent, &param);
444                         else
445                                 err = -EINVAL;
446                 }
447
448                 break;
449
450         default:
451                 /* Finally try the driver's ioctl interface */
452                 if (ops->ioctl) {
453                         err = ops->ioctl(rtc->dev.parent, cmd, arg);
454                         if (err == -ENOIOCTLCMD)
455                                 err = -ENOTTY;
456                 } else {
457                         err = -ENOTTY;
458                 }
459                 break;
460         }
461
462 done:
463         mutex_unlock(&rtc->ops_lock);
464         return err;
465 }
466
467 #ifdef CONFIG_COMPAT
468 #define RTC_IRQP_SET32          _IOW('p', 0x0c, __u32)
469 #define RTC_IRQP_READ32         _IOR('p', 0x0b, __u32)
470 #define RTC_EPOCH_SET32         _IOW('p', 0x0e, __u32)
471
472 static long rtc_dev_compat_ioctl(struct file *file,
473                                  unsigned int cmd, unsigned long arg)
474 {
475         struct rtc_device *rtc = file->private_data;
476         void __user *uarg = compat_ptr(arg);
477
478         switch (cmd) {
479         case RTC_IRQP_READ32:
480                 return put_user(rtc->irq_freq, (__u32 __user *)uarg);
481
482         case RTC_IRQP_SET32:
483                 /* arg is a plain integer, not pointer */
484                 return rtc_dev_ioctl(file, RTC_IRQP_SET, arg);
485
486         case RTC_EPOCH_SET32:
487                 /* arg is a plain integer, not pointer */
488                 return rtc_dev_ioctl(file, RTC_EPOCH_SET, arg);
489         }
490
491         return rtc_dev_ioctl(file, cmd, (unsigned long)uarg);
492 }
493 #endif
494
495 static int rtc_dev_fasync(int fd, struct file *file, int on)
496 {
497         struct rtc_device *rtc = file->private_data;
498
499         return fasync_helper(fd, file, on, &rtc->async_queue);
500 }
501
502 static int rtc_dev_release(struct inode *inode, struct file *file)
503 {
504         struct rtc_device *rtc = file->private_data;
505
506         /* We shut down the repeating IRQs that userspace enabled,
507          * since nothing is listening to them.
508          *  - Update (UIE) ... currently only managed through ioctls
509          *  - Periodic (PIE) ... also used through rtc_*() interface calls
510          *
511          * Leave the alarm alone; it may be set to trigger a system wakeup
512          * later, or be used by kernel code, and is a one-shot event anyway.
513          */
514
515         /* Keep ioctl until all drivers are converted */
516         rtc_dev_ioctl(file, RTC_UIE_OFF, 0);
517         rtc_update_irq_enable(rtc, 0);
518         rtc_irq_set_state(rtc, 0);
519
520         clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
521         return 0;
522 }
523
524 static const struct file_operations rtc_dev_fops = {
525         .owner          = THIS_MODULE,
526         .llseek         = no_llseek,
527         .read           = rtc_dev_read,
528         .poll           = rtc_dev_poll,
529         .unlocked_ioctl = rtc_dev_ioctl,
530 #ifdef CONFIG_COMPAT
531         .compat_ioctl   = rtc_dev_compat_ioctl,
532 #endif
533         .open           = rtc_dev_open,
534         .release        = rtc_dev_release,
535         .fasync         = rtc_dev_fasync,
536 };
537
538 /* insertion/removal hooks */
539
540 void rtc_dev_prepare(struct rtc_device *rtc)
541 {
542         if (!rtc_devt)
543                 return;
544
545         if (rtc->id >= RTC_DEV_MAX) {
546                 dev_dbg(&rtc->dev, "too many RTC devices\n");
547                 return;
548         }
549
550         rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
551
552 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
553         INIT_WORK(&rtc->uie_task, rtc_uie_task);
554         timer_setup(&rtc->uie_timer, rtc_uie_timer, 0);
555 #endif
556
557         cdev_init(&rtc->char_dev, &rtc_dev_fops);
558         rtc->char_dev.owner = rtc->owner;
559 }
560
561 void __init rtc_dev_init(void)
562 {
563         int err;
564
565         err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
566         if (err < 0)
567                 pr_err("failed to allocate char dev region\n");
568 }
569
570 void __exit rtc_dev_exit(void)
571 {
572         if (rtc_devt)
573                 unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
574 }