timer: Implement TIMER_IRQSAFE

#endif

/*

 * Note that all tvec_bases are 2 byte aligned and lower bit of

 * base in timer_list is guaranteed to be zero. Use the LSB to

 * indicate whether the timer is deferrable.

 * Note that all tvec_bases are at least 4 byte aligned and lower two bits

 * of base in timer_list is guaranteed to be zero. Use them for flags.

 *

 * A deferrable timer will work normally when the system is busy, but

 * will not cause a CPU to come out of idle just to service it; instead,

 * the timer will be serviced when the CPU eventually wakes up with a

 * subsequent non-deferrable timer.

 *

 * An irqsafe timer is executed with IRQ disabled and it's safe to wait for

 * the completion of the running instance from IRQ handlers, for example,

 * by calling del_timer_sync().

 *

 * Note: The irq disabled callback execution is a special case for

 * workqueue locking issues. It's not meant for executing random crap

 * with interrupts disabled. Abuse is monitored!

 */

#define TIMER_DEFERRABLE		0x1LU

#define TIMER_IRQSAFE			0x2LU

#define TIMER_FLAG_MASK			0x1LU

#define TIMER_FLAG_MASK			0x3LU

#define __TIMER_INITIALIZER(_function, _expires, _data, _flags) { \

		.entry = { .prev = TIMER_ENTRY_STATIC },	\

	return ((unsigned int)(unsigned long)base & TIMER_DEFERRABLE);

}

static inline unsigned int tbase_get_irqsafe(struct tvec_base *base)

{

	return ((unsigned int)(unsigned long)base & TIMER_IRQSAFE);

}

static inline struct tvec_base *tbase_get_base(struct tvec_base *base)

{

	return ((struct tvec_base *)((unsigned long)base & ~TIMER_FLAG_MASK));

 *

 * Synchronization rules: Callers must prevent restarting of the timer,

 * otherwise this function is meaningless. It must not be called from

 * interrupt contexts. The caller must not hold locks which would prevent

 * completion of the timer's handler. The timer's handler must not call

 * add_timer_on(). Upon exit the timer is not queued and the handler is

 * not running on any CPU.

 * interrupt contexts unless the timer is an irqsafe one. The caller must

 * not hold locks which would prevent completion of the timer's

 * handler. The timer's handler must not call add_timer_on(). Upon exit the

 * timer is not queued and the handler is not running on any CPU.

 *

 * Note: You must not hold locks that are held in interrupt context

 *   while calling this function. Even if the lock has nothing to do

 *   with the timer in question.  Here's why:

 * Note: For !irqsafe timers, you must not hold locks that are held in

 *   interrupt context while calling this function. Even if the lock has

 *   nothing to do with the timer in question.  Here's why:

 *

 *    CPU0                             CPU1

 *    ----                             ----

	 * don't use it in hardirq context, because it

	 * could lead to deadlock.

	 */

	WARN_ON(in_irq());

	WARN_ON(in_irq() && !tbase_get_irqsafe(timer->base));

	for (;;) {

		int ret = try_to_del_timer_sync(timer);

		if (ret >= 0)

		while (!list_empty(head)) {

			void (*fn)(unsigned long);

			unsigned long data;

			bool irqsafe;

			timer = list_first_entry(head, struct timer_list,entry);

			fn = timer->function;

			data = timer->data;

			irqsafe = tbase_get_irqsafe(timer->base);

			timer_stats_account_timer(timer);

			base->running_timer = timer;

			detach_expired_timer(timer, base);

			if (irqsafe) {

				spin_unlock(&base->lock);

				call_timer_fn(timer, fn, data);

				spin_lock(&base->lock);

			} else {

				spin_unlock_irq(&base->lock);

				call_timer_fn(timer, fn, data);

				spin_lock_irq(&base->lock);

			}

		}

	}

	base->running_timer = NULL;

	spin_unlock_irq(&base->lock);

}