/*
* 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);
