568 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * RTC subsystem, dev interface4 *5 * Copyright (C) 2005 Tower Technologies6 * Author: Alessandro Zummo <a.zummo@towertech.it>7 *8 * based on arch/arm/common/rtctime.c9 */10 11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt12 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 19static dev_t rtc_devt;20 21#define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */22 23static 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_EMUL41/*42 * Routine to poll RTC seconds field for change as often as possible,43 * after first RTC_UIE use timer to reduce polling44 */45static 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 73static 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 86static 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_work(&rtc->uie_task);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 108static 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 130int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled)131{132 if (enabled)133 return set_uie(rtc);134 else135 return clear_uie(rtc);136}137EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul);138 139#endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */140 141static ssize_t142rtc_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 else185 ret = put_user(data, (unsigned long __user *)buf) ?:186 sizeof(unsigned long);187 }188 return ret;189}190 191static __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 203static 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 permissions219 * for certain ioctls. doing this check here is useful220 * 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 implementations247 * for these requests. Instead, provide methods to248 * support the following code, so that the RTC's main249 * 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 must253 * 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 have283 * the right values for those fields.284 *285 * RTC_WKALM_SET should be used instead. Not only does it286 * eliminate the need for a separate RTC_AIE_ON call, it287 * doesn't have the "alarm 23:59:59 in the future" race.288 *289 * NOTE: some legacy code may have used invalid fields as290 * 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(¶m, uarg, sizeof(param))) {389 mutex_unlock(&rtc->ops_lock);390 return -EFAULT;391 }392 393 switch(param.param) {394 case RTC_PARAM_FEATURES:395 if (param.index != 0)396 err = -EINVAL;397 param.uvalue = rtc->features[0];398 break;399 400 case RTC_PARAM_CORRECTION: {401 long offset;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, ¶m);414 else415 err = -EINVAL;416 }417 418 if (!err)419 if (copy_to_user(uarg, ¶m, sizeof(param)))420 err = -EFAULT;421 422 break;423 424 case RTC_PARAM_SET:425 if (copy_from_user(¶m, 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, ¶m);444 else445 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 462done:463 mutex_unlock(&rtc->ops_lock);464 return err;465}466 467#ifdef CONFIG_COMPAT468#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 472static 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#endif494 495static 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 502static 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 ioctls509 * - Periodic (PIE) ... also used through rtc_*() interface calls510 *511 * Leave the alarm alone; it may be set to trigger a system wakeup512 * 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 524static const struct file_operations rtc_dev_fops = {525 .owner = THIS_MODULE,526 .read = rtc_dev_read,527 .poll = rtc_dev_poll,528 .unlocked_ioctl = rtc_dev_ioctl,529#ifdef CONFIG_COMPAT530 .compat_ioctl = rtc_dev_compat_ioctl,531#endif532 .open = rtc_dev_open,533 .release = rtc_dev_release,534 .fasync = rtc_dev_fasync,535};536 537/* insertion/removal hooks */538 539void rtc_dev_prepare(struct rtc_device *rtc)540{541 if (!rtc_devt)542 return;543 544 if (rtc->id >= RTC_DEV_MAX) {545 dev_dbg(&rtc->dev, "too many RTC devices\n");546 return;547 }548 549 rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);550 551#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL552 INIT_WORK(&rtc->uie_task, rtc_uie_task);553 timer_setup(&rtc->uie_timer, rtc_uie_timer, 0);554#endif555 556 cdev_init(&rtc->char_dev, &rtc_dev_fops);557 rtc->char_dev.owner = rtc->owner;558}559 560void __init rtc_dev_init(void)561{562 int err;563 564 err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");565 if (err < 0)566 pr_err("failed to allocate char dev region\n");567}568