int
main(int argc, char *argv[])
{
int ch;
cpu_t *cpu = init_cpu();
char *sys_file;
while ((ch = getopt(argc, argv, "df:")) != EOF) {
switch (ch) {
case 'd':
cpu->debug = true;
break;
case 'f':
sys_file = strdup(optarg);
break;
}
}
argc -= optind;
argv += optind;
init_disk(cpu->port0, "/tmp/disk0");
load_cpu(cpu, sys_file);
while (true)
run_cpu(cpu);
free_cpu(cpu);
return 0;
}
void retro_reset(void)
{
init_cpu();
init_roms();
init_vpp();
clearscr();
}
// ------------------------------------------------------------------------- //
// cpu_manager //
// ------------------------------------------------------------------------- //
void cpu_manager::configure() {
// init cpu interface if unknown
if (m_icpu == NULL)
init_cpu();
// get current thread and thread mask
prl::thread current_thread = prl::thread::get_current_thread();
prl::affinity_mask pam = current_thread.get_thread_mask();
// affinity mask cutter
prl::affinity_mask_cutter cutter(pam);
// determin max topology layer size
//TODO: optimize
uint32_t max = pam.num_bits_set();
m_smts.reserve( max );
m_cores.reserve( max );
m_pkgs.reserve( max );
// split process affinity mask into multiple masks
prl::affinity_mask single_lp;
while (cutter.has_next()) {
single_lp = cutter.next();
current_thread.set_thread_mask(single_lp);
apic apic = m_icpu->get_apic();
register_lp(single_lp, apic);
}
// reset thread affinity
current_thread.set_thread_mask(pam);
}
/*
* Invoked by init_smp() to perform any per-cpu specific initialisation.
*/
void
smp_init_cpu()
{
smp_exc_init();
ppcbke_tlb_init(0);
init_cpu();
}
SIM_DESC
sim_open (SIM_OPEN_KIND kind,
struct host_callback_struct *callback,
struct bfd *abfd, char **argv)
{
if (open)
fprintf (stderr, "rl78 minisim: re-opened sim\n");
/* The 'run' interface doesn't use this function, so we don't care
about KIND; it's always SIM_OPEN_DEBUG. */
if (kind != SIM_OPEN_DEBUG)
fprintf (stderr, "rl78 minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
kind);
/* We use this for the load command. Perhaps someday, it'll be used
for syscalls too. */
host_callbacks = callback;
/* We don't expect any command-line arguments. */
init_cpu ();
trace = 0;
sim_disasm_init (abfd);
open = 1;
return &the_minisim;
}
int main(int argc, char *argv[]){
if (argc != 3){
printf("Usage: %s <cycles> <filename>\n", argv[0]);
exit(EXIT_FAILURE);
}
int cycles;
xcpu *c = malloc(sizeof(xcpu));
init_cpu(c);
FILE *fd=load_file(argv[2]);
load_programme(c, fd); // loads the bytes of fd into c->memory
cycles = atoi(argv[1]);
// the IHandler type is defined in xcpu.h, and the IHandler jump table
// is implemented in xcpu.c
IHandler *table = build_jump_table();
// It is a jump table to the functions handling each instruction.
char *graceful = "CPU has halted.";
char *out_of_time = "CPU ran out of time.";
int halted, i=0;
while (i++ < cycles || !cycles){
if (MOREDEBUG) fprintf(LOG, "<CYCLE %d>\n",i-1);
if (halted = !xcpu_execute(c, table)) break;
} // on halt, halted gets 0; otherwise halted remains 1
char *exit_msg = (halted)? graceful : out_of_time;
fprintf(stdout, "%s\n", exit_msg);
fprintf(LOG, "(%d cycles completed.)\n", i-1);
destroy_jump_table(table);
shutdown(c);
return !halted;
}
SIM_DESC
sim_open (SIM_OPEN_KIND kind,
struct host_callback_struct *callback,
struct bfd *abfd, char **argv)
{
if (open)
fprintf (stderr, "rl78 minisim: re-opened sim\n");
/* The 'run' interface doesn't use this function, so we don't care
about KIND; it's always SIM_OPEN_DEBUG. */
if (kind != SIM_OPEN_DEBUG)
fprintf (stderr, "rl78 minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
kind);
/* We use this for the load command. Perhaps someday, it'll be used
for syscalls too. */
host_callbacks = callback;
/* We don't expect any command-line arguments. */
init_cpu ();
trace = 0;
sim_disasm_init (abfd);
open = 1;
while (argv != NULL && *argv != NULL)
{
if (strcmp (*argv, "g10") == 0 || strcmp (*argv, "-Mg10") == 0)
{
fprintf (stderr, "rl78 g10 support enabled.\n");
rl78_g10_mode = 1;
g13_multiply = 0;
g14_multiply = 0;
mem_set_mirror (0, 0xf8000, 4096);
break;
}
if (strcmp (*argv, "g13") == 0 || strcmp (*argv, "-Mg13") == 0)
{
fprintf (stderr, "rl78 g13 support enabled.\n");
rl78_g10_mode = 0;
g13_multiply = 1;
g14_multiply = 0;
break;
}
if (strcmp (*argv, "g14") == 0 || strcmp (*argv, "-Mg14") == 0)
{
fprintf (stderr, "rl78 g14 support enabled.\n");
rl78_g10_mode = 0;
g13_multiply = 0;
g14_multiply = 1;
break;
}
argv++;
}
return &the_minisim;
}
int main(int argc,char *argv[]){
int exitcode = 0;
t_state state, *s=&state;
/* Parse command line and pass any relevant arguments to CPU record */
parse_cmd_line(argc,argv, &cmd_line_args);
fprintf(stderr,"ION (MIPS32 clone) core emulator (" __DATE__ ")\n\n");
if(!init_cpu(s, &cmd_line_args)){
fprintf(stderr,"Trouble allocating memory, quitting!\n");
exit(71);
};
/* Read binary object files into memory*/
if(!read_binary_files(s, &cmd_line_args)){
exit(66);
}
fprintf(stderr,"\n\n");
/* Open the CPU console output file if not stdout. */
if (cmd_line_args.conout_filename!=NULL) {
cpuconout = fopen(cmd_line_args.conout_filename, "w");
if (cpuconout==NULL){
fprintf(stderr,"Trouble opening console log file '%s', quitting.\n", cmd_line_args.conout_filename);
exitcode = 2;
goto main_quit;
}
}
else {
cpuconout = stdout;
}
init_trace_buffer(s, &cmd_line_args);
/* NOTE: Original mlite supported loading little-endian code, which this
program doesn't. The endianess-conversion code has been removed.
*/
/* Simulate a CPU reset */
reset_cpu(s);
/* Simulate the work of the uClinux bootloader */
if(cmd_line_args.memory_map == MAP_UCLINUX){
/* FIXME this 'bootloader' is a stub, flesh it out */
s->pc = 0x80002400;
}
/* Enter debug command interface; will only exit clean with user command */
do_debug(s, cmd_line_args.no_prompt);
main_quit:
/* Close and deallocate everything and quit */
close_trace_buffer(s);
free_cpu(s);
if (cmd_line_args.conout_filename!=NULL && cpuconout!=NULL) fclose(cpuconout);
exit(0);
}
void
init_smp() {
//
// We're back in the kernel, with a sideway dive
//
set_inkernel(INKERNEL_NOW|INKERNEL_LOCK);
//nohalt = 1;
init_cpu();
// This will return through the kernel and idle will be running!
set_inkernel(0);
ker_start();
}
int main(int argc, char **argv) {
steplimit = parse_args(argc, argv);
cpu_t cpu = init_cpu();
pcpu = &cpu;
/* Code section is protected from writes by default, un-protect it */
if (mprotect(gen_code, JIT_CODE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC)) {
perror("mprotect");
exit(2);
}
/* Pre-populate resulting code buffer with INT3 (machine code 0xCC).
This will help to catch jumps to wrong locations */
memset(gen_code, 0xcc, JIT_CODE_SIZE);
void* entrypoints[PROGRAM_SIZE] = {0}; /* a map of guest PCs to capsules */
translate_program(cpu.pmem, gen_code, entrypoints, PROGRAM_SIZE);
setjmp(return_buf); /* Will get here from generated code. */
while (cpu.state == Cpu_Running && cpu.steps < steplimit) {
if (cpu.pc > PROGRAM_SIZE) {
cpu.state = Cpu_Break;
break;
}
enter_generated_code(entrypoints[cpu.pc]); /* Will not return */
}
assert(cpu.state != Cpu_Running || cpu.steps == steplimit);
/* Print CPU state */
printf("CPU executed %lld steps. End state \"%s\".\n",
cpu.steps, cpu.state == Cpu_Halted? "Halted":
cpu.state == Cpu_Running? "Running": "Break");
printf("PC = %#x, SP = %d\n", cpu.pc, cpu.sp);
printf("Stack: ");
for (int32_t i=cpu.sp; i >= 0 ; i--) {
printf("%#10x ", cpu.stack[i]);
}
printf("%s\n", cpu.sp == -1? "(empty)": "");
free(LoadedProgram);
return cpu.state == Cpu_Halted ||
(cpu.state == Cpu_Running &&
cpu.steps == steplimit)?0:1;
}
void main(int argc, char **argv)
{
progname = (progname = strrchr(argv[0],'/')) ? progname : argv[0];
#ifndef BOOT
FILE *f1;
if (argc != 2)
{
fprintf(stderr,"Format: %s testfile\n",progname);
exit(1);
}
#endif
if (!(memory = (BYTE *)malloc(MEMORY_SIZE)))
{
fprintf(stderr,"Insufficient available memory\n");
exit(1);
}
#ifdef BOOT
memset(memory,0, MEMORY_SIZE);
#else
if (!(f1 = fopen(argv[1],"rb")))
{
fprintf(stderr,"Cannot open test file\n");
exit(1);
}
fread(memory+0x800,1,MEMORY_SIZE-0x800,f1);
fclose(f1);
#endif
read_pcemurc();
disable();
start_X();
init_cpu();
init_bios();
init_vga();
init_timer();
enable();
execute();
/* NOT REACHED */
}
static void run() {
int n_data_hazards = 0;
int n_cycles = 0;
char *mem;
int rs, rt, rd, imm;
int i, j = 0, k;
init_cpu();
while (cpu.pc_mem < ins_buf + n_ins) {
if (need_resched())
resched();
if (debug) {
printf("%d: ", cpu.pc_mem - ins_buf);
print_ins(cpu.pc_rb);
}
history_buf[j] = *cpu.pc_rb;
exec_ins();
if (debug) {
for (i = 0; i < 4; i++)
printf("%ss%d=%d", i==0?"\t# ":", ", i, cpu.reg_value[REG_S0 + i]);
for (i = 0; i < 2; i++)
printf(", t%d=%d", i, cpu.reg_value[REG_T0 + i]);
printf("\n");
}
cpu.pc_mem++;
if (cpu.pc_rb != NULL) cpu.pc_rb++;
n_cycles++;
// count hazard
for (k = 1; k < stall_range && k < n_cycles; k++)
if (has_dep(&history_buf[(j - k + HISTORY_BUF_LEN) % HISTORY_BUF_LEN],
&history_buf[j])) {
n_data_hazards++;
break;
}
j = (j + 1) % HISTORY_BUF_LEN;
}
if (profile)
printf("Cycles: %d, data hazards: %d\n", n_cycles, n_data_hazards);
}
static BOOT_CODE bool_t
try_boot_sys_node(cpu_id_t cpu_id)
{
p_region_t boot_mem_reuse_p_reg;
if (!map_kernel_window(
boot_state.num_ioapic,
boot_state.ioapic_paddr,
boot_state.num_drhu,
boot_state.drhu_list
)) {
return false;
}
setCurrentVSpaceRoot(kpptr_to_paddr(X86_GLOBAL_VSPACE_ROOT), 0);
/* Sync up the compilers view of the world here to force the PD to actually
* be set *right now* instead of delayed */
asm volatile("" ::: "memory");
/* reuse boot code/data memory */
boot_mem_reuse_p_reg.start = PADDR_LOAD;
boot_mem_reuse_p_reg.end = (paddr_t)ki_boot_end - KERNEL_BASE_OFFSET;
/* initialise the CPU */
if (!init_cpu(config_set(CONFIG_IRQ_IOAPIC) ? 1 : 0)) {
return false;
}
/* initialise NDKS and kernel heap */
if (!init_sys_state(
cpu_id,
boot_state.mem_p_regs,
boot_state.ui_info,
boot_mem_reuse_p_reg,
/* parameters below not modeled in abstract specification */
boot_state.num_drhu,
boot_state.drhu_list,
&boot_state.rmrr_list,
&boot_state.vbe_info
)) {
return false;
}
return true;
}
/*
========================================================================
main: This is the main entry point for the VirtualT application.
========================================================================
*/
int main(int argc, char **argv)
{
if (process_args(argc, argv)) /* Parse command line args */
return 1;
setup_working_path(argv); /* Create a working dir path */
setup_unix_signals(); /* Setup Unix signal handling */
// Added by JV for prefs
init_pref(); /* load user Menu preferences */
check_installation(); /* Test if install needs to be performed */
load_setup_preferences(); /* Load user Peripheral setup preferences */
load_memory_preferences(); /* Load user Memory setup preferences */
load_remote_preferences(); /* Load user Remote Socket preferences */
/* Perform initialization */
init_mem(); /* Initialize Memory */
init_io(); /* Initialize I/O structures */
init_sound(); /* Initialize Sound system */
init_display(); /* Initialize the Display */
init_cpu(); /* Initialize the CPU */
init_throttle_timer(); /* Initialize the throttle timer */
init_remote(); /* Initialize the remote control */
init_lpt(); /* Initialize the printer subsystem */
init_other_windows(); /* Initialize other windows that were opened (memedit, regs, etc. */
get_model_time(); /* Load the emulated time for current model */
/* Perform Emulation */
emulate(); /* Main emulation loop */
/* Save RAM contents after emulation */
save_ram();
save_model_time(); /* Save the emulated time */
/* Cleanup */
deinit_io(); /* Deinitialize I/O */
deinit_sound(); /* Deinitialize sound */
deinit_lpt(); /* Deinitialize the printer */
deinit_throttle_timer(); /* Deinitialize the throttle timer */
deinit_display(); /* Deinitialze and free the main window */
free_mem(); /* Free memory used by ReMem and/or Rampac */
return 0;
}
BOOT_CODE static bool_t try_init_kernel_secondary_core(void)
{
/* need to first wait until some kernel init has been done */
while (!node_boot_lock);
/* Perform cpu init */
init_cpu();
/* Enable per-CPU timer interrupts */
maskInterrupt(false, KERNEL_TIMER_IRQ);
NODE_LOCK_SYS;
ksNumCPUs++;
init_core_state(SchedulerAction_ResumeCurrentThread);
return true;
}
void main(void) {
unsigned char i;
init_cpu();
//Initialize the checksum.
captureBuffer.checksum = 0xFF;
while(1) {
/*
//Echo everything back to the tagger.
//Should put it in factory test mode.
if(captureBuffer.size & 0x80 && !ser_tx_size && !ser_tx_cooldown) {
//Block received.
//Echo it back for testing.
unsigned char rx_size = (captureBuffer.size & 0x7F);
int i;
for(i = 0; i < rx_size;i++) {
queueByte(captureBuffer.buffer[i]);
}
sendQueue();
captureBuffer.size = 0;
} else {
if(!(U0STAT0 ^ 0x06)) {
IRQ0 |= 0x08;
}
}
*/
//The actual main loop if you want it to work like a weapon accessory.
receiveSomething(); //Go check if there's anything to process in the receive buffer
sendSomething(); //Go check if there's anything we need to transmit
if(btn_pressed) { //If the button has been pressed and debounced
btn_pressed = 0; //Clear the flag.
if(weAreRegistered) { //If the tagger has acknowledged our presence
sendLoadSpecial = 1; //Flag that we should start loading the attachment
}
}
}
}
int main(int argc, char **argv) {
if(argc < 2) {
printf("Especifique o arquivo com o codigo\n");
exit(0);
}
init_memory();
init_stack();
loadcode(argv[1]);
init_cpu();
while(cpu_cycle());
memory_dump();
free_memory();
return 0;
}
int main(void)
{
init_pmm();
if (init_mm())
return(1);
vid_init();
vid_set_attr(FG_COLOR, RED);
printf("\naMOS BOSS V.%s %s\n", STRING_VERSION, BUILD_ARCH);
printf("Build %s %s by %s on %s\n\n", COMPILE_DATE, COMPILE_TIME, COMPILE_BY, COMPILE_HOST);
vid_set_attr(FG_COLOR, WHITE);
init_pit();
init_tss();
if (init_intr())
return(1);
init_cpu();
if (init_sched())
return(1);
init_fd();
printf("System memory: %d Mb\n\n", (int)pmm_get_size_mb());
printf("Free kernel mem: %d bytes\nUsed kernel mem: %d bytes\n", (int)get_free_mem(), (int)get_used_mem());
for (;;) {}
return(0);
}
int run_dgcuda(int argc, char *argv[]) {
int local_num_elem, local_num_sides;
int n_threads, n_blocks_elem, n_blocks_sides;
int i, n, local_n_p, total_timesteps, local_n_quad, local_n_quad1d;
int verbose, convergence, video, eval_error, benchmark;
double endtime, t;
double tol, total_error, max_error;
double *min_radius;
double min_r;
double *V1x, *V1y, *V2x, *V2y, *V3x, *V3y;
double *sides_x1, *sides_x2;
double *sides_y1, *sides_y2;
double *r1_local, *r2_local, *w_local;
double *s_r, *oned_w_local;
int *left_elem, *right_elem;
int *elem_s1, *elem_s2, *elem_s3;
int *left_side_number, *right_side_number;
FILE *mesh_file, *out_file;
char out_filename[100];
char *mesh_filename;
double *Uv1, *Uv2, *Uv3;
double *error;
clock_t start, end;
double elapsed;
// get input
endtime = -1;
if (get_input(argc, argv, &n, &total_timesteps, &endtime,
&verbose, &video, &convergence, &tol,
&benchmark, &eval_error,
&mesh_filename)) {
return 1;
}
// set the order of the approximation & timestep
local_n_p = (n + 1) * (n + 2) / 2;
// sanity check on limiter
if (limiter && n != 1) {
printf("Error: limiter only enabled for p = 1\n");
exit(0);
}
// open the mesh to get local_num_elem for allocations
mesh_file = fopen(mesh_filename, "r");
if (!mesh_file) {
printf("\nERROR: mesh file not found.\n");
return 1;
}
// read in the mesh and make all the mappings
read_mesh(mesh_file, &local_num_sides, &local_num_elem,
&V1x, &V1y, &V2x, &V2y, &V3x, &V3y,
&left_side_number, &right_side_number,
&sides_x1, &sides_y1,
&sides_x2, &sides_y2,
&elem_s1, &elem_s2, &elem_s3,
&left_elem, &right_elem);
// close the file
fclose(mesh_file);
// initialize the gpu
init_cpu(local_num_elem, local_num_sides, local_n_p,
V1x, V1y, V2x, V2y, V3x, V3y,
left_side_number, right_side_number,
sides_x1, sides_y1,
sides_x2, sides_y2,
elem_s1, elem_s2, elem_s3,
left_elem, right_elem,
convergence, eval_error);
// get the correct quadrature rules for this scheme
set_quadrature(n, &r1_local, &r2_local, &w_local,
&s_r, &oned_w_local, &local_n_quad, &local_n_quad1d);
// set constant data
set_N(local_N);
set_n_p(local_n_p);
set_num_elem(local_num_elem);
set_num_sides(local_num_sides);
set_n_quad(local_n_quad);
set_n_quad1d(local_n_quad1d);
// find the min inscribed circle
preval_inscribed_circles(d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y);
min_radius = (double *) malloc(local_num_elem * sizeof(double));
memcpy(min_radius, d_J, local_num_elem * sizeof(double));
min_r = min_radius[0];
for (i = 1; i < local_num_elem; i++) {
min_r = (min_radius[i] < min_r) ? min_radius[i] : min_r;
// report problem
if (min_radius[i] == 0) {
printf("%i\n", i);
printf("%.015lf, %.015lf, %.015lf, %.015lf, %.015lf, %.015lf\n",
V1x[i], V1y[i],
V2x[i], V2y[i],
V3x[i], V3y[i]);
}
}
free(min_radius);
// pre computations
preval_jacobian(d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y);
preval_side_length(d_s_length, d_s_V1x, d_s_V1y, d_s_V2x, d_s_V2y);
preval_normals(d_Nx, d_Ny,
d_s_V1x, d_s_V1y, d_s_V2x, d_s_V2y,
d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_left_side_number);
preval_normals_direction(d_Nx, d_Ny,
d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_left_elem, d_left_side_number);
preval_partials(d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_xr, d_yr,
d_xs, d_ys);
// evaluate the basis functions at those points and store on GPU
preval_basis(r1_local, r2_local, s_r, w_local, oned_w_local, local_n_quad, local_n_quad1d, local_n_p);
// no longer need any of these CPU variables
free(elem_s1);
free(elem_s2);
free(elem_s3);
free(sides_x1);
free(sides_x2);
free(sides_y1);
free(sides_y2);
free(left_elem);
free(right_elem);
free(left_side_number);
free(right_side_number);
free(r1_local);
free(r2_local);
free(w_local);
free(s_r);
free(oned_w_local);
// initial conditions
init_conditions(d_c, d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y);
printf(" ? %i degree polynomial interpolation (local_n_p = %i)\n", n, local_n_p);
printf(" ? %i precomputed basis points\n", local_n_quad * local_n_p);
printf(" ? %i elements\n", local_num_elem);
printf(" ? %i sides\n", local_num_sides);
printf(" ? min radius = %.015lf\n", min_r);
if (endtime == -1 && convergence != 1) {
printf(" ? total_timesteps = %i\n", total_timesteps);
} else if (endtime != -1 && convergence != 1) {
printf(" ? endtime = %lf\n", endtime);
}
if (benchmark) {
start = clock();
}
t = time_integrate_rk4(local_num_elem, local_num_sides,
n, local_n_p,
endtime, total_timesteps, min_r,
verbose, convergence, video, tol);
if (benchmark) {
end = clock();
elapsed = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Runtime: %lf seconds\n", elapsed);
}
// evaluate and write U to file
write_U(local_num_elem, total_timesteps, total_timesteps);
// free everything else
free(d_s_V1x);
free(d_s_V2x);
free(d_s_V1y);
free(d_s_V2y);
free(d_s_length);
free(d_lambda);
free(d_k1);
free(d_k2);
free(d_k3);
free(d_k4);
free(d_rhs_volume);
free(d_rhs_surface_left);
free(d_rhs_surface_right);
free(d_elem_s1);
free(d_elem_s2);
free(d_elem_s3);
free(d_xr);
free(d_yr);
free(d_xs);
free(d_ys);
free(d_left_side_number);
free(d_right_side_number);
free(d_Nx);
free(d_Ny);
free(d_right_elem);
free(d_left_elem);
free(d_c);
free(d_J);
free(d_Uv1);
free(d_Uv2);
free(d_Uv3);
free(d_V1x);
free(d_V1y);
free(d_V2x);
free(d_V2y);
free(d_V3x);
free(d_V3y);
// free CPU variables
free(V1x);
free(V1y);
free(V2x);
free(V2y);
free(V3x);
free(V3y);
return 0;
}
/********************* Main*/
int omain(int argc, char *argv[]){
int i, cnt, cntt, cnttt, way;
static char file[MAXC], attr[MAXC], val[MAXC], *p, *binver;
#if defined(ALLEGRO_WINDOWS)
binver = "Windows binary";
#elif defined(ALLEGRO_DOS)
binver = "DOS binary";
#elif defined(ALLEGRO_LINUX)
binver = "Linux binary";
#elif defined(ALLEGRO_BEOS)
binver = "BEOS binary";
#elif defined(ALLEGRO_QNX)
binver = "QNX binary";
#elif defined(ALLEGRO_UNIX)
binver = "UNIX binary";
#elif defined(ALLEGRO_MPW)
binver = "MacOS binary";
#else
binver = "Unknown binary";
#endif
printf("%s %s\n","\nO2EM v" O2EM_VERSION " " RELEASE_DATE " - ", binver);
printf("Free Odyssey2 / Videopac+ Emulator - http://o2em.sourceforge.net\n");
printf("Created by Daniel Boris (c)1996/1998\n");
printf("Developed by:\n");
printf(" Andre de la Rocha since version 0.80\n");
printf(" Arlindo M. de Oliveira since version 1.16\n");
printf("\n");
app_data.debug = 0;
app_data.stick[0] = app_data.stick[1] = 1;
app_data.sticknumber[0] = app_data.sticknumber[1] = 0;
set_defjoykeys(0,0);
set_defjoykeys(1,1);
set_defsystemkeys();
app_data.bank = 0;
app_data.limit = 1;
app_data.sound_en = 1;
app_data.speed = 100;
app_data.wsize = 2;
#ifdef ALLEGRO_DOS
app_data.fullscreen = 1;
#else
app_data.fullscreen = 0;
#endif
app_data.scanlines = 0;
app_data.voice = 1;
app_data.window_title = "O2EM v" O2EM_VERSION;
app_data.svolume = 100;
app_data.vvolume = 100;
app_data.filter = 0;
app_data.exrom = 0;
app_data.three_k = 0;
app_data.crc = 0;
app_data.scshot = scshot;
app_data.statefile = statefile;
app_data.euro = 0;
app_data.openb = 0;
app_data.vpp = 0;
app_data.bios = 0;
app_data.scoretype = 0;
app_data.scoreaddress = 0;
app_data.default_highscore = 0;
app_data.breakpoint = 65535;
app_data.megaxrom = 0;
strcpy(file,"");
strcpy(file_l,"");
strcpy(bios_l,"");
strcpy(bios,"");
strcpy(scshot,"");
strcpy(statefile,"");
strcpy(xrom,"");
strcpy(scorefile,"highscore.txt");
read_default_config();
if (argc >= 2){
for(i=1; i<argc; i++) {
if (argv[i][0] != '-') {
strncat(file,argv[i],MAXC-1);
file[MAXC-1]=0;
strcpy(file_v,file);
} else {
p=strtok(argv[i],"=");
if (p){
strncpy(attr,p+1,MAXC-1);
attr[MAXC-1]=0;
} else
strcpy(attr,"");
p=strtok(NULL,"=");
if (p){
strncpy(val,p,MAXC-1);
val[MAXC-1]=0;
if (!strcmp(attr,"romdir")||!strcmp(attr,"ROMDIR"))
{
strcpy(romdir,val);
strcat(romdir,file);
strcpy(file,romdir);
strcpy(romdir,val);
}
if (!strcmp(attr,"biosdir")||!strcmp(attr,"BIOSDIR"))
{
strcpy(biosdir,val);
}
} else
strcpy(val,"");
strlwr(attr);
if (!parse_option(attr, val)) exit(EXIT_FAILURE);
}
}
if (helpflag) helpus();
if (strlen(file)==0) {
fprintf(stderr,"Error: file name missing\n");
exit(EXIT_FAILURE);
}
#ifdef __LIBRETRO__
sprintf(statefile,"%s.state\0",file);
#endif
printf("Starting emulation ...\n");
#ifndef __LIBRETRO__
allegro_init();
install_timer();
#endif
init_audio();
#ifndef __LIBRETRO__
printf("Using Allegro %s\n",allegro_id);
#endif
/********************** ROMs if Launcher running... */
k = strchr(romdir, '/');
launcher_flag_r = strchr(file, '\\');
if (k != 0) {
strcpy (xrom,romdir);
}
else if (!launcher_flag_r)
{
strcpy(xrom,"roms/");
strcpy(romdir,file);
#ifndef __LIBRETRO__
strcpy(file,xrom);
strcat(file,romdir);
#endif
strcpy(romdir,xrom);
}
else
{
cnt = 0;
cntt = 0;
cnttt = 0;
way = 0;
for (cnt=0; file[cnt] != '\0'; cnt=cnt+1)
{
if ( file[cnt] == '\\' )
{
cnttt = cnt;
}
}
for (cnt=0; cnt<=cnttt; cnt++)
{
file_l[cnt] = file[cnt];
}
strcpy (romdir,file_l);
strcpy (xrom,romdir);
}
#ifdef __LIBRETRO__
#ifdef AND
sprintf(xrom,"%s\0","/mnt/sdcard/O2EM/roms/");
strcpy(romdir,xrom);
#else
sprintf(xrom,"%s\0","./roms/");
strcpy(romdir,xrom);
#endif
#endif
file_name(xrom);
if (contax < 3)
{
printf("\nROMs directory empty!\n");
exit(EXIT_FAILURE);
}
app_data.crc = crc32_file(file);
crcx = app_data.crc;
suck_roms();
/********************** BIOSs if Launcher running... */
launcher_flag_b = strchr(bios, '\\');
if (!launcher_flag_b){
k = strchr(biosdir, '/');
if (k != 0) {
strcpy (xbios,biosdir);
}
else
{
strcpy (xbios,"bios/");
strcpy (biosdir,xbios);
}
#ifdef __LIBRETRO__
#ifdef AND
sprintf(xbios,"%s\0","/mnt/sdcard/O2EM/bios/");
strcpy (biosdir,xbios);
#else
sprintf(xbios,"%s\0","./bios/");
strcpy (biosdir,xbios);
#endif
#endif
file_name(xbios);
if (contax < 3)
{
printf("\nBIOS directory empty!\n");
exit(EXIT_FAILURE);
}
suck_bios();
c_j = strcmp(bios,"jopac");
if ((rom_f!=1) && (c_j!=0)) strcpy(bios,g7400);
if ((!o2flag) && (!jopflag) && (!c52flag) && (!g74flag))
{
printf("\ndir '%s' without BIOS !",biosdir);
exit(EXIT_FAILURE);
}
printf("BIOS found:\n");
if (!strcmp(bios,"g7400")){
strcpy(bios,g7400);
if (g74flag != 1) {
printf("\nG7400 BIOS not found !");
exit(EXIT_FAILURE);
}
}
if (g74flag) printf(" G7400 VP+\n");
if (!strcmp(bios,"c52")){
strcpy(bios,c52);
if (c52flag != 1) {
printf("\nC52 BIOS not found !");
exit(EXIT_FAILURE);
}
}
if (c52flag) printf(" C52\n");
if (!strcmp(bios,"jopac")){
strcpy(bios,jopac);
if (jopflag != 1) {
printf("\nJOPAC BIOS not found !");
exit(EXIT_FAILURE);
}
}
if (jopflag) printf(" JOPAC VP+\n");
if ((!strcmp(bios,"")) || (!strcmp(bios,"o2rom")))
{
strcpy(bios,odyssey2);
if ((!o2flag)&&(!c52flag)&&(rom_f)){
printf("Odyssey2 BIOS not found !\n");
exit(EXIT_FAILURE);
}
if ((!o2flag)&&(c52flag)&&(rom_f)){
printf("\nOdyssey2 BIOS not found !\n");
printf("Loading C52 BIOS ... ");
strcpy(bios,c52);
}
}
if (o2flag) printf(" Odyssey 2\n");
}
if (launcher_flag_b)
{
identify_bios(bios);
if (rom_f!=1)
{
if (!((g74flag)||(jopflag)))
{
fprintf(stderr,"\nError: ROM only VP+ BIOS");
exit(EXIT_FAILURE);
}
}
}
if (!launcher_flag_b)
{
if (rom_f!=1)
{
if (!((g74flag)||(jopflag)))
{
printf("\nROM only VP+ BIOS\n");
exit(EXIT_FAILURE);
}
if (!(g74flag))
{
printf("\nVP+ G7400 BIOS not found !");
printf("\nLoading VP+ Jopac BIOS ...");
strcpy(bios,jopac);
}
}
}
load_bios(bios);
load_cart(file);
if (app_data.voice) load_voice_samples(path);
init_display();
init_cpu();
init_system();
set_score(app_data.scoretype, app_data.scoreaddress, app_data.default_highscore);
int stateError;
if ((stateError=loadstate(app_data.statefile))==0)
{
printf("Savefile loaded.");
}
else if (stateError>=199)
{
if (stateError==199) fprintf(stderr,"Wrong ROM-File for Savefile.");
else if (stateError==200+ROM_O2) fprintf(stderr,"Wrong BIOS for Savefile: O2ROM needed.");
else if (stateError==200+ROM_G7400) fprintf(stderr,"Wrong BIOS for Savefile: G7400 ROM needed.");
else if (stateError==200+ROM_C52) fprintf(stderr,"Wrong BIOS for Savefile: C52 ROM needed.");
else if (stateError==200+ROM_JOPAC) fprintf(stderr,"Wrong BIOS for Savefile: JOPAC ROM needed.");
else fprintf(stderr,"Wrong BIOS for Savefile: UNKNOWN ROM needed.");
return(0);
}
if (app_data.debug) key_debug=1;
#ifndef _DEBUG
#ifdef ALLEGRO_WINDOWS
FreeConsole();
#endif
#endif
#ifdef __LIBRETRO__
return 1;
#endif
run();
if (app_data.scoretype!=0) save_highscore(get_score(app_data.scoretype, app_data.scoreaddress), scorefile);
exit(EXIT_SUCCESS);
}
if (!strcmp(attr,"help")||!strcmp(attr,"HELP")) helpus();
printf("type o2em -help");
exit(EXIT_SUCCESS);
}
void
rl78_load (bfd *prog, host_callback *callbacks, const char * const simname)
{
Elf_Internal_Phdr * phdrs;
long sizeof_phdrs;
int num_headers;
int i;
int max_rom = 0;
init_cpu ();
/* Note we load by ELF program header not by BFD sections.
This is because BFD sections get their information from
the ELF section structure, which only includes a VMA value
and not an LMA value. */
sizeof_phdrs = bfd_get_elf_phdr_upper_bound (prog);
if (sizeof_phdrs == 0)
{
fprintf (stderr, "%s: Failed to get size of program headers\n", simname);
return;
}
phdrs = xmalloc (sizeof_phdrs);
num_headers = bfd_get_elf_phdrs (prog, phdrs);
if (num_headers < 1)
{
fprintf (stderr, "%s: Failed to read program headers\n", simname);
return;
}
for (i = 0; i < num_headers; i++)
{
Elf_Internal_Phdr * p = phdrs + i;
char *buf;
bfd_vma size;
bfd_vma base;
file_ptr offset;
size = p->p_filesz;
if (size <= 0)
continue;
base = p->p_paddr;
if (verbose > 1)
fprintf (stderr, "[load segment: lma=%08x vma=%08x size=%08x]\n",
(int) base, (int) p->p_vaddr, (int) size);
if (callbacks)
xprintf (callbacks,
"Loading section %s, size %#lx lma %08lx vma %08lx\n",
find_section_name_by_offset (prog, p->p_offset),
size, base, p->p_vaddr);
buf = xmalloc (size);
offset = p->p_offset;
if (prog->iovec->bseek (prog, offset, SEEK_SET) != 0)
{
fprintf (stderr, "%s, Failed to seek to offset %lx\n", simname, (long) offset);
continue;
}
if (prog->iovec->bread (prog, buf, size) != size)
{
fprintf (stderr, "%s: Failed to read %lx bytes\n", simname, size);
continue;
}
if (base > 0xeffff || base + size > 0xeffff)
{
fprintf (stderr, "%s, Can't load image to RAM/SFR space: 0x%lx - 0x%lx\n",
simname, base, base+size);
continue;
}
if (max_rom < base + size)
max_rom = base + size;
mem_put_blk (base, buf, size);
free (buf);
}
free (phdrs);
mem_rom_size (max_rom);
pc = prog->start_address;
if (strcmp (bfd_get_target (prog), "srec") == 0
|| pc == 0)
{
pc = mem_get_hi (0);
}
if (verbose > 1)
fprintf (stderr, "[start pc=%08x]\n", (unsigned int) pc);
}
void handle_key(void){
if (NeedsPoll) poll_keyboard();
if (key[syskeys[0]] || key[KEY_ESC]) {
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[0]] || key[KEY_ESC]);
key_done=1;
}
if (key[syskeys[1]]) {
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[1]]);
mute_audio();
mute_voice();
abaut();
do {
rest(5);
if (NeedsPoll) poll_keyboard();
if (key[KEY_ALT] && key[KEY_ENTER]) {
app_data.fullscreen = app_data.fullscreen ? 0 : 1;
grmode();
abaut();
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[KEY_ENTER]);
}
} while ((!key[syskeys[1]]) && (!key[KEY_ESC]) && (!key[syskeys[0]]));
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[1]]);
init_sound_stream();
}
if (key[syskeys[5]])
{
if (savestate(app_data.statefile)==0)
{
display_msg("Savefile saved.",5);
}
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[5]]);
}
/* LOAD STATE */
if (key[syskeys[6]])
{
int stateError;
if ((stateError=loadstate(app_data.statefile))==0)
{
display_msg("Savefile loaded.",5);
}
else if (stateError>=199)
{
if (stateError==199) display_msg("Wrong ROM-File for Savefile.",5);
else if (stateError==200+ROM_O2) display_msg("Wrong BIOS for Savefile: O2ROM needed.",5);
else if (stateError==200+ROM_G7400) display_msg("Wrong BIOS for Savefile: G7400 ROM needed.",5);
else if (stateError==200+ROM_C52) display_msg("Wrong BIOS for Savefile: C52 ROM needed.",5);
else if (stateError==200+ROM_JOPAC) display_msg("Wrong BIOS for Savefile: JOPAC ROM needed.",5);
else display_msg("Wrong BIOS for Savefile: UNKNOWN ROM needed.",5);
}
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[6]]);
}
if (key[syskeys[2]]) key_debug=1;
if (key[syskeys[3]]) {
init_cpu();
init_roms();
init_vpp();
clearscr();
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[3]]);
}
/* SET HIGHSCORE */
if (key[syskeys[7]])
{
set_score(app_data.scoretype, app_data.scoreaddress, app_data.default_highscore);
}
if (key[syskeys[4]]) {
BITMAP *bmp;
PALETTE pal;
char *p;
static char name[1024];
static int scshot_counter = 0;
if (strlen(app_data.scshot)>0){
if ((p=strchr(app_data.scshot,'@'))) {
*p = 0;
sprintf(name, "%s%02d%s", app_data.scshot, scshot_counter++, p+1);
*p = '@';
} else {
strcpy(name, app_data.scshot);
}
get_palette(pal);
bmp = create_sub_bitmap(screen, 0, 0, SCREEN_W, SCREEN_H);
save_bitmap(name, bmp, pal);
destroy_bitmap(bmp);
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[4]]);
}
}
// switch joystick
if (key[syskeys[8]]) {
joyswitch = joyswitch ? 0 : 1;
set_defjoykeys(0,joyswitch);
set_defjoykeys(1,joyswitch ? 0 : 1);
int tmp = app_data.stick[0];
app_data.stick[0] = app_data.stick[1];
app_data.stick[1] = tmp;
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[syskeys[8]]);
}
if (key[KEY_ALT] && key[KEY_ENTER]) {
app_data.fullscreen = app_data.fullscreen ? 0 : 1;
grmode();
do {
rest(5);
if (NeedsPoll) poll_keyboard();
} while (key[KEY_ENTER]);
}
}
static int acpi_config_smp(struct acpi_madt *madt)
{
uint32 lapic_addr;
uint nioapic = 0;
uchar *p, *e;
void init_cpu(u32 apicid);
if (!madt)
return -1;
if (madt->header.length < sizeof(struct acpi_madt))
return -1;
lapic_addr = madt->lapic_addr_phys;
printk("lapic_addr:%lx\n", lapic_addr);
p = madt->table;
e = p + madt->header.length - sizeof(struct acpi_madt);
while (p < e) {
uint len;
if ((e - p) < 2)
break;
len = p[1];
if ((e - p) < len)
break;
switch (p[0]) {
case TYPE_LAPIC:{
struct madt_lapic *lapic = (void *)p;
if (len < sizeof(*lapic))
break;
if (!(lapic->flags & APIC_LAPIC_ENABLED))
break;
printk("acpi: cpu#%d apicid %d\n", nr_cpu, lapic->apic_id);
init_cpu(lapic->apic_id);
break;
}
case TYPE_IOAPIC:{
struct madt_ioapic *ioapic = (void *)p;
if (len < sizeof(*ioapic))
break;
printk("acpi: ioapic#%d @%x id=%d base=%d\n",
nioapic, ioapic->addr, ioapic->id,
ioapic->interrupt_base);
if (nioapic) {
printk("warning: multiple ioapics are not supported");
}
else {
ioapicid = ioapic->id;
}
nioapic++;
break;
}
}
p += len;
}
if (nr_cpu) {
ismp = 1;
lapic_base = (u32 *) IO2V(((uintp) lapic_addr));
printk("lapic:%lx,%lx\n", (ulong) lapic_base, lapic_read_base());
return 0;
}
return -1;
}
int main(int argc,char **argv)
{
int i;
for(i=1; i<argc; i++) {
if(argv[i][0]=='-'&&argv[i][1]=='F') {
output_format=argv[i]+2;
argv[i][0]=0;
}
if(!strcmp("-quiet",argv[i])) {
verbose=0;
argv[i][0]=0;
}
}
if(!init_output(output_format))
general_error(16,output_format);
if(!init_main())
general_error(10,"main");
if(verbose)
printf("%s\n%s\n%s\n%s\n",copyright,cpu_copyright,syntax_copyright,output_copyright);
for(i=1; i<argc; i++) {
if(argv[i][0]==0)
continue;
if(argv[i][0]!='-') {
if(inname)
general_error(11);
inname=argv[i];
continue;
}
if(!strcmp("-o",argv[i])&&i<argc-1) {
if(outname)
general_error(28,'o');
outname=argv[++i];
continue;
}
if(!strcmp("-L",argv[i])&&i<argc-1) {
if(listname)
general_error(28,'L');
listname=argv[++i];
produce_listing=1;
continue;
}
if(!strcmp("-Lnf",argv[i])) {
listformfeed=0;
continue;
}
if(!strcmp("-Lns",argv[i])) {
listnosyms=1;
continue;
}
if(!strncmp("-Ll",argv[i],3)) {
sscanf(argv[i]+3,"%i",&listlinesperpage);
continue;
}
if(!strncmp("-D",argv[i],2)) {
char *def=NULL;
expr *val;
if(argv[i][2])
def=&argv[i][2];
else if (i<argc-1)
def=argv[++i];
if(def) {
char *s=def;
if(ISIDSTART(*s)) {
s++;
while(ISIDCHAR(*s))
s++;
def=cnvstr(def,s-def);
if(*s=='=') {
s++;
val=parse_expr(&s);
}
else
val=number_expr(1);
if(*s)
general_error(23,'D'); /* trailing garbage after option */
new_abs(def,val);
myfree(def);
continue;
}
}
}
if(!strncmp("-I",argv[i],2)) {
char *path=NULL;
if(argv[i][2])
path=&argv[i][2];
else if (i<argc-1)
path=argv[++i];
if(path) {
new_include_path(path);
continue;
}
}
if(!strcmp("-unnamed-sections",argv[i])) {
unnamed_sections=1;
continue;
}
if(!strcmp("-ignore-mult-inc",argv[i])) {
ignore_multinc=1;
continue;
}
if(!strcmp("-nocase",argv[i])) {
nocase=1;
continue;
}
if(!strcmp("-noesc",argv[i])) {
esc_sequences=0;
continue;
}
if(!strcmp("-nosym",argv[i])) {
no_symbols=1;
continue;
}
if(!strncmp("-nowarn=",argv[i],8)) {
int wno;
sscanf(argv[i]+8,"%i",&wno);
disable_warning(wno);
continue;
}
else if(!strcmp("-w",argv[i])) {
no_warn=1;
continue;
}
if(!strncmp("-maxerrors=",argv[i],11)) {
sscanf(argv[i]+11,"%i",&max_errors);
continue;
}
else if(!strcmp("-pic",argv[i])) {
pic_check=1;
continue;
}
if(cpu_args(argv[i]))
continue;
if(syntax_args(argv[i]))
continue;
if(output_args(argv[i]))
continue;
if (!strncmp("-x",argv[i],2)) {
auto_import=0;
continue;
}
general_error(14,argv[i]);
}
if(inname) {
setfilename(inname);
setdebugname(inname);
include_source(inname);
} else
general_error(15);
if(!init_parse())
general_error(10,"parse");
if(!init_syntax())
general_error(10,"syntax");
if(!init_cpu())
general_error(10,"cpu");
parse();
if(errors==0||produce_listing)
resolve();
if(errors==0||produce_listing)
assemble();
if(errors==0&&!auto_import)
undef_syms();
if(!listname)
listname="a.lst";
if(produce_listing)
write_listing(listname);
if(!outname)
outname="a.out";
if(errors==0) {
if(verbose)
statistics();
outfile=fopen(outname,"wb");
if(!outfile)
general_error(13,outname);
write_object(outfile,first_section,first_symbol);
}
leave();
return 0; /* not reached */
}
static BOOT_CODE bool_t try_init_kernel(
paddr_t ui_p_reg_start,
paddr_t ui_p_reg_end,
sword_t pv_offset,
vptr_t v_entry,
paddr_t dtb_addr_start,
paddr_t dtb_addr_end
)
{
cap_t root_cnode_cap;
cap_t it_ap_cap;
cap_t it_pd_cap;
cap_t ipcbuf_cap;
region_t ui_reg = paddr_to_pptr_reg((p_region_t) {
ui_p_reg_start, ui_p_reg_end
});
region_t dtb_reg;
word_t extra_bi_size = sizeof(seL4_BootInfoHeader) + (dtb_addr_end - dtb_addr_start);
region_t extra_bi_region;
pptr_t extra_bi_offset = 0;
vptr_t extra_bi_frame_vptr;
pptr_t bi_frame_pptr;
vptr_t bi_frame_vptr;
vptr_t ipcbuf_vptr;
create_frames_of_region_ret_t create_frames_ret;
create_frames_of_region_ret_t extra_bi_ret;
/* convert from physical addresses to userland vptrs */
v_region_t ui_v_reg;
v_region_t it_v_reg;
ui_v_reg.start = ui_p_reg_start - pv_offset;
ui_v_reg.end = ui_p_reg_end - pv_offset;
ipcbuf_vptr = ui_v_reg.end;
bi_frame_vptr = ipcbuf_vptr + BIT(PAGE_BITS);
extra_bi_frame_vptr = bi_frame_vptr + BIT(PAGE_BITS);
/* If no DTB was provided, skip allocating extra bootinfo */
if (dtb_addr_start == 0) {
extra_bi_size = 0;
dtb_reg = (region_t) {
0, 0
};
} else {
dtb_reg = paddr_to_pptr_reg((p_region_t) {
dtb_addr_start, ROUND_UP(dtb_addr_end, PAGE_BITS)
});
}
/* The region of the initial thread is the user image + ipcbuf and boot info */
it_v_reg.start = ui_v_reg.start;
it_v_reg.end = extra_bi_frame_vptr;
if (it_v_reg.end > kernelBase) {
printf("Userland image virtual end address too high\n");
return false;
}
/* setup virtual memory for the kernel */
map_kernel_window();
/* initialise the CPU */
if (!init_cpu()) {
return false;
}
/* debug output via serial port is only available from here */
printf("Bootstrapping kernel\n");
/* initialise the platform */
init_plat();
/* make the free memory available to alloc_region() */
arch_init_freemem(ui_reg, dtb_reg);
/* create the root cnode */
root_cnode_cap = create_root_cnode();
if (cap_get_capType(root_cnode_cap) == cap_null_cap) {
return false;
}
/* create the cap for managing thread domains */
create_domain_cap(root_cnode_cap);
/* initialise the IRQ states and provide the IRQ control cap */
init_irqs(root_cnode_cap);
/* create the bootinfo frame */
bi_frame_pptr = allocate_bi_frame(0, CONFIG_MAX_NUM_NODES, ipcbuf_vptr);
if (!bi_frame_pptr) {
return false;
}
/* create extra bootinfo region - will return an empty allocation if extra_bi_size = 0 */
extra_bi_region = allocate_extra_bi_region(extra_bi_size);
if (extra_bi_region.start == 0) {
return false;
}
/* update initial thread virtual address range for extra bootinfo */
it_v_reg.end += extra_bi_region.end - extra_bi_region.start;
if (it_v_reg.end > kernelBase) {
printf("Userland extra bootinfo end address too high\n");
return false;
}
/* put DTB in the bootinfo block, if present. */
seL4_BootInfoHeader header;
if (dtb_reg.start) {
header.id = SEL4_BOOTINFO_HEADER_FDT;
header.len = sizeof(header) + dtb_reg.end - dtb_reg.start;
*(seL4_BootInfoHeader *)(extra_bi_region.start + extra_bi_offset) = header;
extra_bi_offset += sizeof(header);
memcpy((void *)(extra_bi_region.start + extra_bi_offset), (void *)dtb_reg.start,
dtb_reg.end - dtb_reg.start);
extra_bi_offset += dtb_reg.end - dtb_reg.start;
}
if ((extra_bi_region.end - extra_bi_region.start) - extra_bi_offset > 0) {
/* provde a chunk for any leftover padding in the extended boot info */
header.id = SEL4_BOOTINFO_HEADER_PADDING;
header.len = (extra_bi_region.end - extra_bi_region.start) - extra_bi_offset;
*(seL4_BootInfoHeader *)(extra_bi_region.start + extra_bi_offset) = header;
}
if (config_set(CONFIG_ARM_SMMU)) {
ndks_boot.bi_frame->ioSpaceCaps = create_iospace_caps(root_cnode_cap);
if (ndks_boot.bi_frame->ioSpaceCaps.start == 0 &&
ndks_boot.bi_frame->ioSpaceCaps.end == 0) {
return false;
}
} else {
ndks_boot.bi_frame->ioSpaceCaps = S_REG_EMPTY;
}
/* Construct an initial address space with enough virtual addresses
* to cover the user image + ipc buffer and bootinfo frames */
it_pd_cap = create_it_address_space(root_cnode_cap, it_v_reg);
if (cap_get_capType(it_pd_cap) == cap_null_cap) {
return false;
}
/* Create and map bootinfo frame cap */
create_bi_frame_cap(
root_cnode_cap,
it_pd_cap,
bi_frame_pptr,
bi_frame_vptr
);
/* create and map extra bootinfo region */
if (extra_bi_size > 0) {
extra_bi_ret =
create_frames_of_region(
root_cnode_cap,
it_pd_cap,
extra_bi_region,
true,
pptr_to_paddr((void *)extra_bi_region.start) - extra_bi_frame_vptr
);
if (!extra_bi_ret.success) {
return false;
}
ndks_boot.bi_frame->extraBIPages = extra_bi_ret.region;
}
/* create the initial thread's IPC buffer */
ipcbuf_cap = create_ipcbuf_frame(root_cnode_cap, it_pd_cap, ipcbuf_vptr);
if (cap_get_capType(ipcbuf_cap) == cap_null_cap) {
return false;
}
/* create all userland image frames */
create_frames_ret =
create_frames_of_region(
root_cnode_cap,
it_pd_cap,
ui_reg,
true,
pv_offset
);
if (!create_frames_ret.success) {
return false;
}
ndks_boot.bi_frame->userImageFrames = create_frames_ret.region;
/* create/initialise the initial thread's ASID pool */
it_ap_cap = create_it_asid_pool(root_cnode_cap);
if (cap_get_capType(it_ap_cap) == cap_null_cap) {
return false;
}
write_it_asid_pool(it_ap_cap, it_pd_cap);
/* create the idle thread */
if (!create_idle_thread()) {
return false;
}
/* Before creating the initial thread (which also switches to it)
* we clean the cache so that any page table information written
* as a result of calling create_frames_of_region will be correctly
* read by the hardware page table walker */
cleanInvalidateL1Caches();
/* create the initial thread */
tcb_t *initial = create_initial_thread(
root_cnode_cap,
it_pd_cap,
v_entry,
bi_frame_vptr,
ipcbuf_vptr,
ipcbuf_cap
);
if (initial == NULL) {
return false;
}
init_core_state(initial);
/* create all of the untypeds. Both devices and kernel window memory */
if (!create_untypeds(
root_cnode_cap,
(region_t) {
kernelBase, (pptr_t)ki_boot_end
} /* reusable boot code/data */
)) {
return false;
}
/* no shared-frame caps (ARM has no multikernel support) */
ndks_boot.bi_frame->sharedFrames = S_REG_EMPTY;
/* finalise the bootinfo frame */
bi_finalise();
/* make everything written by the kernel visible to userland. Cleaning to PoC is not
* strictly neccessary, but performance is not critical here so clean and invalidate
* everything to PoC */
cleanInvalidateL1Caches();
invalidateLocalTLB();
if (config_set(CONFIG_ARM_HYPERVISOR_SUPPORT)) {
invalidateHypTLB();
}
ksNumCPUs = 1;
/* initialize BKL before booting up other cores */
SMP_COND_STATEMENT(clh_lock_init());
SMP_COND_STATEMENT(release_secondary_cpus());
/* grab BKL before leaving the kernel */
NODE_LOCK_SYS;
printf("Booting all finished, dropped to user space\n");
/* kernel successfully initialized */
return true;
}
int main(int argc, char** argv) {
unsigned char flags = 0;
init_cpu();
hw_init_flags();
hw_write_flags(0);
link_init();
POINTER c = (POINTER)(ADDR_BASE_XIL + 0x06);
*c = 0x100;
UINT16 len = 0;
/* IP address */
localmachine.localip = 0xC0A80146 + flags; /* 192.168.0.* */
/* Default gateway */
localmachine.defgw = 0xC0A80101; /* 192.168.0.1 */
/* Subnet mask */
localmachine.netmask = 0xFFFFFF00;
/* Ethernet (MAC) address */
localmachine.localHW[5] = 0x00;
localmachine.localHW[4] = 0x33;
localmachine.localHW[3] = 0xCC;
localmachine.localHW[2] = 0xAB;
localmachine.localHW[1] = 0xBA;
localmachine.localHW[0] = 0x11 + flags;
data_port = UDP_DATA_PORT + flags;
timer_pool_init();
NE2000Init(&localmachine.localHW[0]);
arp_init();
udp_init();
tcp_init();
/* Initialize applications */
tcps_init();
udps_init();
while(1) {
if (NETWORK_CHECK_IF_RECEIVED() == TRUE) {
switch( received_frame.protocol) {
case PROTOCOL_ARP:
process_arp(&received_frame);
break;
case PROTOCOL_IP:
len = process_ip_in(&received_frame);
if(len < 0)
break;
switch(received_ip_packet.protocol){
case IP_ICMP:
process_icmp_in (&received_ip_packet, len);
break;
case IP_UDP:
process_udp_in (&received_ip_packet,len);
break;
case IP_TCP:
process_tcp_in (&received_ip_packet, len);
break;
}
break;
}
/* discard received frame */
NETWORK_RECEIVE_END();
}
/* Application main loops */
/* Do not forget this!!! These don't get invoked magically :-) */
tcps_run();
udps_run();
/* manage arp cache tables */
arp_manage();
/* manage opened TCP connections (retransmissions, timeouts,...)*/
tcp_poll();
}
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
register char *s, *p;
register int i;
char *pn = basename(argv[0]);
struct timeval tv;
#ifdef HAS_CONFIG
struct stat sbuf;
#endif
#ifdef BOOTROM
char *rom = "-r ";
#else
char *rom = "";
#endif
#ifdef CPU_SPEED
f_flag = CPU_SPEED;
tmax = CPU_SPEED * 10000;
#endif
while (--argc > 0 && (*++argv)[0] == '-')
for (s = argv[0] + 1; *s != '\0'; s++)
switch (*s) {
case 's': /* save core and CPU on exit */
s_flag = 1;
break;
case 'l': /* load core and CPU from file */
l_flag = 1;
break;
case 'u': /* trap undocumented ops */
u_flag = 1;
break;
case 'i': /* trap I/O on unused ports */
i_flag = 1;
break;
case 'm': /* initialise Z80 memory */
if (*(s+1) != '\0') {
m_flag = exatoi(s+1);
s += strlen(s+1);
} else {
if (argc <= 1)
goto usage;
argc--;
argv++;
m_flag = exatoi(argv[0]);
}
break;
case 'f': /* set emulation speed */
if (*(s+1) != '\0') {
f_flag = atoi(s+1);
s += strlen(s+1);
} else {
if (argc <= 1)
goto usage;
argc--;
argv++;
f_flag = atoi(argv[0]);
}
tmax = f_flag * 10000;
break;
case 'x': /* get filename with Z80 executable */
x_flag = 1;
s++;
if (*s == '\0') {
if (argc <= 1)
goto usage;
argc--;
argv++;
s = argv[0];
}
p = xfn;
while (*s)
*p++ = *s++;
*p = '\0';
s--;
break;
#ifdef BOOTROM
case 'r': /* load default boot ROM */
x_flag = 1;
strcpy(xfn, BOOTROM);
break;
#endif
#ifdef HAS_DISKS
case 'd': /* get path for disk images */
s++;
if (*s == '\0') {
if (argc <= 1)
goto usage;
argc--;
argv++;
s = argv[0];
}
p = diskdir = diskd;
while (*s)
*p++ = *s++;
*p = '\0';
s--;
break;
#endif
case '8':
cpu = I8080;
break;
case 'z':
cpu = Z80;
break;
case '?':
case 'h':
goto usage;
default:
printf("illegal option %c\n", *s);
usage:
#ifdef HAS_DISKS
printf("usage:\t%s -z -8 -s -l -i -u %s-m val -f freq -x filename -d diskpath\n", pn, rom);
#else
printf("usage:\t%s -z -8 -s -l -i -u %s-m val -f freq -x filename\n", pn, rom);
#endif
puts("\t-z = emulate Zilog Z80");
puts("\t-8 = emulate Intel 8080");
puts("\t-s = save core and CPU");
puts("\t-l = load core and CPU");
puts("\t-i = trap on I/O to unused ports");
puts("\t-u = trap on undocumented instructions");
#ifdef BOOTROM
puts("\t-r = load and execute default ROM");
printf("\t %s\n", BOOTROM);
#endif
puts("\t-m = init memory with val (00-FF)");
puts("\t-f = CPU clock frequency freq in MHz");
puts("\t-x = load and execute filename");
#ifdef HAS_DISKS
puts("\t-d = use disks images at diskpath");
puts("\t default path for disk images:");
puts("\t ./disks");
printf("\t %s\n", DISKSDIR);
#endif
exit(1);
}
putchar('\n');
if (cpu == Z80) {
puts("####### ##### ### ##### ### # #");
puts(" # # # # # # # # ## ##");
puts(" # # # # # # # # # # #");
puts(" # ##### # # ##### ##### # # # #");
puts(" # # # # # # # # #");
puts(" # # # # # # # # # #");
puts("####### ##### ### ##### ### # #");
} else {
puts(" ##### ### ##### ### ##### ### # #");
puts("# # # # # # # # # # # ## ##");
puts("# # # # # # # # # # # # # #");
puts(" ##### # # ##### # # ##### ##### # # # #");
puts("# # # # # # # # # # # #");
puts("# # # # # # # # # # # # #");
puts(" ##### ### ##### ### ##### ### # #");
}
printf("\nRelease %s, %s\n", RELEASE, COPYR);
#ifdef USR_COM
printf("%s Release %s, %s\n\n", USR_COM, USR_REL, USR_CPR);
#else
putchar('\n');
#endif
if (f_flag > 0)
printf("CPU speed is %d MHz\n", f_flag);
else
printf("CPU speed is unlimited\n");
fflush(stdout);
/* if the machine has configuration files try to find them */
#ifdef HAS_CONFIG
/* first try ./conf */
if ((stat("./conf", &sbuf) == 0) && S_ISDIR(sbuf.st_mode)) {
strcpy(&confdir[0], "./conf");
/* then CONFDIR as set in Makefile */
} else {
strcpy(&confdir[0], CONFDIR);
}
//printf("config = %s\n", &confdir[0]);
#endif
/* seed random generator */
gettimeofday(&tv, NULL);
srand(tv.tv_sec);
config(); /* read system configuration */
init_memory(); /* initialise memory configuration */
init_cpu(); /* initialise CPU */
wrk_ram = mem_base(); /* set work pointer for memory */
/* fill memory content with some initial value */
if (m_flag >= 0) {
memset((char *) wrk_ram, m_flag, 65536);
} else {
for (i = 0; i < 65536; i++)
*(wrk_ram + i) = (BYTE) (rand() % 256);
}
init_rom(); /* initialise ROM's */
if (l_flag) /* load core */
if (load_core())
return(1);
int_on(); /* initialize UNIX interrupts */
init_io(); /* initialize I/O devices */
mon(); /* run system */
if (s_flag) /* save core */
save_core();
exit_io(); /* stop I/O devices */
int_off(); /* stop UNIX interrupts */
return(0);
}
bool retro_load_game(const struct retro_game_info *info)
{
char bios_file_path[256];
const char *full_path, *system_directory_c;
enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_RGB565;
if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt))
{
if (log_cb)
log_cb(RETRO_LOG_INFO, "[O2EM]: RGB565 is not supported.\n");
return false;
}
struct retro_input_descriptor desc[] = {
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "Up" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "Down" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Fire" },
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "Up" },
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "Down" },
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Action" },
{ 0 },
};
environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc);
full_path = info->path;
system_directory_c = NULL;
// BIOS is required
environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &system_directory_c);
if (!system_directory_c)
{
if (log_cb)
log_cb(RETRO_LOG_WARN, "[O2EM]: no system directory defined, unable to look for o2rom.bin\n");
return false;
}
else
{
#ifdef _WIN32
char slash = '\\';
#else
char slash = '/';
#endif
snprintf(bios_file_path, sizeof(bios_file_path), "%s%c%s", system_directory_c, slash, "o2rom.bin");
if (!does_file_exist(bios_file_path))
{
if (log_cb)
log_cb(RETRO_LOG_WARN, "[O2EM]: o2rom.bin not found, cannot load BIOS\n");
return false;
}
}
app_data.debug = 0;
app_data.stick[0] = app_data.stick[1] = 1;
app_data.sticknumber[0] = app_data.sticknumber[1] = 0;
set_defjoykeys(0,0);
set_defjoykeys(1,1);
set_defsystemkeys();
app_data.bank = 0;
app_data.limit = 1;
app_data.sound_en = 1;
app_data.speed = 100;
app_data.wsize = 2;
app_data.fullscreen = 0;
app_data.scanlines = 0;
app_data.voice = 1;
app_data.window_title = "O2EM v" O2EM_VERSION;
app_data.svolume = 100;
app_data.vvolume = 100;
app_data.filter = 0;
app_data.exrom = 0;
app_data.three_k = 0;
app_data.crc = 0;
app_data.scshot = scshot;
app_data.statefile = statefile;
app_data.euro = 0;
app_data.openb = 0;
app_data.vpp = 0;
app_data.bios = 0;
app_data.scoretype = 0;
app_data.scoreaddress = 0;
app_data.default_highscore = 0;
app_data.breakpoint = 65535;
app_data.megaxrom = 0;
//strcpy(file,"");
//strcpy(file_l,"");
//strcpy(bios_l,"");
//strcpy(bios,"");
//strcpy(scshot,"");
//strcpy(statefile,"");
//strcpy(xrom,"");
strcpy(scorefile,"highscore.txt");
//read_default_config();
init_audio();
app_data.crc = crc32_file(full_path);
//suck_bios();
o2flag = 1;
crcx = app_data.crc;
//suck_roms();
load_bios(bios_file_path);
load_cart(full_path);
//if (app_data.voice) load_voice_samples(path2);
init_display();
init_cpu();
init_system();
set_score(app_data.scoretype, app_data.scoreaddress, app_data.default_highscore);
return true;
}
int
main (int argc, char **argv)
{
int o;
int save_trace;
bfd *prog;
int rc;
xmalloc_set_program_name (argv[0]);
while ((o = getopt (argc, argv, "tvdr:D:")) != -1)
{
switch (o)
{
case 't':
trace ++;
break;
case 'v':
verbose ++;
break;
case 'd':
disassemble ++;
break;
case 'r':
mem_ram_size (atoi (optarg));
break;
case 'D':
dump_counts_filename = optarg;
break;
case '?':
{
fprintf (stderr,
"usage: run [options] program [arguments]\n");
fprintf (stderr,
"\t-v\t\t- increase verbosity.\n"
"\t-t\t\t- trace.\n"
"\t-d\t\t- disassemble.\n"
"\t-r <bytes>\t- ram size.\n"
"\t-D <filename>\t- dump cycle count histogram\n");
exit (1);
}
}
}
prog = bfd_openr (argv[optind], 0);
if (!prog)
{
fprintf (stderr, "Can't read %s\n", argv[optind]);
exit (1);
}
if (!bfd_check_format (prog, bfd_object))
{
fprintf (stderr, "%s not a rl78 program\n", argv[optind]);
exit (1);
}
init_cpu ();
rl78_in_gdb = 0;
save_trace = trace;
trace = 0;
rl78_load (prog, 0, argv[0]);
trace = save_trace;
sim_disasm_init (prog);
rc = setjmp (decode_jmp_buf);
if (rc == 0)
{
if (!trace && !disassemble)
{
/* This will longjmp to the above if an exception
happens. */
for (;;)
decode_opcode ();
}
else
while (1)
{
if (trace)
printf ("\n");
if (disassemble)
sim_disasm_one ();
rc = decode_opcode ();
if (trace)
trace_register_changes ();
}
}
if (RL78_HIT_BREAK (rc))
done (1);
else if (RL78_EXITED (rc))
done (RL78_EXIT_STATUS (rc));
else if (RL78_STOPPED (rc))
{
if (verbose)
printf ("Stopped on signal %d\n", RL78_STOP_SIG (rc));
exit (1);
}
done (0);
exit (0);
}
