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 return 0; 270 271 /* get the "after" timestamp, to detect wrapped fields */ 272 err = rtc_read_time(rtc, &now); 273 if (err < 0) 274 return err; 275 276 /* note that tm_sec is a "don't care" value here: */ 277 } while ( before.tm_min != now.tm_min 278 || before.tm_hour != now.tm_hour 279 || before.tm_mon != now.tm_mon 280 || before.tm_year != now.tm_year); 281 282 /* Fill in the missing alarm fields using the timestamp; we 283 * know there's at least one since alarm->time is invalid. 284 */ 285 if (alarm->time.tm_sec == -1) 286 alarm->time.tm_sec = now.tm_sec; 287 if (alarm->time.tm_min == -1) 288 alarm->time.tm_min = now.tm_min; 289 if (alarm->time.tm_hour == -1) 290 alarm->time.tm_hour = now.tm_hour; 291 292 /* For simplicity, only support date rollover for now */ 293 if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) { 294 alarm->time.tm_mday = now.tm_mday; 295 missing = day; 296 } 297 if ((unsigned)alarm->time.tm_mon >= 12) { 298 alarm->time.tm_mon = now.tm_mon; 299 if (missing == none) 300 missing = month; 301 } 302 if (alarm->time.tm_year == -1) { 303 alarm->time.tm_year = now.tm_year; 304 if (missing == none) 305 missing = year; 306 } 307 308 /* Can't proceed if alarm is still invalid after replacing 309 * missing fields. 310 */ 311 err = rtc_valid_tm(&alarm->time); 312 if (err) 313 goto done; 314 315 /* with luck, no rollover is needed */ 316 t_now = rtc_tm_to_time64(&now); 317 t_alm = rtc_tm_to_time64(&alarm->time); 318 if (t_now < t_alm) 319 goto done; 320 321 switch (missing) { 322 323 /* 24 hour rollover ... if it's now 10am Monday, an alarm that 324 * that will trigger at 5am will do so at 5am Tuesday, which 325 * could also be in the next month or year. This is a common 326 * case, especially for PCs. 327 */ 328 case day: 329 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day"); 330 t_alm += 24 * 60 * 60; 331 rtc_time64_to_tm(t_alm, &alarm->time); 332 break; 333 334 /* Month rollover ... if it's the 31th, an alarm on the 3rd will 335 * be next month. An alarm matching on the 30th, 29th, or 28th 336 * may end up in the month after that! Many newer PCs support 337 * this type of alarm. 338 */ 339 case month: 340 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month"); 341 do { 342 if (alarm->time.tm_mon < 11) 343 alarm->time.tm_mon++; 344 else { 345 alarm->time.tm_mon = 0; 346 alarm->time.tm_year++; 347 } 348 days = rtc_month_days(alarm->time.tm_mon, 349 alarm->time.tm_year); 350 } while (days < alarm->time.tm_mday); 351 break; 352 353 /* Year rollover ... easy except for leap years! */ 354 case year: 355 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year"); 356 do { 357 alarm->time.tm_year++; 358 } while (!is_leap_year(alarm->time.tm_year + 1900) 359 && rtc_valid_tm(&alarm->time) != 0); 360 break; 361 362 default: 363 dev_warn(&rtc->dev, "alarm rollover not handled\n"); 364 } 365 366 err = rtc_valid_tm(&alarm->time); 367 368 done: 369 if (err) { 370 dev_warn(&rtc->dev, "invalid alarm value: %d-%d-%d %d:%d:%d\n", 371 alarm->time.tm_year + 1900, alarm->time.tm_mon + 1, 372 alarm->time.tm_mday, alarm->time.tm_hour, alarm->time.tm_min, 373 alarm->time.tm_sec); 374 } 375 376 return err; 377 } 378 379 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 380 { 381 int err; 382 383 err = mutex_lock_interruptible(&rtc->ops_lock); 384 if (err) 385 return err; 386 if (rtc->ops == NULL) 387 err = -ENODEV; 388 else if (!rtc->ops->read_alarm) 389 err = -EINVAL; 390 else { 391 memset(alarm, 0, sizeof(struct rtc_wkalrm)); 392 alarm->enabled = rtc->aie_timer.enabled; 393 alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires); 394 } 395 mutex_unlock(&rtc->ops_lock); 396 397 trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err); 398 return err; 399 } 400 EXPORT_SYMBOL_GPL(rtc_read_alarm); 401 402 static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 403 { 404 struct rtc_time tm; 405 time64_t now, scheduled; 406 int err; 407 408 err = rtc_valid_tm(&alarm->time); 409 if (err) 410 return err; 411 412 rtc_subtract_offset(rtc, &alarm->time); 413 scheduled = rtc_tm_to_time64(&alarm->time); 414 415 /* Make sure we're not setting alarms in the past */ 416 err = __rtc_read_time(rtc, &tm); 417 if (err) 418 return err; 419 now = rtc_tm_to_time64(&tm); 420 if (scheduled <= now) 421 return -ETIME; 422 /* 423 * XXX - We just checked to make sure the alarm time is not 424 * in the past, but there is still a race window where if 425 * the is alarm set for the next second and the second ticks 426 * over right here, before we set the alarm. 427 */ 428 429 if (!rtc->ops) 430 err = -ENODEV; 431 else if (!rtc->ops->set_alarm) 432 err = -EINVAL; 433 else 434 err = rtc->ops->set_alarm(rtc->dev.parent, alarm); 435 436 trace_rtc_set_alarm(rtc_tm_to_time64(&alarm->time), err); 437 return err; 438 } 439 440 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 441 { 442 int err; 443 444 if (!rtc->ops) 445 return -ENODEV; 446 else if (!rtc->ops->set_alarm) 447 return -EINVAL; 448 449 err = rtc_valid_tm(&alarm->time); 450 if (err != 0) 451 return err; 452 453 err = rtc_valid_range(rtc, &alarm->time); 454 if (err) 455 return err; 456 457 err = mutex_lock_interruptible(&rtc->ops_lock); 458 if (err) 459 return err; 460 if (rtc->aie_timer.enabled) 461 rtc_timer_remove(rtc, &rtc->aie_timer); 462 463 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 464 rtc->aie_timer.period = 0; 465 if (alarm->enabled) 466 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 467 468 mutex_unlock(&rtc->ops_lock); 469 470 rtc_add_offset(rtc, &alarm->time); 471 return err; 472 } 473 EXPORT_SYMBOL_GPL(rtc_set_alarm); 474 475 /* Called once per device from rtc_device_register */ 476 int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 477 { 478 int err; 479 struct rtc_time now; 480 481 err = rtc_valid_tm(&alarm->time); 482 if (err != 0) 483 return err; 484 485 err = rtc_read_time(rtc, &now); 486 if (err) 487 return err; 488 489 err = mutex_lock_interruptible(&rtc->ops_lock); 490 if (err) 491 return err; 492 493 rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time); 494 rtc->aie_timer.period = 0; 495 496 /* Alarm has to be enabled & in the future for us to enqueue it */ 497 if (alarm->enabled && (rtc_tm_to_ktime(now) < 498 rtc->aie_timer.node.expires)) { 499 500 rtc->aie_timer.enabled = 1; 501 timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node); 502 trace_rtc_timer_enqueue(&rtc->aie_timer); 503 } 504 mutex_unlock(&rtc->ops_lock); 505 return err; 506 } 507 EXPORT_SYMBOL_GPL(rtc_initialize_alarm); 508 509 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled) 510 { 511 int err = mutex_lock_interruptible(&rtc->ops_lock); 512 if (err) 513 return err; 514 515 if (rtc->aie_timer.enabled != enabled) { 516 if (enabled) 517 err = rtc_timer_enqueue(rtc, &rtc->aie_timer); 518 else 519 rtc_timer_remove(rtc, &rtc->aie_timer); 520 } 521 522 if (err) 523 /* nothing */; 524 else if (!rtc->ops) 525 err = -ENODEV; 526 else if (!rtc->ops->alarm_irq_enable) 527 err = -EINVAL; 528 else 529 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled); 530 531 mutex_unlock(&rtc->ops_lock); 532 533 trace_rtc_alarm_irq_enable(enabled, err); 534 return err; 535 } 536 EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable); 537 538 int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) 539 { 540 int err = mutex_lock_interruptible(&rtc->ops_lock); 541 if (err) 542 return err; 543 544 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 545 if (enabled == 0 && rtc->uie_irq_active) { 546 mutex_unlock(&rtc->ops_lock); 547 return rtc_dev_update_irq_enable_emul(rtc, 0); 548 } 549 #endif 550 /* make sure we're changing state */ 551 if (rtc->uie_rtctimer.enabled == enabled) 552 goto out; 553 554 if (rtc->uie_unsupported) { 555 err = -EINVAL; 556 goto out; 557 } 558 559 if (enabled) { 560 struct rtc_time tm; 561 ktime_t now, onesec; 562 563 __rtc_read_time(rtc, &tm); 564 onesec = ktime_set(1, 0); 565 now = rtc_tm_to_ktime(tm); 566 rtc->uie_rtctimer.node.expires = ktime_add(now, onesec); 567 rtc->uie_rtctimer.period = ktime_set(1, 0); 568 err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer); 569 } else 570 rtc_timer_remove(rtc, &rtc->uie_rtctimer); 571 572 out: 573 mutex_unlock(&rtc->ops_lock); 574 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 575 /* 576 * Enable emulation if the driver did not provide 577 * the update_irq_enable function pointer or if returned 578 * -EINVAL to signal that it has been configured without 579 * interrupts or that are not available at the moment. 580 */ 581 if (err == -EINVAL) 582 err = rtc_dev_update_irq_enable_emul(rtc, enabled); 583 #endif 584 return err; 585 586 } 587 EXPORT_SYMBOL_GPL(rtc_update_irq_enable); 588 589 590 /** 591 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook 592 * @rtc: pointer to the rtc device 593 * 594 * This function is called when an AIE, UIE or PIE mode interrupt 595 * has occurred (or been emulated). 596 * 597 * Triggers the registered irq_task function callback. 598 */ 599 void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode) 600 { 601 unsigned long flags; 602 603 /* mark one irq of the appropriate mode */ 604 spin_lock_irqsave(&rtc->irq_lock, flags); 605 rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode); 606 spin_unlock_irqrestore(&rtc->irq_lock, flags); 607 608 wake_up_interruptible(&rtc->irq_queue); 609 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); 610 } 611 612 613 /** 614 * rtc_aie_update_irq - AIE mode rtctimer hook 615 * @private: pointer to the rtc_device 616 * 617 * This functions is called when the aie_timer expires. 618 */ 619 void rtc_aie_update_irq(void *private) 620 { 621 struct rtc_device *rtc = (struct rtc_device *)private; 622 rtc_handle_legacy_irq(rtc, 1, RTC_AF); 623 } 624 625 626 /** 627 * rtc_uie_update_irq - UIE mode rtctimer hook 628 * @private: pointer to the rtc_device 629 * 630 * This functions is called when the uie_timer expires. 631 */ 632 void rtc_uie_update_irq(void *private) 633 { 634 struct rtc_device *rtc = (struct rtc_device *)private; 635 rtc_handle_legacy_irq(rtc, 1, RTC_UF); 636 } 637 638 639 /** 640 * rtc_pie_update_irq - PIE mode hrtimer hook 641 * @timer: pointer to the pie mode hrtimer 642 * 643 * This function is used to emulate PIE mode interrupts 644 * using an hrtimer. This function is called when the periodic 645 * hrtimer expires. 646 */ 647 enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer) 648 { 649 struct rtc_device *rtc; 650 ktime_t period; 651 int count; 652 rtc = container_of(timer, struct rtc_device, pie_timer); 653 654 period = NSEC_PER_SEC / rtc->irq_freq; 655 count = hrtimer_forward_now(timer, period); 656 657 rtc_handle_legacy_irq(rtc, count, RTC_PF); 658 659 return HRTIMER_RESTART; 660 } 661 662 /** 663 * rtc_update_irq - Triggered when a RTC interrupt occurs. 664 * @rtc: the rtc device 665 * @num: how many irqs are being reported (usually one) 666 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF 667 * Context: any 668 */ 669 void rtc_update_irq(struct rtc_device *rtc, 670 unsigned long num, unsigned long events) 671 { 672 if (IS_ERR_OR_NULL(rtc)) 673 return; 674 675 pm_stay_awake(rtc->dev.parent); 676 schedule_work(&rtc->irqwork); 677 } 678 EXPORT_SYMBOL_GPL(rtc_update_irq); 679 680 static int __rtc_match(struct device *dev, const void *data) 681 { 682 const char *name = data; 683 684 if (strcmp(dev_name(dev), name) == 0) 685 return 1; 686 return 0; 687 } 688 689 struct rtc_device *rtc_class_open(const char *name) 690 { 691 struct device *dev; 692 struct rtc_device *rtc = NULL; 693 694 dev = class_find_device(rtc_class, NULL, name, __rtc_match); 695 if (dev) 696 rtc = to_rtc_device(dev); 697 698 if (rtc) { 699 if (!try_module_get(rtc->owner)) { 700 put_device(dev); 701 rtc = NULL; 702 } 703 } 704 705 return rtc; 706 } 707 EXPORT_SYMBOL_GPL(rtc_class_open); 708 709 void rtc_class_close(struct rtc_device *rtc) 710 { 711 module_put(rtc->owner); 712 put_device(&rtc->dev); 713 } 714 EXPORT_SYMBOL_GPL(rtc_class_close); 715 716 static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled) 717 { 718 /* 719 * We always cancel the timer here first, because otherwise 720 * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK); 721 * when we manage to start the timer before the callback 722 * returns HRTIMER_RESTART. 723 * 724 * We cannot use hrtimer_cancel() here as a running callback 725 * could be blocked on rtc->irq_task_lock and hrtimer_cancel() 726 * would spin forever. 727 */ 728 if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0) 729 return -1; 730 731 if (enabled) { 732 ktime_t period = NSEC_PER_SEC / rtc->irq_freq; 733 734 hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL); 735 } 736 return 0; 737 } 738 739 /** 740 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs 741 * @rtc: the rtc device 742 * @task: currently registered with rtc_irq_register() 743 * @enabled: true to enable periodic IRQs 744 * Context: any 745 * 746 * Note that rtc_irq_set_freq() should previously have been used to 747 * specify the desired frequency of periodic IRQ. 748 */ 749 int rtc_irq_set_state(struct rtc_device *rtc, int enabled) 750 { 751 int err = 0; 752 753 while (rtc_update_hrtimer(rtc, enabled) < 0) 754 cpu_relax(); 755 756 rtc->pie_enabled = enabled; 757 758 trace_rtc_irq_set_state(enabled, err); 759 return err; 760 } 761 762 /** 763 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ 764 * @rtc: the rtc device 765 * @task: currently registered with rtc_irq_register() 766 * @freq: positive frequency 767 * Context: any 768 * 769 * Note that rtc_irq_set_state() is used to enable or disable the 770 * periodic IRQs. 771 */ 772 int rtc_irq_set_freq(struct rtc_device *rtc, int freq) 773 { 774 int err = 0; 775 776 if (freq <= 0 || freq > RTC_MAX_FREQ) 777 return -EINVAL; 778 779 rtc->irq_freq = freq; 780 while (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) 781 cpu_relax(); 782 783 trace_rtc_irq_set_freq(freq, err); 784 return err; 785 } 786 787 /** 788 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue 789 * @rtc rtc device 790 * @timer timer being added. 791 * 792 * Enqueues a timer onto the rtc devices timerqueue and sets 793 * the next alarm event appropriately. 794 * 795 * Sets the enabled bit on the added timer. 796 * 797 * Must hold ops_lock for proper serialization of timerqueue 798 */ 799 static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer) 800 { 801 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 802 struct rtc_time tm; 803 ktime_t now; 804 805 timer->enabled = 1; 806 __rtc_read_time(rtc, &tm); 807 now = rtc_tm_to_ktime(tm); 808 809 /* Skip over expired timers */ 810 while (next) { 811 if (next->expires >= now) 812 break; 813 next = timerqueue_iterate_next(next); 814 } 815 816 timerqueue_add(&rtc->timerqueue, &timer->node); 817 trace_rtc_timer_enqueue(timer); 818 if (!next || ktime_before(timer->node.expires, next->expires)) { 819 struct rtc_wkalrm alarm; 820 int err; 821 alarm.time = rtc_ktime_to_tm(timer->node.expires); 822 alarm.enabled = 1; 823 err = __rtc_set_alarm(rtc, &alarm); 824 if (err == -ETIME) { 825 pm_stay_awake(rtc->dev.parent); 826 schedule_work(&rtc->irqwork); 827 } else if (err) { 828 timerqueue_del(&rtc->timerqueue, &timer->node); 829 trace_rtc_timer_dequeue(timer); 830 timer->enabled = 0; 831 return err; 832 } 833 } 834 return 0; 835 } 836 837 static void rtc_alarm_disable(struct rtc_device *rtc) 838 { 839 if (!rtc->ops || !rtc->ops->alarm_irq_enable) 840 return; 841 842 rtc->ops->alarm_irq_enable(rtc->dev.parent, false); 843 trace_rtc_alarm_irq_enable(0, 0); 844 } 845 846 /** 847 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue 848 * @rtc rtc device 849 * @timer timer being removed. 850 * 851 * Removes a timer onto the rtc devices timerqueue and sets 852 * the next alarm event appropriately. 853 * 854 * Clears the enabled bit on the removed timer. 855 * 856 * Must hold ops_lock for proper serialization of timerqueue 857 */ 858 static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer) 859 { 860 struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue); 861 timerqueue_del(&rtc->timerqueue, &timer->node); 862 trace_rtc_timer_dequeue(timer); 863 timer->enabled = 0; 864 if (next == &timer->node) { 865 struct rtc_wkalrm alarm; 866 int err; 867 next = timerqueue_getnext(&rtc->timerqueue); 868 if (!next) { 869 rtc_alarm_disable(rtc); 870 return; 871 } 872 alarm.time = rtc_ktime_to_tm(next->expires); 873 alarm.enabled = 1; 874 err = __rtc_set_alarm(rtc, &alarm); 875 if (err == -ETIME) { 876 pm_stay_awake(rtc->dev.parent); 877 schedule_work(&rtc->irqwork); 878 } 879 } 880 } 881 882 /** 883 * rtc_timer_do_work - Expires rtc timers 884 * @rtc rtc device 885 * @timer timer being removed. 886 * 887 * Expires rtc timers. Reprograms next alarm event if needed. 888 * Called via worktask. 889 * 890 * Serializes access to timerqueue via ops_lock mutex 891 */ 892 void rtc_timer_do_work(struct work_struct *work) 893 { 894 struct rtc_timer *timer; 895 struct timerqueue_node *next; 896 ktime_t now; 897 struct rtc_time tm; 898 899 struct rtc_device *rtc = 900 container_of(work, struct rtc_device, irqwork); 901 902 mutex_lock(&rtc->ops_lock); 903 again: 904 __rtc_read_time(rtc, &tm); 905 now = rtc_tm_to_ktime(tm); 906 while ((next = timerqueue_getnext(&rtc->timerqueue))) { 907 if (next->expires > now) 908 break; 909 910 /* expire timer */ 911 timer = container_of(next, struct rtc_timer, node); 912 timerqueue_del(&rtc->timerqueue, &timer->node); 913 trace_rtc_timer_dequeue(timer); 914 timer->enabled = 0; 915 if (timer->task.func) 916 timer->task.func(timer->task.private_data); 917 918 trace_rtc_timer_fired(timer); 919 /* Re-add/fwd periodic timers */ 920 if (ktime_to_ns(timer->period)) { 921 timer->node.expires = ktime_add(timer->node.expires, 922 timer->period); 923 timer->enabled = 1; 924 timerqueue_add(&rtc->timerqueue, &timer->node); 925 trace_rtc_timer_enqueue(timer); 926 } 927 } 928 929 /* Set next alarm */ 930 if (next) { 931 struct rtc_wkalrm alarm; 932 int err; 933 int retry = 3; 934 935 alarm.time = rtc_ktime_to_tm(next->expires); 936 alarm.enabled = 1; 937 reprogram: 938 err = __rtc_set_alarm(rtc, &alarm); 939 if (err == -ETIME) 940 goto again; 941 else if (err) { 942 if (retry-- > 0) 943 goto reprogram; 944 945 timer = container_of(next, struct rtc_timer, node); 946 timerqueue_del(&rtc->timerqueue, &timer->node); 947 trace_rtc_timer_dequeue(timer); 948 timer->enabled = 0; 949 dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err); 950 goto again; 951 } 952 } else 953 rtc_alarm_disable(rtc); 954 955 pm_relax(rtc->dev.parent); 956 mutex_unlock(&rtc->ops_lock); 957 } 958 959 960 /* rtc_timer_init - Initializes an rtc_timer 961 * @timer: timer to be intiialized 962 * @f: function pointer to be called when timer fires 963 * @data: private data passed to function pointer 964 * 965 * Kernel interface to initializing an rtc_timer. 966 */ 967 void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data) 968 { 969 timerqueue_init(&timer->node); 970 timer->enabled = 0; 971 timer->task.func = f; 972 timer->task.private_data = data; 973 } 974 975 /* rtc_timer_start - Sets an rtc_timer to fire in the future 976 * @ rtc: rtc device to be used 977 * @ timer: timer being set 978 * @ expires: time at which to expire the timer 979 * @ period: period that the timer will recur 980 * 981 * Kernel interface to set an rtc_timer 982 */ 983 int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer, 984 ktime_t expires, ktime_t period) 985 { 986 int ret = 0; 987 mutex_lock(&rtc->ops_lock); 988 if (timer->enabled) 989 rtc_timer_remove(rtc, timer); 990 991 timer->node.expires = expires; 992 timer->period = period; 993 994 ret = rtc_timer_enqueue(rtc, timer); 995 996 mutex_unlock(&rtc->ops_lock); 997 return ret; 998 } 999 1000 /* rtc_timer_cancel - Stops an rtc_timer 1001 * @ rtc: rtc device to be used 1002 * @ timer: timer being set 1003 * 1004 * Kernel interface to cancel an rtc_timer 1005 */ 1006 void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer) 1007 { 1008 mutex_lock(&rtc->ops_lock); 1009 if (timer->enabled) 1010 rtc_timer_remove(rtc, timer); 1011 mutex_unlock(&rtc->ops_lock); 1012 } 1013 1014 /** 1015 * rtc_read_offset - Read the amount of rtc offset in parts per billion 1016 * @ rtc: rtc device to be used 1017 * @ offset: the offset in parts per billion 1018 * 1019 * see below for details. 1020 * 1021 * Kernel interface to read rtc clock offset 1022 * Returns 0 on success, or a negative number on error. 1023 * If read_offset() is not implemented for the rtc, return -EINVAL 1024 */ 1025 int rtc_read_offset(struct rtc_device *rtc, long *offset) 1026 { 1027 int ret; 1028 1029 if (!rtc->ops) 1030 return -ENODEV; 1031 1032 if (!rtc->ops->read_offset) 1033 return -EINVAL; 1034 1035 mutex_lock(&rtc->ops_lock); 1036 ret = rtc->ops->read_offset(rtc->dev.parent, offset); 1037 mutex_unlock(&rtc->ops_lock); 1038 1039 trace_rtc_read_offset(*offset, ret); 1040 return ret; 1041 } 1042 1043 /** 1044 * rtc_set_offset - Adjusts the duration of the average second 1045 * @ rtc: rtc device to be used 1046 * @ offset: the offset in parts per billion 1047 * 1048 * Some rtc's allow an adjustment to the average duration of a second 1049 * to compensate for differences in the actual clock rate due to temperature, 1050 * the crystal, capacitor, etc. 1051 * 1052 * The adjustment applied is as follows: 1053 * t = t0 * (1 + offset * 1e-9) 1054 * where t0 is the measured length of 1 RTC second with offset = 0 1055 * 1056 * Kernel interface to adjust an rtc clock offset. 1057 * Return 0 on success, or a negative number on error. 1058 * If the rtc offset is not setable (or not implemented), return -EINVAL 1059 */ 1060 int rtc_set_offset(struct rtc_device *rtc, long offset) 1061 { 1062 int ret; 1063 1064 if (!rtc->ops) 1065 return -ENODEV; 1066 1067 if (!rtc->ops->set_offset) 1068 return -EINVAL; 1069 1070 mutex_lock(&rtc->ops_lock); 1071 ret = rtc->ops->set_offset(rtc->dev.parent, offset); 1072 mutex_unlock(&rtc->ops_lock); 1073 1074 trace_rtc_set_offset(offset, ret); 1075 return ret; 1076 } 1077