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