/* * Running in virtual memory, on the interrupt stack. * Does not return. Dispatches initial thread. * * Assumes that master_cpu is set. */ void setup_main(void) { thread_t startup_thread; printf_init(); panic_init(); sched_init(); vm_mem_bootstrap(); ipc_bootstrap(); vm_mem_init(); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ PMAP_ACTIVATE_KERNEL(master_cpu); init_timers(); timeout_init(); #if CDLI > 0 ns_init(); /* Initialize CDLI */ #endif /* CDLI > 0 */ dev_lookup_init(); timeout_init(); machine_init(); machine_info.max_cpus = NCPUS; machine_info.memory_size = mem_size; machine_info.avail_cpus = 0; machine_info.major_version = KERNEL_MAJOR_VERSION; machine_info.minor_version = KERNEL_MINOR_VERSION; #if XPR_DEBUG xprbootstrap(); #endif /* XPR_DEBUG */ /* * Initialize the IPC, task, and thread subsystems. */ clock_init(); utime_init(); ledger_init(); #if THREAD_SWAPPER thread_swapper_init(); #endif /* THREAD_SWAPPER */ #if TASK_SWAPPER task_swapper_init(); #endif /* TASK_SWAPPER */ task_init(); act_init(); thread_init(); subsystem_init(); #if TASK_SWAPPER task_swappable(&realhost, kernel_task, FALSE); #endif /* TASK_SWAPPER */ #if MACH_HOST pset_sys_init(); #endif /* MACH_HOST */ /* * Kick off the time-out driven routines by calling * them the first time. */ recompute_priorities(); compute_mach_factor(); /* * Initialize the Event Trace Analysis Package. * Dynamic Phase: 2 of 2 */ etap_init_phase2(); /* * Create a kernel thread to start the other kernel * threads. Thread_resume (from kernel_thread) calls * thread_setrun, which may look at current thread; * we must avoid this, since there is no current thread. */ /* * Create the thread, and point it at the routine. */ (void) thread_create_at(kernel_task, &startup_thread, start_kernel_threads); #if NCPUS > 1 && PARAGON860 thread_bind(startup_thread, cpu_to_processor(master_cpu)); #endif /* * Pretend it is already running, and resume it. * Since it looks as if it is running, thread_resume * will not try to put it on the run queues. * * We can do all of this without locking, because nothing * else is running yet. */ startup_thread->state |= TH_RUN; (void) thread_resume(startup_thread->top_act); /* * Start the thread. */ cpu_launch_first_thread(startup_thread); /*NOTREACHED*/ panic("cpu_launch_first_thread returns!"); }
static void test_machine_command_with_clamp(void) { TEST_START_PRINT(); register_value_t data[] = { 0, // A REGISTER_MAX - 10, 20, // B, C REGISTER_MIN + 10, -20, // D, E REGISTER_MAX / 2 + 1, 2, // F, G REGISTER_MIN / 2 - 1, 2, // H, I 42, 0, // J, K 11, 12, 13, 14, 15, 16, 17 }; machine_init(data, NB_REGISTERS); command_t *command; register_value_t result; // Clamping of ADD. command = machine_command_create(reg_A, ADD, reg_B, reg_C); machine_command_run(command); result = machine_result_get(); assert(result == REGISTER_MAX); machine_command_destroy(command); command = machine_command_create(reg_A, ADD, reg_D, reg_E); machine_command_run(command); result = machine_result_get(); assert(result == REGISTER_MIN); machine_command_destroy(command); // Clamping of SUB. command = machine_command_create(reg_A, SUB, reg_B, reg_E); machine_command_run(command); result = machine_result_get(); assert(result == REGISTER_MAX); machine_command_destroy(command); command = machine_command_create(reg_A, SUB, reg_D, reg_C); machine_command_run(command); result = machine_result_get(); assert(result == REGISTER_MIN); machine_command_destroy(command); // Clamping of MUL. command = machine_command_create(reg_A, MUL, reg_F, reg_G); machine_command_run(command); result = machine_result_get(); assert(result == REGISTER_MAX); machine_command_destroy(command); command = machine_command_create(reg_A, MUL, reg_H, reg_I); machine_command_run(command); result = machine_result_get(); assert(result == REGISTER_MIN); machine_command_destroy(command); // Division by 0. command = machine_command_create(reg_A, DIV, reg_J, reg_K); machine_command_run(command); result = machine_result_get(); assert(result == data[reg_J]); machine_command_destroy(command); TEST_END_PRINT(); }
void kernel_bootstrap(void) { kern_return_t result; thread_t thread; char namep[16]; printf("%s\n", version); /* log kernel version */ #define kernel_bootstrap_kprintf(x...) /* kprintf("kernel_bootstrap: " x) */ if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */ turn_on_log_leaks = 1; PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs)); PE_parse_boot_argn("trace_wake", &wake_nkdbufs, sizeof (wake_nkdbufs)); /* i386_vm_init already checks for this ; do it aagin anyway */ if (PE_parse_boot_argn("serverperfmode", &serverperfmode, sizeof (serverperfmode))) { serverperfmode = 1; } scale_setup(); kernel_bootstrap_kprintf("calling vm_mem_bootstrap\n"); vm_mem_bootstrap(); kernel_bootstrap_kprintf("calling vm_mem_init\n"); vm_mem_init(); machine_info.memory_size = (uint32_t)mem_size; machine_info.max_mem = max_mem; machine_info.major_version = version_major; machine_info.minor_version = version_minor; kernel_bootstrap_kprintf("calling sched_init\n"); sched_init(); kernel_bootstrap_kprintf("calling wait_queue_bootstrap\n"); wait_queue_bootstrap(); kernel_bootstrap_kprintf("calling ipc_bootstrap\n"); ipc_bootstrap(); #if CONFIG_MACF mac_policy_init(); #endif kernel_bootstrap_kprintf("calling ipc_init\n"); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ kernel_bootstrap_kprintf("calling PMAP_ACTIVATE_KERNEL\n"); PMAP_ACTIVATE_KERNEL(master_cpu); kernel_bootstrap_kprintf("calling mapping_free_prime\n"); mapping_free_prime(); /* Load up with temporary mapping blocks */ kernel_bootstrap_kprintf("calling machine_init\n"); machine_init(); kernel_bootstrap_kprintf("calling clock_init\n"); clock_init(); ledger_init(); /* * Initialize the IPC, task, and thread subsystems. */ kernel_bootstrap_kprintf("calling task_init\n"); task_init(); kernel_bootstrap_kprintf("calling thread_init\n"); thread_init(); /* * Create a kernel thread to execute the kernel bootstrap. */ kernel_bootstrap_kprintf("calling kernel_thread_create\n"); result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result); thread->state = TH_RUN; thread_deallocate(thread); kernel_bootstrap_kprintf("calling load_context - done\n"); load_context(thread); /*NOTREACHED*/ }
/* * Running in virtual memory, on the interrupt stack. * Does not return. Dispatches initial thread. * * Assumes that master_cpu is set. */ void setup_main() { thread_t startup_thread; panic_init(); printf_init(); sched_init(); vm_mem_bootstrap(); ipc_bootstrap(); vm_mem_init(); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ PMAP_ACTIVATE_KERNEL(master_cpu); init_timers(); init_timeout(); #if XPR_DEBUG xprbootstrap(); #endif XPR_DEBUG timestamp_init(); mapable_time_init(); machine_init(); machine_info.max_cpus = NCPUS; machine_info.memory_size = phys_last_addr - phys_first_addr; /* XXX mem_size */ machine_info.avail_cpus = 0; machine_info.major_version = KERNEL_MAJOR_VERSION; machine_info.minor_version = KERNEL_MINOR_VERSION; /* * Initialize the IPC, task, and thread subsystems. */ task_init(); thread_init(); swapper_init(); #if MACH_HOST pset_sys_init(); #endif MACH_HOST /* * Kick off the time-out driven routines by calling * them the first time. */ recompute_priorities(); compute_mach_factor(); /* * Create a kernel thread to start the other kernel * threads. Thread_resume (from kernel_thread) calls * thread_setrun, which may look at current thread; * we must avoid this, since there is no current thread. */ /* * Create the thread, and point it at the routine. */ (void) thread_create(kernel_task, &startup_thread); thread_start(startup_thread, start_kernel_threads); /* * Give it a kernel stack. */ thread_doswapin(startup_thread); /* * Pretend it is already running, and resume it. * Since it looks as if it is running, thread_resume * will not try to put it on the run queues. * * We can do all of this without locking, because nothing * else is running yet. */ startup_thread->state |= TH_RUN; (void) thread_resume(startup_thread); /* * Start the thread. */ cpu_launch_first_thread(startup_thread); /*NOTREACHED*/ }
void kernel_bootstrap(void) { kern_return_t result; thread_t thread; char namep[16]; printf("%s\n", version); /* log kernel version */ if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */ turn_on_log_leaks = 1; PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs)); PE_parse_boot_argn("trace_wake", &wake_nkdbufs, sizeof (wake_nkdbufs)); PE_parse_boot_argn("trace_panic", &write_trace_on_panic, sizeof(write_trace_on_panic)); PE_parse_boot_argn("trace_typefilter", &trace_typefilter, sizeof(trace_typefilter)); scale_setup(); kernel_bootstrap_log("vm_mem_bootstrap"); vm_mem_bootstrap(); kernel_bootstrap_log("cs_init"); cs_init(); kernel_bootstrap_log("vm_mem_init"); vm_mem_init(); machine_info.memory_size = (uint32_t)mem_size; machine_info.max_mem = max_mem; machine_info.major_version = version_major; machine_info.minor_version = version_minor; #if CONFIG_TELEMETRY kernel_bootstrap_log("telemetry_init"); telemetry_init(); #endif #if CONFIG_CSR kernel_bootstrap_log("csr_init"); csr_init(); #endif if (PE_i_can_has_debugger(NULL) && PE_parse_boot_argn("-show_pointers", &namep, sizeof (namep))) { doprnt_hide_pointers = FALSE; } kernel_bootstrap_log("stackshot_lock_init"); stackshot_lock_init(); kernel_bootstrap_log("sched_init"); sched_init(); kernel_bootstrap_log("waitq_bootstrap"); waitq_bootstrap(); kernel_bootstrap_log("ipc_bootstrap"); ipc_bootstrap(); #if CONFIG_MACF kernel_bootstrap_log("mac_policy_init"); mac_policy_init(); #endif kernel_bootstrap_log("ipc_init"); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ kernel_bootstrap_log("PMAP_ACTIVATE_KERNEL"); PMAP_ACTIVATE_KERNEL(master_cpu); kernel_bootstrap_log("mapping_free_prime"); mapping_free_prime(); /* Load up with temporary mapping blocks */ kernel_bootstrap_log("machine_init"); machine_init(); kernel_bootstrap_log("clock_init"); clock_init(); ledger_init(); /* * Initialize the IPC, task, and thread subsystems. */ #if CONFIG_COALITIONS kernel_bootstrap_log("coalitions_init"); coalitions_init(); #endif kernel_bootstrap_log("task_init"); task_init(); kernel_bootstrap_log("thread_init"); thread_init(); #if CONFIG_ATM /* Initialize the Activity Trace Resource Manager. */ kernel_bootstrap_log("atm_init"); atm_init(); #endif #if CONFIG_BANK /* Initialize the BANK Manager. */ kernel_bootstrap_log("bank_init"); bank_init(); #endif /* initialize the corpse config based on boot-args */ corpses_init(); /* * Create a kernel thread to execute the kernel bootstrap. */ kernel_bootstrap_log("kernel_thread_create"); result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result); thread->state = TH_RUN; thread->last_made_runnable_time = mach_absolute_time(); thread_deallocate(thread); kernel_bootstrap_log("load_context - done"); load_context(thread); /*NOTREACHED*/ }
int main(int argc, char *argv[]) { char *env_top; char **preset_argv; int preset_argc = 0; void *mask; int need_mini = 1; struct statics statics; globalstate *gstate; /* get our name */ if (argc > 0) { if ((myname = strrchr(argv[0], '/')) == 0) { myname = argv[0]; } else { myname++; } } /* binary compatibility check */ #ifdef HAVE_UNAME { struct utsname uts; if (uname(&uts) == 0) { if (strcmp(uts.machine, UNAME_HARDWARE) != 0) { fprintf(stderr, "%s: incompatible hardware platform\n", myname); exit(EX_UNAVAILABLE); } } } #endif /* initialization */ gstate = (globalstate *)calloc(1, sizeof(globalstate)); gstate->statics = &statics; time_mark(NULL); /* preset defaults for various options */ gstate->show_usernames = Yes; gstate->topn = DEFAULT_TOPN; gstate->delay = DEFAULT_DELAY; gstate->fulldraw = Yes; gstate->use_color = Yes; gstate->interactive = Maybe; /* preset defaults for process selection */ gstate->pselect.idle = Yes; gstate->pselect.system = No; gstate->pselect.fullcmd = No; gstate->pselect.command = NULL; gstate->pselect.uid = -1; gstate->pselect.mode = 0; /* use a large buffer for stdout */ #ifdef HAVE_SETVBUF setvbuf(stdout, stdoutbuf, _IOFBF, BUFFERSIZE); #else #ifdef HAVE_SETBUFFER setbuffer(stdout, stdoutbuf, BUFFERSIZE); #endif #endif /* get preset options from the environment */ if ((env_top = getenv("TOP")) != NULL) { preset_argv = argparse(env_top, &preset_argc); preset_argv[0] = myname; do_arguments(gstate, preset_argc, preset_argv); } /* process arguments */ do_arguments(gstate, argc, argv); #ifdef ENABLE_COLOR /* If colour has been turned on read in the settings. */ env_top = getenv("TOPCOLOURS"); if (!env_top) { env_top = getenv("TOPCOLORS"); } /* must do something about error messages */ color_env_parse(env_top); color_activate(gstate->use_color); #endif /* in order to support forward compatability, we have to ensure that the entire statics structure is set to a known value before we call machine_init. This way fields that a module does not know about will retain their default values */ memzero((void *)&statics, sizeof(statics)); statics.boottime = -1; /* call the platform-specific init */ if (machine_init(&statics) == -1) { exit(EX_SOFTWARE); } /* create a helper list of sort order names */ gstate->order_namelist = string_list(statics.order_names); /* look up chosen sorting order */ if (gstate->order_name != NULL) { int i; if (statics.order_names == NULL) { message_error(" This platform does not support arbitrary ordering"); } else if ((i = string_index(gstate->order_name, statics.order_names)) == -1) { message_error(" Sort order `%s' not recognized", gstate->order_name); message_error(" Recognized sort orders: %s", gstate->order_namelist); } else { gstate->order_index = i; } } /* initialize extensions */ init_username(); /* initialize termcap */ gstate->smart_terminal = screen_readtermcap(gstate->interactive); /* determine interactive state */ if (gstate->interactive == Maybe) { gstate->interactive = smart_terminal; } /* if displays were not specified, choose an appropriate default */ if (gstate->displays == 0) { gstate->displays = gstate->smart_terminal ? Infinity: 1; } /* we don't need a mini display when delay is less than 2 seconds or when we are not on a smart terminal */ if (gstate->delay <= 1 || !smart_terminal) { need_mini = 0; } #ifndef HAVE_FORMAT_PROCESS_HEADER /* set constants for username/uid display */ if (gstate->show_usernames) { gstate->header_text = format_header("USERNAME"); gstate->get_userid = username; } else { gstate->header_text = format_header(" UID "); gstate->get_userid = itoa7; } #endif gstate->pselect.usernames = gstate->show_usernames; /* initialize display */ if ((gstate->max_topn = display_init(&statics)) == -1) { fprintf(stderr, "%s: can't allocate sufficient memory\n", myname); exit(EX_OSERR); } /* check for infinity and for overflowed screen */ if (gstate->topn == Infinity) { gstate->topn = INT_MAX; } else if (gstate->topn > gstate->max_topn) { message_error(" This terminal can only display %d processes", gstate->max_topn); } #ifdef ENABLE_COLOR /* producing a list of color tags is easy */ if (gstate->show_tags) { color_dump(stdout); exit(EX_OK); } #endif /* hold all signals while we initialize the screen */ mask = hold_signals(); screen_init(); /* set the signal handlers */ set_signals(); /* longjmp re-entry point */ /* set the jump buffer for long jumps out of signal handlers */ if (setjmp(jmp_int) != 0) { /* this is where we end up after processing sigwinch or sigtstp */ /* tell display to resize its buffers, and get the new length */ if ((gstate->max_topn = display_resize()) == -1) { /* thats bad */ quit(EX_OSERR); /*NOTREACHED*/ } /* set up for a full redraw, and get the current line count */ gstate->fulldraw = Yes; /* safe to release the signals now */ release_signals(mask); } else { /* release the signals */ release_signals(mask); /* some systems require a warmup */ /* always do a warmup for batch mode */ if (gstate->interactive == 0 || statics.flags.warmup) { struct system_info system_info; struct timeval timeout; time_mark(&(gstate->now)); get_system_info(&system_info); (void)get_process_info(&system_info, &gstate->pselect, 0); timeout.tv_sec = 1; timeout.tv_usec = 0; select(0, NULL, NULL, NULL, &timeout); /* if we've warmed up, then we can show good states too */ gstate->show_cpustates = Yes; need_mini = 0; } } /* main loop */ while ((gstate->displays == -1) || (--gstate->displays > 0)) { do_display(gstate); if (gstate->interactive) { if (need_mini) { do_minidisplay(gstate); need_mini = 0; } do_command(gstate); } else { do_wait(gstate); } } /* do one last display */ do_display(gstate); quit(EX_OK); /* NOTREACHED */ return 1; /* Keep compiler quiet. */ }
static void bios_init(void) { KDEBUG(("bios_init()\n")); /* initialize Native Features, if available * do it as soon as possible so that kprintf can make use of them */ #if DETECT_NATIVE_FEATURES KDEBUG(("natfeat_init()\n")); natfeat_init(); #endif #if STONX_NATIVE_PRINT KDEBUG(("stonx_kprintf_init()\n")); stonx_kprintf_init(); #endif #if CONF_WITH_UAE KDEBUG(("amiga_uaelib_init()\n")); amiga_uaelib_init(); #endif /* Initialize the processor */ KDEBUG(("processor_init()\n")); processor_init(); /* Set CPU type, longframe and FPU type */ KDEBUG(("vecs_init()\n")); vecs_init(); /* setup all exception vectors (above) */ KDEBUG(("init_delay()\n")); init_delay(); /* set 'reasonable' default values for delay */ /* Detect optional hardware (video, sound, etc.) */ KDEBUG(("machine_detect()\n")); machine_detect(); /* detect hardware */ KDEBUG(("machine_init()\n")); machine_init(); /* initialise machine-specific stuff */ /* Initialize the screen */ KDEBUG(("screen_init()\n")); screen_init(); /* detect monitor type, ... */ /* Initialize the BIOS memory management */ KDEBUG(("bmem_init()\n")); bmem_init(); /* this must be done after screen_init() */ KDEBUG(("cookie_init()\n")); cookie_init(); /* sets a cookie jar */ KDEBUG(("fill_cookie_jar()\n")); fill_cookie_jar(); /* detect hardware features and fill the cookie jar */ /* Set up the BIOS console output */ KDEBUG(("linea_init()\n")); linea_init(); /* initialize screen related line-a variables */ font_init(); /* initialize font ring (requires cookie_akp) */ font_set_default(-1);/* set default font */ vt52_init(); /* initialize the vt52 console */ /* Now kcprintf() will also send debug info to the screen */ KDEBUG(("after vt52_init()\n")); /* misc. variables */ dumpflg = -1; sysbase = (LONG) os_entry; savptr = (LONG) trap_save_area; etv_timer = (void(*)(int)) just_rts; etv_critic = default_etv_critic; etv_term = just_rts; /* setup VBL queue */ nvbls = 8; vblqueue = vbl_list; { int i; for(i = 0 ; i < 8 ; i++) { vbl_list[i] = 0; } } #if CONF_WITH_MFP KDEBUG(("mfp_init()\n")); mfp_init(); #endif #if CONF_WITH_TT_MFP if (has_tt_mfp) { KDEBUG(("tt_mfp_init()\n")); tt_mfp_init(); } #endif /* Initialize the system 200 Hz timer */ KDEBUG(("init_system_timer()\n")); init_system_timer(); /* Initialize the RS-232 port(s) */ KDEBUG(("chardev_init()\n")); chardev_init(); /* Initialize low-memory bios vectors */ boot_status |= CHARDEV_AVAILABLE; /* track progress */ KDEBUG(("init_serport()\n")); init_serport(); boot_status |= RS232_AVAILABLE; /* track progress */ #if CONF_WITH_SCC if (has_scc) boot_status |= SCC_AVAILABLE; /* track progress */ #endif /* The sound init must be done before allowing MFC interrupts, * because of dosound stuff in the timer C interrupt routine. */ #if CONF_WITH_DMASOUND KDEBUG(("dmasound_init()\n")); dmasound_init(); #endif KDEBUG(("snd_init()\n")); snd_init(); /* Reset Soundchip, deselect floppies */ /* Init the two ACIA devices (MIDI and KBD). The three actions below can * be done in any order provided they happen before allowing MFP * interrupts. */ KDEBUG(("kbd_init()\n")); kbd_init(); /* init keyboard, disable mouse and joystick */ KDEBUG(("midi_init()\n")); midi_init(); /* init MIDI acia so that kbd acia irq works */ KDEBUG(("init_acia_vecs()\n")); init_acia_vecs(); /* Init the ACIA interrupt vector and related stuff */ KDEBUG(("after init_acia_vecs()\n")); boot_status |= MIDI_AVAILABLE; /* track progress */ /* Now we can enable the interrupts. * We need a timer for DMA timeouts in floppy and harddisk initialisation. * The VBL processing will be enabled later with the vblsem semaphore. */ #if CONF_WITH_ATARI_VIDEO /* Keep the HBL disabled */ set_sr(0x2300); #else set_sr(0x2000); #endif KDEBUG(("calibrate_delay()\n")); calibrate_delay(); /* determine values for delay() function */ /* - requires interrupts to be enabled */ KDEBUG(("blkdev_init()\n")); blkdev_init(); /* floppy and harddisk initialisation */ KDEBUG(("after blkdev_init()\n")); /* initialize BIOS components */ KDEBUG(("parport_init()\n")); parport_init(); /* parallel port */ //mouse_init(); /* init mouse driver */ KDEBUG(("clock_init()\n")); clock_init(); /* init clock */ KDEBUG(("after clock_init()\n")); #if CONF_WITH_NLS KDEBUG(("nls_init()\n")); nls_init(); /* init native language support */ nls_set_lang(get_lang_name()); #endif /* set start of user interface */ #if WITH_AES exec_os = ui_start; #elif WITH_CLI exec_os = coma_start; #else exec_os = NULL; #endif KDEBUG(("osinit()\n")); osinit(); /* initialize BDOS */ KDEBUG(("after osinit()\n")); boot_status |= DOS_AVAILABLE; /* track progress */ /* Enable VBL processing */ vblsem = 1; #if CONF_WITH_CARTRIDGE { WORD save_hz = v_hz_rez, save_vt = v_vt_rez, save_pl = v_planes; /* Run all boot applications from the application cartridge. * Beware: Hatari features a special cartridge which is used * for GEMDOS drive emulation. It will hack drvbits and hook Pexec(). * It will also hack Line A variables to enable extended VDI video modes. */ KDEBUG(("run_cartridge_applications(3)\n")); run_cartridge_applications(3); /* Type "Execute prior to bootdisk" */ KDEBUG(("after run_cartridge_applications()\n")); if ((v_hz_rez != save_hz) || (v_vt_rez != save_vt) || (v_planes != save_pl)) { set_rez_hacked(); font_set_default(-1); /* set default font */ vt52_init(); /* initialize the vt52 console */ } } #endif #if CONF_WITH_ALT_RAM #if CONF_WITH_FASTRAM /* add TT-RAM that was detected in memory.S */ if (ramtop != NULL) { KDEBUG(("xmaddalt()\n")); xmaddalt(FASTRAM_START, ramtop - FASTRAM_START); } #endif #if CONF_WITH_MONSTER /* Add MonSTer alt-RAM detected in machine.c */ if (has_monster) { /* Dummy read from MonSTer register to initiate write sequence. */ unsigned short monster_reg = *(volatile unsigned short *)MONSTER_REG; /* Only enable 6Mb when on a Mega STE due to address conflict with VME bus. Todo: This should be made configurable. */ if (has_vme) monster_reg = 6; else monster_reg = 8; /* Register write sequence: read - write - write */ *(volatile unsigned short *)MONSTER_REG = monster_reg; *(volatile unsigned short *)MONSTER_REG = monster_reg; KDEBUG(("xmaddalt()\n")); xmaddalt((UBYTE *)0x400000L, monster_reg*0x100000L); } #endif #ifdef MACHINE_AMIGA KDEBUG(("amiga_add_alt_ram()\n")); amiga_add_alt_ram(); #endif #endif /* CONF_WITH_ALT_RAM */ KDEBUG(("bios_init() end\n")); }
static void xtensa_lx60_init(QEMUMachineInitArgs *args) { static const LxBoardDesc lx60_board = { .flash_base = 0xf8000000, .flash_size = 0x00400000, .flash_sector_size = 0x10000, .sram_size = 0x20000, }; lx_init(&lx60_board, args); } static void xtensa_lx200_init(QEMUMachineInitArgs *args) { static const LxBoardDesc lx200_board = { .flash_base = 0xf8000000, .flash_size = 0x01000000, .flash_sector_size = 0x20000, .sram_size = 0x2000000, }; lx_init(&lx200_board, args); } static void xtensa_ml605_init(QEMUMachineInitArgs *args) { static const LxBoardDesc ml605_board = { .flash_base = 0xf8000000, .flash_size = 0x02000000, .flash_sector_size = 0x20000, .sram_size = 0x2000000, }; lx_init(&ml605_board, args); } static void xtensa_kc705_init(QEMUMachineInitArgs *args) { static const LxBoardDesc kc705_board = { .flash_base = 0xf0000000, .flash_size = 0x08000000, .flash_sector_size = 0x20000, .sram_size = 0x2000000, }; lx_init(&kc705_board, args); } static QEMUMachine xtensa_lx60_machine = { .name = "lx60", .desc = "lx60 EVB (" XTENSA_DEFAULT_CPU_MODEL ")", .init = xtensa_lx60_init, .max_cpus = 4, }; static QEMUMachine xtensa_lx200_machine = { .name = "lx200", .desc = "lx200 EVB (" XTENSA_DEFAULT_CPU_MODEL ")", .init = xtensa_lx200_init, .max_cpus = 4, }; static QEMUMachine xtensa_ml605_machine = { .name = "ml605", .desc = "ml605 EVB (" XTENSA_DEFAULT_CPU_MODEL ")", .init = xtensa_ml605_init, .max_cpus = 4, }; static QEMUMachine xtensa_kc705_machine = { .name = "kc705", .desc = "kc705 EVB (" XTENSA_DEFAULT_CPU_MODEL ")", .init = xtensa_kc705_init, .max_cpus = 4, }; static void xtensa_lx_machines_init(void) { qemu_register_machine(&xtensa_lx60_machine); qemu_register_machine(&xtensa_lx200_machine); qemu_register_machine(&xtensa_ml605_machine); qemu_register_machine(&xtensa_kc705_machine); } machine_init(xtensa_lx_machines_init);