INLINE UINT16 get_cvsd_address(void)
{
if (cvsd.address)
return cvsd.address[0] * 256 + cvsd.address[1];
else
return cpunum_get_reg(williams_cpunum, M6809_Y);
}
static READ8_HANDLER( mcu_tnzs_r )
{
unsigned char data;
if (offset == 0)
{
data = cpunum_get_reg(2, I8X41_DATA);
cpu_yield();
}
else
{
data = cpunum_get_reg(2, I8X41_STAT);
cpu_yield();
}
// logerror("PC %04x: read %02x from mcu $c00%01x\n", activecpu_get_previouspc(), data, offset);
return data;
}
static void dump_registers(void)
{
logerror("PC = %04x\n", (unsigned) cpunum_get_reg(0, I8080_PC));
logerror("SP = %04x\n", (unsigned) cpunum_get_reg(0, I8080_SP));
logerror("AF = %04x\n", (unsigned) cpunum_get_reg(0, I8080_AF));
logerror("BC = %04x\n", (unsigned) cpunum_get_reg(0, I8080_BC));
logerror("DE = %04x\n", (unsigned) cpunum_get_reg(0, I8080_DE));
logerror("HL = %04x\n", (unsigned) cpunum_get_reg(0, I8080_HL));
}
static void c128_bankswitch (int reset)
{
if (mmu_cpu != MMU_CPU8502)
{
if (!MMU_CPU8502)
{
DBG_LOG (1, "switching to z80",
("active %d\n",cpu_getactivecpu()) );
memory_set_context(0);
c128_bankswitch_z80();
memory_set_context(1);
cpunum_set_input_line(0, INPUT_LINE_HALT, CLEAR_LINE);
cpunum_set_input_line(1, INPUT_LINE_HALT, ASSERT_LINE);
}
else
{
DBG_LOG (1, "switching to m6502",
("active %d\n",cpu_getactivecpu()) );
memory_set_context(1);
c128_bankswitch_128(reset);
memory_set_context(0);
cpunum_set_input_line(0, INPUT_LINE_HALT, ASSERT_LINE);
cpunum_set_input_line(1, INPUT_LINE_HALT, CLEAR_LINE);
/* NPW 19-Nov-2005 - In the C128, CPU #0 starts out and hands over
* control to CPU #1. CPU #1 seems to execute garbage from 0x0000
* up to 0x1100, at which point it finally hits some code
* (presumably set up by CPU #1.) This always worked, but when I
* changed the m8502 CPU core to use an internal memory map, it
* started BRK-ing forever when trying to execute 0x0000.
*
* I am not sure whether the C128 actually executes this invalid
* memory or if this is a bug in the C128 driver. In any case, the
* driver used to work with this behavior, so I am doing this hack
* where I set CPU #1's PC to 0x1100 on reset.
*/
if (cpunum_get_reg(1, REG_PC) == 0x0000)
cpunum_set_reg(1, REG_PC, 0x1100);
}
mmu_cpu = MMU_CPU8502;
return;
}
if (!MMU_CPU8502)
c128_bankswitch_z80();
else
c128_bankswitch_128(reset);
}
void osd_update_video_and_audio(mame_display *display)
{
int i;
double time_limit;
double current_time;
int cpunum;
/* if the visible area has changed, update it */
if (display->changed_flags & GAME_VISIBLE_AREA_CHANGED)
{
ui_set_visible_area(display->game_visible_area.min_x, display->game_visible_area.min_y,
display->game_visible_area.max_x, display->game_visible_area.max_y);
}
/* is this the first update? if so, eat it */
if (!seen_first_update)
{
seen_first_update = TRUE;
return;
}
/* if we have already aborted or completed, our work is done */
if ((state == STATE_ABORTED) || (state == STATE_DONE))
return;
/* have we hit the time limit? */
current_time = timer_get_time();
time_limit = (current_testcase.time_limit != 0.0) ? current_testcase.time_limit
: TIME_IN_SEC(600);
if (current_time > time_limit)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Time limit of %.2f seconds exceeded", time_limit);
return;
}
/* update the runtime hash */
if (0)
{
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
runtime_hash *= 57;
runtime_hash ^= cpunum_get_reg(cpunum, REG_PC); /* TODO - Add more registers? */
}
}
for (i = 0; i < sizeof(commands) / sizeof(commands[i]); i++)
{
if (current_command->command_type == commands[i].command_type)
{
commands[i].proc();
break;
}
}
/* if we are ready for the next command, advance to it */
if (state == STATE_READY)
{
/* if we are at the end, and we are dumping screenshots, and we didn't
* just dump a screenshot, dump one now
*/
if ((test_flags & MESSTEST_ALWAYS_DUMP_SCREENSHOT) &&
(current_command[0].command_type != MESSTEST_COMMAND_SCREENSHOT) &&
(current_command[1].command_type == MESSTEST_COMMAND_END))
{
dump_screenshot(TRUE);
}
current_command++;
}
}
/*
draw the operator control panel (dynamic elements)
*/
static void pdp1_draw_panel(mame_bitmap *bitmap)
{
/* column 1: registers, test word, test address */
pdp1_draw_multipleled(bitmap, x_panel_col1_offset+2*8, y_panel_pc_offset+8, cpunum_get_reg(0, PDP1_PC), 16);
pdp1_draw_multipleled(bitmap, x_panel_col1_offset+2*8, y_panel_ma_offset+8, cpunum_get_reg(0, PDP1_MA), 16);
pdp1_draw_multipleled(bitmap, x_panel_col1_offset, y_panel_mb_offset+8, cpunum_get_reg(0, PDP1_MB), 18);
pdp1_draw_multipleled(bitmap, x_panel_col1_offset, y_panel_ac_offset+8, cpunum_get_reg(0, PDP1_AC), 18);
pdp1_draw_multipleled(bitmap, x_panel_col1_offset, y_panel_io_offset+8, cpunum_get_reg(0, PDP1_IO), 18);
pdp1_draw_switch(bitmap, x_panel_col1_offset, y_panel_ta_offset+8, cpunum_get_reg(0, PDP1_EXTEND_SW));
pdp1_draw_multipleswitch(bitmap, x_panel_col1_offset+2*8, y_panel_ta_offset+8, cpunum_get_reg(0, PDP1_TA), 16);
pdp1_draw_multipleswitch(bitmap, x_panel_col1_offset, y_panel_tw_offset+8, cpunum_get_reg(0, PDP1_TW), 18);
/* column 2: 1-bit indicators */
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_run_offset, cpunum_get_reg(0, PDP1_RUN));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_cyc_offset, cpunum_get_reg(0, PDP1_CYC));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_defer_offset, cpunum_get_reg(0, PDP1_DEFER));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_hs_cyc_offset, 0); /* not emulated */
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_brk_ctr_1_offset, cpunum_get_reg(0, PDP1_BRK_CTR) & 1);
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_brk_ctr_2_offset, cpunum_get_reg(0, PDP1_BRK_CTR) & 2);
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_ov_offset, cpunum_get_reg(0, PDP1_OV));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_rim_offset, cpunum_get_reg(0, PDP1_RIM));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_sbm_offset, cpunum_get_reg(0, PDP1_SBM));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_exd_offset, cpunum_get_reg(0, PDP1_EXD));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_ioh_offset, cpunum_get_reg(0, PDP1_IOH));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_ioc_offset, cpunum_get_reg(0, PDP1_IOC));
pdp1_draw_led(bitmap, x_panel_col2_offset, y_panel_ios_offset, cpunum_get_reg(0, PDP1_IOS));
/* column 3: power, single step, single inst, sense, flags, instr... */
pdp1_draw_led(bitmap, x_panel_col3_offset, y_panel_power_offset, 1); /* always on */
pdp1_draw_switch(bitmap, x_panel_col3_offset+8, y_panel_power_offset, 1); /* always on */
pdp1_draw_led(bitmap, x_panel_col3_offset, y_panel_sngl_step_offset, cpunum_get_reg(0, PDP1_SNGL_STEP));
pdp1_draw_switch(bitmap, x_panel_col3_offset+8, y_panel_sngl_step_offset, cpunum_get_reg(0, PDP1_SNGL_STEP));
pdp1_draw_led(bitmap, x_panel_col3_offset, y_panel_sngl_inst_offset, cpunum_get_reg(0, PDP1_SNGL_INST));
pdp1_draw_switch(bitmap, x_panel_col3_offset+8, y_panel_sngl_inst_offset, cpunum_get_reg(0, PDP1_SNGL_INST));
pdp1_draw_multipleled(bitmap, x_panel_col3_offset, y_panel_ss_offset+8, cpunum_get_reg(0, PDP1_SS), 6);
pdp1_draw_multipleswitch(bitmap, x_panel_col3_offset, y_panel_ss_offset+2*8, cpunum_get_reg(0, PDP1_SS), 6);
pdp1_draw_multipleled(bitmap, x_panel_col3_offset, y_panel_pf_offset+8, cpunum_get_reg(0, PDP1_PF), 6);
pdp1_draw_multipleled(bitmap, x_panel_col3_offset, y_panel_ir_offset+8, cpunum_get_reg(0, PDP1_IR), 5);
}
int osd_update(mame_time emutime)
{
int i;
double time_limit;
double current_time;
int cpunum;
render_target_get_primitives(target);
/* is this the first update? if so, eat it */
if (!seen_first_update)
{
seen_first_update = TRUE;
goto done;
}
/* if we have already aborted or completed, our work is done */
if ((state == STATE_ABORTED) || (state == STATE_DONE))
{
mame_schedule_exit(Machine);
goto done;
}
/* have we hit the time limit? */
current_time = timer_get_time();
time_limit = (current_testcase.time_limit != 0.0) ? current_testcase.time_limit
: TIME_IN_SEC(600);
if (current_time > time_limit)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Time limit of %.2f seconds exceeded", time_limit);
goto done;
}
/* update the runtime hash */
if (0)
{
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
runtime_hash *= 57;
runtime_hash ^= cpunum_get_reg(cpunum, REG_PC); /* TODO - Add more registers? */
}
}
for (i = 0; i < sizeof(commands) / sizeof(commands[i]); i++)
{
if (current_command->command_type == commands[i].command_type)
{
commands[i].proc();
break;
}
}
/* if we are ready for the next command, advance to it */
if (state == STATE_READY)
{
/* if we are at the end, and we are dumping screenshots, and we didn't
* just dump a screenshot, dump one now
*/
if ((test_flags & MESSTEST_ALWAYS_DUMP_SCREENSHOT) &&
(current_command[0].command_type != MESSTEST_COMMAND_SCREENSHOT) &&
(current_command[1].command_type == MESSTEST_COMMAND_END))
{
dump_screenshot(TRUE);
}
current_command++;
}
done:
return FALSE;
}
