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