alarmtimer.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803
  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. * struct alarm_base - Alarm timer bases
  30. * @lock: Lock for syncrhonized access to the base
  31. * @timerqueue: Timerqueue head managing the list of events
  32. * @timer: hrtimer used to schedule events while running
  33. * @gettime: Function to read the time correlating to the base
  34. * @base_clockid: clockid for the base
  35. */
  36. static struct alarm_base {
  37. spinlock_t lock;
  38. struct timerqueue_head timerqueue;
  39. struct hrtimer timer;
  40. ktime_t (*gettime)(void);
  41. clockid_t base_clockid;
  42. } alarm_bases[ALARM_NUMTYPE];
  43. /* freezer delta & lock used to handle clock_nanosleep triggered wakeups */
  44. static ktime_t freezer_delta;
  45. static DEFINE_SPINLOCK(freezer_delta_lock);
  46. #ifdef CONFIG_RTC_CLASS
  47. /* rtc timer and device for setting alarm wakeups at suspend */
  48. static struct rtc_timer rtctimer;
  49. static struct rtc_device *rtcdev;
  50. static DEFINE_SPINLOCK(rtcdev_lock);
  51. /**
  52. * alarmtimer_get_rtcdev - Return selected rtcdevice
  53. *
  54. * This function returns the rtc device to use for wakealarms.
  55. * If one has not already been chosen, it checks to see if a
  56. * functional rtc device is available.
  57. */
  58. static struct rtc_device *alarmtimer_get_rtcdev(void)
  59. {
  60. unsigned long flags;
  61. struct rtc_device *ret;
  62. spin_lock_irqsave(&rtcdev_lock, flags);
  63. ret = rtcdev;
  64. spin_unlock_irqrestore(&rtcdev_lock, flags);
  65. return ret;
  66. }
  67. static int alarmtimer_rtc_add_device(struct device *dev,
  68. struct class_interface *class_intf)
  69. {
  70. unsigned long flags;
  71. struct rtc_device *rtc = to_rtc_device(dev);
  72. if (rtcdev)
  73. return -EBUSY;
  74. if (!rtc->ops->set_alarm)
  75. return -1;
  76. if (!device_may_wakeup(rtc->dev.parent))
  77. return -1;
  78. spin_lock_irqsave(&rtcdev_lock, flags);
  79. if (!rtcdev) {
  80. rtcdev = rtc;
  81. /* hold a reference so it doesn't go away */
  82. get_device(dev);
  83. }
  84. spin_unlock_irqrestore(&rtcdev_lock, flags);
  85. return 0;
  86. }
  87. static struct class_interface alarmtimer_rtc_interface = {
  88. .add_dev = &alarmtimer_rtc_add_device,
  89. };
  90. static void alarmtimer_rtc_interface_setup(void)
  91. {
  92. alarmtimer_rtc_interface.class = rtc_class;
  93. class_interface_register(&alarmtimer_rtc_interface);
  94. }
  95. #else
  96. #define alarmtimer_get_rtcdev() (0)
  97. #define rtcdev (0)
  98. #define alarmtimer_rtc_interface_setup()
  99. #endif
  100. /**
  101. * alarmtimer_enqueue - Adds an alarm timer to an alarm_base timerqueue
  102. * @base: pointer to the base where the timer is being run
  103. * @alarm: pointer to alarm being enqueued.
  104. *
  105. * Adds alarm to a alarm_base timerqueue and if necessary sets
  106. * an hrtimer to run.
  107. *
  108. * Must hold base->lock when calling.
  109. */
  110. static void alarmtimer_enqueue(struct alarm_base *base, struct alarm *alarm)
  111. {
  112. timerqueue_add(&base->timerqueue, &alarm->node);
  113. alarm->state |= ALARMTIMER_STATE_ENQUEUED;
  114. if (&alarm->node == timerqueue_getnext(&base->timerqueue)) {
  115. hrtimer_try_to_cancel(&base->timer);
  116. hrtimer_start(&base->timer, alarm->node.expires,
  117. HRTIMER_MODE_ABS);
  118. }
  119. }
  120. /**
  121. * alarmtimer_remove - Removes an alarm timer from an alarm_base timerqueue
  122. * @base: pointer to the base where the timer is running
  123. * @alarm: pointer to alarm being removed
  124. *
  125. * Removes alarm to a alarm_base timerqueue and if necessary sets
  126. * a new timer to run.
  127. *
  128. * Must hold base->lock when calling.
  129. */
  130. static void alarmtimer_remove(struct alarm_base *base, struct alarm *alarm)
  131. {
  132. struct timerqueue_node *next = timerqueue_getnext(&base->timerqueue);
  133. if (!(alarm->state & ALARMTIMER_STATE_ENQUEUED))
  134. return;
  135. timerqueue_del(&base->timerqueue, &alarm->node);
  136. alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
  137. if (next == &alarm->node) {
  138. hrtimer_try_to_cancel(&base->timer);
  139. next = timerqueue_getnext(&base->timerqueue);
  140. if (!next)
  141. return;
  142. hrtimer_start(&base->timer, next->expires, HRTIMER_MODE_ABS);
  143. }
  144. }
  145. /**
  146. * alarmtimer_fired - Handles alarm hrtimer being fired.
  147. * @timer: pointer to hrtimer being run
  148. *
  149. * When a alarm timer fires, this runs through the timerqueue to
  150. * see which alarms expired, and runs those. If there are more alarm
  151. * timers queued for the future, we set the hrtimer to fire when
  152. * when the next future alarm timer expires.
  153. */
  154. static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
  155. {
  156. struct alarm_base *base = container_of(timer, struct alarm_base, timer);
  157. struct timerqueue_node *next;
  158. unsigned long flags;
  159. ktime_t now;
  160. int ret = HRTIMER_NORESTART;
  161. int restart = ALARMTIMER_NORESTART;
  162. spin_lock_irqsave(&base->lock, flags);
  163. now = base->gettime();
  164. while ((next = timerqueue_getnext(&base->timerqueue))) {
  165. struct alarm *alarm;
  166. ktime_t expired = next->expires;
  167. if (expired.tv64 >= now.tv64)
  168. break;
  169. alarm = container_of(next, struct alarm, node);
  170. timerqueue_del(&base->timerqueue, &alarm->node);
  171. alarm->state &= ~ALARMTIMER_STATE_ENQUEUED;
  172. alarm->state |= ALARMTIMER_STATE_CALLBACK;
  173. spin_unlock_irqrestore(&base->lock, flags);
  174. if (alarm->function)
  175. restart = alarm->function(alarm, now);
  176. spin_lock_irqsave(&base->lock, flags);
  177. alarm->state &= ~ALARMTIMER_STATE_CALLBACK;
  178. if (restart != ALARMTIMER_NORESTART) {
  179. timerqueue_add(&base->timerqueue, &alarm->node);
  180. alarm->state |= ALARMTIMER_STATE_ENQUEUED;
  181. }
  182. }
  183. if (next) {
  184. hrtimer_set_expires(&base->timer, next->expires);
  185. ret = HRTIMER_RESTART;
  186. }
  187. spin_unlock_irqrestore(&base->lock, flags);
  188. return ret;
  189. }
  190. #ifdef CONFIG_RTC_CLASS
  191. /**
  192. * alarmtimer_suspend - Suspend time callback
  193. * @dev: unused
  194. * @state: unused
  195. *
  196. * When we are going into suspend, we look through the bases
  197. * to see which is the soonest timer to expire. We then
  198. * set an rtc timer to fire that far into the future, which
  199. * will wake us from suspend.
  200. */
  201. static int alarmtimer_suspend(struct device *dev)
  202. {
  203. struct rtc_time tm;
  204. ktime_t min, now;
  205. unsigned long flags;
  206. struct rtc_device *rtc;
  207. int i;
  208. spin_lock_irqsave(&freezer_delta_lock, flags);
  209. min = freezer_delta;
  210. freezer_delta = ktime_set(0, 0);
  211. spin_unlock_irqrestore(&freezer_delta_lock, flags);
  212. rtc = alarmtimer_get_rtcdev();
  213. /* If we have no rtcdev, just return */
  214. if (!rtc)
  215. return 0;
  216. /* Find the soonest timer to expire*/
  217. for (i = 0; i < ALARM_NUMTYPE; i++) {
  218. struct alarm_base *base = &alarm_bases[i];
  219. struct timerqueue_node *next;
  220. ktime_t delta;
  221. spin_lock_irqsave(&base->lock, flags);
  222. next = timerqueue_getnext(&base->timerqueue);
  223. spin_unlock_irqrestore(&base->lock, flags);
  224. if (!next)
  225. continue;
  226. delta = ktime_sub(next->expires, base->gettime());
  227. if (!min.tv64 || (delta.tv64 < min.tv64))
  228. min = delta;
  229. }
  230. if (min.tv64 == 0)
  231. return 0;
  232. /* XXX - Should we enforce a minimum sleep time? */
  233. WARN_ON(min.tv64 < NSEC_PER_SEC);
  234. /* Setup an rtc timer to fire that far in the future */
  235. rtc_timer_cancel(rtc, &rtctimer);
  236. rtc_read_time(rtc, &tm);
  237. now = rtc_tm_to_ktime(tm);
  238. now = ktime_add(now, min);
  239. rtc_timer_start(rtc, &rtctimer, now, ktime_set(0, 0));
  240. return 0;
  241. }
  242. #else
  243. static int alarmtimer_suspend(struct device *dev)
  244. {
  245. return 0;
  246. }
  247. #endif
  248. static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
  249. {
  250. ktime_t delta;
  251. unsigned long flags;
  252. struct alarm_base *base = &alarm_bases[type];
  253. delta = ktime_sub(absexp, base->gettime());
  254. spin_lock_irqsave(&freezer_delta_lock, flags);
  255. if (!freezer_delta.tv64 || (delta.tv64 < freezer_delta.tv64))
  256. freezer_delta = delta;
  257. spin_unlock_irqrestore(&freezer_delta_lock, flags);
  258. }
  259. /**
  260. * alarm_init - Initialize an alarm structure
  261. * @alarm: ptr to alarm to be initialized
  262. * @type: the type of the alarm
  263. * @function: callback that is run when the alarm fires
  264. */
  265. void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
  266. enum alarmtimer_restart (*function)(struct alarm *, ktime_t))
  267. {
  268. timerqueue_init(&alarm->node);
  269. alarm->function = function;
  270. alarm->type = type;
  271. alarm->state = ALARMTIMER_STATE_INACTIVE;
  272. }
  273. /**
  274. * alarm_start - Sets an alarm to fire
  275. * @alarm: ptr to alarm to set
  276. * @start: time to run the alarm
  277. */
  278. void alarm_start(struct alarm *alarm, ktime_t start)
  279. {
  280. struct alarm_base *base = &alarm_bases[alarm->type];
  281. unsigned long flags;
  282. spin_lock_irqsave(&base->lock, flags);
  283. if (alarmtimer_active(alarm))
  284. alarmtimer_remove(base, alarm);
  285. alarm->node.expires = start;
  286. alarmtimer_enqueue(base, alarm);
  287. spin_unlock_irqrestore(&base->lock, flags);
  288. }
  289. /**
  290. * alarm_try_to_cancel - Tries to cancel an alarm timer
  291. * @alarm: ptr to alarm to be canceled
  292. *
  293. * Returns 1 if the timer was canceled, 0 if it was not running,
  294. * and -1 if the callback was running
  295. */
  296. int alarm_try_to_cancel(struct alarm *alarm)
  297. {
  298. struct alarm_base *base = &alarm_bases[alarm->type];
  299. unsigned long flags;
  300. int ret = -1;
  301. spin_lock_irqsave(&base->lock, flags);
  302. if (alarmtimer_callback_running(alarm))
  303. goto out;
  304. if (alarmtimer_is_queued(alarm)) {
  305. alarmtimer_remove(base, alarm);
  306. ret = 1;
  307. } else
  308. ret = 0;
  309. out:
  310. spin_unlock_irqrestore(&base->lock, flags);
  311. return ret;
  312. }
  313. /**
  314. * alarm_cancel - Spins trying to cancel an alarm timer until it is done
  315. * @alarm: ptr to alarm to be canceled
  316. *
  317. * Returns 1 if the timer was canceled, 0 if it was not active.
  318. */
  319. int alarm_cancel(struct alarm *alarm)
  320. {
  321. for (;;) {
  322. int ret = alarm_try_to_cancel(alarm);
  323. if (ret >= 0)
  324. return ret;
  325. cpu_relax();
  326. }
  327. }
  328. u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
  329. {
  330. u64 overrun = 1;
  331. ktime_t delta;
  332. delta = ktime_sub(now, alarm->node.expires);
  333. if (delta.tv64 < 0)
  334. return 0;
  335. if (unlikely(delta.tv64 >= interval.tv64)) {
  336. s64 incr = ktime_to_ns(interval);
  337. overrun = ktime_divns(delta, incr);
  338. alarm->node.expires = ktime_add_ns(alarm->node.expires,
  339. incr*overrun);
  340. if (alarm->node.expires.tv64 > now.tv64)
  341. return overrun;
  342. /*
  343. * This (and the ktime_add() below) is the
  344. * correction for exact:
  345. */
  346. overrun++;
  347. }
  348. alarm->node.expires = ktime_add(alarm->node.expires, interval);
  349. return overrun;
  350. }
  351. /**
  352. * clock2alarm - helper that converts from clockid to alarmtypes
  353. * @clockid: clockid.
  354. */
  355. static enum alarmtimer_type clock2alarm(clockid_t clockid)
  356. {
  357. if (clockid == CLOCK_REALTIME_ALARM)
  358. return ALARM_REALTIME;
  359. if (clockid == CLOCK_BOOTTIME_ALARM)
  360. return ALARM_BOOTTIME;
  361. return -1;
  362. }
  363. /**
  364. * alarm_handle_timer - Callback for posix timers
  365. * @alarm: alarm that fired
  366. *
  367. * Posix timer callback for expired alarm timers.
  368. */
  369. static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
  370. ktime_t now)
  371. {
  372. struct k_itimer *ptr = container_of(alarm, struct k_itimer,
  373. it.alarm.alarmtimer);
  374. if (posix_timer_event(ptr, 0) != 0)
  375. ptr->it_overrun++;
  376. /* Re-add periodic timers */
  377. if (ptr->it.alarm.interval.tv64) {
  378. ptr->it_overrun += alarm_forward(alarm, now,
  379. ptr->it.alarm.interval);
  380. return ALARMTIMER_RESTART;
  381. }
  382. return ALARMTIMER_NORESTART;
  383. }
  384. /**
  385. * alarm_clock_getres - posix getres interface
  386. * @which_clock: clockid
  387. * @tp: timespec to fill
  388. *
  389. * Returns the granularity of underlying alarm base clock
  390. */
  391. static int alarm_clock_getres(const clockid_t which_clock, struct timespec *tp)
  392. {
  393. clockid_t baseid = alarm_bases[clock2alarm(which_clock)].base_clockid;
  394. if (!alarmtimer_get_rtcdev())
  395. return -ENOTSUPP;
  396. return hrtimer_get_res(baseid, tp);
  397. }
  398. /**
  399. * alarm_clock_get - posix clock_get interface
  400. * @which_clock: clockid
  401. * @tp: timespec to fill.
  402. *
  403. * Provides the underlying alarm base time.
  404. */
  405. static int alarm_clock_get(clockid_t which_clock, struct timespec *tp)
  406. {
  407. struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
  408. if (!alarmtimer_get_rtcdev())
  409. return -ENOTSUPP;
  410. *tp = ktime_to_timespec(base->gettime());
  411. return 0;
  412. }
  413. /**
  414. * alarm_timer_create - posix timer_create interface
  415. * @new_timer: k_itimer pointer to manage
  416. *
  417. * Initializes the k_itimer structure.
  418. */
  419. static int alarm_timer_create(struct k_itimer *new_timer)
  420. {
  421. enum alarmtimer_type type;
  422. struct alarm_base *base;
  423. if (!alarmtimer_get_rtcdev())
  424. return -ENOTSUPP;
  425. if (!capable(CAP_WAKE_ALARM))
  426. return -EPERM;
  427. type = clock2alarm(new_timer->it_clock);
  428. base = &alarm_bases[type];
  429. alarm_init(&new_timer->it.alarm.alarmtimer, type, alarm_handle_timer);
  430. return 0;
  431. }
  432. /**
  433. * alarm_timer_get - posix timer_get interface
  434. * @new_timer: k_itimer pointer
  435. * @cur_setting: itimerspec data to fill
  436. *
  437. * Copies the itimerspec data out from the k_itimer
  438. */
  439. static void alarm_timer_get(struct k_itimer *timr,
  440. struct itimerspec *cur_setting)
  441. {
  442. memset(cur_setting, 0, sizeof(struct itimerspec));
  443. cur_setting->it_interval =
  444. ktime_to_timespec(timr->it.alarm.interval);
  445. cur_setting->it_value =
  446. ktime_to_timespec(timr->it.alarm.alarmtimer.node.expires);
  447. return;
  448. }
  449. /**
  450. * alarm_timer_del - posix timer_del interface
  451. * @timr: k_itimer pointer to be deleted
  452. *
  453. * Cancels any programmed alarms for the given timer.
  454. */
  455. static int alarm_timer_del(struct k_itimer *timr)
  456. {
  457. if (!rtcdev)
  458. return -ENOTSUPP;
  459. if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
  460. return TIMER_RETRY;
  461. return 0;
  462. }
  463. /**
  464. * alarm_timer_set - posix timer_set interface
  465. * @timr: k_itimer pointer to be deleted
  466. * @flags: timer flags
  467. * @new_setting: itimerspec to be used
  468. * @old_setting: itimerspec being replaced
  469. *
  470. * Sets the timer to new_setting, and starts the timer.
  471. */
  472. static int alarm_timer_set(struct k_itimer *timr, int flags,
  473. struct itimerspec *new_setting,
  474. struct itimerspec *old_setting)
  475. {
  476. if (!rtcdev)
  477. return -ENOTSUPP;
  478. if (old_setting)
  479. alarm_timer_get(timr, old_setting);
  480. /* If the timer was already set, cancel it */
  481. if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
  482. return TIMER_RETRY;
  483. /* start the timer */
  484. timr->it.alarm.interval = timespec_to_ktime(new_setting->it_interval);
  485. alarm_start(&timr->it.alarm.alarmtimer,
  486. timespec_to_ktime(new_setting->it_value));
  487. return 0;
  488. }
  489. /**
  490. * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
  491. * @alarm: ptr to alarm that fired
  492. *
  493. * Wakes up the task that set the alarmtimer
  494. */
  495. static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
  496. ktime_t now)
  497. {
  498. struct task_struct *task = (struct task_struct *)alarm->data;
  499. alarm->data = NULL;
  500. if (task)
  501. wake_up_process(task);
  502. return ALARMTIMER_NORESTART;
  503. }
  504. /**
  505. * alarmtimer_do_nsleep - Internal alarmtimer nsleep implementation
  506. * @alarm: ptr to alarmtimer
  507. * @absexp: absolute expiration time
  508. *
  509. * Sets the alarm timer and sleeps until it is fired or interrupted.
  510. */
  511. static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
  512. {
  513. alarm->data = (void *)current;
  514. do {
  515. set_current_state(TASK_INTERRUPTIBLE);
  516. alarm_start(alarm, absexp);
  517. if (likely(alarm->data))
  518. schedule();
  519. alarm_cancel(alarm);
  520. } while (alarm->data && !signal_pending(current));
  521. __set_current_state(TASK_RUNNING);
  522. return (alarm->data == NULL);
  523. }
  524. /**
  525. * update_rmtp - Update remaining timespec value
  526. * @exp: expiration time
  527. * @type: timer type
  528. * @rmtp: user pointer to remaining timepsec value
  529. *
  530. * Helper function that fills in rmtp value with time between
  531. * now and the exp value
  532. */
  533. static int update_rmtp(ktime_t exp, enum alarmtimer_type type,
  534. struct timespec __user *rmtp)
  535. {
  536. struct timespec rmt;
  537. ktime_t rem;
  538. rem = ktime_sub(exp, alarm_bases[type].gettime());
  539. if (rem.tv64 <= 0)
  540. return 0;
  541. rmt = ktime_to_timespec(rem);
  542. if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
  543. return -EFAULT;
  544. return 1;
  545. }
  546. /**
  547. * alarm_timer_nsleep_restart - restartblock alarmtimer nsleep
  548. * @restart: ptr to restart block
  549. *
  550. * Handles restarted clock_nanosleep calls
  551. */
  552. static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
  553. {
  554. enum alarmtimer_type type = restart->nanosleep.clockid;
  555. ktime_t exp;
  556. struct timespec __user *rmtp;
  557. struct alarm alarm;
  558. int ret = 0;
  559. exp.tv64 = restart->nanosleep.expires;
  560. alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
  561. if (alarmtimer_do_nsleep(&alarm, exp))
  562. goto out;
  563. if (freezing(current))
  564. alarmtimer_freezerset(exp, type);
  565. rmtp = restart->nanosleep.rmtp;
  566. if (rmtp) {
  567. ret = update_rmtp(exp, type, rmtp);
  568. if (ret <= 0)
  569. goto out;
  570. }
  571. /* The other values in restart are already filled in */
  572. ret = -ERESTART_RESTARTBLOCK;
  573. out:
  574. return ret;
  575. }
  576. /**
  577. * alarm_timer_nsleep - alarmtimer nanosleep
  578. * @which_clock: clockid
  579. * @flags: determins abstime or relative
  580. * @tsreq: requested sleep time (abs or rel)
  581. * @rmtp: remaining sleep time saved
  582. *
  583. * Handles clock_nanosleep calls against _ALARM clockids
  584. */
  585. static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
  586. struct timespec *tsreq, struct timespec __user *rmtp)
  587. {
  588. enum alarmtimer_type type = clock2alarm(which_clock);
  589. struct alarm alarm;
  590. ktime_t exp;
  591. int ret = 0;
  592. struct restart_block *restart;
  593. if (!alarmtimer_get_rtcdev())
  594. return -ENOTSUPP;
  595. if (!capable(CAP_WAKE_ALARM))
  596. return -EPERM;
  597. alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
  598. exp = timespec_to_ktime(*tsreq);
  599. /* Convert (if necessary) to absolute time */
  600. if (flags != TIMER_ABSTIME) {
  601. ktime_t now = alarm_bases[type].gettime();
  602. exp = ktime_add(now, exp);
  603. }
  604. if (alarmtimer_do_nsleep(&alarm, exp))
  605. goto out;
  606. if (freezing(current))
  607. alarmtimer_freezerset(exp, type);
  608. /* abs timers don't set remaining time or restart */
  609. if (flags == TIMER_ABSTIME) {
  610. ret = -ERESTARTNOHAND;
  611. goto out;
  612. }
  613. if (rmtp) {
  614. ret = update_rmtp(exp, type, rmtp);
  615. if (ret <= 0)
  616. goto out;
  617. }
  618. restart = &current_thread_info()->restart_block;
  619. restart->fn = alarm_timer_nsleep_restart;
  620. restart->nanosleep.clockid = type;
  621. restart->nanosleep.expires = exp.tv64;
  622. restart->nanosleep.rmtp = rmtp;
  623. ret = -ERESTART_RESTARTBLOCK;
  624. out:
  625. return ret;
  626. }
  627. /* Suspend hook structures */
  628. static const struct dev_pm_ops alarmtimer_pm_ops = {
  629. .suspend = alarmtimer_suspend,
  630. };
  631. static struct platform_driver alarmtimer_driver = {
  632. .driver = {
  633. .name = "alarmtimer",
  634. .pm = &alarmtimer_pm_ops,
  635. }
  636. };
  637. /**
  638. * alarmtimer_init - Initialize alarm timer code
  639. *
  640. * This function initializes the alarm bases and registers
  641. * the posix clock ids.
  642. */
  643. static int __init alarmtimer_init(void)
  644. {
  645. int error = 0;
  646. int i;
  647. struct k_clock alarm_clock = {
  648. .clock_getres = alarm_clock_getres,
  649. .clock_get = alarm_clock_get,
  650. .timer_create = alarm_timer_create,
  651. .timer_set = alarm_timer_set,
  652. .timer_del = alarm_timer_del,
  653. .timer_get = alarm_timer_get,
  654. .nsleep = alarm_timer_nsleep,
  655. };
  656. posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
  657. posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
  658. /* Initialize alarm bases */
  659. alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
  660. alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
  661. alarm_bases[ALARM_BOOTTIME].base_clockid = CLOCK_BOOTTIME;
  662. alarm_bases[ALARM_BOOTTIME].gettime = &ktime_get_boottime;
  663. for (i = 0; i < ALARM_NUMTYPE; i++) {
  664. timerqueue_init_head(&alarm_bases[i].timerqueue);
  665. spin_lock_init(&alarm_bases[i].lock);
  666. hrtimer_init(&alarm_bases[i].timer,
  667. alarm_bases[i].base_clockid,
  668. HRTIMER_MODE_ABS);
  669. alarm_bases[i].timer.function = alarmtimer_fired;
  670. }
  671. alarmtimer_rtc_interface_setup();
  672. error = platform_driver_register(&alarmtimer_driver);
  673. platform_device_register_simple("alarmtimer", -1, NULL, 0);
  674. return error;
  675. }
  676. device_initcall(alarmtimer_init);