main.c

/***************************************************************************
                          main.c  -  description
                             -------------------
    begin                : Sat Dec 13 2003
    copyright            : (C) 2003 by Dynacube Team
    email                : mdshah82@yahoo.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/


#include "core/kmaster.h"
#include "core/vm86.h"
#include "core/ktask.h"

#include "common/stdlib.h"
#include "common/string.h"
#include "common/ds/stack.h"
#include "common/ds/queue.h"
#include "common/ds/hashmap.h"

#include "mm/mm.h"
#include "proc/proc.h"
#include "fs/fat12.h"

#include "gui/zorder.h"
#include "gui/svga.h"
#include "gui/server/gui.h"

#include "dev/core/kpic.h"
#include "dev/floppy/floppy.h"


// Exported Symbols
extern void _Z6runGUIv();
extern void _Z9list_initv();

void callGUI();

int main(void)
{
 //Global Initialization
 //Perhaps I should replace it with some init()....
 DD i;

 cli();
 cls();

 kprint("Dynacube\t1.0\tLoading [dd/mm/yyyy]\n");
 kprint("------------------------------------------------------\n");

 printf("\n\n\n\t\tHELLO WORLD !!!\n\n");
 kdump();

// BLOCK
 gdt_init();

 kprint("\nSystem Descriptors Loaded................ ");

 pic_init();

 kprint("\nPIC remapped................ \n");

 printf("\nkrnl_size %x val: %d",KERNEL_SIZE,(PHYS_MEM/_4MB));

 task_init();
 proc_init();
 
 memcpy((void *)(KERNEL_SIZE),(void *)null_proc,512);

 q_init(&ready_q);
 q_init(&message_q);
 q_init(&timer_q);
 q_init(&intr_q);
 q_init(&gui_q);
 q_init(&fs_q);

 for(i = 0 ; i < 3 ; i++)
   q_init(&device_q[i]);

 z_init();
 hash_init();

 _Z9list_initv();

 cls();

 // Retrieve stored VBE information
 vbe_mode = *((VBE_ModeInfo *) (0x91000));
 printf("\nPhys addr: %x xRes %d yRes %d bpp %d",vbe_mode.PhysBasePtr,vbe_mode.XResolution,vbe_mode.YResolution,vbe_mode.BitsPerPixel);
 printf("\nModeAttributes : %x",vbe_mode.ModeAttributes);

 mouse_init();

 mm_init();
 task_init();
 proc_init();
 fs_init();

 forkNULL();
 startGUI();
 startFloppy();
 startFS();
 create("\\editor");
// create("\\calc");
// create("\\run");
// create("\\timeset");

 printQ(&ready_q);

 cls();
 pit0_init(1);
 pic_enable(TIMER);
 pic_enable(KEYBOARD);
 pic_enable(FLOPPY);
 pic_enable(PS2_MOUSE);
 
 // Let multi-tasking begin :)
 sti();

 while(1);

 return 0;
}


void startGUI()
{
  _proc[GUI_PID].avl = _false;

  _proc[GUI_PID].cr3 = _system.cr3;

  _proc[GUI_PID].cs = _system.cs;
  _proc[GUI_PID].ds = _system.ds;
  _proc[GUI_PID].ss = GUI_STACK_SEL * 8; //_system.ss;//
  _proc[GUI_PID].es = _system.es;
  _proc[GUI_PID].fs = _system.fs;
  _proc[GUI_PID].gs = _system.gs;

  _proc[GUI_PID].eax = 0;
  _proc[GUI_PID].ebx = 0;
  _proc[GUI_PID].ecx = 0;
  _proc[GUI_PID].edx = 0;
  _proc[GUI_PID].esi = 0;
  _proc[GUI_PID].edi = 0;
  _proc[GUI_PID].ebp = 0;

  _proc[GUI_PID].esp = (KERNEL_SIZE - 2 *_4MB/4); //Set ESP
  _proc[GUI_PID].eip = _Z6runGUIv;
  _proc[GUI_PID].eflags = _system.eflags | (1<<9);

  _proc[GUI_PID].ss0 = _system.ss;
  _proc[GUI_PID].ss1 = NULL1_SEL;
  _proc[GUI_PID].ss2 = NULL1_SEL;   
  
  _proc[GUI_PID].ldt_sel = LDT_USR_SEL * 8; //_system.ldt_sel;
  
   enq(&ready_q,GUI_PID);    
}

void startFloppy()
{
  _proc[FLOPPY_PID].avl = _false;

  _proc[FLOPPY_PID].cr3 = _system.cr3;

  _proc[FLOPPY_PID].cs = _system.cs;
  _proc[FLOPPY_PID].ds = _system.ds;
  _proc[FLOPPY_PID].ss = FLOPPY_STACK_SEL * 8; //_system.ss;//
  _proc[FLOPPY_PID].es = _system.es;
  _proc[FLOPPY_PID].fs = _system.fs;
  _proc[FLOPPY_PID].gs = _system.gs;

  _proc[FLOPPY_PID].eax = 0;
  _proc[FLOPPY_PID].ebx = 0;
  _proc[FLOPPY_PID].ecx = 0;
  _proc[FLOPPY_PID].edx = 0;
  _proc[FLOPPY_PID].esi = 0;
  _proc[FLOPPY_PID].edi = 0;
  _proc[FLOPPY_PID].ebp = 0;

  _proc[FLOPPY_PID].esp = (KERNEL_SIZE - _4MB/4); //Set ESP
  _proc[FLOPPY_PID].eip =  runFloppy; // callGUI; 
  _proc[FLOPPY_PID].eflags = _system.eflags | (1<<9);

  _proc[FLOPPY_PID].ss0 = _system.ss;
  _proc[FLOPPY_PID].ss1 = NULL1_SEL;
  _proc[FLOPPY_PID].ss2 = NULL1_SEL;

  _proc[FLOPPY_PID].ldt_sel = LDT_USR_SEL * 8; //_system.ldt_sel;

   enq(&ready_q,FLOPPY_PID);
}

void startFS()
{
  _proc[FS_PID].avl = _false;

  _proc[FS_PID].cr3 = _system.cr3;

  _proc[FS_PID].cs = _system.cs;
  _proc[FS_PID].ds = _system.ds;
  _proc[FS_PID].ss = FS_STACK_SEL * 8; //_system.ss;//
  _proc[FS_PID].es = _system.es;
  _proc[FS_PID].fs = _system.fs;
  _proc[FS_PID].gs = _system.gs;

  _proc[FS_PID].eax = 0;
  _proc[FS_PID].ebx = 0;
  _proc[FS_PID].ecx = 0;
  _proc[FS_PID].edx = 0;
  _proc[FS_PID].esi = 0;
  _proc[FS_PID].edi = 0;
  _proc[FS_PID].ebp = 0;

  _proc[FS_PID].esp = (KERNEL_SIZE - _4MB); //Set ESP
  _proc[FS_PID].eip =  runFS;
  _proc[FS_PID].eflags = _system.eflags | (1<<9);

  _proc[FS_PID].ss0 = _system.ss;
  _proc[FS_PID].ss1 = NULL1_SEL;
  _proc[FS_PID].ss2 = NULL1_SEL;

  _proc[FS_PID].ldt_sel = LDT_USR_SEL * 8; //_system.ldt_sel;

   enq(&ready_q,FS_PID);
}

/* END OF FILE */

---