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); }