void serial_init(void) { serial_enable(SERIAL_PORT_A); serial_enable(SERIAL_PORT_B); register_interrupt_handler(SERIAL_IRQ, serial_handler_a); /* Install the serial input handler */ register_interrupt_handler(SERIAL_IRQ - 1, serial_handler_b); /* Install the serial input handler */ outportb(SERIAL_PORT_A + 1, 0x01); /* Enable interrupts on receive */ outportb(SERIAL_PORT_B + 1, 0x01); /* Enable interrupts on receive */ }
int f () { register_interrupt_handler(2, &h, (void*)0xdeadbeef); register_interrupt_handler(2, &h, (void*)0xdeadbaba); __asm volatile("int $2"); // CHECK: ... and I'm back! kprintf("... and I'm back!"); return 0; }
void InitSyscalls(void) { //KernelStack = kmalloc(STACK_SIZE); u32 StackTop = (u32)KernelStack + STACK_SIZE - 4; set_kernel_stack(StackTop); WriteMSR(MSR_IA32_SYSENTER_CS, 0, 0xb); // 0x8 + 0x3 WriteMSR(MSR_IA32_SYSENTER_ESP, 0, StackTop); WriteMSR(MSR_IA32_SYSENTER_EIP, 0, (u32)SyscallEntry); register_interrupt_handler(0x80, Int80hSyscall); register_interrupt_handler(0x21, kbd_irq); }
// Register some generic interrupt handlers void register_basic_handlers() { register_interrupt_handler(0, &handle_div0); register_interrupt_handler(8, &handle_double_fault); register_interrupt_handler(10, &handle_bad_tss); register_interrupt_handler(11, &handle_seg_notpresent); register_interrupt_handler(12, &handle_stack_fault); register_interrupt_handler(13, &handle_gen_protection_fault); register_interrupt_handler(14, &handle_page_fault); register_interrupt_handler(15, &handle_unknown_int); register_interrupt_handler(16, &handle_coproc_fault); }
void init_mouse() { unsigned char _status; //unsigned char //Enable the auxiliary mouse device mouse_wait(1); outb(0x64, 0xA8); //Enable the interrupts mouse_wait(1); outb(0x64, 0x20); mouse_wait(0); _status=(inb(0x60) | 2); mouse_wait(1); outb(0x64, 0x60); mouse_wait(1); outb(0x60, _status); //Tell the mouse to use default settings mouse_write(0xF6); mouse_read(); //Acknowledge //Enable the mouse mouse_write(0xF4); mouse_read(); //Acknowledge //Setup the mouse handler //irq_install_handler(12, mouse_handler); // Firstly, register our keyboard callback. register_interrupt_handler(IRQ12, &mouse_callback); }
int main(int argc, char **argv) { int enabled; thread_init(); /* show interrupt handler output */ register_interrupt_handler(1); test(1); /* test interrupts_on/off/set */ enabled = interrupts_off(); assert(enabled); test(0); enabled = interrupts_off(); assert(!enabled); test(0); enabled = interrupts_set(1); assert(!enabled); test(1); enabled = interrupts_set(1); assert(enabled); test(1); exit(0); }
error_t vmmngr_initialize(uint32 kernel_pages) { pdirectory* pdir = (pdirectory*)pmmngr_alloc_block(); if (pdir == 0) return ERROR_OCCUR; kernel_directory = pdir; memset(pdir, 0, sizeof(pdirectory)); physical_addr phys = 0; // page directory structure is allocated at the beginning (<1MB) (false) // so identity map the first 4MB to be sure we can point to them for (uint32 i = 0; i < 1024; i++, phys += 4096) if (vmmngr_map_page(pdir, phys, phys, DEFAULT_FLAGS) != ERROR_OK) return ERROR_OCCUR; phys = 0x100000; virtual_addr virt = 0xC0000000; for (uint32 i = 0; i < kernel_pages; i++, virt += 4096, phys += 4096) if (vmmngr_map_page(pdir, phys, virt, DEFAULT_FLAGS) != ERROR_OK) return ERROR_OCCUR; if (vmmngr_switch_directory(pdir, (physical_addr)&pdir->entries) != ERROR_OK) return ERROR_OCCUR; register_interrupt_handler(14, page_fault); register_bottom_interrupt_handler(14, page_fault_bottom); return ERROR_OK; }
void init_keyboard() { // Keyboard throws IRQ1 to signal that there is a key pressed / released register_interrupt_handler(IRQ1, keyboard_int_handler); // ** Keyboard installed at this point ** }
void init_keyboard(uint8_t keyboard_type) { // currently default to US // TO-DO: set keyboard to appropriate type register_interrupt_handler(IRQ1 , &keyboard_callback); }
void init_timer(uint32 frequency) { /* interrupt handler function about registe timer */ register_interrupt_handler(IRQ0, &timer_callback); /* Intel 8253/8254 PIT chip * I/O port address: 0x40h ~ 0x43h * Input frequency: 1193180, frequency is the counts per second */ uint32 divisor = 1193180 / frequency; /* D7 D6 D5 D4 D3 D2 D1 D0 * 0 0 1 1 0 1 1 0 * Above binary code is 0x36H * setup 8253/8254 chip work in Mode 3 */ outportb(0x43, 0x36); /* divide low bytes and high bytes */ uint8 low = (uint8)(divisor & 0xFF); uint8 high = (uint8)((divisor >> 8) & 0xFF); /* * write into low bytes * write into high bytes */ outportb(0x40, low); outportb(0x40, high); }
void keyboard_install(fs_node_t * dev_root) { printk("keyboard selftest good: %b\n", keyboard_selftest); keyboard_reset(); fs_node_t * keyboard = keyboard_create(); devfs_keyboard_attach(keyboard); register_interrupt_handler(IRQ1, &keyboard_callback); }
void setup_timer(unsigned freq) { register_interrupt_handler(IRQ0, irq_timer); // registrar IH para el timer uint16 val = 1193180 / freq; outb(0x43, 0x34); outb(0x40, val & 0xFF); outb(0x40, val >> 8); }
int main(int argc, char **argv) { thread_init(); register_interrupt_handler(0); /* Test cv */ test_cv(); return 0; }
void init_timer(u32int frequency){ register_interrupt_handler(32, &timer_callback); u32int divisor = 1193180 / frequency; outb(0x43, 0x36); u8int l = (u8int)(divisor & 0xFF); u8int h = (u8int)( (divisor>>8) & 0xFF ); outb(0x40, l); outb(0x40, h); }
void setup_floppy(void) { outportb(0x70,0x10); if (!inportb(0x71)) return; register_interrupt_handler(IRQ6,FloppyIRQ); reset(); devfs_handle *dev=devfs_register_device(NULL,"fd0",0660,FS_UID_ROOT,FS_GID_ROOT,FS_BLOCKDEVICE,&floppy_ops); dev->bcount=FLOPPY_SECTOR_COUNT; dev->bsize=FLOPPY_SECTOR_SIZE; }
int f () { /* Handle IRQ0 = PIT timer. */ register_interrupt_handler(IRQ(0), &h, (void*)0xdeadbeef); __asm volatile("sti"); for (;;); return 0; }
void init_timer(uint32_t frequency) { // Firstly, register our timer callback. register_interrupt_handler(IRQ0, &timer_callback); uint32_t divisor = 1193180 / frequency; /* Calculate our divisor */ outb(0x43, 0x36); /* Set our command byte 0x36 */ outb(0x40, divisor & 0xFF); /* Set low byte of divisor */ outb(0x40, divisor >> 8); /* Set high byte of divisor */ }
void init_timer( uint32_t freq ){ register_interrupt_handler( IRQ0, &timer_call ); current_freq = freq; uint32_t divisor = PIT_FREQ / freq; uint8_t l = (uint8_t)( divisor & 0xff ); uint8_t h = (uint8_t)( divisor >> 8 ) & 0xff; outb( 0x43, 0x36 ); outb( 0x40, l ); outb( 0x40, h ); }
void init_timer(void) { register_interrupt_handler(IRQ0, &timer_callback); // We want ticks to update every ms. // // The internal PIT has a clock rate of 1.19Mhz. const uint32_t divisor = 1193180ull / 1000; outb(0x43, 0x36); outb(0x40, divisor & 0xFF); outb(0x40, divisor >> 8); }
void fdc_init() { register_interrupt_handler(IRQ6, &fdc_irq_handler); fdc_init_dma (); //! reset the fdc fdc_reset (); //! set drive information fdc_drive_data (13, 1, 0xf, true); }
void init_timer(unsigned int frequency){ register_interrupt_handler(32, &timer_callback); u32int divisor = 1193180/frequency; outb(0x43, 0x36); unsigned char low = (unsigned char) (divisor & 0xFF); unsigned char high = (unsigned char) ((divisor >> 8) & 0xFF); outb(0x40, low); outb(0x40, high); }
void init_tasking() { current_task = (struct task_t*)kmalloc(sizeof(struct task_t)); current_task->pid = next_pid++; current_task->page_directory = current_directory; current_task->next = 0; ready_queue_start = current_task; ready_queue_end = current_task; register_interrupt_handler(IRQ0, &timer_callback); init_timer(19); }
void init_timer(u32 freq) { /* Install the function we just wrote */ register_interrupt_handler(IRQ0, timer_callback); /* Get the PIT value: hardware clock at 1193180 Hz */ u32 divisor = 1193180 / freq; u8 low = (u8)(divisor & 0xFF); u8 high = (u8)( (divisor >> 8) & 0xFF); /* Send the command */ port_byte_out(0x43, 0x36); /* Command port */ port_byte_out(0x40, low); port_byte_out(0x40, high); }
void init_pit(unsigned frequency) { register_interrupt_handler(IRQ0, &timer_callback); unsigned divisor = 1193180 / frequency; outportb(PIT_CR_PORT, 0x36); unsigned char l = (unsigned char)(divisor & 0xFF); unsigned char h = (unsigned)( (divisor>>8) & 0xFF ); outportb(PIT_PORT_1, l); outportb(PIT_PORT_1, h); }
TEST(interrupt_test, TooManyHandlers) { // This should fail after 4 registered // We already have 1 from the setup. int i = 1; while(register_interrupt_handler(3, &callback, (void*)i) == 0) { i++; if(i > 300) { // arbitrarily large number break; } } TEST_ASSERT_EQUAL(4, i); // unregister all the interrupts we assigned. while(unregister_interrupt_handler(3, &callback, (void*)i--) == 0); }
void init_timer(u32int frequency) { register_interrupt_handler(IRQ0, &timer_callback); u32int divisor = 1193180 / frequency; outb(0x43, 0x36); // Divisor has to be sent byte-wise u8int l = (u8int)(divisor & 0xFF); u8int h = (u8int)(divisor>>8); outb(0x40, l); outb(0x40, h); }
void* console_device(void * arg) { uint32_t scancode; iorq_t iorq; int i; char c; char * aux; memset(&keybd_device, 0, sizeof(device_t)); strcpy(keybd_device.ln_link.name, "org.era.dev.console"); keybd_device.iorq_queue = create_queue(10, sizeof(iorq_t)); keybd_queue = create_queue(1, sizeof(uint32_t)); register_interrupt_handler(IRQ1, &keypress_isr); monitor_writexy(0,24, " 1", 7, 0); for(;;) { queue_recv(keybd_device.iorq_queue, &iorq, QM_BLOCKING); if(iorq.io_desc == DC_READ) { i = 0; aux = (char *) iorq.io_dptr; memset(aux, 0, iorq.io_sz); while(1) { queue_recv(keybd_queue, &scancode, QM_BLOCKING); c = kbdus[scancode]; if (c == '\n') break; if ((c == '\b') && (i > 0)) { aux[i] = '\0'; i--; monitor_put('\b'); continue; } if (c == 0 || c == '\t' || i == (iorq.io_sz - 1)) continue; if(isprintable(c) ) { aux[i++] = c; monitor_put(c); } } monitor_put('\n'); aux[i] = '\0'; queue_send(iorq.io_response, NULL, QM_NONBLOCKING); } } }
void init_timer_divisor(u32 div) { register_interrupt_handler(IRQ0, &timer_callback); u16 divisor = div; outb(0x43, 0x36); u8 l = (u8)(divisor & 0xFF); u8 h = (u8)((divisor >> 8) & 0xFF); outb(0x40, h); outb(0x40, l); ioapic_set_int(acpi_remap_irq(0), 32); }
s8int init_keyboard() { printf ( "Initalizing Keyboard." ); keyboard_inst = (keyboard_t*)kmalloc(sizeof(keyboard_t)); strcpy(keyboard_inst->driver_name, "i8042_Matrix_kybd\000"); keyboard_inst->init = (void*)i8042_Init; //TODO When PCI make this search for keyboards and use the right handler keyboard_inst->lights = (void*)i8042_Caps; //keyboard_inst->init(); i8042_Init(); i8042_Caps(1,0,0); i8042_Caps(0,0,0); register_interrupt_handler ( IRQ1, &keyboard_handler ); return 0; }
void timer_init(u32 frequency) { register_interrupt_handler(IRQ0, &timer_callback); u32 divisor = 1193180 / frequency; // - send command byte and set PIT to repeating mode // - tell that we want to set the divisor outb(0x43, 0x36); u8 l = (u8)(divisor & 0xff); u8 h = (u8)((divisor >> 8) & 0xff); // send frequency divisor outb(0x40, l); outb(0x40, h); }