Previous

199869 Revisions

Next

r22526 Wednesday 24th April, 2013 at 14:54:54 UTC by Miodrag Milanović
removed implementation of legacy DEVCB_MEMORY_HANDLER and used members instead (nw) this require clean compile

[src/emu]	devcb.c devcb.h
[src/mame/drivers]	dkong.c mario.c nbmj8688.c
[src/mame/includes]	dkong.h mario.h nbmj8688.h
[src/mess/drivers]	b16.c bigbord2.c bullet.c dmv.c p8k.c qx10.c super6.c trs80m2.c vidbrain.c x1.c x1twin.c
[src/mess/includes]	bullet.h radio86.h super6.h trs80m2.h vidbrain.h x1.h
[src/mess/machine]	lux21046.c lux21046.h partner.c radio86.c x1.c

trunk/src/emu/devcb.c

r22525	r22526
70	70	static ioport_port *resolve_port(const char *tag, device_t &current);
71	71	static device_t *resolve_device(int index, const char *tag, device_t &current);
72	72	static device_execute_interface *resolve_execute_interface(const char *tag, device_t &current);
73		static address_space &resolve_space(int index, const char *tag, device_t &current);
74	73	};
75	74
76	75
r22525	r22526
130	129	}
131	130
132	131
133		//-------------------------------------------------
134		//  resolve_space - resolve to an address space
135		//  given a device tag and a space index
136		//-------------------------------------------------
137
138		address_space &devcb_resolver::resolve_space(int index, const char *tag, device_t &current)
139		{
140		// find our target device
141		device_t *targetdev = current.siblingdevice(tag);
142		if (targetdev == NULL)
143		throw emu_fatalerror("Unable to resolve device '%s' (requested by %s '%s')", tag, current.name(), current.tag());
144
145		// make sure the target device has a memory interface
146		device_memory_interface *memory;
147		if (!targetdev->interface(memory))
148		throw emu_fatalerror("Device '%s' (requested by %s '%s') has no memory interface", tag, current.name(), current.tag());
149
150		// set the real target and function, then prime a delegate
151		if (!memory->has_space(index))
152		throw emu_fatalerror("Unable to find device '%s' space %d (requested by %s '%s')", tag, index, current.name(), current.tag());
153		return memory->space(index);
154		}
155
156
157
158	132	//**************************************************************************
159	133	//  DEVCB RESOLVED READ LINE
160	134	//**************************************************************************
r22525	r22526
202	176	}
203	177	break;
204	178
205		case DEVCB_TYPE_LEGACY_SPACE:
206		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
207		m_helper.read8_space = desc.readspace;
208		*static_cast<devcb_read_line_delegate *>(this) = devcb_read_line_delegate(&devcb_resolved_read_line::from_read8, desc.name, this);
209		break;
210
211	179	case DEVCB_TYPE_CONSTANT:
212	180	m_object.constant = desc.index;
213	181	*static_cast<devcb_read_line_delegate *>(this) = devcb_read_line_delegate(&devcb_resolved_read_line::from_constant, "constant", this);
r22525	r22526
313	281	}
314	282	break;
315	283
316		case DEVCB_TYPE_LEGACY_SPACE:
317		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
318		m_helper.write8_space = desc.writespace;
319		*static_cast<devcb_write_line_delegate *>(this) = devcb_write_line_delegate(&devcb_resolved_write_line::to_write8, desc.name, this);
320		break;
321
322	284	case DEVCB_TYPE_INPUT_LINE:
323	285	m_object.execute = devcb_resolver::resolve_execute_interface(desc.tag, device);
324	286	m_helper.input_line = desc.index;
r22525	r22526
437	399	}
438	400	break;
439	401
440		case DEVCB_TYPE_LEGACY_SPACE:
441		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
442		m_helper.read8_space = desc.readspace;
443		*static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(&devcb_resolved_read8::from_read8space, desc.name, this);
444		break;
445
446	402	case DEVCB_TYPE_CONSTANT:
447	403	m_object.constant = desc.index;
448	404	*static_cast<devcb_read8_delegate *>(this) = devcb_read8_delegate(&devcb_resolved_read8::from_constant, "constant", this);
r22525	r22526
572	528	}
573	529	break;
574	530
575		case DEVCB_TYPE_LEGACY_SPACE:
576		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
577		m_helper.write8_space = desc.writespace;
578		*static_cast<devcb_write8_delegate *>(this) = devcb_write8_delegate(&devcb_resolved_write8::to_write8space, desc.name, this);
579		break;
580
581	531	case DEVCB_TYPE_INPUT_LINE:
582	532	m_object.execute = devcb_resolver::resolve_execute_interface(desc.tag, device);
583	533	m_helper.input_line = desc.index;
r22525	r22526
719	669	}
720	670	break;
721	671
722		case DEVCB_TYPE_LEGACY_SPACE:
723		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
724		*static_cast<devcb_read16_delegate *>(this) = devcb_read16_delegate(desc.readspace, desc.name, m_object.space);
725		break;
726
727	672	case DEVCB_TYPE_CONSTANT:
728	673	m_object.constant = desc.index;
729	674	*static_cast<devcb_read16_delegate *>(this) = devcb_read16_delegate(&devcb_resolved_read16::from_constant, "constant", this);
r22525	r22526
842	787	}
843	788	break;
844	789
845		case DEVCB_TYPE_LEGACY_SPACE:
846		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
847		*static_cast<devcb_write16_delegate *>(this) = devcb_write16_delegate(desc.writespace, desc.name, m_object.space);
848		break;
849
850	790	case DEVCB_TYPE_INPUT_LINE:
851	791	m_object.execute = devcb_resolver::resolve_execute_interface(desc.tag, device);
852	792	m_helper.input_line = desc.index;
r22525	r22526
976	916	}
977	917	break;
978	918
979		case DEVCB_TYPE_LEGACY_SPACE:
980		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
981		*static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(desc.readspace, desc.name, m_object.space);
982		break;
983
984	919	case DEVCB_TYPE_CONSTANT:
985	920	m_object.constant = desc.index;
986	921	*static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_constant, "constant", this);
r22525	r22526
1099	1034	}
1100	1035	break;
1101	1036
1102		case DEVCB_TYPE_LEGACY_SPACE:
1103		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
1104		*static_cast<devcb_write32_delegate *>(this) = devcb_write32_delegate(desc.writespace, desc.name, m_object.space);
1105		break;
1106
1107	1037	case DEVCB_TYPE_INPUT_LINE:
1108	1038	m_object.execute = devcb_resolver::resolve_execute_interface(desc.tag, device);
1109	1039	m_helper.input_line = desc.index;
r22525	r22526
1233	1163	}
1234	1164	break;
1235	1165
1236		case DEVCB_TYPE_LEGACY_SPACE:
1237		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
1238		*static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(desc.readspace, desc.name, m_object.space);
1239		break;
1240
1241	1166	case DEVCB_TYPE_CONSTANT:
1242	1167	m_object.constant = desc.index;
1243	1168	*static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_constant, "constant", this);
r22525	r22526
1356	1281	}
1357	1282	break;
1358	1283
1359		case DEVCB_TYPE_LEGACY_SPACE:
1360		m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device);
1361		*static_cast<devcb_write64_delegate *>(this) = devcb_write64_delegate(desc.writespace, desc.name, m_object.space);
1362		break;
1363
1364	1284	case DEVCB_TYPE_INPUT_LINE:
1365	1285	m_object.execute = devcb_resolver::resolve_execute_interface(desc.tag, device);
1366	1286	m_helper.input_line = desc.index;

trunk/src/emu/devcb.h

r22525	r22526
100	100	DEVCB_TYPE_NULL = 0,            // NULL callback
101	101	DEVCB_TYPE_IOPORT,              // I/O port read/write
102	102	DEVCB_TYPE_DEVICE,              // device read/write
103		DEVCB_TYPE_LEGACY_SPACE,        // legacy address space read/write
104	103	DEVCB_TYPE_INPUT_LINE,          // device input line write
105	104	DEVCB_TYPE_CONSTANT,            // constant value read
106	105	DEVCB_TYPE_UNMAP                // unmapped line
r22525	r22526
229	228
230	229	#define DEVCB_UNMAPPED                          { DEVCB_TYPE_UNMAP, 0, NULL, NULL, NULL, NULL }
231	230
232		// read/write handlers for a given CPU's address space
233		#define DEVCB_MEMORY_HANDLER(cpu,space,func)    { DEVCB_TYPE_LEGACY_SPACE, AS_##space, (cpu), #func, NULL, NULL, func }
234
235	231	// read handlers for an I/O port by tag
236	232	#define DEVCB_INPUT_PORT(tag)                   { DEVCB_TYPE_IOPORT, 0, (tag), NULL, NULL, NULL, NULL }
237	233

trunk/src/mess/machine/partner.c

r22525	r22526
363	363	machine().device<i8257_device>("dma8257")->i8257_hlda_w(state);
364	364	}
365	365
366		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
367		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
368
369	366	I8257_INTERFACE( partner_dma )
370	367	{
371	368	DEVCB_DRIVER_LINE_MEMBER(partner_state,hrq_w),
372	369	DEVCB_NULL,
373	370	DEVCB_NULL,
374		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
375		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	371	DEVCB_DRIVER_MEMBER(radio86_state, memory_read_byte),
	372	DEVCB_DRIVER_MEMBER(radio86_state, memory_write_byte),
376	373	{ DEVCB_DEVICE_HANDLER("wd1793", wd17xx_data_r), DEVCB_NULL, DEVCB_NULL, DEVCB_NULL },
377	374	{ DEVCB_DEVICE_HANDLER("wd1793", wd17xx_data_w), DEVCB_NULL, DEVCB_DEVICE_MEMBER("i8275", i8275_device, dack_w), DEVCB_NULL }
378	375	};

trunk/src/mess/machine/x1.c

r22525	r22526
53	53	{
54	54	x1_state *state = machine().driver_data<x1_state>();
55	55	state->m_key_irq_flag = 0;
56		state->m_x1_cpu->set_input_line(INPUT_LINE_IRQ0,CLEAR_LINE);
	56	state->m_maincpu->set_input_line(INPUT_LINE_IRQ0,CLEAR_LINE);
57	57	return state->m_key_irq_vector;
58	58	}
59	59

trunk/src/mess/machine/lux21046.c

r22525	r22526
219	219	m_maincpu->set_input_line(INPUT_LINE_IRQ0, m_fdc_irq || m_dma_irq);
220	220	}
221	221
222		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
223		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	222	READ8_MEMBER(luxor_55_21046_device::memory_read_byte)
	223	{
	224	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	225	return prog_space.read_byte(offset);
	226	}
224	227
	228	WRITE8_MEMBER(luxor_55_21046_device::memory_write_byte)
	229	{
	230	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	231	return prog_space.write_byte(offset, data);
	232	}
	233
	234	READ8_MEMBER(luxor_55_21046_device::io_read_byte)
	235	{
	236	address_space& prog_space = m_maincpu->space(AS_IO);
	237	return prog_space.read_byte(offset);
	238	}
	239
	240	WRITE8_MEMBER(luxor_55_21046_device::io_write_byte)
	241	{
	242	address_space& prog_space = m_maincpu->space(AS_IO);
	243	return prog_space.write_byte(offset, data);
	244	}
	245
225	246	static Z80DMA_INTERFACE( dma_intf )
226	247	{
227	248	DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_HALT),
228	249	DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, luxor_55_21046_device, dma_int_w),
229	250	DEVCB_NULL,
230		DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_read_byte),
231		DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_write_byte),
232		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_read_byte),
233		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_write_byte)
	251	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, luxor_55_21046_device, memory_read_byte),
	252	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, luxor_55_21046_device, memory_write_byte),
	253	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, luxor_55_21046_device, io_read_byte),
	254	DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, luxor_55_21046_device, io_write_byte),
234	255	};
235	256
236	257

trunk/src/mess/machine/lux21046.h

r22525	r22526
71	71
72	72	DECLARE_WRITE_LINE_MEMBER( dma_int_w );
73	73
	74	DECLARE_READ8_MEMBER(memory_read_byte);
	75	DECLARE_WRITE8_MEMBER(memory_write_byte);
	76	DECLARE_READ8_MEMBER(io_read_byte);
	77	DECLARE_WRITE8_MEMBER(io_write_byte);
	78
74	79	void fdc_intrq_w(bool state);
75	80	void fdc_drq_w(bool state);
76	81

trunk/src/mess/machine/radio86.c

r22525	r22526
134	134	m_dma8257->i8257_hlda_w(state);
135	135	}
136	136
137		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
138		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	137	READ8_MEMBER(radio86_state::memory_read_byte)
	138	{
	139	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	140	return prog_space.read_byte(offset);
	141	}
139	142
	143	WRITE8_MEMBER(radio86_state::memory_write_byte)
	144	{
	145	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	146	return prog_space.write_byte(offset, data);
	147	}
	148
140	149	I8257_INTERFACE( radio86_dma )
141	150	{
142	151	DEVCB_DRIVER_LINE_MEMBER(radio86_state,hrq_w),
143	152	DEVCB_NULL,
144	153	DEVCB_NULL,
145		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
146		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	154	DEVCB_DRIVER_MEMBER(radio86_state, memory_read_byte),
	155	DEVCB_DRIVER_MEMBER(radio86_state, memory_write_byte),
147	156	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL },
148	157	{ DEVCB_NULL, DEVCB_NULL, DEVCB_DEVICE_MEMBER("i8275", i8275_device, dack_w), DEVCB_NULL }
149	158	};

trunk/src/mess/includes/trs80m2.h

r22525	r22526
126	126	int m_enable_rtc_int;
127	127
128	128	TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);
	129	DECLARE_READ8_MEMBER(io_read_byte);
	130	DECLARE_WRITE8_MEMBER(io_write_byte);
129	131	};
130	132
131	133	class trs80m16_state : public trs80m2_state

trunk/src/mess/includes/vidbrain.h

r22525	r22526
96	96	DECLARE_INPUT_CHANGED_MEMBER( trigger_reset );
97	97	DECLARE_WRITE_LINE_MEMBER( ext_int_w );
98	98	DECLARE_WRITE_LINE_MEMBER( hblank_w );
	99	DECLARE_READ8_MEMBER(memory_read_byte);
	100
99	101
100	102	IRQ_CALLBACK_MEMBER(vidbrain_int_ack);
101	103

trunk/src/mess/includes/radio86.h

r22525	r22526
72	72	DECLARE_WRITE8_MEMBER(radio86_romdisk_portb_w);
73	73	DECLARE_WRITE8_MEMBER(radio86_romdisk_portc_w);
74	74	DECLARE_WRITE8_MEMBER(mikrosha_8255_font_page_w);
75
	75	DECLARE_READ8_MEMBER(memory_read_byte);
	76	DECLARE_WRITE8_MEMBER(memory_write_byte);
76	77	required_device<cpu_device> m_maincpu;
77	78	protected:
78	79	required_device<cassette_image_device> m_cassette;

trunk/src/mess/includes/bullet.h

r22525	r22526
121	121
122	122	TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);
123	123	DECLARE_WRITE_LINE_MEMBER(dart_rxtxca_w);
	124	DECLARE_READ8_MEMBER(io_read_byte);
	125	DECLARE_WRITE8_MEMBER(io_write_byte);
124	126	};
125	127
126	128	class bulletf_state : public bullet_state

trunk/src/mess/includes/x1.h

r22525	r22526
75	75	public:
76	76	x1_state(const machine_config &mconfig, device_type type, const char *tag)
77	77	: driver_device(mconfig, type, tag),
78		m_x1_cpu(*this,"x1_cpu"),
	78	m_maincpu(*this,"x1_cpu"),
79	79	m_cassette(*this, "cassette"),
80	80	m_fdc(*this, "fdc"),
81	81	m_crtc(*this, "crtc"),
82	82	m_ctc(*this, "ctc")
83	83	{ }
84	84
85		required_device<cpu_device> m_x1_cpu;
	85	required_device<cpu_device> m_maincpu;
86	86	required_device<cassette_image_device> m_cassette;
87	87	required_device<mb8877_device> m_fdc;
88	88	required_device<mc6845_device> m_crtc;
r22525	r22526
223	223	int priority_mixer_pri(int color);
224	224	void cmt_command( UINT8 cmd );
225	225	UINT16 jis_convert(int kanji_addr);
	226
	227	DECLARE_READ8_MEMBER(memory_read_byte);
	228	DECLARE_WRITE8_MEMBER(memory_write_byte);
	229	DECLARE_READ8_MEMBER(io_read_byte);
	230	DECLARE_WRITE8_MEMBER(io_write_byte);
226	231	};
227	232
228	233	/*----------- defined in machine/x1.c -----------*/

trunk/src/mess/includes/super6.h

r22525	r22526
78	78	UINT8 m_bank1;
79	79	TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);
80	80	DECLARE_WRITE8_MEMBER(dummy_w);
	81	DECLARE_READ8_MEMBER(memory_read_byte);
	82	DECLARE_WRITE8_MEMBER(memory_write_byte);
	83	DECLARE_READ8_MEMBER(io_read_byte);
	84	DECLARE_WRITE8_MEMBER(io_write_byte);
81	85	};
82	86
83	87	#endif

trunk/src/mess/drivers/bigbord2.c

r22525	r22526
147	147	DECLARE_DRIVER_INIT(bigbord2);
148	148	TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);
149	149	DECLARE_WRITE_LINE_MEMBER(bigbord2_interrupt);
	150	DECLARE_READ8_MEMBER(memory_read_byte);
	151	DECLARE_WRITE8_MEMBER(memory_write_byte);
	152	DECLARE_READ8_MEMBER(io_read_byte);
	153	DECLARE_WRITE8_MEMBER(io_write_byte);
150	154	};
151	155
152	156	/* Status port
r22525	r22526
211	215	/* Z80 DMA */
212	216
213	217
214		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
215		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	218	READ8_MEMBER(bigbord2_state::memory_read_byte)
	219	{
	220	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	221	return prog_space.read_byte(offset);
	222	}
216	223
	224	WRITE8_MEMBER(bigbord2_state::memory_write_byte)
	225	{
	226	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	227	return prog_space.write_byte(offset, data);
	228	}
	229
	230	READ8_MEMBER(bigbord2_state::io_read_byte)
	231	{
	232	address_space& prog_space = m_maincpu->space(AS_IO);
	233	return prog_space.read_byte(offset);
	234	}
	235
	236	WRITE8_MEMBER(bigbord2_state::io_write_byte)
	237	{
	238	address_space& prog_space = m_maincpu->space(AS_IO);
	239	return prog_space.write_byte(offset, data);
	240	}
	241
217	242	static Z80DMA_INTERFACE( dma_intf )
218	243	{
219	244	DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_HALT), // actually BUSRQ
220	245	DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_IRQ0),
221	246	DEVCB_NULL,
222		DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_read_byte),
223		DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_write_byte),
224		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_read_byte),
225		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_write_byte)
	247	DEVCB_DRIVER_MEMBER(bigbord2_state, memory_read_byte),
	248	DEVCB_DRIVER_MEMBER(bigbord2_state, memory_write_byte),
	249	DEVCB_DRIVER_MEMBER(bigbord2_state, io_read_byte),
	250	DEVCB_DRIVER_MEMBER(bigbord2_state, io_write_byte),
	251
226	252	};
227	253
228	254

trunk/src/mess/drivers/x1.c

r22525	r22526
1895	1895	NULL        /* update address callback */
1896	1896	};
1897	1897
1898		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
1899		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	1898	READ8_MEMBER(x1_state::memory_read_byte)
	1899	{
	1900	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	1901	return prog_space.read_byte(offset);
	1902	}
1900	1903
	1904	WRITE8_MEMBER(x1_state::memory_write_byte)
	1905	{
	1906	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	1907	return prog_space.write_byte(offset, data);
	1908	}
	1909
	1910	READ8_MEMBER(x1_state::io_read_byte)
	1911	{
	1912	address_space& prog_space = m_maincpu->space(AS_IO);
	1913	return prog_space.read_byte(offset);
	1914	}
	1915
	1916	WRITE8_MEMBER(x1_state::io_write_byte)
	1917	{
	1918	address_space& prog_space = m_maincpu->space(AS_IO);
	1919	return prog_space.write_byte(offset, data);
	1920	}
	1921
1901	1922	static Z80DMA_INTERFACE( x1_dma )
1902	1923	{
1903	1924	DEVCB_CPU_INPUT_LINE("x1_cpu", INPUT_LINE_HALT),
1904	1925	DEVCB_CPU_INPUT_LINE("x1_cpu", INPUT_LINE_IRQ0),
1905	1926	DEVCB_NULL,
1906		DEVCB_MEMORY_HANDLER("x1_cpu", PROGRAM, memory_read_byte),
1907		DEVCB_MEMORY_HANDLER("x1_cpu", PROGRAM, memory_write_byte),
1908		DEVCB_MEMORY_HANDLER("x1_cpu", IO, memory_read_byte),
1909		DEVCB_MEMORY_HANDLER("x1_cpu", IO, memory_write_byte)
	1927	DEVCB_DRIVER_MEMBER(x1_state, memory_read_byte),
	1928	DEVCB_DRIVER_MEMBER(x1_state, memory_write_byte),
	1929	DEVCB_DRIVER_MEMBER(x1_state, io_read_byte),
	1930	DEVCB_DRIVER_MEMBER(x1_state, io_write_byte)
1910	1931	};
1911	1932
1912	1933	/*************************************
r22525	r22526
1917	1938
1918	1939	INPUT_CHANGED_MEMBER(x1_state::ipl_reset)
1919	1940	{
1920		m_x1_cpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	1941	m_maincpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
1921	1942
1922	1943	m_ram_bank = 0x00;
1923	1944	if(m_is_turbo) { m_ex_bank = 0x10; }
r22525	r22526
1927	1948	/* Apparently most games doesn't support this (not even the Konami ones!), one that does is...177 :o */
1928	1949	INPUT_CHANGED_MEMBER(x1_state::nmi_reset)
1929	1950	{
1930		m_x1_cpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	1951	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
1931	1952	}
1932	1953
1933	1954	INPUT_PORTS_START( x1 )
r22525	r22526
2368	2389
2369	2390	TIMER_DEVICE_CALLBACK_MEMBER(x1_state::x1_keyboard_callback)
2370	2391	{
2371		address_space &space = m_x1_cpu->space(AS_PROGRAM);
	2392	address_space &space = m_maincpu->space(AS_PROGRAM);
2372	2393	UINT32 key1 = ioport("key1")->read();
2373	2394	UINT32 key2 = ioport("key2")->read();
2374	2395	UINT32 key3 = ioport("key3")->read();
r22525	r22526
2386	2407	x1_sub_io_w(space,0,0xe6);
2387	2408	m_irq_vector = m_key_irq_vector;
2388	2409	m_key_irq_flag = 1;
2389		m_x1_cpu->set_input_line(0,ASSERT_LINE);
	2410	m_maincpu->set_input_line(0,ASSERT_LINE);
2390	2411	m_old_key1 = key1;
2391	2412	m_old_key2 = key2;
2392	2413	m_old_key3 = key3;

trunk/src/mess/drivers/p8k.c

r22525	r22526
107	107	DECLARE_WRITE_LINE_MEMBER( p8k_16_daisy_interrupt );
108	108	DECLARE_WRITE16_MEMBER( pk8_16_sio_0_serial_transmit );
109	109	DECLARE_WRITE16_MEMBER( pk8_16_sio_1_serial_transmit );
	110	DECLARE_READ8_MEMBER(memory_read_byte);
	111	DECLARE_WRITE8_MEMBER(memory_write_byte);
	112	DECLARE_READ8_MEMBER(io_read_byte);
	113	DECLARE_WRITE8_MEMBER(io_write_byte);
110	114	};
111	115
112	116	/***************************************************************************
r22525	r22526
241	245	p8k_daisy_interrupt(state);
242	246	}
243	247
244		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
245		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	248	READ8_MEMBER(p8k_state::memory_read_byte)
	249	{
	250	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	251	return prog_space.read_byte(offset);
	252	}
246	253
	254	WRITE8_MEMBER(p8k_state::memory_write_byte)
	255	{
	256	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	257	return prog_space.write_byte(offset, data);
	258	}
	259
	260	READ8_MEMBER(p8k_state::io_read_byte)
	261	{
	262	address_space& prog_space = m_maincpu->space(AS_IO);
	263	return prog_space.read_byte(offset);
	264	}
	265
	266	WRITE8_MEMBER(p8k_state::io_write_byte)
	267	{
	268	address_space& prog_space = m_maincpu->space(AS_IO);
	269	return prog_space.write_byte(offset, data);
	270	}
	271
247	272	static Z80DMA_INTERFACE( p8k_dma_intf )
248	273	{
249	274	DEVCB_DRIVER_LINE_MEMBER(p8k_state, p8k_dma_irq_w),
250	275	DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_IRQ0),
251	276	DEVCB_NULL,
252		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
253		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
254		DEVCB_MEMORY_HANDLER("maincpu", IO, memory_read_byte),
255		DEVCB_MEMORY_HANDLER("maincpu", IO, memory_write_byte)
	277	DEVCB_DRIVER_MEMBER(p8k_state, memory_read_byte),
	278	DEVCB_DRIVER_MEMBER(p8k_state, memory_write_byte),
	279	DEVCB_DRIVER_MEMBER(p8k_state, io_read_byte),
	280	DEVCB_DRIVER_MEMBER(p8k_state, io_write_byte)
256	281	};
257	282
258	283	/* Z80 CTC 0 */

trunk/src/mess/drivers/dmv.c

r22525	r22526
48	48	DECLARE_WRITE8_MEMBER(kb_ctrl_mcu_w);
49	49	DECLARE_READ8_MEMBER(fdc_dma_r);
50	50	DECLARE_WRITE8_MEMBER(fdc_dma_w);
	51	DECLARE_READ8_MEMBER(memory_read_byte);
	52	DECLARE_WRITE8_MEMBER(memory_write_byte);
51	53
52	54	void fdc_irq(bool state);
53	55	void fdc_drq(bool state);
r22525	r22526
283	285	m_dmac->i8237_hlda_w(state);
284	286	}
285	287
286		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask)             { return space.read_byte(address); }
287		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	288	READ8_MEMBER(dmv_state::memory_read_byte)
	289	{
	290	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	291	return prog_space.read_byte(offset);
	292	}
288	293
	294	WRITE8_MEMBER(dmv_state::memory_write_byte)
	295	{
	296	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	297	return prog_space.write_byte(offset, data);
	298	}
	299
289	300	static I8237_INTERFACE( dmv_dma8237_config )
290	301	{
291	302	DEVCB_DRIVER_LINE_MEMBER(dmv_state, dma_hrq_changed),
292	303	DEVCB_NULL,
293		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
294		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	304	DEVCB_DRIVER_MEMBER(dmv_state, memory_read_byte),
	305	DEVCB_DRIVER_MEMBER(dmv_state, memory_write_byte),
295	306	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_DRIVER_MEMBER(dmv_state, fdc_dma_r) },
296	307	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_DRIVER_MEMBER(dmv_state, fdc_dma_w) },
297	308	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }

trunk/src/mess/drivers/b16.c

r22525	r22526
36	36	DECLARE_WRITE8_MEMBER(b16_6845_data_w);
37	37	DECLARE_READ8_MEMBER(unk_dev_r);
38	38	DECLARE_WRITE8_MEMBER(unk_dev_w);
	39	DECLARE_READ8_MEMBER(memory_read_byte);
	40	DECLARE_WRITE8_MEMBER(memory_write_byte);
39	41
40	42	virtual void video_start();
41	43	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
r22525	r22526
264	266	NULL        /* update address callback */
265	267	};
266	268
267		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
268		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	269	READ8_MEMBER(b16_state::memory_read_byte)
	270	{
	271	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	272	return prog_space.read_byte(offset);
	273	}
269	274
	275	WRITE8_MEMBER(b16_state::memory_write_byte)
	276	{
	277	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	278	return prog_space.write_byte(offset, data);
	279	}
	280
270	281	static I8237_INTERFACE( b16_dma8237_interface )
271	282	{
272	283	DEVCB_NULL,
273	284	DEVCB_NULL,
274		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
275		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	285	DEVCB_DRIVER_MEMBER(b16_state, memory_read_byte),
	286	DEVCB_DRIVER_MEMBER(b16_state, memory_write_byte),
276	287	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL },
277	288	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL },
278	289	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }

trunk/src/mess/drivers/trs80m2.c

r22525	r22526
525	525	//  Z80DMA_INTERFACE( dma_intf )
526	526	//-------------------------------------------------
527	527
528		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
529		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	528	READ8_MEMBER(trs80m2_state::io_read_byte)
	529	{
	530	address_space& prog_space = m_maincpu->space(AS_IO);
	531	return prog_space.read_byte(offset);
	532	}
530	533
	534	WRITE8_MEMBER(trs80m2_state::io_write_byte)
	535	{
	536	address_space& prog_space = m_maincpu->space(AS_IO);
	537	return prog_space.write_byte(offset, data);
	538	}
	539
531	540	static Z80DMA_INTERFACE( dma_intf )
532	541	{
533	542	DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_HALT),
r22525	r22526
535	544	DEVCB_NULL,
536	545	DEVCB_DRIVER_MEMBER(trs80m2_state, read),
537	546	DEVCB_DRIVER_MEMBER(trs80m2_state, write),
538		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_read_byte),
539		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_write_byte)
	547	DEVCB_DRIVER_MEMBER(trs80m2_state, io_read_byte),
	548	DEVCB_DRIVER_MEMBER(trs80m2_state, io_write_byte),
540	549	};
541	550
542	551

trunk/src/mess/drivers/x1twin.c

r22525	r22526
111	111
112	112	INPUT_CHANGED_MEMBER(x1twin_state::ipl_reset)
113	113	{
114		//address_space &space = m_x1_cpu->space(AS_PROGRAM);
	114	//address_space &space = m_maincpu->space(AS_PROGRAM);
115	115
116		m_x1_cpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	116	m_maincpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
117	117
118	118	m_ram_bank = 0x00;
119	119	if(m_is_turbo) { m_ex_bank = 0x10; }
r22525	r22526
123	123	/* Apparently most games doesn't support this (not even the Konami ones!), one that does is...177 :o */
124	124	INPUT_CHANGED_MEMBER(x1twin_state::nmi_reset)
125	125	{
126		m_x1_cpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	126	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
127	127	}
128	128
129	129	INPUT_PORTS_START( x1twin )

trunk/src/mess/drivers/vidbrain.c

r22525	r22526
449	449	}
450	450	}
451	451
452		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
	452	READ8_MEMBER(vidbrain_state::memory_read_byte)
	453	{
	454	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	455	return prog_space.read_byte(offset);
	456	}
453	457
454	458	static UV201_INTERFACE( uv_intf )
455	459	{
456	460	SCREEN_TAG,
457	461	DEVCB_DRIVER_LINE_MEMBER(vidbrain_state, ext_int_w),
458	462	DEVCB_DRIVER_LINE_MEMBER(vidbrain_state, hblank_w),
459		DEVCB_MEMORY_HANDLER(F3850_TAG, PROGRAM, memory_read_byte)
	463	DEVCB_DRIVER_MEMBER(vidbrain_state, memory_read_byte)
460	464	};
461	465
462	466

trunk/src/mess/drivers/super6.c

r22525	r22526
391	391	//  Z80DMA_INTERFACE( dma_intf )
392	392	//-------------------------------------------------
393	393
394		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
395		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	394	READ8_MEMBER(super6_state::memory_read_byte)
	395	{
	396	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	397	return prog_space.read_byte(offset);
	398	}
396	399
	400	WRITE8_MEMBER(super6_state::memory_write_byte)
	401	{
	402	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	403	return prog_space.write_byte(offset, data);
	404	}
	405
	406	READ8_MEMBER(super6_state::io_read_byte)
	407	{
	408	address_space& prog_space = m_maincpu->space(AS_IO);
	409	return prog_space.read_byte(offset);
	410	}
	411
	412	WRITE8_MEMBER(super6_state::io_write_byte)
	413	{
	414	address_space& prog_space = m_maincpu->space(AS_IO);
	415	return prog_space.write_byte(offset, data);
	416	}
	417
397	418	static Z80DMA_INTERFACE( dma_intf )
398	419	{
399	420	DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_HALT),
400	421	DEVCB_DEVICE_LINE_MEMBER(Z80CTC_TAG, z80ctc_device, trg2),
401	422	DEVCB_NULL,
402		DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_read_byte),
403		DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_write_byte),
404		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_read_byte),
405		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_write_byte)
	423	DEVCB_DRIVER_MEMBER(super6_state, memory_read_byte),
	424	DEVCB_DRIVER_MEMBER(super6_state, memory_write_byte),
	425	DEVCB_DRIVER_MEMBER(super6_state, io_read_byte),
	426	DEVCB_DRIVER_MEMBER(super6_state, io_write_byte),
406	427	};
407	428
408	429

trunk/src/mess/drivers/qx10.c

r22525	r22526
115	115	DECLARE_WRITE8_MEMBER( vram_bank_w );
116	116	DECLARE_READ8_MEMBER( vram_r );
117	117	DECLARE_WRITE8_MEMBER( vram_w );
	118	DECLARE_READ8_MEMBER(memory_read_byte);
	119	DECLARE_WRITE8_MEMBER(memory_write_byte);
118	120
119	121	UINT8 *m_char_rom;
120	122
r22525	r22526
392	394	Channel 2: GDC
393	395	Channel 3: Option slots
394	396	*/
395		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
396		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	397	READ8_MEMBER(qx10_state::memory_read_byte)
	398	{
	399	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	400	return prog_space.read_byte(offset);
	401	}
397	402
	403	WRITE8_MEMBER(qx10_state::memory_write_byte)
	404	{
	405	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	406	return prog_space.write_byte(offset, data);
	407	}
	408
398	409	static I8237_INTERFACE( qx10_dma8237_1_interface )
399	410	{
400	411	DEVCB_DRIVER_LINE_MEMBER(qx10_state,dma_hrq_changed),
401	412	DEVCB_DRIVER_LINE_MEMBER(qx10_state, tc_w),
402		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
403		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	413	DEVCB_DRIVER_MEMBER(qx10_state, memory_read_byte),
	414	DEVCB_DRIVER_MEMBER(qx10_state, memory_write_byte),
404	415	{ DEVCB_DRIVER_MEMBER(qx10_state, fdc_dma_r), DEVCB_DRIVER_MEMBER(qx10_state, gdc_dack_r),/*DEVCB_DEVICE_HANDLER("upd7220", upd7220_dack_r)*/ DEVCB_NULL, DEVCB_NULL },
405	416	{ DEVCB_DRIVER_MEMBER(qx10_state, fdc_dma_w), DEVCB_DRIVER_MEMBER(qx10_state, gdc_dack_w),/*DEVCB_DEVICE_HANDLER("upd7220", upd7220_dack_w)*/ DEVCB_NULL, DEVCB_NULL },
406	417	{ DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }

trunk/src/mess/drivers/bullet.c

r22525	r22526
847	847	}
848	848	}
849	849
850		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
851		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	850	READ8_MEMBER(bullet_state::io_read_byte)
	851	{
	852	address_space& prog_space = m_maincpu->space(AS_IO);
	853	return prog_space.read_byte(offset);
	854	}
852	855
	856	WRITE8_MEMBER(bullet_state::io_write_byte)
	857	{
	858	address_space& prog_space = m_maincpu->space(AS_IO);
	859	return prog_space.write_byte(offset, data);
	860	}
	861
	862
853	863	static Z80DMA_INTERFACE( dma_intf )
854	864	{
855	865	DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_HALT),
r22525	r22526
857	867	DEVCB_NULL,
858	868	DEVCB_DRIVER_MEMBER(bullet_state, dma_mreq_r),
859	869	DEVCB_DRIVER_MEMBER(bullet_state, dma_mreq_w),
860		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_read_byte),
861		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_write_byte)
	870	DEVCB_DRIVER_MEMBER(bullet_state, io_read_byte),
	871	DEVCB_DRIVER_MEMBER(bullet_state, io_write_byte)
862	872	};
863	873
864	874
r22525	r22526
899	909	DEVCB_NULL,
900	910	DEVCB_DRIVER_MEMBER(bulletf_state, dma_mreq_r),
901	911	DEVCB_DRIVER_MEMBER(bulletf_state, dma_mreq_w),
902		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_read_byte),
903		DEVCB_MEMORY_HANDLER(Z80_TAG, IO, memory_write_byte)
	912	DEVCB_DRIVER_MEMBER(bullet_state, io_read_byte),
	913	DEVCB_DRIVER_MEMBER(bullet_state, io_write_byte)
904	914	};
905	915
906	916

trunk/src/mame/includes/mario.h

r22525	r22526
92	92	DECLARE_WRITE8_MEMBER(mario_sh_sound_w);
93	93	DECLARE_WRITE8_MEMBER(mario_sh1_w);
94	94	DECLARE_WRITE8_MEMBER(mario_sh2_w);
	95	DECLARE_READ8_MEMBER(memory_read_byte);
	96	DECLARE_WRITE8_MEMBER(memory_write_byte);
95	97	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
96	98	required_device<cpu_device> m_maincpu;
97	99	required_device<cpu_device> m_audiocpu;

trunk/src/mame/includes/nbmj8688.h

r22525	r22526
88	88	DECLARE_VIDEO_START(mbmj8688_hybrid_16bit);
89	89	DECLARE_VIDEO_START(mbmj8688_hybrid_12bit);
90	90	DECLARE_VIDEO_START(mbmj8688_pure_16bit);
	91	DECLARE_READ8_MEMBER(dipsw1_r);
	92	DECLARE_READ8_MEMBER(dipsw2_r);
91	93	UINT32 screen_update_mbmj8688(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
92	94	UINT32 screen_update_mbmj8688_lcd0(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
93	95	UINT32 screen_update_mbmj8688_lcd1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

trunk/src/mame/includes/dkong.h

r22525	r22526
239	239	void dkong_init_device_driver_data(  );
240	240	void braze_decrypt_rom(UINT8 *dest);
241	241	void drakton_decrypt_rom(UINT8 mod, int offs, int *bs);
	242	DECLARE_READ8_MEMBER(memory_read_byte);
	243	DECLARE_WRITE8_MEMBER(memory_write_byte);
	244
242	245	required_device<cpu_device> m_maincpu;
243	246	optional_device<cpu_device> m_soundcpu;
244	247	optional_device<eeprom_device> m_eeprom;

trunk/src/mame/drivers/nbmj8688.c

r22525	r22526
2895	2895	INPUT_PORTS_END
2896	2896
2897	2897
	2898	READ8_MEMBER(nbmj8688_state::dipsw1_r)
	2899	{
	2900	return nb1413m3_dipsw1_r(space,offset);
	2901	}
	2902
	2903	READ8_MEMBER(nbmj8688_state::dipsw2_r)
	2904	{
	2905	return nb1413m3_dipsw2_r(space,offset);
	2906	}
	2907
2898	2908	static const ay8910_interface ay8910_config =
2899	2909	{
2900	2910	AY8910_LEGACY_OUTPUT,
2901	2911	AY8910_DEFAULT_LOADS,
2902		DEVCB_MEMORY_HANDLER("maincpu", IO, nb1413m3_dipsw1_r),     // DIPSW-A read
2903		DEVCB_MEMORY_HANDLER("maincpu", IO, nb1413m3_dipsw2_r),     // DIPSW-B read
	2912	DEVCB_DRIVER_MEMBER(nbmj8688_state, dipsw1_r),     // DIPSW-A read
	2913	DEVCB_DRIVER_MEMBER(nbmj8688_state, dipsw2_r),     // DIPSW-B read
2904	2914	DEVCB_NULL,
2905	2915	DEVCB_NULL
2906	2916	};

trunk/src/mame/drivers/dkong.c

r22525	r22526
330	330
331	331	#define COMBINE_TYPE_PC(_tyn, _pc) ((_tyn)<<16 | (_pc))
332	332
333		/*************************************
334		*
335		*  Prototypes
336		*
337		*************************************/
338	333
339
340
341
342
343
344	334	/*************************************
345	335	*
346	336	*  statics
347	337	*
348	338	*************************************/
349	339
350		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
351		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	340	READ8_MEMBER(dkong_state::memory_read_byte)
	341	{
	342	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	343	return prog_space.read_byte(offset);
	344	}
352	345
	346	WRITE8_MEMBER(dkong_state::memory_write_byte)
	347	{
	348	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	349	return prog_space.write_byte(offset, data);
	350	}
	351
353	352	static Z80DMA_INTERFACE( dk3_dma )
354	353	{
355	354	DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_HALT),
356	355	DEVCB_NULL,
357	356	DEVCB_NULL,
358		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
359		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	357	DEVCB_DRIVER_MEMBER(dkong_state, memory_read_byte),
	358	DEVCB_DRIVER_MEMBER(dkong_state, memory_write_byte),
360	359	DEVCB_NULL,
361	360	DEVCB_NULL
362	361	};
r22525	r22526
366	365	DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_HALT),
367	366	DEVCB_NULL,
368	367	DEVCB_NULL,
369		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
370		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	368	DEVCB_DRIVER_MEMBER(dkong_state, memory_read_byte),
	369	DEVCB_DRIVER_MEMBER(dkong_state, memory_write_byte),
371	370	{ DEVCB_NULL, DEVCB_DRIVER_MEMBER(dkong_state,p8257_ctl_r), DEVCB_NULL, DEVCB_NULL },
372	371	{ DEVCB_DRIVER_MEMBER(dkong_state,p8257_ctl_w), DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }
373	372	};

trunk/src/mame/drivers/mario.c

r22525	r22526
101	101	*
102	102	*************************************/
103	103
104		static UINT8 memory_read_byte(address_space &space, offs_t address, UINT8 mem_mask) { return space.read_byte(address); }
105		static void memory_write_byte(address_space &space, offs_t address, UINT8 data, UINT8 mem_mask) { space.write_byte(address, data); }
	104	READ8_MEMBER(mario_state::memory_read_byte)
	105	{
	106	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	107	return prog_space.read_byte(offset);
	108	}
106	109
	110	WRITE8_MEMBER(mario_state::memory_write_byte)
	111	{
	112	address_space& prog_space = m_maincpu->space(AS_PROGRAM);
	113	return prog_space.write_byte(offset, data);
	114	}
	115
107	116	static Z80DMA_INTERFACE( mario_dma )
108	117	{
109	118	DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_HALT),
110	119	DEVCB_NULL,
111	120	DEVCB_NULL,
112		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte),
113		DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte),
	121	DEVCB_DRIVER_MEMBER(mario_state, memory_read_byte),
	122	DEVCB_DRIVER_MEMBER(mario_state, memory_write_byte),
114	123	DEVCB_NULL,
115	124	DEVCB_NULL
116	125	};

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team