1/*
  2 * Alarmtimer interface
  3 *
  4 * This interface provides a timer which is similarto hrtimers,
  5 * but triggers a RTC alarm if the box is suspend.
  6 *
  7 * This interface is influenced by the Android RTC Alarm timer
  8 * interface.
  9 *
 10 * Copyright (C) 2010 IBM Corperation
 11 *
 12 * Author: John Stultz <john.stultz@linaro.org>
 13 *
 14 * This program is free software; you can redistribute it and/or modify
 15 * it under the terms of the GNU General Public License version 2 as
 16 * published by the Free Software Foundation.
 17 */
 18#include <linux/time.h>
 19#include <linux/hrtimer.h>
 20#include <linux/timerqueue.h>
 21#include <linux/rtc.h>
 22#include <linux/alarmtimer.h>
 23#include <linux/mutex.h>
 24#include <linux/platform_device.h>
 25#include <linux/posix-timers.h>
 26#include <linux/workqueue.h>
 27#include <linux/freezer.h>
 28
 29#define CREATE_TRACE_POINTS
 30#include <trace/events/alarmtimer.h>
 31
 32/**
 33 * struct alarm_base - Alarm timer bases
 34 * @lock:		Lock for syncrhonized access to the base
 35 * @timerqueue:		Timerqueue head managing the list of events
 
 36 * @gettime:		Function to read the time correlating to the base
 37 * @base_clockid:	clockid for the base
 38 */
 39static struct alarm_base {
 40	spinlock_t		lock;
 41	struct timerqueue_head	timerqueue;
 
 42	ktime_t			(*gettime)(void);
 43	clockid_t		base_clockid;
 44} alarm_bases[ALARM_NUMTYPE];
 45
 46/* freezer information to handle clock_nanosleep triggered wakeups */
 47static enum alarmtimer_type freezer_alarmtype;
 48static ktime_t freezer_expires;
 49static ktime_t freezer_delta;
 50static DEFINE_SPINLOCK(freezer_delta_lock);
 51
 52static struct wakeup_source *ws;
 53
 54#ifdef CONFIG_RTC_CLASS
 55/* rtc timer and device for setting alarm wakeups at suspend */
 56static struct rtc_timer		rtctimer;
 57static struct rtc_device	*rtcdev;
 58static DEFINE_SPINLOCK(rtcdev_lock);
 59
 60/**
 61 * alarmtimer_get_rtcdev - Return selected rtcdevice
 
 
 62 *
 63 * This function returns the rtc device to use for wakealarms.
 64 * If one has not already been chosen, it checks to see if a
 65 * functional rtc device is available.
 66 */
 67struct rtc_device *alarmtimer_get_rtcdev(void)
 68{
 69	unsigned long flags;
 70	struct rtc_device *ret;
 71
 72	spin_lock_irqsave(&rtcdev_lock, flags);
 73	ret = rtcdev;
 74	spin_unlock_irqrestore(&rtcdev_lock, flags);
 
 75
 76	return ret;
 
 77}
 78EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev);
 79
 80static int alarmtimer_rtc_add_device(struct device *dev,
 81				struct class_interface *class_intf)
 
 
 
 
 
 
 82{
 
 
 83	unsigned long flags;
 84	struct rtc_device *rtc = to_rtc_device(dev);
 85
 86	if (rtcdev)
 87		return -EBUSY;
 88
 89	if (!rtc->ops->set_alarm)
 90		return -1;
 91	if (!device_may_wakeup(rtc->dev.parent))
 92		return -1;
 93
 94	spin_lock_irqsave(&rtcdev_lock, flags);
 95	if (!rtcdev) {
 96		rtcdev = rtc;
 97		/* hold a reference so it doesn't go away */
 98		get_device(dev);
 
 
 
 
 
 
 
 
 
 99	}
 
100	spin_unlock_irqrestore(&rtcdev_lock, flags);
101	return 0;
102}
103
104static inline void alarmtimer_rtc_timer_init(void)
105{
106	rtc_timer_init(&rtctimer, NULL, NULL);
107}
108
109static struct class_interface alarmtimer_rtc_interface = {
110	.add_dev = &alarmtimer_rtc_add_device,
111};
112
113static int alarmtimer_rtc_interface_setup(void)
114{
115	alarmtimer_rtc_interface.class = rtc_class;
116	return class_interface_register(&alarmtimer_rtc_interface);
117}
118static void alarmtimer_rtc_interface_remove(void)
119{
120	class_interface_unregister(&alarmtimer_rtc_interface);
121}
122#else
123struct rtc_device *alarmtimer_get_rtcdev(void)
124{
125	return NULL;
126}
127#define rtcdev (NULL)
128static inline int alarmtimer_rtc_interface_setup(void) { return 0; }
129static inline void alarmtimer_rtc_interface_remove(void) { }
130static inline void alarmtimer_rtc_timer_init(void) { }
131#endif
132
 
133/**
134 * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
135 * @base: pointer to the base where the timer is being run
136 * @alarm: pointer to alarm being enqueued.
137 *
138 * Adds alarm to a alarm_base timerqueue
 
139 *
140 * Must hold base->lock when calling.
141 */
142static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
143{
144	if (alarm->state & ALARMTIMER_STATE_ENQUEUED)
145		timerqueue_del(&base->timerqueue, &alarm->node);
146
147	timerqueue_add(&base->timerqueue, &alarm->node);
148	alarm->state |= ALARMTIMER_STATE_ENQUEUED;
 
 
 
 
149}
150
151/**
152 * alarmtimer_dequeue - Removes an alarm timer from an alarm_base timerqueue
153 * @base: pointer to the base where the timer is running
154 * @alarm: pointer to alarm being removed
155 *
156 * Removes alarm to a alarm_base timerqueue
 
157 *
158 * Must hold base->lock when calling.
159 */
160static void alarmtimer_dequeue(struct alarm_base *base, struct alarm *alarm)
161{
162	if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))
163		return;
164
165	timerqueue_del(&base->timerqueue, &alarm->node);
166	alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
 
 
 
 
 
 
167}
168
169
170/**
171 * alarmtimer_fired - Handles alarm hrtimer being fired.
172 * @timer: pointer to hrtimer being run
173 *
174 * When a alarm timer fires, this runs through the timerqueue to
175 * see which alarms expired, and runs those. If there are more alarm
176 * timers queued for the future, we set the hrtimer to fire when
177 * when the next future alarm timer expires.
178 */
179static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
180{
181	struct alarm *alarm = container_of(timer, struct alarm, timer);
182	struct alarm_base *base = &alarm_bases[alarm->type];
183	unsigned long flags;
 
184	int ret = HRTIMER_NORESTART;
185	int restart = ALARMTIMER_NORESTART;
186
187	spin_lock_irqsave(&base->lock, flags);
188	alarmtimer_dequeue(base, alarm);
189	spin_unlock_irqrestore(&base->lock, flags);
 
 
190
191	if (alarm->function)
192		restart = alarm->function(alarm, base->gettime());
193
194	spin_lock_irqsave(&base->lock, flags);
195	if (restart != ALARMTIMER_NORESTART) {
196		hrtimer_set_expires(&alarm->timer, alarm->node.expires);
197		alarmtimer_enqueue(base, alarm);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
198		ret = HRTIMER_RESTART;
199	}
200	spin_unlock_irqrestore(&base->lock, flags);
201
202	trace_alarmtimer_fired(alarm, base->gettime());
203	return ret;
204
205}
206
207ktime_t alarm_expires_remaining(const struct alarm *alarm)
208{
209	struct alarm_base *base = &alarm_bases[alarm->type];
210	return ktime_sub(alarm->node.expires, base->gettime());
211}
212EXPORT_SYMBOL_GPL(alarm_expires_remaining);
213
214#ifdef CONFIG_RTC_CLASS
215/**
216 * alarmtimer_suspend - Suspend time callback
217 * @dev: unused
218 * @state: unused
219 *
220 * When we are going into suspend, we look through the bases
221 * to see which is the soonest timer to expire. We then
222 * set an rtc timer to fire that far into the future, which
223 * will wake us from suspend.
224 */
225static int alarmtimer_suspend(struct device *dev)
226{
227	ktime_t min, now, expires;
228	int i, ret, type;
229	struct rtc_device *rtc;
230	unsigned long flags;
231	struct rtc_time tm;
 
 
 
 
232
233	spin_lock_irqsave(&freezer_delta_lock, flags);
234	min = freezer_delta;
235	expires = freezer_expires;
236	type = freezer_alarmtype;
237	freezer_delta = 0;
238	spin_unlock_irqrestore(&freezer_delta_lock, flags);
239
240	rtc = alarmtimer_get_rtcdev();
241	/* If we have no rtcdev, just return */
242	if (!rtc)
243		return 0;
244
245	/* Find the soonest timer to expire*/
246	for (i = 0; i < ALARM_NUMTYPE; i++) {
247		struct alarm_base *base = &alarm_bases[i];
248		struct timerqueue_node *next;
249		ktime_t delta;
250
251		spin_lock_irqsave(&base->lock, flags);
252		next = timerqueue_getnext(&base->timerqueue);
253		spin_unlock_irqrestore(&base->lock, flags);
254		if (!next)
255			continue;
256		delta = ktime_sub(next->expires, base->gettime());
257		if (!min || (delta < min)) {
258			expires = next->expires;
259			min = delta;
260			type = i;
261		}
262	}
263	if (min == 0)
264		return 0;
265
266	if (ktime_to_ns(min) < 2 * NSEC_PER_SEC) {
267		__pm_wakeup_event(ws, 2 * MSEC_PER_SEC);
268		return -EBUSY;
269	}
270
271	trace_alarmtimer_suspend(expires, type);
272
273	/* Setup an rtc timer to fire that far in the future */
274	rtc_timer_cancel(rtc, &rtctimer);
275	rtc_read_time(rtc, &tm);
276	now = rtc_tm_to_ktime(tm);
277	now = ktime_add(now, min);
278
279	/* Set alarm, if in the past reject suspend briefly to handle */
280	ret = rtc_timer_start(rtc, &rtctimer, now, 0);
281	if (ret < 0)
282		__pm_wakeup_event(ws, MSEC_PER_SEC);
283	return ret;
284}
285
286static int alarmtimer_resume(struct device *dev)
287{
288	struct rtc_device *rtc;
289
290	rtc = alarmtimer_get_rtcdev();
291	if (rtc)
292		rtc_timer_cancel(rtc, &rtctimer);
293	return 0;
294}
295
296#else
297static int alarmtimer_suspend(struct device *dev)
298{
299	return 0;
300}
301
302static int alarmtimer_resume(struct device *dev)
303{
304	return 0;
305}
306#endif
307
308static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
309{
310	struct alarm_base *base;
311	unsigned long flags;
312	ktime_t delta;
313
314	switch(type) {
315	case ALARM_REALTIME:
316		base = &alarm_bases[ALARM_REALTIME];
317		type = ALARM_REALTIME_FREEZER;
318		break;
319	case ALARM_BOOTTIME:
320		base = &alarm_bases[ALARM_BOOTTIME];
321		type = ALARM_BOOTTIME_FREEZER;
322		break;
323	default:
324		WARN_ONCE(1, "Invalid alarm type: %d\n", type);
325		return;
326	}
327
328	delta = ktime_sub(absexp, base->gettime());
329
330	spin_lock_irqsave(&freezer_delta_lock, flags);
331	if (!freezer_delta || (delta < freezer_delta)) {
332		freezer_delta = delta;
333		freezer_expires = absexp;
334		freezer_alarmtype = type;
335	}
336	spin_unlock_irqrestore(&freezer_delta_lock, flags);
337}
338
339
340/**
341 * alarm_init - Initialize an alarm structure
342 * @alarm: ptr to alarm to be initialized
343 * @type: the type of the alarm
344 * @function: callback that is run when the alarm fires
345 */
346void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
347		enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
348{
349	timerqueue_init(&alarm->node);
350	hrtimer_init(&alarm->timer, alarm_bases[type].base_clockid,
351			HRTIMER_MODE_ABS);
352	alarm->timer.function = alarmtimer_fired;
353	alarm->function = function;
354	alarm->type = type;
355	alarm->state = ALARMTIMER_STATE_INACTIVE;
356}
357EXPORT_SYMBOL_GPL(alarm_init);
358
359/**
360 * alarm_start - Sets an absolute alarm to fire
361 * @alarm: ptr to alarm to set
362 * @start: time to run the alarm
 
363 */
364void alarm_start(struct alarm *alarm, ktime_t start)
365{
366	struct alarm_base *base = &alarm_bases[alarm->type];
367	unsigned long flags;
368
369	spin_lock_irqsave(&base->lock, flags);
 
 
370	alarm->node.expires = start;
 
371	alarmtimer_enqueue(base, alarm);
372	hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS);
373	spin_unlock_irqrestore(&base->lock, flags);
374
375	trace_alarmtimer_start(alarm, base->gettime());
376}
377EXPORT_SYMBOL_GPL(alarm_start);
378
379/**
380 * alarm_start_relative - Sets a relative alarm to fire
381 * @alarm: ptr to alarm to set
382 * @start: time relative to now to run the alarm
383 */
384void alarm_start_relative(struct alarm *alarm, ktime_t start)
385{
386	struct alarm_base *base = &alarm_bases[alarm->type];
387
388	start = ktime_add(start, base->gettime());
389	alarm_start(alarm, start);
390}
391EXPORT_SYMBOL_GPL(alarm_start_relative);
392
393void alarm_restart(struct alarm *alarm)
394{
395	struct alarm_base *base = &alarm_bases[alarm->type];
396	unsigned long flags;
397
398	spin_lock_irqsave(&base->lock, flags);
399	hrtimer_set_expires(&alarm->timer, alarm->node.expires);
400	hrtimer_restart(&alarm->timer);
401	alarmtimer_enqueue(base, alarm);
402	spin_unlock_irqrestore(&base->lock, flags);
403}
404EXPORT_SYMBOL_GPL(alarm_restart);
405
406/**
407 * alarm_try_to_cancel - Tries to cancel an alarm timer
408 * @alarm: ptr to alarm to be canceled
409 *
410 * Returns 1 if the timer was canceled, 0 if it was not running,
411 * and -1 if the callback was running
412 */
413int alarm_try_to_cancel(struct alarm *alarm)
414{
415	struct alarm_base *base = &alarm_bases[alarm->type];
416	unsigned long flags;
417	int ret;
418
419	spin_lock_irqsave(&base->lock, flags);
420	ret = hrtimer_try_to_cancel(&alarm->timer);
421	if (ret >= 0)
422		alarmtimer_dequeue(base, alarm);
423	spin_unlock_irqrestore(&base->lock, flags);
424
425	trace_alarmtimer_cancel(alarm, base->gettime());
426	return ret;
427}
428EXPORT_SYMBOL_GPL(alarm_try_to_cancel);
429
430
431/**
432 * alarm_cancel - Spins trying to cancel an alarm timer until it is done
433 * @alarm: ptr to alarm to be canceled
434 *
435 * Returns 1 if the timer was canceled, 0 if it was not active.
436 */
437int alarm_cancel(struct alarm *alarm)
438{
439	for (;;) {
440		int ret = alarm_try_to_cancel(alarm);
441		if (ret >= 0)
442			return ret;
443		cpu_relax();
444	}
445}
446EXPORT_SYMBOL_GPL(alarm_cancel);
447
448
449u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
450{
451	u64 overrun = 1;
452	ktime_t delta;
453
454	delta = ktime_sub(now, alarm->node.expires);
455
456	if (delta < 0)
457		return 0;
458
459	if (unlikely(delta >= interval)) {
460		s64 incr = ktime_to_ns(interval);
461
462		overrun = ktime_divns(delta, incr);
463
464		alarm->node.expires = ktime_add_ns(alarm->node.expires,
465							incr*overrun);
466
467		if (alarm->node.expires > now)
468			return overrun;
469		/*
470		 * This (and the ktime_add() below) is the
471		 * correction for exact:
472		 */
473		overrun++;
474	}
475
476	alarm->node.expires = ktime_add(alarm->node.expires, interval);
477	return overrun;
478}
479EXPORT_SYMBOL_GPL(alarm_forward);
480
481u64 alarm_forward_now(struct alarm *alarm, ktime_t interval)
482{
483	struct alarm_base *base = &alarm_bases[alarm->type];
484
485	return alarm_forward(alarm, base->gettime(), interval);
486}
487EXPORT_SYMBOL_GPL(alarm_forward_now);
488
489
490/**
491 * clock2alarm - helper that converts from clockid to alarmtypes
492 * @clockid: clockid.
493 */
494static enum alarmtimer_type clock2alarm(clockid_t clockid)
495{
496	if (clockid == CLOCK_REALTIME_ALARM)
497		return ALARM_REALTIME;
498	if (clockid == CLOCK_BOOTTIME_ALARM)
499		return ALARM_BOOTTIME;
500	return -1;
501}
502
503/**
504 * alarm_handle_timer - Callback for posix timers
505 * @alarm: alarm that fired
506 *
507 * Posix timer callback for expired alarm timers.
508 */
509static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
510							ktime_t now)
511{
512	unsigned long flags;
513	struct k_itimer *ptr = container_of(alarm, struct k_itimer,
514						it.alarm.alarmtimer);
515	enum alarmtimer_restart result = ALARMTIMER_NORESTART;
516
517	spin_lock_irqsave(&ptr->it_lock, flags);
518	if ((ptr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) {
519		if (IS_ENABLED(CONFIG_POSIX_TIMERS) &&
520		    posix_timer_event(ptr, 0) != 0)
521			ptr->it_overrun++;
522	}
523
524	/* Re-add periodic timers */
525	if (ptr->it.alarm.interval) {
526		ptr->it_overrun += alarm_forward(alarm, now,
527						ptr->it.alarm.interval);
528		result = ALARMTIMER_RESTART;
529	}
530	spin_unlock_irqrestore(&ptr->it_lock, flags);
531
532	return result;
533}
534
535/**
536 * alarm_clock_getres - posix getres interface
537 * @which_clock: clockid
538 * @tp: timespec to fill
539 *
540 * Returns the granularity of underlying alarm base clock
541 */
542static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp)
543{
 
 
544	if (!alarmtimer_get_rtcdev())
545		return -EINVAL;
546
547	tp->tv_sec = 0;
548	tp->tv_nsec = hrtimer_resolution;
549	return 0;
550}
551
552/**
553 * alarm_clock_get - posix clock_get interface
554 * @which_clock: clockid
555 * @tp: timespec to fill.
556 *
557 * Provides the underlying alarm base time.
558 */
559static int alarm_clock_get(clockid_t which_clock, struct timespec *tp)
560{
561	struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
562
563	if (!alarmtimer_get_rtcdev())
564		return -EINVAL;
565
566	*tp = ktime_to_timespec(base->gettime());
567	return 0;
568}
569
570/**
571 * alarm_timer_create - posix timer_create interface
572 * @new_timer: k_itimer pointer to manage
573 *
574 * Initializes the k_itimer structure.
575 */
576static int alarm_timer_create(struct k_itimer *new_timer)
577{
578	enum  alarmtimer_type type;
 
579
580	if (!alarmtimer_get_rtcdev())
581		return -ENOTSUPP;
582
583	if (!capable(CAP_WAKE_ALARM))
584		return -EPERM;
585
586	type = clock2alarm(new_timer->it_clock);
587	alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
 
588	return 0;
589}
590
591/**
592 * alarm_timer_get - posix timer_get interface
593 * @new_timer: k_itimer pointer
594 * @cur_setting: itimerspec data to fill
595 *
596 * Copies out the current itimerspec data
597 */
598static void alarm_timer_get(struct k_itimer *timr,
599				struct itimerspec *cur_setting)
600{
601	ktime_t relative_expiry_time =
602		alarm_expires_remaining(&(timr->it.alarm.alarmtimer));
603
604	if (ktime_to_ns(relative_expiry_time) > 0) {
605		cur_setting->it_value = ktime_to_timespec(relative_expiry_time);
606	} else {
607		cur_setting->it_value.tv_sec = 0;
608		cur_setting->it_value.tv_nsec = 0;
609	}
610
611	cur_setting->it_interval = ktime_to_timespec(timr->it.alarm.interval);
612}
613
614/**
615 * alarm_timer_del - posix timer_del interface
616 * @timr: k_itimer pointer to be deleted
617 *
618 * Cancels any programmed alarms for the given timer.
619 */
620static int alarm_timer_del(struct k_itimer *timr)
621{
622	if (!rtcdev)
623		return -ENOTSUPP;
624
625	if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
626		return TIMER_RETRY;
627
628	return 0;
629}
630
631/**
632 * alarm_timer_set - posix timer_set interface
633 * @timr: k_itimer pointer to be deleted
634 * @flags: timer flags
635 * @new_setting: itimerspec to be used
636 * @old_setting: itimerspec being replaced
637 *
638 * Sets the timer to new_setting, and starts the timer.
639 */
640static int alarm_timer_set(struct k_itimer *timr, int flags,
641				struct itimerspec *new_setting,
642				struct itimerspec *old_setting)
643{
644	ktime_t exp;
645
646	if (!rtcdev)
647		return -ENOTSUPP;
648
649	if (flags & ~TIMER_ABSTIME)
650		return -EINVAL;
 
 
 
 
 
 
651
652	if (old_setting)
653		alarm_timer_get(timr, old_setting);
654
655	/* If the timer was already set, cancel it */
656	if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
657		return TIMER_RETRY;
658
659	/* start the timer */
660	timr->it.alarm.interval = timespec_to_ktime(new_setting->it_interval);
661	exp = timespec_to_ktime(new_setting->it_value);
662	/* Convert (if necessary) to absolute time */
663	if (flags != TIMER_ABSTIME) {
664		ktime_t now;
665
666		now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
667		exp = ktime_add(now, exp);
668	}
669
670	alarm_start(&timr->it.alarm.alarmtimer, exp);
671	return 0;
672}
673
674/**
675 * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
676 * @alarm: ptr to alarm that fired
677 *
678 * Wakes up the task that set the alarmtimer
679 */
680static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
681								ktime_t now)
682{
683	struct task_struct *task = (struct task_struct *)alarm->data;
684
685	alarm->data = NULL;
686	if (task)
687		wake_up_process(task);
688	return ALARMTIMER_NORESTART;
689}
690
691/**
692 * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
693 * @alarm: ptr to alarmtimer
694 * @absexp: absolute expiration time
695 *
696 * Sets the alarm timer and sleeps until it is fired or interrupted.
697 */
698static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
699{
700	alarm->data = (void *)current;
701	do {
702		set_current_state(TASK_INTERRUPTIBLE);
703		alarm_start(alarm, absexp);
704		if (likely(alarm->data))
705			schedule();
706
707		alarm_cancel(alarm);
708	} while (alarm->data && !signal_pending(current));
709
710	__set_current_state(TASK_RUNNING);
711
712	return (alarm->data == NULL);
713}
714
715
716/**
717 * update_rmtp - Update remaining timespec value
718 * @exp: expiration time
719 * @type: timer type
720 * @rmtp: user pointer to remaining timepsec value
721 *
722 * Helper function that fills in rmtp value with time between
723 * now and the exp value
724 */
725static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
726			struct timespec __user *rmtp)
727{
728	struct timespec rmt;
729	ktime_t rem;
730
731	rem = ktime_sub(exp, alarm_bases[type].gettime());
732
733	if (rem <= 0)
734		return 0;
735	rmt = ktime_to_timespec(rem);
736
737	if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
738		return -EFAULT;
739
740	return 1;
741
742}
743
744/**
745 * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
746 * @restart: ptr to restart block
747 *
748 * Handles restarted clock_nanosleep calls
749 */
750static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
751{
752	enum  alarmtimer_type type = restart->nanosleep.clockid;
753	ktime_t exp;
754	struct timespec __user  *rmtp;
755	struct alarm alarm;
756	int ret = 0;
757
758	exp = restart->nanosleep.expires;
759	alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
760
761	if (alarmtimer_do_nsleep(&alarm, exp))
762		goto out;
763
764	if (freezing(current))
765		alarmtimer_freezerset(exp, type);
766
767	rmtp = restart->nanosleep.rmtp;
768	if (rmtp) {
769		ret = update_rmtp(exp, type, rmtp);
770		if (ret <= 0)
771			goto out;
772	}
773
774
775	/* The other values in restart are already filled in */
776	ret = -ERESTART_RESTARTBLOCK;
777out:
778	return ret;
779}
780
781/**
782 * alarm_timer_nsleep - alarmtimer nanosleep
783 * @which_clock: clockid
784 * @flags: determins abstime or relative
785 * @tsreq: requested sleep time (abs or rel)
786 * @rmtp: remaining sleep time saved
787 *
788 * Handles clock_nanosleep calls against _ALARM clockids
789 */
790static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
791		     struct timespec *tsreq, struct timespec __user *rmtp)
792{
793	enum  alarmtimer_type type = clock2alarm(which_clock);
794	struct alarm alarm;
795	ktime_t exp;
796	int ret = 0;
797	struct restart_block *restart;
798
799	if (!alarmtimer_get_rtcdev())
800		return -ENOTSUPP;
801
802	if (flags & ~TIMER_ABSTIME)
803		return -EINVAL;
804
805	if (!capable(CAP_WAKE_ALARM))
806		return -EPERM;
807
808	alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
809
810	exp = timespec_to_ktime(*tsreq);
811	/* Convert (if necessary) to absolute time */
812	if (flags != TIMER_ABSTIME) {
813		ktime_t now = alarm_bases[type].gettime();
814		exp = ktime_add(now, exp);
815	}
816
817	if (alarmtimer_do_nsleep(&alarm, exp))
818		goto out;
819
820	if (freezing(current))
821		alarmtimer_freezerset(exp, type);
822
823	/* abs timers don't set remaining time or restart */
824	if (flags == TIMER_ABSTIME) {
825		ret = -ERESTARTNOHAND;
826		goto out;
827	}
828
829	if (rmtp) {
830		ret = update_rmtp(exp, type, rmtp);
831		if (ret <= 0)
832			goto out;
833	}
834
835	restart = &current->restart_block;
836	restart->fn = alarm_timer_nsleep_restart;
837	restart->nanosleep.clockid = type;
838	restart->nanosleep.expires = exp;
839	restart->nanosleep.rmtp = rmtp;
840	ret = -ERESTART_RESTARTBLOCK;
841
842out:
843	return ret;
844}
845
846
847/* Suspend hook structures */
848static const struct dev_pm_ops alarmtimer_pm_ops = {
849	.suspend = alarmtimer_suspend,
850	.resume = alarmtimer_resume,
851};
852
853static struct platform_driver alarmtimer_driver = {
854	.driver = {
855		.name = "alarmtimer",
856		.pm = &alarmtimer_pm_ops,
857	}
858};
859
860/**
861 * alarmtimer_init - Initialize alarm timer code
862 *
863 * This function initializes the alarm bases and registers
864 * the posix clock ids.
865 */
866static int __init alarmtimer_init(void)
867{
868	struct platform_device *pdev;
869	int error = 0;
870	int i;
871	struct k_clock alarm_clock = {
872		.clock_getres	= alarm_clock_getres,
873		.clock_get	= alarm_clock_get,
874		.timer_create	= alarm_timer_create,
875		.timer_set	= alarm_timer_set,
876		.timer_del	= alarm_timer_del,
877		.timer_get	= alarm_timer_get,
878		.nsleep		= alarm_timer_nsleep,
879	};
880
881	alarmtimer_rtc_timer_init();
882
883	if (IS_ENABLED(CONFIG_POSIX_TIMERS)) {
884		posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
885		posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
886	}
887
888	/* Initialize alarm bases */
889	alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
890	alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
891	alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
892	alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
893	for (i = 0; i < ALARM_NUMTYPE; i++) {
894		timerqueue_init_head(&alarm_bases[i].timerqueue);
895		spin_lock_init(&alarm_bases[i].lock);
 
 
 
 
896	}
897
898	error = alarmtimer_rtc_interface_setup();
899	if (error)
900		return error;
901
902	error = platform_driver_register(&alarmtimer_driver);
903	if (error)
904		goto out_if;
905
906	pdev = platform_device_register_simple("alarmtimer", -1, NULL, 0);
907	if (IS_ERR(pdev)) {
908		error = PTR_ERR(pdev);
909		goto out_drv;
910	}
911	ws = wakeup_source_register("alarmtimer");
912	return 0;
913
914out_drv:
915	platform_driver_unregister(&alarmtimer_driver);
916out_if:
917	alarmtimer_rtc_interface_remove();
918	return error;
919}
920device_initcall(alarmtimer_init);