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