/* Copyright (C) 2004  The SOS Team
    Copyright (C) 1999  Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA. 
 */
 
 /* Include definitions of the multiboot standard */
 #include <bootstrap/multiboot.h>
 #include <hwcore/idt.h>
 #include <hwcore/gdt.h>
 #include <hwcore/irq.h>
 #include <hwcore/exception.h>
 #include <hwcore/i8254.h>
 #include <sos/list.h>
 #include <sos/physmem.h>
 #include <hwcore/paging.h>
 #include <sos/list.h>
 #include <sos/klibc.h>
 #include <sos/assert.h>
 #include <drivers/x86_videomem.h>
 #include <drivers/bochs.h>
 
 
 /* Helper function to display each bits of a 32bits integer on the
    screen as dark or light carrets */
 static void display_bits(unsigned char row, unsigned char col,
                          unsigned char attribute,
                          sos_ui32_t integer)
 {
   int i;
   /* Scan each bit of the integer, MSb first */
   for (i = 31 ; i >= 0 ; i--)
     {
       /* Test if bit i of 'integer' is set */
       int bit_i = (integer & (1 << i));
       /* Ascii 219 => dark carret, Ascii 177 => light carret */
       unsigned char ascii_code = bit_i?219:177;
       sos_x86_videomem_putchar(row, col++,
                                attribute,
                                ascii_code);
     }
 }
 
 
 /* Clock IRQ handler */
 static void clk_it(int intid)
 {
   static sos_ui32_t clock_count = 0;
 
   display_bits(0, 48,
                SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
                clock_count);
   clock_count++;
 
 }
 
 /* Page fault exception handler */
 static void pgflt_ex(int exid)
 {
   sos_bochs_printf("Got page fault\n");
   sos_x86_videomem_printf(10, 30,
                           SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
                           "Got EXPECTED (?) Page fault ! But where ???");
   for (;;) ;
 }
 
 static void test_paging(sos_vaddr_t sos_kernel_core_top_vaddr)
 {
   /* The (linear) address of the page holding the code we are
      currently executing */
   sos_vaddr_t vpage_code = SOS_PAGE_ALIGN_INF(test_paging);
 
   /* The new physical page that will hold the code */
   sos_paddr_t ppage_new;
 
   /* Where this page will be mapped temporarily in order to copy the
      code into it: right after the kernel code/data */
   sos_vaddr_t vpage_tmp = sos_kernel_core_top_vaddr;
 
   unsigned i;
 
   /* Bind the page fault exception to one of our routines */
   sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
                             pgflt_ex);
 
   /*
    * Test 1: move the page where we execute the code elsewhere in
    * physical memory
    */
   sos_x86_videomem_printf(4, 0,
                           SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
                           "Moving current code elsewhere in physical memory:");
 
 
   /* Allocate a new physical page */
   ppage_new = sos_physmem_ref_physpage_new(FALSE);
   if (! ppage_new)
     {
       /* STOP ! No memory left */
       sos_x86_videomem_putstring(20, 0,
                                  SOS_X86_VIDEO_FG_LTRED
                                    | SOS_X86_VIDEO_BG_BLUE,
                                  "test_paging : Cannot allocate page");
       return;
     }
 
   sos_x86_videomem_printf(5, 0,
                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                           "Hello from the address 0x%x in physical memory",
                           sos_paging_get_paddr(vpage_code));
 
   sos_x86_videomem_printf(6, 0,
                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                           "Transfer vpage 0x%x: ppage 0x%x -> 0x%x (tmp vpage 0x%x)",
                           vpage_code,
                           sos_paging_get_paddr(vpage_code),
                           ppage_new,
                           (unsigned)vpage_tmp);
 
   /* Map the page somewhere (right after the kernel mapping) in order
      to copy the code we are currently executing */
   sos_paging_map(ppage_new, vpage_tmp,
                  FALSE,
                  SOS_VM_MAP_ATOMIC
                  | SOS_VM_MAP_PROT_READ
                  | SOS_VM_MAP_PROT_WRITE);
 
   /* Ok, the new page is referenced by the mapping, we can release our
      reference to it */
   sos_physmem_unref_physpage(ppage_new);
 
   /* Copy the contents of the current page of code to this new page
      mapping */
   memcpy((void*)vpage_tmp,
          (void*)vpage_code,
          SOS_PAGE_SIZE);
 
   /* Transfer the mapping of the current page of code to this new page */
   sos_paging_map(ppage_new, vpage_code,
                  FALSE,
                  SOS_VM_MAP_ATOMIC
                  | SOS_VM_MAP_PROT_READ
                  | SOS_VM_MAP_PROT_WRITE);
   
   /* Ok, here we are: we have changed the physcal page that holds the
      code we are executing ;). However, this new page is mapped at 2
      virtual addresses:
      - vpage_tmp
      - vpage_code
      We can safely unmap it from sos_kernel_core_top_vaddr, while
      still keeping the vpage_code mapping */
   sos_paging_unmap(vpage_tmp);
 
   sos_x86_videomem_printf(7, 0,
                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                           "Hello from the address 0x%x in physical memory",
                           sos_paging_get_paddr(vpage_code));
 
   sos_x86_videomem_printf(9, 0,
                           SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
                           "Provoking a page fault:");
 
   /*
    * Test 2: make sure the #PF handler works
    */
 
   /* Scan part of the kernel up to a page fault. This page fault
      should occur on the first page unmapped after the kernel area,
      which is exactly the page we temporarily mapped/unmapped
      (vpage_tmp) above to move the kernel code we are executing */
   for (i = vpage_code ; /* none */ ; i += SOS_PAGE_SIZE)
     {
       unsigned *pint = (unsigned *)SOS_PAGE_ALIGN_INF(i);
       sos_bochs_printf("Test vaddr 0x%x : val=", (unsigned)pint);
       sos_x86_videomem_printf(10, 0,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "Test vaddr 0x%x : val=      ",
                               (unsigned)pint);
       sos_bochs_printf("0x%x\n", *pint);
       sos_x86_videomem_printf(10, 30,
                               SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                               "0x%x          ", *pint);
     }
 
   /* BAD ! Did not get the page fault... */
   sos_x86_videomem_printf(20, 0,
                           SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
                           "We should have had a #PF at vaddr 0x%x !",
                           vpage_tmp);
 }
 
 /* The C entry point of our operating system */
 void sos_main(unsigned long magic, unsigned long addr)
 {
   unsigned i;
   sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
 
   /* Grub sends us a structure, called multiboot_info_t with a lot of
      precious informations about the system, see the multiboot
      documentation for more information. */
   multiboot_info_t *mbi;
   mbi = (multiboot_info_t *) addr;
 
   /* Setup bochs and console, and clear the console */
   sos_bochs_setup();
 
   sos_x86_videomem_setup();
   sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
 
   /* Greetings from SOS */
   if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
     /* Loaded with Grub */
     sos_x86_videomem_printf(1, 0,
                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                             "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
                             "SOS", ',',
                             (unsigned)(mbi->mem_upper >> 10) + 1,
                             (unsigned)mbi->mem_upper);
   else
     /* Not loaded with grub */
     sos_x86_videomem_printf(1, 0,
                             SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                             "Welcome to SOS");
 
   sos_bochs_putstring("Message in a bochs\n");
 
   /* Setup CPU segmentation and IRQ subsystem */
   sos_gdt_setup();
   sos_idt_setup();
 
   /* Setup SOS IRQs and exceptions subsystem */
   sos_exceptions_setup();
   sos_irq_setup();
 
   /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
   sos_i8254_set_frequency(100);
 
 
   /* We need a multiboot-compliant boot loader to get the size of the RAM */
   if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
     {
       sos_x86_videomem_putstring(20, 0,
                                  SOS_X86_VIDEO_FG_LTRED
                                    | SOS_X86_VIDEO_BG_BLUE
                                    | SOS_X86_VIDEO_FG_BLINKING,
                                  "I'm not loaded with Grub !");
       /* STOP ! */
       for (;;)
         continue;
     }
 
   /* Binding some HW interrupts and exceptions to software routines */
   sos_irq_set_routine(SOS_IRQ_TIMER,
                             clk_it);
   /* Enabling the HW interrupts here, this will make the timer HW
      interrupt call our clk_it handler */
   asm volatile ("sti\n");
   /* Multiboot says: "The value returned for upper memory is maximally
      the address of the first upper memory hole minus 1 megabyte.". It
      also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */
   sos_physmem_setup((mbi->mem_upper<<10) + (1<<20),
                     & sos_kernel_core_base_paddr,
                     & sos_kernel_core_top_paddr);
   
   /*
    * Switch to paged-memory mode
    */
 
   /* Disabling interrupts should seem more correct, but it's not really
      necessary at this stage */
   if (sos_paging_setup(sos_kernel_core_base_paddr,
                        sos_kernel_core_top_paddr))
     sos_bochs_printf("Could not setup paged memory mode\n");
   sos_x86_videomem_printf(2, 0,
                           SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
                           "Paged-memory mode is activated");
 
   test_paging(sos_kernel_core_top_paddr);
 
   /* An operatig system never ends */
   for (;;)
     continue;
 
   return;
 }