static DEVICE_START(duart68681)
{
duart68681_state *duart68681 = get_safe_token(device);
/* validate arguments */
assert(device != NULL);
duart68681->duart_config = (const duart68681_config *)device->baseconfig().static_config();
duart68681->device = device;
duart68681->channel[0].tx_timer = timer_alloc(device->machine, tx_timer_callback, (void*)device);
duart68681->channel[1].tx_timer = timer_alloc(device->machine, tx_timer_callback, (void*)device);
duart68681->duart_timer = timer_alloc(device->machine, duart_timer_callback, (void*)device);
state_save_register_device_item(device, 0, duart68681->ACR);
state_save_register_device_item(device, 0, duart68681->IMR);
state_save_register_device_item(device, 0, duart68681->ISR);
state_save_register_device_item(device, 0, duart68681->IVR);
state_save_register_device_item(device, 0, duart68681->OPCR);
state_save_register_device_item(device, 0, duart68681->CTR);
state_save_register_device_item(device, 0, duart68681->IP_last_state);
state_save_register_device_item(device, 0, duart68681->channel[0].CR);
state_save_register_device_item(device, 0, duart68681->channel[0].CSR);
state_save_register_device_item(device, 0, duart68681->channel[0].MR1);
state_save_register_device_item(device, 0, duart68681->channel[0].MR2);
state_save_register_device_item(device, 0, duart68681->channel[0].MR_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].SR);
state_save_register_device_item(device, 0, duart68681->channel[0].baud_rate);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_enabled);
state_save_register_device_item_array(device, 0, duart68681->channel[0].rx_fifo);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_read_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_write_ptr);
state_save_register_device_item(device, 0, duart68681->channel[0].rx_fifo_num);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_enabled);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_data);
state_save_register_device_item(device, 0, duart68681->channel[0].tx_ready);
state_save_register_device_item(device, 0, duart68681->channel[1].CR);
state_save_register_device_item(device, 0, duart68681->channel[1].CSR);
state_save_register_device_item(device, 0, duart68681->channel[1].MR1);
state_save_register_device_item(device, 0, duart68681->channel[1].MR2);
state_save_register_device_item(device, 0, duart68681->channel[1].MR_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].SR);
state_save_register_device_item(device, 0, duart68681->channel[1].baud_rate);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_enabled);
state_save_register_device_item_array(device, 0, duart68681->channel[1].rx_fifo);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_read_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_write_ptr);
state_save_register_device_item(device, 0, duart68681->channel[1].rx_fifo_num);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_enabled);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_data);
state_save_register_device_item(device, 0, duart68681->channel[1].tx_ready);
}
static CPU_INIT( arm )
{
ARM_REGS *cpustate = get_safe_token(device);
cpustate->irq_callback = irqcallback;
cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM);
state_save_register_device_item_array(device, 0, cpustate->sArmRegister);
state_save_register_device_item_array(device, 0, cpustate->coproRegister);
state_save_register_device_item(device, 0, cpustate->pendingIrq);
state_save_register_device_item(device, 0, cpustate->pendingFiq);
}
static CPU_INIT( arm )
{
ARM_REGS *cpustate = get_safe_token(device);
cpustate->irq_callback = irqcallback;
cpustate->device = device;
cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_device_item_array(device, 0, cpustate->sArmRegister);
state_save_register_device_item_array(device, 0, cpustate->coproRegister);
state_save_register_device_item(device, 0, cpustate->pendingIrq);
state_save_register_device_item(device, 0, cpustate->pendingFiq);
}
static CPU_INIT( i860 )
{
i860_state_t *cpustate = get_safe_token(device);
cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM);
reset_i860(cpustate);
i860_set_pin(device, DEC_PIN_BUS_HOLD, 0);
i860_set_pin(device, DEC_PIN_RESET, 0);
cpustate->single_stepping = 0;
state_save_register_device_item_array(device, 0, cpustate->iregs);
state_save_register_device_item_array(device, 0, cpustate->cregs);
state_save_register_device_item_array(device, 0, cpustate->frg);
state_save_register_device_item(device, 0, cpustate->pc);
}
static DEVICE_START( iremga20 )
{
ga20_state *chip = get_safe_token(device);
int i;
/* Initialize our chip structure */
chip->rom = *device->region;
chip->rom_size = device->region->bytes();
iremga20_reset(chip);
for ( i = 0; i < 0x40; i++ )
chip->regs[i] = 0;
chip->stream = stream_create( device, 0, 2, device->clock/4, chip, IremGA20_update );
state_save_register_device_item_array(device, 0, chip->regs);
for (i = 0; i < 4; i++)
{
state_save_register_device_item(device, i, chip->channel[i].rate);
state_save_register_device_item(device, i, chip->channel[i].size);
state_save_register_device_item(device, i, chip->channel[i].start);
state_save_register_device_item(device, i, chip->channel[i].pos);
state_save_register_device_item(device, i, chip->channel[i].end);
state_save_register_device_item(device, i, chip->channel[i].volume);
state_save_register_device_item(device, i, chip->channel[i].pan);
state_save_register_device_item(device, i, chip->channel[i].effect);
state_save_register_device_item(device, i, chip->channel[i].play);
}
}
void z80dart_device::device_start()
{
// resolve callbacks
devcb_resolve_write_line(&m_out_int_func, &m_config.m_out_int_func, this);
m_channel[Z80DART_CH_A].start(this, Z80DART_CH_A, m_config.m_in_rxda_func, m_config.m_out_txda_func, m_config.m_out_dtra_func, m_config.m_out_rtsa_func, m_config.m_out_wrdya_func);
m_channel[Z80DART_CH_B].start(this, Z80DART_CH_B, m_config.m_in_rxdb_func, m_config.m_out_txdb_func, m_config.m_out_dtrb_func, m_config.m_out_rtsb_func, m_config.m_out_wrdyb_func);
if (m_config.m_rx_clock_a != 0)
{
// allocate channel A receive timer
m_rxca_timer = timer_alloc(&m_machine, dart_channel::static_rxca_tick, (void *)&m_channel[Z80DART_CH_A]);
timer_adjust_periodic(m_rxca_timer, attotime_zero, 0, ATTOTIME_IN_HZ(m_config.m_rx_clock_a));
}
if (m_config.m_tx_clock_a != 0)
{
// allocate channel A transmit timer
m_txca_timer = timer_alloc(&m_machine, dart_channel::static_txca_tick, (void *)&m_channel[Z80DART_CH_A]);
timer_adjust_periodic(m_txca_timer, attotime_zero, 0, ATTOTIME_IN_HZ(m_config.m_tx_clock_a));
}
if (m_config.m_rx_tx_clock_b != 0)
{
// allocate channel B receive/transmit timer
m_rxtxcb_timer = timer_alloc(&m_machine, dart_channel::static_rxtxcb_tick, (void *)&m_channel[Z80DART_CH_B]);
timer_adjust_periodic(m_rxtxcb_timer, attotime_zero, 0, ATTOTIME_IN_HZ(m_config.m_rx_tx_clock_b));
}
state_save_register_device_item_array(this, 0, m_int_state);
}
static DEVICE_START( nmk112 )
{
nmk112_state *nmk112 = get_safe_token(device);
const nmk112_interface *intf = get_interface(device);
nmk112->rom0 = memory_region(device->machine, intf->rgn0);
nmk112->size0 = memory_region_length(device->machine, intf->rgn0) - 0x40000;
nmk112->rom1 = memory_region(device->machine, intf->rgn1);
nmk112->size1 = memory_region_length(device->machine, intf->rgn1) - 0x40000;
nmk112->page_mask = ~intf->disable_page_mask;
state_save_register_device_item_array(device, 0, nmk112->current_bank);
state_save_register_device_item_array(device, 0, nmk112->last_bank);
state_save_register_postload(device->machine, nmk112_postload_bankswitch, nmk112);
}
static CPU_INIT( m6809 )
{
/* default configuration */
static const m6809_config default_config =
{
0
};
const m6809_config *configdata = device->static_config ? (const m6809_config *)device->static_config : &default_config;
m68_state_t *m68_state = get_safe_token(device);
m68_state->config = configdata;
m68_state->irq_callback = irqcallback;
m68_state->device = device;
m68_state->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
/* setup regtable */
state_save_register_device_item(device, 0, PC);
state_save_register_device_item(device, 0, PPC);
state_save_register_device_item(device, 0, D);
state_save_register_device_item(device, 0, DP);
state_save_register_device_item(device, 0, U);
state_save_register_device_item(device, 0, S);
state_save_register_device_item(device, 0, X);
state_save_register_device_item(device, 0, Y);
state_save_register_device_item(device, 0, CC);
state_save_register_device_item_array(device, 0, m68_state->irq_state);
state_save_register_device_item(device, 0, m68_state->int_state);
state_save_register_device_item(device, 0, m68_state->nmi_state);
}
static DEVICE_START( ic_315_5250 )
{
ic_315_5250_state *ic_315_5250 = _315_5250_get_safe_token(device);
const ic_315_5250_interface *intf = _315_5250_get_interface(device);
ic_315_5250->sound_w = intf->sound_write_callback;
ic_315_5250->timer_ack = intf->timer_ack_callback;
state_save_register_device_item(device, 0, ic_315_5250->counter);
state_save_register_device_item(device, 0, ic_315_5250->bit);
state_save_register_device_item_array(device, 0, ic_315_5250->regs);
}
static DEVICE_START( tc0510nio )
{
tc0510nio_state *tc0510nio = tc0510nio_get_safe_token(device);
const tc0510nio_interface *intf = tc0510nio_get_interface(device);
devcb_resolve_read8(&tc0510nio->read_0, &intf->read_0, device);
devcb_resolve_read8(&tc0510nio->read_1, &intf->read_1, device);
devcb_resolve_read8(&tc0510nio->read_2, &intf->read_2, device);
devcb_resolve_read8(&tc0510nio->read_3, &intf->read_3, device);
devcb_resolve_read8(&tc0510nio->read_7, &intf->read_7, device);
state_save_register_device_item_array(device, 0, tc0510nio->regs);
}
static DEVICE_START( mathbox )
{
mathbox_state *mb = get_safe_token(device);
/* validate arguments */
assert(device != NULL);
/* set static values */
mb->device = device;
/* register for save states */
state_save_register_device_item(device, 0, mb->result);
state_save_register_device_item_array(device, 0, mb->reg);
}
static DEVICE_START( vrender0 )
{
const vr0_interface *intf;
vr0_state *VR0 = get_safe_token(device);
intf = (const vr0_interface *)device->baseconfig().static_config();
memcpy(&(VR0->Intf),intf,sizeof(vr0_interface));
memset(VR0->SOUNDREGS,0,sizeof(VR0->SOUNDREGS));
VR0->stream = stream_create(device, 0, 2, 44100, VR0, VR0_Update);
state_save_register_device_item_array(device, 0, VR0->SOUNDREGS);
}
static DEVICE_START( tc0220ioc )
{
tc0220ioc_state *tc0220ioc = tc0220ioc_get_safe_token(device);
const tc0220ioc_interface *intf = tc0220ioc_get_interface(device);
devcb_resolve_read8(&tc0220ioc->read_0, &intf->read_0, device);
devcb_resolve_read8(&tc0220ioc->read_1, &intf->read_1, device);
devcb_resolve_read8(&tc0220ioc->read_2, &intf->read_2, device);
devcb_resolve_read8(&tc0220ioc->read_3, &intf->read_3, device);
devcb_resolve_read8(&tc0220ioc->read_7, &intf->read_7, device);
state_save_register_device_item_array(device, 0, tc0220ioc->regs);
state_save_register_device_item(device, 0, tc0220ioc->port);
}
void z80dart_device::dart_channel::start(z80dart_device *device, int index, const devcb_read_line &in_rxd, const devcb_write_line &out_txd, const devcb_write_line &out_dtr, const devcb_write_line &out_rts, const devcb_write_line &out_wrdy)
{
m_index = index;
m_device = device;
devcb_resolve_read_line(&m_in_rxd_func, &in_rxd, m_device);
devcb_resolve_write_line(&m_out_txd_func, &out_txd, m_device);
devcb_resolve_write_line(&m_out_dtr_func, &out_dtr, m_device);
devcb_resolve_write_line(&m_out_rts_func, &out_rts, m_device);
devcb_resolve_write_line(&m_out_wrdy_func, &out_wrdy, m_device);
state_save_register_device_item_array(m_device, m_index, m_rr);
state_save_register_device_item_array(m_device, m_index, m_wr);
state_save_register_device_item_array(m_device, m_index, m_rx_data_fifo);
state_save_register_device_item_array(m_device, m_index, m_rx_error_fifo);
state_save_register_device_item(m_device, m_index, m_rx_shift);
state_save_register_device_item(m_device, m_index, m_rx_error);
state_save_register_device_item(m_device, m_index, m_rx_fifo);
state_save_register_device_item(m_device, m_index, m_rx_clock);
state_save_register_device_item(m_device, m_index, m_rx_state);
state_save_register_device_item(m_device, m_index, m_rx_bits);
state_save_register_device_item(m_device, m_index, m_rx_first);
state_save_register_device_item(m_device, m_index, m_rx_parity);
state_save_register_device_item(m_device, m_index, m_rx_break);
state_save_register_device_item(m_device, m_index, m_rx_rr0_latch);
state_save_register_device_item(m_device, m_index, m_ri);
state_save_register_device_item(m_device, m_index, m_cts);
state_save_register_device_item(m_device, m_index, m_dcd);
state_save_register_device_item(m_device, m_index, m_tx_data);
state_save_register_device_item(m_device, m_index, m_tx_shift);
state_save_register_device_item(m_device, m_index, m_tx_clock);
state_save_register_device_item(m_device, m_index, m_tx_state);
state_save_register_device_item(m_device, m_index, m_tx_bits);
state_save_register_device_item(m_device, m_index, m_tx_parity);
state_save_register_device_item(m_device, m_index, m_dtr);
state_save_register_device_item(m_device, m_index, m_rts);
}
/* device interface */
static DEVICE_START( tms9927 )
{
tms9927_state *tms = get_safe_token(device);
/* validate arguments */
assert(device != NULL);
assert(device->tag != NULL);
tms->intf = (const tms9927_interface *)device->static_config;
if (tms->intf != NULL)
{
assert(device->clock > 0);
assert(tms->intf->hpixels_per_column > 0);
/* copy the initial parameters */
tms->clock = device->clock;
tms->hpixels_per_column = tms->intf->hpixels_per_column;
/* get the screen device */
tms->screen = devtag_get_device(device->machine, tms->intf->screen_tag);
assert(tms->screen != NULL);
/* get the self-load PROM */
if (tms->intf->selfload_region != NULL)
{
tms->selfload = memory_region(device->machine, tms->intf->selfload_region);
assert(tms->selfload != NULL);
}
}
/* register for state saving */
state_save_register_postload(device->machine, tms9927_state_save_postload, tms);
state_save_register_device_item(device, 0, tms->clock);
state_save_register_device_item_array(device, 0, tms->reg);
state_save_register_device_item(device, 0, tms->start_datarow);
state_save_register_device_item(device, 0, tms->reset);
state_save_register_device_item(device, 0, tms->hpixels_per_column);
}
static CPU_INIT( h6280 )
{
h6280_Regs* cpustate = get_safe_token(device);
state_save_register_device_item(device, 0, cpustate->ppc.w.l);
state_save_register_device_item(device, 0, cpustate->pc.w.l);
state_save_register_device_item(device, 0, cpustate->sp.w.l);
state_save_register_device_item(device, 0, cpustate->zp.w.l);
state_save_register_device_item(device, 0, cpustate->ea.w.l);
state_save_register_device_item(device, 0, cpustate->a);
state_save_register_device_item(device, 0, cpustate->x);
state_save_register_device_item(device, 0, cpustate->y);
state_save_register_device_item(device, 0, cpustate->p);
state_save_register_device_item_array(device, 0, cpustate->mmr);
state_save_register_device_item(device, 0, cpustate->irq_mask);
state_save_register_device_item(device, 0, cpustate->timer_status);
state_save_register_device_item(device, 0, cpustate->timer_ack);
state_save_register_device_item(device, 0, cpustate->clocks_per_cycle);
state_save_register_device_item(device, 0, cpustate->timer_value);
state_save_register_device_item(device, 0, cpustate->timer_load);
state_save_register_device_item(device, 0, cpustate->nmi_state);
state_save_register_device_item(device, 0, cpustate->irq_state[0]);
state_save_register_device_item(device, 0, cpustate->irq_state[1]);
state_save_register_device_item(device, 0, cpustate->irq_state[2]);
state_save_register_device_item(device, 0, cpustate->irq_pending);
#if LAZY_FLAGS
state_save_register_device_item(device, 0, cpustate->NZ);
#endif
state_save_register_device_item(device, 0, cpustate->io_buffer);
cpustate->irq_callback = irqcallback;
cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct();
cpustate->io = device->space(AS_IO);
}
static DEVICE_START( i8255a )
{
i8255a_t *i8255a = get_safe_token(device);
const i8255a_interface *intf = get_interface(device);
/* resolve callbacks */
devcb_resolve_read8(&i8255a->in_port_func[PORT_A], &intf->in_pa_func, device);
devcb_resolve_read8(&i8255a->in_port_func[PORT_B], &intf->in_pb_func, device);
devcb_resolve_read8(&i8255a->in_port_func[PORT_C], &intf->in_pc_func, device);
devcb_resolve_write8(&i8255a->out_port_func[PORT_A], &intf->out_pa_func, device);
devcb_resolve_write8(&i8255a->out_port_func[PORT_B], &intf->out_pb_func, device);
devcb_resolve_write8(&i8255a->out_port_func[PORT_C], &intf->out_pc_func, device);
/* register for state saving */
state_save_register_device_item(device, 0, i8255a->control);
state_save_register_device_item_array(device, 0, i8255a->output);
state_save_register_device_item_array(device, 0, i8255a->input);
state_save_register_device_item_array(device, 0, i8255a->ibf);
state_save_register_device_item_array(device, 0, i8255a->obf);
state_save_register_device_item_array(device, 0, i8255a->inte);
state_save_register_device_item(device, 0, i8255a->inte1);
state_save_register_device_item(device, 0, i8255a->inte2);
state_save_register_device_item_array(device, 0, i8255a->intr);
}
static DEVICE_START( ic_315_5249 )
{
ic_315_5249_state *ic_315_5249 = _315_5249_get_safe_token(device);
state_save_register_device_item_array(device, 0, ic_315_5249->regs);
}
