自学教程：C++ write32_delegate函数代码示例

void gt64xxx_device::map_cpu_space(){	UINT32 winStart, winEnd;	// ROM region starts at 0x1fc00000	m_cpu_space->unmap_readwrite(0x00000000, 0x1fbfffff);	m_cpu_space->unmap_readwrite(0x20000000, 0xffffffff);	// Clear fastram regions in cpu after rom	m_cpu->clear_fastram(1);	// CPU Regs	winStart = m_reg[GREG_INTERNAL_SPACE]<<21;	winEnd = winStart + sizeof(m_reg) - 1;	m_cpu_space->install_device(winStart, winEnd, *static_cast<gt64xxx_device *>(this), &gt64xxx_device::cpu_map);	if (LOG_GALILEO)		logerror("%s: map_cpu_space cpu_reg start: %08X end: %08X/n", tag(), winStart, winEnd);	// Ras0	winStart = (m_reg[GREG_RAS_1_0_LO]<<21) | (m_reg[GREG_RAS0_LO]<<20);	winEnd =   (m_reg[GREG_RAS_1_0_LO]<<21) | (m_reg[GREG_RAS0_HI]<<20) | 0xfffff;	m_ram[0].resize((winEnd+1-winStart)/4);	m_cpu_space->install_ram(winStart, winEnd, &m_ram[0][0]);	m_cpu->add_fastram(winStart, m_ram[0].size()*sizeof(m_ram[0][0]), FALSE, &m_ram[0][0]);	if (LOG_GALILEO)		logerror("%s: map_cpu_space ras0 start: %08X end: %08X/n", tag(), winStart, winEnd);	// PCI IO Window	winStart = m_reg[GREG_PCI_IO_LO]<<21;	winEnd =   (m_reg[GREG_PCI_IO_LO]<<21) | (m_reg[GREG_PCI_IO_HI]<<21) | 0x1fffff;	m_cpu_space->install_read_handler(winStart, winEnd, 0, 0, read32_delegate(FUNC(gt64xxx_device::master_io_r), this));	m_cpu_space->install_write_handler(winStart, winEnd, 0, 0, write32_delegate(FUNC(gt64xxx_device::master_io_w), this));	if (LOG_GALILEO)		logerror("%s: map_cpu_space pci_io start: %08X end: %08X/n", tag(), winStart, winEnd);	// PCI MEM0 Window	winStart = m_reg[GREG_PCI_MEM0_LO]<<21;	winEnd =   (m_reg[GREG_PCI_MEM0_LO]<<21) | (m_reg[GREG_PCI_MEM0_HI]<<21) | 0x1fffff;	m_cpu_space->install_read_handler(winStart, winEnd, 0, 0, read32_delegate(FUNC(gt64xxx_device::master_mem0_r), this));	m_cpu_space->install_write_handler(winStart, winEnd, 0, 0, write32_delegate(FUNC(gt64xxx_device::master_mem0_w), this));	if (LOG_GALILEO)		logerror("%s: map_cpu_space pci_mem0 start: %08X end: %08X/n", tag(), winStart, winEnd);	// PCI MEM1 Window	winStart = m_reg[GREG_PCI_MEM1_LO]<<21;	winEnd =   (m_reg[GREG_PCI_MEM1_LO]<<21) | (m_reg[GREG_PCI_MEM1_HI]<<21) | 0x1fffff;	m_cpu_space->install_read_handler(winStart, winEnd, 0, 0, read32_delegate(FUNC(gt64xxx_device::master_mem1_r), this));	m_cpu_space->install_write_handler(winStart, winEnd, 0, 0, write32_delegate(FUNC(gt64xxx_device::master_mem1_w), this));	if (LOG_GALILEO)		logerror("%s: map_cpu_space pci_mem1 start: %08X end: %08X/n", tag(), winStart, winEnd);}

void gt64xxx_device::map_extra(UINT64 memory_window_start, UINT64 memory_window_end, UINT64 memory_offset, address_space *memory_space,									UINT64 io_window_start, UINT64 io_window_end, UINT64 io_offset, address_space *io_space){	int ramIndex;	UINT32 winStart, winEnd, winSize;	// Not sure if GREG_RAS_1_0_LO should be added on PCI address map side.	// RAS0	ramIndex = 0;	winStart = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_LO + 0x8 / 4 * ramIndex] << 20);	winEnd = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_HI + 0x8 / 4 * ramIndex] << 20) | 0xfffff;	winSize = winEnd - winStart + 1;	memory_space->install_read_handler(winStart, winEnd, read32_delegate(FUNC(gt64xxx_device::ras_0_r), this));	memory_space->install_write_handler(winStart, winEnd, write32_delegate(FUNC(gt64xxx_device::ras_0_w), this));	if (LOG_GALILEO)		logerror("%s: map_extra RAS0 start=%08X end=%08X size=%08X/n", tag(), winStart, winEnd, winSize);	// RAS1	ramIndex = 1;	winStart = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_LO + 0x8 / 4 * ramIndex] << 20);	winEnd = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_HI + 0x8 / 4 * ramIndex] << 20) | 0xfffff;	winSize = winEnd - winStart + 1;	memory_space->install_read_handler(winStart, winEnd, read32_delegate(FUNC(gt64xxx_device::ras_1_r), this));	memory_space->install_write_handler(winStart, winEnd, write32_delegate(FUNC(gt64xxx_device::ras_1_w), this));	if (LOG_GALILEO)		logerror("%s: map_extra RAS1 start=%08X end=%08X size=%08X/n", tag(), winStart, winEnd, winSize);	// RAS2	ramIndex = 2;	winStart = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_LO + 0x8 / 4 * ramIndex] << 20);	winEnd = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_HI + 0x8 / 4 * ramIndex] << 20) | 0xfffff;	winSize = winEnd - winStart + 1;	memory_space->install_read_handler(winStart, winEnd, read32_delegate(FUNC(gt64xxx_device::ras_2_r), this));	memory_space->install_write_handler(winStart, winEnd, write32_delegate(FUNC(gt64xxx_device::ras_2_w), this));	if (LOG_GALILEO)		logerror("%s: map_extra RAS2 start=%08X end=%08X size=%08X/n", tag(), winStart, winEnd, winSize);	// RAS3	ramIndex = 3;	winStart = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_LO + 0x8 / 4 * ramIndex] << 20);	winEnd = (m_reg[GREG_RAS_1_0_LO + 0x10 / 4 * (ramIndex / 2)] << 21) | (m_reg[GREG_RAS0_HI + 0x8 / 4 * ramIndex] << 20) | 0xfffff;	winSize = winEnd - winStart + 1;	memory_space->install_read_handler(winStart, winEnd, read32_delegate(FUNC(gt64xxx_device::ras_3_r), this));	memory_space->install_write_handler(winStart, winEnd, write32_delegate(FUNC(gt64xxx_device::ras_3_w), this));	if (LOG_GALILEO)		logerror("%s: map_extra RAS3 start=%08X end=%08X size=%08X/n", tag(), winStart, winEnd, winSize);}

void devcb_write_base::reset(callback_type type){	// parent first	devcb_base::reset(type);	// local stuff	m_writeline = write_line_delegate();	m_write8 = write8_delegate();	m_write16 = write16_delegate();	m_write32 = write32_delegate();	m_write64 = write64_delegate();	m_adapter = &devcb_write_base::write_unresolved_adapter;}

void rastersp_state::machine_start(){	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(rastersp_state::irq_callback),this));	m_nvram8 = auto_alloc_array(machine(), UINT8, NVRAM_SIZE);	m_palette = auto_alloc_array(machine(), UINT16, 0x8000);	membank("bank1")->set_base(m_dram);	membank("bank2")->set_base(&m_dram[0x10000/4]);	membank("bank3")->set_base(&m_dram[0x300000/4]);#if USE_SPEEDUP_HACK	m_dsp->space(AS_PROGRAM).install_read_handler(0x809923, 0x809923, read32_delegate(FUNC(rastersp_state::dsp_speedup_r), this));	m_dsp->space(AS_PROGRAM).install_write_handler(0x809923, 0x809923, write32_delegate(FUNC(rastersp_state::dsp_speedup_w), this));#endif}

void rastersp_state::machine_start(){	m_nvram8 = std::make_unique<uint8_t[]>(NVRAM_SIZE);	m_nvram->set_base(m_nvram8.get(),NVRAM_SIZE);	m_paletteram = std::make_unique<uint16_t[]>(0x8000);	membank("bank1")->set_base(m_dram);	membank("bank2")->set_base(&m_dram[0x10000/4]);	membank("bank3")->set_base(&m_dram[0x300000/4]);	if (!m_tms_timer1)		m_tms_timer1 = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(rastersp_state::tms_timer1), this));	if (!m_tms_tx_timer)		m_tms_tx_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(rastersp_state::tms_tx_timer), this));#if USE_SPEEDUP_HACK	m_dsp->space(AS_PROGRAM).install_read_handler(0x809923, 0x809923, read32_delegate(FUNC(rastersp_state::dsp_speedup_r), this));	m_dsp->space(AS_PROGRAM).install_write_handler(0x809923, 0x809923, write32_delegate(FUNC(rastersp_state::dsp_speedup_w), this));#endif}

void nubus_mac8390_device::device_start(){	UINT32 slotspace;	char mac[7];	UINT32 num = rand();	memset(m_prom, 0x57, 16);	sprintf(mac+2, "/x1b%c%c%c", (num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff);	mac[0] = mac[1] = 0;  // avoid gcc warning	memcpy(m_prom, mac, 6);	m_dp83902->set_mac(mac);	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, MAC8390_ROM_REGION, true);	slotspace = get_slotspace();//  printf("[ASNTMC3NB %p] slotspace = %x/n", this, slotspace);	// TODO: move 24-bit mirroring down into nubus.c	UINT32 ofs_24bit = m_slot<<20;	m_nubus->install_device(slotspace+0xd0000, slotspace+0xdffff, read8_delegate(FUNC(nubus_mac8390_device::asntm3b_ram_r), this), write8_delegate(FUNC(nubus_mac8390_device::asntm3b_ram_w), this));	m_nubus->install_device(slotspace+0xe0000, slotspace+0xe003f, read32_delegate(FUNC(nubus_mac8390_device::en_r), this), write32_delegate(FUNC(nubus_mac8390_device::en_w), this));	m_nubus->install_device(slotspace+0xd0000+ofs_24bit, slotspace+0xdffff+ofs_24bit, read8_delegate(FUNC(nubus_mac8390_device::asntm3b_ram_r), this), write8_delegate(FUNC(nubus_mac8390_device::asntm3b_ram_w), this));	m_nubus->install_device(slotspace+0xe0000+ofs_24bit, slotspace+0xe003f+ofs_24bit, read32_delegate(FUNC(nubus_mac8390_device::en_r), this), write32_delegate(FUNC(nubus_mac8390_device::en_w), this));}

void nubus_vikbw_device::device_start(){	uint32_t slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, VIKBW_ROM_REGION, true);	slotspace = get_slotspace();//  printf("[vikbw %p] slotspace = %x/n", this, slotspace);	m_vram.resize(VRAM_SIZE);	install_bank(slotspace+0x40000, slotspace+0x40000+VRAM_SIZE-1, "bank_vikbw", &m_vram[0]);	install_bank(slotspace+0x940000, slotspace+0x940000+VRAM_SIZE-1, "bank_vikbw2", &m_vram[0]);	m_nubus->install_device(slotspace, slotspace+3, read32_delegate(FUNC(nubus_vikbw_device::viking_enable_r), this), write32_delegate(FUNC(nubus_vikbw_device::viking_disable_w), this));	m_nubus->install_device(slotspace+0x80000, slotspace+0x80000+3, read32_delegate(FUNC(nubus_vikbw_device::viking_ack_r), this), write32_delegate(FUNC(nubus_vikbw_device::viking_ack_w), this));}

void jmfb_device::device_start(){	UINT32 slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, GC48_ROM_REGION);	slotspace = get_slotspace();//  printf("[JMFB %p] slotspace = %x/n", this, slotspace);	m_vram.resize(VRAM_SIZE);	install_bank(slotspace, slotspace+VRAM_SIZE-1, 0, 0, "bank_48gc", &m_vram[0]);	m_nubus->install_device(slotspace+0x200000, slotspace+0x2003ff, read32_delegate(FUNC(jmfb_device::mac_48gc_r), this), write32_delegate(FUNC(jmfb_device::mac_48gc_w), this));	m_timer = timer_alloc(0, NULL);	m_screen = NULL;    // can we look this up now?}

void nubus_xceedmc30_device::device_start(){	UINT32 slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, XCEEDMC30_ROM_REGION);	slotspace = get_slotspace();//  printf("[xceedmc30 %p] slotspace = %x/n", this, slotspace);	m_vram = auto_alloc_array(machine(), UINT8, VRAM_SIZE);	m_vram32 = (UINT32 *)m_vram;	m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_xceedmc30_device::vram_r), this), write32_delegate(FUNC(nubus_xceedmc30_device::vram_w), this));	m_nubus->install_device(slotspace+0x800000, slotspace+0xefffff, read32_delegate(FUNC(nubus_xceedmc30_device::xceedmc30_r), this), write32_delegate(FUNC(nubus_xceedmc30_device::xceedmc30_w), this));	m_timer = timer_alloc(0, NULL);	m_timer->adjust(m_screen->time_until_pos(479, 0), 0);}

void nubus_image_device::device_start(){	UINT32 slotspace;	UINT32 superslotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, IMAGE_ROM_REGION);	slotspace = get_slotspace();	superslotspace = get_super_slotspace();//  printf("[image %p] slotspace = %x, super = %x/n", this, slotspace, superslotspace);	m_nubus->install_device(slotspace, slotspace+3, read32_delegate(FUNC(nubus_image_device::image_r), this), write32_delegate(FUNC(nubus_image_device::image_w), this));	m_nubus->install_device(slotspace+4, slotspace+7, read32_delegate(FUNC(nubus_image_device::image_status_r), this), write32_delegate(FUNC(nubus_image_device::image_status_w), this));	m_nubus->install_device(slotspace+8, slotspace+11, read32_delegate(FUNC(nubus_image_device::file_cmd_r), this), write32_delegate(FUNC(nubus_image_device::file_cmd_w), this));	m_nubus->install_device(slotspace+12, slotspace+15, read32_delegate(FUNC(nubus_image_device::file_data_r), this), write32_delegate(FUNC(nubus_image_device::file_data_w), this));	m_nubus->install_device(slotspace+16, slotspace+19, read32_delegate(FUNC(nubus_image_device::file_len_r), this), write32_delegate(FUNC(nubus_image_device::file_len_w), this));	m_nubus->install_device(slotspace+20, slotspace+147, read32_delegate(FUNC(nubus_image_device::file_name_r), this), write32_delegate(FUNC(nubus_image_device::file_name_w), this));	m_nubus->install_device(superslotspace, superslotspace+((256*1024*1024)-1), read32_delegate(FUNC(nubus_image_device::image_super_r), this), write32_delegate(FUNC(nubus_image_device::image_super_w), this));	m_image = subdevice<messimg_disk_image_device>(IMAGE_DISK0_TAG);	filectx.curdir[0] = '.';	filectx.curdir[1] = '/0';	filectx.dirp = nullptr;	filectx.fd = nullptr;}

DRIVER_INIT_MEMBER(pgm_arm_type2_state,martmast){	pgm_basic_init();	pgm_mm_decrypt(machine());	kov2_latch_init();	// we only have a USA / CHINA internal ROMs dumped for now, allow us to override that for debugging purposes.	machine().device("prot")->memory().space(AS_PROGRAM).install_write_handler(0x48000138, 0x4800013b, write32_delegate(FUNC(pgm_arm_type2_state::martmast_arm_region_w),this));}

void nubus_radiustpd_device::device_start(){	UINT32 slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, RADIUSTPD_ROM_REGION, true, true);	slotspace = get_slotspace();	printf("[radiustpd %p] slotspace = %x/n", this, slotspace);	m_vram.resize(VRAM_SIZE);	m_vram32 = (UINT32 *)&m_vram[0];	m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_radiustpd_device::vram_r), this), write32_delegate(FUNC(nubus_radiustpd_device::vram_w), this));	m_nubus->install_device(slotspace+0x900000, slotspace+VRAM_SIZE-1+0x900000, read32_delegate(FUNC(nubus_radiustpd_device::vram_r), this), write32_delegate(FUNC(nubus_radiustpd_device::vram_w), this));	m_nubus->install_device(slotspace+0x80000, slotspace+0xeffff, read32_delegate(FUNC(nubus_radiustpd_device::radiustpd_r), this), write32_delegate(FUNC(nubus_radiustpd_device::radiustpd_w), this));	m_nubus->install_device(slotspace+0x980000, slotspace+0x9effff, read32_delegate(FUNC(nubus_radiustpd_device::radiustpd_r), this), write32_delegate(FUNC(nubus_radiustpd_device::radiustpd_w), this));	m_timer = timer_alloc(0, NULL);	m_timer->adjust(m_screen->time_until_pos(479, 0), 0);}

void southbridge_device::device_start(){	address_space& spaceio = machine().device(":maincpu")->memory().space(AS_IO);	spaceio.install_readwrite_handler(0x0000, 0x001f, read8_delegate(FUNC(am9517a_device::read),&(*m_dma8237_1)), write8_delegate(FUNC(am9517a_device::write),&(*m_dma8237_1)), 0xffffffff);	spaceio.install_readwrite_handler(0x0020, 0x003f, read8_delegate(FUNC(pic8259_device::read),&(*m_pic8259_master)), write8_delegate(FUNC(pic8259_device::write),&(*m_pic8259_master)), 0xffffffff);	spaceio.install_readwrite_handler(0x0040, 0x005f, read8_delegate(FUNC(pit8254_device::read),&(*m_pit8254)), write8_delegate(FUNC(pit8254_device::write),&(*m_pit8254)), 0xffffffff);	spaceio.install_readwrite_handler(0x0060, 0x0063, read8_delegate(FUNC(southbridge_device::at_keybc_r),this), write8_delegate(FUNC(southbridge_device::at_keybc_w),this), 0xffffffff);	spaceio.install_readwrite_handler(0x0064, 0x0067, read8_delegate(FUNC(at_keyboard_controller_device::status_r),&(*m_keybc)), write8_delegate(FUNC(at_keyboard_controller_device::command_w),&(*m_keybc)), 0xffffffff);	spaceio.install_readwrite_handler(0x0070, 0x007f, read8_delegate(FUNC(ds12885_device::read),&(*m_ds12885)), write8_delegate(FUNC(ds12885_device::write),&(*m_ds12885)), 0xffffffff);	spaceio.install_readwrite_handler(0x0080, 0x009f, read8_delegate(FUNC(southbridge_device::at_page8_r),this), write8_delegate(FUNC(southbridge_device::at_page8_w),this), 0xffffffff);	spaceio.install_readwrite_handler(0x00a0, 0x00bf, read8_delegate(FUNC(pic8259_device::read),&(*m_pic8259_slave)), write8_delegate(FUNC(pic8259_device::write),&(*m_pic8259_slave)), 0xffffffff);	spaceio.install_readwrite_handler(0x00c0, 0x00df, read8_delegate(FUNC(southbridge_device::at_dma8237_2_r),this), write8_delegate(FUNC(southbridge_device::at_dma8237_2_w),this), 0xffffffff);	spaceio.install_readwrite_handler(0x0170, 0x0177, read32_delegate(FUNC(bus_master_ide_controller_device::read_cs0),&(*m_ide2)), write32_delegate(FUNC(bus_master_ide_controller_device::write_cs0), &(*m_ide2)),0xffffffff);	spaceio.install_readwrite_handler(0x01f0, 0x01f7, read32_delegate(FUNC(bus_master_ide_controller_device::read_cs0),&(*m_ide)), write32_delegate(FUNC(bus_master_ide_controller_device::write_cs0), &(*m_ide)),0xffffffff);//  HACK: this works if you take out the (non working) fdc//  spaceio.install_readwrite_handler(0x0370, 0x0377, read32_delegate(FUNC(bus_master_ide_controller_device::read_cs1),&(*m_ide2)), write32_delegate(FUNC(bus_master_ide_controller_device::write_cs1), &(*m_ide2)),0xffffffff);//  spaceio.install_readwrite_handler(0x03f0, 0x03f7, read32_delegate(FUNC(bus_master_ide_controller_device::read_cs1),&(*m_ide)), write32_delegate(FUNC(bus_master_ide_controller_device::write_cs1), &(*m_ide)),0xffffffff);	spaceio.install_readwrite_handler(0x0374, 0x0377, read8_delegate(FUNC(southbridge_device::ide2_read_cs1_r),this), write8_delegate(FUNC(southbridge_device::ide2_write_cs1_w), this),0xff0000);	spaceio.install_readwrite_handler(0x03f4, 0x03f7, read8_delegate(FUNC(southbridge_device::ide_read_cs1_r),this), write8_delegate(FUNC(southbridge_device::ide_write_cs1_w), this),0xff0000);	spaceio.nop_readwrite(0x00e0, 0x00ef);}

void nubus_radiustpd_device::device_start(){	UINT32 slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, RADIUSTPD_ROM_REGION, true, true);	slotspace = get_slotspace();	printf("[radiustpd %p] slotspace = %x/n", this, slotspace);	m_vram = auto_alloc_array(machine(), UINT8, VRAM_SIZE);	m_vram32 = (UINT32 *)m_vram;	m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_radiustpd_device::vram_r), this), write32_delegate(FUNC(nubus_radiustpd_device::vram_w), this));	m_nubus->install_device(slotspace+0x900000, slotspace+VRAM_SIZE-1+0x900000, read32_delegate(FUNC(nubus_radiustpd_device::vram_r), this), write32_delegate(FUNC(nubus_radiustpd_device::vram_w), this));	m_nubus->install_device(slotspace+0x80000, slotspace+0xeffff, read32_delegate(FUNC(nubus_radiustpd_device::radiustpd_r), this), write32_delegate(FUNC(nubus_radiustpd_device::radiustpd_w), this));	m_nubus->install_device(slotspace+0x980000, slotspace+0x9effff, read32_delegate(FUNC(nubus_radiustpd_device::radiustpd_r), this), write32_delegate(FUNC(nubus_radiustpd_device::radiustpd_w), this));	m_timer = timer_alloc(0, NULL);	m_screen = NULL;	// can we look this up now?}

static DRIVER_INIT(a310){	UINT32 ram_size = machine.device<ram_device>(RAM_TAG)->size();	a310_state *state = machine.driver_data<a310_state>();	archimedes_memc_physmem = auto_alloc_array(machine, UINT32, 0x01000000);	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_handler( 0x02000000, 0x02000000+(ram_size-1), read32_delegate(FUNC(a310_state::a310_psy_wram_r), state), write32_delegate(FUNC(a310_state::a310_psy_wram_w), state));	archimedes_driver_init(machine);}

void nubus_m2hires_device::device_start(){	uint32_t slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, M2HIRES_ROM_REGION, true);	slotspace = get_slotspace();//  printf("[m2hires %p] slotspace = %x/n", this, slotspace);	m_vram.resize(VRAM_SIZE);	m_vram32 = (uint32_t *)&m_vram[0];	m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_m2hires_device::vram_r), this), write32_delegate(FUNC(nubus_m2hires_device::vram_w), this));	m_nubus->install_device(slotspace+0x900000, slotspace+VRAM_SIZE-1+0x900000, read32_delegate(FUNC(nubus_m2hires_device::vram_r), this), write32_delegate(FUNC(nubus_m2hires_device::vram_w), this));	m_nubus->install_device(slotspace+0x80000, slotspace+0xeffff, read32_delegate(FUNC(nubus_m2hires_device::m2hires_r), this), write32_delegate(FUNC(nubus_m2hires_device::m2hires_w), this));	m_timer = timer_alloc(0, nullptr);	m_timer->adjust(m_screen->time_until_pos(479, 0), 0);}

void s3c2400_device::device_start(){	s3c24xx_device_start();	address_space &space = m_cpu->memory().space( AS_PROGRAM);	space.install_readwrite_handler(0x14000000, 0x1400003b, read32_delegate(FUNC(s3c2400_device::s3c24xx_memcon_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_memcon_w), this));	space.install_readwrite_handler(0x14200000, 0x1420005b, read32_delegate(FUNC(s3c2400_device::s3c24xx_usb_host_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_usb_host_w), this));	space.install_readwrite_handler(0x14400000, 0x14400017, read32_delegate(FUNC(s3c2400_device::s3c24xx_irq_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_irq_w), this));	space.install_readwrite_handler(0x14600000, 0x1460001b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_0_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_0_w), this));	space.install_readwrite_handler(0x14600020, 0x1460003b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_1_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_1_w), this));	space.install_readwrite_handler(0x14600040, 0x1460005b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_2_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_2_w), this));	space.install_readwrite_handler(0x14600060, 0x1460007b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_3_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_3_w), this));	space.install_readwrite_handler(0x14800000, 0x14800017, read32_delegate(FUNC(s3c2400_device::s3c24xx_clkpow_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_clkpow_w), this));	space.install_readwrite_handler(0x14a00000, 0x14a003ff, read32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_w), this));	space.install_readwrite_handler(0x14a00400, 0x14a007ff, read32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_palette_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_palette_w), this));	space.install_readwrite_handler(0x15000000, 0x1500002b, read32_delegate(FUNC(s3c2400_device::s3c24xx_uart_0_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_uart_0_w), this));	space.install_readwrite_handler(0x15004000, 0x1500402b, read32_delegate(FUNC(s3c2400_device::s3c24xx_uart_1_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_uart_1_w), this));	space.install_readwrite_handler(0x15100000, 0x15100043, read32_delegate(FUNC(s3c2400_device::s3c24xx_pwm_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_pwm_w), this));	space.install_readwrite_handler(0x15200140, 0x152001fb, read32_delegate(FUNC(s3c2400_device::s3c24xx_usb_device_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_usb_device_w), this));	space.install_readwrite_handler(0x15300000, 0x1530000b, read32_delegate(FUNC(s3c2400_device::s3c24xx_wdt_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_wdt_w), this));	space.install_readwrite_handler(0x15400000, 0x1540000f, read32_delegate(FUNC(s3c2400_device::s3c24xx_iic_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_iic_w), this));	space.install_readwrite_handler(0x15508000, 0x15508013, read32_delegate(FUNC(s3c2400_device::s3c24xx_iis_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_iis_w), this));	space.install_readwrite_handler(0x15600000, 0x1560005b, read32_delegate(FUNC(s3c2400_device::s3c24xx_gpio_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_gpio_w), this));	space.install_readwrite_handler(0x15700040, 0x1570008b, read32_delegate(FUNC(s3c2400_device::s3c24xx_rtc_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_rtc_w), this));	space.install_readwrite_handler(0x15800000, 0x15800007, read32_delegate(FUNC(s3c2400_device::s3c24xx_adc_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_adc_w), this));	space.install_readwrite_handler(0x15900000, 0x15900017, read32_delegate(FUNC(s3c2400_device::s3c24xx_spi_0_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_spi_0_w), this));	space.install_readwrite_handler(0x15a00000, 0x15a0003f, read32_delegate(FUNC(s3c2400_device::s3c24xx_mmc_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_mmc_w), this));	s3c24xx_video_start();}

void nubus_wsportrait_device::device_start(){	UINT32 slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, WSPORTRAIT_ROM_REGION, true);	slotspace = get_slotspace();	printf("[wsportrait %p] slotspace = %x/n", this, slotspace);	m_vram.resize(VRAM_SIZE);	m_vram32 = (UINT32 *)&m_vram[0];	m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_wsportrait_device::vram_r), this), write32_delegate(FUNC(nubus_wsportrait_device::vram_w), this));	m_nubus->install_device(slotspace+0x900000, slotspace+0x900000+VRAM_SIZE-1, read32_delegate(FUNC(nubus_wsportrait_device::vram_r), this), write32_delegate(FUNC(nubus_wsportrait_device::vram_w), this));	m_nubus->install_device(slotspace+0x80000, slotspace+0xeffff, read32_delegate(FUNC(nubus_wsportrait_device::wsportrait_r), this), write32_delegate(FUNC(nubus_wsportrait_device::wsportrait_w), this));	m_timer = timer_alloc(0, NULL);	m_timer->adjust(m_screen->time_until_pos(869, 0), 0);}

void nubus_spec8s3_device::device_start(){    UINT32 slotspace;    // set_nubus_device makes m_slot valid    set_nubus_device();    install_declaration_rom(this, SPEC8S3_ROM_REGION);    slotspace = get_slotspace();//  printf("[SPEC8S3 %p] slotspace = %x/n", this, slotspace);    m_vram.resize(VRAM_SIZE);    m_vram32 = (UINT32 *)&m_vram[0];    m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_spec8s3_device::vram_r), this), write32_delegate(FUNC(nubus_spec8s3_device::vram_w), this));    m_nubus->install_device(slotspace+0x900000, slotspace+VRAM_SIZE-1+0x900000, read32_delegate(FUNC(nubus_spec8s3_device::vram_r), this), write32_delegate(FUNC(nubus_spec8s3_device::vram_w), this));    m_nubus->install_device(slotspace+0xd0000, slotspace+0xfffff, read32_delegate(FUNC(nubus_spec8s3_device::spec8s3_r), this), write32_delegate(FUNC(nubus_spec8s3_device::spec8s3_w), this));    m_timer = timer_alloc(0, NULL);    m_timer->adjust(m_screen->time_until_pos(767, 0), 0);}

void nubus_xceed30hr_device::device_start(){	UINT32 slotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, XCEED30HR_ROM_REGION);	slotspace = get_slotspace();//  printf("[xceed30hr %p] slotspace = %x/n", this, slotspace);	m_vram.resize(VRAM_SIZE);	m_vram32 = (UINT32 *)&m_vram[0];	m_nubus->install_device(slotspace, slotspace+VRAM_SIZE-1, read32_delegate(FUNC(nubus_xceed30hr_device::vram_r), this), write32_delegate(FUNC(nubus_xceed30hr_device::vram_w), this));	m_nubus->install_device(slotspace+0x800000, slotspace+0xefffff, read32_delegate(FUNC(nubus_xceed30hr_device::xceed30hr_r), this), write32_delegate(FUNC(nubus_xceed30hr_device::xceed30hr_w), this));	m_timer = timer_alloc(0, NULL);	m_timer->adjust(m_screen->time_until_pos(479, 0), 0);}

void calchase_state::init_calchase(){	m_bios_ram = std::make_unique<uint32_t[]>(0x20000/4);	intel82439tx_init();	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3f0b160, 0x3f0b163, read32_delegate(FUNC(calchase_state::calchase_idle_skip_r),this), write32_delegate(FUNC(calchase_state::calchase_idle_skip_w),this));}

void nubus_image_device::device_start(){	UINT32 slotspace;	UINT32 superslotspace;	// set_nubus_device makes m_slot valid	set_nubus_device();	install_declaration_rom(this, IMAGE_ROM_REGION);	slotspace = get_slotspace();	superslotspace = get_super_slotspace();//  printf("[image %p] slotspace = %x, super = %x/n", this, slotspace, superslotspace);	m_nubus->install_device(slotspace, slotspace+3, read32_delegate(FUNC(nubus_image_device::image_r), this), write32_delegate(FUNC(nubus_image_device::image_w), this));	m_nubus->install_device(slotspace+4, slotspace+7, read32_delegate(FUNC(nubus_image_device::image_status_r), this), write32_delegate(FUNC(nubus_image_device::image_status_w), this));	m_nubus->install_device(superslotspace, superslotspace+((256*1024*1024)-1), read32_delegate(FUNC(nubus_image_device::image_super_r), this), write32_delegate(FUNC(nubus_image_device::image_super_w), this));	device_t *device0 = subdevice(IMAGE_DISK0_TAG);	m_image = (disk_data *) downcast<messimg_disk_image_device *>(device0)->token();}

void voodoo_pci_device::map_extra(uint64_t memory_window_start, uint64_t memory_window_end, uint64_t memory_offset, address_space *memory_space,									uint64_t io_window_start, uint64_t io_window_end, uint64_t io_offset, address_space *io_space){	logerror("%s: map_extra/n", this->tag());	// Map VGA legacy access	// Should really be dependent on voodoo VGAINIT0 bit 8 and IO base + 0xc3 bit 0	if (m_type>=TYPE_VOODOO_BANSHEE) {		uint64_t start = io_offset + 0x3b0;		uint64_t end = io_offset + 0x3df;		io_space->install_readwrite_handler(start, end, read32_delegate(FUNC(voodoo_pci_device::vga_r), this), write32_delegate(FUNC(voodoo_pci_device::vga_w), this));		logerror("%s: map %s at %0*x-%0*x/n", this->tag(), "vga_r/w", 4, uint32_t(start), 4, uint32_t(end));	}}