VIDEO_START_MEMBER(aim65_state,aim65)
{
m_print_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(aim65_state::aim65_printer_timer),this));
m_printerRAM = std::make_unique<uint16_t[]>((600 * 10 * 2) / 2);
memset(m_printerRAM, 0, videoram_size);
VIDEO_START_CALL_MEMBER(generic);
m_printer_x = 0;
m_printer_y = 0;
m_printer_dir = 0;
m_flag_a = 0;
m_flag_b = 0;
m_printer_level = 0;
}
void beta_state::machine_start()
{
m_led_refresh_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(beta_state::led_refresh),this));
// state saving
save_item(NAME(m_eprom_oe));
save_item(NAME(m_eprom_ce));
save_item(NAME(m_eprom_addr));
save_item(NAME(m_eprom_data));
save_item(NAME(m_old_data));
save_item(NAME(m_ls145_p));
save_item(NAME(m_segment));
}
void famibox_state::machine_start()
{
m_nt_ram = auto_alloc_array(machine(), UINT8, 0x1000);
m_nt_page[0] = m_nt_ram;
m_nt_page[1] = m_nt_ram + 0x400;
m_nt_page[2] = m_nt_ram + 0x800;
m_nt_page[3] = m_nt_ram + 0xc00;
machine().device("ppu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x2000, 0x3eff, read8_delegate(FUNC(famibox_state::famibox_nt_r), this), write8_delegate(FUNC(famibox_state::famibox_nt_w), this));
machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x1fff, "ppubank1");
famicombox_bankswitch(0);
m_attract_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(famibox_state::famicombox_attract_timer_callback),this));
m_gameplay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(famibox_state::famicombox_gameplay_timer_callback),this));
m_exception_cause = 0xff;
m_exception_mask = 0;
m_attract_timer_period = 0;
m_money_reg = 0;
m_coins = 0;
}
void tms34061_device::device_start()
{
/* resolve callbak */
m_interrupt_cb.resolve();
/* reset the data */
m_vrammask = m_vramsize - 1;
/* allocate memory for VRAM */
m_vram = auto_alloc_array_clear(machine(), UINT8, m_vramsize + 256 * 2);
/* allocate memory for latch RAM */
m_latchram = auto_alloc_array_clear(machine(), UINT8, m_vramsize + 256 * 2);
/* add some buffer space for VRAM and latch RAM */
m_vram += 256;
m_latchram += 256;
/* point the shift register to the base of VRAM for now */
m_shiftreg = m_vram;
/* initialize registers to their default values from the manual */
m_regs[TMS34061_HORENDSYNC] = 0x0010;
m_regs[TMS34061_HORENDBLNK] = 0x0020;
m_regs[TMS34061_HORSTARTBLNK] = 0x01f0;
m_regs[TMS34061_HORTOTAL] = 0x0200;
m_regs[TMS34061_VERENDSYNC] = 0x0004;
m_regs[TMS34061_VERENDBLNK] = 0x0010;
m_regs[TMS34061_VERSTARTBLNK] = 0x00f0;
m_regs[TMS34061_VERTOTAL] = 0x0100;
m_regs[TMS34061_DISPUPDATE] = 0x0000;
m_regs[TMS34061_DISPSTART] = 0x0000;
m_regs[TMS34061_VERINT] = 0x0000;
m_regs[TMS34061_CONTROL1] = 0x7000;
m_regs[TMS34061_CONTROL2] = 0x0600;
m_regs[TMS34061_STATUS] = 0x0000;
m_regs[TMS34061_XYOFFSET] = 0x0010;
m_regs[TMS34061_XYADDRESS] = 0x0000;
m_regs[TMS34061_DISPADDRESS] = 0x0000;
m_regs[TMS34061_VERCOUNTER] = 0x0000;
/* start vertical interrupt timer */
m_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tms34061_device::interrupt), this));
save_item(NAME(m_regs));
save_item(NAME(m_xmask));
save_item(NAME(m_yshift));
save_pointer(NAME(m_vram), m_vramsize);
save_pointer(NAME(m_latchram), m_vramsize);
save_item(NAME(m_latchdata));
}
MACHINE_START_MEMBER(gb_state,sgb)
{
m_sgb_packets = -1;
/* Allocate the serial timer, and disable it */
m_gb_serial_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(gb_state::gb_serial_timer_proc),this));
m_gb_serial_timer->enable( 0 );
save_gb_base();
save_sgb_only();
if (m_cartslot && m_cartslot->get_sgb_hack())
machine().device<sgb_lcd_device>("lcd")->set_sgb_hack(TRUE);
}
void kbdc8042_device::device_start()
{
// resolve callbacks
m_system_reset_func.resolve(m_system_reset_cb, *this);
m_gate_a20_func.resolve(m_gate_a20_cb, *this);
m_input_buffer_full_func.resolve(m_input_buffer_full_cb, *this);
m_output_buffer_empty_func.resolve(m_output_buffer_empty_cb, *this);
m_speaker_func.resolve(m_speaker_cb, *this);
m_getout2_func.resolve(m_getout2_cb, *this);
machine().scheduler().timer_pulse(attotime::from_hz(60), timer_expired_delegate(FUNC(kbdc8042_device::kbdc8042_time),this));
at_keyboard_init(machine(), AT_KEYBOARD_TYPE_AT);
at_keyboard_set_scan_code_set(1);
m_operation_write_state = 0; /* first write to 0x60 might occur before anything can set this */
}
void amis2152_cpu_device::device_start()
{
amis2000_base_device::device_start();
m_d2f_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(amis2152_cpu_device::d2f_timer_cb), this));
// zerofill
m_d2f_latch = 0;
m_fout_state = 0;
// register for savestates
save_item(NAME(m_d2f_latch));
save_item(NAME(m_fout_state));
}
void mame_machine_manager::create_custom(running_machine& machine)
{
// start the inifile manager
m_inifile = std::make_unique<inifile_manager>(machine, m_ui->options());
// allocate autoboot timer
m_autoboot_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(mame_machine_manager::autoboot_callback), this));
// start favorite manager
m_favorite = std::make_unique<favorite_manager>(machine, m_ui->options());
// set up the cheat engine
m_cheat = std::make_unique<cheat_manager>(machine);
}
void sprint4_state::machine_reset()
{
machine().scheduler().timer_set(machine().primary_screen->time_until_pos(32), timer_expired_delegate(FUNC(sprint4_state::nmi_callback),this), 32);
memset(m_steer_FF1, 0, sizeof m_steer_FF1);
memset(m_steer_FF2, 0, sizeof m_steer_FF2);
m_gear[0] = 1;
m_gear[1] = 1;
m_gear[2] = 1;
m_gear[3] = 1;
m_da_latch = 0;
}
void pb1000_state::machine_start()
{
std::string region_tag;
m_rom_reg = memregion("rom");
if (m_card1)
m_card1_reg = memregion(region_tag.assign(m_card1->tag()).append(GENERIC_ROM_REGION_TAG).c_str());
if (m_card2)
m_card2_reg = memregion(region_tag.assign(m_card2->tag()).append(GENERIC_ROM_REGION_TAG).c_str());
membank("bank1")->set_base(m_rom_reg->base());
m_kb_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pb1000_state::keyboard_timer),this));
m_kb_timer->adjust(attotime::from_hz(192), 0, attotime::from_hz(192));
}
void cdislave_device::device_start()
{
save_item(NAME(m_channel[0].m_out_buf[0]));
save_item(NAME(m_channel[0].m_out_buf[1]));
save_item(NAME(m_channel[0].m_out_buf[2]));
save_item(NAME(m_channel[0].m_out_buf[3]));
save_item(NAME(m_channel[0].m_out_index));
save_item(NAME(m_channel[0].m_out_count));
save_item(NAME(m_channel[0].m_out_cmd));
save_item(NAME(m_channel[1].m_out_buf[0]));
save_item(NAME(m_channel[1].m_out_buf[1]));
save_item(NAME(m_channel[1].m_out_buf[2]));
save_item(NAME(m_channel[1].m_out_buf[3]));
save_item(NAME(m_channel[1].m_out_index));
save_item(NAME(m_channel[1].m_out_count));
save_item(NAME(m_channel[1].m_out_cmd));
save_item(NAME(m_channel[2].m_out_buf[0]));
save_item(NAME(m_channel[2].m_out_buf[1]));
save_item(NAME(m_channel[2].m_out_buf[2]));
save_item(NAME(m_channel[2].m_out_buf[3]));
save_item(NAME(m_channel[2].m_out_index));
save_item(NAME(m_channel[2].m_out_count));
save_item(NAME(m_channel[2].m_out_cmd));
save_item(NAME(m_channel[3].m_out_buf[0]));
save_item(NAME(m_channel[3].m_out_buf[1]));
save_item(NAME(m_channel[3].m_out_buf[2]));
save_item(NAME(m_channel[3].m_out_buf[3]));
save_item(NAME(m_channel[3].m_out_index));
save_item(NAME(m_channel[3].m_out_count));
save_item(NAME(m_channel[3].m_out_cmd));
save_item(NAME(m_in_buf));
save_item(NAME(m_in_index));
save_item(NAME(m_in_count));
save_item(NAME(m_polling_active));
save_item(NAME(m_xbus_interrupt_enable));
save_item(NAME(m_lcd_state));
save_item(NAME(m_real_mouse_x));
save_item(NAME(m_real_mouse_y));
save_item(NAME(m_fake_mouse_x));
save_item(NAME(m_fake_mouse_y));
m_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(cdislave_device::trigger_readback_int), this));
m_interrupt_timer->adjust(attotime::never);
}
void irisha_state::machine_start()
{
static const char *const keynames[] = {
"LINE0", "LINE1", "LINE2", "LINE3", "LINE4",
"LINE5", "LINE6", "LINE7", "LINE8", "LINE9"
};
for ( int i = 0; i < 10; i++ )
{
m_io_ports[i] = ioport( keynames[i] );
}
machine().scheduler().timer_pulse(attotime::from_msec(30), timer_expired_delegate(FUNC(irisha_state::irisha_key),this));
}
INPUT_PORTS_END
MACHINE_START_MEMBER(moo_state,moo)
{
save_item(NAME(m_cur_control2));
save_item(NAME(m_alpha_enabled));
save_item(NAME(m_sprite_colorbase));
save_item(NAME(m_layer_colorbase));
save_item(NAME(m_layerpri));
save_item(NAME(m_protram));
m_dmaend_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(moo_state::dmaend_callback),this));
}
void z80ctc_device::ctc_channel::start(z80ctc_device *device, int index)
{
// initialize state
m_device = device;
m_index = index;
m_timer = m_device->machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(z80ctc_device::ctc_channel::timer_callback), this));
// register for save states
m_device->save_item(NAME(m_mode), m_index);
m_device->save_item(NAME(m_tconst), m_index);
m_device->save_item(NAME(m_down), m_index);
m_device->save_item(NAME(m_extclk), m_index);
m_device->save_item(NAME(m_int_state), m_index);
}
void ay31015_device::device_start()
{
m_read_si.resolve(read_si_cb, *this);
m_write_so.resolve(write_so_cb, *this);
m_status_changed.resolve(status_changed_cb, *this);
m_tx_clock = transmitter_clock;
m_rx_clock = receiver_clock;
m_rx_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(ay31015_device::rx_process),this));
m_tx_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(ay31015_device::tx_process),this));
update_rx_timer();
update_tx_timer();
save_item(NAME(m_pins));
save_item(NAME(m_control_reg));
save_item(NAME(m_status_reg));
save_item(NAME(m_second_stop_bit));
save_item(NAME(m_total_pulses));
save_item(NAME(m_internal_sample));
save_item(NAME(m_rx_state));
save_item(NAME(m_rx_data));
save_item(NAME(m_rx_buffer));
save_item(NAME(m_rx_bit_count));
save_item(NAME(m_rx_parity));
save_item(NAME(m_rx_pulses));
save_item(NAME(m_rx_clock));
save_item(NAME(m_tx_state));
save_item(NAME(m_tx_data));
save_item(NAME(m_tx_buffer));
save_item(NAME(m_tx_parity));
save_item(NAME(m_tx_pulses));
save_item(NAME(m_tx_clock));
}
ROM_END
DRIVER_INIT_MEMBER(sslam_state,sslam)
{
m_track = 0;
m_melody = 0;
m_bar = 0;
save_item(NAME(m_track));
save_item(NAME(m_melody));
save_item(NAME(m_bar));
save_item(NAME(m_snd_bank));
m_music_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(sslam_state::music_playback),this));
}
MACHINE_START_MEMBER( mc1502_state, mc1502 )
{
DBG_LOG(0,"init",("machine_start()\n"));
/*
Keyboard polling circuit holds IRQ1 high until a key is
pressed, then it starts a timer that pulses IRQ1 low each
40ms (check) for 20ms (check) until all keys are released.
Last pulse causes BIOS to write a 'break' scancode into port 60h.
*/
m_pic8259->ir1_w(1);
memset(&m_kbd, 0, sizeof(m_kbd));
m_kbd.keyb_signal_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(mc1502_state::keyb_signal_callback),this));
m_kbd.keyb_signal_timer->adjust( attotime::from_msec(20), 0, attotime::from_msec(20) );
}
void pecom_state::machine_start()
{
static const char *const keynames[] = {
"LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7",
"LINE8", "LINE9", "LINE10", "LINE11", "LINE12", "LINE13", "LINE14", "LINE15", "LINE16",
"LINE17", "LINE18", "LINE19", "LINE20", "LINE21", "LINE22", "LINE23", "LINE24","LINE25"
};
for ( int i = 0; i < 26; i++ )
{
m_io_ports[i] = ioport(keynames[i]);
}
m_reset_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(pecom_state::reset_tick),this));
}
MACHINE_CONFIG_END
MACHINE_START_MEMBER(md_boot_state, md_6button)
{
MACHINE_START_CALL_MEMBER(md_bootleg);
m_io_pad_6b[0] = ioport("EXTRA1");
m_io_pad_6b[1] = ioport("EXTRA2");
m_io_pad_6b[2] = ioport("IN0");
m_io_pad_6b[3] = ioport("UNK");
// setup timers for 6 button pads
for (int i = 0; i < 3; i++)
m_io_timeout[i] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(md_base_state::io_timeout_timer_callback),this), (void*)(FPTR)i);
}
void sorcerer_state::machine_reset()
{
address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
/* Initialize cassette interface */
m_cass_data.output.length = 0;
m_cass_data.output.level = 1;
m_cass_data.input.length = 0;
m_cass_data.input.bit = 1;
m_fe = 0xff;
sorcerer_fe_w(space, 0, 0, 0xff);
membank("boot")->set_entry(1);
machine().scheduler().timer_set(attotime::from_usec(10), timer_expired_delegate(FUNC(sorcerer_state::sorcerer_reset),this));
}
INPUT_PORTS_END
/******************************************************************************
Machine Drivers
******************************************************************************/
TIMER_CALLBACK_MEMBER(dectalk_state::outfifo_read_cb)
{
UINT16 data;
dac_device *speaker = machine().device<dac_device>("dac");
data = dectalk_outfifo_r(machine());
#ifdef VERBOSE
if (data!= 0x8000) logerror("sample output: %04X\n", data);
#endif
machine().scheduler().timer_set(attotime::from_hz(10000), timer_expired_delegate(FUNC(dectalk_state::outfifo_read_cb),this));
speaker->write_signed16(data);
}
void kbdc8042_device::at_8042_receive(UINT8 data)
{
if (LOG_KEYBOARD)
logerror("at_8042_receive Received 0x%02x\n", data);
m_data = data;
m_keyboard.received = 1;
if (!m_input_buffer_full_cb.isnull())
{
m_input_buffer_full_cb(1);
/* Lets 8952's timers do their job before clear the interrupt line, */
/* else Keyboard interrupt never happens. */
machine().scheduler().timer_set(attotime::from_usec(2), timer_expired_delegate(FUNC(kbdc8042_device::kbdc8042_clr_int),this));
}
}
void v3021_device::device_start()
{
/* let's call the timer callback every second */
machine().scheduler().timer_pulse(attotime::from_hz(clock() / XTAL_32_768kHz), timer_expired_delegate(FUNC(v3021_device::timer_callback),this));
system_time systime;
machine().base_datetime(systime);
m_rtc.day = ((systime.local_time.mday / 10)<<4) | ((systime.local_time.mday % 10) & 0xf);
m_rtc.month = (((systime.local_time.month+1) / 10) << 4) | (((systime.local_time.month+1) % 10) & 0xf);
m_rtc.wday = 1 << systime.local_time.weekday;
m_rtc.year = (((systime.local_time.year % 100)/10)<<4) | ((systime.local_time.year % 10) & 0xf);
m_rtc.hour = ((systime.local_time.hour / 10)<<4) | ((systime.local_time.hour % 10) & 0xf);
m_rtc.min = ((systime.local_time.minute / 10)<<4) | ((systime.local_time.minute % 10) & 0xf);
m_rtc.sec = ((systime.local_time.second / 10)<<4) | ((systime.local_time.second % 10) & 0xf);
}
VIDEO_START_MEMBER(atarisy2_state,atarisy2)
{
/* initialize banked memory */
m_alpha_tilemap->basemem().set(&m_vram[0x0000], 0x2000, 16, ENDIANNESS_NATIVE, 2);
m_playfield_tilemap->basemem().set(&m_vram[0x2000], 0x2000, 16, ENDIANNESS_NATIVE, 2);
m_mob->set_spriteram(&m_vram[0x0c00], 0x0400);
/* reset the statics */
m_yscroll_reset_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(atarisy2_state::reset_yscroll_callback),this));
m_videobank = 0;
/* save states */
save_item(NAME(m_playfield_tile_bank));
save_item(NAME(m_videobank));
save_item(NAME(m_vram));
}
GFXDECODE_END
/*************************************
*
* Machine setup
*
*************************************/
void orbit_state::machine_start()
{
m_irq_off_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(orbit_state::irq_off), this));
save_item(NAME(m_flip_screen));
}
void psxrcnt_device::device_start()
{
int n;
m_irq0_handler.resolve_safe();
m_irq1_handler.resolve_safe();
m_irq2_handler.resolve_safe();
for( n = 0; n < 3; n++ )
{
root_counter[ n ].timer = machine().scheduler().timer_alloc( timer_expired_delegate( FUNC( psxrcnt_device::root_finished ), this ) );
state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_count );
state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_mode );
state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_target );
state_save_register_item( machine(), "psxroot", NULL, n, root_counter[ n ].n_start );
}
}
void dio16_98544_device::device_start()
{
// set_nubus_device makes m_slot valid
set_dio_device();
m_rom = device().machine().root_device().memregion(this->subtag(HP98544_ROM_REGION).c_str())->base();
m_vram.resize(VRAM_SIZE);
m_dio->install_memory(0x200000, 0x2fffff, read16_delegate(FUNC(dio16_98544_device::vram_r), this),
write16_delegate(FUNC(dio16_98544_device::vram_w), this));
m_dio->install_memory(0x560000, 0x563fff, read16_delegate(FUNC(dio16_98544_device::rom_r), this),
write16_delegate(FUNC(dio16_98544_device::rom_w), this));
m_dio->install_memory(0x564000, 0x567fff, read16_delegate(FUNC(dio16_98544_device::ctrl_r), this),
write16_delegate(FUNC(dio16_98544_device::ctrl_w), this));
m_cursor_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(dio16_98544_device::cursor_callback),this));
m_cursor_timer->adjust(attotime::from_hz(3));
}
void itech32_state::video_start()
{
int i;
/* allocate memory */
m_videoram = std::make_unique<UINT16[]>(VRAM_WIDTH * (m_vram_height + 16) * 2);
memset(m_videoram.get(), 0xff, VRAM_WIDTH * (m_vram_height + 16) * 2 * 2);
/* videoplane[0] is the foreground; videoplane[1] is the background */
m_videoplane[0] = &m_videoram[0 * VRAM_WIDTH * (m_vram_height + 16) + 8 * VRAM_WIDTH];
m_videoplane[1] = &m_videoram[1 * VRAM_WIDTH * (m_vram_height + 16) + 8 * VRAM_WIDTH];
/* set the masks */
m_vram_mask = VRAM_WIDTH * m_vram_height - 1;
m_vram_xmask = VRAM_WIDTH - 1;
m_vram_ymask = m_vram_height - 1;
/* clear the planes initially */
for (i = 0; i < VRAM_WIDTH * m_vram_height; i++)
m_videoplane[0][i] = m_videoplane[1][i] = 0xff;
/* fetch the GROM base */
m_grom_base = memregion("gfx1")->base();
m_grom_size = memregion("gfx1")->bytes();
m_grom_bank = 0;
m_grom_bank_mask = m_grom_size >> 24;
if (m_grom_bank_mask == 2)
m_grom_bank_mask = 3;
/* reset statics */
memset(m_video, 0, 0x80);
m_scanline_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(itech32_state::scanline_interrupt),this));
m_enable_latch[0] = 1;
m_enable_latch[1] = (m_planes > 1) ? 1 : 0;
save_item(NAME(m_xfer_xcount));
save_item(NAME(m_xfer_ycount));
save_item(NAME(m_xfer_xcur));
save_item(NAME(m_xfer_ycur));
save_item(NAME(m_grom_bank));
save_item(NAME(m_color_latch));
save_item(NAME(m_enable_latch));
save_pointer(NAME(m_videoram.get()), VRAM_WIDTH * (m_vram_height + 16) * 2);
}
void tmp68301_device::device_start()
{
int i;
for (i = 0; i < 3; i++)
m_tmp68301_timer[i] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tmp68301_device::timer_callback), this));
m_in_parallel_cb.resolve_safe(0);
m_out_parallel_cb.resolve_safe();
save_item(NAME(m_regs));
save_item(NAME(m_icr));
save_item(NAME(m_irq_vector));
save_item(NAME(m_imr));
save_item(NAME(m_iisr));
save_item(NAME(m_scr));
save_item(NAME(m_pdir));
save_item(NAME(m_pdr));
}
void xexex_state::machine_start()
{
membank("z80bank")->configure_entries(0, 8, memregion("audiocpu")->base(), 0x4000);
membank("z80bank")->set_entry(0);
save_item(NAME(m_cur_alpha));
save_item(NAME(m_sprite_colorbase));
save_item(NAME(m_layer_colorbase));
save_item(NAME(m_layerpri));
save_item(NAME(m_suspension_active));
save_item(NAME(m_frame));
save_item(NAME(m_cur_control2));
machine().save().register_postload(save_prepost_delegate(FUNC(xexex_state::xexex_postload), this));
m_dmadelay_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(xexex_state::dmaend_callback),this));
}
