C++ (Cpp) set_interrupt_handler Examples

Example #1

File: interrupts.c Project: 247a/lenovo_b6000-8000_kernel_source

void timer_init(void)
{
	extern void timer_interrupt_handler(void);
	u64 tmp;

	sysreg_write(COUNT, 0);

	tmp = (u64)CONFIG_SYS_HZ << 32;
	tmp += gd->cpu_hz / 2;
	do_div(tmp, gd->cpu_hz);
	tb_factor = (u32)tmp;

	if (set_interrupt_handler(0, &timer_interrupt_handler, 3))
		return;

	/* For all practical purposes, this gives us an overflow interrupt */
	sysreg_write(COMPARE, 0xffffffff);
}

Example #2

File: io_apic.c Project: pdziepak/quarnos-old

int
arch_irq_register(unsigned irq)
{
	unsigned vector;
	int result;

	if (irq >= MAX_IRQ_COUNT || !irq_ctrl[irq])
		return E_NO_DEV;

	result = irq_alloc_vectors(1, &vector);
	assert(!result);
	if (result)
		return result;

	vector_to_irq[vector] = irq;
	set_interrupt_handler(vector, io_apic_irq_handler);

	io_apic_register_irq(irq_ctrl[irq], irq, vector);
	return E_OK;
}

Example #3

File: interrupt.cpp Project: peres/BRA_adlib_driver

// int 8 (timer)
void interrupt_handler() {
	switch (command) {
	case 1:
		midi_stop();
		midi_buffer_hi = parameter;
		break;
	case 2:
		midi_stop();
		midi_buffer_lo = parameter;
		break;
	case 3:
		midi_buffer_size = parameter;
		break;
	case 4:
		midi_resume();
		break;
	case 5:
		midi_fadeout_and_stop();
		break;
	case 6:
		midi_pause();
		eak;
	case 7:
		voices[parameter & 0xFF].volume = parameter >> 8;
		break;
	case 8:
		midi_fade_in_flag = parameter != 0;
		break;
	case 9:
		midi_fade_out_flag = parameter != 0;
		break;
	case 10:
		midi_volume = parameter;
		break;
	case 11:
		reset_hw_timer();
		ADLIB_mute_voices();
		set_interrupt_handler(8, old_interrupt_handler);
		break;
	case 12:
		parameter = driver_status;
		break;
	case 13:
		midi_fade_volume_change_rate = parameter & 0xFF;
		fadeout_volume_cur = 0;
		fadein_volume_cur = 0;
		break;
	case 14:
		parameter = midi_volume;
		break;
	case 15:
		parameter = midi_fade_in_flag;
		break;
	case 16:
		parameter = midi_fade_out_flag;
		break;
	case 17:
		midi_tempo = parameter & 0xFF;
		midi_set_tempo();
		break;
	case 18:
		parameter = midi_tempo;
		break;
	case 19:
		parameter = midi_fade_volume_change_rate;
		break;
	case 20:
		midi_loop = parameter != 0;
		break;
	case 21:
		parameter = midi_loop;
		break;
	case 22:
		parameter = 0xF0;	// version??
		break;
	case 23:
		parameter = 1;		// version??
		break;
	case 24:
		voices[parameter & 0xFF].program = parameter >> 8;
		break;
	case 25:
		parameter = voices[parameter & 0xFF].program;
		break;
	}
	
	command = 0;
	midi_driver();
	interrupt_cycles++;
	if (interrupt_cycles >= interrupt_ratio) {
		old_interrupt_handler();
		interrupt_cycles = 0;
	}
}

Example #4

File: idt.c Project: BFridge/OS

/**
* Initialises the Interrupt Descriptor Table to contain valid descriptors.
* These are used when interrupts and exceptions occur and jump to valid
* function handlers
*
* @return BOOL true if 
*/
BOOL init_idt()
{
    int i;

    //First set all our interrupts to the default handler 
    for (i=0; i < NUMBER_OF_INTERRUPTS; i++)
    {
        set_interrupt_handler( INTERRUPT_GATE, i, &default_interrupt, KERNEL_CODE, KERNEL_LEVEL);
    }

    //Set the 19 CPU Specific interrupts
    set_interrupt_handler( INTERRUPT_GATE, 0, &divide_error, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 1, &debug_exception, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 2, &nmi_hardware, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 3, &debug_breakpoint, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 4, &instruction_overflow, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 5, &instruction_overrange, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 6, &invalid_opcode, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 7, &no_coprocessor, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 8, &double_fault, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 9, &coprocessor_segment_overrun, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 10, &invalid_tss, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 11, &segment_not_present, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 12, &stack_fault, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 13, &general_protection_fault, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 14, &page_fault, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 15, &reserved15, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 16, &coprocessor_error, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 17, &alignment_check, KERNEL_CODE, KERNEL_LEVEL);
    set_interrupt_handler( INTERRUPT_GATE, 18, &machine_check, KERNEL_CODE, KERNEL_LEVEL);

    //Set the 16 IRQ Handlers
    /* Timer interrupt */
    set_interrupt_handler( INTERRUPT_GATE, 0x20, &irq0, KERNEL_CODE, KERNEL_LEVEL );
    
    /** Set system call interrupt */
    set_interrupt_handler( INTERRUPT_GATE, 0x80, &system_call_entry, KERNEL_CODE, USER_LEVEL );

    return TRUE;
}

Example #5

File: exeptions.c Project: dxywx/puzzleOS

void exeptions_init() {
	int i = 0;
	for (i = 0; i < EXEPTIONS_COUNT; i++)
		set_interrupt_handler(i, &exeption_handler);
}