1 /* 2 * RTC subsystem, interface functions 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 #include <linux/rtc.h> 15 #include <linux/sched.h> 16 #include <linux/log2.h> 17 #include <linux/workqueue.h> 18 19 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer); 20 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer); 21 22 static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 23 { 24 int err; 25 if (!rtc->ops) 26 err = -ENODEV; 27 else if (!rtc->ops->read_time) 28 err = -EINVAL; 29 else { 30 memset(tm, 0, sizeof(struct rtc_time)); 31 err = rtc->ops->read_time(rtc->dev.parent, tm); 32 } 33 return err; 34 } 35 36 int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 37 { 38 int err; 39 40 err = mutex_lock_interruptible(&rtc->ops_lock); 41 if (err) 42 return err; 43 44 err = __rtc_read_time(rtc, tm); 45 mutex_unlock(&rtc->ops_lock); 46 return err; 47 } 48 EXPORT_SYMBOL_GPL(rtc_read_time); 49 50 int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm) 51 { 52 int err; 53 54 err = rtc_valid_tm(tm); 55 if (err != 0) 56 return err; 57 58 err = mutex_lock_interruptible(&rtc->ops_lock); 59 if (err) 60 return err; 61 62 if (!rtc->ops) 63 err = -ENODEV; 64 else if (rtc->ops->set_time) 65 err = rtc->ops->set_time(rtc->dev.parent, tm); 66 else if (rtc->ops->set_mmss) { 67 unsigned long secs; 68 err = rtc_tm_to_time(tm, &secs); 69 if (err == 0) 70 err = rtc->ops->set_mmss(rtc->dev.parent, secs); 71 } else 72 err = -EINVAL; 73 74 mutex_unlock(&rtc->ops_lock); 75 return err; 76 } 77 EXPORT_SYMBOL_GPL(rtc_set_time); 78 79 int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs) 80 { 81 int err; 82 83 err = mutex_lock_interruptible(&rtc->ops_lock); 84 if (err) 85 return err; 86 87 if (!rtc->ops) 88 err = -ENODEV; 89 else if (rtc->ops->set_mmss) 90 err = rtc->ops->set_mmss(rtc->dev.parent, secs); 91 else if (rtc->ops->read_time && rtc->ops->set_time) { 92 struct rtc_time new, old; 93 94 err = rtc->ops->read_time(rtc->dev.parent, &old); 95 if (err == 0) { 96 rtc_time_to_tm(secs, &new); 97 98 /* 99 * avoid writing when we're going to change the day of 100 * the month. We will retry in the next minute. This 101 * basically means that if the RTC must not drift 102 * by more than 1 minute in 11 minutes. 103 */ 104 if (!((old.tm_hour == 23 && old.tm_min == 59) || 105 (new.tm_hour == 23 && new.tm_min == 59))) 106 err = rtc->ops->set_time(rtc->dev.parent, 107 &new); 108 } 109 } 110 else 111 err = -EINVAL; 112 113 mutex_unlock(&rtc->ops_lock); 114 115 return err; 116 } 117 EXPORT_SYMBOL_GPL(rtc_set_mmss); 118 119 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 120 { 121 int err; 122 123 err = mutex_lock_interruptible(&rtc->ops_lock); 124 if (err) 125 return err; 126 if (rtc->ops == NULL) 127 err = -ENODEV; 128 else if (!rtc->ops->read_alarm) 129 err = -EINVAL; 130 else { 131 memset(alarm, 0, sizeof(struct rtc_wkalrm)); 132 alarm->enabled = rtc->aie_timer.enabled; 133 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires); 134 } 135 mutex_unlock(&rtc->ops_lock); 136 137 return err; 138 } 139 EXPORT_SYMBOL_GPL(rtc_read_alarm); 140 141 int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 142 { 143 struct rtc_time tm; 144 long now, scheduled; 145 int err; 146 147 err = rtc_valid_tm(&alarm->time); 148 if (err) 149 return err; 150 rtc_tm_to_time(&alarm->time, &scheduled); 151 152 /* Make sure we're not setting alarms in the past */ 153 err = __rtc_read_time(rtc, &tm); 154 rtc_tm_to_time(&tm, &now); 155 if (scheduled <= now) 156 return -ETIME; 157 /* 158 * XXX - We just checked to make sure the alarm time is not 159 * in the past, but there is still a race window where if 160 * the is alarm set for the next second and the second ticks 161 * over right here, before we set the alarm. 162 */ 163 164 if (!rtc->ops) 165 err = -ENODEV; 166 else if (!rtc->ops->set_alarm) 167 err = -EINVAL; 168 else 169 err = rtc->ops->set_alarm(rtc->dev.parent, alarm); 170 171 return err; 172 } 173 174 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 175 { 176 int err; 177 178 err = rtc_valid_tm(&alarm->time); 179 if (err != 0) 180 return err; 181 182 err = mutex_lock_interruptible(&rtc->ops_lock); 183 if (err) 184 return err; 185 if (rtc->aie_timer.enabled) { 186 rtc_timer_remove(rtc, &rtc->aie_timer); 187 } 188 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 189 rtc->aie_timer.period = ktime_set(0, 0); 190 if (alarm->enabled) { 191 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 192 } 193 mutex_unlock(&rtc->ops_lock); 194 return err; 195 } 196 EXPORT_SYMBOL_GPL(rtc_set_alarm); 197 198 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled) 199 { 200 int err = mutex_lock_interruptible(&rtc->ops_lock); 201 if (err) 202 return err; 203 204 if (rtc->aie_timer.enabled != enabled) { 205 if (enabled) 206 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 207 else 208 rtc_timer_remove(rtc, &rtc->aie_timer); 209 } 210 211 if (err) 212 /* nothing */; 213 else if (!rtc->ops) 214 err = -ENODEV; 215 else if (!rtc->ops->alarm_irq_enable) 216 err = -EINVAL; 217 else 218 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled); 219 220 mutex_unlock(&rtc->ops_lock); 221 return err; 222 } 223 EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable); 224 225 int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) 226 { 227 int err = mutex_lock_interruptible(&rtc->ops_lock); 228 if (err) 229 return err; 230 231 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 232 if (enabled == 0 && rtc->uie_irq_active) { 233 mutex_unlock(&rtc->ops_lock); 234 return rtc_dev_update_irq_enable_emul(rtc, 0); 235 } 236 #endif 237 /* make sure we're changing state */ 238 if (rtc->uie_rtctimer.enabled == enabled) 239 goto out; 240 241 if (enabled) { 242 struct rtc_time tm; 243 ktime_t now, onesec; 244 245 __rtc_read_time(rtc, &tm); 246 onesec = ktime_set(1, 0); 247 now = rtc_tm_to_ktime(tm); 248 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec); 249 rtc->uie_rtctimer.period = ktime_set(1, 0); 250 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer); 251 } else 252 rtc_timer_remove(rtc, &rtc->uie_rtctimer); 253 254 out: 255 mutex_unlock(&rtc->ops_lock); 256 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 257 /* 258 * Enable emulation if the driver did not provide 259 * the update_irq_enable function pointer or if returned 260 * -EINVAL to signal that it has been configured without 261 * interrupts or that are not available at the moment. 262 */ 263 if (err == -EINVAL) 264 err = rtc_dev_update_irq_enable_emul(rtc, enabled); 265 #endif 266 return err; 267 268 } 269 EXPORT_SYMBOL_GPL(rtc_update_irq_enable); 270 271 272 /** 273 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook 274 * @rtc: pointer to the rtc device 275 * 276 * This function is called when an AIE, UIE or PIE mode interrupt 277 * has occured (or been emulated). 278 * 279 * Triggers the registered irq_task function callback. 280 */ 281 void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode) 282 { 283 unsigned long flags; 284 285 /* mark one irq of the appropriate mode */ 286 spin_lock_irqsave(&rtc->irq_lock, flags); 287 rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode); 288 spin_unlock_irqrestore(&rtc->irq_lock, flags); 289 290 /* call the task func */ 291 spin_lock_irqsave(&rtc->irq_task_lock, flags); 292 if (rtc->irq_task) 293 rtc->irq_task->func(rtc->irq_task->private_data); 294 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 295 296 wake_up_interruptible(&rtc->irq_queue); 297 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); 298 } 299 300 301 /** 302 * rtc_aie_update_irq - AIE mode rtctimer hook 303 * @private: pointer to the rtc_device 304 * 305 * This functions is called when the aie_timer expires. 306 */ 307 void rtc_aie_update_irq(void *private) 308 { 309 struct rtc_device *rtc = (struct rtc_device *)private; 310 rtc_handle_legacy_irq(rtc, 1, RTC_AF); 311 } 312 313 314 /** 315 * rtc_uie_update_irq - UIE mode rtctimer hook 316 * @private: pointer to the rtc_device 317 * 318 * This functions is called when the uie_timer expires. 319 */ 320 void rtc_uie_update_irq(void *private) 321 { 322 struct rtc_device *rtc = (struct rtc_device *)private; 323 rtc_handle_legacy_irq(rtc, 1, RTC_UF); 324 } 325 326 327 /** 328 * rtc_pie_update_irq - PIE mode hrtimer hook 329 * @timer: pointer to the pie mode hrtimer 330 * 331 * This function is used to emulate PIE mode interrupts 332 * using an hrtimer. This function is called when the periodic 333 * hrtimer expires. 334 */ 335 enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer) 336 { 337 struct rtc_device *rtc; 338 ktime_t period; 339 int count; 340 rtc = container_of(timer, struct rtc_device, pie_timer); 341 342 period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq); 343 count = hrtimer_forward_now(timer, period); 344 345 rtc_handle_legacy_irq(rtc, count, RTC_PF); 346 347 return HRTIMER_RESTART; 348 } 349 350 /** 351 * rtc_update_irq - Triggered when a RTC interrupt occurs. 352 * @rtc: the rtc device 353 * @num: how many irqs are being reported (usually one) 354 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF 355 * Context: any 356 */ 357 void rtc_update_irq(struct rtc_device *rtc, 358 unsigned long num, unsigned long events) 359 { 360 schedule_work(&rtc->irqwork); 361 } 362 EXPORT_SYMBOL_GPL(rtc_update_irq); 363 364 static int __rtc_match(struct device *dev, void *data) 365 { 366 char *name = (char *)data; 367 368 if (strcmp(dev_name(dev), name) == 0) 369 return 1; 370 return 0; 371 } 372 373 struct rtc_device *rtc_class_open(char *name) 374 { 375 struct device *dev; 376 struct rtc_device *rtc = NULL; 377 378 dev = class_find_device(rtc_class, NULL, name, __rtc_match); 379 if (dev) 380 rtc = to_rtc_device(dev); 381 382 if (rtc) { 383 if (!try_module_get(rtc->owner)) { 384 put_device(dev); 385 rtc = NULL; 386 } 387 } 388 389 return rtc; 390 } 391 EXPORT_SYMBOL_GPL(rtc_class_open); 392 393 void rtc_class_close(struct rtc_device *rtc) 394 { 395 module_put(rtc->owner); 396 put_device(&rtc->dev); 397 } 398 EXPORT_SYMBOL_GPL(rtc_class_close); 399 400 int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task) 401 { 402 int retval = -EBUSY; 403 404 if (task == NULL || task->func == NULL) 405 return -EINVAL; 406 407 /* Cannot register while the char dev is in use */ 408 if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags)) 409 return -EBUSY; 410 411 spin_lock_irq(&rtc->irq_task_lock); 412 if (rtc->irq_task == NULL) { 413 rtc->irq_task = task; 414 retval = 0; 415 } 416 spin_unlock_irq(&rtc->irq_task_lock); 417 418 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags); 419 420 return retval; 421 } 422 EXPORT_SYMBOL_GPL(rtc_irq_register); 423 424 void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task) 425 { 426 spin_lock_irq(&rtc->irq_task_lock); 427 if (rtc->irq_task == task) 428 rtc->irq_task = NULL; 429 spin_unlock_irq(&rtc->irq_task_lock); 430 } 431 EXPORT_SYMBOL_GPL(rtc_irq_unregister); 432 433 /** 434 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs 435 * @rtc: the rtc device 436 * @task: currently registered with rtc_irq_register() 437 * @enabled: true to enable periodic IRQs 438 * Context: any 439 * 440 * Note that rtc_irq_set_freq() should previously have been used to 441 * specify the desired frequency of periodic IRQ task->func() callbacks. 442 */ 443 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled) 444 { 445 int err = 0; 446 unsigned long flags; 447 448 spin_lock_irqsave(&rtc->irq_task_lock, flags); 449 if (rtc->irq_task != NULL && task == NULL) 450 err = -EBUSY; 451 if (rtc->irq_task != task) 452 err = -EACCES; 453 454 if (enabled) { 455 ktime_t period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq); 456 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL); 457 } else { 458 hrtimer_cancel(&rtc->pie_timer); 459 } 460 rtc->pie_enabled = enabled; 461 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 462 463 return err; 464 } 465 EXPORT_SYMBOL_GPL(rtc_irq_set_state); 466 467 /** 468 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ 469 * @rtc: the rtc device 470 * @task: currently registered with rtc_irq_register() 471 * @freq: positive frequency with which task->func() will be called 472 * Context: any 473 * 474 * Note that rtc_irq_set_state() is used to enable or disable the 475 * periodic IRQs. 476 */ 477 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq) 478 { 479 int err = 0; 480 unsigned long flags; 481 482 if (freq <= 0) 483 return -EINVAL; 484 485 spin_lock_irqsave(&rtc->irq_task_lock, flags); 486 if (rtc->irq_task != NULL && task == NULL) 487 err = -EBUSY; 488 if (rtc->irq_task != task) 489 err = -EACCES; 490 if (err == 0) { 491 rtc->irq_freq = freq; 492 if (rtc->pie_enabled) { 493 ktime_t period; 494 hrtimer_cancel(&rtc->pie_timer); 495 period = ktime_set(0, NSEC_PER_SEC/rtc->irq_freq); 496 hrtimer_start(&rtc->pie_timer, period, 497 HRTIMER_MODE_REL); 498 } 499 } 500 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 501 return err; 502 } 503 EXPORT_SYMBOL_GPL(rtc_irq_set_freq); 504 505 /** 506 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue 507 * @rtc rtc device 508 * @timer timer being added. 509 * 510 * Enqueues a timer onto the rtc devices timerqueue and sets 511 * the next alarm event appropriately. 512 * 513 * Sets the enabled bit on the added timer. 514 * 515 * Must hold ops_lock for proper serialization of timerqueue 516 */ 517 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer) 518 { 519 timer->enabled = 1; 520 timerqueue_add(&rtc->timerqueue, &timer->node); 521 if (&timer->node == timerqueue_getnext(&rtc->timerqueue)) { 522 struct rtc_wkalrm alarm; 523 int err; 524 alarm.time = rtc_ktime_to_tm(timer->node.expires); 525 alarm.enabled = 1; 526 err = __rtc_set_alarm(rtc, &alarm); 527 if (err == -ETIME) 528 schedule_work(&rtc->irqwork); 529 else if (err) { 530 timerqueue_del(&rtc->timerqueue, &timer->node); 531 timer->enabled = 0; 532 return err; 533 } 534 } 535 return 0; 536 } 537 538 /** 539 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue 540 * @rtc rtc device 541 * @timer timer being removed. 542 * 543 * Removes a timer onto the rtc devices timerqueue and sets 544 * the next alarm event appropriately. 545 * 546 * Clears the enabled bit on the removed timer. 547 * 548 * Must hold ops_lock for proper serialization of timerqueue 549 */ 550 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) 551 { 552 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 553 timerqueue_del(&rtc->timerqueue, &timer->node); 554 timer->enabled = 0; 555 if (next == &timer->node) { 556 struct rtc_wkalrm alarm; 557 int err; 558 next = timerqueue_getnext(&rtc->timerqueue); 559 if (!next) 560 return; 561 alarm.time = rtc_ktime_to_tm(next->expires); 562 alarm.enabled = 1; 563 err = __rtc_set_alarm(rtc, &alarm); 564 if (err == -ETIME) 565 schedule_work(&rtc->irqwork); 566 } 567 } 568 569 /** 570 * rtc_timer_do_work - Expires rtc timers 571 * @rtc rtc device 572 * @timer timer being removed. 573 * 574 * Expires rtc timers. Reprograms next alarm event if needed. 575 * Called via worktask. 576 * 577 * Serializes access to timerqueue via ops_lock mutex 578 */ 579 void rtc_timer_do_work(struct work_struct *work) 580 { 581 struct rtc_timer *timer; 582 struct timerqueue_node *next; 583 ktime_t now; 584 struct rtc_time tm; 585 586 struct rtc_device *rtc = 587 container_of(work, struct rtc_device, irqwork); 588 589 mutex_lock(&rtc->ops_lock); 590 again: 591 __rtc_read_time(rtc, &tm); 592 now = rtc_tm_to_ktime(tm); 593 while ((next = timerqueue_getnext(&rtc->timerqueue))) { 594 if (next->expires.tv64 > now.tv64) 595 break; 596 597 /* expire timer */ 598 timer = container_of(next, struct rtc_timer, node); 599 timerqueue_del(&rtc->timerqueue, &timer->node); 600 timer->enabled = 0; 601 if (timer->task.func) 602 timer->task.func(timer->task.private_data); 603 604 /* Re-add/fwd periodic timers */ 605 if (ktime_to_ns(timer->period)) { 606 timer->node.expires = ktime_add(timer->node.expires, 607 timer->period); 608 timer->enabled = 1; 609 timerqueue_add(&rtc->timerqueue, &timer->node); 610 } 611 } 612 613 /* Set next alarm */ 614 if (next) { 615 struct rtc_wkalrm alarm; 616 int err; 617 alarm.time = rtc_ktime_to_tm(next->expires); 618 alarm.enabled = 1; 619 err = __rtc_set_alarm(rtc, &alarm); 620 if (err == -ETIME) 621 goto again; 622 } 623 624 mutex_unlock(&rtc->ops_lock); 625 } 626 627 628 /* rtc_timer_init - Initializes an rtc_timer 629 * @timer: timer to be intiialized 630 * @f: function pointer to be called when timer fires 631 * @data: private data passed to function pointer 632 * 633 * Kernel interface to initializing an rtc_timer. 634 */ 635 void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data) 636 { 637 timerqueue_init(&timer->node); 638 timer->enabled = 0; 639 timer->task.func = f; 640 timer->task.private_data = data; 641 } 642 643 /* rtc_timer_start - Sets an rtc_timer to fire in the future 644 * @ rtc: rtc device to be used 645 * @ timer: timer being set 646 * @ expires: time at which to expire the timer 647 * @ period: period that the timer will recur 648 * 649 * Kernel interface to set an rtc_timer 650 */ 651 int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer, 652 ktime_t expires, ktime_t period) 653 { 654 int ret = 0; 655 mutex_lock(&rtc->ops_lock); 656 if (timer->enabled) 657 rtc_timer_remove(rtc, timer); 658 659 timer->node.expires = expires; 660 timer->period = period; 661 662 ret = rtc_timer_enqueue(rtc, timer); 663 664 mutex_unlock(&rtc->ops_lock); 665 return ret; 666 } 667 668 /* rtc_timer_cancel - Stops an rtc_timer 669 * @ rtc: rtc device to be used 670 * @ timer: timer being set 671 * 672 * Kernel interface to cancel an rtc_timer 673 */ 674 int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer) 675 { 676 int ret = 0; 677 mutex_lock(&rtc->ops_lock); 678 if (timer->enabled) 679 rtc_timer_remove(rtc, timer); 680 mutex_unlock(&rtc->ops_lock); 681 return ret; 682 } 683 684 685