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