#ifndef __LITMUS_SOFTIRQ_H
#define __LITMUS_SOFTIRQ_H

#include <linux/interrupt.h>
#include <linux/workqueue.h>

/*
   Threaded tasklet handling for Litmus.  Tasklets
   are scheduled with the priority of the tasklet's
   owner---that is, the RT task on behalf the tasklet
   runs.
 
   Tasklets are current scheduled in FIFO order with
   NO priority inheritance for "blocked" tasklets.
 
   klitirqd assumes the priority of the owner of the
   tasklet when the tasklet is next to execute.
 
   Currently, hi-tasklets are scheduled before
   low-tasklets, regardless of priority of low-tasklets.
   And likewise, low-tasklets are scheduled before work
   queue objects.  This priority inversion probably needs
   to be fixed, though it is not an issue if our work with
   GPUs as GPUs are owned (and associated klitirqds) for
   exclusive time periods, thus no inversions can
   occur.
 */



#define NR_LITMUS_SOFTIRQD CONFIG_NR_LITMUS_SOFTIRQD

/* Spawns NR_LITMUS_SOFTIRQD klitirqd daemons.
   Actual launch of threads is deffered to kworker's
   workqueue, so daemons will likely not be immediately
   running when this function returns, though the required
   data will be initialized.
 
   @affinity_set: an array expressing the processor affinity
    for each of the NR_LITMUS_SOFTIRQD daemons.  May be set
    to NULL for global scheduling.
 
	- Examples -
	8-CPU system with two CPU clusters:
		affinity[] = {0, 0, 0, 0, 3, 3, 3, 3}
		NOTE: Daemons not actually bound to specified CPU, but rather
		cluster in which the CPU resides.
 
	8-CPU system, partitioned:
		affinity[] = {0, 1, 2, 3, 4, 5, 6, 7}
 
	FIXME: change array to a CPU topology or array of cpumasks
 
 */
void spawn_klitirqd(int* affinity);


/* Raises a flag to tell klitirqds to terminate.
   Termination is async, so some threads may be running
   after function return. */
void kill_klitirqd(void);


/* Returns 1 if all NR_LITMUS_SOFTIRQD klitirqs are ready
   to handle tasklets. 0, otherwise.*/
int klitirqd_is_ready(void);

/* Returns 1 if no NR_LITMUS_SOFTIRQD klitirqs are ready
   to handle tasklets. 0, otherwise.*/
int klitirqd_is_dead(void);

/* Flushes all pending work out to the OS for regular
 * tasklet/work processing of the specified 'owner'
 *
 * PRECOND: klitirqd_thread must have a clear entry
 * in the GPU registry, otherwise this call will become
 * a no-op as work will loop back to the klitirqd_thread.
 *
 * Pass NULL for owner to flush ALL pending items.
 */
void flush_pending(struct task_struct* klitirqd_thread,
				   struct task_struct* owner);

struct task_struct* get_klitirqd(unsigned int k_id);


extern int __litmus_tasklet_schedule(
        struct tasklet_struct *t,
        unsigned int k_id);

/* schedule a tasklet on klitirqd #k_id */
static inline int litmus_tasklet_schedule(
    struct tasklet_struct *t,
    unsigned int k_id)
{
	int ret = 0;
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		ret = __litmus_tasklet_schedule(t, k_id);
	return(ret);
}

/* for use by __tasklet_schedule() */
static inline int _litmus_tasklet_schedule(
    struct tasklet_struct *t,
    unsigned int k_id)
{
    return(__litmus_tasklet_schedule(t, k_id));
}




extern int __litmus_tasklet_hi_schedule(struct tasklet_struct *t,
                                         unsigned int k_id);

/* schedule a hi tasklet on klitirqd #k_id */
static inline int litmus_tasklet_hi_schedule(struct tasklet_struct *t,
                                              unsigned int k_id)
{
	int ret = 0;
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		ret = __litmus_tasklet_hi_schedule(t, k_id);
	return(ret);
}

/* for use by __tasklet_hi_schedule() */
static inline int _litmus_tasklet_hi_schedule(struct tasklet_struct *t,
                                               unsigned int k_id)
{
    return(__litmus_tasklet_hi_schedule(t, k_id));
}





extern int __litmus_tasklet_hi_schedule_first(
    struct tasklet_struct *t,
    unsigned int k_id);

/* schedule a hi tasklet on klitirqd #k_id on next go-around */
/* PRECONDITION: Interrupts must be disabled. */
static inline int litmus_tasklet_hi_schedule_first(
    struct tasklet_struct *t,
    unsigned int k_id)
{
	int ret = 0;
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		ret = __litmus_tasklet_hi_schedule_first(t, k_id);
	return(ret);
}

/* for use by __tasklet_hi_schedule_first() */
static inline int _litmus_tasklet_hi_schedule_first(
    struct tasklet_struct *t,
    unsigned int k_id)
{
    return(__litmus_tasklet_hi_schedule_first(t, k_id));
}



//////////////

extern int __litmus_schedule_work(
	struct work_struct* w,
	unsigned int k_id);

static inline int litmus_schedule_work(
	struct work_struct* w,
	unsigned int k_id)
{
	return(__litmus_schedule_work(w, k_id));
}



///////////// mutex operations for client threads.
 
void down_and_set_stat(struct task_struct* t,
					 enum klitirqd_sem_status to_set,
					 struct mutex* sem);

void __down_and_reset_and_set_stat(struct task_struct* t,
				enum klitirqd_sem_status to_reset,
				enum klitirqd_sem_status to_set,
				struct mutex* sem);

void up_and_set_stat(struct task_struct* t,
					enum klitirqd_sem_status to_set,
					struct mutex* sem);



void release_klitirqd_lock(struct task_struct* t);

int reacquire_klitirqd_lock(struct task_struct* t);

#endif