void main(void) /* This really IS void, no error here. */ { /* The startup routine assumes (well, ...) this */ /* * Interrupts are still disabled. Do necessary setups, then * enable them */ ROOT_DEV = ORIG_ROOT_DEV; drive_info = DRIVE_INFO; memory_end = (1<<20) + (EXT_MEM_K<<10); memory_end &= 0xfffff000; if (memory_end > 16*1024*1024) memory_end = 16*1024*1024; if (memory_end > 12*1024*1024) buffer_memory_end = 4*1024*1024; else if (memory_end > 6*1024*1024) buffer_memory_end = 2*1024*1024; else buffer_memory_end = 1*1024*1024; main_memory_start = buffer_memory_end; #ifdef RAMDISK main_memory_start += rd_init(main_memory_start, RAMDISK*1024); #endif mem_init(main_memory_start,memory_end); trap_init(); blk_dev_init(); chr_dev_init(); tty_init(); time_init(); sched_init(); buffer_init(buffer_memory_end); hd_init(); floppy_init(); sti(); move_to_user_mode(); setup((void *) &drive_info); (void) open("/dev/tty0",O_RDWR,0); (void) dup(0); (void) dup(0); (void) open("/var/process.log",O_CREAT|O_TRUNC|O_WRONLY,0666); #ifdef dis_func (void) open("/var/dis_func.log",O_CREAT|O_TRUNC|O_WRONLY,0666); #endif if (!fork()) { /* we count on this going ok */ init(); } /* * NOTE!! For any other task 'pause()' would mean we have to get a * signal to awaken, but task0 is the sole exception (see 'schedule()') * as task 0 gets activated at every idle moment (when no other tasks * can run). For task0 'pause()' just means we go check if some other * task can run, and if not we return here. */ for(;;) pause(); }
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"); }
/* * This is the kernel main routine. When the boot process is completed, this * function is called. */ void start_kernel(void) { int pid, i; char *names[N_CONSOLES] = { "PRG1", "PRG2", "PRG3", "PRG4", "PRG5", "PRG6" }; // init traps init_traps(); // initialize IRQs init_irq(); // initialize the tty driver. The tty is composed by a keyboard driver // that read input keys a print the relative ASCII code on video. tty_init(); // initialize the timer. time_init(); // initialize the scheduler sched_init(); printk("Kernel info: %u bytes, start at 0x%x0 end at 0x%x0.\n", &__KERNEL_END__-K_START, K_START, &__KERNEL_END__); sti(); // calibrate delay calibrate_delay(); // floppy driver initialization floppy_init(); // switch in user mode move_to_user_mode(); // for a process for each console and execute the program PRGi for (i=0; i<N_CONSOLES; ++i) { // spawn process i and run PRG1 pid = fork(); if (pid == 0) { exec(names[i]); } else if (pid < 0) { print("idle: cannot duplicate myself.\n"); } } print("Idle: ok!\n"); // idle loop while(1); }
static bool fd_init(void) { fs = (struct fs_module *)kernel->open_module("fs", SYS_VER); if(fs == NULL) return FALSE; shell = (struct shell_module *)kernel->open_module("shell", SYS_VER); if(shell == NULL) { kernel->close_module((struct module *)fs); return FALSE; } add_floppy_commands(); floppy_init(); return TRUE; }
void main(void) /* This really IS void, no error here. */ { /* The startup routine assumes (well, ...) this */ /* * Interrupts are still disabled. Do necessary setups, then * enable them */ ROOT_DEV = ORIG_ROOT_DEV; drive_info = DRIVE_INFO; memory_end = (1<<20) + (EXT_MEM_K<<10); memory_end &= 0xfffff000; if (memory_end > 16*1024*1024) memory_end = 16*1024*1024; if (memory_end > 12*1024*1024) buffer_memory_end = 4*1024*1024; else if (memory_end > 6*1024*1024) buffer_memory_end = 2*1024*1024; else buffer_memory_end = 1*1024*1024; main_memory_start = buffer_memory_end; #ifdef RAMDISK main_memory_start += rd_init(main_memory_start, RAMDISK*1024); #endif mem_init(main_memory_start,memory_end); trap_init(); /* set the IDT in 0x00080000~0x000807ff(4KB)*/ blk_dev_init(); chr_dev_init(); /* this function do nothing */ tty_init(); /* rs_init() and con_init() */ time_init(); sched_init(); buffer_init(buffer_memory_end); hd_init(); floppy_init(); sti(); move_to_user_mode(); if (!fork()) { /* we count on this going ok */ init(); } /* * NOTE!! For any other task 'pause()' would mean we have to get a * signal to awaken, but task0 is the sole exception (see 'schedule()') * as task 0 gets activated at every idle moment (when no other tasks * can run). For task0 'pause()' just means we go check if some other * task can run, and if not we return here. */ for(;;) pause(); }
int main() { //Start video driver (must always be before loading message) mm_init(); pg_init(); real_init(); video_init(); video_setdriver(video_vgatext_getdriver(),0); //Put loading message cli_puts("ArcaneOS Loading...\n"); //Setup kernel gdt_init(); idt_init(); isr_init(); irq_init(); timer_init(); kb_init(); ui_init(); cpuid_init(); cmos_init(); rtc_init(); acpi_init(); power_init(); mt_init(); syscall_init(); floppy_init(); __asm__ __volatile__ ("sti"); //Enable ACPI acpi_enable(); //Create thread for ui mt_create_thread(mt_kernel_process,test,2); //Endless loop to prevent bugs when all threads are sleeping for(;;) __asm__ __volatile__ ("hlt"); }
void i8272_init(void) { floppy_init(); }
/* main code for identifying and maybe opening a disk image; not exposed * directly because this function is big and hideous */ static floperr_t floppy_open_internal(void *fp, const struct io_procs *procs, const char *extension, const struct FloppyFormat *floppy_options, int max_options, int flags, floppy_image **outfloppy, int *outoption) { floperr_t err; floppy_image *floppy; int best_option = -1; int best_vote = 0; int vote; size_t i; floppy = floppy_init(fp, procs, flags); if (!floppy) { err = FLOPPY_ERROR_OUTOFMEMORY; goto done; } /* vote on the best format */ for (i = 0; (i < max_options) && floppy_options[i].construct; i++) { if (!extension || !floppy_options[i].extensions || findextension(floppy_options[i].extensions, extension)) { if (floppy_options[i].identify) { vote = 0; err = floppy_options[i].identify(floppy, &floppy_options[i], &vote); if (err) goto done; } else { vote = 1; } /* is this option a better one? */ if (vote > best_vote) { best_vote = vote; best_option = i; } } } /* did we find a format? */ if (best_option == -1) { err = FLOPPY_ERROR_INVALIDIMAGE; goto done; } if (outfloppy) { /* call the format constructor */ err = floppy_options[best_option].construct(floppy, &floppy_options[best_option], NULL); if (err) goto done; floppy->floppy_option = &floppy_options[best_option]; } err = FLOPPY_ERROR_SUCCESS; done: /* if we have a floppy disk and we either errored or are not keeping it, close it */ if (floppy && (!outfloppy || err)) { floppy_close_internal(floppy, FALSE); floppy = NULL; } if (outoption) *outoption = err ? -1 : best_option; if (outfloppy) *outfloppy = floppy; return err; }
floperr_t floppy_create(void *fp, const struct io_procs *procs, const struct FloppyFormat *format, option_resolution *parameters, floppy_image **outfloppy) { floppy_image *floppy = NULL; optreserr_t oerr; floperr_t err; int heads, tracks, h, t; option_resolution *alloc_resolution = NULL; assert(format); /* create the new image */ floppy = floppy_init(fp, procs, 0); if (!floppy) { err = FLOPPY_ERROR_OUTOFMEMORY; goto done; } /* if this format expects creation parameters and none were specified, create some */ if (!parameters && floppy_option_guide && format->param_guidelines) { alloc_resolution = option_resolution_create(floppy_option_guide, format->param_guidelines); if (!alloc_resolution) { err = FLOPPY_ERROR_OUTOFMEMORY; goto done; } parameters = alloc_resolution; } /* finish the parameters, if specified */ if (parameters) { oerr = option_resolution_finish(parameters); if (oerr) { err = option_to_floppy_error(oerr); goto done; } } /* call the format constructor */ err = format->construct(floppy, format, parameters); if (err) goto done; /* format the disk, ignoring if formatting not implemented */ if (floppy->format.format_track) { heads = floppy_get_heads_per_disk(floppy); tracks = floppy_get_tracks_per_disk(floppy); for (h = 0; h < heads; h++) { for (t = 0; t < tracks; t++) { err = floppy->format.format_track(floppy, h, t, parameters); if (err) goto done; } } } /* call the post_format function, if present */ if (floppy->format.post_format) { err = floppy->format.post_format(floppy, parameters); if (err) goto done; } floppy->floppy_option = format; err = FLOPPY_ERROR_SUCCESS; done: if (err && floppy) { floppy_close_internal(floppy, FALSE); floppy = NULL; } if (outfloppy) *outfloppy = floppy; else if (floppy) floppy_close_internal(floppy, FALSE); if (alloc_resolution) option_resolution_close(alloc_resolution); return err; }
// // Start Kernel asmlinkage void start_kernel(void) { char buf[255]; int _i = 0; int _diff = 0; _video_draw_char('O', 79, 10); _video_draw_char('c', 79, 11); _video_draw_char('t', 79, 12); _video_draw_char('a', 79, 13); _video_draw_char('n', 79, 14); _video_draw_char('e', 79, 15); _video_draw_char(' ', 79, 16); _video_draw_char(' ', 79, 17); // Draw a banner line of the right side of the screen for (_i = 0; _i < 10; _i++) { _video_draw_char(' ', 79,_i); } for (_i = 18; _i < 22; _i++) { _video_draw_char(' ', 79,_i); } load_misc_kprint(); __sprintf(buf, "=========== Octane ===========\n"); __puts(buf); __sprintf(buf, "@INFO: Build: %ld; since (10/15/2007) %s\n", main_get_build_count, main_get_version); __puts(buf); //memory_end = (1<<20) + (EXT_MEM_K<<10); // memory_end &= PAGE_MASK; memory_end = 16*1024*1024; memory_start = 1024*1024; low_memory_start = (unsigned long) &_end; // now lets load the IDT load_exception_table(); init_interrupts(); sched_init(); load_keyboard_driver(); //memory_start = blk_dev_init(memory_start, memory_end); sti(); //calibrate_delay(); //memory_start = inode_init(memory_start, memory_end); //memory_start = file_table_init(memory_start, memory_end); //mem_init(low_memory_start, memory_start, memory_end); //buffer_init(); time_init(); // Print the current time. printk("INFO: current time: %d\n", xtime.tv_sec); printk("INFO: %d/%d/%d %d:%d\n", cur_simpletime.mon, cur_simpletime.day, cur_simpletime.year, cur_simpletime.hour, cur_simpletime.min); floppy_init(); sti(); //__debug_floppy_open(); //__debug_floppy_release(); test_time_1(); test_block_1(); tests(); for(;;) { _nop(); } }
int main(int argc, char *argv[]) { int c; struct state *state = NULL; #if TEST_BUILD struct test_case *test_case; #endif prefs_init(); while(1) { int option_index = 0; static struct option long_options[] = { {"cart", required_argument, 0, OPT_CART }, {"force-extreme-disasm", no_argument, 0, OPT_FORCE_EXTREME_DISASM }, {"crop-screen", no_argument, 0, OPT_CROP_SCREEN }, {"loglevels" , required_argument, 0, OPT_LOGLEVELS }, {"audio-device" , required_argument, 0, OPT_AUDIO_DEVICE }, #if TEST_BUILD {"test-case", required_argument, 0, OPT_TEST_MODE}, #endif {0, 0, 0, 0 } }; c = getopt_long(argc, argv, "a:b:c:t:s:hdpyVAMvq", long_options, &option_index); if(c == -1) break; switch(c) { case 'a': prefs_set("diskimage", optarg); break; case 'b': prefs_set("diskimage2", optarg); break; case 'c': prefs_set("hdimage", optarg); break; case 't': prefs_set("tosimage", optarg); break; case 's': prefs_set("stateimage", optarg); break; case OPT_CART: prefs_set("cartimage", optarg); break; case OPT_FORCE_EXTREME_DISASM: cprint_all = 1; break; case OPT_CROP_SCREEN: crop_screen = 1; break; case OPT_LOGLEVELS: diag_set_module_levels(optarg); break; case OPT_AUDIO_DEVICE: if(!strncmp("list", optarg, 4)) { audio_device = -1; } else { audio_device = atoi(optarg); } break; #if TEST_BUILD case OPT_TEST_MODE: test_case_name = xstrdup(optarg); test_mode = 1; break; #endif case 'd': debugger = 1; break; case 'p': ppmoutput = 1; break; case 'y': psgoutput = 1; break; case 'v': verbosity++; break; case 'q': verbosity = MAX(1, verbosity-1); break; case 'V': vsync_delay = 1; break; case 'A': play_audio = 1; break; case 'M': monitor_sm124 = 1; break; case 'h': default: printf("Usage: %s [-AdMpqvVy] [-a diskimage1] [-b diskimage2] [-c hdimage] [-t tosimage] [-s stateimage]\n", argv[0]); exit(-1); break; } } /* Do not crop screen while debugging */ if(debugger) { crop_screen = 0; } if((prefs.diskimage == NULL) && (argv[optind] != NULL)) prefs_set("diskimage", argv[optind]); SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_AUDIO); #if TEST_BUILD if(test_mode) { test_case = test_init(test_case_name); if(test_case) { if(test_case->cartridge_name) { prefs_set("cartimage", test_case->cartridge_name); } if(test_case->floppy_name) { prefs_set("diskimage", test_case->floppy_name); } } else { printf("DEBUG: Could not load test case %s\n", test_case_name); exit(-3); } } #endif /* Must run before hardware module inits */ mmu_init(); /* This must also be run before hardware modules. It gives a dummy area for some memory regions to not cause bus errors */ mmu_fallback_init(); /* Actual hardware */ ram_init(); rom_init(); cpu_init(); if(prefs.cartimage) { cartridge_init(prefs.cartimage); } else { cartridge_init(NULL); } psg_init(); midi_init(); acia_init(); ikbd_init(); #if INCLUDE_RTC rtc_init(); #endif dma_init(); fdc_init(); hdc_init(prefs.hdimage); mfp_init(); screen_disable(0); glue_init(); shifter_init(); if(debugger) { debug_init(); cpu_halt_for_debug(); } screen_init(); floppy_init(prefs.diskimage, prefs.diskimage2); if(prefs.stateimage) { state = state_load(prefs.stateimage); } if(state != NULL) state_restore(state); memset(&reset, 0, sizeof reset); reset.sa_sigaction = reset_action; sigaction(SIGHUP, &reset, NULL); while(cpu_run(CPU_RUN)); return 0; }