interrupt.c

用于汇编领域的,运用于OS的MAIN函数.基于硬件基础的源代码

#include "hos.h"

unsigned long get_current_eflags(void);

void do_dummy_interrupt_handler(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt\n");
        display_regs(regs);
	//dump_interrupt_state(state);

	STOP();
}
void do_dummy_interrupt_handler0(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 0\n");
	STOP();
}
void do_dummy_interrupt_handler1(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 1\n");
	STOP();
}
void do_dummy_interrupt_handler2(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 2\n");
	STOP();
}
void do_dummy_interrupt_handler3(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 3\n");
	STOP();
}
void do_dummy_interrupt_handler4(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 4\n");
	STOP();
}
void do_dummy_interrupt_handler5(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 5\n");
	STOP();
}
void do_dummy_interrupt_handler6(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 6\n");
	STOP();
}
void do_dummy_interrupt_handler7(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 7\n");
	STOP();
}
void do_dummy_interrupt_handler8(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 8\n");
	STOP();
}
void do_dummy_interrupt_handler9(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 9\n");
	STOP();
}
void do_dummy_interrupt_handler10(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 10\n");
	STOP();
}
void do_dummy_interrupt_handler11(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 11\n");
	STOP();
}
void do_dummy_interrupt_handler12(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 12\n");
	STOP();
}
void do_dummy_interrupt_handler13(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 13\n");
	STOP();
}
void do_dummy_interrupt_handler14(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 14\n");
	STOP();
}
void do_dummy_interrupt_handler15(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 15\n");
	STOP();
}
void do_dummy_interrupt_handler16(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 16\n");
	STOP();
}
void do_dummy_interrupt_handler17(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 17\n");
	STOP();
}
void do_dummy_interrupt_handler18(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 18\n");
	STOP();
}
void do_dummy_interrupt_handler19(struct pt_regs *regs)
{
	printk("[kernel]Not implemented interrupt 19\n");
	STOP();
}

/* =========================================================== */
/* =========================================================== */

void init_interrupt(void)
{
	int i;


    set_intr_gate(0, &do_dummy_interrupt_handler0);
    set_intr_gate(1, &do_dummy_interrupt_handler1);
    set_intr_gate(2, &do_dummy_interrupt_handler2);
    set_intr_gate(3, &do_dummy_interrupt_handler3);
    set_intr_gate(4, &do_dummy_interrupt_handler4);
    set_intr_gate(5, &do_dummy_interrupt_handler5);
    set_intr_gate(6, &do_dummy_interrupt_handler6);
    set_intr_gate(7, &do_dummy_interrupt_handler7);
    set_intr_gate(8, &do_dummy_interrupt_handler8);
    set_intr_gate(9, &do_dummy_interrupt_handler9);
    set_intr_gate(10, &do_dummy_interrupt_handler10);
    set_intr_gate(11, &do_dummy_interrupt_handler11);
    set_intr_gate(12, &do_dummy_interrupt_handler12);
    set_intr_gate(13, &do_dummy_interrupt_handler13);
    set_intr_gate(14, &dummy_interrupt_handler);
    set_intr_gate(15, &do_dummy_interrupt_handler15);
    set_intr_gate(16, &do_dummy_interrupt_handler16);
    set_intr_gate(17, &do_dummy_interrupt_handler17);
    set_intr_gate(18, &do_dummy_interrupt_handler18);
    set_intr_gate(19, &do_dummy_interrupt_handler19);
	for(i = 20; i < 256; i++){
		   set_intr_gate(i, &dummy_interrupt_handler);
	}
	init_idt();

	enable_interrupts();
}

int is_interrupts_enabled(void)
{
	unsigned long efalgs = get_current_eflags();
	return (efalgs & EFLAGS_IF) != 0;
}

unsigned long get_current_eflags(void)
{
	unsigned long eflags;
	
	__asm__ __volatile__ (
		"pushfl \t\n"
		"pop	%0 \t\n"
		: "=a" (eflags)
	);

	return eflags;
}

void mask_irq(unsigned char irq)
{
	if(irq < 8)
		outbyte(0x21, ((1<<irq) | inbyte(0x21)));
	else
		outbyte(0xA1, ((1<<(irq-8)) | inbyte(0xA1)));
}

void unmask_irq(unsigned char irq)
{
	if(irq < 8)
		outbyte(0x21, (~(1<<irq) & inbyte(0x21)));
	else
		outbyte(0xA1, (~(1<<(irq-8)) & inbyte(0xA1)));
}
/*
void dump_interrupt_state(interrupt_state_t *state)
{
	unsigned int errorcode = state->errorcode;

	printk("eax = %x ebx = %x ecx = %x edx = %x\n"
		"esi = %x edi = %x ebp = %x\n"
		"eip = %x cs = %x eflags = %x\n"
		"interrupt number = %d, error code = %d\n"
		"index = %d, TI = %d, IDT = %d, EXT = %d\n",
		state->eax, state->ebx, state->ecx, state->edx,
		state->esi, state->edi, state->ebp,
		state->eip, state->cs, state->eflags,
		state->intnum, errorcode,
		errorcode >> 3, (errorcode >> 2) & 1, (errorcode >> 1) & 1,
		errorcode & 1);
}
*/