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