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/module.h> 17 #include <linux/log2.h> 18 #include <linux/workqueue.h> 19 20 #define CREATE_TRACE_POINTS 21 #include <trace/events/rtc.h> 22 23 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer); 24 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer); 25 26 static void rtc_add_offset(struct rtc_device *rtc, struct rtc_time *tm) 27 { 28 time64_t secs; 29 30 if (!rtc->offset_secs) 31 return; 32 33 secs = rtc_tm_to_time64(tm); 34 35 /* 36 * Since the reading time values from RTC device are always in the RTC 37 * original valid range, but we need to skip the overlapped region 38 * between expanded range and original range, which is no need to add 39 * the offset. 40 */ 41 if ((rtc->start_secs > rtc->range_min && secs >= rtc->start_secs) || 42 (rtc->start_secs < rtc->range_min && 43 secs <= (rtc->start_secs + rtc->range_max - rtc->range_min))) 44 return; 45 46 rtc_time64_to_tm(secs + rtc->offset_secs, tm); 47 } 48 49 static void rtc_subtract_offset(struct rtc_device *rtc, struct rtc_time *tm) 50 { 51 time64_t secs; 52 53 if (!rtc->offset_secs) 54 return; 55 56 secs = rtc_tm_to_time64(tm); 57 58 /* 59 * If the setting time values are in the valid range of RTC hardware 60 * device, then no need to subtract the offset when setting time to RTC 61 * device. Otherwise we need to subtract the offset to make the time 62 * values are valid for RTC hardware device. 63 */ 64 if (secs >= rtc->range_min && secs <= rtc->range_max) 65 return; 66 67 rtc_time64_to_tm(secs - rtc->offset_secs, tm); 68 } 69 70 static int rtc_valid_range(struct rtc_device *rtc, struct rtc_time *tm) 71 { 72 if (rtc->range_min != rtc->range_max) { 73 time64_t time = rtc_tm_to_time64(tm); 74 time64_t range_min = rtc->set_start_time ? rtc->start_secs : 75 rtc->range_min; 76 time64_t range_max = rtc->set_start_time ? 77 (rtc->start_secs + rtc->range_max - rtc->range_min) : 78 rtc->range_max; 79 80 if (time < range_min || time > range_max) 81 return -ERANGE; 82 } 83 84 return 0; 85 } 86 87 static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 88 { 89 int err; 90 if (!rtc->ops) 91 err = -ENODEV; 92 else if (!rtc->ops->read_time) 93 err = -EINVAL; 94 else { 95 memset(tm, 0, sizeof(struct rtc_time)); 96 err = rtc->ops->read_time(rtc->dev.parent, tm); 97 if (err < 0) { 98 dev_dbg(&rtc->dev, "read_time: fail to read: %d\n", 99 err); 100 return err; 101 } 102 103 rtc_add_offset(rtc, tm); 104 105 err = rtc_valid_tm(tm); 106 if (err < 0) 107 dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n"); 108 } 109 return err; 110 } 111 112 int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 113 { 114 int err; 115 116 err = mutex_lock_interruptible(&rtc->ops_lock); 117 if (err) 118 return err; 119 120 err = __rtc_read_time(rtc, tm); 121 mutex_unlock(&rtc->ops_lock); 122 123 trace_rtc_read_time(rtc_tm_to_time64(tm), err); 124 return err; 125 } 126 EXPORT_SYMBOL_GPL(rtc_read_time); 127 128 int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm) 129 { 130 int err; 131 132 err = rtc_valid_tm(tm); 133 if (err != 0) 134 return err; 135 136 err = rtc_valid_range(rtc, tm); 137 if (err) 138 return err; 139 140 rtc_subtract_offset(rtc, tm); 141 142 err = mutex_lock_interruptible(&rtc->ops_lock); 143 if (err) 144 return err; 145 146 if (!rtc->ops) 147 err = -ENODEV; 148 else if (rtc->ops->set_time) 149 err = rtc->ops->set_time(rtc->dev.parent, tm); 150 else if (rtc->ops->set_mmss64) { 151 time64_t secs64 = rtc_tm_to_time64(tm); 152 153 err = rtc->ops->set_mmss64(rtc->dev.parent, secs64); 154 } else if (rtc->ops->set_mmss) { 155 time64_t secs64 = rtc_tm_to_time64(tm); 156 err = rtc->ops->set_mmss(rtc->dev.parent, secs64); 157 } else 158 err = -EINVAL; 159 160 pm_stay_awake(rtc->dev.parent); 161 mutex_unlock(&rtc->ops_lock); 162 /* A timer might have just expired */ 163 schedule_work(&rtc->irqwork); 164 165 trace_rtc_set_time(rtc_tm_to_time64(tm), err); 166 return err; 167 } 168 EXPORT_SYMBOL_GPL(rtc_set_time); 169 170 static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 171 { 172 int err; 173 174 err = mutex_lock_interruptible(&rtc->ops_lock); 175 if (err) 176 return err; 177 178 if (rtc->ops == NULL) 179 err = -ENODEV; 180 else if (!rtc->ops->read_alarm) 181 err = -EINVAL; 182 else { 183 alarm->enabled = 0; 184 alarm->pending = 0; 185 alarm->time.tm_sec = -1; 186 alarm->time.tm_min = -1; 187 alarm->time.tm_hour = -1; 188 alarm->time.tm_mday = -1; 189 alarm->time.tm_mon = -1; 190 alarm->time.tm_year = -1; 191 alarm->time.tm_wday = -1; 192 alarm->time.tm_yday = -1; 193 alarm->time.tm_isdst = -1; 194 err = rtc->ops->read_alarm(rtc->dev.parent, alarm); 195 } 196 197 mutex_unlock(&rtc->ops_lock); 198 199 trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err); 200 return err; 201 } 202 203 int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 204 { 205 int err; 206 struct rtc_time before, now; 207 int first_time = 1; 208 time64_t t_now, t_alm; 209 enum { none, day, month, year } missing = none; 210 unsigned days; 211 212 /* The lower level RTC driver may return -1 in some fields, 213 * creating invalid alarm->time values, for reasons like: 214 * 215 * - The hardware may not be capable of filling them in; 216 * many alarms match only on time-of-day fields, not 217 * day/month/year calendar data. 218 * 219 * - Some hardware uses illegal values as "wildcard" match 220 * values, which non-Linux firmware (like a BIOS) may try 221 * to set up as e.g. "alarm 15 minutes after each hour". 222 * Linux uses only oneshot alarms. 223 * 224 * When we see that here, we deal with it by using values from 225 * a current RTC timestamp for any missing (-1) values. The 226 * RTC driver prevents "periodic alarm" modes. 227 * 228 * But this can be racey, because some fields of the RTC timestamp 229 * may have wrapped in the interval since we read the RTC alarm, 230 * which would lead to us inserting inconsistent values in place 231 * of the -1 fields. 232 * 233 * Reading the alarm and timestamp in the reverse sequence 234 * would have the same race condition, and not solve the issue. 235 * 236 * So, we must first read the RTC timestamp, 237 * then read the RTC alarm value, 238 * and then read a second RTC timestamp. 239 * 240 * If any fields of the second timestamp have changed 241 * when compared with the first timestamp, then we know 242 * our timestamp may be inconsistent with that used by 243 * the low-level rtc_read_alarm_internal() function. 244 * 245 * So, when the two timestamps disagree, we just loop and do 246 * the process again to get a fully consistent set of values. 247 * 248 * This could all instead be done in the lower level driver, 249 * but since more than one lower level RTC implementation needs it, 250 * then it's probably best best to do it here instead of there.. 251 */ 252 253 /* Get the "before" timestamp */ 254 err = rtc_read_time(rtc, &before); 255 if (err < 0) 256 return err; 257 do { 258 if (!first_time) 259 memcpy(&before, &now, sizeof(struct rtc_time)); 260 first_time = 0; 261 262 /* get the RTC alarm values, which may be incomplete */ 263 err = rtc_read_alarm_internal(rtc, alarm); 264 if (err) 265 return err; 266 267 /* full-function RTCs won't have such missing fields */ 268 if (rtc_valid_tm(&alarm->time) == 0) { 269 rtc_add_offset(rtc, &alarm->time); 270 return 0; 271 } 272 273 /* get the "after" timestamp, to detect wrapped fields */ 274 err = rtc_read_time(rtc, &now); 275 if (err < 0) 276 return err; 277 278 /* note that tm_sec is a "don't care" value here: */ 279 } while ( before.tm_min != now.tm_min 280 || before.tm_hour != now.tm_hour 281 || before.tm_mon != now.tm_mon 282 || before.tm_year != now.tm_year); 283 284 /* Fill in the missing alarm fields using the timestamp; we 285 * know there's at least one since alarm->time is invalid. 286 */ 287 if (alarm->time.tm_sec == -1) 288 alarm->time.tm_sec = now.tm_sec; 289 if (alarm->time.tm_min == -1) 290 alarm->time.tm_min = now.tm_min; 291 if (alarm->time.tm_hour == -1) 292 alarm->time.tm_hour = now.tm_hour; 293 294 /* For simplicity, only support date rollover for now */ 295 if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) { 296 alarm->time.tm_mday = now.tm_mday; 297 missing = day; 298 } 299 if ((unsigned)alarm->time.tm_mon >= 12) { 300 alarm->time.tm_mon = now.tm_mon; 301 if (missing == none) 302 missing = month; 303 } 304 if (alarm->time.tm_year == -1) { 305 alarm->time.tm_year = now.tm_year; 306 if (missing == none) 307 missing = year; 308 } 309 310 /* Can't proceed if alarm is still invalid after replacing 311 * missing fields. 312 */ 313 err = rtc_valid_tm(&alarm->time); 314 if (err) 315 goto done; 316 317 /* with luck, no rollover is needed */ 318 t_now = rtc_tm_to_time64(&now); 319 t_alm = rtc_tm_to_time64(&alarm->time); 320 if (t_now < t_alm) 321 goto done; 322 323 switch (missing) { 324 325 /* 24 hour rollover ... if it's now 10am Monday, an alarm that 326 * that will trigger at 5am will do so at 5am Tuesday, which 327 * could also be in the next month or year. This is a common 328 * case, especially for PCs. 329 */ 330 case day: 331 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day"); 332 t_alm += 24 * 60 * 60; 333 rtc_time64_to_tm(t_alm, &alarm->time); 334 break; 335 336 /* Month rollover ... if it's the 31th, an alarm on the 3rd will 337 * be next month. An alarm matching on the 30th, 29th, or 28th 338 * may end up in the month after that! Many newer PCs support 339 * this type of alarm. 340 */ 341 case month: 342 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month"); 343 do { 344 if (alarm->time.tm_mon < 11) 345 alarm->time.tm_mon++; 346 else { 347 alarm->time.tm_mon = 0; 348 alarm->time.tm_year++; 349 } 350 days = rtc_month_days(alarm->time.tm_mon, 351 alarm->time.tm_year); 352 } while (days < alarm->time.tm_mday); 353 break; 354 355 /* Year rollover ... easy except for leap years! */ 356 case year: 357 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year"); 358 do { 359 alarm->time.tm_year++; 360 } while (!is_leap_year(alarm->time.tm_year + 1900) 361 && rtc_valid_tm(&alarm->time) != 0); 362 break; 363 364 default: 365 dev_warn(&rtc->dev, "alarm rollover not handled\n"); 366 } 367 368 err = rtc_valid_tm(&alarm->time); 369 370 done: 371 if (err) 372 dev_warn(&rtc->dev, "invalid alarm value: %ptR\n", &alarm->time); 373 374 return err; 375 } 376 377 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 378 { 379 int err; 380 381 err = mutex_lock_interruptible(&rtc->ops_lock); 382 if (err) 383 return err; 384 if (rtc->ops == NULL) 385 err = -ENODEV; 386 else if (!rtc->ops->read_alarm) 387 err = -EINVAL; 388 else { 389 memset(alarm, 0, sizeof(struct rtc_wkalrm)); 390 alarm->enabled = rtc->aie_timer.enabled; 391 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires); 392 } 393 mutex_unlock(&rtc->ops_lock); 394 395 trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err); 396 return err; 397 } 398 EXPORT_SYMBOL_GPL(rtc_read_alarm); 399 400 static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 401 { 402 struct rtc_time tm; 403 time64_t now, scheduled; 404 int err; 405 406 err = rtc_valid_tm(&alarm->time); 407 if (err) 408 return err; 409 410 scheduled = rtc_tm_to_time64(&alarm->time); 411 412 /* Make sure we're not setting alarms in the past */ 413 err = __rtc_read_time(rtc, &tm); 414 if (err) 415 return err; 416 now = rtc_tm_to_time64(&tm); 417 if (scheduled <= now) 418 return -ETIME; 419 /* 420 * XXX - We just checked to make sure the alarm time is not 421 * in the past, but there is still a race window where if 422 * the is alarm set for the next second and the second ticks 423 * over right here, before we set the alarm. 424 */ 425 426 rtc_subtract_offset(rtc, &alarm->time); 427 428 if (!rtc->ops) 429 err = -ENODEV; 430 else if (!rtc->ops->set_alarm) 431 err = -EINVAL; 432 else 433 err = rtc->ops->set_alarm(rtc->dev.parent, alarm); 434 435 trace_rtc_set_alarm(rtc_tm_to_time64(&alarm->time), err); 436 return err; 437 } 438 439 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 440 { 441 int err; 442 443 if (!rtc->ops) 444 return -ENODEV; 445 else if (!rtc->ops->set_alarm) 446 return -EINVAL; 447 448 err = rtc_valid_tm(&alarm->time); 449 if (err != 0) 450 return err; 451 452 err = rtc_valid_range(rtc, &alarm->time); 453 if (err) 454 return err; 455 456 err = mutex_lock_interruptible(&rtc->ops_lock); 457 if (err) 458 return err; 459 if (rtc->aie_timer.enabled) 460 rtc_timer_remove(rtc, &rtc->aie_timer); 461 462 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 463 rtc->aie_timer.period = 0; 464 if (alarm->enabled) 465 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 466 467 mutex_unlock(&rtc->ops_lock); 468 469 return err; 470 } 471 EXPORT_SYMBOL_GPL(rtc_set_alarm); 472 473 /* Called once per device from rtc_device_register */ 474 int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 475 { 476 int err; 477 struct rtc_time now; 478 479 err = rtc_valid_tm(&alarm->time); 480 if (err != 0) 481 return err; 482 483 err = rtc_read_time(rtc, &now); 484 if (err) 485 return err; 486 487 err = mutex_lock_interruptible(&rtc->ops_lock); 488 if (err) 489 return err; 490 491 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 492 rtc->aie_timer.period = 0; 493 494 /* Alarm has to be enabled & in the future for us to enqueue it */ 495 if (alarm->enabled && (rtc_tm_to_ktime(now) < 496 rtc->aie_timer.node.expires)) { 497 498 rtc->aie_timer.enabled = 1; 499 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node); 500 trace_rtc_timer_enqueue(&rtc->aie_timer); 501 } 502 mutex_unlock(&rtc->ops_lock); 503 return err; 504 } 505 EXPORT_SYMBOL_GPL(rtc_initialize_alarm); 506 507 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled) 508 { 509 int err = mutex_lock_interruptible(&rtc->ops_lock); 510 if (err) 511 return err; 512 513 if (rtc->aie_timer.enabled != enabled) { 514 if (enabled) 515 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 516 else 517 rtc_timer_remove(rtc, &rtc->aie_timer); 518 } 519 520 if (err) 521 /* nothing */; 522 else if (!rtc->ops) 523 err = -ENODEV; 524 else if (!rtc->ops->alarm_irq_enable) 525 err = -EINVAL; 526 else 527 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled); 528 529 mutex_unlock(&rtc->ops_lock); 530 531 trace_rtc_alarm_irq_enable(enabled, err); 532 return err; 533 } 534 EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable); 535 536 int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) 537 { 538 int err = mutex_lock_interruptible(&rtc->ops_lock); 539 if (err) 540 return err; 541 542 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 543 if (enabled == 0 && rtc->uie_irq_active) { 544 mutex_unlock(&rtc->ops_lock); 545 return rtc_dev_update_irq_enable_emul(rtc, 0); 546 } 547 #endif 548 /* make sure we're changing state */ 549 if (rtc->uie_rtctimer.enabled == enabled) 550 goto out; 551 552 if (rtc->uie_unsupported) { 553 err = -EINVAL; 554 goto out; 555 } 556 557 if (enabled) { 558 struct rtc_time tm; 559 ktime_t now, onesec; 560 561 __rtc_read_time(rtc, &tm); 562 onesec = ktime_set(1, 0); 563 now = rtc_tm_to_ktime(tm); 564 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec); 565 rtc->uie_rtctimer.period = ktime_set(1, 0); 566 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer); 567 } else 568 rtc_timer_remove(rtc, &rtc->uie_rtctimer); 569 570 out: 571 mutex_unlock(&rtc->ops_lock); 572 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 573 /* 574 * Enable emulation if the driver did not provide 575 * the update_irq_enable function pointer or if returned 576 * -EINVAL to signal that it has been configured without 577 * interrupts or that are not available at the moment. 578 */ 579 if (err == -EINVAL) 580 err = rtc_dev_update_irq_enable_emul(rtc, enabled); 581 #endif 582 return err; 583 584 } 585 EXPORT_SYMBOL_GPL(rtc_update_irq_enable); 586 587 588 /** 589 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook 590 * @rtc: pointer to the rtc device 591 * 592 * This function is called when an AIE, UIE or PIE mode interrupt 593 * has occurred (or been emulated). 594 * 595 */ 596 void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode) 597 { 598 unsigned long flags; 599 600 /* mark one irq of the appropriate mode */ 601 spin_lock_irqsave(&rtc->irq_lock, flags); 602 rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode); 603 spin_unlock_irqrestore(&rtc->irq_lock, flags); 604 605 wake_up_interruptible(&rtc->irq_queue); 606 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); 607 } 608 609 610 /** 611 * rtc_aie_update_irq - AIE mode rtctimer hook 612 * @rtc: pointer to the rtc_device 613 * 614 * This functions is called when the aie_timer expires. 615 */ 616 void rtc_aie_update_irq(struct rtc_device *rtc) 617 { 618 rtc_handle_legacy_irq(rtc, 1, RTC_AF); 619 } 620 621 622 /** 623 * rtc_uie_update_irq - UIE mode rtctimer hook 624 * @rtc: pointer to the rtc_device 625 * 626 * This functions is called when the uie_timer expires. 627 */ 628 void rtc_uie_update_irq(struct rtc_device *rtc) 629 { 630 rtc_handle_legacy_irq(rtc, 1, RTC_UF); 631 } 632 633 634 /** 635 * rtc_pie_update_irq - PIE mode hrtimer hook 636 * @timer: pointer to the pie mode hrtimer 637 * 638 * This function is used to emulate PIE mode interrupts 639 * using an hrtimer. This function is called when the periodic 640 * hrtimer expires. 641 */ 642 enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer) 643 { 644 struct rtc_device *rtc; 645 ktime_t period; 646 int count; 647 rtc = container_of(timer, struct rtc_device, pie_timer); 648 649 period = NSEC_PER_SEC / rtc->irq_freq; 650 count = hrtimer_forward_now(timer, period); 651 652 rtc_handle_legacy_irq(rtc, count, RTC_PF); 653 654 return HRTIMER_RESTART; 655 } 656 657 /** 658 * rtc_update_irq - Triggered when a RTC interrupt occurs. 659 * @rtc: the rtc device 660 * @num: how many irqs are being reported (usually one) 661 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF 662 * Context: any 663 */ 664 void rtc_update_irq(struct rtc_device *rtc, 665 unsigned long num, unsigned long events) 666 { 667 if (IS_ERR_OR_NULL(rtc)) 668 return; 669 670 pm_stay_awake(rtc->dev.parent); 671 schedule_work(&rtc->irqwork); 672 } 673 EXPORT_SYMBOL_GPL(rtc_update_irq); 674 675 static int __rtc_match(struct device *dev, const void *data) 676 { 677 const char *name = data; 678 679 if (strcmp(dev_name(dev), name) == 0) 680 return 1; 681 return 0; 682 } 683 684 struct rtc_device *rtc_class_open(const char *name) 685 { 686 struct device *dev; 687 struct rtc_device *rtc = NULL; 688 689 dev = class_find_device(rtc_class, NULL, name, __rtc_match); 690 if (dev) 691 rtc = to_rtc_device(dev); 692 693 if (rtc) { 694 if (!try_module_get(rtc->owner)) { 695 put_device(dev); 696 rtc = NULL; 697 } 698 } 699 700 return rtc; 701 } 702 EXPORT_SYMBOL_GPL(rtc_class_open); 703 704 void rtc_class_close(struct rtc_device *rtc) 705 { 706 module_put(rtc->owner); 707 put_device(&rtc->dev); 708 } 709 EXPORT_SYMBOL_GPL(rtc_class_close); 710 711 static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled) 712 { 713 /* 714 * We always cancel the timer here first, because otherwise 715 * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK); 716 * when we manage to start the timer before the callback 717 * returns HRTIMER_RESTART. 718 * 719 * We cannot use hrtimer_cancel() here as a running callback 720 * could be blocked on rtc->irq_task_lock and hrtimer_cancel() 721 * would spin forever. 722 */ 723 if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0) 724 return -1; 725 726 if (enabled) { 727 ktime_t period = NSEC_PER_SEC / rtc->irq_freq; 728 729 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL); 730 } 731 return 0; 732 } 733 734 /** 735 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs 736 * @rtc: the rtc device 737 * @enabled: true to enable periodic IRQs 738 * Context: any 739 * 740 * Note that rtc_irq_set_freq() should previously have been used to 741 * specify the desired frequency of periodic IRQ. 742 */ 743 int rtc_irq_set_state(struct rtc_device *rtc, int enabled) 744 { 745 int err = 0; 746 747 while (rtc_update_hrtimer(rtc, enabled) < 0) 748 cpu_relax(); 749 750 rtc->pie_enabled = enabled; 751 752 trace_rtc_irq_set_state(enabled, err); 753 return err; 754 } 755 756 /** 757 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ 758 * @rtc: the rtc device 759 * @freq: positive frequency 760 * Context: any 761 * 762 * Note that rtc_irq_set_state() is used to enable or disable the 763 * periodic IRQs. 764 */ 765 int rtc_irq_set_freq(struct rtc_device *rtc, int freq) 766 { 767 int err = 0; 768 769 if (freq <= 0 || freq > RTC_MAX_FREQ) 770 return -EINVAL; 771 772 rtc->irq_freq = freq; 773 while (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) 774 cpu_relax(); 775 776 trace_rtc_irq_set_freq(freq, err); 777 return err; 778 } 779 780 /** 781 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue 782 * @rtc rtc device 783 * @timer timer being added. 784 * 785 * Enqueues a timer onto the rtc devices timerqueue and sets 786 * the next alarm event appropriately. 787 * 788 * Sets the enabled bit on the added timer. 789 * 790 * Must hold ops_lock for proper serialization of timerqueue 791 */ 792 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer) 793 { 794 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 795 struct rtc_time tm; 796 ktime_t now; 797 798 timer->enabled = 1; 799 __rtc_read_time(rtc, &tm); 800 now = rtc_tm_to_ktime(tm); 801 802 /* Skip over expired timers */ 803 while (next) { 804 if (next->expires >= now) 805 break; 806 next = timerqueue_iterate_next(next); 807 } 808 809 timerqueue_add(&rtc->timerqueue, &timer->node); 810 trace_rtc_timer_enqueue(timer); 811 if (!next || ktime_before(timer->node.expires, next->expires)) { 812 struct rtc_wkalrm alarm; 813 int err; 814 alarm.time = rtc_ktime_to_tm(timer->node.expires); 815 alarm.enabled = 1; 816 err = __rtc_set_alarm(rtc, &alarm); 817 if (err == -ETIME) { 818 pm_stay_awake(rtc->dev.parent); 819 schedule_work(&rtc->irqwork); 820 } else if (err) { 821 timerqueue_del(&rtc->timerqueue, &timer->node); 822 trace_rtc_timer_dequeue(timer); 823 timer->enabled = 0; 824 return err; 825 } 826 } 827 return 0; 828 } 829 830 static void rtc_alarm_disable(struct rtc_device *rtc) 831 { 832 if (!rtc->ops || !rtc->ops->alarm_irq_enable) 833 return; 834 835 rtc->ops->alarm_irq_enable(rtc->dev.parent, false); 836 trace_rtc_alarm_irq_enable(0, 0); 837 } 838 839 /** 840 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue 841 * @rtc rtc device 842 * @timer timer being removed. 843 * 844 * Removes a timer onto the rtc devices timerqueue and sets 845 * the next alarm event appropriately. 846 * 847 * Clears the enabled bit on the removed timer. 848 * 849 * Must hold ops_lock for proper serialization of timerqueue 850 */ 851 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) 852 { 853 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 854 timerqueue_del(&rtc->timerqueue, &timer->node); 855 trace_rtc_timer_dequeue(timer); 856 timer->enabled = 0; 857 if (next == &timer->node) { 858 struct rtc_wkalrm alarm; 859 int err; 860 next = timerqueue_getnext(&rtc->timerqueue); 861 if (!next) { 862 rtc_alarm_disable(rtc); 863 return; 864 } 865 alarm.time = rtc_ktime_to_tm(next->expires); 866 alarm.enabled = 1; 867 err = __rtc_set_alarm(rtc, &alarm); 868 if (err == -ETIME) { 869 pm_stay_awake(rtc->dev.parent); 870 schedule_work(&rtc->irqwork); 871 } 872 } 873 } 874 875 /** 876 * rtc_timer_do_work - Expires rtc timers 877 * @rtc rtc device 878 * @timer timer being removed. 879 * 880 * Expires rtc timers. Reprograms next alarm event if needed. 881 * Called via worktask. 882 * 883 * Serializes access to timerqueue via ops_lock mutex 884 */ 885 void rtc_timer_do_work(struct work_struct *work) 886 { 887 struct rtc_timer *timer; 888 struct timerqueue_node *next; 889 ktime_t now; 890 struct rtc_time tm; 891 892 struct rtc_device *rtc = 893 container_of(work, struct rtc_device, irqwork); 894 895 mutex_lock(&rtc->ops_lock); 896 again: 897 __rtc_read_time(rtc, &tm); 898 now = rtc_tm_to_ktime(tm); 899 while ((next = timerqueue_getnext(&rtc->timerqueue))) { 900 if (next->expires > now) 901 break; 902 903 /* expire timer */ 904 timer = container_of(next, struct rtc_timer, node); 905 timerqueue_del(&rtc->timerqueue, &timer->node); 906 trace_rtc_timer_dequeue(timer); 907 timer->enabled = 0; 908 if (timer->func) 909 timer->func(timer->rtc); 910 911 trace_rtc_timer_fired(timer); 912 /* Re-add/fwd periodic timers */ 913 if (ktime_to_ns(timer->period)) { 914 timer->node.expires = ktime_add(timer->node.expires, 915 timer->period); 916 timer->enabled = 1; 917 timerqueue_add(&rtc->timerqueue, &timer->node); 918 trace_rtc_timer_enqueue(timer); 919 } 920 } 921 922 /* Set next alarm */ 923 if (next) { 924 struct rtc_wkalrm alarm; 925 int err; 926 int retry = 3; 927 928 alarm.time = rtc_ktime_to_tm(next->expires); 929 alarm.enabled = 1; 930 reprogram: 931 err = __rtc_set_alarm(rtc, &alarm); 932 if (err == -ETIME) 933 goto again; 934 else if (err) { 935 if (retry-- > 0) 936 goto reprogram; 937 938 timer = container_of(next, struct rtc_timer, node); 939 timerqueue_del(&rtc->timerqueue, &timer->node); 940 trace_rtc_timer_dequeue(timer); 941 timer->enabled = 0; 942 dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err); 943 goto again; 944 } 945 } else 946 rtc_alarm_disable(rtc); 947 948 pm_relax(rtc->dev.parent); 949 mutex_unlock(&rtc->ops_lock); 950 } 951 952 953 /* rtc_timer_init - Initializes an rtc_timer 954 * @timer: timer to be intiialized 955 * @f: function pointer to be called when timer fires 956 * @rtc: pointer to the rtc_device 957 * 958 * Kernel interface to initializing an rtc_timer. 959 */ 960 void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r), 961 struct rtc_device *rtc) 962 { 963 timerqueue_init(&timer->node); 964 timer->enabled = 0; 965 timer->func = f; 966 timer->rtc = rtc; 967 } 968 969 /* rtc_timer_start - Sets an rtc_timer to fire in the future 970 * @ rtc: rtc device to be used 971 * @ timer: timer being set 972 * @ expires: time at which to expire the timer 973 * @ period: period that the timer will recur 974 * 975 * Kernel interface to set an rtc_timer 976 */ 977 int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer, 978 ktime_t expires, ktime_t period) 979 { 980 int ret = 0; 981 mutex_lock(&rtc->ops_lock); 982 if (timer->enabled) 983 rtc_timer_remove(rtc, timer); 984 985 timer->node.expires = expires; 986 timer->period = period; 987 988 ret = rtc_timer_enqueue(rtc, timer); 989 990 mutex_unlock(&rtc->ops_lock); 991 return ret; 992 } 993 994 /* rtc_timer_cancel - Stops an rtc_timer 995 * @ rtc: rtc device to be used 996 * @ timer: timer being set 997 * 998 * Kernel interface to cancel an rtc_timer 999 */ 1000 void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer) 1001 { 1002 mutex_lock(&rtc->ops_lock); 1003 if (timer->enabled) 1004 rtc_timer_remove(rtc, timer); 1005 mutex_unlock(&rtc->ops_lock); 1006 } 1007 1008 /** 1009 * rtc_read_offset - Read the amount of rtc offset in parts per billion 1010 * @ rtc: rtc device to be used 1011 * @ offset: the offset in parts per billion 1012 * 1013 * see below for details. 1014 * 1015 * Kernel interface to read rtc clock offset 1016 * Returns 0 on success, or a negative number on error. 1017 * If read_offset() is not implemented for the rtc, return -EINVAL 1018 */ 1019 int rtc_read_offset(struct rtc_device *rtc, long *offset) 1020 { 1021 int ret; 1022 1023 if (!rtc->ops) 1024 return -ENODEV; 1025 1026 if (!rtc->ops->read_offset) 1027 return -EINVAL; 1028 1029 mutex_lock(&rtc->ops_lock); 1030 ret = rtc->ops->read_offset(rtc->dev.parent, offset); 1031 mutex_unlock(&rtc->ops_lock); 1032 1033 trace_rtc_read_offset(*offset, ret); 1034 return ret; 1035 } 1036 1037 /** 1038 * rtc_set_offset - Adjusts the duration of the average second 1039 * @ rtc: rtc device to be used 1040 * @ offset: the offset in parts per billion 1041 * 1042 * Some rtc's allow an adjustment to the average duration of a second 1043 * to compensate for differences in the actual clock rate due to temperature, 1044 * the crystal, capacitor, etc. 1045 * 1046 * The adjustment applied is as follows: 1047 * t = t0 * (1 + offset * 1e-9) 1048 * where t0 is the measured length of 1 RTC second with offset = 0 1049 * 1050 * Kernel interface to adjust an rtc clock offset. 1051 * Return 0 on success, or a negative number on error. 1052 * If the rtc offset is not setable (or not implemented), return -EINVAL 1053 */ 1054 int rtc_set_offset(struct rtc_device *rtc, long offset) 1055 { 1056 int ret; 1057 1058 if (!rtc->ops) 1059 return -ENODEV; 1060 1061 if (!rtc->ops->set_offset) 1062 return -EINVAL; 1063 1064 mutex_lock(&rtc->ops_lock); 1065 ret = rtc->ops->set_offset(rtc->dev.parent, offset); 1066 mutex_unlock(&rtc->ops_lock); 1067 1068 trace_rtc_set_offset(offset, ret); 1069 return ret; 1070 } 1071