interrupt.cpp

Go to the documentation of this file.

//
// Created on 5/19/20.
//

#include <interrupt.h>
#include <common.h>
#include <utilities.h>
#include <gdt.h>
#include <accessright.h>
#include <pic.h>


namespace TIMER
{
    extern uint64_t timer_ticks;
}

namespace INTRP // interrupt
{
    DescriptorEntry idt_table[IDT_ENTRIES];

    void RegisterHandler(DescriptorEntry IdtTable[], size_t Idx, func_ptr Handler)
    {
        IdtTable[Idx].m_OffsetLow   = (ptr_t) (Handler) & 0xFFFF;
        IdtTable[Idx].m_CS_Selector = GDT::SEG_OFFSET(GDT::Segment::K_CS);
        IdtTable[Idx].m_Reserve     = 0x0;
        IdtTable[Idx].m_Access      = AR::INTERRUPT_ACCESS;
        IdtTable[Idx].m_OffsetHigh  = ((ptr_t) (Handler) >> 16) & 0xFFFF;
    }

    void UnhandledException()
    {
        kprintf("Unhandled exception encountered\n");
        Hang();
    }

    void TimerInterruptHandler()
    {
        TIMER::timer_ticks++;

        kprintf("Timer interrupt occurred\n");
        Hang();
    }

    void PageFaultHandler()
    {
        kprintf("Page fault handler is not yet set up\n");
        Hang();
    }

    void UnhandledInterrupt()
    {
        kprintf("Unhandled interrupt encountered\n");
        Hang();
    }

    void SetExceptionHandler(DescriptorEntry IdtTable[])
    {
        for (size_t Idx = IVT::RESERVED_START; Idx <= IVT::RESERVED_END; ++Idx)
            RegisterHandler(IdtTable, Idx, UnhandledException);

        RegisterHandler(IdtTable, IVT::PAGE_FAULT, PageFaultHandler);
    }

    void SetInterruptHandler(DescriptorEntry IdtTable[])
    {
        for (size_t Idx = IVT::USER_DEFINED_START; Idx <= IVT::USER_DEFINED_END; ++Idx)
            RegisterHandler(IdtTable, Idx, UnhandledInterrupt);

        RegisterHandler(IdtTable, IVT::TIMER, TimerInterruptHandler);
    }

    inline void Load_lidt(void *lidtAddress, uint16_t LimitUse)
    {
        struct [[gnu::packed]]
        {
            uint16_t Limit;
            void *Base;
        } IDTR = { LimitUse, lidtAddress };

        asm volatile
        (
        "lidt %0"   // load interrupt descriptor table
        :           // no output
        : "m"(IDTR) // memory operand allowed, with any kind of address that the machine supports
        );
    }

    void Install_idt()
    {
        SetExceptionHandler (idt_table);
        SetInterruptHandler (idt_table);
        Load_lidt(idt_table, IDT_ENTRIES * 8 - 1);
    }
} // namespace INTRP

namespace INIT
{
    void idt()
    {
        PIC::Remap();         // remap PIC's interrupt number as default by Bios unsuitable in protected mode
        INTRP::Install_idt(); // install exception, and interrupt handlers
    }
}