int PE_initialize_console( PE_Video * info, int op )
{
static int last_console = -1;
if (info) {
info->v_offset = 0;
info->v_length = 0;
info->v_display = GRAPHICS_MODE;
}
switch ( op ) {
case kPEDisableScreen:
initialize_screen(info, op);
kprintf("kPEDisableScreen %d\n", last_console);
if (!console_is_serial())
last_console = switch_to_serial_console();
break;
case kPEEnableScreen:
initialize_screen(info, op);
if (info) PE_state.video = *info;
kprintf("kPEEnableScreen %d\n", last_console);
if( last_console != -1)
switch_to_old_console( last_console);
break;
case kPEBaseAddressChange:
if (info) PE_state.video = *info;
/* fall thru */
default:
initialize_screen(info, op);
break;
}
return 0;
}
/**
* arm_init
*
* Initialize the core ARM subsystems, this routine is called from the
* boot loader. A basic identity mapping is created in __start, however,
* arm_vm_init will create new mappings.
*/
void arm_init(boot_args * args)
{
cpu_data_t *bootProcessorData;
processor_t bootProcessor;
uint32_t baMaxMem;
uint64_t maxMem;
thread_t thread;
/*
* We are in.
*/
PE_early_puts("arm_init: starting up\n");
/*
* arm_init is only called on processor #0, the others will enter using arm_slave_init.
*/
bootProcessor = cpu_processor_alloc(TRUE);
if (!bootProcessor) {
panic("cpu_processor_alloc failed\n");
}
/*
* Pin the processor information to CPU #0.
*/
PE_early_puts("arm_init: calling cpu_bootstrap\n");
cpu_bootstrap();
/*
* Initialize core processor data.
*/
bootProcessorData = current_cpu_datap();
bootProcessorData->cpu_number = 0;
bootProcessorData->cpu_active_stack = (vm_offset_t)&irqstack;
bootProcessorData->cpu_phys_number = 0;
bootProcessorData->cpu_preemption_level = 1;
bootProcessorData->cpu_interrupt_level = 0;
bootProcessorData->cpu_running = 1;
bootProcessorData->cpu_pending_ast = AST_NONE;
/*
* Initialize the core thread subsystem (This sets up a template
* which will then be used to initialize the rest of the thread
* system later.)
*
* Additionally, this also sets the current kernel thread register
* to our bootstrap thread.
*/
PE_early_puts("arm_init: calling thread_bootstrap\n");
thread_bootstrap();
/*
* CPU initialization.
*/
PE_early_puts("arm_init: calling cpu_init\n");
cpu_init();
/*
* Mach processor bootstrap.
*/
PE_early_puts("arm_init: calling processor_bootstrap\n");
processor_bootstrap();
/*
* Initialize the ARM platform expert.
*/
PE_early_puts("arm_init: calling PE_init_platform\n");
PE_init_platform(FALSE, (void *) args);
/*
* Initialize kprintf, but no VM is running yet.
*/
PE_init_kprintf(FALSE);
/*
* Set maximum memory size based on boot-args.
*/
if (!PE_parse_boot_argn("maxmem", &baMaxMem, sizeof(baMaxMem)))
maxMem = 0;
else
maxMem = (uint64_t) baMaxMem *(1024 * 1024);
/*
* After this, we'll no longer be using physical mappings created by the bootloader.
*/
arm_vm_init(maxMem, args);
/*
* Kernel early bootstrap.
*/
kernel_early_bootstrap();
/*
* PE platform init.
*/
PE_init_platform(TRUE, (void *) args);
/*
* Enable I+D cache.
*/
char tempbuf[16];
if (PE_parse_boot_argn("-no-cache", tempbuf, sizeof(tempbuf))) {
kprintf("cache: No caching enabled (I+D).\n");
} else {
kprintf("cache: initializing i+dcache ... ");
cache_initialize();
kprintf("done\n");
}
/*
* Specify serial mode.
*/
serialmode = 0;
if (PE_parse_boot_argn("serial", &serialmode, sizeof(serialmode))) {
/*
* We want a serial keyboard and/or console
*/
kprintf("Serial mode specified: %08X\n", serialmode);
}
if (serialmode & 1) {
(void) switch_to_serial_console();
disableConsoleOutput = FALSE; /* Allow printfs to happen */
}
/*
* Start system timers.
*/
thread = current_thread();
thread->machine.preempt_count = 1;
thread->machine.cpu_data = cpu_datap(cpu_number());
thread->kernel_stack = irqstack;
timer_start(&thread->system_timer, mach_absolute_time());
/*
* Processor identification.
*/
arm_processor_identify();
/*
* VFP/float initialization.
*/
init_vfp();
/*
* Machine startup.
*/
machine_startup();
/*
* If we return, something very bad is happening.
*/
panic("20:02:14 <DHowett> wwwwwwwat is HAAAAAAAPPENING\n");
/*
* Last chance.
*/
while (1) ;
}
/*
* kdb_trap - field a TRACE or BPT trap
*/
void
kdb_trap(
int type,
struct savearea *regs)
{
boolean_t trap_from_user;
int previous_console_device;
int code=0;
previous_console_device=switch_to_serial_console();
switch (type) {
case T_TRACE: /* single_step */
case T_PROGRAM: /* breakpoint */
#if 0
case T_WATCHPOINT: /* watchpoint */
#endif
case -1: /* keyboard interrupt */
break;
default:
if (db_recover) {
ppc_nested_saved_state = *regs;
db_printf("Caught ");
if (type > TRAP_TYPES)
db_printf("type %d", type);
else
db_printf("%s", trap_type[type]);
db_printf(" trap, pc = %x\n",
regs->save_srr0);
db_error("");
/*NOTREACHED*/
}
kdbprinttrap(type, code, (int *)®s->save_srr0, regs->save_r1);
}
saved_state[cpu_number()] = regs;
ppc_last_saved_statep = regs;
ppc_last_kdb_sp = (unsigned) &type;
if (!IS_USER_TRAP(regs)) {
bzero((char *)&ddb_regs, sizeof (ddb_regs));
ddb_regs = *regs;
trap_from_user = FALSE;
}
else {
ddb_regs = *regs;
trap_from_user = TRUE;
}
db_task_trap(type, code, trap_from_user);
*regs = ddb_regs;
if ((type == T_PROGRAM) &&
(db_get_task_value(regs->save_srr0,
BKPT_SIZE,
FALSE,
db_target_space(current_act(),
trap_from_user))
== BKPT_INST))
regs->save_srr0 += BKPT_SIZE;
kdb_exit:
saved_state[cpu_number()] = 0;
switch_to_old_console(previous_console_device);
}
