int cpuint_init(void)
{
int cpunum;
int irqline;
/* loop over all CPUs */
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
/* reset the IRQ lines */
for (irqline = 0; irqline < MAX_IRQ_LINES; irqline++)
{
irq_line_state[cpunum][irqline] = CLEAR_LINE;
interrupt_vector[cpunum][irqline] =
irq_line_vector[cpunum][irqline] = cpunum_default_irq_vector(cpunum);
}
/* reset the IRQ event queues */
irq_event_index[cpunum] = 0;
}
/* set up some stuff to save */
state_save_set_current_tag(0);
state_save_register_UINT8("cpu", 0, "irq enable", interrupt_enable, cpu_gettotalcpu());
state_save_register_INT32("cpu", 0, "irq vector", &interrupt_vector[0][0],cpu_gettotalcpu() * MAX_IRQ_LINES);
state_save_register_UINT8("cpu", 0, "irqline state", &irq_line_state[0][0], cpu_gettotalcpu() * MAX_IRQ_LINES);
state_save_register_INT32("cpu", 0, "irqline vector", &irq_line_vector[0][0], cpu_gettotalcpu() * MAX_IRQ_LINES);
return 0;
}
int cpu_init(void)
{
int cpunum;
/* initialize the interfaces first */
if (cpuintrf_init())
return 1;
/* loop over all our CPUs */
for (cpunum = 0; cpunum < MAX_CPU; cpunum++)
{
int cputype = Machine->drv->cpu[cpunum].cpu_type;
/* if this is a dummy, stop looking */
if (cputype == CPU_DUMMY)
break;
/* set the save state tag */
state_save_set_current_tag(cpunum + 1);
/* initialize the cpuinfo struct */
memset(&cpu[cpunum], 0, sizeof(cpu[cpunum]));
cpu[cpunum].suspend = SUSPEND_REASON_RESET;
cpu[cpunum].clockscale = cputype_get_interface(cputype)->overclock;
/* compute the cycle times */
sec_to_cycles[cpunum] = cpu[cpunum].clockscale * Machine->drv->cpu[cpunum].cpu_clock;
cycles_to_sec[cpunum] = 1.0 / sec_to_cycles[cpunum];
/* initialize this CPU */
if (cpuintrf_init_cpu(cpunum, cputype))
return 1;
}
/* compute the perfect interleave factor */
compute_perfect_interleave();
/* save some stuff in tag 0 */
state_save_set_current_tag(0);
state_save_register_INT32("cpu", 0, "watchdog count", &watchdog_counter, 1);
/* reset the IRQ lines and save those */
if (cpuint_init())
return 1;
return 0;
}
bool retro_serialize(void *data, size_t size)
{
int cpunum;
if(retro_serialize_size() && data && size)
{
/* write the save state */
state_save_save_begin(data);
/* write tag 0 */
state_save_set_current_tag(0);
if(state_save_save_continue())
{
return false;
}
/* loop over CPUs */
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
cpuintrf_push_context(cpunum);
/* make sure banking is set */
activecpu_reset_banking();
/* save the CPU data */
state_save_set_current_tag(cpunum + 1);
if(state_save_save_continue())
return false;
cpuintrf_pop_context();
}
/* finish and close */
state_save_save_finish();
return true;
}
return false;
}
bool retro_unserialize(const void * data, size_t size)
{
int cpunum;
/* if successful, load it */
if (retro_serialize_size() && data && size && !state_save_load_begin((void*)data, size))
{
/* read tag 0 */
state_save_set_current_tag(0);
if(state_save_load_continue())
return false;
/* loop over CPUs */
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
cpuintrf_push_context(cpunum);
/* make sure banking is set */
activecpu_reset_banking();
/* load the CPU data */
state_save_set_current_tag(cpunum + 1);
if(state_save_load_continue())
return false;
cpuintrf_pop_context();
}
/* finish and close */
state_save_load_finish();
return true;
}
return false;
}
