static DEVICE_START( cdp1861 )
{
cdp1861_t *cdp1861 = get_safe_token(device);
const cdp1861_interface *intf = get_interface(device);
/* resolve callbacks */
devcb_resolve_write_line(&cdp1861->out_int_func, &intf->out_int_func, device);
devcb_resolve_write_line(&cdp1861->out_dmao_func, &intf->out_dmao_func, device);
devcb_resolve_write_line(&cdp1861->out_efx_func, &intf->out_efx_func, device);
/* get the cpu */
cdp1861->cpu = device->machine().device<cpu_device>(intf->cpu_tag);
/* get the screen device */
cdp1861->screen = device->machine().device<screen_device>(intf->screen_tag);
assert(cdp1861->screen != NULL);
/* allocate the temporary bitmap */
cdp1861->bitmap = auto_bitmap_alloc(device->machine(), cdp1861->screen->width(), cdp1861->screen->height(), cdp1861->screen->format());
/* create the timers */
cdp1861->int_timer = device->machine().scheduler().timer_alloc(FUNC(cdp1861_int_tick), (void *)device);
cdp1861->efx_timer = device->machine().scheduler().timer_alloc(FUNC(cdp1861_efx_tick), (void *)device);
cdp1861->dma_timer = device->machine().scheduler().timer_alloc(FUNC(cdp1861_dma_tick), (void *)device);
/* register for state saving */
device->save_item(NAME(cdp1861->disp));
device->save_item(NAME(cdp1861->dispon));
device->save_item(NAME(cdp1861->dispoff));
device->save_item(NAME(cdp1861->dmaout));
device->save_item(NAME(*cdp1861->bitmap));
}
void abc99_device::device_start()
{
// allocate timers
m_serial_timer = timer_alloc(TIMER_SERIAL);
m_serial_timer->adjust(MCS48_ALE_CLOCK(XTAL_6MHz/3), 0, MCS48_ALE_CLOCK(XTAL_6MHz/3));
m_mouse_timer = timer_alloc(TIMER_MOUSE);
// resolve callbacks
devcb_resolve_write_line(&m_out_txd_func, &m_config.m_out_txd_func, this);
devcb_resolve_write_line(&m_out_clock_func, &m_config.m_out_clock_func, this);
devcb_resolve_write_line(&m_out_keydown_func, &m_config.m_out_keydown_func, this);
// state saving
save_item(NAME(m_si));
save_item(NAME(m_si_en));
save_item(NAME(m_so));
save_item(NAME(m_so_z2));
save_item(NAME(m_so_z5));
save_item(NAME(m_keydown));
save_item(NAME(m_t1_z2));
save_item(NAME(m_t1_z5));
save_item(NAME(m_led_en));
save_item(NAME(m_reset));
}
static DEVICE_START( e05a03 )
{
e05a03_state *e05a03 = get_safe_token(device);
const e05a03_interface *intf = (const e05a03_interface *)device->baseconfig().static_config();
/* validate some basic stuff */
assert(device->baseconfig().static_config() != NULL);
/* resolve callbacks */
devcb_resolve_write_line(&e05a03->out_nlq_lp_func, &intf->out_nlq_lp_func, device);
devcb_resolve_write_line(&e05a03->out_pe_lp_func, &intf->out_pe_lp_func, device);
devcb_resolve_write_line(&e05a03->out_reso_func, &intf->out_reso_func, device);
devcb_resolve_write_line(&e05a03->out_pe_func, &intf->out_pe_func, device);
devcb_resolve_read8(&e05a03->in_data_func, &intf->in_data_func, device);
/* register for state saving */
device->save_item(NAME(e05a03->shift));
device->save_item(NAME(e05a03->busy_leading));
device->save_item(NAME(e05a03->busy_software));
device->save_item(NAME(e05a03->nlqlp));
device->save_item(NAME(e05a03->cndlp));
#if 0
device->save_item(NAME(e05a03->pe));
device->save_item(NAME(e05a03->pelp));
#endif
device->save_item(NAME(e05a03->printhead));
device->save_item(NAME(e05a03->pf_motor));
device->save_item(NAME(e05a03->cr_motor));
}
void z80dma_device::device_start()
{
// resolve callbacks
devcb_resolve_write_line(&m_out_busreq_func, &m_config.m_out_busreq_func, this);
devcb_resolve_write_line(&m_out_int_func, &m_config.m_out_int_func, this);
devcb_resolve_write_line(&m_out_bao_func, &m_config.m_out_bao_func, this);
devcb_resolve_read8(&m_in_mreq_func, &m_config.m_in_mreq_func, this);
devcb_resolve_write8(&m_out_mreq_func, &m_config.m_out_mreq_func, this);
devcb_resolve_read8(&m_in_iorq_func, &m_config.m_in_iorq_func, this);
devcb_resolve_write8(&m_out_iorq_func, &m_config.m_out_iorq_func, this);
// allocate timer
m_timer = timer_alloc(&m_machine, static_timerproc, (void *)this);
// register for state saving
state_save_register_device_item_array(this, 0, m_regs);
state_save_register_device_item_array(this, 0, m_regs_follow);
state_save_register_device_item(this, 0, m_num_follow);
state_save_register_device_item(this, 0, m_cur_follow);
state_save_register_device_item(this, 0, m_status);
state_save_register_device_item(this, 0, m_dma_enabled);
state_save_register_device_item(this, 0, m_vector);
state_save_register_device_item(this, 0, m_ip);
state_save_register_device_item(this, 0, m_ius);
state_save_register_device_item(this, 0, m_addressA);
state_save_register_device_item(this, 0, m_addressB);
state_save_register_device_item(this, 0, m_count);
state_save_register_device_item(this, 0, m_rdy);
state_save_register_device_item(this, 0, m_force_ready);
state_save_register_device_item(this, 0, m_is_read);
state_save_register_device_item(this, 0, m_cur_cycle);
state_save_register_device_item(this, 0, m_latch);
}
static DEVICE_START( z80pio )
{
const z80pio_interface *intf = (const z80pio_interface *)device->static_config;
z80pio_t *z80pio = get_safe_token( device );
devcb_resolve_write_line(&z80pio->intr, &intf->intr, device);
devcb_resolve_read8(&z80pio->port_read[0], &intf->portAread, device);
devcb_resolve_read8(&z80pio->port_read[1], &intf->portBread, device);
devcb_resolve_write8(&z80pio->port_write[0], &intf->portAwrite, device);
devcb_resolve_write8(&z80pio->port_write[1], &intf->portBwrite, device);
devcb_resolve_write_line(&z80pio->rdyr[0], &intf->rdyA, device);
devcb_resolve_write_line(&z80pio->rdyr[1], &intf->rdyB, device);
/* register for save states */
state_save_register_device_item_array(device, 0, z80pio->vector);
state_save_register_device_item_array(device, 0, z80pio->mode);
state_save_register_device_item_array(device, 0, z80pio->enable);
state_save_register_device_item_array(device, 0, z80pio->mask);
state_save_register_device_item_array(device, 0, z80pio->dir);
state_save_register_device_item_array(device, 0, z80pio->rdy);
state_save_register_device_item_array(device, 0, z80pio->in);
state_save_register_device_item_array(device, 0, z80pio->out);
state_save_register_device_item_array(device, 0, z80pio->strobe);
state_save_register_device_item_array(device, 0, z80pio->int_state);
}
static DEVICE_START( pia6821 )
{
pia6821_state *p = get_token(device);
const pia6821_interface *intf = get_interface(device);
/* clear structure */
memset(p, 0, sizeof(*p));
/* resolve callbacks */
devcb_resolve_read8(&p->in_a_func, &intf->in_a_func, device);
devcb_resolve_read8(&p->in_b_func, &intf->in_b_func, device);
devcb_resolve_read_line(&p->in_ca1_func, &intf->in_ca1_func, device);
devcb_resolve_read_line(&p->in_cb1_func, &intf->in_cb1_func, device);
devcb_resolve_read_line(&p->in_ca2_func, &intf->in_ca2_func, device);
devcb_resolve_read_line(&p->in_cb2_func, &intf->in_cb2_func, device);
devcb_resolve_write8(&p->out_a_func, &intf->out_a_func, device);
devcb_resolve_write8(&p->out_b_func, &intf->out_b_func, device);
devcb_resolve_write_line(&p->out_ca2_func, &intf->out_ca2_func, device);
devcb_resolve_write_line(&p->out_cb2_func, &intf->out_cb2_func, device);
devcb_resolve_write_line(&p->irq_a_func, &intf->irq_a_func, device);
devcb_resolve_write_line(&p->irq_b_func, &intf->irq_b_func, device);
state_save_register_device_item(device, 0, p->in_a);
state_save_register_device_item(device, 0, p->in_ca1);
state_save_register_device_item(device, 0, p->in_ca2);
state_save_register_device_item(device, 0, p->out_a);
state_save_register_device_item(device, 0, p->out_ca2);
state_save_register_device_item(device, 0, p->port_a_z_mask);
state_save_register_device_item(device, 0, p->ddr_a);
state_save_register_device_item(device, 0, p->ctl_a);
state_save_register_device_item(device, 0, p->irq_a1);
state_save_register_device_item(device, 0, p->irq_a2);
state_save_register_device_item(device, 0, p->irq_a_state);
state_save_register_device_item(device, 0, p->in_b);
state_save_register_device_item(device, 0, p->in_cb1);
state_save_register_device_item(device, 0, p->in_cb2);
state_save_register_device_item(device, 0, p->out_b);
state_save_register_device_item(device, 0, p->out_cb2);
state_save_register_device_item(device, 0, p->last_out_cb2_z);
state_save_register_device_item(device, 0, p->ddr_b);
state_save_register_device_item(device, 0, p->ctl_b);
state_save_register_device_item(device, 0, p->irq_b1);
state_save_register_device_item(device, 0, p->irq_b2);
state_save_register_device_item(device, 0, p->irq_b_state);
state_save_register_device_item(device, 0, p->in_a_pushed);
state_save_register_device_item(device, 0, p->out_a_needs_pulled);
state_save_register_device_item(device, 0, p->in_ca1_pushed);
state_save_register_device_item(device, 0, p->in_ca2_pushed);
state_save_register_device_item(device, 0, p->out_ca2_needs_pulled);
state_save_register_device_item(device, 0, p->in_b_pushed);
state_save_register_device_item(device, 0, p->out_b_needs_pulled);
state_save_register_device_item(device, 0, p->in_cb1_pushed);
state_save_register_device_item(device, 0, p->in_cb2_pushed);
state_save_register_device_item(device, 0, p->out_cb2_needs_pulled);
}
void ttl7474_device::device_start()
{
state_save_register_device_item(this, 0, m_clear);
state_save_register_device_item(this, 0, m_preset);
state_save_register_device_item(this, 0, m_clk);
state_save_register_device_item(this, 0, m_d);
state_save_register_device_item(this, 0, m_output);
state_save_register_device_item(this, 0, m_output_comp);
state_save_register_device_item(this, 0, m_last_clock);
state_save_register_device_item(this, 0, m_last_output);
state_save_register_device_item(this, 0, m_last_output_comp);
devcb_resolve_write_line(&m_output_cb, &m_config.m_output_cb, this);
devcb_resolve_write_line(&m_comp_output_cb, &m_config.m_comp_output_cb, this);
}
static DEVICE_START( cdp1852 )
{
cdp1852_t *cdp1852 = get_safe_token(device);
const cdp1852_interface *intf = get_interface(device);
/* resolve callbacks */
devcb_resolve_read8(&cdp1852->in_data_func, &intf->in_data_func, device);
devcb_resolve_write8(&cdp1852->out_data_func, &intf->out_data_func, device);
devcb_resolve_write_line(&cdp1852->out_sr_func, &intf->out_sr_func, device);
/* set initial values */
cdp1852->mode = (cdp1852_mode)intf->mode;
if (device->clock > 0)
{
/* create the scan timer */
cdp1852->scan_timer = timer_alloc(device->machine, cdp1852_scan_tick, (void *)device);
timer_adjust_periodic(cdp1852->scan_timer, attotime_zero, 0, ATTOTIME_IN_HZ(device->clock));
}
/* register for state saving */
state_save_register_device_item(device, 0, cdp1852->new_data);
state_save_register_device_item(device, 0, cdp1852->data);
state_save_register_device_item(device, 0, cdp1852->next_data);
state_save_register_device_item(device, 0, cdp1852->sr);
state_save_register_device_item(device, 0, cdp1852->next_sr);
}
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( cdp1852 )
{
cdp1852_t *cdp1852 = get_safe_token(device);
const cdp1852_interface *intf = get_interface(device);
/* resolve callbacks */
devcb_resolve_read8(&cdp1852->in_data_func, &intf->in_data_func, device);
devcb_resolve_write8(&cdp1852->out_data_func, &intf->out_data_func, device);
devcb_resolve_write_line(&cdp1852->out_sr_func, &intf->out_sr_func, device);
/* set initial values */
cdp1852->mode = (cdp1852_mode)intf->mode;
if (device->clock() > 0)
{
/* create the scan timer */
cdp1852->scan_timer = device->machine().scheduler().timer_alloc(FUNC(cdp1852_scan_tick), (void *)device);
cdp1852->scan_timer->adjust(attotime::zero, 0, attotime::from_hz(device->clock()));
}
/* register for state saving */
device->save_item(NAME(cdp1852->new_data));
device->save_item(NAME(cdp1852->data));
device->save_item(NAME(cdp1852->next_data));
device->save_item(NAME(cdp1852->sr));
device->save_item(NAME(cdp1852->next_sr));
}
void zx8301_device::device_start()
{
// get the CPU
m_cpu = m_machine.device<cpu_device>(m_config.cpu_tag);
assert(m_cpu != NULL);
// get the screen device
m_screen = m_machine.device<screen_device>(m_config.screen_tag);
assert(m_screen != NULL);
// resolve callbacks
devcb_resolve_write_line(&m_out_vsync_func, &m_config.out_vsync_func, this);
// allocate timers
m_vsync_timer = timer_alloc(TIMER_VSYNC);
m_flash_timer = timer_alloc(TIMER_FLASH);
// adjust timer periods
m_vsync_timer->adjust(attotime::zero, 0, attotime::from_hz(50));
m_flash_timer->adjust(attotime::from_hz(2), 0, attotime::from_hz(2));
// register for state saving
save_item(NAME(m_dispoff));
save_item(NAME(m_mode8));
save_item(NAME(m_base));
save_item(NAME(m_flash));
save_item(NAME(m_vsync));
save_item(NAME(m_vda));
}
void acia6850_device::device_start()
{
/* resolve callbacks */
devcb_resolve_read_line(&m_in_rx_func, &m_config.m_in_rx_func, this);
devcb_resolve_write_line(&m_out_tx_func, &m_config.m_out_tx_func, this);
devcb_resolve_read_line(&m_in_cts_func, &m_config.m_in_cts_func, this);
devcb_resolve_write_line(&m_out_rts_func, &m_config.m_out_rts_func, this);
devcb_resolve_read_line(&m_in_dcd_func, &m_config.m_in_dcd_func, this);
devcb_resolve_write_line(&m_out_irq_func, &m_config.m_out_irq_func, this);
m_rx_clock = m_config.m_rx_clock;
m_tx_clock = m_config.m_tx_clock;
m_tx_counter = 0;
m_rx_counter = 0;
m_rx_timer = m_machine.scheduler().timer_alloc(FUNC(receive_event_callback), (void *)this);
m_tx_timer = m_machine.scheduler().timer_alloc(FUNC(transmit_event_callback), (void *)this);
m_first_reset = 1;
m_status_read = 0;
m_brk = 0;
m_rx_timer->reset();
m_tx_timer->reset();
save_item(NAME(m_ctrl));
save_item(NAME(m_status));
save_item(NAME(m_rx_clock));
save_item(NAME(m_tx_clock));
save_item(NAME(m_rx_counter));
save_item(NAME(m_tx_counter));
save_item(NAME(m_rx_shift));
save_item(NAME(m_tx_shift));
save_item(NAME(m_rdr));
save_item(NAME(m_tdr));
save_item(NAME(m_rx_bits));
save_item(NAME(m_tx_bits));
save_item(NAME(m_rx_parity));
save_item(NAME(m_tx_parity));
save_item(NAME(m_tx_int));
save_item(NAME(m_divide));
save_item(NAME(m_overrun));
save_item(NAME(m_reset));
save_item(NAME(m_first_reset));
save_item(NAME(m_rts));
save_item(NAME(m_brk));
save_item(NAME(m_status_read));
}
static DEVICE_START( ti99_pcoden )
{
ti99_pcoden_state *pcode = get_safe_token(device);
/* Resolve the callbacks to the PEB */
peb_callback_if *topeb = (peb_callback_if *)device->baseconfig().static_config();
devcb_resolve_write_line(&pcode->lines.ready, &topeb->ready, device);
}
static DEVICE_START( ttl7474 )
{
ttl7474_config *config = (ttl7474_config *)downcast<const legacy_device_config_base &>(device->baseconfig()).inline_config();
ttl7474_state *state = get_safe_token(device);
devcb_resolve_write_line(&state->output_cb, &config->output_cb, device);
devcb_resolve_write_line(&state->comp_output_cb, &config->comp_output_cb, device);
state->device = device;
state_save_register_device_item(device, 0, state->clear);
state_save_register_device_item(device, 0, state->preset);
state_save_register_device_item(device, 0, state->clock);
state_save_register_device_item(device, 0, state->d);
state_save_register_device_item(device, 0, state->output);
state_save_register_device_item(device, 0, state->output_comp);
state_save_register_device_item(device, 0, state->last_clock);
state_save_register_device_item(device, 0, state->last_output);
state_save_register_device_item(device, 0, state->last_output_comp);
}
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);
}
static DEVICE_START( microdrive )
{
microdrive_t *mdv = get_safe_token(device);
const microdrive_config *config = (const microdrive_config*) device->baseconfig().static_config();
// resolve callbacks
devcb_resolve_write_line(&mdv->out_comms_out_func, &config->out_comms_out_func, device);
// allocate track buffers
mdv->left = auto_alloc_array(device->machine(), UINT8, MDV_IMAGE_LENGTH / 2);
mdv->right = auto_alloc_array(device->machine(), UINT8, MDV_IMAGE_LENGTH / 2);
// allocate timers
mdv->bit_timer = device->machine().scheduler().timer_alloc(FUNC(bit_timer_tick), (void *) device);
mdv->bit_timer->adjust(attotime::zero, 0, attotime::from_hz(MDV_BITRATE));
mdv->bit_timer->enable(0);
}
void i8155_device::device_start()
{
// resolve callbacks
devcb_resolve_read8(&m_in_port_func[0], &m_config.in_pa_func, this);
devcb_resolve_read8(&m_in_port_func[1], &m_config.in_pb_func, this);
devcb_resolve_read8(&m_in_port_func[2], &m_config.in_pc_func, this);
devcb_resolve_write8(&m_out_port_func[0], &m_config.out_pa_func, this);
devcb_resolve_write8(&m_out_port_func[1], &m_config.out_pb_func, this);
devcb_resolve_write8(&m_out_port_func[2], &m_config.out_pc_func, this);
devcb_resolve_write_line(&m_out_to_func, &m_config.out_to_func, this);
// allocate timers
m_timer = timer_alloc();
// register for state saving
save_item(NAME(m_io_m));
save_item(NAME(m_ad));
save_item(NAME(m_command));
save_item(NAME(m_status));
save_item(NAME(m_output));
save_item(NAME(m_count_length));
save_item(NAME(m_counter));
save_item(NAME(m_to));
}
void via6522_device::device_start()
{
devcb_resolve_read8(&m_in_a_func, &m_config.m_in_a_func, this);
devcb_resolve_read8(&m_in_b_func, &m_config.m_in_b_func, this);
devcb_resolve_read_line(&m_in_ca1_func, &m_config.m_in_ca1_func, this);
devcb_resolve_read_line(&m_in_cb1_func, &m_config.m_in_cb1_func, this);
devcb_resolve_read_line(&m_in_ca2_func, &m_config.m_in_ca2_func, this);
devcb_resolve_read_line(&m_in_cb2_func, &m_config.m_in_cb2_func, this);
devcb_resolve_write8(&m_out_a_func, &m_config.m_out_a_func, this);
devcb_resolve_write8(&m_out_b_func, &m_config.m_out_b_func, this);
devcb_resolve_write_line(&m_out_ca1_func, &m_config.m_out_ca1_func, this);
devcb_resolve_write_line(&m_out_cb1_func, &m_config.m_out_cb1_func, this);
devcb_resolve_write_line(&m_out_ca2_func, &m_config.m_out_ca2_func, this);
devcb_resolve_write_line(&m_out_cb2_func, &m_config.m_out_cb2_func, this);
devcb_resolve_write_line(&m_irq_func, &m_config.m_irq_func, this);
m_t1ll = 0xf3; /* via at 0x9110 in vic20 show these values */
m_t1lh = 0xb5; /* ports are not written by kernel! */
m_t2ll = 0xff; /* taken from vice */
m_t2lh = 0xff;
m_time2 = m_time1 = timer_get_time(&m_machine);
m_t1 = device_timer_alloc(*this, TIMER_T1);
m_t2 = device_timer_alloc(*this, TIMER_T2);
m_shift_timer = device_timer_alloc(*this, TIMER_SHIFT);
/* Default clock is from CPU1 */
if (clock() == 0)
{
set_unscaled_clock(m_machine.firstcpu->clock());
}
/* save state register */
state_save_register_device_item(this, 0, m_in_a);
state_save_register_device_item(this, 0, m_in_ca1);
state_save_register_device_item(this, 0, m_in_ca2);
state_save_register_device_item(this, 0, m_out_a);
state_save_register_device_item(this, 0, m_out_ca2);
state_save_register_device_item(this, 0, m_ddr_a);
state_save_register_device_item(this, 0, m_in_b);
state_save_register_device_item(this, 0, m_in_cb1);
state_save_register_device_item(this, 0, m_in_cb2);
state_save_register_device_item(this, 0, m_out_b);
state_save_register_device_item(this, 0, m_out_cb2);
state_save_register_device_item(this, 0, m_ddr_b);
state_save_register_device_item(this, 0, m_t1cl);
state_save_register_device_item(this, 0, m_t1ch);
state_save_register_device_item(this, 0, m_t1ll);
state_save_register_device_item(this, 0, m_t1lh);
state_save_register_device_item(this, 0, m_t2cl);
state_save_register_device_item(this, 0, m_t2ch);
state_save_register_device_item(this, 0, m_t2ll);
state_save_register_device_item(this, 0, m_t2lh);
state_save_register_device_item(this, 0, m_sr);
state_save_register_device_item(this, 0, m_pcr);
state_save_register_device_item(this, 0, m_acr);
state_save_register_device_item(this, 0, m_ier);
state_save_register_device_item(this, 0, m_ifr);
state_save_register_device_item(this, 0, m_t1_active);
state_save_register_device_item(this, 0, m_t2_active);
state_save_register_device_item(this, 0, m_shift_counter);
}
