mirror of
https://github.com/holub/mame
synced 2025-05-07 23:02:33 +03:00
Added "tag" parameter to state_save_register_item_* calls. Removed
state_save_combine_module_and_tag() function in favor of passing the tag when registering. Revisited all save state item registrations and changed them to use the tag where appropriate.
This commit is contained in:
Aaron Giles
parent
8aa46743d1
commit
a5bf427929
@ -613,85 +613,85 @@ static adsp2100_state *adsp21xx_init(const device_config *device, int index, int
|
||||
adsp->shift_xregs[7] = &adsp->core.sr.srx.sr1;
|
||||
|
||||
/* "core" */
|
||||
state_save_register_item("adsp2100", index, adsp->core.ax0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.ax1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.ay0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.ay1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.ar.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.af.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.mx0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.mx1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.my0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.my1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.mr.mr);
|
||||
state_save_register_item("adsp2100", index, adsp->core.mf.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.si.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.se.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.sb.u);
|
||||
state_save_register_item("adsp2100", index, adsp->core.sr.sr);
|
||||
state_save_register_item("adsp2100", index, adsp->core.zero.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ax0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ax1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ay0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ay1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.ar.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.af.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mx0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mx1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.my0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.my1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mr.mr);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.mf.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.si.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.se.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.sb.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.sr.sr);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->core.zero.u);
|
||||
|
||||
/* "alt" */
|
||||
state_save_register_item("adsp2100", index, adsp->alt.ax0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.ax1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.ay0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.ay1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.ar.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.af.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.mx0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.mx1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.my0.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.my1.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.mr.mr);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.mf.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.si.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.se.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.sb.u);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.sr.sr);
|
||||
state_save_register_item("adsp2100", index, adsp->alt.zero.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ax0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ax1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ay0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ay1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.ar.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.af.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mx0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mx1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.my0.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.my1.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mr.mr);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.mf.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.si.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.se.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.sb.u);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.sr.sr);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->alt.zero.u);
|
||||
|
||||
state_save_register_item_array("adsp2100", index, adsp->i);
|
||||
state_save_register_item_array("adsp2100", index, adsp->m);
|
||||
state_save_register_item_array("adsp2100", index, adsp->l);
|
||||
state_save_register_item_array("adsp2100", index, adsp->lmask);
|
||||
state_save_register_item_array("adsp2100", index, adsp->base);
|
||||
state_save_register_item("adsp2100", index, adsp->px);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->i);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->m);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->l);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->lmask);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->base);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->px);
|
||||
|
||||
state_save_register_item("adsp2100", index, adsp->pc);
|
||||
state_save_register_item("adsp2100", index, adsp->ppc);
|
||||
state_save_register_item("adsp2100", index, adsp->loop);
|
||||
state_save_register_item("adsp2100", index, adsp->loop_condition);
|
||||
state_save_register_item("adsp2100", index, adsp->cntr);
|
||||
state_save_register_item("adsp2100", index, adsp->astat);
|
||||
state_save_register_item("adsp2100", index, adsp->sstat);
|
||||
state_save_register_item("adsp2100", index, adsp->mstat);
|
||||
state_save_register_item("adsp2100", index, adsp->astat_clear);
|
||||
state_save_register_item("adsp2100", index, adsp->idle);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->pc);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->ppc);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->loop);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->loop_condition);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->cntr);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->astat);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->sstat);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->mstat);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->astat_clear);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->idle);
|
||||
|
||||
state_save_register_item_array("adsp2100", index, adsp->loop_stack);
|
||||
state_save_register_item_array("adsp2100", index, adsp->cntr_stack);
|
||||
state_save_register_item_array("adsp2100", index, adsp->pc_stack);
|
||||
state_save_register_item_2d_array("adsp2100", index, adsp->stat_stack);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->loop_stack);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->cntr_stack);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->pc_stack);
|
||||
state_save_register_item_2d_array("adsp2100", device->tag, 0, adsp->stat_stack);
|
||||
|
||||
state_save_register_item("adsp2100", index, adsp->pc_sp);
|
||||
state_save_register_item("adsp2100", index, adsp->cntr_sp);
|
||||
state_save_register_item("adsp2100", index, adsp->stat_sp);
|
||||
state_save_register_item("adsp2100", index, adsp->loop_sp);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->pc_sp);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->cntr_sp);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->stat_sp);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->loop_sp);
|
||||
|
||||
state_save_register_item("adsp2100", index, adsp->flagout);
|
||||
state_save_register_item("adsp2100", index, adsp->flagin);
|
||||
state_save_register_item("adsp2100", index, adsp->fl0);
|
||||
state_save_register_item("adsp2100", index, adsp->fl1);
|
||||
state_save_register_item("adsp2100", index, adsp->fl2);
|
||||
state_save_register_item("adsp2100", index, adsp->idma_addr);
|
||||
state_save_register_item("adsp2100", index, adsp->idma_cache);
|
||||
state_save_register_item("adsp2100", index, adsp->idma_offs);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->flagout);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->flagin);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->fl0);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->fl1);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->fl2);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->idma_addr);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->idma_cache);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->idma_offs);
|
||||
|
||||
state_save_register_item("adsp2100", index, adsp->imask);
|
||||
state_save_register_item("adsp2100", index, adsp->icntl);
|
||||
state_save_register_item("adsp2100", index, adsp->ifc);
|
||||
state_save_register_item_array("adsp2100", index, adsp->irq_state);
|
||||
state_save_register_item_array("adsp2100", index, adsp->irq_latch);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->imask);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->icntl);
|
||||
state_save_register_item("adsp2100", device->tag, 0, adsp->ifc);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->irq_state);
|
||||
state_save_register_item_array("adsp2100", device->tag, 0, adsp->irq_latch);
|
||||
|
||||
return adsp;
|
||||
}
|
||||
|
||||
@ -664,27 +664,27 @@ static const s_opcode opcode_8301[256]=
|
||||
****************************************************************************/
|
||||
static CPU_INIT( ALPHA8201 )
|
||||
{
|
||||
state_save_register_item_array("ALPHA8201", index, R.RAM);
|
||||
state_save_register_item("ALPHA8201", index, R.PREVPC);
|
||||
state_save_register_item("ALPHA8201", index, PC);
|
||||
state_save_register_item("ALPHA8201", index, regPTR);
|
||||
state_save_register_item("ALPHA8201", index, ZF);
|
||||
state_save_register_item("ALPHA8201", index, CF);
|
||||
state_save_register_item("ALPHA8201", index, R.mb);
|
||||
state_save_register_item_array("ALPHA8201", device->tag, 0, R.RAM);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.PREVPC);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, PC);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, regPTR);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, ZF);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, CF);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.mb);
|
||||
#if HANDLE_HALT_LINE
|
||||
state_save_register_item("ALPHA8201", index, R.halt);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.halt);
|
||||
#endif
|
||||
state_save_register_item("ALPHA8201", index, IX0);
|
||||
state_save_register_item("ALPHA8201", index, IX1);
|
||||
state_save_register_item("ALPHA8201", index, IX2);
|
||||
state_save_register_item("ALPHA8201", index, LP0);
|
||||
state_save_register_item("ALPHA8201", index, LP1);
|
||||
state_save_register_item("ALPHA8201", index, LP2);
|
||||
state_save_register_item("ALPHA8201", index, R.A);
|
||||
state_save_register_item("ALPHA8201", index, R.B);
|
||||
state_save_register_item("ALPHA8201", index, R.retptr);
|
||||
state_save_register_item("ALPHA8201", index, R.savec);
|
||||
state_save_register_item("ALPHA8201", index, R.savez);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, IX0);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, IX1);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, IX2);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, LP0);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, LP1);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, LP2);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.A);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.B);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.retptr);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.savec);
|
||||
state_save_register_item("ALPHA8201", device->tag, 0, R.savez);
|
||||
}
|
||||
/****************************************************************************
|
||||
* Reset registers to their initial values
|
||||
|
||||
@ -515,10 +515,10 @@ static CPU_INIT( arm )
|
||||
arm.irq_callback = irqcallback;
|
||||
arm.device = device;
|
||||
|
||||
state_save_register_item_array("arm", index, arm.sArmRegister);
|
||||
state_save_register_item_array("arm", index, arm.coproRegister);
|
||||
state_save_register_item("arm", index, arm.pendingIrq);
|
||||
state_save_register_item("arm", index, arm.pendingFiq);
|
||||
state_save_register_item_array("arm", device->tag, 0, arm.sArmRegister);
|
||||
state_save_register_item_array("arm", device->tag, 0, arm.coproRegister);
|
||||
state_save_register_item("arm", device->tag, 0, arm.pendingIrq);
|
||||
state_save_register_item("arm", device->tag, 0, arm.pendingFiq);
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
@ -85,7 +85,7 @@ static int ARM7_ICOUNT;
|
||||
static CPU_INIT( arm7 )
|
||||
{
|
||||
// must call core
|
||||
arm7_core_init("arm7", index);
|
||||
arm7_core_init("arm7", device);
|
||||
|
||||
ARM7.irq_callback = irqcallback;
|
||||
ARM7.device = device;
|
||||
|
||||
@ -508,15 +508,15 @@ static int storeDec(UINT32 pat, UINT32 rbv)
|
||||
***************************************************************************/
|
||||
|
||||
// CPU INIT
|
||||
static void arm7_core_init(const char *cpuname, int index)
|
||||
static void arm7_core_init(const char *cpuname, const device_config *device)
|
||||
{
|
||||
state_save_register_item_array(cpuname, index, ARM7.sArmRegister);
|
||||
state_save_register_item(cpuname, index, ARM7.pendingIrq);
|
||||
state_save_register_item(cpuname, index, ARM7.pendingFiq);
|
||||
state_save_register_item(cpuname, index, ARM7.pendingAbtD);
|
||||
state_save_register_item(cpuname, index, ARM7.pendingAbtP);
|
||||
state_save_register_item(cpuname, index, ARM7.pendingUnd);
|
||||
state_save_register_item(cpuname, index, ARM7.pendingSwi);
|
||||
state_save_register_item_array(cpuname, device->tag, 0, ARM7.sArmRegister);
|
||||
state_save_register_item(cpuname, device->tag, 0, ARM7.pendingIrq);
|
||||
state_save_register_item(cpuname, device->tag, 0, ARM7.pendingFiq);
|
||||
state_save_register_item(cpuname, device->tag, 0, ARM7.pendingAbtD);
|
||||
state_save_register_item(cpuname, device->tag, 0, ARM7.pendingAbtP);
|
||||
state_save_register_item(cpuname, device->tag, 0, ARM7.pendingUnd);
|
||||
state_save_register_item(cpuname, device->tag, 0, ARM7.pendingSwi);
|
||||
}
|
||||
|
||||
// CPU RESET
|
||||
|
||||
@ -141,25 +141,25 @@ static CPU_INIT( ccpu )
|
||||
ccpu.external_input = configdata->external_input ? configdata->external_input : read_jmi;
|
||||
ccpu.vector_callback = configdata->vector_callback;
|
||||
|
||||
state_save_register_item("ccpu", clock, ccpu.PC);
|
||||
state_save_register_item("ccpu", clock, ccpu.A);
|
||||
state_save_register_item("ccpu", clock, ccpu.B);
|
||||
state_save_register_item("ccpu", clock, ccpu.I);
|
||||
state_save_register_item("ccpu", clock, ccpu.J);
|
||||
state_save_register_item("ccpu", clock, ccpu.P);
|
||||
state_save_register_item("ccpu", clock, ccpu.X);
|
||||
state_save_register_item("ccpu", clock, ccpu.Y);
|
||||
state_save_register_item("ccpu", clock, ccpu.T);
|
||||
state_save_register_item("ccpu", clock, ccpu.a0flag);
|
||||
state_save_register_item("ccpu", clock, ccpu.ncflag);
|
||||
state_save_register_item("ccpu", clock, ccpu.cmpacc);
|
||||
state_save_register_item("ccpu", clock, ccpu.cmpval);
|
||||
state_save_register_item("ccpu", clock, ccpu.miflag);
|
||||
state_save_register_item("ccpu", clock, ccpu.nextmiflag);
|
||||
state_save_register_item("ccpu", clock, ccpu.nextnextmiflag);
|
||||
state_save_register_item("ccpu", clock, ccpu.drflag);
|
||||
state_save_register_item("ccpu", clock, ccpu.waiting);
|
||||
state_save_register_item("ccpu", clock, ccpu.watchdog);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.PC);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.A);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.B);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.I);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.J);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.P);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.X);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.Y);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.T);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.a0flag);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.ncflag);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.cmpacc);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.cmpval);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.miflag);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.nextmiflag);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.nextnextmiflag);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.drflag);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.waiting);
|
||||
state_save_register_item("ccpu", device->tag, 0, ccpu.watchdog);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -74,24 +74,24 @@ static CPU_INIT( cdp1802 )
|
||||
cdp1802.dmain = CLEAR_LINE;
|
||||
cdp1802.dmaout = CLEAR_LINE;
|
||||
|
||||
state_save_register_item("cdp1802", index, cdp1802.p);
|
||||
state_save_register_item("cdp1802", index, cdp1802.x);
|
||||
state_save_register_item("cdp1802", index, cdp1802.d);
|
||||
state_save_register_item("cdp1802", index, cdp1802.b);
|
||||
state_save_register_item("cdp1802", index, cdp1802.t);
|
||||
state_save_register_item_array("cdp1802", index, cdp1802.r);
|
||||
state_save_register_item("cdp1802", index, cdp1802.df);
|
||||
state_save_register_item("cdp1802", index, cdp1802.ie);
|
||||
state_save_register_item("cdp1802", index, cdp1802.q);
|
||||
state_save_register_item("cdp1802", index, cdp1802.n);
|
||||
state_save_register_item("cdp1802", index, cdp1802.i);
|
||||
state_save_register_item("cdp1802", index, cdp1802.state);
|
||||
state_save_register_item("cdp1802", index, cdp1802.prevmode);
|
||||
state_save_register_item("cdp1802", index, cdp1802.mode);
|
||||
state_save_register_item("cdp1802", index, cdp1802.irq);
|
||||
state_save_register_item("cdp1802", index, cdp1802.dmain);
|
||||
state_save_register_item("cdp1802", index, cdp1802.dmaout);
|
||||
state_save_register_item("cdp1802", index, cdp1802.ef);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.p);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.x);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.d);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.b);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.t);
|
||||
state_save_register_item_array("cdp1802", device->tag, 0, cdp1802.r);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.df);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.ie);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.q);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.n);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.i);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.state);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.prevmode);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.mode);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.irq);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.dmain);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.dmaout);
|
||||
state_save_register_item("cdp1802", device->tag, 0, cdp1802.ef);
|
||||
}
|
||||
|
||||
INLINE void cdp1802_add(int left, int right)
|
||||
|
||||
@ -255,25 +255,25 @@ static CPU_INIT( cop410 )
|
||||
|
||||
/* register for state saving */
|
||||
|
||||
state_save_register_item("cop410", index, PC);
|
||||
state_save_register_item("cop410", index, R.PREVPC);
|
||||
state_save_register_item("cop410", index, A);
|
||||
state_save_register_item("cop410", index, B);
|
||||
state_save_register_item("cop410", index, C);
|
||||
state_save_register_item("cop410", index, EN);
|
||||
state_save_register_item("cop410", index, G);
|
||||
state_save_register_item("cop410", index, Q);
|
||||
state_save_register_item("cop410", index, SA);
|
||||
state_save_register_item("cop410", index, SB);
|
||||
state_save_register_item("cop410", index, SIO);
|
||||
state_save_register_item("cop410", index, SKL);
|
||||
state_save_register_item("cop410", index, skip);
|
||||
state_save_register_item("cop410", index, skipLBI);
|
||||
state_save_register_item("cop410", index, R.G_mask);
|
||||
state_save_register_item("cop410", index, R.D_mask);
|
||||
state_save_register_item("cop410", index, R.si);
|
||||
state_save_register_item("cop410", index, R.microbus_int);
|
||||
state_save_register_item("cop410", index, R.halt);
|
||||
state_save_register_item("cop410", device->tag, 0, PC);
|
||||
state_save_register_item("cop410", device->tag, 0, R.PREVPC);
|
||||
state_save_register_item("cop410", device->tag, 0, A);
|
||||
state_save_register_item("cop410", device->tag, 0, B);
|
||||
state_save_register_item("cop410", device->tag, 0, C);
|
||||
state_save_register_item("cop410", device->tag, 0, EN);
|
||||
state_save_register_item("cop410", device->tag, 0, G);
|
||||
state_save_register_item("cop410", device->tag, 0, Q);
|
||||
state_save_register_item("cop410", device->tag, 0, SA);
|
||||
state_save_register_item("cop410", device->tag, 0, SB);
|
||||
state_save_register_item("cop410", device->tag, 0, SIO);
|
||||
state_save_register_item("cop410", device->tag, 0, SKL);
|
||||
state_save_register_item("cop410", device->tag, 0, skip);
|
||||
state_save_register_item("cop410", device->tag, 0, skipLBI);
|
||||
state_save_register_item("cop410", device->tag, 0, R.G_mask);
|
||||
state_save_register_item("cop410", device->tag, 0, R.D_mask);
|
||||
state_save_register_item("cop410", device->tag, 0, R.si);
|
||||
state_save_register_item("cop410", device->tag, 0, R.microbus_int);
|
||||
state_save_register_item("cop410", device->tag, 0, R.halt);
|
||||
}
|
||||
|
||||
static CPU_INIT( cop411 )
|
||||
|
||||
@ -367,31 +367,31 @@ static CPU_INIT( cop420 )
|
||||
|
||||
/* register for state saving */
|
||||
|
||||
state_save_register_item("cop420", index, PC);
|
||||
state_save_register_item("cop420", index, R.PREVPC);
|
||||
state_save_register_item("cop420", index, A);
|
||||
state_save_register_item("cop420", index, B);
|
||||
state_save_register_item("cop420", index, C);
|
||||
state_save_register_item("cop420", index, EN);
|
||||
state_save_register_item("cop420", index, G);
|
||||
state_save_register_item("cop420", index, Q);
|
||||
state_save_register_item("cop420", index, SA);
|
||||
state_save_register_item("cop420", index, SB);
|
||||
state_save_register_item("cop420", index, SC);
|
||||
state_save_register_item("cop420", index, SIO);
|
||||
state_save_register_item("cop420", index, SKL);
|
||||
state_save_register_item("cop420", index, skip);
|
||||
state_save_register_item("cop420", index, skipLBI);
|
||||
state_save_register_item("cop420", index, R.timerlatch);
|
||||
state_save_register_item("cop420", index, R.counter);
|
||||
state_save_register_item("cop420", index, R.G_mask);
|
||||
state_save_register_item("cop420", index, R.D_mask);
|
||||
state_save_register_item("cop420", index, R.IN_mask);
|
||||
state_save_register_item("cop420", index, R.si);
|
||||
state_save_register_item("cop420", index, R.last_skip);
|
||||
state_save_register_item_array("cop420", index, R.in);
|
||||
state_save_register_item("cop420", index, R.microbus_int);
|
||||
state_save_register_item("cop420", index, R.halt);
|
||||
state_save_register_item("cop420", device->tag, 0, PC);
|
||||
state_save_register_item("cop420", device->tag, 0, R.PREVPC);
|
||||
state_save_register_item("cop420", device->tag, 0, A);
|
||||
state_save_register_item("cop420", device->tag, 0, B);
|
||||
state_save_register_item("cop420", device->tag, 0, C);
|
||||
state_save_register_item("cop420", device->tag, 0, EN);
|
||||
state_save_register_item("cop420", device->tag, 0, G);
|
||||
state_save_register_item("cop420", device->tag, 0, Q);
|
||||
state_save_register_item("cop420", device->tag, 0, SA);
|
||||
state_save_register_item("cop420", device->tag, 0, SB);
|
||||
state_save_register_item("cop420", device->tag, 0, SC);
|
||||
state_save_register_item("cop420", device->tag, 0, SIO);
|
||||
state_save_register_item("cop420", device->tag, 0, SKL);
|
||||
state_save_register_item("cop420", device->tag, 0, skip);
|
||||
state_save_register_item("cop420", device->tag, 0, skipLBI);
|
||||
state_save_register_item("cop420", device->tag, 0, R.timerlatch);
|
||||
state_save_register_item("cop420", device->tag, 0, R.counter);
|
||||
state_save_register_item("cop420", device->tag, 0, R.G_mask);
|
||||
state_save_register_item("cop420", device->tag, 0, R.D_mask);
|
||||
state_save_register_item("cop420", device->tag, 0, R.IN_mask);
|
||||
state_save_register_item("cop420", device->tag, 0, R.si);
|
||||
state_save_register_item("cop420", device->tag, 0, R.last_skip);
|
||||
state_save_register_item_array("cop420", device->tag, 0, R.in);
|
||||
state_save_register_item("cop420", device->tag, 0, R.microbus_int);
|
||||
state_save_register_item("cop420", device->tag, 0, R.halt);
|
||||
}
|
||||
|
||||
static CPU_INIT( cop421 )
|
||||
|
||||
@ -313,26 +313,26 @@ static STATE_POSTLOAD( cquestsnd_postload )
|
||||
|
||||
}
|
||||
|
||||
static void cquestsnd_state_register(int index, const char *type)
|
||||
static void cquestsnd_state_register(const device_config *device, const char *type)
|
||||
{
|
||||
state_save_register_item_array(type, index, cquestsnd.ram);
|
||||
state_save_register_item(type, index, cquestsnd.q);
|
||||
state_save_register_item(type, index, cquestsnd.f);
|
||||
state_save_register_item(type, index, cquestsnd.y);
|
||||
state_save_register_item(type, index, cquestsnd.cflag);
|
||||
state_save_register_item(type, index, cquestsnd.vflag);
|
||||
state_save_register_item_array(type, device->tag, 0, cquestsnd.ram);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.q);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.f);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.y);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.cflag);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.vflag);
|
||||
|
||||
state_save_register_item(type, index, cquestsnd.pc);
|
||||
state_save_register_item(type, index, cquestsnd.platch);
|
||||
state_save_register_item(type, index, cquestsnd.rtnlatch);
|
||||
state_save_register_item(type, index, cquestsnd.adrcntr);
|
||||
state_save_register_item(type, index, cquestsnd.adrlatch);
|
||||
state_save_register_item(type, index, cquestsnd.dinlatch);
|
||||
state_save_register_item(type, index, cquestsnd.ramwlatch);
|
||||
state_save_register_item(type, index, cquestsnd.prev_ipram);
|
||||
state_save_register_item(type, index, cquestsnd.prev_ipwrt);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.pc);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.platch);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.rtnlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.adrcntr);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.adrlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.dinlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.ramwlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.prev_ipram);
|
||||
state_save_register_item(type, device->tag, 0, cquestsnd.prev_ipwrt);
|
||||
|
||||
state_save_register_postload(Machine, cquestsnd_postload, NULL);
|
||||
state_save_register_postload(device->machine, cquestsnd_postload, (void *)device);
|
||||
}
|
||||
|
||||
static CPU_INIT( cquestsnd )
|
||||
@ -347,7 +347,7 @@ static CPU_INIT( cquestsnd )
|
||||
/* Allocate RAM shared with 68000 */
|
||||
cquestsnd.sram = malloc(4096);
|
||||
|
||||
cquestsnd_state_register(index, "cquestsnd");
|
||||
cquestsnd_state_register(device, "cquestsnd");
|
||||
}
|
||||
|
||||
|
||||
@ -372,35 +372,35 @@ static STATE_POSTLOAD( cquestrot_postload )
|
||||
|
||||
}
|
||||
|
||||
static void cquestrot_state_register(int index, const char *type)
|
||||
static void cquestrot_state_register(const device_config *device, const char *type)
|
||||
{
|
||||
state_save_register_item_array(type, index, cquestrot.ram);
|
||||
state_save_register_item(type, index, cquestrot.q);
|
||||
state_save_register_item(type, index, cquestrot.f);
|
||||
state_save_register_item(type, index, cquestrot.y);
|
||||
state_save_register_item(type, index, cquestrot.cflag);
|
||||
state_save_register_item(type, index, cquestrot.vflag);
|
||||
state_save_register_item_array(type, device->tag, 0, cquestrot.ram);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.q);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.f);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.y);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.cflag);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.vflag);
|
||||
|
||||
state_save_register_item(type, index, cquestrot.pc);
|
||||
state_save_register_item(type, index, cquestrot.seqcnt);
|
||||
state_save_register_item(type, index, cquestrot.dsrclatch);
|
||||
state_save_register_item(type, index, cquestrot.rsrclatch);
|
||||
state_save_register_item(type, index, cquestrot.dynaddr);
|
||||
state_save_register_item(type, index, cquestrot.dyndata);
|
||||
state_save_register_item(type, index, cquestrot.yrlatch);
|
||||
state_save_register_item(type, index, cquestrot.ydlatch);
|
||||
state_save_register_item(type, index, cquestrot.dinlatch);
|
||||
state_save_register_item(type, index, cquestrot.divreg);
|
||||
state_save_register_item(type, index, cquestrot.linedata);
|
||||
state_save_register_item(type, index, cquestrot.lineaddr);
|
||||
state_save_register_item(type, index, cquestrot.prev_dred);
|
||||
state_save_register_item(type, index, cquestrot.prev_dwrt);
|
||||
state_save_register_item(type, index, cquestrot.wc);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.pc);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.seqcnt);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.dsrclatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.rsrclatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.dynaddr);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.dyndata);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.yrlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.ydlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.dinlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.divreg);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.linedata);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.lineaddr);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.prev_dred);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.prev_dwrt);
|
||||
state_save_register_item(type, device->tag, 0, cquestrot.wc);
|
||||
|
||||
state_save_register_item_pointer(type, index, cquestrot.dram, 16384);
|
||||
state_save_register_item_pointer(type, index, cquestrot.sram, 2048);
|
||||
state_save_register_item_pointer(type, device->tag, 0, cquestrot.dram, 16384);
|
||||
state_save_register_item_pointer(type, device->tag, 0, cquestrot.sram, 2048);
|
||||
|
||||
state_save_register_postload(Machine, cquestrot_postload, NULL);
|
||||
state_save_register_postload(device->machine, cquestrot_postload, (void *)device);
|
||||
}
|
||||
|
||||
static CPU_INIT( cquestrot )
|
||||
@ -411,7 +411,7 @@ static CPU_INIT( cquestrot )
|
||||
cquestrot.dram = malloc(16384 * sizeof(UINT16)); /* Shared with 68000 */
|
||||
cquestrot.sram = malloc(2048 * sizeof(UINT16)); /* Private */
|
||||
|
||||
cquestrot_state_register(index, "cquestrot");
|
||||
cquestrot_state_register(device, "cquestrot");
|
||||
}
|
||||
|
||||
|
||||
@ -444,39 +444,39 @@ static STATE_POSTLOAD( cquestlin_postload )
|
||||
|
||||
}
|
||||
|
||||
static void cquestlin_state_register(int index, const char *type)
|
||||
static void cquestlin_state_register(const device_config *device, const char *type)
|
||||
{
|
||||
state_save_register_item_array(type, index, cquestlin.ram);
|
||||
state_save_register_item(type, index, cquestlin.q);
|
||||
state_save_register_item(type, index, cquestlin.f);
|
||||
state_save_register_item(type, index, cquestlin.y);
|
||||
state_save_register_item(type, index, cquestlin.cflag);
|
||||
state_save_register_item(type, index, cquestlin.vflag);
|
||||
state_save_register_item_array(type, device->tag, 0, cquestlin.ram);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.q);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.f);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.y);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.cflag);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.vflag);
|
||||
|
||||
state_save_register_item(type, index, cquestlin.pc[0]);
|
||||
state_save_register_item(type, index, cquestlin.pc[1]);
|
||||
state_save_register_item(type, index, cquestlin.seqcnt);
|
||||
state_save_register_item(type, index, cquestlin.clatch);
|
||||
state_save_register_item(type, index, cquestlin.zlatch);
|
||||
state_save_register_item(type, index, cquestlin.xcnt);
|
||||
state_save_register_item(type, index, cquestlin.ycnt);
|
||||
state_save_register_item(type, index, cquestlin.sreg);
|
||||
state_save_register_item(type, index, cquestlin.fadlatch);
|
||||
state_save_register_item(type, index, cquestlin.badlatch);
|
||||
state_save_register_item(type, index, cquestlin.sramdlatch);
|
||||
state_save_register_item(type, index, cquestlin.fglatch);
|
||||
state_save_register_item(type, index, cquestlin.bglatch);
|
||||
state_save_register_item(type, index, cquestlin.gt0reg);
|
||||
state_save_register_item(type, index, cquestlin.fdxreg);
|
||||
state_save_register_item(type, index, cquestlin.field);
|
||||
state_save_register_item(type, index, cquestlin.clkcnt);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.pc[0]);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.pc[1]);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.seqcnt);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.clatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.zlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.xcnt);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.ycnt);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.sreg);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.fadlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.badlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.sramdlatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.fglatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.bglatch);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.gt0reg);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.fdxreg);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.field);
|
||||
state_save_register_item(type, device->tag, 0, cquestlin.clkcnt);
|
||||
|
||||
state_save_register_item_pointer(type, index, cquestlin.sram, 4096);
|
||||
state_save_register_item_pointer(type, index, cquestlin.ptr_ram, 1024);
|
||||
state_save_register_item_pointer(type, index, cquestlin.e_stack, 32768);
|
||||
state_save_register_item_pointer(type, index, cquestlin.o_stack, 32768);
|
||||
state_save_register_item_pointer(type, device->tag, 0, cquestlin.sram, 4096);
|
||||
state_save_register_item_pointer(type, device->tag, 0, cquestlin.ptr_ram, 1024);
|
||||
state_save_register_item_pointer(type, device->tag, 0, cquestlin.e_stack, 32768);
|
||||
state_save_register_item_pointer(type, device->tag, 0, cquestlin.o_stack, 32768);
|
||||
|
||||
state_save_register_postload(Machine, cquestlin_postload, NULL);
|
||||
state_save_register_postload(device->machine, cquestlin_postload, (void *)device);
|
||||
}
|
||||
|
||||
static CPU_INIT( cquestlin )
|
||||
@ -489,7 +489,7 @@ static CPU_INIT( cquestlin )
|
||||
cquestlin.e_stack = malloc(32768 * sizeof(UINT32)); /* Stack DRAM: 32kx20 */
|
||||
cquestlin.o_stack = malloc(32768 * sizeof(UINT32)); /* Stack DRAM: 32kx20 */
|
||||
|
||||
cquestlin_state_register(index, "cquestlin");
|
||||
cquestlin_state_register(device, "cquestlin");
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -395,7 +395,7 @@ static CPU_INIT( dsp56k )
|
||||
core.reset_state = FALSE;
|
||||
|
||||
/* Save the core's state */
|
||||
// state_save_register_item("dsp56k", index, modA_state);
|
||||
// state_save_register_item("dsp56k", device->tag, 0, modA_state);
|
||||
// ...
|
||||
|
||||
//core.config = device->static_config;
|
||||
|
||||
@ -1568,15 +1568,15 @@ static void set_irq_line(int irqline, int state)
|
||||
|
||||
static void hyperstone_init(const device_config *device, int index, int clock, cpu_irq_callback irqcallback, int scale_mask)
|
||||
{
|
||||
state_save_register_item_array("E132XS", index, hyperstone.global_regs);
|
||||
state_save_register_item_array("E132XS", index, hyperstone.local_regs);
|
||||
state_save_register_item("E132XS", index, hyperstone.ppc);
|
||||
state_save_register_item("E132XS", index, hyperstone.trap_entry);
|
||||
state_save_register_item("E132XS", index, hyperstone.delay.delay_pc);
|
||||
state_save_register_item("E132XS", index, hyperstone.instruction_length);
|
||||
state_save_register_item("E132XS", index, hyperstone.intblock);
|
||||
state_save_register_item("E132XS", index, hyperstone.delay.delay_cmd);
|
||||
state_save_register_item("E132XS", index, hyperstone.tr_clocks_per_tick);
|
||||
state_save_register_item_array("E132XS", device->tag, 0, hyperstone.global_regs);
|
||||
state_save_register_item_array("E132XS", device->tag, 0, hyperstone.local_regs);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.ppc);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.trap_entry);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.delay.delay_pc);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.instruction_length);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.intblock);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.delay.delay_cmd);
|
||||
state_save_register_item("E132XS", device->tag, 0, hyperstone.tr_clocks_per_tick);
|
||||
|
||||
hyperstone.irq_callback = irqcallback;
|
||||
hyperstone.device = device;
|
||||
|
||||
@ -331,30 +331,30 @@ static CPU_INIT( g65816 )
|
||||
g65816_set_irq_callback(irqcallback);
|
||||
g65816i_cpu.device = device;
|
||||
|
||||
state_save_register_item("G65816", index, g65816i_cpu.a);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.b);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.x);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.y);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.s);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.pc);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.ppc);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.pb);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.db);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.d);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_e);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_m);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_x);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_n);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_v);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_d);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_i);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_z);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.flag_c);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.line_irq);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.line_nmi);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.ir);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.irq_delay);
|
||||
state_save_register_item("G65816", index, g65816i_cpu.stopped);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.a);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.b);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.x);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.y);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.s);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.pc);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.ppc);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.pb);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.db);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.d);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_e);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_m);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_x);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_n);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_v);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_d);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_i);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_z);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.flag_c);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.line_irq);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.line_nmi);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.ir);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.irq_delay);
|
||||
state_save_register_item("G65816", device->tag, 0, g65816i_cpu.stopped);
|
||||
|
||||
state_save_register_postload(device->machine, g65816_restore_state, NULL);
|
||||
}
|
||||
|
||||
@ -159,32 +159,32 @@ static void set_irq_line(int irqline, int state);
|
||||
/*****************************************************************************/
|
||||
static CPU_INIT( h6280 )
|
||||
{
|
||||
state_save_register_item("h6280", index, h6280.ppc.w.l);
|
||||
state_save_register_item("h6280", index, h6280.pc.w.l);
|
||||
state_save_register_item("h6280", index, h6280.sp.w.l);
|
||||
state_save_register_item("h6280", index, h6280.zp.w.l);
|
||||
state_save_register_item("h6280", index, h6280.ea.w.l);
|
||||
state_save_register_item("h6280", index, h6280.a);
|
||||
state_save_register_item("h6280", index, h6280.x);
|
||||
state_save_register_item("h6280", index, h6280.y);
|
||||
state_save_register_item("h6280", index, h6280.p);
|
||||
state_save_register_item_array("h6280", index, h6280.mmr);
|
||||
state_save_register_item("h6280", index, h6280.irq_mask);
|
||||
state_save_register_item("h6280", index, h6280.timer_status);
|
||||
state_save_register_item("h6280", index, h6280.timer_ack);
|
||||
state_save_register_item("h6280", index, h6280.clocks_per_cycle);
|
||||
state_save_register_item("h6280", index, h6280.timer_value);
|
||||
state_save_register_item("h6280", index, h6280.timer_load);
|
||||
state_save_register_item("h6280", index, h6280.nmi_state);
|
||||
state_save_register_item("h6280", index, h6280.irq_state[0]);
|
||||
state_save_register_item("h6280", index, h6280.irq_state[1]);
|
||||
state_save_register_item("h6280", index, h6280.irq_state[2]);
|
||||
state_save_register_item("h6280", index, h6280.irq_pending);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.ppc.w.l);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.pc.w.l);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.sp.w.l);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.zp.w.l);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.ea.w.l);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.a);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.x);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.y);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.p);
|
||||
state_save_register_item_array("h6280", device->tag, 0, h6280.mmr);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.irq_mask);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.timer_status);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.timer_ack);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.clocks_per_cycle);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.timer_value);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.timer_load);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.nmi_state);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.irq_state[0]);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.irq_state[1]);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.irq_state[2]);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.irq_pending);
|
||||
|
||||
#if LAZY_FLAGS
|
||||
state_save_register_item("h6280", index, h6280.NZ);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.NZ);
|
||||
#endif
|
||||
state_save_register_item("h6280", index, h6280.io_buffer);
|
||||
state_save_register_item("h6280", device->tag, 0, h6280.io_buffer);
|
||||
|
||||
h6280.irq_callback = irqcallback;
|
||||
h6280.device = device;
|
||||
|
||||
@ -326,17 +326,17 @@ static CPU_INIT( h8 )
|
||||
h8.irq_cb = irqcallback;
|
||||
h8.device = device;
|
||||
|
||||
state_save_register_item("H8/3002", index, h8.h8err);
|
||||
state_save_register_item_array("H8/3002", index, h8.regs);
|
||||
state_save_register_item("H8/3002", index, h8.pc);
|
||||
state_save_register_item("H8/3002", index, h8.ppc);
|
||||
state_save_register_item("H8/3002", index, h8.h8_IRQrequestH);
|
||||
state_save_register_item("H8/3002", index, h8.h8_IRQrequestL);
|
||||
state_save_register_item("H8/3002", index, h8.ccr);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.h8err);
|
||||
state_save_register_item_array("H8/3002", device->tag, 0, h8.regs);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.pc);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.ppc);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.h8_IRQrequestH);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.h8_IRQrequestL);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.ccr);
|
||||
|
||||
state_save_register_item_array("H8/3002", index, h8.per_regs);
|
||||
state_save_register_item("H8/3002", index, h8.h8TSTR);
|
||||
state_save_register_item_array("H8/3002", index, h8.h8TCNT);
|
||||
state_save_register_item_array("H8/3002", device->tag, 0, h8.per_regs);
|
||||
state_save_register_item("H8/3002", device->tag, 0, h8.h8TSTR);
|
||||
state_save_register_item_array("H8/3002", device->tag, 0, h8.h8TCNT);
|
||||
|
||||
state_save_register_postload(device->machine, h8_onstateload, NULL);
|
||||
|
||||
|
||||
@ -529,20 +529,20 @@ static CPU_INIT( hd6309 )
|
||||
m68_state->regTable[2] = &(B);
|
||||
m68_state->regTable[3] = &m68_state->dummy_byte;
|
||||
|
||||
state_save_register_item("hd6309", index, PC);
|
||||
state_save_register_item("hd6309", index, U);
|
||||
state_save_register_item("hd6309", index, S);
|
||||
state_save_register_item("hd6309", index, X);
|
||||
state_save_register_item("hd6309", index, Y);
|
||||
state_save_register_item("hd6309", index, V);
|
||||
state_save_register_item("hd6309", index, DP);
|
||||
state_save_register_item("hd6309", index, CC);
|
||||
state_save_register_item("hd6309", index, MD);
|
||||
state_save_register_item("hd6309", device->tag, 0, PC);
|
||||
state_save_register_item("hd6309", device->tag, 0, U);
|
||||
state_save_register_item("hd6309", device->tag, 0, S);
|
||||
state_save_register_item("hd6309", device->tag, 0, X);
|
||||
state_save_register_item("hd6309", device->tag, 0, Y);
|
||||
state_save_register_item("hd6309", device->tag, 0, V);
|
||||
state_save_register_item("hd6309", device->tag, 0, DP);
|
||||
state_save_register_item("hd6309", device->tag, 0, CC);
|
||||
state_save_register_item("hd6309", device->tag, 0, MD);
|
||||
state_save_register_postload(device->machine, hd6309_postload, (void *) device);
|
||||
state_save_register_item("hd6309", index, m68_state->int_state);
|
||||
state_save_register_item("hd6309", index, m68_state->nmi_state);
|
||||
state_save_register_item("hd6309", index, m68_state->irq_state[0]);
|
||||
state_save_register_item("hd6309", index, m68_state->irq_state[1]);
|
||||
state_save_register_item("hd6309", device->tag, 0, m68_state->int_state);
|
||||
state_save_register_item("hd6309", device->tag, 0, m68_state->nmi_state);
|
||||
state_save_register_item("hd6309", device->tag, 0, m68_state->irq_state[0]);
|
||||
state_save_register_item("hd6309", device->tag, 0, m68_state->irq_state[1]);
|
||||
}
|
||||
|
||||
/****************************************************************************/
|
||||
|
||||
@ -525,59 +525,59 @@ static CPU_INIT( i386 )
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
state_save_register_item_array(state_type, index, I.reg.d);
|
||||
state_save_register_item(state_type, index, I.sreg[ES].selector);
|
||||
state_save_register_item(state_type, index, I.sreg[ES].base);
|
||||
state_save_register_item(state_type, index, I.sreg[ES].limit);
|
||||
state_save_register_item(state_type, index, I.sreg[ES].flags);
|
||||
state_save_register_item(state_type, index, I.sreg[CS].selector);
|
||||
state_save_register_item(state_type, index, I.sreg[CS].base);
|
||||
state_save_register_item(state_type, index, I.sreg[CS].limit);
|
||||
state_save_register_item(state_type, index, I.sreg[CS].flags);
|
||||
state_save_register_item(state_type, index, I.sreg[SS].selector);
|
||||
state_save_register_item(state_type, index, I.sreg[SS].base);
|
||||
state_save_register_item(state_type, index, I.sreg[SS].limit);
|
||||
state_save_register_item(state_type, index, I.sreg[SS].flags);
|
||||
state_save_register_item(state_type, index, I.sreg[DS].selector);
|
||||
state_save_register_item(state_type, index, I.sreg[DS].base);
|
||||
state_save_register_item(state_type, index, I.sreg[DS].limit);
|
||||
state_save_register_item(state_type, index, I.sreg[DS].flags);
|
||||
state_save_register_item(state_type, index, I.sreg[FS].selector);
|
||||
state_save_register_item(state_type, index, I.sreg[FS].base);
|
||||
state_save_register_item(state_type, index, I.sreg[FS].limit);
|
||||
state_save_register_item(state_type, index, I.sreg[FS].flags);
|
||||
state_save_register_item(state_type, index, I.sreg[GS].selector);
|
||||
state_save_register_item(state_type, index, I.sreg[GS].base);
|
||||
state_save_register_item(state_type, index, I.sreg[GS].limit);
|
||||
state_save_register_item(state_type, index, I.sreg[GS].flags);
|
||||
state_save_register_item(state_type, index, I.eip);
|
||||
state_save_register_item(state_type, index, I.prev_eip);
|
||||
state_save_register_item(state_type, index, I.CF);
|
||||
state_save_register_item(state_type, index, I.DF);
|
||||
state_save_register_item(state_type, index, I.SF);
|
||||
state_save_register_item(state_type, index, I.OF);
|
||||
state_save_register_item(state_type, index, I.ZF);
|
||||
state_save_register_item(state_type, index, I.PF);
|
||||
state_save_register_item(state_type, index, I.AF);
|
||||
state_save_register_item(state_type, index, I.IF);
|
||||
state_save_register_item(state_type, index, I.TF);
|
||||
state_save_register_item_array(state_type, index, I.cr);
|
||||
state_save_register_item_array(state_type, index, I.dr);
|
||||
state_save_register_item_array(state_type, index, I.tr);
|
||||
state_save_register_item(state_type, index, I.idtr.base);
|
||||
state_save_register_item(state_type, index, I.idtr.limit);
|
||||
state_save_register_item(state_type, index, I.gdtr.base);
|
||||
state_save_register_item(state_type, index, I.gdtr.limit);
|
||||
state_save_register_item(state_type, index, I.task.base);
|
||||
state_save_register_item(state_type, index, I.task.segment);
|
||||
state_save_register_item(state_type, index, I.task.limit);
|
||||
state_save_register_item(state_type, index, I.task.flags);
|
||||
state_save_register_item(state_type, index, I.ldtr.base);
|
||||
state_save_register_item(state_type, index, I.ldtr.segment);
|
||||
state_save_register_item(state_type, index, I.ldtr.limit);
|
||||
state_save_register_item(state_type, index, I.ldtr.flags);
|
||||
state_save_register_item(state_type, index, I.irq_state);
|
||||
state_save_register_item(state_type, index, I.performed_intersegment_jump);
|
||||
state_save_register_item_array(state_type, device->tag, 0, I.reg.d);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].selector);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[ES].flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].selector);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[CS].flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].selector);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[SS].flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].selector);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[DS].flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].selector);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[FS].flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].selector);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.sreg[GS].flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.eip);
|
||||
state_save_register_item(state_type, device->tag, 0, I.prev_eip);
|
||||
state_save_register_item(state_type, device->tag, 0, I.CF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.DF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.SF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.OF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.ZF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.PF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.AF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.IF);
|
||||
state_save_register_item(state_type, device->tag, 0, I.TF);
|
||||
state_save_register_item_array(state_type, device->tag, 0, I.cr);
|
||||
state_save_register_item_array(state_type, device->tag, 0, I.dr);
|
||||
state_save_register_item_array(state_type, device->tag, 0, I.tr);
|
||||
state_save_register_item(state_type, device->tag, 0, I.idtr.base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.idtr.limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.gdtr.base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.gdtr.limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.task.base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.task.segment);
|
||||
state_save_register_item(state_type, device->tag, 0, I.task.limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.task.flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.ldtr.base);
|
||||
state_save_register_item(state_type, device->tag, 0, I.ldtr.segment);
|
||||
state_save_register_item(state_type, device->tag, 0, I.ldtr.limit);
|
||||
state_save_register_item(state_type, device->tag, 0, I.ldtr.flags);
|
||||
state_save_register_item(state_type, device->tag, 0, I.irq_state);
|
||||
state_save_register_item(state_type, device->tag, 0, I.performed_intersegment_jump);
|
||||
state_save_register_postload(device->machine, i386_postload, NULL);
|
||||
}
|
||||
|
||||
|
||||
@ -1363,21 +1363,21 @@ static CPU_INIT( i8085 )
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
state_save_register_item("i8085", index, I.AF.w.l);
|
||||
state_save_register_item("i8085", index, I.BC.w.l);
|
||||
state_save_register_item("i8085", index, I.DE.w.l);
|
||||
state_save_register_item("i8085", index, I.HL.w.l);
|
||||
state_save_register_item("i8085", index, I.SP.w.l);
|
||||
state_save_register_item("i8085", index, I.PC.w.l);
|
||||
state_save_register_item("i8085", index, I.HALT);
|
||||
state_save_register_item("i8085", index, I.IM);
|
||||
state_save_register_item("i8085", index, I.IREQ);
|
||||
state_save_register_item("i8085", index, I.ISRV);
|
||||
state_save_register_item("i8085", index, I.INTR);
|
||||
state_save_register_item("i8085", index, I.IRQ2);
|
||||
state_save_register_item("i8085", index, I.IRQ1);
|
||||
state_save_register_item("i8085", index, I.STATUS);
|
||||
state_save_register_item_array("i8085", index, I.irq_state);
|
||||
state_save_register_item("i8085", device->tag, 0, I.AF.w.l);
|
||||
state_save_register_item("i8085", device->tag, 0, I.BC.w.l);
|
||||
state_save_register_item("i8085", device->tag, 0, I.DE.w.l);
|
||||
state_save_register_item("i8085", device->tag, 0, I.HL.w.l);
|
||||
state_save_register_item("i8085", device->tag, 0, I.SP.w.l);
|
||||
state_save_register_item("i8085", device->tag, 0, I.PC.w.l);
|
||||
state_save_register_item("i8085", device->tag, 0, I.HALT);
|
||||
state_save_register_item("i8085", device->tag, 0, I.IM);
|
||||
state_save_register_item("i8085", device->tag, 0, I.IREQ);
|
||||
state_save_register_item("i8085", device->tag, 0, I.ISRV);
|
||||
state_save_register_item("i8085", device->tag, 0, I.INTR);
|
||||
state_save_register_item("i8085", device->tag, 0, I.IRQ2);
|
||||
state_save_register_item("i8085", device->tag, 0, I.IRQ1);
|
||||
state_save_register_item("i8085", device->tag, 0, I.STATUS);
|
||||
state_save_register_item_array("i8085", device->tag, 0, I.irq_state);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
@ -1600,21 +1600,21 @@ static CPU_INIT( i8080 )
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
state_save_register_item("i8080", index, I.AF.w.l);
|
||||
state_save_register_item("i8080", index, I.BC.w.l);
|
||||
state_save_register_item("i8080", index, I.DE.w.l);
|
||||
state_save_register_item("i8080", index, I.HL.w.l);
|
||||
state_save_register_item("i8080", index, I.SP.w.l);
|
||||
state_save_register_item("i8080", index, I.PC.w.l);
|
||||
state_save_register_item("i8080", index, I.HALT);
|
||||
state_save_register_item("i8085", index, I.IM);
|
||||
state_save_register_item("i8080", index, I.IREQ);
|
||||
state_save_register_item("i8080", index, I.ISRV);
|
||||
state_save_register_item("i8080", index, I.INTR);
|
||||
state_save_register_item("i8080", index, I.IRQ2);
|
||||
state_save_register_item("i8080", index, I.IRQ1);
|
||||
state_save_register_item("i8080", index, I.STATUS);
|
||||
state_save_register_item_array("i8080", index, I.irq_state);
|
||||
state_save_register_item("i8080", device->tag, 0, I.AF.w.l);
|
||||
state_save_register_item("i8080", device->tag, 0, I.BC.w.l);
|
||||
state_save_register_item("i8080", device->tag, 0, I.DE.w.l);
|
||||
state_save_register_item("i8080", device->tag, 0, I.HL.w.l);
|
||||
state_save_register_item("i8080", device->tag, 0, I.SP.w.l);
|
||||
state_save_register_item("i8080", device->tag, 0, I.PC.w.l);
|
||||
state_save_register_item("i8080", device->tag, 0, I.HALT);
|
||||
state_save_register_item("i8085", device->tag, 0, I.IM);
|
||||
state_save_register_item("i8080", device->tag, 0, I.IREQ);
|
||||
state_save_register_item("i8080", device->tag, 0, I.ISRV);
|
||||
state_save_register_item("i8080", device->tag, 0, I.INTR);
|
||||
state_save_register_item("i8080", device->tag, 0, I.IRQ2);
|
||||
state_save_register_item("i8080", device->tag, 0, I.IRQ1);
|
||||
state_save_register_item("i8080", device->tag, 0, I.STATUS);
|
||||
state_save_register_item_array("i8080", device->tag, 0, I.irq_state);
|
||||
}
|
||||
|
||||
static void i8080_set_irq_line(int irqline, int state)
|
||||
|
||||
@ -251,40 +251,40 @@ static CPU_DISASSEMBLE( i80286 )
|
||||
static CPU_INIT( i80286 )
|
||||
{
|
||||
static const char type[] = "80286";
|
||||
state_save_register_item_array(type, index, I.regs.w);
|
||||
state_save_register_item(type, index, I.amask);
|
||||
state_save_register_item(type, index, I.pc);
|
||||
state_save_register_item(type, index, I.prevpc);
|
||||
state_save_register_item(type, index, I.msw);
|
||||
state_save_register_item_array(type, index, I.base);
|
||||
state_save_register_item_array(type, index, I.sregs);
|
||||
state_save_register_item_array(type, index, I.limit);
|
||||
state_save_register_item_array(type, index, I.rights);
|
||||
state_save_register_item(type, index, I.gdtr.base);
|
||||
state_save_register_item(type, index, I.gdtr.limit);
|
||||
state_save_register_item(type, index, I.idtr.base);
|
||||
state_save_register_item(type, index, I.idtr.limit);
|
||||
state_save_register_item(type, index, I.ldtr.sel);
|
||||
state_save_register_item(type, index, I.ldtr.base);
|
||||
state_save_register_item(type, index, I.ldtr.limit);
|
||||
state_save_register_item(type, index, I.ldtr.rights);
|
||||
state_save_register_item(type, index, I.tr.sel);
|
||||
state_save_register_item(type, index, I.tr.base);
|
||||
state_save_register_item(type, index, I.tr.limit);
|
||||
state_save_register_item(type, index, I.tr.rights);
|
||||
state_save_register_item(type, index, I.AuxVal);
|
||||
state_save_register_item(type, index, I.OverVal);
|
||||
state_save_register_item(type, index, I.SignVal);
|
||||
state_save_register_item(type, index, I.ZeroVal);
|
||||
state_save_register_item(type, index, I.CarryVal);
|
||||
state_save_register_item(type, index, I.DirVal);
|
||||
state_save_register_item(type, index, I.ParityVal);
|
||||
state_save_register_item(type, index, I.TF);
|
||||
state_save_register_item(type, index, I.IF);
|
||||
state_save_register_item(type, index, I.int_vector);
|
||||
state_save_register_item(type, index, I.nmi_state);
|
||||
state_save_register_item(type, index, I.irq_state);
|
||||
state_save_register_item(type, index, I.extra_cycles);
|
||||
state_save_register_item_array(type, device->tag, 0, I.regs.w);
|
||||
state_save_register_item(type, device->tag, 0, I.amask);
|
||||
state_save_register_item(type, device->tag, 0, I.pc);
|
||||
state_save_register_item(type, device->tag, 0, I.prevpc);
|
||||
state_save_register_item(type, device->tag, 0, I.msw);
|
||||
state_save_register_item_array(type, device->tag, 0, I.base);
|
||||
state_save_register_item_array(type, device->tag, 0, I.sregs);
|
||||
state_save_register_item_array(type, device->tag, 0, I.limit);
|
||||
state_save_register_item_array(type, device->tag, 0, I.rights);
|
||||
state_save_register_item(type, device->tag, 0, I.gdtr.base);
|
||||
state_save_register_item(type, device->tag, 0, I.gdtr.limit);
|
||||
state_save_register_item(type, device->tag, 0, I.idtr.base);
|
||||
state_save_register_item(type, device->tag, 0, I.idtr.limit);
|
||||
state_save_register_item(type, device->tag, 0, I.ldtr.sel);
|
||||
state_save_register_item(type, device->tag, 0, I.ldtr.base);
|
||||
state_save_register_item(type, device->tag, 0, I.ldtr.limit);
|
||||
state_save_register_item(type, device->tag, 0, I.ldtr.rights);
|
||||
state_save_register_item(type, device->tag, 0, I.tr.sel);
|
||||
state_save_register_item(type, device->tag, 0, I.tr.base);
|
||||
state_save_register_item(type, device->tag, 0, I.tr.limit);
|
||||
state_save_register_item(type, device->tag, 0, I.tr.rights);
|
||||
state_save_register_item(type, device->tag, 0, I.AuxVal);
|
||||
state_save_register_item(type, device->tag, 0, I.OverVal);
|
||||
state_save_register_item(type, device->tag, 0, I.SignVal);
|
||||
state_save_register_item(type, device->tag, 0, I.ZeroVal);
|
||||
state_save_register_item(type, device->tag, 0, I.CarryVal);
|
||||
state_save_register_item(type, device->tag, 0, I.DirVal);
|
||||
state_save_register_item(type, device->tag, 0, I.ParityVal);
|
||||
state_save_register_item(type, device->tag, 0, I.TF);
|
||||
state_save_register_item(type, device->tag, 0, I.IF);
|
||||
state_save_register_item(type, device->tag, 0, I.int_vector);
|
||||
state_save_register_item(type, device->tag, 0, I.nmi_state);
|
||||
state_save_register_item(type, device->tag, 0, I.irq_state);
|
||||
state_save_register_item(type, device->tag, 0, I.extra_cycles);
|
||||
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
@ -90,30 +90,30 @@ static struct i80x86_timing timing;
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
static void i8086_state_register(int index)
|
||||
static void i8086_state_register(const device_config *device)
|
||||
{
|
||||
static const char type[] = "I8086";
|
||||
state_save_register_item_array(type, index, I.regs.w);
|
||||
state_save_register_item(type, index, I.pc);
|
||||
state_save_register_item(type, index, I.prevpc);
|
||||
state_save_register_item_array(type, index, I.base);
|
||||
state_save_register_item_array(type, index, I.sregs);
|
||||
state_save_register_item(type, index, I.flags);
|
||||
state_save_register_item(type, index, I.AuxVal);
|
||||
state_save_register_item(type, index, I.OverVal);
|
||||
state_save_register_item(type, index, I.SignVal);
|
||||
state_save_register_item(type, index, I.ZeroVal);
|
||||
state_save_register_item(type, index, I.CarryVal);
|
||||
state_save_register_item(type, index, I.DirVal);
|
||||
state_save_register_item(type, index, I.ParityVal);
|
||||
state_save_register_item(type, index, I.TF);
|
||||
state_save_register_item(type, index, I.IF);
|
||||
state_save_register_item(type, index, I.MF);
|
||||
state_save_register_item(type, index, I.int_vector);
|
||||
state_save_register_item(type, index, I.nmi_state);
|
||||
state_save_register_item(type, index, I.irq_state);
|
||||
state_save_register_item(type, index, I.extra_cycles);
|
||||
state_save_register_item(type, index, I.test_state); /* PJB 03/05 */
|
||||
state_save_register_item_array(type, device->tag, 0, I.regs.w);
|
||||
state_save_register_item(type, device->tag, 0, I.pc);
|
||||
state_save_register_item(type, device->tag, 0, I.prevpc);
|
||||
state_save_register_item_array(type, device->tag, 0, I.base);
|
||||
state_save_register_item_array(type, device->tag, 0, I.sregs);
|
||||
state_save_register_item(type, device->tag, 0, I.flags);
|
||||
state_save_register_item(type, device->tag, 0, I.AuxVal);
|
||||
state_save_register_item(type, device->tag, 0, I.OverVal);
|
||||
state_save_register_item(type, device->tag, 0, I.SignVal);
|
||||
state_save_register_item(type, device->tag, 0, I.ZeroVal);
|
||||
state_save_register_item(type, device->tag, 0, I.CarryVal);
|
||||
state_save_register_item(type, device->tag, 0, I.DirVal);
|
||||
state_save_register_item(type, device->tag, 0, I.ParityVal);
|
||||
state_save_register_item(type, device->tag, 0, I.TF);
|
||||
state_save_register_item(type, device->tag, 0, I.IF);
|
||||
state_save_register_item(type, device->tag, 0, I.MF);
|
||||
state_save_register_item(type, device->tag, 0, I.int_vector);
|
||||
state_save_register_item(type, device->tag, 0, I.nmi_state);
|
||||
state_save_register_item(type, device->tag, 0, I.irq_state);
|
||||
state_save_register_item(type, device->tag, 0, I.extra_cycles);
|
||||
state_save_register_item(type, device->tag, 0, I.test_state); /* PJB 03/05 */
|
||||
}
|
||||
|
||||
static CPU_INIT( i8086 )
|
||||
@ -144,7 +144,7 @@ static CPU_INIT( i8086 )
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
i8086_state_register(index);
|
||||
i8086_state_register(device);
|
||||
configure_memory_16bit();
|
||||
}
|
||||
|
||||
|
||||
@ -842,21 +842,21 @@ static CPU_INIT( i8x41 )
|
||||
upi41_state->subtype = 8041;
|
||||
upi41_state->ram_mask = I8X41_intRAM_MASK;
|
||||
|
||||
state_save_register_item("i8x41", index, upi41_state->ppc);
|
||||
state_save_register_item("i8x41", index, upi41_state->pc);
|
||||
state_save_register_item("i8x41", index, upi41_state->timer);
|
||||
state_save_register_item("i8x41", index, upi41_state->prescaler);
|
||||
state_save_register_item("i8x41", index, upi41_state->subtype);
|
||||
state_save_register_item("i8x41", index, upi41_state->a);
|
||||
state_save_register_item("i8x41", index, upi41_state->psw);
|
||||
state_save_register_item("i8x41", index, upi41_state->state);
|
||||
state_save_register_item("i8x41", index, upi41_state->enable);
|
||||
state_save_register_item("i8x41", index, upi41_state->control);
|
||||
state_save_register_item("i8x41", index, upi41_state->dbbi);
|
||||
state_save_register_item("i8x41", index, upi41_state->dbbo);
|
||||
state_save_register_item("i8x41", index, upi41_state->p1);
|
||||
state_save_register_item("i8x41", index, upi41_state->p2);
|
||||
state_save_register_item("i8x41", index, upi41_state->p2_hs);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->ppc);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->pc);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->timer);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->prescaler);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->subtype);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->a);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->psw);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->state);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->enable);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->control);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->dbbi);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->dbbo);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->p1);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->p2);
|
||||
state_save_register_item("i8x41", device->tag, 0, upi41_state->p2_hs);
|
||||
}
|
||||
|
||||
static CPU_INIT( i8042 )
|
||||
|
||||
@ -2075,16 +2075,16 @@ static CPU_INIT( i960 )
|
||||
i960_state->irq_cb = irqcallback;
|
||||
i960_state->device = device;
|
||||
|
||||
state_save_register_item("i960", index, i960_state->PIP);
|
||||
state_save_register_item("i960", index, i960_state->SAT);
|
||||
state_save_register_item("i960", index, i960_state->PRCB);
|
||||
state_save_register_item("i960", index, i960_state->PC);
|
||||
state_save_register_item("i960", index, i960_state->AC);
|
||||
state_save_register_item("i960", index, i960_state->ICR);
|
||||
state_save_register_item_array("i960", index, i960_state->r);
|
||||
state_save_register_item_array("i960", index, i960_state->fp);
|
||||
state_save_register_item_2d_array("i960", index, i960_state->rcache);
|
||||
state_save_register_item_array("i960", index, i960_state->rcache_frame_addr);
|
||||
state_save_register_item("i960", device->tag, 0, i960_state->PIP);
|
||||
state_save_register_item("i960", device->tag, 0, i960_state->SAT);
|
||||
state_save_register_item("i960", device->tag, 0, i960_state->PRCB);
|
||||
state_save_register_item("i960", device->tag, 0, i960_state->PC);
|
||||
state_save_register_item("i960", device->tag, 0, i960_state->AC);
|
||||
state_save_register_item("i960", device->tag, 0, i960_state->ICR);
|
||||
state_save_register_item_array("i960", device->tag, 0, i960_state->r);
|
||||
state_save_register_item_array("i960", device->tag, 0, i960_state->fp);
|
||||
state_save_register_item_2d_array("i960", device->tag, 0, i960_state->rcache);
|
||||
state_save_register_item_array("i960", device->tag, 0, i960_state->rcache_frame_addr);
|
||||
}
|
||||
|
||||
static CPU_DISASSEMBLE( i960 )
|
||||
|
||||
@ -423,13 +423,13 @@ static STATE_POSTLOAD( jaguar_postload )
|
||||
check_irqs();
|
||||
}
|
||||
|
||||
static void jaguar_state_register(int index, const char *type)
|
||||
static void jaguar_state_register(const device_config *device, const char *type)
|
||||
{
|
||||
state_save_register_item_array(type, index, jaguar.r);
|
||||
state_save_register_item_array(type, index, jaguar.a);
|
||||
state_save_register_item_array(type, index, jaguar.ctrl);
|
||||
state_save_register_item(type, index, jaguar.ppc);
|
||||
state_save_register_postload(Machine, jaguar_postload, NULL);
|
||||
state_save_register_item_array(type, device->tag, 0, jaguar.r);
|
||||
state_save_register_item_array(type, device->tag, 0, jaguar.a);
|
||||
state_save_register_item_array(type, device->tag, 0, jaguar.ctrl);
|
||||
state_save_register_item(type, device->tag, 0, jaguar.ppc);
|
||||
state_save_register_postload(device->machine, jaguar_postload, NULL);
|
||||
}
|
||||
|
||||
static CPU_INIT( jaguargpu )
|
||||
@ -438,7 +438,7 @@ static CPU_INIT( jaguargpu )
|
||||
|
||||
memset(&jaguar, 0, sizeof(jaguar));
|
||||
|
||||
jaguar_state_register(index, "jaguargpu");
|
||||
jaguar_state_register(device, "jaguargpu");
|
||||
|
||||
jaguar.irq_callback = irqcallback;
|
||||
jaguar.device = device;
|
||||
@ -452,7 +452,7 @@ static CPU_INIT( jaguardsp )
|
||||
|
||||
memset(&jaguar, 0, sizeof(jaguar));
|
||||
|
||||
jaguar_state_register(index, "jaguardsp");
|
||||
jaguar_state_register(device, "jaguardsp");
|
||||
|
||||
jaguar.irq_callback = irqcallback;
|
||||
jaguar.device = device;
|
||||
|
||||
@ -393,18 +393,18 @@ static CPU_INIT( konami )
|
||||
konami.irq_callback = irqcallback;
|
||||
konami.device = device;
|
||||
|
||||
state_save_register_item("KONAMI", index, PC);
|
||||
state_save_register_item("KONAMI", index, U);
|
||||
state_save_register_item("KONAMI", index, S);
|
||||
state_save_register_item("KONAMI", index, X);
|
||||
state_save_register_item("KONAMI", index, Y);
|
||||
state_save_register_item("KONAMI", index, D);
|
||||
state_save_register_item("KONAMI", index, DP);
|
||||
state_save_register_item("KONAMI", index, CC);
|
||||
state_save_register_item("KONAMI", index, konami.int_state);
|
||||
state_save_register_item("KONAMI", index, konami.nmi_state);
|
||||
state_save_register_item("KONAMI", index, konami.irq_state[0]);
|
||||
state_save_register_item("KONAMI", index, konami.irq_state[1]);
|
||||
state_save_register_item("KONAMI", device->tag, 0, PC);
|
||||
state_save_register_item("KONAMI", device->tag, 0, U);
|
||||
state_save_register_item("KONAMI", device->tag, 0, S);
|
||||
state_save_register_item("KONAMI", device->tag, 0, X);
|
||||
state_save_register_item("KONAMI", device->tag, 0, Y);
|
||||
state_save_register_item("KONAMI", device->tag, 0, D);
|
||||
state_save_register_item("KONAMI", device->tag, 0, DP);
|
||||
state_save_register_item("KONAMI", device->tag, 0, CC);
|
||||
state_save_register_item("KONAMI", device->tag, 0, konami.int_state);
|
||||
state_save_register_item("KONAMI", device->tag, 0, konami.nmi_state);
|
||||
state_save_register_item("KONAMI", device->tag, 0, konami.irq_state[0]);
|
||||
state_save_register_item("KONAMI", device->tag, 0, konami.irq_state[1]);
|
||||
}
|
||||
|
||||
static CPU_RESET( konami )
|
||||
|
||||
@ -992,54 +992,54 @@ static CPU_INIT( m37710 )
|
||||
for (i=0; i<8; i++)
|
||||
m37710i_cpu.timers[i] = timer_alloc(m37710_timer_cb, (void*)(FPTR)i);
|
||||
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.a);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.b);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.ba);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.bb);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.x);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.y);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.s);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.pc);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.ppc);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.pb);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.db);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.d);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_e);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_m);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_x);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_n);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_v);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_d);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_i);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_z);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.flag_c);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.line_irq);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.ipl);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.ir);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.im);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.im2);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.im3);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.im4);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.irq_delay);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.irq_level);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.stopped);
|
||||
state_save_register_item_array("M377xx", index, m37710i_cpu.m37710_regs);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[0].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[0].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[1].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[1].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[2].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[2].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[3].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[3].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[4].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[4].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[5].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[5].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[6].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[6].attoseconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[7].seconds);
|
||||
state_save_register_item("M377xx", index, m37710i_cpu.reload[7].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.a);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.b);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.ba);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.bb);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.x);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.y);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.s);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.pc);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.ppc);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.pb);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.db);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.d);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_e);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_m);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_x);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_n);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_v);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_d);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_i);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_z);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.flag_c);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.line_irq);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.ipl);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.ir);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.im);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.im2);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.im3);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.im4);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.irq_delay);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.irq_level);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.stopped);
|
||||
state_save_register_item_array("M377xx", device->tag, 0, m37710i_cpu.m37710_regs);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[0].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[0].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[1].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[1].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[2].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[2].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[3].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[3].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[4].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[4].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[5].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[5].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[6].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[6].attoseconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[7].seconds);
|
||||
state_save_register_item("M377xx", device->tag, 0, m37710i_cpu.reload[7].attoseconds);
|
||||
|
||||
state_save_register_postload(device->machine, m37710_restore_state, NULL);
|
||||
}
|
||||
|
||||
@ -147,23 +147,23 @@ static void m6502_common_init(const device_config *device, int index, int clock,
|
||||
m6502->rdmem_id = default_rdmem_id;
|
||||
m6502->wrmem_id = default_wdmem_id;
|
||||
|
||||
state_save_register_item(type, index, m6502->pc.w.l);
|
||||
state_save_register_item(type, index, m6502->sp.w.l);
|
||||
state_save_register_item(type, index, m6502->p);
|
||||
state_save_register_item(type, index, m6502->a);
|
||||
state_save_register_item(type, index, m6502->x);
|
||||
state_save_register_item(type, index, m6502->y);
|
||||
state_save_register_item(type, index, m6502->pending_irq);
|
||||
state_save_register_item(type, index, m6502->after_cli);
|
||||
state_save_register_item(type, index, m6502->nmi_state);
|
||||
state_save_register_item(type, index, m6502->irq_state);
|
||||
state_save_register_item(type, index, m6502->so_state);
|
||||
state_save_register_item(type, device->tag, 0, m6502->pc.w.l);
|
||||
state_save_register_item(type, device->tag, 0, m6502->sp.w.l);
|
||||
state_save_register_item(type, device->tag, 0, m6502->p);
|
||||
state_save_register_item(type, device->tag, 0, m6502->a);
|
||||
state_save_register_item(type, device->tag, 0, m6502->x);
|
||||
state_save_register_item(type, device->tag, 0, m6502->y);
|
||||
state_save_register_item(type, device->tag, 0, m6502->pending_irq);
|
||||
state_save_register_item(type, device->tag, 0, m6502->after_cli);
|
||||
state_save_register_item(type, device->tag, 0, m6502->nmi_state);
|
||||
state_save_register_item(type, device->tag, 0, m6502->irq_state);
|
||||
state_save_register_item(type, device->tag, 0, m6502->so_state);
|
||||
|
||||
#if (HAS_M6510) || (HAS_M6510T) || (HAS_M8502) || (HAS_M7501)
|
||||
if (subtype == SUBTYPE_6510)
|
||||
{
|
||||
state_save_register_item(type, index, m6502->port);
|
||||
state_save_register_item(type, index, m6502->ddr);
|
||||
state_save_register_item(type, device->tag, 0, m6502->port);
|
||||
state_save_register_item(type, device->tag, 0, m6502->ddr);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -838,49 +838,49 @@ static TIMER_CALLBACK(m6800_rx_tick)
|
||||
/****************************************************************************
|
||||
* Reset registers to their initial values
|
||||
****************************************************************************/
|
||||
static void state_register(m68_state_t *m68_state, const char *type, int index)
|
||||
static void state_register(m68_state_t *m68_state, const char *type)
|
||||
{
|
||||
state_save_register_item(type, index, m68_state->ppc.w.l);
|
||||
state_save_register_item(type, index, m68_state->pc.w.l);
|
||||
state_save_register_item(type, index, m68_state->s.w.l);
|
||||
state_save_register_item(type, index, m68_state->x.w.l);
|
||||
state_save_register_item(type, index, m68_state->d.w.l);
|
||||
state_save_register_item(type, index, m68_state->cc);
|
||||
state_save_register_item(type, index, m68_state->wai_state);
|
||||
state_save_register_item(type, index, m68_state->nmi_state);
|
||||
state_save_register_item_array(type, index, m68_state->irq_state);
|
||||
state_save_register_item(type, index, m68_state->ic_eddge);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->ppc.w.l);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->pc.w.l);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->s.w.l);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->x.w.l);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->d.w.l);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->cc);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->wai_state);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->nmi_state);
|
||||
state_save_register_item_array(type, m68_state->device->tag, 0, m68_state->irq_state);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->ic_eddge);
|
||||
|
||||
state_save_register_item(type, index, m68_state->port1_ddr);
|
||||
state_save_register_item(type, index, m68_state->port2_ddr);
|
||||
state_save_register_item(type, index, m68_state->port3_ddr);
|
||||
state_save_register_item(type, index, m68_state->port4_ddr);
|
||||
state_save_register_item(type, index, m68_state->port1_data);
|
||||
state_save_register_item(type, index, m68_state->port2_data);
|
||||
state_save_register_item(type, index, m68_state->port3_data);
|
||||
state_save_register_item(type, index, m68_state->port4_data);
|
||||
state_save_register_item(type, index, m68_state->tcsr);
|
||||
state_save_register_item(type, index, m68_state->pending_tcsr);
|
||||
state_save_register_item(type, index, m68_state->irq2);
|
||||
state_save_register_item(type, index, m68_state->ram_ctrl);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port1_ddr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port2_ddr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port3_ddr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port4_ddr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port1_data);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port2_data);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port3_data);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->port4_data);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tcsr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->pending_tcsr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->irq2);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->ram_ctrl);
|
||||
|
||||
state_save_register_item(type, index, m68_state->counter.d);
|
||||
state_save_register_item(type, index, m68_state->output_compare.d);
|
||||
state_save_register_item(type, index, m68_state->input_capture);
|
||||
state_save_register_item(type, index, m68_state->timer_over.d);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->counter.d);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->output_compare.d);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->input_capture);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->timer_over.d);
|
||||
|
||||
state_save_register_item(type, index, m68_state->clock);
|
||||
state_save_register_item(type, index, m68_state->trcsr);
|
||||
state_save_register_item(type, index, m68_state->rmcr);
|
||||
state_save_register_item(type, index, m68_state->rdr);
|
||||
state_save_register_item(type, index, m68_state->tdr);
|
||||
state_save_register_item(type, index, m68_state->rsr);
|
||||
state_save_register_item(type, index, m68_state->tsr);
|
||||
state_save_register_item(type, index, m68_state->rxbits);
|
||||
state_save_register_item(type, index, m68_state->txbits);
|
||||
state_save_register_item(type, index, m68_state->txstate);
|
||||
state_save_register_item(type, index, m68_state->trcsr_read);
|
||||
state_save_register_item(type, index, m68_state->tx);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->clock);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->trcsr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rmcr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rdr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tdr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rsr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tsr);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->rxbits);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->txbits);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->txstate);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->trcsr_read);
|
||||
state_save_register_item(type, m68_state->device->tag, 0, m68_state->tx);
|
||||
}
|
||||
|
||||
static CPU_INIT( m6800 )
|
||||
@ -891,7 +891,7 @@ static CPU_INIT( m6800 )
|
||||
m68_state->cycles = cycles_6800;
|
||||
m68_state->irq_callback = irqcallback;
|
||||
m68_state->device = device;
|
||||
state_register(m68_state, "m6800", index);
|
||||
state_register(m68_state, "m6800");
|
||||
}
|
||||
|
||||
static CPU_RESET( m6800 )
|
||||
@ -1321,7 +1321,7 @@ static CPU_INIT( m6801 )
|
||||
m68_state->m6800_rx_timer = timer_alloc(m6800_rx_tick, m68_state);
|
||||
m68_state->m6800_tx_timer = timer_alloc(m6800_tx_tick, m68_state);
|
||||
|
||||
state_register(m68_state, "m6801", index);
|
||||
state_register(m68_state, "m6801");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1337,7 +1337,7 @@ static CPU_INIT( m6802 )
|
||||
m68_state->cycles = cycles_6800;
|
||||
m68_state->irq_callback = irqcallback;
|
||||
m68_state->device = device;
|
||||
state_register(m68_state, "m6802", index);
|
||||
state_register(m68_state, "m6802");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1358,7 +1358,7 @@ static CPU_INIT( m6803 )
|
||||
m68_state->m6800_rx_timer = timer_alloc(m6800_rx_tick, m68_state);
|
||||
m68_state->m6800_tx_timer = timer_alloc(m6800_tx_tick, m68_state);
|
||||
|
||||
state_register(m68_state, "m6803", index);
|
||||
state_register(m68_state, "m6803");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1692,7 +1692,7 @@ static CPU_INIT( m6808 )
|
||||
m68_state->cycles = cycles_6800;
|
||||
m68_state->irq_callback = irqcallback;
|
||||
m68_state->device = device;
|
||||
state_register(m68_state, "m6808", index);
|
||||
state_register(m68_state, "m6808");
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1714,7 +1714,7 @@ static CPU_INIT( hd63701 )
|
||||
m68_state->m6800_rx_timer = timer_alloc(m6800_rx_tick, m68_state);
|
||||
m68_state->m6800_tx_timer = timer_alloc(m6800_tx_tick, m68_state);
|
||||
|
||||
state_register(m68_state, "hd63701", index);
|
||||
state_register(m68_state, "hd63701");
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
@ -2059,7 +2059,7 @@ static CPU_INIT( nsc8105 )
|
||||
// m68_state->subtype = SUBTYPE_NSC8105;
|
||||
m68_state->insn = nsc8105_insn;
|
||||
m68_state->cycles = cycles_nsc8105;
|
||||
state_register(m68_state, "nsc8105", index);
|
||||
state_register(m68_state, "nsc8105");
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
|
||||
@ -226,7 +226,7 @@ unsigned int m68k_get_context(void* dst);
|
||||
void m68k_set_context(void* dst);
|
||||
|
||||
/* Register the CPU state information */
|
||||
void m68k_state_register(m68ki_cpu_core *m68k, const char *type, int index);
|
||||
void m68k_state_register(m68ki_cpu_core *m68k, const char *type);
|
||||
|
||||
|
||||
/* Peek at the internals of a CPU context. This can either be a context
|
||||
|
||||
@ -941,28 +941,28 @@ static void m68k_post_load(running_machine *machine, void *param)
|
||||
m68ki_jump(m68k, REG_PC);
|
||||
}
|
||||
|
||||
void m68k_state_register(m68ki_cpu_core *m68k, const char *type, int index)
|
||||
void m68k_state_register(m68ki_cpu_core *m68k, const char *type)
|
||||
{
|
||||
/* Note, D covers A because the dar array is common, REG_A=REG_D+8 */
|
||||
state_save_register_item_array(type, index, REG_D);
|
||||
state_save_register_item(type, index, REG_PPC);
|
||||
state_save_register_item(type, index, REG_PC);
|
||||
state_save_register_item(type, index, REG_USP);
|
||||
state_save_register_item(type, index, REG_ISP);
|
||||
state_save_register_item(type, index, REG_MSP);
|
||||
state_save_register_item(type, index, m68k->vbr);
|
||||
state_save_register_item(type, index, m68k->sfc);
|
||||
state_save_register_item(type, index, m68k->dfc);
|
||||
state_save_register_item(type, index, m68k->cacr);
|
||||
state_save_register_item(type, index, m68k->caar);
|
||||
state_save_register_item(type, index, m68k_substate.sr);
|
||||
state_save_register_item(type, index, m68k->int_level);
|
||||
state_save_register_item(type, index, m68k_substate.stopped);
|
||||
state_save_register_item(type, index, m68k_substate.halted);
|
||||
state_save_register_item(type, index, m68k->pref_addr);
|
||||
state_save_register_item(type, index, m68k->pref_data);
|
||||
state_save_register_presave(Machine, m68k_prepare_substate, m68k);
|
||||
state_save_register_postload(Machine, m68k_post_load, m68k);
|
||||
state_save_register_item_array(type, m68k->device->tag, 0, REG_D);
|
||||
state_save_register_item(type, m68k->device->tag, 0, REG_PPC);
|
||||
state_save_register_item(type, m68k->device->tag, 0, REG_PC);
|
||||
state_save_register_item(type, m68k->device->tag, 0, REG_USP);
|
||||
state_save_register_item(type, m68k->device->tag, 0, REG_ISP);
|
||||
state_save_register_item(type, m68k->device->tag, 0, REG_MSP);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->vbr);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->sfc);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->dfc);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->cacr);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->caar);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k_substate.sr);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->int_level);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k_substate.stopped);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k_substate.halted);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->pref_addr);
|
||||
state_save_register_item(type, m68k->device->tag, 0, m68k->pref_data);
|
||||
state_save_register_presave(m68k->device->machine, m68k_prepare_substate, m68k);
|
||||
state_save_register_postload(m68k->device->machine, m68k_post_load, m68k);
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
|
||||
@ -161,7 +161,7 @@ static CPU_INIT( m68000 )
|
||||
m68k->memory = interface_d16;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68000);
|
||||
m68k_state_register(m68k, "m68000", index);
|
||||
m68k_state_register(m68k, "m68000");
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
|
||||
@ -206,7 +206,7 @@ static CPU_INIT( m68008 )
|
||||
m68k->memory = interface_d8;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68008);
|
||||
m68k_state_register(m68k, "m68008", index);
|
||||
m68k_state_register(m68k, "m68008");
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, irqcallback);
|
||||
}
|
||||
|
||||
@ -253,7 +253,7 @@ static CPU_INIT( m68010 )
|
||||
m68k->memory = interface_d16;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68010);
|
||||
m68k_state_register(m68k, "m68010", index);
|
||||
m68k_state_register(m68k, "m68010");
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
|
||||
@ -276,7 +276,7 @@ static CPU_INIT( m68020 )
|
||||
m68k->memory = interface_d32;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68020);
|
||||
m68k_state_register(m68k, "m68020", index);
|
||||
m68k_state_register(m68k, "m68020");
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
|
||||
@ -322,7 +322,7 @@ static CPU_INIT( m68ec020 )
|
||||
m68k->memory = interface_d32;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68EC020);
|
||||
m68k_state_register(m68k, "m68ec020", index);
|
||||
m68k_state_register(m68k, "m68ec020");
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
|
||||
@ -346,7 +346,7 @@ static CPU_INIT( m68040 )
|
||||
m68k->memory = interface_d32;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68040);
|
||||
m68k_state_register(m68k, "m68040", index);
|
||||
m68k_state_register(m68k, "m68040");
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
|
||||
|
||||
@ -429,20 +429,20 @@ static void Interrupt(void)
|
||||
}
|
||||
}
|
||||
|
||||
static void state_register(const char *type, int index)
|
||||
static void state_register(const char *type, const device_config *device)
|
||||
{
|
||||
state_save_register_item(type, index, A);
|
||||
state_save_register_item(type, index, PC);
|
||||
state_save_register_item(type, index, S);
|
||||
state_save_register_item(type, index, X);
|
||||
state_save_register_item(type, index, CC);
|
||||
state_save_register_item(type, index, m6805.pending_interrupts);
|
||||
state_save_register_item_array(type, index, m6805.irq_state);
|
||||
state_save_register_item(type, device->tag, 0, A);
|
||||
state_save_register_item(type, device->tag, 0, PC);
|
||||
state_save_register_item(type, device->tag, 0, S);
|
||||
state_save_register_item(type, device->tag, 0, X);
|
||||
state_save_register_item(type, device->tag, 0, CC);
|
||||
state_save_register_item(type, device->tag, 0, m6805.pending_interrupts);
|
||||
state_save_register_item_array(type, device->tag, 0, m6805.irq_state);
|
||||
}
|
||||
|
||||
static CPU_INIT( m6805 )
|
||||
{
|
||||
state_register("m6805", index);
|
||||
state_register("m6805", device);
|
||||
m6805.irq_callback = irqcallback;
|
||||
m6805.device = device;
|
||||
}
|
||||
@ -808,7 +808,7 @@ static CPU_EXECUTE( m6805 )
|
||||
#if (HAS_M68705)
|
||||
static CPU_INIT( m68705 )
|
||||
{
|
||||
state_register("m68705", index);
|
||||
state_register("m68705", device);
|
||||
m6805.irq_callback = irqcallback;
|
||||
m6805.device = device;
|
||||
}
|
||||
@ -836,7 +836,7 @@ static void m68705_set_irq_line(int irqline, int state)
|
||||
#if (HAS_HD63705)
|
||||
static CPU_INIT( hd63705 )
|
||||
{
|
||||
state_register("hd63705", index);
|
||||
state_register("hd63705", device);
|
||||
m6805.irq_callback = irqcallback;
|
||||
m6805.device = device;
|
||||
}
|
||||
|
||||
@ -374,18 +374,18 @@ static CPU_INIT( m6809 )
|
||||
m68_state->irq_callback = irqcallback;
|
||||
m68_state->device = device;
|
||||
|
||||
state_save_register_item("m6809", index, PC);
|
||||
state_save_register_item("m6809", index, PPC);
|
||||
state_save_register_item("m6809", index, D);
|
||||
state_save_register_item("m6809", index, DP);
|
||||
state_save_register_item("m6809", index, U);
|
||||
state_save_register_item("m6809", index, S);
|
||||
state_save_register_item("m6809", index, X);
|
||||
state_save_register_item("m6809", index, Y);
|
||||
state_save_register_item("m6809", index, CC);
|
||||
state_save_register_item_array("m6809", index, m68_state->irq_state);
|
||||
state_save_register_item("m6809", index, m68_state->int_state);
|
||||
state_save_register_item("m6809", index, m68_state->nmi_state);
|
||||
state_save_register_item("m6809", device->tag, 0, PC);
|
||||
state_save_register_item("m6809", device->tag, 0, PPC);
|
||||
state_save_register_item("m6809", device->tag, 0, D);
|
||||
state_save_register_item("m6809", device->tag, 0, DP);
|
||||
state_save_register_item("m6809", device->tag, 0, U);
|
||||
state_save_register_item("m6809", device->tag, 0, S);
|
||||
state_save_register_item("m6809", device->tag, 0, X);
|
||||
state_save_register_item("m6809", device->tag, 0, Y);
|
||||
state_save_register_item("m6809", device->tag, 0, CC);
|
||||
state_save_register_item_array("m6809", device->tag, 0, m68_state->irq_state);
|
||||
state_save_register_item("m6809", device->tag, 0, m68_state->int_state);
|
||||
state_save_register_item("m6809", device->tag, 0, m68_state->nmi_state);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -129,27 +129,27 @@ static CPU_INIT( mb88 )
|
||||
mb88.irqcallback = irqcallback;
|
||||
mb88.device = device;
|
||||
|
||||
state_save_register_item("mb88", clock, mb88.PC);
|
||||
state_save_register_item("mb88", clock, mb88.PA);
|
||||
state_save_register_item("mb88", clock, mb88.SP[0]);
|
||||
state_save_register_item("mb88", clock, mb88.SP[1]);
|
||||
state_save_register_item("mb88", clock, mb88.SP[2]);
|
||||
state_save_register_item("mb88", clock, mb88.SP[3]);
|
||||
state_save_register_item("mb88", clock, mb88.SI);
|
||||
state_save_register_item("mb88", clock, mb88.A);
|
||||
state_save_register_item("mb88", clock, mb88.X);
|
||||
state_save_register_item("mb88", clock, mb88.Y);
|
||||
state_save_register_item("mb88", clock, mb88.st);
|
||||
state_save_register_item("mb88", clock, mb88.zf);
|
||||
state_save_register_item("mb88", clock, mb88.cf);
|
||||
state_save_register_item("mb88", clock, mb88.vf);
|
||||
state_save_register_item("mb88", clock, mb88.sf);
|
||||
state_save_register_item("mb88", clock, mb88.nf);
|
||||
state_save_register_item("mb88", clock, mb88.pio);
|
||||
state_save_register_item("mb88", clock, mb88.TH);
|
||||
state_save_register_item("mb88", clock, mb88.TL);
|
||||
state_save_register_item("mb88", clock, mb88.SB);
|
||||
state_save_register_item("mb88", clock, mb88.pending_interrupt);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.PC);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.PA);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.SP[0]);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.SP[1]);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.SP[2]);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.SP[3]);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.SI);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.A);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.X);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.Y);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.st);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.zf);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.cf);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.vf);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.sf);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.nf);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.pio);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.TH);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.TL);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.SB);
|
||||
state_save_register_item("mb88", device->tag, 0, mb88.pending_interrupt);
|
||||
}
|
||||
|
||||
static CPU_RESET( mb88 )
|
||||
|
||||
@ -708,25 +708,25 @@ static void mcs48_init(const device_config *device, int index, int clock, cpu_ir
|
||||
mcs48->device = device;
|
||||
mcs48->int_rom_size = romsize;
|
||||
|
||||
state_save_register_item("mcs48", index, mcs48->prevpc.w.l);
|
||||
state_save_register_item("mcs48", index, PC);
|
||||
state_save_register_item("mcs48", index, A);
|
||||
state_save_register_item("mcs48", index, PSW);
|
||||
state_save_register_item("mcs48", index, mcs48->p1);
|
||||
state_save_register_item("mcs48", index, mcs48->p2);
|
||||
state_save_register_item("mcs48", index, mcs48->f1);
|
||||
state_save_register_item("mcs48", index, mcs48->ea);
|
||||
state_save_register_item("mcs48", index, mcs48->timer);
|
||||
state_save_register_item("mcs48", index, mcs48->prescaler);
|
||||
state_save_register_item("mcs48", index, mcs48->t1_history);
|
||||
state_save_register_item("mcs48", index, mcs48->irq_state);
|
||||
state_save_register_item("mcs48", index, mcs48->irq_in_progress);
|
||||
state_save_register_item("mcs48", index, mcs48->timer_overflow);
|
||||
state_save_register_item("mcs48", index, mcs48->timer_flag);
|
||||
state_save_register_item("mcs48", index, mcs48->tirq_enabled);
|
||||
state_save_register_item("mcs48", index, mcs48->xirq_enabled);
|
||||
state_save_register_item("mcs48", index, mcs48->timecount_enabled);
|
||||
state_save_register_item("mcs48", index, mcs48->a11);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->prevpc.w.l);
|
||||
state_save_register_item("mcs48", device->tag, 0, PC);
|
||||
state_save_register_item("mcs48", device->tag, 0, A);
|
||||
state_save_register_item("mcs48", device->tag, 0, PSW);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->p1);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->p2);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->f1);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->ea);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->timer);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->prescaler);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->t1_history);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->irq_state);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->irq_in_progress);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->timer_overflow);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->timer_flag);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->tirq_enabled);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->xirq_enabled);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->timecount_enabled);
|
||||
state_save_register_item("mcs48", device->tag, 0, mcs48->a11);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -2067,18 +2067,18 @@ static CPU_INIT( mcs51 )
|
||||
mcs51_state->sfr_write = mcs51_sfr_write;
|
||||
|
||||
/* Save states */
|
||||
state_save_register_item("mcs51", index, mcs51_state->ppc);
|
||||
state_save_register_item("mcs51", index, mcs51_state->pc);
|
||||
state_save_register_item("mcs51", index, mcs51_state->rwm );
|
||||
state_save_register_item("mcs51", index, mcs51_state->cur_irq_prio );
|
||||
state_save_register_item("mcs51", index, mcs51_state->last_line_state );
|
||||
state_save_register_item("mcs51", index, mcs51_state->t0_cnt );
|
||||
state_save_register_item("mcs51", index, mcs51_state->t1_cnt );
|
||||
state_save_register_item("mcs51", index, mcs51_state->t2_cnt );
|
||||
state_save_register_item("mcs51", index, mcs51_state->t2ex_cnt );
|
||||
state_save_register_item("mcs51", index, mcs51_state->recalc_parity );
|
||||
state_save_register_item_array("mcs51", index, mcs51_state->irq_prio );
|
||||
state_save_register_item("mcs51", index, mcs51_state->irq_active );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->ppc);
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->pc);
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->rwm );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->cur_irq_prio );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->last_line_state );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->t0_cnt );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->t1_cnt );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->t2_cnt );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->t2ex_cnt );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->recalc_parity );
|
||||
state_save_register_item_array("mcs51", device->tag, 0, mcs51_state->irq_prio );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->irq_active );
|
||||
}
|
||||
|
||||
static CPU_INIT( i80c51 )
|
||||
@ -2376,9 +2376,9 @@ static CPU_INIT( ds5002fp )
|
||||
mcs51_state->sfr_read = ds5002fp_sfr_read;
|
||||
mcs51_state->sfr_write = ds5002fp_sfr_write;
|
||||
|
||||
state_save_register_item("mcs51", index, mcs51_state->ds5002fp.previous_ta );
|
||||
state_save_register_item("mcs51", index, mcs51_state->ds5002fp.ta_window );
|
||||
state_save_register_item("mcs51", index, mcs51_state->ds5002fp.range );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->ds5002fp.previous_ta );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->ds5002fp.ta_window );
|
||||
state_save_register_item("mcs51", device->tag, 0, mcs51_state->ds5002fp.range );
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -100,17 +100,17 @@ void mips3com_init(mips3_state *mips, mips3_flavor flavor, int bigendian, const
|
||||
mips3com_reset(mips);
|
||||
|
||||
/* register for save states */
|
||||
state_save_register_item("mips3", index, mips->pc);
|
||||
state_save_register_item_array("mips3", index, mips->r);
|
||||
state_save_register_item_2d_array("mips3", index, mips->cpr);
|
||||
state_save_register_item_2d_array("mips3", index, mips->ccr);
|
||||
state_save_register_item("mips3", index, mips->llbit);
|
||||
state_save_register_item("mips3", index, mips->count_zero_time);
|
||||
state_save_register_item("mips3", device->tag, 0, mips->pc);
|
||||
state_save_register_item_array("mips3", device->tag, 0, mips->r);
|
||||
state_save_register_item_2d_array("mips3", device->tag, 0, mips->cpr);
|
||||
state_save_register_item_2d_array("mips3", device->tag, 0, mips->ccr);
|
||||
state_save_register_item("mips3", device->tag, 0, mips->llbit);
|
||||
state_save_register_item("mips3", device->tag, 0, mips->count_zero_time);
|
||||
for (tlbindex = 0; tlbindex < ARRAY_LENGTH(mips->tlb); tlbindex++)
|
||||
{
|
||||
state_save_register_item("mips3", index * ARRAY_LENGTH(mips->tlb) + tlbindex, mips->tlb[tlbindex].page_mask);
|
||||
state_save_register_item("mips3", index * ARRAY_LENGTH(mips->tlb) + tlbindex, mips->tlb[tlbindex].entry_hi);
|
||||
state_save_register_item_array("mips3", index * ARRAY_LENGTH(mips->tlb) + tlbindex, mips->tlb[tlbindex].entry_lo);
|
||||
state_save_register_item("mips3", device->tag, tlbindex, mips->tlb[tlbindex].page_mask);
|
||||
state_save_register_item("mips3", device->tag, tlbindex, mips->tlb[tlbindex].entry_hi);
|
||||
state_save_register_item_array("mips3", device->tag, tlbindex, mips->tlb[tlbindex].entry_lo);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1559,26 +1559,26 @@ static STATE_POSTLOAD( mips_postload )
|
||||
mips_update_scratchpad(machine);
|
||||
}
|
||||
|
||||
static void mips_state_register( const char *type, int index )
|
||||
static void mips_state_register( const char *type, const device_config *device )
|
||||
{
|
||||
state_save_register_item( type, index, mipscpu.op );
|
||||
state_save_register_item( type, index, mipscpu.pc );
|
||||
state_save_register_item( type, index, mipscpu.delayv );
|
||||
state_save_register_item( type, index, mipscpu.delayr );
|
||||
state_save_register_item( type, index, mipscpu.hi );
|
||||
state_save_register_item( type, index, mipscpu.lo );
|
||||
state_save_register_item( type, index, mipscpu.biu );
|
||||
state_save_register_item_array( type, index, mipscpu.r );
|
||||
state_save_register_item_array( type, index, mipscpu.cp0r );
|
||||
state_save_register_item_array( type, index, mipscpu.cp2cr );
|
||||
state_save_register_item_array( type, index, mipscpu.cp2dr );
|
||||
state_save_register_item_array( type, index, mipscpu.icacheTag );
|
||||
state_save_register_item_array( type, index, mipscpu.icache );
|
||||
state_save_register_item_array( type, index, mipscpu.dcache );
|
||||
state_save_register_item( type, index, mipscpu.multiplier_operation );
|
||||
state_save_register_item( type, index, mipscpu.multiplier_operand1 );
|
||||
state_save_register_item( type, index, mipscpu.multiplier_operand2 );
|
||||
state_save_register_postload( Machine, mips_postload, NULL );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.op );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.pc );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.delayv );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.delayr );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.hi );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.lo );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.biu );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.r );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.cp0r );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.cp2cr );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.cp2dr );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.icacheTag );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.icache );
|
||||
state_save_register_item_array( type, device->tag, 0, mipscpu.dcache );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.multiplier_operation );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.multiplier_operand1 );
|
||||
state_save_register_item( type, device->tag, 0, mipscpu.multiplier_operand2 );
|
||||
state_save_register_postload( device->machine, mips_postload, NULL );
|
||||
}
|
||||
|
||||
static CPU_INIT( mips )
|
||||
@ -1586,7 +1586,7 @@ static CPU_INIT( mips )
|
||||
mipscpu.irq_callback = irqcallback;
|
||||
mipscpu.device = device;
|
||||
|
||||
mips_state_register( "psxcpu", index );
|
||||
mips_state_register( "psxcpu", device );
|
||||
}
|
||||
|
||||
static CPU_RESET( mips )
|
||||
|
||||
@ -1118,25 +1118,25 @@ static void nec_init(const device_config *device, int index, int clock, cpu_irq_
|
||||
I.config = config;
|
||||
|
||||
|
||||
state_save_register_item_array(names[type], index, I.regs.w);
|
||||
state_save_register_item_array(names[type], index, I.sregs);
|
||||
state_save_register_item_array(names[type], device->tag, 0, I.regs.w);
|
||||
state_save_register_item_array(names[type], device->tag, 0, I.sregs);
|
||||
|
||||
state_save_register_item(names[type], index, I.ip);
|
||||
state_save_register_item(names[type], index, I.TF);
|
||||
state_save_register_item(names[type], index, I.IF);
|
||||
state_save_register_item(names[type], index, I.DF);
|
||||
state_save_register_item(names[type], index, I.MF);
|
||||
state_save_register_item(names[type], index, I.SignVal);
|
||||
state_save_register_item(names[type], index, I.int_vector);
|
||||
state_save_register_item(names[type], index, I.pending_irq);
|
||||
state_save_register_item(names[type], index, I.nmi_state);
|
||||
state_save_register_item(names[type], index, I.irq_state);
|
||||
state_save_register_item(names[type], index, I.poll_state);
|
||||
state_save_register_item(names[type], index, I.AuxVal);
|
||||
state_save_register_item(names[type], index, I.OverVal);
|
||||
state_save_register_item(names[type], index, I.ZeroVal);
|
||||
state_save_register_item(names[type], index, I.CarryVal);
|
||||
state_save_register_item(names[type], index, I.ParityVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.ip);
|
||||
state_save_register_item(names[type], device->tag, 0, I.TF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.IF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.DF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.MF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.SignVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.int_vector);
|
||||
state_save_register_item(names[type], device->tag, 0, I.pending_irq);
|
||||
state_save_register_item(names[type], device->tag, 0, I.nmi_state);
|
||||
state_save_register_item(names[type], device->tag, 0, I.irq_state);
|
||||
state_save_register_item(names[type], device->tag, 0, I.poll_state);
|
||||
state_save_register_item(names[type], device->tag, 0, I.AuxVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.OverVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.ZeroVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.CarryVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.ParityVal);
|
||||
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
@ -691,33 +691,33 @@ static const opcode_fn opcode_000_other[16]=
|
||||
|
||||
static CPU_INIT( pic16C5x )
|
||||
{
|
||||
state_save_register_item("pic16C5x", index, old_data);
|
||||
state_save_register_item("pic16C5x", index, R.W);
|
||||
state_save_register_item("pic16C5x", index, R.ALU);
|
||||
state_save_register_item("pic16C5x", index, R.OPTION);
|
||||
state_save_register_item("pic16C5x", index, R.TMR0);
|
||||
state_save_register_item("pic16C5x", index, R.PCL);
|
||||
state_save_register_item("pic16C5x", index, R.STATUS);
|
||||
state_save_register_item("pic16C5x", index, R.FSR);
|
||||
state_save_register_item("pic16C5x", index, R.PORTA);
|
||||
state_save_register_item("pic16C5x", index, R.PORTB);
|
||||
state_save_register_item("pic16C5x", index, R.PORTC);
|
||||
state_save_register_item("pic16C5x", index, R.TRISA);
|
||||
state_save_register_item("pic16C5x", index, R.TRISB);
|
||||
state_save_register_item("pic16C5x", index, R.TRISC);
|
||||
state_save_register_item("pic16C5x", index, old_T0);
|
||||
state_save_register_item("pic16C5x", index, picRAMmask);
|
||||
state_save_register_item("pic16C5x", index, R.WDT);
|
||||
state_save_register_item("pic16C5x", index, R.prescaler);
|
||||
state_save_register_item("pic16C5x", index, R.STACK[0]);
|
||||
state_save_register_item("pic16C5x", index, R.STACK[1]);
|
||||
state_save_register_item("pic16C5x", index, R.PC);
|
||||
state_save_register_item("pic16C5x", index, R.PREVPC);
|
||||
state_save_register_item("pic16C5x", index, R.CONFIG);
|
||||
state_save_register_item("pic16C5x", index, R.opcode.d);
|
||||
state_save_register_item("pic16C5x", index, delay_timer);
|
||||
state_save_register_item("pic16C5x", index, picmodel);
|
||||
state_save_register_item("pic16C5x", index, pic16C5x_reset_vector);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, old_data);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.W);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.ALU);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.OPTION);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.TMR0);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.PCL);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.STATUS);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.FSR);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.PORTA);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.PORTB);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.PORTC);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.TRISA);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.TRISB);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.TRISC);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, old_T0);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, picRAMmask);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.WDT);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.prescaler);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.STACK[0]);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.STACK[1]);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.PC);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.PREVPC);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.CONFIG);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, R.opcode.d);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, delay_timer);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, picmodel);
|
||||
state_save_register_item("pic16C5x", device->tag, 0, pic16C5x_reset_vector);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -221,36 +221,36 @@ void ppccom_init(powerpc_state *ppc, powerpc_flavor flavor, UINT8 cap, int tb_di
|
||||
ppccom_reset(ppc);
|
||||
|
||||
/* register for save states */
|
||||
state_save_register_item("ppc", index, ppc->pc);
|
||||
state_save_register_item_array("ppc", index, ppc->r);
|
||||
state_save_register_item_array("ppc", index, ppc->f);
|
||||
state_save_register_item_array("ppc", index, ppc->cr);
|
||||
state_save_register_item("ppc", index, ppc->xerso);
|
||||
state_save_register_item("ppc", index, ppc->fpscr);
|
||||
state_save_register_item("ppc", index, ppc->msr);
|
||||
state_save_register_item_array("ppc", index, ppc->sr);
|
||||
state_save_register_item_array("ppc", index, ppc->spr);
|
||||
state_save_register_item_array("ppc", index, ppc->dcr);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->pc);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->r);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->f);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->cr);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->xerso);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->fpscr);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->msr);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->sr);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->spr);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->dcr);
|
||||
if (cap & PPCCAP_4XX)
|
||||
{
|
||||
state_save_register_item_array("ppc", index, ppc->spu.regs);
|
||||
state_save_register_item("ppc", index, ppc->spu.txbuf);
|
||||
state_save_register_item("ppc", index, ppc->spu.rxbuf);
|
||||
state_save_register_item_array("ppc", index, ppc->spu.rxbuffer);
|
||||
state_save_register_item("ppc", index, ppc->spu.rxin);
|
||||
state_save_register_item("ppc", index, ppc->spu.rxout);
|
||||
state_save_register_item("ppc", index, ppc->pit_reload);
|
||||
state_save_register_item("ppc", index, ppc->irqstate);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->spu.regs);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->spu.txbuf);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->spu.rxbuf);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->spu.rxbuffer);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->spu.rxin);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->spu.rxout);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->pit_reload);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->irqstate);
|
||||
}
|
||||
if (cap & PPCCAP_603_MMU)
|
||||
{
|
||||
state_save_register_item("ppc", index, ppc->mmu603_cmp);
|
||||
state_save_register_item_array("ppc", index, ppc->mmu603_hash);
|
||||
state_save_register_item_array("ppc", index, ppc->mmu603_r);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->mmu603_cmp);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->mmu603_hash);
|
||||
state_save_register_item_array("ppc", device->tag, 0, ppc->mmu603_r);
|
||||
}
|
||||
state_save_register_item("ppc", index, ppc->irq_pending);
|
||||
state_save_register_item("ppc", index, ppc->tb_zero_cycles);
|
||||
state_save_register_item("ppc", index, ppc->dec_zero_cycles);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->irq_pending);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->tb_zero_cycles);
|
||||
state_save_register_item("ppc", device->tag, 0, ppc->dec_zero_cycles);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -771,18 +771,18 @@ static CPU_INIT( s2650 )
|
||||
S.irq_callback = irqcallback;
|
||||
S.device = device;
|
||||
|
||||
state_save_register_item("s2650", index, S.ppc);
|
||||
state_save_register_item("s2650", index, S.page);
|
||||
state_save_register_item("s2650", index, S.iar);
|
||||
state_save_register_item("s2650", index, S.ea);
|
||||
state_save_register_item("s2650", index, S.psl);
|
||||
state_save_register_item("s2650", index, S.psu);
|
||||
state_save_register_item("s2650", index, S.r);
|
||||
state_save_register_item_array("s2650", index, S.reg);
|
||||
state_save_register_item("s2650", index, S.halt);
|
||||
state_save_register_item("s2650", index, S.ir);
|
||||
state_save_register_item_array("s2650", index, S.ras);
|
||||
state_save_register_item("s2650", index, S.irq_state);
|
||||
state_save_register_item("s2650", device->tag, 0, S.ppc);
|
||||
state_save_register_item("s2650", device->tag, 0, S.page);
|
||||
state_save_register_item("s2650", device->tag, 0, S.iar);
|
||||
state_save_register_item("s2650", device->tag, 0, S.ea);
|
||||
state_save_register_item("s2650", device->tag, 0, S.psl);
|
||||
state_save_register_item("s2650", device->tag, 0, S.psu);
|
||||
state_save_register_item("s2650", device->tag, 0, S.r);
|
||||
state_save_register_item_array("s2650", device->tag, 0, S.reg);
|
||||
state_save_register_item("s2650", device->tag, 0, S.halt);
|
||||
state_save_register_item("s2650", device->tag, 0, S.ir);
|
||||
state_save_register_item_array("s2650", device->tag, 0, S.ras);
|
||||
state_save_register_item("s2650", device->tag, 0, S.irq_state);
|
||||
}
|
||||
|
||||
static CPU_RESET( s2650 )
|
||||
|
||||
@ -104,29 +104,29 @@ static CPU_INIT( saturn )
|
||||
saturn.irq_callback = irqcallback;
|
||||
saturn.device = device;
|
||||
|
||||
state_save_register_item_array("saturn",index,saturn.reg[R0]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[R1]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[R2]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[R3]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[R4]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[A]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[B]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[C]);
|
||||
state_save_register_item_array("saturn",index,saturn.reg[D]);
|
||||
state_save_register_item_array("saturn",index,saturn.d);
|
||||
state_save_register_item("saturn",index,saturn.pc);
|
||||
state_save_register_item("saturn",index,saturn.oldpc);
|
||||
state_save_register_item_array("saturn",index,saturn.rstk);
|
||||
state_save_register_item("saturn",index,saturn.out);
|
||||
state_save_register_item("saturn",index,saturn.carry);
|
||||
state_save_register_item("saturn",index,saturn.st);
|
||||
state_save_register_item("saturn",index,saturn.hst);
|
||||
state_save_register_item("saturn",index,saturn.nmi_state);
|
||||
state_save_register_item("saturn",index,saturn.irq_state);
|
||||
state_save_register_item("saturn",index,saturn.irq_enable);
|
||||
state_save_register_item("saturn",index,saturn.in_irq);
|
||||
state_save_register_item("saturn",index,saturn.pending_irq);
|
||||
state_save_register_item("saturn",index,saturn.sleeping);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R0]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R1]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R2]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R3]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[R4]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[A]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[B]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[C]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.reg[D]);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.d);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.pc);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.oldpc);
|
||||
state_save_register_item_array("saturn",device->tag, 0,saturn.rstk);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.out);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.carry);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.st);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.hst);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.nmi_state);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.irq_state);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.irq_enable);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.in_irq);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.pending_irq);
|
||||
state_save_register_item("saturn",device->tag, 0,saturn.sleeping);
|
||||
}
|
||||
|
||||
static CPU_RESET( saturn )
|
||||
|
||||
@ -736,29 +736,29 @@ void sh2_common_init(int alloc, const device_config *device, int index, int cloc
|
||||
sh2->device = device;
|
||||
sh2->internal = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
|
||||
state_save_register_item("sh2", index, sh2->pc);
|
||||
state_save_register_item("sh2", index, sh2->r[15]);
|
||||
state_save_register_item("sh2", index, sh2->sr);
|
||||
state_save_register_item("sh2", index, sh2->pr);
|
||||
state_save_register_item("sh2", index, sh2->gbr);
|
||||
state_save_register_item("sh2", index, sh2->vbr);
|
||||
state_save_register_item("sh2", index, sh2->mach);
|
||||
state_save_register_item("sh2", index, sh2->macl);
|
||||
state_save_register_item("sh2", index, sh2->r[ 0]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 1]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 2]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 3]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 4]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 5]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 6]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 7]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 8]);
|
||||
state_save_register_item("sh2", index, sh2->r[ 9]);
|
||||
state_save_register_item("sh2", index, sh2->r[10]);
|
||||
state_save_register_item("sh2", index, sh2->r[11]);
|
||||
state_save_register_item("sh2", index, sh2->r[12]);
|
||||
state_save_register_item("sh2", index, sh2->r[13]);
|
||||
state_save_register_item("sh2", index, sh2->r[14]);
|
||||
state_save_register_item("sh2", index, sh2->ea);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->pc);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[15]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->sr);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->pr);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->gbr);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->vbr);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->mach);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->macl);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 0]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 1]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 2]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 3]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 4]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 5]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 6]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 7]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 8]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[ 9]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[10]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[11]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[12]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[13]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->r[14]);
|
||||
state_save_register_item("sh2", device->tag, 0, sh2->ea);
|
||||
}
|
||||
|
||||
|
||||
@ -3406,70 +3406,70 @@ static CPU_INIT( sh4 )
|
||||
sh4.irln = 15;
|
||||
sh4.test_irq = 0;
|
||||
|
||||
state_save_register_item("sh4", index, sh4.pc);
|
||||
state_save_register_item("sh4", index, sh4.r[15]);
|
||||
state_save_register_item("sh4", index, sh4.sr);
|
||||
state_save_register_item("sh4", index, sh4.pr);
|
||||
state_save_register_item("sh4", index, sh4.gbr);
|
||||
state_save_register_item("sh4", index, sh4.vbr);
|
||||
state_save_register_item("sh4", index, sh4.mach);
|
||||
state_save_register_item("sh4", index, sh4.macl);
|
||||
state_save_register_item("sh4", index, sh4.spc);
|
||||
state_save_register_item("sh4", index, sh4.ssr);
|
||||
state_save_register_item("sh4", index, sh4.sgr);
|
||||
state_save_register_item("sh4", index, sh4.fpscr);
|
||||
state_save_register_item("sh4", index, sh4.r[ 0]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 1]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 2]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 3]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 4]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 5]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 6]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 7]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 8]);
|
||||
state_save_register_item("sh4", index, sh4.r[ 9]);
|
||||
state_save_register_item("sh4", index, sh4.r[10]);
|
||||
state_save_register_item("sh4", index, sh4.r[11]);
|
||||
state_save_register_item("sh4", index, sh4.r[12]);
|
||||
state_save_register_item("sh4", index, sh4.r[13]);
|
||||
state_save_register_item("sh4", index, sh4.r[14]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 0]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 1]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 2]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 3]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 4]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 5]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 6]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 7]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 8]);
|
||||
state_save_register_item("sh4", index, sh4.fr[ 9]);
|
||||
state_save_register_item("sh4", index, sh4.fr[10]);
|
||||
state_save_register_item("sh4", index, sh4.fr[11]);
|
||||
state_save_register_item("sh4", index, sh4.fr[12]);
|
||||
state_save_register_item("sh4", index, sh4.fr[13]);
|
||||
state_save_register_item("sh4", index, sh4.fr[14]);
|
||||
state_save_register_item("sh4", index, sh4.fr[15]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 0]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 1]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 2]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 3]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 4]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 5]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 6]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 7]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 8]);
|
||||
state_save_register_item("sh4", index, sh4.xf[ 9]);
|
||||
state_save_register_item("sh4", index, sh4.xf[10]);
|
||||
state_save_register_item("sh4", index, sh4.xf[11]);
|
||||
state_save_register_item("sh4", index, sh4.xf[12]);
|
||||
state_save_register_item("sh4", index, sh4.xf[13]);
|
||||
state_save_register_item("sh4", index, sh4.xf[14]);
|
||||
state_save_register_item("sh4", index, sh4.xf[15]);
|
||||
state_save_register_item("sh4", index, sh4.ea);
|
||||
state_save_register_item("sh4", index, sh4.fpul);
|
||||
state_save_register_item("sh4", index, sh4.dbr);
|
||||
state_save_register_item_array("sh4", index, sh4.exception_priority);
|
||||
state_save_register_item_array("sh4", index, sh4.exception_requesting);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.pc);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[15]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.sr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.pr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.gbr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.vbr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.mach);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.macl);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.spc);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.ssr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.sgr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fpscr);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 0]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 1]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 2]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 3]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 4]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 5]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 6]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 7]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 8]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[ 9]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[10]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[11]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[12]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[13]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.r[14]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 0]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 1]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 2]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 3]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 4]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 5]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 6]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 7]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 8]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[ 9]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[10]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[11]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[12]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[13]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[14]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fr[15]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 0]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 1]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 2]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 3]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 4]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 5]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 6]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 7]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 8]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[ 9]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[10]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[11]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[12]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[13]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[14]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.xf[15]);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.ea);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.fpul);
|
||||
state_save_register_item("sh4", device->tag, 0, sh4.dbr);
|
||||
state_save_register_item_array("sh4", device->tag, 0, sh4.exception_priority);
|
||||
state_save_register_item_array("sh4", device->tag, 0, sh4.exception_requesting);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -434,120 +434,120 @@ static CPU_INIT( sharc )
|
||||
sharc.internal_ram_block0 = &sharc.internal_ram[0];
|
||||
sharc.internal_ram_block1 = &sharc.internal_ram[0x20000/2];
|
||||
|
||||
state_save_register_item("sharc", index, sharc.pc);
|
||||
state_save_register_item_pointer("sharc", index, (&sharc.r[0].r), ARRAY_LENGTH(sharc.r));
|
||||
state_save_register_item_pointer("sharc", index, (&sharc.reg_alt[0].r), ARRAY_LENGTH(sharc.reg_alt));
|
||||
state_save_register_item("sharc", index, sharc.mrf);
|
||||
state_save_register_item("sharc", index, sharc.mrb);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.pc);
|
||||
state_save_register_item_pointer("sharc", device->tag, 0, (&sharc.r[0].r), ARRAY_LENGTH(sharc.r));
|
||||
state_save_register_item_pointer("sharc", device->tag, 0, (&sharc.reg_alt[0].r), ARRAY_LENGTH(sharc.reg_alt));
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.mrf);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.mrb);
|
||||
|
||||
state_save_register_item_array("sharc", index, sharc.pcstack);
|
||||
state_save_register_item_array("sharc", index, sharc.lcstack);
|
||||
state_save_register_item_array("sharc", index, sharc.lastack);
|
||||
state_save_register_item("sharc", index, sharc.lstkp);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.pcstack);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.lcstack);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.lastack);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.lstkp);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.faddr);
|
||||
state_save_register_item("sharc", index, sharc.daddr);
|
||||
state_save_register_item("sharc", index, sharc.pcstk);
|
||||
state_save_register_item("sharc", index, sharc.pcstkp);
|
||||
state_save_register_item("sharc", index, sharc.laddr);
|
||||
state_save_register_item("sharc", index, sharc.curlcntr);
|
||||
state_save_register_item("sharc", index, sharc.lcntr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.faddr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.daddr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.pcstk);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.pcstkp);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.laddr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.curlcntr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.lcntr);
|
||||
|
||||
state_save_register_item_array("sharc", index, sharc.dag1.i);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1.m);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1.b);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1.l);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2.i);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2.m);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2.b);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2.l);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1_alt.i);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1_alt.m);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1_alt.b);
|
||||
state_save_register_item_array("sharc", index, sharc.dag1_alt.l);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2_alt.i);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2_alt.m);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2_alt.b);
|
||||
state_save_register_item_array("sharc", index, sharc.dag2_alt.l);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1.i);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1.m);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1.b);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1.l);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2.i);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2.m);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2.b);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2.l);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1_alt.i);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1_alt.m);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1_alt.b);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag1_alt.l);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2_alt.i);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2_alt.m);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2_alt.b);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.dag2_alt.l);
|
||||
|
||||
for (saveindex = 0; saveindex < ARRAY_LENGTH(sharc.dma); saveindex++)
|
||||
{
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].control);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].int_index);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].int_modifier);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].int_count);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].chain_ptr);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].gen_purpose);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].ext_index);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].ext_modifier);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.dma) + saveindex, sharc.dma[saveindex].ext_count);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].control);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].int_index);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].int_modifier);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].int_count);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].chain_ptr);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].gen_purpose);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].ext_index);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].ext_modifier);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.dma[saveindex].ext_count);
|
||||
}
|
||||
|
||||
state_save_register_item("sharc", index, sharc.mode1);
|
||||
state_save_register_item("sharc", index, sharc.mode2);
|
||||
state_save_register_item("sharc", index, sharc.astat);
|
||||
state_save_register_item("sharc", index, sharc.stky);
|
||||
state_save_register_item("sharc", index, sharc.irptl);
|
||||
state_save_register_item("sharc", index, sharc.imask);
|
||||
state_save_register_item("sharc", index, sharc.imaskp);
|
||||
state_save_register_item("sharc", index, sharc.ustat1);
|
||||
state_save_register_item("sharc", index, sharc.ustat2);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.mode1);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.mode2);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.astat);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.stky);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.irptl);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.imask);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.imaskp);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.ustat1);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.ustat2);
|
||||
|
||||
state_save_register_item_array("sharc", index, sharc.flag);
|
||||
state_save_register_item_array("sharc", device->tag, 0, sharc.flag);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.syscon);
|
||||
state_save_register_item("sharc", index, sharc.sysstat);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.syscon);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.sysstat);
|
||||
|
||||
for (saveindex = 0; saveindex < ARRAY_LENGTH(sharc.status_stack); saveindex++)
|
||||
{
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.status_stack) + saveindex, sharc.status_stack[saveindex].mode1);
|
||||
state_save_register_item("sharc", index * ARRAY_LENGTH(sharc.status_stack) + saveindex, sharc.status_stack[saveindex].astat);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.status_stack[saveindex].mode1);
|
||||
state_save_register_item("sharc", device->tag, saveindex, sharc.status_stack[saveindex].astat);
|
||||
}
|
||||
state_save_register_item("sharc", index, sharc.status_stkp);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.status_stkp);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.px);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.px);
|
||||
|
||||
state_save_register_item_pointer("sharc", index, sharc.internal_ram, 2 * 0x10000);
|
||||
state_save_register_item_pointer("sharc", device->tag, 0, sharc.internal_ram, 2 * 0x10000);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.opcode);
|
||||
state_save_register_item("sharc", index, sharc.fetch_opcode);
|
||||
state_save_register_item("sharc", index, sharc.decode_opcode);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.opcode);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.fetch_opcode);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.decode_opcode);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.nfaddr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.nfaddr);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.idle);
|
||||
state_save_register_item("sharc", index, sharc.irq_active);
|
||||
state_save_register_item("sharc", index, sharc.active_irq_num);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.idle);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.irq_active);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.active_irq_num);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.dmaop_src);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_dst);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_chain_ptr);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_src_modifier);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_dst_modifier);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_src_count);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_dst_count);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_pmode);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_cycles);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_channel);
|
||||
state_save_register_item("sharc", index, sharc.dmaop_chained_direction);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_src);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_dst);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_chain_ptr);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_src_modifier);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_dst_modifier);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_src_count);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_dst_count);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_pmode);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_cycles);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_channel);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.dmaop_chained_direction);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.interrupt_active);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.interrupt_active);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.iop_latency_cycles);
|
||||
state_save_register_item("sharc", index, sharc.iop_latency_reg);
|
||||
state_save_register_item("sharc", index, sharc.iop_latency_data);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.iop_latency_cycles);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.iop_latency_reg);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.iop_latency_data);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.delay_slot1);
|
||||
state_save_register_item("sharc", index, sharc.delay_slot2);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.delay_slot1);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.delay_slot2);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.systemreg_latency_cycles);
|
||||
state_save_register_item("sharc", index, sharc.systemreg_latency_reg);
|
||||
state_save_register_item("sharc", index, sharc.systemreg_latency_data);
|
||||
state_save_register_item("sharc", index, sharc.systemreg_previous_data);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.systemreg_latency_cycles);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.systemreg_latency_reg);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.systemreg_latency_data);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.systemreg_previous_data);
|
||||
|
||||
state_save_register_item("sharc", index, sharc.astat_old);
|
||||
state_save_register_item("sharc", index, sharc.astat_old_old);
|
||||
state_save_register_item("sharc", index, sharc.astat_old_old_old);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.astat_old);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.astat_old_old);
|
||||
state_save_register_item("sharc", device->tag, 0, sharc.astat_old_old_old);
|
||||
}
|
||||
|
||||
static CPU_RESET( sharc )
|
||||
|
||||
@ -498,17 +498,17 @@ static UINT32 ptr2_read(int op)
|
||||
|
||||
static CPU_INIT( ssp1601 )
|
||||
{
|
||||
state_save_register_item(CHIP_NAME, index, rX);
|
||||
state_save_register_item(CHIP_NAME, index, rY);
|
||||
state_save_register_item(CHIP_NAME, index, rA32);
|
||||
state_save_register_item(CHIP_NAME, index, rST);
|
||||
state_save_register_item(CHIP_NAME, index, rSTACK);
|
||||
state_save_register_item(CHIP_NAME, index, rPC);
|
||||
state_save_register_item(CHIP_NAME, index, rP.d);
|
||||
state_save_register_item(CHIP_NAME, index, PPC);
|
||||
state_save_register_item_array(CHIP_NAME, index, ssp1601.stack);
|
||||
state_save_register_item_array(CHIP_NAME, index, ssp1601.r);
|
||||
state_save_register_item_array(CHIP_NAME, index, ssp1601.RAM);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rX);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rY);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rA32);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rST);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rSTACK);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rPC);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, rP.d);
|
||||
state_save_register_item(CHIP_NAME, device->tag, 0, PPC);
|
||||
state_save_register_item_array(CHIP_NAME, device->tag, 0, ssp1601.stack);
|
||||
state_save_register_item_array(CHIP_NAME, device->tag, 0, ssp1601.r);
|
||||
state_save_register_item_array(CHIP_NAME, device->tag, 0, ssp1601.RAM);
|
||||
|
||||
/* clear the state */
|
||||
memset(&ssp1601, 0, sizeof(ssp1601));
|
||||
|
||||
@ -297,21 +297,21 @@ static CPU_INIT( t11 )
|
||||
t11.irq_callback = irqcallback;
|
||||
t11.device = device;
|
||||
|
||||
state_save_register_item("t11", index, t11.ppc.w.l);
|
||||
state_save_register_item("t11", index, t11.reg[0].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[1].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[2].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[3].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[4].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[5].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[6].w.l);
|
||||
state_save_register_item("t11", index, t11.reg[7].w.l);
|
||||
state_save_register_item("t11", index, t11.psw.w.l);
|
||||
state_save_register_item("t11", index, t11.op);
|
||||
state_save_register_item("t11", index, t11.initial_pc);
|
||||
state_save_register_item("t11", index, t11.wait_state);
|
||||
state_save_register_item("t11", index, t11.irq_state);
|
||||
state_save_register_item("t11", index, t11.interrupt_cycles);
|
||||
state_save_register_item("t11", device->tag, 0, t11.ppc.w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[0].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[1].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[2].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[3].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[4].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[5].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[6].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.reg[7].w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.psw.w.l);
|
||||
state_save_register_item("t11", device->tag, 0, t11.op);
|
||||
state_save_register_item("t11", device->tag, 0, t11.initial_pc);
|
||||
state_save_register_item("t11", device->tag, 0, t11.wait_state);
|
||||
state_save_register_item("t11", device->tag, 0, t11.irq_state);
|
||||
state_save_register_item("t11", device->tag, 0, t11.interrupt_cycles);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -2626,7 +2626,7 @@ static CPU_INIT( t90 )
|
||||
{
|
||||
int i, p;
|
||||
|
||||
// state_save_register_item("z80", index, Z80.prvpc.w.l);
|
||||
// state_save_register_item("z80", device->tag, 0, Z80.prvpc.w.l);
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
|
||||
@ -711,21 +711,21 @@ static const opcode_fn opcode_7F_other[32]=
|
||||
****************************************************************************/
|
||||
static CPU_INIT( tms32010 )
|
||||
{
|
||||
state_save_register_item("tms32010", index, R.PC);
|
||||
state_save_register_item("tms32010", index, R.PREVPC);
|
||||
state_save_register_item("tms32010", index, R.STR);
|
||||
state_save_register_item("tms32010", index, R.ACC.d);
|
||||
state_save_register_item("tms32010", index, R.ALU.d);
|
||||
state_save_register_item("tms32010", index, R.Preg.d);
|
||||
state_save_register_item("tms32010", index, R.Treg);
|
||||
state_save_register_item("tms32010", index, R.AR[0]);
|
||||
state_save_register_item("tms32010", index, R.AR[1]);
|
||||
state_save_register_item("tms32010", index, R.STACK[0]);
|
||||
state_save_register_item("tms32010", index, R.STACK[1]);
|
||||
state_save_register_item("tms32010", index, R.STACK[2]);
|
||||
state_save_register_item("tms32010", index, R.STACK[3]);
|
||||
state_save_register_item("tms32010", index, R.INTF);
|
||||
state_save_register_item("tms32010", index, R.opcode.d);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.PC);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.PREVPC);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.STR);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.ACC.d);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.ALU.d);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.Preg.d);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.Treg);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.AR[0]);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.AR[1]);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.STACK[0]);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.STACK[1]);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.STACK[2]);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.STACK[3]);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.INTF);
|
||||
state_save_register_item("tms32010", device->tag, 0, R.opcode.d);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
|
||||
@ -1734,38 +1734,38 @@ static CPU_INIT( tms32025 )
|
||||
R.irq_callback = irqcallback;
|
||||
R.device = device;
|
||||
|
||||
state_save_register_item("tms32025", index, R.PC);
|
||||
state_save_register_item("tms32025", index, R.STR0);
|
||||
state_save_register_item("tms32025", index, R.STR1);
|
||||
state_save_register_item("tms32025", index, R.PFC);
|
||||
state_save_register_item("tms32025", index, R.IFR);
|
||||
state_save_register_item("tms32025", index, R.RPTC);
|
||||
state_save_register_item("tms32025", index, R.ACC.d);
|
||||
state_save_register_item("tms32025", index, R.ALU.d);
|
||||
state_save_register_item("tms32025", index, R.Preg.d);
|
||||
state_save_register_item("tms32025", index, R.Treg);
|
||||
state_save_register_item("tms32025", index, R.AR[0]);
|
||||
state_save_register_item("tms32025", index, R.AR[1]);
|
||||
state_save_register_item("tms32025", index, R.AR[2]);
|
||||
state_save_register_item("tms32025", index, R.AR[3]);
|
||||
state_save_register_item("tms32025", index, R.AR[4]);
|
||||
state_save_register_item("tms32025", index, R.AR[5]);
|
||||
state_save_register_item("tms32025", index, R.AR[6]);
|
||||
state_save_register_item("tms32025", index, R.AR[7]);
|
||||
state_save_register_item("tms32025", index, R.STACK[0]);
|
||||
state_save_register_item("tms32025", index, R.STACK[1]);
|
||||
state_save_register_item("tms32025", index, R.STACK[2]);
|
||||
state_save_register_item("tms32025", index, R.STACK[3]);
|
||||
state_save_register_item("tms32025", index, R.STACK[4]);
|
||||
state_save_register_item("tms32025", index, R.STACK[5]);
|
||||
state_save_register_item("tms32025", index, R.STACK[6]);
|
||||
state_save_register_item("tms32025", index, R.STACK[7]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.PC);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STR0);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STR1);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.PFC);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.IFR);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.RPTC);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.ACC.d);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.ALU.d);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.Preg.d);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.Treg);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[0]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[1]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[2]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[3]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[4]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[5]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[6]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.AR[7]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[0]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[1]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[2]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[3]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[4]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[5]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[6]);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.STACK[7]);
|
||||
|
||||
state_save_register_item("tms32025", index, R.idle);
|
||||
state_save_register_item("tms32025", index, R.hold);
|
||||
state_save_register_item("tms32025", index, R.external_mem_access);
|
||||
state_save_register_item("tms32025", index, R.init_load_addr);
|
||||
state_save_register_item("tms32025", index, R.PREVPC);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.idle);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.hold);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.external_mem_access);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.init_load_addr);
|
||||
state_save_register_item("tms32025", device->tag, 0, R.PREVPC);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
|
||||
@ -429,20 +429,20 @@ static CPU_INIT( tms32031 )
|
||||
tms32031.iack_w = configdata->iack_w;
|
||||
}
|
||||
|
||||
state_save_register_item("tms32031", index, tms32031.pc);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.pc);
|
||||
for (i=0;i<36;i++)
|
||||
{
|
||||
sprintf(namebuf,"tms32031.r[%d]",i);
|
||||
state_save_register_generic("tms32031", index, namebuf, tms32031.r[i].i8, UINT8, 8);
|
||||
state_save_register_generic("tms32031", device->tag, 0, namebuf, tms32031.r[i].i8, UINT8, 8);
|
||||
}
|
||||
state_save_register_item("tms32031", index, tms32031.bkmask);
|
||||
state_save_register_item("tms32031", index, tms32031.op);
|
||||
state_save_register_item("tms32031", index, tms32031.irq_state);
|
||||
state_save_register_item("tms32031", index, tms32031.delayed);
|
||||
state_save_register_item("tms32031", index, tms32031.irq_pending);
|
||||
state_save_register_item("tms32031", index, tms32031.mcu_mode);
|
||||
state_save_register_item("tms32031", index, tms32031.is_idling);
|
||||
state_save_register_item("tms32031", index, tms32031.interrupt_cycles);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.bkmask);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.op);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.irq_state);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.delayed);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.irq_pending);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.mcu_mode);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.is_idling);
|
||||
state_save_register_item("tms32031", device->tag, 0, tms32031.interrupt_cycles);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -633,17 +633,17 @@ static CPU_INIT( tms34010 )
|
||||
/* allocate the shiftreg */
|
||||
tms->shiftreg = auto_malloc(SHIFTREG_SIZE);
|
||||
|
||||
state_save_register_item("tms34010", index, tms->pc);
|
||||
state_save_register_item("tms34010", index, tms->st);
|
||||
state_save_register_item("tms34010", index, tms->reset_deferred);
|
||||
state_save_register_item_pointer("tms34010", index, tms->shiftreg, SHIFTREG_SIZE / 2);
|
||||
state_save_register_item_array("tms34010", index, tms->IOregs);
|
||||
state_save_register_item("tms34010", index, tms->convsp);
|
||||
state_save_register_item("tms34010", index, tms->convdp);
|
||||
state_save_register_item("tms34010", index, tms->convmp);
|
||||
state_save_register_item("tms34010", index, tms->pixelshift);
|
||||
state_save_register_item("tms34010", index, tms->gfxcycles);
|
||||
state_save_register_item_pointer("tms34010", index, (&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->pc);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->st);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->reset_deferred);
|
||||
state_save_register_item_pointer("tms34010", device->tag, 0, tms->shiftreg, SHIFTREG_SIZE / 2);
|
||||
state_save_register_item_array("tms34010", device->tag, 0, tms->IOregs);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->convsp);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->convdp);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->convmp);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->pixelshift);
|
||||
state_save_register_item("tms34010", device->tag, 0, tms->gfxcycles);
|
||||
state_save_register_item_pointer("tms34010", device->tag, 0, (&tms->regs[0].reg), ARRAY_LENGTH(tms->regs));
|
||||
state_save_register_postload(device->machine, tms34010_state_postload, tms);
|
||||
}
|
||||
|
||||
|
||||
@ -187,8 +187,6 @@ static CPU_SET_CONTEXT( tms7000 )
|
||||
|
||||
static CPU_INIT( tms7000 )
|
||||
{
|
||||
int cpu = cpunum_get_active();
|
||||
|
||||
tms7000.irq_callback = irqcallback;
|
||||
tms7000.device = device;
|
||||
|
||||
@ -196,23 +194,23 @@ static CPU_INIT( tms7000 )
|
||||
memset(tms7000.rf, 0, 0x80);
|
||||
|
||||
/* Save register state */
|
||||
state_save_register_item("tms7000", cpu, pPC);
|
||||
state_save_register_item("tms7000", cpu, pSP);
|
||||
state_save_register_item("tms7000", cpu, pSR);
|
||||
state_save_register_item("tms7000", device->tag, 0, pPC);
|
||||
state_save_register_item("tms7000", device->tag, 0, pSP);
|
||||
state_save_register_item("tms7000", device->tag, 0, pSR);
|
||||
|
||||
/* Save Interrupt state */
|
||||
state_save_register_item_array("tms7000", cpu, tms7000.irq_state);
|
||||
state_save_register_item_array("tms7000", device->tag, 0, tms7000.irq_state);
|
||||
|
||||
/* Save register and perpherial file state */
|
||||
state_save_register_item_array("tms7000", cpu, tms7000.rf);
|
||||
state_save_register_item_array("tms7000", cpu, tms7000.pf);
|
||||
state_save_register_item_array("tms7000", device->tag, 0, tms7000.rf);
|
||||
state_save_register_item_array("tms7000", device->tag, 0, tms7000.pf);
|
||||
|
||||
/* Save timer state */
|
||||
state_save_register_item("tms7000", cpu, tms7000.t1_prescaler);
|
||||
state_save_register_item("tms7000", cpu, tms7000.t1_capture_latch);
|
||||
state_save_register_item("tms7000", cpu, tms7000.t1_decrementer);
|
||||
state_save_register_item("tms7000", device->tag, 0, tms7000.t1_prescaler);
|
||||
state_save_register_item("tms7000", device->tag, 0, tms7000.t1_capture_latch);
|
||||
state_save_register_item("tms7000", device->tag, 0, tms7000.t1_decrementer);
|
||||
|
||||
state_save_register_item("tms7000", cpu, tms7000.idle_state);
|
||||
state_save_register_item("tms7000", device->tag, 0, tms7000.idle_state);
|
||||
}
|
||||
|
||||
static CPU_RESET( tms7000 )
|
||||
|
||||
@ -1203,78 +1203,78 @@ static void set_flag1(int val);
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
static void register_for_save_state(int index)
|
||||
static void register_for_save_state(const device_config *device)
|
||||
{
|
||||
state_save_register_item("tms99xx", index, I.WP);
|
||||
state_save_register_item("tms99xx", index, I.PC);
|
||||
state_save_register_item("tms99xx", index, I.STATUS);
|
||||
state_save_register_item("tms99xx", index, I.interrupt_pending);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.WP);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.PC);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.STATUS);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.interrupt_pending);
|
||||
|
||||
#if ! ((TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID))
|
||||
state_save_register_item("tms99xx", index, I.load_state);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.load_state);
|
||||
#endif
|
||||
|
||||
#if (TMS99XX_MODEL == TI990_10_ID) || (TMS99XX_MODEL == TMS9900_ID) || (TMS99XX_MODEL == TMS9980_ID)
|
||||
state_save_register_item("tms99xx", index, I.irq_level);
|
||||
state_save_register_item("tms99xx", index, I.irq_state);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.irq_level);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.irq_state);
|
||||
#elif (TMS99XX_MODEL == TMS9995_ID)
|
||||
state_save_register_item("tms99xx", index, I.irq_level);
|
||||
state_save_register_item("tms99xx", index, I.int_state);
|
||||
state_save_register_item("tms99xx", index, I.int_latch);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.irq_level);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.int_state);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.int_latch);
|
||||
#endif
|
||||
|
||||
state_save_register_item("tms99xx", index, I.IDLE);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.IDLE);
|
||||
|
||||
#if HAS_MAPPING
|
||||
state_save_register_item("tms99xx", index, I.mapping_on);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[0].L);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[0].B);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[0].limit);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[0].bias);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[1].L);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[1].B);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[1].limit);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[1].bias);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[2].L);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[2].B);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[2].limit);
|
||||
state_save_register_item_array("tms99xx", index, I.map_files[2].bias);
|
||||
state_save_register_item("tms99xx", index, I.cur_map);
|
||||
state_save_register_item("tms99xx", index, I.cur_src_map);
|
||||
state_save_register_item("tms99xx", index, I.cur_dst_map);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.mapping_on);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[0].L);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[0].B);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[0].limit);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[0].bias);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[1].L);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[1].B);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[1].limit);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[1].bias);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[2].L);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[2].B);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[2].limit);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.map_files[2].bias);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.cur_map);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.cur_src_map);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.cur_dst_map);
|
||||
|
||||
#if (TMS99XX_MODEL == TI990_10_ID)
|
||||
state_save_register_item("tms99xx", index, I.reset_maperr);
|
||||
state_save_register_item("tms99xx", index, I.mapper_address_latch);
|
||||
state_save_register_item("tms99xx", index, I.mapper_cru_read_register);
|
||||
state_save_register_item("tms99xx", index, I.diaglat);
|
||||
state_save_register_item_array("tms99xx", index, I.latch_control);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.reset_maperr);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.mapper_address_latch);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.mapper_cru_read_register);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.diaglat);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.latch_control);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if (TMS99XX_MODEL == TI990_10_ID)
|
||||
state_save_register_item("tms99xx", index, I.error_interrupt_register);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.error_interrupt_register);
|
||||
#endif
|
||||
|
||||
#if (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID)
|
||||
state_save_register_item_array("tms99xx", index, I.RAM);
|
||||
state_save_register_item_array("tms99xx", device->tag, 0, I.RAM);
|
||||
#endif
|
||||
|
||||
#if (TMS99XX_MODEL == TMS9940_ID) || (TMS99XX_MODEL == TMS9985_ID) || (TMS99XX_MODEL == TMS9995_ID)
|
||||
state_save_register_item("tms99xx", index, I.decrementer_enabled);
|
||||
state_save_register_item("tms99xx", index, I.decrementer_interval);
|
||||
state_save_register_item("tms99xx", index, I.decrementer_count);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.decrementer_enabled);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.decrementer_interval);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.decrementer_count);
|
||||
#endif
|
||||
|
||||
#if (TMS99XX_MODEL == TMS9995_ID)
|
||||
state_save_register_item("tms99xx", index, I.flag);
|
||||
state_save_register_item("tms99xx", index, I.MID_flag);
|
||||
state_save_register_item("tms99xx", index, I.memory_wait_states_byte);
|
||||
state_save_register_item("tms99xx", index, I.memory_wait_states_word);
|
||||
state_save_register_item("tms99xx", index, I.is_mp9537);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.flag);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.MID_flag);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.memory_wait_states_byte);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.memory_wait_states_word);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.is_mp9537);
|
||||
#endif
|
||||
|
||||
state_save_register_item("tms99xx", index, I.disable_interrupt_recognition);
|
||||
state_save_register_item("tms99xx", device->tag, 0, I.disable_interrupt_recognition);
|
||||
}
|
||||
|
||||
|
||||
@ -1282,7 +1282,7 @@ static CPU_INIT( tms99xx )
|
||||
{
|
||||
const TMS99XX_RESET_PARAM *param = (const TMS99XX_RESET_PARAM *) device->static_config;
|
||||
|
||||
register_for_save_state(index);
|
||||
register_for_save_state(device);
|
||||
|
||||
I.irq_level = 16;
|
||||
I.irq_callback = irqcallback;
|
||||
|
||||
@ -1535,68 +1535,68 @@ static CPU_INIT( upd7810 )
|
||||
upd7810.irq_callback = irqcallback;
|
||||
upd7810.device = device;
|
||||
|
||||
state_save_register_item("upd7810", index, upd7810.ppc.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.pc.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.sp.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.psw);
|
||||
state_save_register_item("upd7810", index, upd7810.op);
|
||||
state_save_register_item("upd7810", index, upd7810.op2);
|
||||
state_save_register_item("upd7810", index, upd7810.iff);
|
||||
state_save_register_item("upd7810", index, upd7810.ea.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.va.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.bc.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.de.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.hl.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.ea2.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.va2.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.bc2.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.de2.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.hl2.w.l);
|
||||
state_save_register_item("upd7810", index, upd7810.cnt.d);
|
||||
state_save_register_item("upd7810", index, upd7810.tm.d);
|
||||
state_save_register_item("upd7810", index, upd7810.ecnt.d);
|
||||
state_save_register_item("upd7810", index, upd7810.etm.d);
|
||||
state_save_register_item("upd7810", index, upd7810.ma);
|
||||
state_save_register_item("upd7810", index, upd7810.mb);
|
||||
state_save_register_item("upd7810", index, upd7810.mcc);
|
||||
state_save_register_item("upd7810", index, upd7810.mc);
|
||||
state_save_register_item("upd7810", index, upd7810.mm);
|
||||
state_save_register_item("upd7810", index, upd7810.mf);
|
||||
state_save_register_item("upd7810", index, upd7810.tmm);
|
||||
state_save_register_item("upd7810", index, upd7810.etmm);
|
||||
state_save_register_item("upd7810", index, upd7810.eom);
|
||||
state_save_register_item("upd7810", index, upd7810.sml);
|
||||
state_save_register_item("upd7810", index, upd7810.smh);
|
||||
state_save_register_item("upd7810", index, upd7810.anm);
|
||||
state_save_register_item("upd7810", index, upd7810.mkl);
|
||||
state_save_register_item("upd7810", index, upd7810.mkh);
|
||||
state_save_register_item("upd7810", index, upd7810.zcm);
|
||||
state_save_register_item("upd7810", index, upd7810.pa_out);
|
||||
state_save_register_item("upd7810", index, upd7810.pb_out);
|
||||
state_save_register_item("upd7810", index, upd7810.pc_out);
|
||||
state_save_register_item("upd7810", index, upd7810.pd_out);
|
||||
state_save_register_item("upd7810", index, upd7810.pf_out);
|
||||
state_save_register_item("upd7810", index, upd7810.cr0);
|
||||
state_save_register_item("upd7810", index, upd7810.cr1);
|
||||
state_save_register_item("upd7810", index, upd7810.cr2);
|
||||
state_save_register_item("upd7810", index, upd7810.cr3);
|
||||
state_save_register_item("upd7810", index, upd7810.txb);
|
||||
state_save_register_item("upd7810", index, upd7810.rxb);
|
||||
state_save_register_item("upd7810", index, upd7810.txd);
|
||||
state_save_register_item("upd7810", index, upd7810.rxd);
|
||||
state_save_register_item("upd7810", index, upd7810.sck);
|
||||
state_save_register_item("upd7810", index, upd7810.ti);
|
||||
state_save_register_item("upd7810", index, upd7810.to);
|
||||
state_save_register_item("upd7810", index, upd7810.ci);
|
||||
state_save_register_item("upd7810", index, upd7810.co0);
|
||||
state_save_register_item("upd7810", index, upd7810.co1);
|
||||
state_save_register_item("upd7810", index, upd7810.irr);
|
||||
state_save_register_item("upd7810", index, upd7810.itf);
|
||||
state_save_register_item("upd7810", index, upd7810.ovc0);
|
||||
state_save_register_item("upd7810", index, upd7810.ovc1);
|
||||
state_save_register_item("upd7810", index, upd7810.ovcf);
|
||||
state_save_register_item("upd7810", index, upd7810.ovcs);
|
||||
state_save_register_item("upd7810", index, upd7810.edges);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ppc.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.pc.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.sp.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.psw);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.op);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.op2);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.iff);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ea.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.va.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.bc.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.de.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.hl.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ea2.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.va2.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.bc2.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.de2.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.hl2.w.l);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.cnt.d);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.tm.d);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ecnt.d);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.etm.d);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ma);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mb);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mcc);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mc);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mm);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mf);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.tmm);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.etmm);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.eom);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.sml);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.smh);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.anm);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mkl);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.mkh);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.zcm);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.pa_out);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.pb_out);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.pc_out);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.pd_out);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.pf_out);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.cr0);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.cr1);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.cr2);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.cr3);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.txb);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.rxb);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.txd);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.rxd);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.sck);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ti);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.to);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ci);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.co0);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.co1);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.irr);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.itf);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ovc0);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ovc1);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ovcf);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.ovcs);
|
||||
state_save_register_item("upd7810", device->tag, 0, upd7810.edges);
|
||||
}
|
||||
|
||||
#include "7810tbl.c"
|
||||
|
||||
@ -928,24 +928,24 @@ static void nec_init(const device_config *device, int index, int clock, cpu_irq_
|
||||
{
|
||||
static const char *const names[]={"V20","V30","V33","V30MZ"};
|
||||
|
||||
state_save_register_item_array(names[type], index, I.regs.w);
|
||||
state_save_register_item_array(names[type], index, I.sregs);
|
||||
state_save_register_item_array(names[type], device->tag, 0, I.regs.w);
|
||||
state_save_register_item_array(names[type], device->tag, 0, I.sregs);
|
||||
|
||||
state_save_register_item(names[type], index, I.ip);
|
||||
state_save_register_item(names[type], index, I.TF);
|
||||
state_save_register_item(names[type], index, I.IF);
|
||||
state_save_register_item(names[type], index, I.DF);
|
||||
state_save_register_item(names[type], index, I.MF);
|
||||
state_save_register_item(names[type], index, I.SignVal);
|
||||
state_save_register_item(names[type], index, I.int_vector);
|
||||
state_save_register_item(names[type], index, I.pending_irq);
|
||||
state_save_register_item(names[type], index, I.nmi_state);
|
||||
state_save_register_item(names[type], index, I.irq_state);
|
||||
state_save_register_item(names[type], index, I.AuxVal);
|
||||
state_save_register_item(names[type], index, I.OverVal);
|
||||
state_save_register_item(names[type], index, I.ZeroVal);
|
||||
state_save_register_item(names[type], index, I.CarryVal);
|
||||
state_save_register_item(names[type], index, I.ParityVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.ip);
|
||||
state_save_register_item(names[type], device->tag, 0, I.TF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.IF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.DF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.MF);
|
||||
state_save_register_item(names[type], device->tag, 0, I.SignVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.int_vector);
|
||||
state_save_register_item(names[type], device->tag, 0, I.pending_irq);
|
||||
state_save_register_item(names[type], device->tag, 0, I.nmi_state);
|
||||
state_save_register_item(names[type], device->tag, 0, I.irq_state);
|
||||
state_save_register_item(names[type], device->tag, 0, I.AuxVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.OverVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.ZeroVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.CarryVal);
|
||||
state_save_register_item(names[type], device->tag, 0, I.ParityVal);
|
||||
|
||||
I.irq_callback = irqcallback;
|
||||
I.device = device;
|
||||
|
||||
@ -308,14 +308,14 @@ static void base_init(const char *type, const device_config *device, int index,
|
||||
v60.irq_line = CLEAR_LINE;
|
||||
v60.nmi_line = CLEAR_LINE;
|
||||
|
||||
state_save_register_item_array(type, index, v60.reg);
|
||||
state_save_register_item(type, index, v60.irq_line);
|
||||
state_save_register_item(type, index, v60.nmi_line);
|
||||
state_save_register_item(type, index, v60.PPC);
|
||||
state_save_register_item(type, index, _CY);
|
||||
state_save_register_item(type, index, _OV);
|
||||
state_save_register_item(type, index, _S);
|
||||
state_save_register_item(type, index, _Z);
|
||||
state_save_register_item_array(type, device->tag, 0, v60.reg);
|
||||
state_save_register_item(type, device->tag, 0, v60.irq_line);
|
||||
state_save_register_item(type, device->tag, 0, v60.nmi_line);
|
||||
state_save_register_item(type, device->tag, 0, v60.PPC);
|
||||
state_save_register_item(type, device->tag, 0, _CY);
|
||||
state_save_register_item(type, device->tag, 0, _OV);
|
||||
state_save_register_item(type, device->tag, 0, _S);
|
||||
state_save_register_item(type, device->tag, 0, _Z);
|
||||
}
|
||||
|
||||
static CPU_INIT( v60 )
|
||||
|
||||
@ -953,10 +953,10 @@ static CPU_INIT( v810 )
|
||||
v810.irq_cb = irqcallback;
|
||||
v810.device = device;
|
||||
|
||||
state_save_register_item_array("v810", index, v810.reg);
|
||||
state_save_register_item("v810", index, v810.irq_line);
|
||||
state_save_register_item("v810", index, v810.nmi_line);
|
||||
state_save_register_item("v810", index, v810.PPC);
|
||||
state_save_register_item_array("v810", device->tag, 0, v810.reg);
|
||||
state_save_register_item("v810", device->tag, 0, v810.irq_line);
|
||||
state_save_register_item("v810", device->tag, 0, v810.nmi_line);
|
||||
state_save_register_item("v810", device->tag, 0, v810.PPC);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -57,7 +57,6 @@ struct _vtlb_state
|
||||
|
||||
vtlb_state *vtlb_alloc(const device_config *cpu, int space, int fixed_entries, int dynamic_entries)
|
||||
{
|
||||
char tempname[100];
|
||||
vtlb_state *vtlb;
|
||||
|
||||
/* allocate memory for the core structure */
|
||||
@ -78,24 +77,22 @@ vtlb_state *vtlb_alloc(const device_config *cpu, int space, int fixed_entries, i
|
||||
assert(vtlb->translate != NULL);
|
||||
assert(vtlb->addrwidth > vtlb->pageshift);
|
||||
|
||||
state_save_combine_module_and_tag(tempname, "vtlb", cpu->tag);
|
||||
|
||||
/* allocate the entry array */
|
||||
vtlb->live = malloc_or_die(sizeof(vtlb->live[0]) * (fixed_entries + dynamic_entries));
|
||||
memset(vtlb->live, 0, sizeof(vtlb->live[0]) * (fixed_entries + dynamic_entries));
|
||||
state_save_register_item_pointer(tempname, space, vtlb->live, fixed_entries + dynamic_entries);
|
||||
state_save_register_item_pointer("vtlb", cpu->tag, space, vtlb->live, fixed_entries + dynamic_entries);
|
||||
|
||||
/* allocate the lookup table */
|
||||
vtlb->table = malloc_or_die(sizeof(vtlb->table[0]) << (vtlb->addrwidth - vtlb->pageshift));
|
||||
memset(vtlb->table, 0, sizeof(vtlb->table[0]) << (vtlb->addrwidth - vtlb->pageshift));
|
||||
state_save_register_item_pointer(tempname, space, vtlb->table, 1 << (vtlb->addrwidth - vtlb->pageshift));
|
||||
state_save_register_item_pointer("vtlb", cpu->tag, space, vtlb->table, 1 << (vtlb->addrwidth - vtlb->pageshift));
|
||||
|
||||
/* allocate the fixed page count array */
|
||||
if (fixed_entries > 0)
|
||||
{
|
||||
vtlb->fixedpages = malloc_or_die(sizeof(vtlb->fixedpages[0]) * fixed_entries);
|
||||
memset(vtlb->fixedpages, 0, sizeof(vtlb->fixedpages[0]) * fixed_entries);
|
||||
state_save_register_item_pointer(tempname, space, vtlb->fixedpages, fixed_entries);
|
||||
state_save_register_item_pointer("vtlb", cpu->tag, space, vtlb->fixedpages, fixed_entries);
|
||||
}
|
||||
return vtlb;
|
||||
}
|
||||
|
||||
@ -1905,31 +1905,31 @@ static CPU_INIT( z180 )
|
||||
Z180.irq_callback = irqcallback;
|
||||
Z180.device = device;
|
||||
|
||||
state_save_register_item("z180", index, Z180.AF.w.l);
|
||||
state_save_register_item("z180", index, Z180.BC.w.l);
|
||||
state_save_register_item("z180", index, Z180.DE.w.l);
|
||||
state_save_register_item("z180", index, Z180.HL.w.l);
|
||||
state_save_register_item("z180", index, Z180.IX.w.l);
|
||||
state_save_register_item("z180", index, Z180.IY.w.l);
|
||||
state_save_register_item("z180", index, Z180.PC.w.l);
|
||||
state_save_register_item("z180", index, Z180.SP.w.l);
|
||||
state_save_register_item("z180", index, Z180.AF2.w.l);
|
||||
state_save_register_item("z180", index, Z180.BC2.w.l);
|
||||
state_save_register_item("z180", index, Z180.DE2.w.l);
|
||||
state_save_register_item("z180", index, Z180.HL2.w.l);
|
||||
state_save_register_item("z180", index, Z180.R);
|
||||
state_save_register_item("z180", index, Z180.R2);
|
||||
state_save_register_item("z180", index, Z180.IFF1);
|
||||
state_save_register_item("z180", index, Z180.IFF2);
|
||||
state_save_register_item("z180", index, Z180.HALT);
|
||||
state_save_register_item("z180", index, Z180.IM);
|
||||
state_save_register_item("z180", index, Z180.I);
|
||||
state_save_register_item("z180", index, Z180.nmi_state);
|
||||
state_save_register_item("z180", index, Z180.nmi_pending);
|
||||
state_save_register_item("z180", index, Z180.irq_state[0]);
|
||||
state_save_register_item("z180", index, Z180.irq_state[1]);
|
||||
state_save_register_item("z180", index, Z180.irq_state[2]);
|
||||
state_save_register_item("z180", index, Z180.after_EI);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.AF.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.BC.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.DE.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.HL.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.IX.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.IY.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.PC.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.SP.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.AF2.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.BC2.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.DE2.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.HL2.w.l);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.R);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.R2);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.IFF1);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.IFF2);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.HALT);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.IM);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.I);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.nmi_state);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.nmi_pending);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.irq_state[0]);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.irq_state[1]);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.irq_state[2]);
|
||||
state_save_register_item("z180", device->tag, 0, Z180.after_EI);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
|
||||
@ -3518,31 +3518,31 @@ static CPU_INIT( z80 )
|
||||
if( (i & 0x0f) == 0x0f ) SZHV_dec[i] |= HF;
|
||||
}
|
||||
|
||||
state_save_register_item("z80", index, z80->prvpc.w.l);
|
||||
state_save_register_item("z80", index, z80->pc.w.l);
|
||||
state_save_register_item("z80", index, z80->sp.w.l);
|
||||
state_save_register_item("z80", index, z80->af.w.l);
|
||||
state_save_register_item("z80", index, z80->bc.w.l);
|
||||
state_save_register_item("z80", index, z80->de.w.l);
|
||||
state_save_register_item("z80", index, z80->hl.w.l);
|
||||
state_save_register_item("z80", index, z80->ix.w.l);
|
||||
state_save_register_item("z80", index, z80->iy.w.l);
|
||||
state_save_register_item("z80", index, z80->memptr.w.l);
|
||||
state_save_register_item("z80", index, z80->af2.w.l);
|
||||
state_save_register_item("z80", index, z80->bc2.w.l);
|
||||
state_save_register_item("z80", index, z80->de2.w.l);
|
||||
state_save_register_item("z80", index, z80->hl2.w.l);
|
||||
state_save_register_item("z80", index, z80->r);
|
||||
state_save_register_item("z80", index, z80->r2);
|
||||
state_save_register_item("z80", index, z80->iff1);
|
||||
state_save_register_item("z80", index, z80->iff2);
|
||||
state_save_register_item("z80", index, z80->halt);
|
||||
state_save_register_item("z80", index, z80->im);
|
||||
state_save_register_item("z80", index, z80->i);
|
||||
state_save_register_item("z80", index, z80->nmi_state);
|
||||
state_save_register_item("z80", index, z80->nmi_pending);
|
||||
state_save_register_item("z80", index, z80->irq_state);
|
||||
state_save_register_item("z80", index, z80->after_ei);
|
||||
state_save_register_item("z80", device->tag, 0, z80->prvpc.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->pc.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->sp.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->af.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->bc.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->de.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->hl.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->ix.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->iy.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->memptr.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->af2.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->bc2.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->de2.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->hl2.w.l);
|
||||
state_save_register_item("z80", device->tag, 0, z80->r);
|
||||
state_save_register_item("z80", device->tag, 0, z80->r2);
|
||||
state_save_register_item("z80", device->tag, 0, z80->iff1);
|
||||
state_save_register_item("z80", device->tag, 0, z80->iff2);
|
||||
state_save_register_item("z80", device->tag, 0, z80->halt);
|
||||
state_save_register_item("z80", device->tag, 0, z80->im);
|
||||
state_save_register_item("z80", device->tag, 0, z80->i);
|
||||
state_save_register_item("z80", device->tag, 0, z80->nmi_state);
|
||||
state_save_register_item("z80", device->tag, 0, z80->nmi_pending);
|
||||
state_save_register_item("z80", device->tag, 0, z80->irq_state);
|
||||
state_save_register_item("z80", device->tag, 0, z80->after_ei);
|
||||
|
||||
/* Reset registers to their initial values */
|
||||
memset(z80, 0, sizeof(*z80));
|
||||
|
||||
@ -1376,27 +1376,26 @@ static void register_save_states(const device_config *device)
|
||||
cpu_class_data *classdata = device->classtoken;
|
||||
int line;
|
||||
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->suspend);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->nextsuspend);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->eatcycles);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->nexteatcycles);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->trigger);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->suspend);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->nextsuspend);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->eatcycles);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->nexteatcycles);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->trigger);
|
||||
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->iloops);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->iloops);
|
||||
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->totalcycles);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->localtime.seconds);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->localtime.attoseconds);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->clock);
|
||||
state_save_register_item("cpu", classdata->header.index, classdata->clockscale);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->totalcycles);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->localtime.seconds);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->localtime.attoseconds);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->clock);
|
||||
state_save_register_item("cpu", device->tag, 0, classdata->clockscale);
|
||||
|
||||
for (line = 0; line < ARRAY_LENGTH(classdata->input); line++)
|
||||
{
|
||||
cpu_input_data *inputline = &classdata->input[line];
|
||||
int index = classdata->header.index * ARRAY_LENGTH(classdata->input) + line;
|
||||
state_save_register_item("cpu", index, inputline->vector);
|
||||
state_save_register_item("cpu", index, inputline->curvector);
|
||||
state_save_register_item("cpu", index, inputline->curstate);
|
||||
state_save_register_item("cpu", device->tag, line, inputline->vector);
|
||||
state_save_register_item("cpu", device->tag, line, inputline->curvector);
|
||||
state_save_register_item("cpu", device->tag, line, inputline->curstate);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -187,38 +187,38 @@ void cia_config(running_machine *machine, int which, const cia6526_interface *in
|
||||
add_exit_callback(machine, cia_exit);
|
||||
|
||||
/* state save support */
|
||||
state_save_register_item("6526cia", which, cia->port[0].ddr);
|
||||
state_save_register_item("6526cia", which, cia->port[0].latch);
|
||||
state_save_register_item("6526cia", which, cia->port[0].in);
|
||||
state_save_register_item("6526cia", which, cia->port[0].out);
|
||||
state_save_register_item("6526cia", which, cia->port[0].mask_value);
|
||||
state_save_register_item("6526cia", which, cia->port[1].ddr);
|
||||
state_save_register_item("6526cia", which, cia->port[1].latch);
|
||||
state_save_register_item("6526cia", which, cia->port[1].in);
|
||||
state_save_register_item("6526cia", which, cia->port[1].out);
|
||||
state_save_register_item("6526cia", which, cia->port[1].mask_value);
|
||||
state_save_register_item("6526cia", which, cia->timer[0].latch);
|
||||
state_save_register_item("6526cia", which, cia->timer[0].count);
|
||||
state_save_register_item("6526cia", which, cia->timer[0].mode);
|
||||
state_save_register_item("6526cia", which, cia->timer[0].irq);
|
||||
state_save_register_item("6526cia", which, cia->timer[1].latch);
|
||||
state_save_register_item("6526cia", which, cia->timer[1].count);
|
||||
state_save_register_item("6526cia", which, cia->timer[1].mode);
|
||||
state_save_register_item("6526cia", which, cia->timer[1].irq);
|
||||
state_save_register_item("6526cia", which, cia->tod);
|
||||
state_save_register_item("6526cia", which, cia->tod_latch);
|
||||
state_save_register_item("6526cia", which, cia->tod_latched);
|
||||
state_save_register_item("6526cia", which, cia->tod_running);
|
||||
state_save_register_item("6526cia", which, cia->alarm);
|
||||
state_save_register_item("6526cia", which, cia->icr);
|
||||
state_save_register_item("6526cia", which, cia->ics);
|
||||
state_save_register_item("6526cia", which, cia->irq);
|
||||
state_save_register_item("6526cia", which, cia->loaded);
|
||||
state_save_register_item("6526cia", which, cia->sdr);
|
||||
state_save_register_item("6526cia", which, cia->sp);
|
||||
state_save_register_item("6526cia", which, cia->cnt);
|
||||
state_save_register_item("6526cia", which, cia->shift);
|
||||
state_save_register_item("6526cia", which, cia->serial);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[0].ddr);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[0].latch);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[0].in);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[0].out);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[0].mask_value);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[1].ddr);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[1].latch);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[1].in);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[1].out);
|
||||
state_save_register_item("6526cia", NULL, which, cia->port[1].mask_value);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[0].latch);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[0].count);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[0].mode);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[0].irq);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[1].latch);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[1].count);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[1].mode);
|
||||
state_save_register_item("6526cia", NULL, which, cia->timer[1].irq);
|
||||
state_save_register_item("6526cia", NULL, which, cia->tod);
|
||||
state_save_register_item("6526cia", NULL, which, cia->tod_latch);
|
||||
state_save_register_item("6526cia", NULL, which, cia->tod_latched);
|
||||
state_save_register_item("6526cia", NULL, which, cia->tod_running);
|
||||
state_save_register_item("6526cia", NULL, which, cia->alarm);
|
||||
state_save_register_item("6526cia", NULL, which, cia->icr);
|
||||
state_save_register_item("6526cia", NULL, which, cia->ics);
|
||||
state_save_register_item("6526cia", NULL, which, cia->irq);
|
||||
state_save_register_item("6526cia", NULL, which, cia->loaded);
|
||||
state_save_register_item("6526cia", NULL, which, cia->sdr);
|
||||
state_save_register_item("6526cia", NULL, which, cia->sp);
|
||||
state_save_register_item("6526cia", NULL, which, cia->cnt);
|
||||
state_save_register_item("6526cia", NULL, which, cia->shift);
|
||||
state_save_register_item("6526cia", NULL, which, cia->serial);
|
||||
}
|
||||
|
||||
void cia_set_port_mask_value(int which, int port, int data)
|
||||
|
||||
@ -428,7 +428,6 @@ static DEVICE_START( riot6532 )
|
||||
{
|
||||
const riot6532_config *config = device->inline_config;
|
||||
riot6532_state *riot = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
/* validate arguments */
|
||||
assert(device != NULL);
|
||||
@ -450,23 +449,21 @@ static DEVICE_START( riot6532 )
|
||||
riot->timer = timer_alloc(timer_end_callback, (void *)device);
|
||||
|
||||
/* register for save states */
|
||||
state_save_combine_module_and_tag(unique_tag, "riot6532", device->tag);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->port[0].in);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->port[0].out);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->port[0].ddr);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->port[1].in);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->port[1].out);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->port[1].ddr);
|
||||
|
||||
state_save_register_item(unique_tag, 0, riot->port[0].in);
|
||||
state_save_register_item(unique_tag, 0, riot->port[0].out);
|
||||
state_save_register_item(unique_tag, 0, riot->port[0].ddr);
|
||||
state_save_register_item(unique_tag, 0, riot->port[1].in);
|
||||
state_save_register_item(unique_tag, 0, riot->port[1].out);
|
||||
state_save_register_item(unique_tag, 0, riot->port[1].ddr);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->irqstate);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->irqenable);
|
||||
|
||||
state_save_register_item(unique_tag, 0, riot->irqstate);
|
||||
state_save_register_item(unique_tag, 0, riot->irqenable);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->pa7dir);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->pa7prev);
|
||||
|
||||
state_save_register_item(unique_tag, 0, riot->pa7dir);
|
||||
state_save_register_item(unique_tag, 0, riot->pa7prev);
|
||||
|
||||
state_save_register_item(unique_tag, 0, riot->timershift);
|
||||
state_save_register_item(unique_tag, 0, riot->timerstate);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->timershift);
|
||||
state_save_register_item("riot6532", device->tag, 0, riot->timerstate);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -127,38 +127,38 @@ void pia_config(int which, const pia6821_interface *intf)
|
||||
|
||||
p->intf = intf;
|
||||
|
||||
state_save_register_item("6821pia", which, p->in_a);
|
||||
state_save_register_item("6821pia", which, p->in_ca1);
|
||||
state_save_register_item("6821pia", which, p->in_ca2);
|
||||
state_save_register_item("6821pia", which, p->out_a);
|
||||
state_save_register_item("6821pia", which, p->out_ca2);
|
||||
state_save_register_item("6821pia", which, p->port_a_z_mask);
|
||||
state_save_register_item("6821pia", which, p->ddr_a);
|
||||
state_save_register_item("6821pia", which, p->ctl_a);
|
||||
state_save_register_item("6821pia", which, p->irq_a1);
|
||||
state_save_register_item("6821pia", which, p->irq_a2);
|
||||
state_save_register_item("6821pia", which, p->irq_a_state);
|
||||
state_save_register_item("6821pia", which, p->in_b);
|
||||
state_save_register_item("6821pia", which, p->in_cb1);
|
||||
state_save_register_item("6821pia", which, p->in_cb2);
|
||||
state_save_register_item("6821pia", which, p->out_b);
|
||||
state_save_register_item("6821pia", which, p->out_cb2);
|
||||
state_save_register_item("6821pia", which, p->last_out_cb2_z);
|
||||
state_save_register_item("6821pia", which, p->ddr_b);
|
||||
state_save_register_item("6821pia", which, p->ctl_b);
|
||||
state_save_register_item("6821pia", which, p->irq_b1);
|
||||
state_save_register_item("6821pia", which, p->irq_b2);
|
||||
state_save_register_item("6821pia", which, p->irq_b_state);
|
||||
state_save_register_item("6821pia", which, p->in_a_pushed);
|
||||
state_save_register_item("6821pia", which, p->out_a_needs_pulled);
|
||||
state_save_register_item("6821pia", which, p->in_ca1_pushed);
|
||||
state_save_register_item("6821pia", which, p->in_ca2_pushed);
|
||||
state_save_register_item("6821pia", which, p->out_ca2_needs_pulled);
|
||||
state_save_register_item("6821pia", which, p->in_b_pushed);
|
||||
state_save_register_item("6821pia", which, p->out_b_needs_pulled);
|
||||
state_save_register_item("6821pia", which, p->in_cb1_pushed);
|
||||
state_save_register_item("6821pia", which, p->in_cb2_pushed);
|
||||
state_save_register_item("6821pia", which, p->out_cb2_needs_pulled);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_a);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_ca1);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_ca2);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_a);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_ca2);
|
||||
state_save_register_item("6821pia", NULL, which, p->port_a_z_mask);
|
||||
state_save_register_item("6821pia", NULL, which, p->ddr_a);
|
||||
state_save_register_item("6821pia", NULL, which, p->ctl_a);
|
||||
state_save_register_item("6821pia", NULL, which, p->irq_a1);
|
||||
state_save_register_item("6821pia", NULL, which, p->irq_a2);
|
||||
state_save_register_item("6821pia", NULL, which, p->irq_a_state);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_b);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_cb1);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_cb2);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_b);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_cb2);
|
||||
state_save_register_item("6821pia", NULL, which, p->last_out_cb2_z);
|
||||
state_save_register_item("6821pia", NULL, which, p->ddr_b);
|
||||
state_save_register_item("6821pia", NULL, which, p->ctl_b);
|
||||
state_save_register_item("6821pia", NULL, which, p->irq_b1);
|
||||
state_save_register_item("6821pia", NULL, which, p->irq_b2);
|
||||
state_save_register_item("6821pia", NULL, which, p->irq_b_state);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_a_pushed);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_a_needs_pulled);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_ca1_pushed);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_ca2_pushed);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_ca2_needs_pulled);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_b_pushed);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_b_needs_pulled);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_cb1_pushed);
|
||||
state_save_register_item("6821pia", NULL, which, p->in_cb2_pushed);
|
||||
state_save_register_item("6821pia", NULL, which, p->out_cb2_needs_pulled);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -402,25 +402,25 @@ void ptm6840_config(running_machine *machine, int which, const ptm6840_interface
|
||||
timer_enable(ptm[which].timer[i], FALSE);
|
||||
}
|
||||
|
||||
state_save_register_item("6840ptm", which, currptr->lsb_buffer);
|
||||
state_save_register_item("6840ptm", which, currptr->msb_buffer);
|
||||
state_save_register_item("6840ptm", which, currptr->status_read_since_int);
|
||||
state_save_register_item("6840ptm", which, currptr->status_reg);
|
||||
state_save_register_item("6840ptm", which, currptr->t3_divisor);
|
||||
state_save_register_item("6840ptm", which, currptr->t3_scaler);
|
||||
state_save_register_item("6840ptm", which, currptr->internal_clock);
|
||||
state_save_register_item("6840ptm", which, currptr->IRQ);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->lsb_buffer);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->msb_buffer);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->status_read_since_int);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->status_reg);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->t3_divisor);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->t3_scaler);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->internal_clock);
|
||||
state_save_register_item("6840ptm", NULL, which, currptr->IRQ);
|
||||
|
||||
state_save_register_item_array("6840ptm", which, currptr->control_reg);
|
||||
state_save_register_item_array("6840ptm", which, currptr->output);
|
||||
state_save_register_item_array("6840ptm", which, currptr->gate);
|
||||
state_save_register_item_array("6840ptm", which, currptr->clock);
|
||||
state_save_register_item_array("6840ptm", which, currptr->mode);
|
||||
state_save_register_item_array("6840ptm", which, currptr->fired);
|
||||
state_save_register_item_array("6840ptm", which, currptr->enabled);
|
||||
state_save_register_item_array("6840ptm", which, currptr->external_clock);
|
||||
state_save_register_item_array("6840ptm", which, currptr->counter);
|
||||
state_save_register_item_array("6840ptm", which, currptr->latch);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->control_reg);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->output);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->gate);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->clock);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->mode);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->fired);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->enabled);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->external_clock);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->counter);
|
||||
state_save_register_item_array("6840ptm", NULL, which, currptr->latch);
|
||||
|
||||
ptm6840_reset(which);
|
||||
}
|
||||
|
||||
@ -186,29 +186,29 @@ void acia6850_config(int which, const struct acia6850_interface *intf)
|
||||
timer_reset(acia_p->rx_timer, attotime_never);
|
||||
timer_reset(acia_p->tx_timer, attotime_never);
|
||||
|
||||
state_save_register_item("acia6850", which, acia_p->ctrl);
|
||||
state_save_register_item("acia6850", which, acia_p->status);
|
||||
state_save_register_item("acia6850", which, acia_p->rx_clock);
|
||||
state_save_register_item("acia6850", which, acia_p->tx_clock);
|
||||
state_save_register_item("acia6850", which, acia_p->rx_counter);
|
||||
state_save_register_item("acia6850", which, acia_p->tx_counter);
|
||||
state_save_register_item("acia6850", which, acia_p->rx_shift);
|
||||
state_save_register_item("acia6850", which, acia_p->tx_shift);
|
||||
state_save_register_item("acia6850", which, acia_p->rdr);
|
||||
state_save_register_item("acia6850", which, acia_p->tdr);
|
||||
state_save_register_item("acia6850", which, acia_p->rx_bits);
|
||||
state_save_register_item("acia6850", which, acia_p->tx_bits);
|
||||
state_save_register_item("acia6850", which, acia_p->rx_parity);
|
||||
state_save_register_item("acia6850", which, acia_p->tx_parity);
|
||||
state_save_register_item("acia6850", which, acia_p->tx_int);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->ctrl);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->status);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rx_clock);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tx_clock);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rx_counter);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tx_counter);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rx_shift);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tx_shift);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rdr);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tdr);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rx_bits);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tx_bits);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rx_parity);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tx_parity);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->tx_int);
|
||||
|
||||
state_save_register_item("acia6850", which, acia_p->divide);
|
||||
state_save_register_item("acia6850", which, acia_p->overrun);
|
||||
state_save_register_item("acia6850", which, acia_p->reset);
|
||||
state_save_register_item("acia6850", which, acia_p->first_reset);
|
||||
state_save_register_item("acia6850", which, acia_p->rts);
|
||||
state_save_register_item("acia6850", which, acia_p->brk);
|
||||
state_save_register_item("acia6850", which, acia_p->status_read);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->divide);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->overrun);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->reset);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->first_reset);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->rts);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->brk);
|
||||
state_save_register_item("acia6850", NULL, which, acia_p->status_read);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -537,54 +537,50 @@ void duart68681_rx_data( const device_config* device, int ch, UINT8 data )
|
||||
static DEVICE_START(duart68681)
|
||||
{
|
||||
duart68681_state *duart68681 = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
/* validate arguments */
|
||||
assert(device != NULL);
|
||||
assert(device->tag != NULL);
|
||||
assert(strlen(device->tag) < 20);
|
||||
|
||||
state_save_combine_module_and_tag(unique_tag, "DUART 68681", device->tag);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->ACR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->IMR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->ISR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->IVR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->OPCR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->CTR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->IP_last_state);
|
||||
|
||||
state_save_register_item(unique_tag, 0, duart68681->ACR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->IMR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->ISR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->IVR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->OPCR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->CTR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->IP_last_state);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].CR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].CSR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].MR1);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].MR2);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].MR_ptr);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].SR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].baud_rate);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_enabled);
|
||||
state_save_register_item_array("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo_read_ptr);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo_write_ptr);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].rx_fifo_num);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].tx_enabled);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].tx_data);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[0].tx_ready);
|
||||
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].CR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].CSR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].MR1);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].MR2);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].MR_ptr);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].SR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].baud_rate);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].rx_enabled);
|
||||
state_save_register_item_array(unique_tag, 0, duart68681->channel[0].rx_fifo);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].rx_fifo_read_ptr);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].rx_fifo_write_ptr);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].rx_fifo_num);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].tx_enabled);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].tx_data);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[0].tx_ready);
|
||||
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].CR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].CSR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].MR1);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].MR2);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].MR_ptr);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].SR);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].baud_rate);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].rx_enabled);
|
||||
state_save_register_item_array(unique_tag, 0, duart68681->channel[1].rx_fifo);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].rx_fifo_read_ptr);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].rx_fifo_write_ptr);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].rx_fifo_num);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].tx_enabled);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].tx_data);
|
||||
state_save_register_item(unique_tag, 0, duart68681->channel[1].tx_ready);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].CR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].CSR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].MR1);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].MR2);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].MR_ptr);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].SR);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].baud_rate);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_enabled);
|
||||
state_save_register_item_array("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo_read_ptr);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo_write_ptr);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].rx_fifo_num);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].tx_enabled);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].tx_data);
|
||||
state_save_register_item("DUART68681", device->tag, 0, duart68681->channel[1].tx_ready);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -189,11 +189,8 @@ WRITE8_DEVICE_HANDLER( ttl74123_reset_w )
|
||||
static DEVICE_START( ttl74123 )
|
||||
{
|
||||
ttl74123_t *chip = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
/* validate arguments */
|
||||
assert(strlen(device->tag) < 20);
|
||||
|
||||
chip->intf = device->static_config;
|
||||
|
||||
assert_always(chip->intf, "No interface specified");
|
||||
@ -208,12 +205,9 @@ static DEVICE_START( ttl74123 )
|
||||
chip->clear = chip->intf->clear;
|
||||
|
||||
/* register for state saving */
|
||||
|
||||
state_save_combine_module_and_tag(unique_tag, "ttl74123", device->tag);
|
||||
|
||||
state_save_register_item(unique_tag, 0, chip->a);
|
||||
state_save_register_item(unique_tag, 0, chip->b);
|
||||
state_save_register_item(unique_tag, 0, chip->clear);
|
||||
state_save_register_item("ttl74123", device->tag, 0, chip->a);
|
||||
state_save_register_item("ttl74123", device->tag, 0, chip->b);
|
||||
state_save_register_item("ttl74123", device->tag, 0, chip->clear);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -39,9 +39,9 @@ void TTL74181_config(running_machine *machine, int which, void *intf)
|
||||
|
||||
c->dirty = 1;
|
||||
|
||||
state_save_register_item_array("TTL74181", which, c->inputs);
|
||||
state_save_register_item_array("TTL74181", which, c->outputs);
|
||||
state_save_register_item ("TTL74181", which, c->dirty);
|
||||
state_save_register_item_array("TTL74181", NULL, which, c->inputs);
|
||||
state_save_register_item_array("TTL74181", NULL, which, c->outputs);
|
||||
state_save_register_item ("TTL74181", NULL, which, c->dirty);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -161,13 +161,13 @@ void TTL7474_config(int which, const struct TTL7474_interface *intf)
|
||||
chip->last_output = -1;
|
||||
chip->last_output_comp = -1;
|
||||
|
||||
state_save_register_item("ttl7474", which, chip->clear);
|
||||
state_save_register_item("ttl7474", which, chip->preset);
|
||||
state_save_register_item("ttl7474", which, chip->clock);
|
||||
state_save_register_item("ttl7474", which, chip->d);
|
||||
state_save_register_item("ttl7474", which, chip->output);
|
||||
state_save_register_item("ttl7474", which, chip->output_comp);
|
||||
state_save_register_item("ttl7474", which, chip->last_clock);
|
||||
state_save_register_item("ttl7474", which, chip->last_output);
|
||||
state_save_register_item("ttl7474", which, chip->last_output_comp);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->clear);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->preset);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->clock);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->d);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->output);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->output_comp);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->last_clock);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->last_output);
|
||||
state_save_register_item("ttl7474", NULL, which, chip->last_output_comp);
|
||||
}
|
||||
|
||||
@ -506,7 +506,6 @@ UINT8 ppi8255_get_port_c( const device_config *device ) {
|
||||
|
||||
static DEVICE_START( ppi8255 ) {
|
||||
ppi8255_t *ppi8255 = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
ppi8255->intf = device->static_config;
|
||||
|
||||
@ -519,24 +518,22 @@ static DEVICE_START( ppi8255 ) {
|
||||
ppi8255->port_write[2] = ppi8255->intf->port_c_write;
|
||||
|
||||
/* register for state saving */
|
||||
state_save_combine_module_and_tag(unique_tag, "ppi8255", device->tag);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ppi8255->group_a_mode);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->group_b_mode);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->port_a_dir);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->port_b_dir);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->port_ch_dir);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->port_cl_dir);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->obf_a);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->obf_b);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->ibf_a);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->ibf_b);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->inte_a);
|
||||
state_save_register_item(unique_tag, 0, ppi8255->inte_b);
|
||||
state_save_register_item_array(unique_tag, 0, ppi8255->in_mask);
|
||||
state_save_register_item_array(unique_tag, 0, ppi8255->out_mask);
|
||||
state_save_register_item_array(unique_tag, 0, ppi8255->read);
|
||||
state_save_register_item_array(unique_tag, 0, ppi8255->latch);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->group_a_mode);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->group_b_mode);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_a_dir);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_b_dir);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_ch_dir);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->port_cl_dir);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->obf_a);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->obf_b);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->ibf_a);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->ibf_b);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->inte_a);
|
||||
state_save_register_item("ppi8255", device->tag, 0, ppi8255->inte_b);
|
||||
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->in_mask);
|
||||
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->out_mask);
|
||||
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->read);
|
||||
state_save_register_item_array("ppi8255", device->tag, 0, ppi8255->latch);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -362,12 +362,10 @@ WRITE8_DEVICE_HANDLER( dma8257_drq_w )
|
||||
static DEVICE_START( dma8257 )
|
||||
{
|
||||
dma8257_t *dma8257 = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
/* validate arguments */
|
||||
assert(device != NULL);
|
||||
assert(device->tag != NULL);
|
||||
assert(strlen(device->tag) < 20);
|
||||
|
||||
//dma8257->device_type = device_type;
|
||||
dma8257->intf = device->static_config;
|
||||
@ -376,18 +374,16 @@ static DEVICE_START( dma8257 )
|
||||
dma8257->timer = timer_alloc(dma8257_timerproc, (void *) device);
|
||||
dma8257->msbflip_timer = timer_alloc(dma8257_msbflip_timerproc, (void *) device);
|
||||
|
||||
state_save_combine_module_and_tag(unique_tag, "dma8257", device->tag);
|
||||
state_save_register_item_array("dma8257", device->tag, 0, dma8257->address);
|
||||
state_save_register_item_array("dma8257", device->tag, 0, dma8257->count);
|
||||
state_save_register_item_array("dma8257", device->tag, 0, dma8257->rwmode);
|
||||
state_save_register_item_array("dma8257", device->tag, 0, dma8257->registers);
|
||||
|
||||
state_save_register_item_array(unique_tag, 0, dma8257->address);
|
||||
state_save_register_item_array(unique_tag, 0, dma8257->count);
|
||||
state_save_register_item_array(unique_tag, 0, dma8257->rwmode);
|
||||
state_save_register_item_array(unique_tag, 0, dma8257->registers);
|
||||
|
||||
state_save_register_item(unique_tag, 0, dma8257->mode);
|
||||
state_save_register_item(unique_tag, 0, dma8257->rr);
|
||||
state_save_register_item(unique_tag, 0, dma8257->msb);
|
||||
state_save_register_item(unique_tag, 0, dma8257->drq);
|
||||
state_save_register_item(unique_tag, 0, dma8257->status);
|
||||
state_save_register_item("dma8257", device->tag, 0, dma8257->mode);
|
||||
state_save_register_item("dma8257", device->tag, 0, dma8257->rr);
|
||||
state_save_register_item("dma8257", device->tag, 0, dma8257->msb);
|
||||
state_save_register_item("dma8257", device->tag, 0, dma8257->drq);
|
||||
state_save_register_item("dma8257", device->tag, 0, dma8257->status);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -114,19 +114,19 @@ void adc083x_init( int chip, int type, double (*input_callback)(int input) )
|
||||
break;
|
||||
}
|
||||
|
||||
state_save_register_item( "adc083x", chip, c->CS );
|
||||
state_save_register_item( "adc083x", chip, c->CLK );
|
||||
state_save_register_item( "adc083x", chip, c->DI );
|
||||
state_save_register_item( "adc083x", chip, c->SE );
|
||||
state_save_register_item( "adc083x", chip, c->SARS );
|
||||
state_save_register_item( "adc083x", chip, c->DO );
|
||||
state_save_register_item( "adc083x", chip, c->SGL );
|
||||
state_save_register_item( "adc083x", chip, c->ODD );
|
||||
state_save_register_item( "adc083x", chip, c->SEL1 );
|
||||
state_save_register_item( "adc083x", chip, c->SEL0 );
|
||||
state_save_register_item( "adc083x", chip, c->state );
|
||||
state_save_register_item( "adc083x", chip, c->bit );
|
||||
state_save_register_item( "adc083x", chip, c->output );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->CS );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->CLK );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->DI );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->SE );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->SARS );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->DO );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->SGL );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->ODD );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->SEL1 );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->SEL0 );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->state );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->bit );
|
||||
state_save_register_item( "adc083x", NULL, chip, c->output );
|
||||
}
|
||||
|
||||
void adc083x_cs_write( int chip, int cs )
|
||||
|
||||
@ -120,7 +120,6 @@ static DEVICE_START(at28c16)
|
||||
{
|
||||
at28c16_state *c = get_safe_token(device);
|
||||
const at28c16_config *config;
|
||||
char unique_tag[50];
|
||||
|
||||
/* validate some basic stuff */
|
||||
assert(device != NULL);
|
||||
@ -148,14 +147,11 @@ static DEVICE_START(at28c16)
|
||||
}
|
||||
|
||||
/* create the name for save states */
|
||||
assert( strlen( device->tag ) < 30 );
|
||||
state_save_combine_module_and_tag( unique_tag, "at28c16", device->tag );
|
||||
|
||||
state_save_register_item_pointer( unique_tag, 0, c->data, SIZE_DATA );
|
||||
state_save_register_item_pointer( unique_tag, 0, c->id, SIZE_ID );
|
||||
state_save_register_item( unique_tag, 0, c->a9_12v );
|
||||
state_save_register_item( unique_tag, 0, c->oe_12v );
|
||||
state_save_register_item( unique_tag, 0, c->last_write );
|
||||
state_save_register_item_pointer( "at28c16", device->tag, 0, c->data, SIZE_DATA );
|
||||
state_save_register_item_pointer( "at28c16", device->tag, 0, c->id, SIZE_ID );
|
||||
state_save_register_item( "at28c16", device->tag, 0, c->a9_12v );
|
||||
state_save_register_item( "at28c16", device->tag, 0, c->oe_12v );
|
||||
state_save_register_item( "at28c16", device->tag, 0, c->last_write );
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -120,12 +120,10 @@ WRITE8_DEVICE_HANDLER( cdp1852_data_w )
|
||||
static DEVICE_START( cdp1852 )
|
||||
{
|
||||
cdp1852_t *cdp1852 = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
/* validate arguments */
|
||||
assert(device != NULL);
|
||||
assert(device->tag != NULL);
|
||||
assert(strlen(device->tag) < 20);
|
||||
|
||||
cdp1852->intf = device->static_config;
|
||||
|
||||
@ -149,13 +147,11 @@ static DEVICE_START( cdp1852 )
|
||||
}
|
||||
|
||||
/* register for state saving */
|
||||
state_save_combine_module_and_tag(unique_tag, "CDP1852", device->tag);
|
||||
|
||||
state_save_register_item(unique_tag, 0, cdp1852->new_data);
|
||||
state_save_register_item(unique_tag, 0, cdp1852->data);
|
||||
state_save_register_item(unique_tag, 0, cdp1852->next_data);
|
||||
state_save_register_item(unique_tag, 0, cdp1852->sr);
|
||||
state_save_register_item(unique_tag, 0, cdp1852->next_sr);
|
||||
state_save_register_item("cdp1852", device->tag, 0, cdp1852->new_data);
|
||||
state_save_register_item("cdp1852", device->tag, 0, cdp1852->data);
|
||||
state_save_register_item("cdp1852", device->tag, 0, cdp1852->next_data);
|
||||
state_save_register_item("cdp1852", device->tag, 0, cdp1852->sr);
|
||||
state_save_register_item("cdp1852", device->tag, 0, cdp1852->next_sr);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -111,16 +111,13 @@ static void cr589_write_data( SCSIInstance *scsiInstance, UINT8 *data, int dataL
|
||||
static void cr589_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
|
||||
{
|
||||
SCSICr589 *our_this = SCSIThis( &SCSIClassCr589, scsiInstance );
|
||||
char tag[256];
|
||||
|
||||
our_this->download = 0;
|
||||
memcpy( &our_this->buffer[ identity_offset ], "MATSHITACD-ROM CR-589 GS0N", 28 );
|
||||
|
||||
state_save_combine_module_and_tag(tag, "cr589", diskregion);
|
||||
|
||||
state_save_register_item( tag, 0, our_this->download );
|
||||
state_save_register_item_array( tag, 0, our_this->buffer );
|
||||
state_save_register_item( tag, 0, our_this->bufferOffset );
|
||||
state_save_register_item( "cr589", diskregion, 0, our_this->download );
|
||||
state_save_register_item_array( "cr589", diskregion, 0, our_this->buffer );
|
||||
state_save_register_item( "cr589", diskregion, 0, our_this->bufferOffset );
|
||||
}
|
||||
|
||||
static int cr589_dispatch( int operation, void *file, INT64 intparm, void *ptrparm )
|
||||
|
||||
@ -156,12 +156,12 @@ void ds2401_init( int which, const UINT8 *data )
|
||||
c->t_pdh = ATTOTIME_IN_USEC( 15 );
|
||||
c->t_pdl = ATTOTIME_IN_USEC( 60 );
|
||||
|
||||
state_save_register_item( "ds2401", which, c->state );
|
||||
state_save_register_item( "ds2401", which, c->bit );
|
||||
state_save_register_item( "ds2401", which, c->byte );
|
||||
state_save_register_item( "ds2401", which, c->shift );
|
||||
state_save_register_item( "ds2401", which, c->rx );
|
||||
state_save_register_item( "ds2401", which, c->tx );
|
||||
state_save_register_item( "ds2401", NULL, which, c->state );
|
||||
state_save_register_item( "ds2401", NULL, which, c->bit );
|
||||
state_save_register_item( "ds2401", NULL, which, c->byte );
|
||||
state_save_register_item( "ds2401", NULL, which, c->shift );
|
||||
state_save_register_item( "ds2401", NULL, which, c->rx );
|
||||
state_save_register_item( "ds2401", NULL, which, c->tx );
|
||||
|
||||
c->timer = timer_alloc( ds2401_tick , NULL);
|
||||
c->reset_timer = timer_alloc( ds2401_reset , NULL);
|
||||
|
||||
@ -72,9 +72,9 @@ void generic_machine_init(running_machine *machine)
|
||||
}
|
||||
|
||||
/* register coin save state */
|
||||
state_save_register_item_array("coin", 0, coin_count);
|
||||
state_save_register_item_array("coin", 0, coinlockedout);
|
||||
state_save_register_item_array("coin", 0, lastcoin);
|
||||
state_save_register_item_array("coin", NULL, 0, coin_count);
|
||||
state_save_register_item_array("coin", NULL, 0, coinlockedout);
|
||||
state_save_register_item_array("coin", NULL, 0, lastcoin);
|
||||
|
||||
/* reset NVRAM size and pointers */
|
||||
generic_nvram_size = 0;
|
||||
@ -87,7 +87,7 @@ void generic_machine_init(running_machine *machine)
|
||||
|
||||
/* register a reset callback and save state for interrupt enable */
|
||||
add_reset_callback(machine, interrupt_reset);
|
||||
state_save_register_item_array("cpu", 0, interrupt_enable);
|
||||
state_save_register_item_array("cpu", NULL, 0, interrupt_enable);
|
||||
|
||||
/* register for configuration */
|
||||
config_register(machine, "counters", counters_load, counters_save);
|
||||
|
||||
@ -121,19 +121,19 @@ void i2cmem_init( int chip, int slave_address, int page_size, int data_size, uns
|
||||
c->data = data;
|
||||
c->page = page;
|
||||
|
||||
state_save_register_item( "i2cmem", chip, c->scl );
|
||||
state_save_register_item( "i2cmem", chip, c->sdaw );
|
||||
state_save_register_item( "i2cmem", chip, c->e0 );
|
||||
state_save_register_item( "i2cmem", chip, c->e1 );
|
||||
state_save_register_item( "i2cmem", chip, c->e2 );
|
||||
state_save_register_item( "i2cmem", chip, c->wc );
|
||||
state_save_register_item( "i2cmem", chip, c->sdar );
|
||||
state_save_register_item( "i2cmem", chip, c->state );
|
||||
state_save_register_item( "i2cmem", chip, c->bits );
|
||||
state_save_register_item( "i2cmem", chip, c->shift );
|
||||
state_save_register_item( "i2cmem", chip, c->devsel );
|
||||
state_save_register_item( "i2cmem", chip, c->byteaddr );
|
||||
state_save_register_item_pointer( "i2cmem", chip, c->data, c->data_size );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->scl );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->sdaw );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->e0 );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->e1 );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->e2 );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->wc );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->sdar );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->state );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->bits );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->shift );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->devsel );
|
||||
state_save_register_item( "i2cmem", NULL, chip, c->byteaddr );
|
||||
state_save_register_item_pointer( "i2cmem", NULL, chip, c->data, c->data_size );
|
||||
}
|
||||
|
||||
static int select_device( struct i2cmem_chip *c )
|
||||
|
||||
@ -1670,7 +1670,6 @@ static DEVICE_START( ide_controller )
|
||||
ide_state *ide = get_safe_token(device);
|
||||
const hard_disk_info *hdinfo;
|
||||
const ide_config *config;
|
||||
char unique_tag[50];
|
||||
|
||||
/* validate some basic stuff */
|
||||
assert(device != NULL);
|
||||
@ -1707,55 +1706,51 @@ static DEVICE_START( ide_controller )
|
||||
ide->last_status_timer = timer_alloc(NULL, NULL);
|
||||
ide->reset_timer = timer_alloc(reset_callback, (void *)device);
|
||||
|
||||
/* create the name for save states */
|
||||
assert(strlen(device->tag) < 30);
|
||||
state_save_combine_module_and_tag(unique_tag, "ide_controller", device->tag);
|
||||
|
||||
/* register ide states */
|
||||
state_save_register_item(unique_tag, 0, ide->adapter_control);
|
||||
state_save_register_item(unique_tag, 0, ide->status);
|
||||
state_save_register_item(unique_tag, 0, ide->error);
|
||||
state_save_register_item(unique_tag, 0, ide->command);
|
||||
state_save_register_item(unique_tag, 0, ide->interrupt_pending);
|
||||
state_save_register_item(unique_tag, 0, ide->precomp_offset);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->adapter_control);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->status);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->error);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->command);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->interrupt_pending);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->precomp_offset);
|
||||
|
||||
state_save_register_item_array(unique_tag, 0, ide->buffer);
|
||||
state_save_register_item_array(unique_tag, 0, ide->features);
|
||||
state_save_register_item(unique_tag, 0, ide->buffer_offset);
|
||||
state_save_register_item(unique_tag, 0, ide->sector_count);
|
||||
state_save_register_item_array("ide_controller", device->tag, 0, ide->buffer);
|
||||
state_save_register_item_array("ide_controller", device->tag, 0, ide->features);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->buffer_offset);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->sector_count);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->block_count);
|
||||
state_save_register_item(unique_tag, 0, ide->sectors_until_int);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->block_count);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->sectors_until_int);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->dma_active);
|
||||
state_save_register_item(unique_tag, 0, ide->dma_cpu);
|
||||
state_save_register_item(unique_tag, 0, ide->dma_address_xor);
|
||||
state_save_register_item(unique_tag, 0, ide->dma_last_buffer);
|
||||
state_save_register_item(unique_tag, 0, ide->dma_address);
|
||||
state_save_register_item(unique_tag, 0, ide->dma_descriptor);
|
||||
state_save_register_item(unique_tag, 0, ide->dma_bytes_left);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_active);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_cpu);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_address_xor);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_last_buffer);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_address);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_descriptor);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->dma_bytes_left);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->bus_master_command);
|
||||
state_save_register_item(unique_tag, 0, ide->bus_master_status);
|
||||
state_save_register_item(unique_tag, 0, ide->bus_master_descriptor);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->bus_master_command);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->bus_master_status);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->bus_master_descriptor);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->cur_cylinder);
|
||||
state_save_register_item(unique_tag, 0, ide->cur_sector);
|
||||
state_save_register_item(unique_tag, 0, ide->cur_head);
|
||||
state_save_register_item(unique_tag, 0, ide->cur_head_reg);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->cur_cylinder);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->cur_sector);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->cur_head);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->cur_head_reg);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->cur_lba);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->cur_lba);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->num_cylinders);
|
||||
state_save_register_item(unique_tag, 0, ide->num_sectors);
|
||||
state_save_register_item(unique_tag, 0, ide->num_heads);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->num_cylinders);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->num_sectors);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->num_heads);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->config_unknown);
|
||||
state_save_register_item_array(unique_tag, 0, ide->config_register);
|
||||
state_save_register_item(unique_tag, 0, ide->config_register_num);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->config_unknown);
|
||||
state_save_register_item_array("ide_controller", device->tag, 0, ide->config_register);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->config_register_num);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ide->master_password_enable);
|
||||
state_save_register_item(unique_tag, 0, ide->user_password_enable);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->master_password_enable);
|
||||
state_save_register_item("ide_controller", device->tag, 0, ide->user_password_enable);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -134,10 +134,10 @@ void intelflash_init(int chip, int type, void *data)
|
||||
c->timer = timer_alloc(erase_finished, c);
|
||||
c->flash_memory = data;
|
||||
|
||||
state_save_register_item( "intelfsh", chip, c->status );
|
||||
state_save_register_item( "intelfsh", chip, c->flash_mode );
|
||||
state_save_register_item( "intelfsh", chip, c->flash_master_lock );
|
||||
state_save_register_memory( "intelfsh", chip, "flash_memory", c->flash_memory, c->bits/8, c->size / (c->bits/8) );
|
||||
state_save_register_item( "intelfsh", NULL, chip, c->status );
|
||||
state_save_register_item( "intelfsh", NULL, chip, c->flash_mode );
|
||||
state_save_register_item( "intelfsh", NULL, chip, c->flash_master_lock );
|
||||
state_save_register_memory( "intelfsh", NULL, chip, "flash_memory", c->flash_memory, c->bits/8, c->size / (c->bits/8) );
|
||||
}
|
||||
|
||||
UINT32 intelflash_read(int chip, UINT32 address)
|
||||
|
||||
@ -186,12 +186,9 @@ WRITE8_DEVICE_HANDLER( latch8_bit7_w ) { latch8_bitx_w(device, 0, offset, data);
|
||||
static DEVICE_START( latch8 )
|
||||
{
|
||||
latch8_t *latch8 = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
int i;
|
||||
|
||||
/* validate arguments */
|
||||
assert(strlen(device->tag) < 20);
|
||||
|
||||
latch8->intf = device->inline_config;
|
||||
|
||||
latch8->value = 0x0;
|
||||
@ -224,9 +221,7 @@ static DEVICE_START( latch8 )
|
||||
latch8->has_read = 1;
|
||||
}
|
||||
|
||||
state_save_combine_module_and_tag(unique_tag, "latch8", device->tag);
|
||||
|
||||
state_save_register_item(unique_tag, 0, latch8->value);
|
||||
state_save_register_item("latch8", device->tag, 0, latch8->value);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -119,18 +119,18 @@ void microtouch_init(void (*tx_cb)(UINT8 data),
|
||||
microtouch.timer = timer_alloc(microtouch_timer_callback, NULL);
|
||||
timer_adjust_periodic(microtouch.timer, ATTOTIME_IN_HZ(167*5), 0, ATTOTIME_IN_HZ(167*5));
|
||||
|
||||
state_save_register_item("microtouch", 0, microtouch.reset_done);
|
||||
state_save_register_item("microtouch", 0, microtouch.format_tablet);
|
||||
state_save_register_item("microtouch", 0, microtouch.mode_inactive);
|
||||
state_save_register_item("microtouch", 0, microtouch.mode_stream);
|
||||
state_save_register_item("microtouch", 0, microtouch.last_touch_state);
|
||||
state_save_register_item("microtouch", 0, microtouch.last_x);
|
||||
state_save_register_item("microtouch", 0, microtouch.last_y);
|
||||
state_save_register_item_array("microtouch", 0, microtouch.rx_buffer);
|
||||
state_save_register_item("microtouch", 0, microtouch.rx_buffer_ptr);
|
||||
state_save_register_item_array("microtouch", 0, microtouch.tx_buffer);
|
||||
state_save_register_item("microtouch", 0, microtouch.tx_buffer_num);
|
||||
state_save_register_item("microtouch", 0, microtouch.tx_buffer_ptr);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.reset_done);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.format_tablet);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.mode_inactive);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.mode_stream);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.last_touch_state);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.last_x);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.last_y);
|
||||
state_save_register_item_array("microtouch", NULL, 0, microtouch.rx_buffer);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.rx_buffer_ptr);
|
||||
state_save_register_item_array("microtouch", NULL, 0, microtouch.tx_buffer);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.tx_buffer_num);
|
||||
state_save_register_item("microtouch", NULL, 0, microtouch.tx_buffer_ptr);
|
||||
|
||||
};
|
||||
|
||||
|
||||
@ -342,27 +342,27 @@ void pd4990a_init(void)
|
||||
clock_line = 0;
|
||||
command_line =0;
|
||||
|
||||
state_save_register_item("pd4990a", 0, pd4990a.seconds);
|
||||
state_save_register_item("pd4990a", 0, pd4990a.minutes);
|
||||
state_save_register_item("pd4990a", 0, pd4990a.hours);
|
||||
state_save_register_item("pd4990a", 0, pd4990a.days);
|
||||
state_save_register_item("pd4990a", 0, pd4990a.month);
|
||||
state_save_register_item("pd4990a", 0, pd4990a.year);
|
||||
state_save_register_item("pd4990a", 0, pd4990a.weekday);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.seconds);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.minutes);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.hours);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.days);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.month);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.year);
|
||||
state_save_register_item("pd4990a", NULL, 0, pd4990a.weekday);
|
||||
|
||||
state_save_register_item("pd4990a", 0, shiftlo);
|
||||
state_save_register_item("pd4990a", 0, shifthi);
|
||||
state_save_register_item("pd4990a", NULL, 0, shiftlo);
|
||||
state_save_register_item("pd4990a", NULL, 0, shifthi);
|
||||
|
||||
state_save_register_item("pd4990a", 0, retraces);
|
||||
state_save_register_item("pd4990a", 0, testwaits);
|
||||
state_save_register_item("pd4990a", 0, maxwaits);
|
||||
state_save_register_item("pd4990a", 0, testbit);
|
||||
state_save_register_item("pd4990a", NULL, 0, retraces);
|
||||
state_save_register_item("pd4990a", NULL, 0, testwaits);
|
||||
state_save_register_item("pd4990a", NULL, 0, maxwaits);
|
||||
state_save_register_item("pd4990a", NULL, 0, testbit);
|
||||
|
||||
state_save_register_item("pd4990a", 0, outputbit);
|
||||
state_save_register_item("pd4990a", 0, bitno);
|
||||
state_save_register_item("pd4990a", 0, reading);
|
||||
state_save_register_item("pd4990a", 0, writting);
|
||||
state_save_register_item("pd4990a", NULL, 0, outputbit);
|
||||
state_save_register_item("pd4990a", NULL, 0, bitno);
|
||||
state_save_register_item("pd4990a", NULL, 0, reading);
|
||||
state_save_register_item("pd4990a", NULL, 0, writting);
|
||||
|
||||
state_save_register_item("pd4990a", 0, clock_line);
|
||||
state_save_register_item("pd4990a", 0, command_line);
|
||||
state_save_register_item("pd4990a", NULL, 0, clock_line);
|
||||
state_save_register_item("pd4990a", NULL, 0, command_line);
|
||||
}
|
||||
|
||||
@ -1046,15 +1046,12 @@ void pit8253_set_clock_signal(const device_config *device, int timerno, int stat
|
||||
|
||||
static device_start_err common_start( const device_config *device, int device_type ) {
|
||||
pit8253_t *pit8253 = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
int timerno;
|
||||
|
||||
pit8253->config = device->static_config;
|
||||
pit8253->device_type = device_type;
|
||||
|
||||
/* register for state saving */
|
||||
state_save_combine_module_and_tag(unique_tag, device_tags[device_type], device->tag);
|
||||
|
||||
for (timerno = 0; timerno < MAX_TIMER; timerno++)
|
||||
{
|
||||
struct pit8253_timer *timer = get_timer(pit8253,timerno);
|
||||
@ -1066,26 +1063,26 @@ static device_start_err common_start( const device_config *device, int device_ty
|
||||
timer_adjust_oneshot(timer->updatetimer, attotime_never, timerno);
|
||||
|
||||
/* set up state save values */
|
||||
state_save_register_item(unique_tag, timerno, timer->clockin);
|
||||
state_save_register_item(unique_tag, timerno, timer->control);
|
||||
state_save_register_item(unique_tag, timerno, timer->status);
|
||||
state_save_register_item(unique_tag, timerno, timer->lowcount);
|
||||
state_save_register_item(unique_tag, timerno, timer->latch);
|
||||
state_save_register_item(unique_tag, timerno, timer->count);
|
||||
state_save_register_item(unique_tag, timerno, timer->value);
|
||||
state_save_register_item(unique_tag, timerno, timer->wmsb);
|
||||
state_save_register_item(unique_tag, timerno, timer->rmsb);
|
||||
state_save_register_item(unique_tag, timerno, timer->output);
|
||||
state_save_register_item(unique_tag, timerno, timer->gate);
|
||||
state_save_register_item(unique_tag, timerno, timer->latched_count);
|
||||
state_save_register_item(unique_tag, timerno, timer->latched_status);
|
||||
state_save_register_item(unique_tag, timerno, timer->null_count);
|
||||
state_save_register_item(unique_tag, timerno, timer->phase);
|
||||
state_save_register_item(unique_tag, timerno, timer->cycles_to_output);
|
||||
state_save_register_item(unique_tag, timerno, timer->last_updated.seconds);
|
||||
state_save_register_item(unique_tag, timerno, timer->last_updated.attoseconds);
|
||||
state_save_register_item(unique_tag, timerno, timer->programmed);
|
||||
state_save_register_item(unique_tag, timerno, timer->clock);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->clockin);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->control);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->status);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->lowcount);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->latch);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->count);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->value);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->wmsb);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->rmsb);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->output);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->gate);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->latched_count);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->latched_status);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->null_count);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->phase);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->cycles_to_output);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->last_updated.seconds);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->last_updated.attoseconds);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->programmed);
|
||||
state_save_register_item(device_tags[device_type], device->tag, timerno, timer->clock);
|
||||
}
|
||||
|
||||
return DEVICE_START_OK;
|
||||
|
||||
@ -674,7 +674,6 @@ static void scsicd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int data
|
||||
static void scsicd_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
|
||||
{
|
||||
SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
|
||||
char tag[256];
|
||||
|
||||
our_this->lba = 0;
|
||||
our_this->blocks = 0;
|
||||
@ -684,15 +683,13 @@ static void scsicd_alloc_instance( SCSIInstance *scsiInstance, const char *diskr
|
||||
our_this->cur_subblock = 0;
|
||||
our_this->play_err_flag = 0;
|
||||
|
||||
state_save_combine_module_and_tag(tag, "scsicd", diskregion);
|
||||
|
||||
state_save_register_item( tag, 0, our_this->lba );
|
||||
state_save_register_item( tag, 0, our_this->blocks );
|
||||
state_save_register_item( tag, 0, our_this->last_lba );
|
||||
state_save_register_item( tag, 0, our_this->bytes_per_sector );
|
||||
state_save_register_item( tag, 0, our_this->num_subblocks );
|
||||
state_save_register_item( tag, 0, our_this->cur_subblock );
|
||||
state_save_register_item( tag, 0, our_this->play_err_flag );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->lba );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->blocks );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->last_lba );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->bytes_per_sector );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->num_subblocks );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->cur_subblock );
|
||||
state_save_register_item( "scsicd", diskregion, 0, our_this->play_err_flag );
|
||||
|
||||
#ifdef MESS
|
||||
/* TODO: get rid of this ifdef MESS section */
|
||||
|
||||
@ -101,13 +101,10 @@ static int scsidev_get_command( SCSIInstance *scsiInstance, void **command )
|
||||
static void scsidev_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
|
||||
{
|
||||
SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
|
||||
char tag[256];
|
||||
|
||||
state_save_combine_module_and_tag(tag, "scsidev", diskregion);
|
||||
|
||||
state_save_register_item_array( tag, 0, our_this->command );
|
||||
state_save_register_item( tag, 0, our_this->commandLength );
|
||||
state_save_register_item( tag, 0, our_this->phase );
|
||||
state_save_register_item_array( "scsidev", diskregion, 0, our_this->command );
|
||||
state_save_register_item( "scsidev", diskregion, 0, our_this->commandLength );
|
||||
state_save_register_item( "scsidev", diskregion, 0, our_this->phase );
|
||||
}
|
||||
|
||||
static int scsidev_dispatch( int operation, void *file, INT64 intparm, void *ptrparm )
|
||||
|
||||
@ -226,15 +226,12 @@ static void scsihd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int data
|
||||
static void scsihd_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
|
||||
{
|
||||
SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
|
||||
char tag[256];
|
||||
|
||||
our_this->lba = 0;
|
||||
our_this->blocks = 0;
|
||||
|
||||
state_save_combine_module_and_tag(tag, "scsihd", diskregion);
|
||||
|
||||
state_save_register_item( tag, 0, our_this->lba );
|
||||
state_save_register_item( tag, 0, our_this->blocks );
|
||||
state_save_register_item( "scsihd", diskregion, 0, our_this->lba );
|
||||
state_save_register_item( "scsihd", diskregion, 0, our_this->blocks );
|
||||
|
||||
#ifdef MESS
|
||||
/* TODO: get rid of this ifdef MESS section */
|
||||
|
||||
@ -512,7 +512,6 @@ static DEVICE_START( smc91c9x )
|
||||
{
|
||||
const smc91c9x_config *config = device->inline_config;
|
||||
smc91c9x_state *smc = get_safe_token(device);
|
||||
char unique_tag[50];
|
||||
|
||||
/* validate some basic stuff */
|
||||
assert(device != NULL);
|
||||
@ -525,20 +524,16 @@ static DEVICE_START( smc91c9x )
|
||||
smc->device = device;
|
||||
smc->irq_handler = config->interrupt;
|
||||
|
||||
/* create the name for save states */
|
||||
assert(strlen(device->tag) < 30);
|
||||
state_save_combine_module_and_tag(unique_tag, "smc91c9x", device->tag);
|
||||
|
||||
/* register ide states */
|
||||
state_save_register_item_array(unique_tag, 0, smc->reg);
|
||||
state_save_register_item_array(unique_tag, 0, smc->regmask);
|
||||
state_save_register_item(unique_tag, 0, smc->irq_state);
|
||||
state_save_register_item(unique_tag, 0, smc->alloc_count);
|
||||
state_save_register_item(unique_tag, 0, smc->fifo_count);
|
||||
state_save_register_item_array(unique_tag, 0, smc->rx);
|
||||
state_save_register_item_array(unique_tag, 0, smc->tx);
|
||||
state_save_register_item(unique_tag, 0, smc->sent);
|
||||
state_save_register_item(unique_tag, 0, smc->recd);
|
||||
state_save_register_item_array("smc91c9x", device->tag, 0, smc->reg);
|
||||
state_save_register_item_array("smc91c9x", device->tag, 0, smc->regmask);
|
||||
state_save_register_item("smc91c9x", device->tag, 0, smc->irq_state);
|
||||
state_save_register_item("smc91c9x", device->tag, 0, smc->alloc_count);
|
||||
state_save_register_item("smc91c9x", device->tag, 0, smc->fifo_count);
|
||||
state_save_register_item_array("smc91c9x", device->tag, 0, smc->rx);
|
||||
state_save_register_item_array("smc91c9x", device->tag, 0, smc->tx);
|
||||
state_save_register_item("smc91c9x", device->tag, 0, smc->sent);
|
||||
state_save_register_item("smc91c9x", device->tag, 0, smc->recd);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -286,7 +286,6 @@ static DEVICE_START(timekeeper)
|
||||
{
|
||||
timekeeper_state *c = get_safe_token(device);
|
||||
const timekeeper_config *config;
|
||||
char unique_tag[50];
|
||||
emu_timer *timer;
|
||||
attotime duration;
|
||||
mame_system_time systime;
|
||||
@ -322,19 +321,16 @@ static DEVICE_START(timekeeper)
|
||||
}
|
||||
}
|
||||
|
||||
assert( strlen( device->tag ) < 30 );
|
||||
state_save_combine_module_and_tag( unique_tag, "timekeeper", device->tag );
|
||||
|
||||
state_save_register_item( unique_tag, 0, c->control );
|
||||
state_save_register_item( unique_tag, 0, c->seconds );
|
||||
state_save_register_item( unique_tag, 0, c->minutes );
|
||||
state_save_register_item( unique_tag, 0, c->hours );
|
||||
state_save_register_item( unique_tag, 0, c->day );
|
||||
state_save_register_item( unique_tag, 0, c->date );
|
||||
state_save_register_item( unique_tag, 0, c->month );
|
||||
state_save_register_item( unique_tag, 0, c->year );
|
||||
state_save_register_item( unique_tag, 0, c->century );
|
||||
state_save_register_item_pointer( unique_tag, 0, c->data, c->size );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->control );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->seconds );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->minutes );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->hours );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->day );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->date );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->month );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->year );
|
||||
state_save_register_item( "timekeeper", device->tag, 0, c->century );
|
||||
state_save_register_item_pointer( "timekeeper", device->tag, 0, c->data, c->size );
|
||||
|
||||
timer = timer_alloc( timekeeper_tick, c );
|
||||
duration = ATTOTIME_IN_SEC(1);
|
||||
|
||||
@ -58,20 +58,20 @@ void uPD4701_init( int chip )
|
||||
c->latchswitches = 0;
|
||||
c->cf = 1;
|
||||
|
||||
state_save_register_item( "uPD4701", chip, c->cs );
|
||||
state_save_register_item( "uPD4701", chip, c->xy );
|
||||
state_save_register_item( "uPD4701", chip, c->ul );
|
||||
state_save_register_item( "uPD4701", chip, c->resetx );
|
||||
state_save_register_item( "uPD4701", chip, c->resety );
|
||||
state_save_register_item( "uPD4701", chip, c->latchx );
|
||||
state_save_register_item( "uPD4701", chip, c->latchy );
|
||||
state_save_register_item( "uPD4701", chip, c->startx );
|
||||
state_save_register_item( "uPD4701", chip, c->starty );
|
||||
state_save_register_item( "uPD4701", chip, c->x );
|
||||
state_save_register_item( "uPD4701", chip, c->y );
|
||||
state_save_register_item( "uPD4701", chip, c->switches );
|
||||
state_save_register_item( "uPD4701", chip, c->latchswitches );
|
||||
state_save_register_item( "uPD4701", chip, c->cf );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->cs );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->xy );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->ul );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->resetx );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->resety );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->latchx );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->latchy );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->startx );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->starty );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->x );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->y );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->switches );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->latchswitches );
|
||||
state_save_register_item( "uPD4701", NULL, chip, c->cf );
|
||||
}
|
||||
|
||||
void uPD4701_ul_w( int chip, int ul )
|
||||
|
||||
@ -800,7 +800,7 @@ extern void wd33c93_init( const struct WD33C93interface *interface )
|
||||
|
||||
scsi_data.temp_input = auto_malloc( TEMP_INPUT_LEN );
|
||||
|
||||
// state_save_register_item_array("wd33c93", 0, scsi_data);
|
||||
// state_save_register_item_array("wd33c93", NULL, 0, scsi_data);
|
||||
}
|
||||
|
||||
extern void wd33c93_exit( const struct WD33C93interface *interface )
|
||||
|
||||
@ -80,7 +80,6 @@ static DEVICE_START(x2212)
|
||||
{
|
||||
x2212_state *c = get_safe_token(device);
|
||||
const x2212_config *config;
|
||||
char unique_tag[50];
|
||||
|
||||
/* validate some basic stuff */
|
||||
assert(device != NULL);
|
||||
@ -100,14 +99,10 @@ static DEVICE_START(x2212)
|
||||
c->default_data = memory_region( device->machine, config->data );
|
||||
}
|
||||
|
||||
/* create the name for save states */
|
||||
assert( strlen( device->tag ) < 30 );
|
||||
state_save_combine_module_and_tag( unique_tag, "x2212", device->tag );
|
||||
|
||||
state_save_register_item_pointer( unique_tag, 0, c->sram, SIZE_DATA );
|
||||
state_save_register_item_pointer( unique_tag, 0, c->e2prom, SIZE_DATA );
|
||||
state_save_register_item( unique_tag, 0, c->store );
|
||||
state_save_register_item( unique_tag, 0, c->array_recall );
|
||||
state_save_register_item_pointer( "x2212", device->tag, 0, c->sram, SIZE_DATA );
|
||||
state_save_register_item_pointer( "x2212", device->tag, 0, c->e2prom, SIZE_DATA );
|
||||
state_save_register_item( "x2212", device->tag, 0, c->store );
|
||||
state_save_register_item( "x2212", device->tag, 0, c->array_recall );
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -153,24 +153,24 @@ void x76f041_init( int chip, UINT8 *data )
|
||||
c->configuration_registers = &data[ offset ]; offset += SIZE_CONFIGURATION_REGISTERS;
|
||||
c->data = &data[ offset ]; offset += SIZE_DATA;
|
||||
|
||||
state_save_register_item( "x76f041", chip, c->cs );
|
||||
state_save_register_item( "x76f041", chip, c->rst );
|
||||
state_save_register_item( "x76f041", chip, c->scl );
|
||||
state_save_register_item( "x76f041", chip, c->sdaw );
|
||||
state_save_register_item( "x76f041", chip, c->sdar );
|
||||
state_save_register_item( "x76f041", chip, c->state );
|
||||
state_save_register_item( "x76f041", chip, c->shift );
|
||||
state_save_register_item( "x76f041", chip, c->bit );
|
||||
state_save_register_item( "x76f041", chip, c->byte );
|
||||
state_save_register_item( "x76f041", chip, c->command );
|
||||
state_save_register_item( "x76f041", chip, c->address );
|
||||
state_save_register_item_array( "x76f041", chip, c->write_buffer );
|
||||
state_save_register_item_pointer( "x76f041", chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
|
||||
state_save_register_item_pointer( "x76f041", chip, c->write_password, SIZE_WRITE_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f041", chip, c->read_password, SIZE_READ_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f041", chip, c->configuration_password, SIZE_CONFIGURATION_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f041", chip, c->configuration_registers, SIZE_CONFIGURATION_REGISTERS );
|
||||
state_save_register_item_pointer( "x76f041", chip, c->data, SIZE_DATA );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->cs );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->rst );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->scl );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->sdaw );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->sdar );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->state );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->shift );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->bit );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->byte );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->command );
|
||||
state_save_register_item( "x76f041", NULL, chip, c->address );
|
||||
state_save_register_item_array( "x76f041", NULL, chip, c->write_buffer );
|
||||
state_save_register_item_pointer( "x76f041", NULL, chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
|
||||
state_save_register_item_pointer( "x76f041", NULL, chip, c->write_password, SIZE_WRITE_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f041", NULL, chip, c->read_password, SIZE_READ_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f041", NULL, chip, c->configuration_password, SIZE_CONFIGURATION_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f041", NULL, chip, c->configuration_registers, SIZE_CONFIGURATION_REGISTERS );
|
||||
state_save_register_item_pointer( "x76f041", NULL, chip, c->data, SIZE_DATA );
|
||||
}
|
||||
|
||||
void x76f041_cs_write( int chip, int cs )
|
||||
|
||||
@ -117,21 +117,21 @@ void x76f100_init( int chip, UINT8 *data )
|
||||
c->read_password = &data[ offset ]; offset += SIZE_READ_PASSWORD;
|
||||
c->data = &data[ offset ]; offset += SIZE_DATA;
|
||||
|
||||
state_save_register_item( "x76f100", chip, c->cs );
|
||||
state_save_register_item( "x76f100", chip, c->rst );
|
||||
state_save_register_item( "x76f100", chip, c->scl );
|
||||
state_save_register_item( "x76f100", chip, c->sdaw );
|
||||
state_save_register_item( "x76f100", chip, c->sdar );
|
||||
state_save_register_item( "x76f100", chip, c->state );
|
||||
state_save_register_item( "x76f100", chip, c->shift );
|
||||
state_save_register_item( "x76f100", chip, c->bit );
|
||||
state_save_register_item( "x76f100", chip, c->byte );
|
||||
state_save_register_item( "x76f100", chip, c->command );
|
||||
state_save_register_item_array( "x76f100", chip, c->write_buffer );
|
||||
state_save_register_item_pointer( "x76f100", chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
|
||||
state_save_register_item_pointer( "x76f100", chip, c->write_password, SIZE_WRITE_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f100", chip, c->read_password, SIZE_READ_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f100", chip, c->data, SIZE_DATA );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->cs );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->rst );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->scl );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->sdaw );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->sdar );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->state );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->shift );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->bit );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->byte );
|
||||
state_save_register_item( "x76f100", NULL, chip, c->command );
|
||||
state_save_register_item_array( "x76f100", NULL, chip, c->write_buffer );
|
||||
state_save_register_item_pointer( "x76f100", NULL, chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
|
||||
state_save_register_item_pointer( "x76f100", NULL, chip, c->write_password, SIZE_WRITE_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f100", NULL, chip, c->read_password, SIZE_READ_PASSWORD );
|
||||
state_save_register_item_pointer( "x76f100", NULL, chip, c->data, SIZE_DATA );
|
||||
}
|
||||
|
||||
void x76f100_cs_write( int chip, int cs )
|
||||
|
||||
@ -465,7 +465,6 @@ static DEVICE_START( z80ctc )
|
||||
const z80ctc_interface *intf = device->static_config;
|
||||
astring *tempstring = astring_alloc();
|
||||
z80ctc *ctc = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
int cpunum = -1;
|
||||
int ch;
|
||||
|
||||
@ -495,17 +494,15 @@ static DEVICE_START( z80ctc )
|
||||
ctc->channel[3].zc = NULL;
|
||||
|
||||
/* register for save states */
|
||||
state_save_combine_module_and_tag(unique_tag, "z80ctc", device->tag);
|
||||
|
||||
state_save_register_item(unique_tag, 0, ctc->vector);
|
||||
state_save_register_item("z80ctc", device->tag, 0, ctc->vector);
|
||||
for (ch = 0; ch < 4; ch++)
|
||||
{
|
||||
ctc_channel *channel = &ctc->channel[ch];
|
||||
state_save_register_item(unique_tag, ch, channel->mode);
|
||||
state_save_register_item(unique_tag, ch, channel->tconst);
|
||||
state_save_register_item(unique_tag, ch, channel->down);
|
||||
state_save_register_item(unique_tag, ch, channel->extclk);
|
||||
state_save_register_item(unique_tag, ch, channel->int_state);
|
||||
state_save_register_item("z80ctc", device->tag, ch, channel->mode);
|
||||
state_save_register_item("z80ctc", device->tag, ch, channel->tconst);
|
||||
state_save_register_item("z80ctc", device->tag, ch, channel->down);
|
||||
state_save_register_item("z80ctc", device->tag, ch, channel->extclk);
|
||||
state_save_register_item("z80ctc", device->tag, ch, channel->int_state);
|
||||
}
|
||||
|
||||
astring_free(tempstring);
|
||||
|
||||
@ -419,34 +419,30 @@ WRITE8_DEVICE_HANDLER( z80dma_rdy_w)
|
||||
static DEVICE_START( z80dma )
|
||||
{
|
||||
z80dma_t *z80dma = get_safe_token(device);
|
||||
char unique_tag[30];
|
||||
|
||||
/* validate arguments */
|
||||
assert(device != NULL);
|
||||
assert(device->tag != NULL);
|
||||
assert(strlen(device->tag) < 20);
|
||||
|
||||
z80dma->intf = device->static_config;
|
||||
|
||||
z80dma->timer = timer_alloc(z80dma_timerproc, (void *) device);
|
||||
|
||||
state_save_combine_module_and_tag(unique_tag, "z80dma", device->tag);
|
||||
state_save_register_item_array("z80dma", device->tag, 0, z80dma->regs);
|
||||
state_save_register_item_array("z80dma", device->tag, 0, z80dma->regs_follow);
|
||||
|
||||
state_save_register_item_array(unique_tag, 0, z80dma->regs);
|
||||
state_save_register_item_array(unique_tag, 0, z80dma->regs_follow);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->num_follow);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->cur_follow);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->status);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->dma_enabled);
|
||||
|
||||
state_save_register_item(unique_tag, 0, z80dma->num_follow);
|
||||
state_save_register_item(unique_tag, 0, z80dma->cur_follow);
|
||||
state_save_register_item(unique_tag, 0, z80dma->status);
|
||||
state_save_register_item(unique_tag, 0, z80dma->dma_enabled);
|
||||
|
||||
state_save_register_item(unique_tag, 0, z80dma->addressA);
|
||||
state_save_register_item(unique_tag, 0, z80dma->addressB);
|
||||
state_save_register_item(unique_tag, 0, z80dma->count);
|
||||
state_save_register_item(unique_tag, 0, z80dma->rdy);
|
||||
state_save_register_item(unique_tag, 0, z80dma->is_read);
|
||||
state_save_register_item(unique_tag, 0, z80dma->cur_cycle);
|
||||
state_save_register_item(unique_tag, 0, z80dma->latch);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->addressA);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->addressB);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->count);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->rdy);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->is_read);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->cur_cycle);
|
||||
state_save_register_item("z80dma", device->tag, 0, z80dma->latch);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -537,7 +537,6 @@ static DEVICE_START( z80pio )
|
||||
{
|
||||
const z80pio_interface *intf = device->static_config;
|
||||
z80pio_t *z80pio = get_safe_token( device );
|
||||
char unique_tag[30];
|
||||
|
||||
z80pio->intr = intf->intr;
|
||||
z80pio->port_read[0] = intf->portAread;
|
||||
@ -548,18 +547,16 @@ static DEVICE_START( z80pio )
|
||||
z80pio->rdyr[1] = intf->rdyB;
|
||||
|
||||
/* register for save states */
|
||||
state_save_combine_module_and_tag(unique_tag, "z80pio", device->tag);
|
||||
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->vector);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->mode);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->enable);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->mask);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->dir);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->rdy);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->in);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->out);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->strobe);
|
||||
state_save_register_item_array(unique_tag, 0, z80pio->int_state);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->vector);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->mode);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->enable);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->mask);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->dir);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->rdy);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->in);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->out);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->strobe);
|
||||
state_save_register_item_array("z80pio", device->tag, 0, z80pio->int_state);
|
||||
|
||||
return DEVICE_START_OK;
|
||||
}
|
||||
|
||||
@ -1971,7 +1971,7 @@ static void bank_assign_static(int banknum, int cpunum, int spacenum, read_or_wr
|
||||
{
|
||||
/* if we're allowed to, wire up state saving for the entry */
|
||||
if (state_save_registration_allowed())
|
||||
state_save_register_item("memory", banknum, bank->curentry);
|
||||
state_save_register_item("memory", NULL, banknum, bank->curentry);
|
||||
|
||||
/* fill in information about the bank */
|
||||
bank->used = TRUE;
|
||||
@ -2632,8 +2632,8 @@ static void register_for_save(int cpunum, int spacenum, offs_t bytestart, void *
|
||||
int bytes_per_element = cpudata[cpunum].space[spacenum].dbits/8;
|
||||
char name[256];
|
||||
|
||||
sprintf(name, "%d.%08x-%08x", spacenum, bytestart, (int)(bytestart + numbytes - 1));
|
||||
state_save_register_memory("memory", cpunum, name, base, bytes_per_element, (UINT32)numbytes / bytes_per_element);
|
||||
sprintf(name, "%08x-%08x", bytestart, (int)(bytestart + numbytes - 1));
|
||||
state_save_register_memory("memory", address_space_names[spacenum], cpunum, name, base, bytes_per_element, (UINT32)numbytes / bytes_per_element);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user