haiku/src/kernel/core/int.c

/* 
** Copyright 2001-2002, Travis Geiselbrecht. All rights reserved. 
** Distributed under the terms of the NewOS License. 
*/ 

#include <kernel.h> 
#include <int.h> 
#include <debug.h> 
#include <memheap.h> 
#include <smp.h> 
#include <arch/int.h> 
#include <errno.h> 
#include <stage2.h> 
#include <string.h> 
#include <stdio.h> 

#define NUM_IO_VECTORS 256 

struct io_handler { 
        struct io_handler *next; 
        int (*func)(void*); 
        void* data; 
}; 

struct io_vector { 
        struct io_handler *handler_list; 
        spinlock_t         vector_lock; 
}; 

static struct io_vector *io_vectors = NULL; 

int int_init(kernel_args *ka) 
{ 
        dprintf("init_int_handlers: entry\n"); 

        return arch_int_init(ka); 
} 

int int_init2(kernel_args *ka) 
{ 
        io_vectors = (struct io_vector *)kmalloc(sizeof(struct io_vectors *) * NUM_IO_VECTORS); 
        if(io_vectors == NULL) 
                panic("int_init2: could not create io vector table!\n"); 

        memset(io_vectors, 0, sizeof(struct io_vector *) * NUM_IO_VECTORS); 

        return arch_int_init2(ka); 
} 

int int_set_io_interrupt_handler(int vector, int (*func)(void*), void* data) 
{ 
        struct io_handler *io; 
        int state; 

        // insert this io handler in the chain of interrupt 
        // handlers registered for this io interrupt 

        io = (struct io_handler *)kmalloc(sizeof(struct io_handler)); 
        if(io == NULL) 
                return ENOMEM; 
        io->func = func; 
        io->data = data; 

        state = int_disable_interrupts(); 
        acquire_spinlock(&io_vectors[vector].vector_lock); 
        io->next = io_vectors[vector].handler_list; 
        io_vectors[vector].handler_list = io; 
        release_spinlock(&io_vectors[vector].vector_lock); 
        int_restore_interrupts(state); 

        arch_int_enable_io_interrupt(vector); 

        return 0; 
} 

int int_remove_io_interrupt_handler(int vector, int (*func)(void*), void* data) 
{ 
        struct io_handler *io, *prev = NULL; 
        int state; 

        // lock the structures down so it is not modified while we search 
        state = int_disable_interrupts(); 
        acquire_spinlock(&io_vectors[vector].vector_lock); 

        // start at the beginning 
        io = io_vectors[vector].handler_list; 

        // while not at end 
        while(io != NULL) { 
                // see if we match both the function & data 
                if (io->func == func && io->data == data) 
                        break; 

                // Store our backlink and move to next 
                prev = io; 
                io = io->next; 
        } 

        // If we found it 
        if (io != NULL) { 
                // unlink it, taking care of the change it was the first in line 
                if (prev != NULL) 
                        prev->next = io->next; 
                else 
                        io_vectors[vector].handler_list = io->next; 
        } 

        // release our lock as we're done with the vector 
        release_spinlock(&io_vectors[vector].vector_lock); 
        int_restore_interrupts(state); 

        // and disable the IRQ if nothing left 
        if (io != NULL) { 
                if (prev == NULL && io->next == NULL) 
                        arch_int_disable_io_interrupt(vector); 

                kfree(io); 
        } 

        return (io != NULL) ? 0 : EINVAL; 
} 

int int_io_interrupt_handler(int vector) 
{ 
        int ret = INT_NO_RESCHEDULE; 

        acquire_spinlock(&io_vectors[vector].vector_lock); 

        if(io_vectors[vector].handler_list == NULL) { 
                dprintf("unhandled io interrupt %d\n", vector); 
        } else { 
                struct io_handler *io; 
                int temp_ret; 

                io = io_vectors[vector].handler_list; 
                while(io != NULL) { 
                        temp_ret = io->func(io->data); 
                        if(temp_ret == INT_RESCHEDULE) 
                                ret = INT_RESCHEDULE; 
                        io = io->next; 
                } 
        } 

        release_spinlock(&io_vectors[vector].vector_lock); 

        return ret; 
}