1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * RTC subsystem, dev interface 4 * 5 * Copyright (C) 2005 Tower Technologies 6 * Author: Alessandro Zummo <[email protected]> 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(¶m, 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 default: 402 err = -EINVAL; 403 } 404 405 if (!err) 406 if (copy_to_user(uarg, ¶m, sizeof(param))) 407 err = -EFAULT; 408 409 break; 410 411 case RTC_PARAM_SET: 412 if (copy_from_user(¶m, uarg, sizeof(param))) { 413 mutex_unlock(&rtc->ops_lock); 414 return -EFAULT; 415 } 416 417 switch(param.param) { 418 case RTC_PARAM_FEATURES: 419 default: 420 err = -EINVAL; 421 } 422 423 break; 424 425 default: 426 /* Finally try the driver's ioctl interface */ 427 if (ops->ioctl) { 428 err = ops->ioctl(rtc->dev.parent, cmd, arg); 429 if (err == -ENOIOCTLCMD) 430 err = -ENOTTY; 431 } else { 432 err = -ENOTTY; 433 } 434 break; 435 } 436 437 done: 438 mutex_unlock(&rtc->ops_lock); 439 return err; 440 } 441 442 #ifdef CONFIG_COMPAT 443 #define RTC_IRQP_SET32 _IOW('p', 0x0c, __u32) 444 #define RTC_IRQP_READ32 _IOR('p', 0x0b, __u32) 445 #define RTC_EPOCH_SET32 _IOW('p', 0x0e, __u32) 446 447 static long rtc_dev_compat_ioctl(struct file *file, 448 unsigned int cmd, unsigned long arg) 449 { 450 struct rtc_device *rtc = file->private_data; 451 void __user *uarg = compat_ptr(arg); 452 453 switch (cmd) { 454 case RTC_IRQP_READ32: 455 return put_user(rtc->irq_freq, (__u32 __user *)uarg); 456 457 case RTC_IRQP_SET32: 458 /* arg is a plain integer, not pointer */ 459 return rtc_dev_ioctl(file, RTC_IRQP_SET, arg); 460 461 case RTC_EPOCH_SET32: 462 /* arg is a plain integer, not pointer */ 463 return rtc_dev_ioctl(file, RTC_EPOCH_SET, arg); 464 } 465 466 return rtc_dev_ioctl(file, cmd, (unsigned long)uarg); 467 } 468 #endif 469 470 static int rtc_dev_fasync(int fd, struct file *file, int on) 471 { 472 struct rtc_device *rtc = file->private_data; 473 474 return fasync_helper(fd, file, on, &rtc->async_queue); 475 } 476 477 static int rtc_dev_release(struct inode *inode, struct file *file) 478 { 479 struct rtc_device *rtc = file->private_data; 480 481 /* We shut down the repeating IRQs that userspace enabled, 482 * since nothing is listening to them. 483 * - Update (UIE) ... currently only managed through ioctls 484 * - Periodic (PIE) ... also used through rtc_*() interface calls 485 * 486 * Leave the alarm alone; it may be set to trigger a system wakeup 487 * later, or be used by kernel code, and is a one-shot event anyway. 488 */ 489 490 /* Keep ioctl until all drivers are converted */ 491 rtc_dev_ioctl(file, RTC_UIE_OFF, 0); 492 rtc_update_irq_enable(rtc, 0); 493 rtc_irq_set_state(rtc, 0); 494 495 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags); 496 return 0; 497 } 498 499 static const struct file_operations rtc_dev_fops = { 500 .owner = THIS_MODULE, 501 .llseek = no_llseek, 502 .read = rtc_dev_read, 503 .poll = rtc_dev_poll, 504 .unlocked_ioctl = rtc_dev_ioctl, 505 #ifdef CONFIG_COMPAT 506 .compat_ioctl = rtc_dev_compat_ioctl, 507 #endif 508 .open = rtc_dev_open, 509 .release = rtc_dev_release, 510 .fasync = rtc_dev_fasync, 511 }; 512 513 /* insertion/removal hooks */ 514 515 void rtc_dev_prepare(struct rtc_device *rtc) 516 { 517 if (!rtc_devt) 518 return; 519 520 if (rtc->id >= RTC_DEV_MAX) { 521 dev_dbg(&rtc->dev, "too many RTC devices\n"); 522 return; 523 } 524 525 rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id); 526 527 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 528 INIT_WORK(&rtc->uie_task, rtc_uie_task); 529 timer_setup(&rtc->uie_timer, rtc_uie_timer, 0); 530 #endif 531 532 cdev_init(&rtc->char_dev, &rtc_dev_fops); 533 rtc->char_dev.owner = rtc->owner; 534 } 535 536 void __init rtc_dev_init(void) 537 { 538 int err; 539 540 err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc"); 541 if (err < 0) 542 pr_err("failed to allocate char dev region\n"); 543 } 544 545 void __exit rtc_dev_exit(void) 546 { 547 if (rtc_devt) 548 unregister_chrdev_region(rtc_devt, RTC_DEV_MAX); 549 } 550