---

interrupt.c

Go to the documentation of this file.

/*!     \file arch/i386/kernel/interrupt.c
 *      \brief Interrupt manager.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2004-01-24
 *      \note Copyright (&copy;) 2003 Andrea Righi
 *
 *      \todo
 *              Stack fault exception in kernel mode must be
 *              managed by a task-gate in the IDT.
 *              We have to define a TSS for the double fault
 *              exception. When the double fault task will be
 *              called we'll have a stack fault exception in
 *              kernel-mode.
 *              In user-mode there are no problems, because there
 *              is also the privileged stack. In this case a stack
 *              fault is managed like a normal page fault.
 */

#include <const.h>

#include <arch/exception.h>
#include <arch/i386.h>
#include <arch/mem.h>
#include <arch/paging.h>

#include <kernel/clock.h>
#include <kernel/console.h>
#include <kernel/floppy.h>
#include <kernel/keyboard.h>
#include <kernel/serial.h>
#include <kernel/speaker.h>
#include <kernel/syscall.h>
#include <kernel/task.h>

#include <net/rtl8139.h>

#include <arch/interrupt.h>

//! Interrupt Descriptor Table (IDT).
volatile idt_entry_t idt[IDT_DIM];

//! Value of Interrupt Descriptor Table Register.
idt_reg_t idt_ptr;

// --- Extern IRQ entry points ---------------------------------------- //

extern void     _irq_00, _irq_01, _irq_02, _irq_03, _irq_04, _irq_05, _irq_06, _irq_07;
extern void     _irq_08, _irq_09, _irq_0A, _irq_0B, _irq_0C, _irq_0D, _irq_0E, _irq_0F;
extern void     _irq_80;
extern void     _irq_unhand;

// --- Extern EXC entry points ---------------------------------------- //

extern void     _exc_00, _exc_01, _exc_02, _exc_03, _exc_04, _exc_05, _exc_06, _exc_07;
extern void     _exc_08, _exc_09, _exc_0A, _exc_0B, _exc_0C, _exc_0D, _exc_0E, _exc_0F;
extern void     _exc_unhand;

//! \brief Disable an IRQ line.
//! \param IRQ The IRQ line to disable.
void disable_IRQ(uint8_t IRQ)
{
        uint8_t mask;

        if (IRQ > 15) return;

        if (IRQ < 8)
        {
                // Master                                               //
                mask = inportb(PORT_INT_MASK_M);
                mask |= 1 << IRQ;
                outportb(PORT_INT_MASK_M, mask);
        }
        else
        {
                // Slave                                                //
                mask = inportb(PORT_INT_MASK_S);
                mask |= 1 << (IRQ-8);
                outportb(PORT_INT_MASK_S, mask);
        }
}

//! \brief Enable an IRQ line.
//! \param IRQ The IRQ line to enable.
void enable_IRQ(uint8_t IRQ)
{
        uint8_t mask;

        if (IRQ > 15) return;

        if (IRQ < 8)
        {
                // Master                                               //
                mask = inportb(PORT_INT_MASK_M);
                mask &= ~(1 << IRQ);
                outportb(PORT_INT_MASK_M, mask);
        }
        else
        {
                // Slave                                                //
                mask = inportb(PORT_INT_MASK_S);
                mask &= ~(1 << (IRQ-8));
                outportb(PORT_INT_MASK_S, mask);
        }
}

//! \brief Initialize the Programmable Interrupt Controllers (PICs).
//! \note
//!     The AT and PS/2 have 2 interrupt controllers to issue the IRQs,
//!     one master and one slaved at IRQ2.
//!     This routine initialize the 8259 interrupt controllers, using
//!     vector [0x20..0x2F] for [IRQ0..IRQ15] (0x20..0x27 for master
//!     and 0x28..0x2F for slave).
void reprogram_PIC()
{
        // Start initialization for master & slave                      //
        outportb(PORT_8259_M, 0x11);
        outportb(PORT_8259_S, 0x11);

        outportb(PORT_INT_MASK_M, 0x20); // master base vector          //
        outportb(PORT_INT_MASK_S, 0x28); // slave base vector           //

        outportb(PORT_INT_MASK_M, 1 << 2); // IRQ2 cascade to slave     //
        outportb(PORT_INT_MASK_S, 2); // cascade on IRQ2                //

        // Finish 8259 initialization                                   //
        outportb(PORT_INT_MASK_M, 1);
        outportb(PORT_INT_MASK_S, 1);

        // Disable all IRQs for master, except the IRQ2 cascade line.   //
        outportb(PORT_INT_MASK_M, ~(1 << 2));
        // Disable all IRQs for slave.                                  //
        outportb(PORT_INT_MASK_S, 0xFF);
}

//! An IRQ handler pointer.
typedef struct irq_desc
{
        void *handler;
} irq_desc_t;

//! A table for hardware interrupt handlers only.
static irq_desc_t irq_handler[] =
{
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },

        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL },
        { NULL }
};

//! Total number of hardware interrupts.
#define TOT_IRQ ( sizeof(irq_handler) / sizeof(irq_desc_t) )

//! \brief Install an IRQ handler routine.
//! \param irq The interrupt number.
//! \param handler A pointer to the handler routine.
//! \note
//!     This is valid only for hardware interrupts. You cannot
//!     install a software interrupt handler in this way.
void install_irq_handler(uint8_t irq, void *handler)
{
        dword IF = GET_IF();

        if ( irq > TOT_IRQ )
                return;

        disable();

        irq_handler[irq].handler = handler;
        enable_IRQ(irq);

        SET_IF(IF);
        return;
}

//! \brief Manage an unhandled interrupt.
//! \param irq The interrupt number.
void unhandled_interrupt(uint8_t irq)
{
        set_color(LIGHT_RED);
        kprintf("\n\rUnhandled IRQ #%03u from task [%s] (%u)!!!", irq, get_pname(), get_pid());
        set_color(DEFAULT_COLOR);
        beep();

        // Kill the task                                                //
        if ( kill(get_pid()) == TRUE )
        {
                kprintf("\n\rTask [%s] (%u) killed!\n\r",
                        get_pname(), get_pid()
                );
        }
        else
                kprintf("\n\rUnable to kill the task [%s] (%u)", get_pname(), get_pid());
}

/*! \ingroup KInterrupt */
//! \brief
//!     This is the default interrupt handler. It is invoked
//!     every time an interrupt occurs.
//! \param c The context of the current task after the interrupt.
//! \note
//!     Only hardware interrupts and #MINIRIGHI_INT are accepted.
//!     In the other cases we assume the interrupt is unhandled!
void default_handler(irq_context_t *c)
{
        if ( c->IRQ < sizeof(irq_handler) )
        {
                // An hardware interrupt occurs                         //
                // Call the interrupt handler if exists                 //
                if ( irq_handler[c->IRQ].handler != NULL )
                {
                        // Pointer to the handler function              //
                        int (*p)()=(void *)irq_handler[c->IRQ].handler;
                        (*p)();
                }
                else
                {
                        // Unhandled interrupt!                         //
                        unhandled_interrupt(c->IRQ);
                }
        }
        else
        {
                // Software interrupt occurs                            //
                // (only MINIRIGHI INT is accepted)                     //
                switch ( c->IRQ )
                {
                        case MINIRIGHI_INT:
                                syscall_handler(&(c->eax), &(c->ebp));
                        break;

                        default:
                                unhandled_interrupt(c->IRQ);
                        break;
                }
                return;
        }
        // Re-enable the IRQ line (master channel)                      //
        outportb(PORT_8259_M, EOI);
        if ( c->IRQ >= 8 )
                // Re-enable also the IRQ slave channel                 //
                outportb(PORT_8259_S, EOI);
}

//! \brief Set up an IDT entry.
//! \param i The index of the entry.
//! \param selector The selector for the interrupt handler.
//! \param offset The entry point of the handler.
//! \param attribs The descriptor attributes.
//! \param paramcnt
//!     How many items must be copied from the previous stack to the
//!     new privileged stack.
void setup_IDT_entry(byte i, word selector, dword offset, byte attribs, byte paramcnt)
{
        dword IF = GET_IF();

        disable();

        idt[i].offset0_15 =  offset & 0xFFFF;
        idt[i].offset16_31 = offset >> 16;
        idt[i].selector = selector;
        idt[i].attribs = attribs;
        idt[i].paramcnt = paramcnt;

        SET_IF(IF);
}

//! \brief Initialize the IDT (Interrupt Descriptor Table).
void install_IDT()
{
        unsigned i;

        // Initialize exception handlers (0x00..0x1F)                   //
        for(i=0x00; i<=0x1F; i++)
                setup_IDT_entry(i, KERNEL_CODE, (dword)&_exc_unhand, INT_GATE, 0);

        // Setup the IDT entries for exceptions                         //
        setup_IDT_entry(0x00, KERNEL_CODE, (dword)&_exc_00, INT_GATE, 0);
        setup_IDT_entry(0x01, KERNEL_CODE, (dword)&_exc_01, INT_GATE, 0);
        setup_IDT_entry(0x02, KERNEL_CODE, (dword)&_exc_02, INT_GATE, 0);
        setup_IDT_entry(0x03, KERNEL_CODE, (dword)&_exc_03, INT_GATE, 0);
        setup_IDT_entry(0x04, KERNEL_CODE, (dword)&_exc_04, INT_GATE, 0);
        setup_IDT_entry(0x05, KERNEL_CODE, (dword)&_exc_05, INT_GATE, 0);
        setup_IDT_entry(0x06, KERNEL_CODE, (dword)&_exc_06, INT_GATE, 0);
        setup_IDT_entry(0x07, KERNEL_CODE, (dword)&_exc_07, INT_GATE, 0);
        setup_IDT_entry(0x08, KERNEL_CODE, (dword)&_exc_08, INT_GATE, 0);
        setup_IDT_entry(0x09, KERNEL_CODE, (dword)&_exc_09, INT_GATE, 0);
        setup_IDT_entry(0x0A, KERNEL_CODE, (dword)&_exc_0A, INT_GATE, 0);
        setup_IDT_entry(0x0B, KERNEL_CODE, (dword)&_exc_0B, INT_GATE, 0);
        setup_IDT_entry(0x0C, KERNEL_CODE, (dword)&_exc_0C, INT_GATE, 0);
        setup_IDT_entry(0x0D, KERNEL_CODE, (dword)&_exc_0D, INT_GATE, 0);
        setup_IDT_entry(0x0E, KERNEL_CODE, (dword)&_exc_0E, INT_GATE, 0);
        setup_IDT_entry(0x0F, KERNEL_CODE, (dword)&_exc_0F, INT_GATE, 0);

        // Initialize interrupt handlers 0x20..0xFF                     //
        for(i=0x20; i<=0xFF; i++)
                setup_IDT_entry(i, KERNEL_CODE, (dword)&_irq_unhand, INT_GATE, 0);

        // Setup the IDT entries for IRQs                               //
        setup_IDT_entry(0x20, KERNEL_CODE, (dword)&_irq_00, INT_GATE, 0);
        setup_IDT_entry(0x21, KERNEL_CODE, (dword)&_irq_01, INT_GATE, 0);
        setup_IDT_entry(0x22, KERNEL_CODE, (dword)&_irq_02, INT_GATE, 0);
        setup_IDT_entry(0x23, KERNEL_CODE, (dword)&_irq_03, INT_GATE, 0);
        setup_IDT_entry(0x24, KERNEL_CODE, (dword)&_irq_04, INT_GATE, 0);
        setup_IDT_entry(0x25, KERNEL_CODE, (dword)&_irq_05, INT_GATE, 0);
        setup_IDT_entry(0x26, KERNEL_CODE, (dword)&_irq_06, INT_GATE, 0);
        setup_IDT_entry(0x27, KERNEL_CODE, (dword)&_irq_07, INT_GATE, 0);
        setup_IDT_entry(0x28, KERNEL_CODE, (dword)&_irq_08, INT_GATE, 0);
        setup_IDT_entry(0x29, KERNEL_CODE, (dword)&_irq_09, INT_GATE, 0);
        setup_IDT_entry(0x2A, KERNEL_CODE, (dword)&_irq_0A, INT_GATE, 0);
        setup_IDT_entry(0x2B, KERNEL_CODE, (dword)&_irq_0B, INT_GATE, 0);
        setup_IDT_entry(0x2C, KERNEL_CODE, (dword)&_irq_0C, INT_GATE, 0);
        setup_IDT_entry(0x2D, KERNEL_CODE, (dword)&_irq_0D, INT_GATE, 0);
        setup_IDT_entry(0x2E, KERNEL_CODE, (dword)&_irq_0E, INT_GATE, 0);
        setup_IDT_entry(0x2F, KERNEL_CODE, (dword)&_irq_0F, INT_GATE, 0);

        // Install Minirighi system calls handler                       //
        setup_IDT_entry(MINIRIGHI_INT, KERNEL_CODE, (dword)&_irq_80, TRAP_GATE | DPL_3, 0);

        // Set up the IDT pointer                                       //
        idt_ptr.limit = (IDT_DIM * sizeof(idt_entry_t) - 1);
        * (dword *)idt_ptr.base = ((dword)&idt);

        // Load info into IDTR register                                 //
        __asm__("lidtl (%0)" : : "r"((dword)&idt_ptr));
}

---