int main()
{
log_init(1, "emu86.log");
mem_init();
/* load_rom("../rom/wdbios.rom", 0xc8000, 8192, "a39b2b1c3e298b3599995c353d16c3ad");*/
load_rom("../rom/basicc11.f6", 0xf6000, 8192, "69e2bd1d08c893cbf841607c8749d5bd");
load_rom("../rom/basicc11.f8", 0xf8000, 8192, "5f85ff5ea352c1ec11b084043fbb549e");
load_rom("../rom/basicc11.fa", 0xfa000, 8192, "04a285d5dc8d86c60679e8f3c779dcc4");
load_rom("../rom/basicc11.fc", 0xfc000, 8192, "b086a6980fc5736098269e62b59726ef");
load_rom("../rom/pc081682.bin", 0xfe000, 8192, "1584aeaadebba4bc95783f1fa0fa3db8");
cpu_init();
pit_init();
pic_init();
dma_init();
ppi_init();
fdc_init();
initscr();
cbreak();
noecho();
nodelay(stdscr, TRUE);
keypad(stdscr, TRUE);
mainloop();
endwin();
return 0;
}
void interrupt_init() {
int i;
pic_init(32, 40);
for (i = 32; i < 48; i++) {
interrupt_disable(i);
interrupt_acknowledge(i);
}
for (i = 0; i < 32; i++) {
interrupt_handler_table[i] = unknown_exception;
interrupt_spurious[i] = 0;
interrupt_count[i] = 0;
}
for (i = 32; i < 48; i++) {
interrupt_handler_table[i] = unknown_hardware;
interrupt_spurious[i] = 0;
interrupt_count[i] = 0;
}
// Wire vector index 14 to pagefault handler
interrupt_handler_table[14] = exception_handle_pagefault;
interrupt_unblock();
console_printf("interrupt: ready\n");
}
void kernel_early(multiboot_info_t* mbd, unsigned int magic)
{
terminal_initialize();
printf("Starting jOS Kernel\n");
printf("===================\n\n");
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
panic("Bootloader is not Multiboot Compliant");
memory_init(mbd);
printf("[x] Memory Initialized\n");
gdt_init();
printf("GDT Initialized, entering Protected Mode\n");
printf("Enabling IDT:\n");
pic_init();
printf("\t[x] PIC IRQs remapped\n");
idt_init();
printf("\t[x] IDT Initialized\n");
if (are_interrupts_enabled())
printf("\t[x] Hardware Interrupts enabled\n");
else
printf("\t[ ] Error enabling Hardware Interrupts\n");
phys_mem_management_init();
}
int lapic_init() {
uint32_t edx = 0;
cpu_t *cpu = cpu_this;
pic_init();
cpu_id(1,NULL,NULL,NULL,&edx);
if (edx&(1<<9) && 0) {
isr_uselapic = 1;
cpu->uselapic = 1;
lapic = memkernel_findvirt(1)+PAGEOFF(LAPIC_PHYS_ADDRESS);
if (paging_map(PAGEDOWN(lapic),PAGEDOWN(LAPIC_PHYS_ADDRESS),0,1)<0) panic("Cannot map LAPIC\n");
lapic->tpr = 0x20;
lapic->lvt_timer = 0x20030;
lapic->lvt_thermal = 0x20031;
lapic->lvt_pmc = 0x20032;
lapic->lvt_lint0 = 0x08700;
lapic->lvt_lint1 = 0x08700;
lapic->lvt_error = 0x20035;
lapic->spurious = 0x0010F;
pic_pit_setinterval(0,LAPIC_PIT_CALIBRATE_INTERVAL);
return 0;
}
else {
isr_uselapic = 0;
cpu->uselapic = 0;
cpu->interval = 10; // IRQ0 all 10 ms
pic_pit_setinterval(0,cpu->interval);
return -1;
}
}
void
i386_init(void)
{
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
cprintf("6828 decimal is %o octal!\n", 6828);
// Lab 2 memory management initialization functions
i386_detect_memory();
i386_vm_init();
page_init();
page_check();
// Lab 3 user environment initialization functions
env_init();
idt_init();
// Lab 4 multitasking initialization functions
pic_init();
kclock_init();
// Should always have an idle process as first one.
ENV_CREATE(user_idle);
// Start fs.
ENV_CREATE(fs_fs);
ENV_CREATE(user_icode);
#if defined(TEST)
// Don't touch -- used by grading script!
ENV_CREATE2(TEST, TESTSIZE)
#else
// Touch all you want.
// ENV_CREATE(user_icode);
// ENV_CREATE(user_pipereadeof);
// ENV_CREATE(user_pipewriteeof);
// ENV_CREATE(user_testpipe);
// ENV_CREATE(user_primespipe);
// ENV_CREATE(user_testpiperace);
// ENV_CREATE(user_testpiperace2);
// ENV_CREATE(user_testfdsharing);
#endif // TEST*
// Should not be necessary - drain keyboard because interrupt has given up.
kbd_intr();
// Schedule and run the first user environment!
sched_yield();
}
status_t
arch_int_init(kernel_args* args)
{
// setup the standard programmable interrupt controller
pic_init();
return B_OK;
}
Pic *pic_open_stream (char *dev, FILE *stream, char *name, char *mode)
{
int i;
char *data;
Pic *p, *q;
if (pic_npic<0) pic_init();
if (!dev) { /* probably comes from pic_file_dev */
fprintf(stderr, "unknown pic device on %s\n", name);
return 0;
}
for (i=0; i<pic_npic && !str_eq(dev, pic_list[i]->dev); i++);
if (i>=pic_npic) {
fprintf(stderr, "unknown pic device: %s\n", dev);
return 0;
}
q = pic_list[i];
data = (*q->procs->open_stream)(stream, name, mode);
if (!data) return 0;
/* copy the Pic structure before modifying it */
ALLOC(p, Pic, 1);
*p = *q;
p->data = data;
return p;
}
int
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
kprintf ("%s\n\n", message);
/* Only to initialize lcpu_count. */
mp_init ();
pmm_init(); // init physical memory management
pmm_init_ap ();
pic_init(); // init interrupt controller
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
ide_init(); // init ide devices
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
cpu_idle(); // run idle process
}
int main()
{
pic_init();
logging_init();
button_init();
bumper_init();
pwm_init();
motor_timer_init();
button_timer_init();
sound_config_timer_init();
//put_str_ln("Initialising DMA...");
//init_DMA();
//put_str_ln("Initialising ADC...");
init_ADC();
// setup des interrupts
INTCONSET = _INTCON_MVEC_MASK;
__builtin_enable_interrupts();
if (VERBOSE_PIC_STATUS)
put_str_ln("Ready.");
while (1)
{
WDTCONbits.WDTCLR = 1; // ecrire un 1 dans ce bit force la reinitialisation du watchdog
}
}
int
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
cprintf("%s\n\n", message);
print_kerninfo();
grade_backtrace();
pic_init(); // init interrupt controller
idt_init(); // init interrupt descriptor table
pmm_init(); // init physical memory management
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
//LAB1: CAHLLENGE 1 If you try to do it, uncomment lab1_switch_test()
// user/kernel mode switch test
//lab1_switch_test();
cpu_idle(); // run idle process
}
void kmain(void)
{
//bsod();
intr_disable();
idt_init();
pic_init();
console_init();
if (keyboard_init())
goto error;
kprintf("kernel86\n");
intr_enable();
shell_do();
error:
kprintf("error");
while (1)
;
}
int __noreturn
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
cprintf("%s\n\n", message);
print_kerninfo();
pmm_init(); // init physical memory management
pic_init(); // init interrupt controller
idt_init(); // init interrupt descriptor table
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
ide_init(); // init ide devices
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
cpu_idle(); // run idle process
}
int kernel_main()
{
/*
* Tell the kernel memory allocator which memory it can't use.
* It already knows not to touch kernel image.
*/
lmm_remove_free( &malloc_lmm, (void*)USER_MEM_START, USER_MEM_SIZE );
lmm_remove_free( &malloc_lmm, (void*)0, 0x100000 );
/*
* Initialize drivers here.
*/
driver_init();
/*
* initialize the PIC so that IRQs and
* exception handlers don't overlap in the IDT.
*/
pic_init( BASE_IRQ_MASTER_BASE, BASE_IRQ_SLAVE_BASE );
/* This is all up to you... */
return -1;
}
void idt_init() {
memset(idt_entries, 0, sizeof(idt_entries));
idt_ptr.base = (uint32_t)idt_entries;
idt_ptr.limit = sizeof(idt_entries) - 1;
pic_init();
idt_set_entry( 0, (uint32_t)exception0 , 0x08, 0x8E);
idt_set_entry( 1, (uint32_t)exception1 , 0x08, 0x8E);
idt_set_entry( 2, (uint32_t)exception2 , 0x08, 0x8E);
idt_set_entry( 3, (uint32_t)exception3 , 0x08, 0x8E);
idt_set_entry( 4, (uint32_t)exception4 , 0x08, 0x8E);
idt_set_entry( 5, (uint32_t)exception5 , 0x08, 0x8E);
idt_set_entry( 6, (uint32_t)exception6 , 0x08, 0x8E);
idt_set_entry( 7, (uint32_t)exception7 , 0x08, 0x8E);
idt_set_entry( 8, (uint32_t)exception8 , 0x08, 0x8E);
idt_set_entry( 9, (uint32_t)exception9 , 0x08, 0x8E);
idt_set_entry(10, (uint32_t)exception10, 0x08, 0x8E);
idt_set_entry(11, (uint32_t)exception11, 0x08, 0x8E);
idt_set_entry(12, (uint32_t)exception12, 0x08, 0x8E);
idt_set_entry(13, (uint32_t)exception13, 0x08, 0x8E);
idt_set_entry(14, (uint32_t)exception14, 0x08, 0x8E);
idt_set_entry(15, (uint32_t)exception15, 0x08, 0x8E);
idt_set_entry(16, (uint32_t)exception16, 0x08, 0x8E);
idt_set_entry(17, (uint32_t)exception17, 0x08, 0x8E);
idt_set_entry(18, (uint32_t)exception18, 0x08, 0x8E);
idt_set_entry(19, (uint32_t)exception19, 0x08, 0x8E);
idt_set_entry(20, (uint32_t)exception20, 0x08, 0x8E);
idt_set_entry(21, (uint32_t)exception21, 0x08, 0x8E);
idt_set_entry(22, (uint32_t)exception22, 0x08, 0x8E);
idt_set_entry(23, (uint32_t)exception23, 0x08, 0x8E);
idt_set_entry(24, (uint32_t)exception24, 0x08, 0x8E);
idt_set_entry(25, (uint32_t)exception25, 0x08, 0x8E);
idt_set_entry(26, (uint32_t)exception26, 0x08, 0x8E);
idt_set_entry(27, (uint32_t)exception27, 0x08, 0x8E);
idt_set_entry(28, (uint32_t)exception28, 0x08, 0x8E);
idt_set_entry(29, (uint32_t)exception29, 0x08, 0x8E);
idt_set_entry(30, (uint32_t)exception30, 0x08, 0x8E);
idt_set_entry(31, (uint32_t)exception31, 0x08, 0x8E);
idt_set_entry(32, (uint32_t)irq0, 0x08, 0x8E);
idt_set_entry(33, (uint32_t)irq1, 0x08, 0x8E);
idt_set_entry(34, (uint32_t)irq2, 0x08, 0x8E);
idt_set_entry(35, (uint32_t)irq3, 0x08, 0x8E);
idt_set_entry(36, (uint32_t)irq4, 0x08, 0x8E);
idt_set_entry(37, (uint32_t)irq5, 0x08, 0x8E);
idt_set_entry(38, (uint32_t)irq6, 0x08, 0x8E);
idt_set_entry(39, (uint32_t)irq7, 0x08, 0x8E);
idt_set_entry(40, (uint32_t)irq8, 0x08, 0x8E);
idt_set_entry(41, (uint32_t)irq9, 0x08, 0x8E);
idt_set_entry(42, (uint32_t)irq10, 0x08, 0x8E);
idt_set_entry(43, (uint32_t)irq11, 0x08, 0x8E);
idt_set_entry(44, (uint32_t)irq12, 0x08, 0x8E);
idt_set_entry(45, (uint32_t)irq13, 0x08, 0x8E);
idt_set_entry(46, (uint32_t)irq14, 0x08, 0x8E);
idt_set_entry(47, (uint32_t)irq15, 0x08, 0x8E);
idt_set_entry(128, (uint32_t)exception128, 0x08, 0x8E);
idt_flush((uint32_t)&(idt_ptr));
asm volatile("sti");
}
void
i386_init(void)
{
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
cprintf("6828 decimal is %o octal!\n", 6828);
// Lab 2 memory management initialization functions
i386_detect_memory();
i386_vm_init();
// Lab 3 user environment initialization functions
env_init();
idt_init();
// Lab 4 multitasking initialization functions
pic_init();
kclock_init();
time_init();
pci_init();
// Should always have an idle process as first one.
ENV_CREATE(user_idle);
// Start fs.
ENV_CREATE(fs_fs);
#if !defined(TEST_NO_NS)
// Start ns.
ENV_CREATE(net_ns);
#endif
#if defined(TEST)
// Don't touch -- used by grading script!
ENV_CREATE2(TEST, TESTSIZE);
#else
// Touch all you want.
// ENV_CREATE(net_testoutput);
// ENV_CREATE(user_echosrv);
// ENV_CREATE(user_httpd);
// ENV_CREATE(user_writemotd);
// ENV_CREATE(user_testfile);
ENV_CREATE(user_icode);
// ENV_CREATE(user_primes);
#endif // TEST*
// Schedule and run the first user environment!
sched_yield();
}
void
i386_init(void)
{
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
cprintf("6828 decimal is %o octal!\n", 6828);
// Lab 2 memory management initialization functions
mem_init();
// Lab 3 user environment initialization functions
env_init();
trap_init();
// Lab 4 multiprocessor initialization functions
mp_init();
lapic_init();
// Lab 4 multitasking initialization functions
pic_init();
// Acquire the big kernel lock before waking up APs
// Your code here:
lock_kernel();
// Starting non-boot CPUs
boot_aps();
// Start fs.
ENV_CREATE(fs_fs, ENV_TYPE_FS);
#if defined(TEST)
// Don't touch -- used by grading script!
ENV_CREATE(TEST, ENV_TYPE_USER);
#else
// Touch all you want.
//<<<<<<< HEAD
ENV_CREATE(user_icode, ENV_TYPE_USER);
//=======
// ENV_CREATE(user_dumbfork, ENV_TYPE_USER);
//>>>>>>> lab4
#endif // TEST*
// Should not be necessary - drains keyboard because interrupt has given up.
kbd_intr();
// Schedule and run the first user environment!
sched_yield();
}
void arch_entry() {
paging_init();
gdt_init();
idt_init();
isr_init();
pic_init();
pit_init();
}
static void
p160x_pic_setup(void)
{
pic_init();
/* I really wonder if this shouldn't be prepivr instead */
isa_pic = setup_i8259();
oea_install_extint(pic_ext_intr);
}
void
i386_init(void)
{
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
//bluesea
//经测试，下面的语句会输出:edata f0114300, end f0114970
//因此，edata < end, [edata, end)之间是bss段, kernel需要用的global variable.
// > end之后的内存可以用于boot_alloc
//cprintf("edata %x, end %x\n", edata, end);
cprintf("6828 decimal is %o octal!\n", 6828);
// Lab 2 memory management initialization functions
mem_init();
// Lab 3 user environment initialization functions
env_init();
trap_init();
// Lab 4 multiprocessor initialization functions
mp_init();
lapic_init();
// Lab 4 multitasking initialization functions
pic_init();
// Acquire the big kernel lock before waking up APs
// Your code here:
lock_kernel();
// Starting non-boot CPUs
boot_aps();
#if defined(TEST)
// Don't touch -- used by grading script!
ENV_CREATE(TEST, ENV_TYPE_USER);
#else
// Touch all you want.
//ENV_CREATE(user_primes, ENV_TYPE_USER);
//ENV_CREATE(user_yield, ENV_TYPE_USER);
//ENV_CREATE(user_yield, ENV_TYPE_USER);
//ENV_CREATE(user_yield, ENV_TYPE_USER);
ENV_CREATE(user_dumbfork, ENV_TYPE_USER);
#endif // TEST*
// Schedule and run the first user environment!
sched_yield();
}
void
i386_init(void)
{
extern char edata[], end[];
// Before doing anything else, complete the ELF loading process.
// Clear the uninitialized global data (BSS) section of our program.
// This ensures that all static/global variables start out zero.
memset(edata, 0, end - edata);
// Initialize the console.
// Can't call cprintf until after we do this!
cons_init();
cprintf("372 decimal is %o octal!\n", 372);
// Lab 2 memory management initialization functions
mem_init();
// Lab 3 user environment initialization functions
env_init();
trap_init();
// Lab 4 multiprocessor initialization functions
mp_init();
lapic_init();
// Lab 4 multitasking initialization functions
pic_init();
// Acquire the big kernel lock before waking up APs
// Your code here:
lock_kernel();
// Starting non-boot CPUs
boot_aps();
// Should always have idle processes at first.
int i;
for (i = 0; i < NCPU; i++)
ENV_CREATE(user_idle, ENV_TYPE_IDLE);
// ENV_CREATE(user_yield, ENV_TYPE_USER);
// ENV_CREATE(user_yield, ENV_TYPE_USER);
// ENV_CREATE(user_yield, ENV_TYPE_USER);
#if defined(TEST)
// Don't touch -- used by grading script!
ENV_CREATE(TEST, ENV_TYPE_USER);
#else
// Touch all you want.
ENV_CREATE(user_primes, ENV_TYPE_USER);
#endif // TEST*
// Schedule and run the first user environment!
sched_yield();
}
void pic_catalog(void)
{
int i;
if (pic_npic<0) pic_init();
printf("picture devices/file formats known:");
for (i=0; i<pic_npic; i++)
printf(" %s", pic_list[i]->dev);
printf("\n");
}
void common_init()
{
dma_init();
fdc_add();
lpt_init();
pic_init();
pit_init();
serial1_init(0x3f8, 4);
serial2_init(0x2f8, 3);
}
/** PC platform initialization. */
__init_text void platform_init(void) {
pic_init();
acpi_init();
/* If the LAPIC is not available, we must use the PIT as the timer. */
if(!lapic_enabled())
pit_init();
i8042_init();
}
/*---------------------------------------------------------------------------*/
void
irq_init(void)
{
pic_init();
/* Set a 'fake' handler for the Spurious IRQ7 interrupts.
* Refer to http://wiki.osdev.org/PIC .
*/
SET_INTERRUPT_HANDLER(IRQ7_INT, 0, spurious_irq7_handler);
}
void pcjr_init()
{
fdc_add_pcjr();
pic_init();
pit_init();
pit_set_out_func(0, pit_irq0_timer_pcjr);
serial1_init(0x2f8, 3);
keyboard_pcjr_init();
device_add(&sn76489_device);
nmi_mask = 0x80;
}
void common_init()
{
dma_init();
fdc_add();
lpt_init();
pic_init();
pit_init();
serial1_init(0x3f8, 4);
serial2_init(0x2f8, 3);
device_add(&gameport_device);
}
/// Called from our bootstub
/// \param mbd Virtual address of Grub multiboot info structure (*? bytes)
/// \param magic Grub boot signature (0x1BADB002) (4 bytes)
void arch_init(multiboot_info_t* mbd, unsigned int magic)
{
// Create the kernel info build string
sprintf(kinfo.buildstring, "EOS (Built %s %s using GNU C version %s)", __DATE__, __TIME__, __VERSION__);
// Low level hardware setup of the interrupt controller and system timer
pic_init();
pit_init(100);
asm ("sti");
// Clear screen
tty_clear();
// Parse the command line
kernel_parse_cmdline((char *)PHYS_VIRT(mbd->cmdline));
// Now safe to print to the kernel log
printf("%s\n", kinfo.buildstring);
kprintf(1, "arch_init(mbd: %08X, magic: %08X)\n", mbd, magic);
// Read CPU information
cpu_init();
// Read placement information
kinfo.start = &_ld_kernel_start;
kinfo.end = &_ld_kernel_end;
kinfo.memory = mbd->mem_upper;
// Read kernel elf headers
elf_init_kernel(&mbd->u.elf_sec);
// Read module information
if (mbd->mods_count > 0)
{
kprintf(2, "found %d modules\n", mbd->mods_count);
// Read multiboot module information
multiboot_module_t *mod;
mod = (void *)PHYS_VIRT(mbd->mods_addr);
// Expand kernel end to include the loaded modules
kinfo.end = (void *)PHYS_VIRT(mod[mbd->mods_count - 1].mod_end);
// The first module is the initfs the rest are drivers
if (mbd->mods_count > 1)
arch_init_drivers(&mod[1], mbd->mods_count - 1);
}
// Start the memory manager
mm_init(128 * 1024);
dev_init();
kernel_init();
}
void boot_64(uint32_t magic, uint32_t multiboot) {
// checking multiboot magic variable.
VGA_AT(0,0) = VGA_ENTRY('H', WHITE_ON_BLACK);
if (magic != MULTIBOOT_BOOTLOADER_MAGIC) {
VGA_AT(0,1) = VGA_ENTRY('!', WHITE_ON_BLACK);
kernel_panic();
}
// copying multiboot data.
VGA_AT(0,1) = VGA_ENTRY('E', WHITE_ON_BLACK);
multiboot_info_t *info = (multiboot_info_t *)kernel_p2v((uintptr_t)multiboot);
switch (multiboot_copy(info)) {
case MULTIBOOT_TOO_MANY_MEMORY_MAPS:
VGA_AT(0,2) = VGA_ENTRY('?', WHITE_ON_BLACK);
kernel_panic();
case MULTIBOOT_TOO_MANY_MODULES:
VGA_AT(0,2) = VGA_ENTRY('?', WHITE_ON_BLACK);
kernel_panic();
case MULTIBOOT_TOO_MANY_ELF_HEADERS:
VGA_AT(0,2) = VGA_ENTRY('.', WHITE_ON_BLACK);
kernel_panic();
}
// we no longer need the original memory map at zero address.
VGA_AT(0,2) = VGA_ENTRY('L', WHITE_ON_BLACK);
page_set_pdpt(0, 0, 0);
page_invalidate_all();
// initialize page allocators.
VGA_AT(0,3) = VGA_ENTRY('L', WHITE_ON_BLACK);
lomem_init();
himem_init();
// initialize CPUs.
VGA_AT(0,4) = VGA_ENTRY('B', WHITE_ON_BLACK);
cpu_enable_features();
cpu_init();
service_init();
gdt_init(); // adds per-cpu TSS into GDT.
tss_update();
// initialize interrupt handling.
VGA_AT(0,5) = VGA_ENTRY('E', WHITE_ON_BLACK);
pic_init();
idt_init();
// kick-start the core service.
VGA_AT(0,6) = VGA_ENTRY('N', WHITE_ON_BLACK);
kernel_start_core();
// start scheduler and do stuff.
VGA_AT(0,7) = VGA_ENTRY('D', WHITE_ON_BLACK);
kernel_main();
}
void init(void)
{
exceptions_init();
hide_cursor();
vga_setcolor(0x07);
pic_init();
idt_write_table();
kb_init(); //Init keyboard driver
floppy_init();
lex_init();
printf("\nSystem booted.\n\n");
}
void init(struct multiboot *mb)
{
size_t i;
for(i=0;i<TEXT_HEIGHT*TEXT_WIDTH*2;i++)
{
*(((char *)TEXT_BUFFER)+i)=0;
}
text_pos=0;
printk("benaryOS booted");
if(mb->mbs_cmdline)
{
printk(" with cmdline \"%s\"",(char *)mb->mbs_cmdline);
}
putchar('\n');
hardware_detection();
//Physical Memory Management
printk("initialise PMM\n");
pmm_init(mb);
//Global Descriptor Table
printk("loading GDT\n");
gdt_init();
//Programmable Interrupt Timer
printk("initialise PIT\n");
pit_init(100);
//Programmable Interrupt Controller
printk("initialise PIC\n");
pic_init();
//Interrupt Descriptor Table
printk("initialise IDT\n");
idt_init();
//Paging
printk("initialise Paging\n");
paging_init(mb);
//Modules
printk("loading modules(%d)\n",mb->mbs_mods_count);
modules_init(mb);
printk("benaryOS running\n");
printk("starting first task now\n");
asm volatile("sti");
//find_com();
//this will forget our thread
asm volatile("int $0x20");
}
