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