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);
}
