Subversion Repositories shark

#include <kernel/int_sem.h>

#include <stdlib.h>

#include <kernel/func.h>

#include <ll/sys/ll/event.h>

#include <ll/i386/pic.h>

#include <tracer.h>

#include <linuxcomp.h>

extern int add_interrupt_job(int no);

extern void set_noint_handler(void * new_handler);

extern int intr_count;

//#define DEBUG_SHARK_GLUE

/* 1-15 for IRQ and 16-63 for timers */

void *timer_arg_table[MAX_TIMER_TABLE];

void *timer_func_table[MAX_TIMER_TABLE];

int  timer_table[MAX_TIMER_TABLE];

int  intr_table[NR_IRQS];

int use_intdrive = 0;

static int current_timer = 0;

void shark_internal_sem_create(void **sem, int init) {

        *sem = (void *)malloc(sizeof(internal_sem_t));

        internal_sem_init((internal_sem_t *)(*sem),init);

}

void shark_internal_sem_wait(void *sem) {

        internal_sem_wait((internal_sem_t *)(sem));

}

void shark_internal_sem_post(void *sem) {

        internal_sem_post((internal_sem_t *)(sem));

}

/* Timers */

int get_free_timer_slot()

{

        int i = current_timer;

        while(timer_table[i] != -1) {

                if (i < MAX_TIMER_TABLE) {

                        i++;

                } else {

                        i = 0;

                }

                if (i == current_timer) return -1;

        }

        current_timer = i+1;

        if (current_timer >= MAX_TIMER_TABLE) current_timer = 0;

        return i;

}

void shark_timer_exec(int n)

{

        int no = n - 16;

        void(*tmp_func)(void*) = timer_func_table[no];

#ifdef DEBUG_SHARK_GLUE

        cprintf("(Timer EXEC %d)", no);

#endif

        if (tmp_func != NULL){

                intr_count++;

                (tmp_func)(timer_arg_table[no]);

                intr_count--;

        }

        timer_table[no] = -1;

        timer_func_table[no] = NULL;

        timer_arg_table[no] = NULL;

}

void fast_call_timer(void *arg)

{

        int no = (int)arg;

        int res;

#ifdef DEBUG_SHARK_GLUE

        cprintf("(Timer fast %d)", no);

#endif

        timer_table[no] = -2;

        if (use_intdrive == TRUE) {

                res = add_interrupt_job(no+16);

        } else {

                shark_timer_exec(no+16);

        }

}

int shark_timer_set(const struct timespec *time, void *handler, void *arg)

{

        SYS_FLAGS f;

        int i;

        f = kern_fsave();

        i = get_free_timer_slot();

        if (i == -1) {

                kern_frestore(f);

                return -1;

        }

        timer_func_table[i] = handler;

        timer_arg_table[i] = arg;

        timer_table[i] = kern_event_post(time, fast_call_timer, (void *)(i));

        if (timer_table[i] == -1) {

                kern_frestore(f);

                return -1;

        }

        kern_frestore(f);

        return i;

}

int shark_timer_delete(int index)

{

        SYS_FLAGS f;

        f = kern_fsave();

        if (index < 0 || index >= MAX_TIMER_TABLE) {

                kern_frestore(f);

                return -1;

        }

#ifdef DEBUG_SHARK_GLUE

        cprintf("(Timer Del %d)", index);

#endif

        if (timer_table[index] != -1 && timer_table[index] != -2) {

                timer_func_table[index] = NULL;

                timer_arg_table[index] = NULL;

                kern_event_delete(timer_table[index]);

                timer_table[index] = -1;

        }

        kern_frestore(f);

        return 0;

}

/* Interrupt */

int shark_handler_set(int no, void *fast){

        if ((no >= 1) && (no < 16) && (intr_table[no] <= 0)) {

                if (use_intdrive == TRUE) {

                        intr_table[no] = handler_set(no, NULL, TRUE, NIL, fast);

#ifdef DEBUG_SHARK_GLUE

                        cprintf("(shark_handler_set - INT: %d - %d)", no, intr_table[no]);

#endif

                } else {

                        intr_table[no] = handler_set(no, fast, TRUE, NIL, NULL);

#ifdef DEBUG_SHARK_GLUE

                        cprintf("(Shark_Handler_Set - NOINT: %d - %d)", no, intr_table[no]);

#endif

                }

                return intr_table[no];

        } else {

#ifdef DEBUG_SHARK_GLUE

                cprintf("(shark_handler_set - ERR: %d - %d)", no, intr_table[no]);

#endif

                return -1;

        }

}

int shark_handler_remove(int no){

        if (intr_table[no] == 1) {

                handler_remove(no);

#ifdef DEBUG_SHARK_GLUE

                cprintf("(shark_handler_remove: %d)", no);

#endif

                intr_table[no] = 0;

        }

        return 0;

}

/* Boot function */

int shark_interrupt_server(int use_intdrv) {

        int i;

        for(i=0; i<MAX_TIMER_TABLE; i++) {

                timer_arg_table[i] = NULL;

                timer_func_table[i] = NULL;

                timer_table[i] = -1;

        }

        for(i=0; i<NR_IRQS; i++) {

                intr_table[i] = 0;

        }

        use_intdrive = use_intdrv;

#ifdef DEBUG_SHARK_GLUE

        cprintf("(Use_intdrive: %d)", use_intdrive);

#endif

        if (use_intdrive == TRUE)

                set_noint_handler(shark_timer_exec);

        return 0;

}