interface.c 26.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * RTC subsystem, interface functions
 *
 * Copyright (C) 2005 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * based on arch/arm/common/rtctime.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
*/

#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 21 22
#define CREATE_TRACE_POINTS
#include <trace/events/rtc.h>

23 24 25
static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer);
static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer);

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
static void rtc_add_offset(struct rtc_device *rtc, struct rtc_time *tm)
{
	time64_t secs;

	if (!rtc->offset_secs)
		return;

	secs = rtc_tm_to_time64(tm);

	/*
	 * Since the reading time values from RTC device are always in the RTC
	 * original valid range, but we need to skip the overlapped region
	 * between expanded range and original range, which is no need to add
	 * the offset.
	 */
	if ((rtc->start_secs > rtc->range_min && secs >= rtc->start_secs) ||
	    (rtc->start_secs < rtc->range_min &&
	     secs <= (rtc->start_secs + rtc->range_max - rtc->range_min)))
		return;

	rtc_time64_to_tm(secs + rtc->offset_secs, tm);
}

static void rtc_subtract_offset(struct rtc_device *rtc, struct rtc_time *tm)
{
	time64_t secs;

	if (!rtc->offset_secs)
		return;

	secs = rtc_tm_to_time64(tm);

	/*
	 * If the setting time values are in the valid range of RTC hardware
	 * device, then no need to subtract the offset when setting time to RTC
	 * device. Otherwise we need to subtract the offset to make the time
	 * values are valid for RTC hardware device.
	 */
	if (secs >= rtc->range_min && secs <= rtc->range_max)
		return;

	rtc_time64_to_tm(secs - rtc->offset_secs, tm);
}

70 71 72 73
static int rtc_valid_range(struct rtc_device *rtc, struct rtc_time *tm)
{
	if (rtc->range_min != rtc->range_max) {
		time64_t time = rtc_tm_to_time64(tm);
74 75 76 77 78
		time64_t range_min = rtc->set_start_time ? rtc->start_secs :
			rtc->range_min;
		time64_t range_max = rtc->set_start_time ?
			(rtc->start_secs + rtc->range_max - rtc->range_min) :
			rtc->range_max;
79

80
		if (time < range_min || time > range_max)
81 82 83 84 85 86
			return -ERANGE;
	}

	return 0;
}

87
static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
88 89 90 91 92 93 94 95
{
	int err;
	if (!rtc->ops)
		err = -ENODEV;
	else if (!rtc->ops->read_time)
		err = -EINVAL;
	else {
		memset(tm, 0, sizeof(struct rtc_time));
96
		err = rtc->ops->read_time(rtc->dev.parent, tm);
97
		if (err < 0) {
98 99
			dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
				err);
100 101 102
			return err;
		}

103 104
		rtc_add_offset(rtc, tm);

105 106
		err = rtc_valid_tm(tm);
		if (err < 0)
107
			dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
108
	}
109 110 111 112 113 114
	return err;
}

int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
{
	int err;
115

116 117 118 119 120
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

	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 125 126 127
	return err;
}
EXPORT_SYMBOL_GPL(rtc_read_time);

128
int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
129 130 131 132 133 134 135
{
	int err;

	err = rtc_valid_tm(tm);
	if (err != 0)
		return err;

136 137 138
	err = rtc_valid_range(rtc, tm);
	if (err)
		return err;
Alexandre Belloni's avatar
Alexandre Belloni committed
139

140 141
	rtc_subtract_offset(rtc, tm);

142 143
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
144
		return err;
145 146 147

	if (!rtc->ops)
		err = -ENODEV;
148
	else if (rtc->ops->set_time)
149
		err = rtc->ops->set_time(rtc->dev.parent, tm);
150 151 152 153 154
	else if (rtc->ops->set_mmss64) {
		time64_t secs64 = rtc_tm_to_time64(tm);

		err = rtc->ops->set_mmss64(rtc->dev.parent, secs64);
	} else if (rtc->ops->set_mmss) {
155 156
		time64_t secs64 = rtc_tm_to_time64(tm);
		err = rtc->ops->set_mmss(rtc->dev.parent, secs64);
157 158
	} else
		err = -EINVAL;
159

160
	pm_stay_awake(rtc->dev.parent);
161
	mutex_unlock(&rtc->ops_lock);
162 163
	/* A timer might have just expired */
	schedule_work(&rtc->irqwork);
164 165

	trace_rtc_set_time(rtc_tm_to_time64(tm), err);
166 167 168 169
	return err;
}
EXPORT_SYMBOL_GPL(rtc_set_time);

170 171 172 173 174 175 176 177 178 179 180 181 182
static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
	int err;

	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

	if (rtc->ops == NULL)
		err = -ENODEV;
	else if (!rtc->ops->read_alarm)
		err = -EINVAL;
	else {
183 184 185 186 187 188 189 190 191 192 193
		alarm->enabled = 0;
		alarm->pending = 0;
		alarm->time.tm_sec = -1;
		alarm->time.tm_min = -1;
		alarm->time.tm_hour = -1;
		alarm->time.tm_mday = -1;
		alarm->time.tm_mon = -1;
		alarm->time.tm_year = -1;
		alarm->time.tm_wday = -1;
		alarm->time.tm_yday = -1;
		alarm->time.tm_isdst = -1;
194 195 196 197
		err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
	}

	mutex_unlock(&rtc->ops_lock);
198 199

	trace_rtc_read_alarm(rtc_tm_to_time64(&alarm->time), err);
200 201 202 203 204 205 206 207
	return err;
}

int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
	int err;
	struct rtc_time before, now;
	int first_time = 1;
208
	time64_t t_now, t_alm;
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
	enum { none, day, month, year } missing = none;
	unsigned days;

	/* The lower level RTC driver may return -1 in some fields,
	 * creating invalid alarm->time values, for reasons like:
	 *
	 *   - The hardware may not be capable of filling them in;
	 *     many alarms match only on time-of-day fields, not
	 *     day/month/year calendar data.
	 *
	 *   - Some hardware uses illegal values as "wildcard" match
	 *     values, which non-Linux firmware (like a BIOS) may try
	 *     to set up as e.g. "alarm 15 minutes after each hour".
	 *     Linux uses only oneshot alarms.
	 *
	 * When we see that here, we deal with it by using values from
	 * a current RTC timestamp for any missing (-1) values.  The
	 * RTC driver prevents "periodic alarm" modes.
	 *
	 * But this can be racey, because some fields of the RTC timestamp
	 * may have wrapped in the interval since we read the RTC alarm,
	 * which would lead to us inserting inconsistent values in place
	 * of the -1 fields.
	 *
	 * Reading the alarm and timestamp in the reverse sequence
	 * would have the same race condition, and not solve the issue.
	 *
	 * So, we must first read the RTC timestamp,
	 * then read the RTC alarm value,
	 * and then read a second RTC timestamp.
	 *
	 * If any fields of the second timestamp have changed
	 * when compared with the first timestamp, then we know
	 * our timestamp may be inconsistent with that used by
	 * the low-level rtc_read_alarm_internal() function.
	 *
	 * So, when the two timestamps disagree, we just loop and do
	 * the process again to get a fully consistent set of values.
	 *
	 * This could all instead be done in the lower level driver,
	 * but since more than one lower level RTC implementation needs it,
	 * then it's probably best best to do it here instead of there..
	 */

	/* Get the "before" timestamp */
	err = rtc_read_time(rtc, &before);
	if (err < 0)
		return err;
	do {
		if (!first_time)
			memcpy(&before, &now, sizeof(struct rtc_time));
		first_time = 0;

		/* get the RTC alarm values, which may be incomplete */
		err = rtc_read_alarm_internal(rtc, alarm);
		if (err)
			return err;

		/* full-function RTCs won't have such missing fields */
268 269
		if (rtc_valid_tm(&alarm->time) == 0) {
			rtc_add_offset(rtc, &alarm->time);
270
			return 0;
271
		}
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294

		/* get the "after" timestamp, to detect wrapped fields */
		err = rtc_read_time(rtc, &now);
		if (err < 0)
			return err;

		/* note that tm_sec is a "don't care" value here: */
	} while (   before.tm_min   != now.tm_min
		 || before.tm_hour  != now.tm_hour
		 || before.tm_mon   != now.tm_mon
		 || before.tm_year  != now.tm_year);

	/* Fill in the missing alarm fields using the timestamp; we
	 * know there's at least one since alarm->time is invalid.
	 */
	if (alarm->time.tm_sec == -1)
		alarm->time.tm_sec = now.tm_sec;
	if (alarm->time.tm_min == -1)
		alarm->time.tm_min = now.tm_min;
	if (alarm->time.tm_hour == -1)
		alarm->time.tm_hour = now.tm_hour;

	/* For simplicity, only support date rollover for now */
295
	if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {
296 297 298
		alarm->time.tm_mday = now.tm_mday;
		missing = day;
	}
299
	if ((unsigned)alarm->time.tm_mon >= 12) {
300 301 302 303 304 305 306 307 308 309
		alarm->time.tm_mon = now.tm_mon;
		if (missing == none)
			missing = month;
	}
	if (alarm->time.tm_year == -1) {
		alarm->time.tm_year = now.tm_year;
		if (missing == none)
			missing = year;
	}

310 311 312 313 314 315 316
	/* Can't proceed if alarm is still invalid after replacing
	 * missing fields.
	 */
	err = rtc_valid_tm(&alarm->time);
	if (err)
		goto done;

317
	/* with luck, no rollover is needed */
318 319
	t_now = rtc_tm_to_time64(&now);
	t_alm = rtc_tm_to_time64(&alarm->time);
320 321 322 323 324 325 326 327 328 329 330 331 332
	if (t_now < t_alm)
		goto done;

	switch (missing) {

	/* 24 hour rollover ... if it's now 10am Monday, an alarm that
	 * that will trigger at 5am will do so at 5am Tuesday, which
	 * could also be in the next month or year.  This is a common
	 * case, especially for PCs.
	 */
	case day:
		dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day");
		t_alm += 24 * 60 * 60;
333
		rtc_time64_to_tm(t_alm, &alarm->time);
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
		break;

	/* Month rollover ... if it's the 31th, an alarm on the 3rd will
	 * be next month.  An alarm matching on the 30th, 29th, or 28th
	 * may end up in the month after that!  Many newer PCs support
	 * this type of alarm.
	 */
	case month:
		dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month");
		do {
			if (alarm->time.tm_mon < 11)
				alarm->time.tm_mon++;
			else {
				alarm->time.tm_mon = 0;
				alarm->time.tm_year++;
			}
			days = rtc_month_days(alarm->time.tm_mon,
					alarm->time.tm_year);
		} while (days < alarm->time.tm_mday);
		break;

	/* Year rollover ... easy except for leap years! */
	case year:
		dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
		do {
			alarm->time.tm_year++;
360 361
		} while (!is_leap_year(alarm->time.tm_year + 1900)
			&& rtc_valid_tm(&alarm->time) != 0);
362 363 364 365 366 367
		break;

	default:
		dev_warn(&rtc->dev, "alarm rollover not handled\n");
	}

368 369
	err = rtc_valid_tm(&alarm->time);

370
done:
371 372 373 374 375 376 377 378
	if (err) {
		dev_warn(&rtc->dev, "invalid alarm value: %d-%d-%d %d:%d:%d\n",
			alarm->time.tm_year + 1900, alarm->time.tm_mon + 1,
			alarm->time.tm_mday, alarm->time.tm_hour, alarm->time.tm_min,
			alarm->time.tm_sec);
	}

	return err;
379 380
}

381
int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
382 383 384 385 386
{
	int err;

	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
387
		return err;
388 389 390 391 392 393 394
	if (rtc->ops == NULL)
		err = -ENODEV;
	else if (!rtc->ops->read_alarm)
		err = -EINVAL;
	else {
		memset(alarm, 0, sizeof(struct rtc_wkalrm));
		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 409
	int err;

410 411
	err = rtc_valid_tm(&alarm->time);
	if (err)
412
		return err;
413

414
	scheduled = rtc_tm_to_time64(&alarm->time);
415

416 417
	/* Make sure we're not setting alarms in the past */
	err = __rtc_read_time(rtc, &tm);
418 419
	if (err)
		return err;
420
	now = rtc_tm_to_time64(&tm);
421 422 423 424 425 426 427
	if (scheduled <= now)
		return -ETIME;
	/*
	 * XXX - We just checked to make sure the alarm time is not
	 * in the past, but there is still a race window where if
	 * the is alarm set for the next second and the second ticks
	 * over right here, before we set the alarm.
428 429
	 */

430 431
	rtc_subtract_offset(rtc, &alarm->time);

432 433 434 435 436 437 438
	if (!rtc->ops)
		err = -ENODEV;
	else if (!rtc->ops->set_alarm)
		err = -EINVAL;
	else
		err = rtc->ops->set_alarm(rtc->dev.parent, alarm);

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 446
{
	int err;

447 448 449 450 451
	if (!rtc->ops)
		return -ENODEV;
	else if (!rtc->ops->set_alarm)
		return -EINVAL;

452 453 454 455
	err = rtc_valid_tm(&alarm->time);
	if (err != 0)
		return err;

456 457 458
	err = rtc_valid_range(rtc, &alarm->time);
	if (err)
		return err;
Alexandre Belloni's avatar
Alexandre Belloni committed
459

460 461
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
462
		return err;
463
	if (rtc->aie_timer.enabled)
Thomas Gleixner's avatar
Thomas Gleixner committed
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 476
}
EXPORT_SYMBOL_GPL(rtc_set_alarm);

477 478 479 480
/* Called once per device from rtc_device_register */
int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
	int err;
481
	struct rtc_time now;
482 483 484 485 486

	err = rtc_valid_tm(&alarm->time);
	if (err != 0)
		return err;

487 488 489 490
	err = rtc_read_time(rtc, &now);
	if (err)
		return err;

491 492 493 494 495
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

	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 500
	if (alarm->enabled && (rtc_tm_to_ktime(now) <
			 rtc->aie_timer.node.expires)) {
501

502 503
		rtc->aie_timer.enabled = 1;
		timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
504
		trace_rtc_timer_enqueue(&rtc->aie_timer);
505 506 507 508 509 510
	}
	mutex_unlock(&rtc->ops_lock);
	return err;
}
EXPORT_SYMBOL_GPL(rtc_initialize_alarm);

511 512 513 514 515 516
int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{
	int err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

517
	if (rtc->aie_timer.enabled != enabled) {
518 519 520
		if (enabled)
			err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
		else
Thomas Gleixner's avatar
Thomas Gleixner committed
521
			rtc_timer_remove(rtc, &rtc->aie_timer);
522 523
	}

524
	if (err)
525 526
		/* nothing */;
	else if (!rtc->ops)
527 528 529 530 531 532 533
		err = -ENODEV;
	else if (!rtc->ops->alarm_irq_enable)
		err = -EINVAL;
	else
		err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);

	mutex_unlock(&rtc->ops_lock);
534 535

	trace_rtc_alarm_irq_enable(enabled, err);
536 537 538 539 540 541 542 543 544 545
	return err;
}
EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);

int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{
	int err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

546 547 548 549 550 551
#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
	if (enabled == 0 && rtc->uie_irq_active) {
		mutex_unlock(&rtc->ops_lock);
		return rtc_dev_update_irq_enable_emul(rtc, 0);
	}
#endif
552 553 554 555
	/* make sure we're changing state */
	if (rtc->uie_rtctimer.enabled == enabled)
		goto out;

556 557 558 559 560
	if (rtc->uie_unsupported) {
		err = -EINVAL;
		goto out;
	}

561 562 563 564 565 566 567 568 569
	if (enabled) {
		struct rtc_time tm;
		ktime_t now, onesec;

		__rtc_read_time(rtc, &tm);
		onesec = ktime_set(1, 0);
		now = rtc_tm_to_ktime(tm);
		rtc->uie_rtctimer.node.expires = ktime_add(now, onesec);
		rtc->uie_rtctimer.period = ktime_set(1, 0);
570 571
		err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
	} else
Thomas Gleixner's avatar
Thomas Gleixner committed
572
		rtc_timer_remove(rtc, &rtc->uie_rtctimer);
573

574
out:
575
	mutex_unlock(&rtc->ops_lock);
576 577 578 579 580 581 582 583 584 585
#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
	/*
	 * Enable emulation if the driver did not provide
	 * the update_irq_enable function pointer or if returned
	 * -EINVAL to signal that it has been configured without
	 * interrupts or that are not available at the moment.
	 */
	if (err == -EINVAL)
		err = rtc_dev_update_irq_enable_emul(rtc, enabled);
#endif
586
	return err;
587

588 589 590
}
EXPORT_SYMBOL_GPL(rtc_update_irq_enable);

591

592
/**
593 594 595 596
 * rtc_handle_legacy_irq - AIE, UIE and PIE event hook
 * @rtc: pointer to the rtc device
 *
 * This function is called when an AIE, UIE or PIE mode interrupt
597
 * has occurred (or been emulated).
598
 *
599
 */
600
void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
601
{
602 603
	unsigned long flags;

604
	/* mark one irq of the appropriate mode */
605
	spin_lock_irqsave(&rtc->irq_lock, flags);
606
	rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
607
	spin_unlock_irqrestore(&rtc->irq_lock, flags);
608 609 610 611

	wake_up_interruptible(&rtc->irq_queue);
	kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
}
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654


/**
 * rtc_aie_update_irq - AIE mode rtctimer hook
 * @private: pointer to the rtc_device
 *
 * This functions is called when the aie_timer expires.
 */
void rtc_aie_update_irq(void *private)
{
	struct rtc_device *rtc = (struct rtc_device *)private;
	rtc_handle_legacy_irq(rtc, 1, RTC_AF);
}


/**
 * rtc_uie_update_irq - UIE mode rtctimer hook
 * @private: pointer to the rtc_device
 *
 * This functions is called when the uie_timer expires.
 */
void rtc_uie_update_irq(void *private)
{
	struct rtc_device *rtc = (struct rtc_device *)private;
	rtc_handle_legacy_irq(rtc, 1,  RTC_UF);
}


/**
 * rtc_pie_update_irq - PIE mode hrtimer hook
 * @timer: pointer to the pie mode hrtimer
 *
 * This function is used to emulate PIE mode interrupts
 * using an hrtimer. This function is called when the periodic
 * hrtimer expires.
 */
enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer)
{
	struct rtc_device *rtc;
	ktime_t period;
	int count;
	rtc = container_of(timer, struct rtc_device, pie_timer);

655
	period = NSEC_PER_SEC / rtc->irq_freq;
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
	count = hrtimer_forward_now(timer, period);

	rtc_handle_legacy_irq(rtc, count, RTC_PF);

	return HRTIMER_RESTART;
}

/**
 * rtc_update_irq - Triggered when a RTC interrupt occurs.
 * @rtc: the rtc device
 * @num: how many irqs are being reported (usually one)
 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
 * Context: any
 */
void rtc_update_irq(struct rtc_device *rtc,
		unsigned long num, unsigned long events)
{
673
	if (IS_ERR_OR_NULL(rtc))
674 675
		return;

676
	pm_stay_awake(rtc->dev.parent);
677 678
	schedule_work(&rtc->irqwork);
}
679 680
EXPORT_SYMBOL_GPL(rtc_update_irq);

681
static int __rtc_match(struct device *dev, const void *data)
682
{
683
	const char *name = data;
684

685
	if (strcmp(dev_name(dev), name) == 0)
686 687 688 689
		return 1;
	return 0;
}

690
struct rtc_device *rtc_class_open(const char *name)
691
{
692
	struct device *dev;
693
	struct rtc_device *rtc = NULL;
694

695
	dev = class_find_device(rtc_class, NULL, name, __rtc_match);
696 697
	if (dev)
		rtc = to_rtc_device(dev);
698

699 700
	if (rtc) {
		if (!try_module_get(rtc->owner)) {
701
			put_device(dev);
702 703
			rtc = NULL;
		}
704 705
	}

706
	return rtc;
707 708 709
}
EXPORT_SYMBOL_GPL(rtc_class_open);

710
void rtc_class_close(struct rtc_device *rtc)
711
{
712
	module_put(rtc->owner);
713
	put_device(&rtc->dev);
714 715 716
}
EXPORT_SYMBOL_GPL(rtc_class_close);

717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
{
	/*
	 * We always cancel the timer here first, because otherwise
	 * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
	 * when we manage to start the timer before the callback
	 * returns HRTIMER_RESTART.
	 *
	 * We cannot use hrtimer_cancel() here as a running callback
	 * could be blocked on rtc->irq_task_lock and hrtimer_cancel()
	 * would spin forever.
	 */
	if (hrtimer_try_to_cancel(&rtc->pie_timer) < 0)
		return -1;

	if (enabled) {
733
		ktime_t period = NSEC_PER_SEC / rtc->irq_freq;
734 735 736 737 738 739

		hrtimer_start(&rtc->pie_timer, period, HRTIMER_MODE_REL);
	}
	return 0;
}

740 741 742 743 744 745 746
/**
 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
 * @rtc: the rtc device
 * @enabled: true to enable periodic IRQs
 * Context: any
 *
 * 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 752
{
	int err = 0;

753 754 755 756
	while (rtc_update_hrtimer(rtc, enabled) < 0)
		cpu_relax();

	rtc->pie_enabled = enabled;
757 758

	trace_rtc_irq_set_state(enabled, err);
759 760 761
	return err;
}

762 763 764
/**
 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
 * @rtc: the rtc device
765
 * @freq: positive frequency
766 767 768 769 770
 * Context: any
 *
 * Note that rtc_irq_set_state() is used to enable or disable the
 * periodic IRQs.
 */
771
int rtc_irq_set_freq(struct rtc_device *rtc, int freq)
772
{
773
	int err = 0;
774

775
	if (freq <= 0 || freq > RTC_MAX_FREQ)
776
		return -EINVAL;
777 778 779 780

	rtc->irq_freq = freq;
	while (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0)
		cpu_relax();
781 782

	trace_rtc_irq_set_freq(freq, err);
783 784
	return err;
}
785 786

/**
Thomas Gleixner's avatar
Thomas Gleixner committed
787
 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
788 789 790 791 792 793
 * @rtc rtc device
 * @timer timer being added.
 *
 * Enqueues a timer onto the rtc devices timerqueue and sets
 * 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
static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
799
{
800 801 802 803
	struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
	struct rtc_time tm;
	ktime_t now;

804
	timer->enabled = 1;
805 806 807 808 809
	__rtc_read_time(rtc, &tm);
	now = rtc_tm_to_ktime(tm);

	/* Skip over expired timers */
	while (next) {
810
		if (next->expires >= now)
811 812 813 814
			break;
		next = timerqueue_iterate_next(next);
	}

815
	timerqueue_add(&rtc->timerqueue, &timer->node);
816
	trace_rtc_timer_enqueue(timer);
817
	if (!next || ktime_before(timer->node.expires, next->expires)) {
818 819 820 821 822
		struct rtc_wkalrm alarm;
		int err;
		alarm.time = rtc_ktime_to_tm(timer->node.expires);
		alarm.enabled = 1;
		err = __rtc_set_alarm(rtc, &alarm);
823 824
		if (err == -ETIME) {
			pm_stay_awake(rtc->dev.parent);
825
			schedule_work(&rtc->irqwork);
826
		} else if (err) {
827
			timerqueue_del(&rtc->timerqueue, &timer->node);
828
			trace_rtc_timer_dequeue(timer);
829 830 831
			timer->enabled = 0;
			return err;
		}
832
	}
833
	return 0;
834 835
}

836 837 838 839 840 841
static void rtc_alarm_disable(struct rtc_device *rtc)
{
	if (!rtc->ops || !rtc->ops->alarm_irq_enable)
		return;

	rtc->ops->alarm_irq_enable(rtc->dev.parent, false);
842
	trace_rtc_alarm_irq_enable(0, 0);
843 844
}

845
/**
Thomas Gleixner's avatar
Thomas Gleixner committed
846
 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
847 848 849 850 851 852
 * @rtc rtc device
 * @timer timer being removed.
 *
 * Removes a timer onto the rtc devices timerqueue and sets
 * 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
static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
858 859 860
{
	struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
	timerqueue_del(&rtc->timerqueue, &timer->node);
861
	trace_rtc_timer_dequeue(timer);
862
	timer->enabled = 0;
863 864 865 866
	if (next == &timer->node) {
		struct rtc_wkalrm alarm;
		int err;
		next = timerqueue_getnext(&rtc->timerqueue);
867 868
		if (!next) {
			rtc_alarm_disable(rtc);
869
			return;
870
		}
871 872 873
		alarm.time = rtc_ktime_to_tm(next->expires);
		alarm.enabled = 1;
		err = __rtc_set_alarm(rtc, &alarm);
874 875
		if (err == -ETIME) {
			pm_stay_awake(rtc->dev.parent);
876
			schedule_work(&rtc->irqwork);
877
		}
878 879 880 881
	}
}

/**
Thomas Gleixner's avatar
Thomas Gleixner committed
882
 * rtc_timer_do_work - Expires rtc timers
883 884 885 886 887 888 889 890
 * @rtc rtc device
 * @timer timer being removed.
 *
 * Expires rtc timers. Reprograms next alarm event if needed.
 * Called via worktask.
 *
 * Serializes access to timerqueue via ops_lock mutex
 */
Thomas Gleixner's avatar
Thomas Gleixner committed
891
void rtc_timer_do_work(struct work_struct *work)
892 893 894 895 896 897 898 899 900 901 902 903 904 905
{
	struct rtc_timer *timer;
	struct timerqueue_node *next;
	ktime_t now;
	struct rtc_time tm;

	struct rtc_device *rtc =
		container_of(work, struct rtc_device, irqwork);

	mutex_lock(&rtc->ops_lock);
again:
	__rtc_read_time(rtc, &tm);
	now = rtc_tm_to_ktime(tm);
	while ((next = timerqueue_getnext(&rtc->timerqueue))) {
906
		if (next->expires > now)
907 908 909 910 911
			break;

		/* expire timer */
		timer = container_of(next, struct rtc_timer, node);
		timerqueue_del(&rtc->timerqueue, &timer->node);
912
		trace_rtc_timer_dequeue(timer);
913
		timer->enabled = 0;
914 915
		if (timer->func)
			timer->func(timer->private_data);
916

917
		trace_rtc_timer_fired(timer);
918 919 920 921 922 923
		/* Re-add/fwd periodic timers */
		if (ktime_to_ns(timer->period)) {
			timer->node.expires = ktime_add(timer->node.expires,
							timer->period);
			timer->enabled = 1;
			timerqueue_add(&rtc->timerqueue, &timer->node);
924
			trace_rtc_timer_enqueue(timer);
925 926 927 928 929 930 931
		}
	}

	/* Set next alarm */
	if (next) {
		struct rtc_wkalrm alarm;
		int err;
932 933
		int retry = 3;

934 935
		alarm.time = rtc_ktime_to_tm(next->expires);
		alarm.enabled = 1;
936
reprogram:
937 938 939
		err = __rtc_set_alarm(rtc, &alarm);
		if (err == -ETIME)
			goto again;
940 941 942 943 944 945
		else if (err) {
			if (retry-- > 0)
				goto reprogram;

			timer = container_of(next, struct rtc_timer, node);
			timerqueue_del(&rtc->timerqueue, &timer->node);
946
			trace_rtc_timer_dequeue(timer);
947 948 949 950
			timer->enabled = 0;
			dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
			goto again;
		}
951 952
	} else
		rtc_alarm_disable(rtc);
953

954
	pm_relax(rtc->dev.parent);
955 956 957 958
	mutex_unlock(&rtc->ops_lock);
}


Thomas Gleixner's avatar
Thomas Gleixner committed
959
/* rtc_timer_init - Initializes an rtc_timer
960 961 962 963 964 965
 * @timer: timer to be intiialized
 * @f: function pointer to be called when timer fires
 * @data: private data passed to function pointer
 *
 * Kernel interface to initializing an rtc_timer.
 */
966
void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data)
967 968 969
{
	timerqueue_init(&timer->node);
	timer->enabled = 0;
970 971
	timer->func = f;
	timer->private_data = data;
972 973
}

Thomas Gleixner's avatar
Thomas Gleixner committed
974
/* rtc_timer_start - Sets an rtc_timer to fire in the future
975 976 977 978 979 980 981
 * @ rtc: rtc device to be used
 * @ timer: timer being set
 * @ expires: time at which to expire the timer
 * @ period: period that the timer will recur
 *
 * Kernel interface to set an rtc_timer
 */
982
int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
983 984 985 986 987
			ktime_t expires, ktime_t period)
{
	int ret = 0;
	mutex_lock(&rtc->ops_lock);
	if (timer->enabled)
Thomas Gleixner's avatar
Thomas Gleixner committed
988
		rtc_timer_remove(rtc, timer);
989 990 991 992

	timer->node.expires = expires;
	timer->period = period;

993
	ret = rtc_timer_enqueue(rtc, timer);
994 995 996 997 998

	mutex_unlock(&rtc->ops_lock);
	return ret;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
999
/* rtc_timer_cancel - Stops an rtc_timer
1000 1001 1002 1003 1004
 * @ rtc: rtc device to be used
 * @ timer: timer being set
 *
 * Kernel interface to cancel an rtc_timer
 */
1005
void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
1006 1007 1008
{
	mutex_lock(&rtc->ops_lock);
	if (timer->enabled)
Thomas Gleixner's avatar
Thomas Gleixner committed
1009
		rtc_timer_remove(rtc, timer);
1010 1011 1012
	mutex_unlock(&rtc->ops_lock);
}

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
/**
 * rtc_read_offset - Read the amount of rtc offset in parts per billion
 * @ rtc: rtc device to be used
 * @ offset: the offset in parts per billion
 *
 * see below for details.
 *
 * Kernel interface to read rtc clock offset
 * Returns 0 on success, or a negative number on error.
 * If read_offset() is not implemented for the rtc, return -EINVAL
 */
int rtc_read_offset(struct rtc_device *rtc, long *offset)
{
	int ret;

	if (!rtc->ops)
		return -ENODEV;

	if (!rtc->ops->read_offset)
		return -EINVAL;

	mutex_lock(&rtc->ops_lock);
	ret = rtc->ops->read_offset(rtc->dev.parent, offset);
	mutex_unlock(&rtc->ops_lock);
1037 1038

	trace_rtc_read_offset(*offset, ret);
1039 1040
	return ret;
}
1041

1042 1043 1044 1045 1046 1047 1048 1049 1050
/**
 * rtc_set_offset - Adjusts the duration of the average second
 * @ rtc: rtc device to be used
 * @ offset: the offset in parts per billion
 *
 * Some rtc's allow an adjustment to the average duration of a second
 * to compensate for differences in the actual clock rate due to temperature,
 * the crystal, capacitor, etc.
 *
1051 1052 1053 1054
 * The adjustment applied is as follows:
 *   t = t0 * (1 + offset * 1e-9)
 * where t0 is the measured length of 1 RTC second with offset = 0
 *
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
 * Kernel interface to adjust an rtc clock offset.
 * Return 0 on success, or a negative number on error.
 * If the rtc offset is not setable (or not implemented), return -EINVAL
 */
int rtc_set_offset(struct rtc_device *rtc, long offset)
{
	int ret;

	if (!rtc->ops)
		return -ENODEV;

	if (!rtc->ops->set_offset)
		return -EINVAL;

	mutex_lock(&rtc->ops_lock);
	ret = rtc->ops->set_offset(rtc->dev.parent, offset);
	mutex_unlock(&rtc->ops_lock);
1072 1073

	trace_rtc_set_offset(offset, ret);
1074 1075
	return ret;
}