/*
 * Copyright (C) 2008 Philippe Gerum <rpm@xenomai.org>.
 *
 * Xenomai is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * Xenomai is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Xenomai; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#ifndef _COBALT_KERNEL_SCHED_H
#define _COBALT_KERNEL_SCHED_H

#include <linux/percpu.h>
#include <cobalt/kernel/lock.h>
#include <cobalt/kernel/thread.h>
#include <cobalt/kernel/schedqueue.h>
#include <cobalt/kernel/sched-tp.h>
#include <cobalt/kernel/sched-weak.h>
#include <cobalt/kernel/sched-sporadic.h>
#include <cobalt/kernel/sched-quota.h>
#include <cobalt/kernel/vfile.h>
#include <cobalt/kernel/assert.h>
#include <asm/xenomai/machine.h>
#include <pipeline/sched.h>

/**
 * @addtogroup cobalt_core_sched
 * @{
 */

/* Sched status flags */
#define XNRESCHED	0x10000000	/* Needs rescheduling */
#define XNINSW		0x20000000	/* In context switch */
#define XNINTCK		0x40000000	/* In master tick handler context */

/* Sched local flags */
#define XNIDLE		0x00010000	/* Idle (no outstanding timer) */
#define XNHTICK		0x00008000	/* Host tick pending  */
#define XNINIRQ		0x00004000	/* In IRQ handling context */
#define XNHDEFER	0x00002000	/* Host tick deferred */

/*
 * Hardware timer is stopped.
 */
#define XNTSTOP		0x00000800

struct xnsched_rt {
	xnsched_queue_t runnable;	/*!< Runnable thread queue. */
};

/*!
 * \brief Scheduling information structure.
 */

struct xnsched {
	/*!< Scheduler specific status bitmask. */
	unsigned long status;
	/*!< Scheduler specific local flags bitmask. */
	unsigned long lflags;
	/*!< Current thread. */
	struct xnthread *curr;
#ifdef CONFIG_SMP
	/*!< Owner CPU id. */
	int cpu;
	/*!< Mask of CPUs needing rescheduling. */
	cpumask_t resched;
#endif
	/*!< Context of built-in real-time class. */
	struct xnsched_rt rt;
#ifdef CONFIG_XENO_OPT_SCHED_WEAK
	/*!< Context of weak scheduling class. */
	struct xnsched_weak weak;
#endif
#ifdef CONFIG_XENO_OPT_SCHED_TP
	/*!< Context of TP class. */
	struct xnsched_tp tp;
#endif
#ifdef CONFIG_XENO_OPT_SCHED_SPORADIC
	/*!< Context of sporadic scheduling class. */
	struct xnsched_sporadic pss;
#endif
#ifdef CONFIG_XENO_OPT_SCHED_QUOTA
	/*!< Context of runtime quota scheduling. */
	struct xnsched_quota quota;
#endif
	/*!< Interrupt nesting level. */
	volatile unsigned inesting;
	/*!< Host timer. */
	struct xntimer htimer;
	/*!< Round-robin timer. */
	struct xntimer rrbtimer;
	/*!< Root thread control block. */
	struct xnthread rootcb;
#ifdef CONFIG_XENO_ARCH_FPU
	/*!< Thread owning the current FPU context. */
	struct xnthread *fpuholder;
#endif
#ifdef CONFIG_XENO_OPT_WATCHDOG
	/*!< Watchdog timer object. */
	struct xntimer wdtimer;
#endif
#ifdef CONFIG_XENO_OPT_STATS
	/*!< Last account switch date (ticks). */
	xnticks_t last_account_switch;
	/*!< Currently active account */
	xnstat_exectime_t *current_account;
#endif
};

DECLARE_PER_CPU(struct xnsched, nksched);

extern cpumask_t cobalt_cpu_affinity;

extern struct list_head nkthreadq;

extern int cobalt_nrthreads;

#ifdef CONFIG_XENO_OPT_VFILE
extern struct xnvfile_rev_tag nkthreadlist_tag;
#endif

union xnsched_policy_param;

struct xnsched_class {
	void (*sched_init)(struct xnsched *sched);
	void (*sched_enqueue)(struct xnthread *thread);
	void (*sched_dequeue)(struct xnthread *thread);
	void (*sched_requeue)(struct xnthread *thread);
	struct xnthread *(*sched_pick)(struct xnsched *sched);
	void (*sched_tick)(struct xnsched *sched);
	void (*sched_rotate)(struct xnsched *sched,
			     const union xnsched_policy_param *p);
	void (*sched_migrate)(struct xnthread *thread,
			      struct xnsched *sched);
	int (*sched_chkparam)(struct xnthread *thread,
			      const union xnsched_policy_param *p);
	/**
	 * Set base scheduling parameters. This routine is indirectly
	 * called upon a change of base scheduling settings through
	 * __xnthread_set_schedparam() -> xnsched_set_policy(),
	 * exclusively.
	 *
	 * The scheduling class implementation should do the necessary
	 * housekeeping to comply with the new settings.
	 * thread->base_class is up to date before the call is made,
	 * and should be considered for the new weighted priority
	 * calculation. On the contrary, thread->sched_class should
	 * NOT be referred to by this handler.
	 *
	 * sched_setparam() is NEVER involved in PI or PP
	 * management. However it must deny a priority update if it
	 * contradicts an ongoing boost for @a thread. This is
	 * typically what the xnsched_set_effective_priority() helper
	 * does for such handler.
	 *
	 * @param thread Affected thread.
	 * @param p New base policy settings.
	 *
	 * @return True if the effective priority was updated
	 * (thread->cprio).
	 */
	bool (*sched_setparam)(struct xnthread *thread,
			       const union xnsched_policy_param *p);
	void (*sched_getparam)(struct xnthread *thread,
			       union xnsched_policy_param *p);
	void (*sched_trackprio)(struct xnthread *thread,
				const union xnsched_policy_param *p);
	void (*sched_protectprio)(struct xnthread *thread, int prio);
	int (*sched_declare)(struct xnthread *thread,
			     const union xnsched_policy_param *p);
	void (*sched_forget)(struct xnthread *thread);
	void (*sched_kick)(struct xnthread *thread);
#ifdef CONFIG_XENO_OPT_VFILE
	int (*sched_init_vfile)(struct xnsched_class *schedclass,
				struct xnvfile_directory *vfroot);
	void (*sched_cleanup_vfile)(struct xnsched_class *schedclass);
#endif
	int nthreads;
	struct xnsched_class *next;
	int weight;
	int policy;
	const char *name;
};

#define XNSCHED_CLASS_WEIGHT(n)		(n * XNSCHED_CLASS_WEIGHT_FACTOR)

/* Placeholder for current thread priority */
#define XNSCHED_RUNPRIO   0x80000000

#define xnsched_for_each_thread(__thread)	\
	list_for_each_entry(__thread, &nkthreadq, glink)

#ifdef CONFIG_SMP
static inline int xnsched_cpu(struct xnsched *sched)
{
	return sched->cpu;
}
#else /* !CONFIG_SMP */
static inline int xnsched_cpu(struct xnsched *sched)
{
	return 0;
}
#endif /* CONFIG_SMP */

static inline struct xnsched *xnsched_struct(int cpu)
{
	return &per_cpu(nksched, cpu);
}

static inline struct xnsched *xnsched_current(void)
{
	/* IRQs off */
	return raw_cpu_ptr(&nksched);
}

static inline struct xnthread *xnsched_current_thread(void)
{
	return xnsched_current()->curr;
}

/* Test resched flag of given sched. */
static inline int xnsched_resched_p(struct xnsched *sched)
{
	return sched->status & XNRESCHED;
}

/* Set self resched flag for the current scheduler. */
static inline void xnsched_set_self_resched(struct xnsched *sched)
{
	sched->status |= XNRESCHED;
}

/* Set resched flag for the given scheduler. */
#ifdef CONFIG_SMP

static inline void xnsched_set_resched(struct xnsched *sched)
{
	struct xnsched *current_sched = xnsched_current();

	if (current_sched == sched)
		current_sched->status |= XNRESCHED;
	else if (!xnsched_resched_p(sched)) {
		cpumask_set_cpu(xnsched_cpu(sched), &current_sched->resched);
		sched->status |= XNRESCHED;
		current_sched->status |= XNRESCHED;
	}
}

#define xnsched_realtime_cpus    cobalt_pipeline.supported_cpus

static inline int xnsched_supported_cpu(int cpu)
{
	return cpumask_test_cpu(cpu, &xnsched_realtime_cpus);
}

static inline int xnsched_threading_cpu(int cpu)
{
	return cpumask_test_cpu(cpu, &cobalt_cpu_affinity);
}

#else /* !CONFIG_SMP */

static inline void xnsched_set_resched(struct xnsched *sched)
{
	xnsched_set_self_resched(sched);
}

#define xnsched_realtime_cpus CPU_MASK_ALL

static inline int xnsched_supported_cpu(int cpu)
{
	return 1;
}

static inline int xnsched_threading_cpu(int cpu)
{
	return 1;
}

#endif /* !CONFIG_SMP */

#define for_each_realtime_cpu(cpu)		\
	for_each_online_cpu(cpu)		\
		if (xnsched_supported_cpu(cpu))	\

int ___xnsched_run(struct xnsched *sched);

void __xnsched_run_handler(void);

static inline int __xnsched_run(struct xnsched *sched)
{
	/*
	 * Reschedule if XNSCHED is pending, but never over an IRQ
	 * handler or in the middle of unlocked context switch.
	 */
	if (((sched->status|sched->lflags) &
	     (XNINIRQ|XNINSW|XNRESCHED)) != XNRESCHED)
		return 0;

	return pipeline_schedule(sched);
}

static inline int xnsched_run(void)
{
	struct xnsched *sched = xnsched_current();
	/*
	 * sched->curr is shared locklessly with ___xnsched_run().
	 * READ_ONCE() makes sure the compiler never uses load tearing
	 * for reading this pointer piecemeal, so that multiple stores
	 * occurring concurrently on remote CPUs never yield a
	 * spurious merged value on the local one.
	 */
	struct xnthread *curr = READ_ONCE(sched->curr);

	/*
	 * If running over the root thread, hard irqs must be off
	 * (asserted out of line in ___xnsched_run()).
	 */
	return curr->lock_count > 0 ? 0 : __xnsched_run(sched);
}

void xnsched_lock(void);

void xnsched_unlock(void);

static inline int xnsched_interrupt_p(void)
{
	return xnsched_current()->lflags & XNINIRQ;
}

static inline int xnsched_root_p(void)
{
	return xnthread_test_state(xnsched_current_thread(), XNROOT);
}

static inline int xnsched_unblockable_p(void)
{
	return xnsched_interrupt_p() || xnsched_root_p();
}

static inline int xnsched_primary_p(void)
{
	return !xnsched_unblockable_p();
}

bool xnsched_set_effective_priority(struct xnthread *thread,
				    int prio);

#include <cobalt/kernel/sched-idle.h>
#include <cobalt/kernel/sched-rt.h>

int xnsched_init_proc(void);

void xnsched_cleanup_proc(void);

void xnsched_register_classes(void);

void xnsched_init_all(void);

void xnsched_destroy_all(void);

struct xnthread *xnsched_pick_next(struct xnsched *sched);

void xnsched_putback(struct xnthread *thread);

int xnsched_set_policy(struct xnthread *thread,
		       struct xnsched_class *sched_class,
		       const union xnsched_policy_param *p);

void xnsched_track_policy(struct xnthread *thread,
			  struct xnthread *target);

void xnsched_protect_priority(struct xnthread *thread,
			      int prio);

void xnsched_migrate(struct xnthread *thread,
		     struct xnsched *sched);

void xnsched_migrate_passive(struct xnthread *thread,
			     struct xnsched *sched);

/**
 * @fn void xnsched_rotate(struct xnsched *sched, struct xnsched_class *sched_class, const union xnsched_policy_param *sched_param)
 * @brief Rotate a scheduler runqueue.
 *
 * The specified scheduling class is requested to rotate its runqueue
 * for the given scheduler. Rotation is performed according to the
 * scheduling parameter specified by @a sched_param.
 *
 * @note The nucleus supports round-robin scheduling for the members
 * of the RT class.
 *
 * @param sched The per-CPU scheduler hosting the target scheduling
 * class.
 *
 * @param sched_class The scheduling class which should rotate its
 * runqueue.
 *
 * @param sched_param The scheduling parameter providing rotation
 * information to the specified scheduling class.
 *
 * @coretags{unrestricted, atomic-entry}
 */
static inline void xnsched_rotate(struct xnsched *sched,
				  struct xnsched_class *sched_class,
				  const union xnsched_policy_param *sched_param)
{
	sched_class->sched_rotate(sched, sched_param);
}

static inline int xnsched_init_thread(struct xnthread *thread)
{
	int ret = 0;

	xnsched_idle_init_thread(thread);
	xnsched_rt_init_thread(thread);

#ifdef CONFIG_XENO_OPT_SCHED_TP
	ret = xnsched_tp_init_thread(thread);
	if (ret)
		return ret;
#endif /* CONFIG_XENO_OPT_SCHED_TP */
#ifdef CONFIG_XENO_OPT_SCHED_SPORADIC
	ret = xnsched_sporadic_init_thread(thread);
	if (ret)
		return ret;
#endif /* CONFIG_XENO_OPT_SCHED_SPORADIC */
#ifdef CONFIG_XENO_OPT_SCHED_QUOTA
	ret = xnsched_quota_init_thread(thread);
	if (ret)
		return ret;
#endif /* CONFIG_XENO_OPT_SCHED_QUOTA */

	return ret;
}

static inline int xnsched_root_priority(struct xnsched *sched)
{
	return sched->rootcb.cprio;
}

static inline struct xnsched_class *xnsched_root_class(struct xnsched *sched)
{
	return sched->rootcb.sched_class;
}

static inline void xnsched_tick(struct xnsched *sched)
{
	struct xnthread *curr = sched->curr;
	struct xnsched_class *sched_class = curr->sched_class;
	/*
	 * A thread that undergoes round-robin scheduling only
	 * consumes its time slice when it runs within its own
	 * scheduling class, which excludes temporary PI boosts, and
	 * does not hold the scheduler lock.
	 */
	if (sched_class == curr->base_class &&
	    sched_class->sched_tick &&
	    xnthread_test_state(curr, XNTHREAD_BLOCK_BITS|XNRRB) == XNRRB &&
		curr->lock_count == 0)
		sched_class->sched_tick(sched);
}

static inline int xnsched_chkparam(struct xnsched_class *sched_class,
				   struct xnthread *thread,
				   const union xnsched_policy_param *p)
{
	if (sched_class->sched_chkparam)
		return sched_class->sched_chkparam(thread, p);

	return 0;
}

static inline int xnsched_declare(struct xnsched_class *sched_class,
				  struct xnthread *thread,
				  const union xnsched_policy_param *p)
{
	int ret;

	if (sched_class->sched_declare) {
		ret = sched_class->sched_declare(thread, p);
		if (ret)
			return ret;
	}
	if (sched_class != thread->base_class)
		sched_class->nthreads++;

	return 0;
}

static inline int xnsched_calc_wprio(struct xnsched_class *sched_class,
				     int prio)
{
	return prio + sched_class->weight;
}

#ifdef CONFIG_XENO_OPT_SCHED_CLASSES

static inline void xnsched_enqueue(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class != &xnsched_class_idle)
		sched_class->sched_enqueue(thread);
}

static inline void xnsched_dequeue(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class != &xnsched_class_idle)
		sched_class->sched_dequeue(thread);
}

static inline void xnsched_requeue(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class != &xnsched_class_idle)
		sched_class->sched_requeue(thread);
}

static inline
bool xnsched_setparam(struct xnthread *thread,
		      const union xnsched_policy_param *p)
{
	return thread->base_class->sched_setparam(thread, p);
}

static inline void xnsched_getparam(struct xnthread *thread,
				    union xnsched_policy_param *p)
{
	thread->sched_class->sched_getparam(thread, p);
}

static inline void xnsched_trackprio(struct xnthread *thread,
				     const union xnsched_policy_param *p)
{
	thread->sched_class->sched_trackprio(thread, p);
	thread->wprio = xnsched_calc_wprio(thread->sched_class, thread->cprio);
}

static inline void xnsched_protectprio(struct xnthread *thread, int prio)
{
	thread->sched_class->sched_protectprio(thread, prio);
	thread->wprio = xnsched_calc_wprio(thread->sched_class, thread->cprio);
}

static inline void xnsched_forget(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->base_class;

	--sched_class->nthreads;

	if (sched_class->sched_forget)
		sched_class->sched_forget(thread);
}

static inline void xnsched_kick(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->base_class;

	xnthread_set_info(thread, XNKICKED);

	if (sched_class->sched_kick)
		sched_class->sched_kick(thread);

	xnsched_set_resched(thread->sched);
}

#else /* !CONFIG_XENO_OPT_SCHED_CLASSES */

/*
 * If only the RT and IDLE scheduling classes are compiled in, we can
 * fully inline common helpers for dealing with those.
 */

static inline void xnsched_enqueue(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class != &xnsched_class_idle)
		__xnsched_rt_enqueue(thread);
}

static inline void xnsched_dequeue(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class != &xnsched_class_idle)
		__xnsched_rt_dequeue(thread);
}

static inline void xnsched_requeue(struct xnthread *thread)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class != &xnsched_class_idle)
		__xnsched_rt_requeue(thread);
}

static inline bool xnsched_setparam(struct xnthread *thread,
				    const union xnsched_policy_param *p)
{
	struct xnsched_class *sched_class = thread->base_class;

	if (sched_class == &xnsched_class_idle)
		return __xnsched_idle_setparam(thread, p);

	return __xnsched_rt_setparam(thread, p);
}

static inline void xnsched_getparam(struct xnthread *thread,
				    union xnsched_policy_param *p)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class == &xnsched_class_idle)
		__xnsched_idle_getparam(thread, p);
	else
		__xnsched_rt_getparam(thread, p);
}

static inline void xnsched_trackprio(struct xnthread *thread,
				     const union xnsched_policy_param *p)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class == &xnsched_class_idle)
		__xnsched_idle_trackprio(thread, p);
	else
		__xnsched_rt_trackprio(thread, p);

	thread->wprio = xnsched_calc_wprio(sched_class, thread->cprio);
}

static inline void xnsched_protectprio(struct xnthread *thread, int prio)
{
	struct xnsched_class *sched_class = thread->sched_class;

	if (sched_class == &xnsched_class_idle)
		__xnsched_idle_protectprio(thread, prio);
	else
		__xnsched_rt_protectprio(thread, prio);

	thread->wprio = xnsched_calc_wprio(sched_class, thread->cprio);
}

static inline void xnsched_forget(struct xnthread *thread)
{
	--thread->base_class->nthreads;
	__xnsched_rt_forget(thread);
}

static inline void xnsched_kick(struct xnthread *thread)
{
	xnthread_set_info(thread, XNKICKED);
	xnsched_set_resched(thread->sched);
}

#endif /* !CONFIG_XENO_OPT_SCHED_CLASSES */

/** @} */

#endif /* !_COBALT_KERNEL_SCHED_H */