path: root/kernel/support.c

/*
** SCCS ID:	@(#)support.c	2.6	1/22/25
**
** @file	support.c
**
** @author  4003-506 class of 20003
** @authors K. Reek, Warren R. Carithers
**
** Miscellaneous system initialization functions, interrupt
** support routines, and data structures.
*/

#include <common.h>

#include <support.h>
#include <cio.h>
#include <x86/arch.h>
#include <x86/pic.h>
#include <x86/ops.h>
#include <bootstrap.h>
#include <syscalls.h>

/*
** Global variables and local data types.
*/

/*
** This is the table that contains pointers to the C-language ISR for
** each interrupt.  These functions are called from the isr stub based
** on the interrupt number.
*/
void (*isr_table[256])(int vector, int code);

/*
** Format of an IDT entry.
*/
typedef struct {
	short offset_15_0;
	short segment_selector;
	short flags;
	short offset_31_16;
} IDT_Gate;

/*
** LOCAL ROUTINES - not intended to be used outside this module.
*/

/**
** unexpected_handler
**
** This routine catches interrupts that we do not expect to ever occur.
** It handles them by (optionally) reporting them and then calling panic().
**
** @param vector   vector number for the interrupt that occurred
** @param code     error code, or a dummy value
**
** Does not return.
*/
#ifdef RPT_INT_UNEXP
/* add any header includes you need here */
#endif
static void unexpected_handler(int vector, int code)
{
#ifdef RPT_INT_UNEXP
	cio_printf("\n** UNEXPECTED vector %d code %d\n", vector, code);
#endif
	panic("Unexpected interrupt");
}

/**
** default_handler
**
** Default handler for interrupts we expect may occur but are not
** handling (yet).  We just reset the PIC and return.
**
** @param vector   vector number for the interrupt that occurred
** @param code     error code, or a dummy value
*/
static void default_handler(int vector, int code)
{
#ifdef RPT_INT_UNEXP
	cio_printf("\n** vector %d code %d\n", vector, code);
#endif
	if (vector >= 0x20 && vector < 0x30) {
		if (vector > 0x27) {
			// must also ACK the secondary PIC
			outb(PIC2_CMD, PIC_EOI);
		}
		outb(PIC1_CMD, PIC_EOI);
	} else {
		/*
		** All the "expected" interrupts will be handled by the
		** code above.  If we get down here, the isr table may
		** have been corrupted.  Print a message and don't return.
		*/
		panic("Unexpected \"expected\" interrupt!");
	}
}

/**
** mystery_handler
**
** Default handler for the "mystery" interrupt that comes through vector
** 0x27.  This is a non-repeatable interrupt whose source has not been
** identified, but it appears to be the famous "spurious level 7 interrupt"
** source.
**
** @param vector   vector number for the interrupt that occurred
** @param code     error code, or a dummy value
*/
static void mystery_handler(int vector, int code)
{
#if defined(RPT_INT_MYSTERY) || defined(RPT_INT_UNEXP)
	cio_printf("\nMystery interrupt!\nVector=0x%02x, code=%d\n", vector, code);
#endif
	outb(PIC1_CMD, PIC_EOI);
}

/**
** init_pic
**
** Initialize the 8259 Programmable Interrupt Controller.
*/
static void init_pic(void)
{
	/*
	** ICW1: start the init sequence, update ICW4
	*/
	outb(PIC1_CMD, PIC_CW1_INIT | PIC_CW1_NEED4);
	outb(PIC2_CMD, PIC_CW1_INIT | PIC_CW1_NEED4);

	/*
	** ICW2: primary offset of 0x20 in the IDT, secondary offset of 0x28
	*/
	outb(PIC1_DATA, PIC1_CW2_VECBASE);
	outb(PIC2_DATA, PIC2_CW2_VECBASE);

	/*
	** ICW3: secondary attached to line 2 of primary, bit mask is 00000100
	**   secondary id is 2
	*/
	outb(PIC1_DATA, PIC1_CW3_SEC_IRQ2);
	outb(PIC2_DATA, PIC2_CW3_SEC_ID);

	/*
	** ICW4: want 8086 mode, not 8080/8085 mode
	*/
	outb(PIC1_DATA, PIC_CW4_PM86);
	outb(PIC2_DATA, PIC_CW4_PM86);

	/*
	** OCW1: allow interrupts on all lines
	*/
	outb(PIC1_DATA, PIC_MASK_NONE);
	outb(PIC2_DATA, PIC_MASK_NONE);
}

/**
** set_idt_entry
**
** Construct an entry in the IDT
**
** @param entry    the vector number of the interrupt
** @param handler  ISR address to be put into the IDT entry
**
** Note: generally, the handler invoked from the IDT will be a "stub"
** that calls the second-level C handler via the isr_table array.
*/
static void set_idt_entry(int entry, void (*handler)(void))
{
	IDT_Gate *g = (IDT_Gate *)IDT_ADDR + entry;

	g->offset_15_0 = (int)handler & 0xffff;
	g->segment_selector = 0x0010;
	g->flags = IDT_PRESENT | IDT_DPL_0 | IDT_INT32_GATE;
	g->offset_31_16 = (int)handler >> 16 & 0xffff;
}

/**
** Name:    init_idt
**
** Initialize the Interrupt Descriptor Table (IDT).  This makes each of
** the entries in the IDT point to the isr stub for that entry, and
** installs a default handler in the handler table.  Temporary handlers
** are then installed for those interrupts we may get before a real
** handler is set up.
*/
static void init_idt(void)
{
	int i;
	extern void (*isr_stub_table[256])(void);

	/*
	** Make each IDT entry point to the stub for that vector.  Also
	** make each entry in the ISR table point to the default handler.
	*/
	for (i = 0; i < 256; i++) {
		set_idt_entry(i, isr_stub_table[i]);
		install_isr(i, unexpected_handler);
	}

	/*
	** Install the handlers for interrupts that have (or will have) a
	** specific handler. Comments indicate which module init function
	** will eventually install the "real" handler.
	*/

	install_isr(VEC_KBD, default_handler); // cio_init()
	install_isr(VEC_COM1, default_handler); // sio_init()
	install_isr(VEC_TIMER, default_handler); // clk_init()
	install_isr(VEC_SYSCALL, default_handler); // sys_init()
	install_isr(VEC_PAGE_FAULT, default_handler); // vm_init()

	install_isr(VEC_MYSTERY, mystery_handler);
}

/*
** END OF LOCAL ROUTINES.
**
** Full documentation for globally-visible routines is in the corresponding
** header file.
*/

/*
** panic
**
** Called when we find an unrecoverable error.
*/
void panic(char *reason)
{
	__asm__("cli");
	cio_printf("\nPANIC: %s\nHalting...", reason);
	for (;;) {
		;
	}
}

/*
** init_interrupts
**
** (Re)initilizes the interrupt system.
*/
void init_interrupts(void)
{
	init_idt();
	init_pic();
}

/*
** install_isr
**
** Installs a second-level handler for a specific interrupt.
*/
void (*install_isr(int vector, void (*handler)(int, int)))(int, int)
{
	void (*old_handler)(int vector, int code);

	old_handler = isr_table[vector];
	isr_table[vector] = handler;
	return old_handler;
}

/*
** Name:	delay
**
** Notes:  The parameter to the delay() function is ambiguous; it
** purports to indicate a delay length, but that isn't really tied
** to any real-world time measurement.
**
** On the original systems we used (dual 500MHz Intel P3 CPUs), each
** "unit" was approximately one tenth of a second, so delay(10) would
** delay for about one second.
**
** On the current machines (Intel Core i5-7500), delay(100) is about
** 2.5 seconds, so each "unit" is roughly 0.025 seconds.
**
** Ultimately, just remember that DELAY VALUES ARE APPROXIMATE AT BEST.
*/
void delay(int length)
{
	while (--length >= 0) {
		for (int i = 0; i < 10000000; ++i)
			;
	}
}