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