/*
 * \brief   Hardware-interrupt subsystem
 * \author  Thomas Friebel <tf13@os.inf.tu-dresden.de>
 * \author  Christian Helmuth <ch12@os.inf.tu-dresden.de>
 * \date    2007-01-22
 *
 * FIXME could intloop_param freed after startup?
 * FIXME use consume flag to indicate IRQ was handled
 */

#include <l4/dde/ddekit/interrupt.h>
#include <l4/dde/ddekit/semaphore.h>
#include <l4/dde/ddekit/thread.h>
#include <l4/dde/ddekit/memory.h>
#include <l4/dde/ddekit/panic.h>

#include <l4/omega0/client.h>
#include <l4/log/l4log.h>
#include <l4/thread/thread.h>

#include <stdio.h>

#define DEBUG_INTERRUPTS  0

#define MAX_INTERRUPTS   32

#define BLOCK_IRQ         0

/*
 * Internal type for interrupt loop parameters
 */
struct intloop_params
{
	unsigned          irq;       /* irq number */
	int               shared;    /* irq sharing supported? */
	void(*thread_init)(void *);  /* thread initialization */
	void(*handler)(void *);      /* IRQ handler function */
	void             *priv;      /* private token */ 
	ddekit_sem_t     *started;

	int               start_err;
};

static struct
{
	int               handle_irq; /* nested irq disable count */
	ddekit_sem_t     *irqsem;     /* synch semaphore */
	ddekit_thread_t  *irq_thread; /* thread ID for detaching from IRQ later on */
	omega0_irqdesc_t  irq_desc;   /* Omega0-style IRQ descriptor */
} ddekit_irq_ctrl[MAX_INTERRUPTS];


static void ddekit_irq_exit_fn(l4thread_t thread, void *data)
{
	int idx = (int)data;

	// * detach from IRQ
	omega0_detach(ddekit_irq_ctrl[idx].irq_desc);
}

L4THREAD_EXIT_FN_STATIC(exit_fn, ddekit_irq_exit_fn);


/**
 * Interrupt service loop
 *
 */
static void intloop(void *arg)
{
	struct intloop_params *params = arg;

	l4thread_set_prio(l4thread_myself(), DDEKIT_IRQ_PRIO);

    omega0_request_t req  = { .i = 0 };
	int o0handle;
	int my_index = params->irq;
    omega0_irqdesc_t *desc = &ddekit_irq_ctrl[my_index].irq_desc;

	/* setup interrupt descriptor */
	desc->s.num = params->irq + 1;
	desc->s.shared = params->shared;

	/* allocate irq */
	o0handle = omega0_attach(*desc);
	if (o0handle < 0) {
		/* inform thread creator of error */
		/* XXX does omega0 error code have any meaning to DDEKit users? */
		params->start_err = o0handle;
		ddekit_sem_up(params->started);
		return;
	}

	/* 
	 * Setup an exit fn. This will make sure that we clean up everything,
	 * before shutting down an IRQ thread.
	 */
	if (l4thread_on_exit(&exit_fn, (void *)my_index) < 0)
		ddekit_panic("Could not set exit handler for IRQ fn.");

	/* after successful initialization call thread_init() before doing anything
	 * else here */
	if (params->thread_init) params->thread_init(params->priv);

	/* save handle + inform thread creator of success */
	params->start_err = 0;
	ddekit_sem_up(params->started);

	/* prepare request structure */
	req.s.param   = params->irq + 1;
	req.s.wait    = 1;
	req.s.consume = 0;
	req.s.unmask  = 1;

	while (1) {
		int err;

		/* wait for int */
		err = omega0_request(o0handle, req);
		if (err != params->irq + 1)
			LOG("omega0_request returned %d, %d (irq+1) expected", err, params->irq + 1);

		LOGd(DEBUG_INTERRUPTS, "received irq 0x%X", err - 1);

		/* unmask only the first time */
		req.s.unmask = 0;

		/* only call registered handler function, if IRQ is not disabled */
		ddekit_sem_down(ddekit_irq_ctrl[my_index].irqsem);
		if (ddekit_irq_ctrl[my_index].handle_irq > 0) {
			LOGd(DEBUG_INTERRUPTS, "IRQ %x, handler %p", my_index,params->handler);
			params->handler(params->priv);
		}
		else
			LOGd(DEBUG_INTERRUPTS, "not handling IRQ %x, because it is disabled.", my_index);

		ddekit_sem_up(ddekit_irq_ctrl[my_index].irqsem);
		LOGd(DEBUG_INTERRUPTS, "after irq handler");
	}
}


/**
 * Attach to hardware interrupt
 *
 * \param irq          IRQ number to attach to
 * \param shared       set to 1 if interrupt sharing is supported; set to 0
 *                     otherwise
 * \param thread_init  called just after DDEKit internal init and before any
 *                     other function
 * \param handler      IRQ handler for interrupt irq
 * \param priv         private token (argument for thread_init and handler)
 *
 * \return pointer to interrupt thread created
 */
ddekit_thread_t *ddekit_interrupt_attach(int irq, int shared,
                                         void(*thread_init)(void *),
                                         void(*handler)(void *), void *priv)
{
	struct intloop_params *params;
	ddekit_thread_t *thread;
	char thread_name[10];

	/* initialize info structure for interrupt loop */
	params = ddekit_simple_malloc(sizeof(*params));
	if (!params) return NULL;

	params->irq         = irq;
	params->thread_init = thread_init;
	params->handler     = handler;
	params->priv        = priv;
	params->started     = ddekit_sem_init(0);
	params->start_err   = 0;
	params->shared      = shared;

	/* construct name */
	snprintf(thread_name, 10, "irq%02X", irq);

	/* create interrupt loop thread */
	thread = ddekit_thread_create(intloop, params, thread_name);
	if (!thread) {
		ddekit_simple_free(params);
		return NULL;
	}

	ddekit_irq_ctrl[irq].handle_irq = 1; /* IRQ nesting level is initially 1 */
	ddekit_irq_ctrl[irq].irq_thread = thread;
	ddekit_irq_ctrl[irq].irqsem     = ddekit_sem_init(1);


	/* wait for intloop initialization result */
	ddekit_sem_down(params->started);
	ddekit_sem_deinit(params->started);
	if (params->start_err) {
		ddekit_simple_free(params);
		return NULL;
	}

	return thread;
}

/**
 * Detach from interrupt by disabling it and then shutting down the IRQ
 * thread.
 */
void ddekit_interrupt_detach(int irq)
{
	ddekit_interrupt_disable(irq);
	ddekit_thread_terminate(ddekit_irq_ctrl[irq].irq_thread);
}


void ddekit_interrupt_disable(int irq)
{
	if (ddekit_irq_ctrl[irq].irqsem) {
		ddekit_sem_down(ddekit_irq_ctrl[irq].irqsem);
		--ddekit_irq_ctrl[irq].handle_irq;
		ddekit_sem_up(ddekit_irq_ctrl[irq].irqsem);
	}
}


void ddekit_interrupt_enable(int irq)
{
	if (ddekit_irq_ctrl[irq].irqsem) {
		ddekit_sem_down(ddekit_irq_ctrl[irq].irqsem);
		++ddekit_irq_ctrl[irq].handle_irq;
		ddekit_sem_up(ddekit_irq_ctrl[irq].irqsem);
	}
}