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