1/*
  2 * linux/kernel/time/tick-broadcast-hrtimer.c
  3 * This file emulates a local clock event device
  4 * via a pseudo clock device.
  5 */
  6#include <linux/cpu.h>
  7#include <linux/err.h>
  8#include <linux/hrtimer.h>
  9#include <linux/interrupt.h>
 10#include <linux/percpu.h>
 11#include <linux/profile.h>
 12#include <linux/clockchips.h>
 13#include <linux/sched.h>
 14#include <linux/smp.h>
 15#include <linux/module.h>
 16
 17#include "tick-internal.h"
 18
 19static struct hrtimer bctimer;
 20
 21static void bc_set_mode(enum clock_event_mode mode,
 22			struct clock_event_device *bc)
 23{
 24	switch (mode) {
 25	case CLOCK_EVT_MODE_SHUTDOWN:
 26		/*
 27		 * Note, we cannot cancel the timer here as we might
 28		 * run into the following live lock scenario:
 29		 *
 30		 * cpu 0		cpu1
 31		 * lock(broadcast_lock);
 32		 *			hrtimer_interrupt()
 33		 *			bc_handler()
 34		 *			   tick_handle_oneshot_broadcast();
 35		 *			    lock(broadcast_lock);
 36		 * hrtimer_cancel()
 37		 *  wait_for_callback()
 38		 */
 39		hrtimer_try_to_cancel(&bctimer);
 40		break;
 41	default:
 42		break;
 43	}
 44}
 45
 46/*
 47 * This is called from the guts of the broadcast code when the cpu
 48 * which is about to enter idle has the earliest broadcast timer event.
 49 */
 50static int bc_set_next(ktime_t expires, struct clock_event_device *bc)
 51{
 52	/*
 53	 * We try to cancel the timer first. If the callback is on
 54	 * flight on some other cpu then we let it handle it. If we
 55	 * were able to cancel the timer nothing can rearm it as we
 56	 * own broadcast_lock.
 57	 *
 58	 * However we can also be called from the event handler of
 59	 * ce_broadcast_hrtimer itself when it expires. We cannot
 60	 * restart the timer because we are in the callback, but we
 61	 * can set the expiry time and let the callback return
 62	 * HRTIMER_RESTART.
 63	 */
 64	if (hrtimer_try_to_cancel(&bctimer) >= 0) {
 65		hrtimer_start(&bctimer, expires, HRTIMER_MODE_ABS_PINNED);
 66		/* Bind the "device" to the cpu */
 67		bc->bound_on = smp_processor_id();
 68	} else if (bc->bound_on == smp_processor_id()) {
 69		hrtimer_set_expires(&bctimer, expires);
 70	}
 71	return 0;
 72}
 73
 74static struct clock_event_device ce_broadcast_hrtimer = {
 75	.set_mode		= bc_set_mode,
 76	.set_next_ktime		= bc_set_next,
 77	.features		= CLOCK_EVT_FEAT_ONESHOT |
 78				  CLOCK_EVT_FEAT_KTIME |
 79				  CLOCK_EVT_FEAT_HRTIMER,
 80	.rating			= 0,
 81	.bound_on		= -1,
 82	.min_delta_ns		= 1,
 83	.max_delta_ns		= KTIME_MAX,
 84	.min_delta_ticks	= 1,
 85	.max_delta_ticks	= ULONG_MAX,
 86	.mult			= 1,
 87	.shift			= 0,
 88	.cpumask		= cpu_all_mask,
 89};
 90
 91static enum hrtimer_restart bc_handler(struct hrtimer *t)
 92{
 93	ce_broadcast_hrtimer.event_handler(&ce_broadcast_hrtimer);
 94
 95	if (ce_broadcast_hrtimer.next_event.tv64 == KTIME_MAX)
 96		return HRTIMER_NORESTART;
 97
 98	return HRTIMER_RESTART;
 99}
100
101void tick_setup_hrtimer_broadcast(void)
102{
103	hrtimer_init(&bctimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
104	bctimer.function = bc_handler;
105	clockevents_register_device(&ce_broadcast_hrtimer);
106}