--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cos/kernel/handlers.c	Mon Nov 14 22:45:55 2011 +0100
@@ -0,0 +1,296 @@
+#include "kernel.h"
+
+void panic(char *msg) {
+  printf("Kernel panic: ");
+  printf(msg);
+  halt();
+}
+
+// Assembler wrapper prototypes:
+void INTDEF(void);
+void INT0(void);
+void INT1(void);
+void INT2(void);
+void INT3(void);
+void INT4(void);
+void INT5(void);
+void INT6(void);
+void INT7(void);
+void INT8(void);
+void INT9(void);
+void INT10(void);
+void INT11(void);
+void INT12(void);
+void INT13(void);
+void INT14(void);
+void INT15(void);
+void INT16(void);
+void INT17(void);
+void INT18(void);
+void INT19(void);
+// Remapped handlers:
+void INT32(void);
+void INT33(void);
+void INT34(void);
+
+// THE interrupt descriptor table:
+static struct IDT_entry idt[256];
+
+void setIDTentry(int num, void (*handler)())
+{
+  // Fill one entry with IDT info:
+  uint64_t offset;
+  unsigned short selector = 0x8; // Code selector
+  unsigned char type = 0x8E; // 32 bits interrupt gate. Thingy is present 
+
+  offset = (uint64_t) handler;
+
+  idt[num].b[0] = offset & 0xFF;
+  idt[num].b[1] = (offset >> 8) & 0xFF;
+  idt[num].b[2] = selector & 0xFF;
+  idt[num].b[3] = (selector >> 8) & 0xFF;
+  idt[num].b[4] = 0; // reserved
+  idt[num].b[5] = type;
+  idt[num].b[6] = (offset >> 16) & 0xFF;
+  idt[num].b[7] = (offset >> 24) & 0xFF;
+}
+
+void setupIDT(void) {
+  int i;
+  // Fill all vectors with the default handler:
+  for (i=0; i<256; i++) {
+    setIDTentry(i, &INTDEF);
+  }
+
+  // Now set other then default handler:
+  setIDTentry(0, INT0);
+  setIDTentry(1, INT1);
+  setIDTentry(2, INT2);
+  setIDTentry(3, INT3);
+  setIDTentry(4, INT4);
+  setIDTentry(5, INT5);
+  setIDTentry(6, INT6);
+  setIDTentry(7, INT7);
+  setIDTentry(8, INT8);
+  setIDTentry(9, INT9);
+  setIDTentry(10, INT10);
+  setIDTentry(11, INT11);
+  setIDTentry(12, INT12);
+  setIDTentry(13, INT13);
+  setIDTentry(14, INT14);
+  setIDTentry(15, INT15);
+  setIDTentry(16, INT16);
+  setIDTentry(17, INT17);
+  setIDTentry(18, INT18);
+  setIDTentry(19, INT19);
+  /* reserved interrupts: */
+  // From int20 - int31
+  setIDTentry(32, INT32);
+  setIDTentry(33, INT33);
+  setIDTentry(34, INT34);
+
+  // call load IDT asm function:
+  loadIDT(idt, 256*8-1);
+
+  PICremap();
+  enableinterrupts();
+}
+
+// PIC functions:
+void PICremap() {
+  unsigned char maskmaster, maskslave, pic1, pic2;
+  pic1 = 0x20; // remapping location master
+  pic2 = 0x28;
+  maskmaster = inb(0x21); // master cmd=0x20, data=0x21
+  maskslave = inb(0xA1); // slave command=0xA0, data=0xA1
+
+  outb(0x20, 0x20); // end of init
+
+  outb(0x20, 0x11); // init + ICW1_ICW2
+  outb(0xA0, 0x11); // init + ICW1_ICW2
+    
+  outb(0x21, pic1); // ICW2, write offset
+  outb(0xA1, pic2); // ICW2
+
+  outb(0x21, 4); // ICW3, write a 4!
+  outb(0xA1, 2); // ICW3, write a 2!
+
+  outb(0x21, 1); // ICW4, 8086 mode
+  outb(0xA1, 1); // ICW4
+
+  outb(0x21, maskmaster);
+  outb(0xA1, maskslave);
+}
+
+// Interrupt service routines:
+
+void INT0handler() 
+{
+  printf("INT0 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT1handler() 
+{
+  printf("INT1 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT2handler() 
+{
+  printf("INT2 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT3handler() 
+{
+  printf("INT3 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT4handler() 
+{
+  printf("INT4 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT5handler() 
+{
+  printf("INT5 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT6handler() 
+{
+  printf("INT6 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT7handler() 
+{
+  printf("INT7 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT8handler() 
+{
+  printf("INT8 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT9handler() 
+{
+  printf("INT9 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT10handler() 
+{
+  printf("INT10 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT11handler() 
+{
+  printf("INT11 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT12handler() 
+{
+  printf("INT12 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT13handler() 
+{
+  printf("INT13 called!\n");
+  panic("Unhandled exception!");
+}
+
+void* getUnusedPage() {
+ return 0;
+
+}
+
+void mappage(uint32_t address) {
+  uint32_t pageDirIndex = address >> 22;
+  uint32_t pageTableIndex = (address >> 12) & 0x3FF;
+
+  printf("Allocating page at %d, tableindex=%d\n", pageDirIndex, pageTableIndex);
+  //uint32_t *pageTable = (uint32_t*)(pageDirectory[pageDirIndex] & 0xFFFFFC00);
+ 
+
+}
+
+void INT14handler(unsigned int address) 
+{
+  printf("INT14 called! Page fault for address 0x%x!\n", address);
+  if ( (address & 0xF0000000) == 0xD0000000 ) {
+    mappage(address & 0xFFFFF000);
+    return;
+  }
+
+  panic("Unhandled exception!");
+}
+
+void INT15handler() 
+{
+  printf("INT15 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT16handler() 
+{
+  printf("INT16 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT17handler() 
+{
+  printf("INT17 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT18handler() 
+{
+  printf("INT18 called!\n");
+  panic("Unhandled exception!");
+}
+
+void INT19handler() 
+{
+  printf("INT19 called!\n");
+  panic("Unhandled exception!");
+}
+
+// remapped IRQ from master PIC:
+void INT32handler() 
+{
+  // System timer.
+  //printf("INT32 called!\n");
+  // called very frequent, what is this?
+  timerDriverUpdate();
+  outb(0x20, 0x20); // EOI to master
+}
+
+void INT33handler() 
+{
+  //printf("INT33 called, key pressed????\n");
+  unsigned char scancode = inb(0x60);
+  //printf("Scancode = 0x%x\n", scancode);
+  keyboardDriverUpdate(scancode);
+  outb(0x20, 0x20); // EOI to master
+}
+
+void INT34handler() 
+{
+  printf("INT34 called!\n");
+}
+
+void INTDEF_handler() 
+{
+  printf("Default int handler called\n");
+}
+
+