interface.c 25.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
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);

23
static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
24 25 26 27 28 29 30 31
{
	int err;
	if (!rtc->ops)
		err = -ENODEV;
	else if (!rtc->ops->read_time)
		err = -EINVAL;
	else {
		memset(tm, 0, sizeof(struct rtc_time));
32
		err = rtc->ops->read_time(rtc->dev.parent, tm);
33
		if (err < 0) {
34 35
			dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
				err);
36 37 38 39 40
			return err;
		}

		err = rtc_valid_tm(tm);
		if (err < 0)
41
			dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
42
	}
43 44 45 46 47 48
	return err;
}

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

50 51 52 53 54
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

	err = __rtc_read_time(rtc, tm);
55 56 57 58 59
	mutex_unlock(&rtc->ops_lock);
	return err;
}
EXPORT_SYMBOL_GPL(rtc_read_time);

60
int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
61 62 63 64 65 66 67 68 69
{
	int err;

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

	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
70
		return err;
71 72 73

	if (!rtc->ops)
		err = -ENODEV;
74
	else if (rtc->ops->set_time)
75
		err = rtc->ops->set_time(rtc->dev.parent, tm);
76 77 78 79 80
	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) {
81 82
		time64_t secs64 = rtc_tm_to_time64(tm);
		err = rtc->ops->set_mmss(rtc->dev.parent, secs64);
83 84
	} else
		err = -EINVAL;
85

86
	pm_stay_awake(rtc->dev.parent);
87
	mutex_unlock(&rtc->ops_lock);
88 89
	/* A timer might have just expired */
	schedule_work(&rtc->irqwork);
90 91 92 93
	return err;
}
EXPORT_SYMBOL_GPL(rtc_set_time);

94 95 96 97 98 99 100 101 102 103 104 105 106
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 {
107 108 109 110 111 112 113 114 115 116 117
		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;
118 119 120 121 122 123 124 125 126 127 128 129
		err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
	}

	mutex_unlock(&rtc->ops_lock);
	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;
130
	time64_t t_now, t_alm;
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
	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 */
		if (rtc_valid_tm(&alarm->time) == 0)
			return 0;

		/* 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 */
215
	if (alarm->time.tm_mday < 1 || alarm->time.tm_mday > 31) {
216 217 218
		alarm->time.tm_mday = now.tm_mday;
		missing = day;
	}
219
	if ((unsigned)alarm->time.tm_mon >= 12) {
220 221 222 223 224 225 226 227 228 229
		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;
	}

230 231 232 233 234 235 236
	/* Can't proceed if alarm is still invalid after replacing
	 * missing fields.
	 */
	err = rtc_valid_tm(&alarm->time);
	if (err)
		goto done;

237
	/* with luck, no rollover is needed */
238 239
	t_now = rtc_tm_to_time64(&now);
	t_alm = rtc_tm_to_time64(&alarm->time);
240 241 242 243 244 245 246 247 248 249 250 251 252
	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;
253
		rtc_time64_to_tm(t_alm, &alarm->time);
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
		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++;
280 281
		} while (!is_leap_year(alarm->time.tm_year + 1900)
			&& rtc_valid_tm(&alarm->time) != 0);
282 283 284 285 286 287
		break;

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

288 289
	err = rtc_valid_tm(&alarm->time);

290
done:
291 292 293 294 295 296 297 298
	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;
299 300
}

301
int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
302 303 304 305 306
{
	int err;

	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
307
		return err;
308 309 310 311 312 313 314
	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;
315
		alarm->time = rtc_ktime_to_tm(rtc->aie_timer.node.expires);
316
	}
317
	mutex_unlock(&rtc->ops_lock);
318

319
	return err;
320
}
321
EXPORT_SYMBOL_GPL(rtc_read_alarm);
322

323
static int __rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
324
{
325
	struct rtc_time tm;
326
	time64_t now, scheduled;
327 328
	int err;

329 330
	err = rtc_valid_tm(&alarm->time);
	if (err)
331
		return err;
332
	scheduled = rtc_tm_to_time64(&alarm->time);
333

334 335
	/* Make sure we're not setting alarms in the past */
	err = __rtc_read_time(rtc, &tm);
336 337
	if (err)
		return err;
338
	now = rtc_tm_to_time64(&tm);
339 340 341 342 343 344 345
	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.
346 347
	 */

348 349 350 351 352 353 354 355
	if (!rtc->ops)
		err = -ENODEV;
	else if (!rtc->ops->set_alarm)
		err = -EINVAL;
	else
		err = rtc->ops->set_alarm(rtc->dev.parent, alarm);

	return err;
356
}
357

358
int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
359 360 361
{
	int err;

362 363 364 365
	err = rtc_valid_tm(&alarm->time);
	if (err != 0)
		return err;

366 367
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
368
		return err;
369
	if (rtc->aie_timer.enabled)
Thomas Gleixner's avatar
Thomas Gleixner committed
370
		rtc_timer_remove(rtc, &rtc->aie_timer);
371

372
	rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
373
	rtc->aie_timer.period = 0;
374
	if (alarm->enabled)
375
		err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
376

377
	mutex_unlock(&rtc->ops_lock);
378
	return err;
379 380 381
}
EXPORT_SYMBOL_GPL(rtc_set_alarm);

382 383 384 385
/* Called once per device from rtc_device_register */
int rtc_initialize_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
	int err;
386
	struct rtc_time now;
387 388 389 390 391

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

392 393 394 395
	err = rtc_read_time(rtc, &now);
	if (err)
		return err;

396 397 398 399 400
	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

	rtc->aie_timer.node.expires = rtc_tm_to_ktime(alarm->time);
401
	rtc->aie_timer.period = 0;
402

403
	/* Alarm has to be enabled & in the future for us to enqueue it */
404 405
	if (alarm->enabled && (rtc_tm_to_ktime(now) <
			 rtc->aie_timer.node.expires)) {
406

407 408 409 410 411 412 413 414
		rtc->aie_timer.enabled = 1;
		timerqueue_add(&rtc->timerqueue, &rtc->aie_timer.node);
	}
	mutex_unlock(&rtc->ops_lock);
	return err;
}
EXPORT_SYMBOL_GPL(rtc_initialize_alarm);

415 416 417 418 419 420
int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{
	int err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

421
	if (rtc->aie_timer.enabled != enabled) {
422 423 424
		if (enabled)
			err = rtc_timer_enqueue(rtc, &rtc->aie_timer);
		else
Thomas Gleixner's avatar
Thomas Gleixner committed
425
			rtc_timer_remove(rtc, &rtc->aie_timer);
426 427
	}

428
	if (err)
429 430
		/* nothing */;
	else if (!rtc->ops)
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
		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);
	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;

448 449 450 451 452 453
#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
454 455 456 457
	/* make sure we're changing state */
	if (rtc->uie_rtctimer.enabled == enabled)
		goto out;

458 459 460 461 462
	if (rtc->uie_unsupported) {
		err = -EINVAL;
		goto out;
	}

463 464 465 466 467 468 469 470 471
	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);
472 473
		err = rtc_timer_enqueue(rtc, &rtc->uie_rtctimer);
	} else
Thomas Gleixner's avatar
Thomas Gleixner committed
474
		rtc_timer_remove(rtc, &rtc->uie_rtctimer);
475

476
out:
477
	mutex_unlock(&rtc->ops_lock);
478 479 480 481 482 483 484 485 486 487
#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
488
	return err;
489

490 491 492
}
EXPORT_SYMBOL_GPL(rtc_update_irq_enable);

493

494
/**
495 496 497 498
 * 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
Lucas De Marchi's avatar
Lucas De Marchi committed
499
 * has occurred (or been emulated).
500 501
 *
 * Triggers the registered irq_task function callback.
502
 */
503
void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode)
504
{
505 506
	unsigned long flags;

507
	/* mark one irq of the appropriate mode */
508
	spin_lock_irqsave(&rtc->irq_lock, flags);
509
	rtc->irq_data = (rtc->irq_data + (num << 8)) | (RTC_IRQF|mode);
510
	spin_unlock_irqrestore(&rtc->irq_lock, flags);
511

512
	/* call the task func */
513
	spin_lock_irqsave(&rtc->irq_task_lock, flags);
514 515
	if (rtc->irq_task)
		rtc->irq_task->func(rtc->irq_task->private_data);
516
	spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
517 518 519 520

	wake_up_interruptible(&rtc->irq_queue);
	kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
}
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563


/**
 * 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);

564
	period = NSEC_PER_SEC / rtc->irq_freq;
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
	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)
{
582
	if (IS_ERR_OR_NULL(rtc))
583 584
		return;

585
	pm_stay_awake(rtc->dev.parent);
586 587
	schedule_work(&rtc->irqwork);
}
588 589
EXPORT_SYMBOL_GPL(rtc_update_irq);

590
static int __rtc_match(struct device *dev, const void *data)
Dave Young's avatar
Dave Young committed
591
{
592
	const char *name = data;
Dave Young's avatar
Dave Young committed
593

594
	if (strcmp(dev_name(dev), name) == 0)
Dave Young's avatar
Dave Young committed
595 596 597 598
		return 1;
	return 0;
}

599
struct rtc_device *rtc_class_open(const char *name)
600
{
601
	struct device *dev;
602
	struct rtc_device *rtc = NULL;
603

604
	dev = class_find_device(rtc_class, NULL, name, __rtc_match);
Dave Young's avatar
Dave Young committed
605 606
	if (dev)
		rtc = to_rtc_device(dev);
607

608 609
	if (rtc) {
		if (!try_module_get(rtc->owner)) {
610
			put_device(dev);
611 612
			rtc = NULL;
		}
613 614
	}

615
	return rtc;
616 617 618
}
EXPORT_SYMBOL_GPL(rtc_class_open);

619
void rtc_class_close(struct rtc_device *rtc)
620
{
621
	module_put(rtc->owner);
622
	put_device(&rtc->dev);
623 624 625
}
EXPORT_SYMBOL_GPL(rtc_class_close);

626
int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
627 628 629 630 631 632
{
	int retval = -EBUSY;

	if (task == NULL || task->func == NULL)
		return -EINVAL;

Alessandro Zummo's avatar
Alessandro Zummo committed
633
	/* Cannot register while the char dev is in use */
634
	if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
Alessandro Zummo's avatar
Alessandro Zummo committed
635 636
		return -EBUSY;

637
	spin_lock_irq(&rtc->irq_task_lock);
638 639 640 641
	if (rtc->irq_task == NULL) {
		rtc->irq_task = task;
		retval = 0;
	}
642
	spin_unlock_irq(&rtc->irq_task_lock);
643

644
	clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
Alessandro Zummo's avatar
Alessandro Zummo committed
645

646 647 648 649
	return retval;
}
EXPORT_SYMBOL_GPL(rtc_irq_register);

650
void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
651
{
652
	spin_lock_irq(&rtc->irq_task_lock);
653 654
	if (rtc->irq_task == task)
		rtc->irq_task = NULL;
655
	spin_unlock_irq(&rtc->irq_task_lock);
656 657 658
}
EXPORT_SYMBOL_GPL(rtc_irq_unregister);

Thomas Gleixner's avatar
Thomas Gleixner committed
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
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) {
675
		ktime_t period = NSEC_PER_SEC / rtc->irq_freq;
Thomas Gleixner's avatar
Thomas Gleixner committed
676 677 678 679 680 681

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

682 683 684 685 686 687 688 689 690 691
/**
 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
 * @rtc: the rtc device
 * @task: currently registered with rtc_irq_register()
 * @enabled: true to enable periodic IRQs
 * Context: any
 *
 * Note that rtc_irq_set_freq() should previously have been used to
 * specify the desired frequency of periodic IRQ task->func() callbacks.
 */
692
int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
693 694 695 696
{
	int err = 0;
	unsigned long flags;

Thomas Gleixner's avatar
Thomas Gleixner committed
697
retry:
698
	spin_lock_irqsave(&rtc->irq_task_lock, flags);
Alessandro Zummo's avatar
Alessandro Zummo committed
699 700
	if (rtc->irq_task != NULL && task == NULL)
		err = -EBUSY;
701
	else if (rtc->irq_task != task)
Alessandro Zummo's avatar
Alessandro Zummo committed
702
		err = -EACCES;
703
	else {
Thomas Gleixner's avatar
Thomas Gleixner committed
704 705 706 707 708 709
		if (rtc_update_hrtimer(rtc, enabled) < 0) {
			spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
			cpu_relax();
			goto retry;
		}
		rtc->pie_enabled = enabled;
710 711
	}
	spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
712 713 714 715
	return err;
}
EXPORT_SYMBOL_GPL(rtc_irq_set_state);

716 717 718 719 720 721 722 723 724 725
/**
 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
 * @rtc: the rtc device
 * @task: currently registered with rtc_irq_register()
 * @freq: positive frequency with which task->func() will be called
 * Context: any
 *
 * Note that rtc_irq_set_state() is used to enable or disable the
 * periodic IRQs.
 */
726
int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
727
{
728
	int err = 0;
729 730
	unsigned long flags;

731
	if (freq <= 0 || freq > RTC_MAX_FREQ)
732
		return -EINVAL;
Thomas Gleixner's avatar
Thomas Gleixner committed
733
retry:
734
	spin_lock_irqsave(&rtc->irq_task_lock, flags);
Alessandro Zummo's avatar
Alessandro Zummo committed
735 736
	if (rtc->irq_task != NULL && task == NULL)
		err = -EBUSY;
737
	else if (rtc->irq_task != task)
Alessandro Zummo's avatar
Alessandro Zummo committed
738
		err = -EACCES;
739
	else {
740
		rtc->irq_freq = freq;
Thomas Gleixner's avatar
Thomas Gleixner committed
741 742 743 744
		if (rtc->pie_enabled && rtc_update_hrtimer(rtc, 1) < 0) {
			spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
			cpu_relax();
			goto retry;
745
		}
746
	}
747
	spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
748 749
	return err;
}
750
EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
751 752

/**
Thomas Gleixner's avatar
Thomas Gleixner committed
753
 * rtc_timer_enqueue - Adds a rtc_timer to the rtc_device timerqueue
754 755 756 757 758 759
 * @rtc rtc device
 * @timer timer being added.
 *
 * Enqueues a timer onto the rtc devices timerqueue and sets
 * the next alarm event appropriately.
 *
760 761
 * Sets the enabled bit on the added timer.
 *
762 763
 * Must hold ops_lock for proper serialization of timerqueue
 */
764
static int rtc_timer_enqueue(struct rtc_device *rtc, struct rtc_timer *timer)
765
{
766 767 768 769
	struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
	struct rtc_time tm;
	ktime_t now;

770
	timer->enabled = 1;
771 772 773 774 775
	__rtc_read_time(rtc, &tm);
	now = rtc_tm_to_ktime(tm);

	/* Skip over expired timers */
	while (next) {
776
		if (next->expires >= now)
777 778 779 780
			break;
		next = timerqueue_iterate_next(next);
	}

781
	timerqueue_add(&rtc->timerqueue, &timer->node);
782
	if (!next) {
783 784 785 786 787
		struct rtc_wkalrm alarm;
		int err;
		alarm.time = rtc_ktime_to_tm(timer->node.expires);
		alarm.enabled = 1;
		err = __rtc_set_alarm(rtc, &alarm);
788 789
		if (err == -ETIME) {
			pm_stay_awake(rtc->dev.parent);
790
			schedule_work(&rtc->irqwork);
791
		} else if (err) {
792 793 794 795
			timerqueue_del(&rtc->timerqueue, &timer->node);
			timer->enabled = 0;
			return err;
		}
796
	}
797
	return 0;
798 799
}

800 801 802 803 804 805 806 807
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);
}

808
/**
Thomas Gleixner's avatar
Thomas Gleixner committed
809
 * rtc_timer_remove - Removes a rtc_timer from the rtc_device timerqueue
810 811 812 813 814 815
 * @rtc rtc device
 * @timer timer being removed.
 *
 * Removes a timer onto the rtc devices timerqueue and sets
 * the next alarm event appropriately.
 *
816 817
 * Clears the enabled bit on the removed timer.
 *
818 819
 * Must hold ops_lock for proper serialization of timerqueue
 */
820
static void rtc_timer_remove(struct rtc_device *rtc, struct rtc_timer *timer)
821 822 823
{
	struct timerqueue_node *next = timerqueue_getnext(&rtc->timerqueue);
	timerqueue_del(&rtc->timerqueue, &timer->node);
824
	timer->enabled = 0;
825 826 827 828
	if (next == &timer->node) {
		struct rtc_wkalrm alarm;
		int err;
		next = timerqueue_getnext(&rtc->timerqueue);
829 830
		if (!next) {
			rtc_alarm_disable(rtc);
831
			return;
832
		}
833 834 835
		alarm.time = rtc_ktime_to_tm(next->expires);
		alarm.enabled = 1;
		err = __rtc_set_alarm(rtc, &alarm);
836 837
		if (err == -ETIME) {
			pm_stay_awake(rtc->dev.parent);
838
			schedule_work(&rtc->irqwork);
839
		}
840 841 842 843
	}
}

/**
Thomas Gleixner's avatar
Thomas Gleixner committed
844
 * rtc_timer_do_work - Expires rtc timers
845 846 847 848 849 850 851 852
 * @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
853
void rtc_timer_do_work(struct work_struct *work)
854 855 856 857 858 859 860 861 862 863 864 865 866 867
{
	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))) {
868
		if (next->expires > now)
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
			break;

		/* expire timer */
		timer = container_of(next, struct rtc_timer, node);
		timerqueue_del(&rtc->timerqueue, &timer->node);
		timer->enabled = 0;
		if (timer->task.func)
			timer->task.func(timer->task.private_data);

		/* 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);
		}
	}

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

893 894
		alarm.time = rtc_ktime_to_tm(next->expires);
		alarm.enabled = 1;
895
reprogram:
896 897 898
		err = __rtc_set_alarm(rtc, &alarm);
		if (err == -ETIME)
			goto again;
899 900 901 902 903 904 905 906 907 908
		else if (err) {
			if (retry-- > 0)
				goto reprogram;

			timer = container_of(next, struct rtc_timer, node);
			timerqueue_del(&rtc->timerqueue, &timer->node);
			timer->enabled = 0;
			dev_err(&rtc->dev, "__rtc_set_alarm: err=%d\n", err);
			goto again;
		}
909 910
	} else
		rtc_alarm_disable(rtc);
911

912
	pm_relax(rtc->dev.parent);
913 914 915 916
	mutex_unlock(&rtc->ops_lock);
}


Thomas Gleixner's avatar
Thomas Gleixner committed
917
/* rtc_timer_init - Initializes an rtc_timer
918 919 920 921 922 923
 * @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.
 */
924
void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data)
925 926 927 928 929 930 931
{
	timerqueue_init(&timer->node);
	timer->enabled = 0;
	timer->task.func = f;
	timer->task.private_data = data;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
932
/* rtc_timer_start - Sets an rtc_timer to fire in the future
933 934 935 936 937 938 939
 * @ 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
 */
940
int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
941 942 943 944 945
			ktime_t expires, ktime_t period)
{
	int ret = 0;
	mutex_lock(&rtc->ops_lock);
	if (timer->enabled)
Thomas Gleixner's avatar
Thomas Gleixner committed
946
		rtc_timer_remove(rtc, timer);
947 948 949 950

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

951
	ret = rtc_timer_enqueue(rtc, timer);
952 953 954 955 956

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

Thomas Gleixner's avatar
Thomas Gleixner committed
957
/* rtc_timer_cancel - Stops an rtc_timer
958 959 960 961 962
 * @ rtc: rtc device to be used
 * @ timer: timer being set
 *
 * Kernel interface to cancel an rtc_timer
 */
963
void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer)
964 965 966
{
	mutex_lock(&rtc->ops_lock);
	if (timer->enabled)
Thomas Gleixner's avatar
Thomas Gleixner committed
967
		rtc_timer_remove(rtc, timer);
968 969 970
	mutex_unlock(&rtc->ops_lock);
}

971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
/**
 * 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);
	return ret;
}
997

998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
/**
 * 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.
 *
 * 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);
	return ret;
}