interrupts.h

Go to the documentation of this file.

 
#ifndef KERNEL_INTERRUPTS_H
#define KERNEL_INTERRUPTS_H
 
#if ARCH == i686
#include <kernel/arch/i686/interrupts.h>
#endif
 
#include <kernel/error.h>
#include <kernel/types.h>
 
#include <libalgo/linked_list.h>
 
typedef enum interrupt_return {
    INTERRUPT_HANDLED, 
    INTERRUPT_IGNORED, 
} interrupt_return_t;
 
typedef struct interrupt_frame interrupt_frame;
 
typedef interrupt_return_t (*interrupt_handler_func_t)(void *);
 
struct interrupt_handler {
    interrupt_handler_func_t    handler;
    void                        *data;
    node_t                      this; /* used by interrupt_vector->handlers */
};
 
struct interrupt_vector {
    const char  *name;
    llist_t     handlers;
};
 
struct interrupt_chip {
    struct interrupt_vector *interrupts; /* Array of struct interrupt_vector */
    size_t                  interrupt_count;
};
 
error_t
interrupts_install_handler(unsigned int irq, interrupt_handler_func_t, void *);
 
error_t
interrupts_install_static_handler(unsigned int nr, struct interrupt_handler *);
 
interrupt_handler_func_t interrupts_get_handler(unsigned int irq, void **);
 
error_t interrupt_handle(unsigned int nr);
const char *interrupt_name(unsigned int nr);
 
#define INTERRUPT_HANDLER(_interrupt) _interrupt##_handler
 
#define INTERRUPT_HANDLER_FUNCTION(_interrupt) \
    interrupt_return_t INTERRUPT_HANDLER(_interrupt)(void *data)
 
static inline void interrupts_disable(void)
{
    arch_interrupts_disable();
}
 
static inline void interrupts_enable(void)
{
    arch_interrupts_enable();
}
 
/* @brief Disable CPU interrupts on the current CPU.
 * @return \c true if the interrupts where enabled previously.
 */
static inline bool interrupts_test_and_disable(void)
{
    return arch_interrupts_test_and_disable();
}
 
static inline bool interrupts_enabled(void)
{
    return arch_interrupts_enabled();
}
 
static inline void interrupts_restore(bool enabled)
{
    if (enabled)
        interrupts_enable();
}
 
typedef struct {
    bool enabled;
    bool done;
} scope_irq_off_t;
 
static inline scope_irq_off_t scope_irq_off_constructor(void)
{
    return (scope_irq_off_t){
        .enabled = interrupts_test_and_disable(),
        .done = false,
    };
}
 
static inline void scope_irq_off_destructor(scope_irq_off_t *guard)
{
    interrupts_restore(guard->enabled);
}
 
#define interrupts_disabled_scope()                                \
    for (scope_irq_off_t guard CLEANUP(scope_irq_off_destructor) = \
             scope_irq_off_constructor();                          \
         !guard.done; guard.done = true)
 
 
/*
 * Generic interrupt handlers.
 */
 
extern struct interrupt_handler division_by_zero;
extern struct interrupt_handler invalid_instruction;
 
#endif /* KERNEL_INTERRUPTS_H */