kernel/time/alarmtimer.c

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