Previous

199869 Revisions

Next

r18056 Friday 21st September, 2012 at 08:25:27 UTC by Miodrag Milanović
change from device->machine() to space.machine() in device handlers in order to make next changes easier (no whatsnew)

[src/mame/audio]	leland.c redalert.c
[src/mame/drivers]	chihiro.c chinagat.c ddenlovr.c dlair.c esripsys.c ghosteo.c m10.c mpu4vid.c mquake.c nyny.c othello.c powerbal.c proconn.c r2dtank.c segac2.c segas16a.c spiders.c topspeed.c trvquest.c
[src/mame/machine]	atari.c beezer.c carpolo.c dc.c konppc.c leland.c mcr68.c megadriv.c n64.c namco06.c namco50.c namco51.c pcshare.c qix.c scramble.c stfight.c taitoio.c vectrex.c williams.c
[src/mame/video]	deco16ic.c decocomn.c gameplan.c gp9001.c hanaawas.c homerun.c konicdev.c leland.c phoenix.c qix.c system1.c taitoic.c vectrex.c xxmissio.c
[src/mess/audio]	dave.c mea8000.c svision.c wswan.c
[src/mess/drivers]	a2600.c ami1200.c amiga.c apexc.c apollo.c apple2.c apple2gs.c atari400.c bml3.c dectalk.c digel804.c dm7000.c einstein.c elwro800.c enterp.c fidelz80.c fm7.c fmtowns.c jr100.c juicebox.c mini2440.c mirage.c ms0515.c mycom.c mz2000.c mz2500.c nanos.c osbexec.c p8k.c palm.c palmz22.c pc8801.c pc88va.c pc9801.c pes.c pk8000.c portfoli.c samcoupe.c sgi_ip2.c spc1000.c ssystem3.c v1050.c vtech1.c x68k.c xor100.c
[src/mess/machine]	a7800.c ac1.c amstrad.c apollo.c apple1.c apple3.c atarifdc.c b2m.c bbc.c bebox.c c64.c c65.c cbmb.c cgenie.c concept.c dgn_beta.c e05a03.c isa_fdc.c isa_hdc.c kaypro.c kramermc.c lisa.c lviv.c mac.c macpci.c mc68328.c mc6843.c mc6846.c mc6854.c micropolis.c microtan.c mos6530.c msx.c mtx.c mz700.c oric.c orion.c pc.c pc_lpt.c pet.c pk8020.c pmd85.c pokemini.c pp01.c radio86.c rmnimbus.c s3c44b0.c samcoupe.c super80.c svi318.c sym1.c tf20.c thomson.c upd7002.c upd765.c z80ne.c
[src/mess/video]	911_vdt.c cirrus.c vic4567.c vic6567.c vtvideo.c

trunk/src/mame/audio/leland.c

r18055	r18056
1839	1839	}
1840	1840
1841	1841	/* /RESET */
1842		device->machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, data & 0x80  ? CLEAR_LINE : ASSERT_LINE);
	1842	space.machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, data & 0x80  ? CLEAR_LINE : ASSERT_LINE);
1843	1843
1844	1844	/* /NMI */
1845	1845	/*  If the master CPU doesn't get a response by the time it's ready to send
1846	1846	the next command, it uses an NMI to force the issue; unfortunately, this
1847	1847	seems to really screw up the sound system. It turns out it's better to
1848	1848	just wait for the original interrupt to occur naturally */
1849		/*  device->machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, data & 0x40  ? CLEAR_LINE : ASSERT_LINE);*/
	1849	/*  space.machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, data & 0x40  ? CLEAR_LINE : ASSERT_LINE);*/
1850	1850
1851	1851	/* INT0 */
1852	1852	if (data & 0x20)
r18055	r18056
1894	1894
1895	1895	WRITE8_DEVICE_HANDLER( leland_80186_command_lo_w )
1896	1896	{
1897		device->machine().scheduler().synchronize(FUNC(command_lo_sync), data, device);
	1897	space.machine().scheduler().synchronize(FUNC(command_lo_sync), data, device);
1898	1898	}
1899	1899
1900	1900
r18055	r18056
1957	1957	if (LOG_COMM) logerror("%04X:Read sound response latch = %02X\n", pc, state->m_sound_response);
1958	1958
1959	1959	/* synchronize the response */
1960		device->machine().scheduler().synchronize(FUNC(delayed_response_r), pc + 2, device);
	1960	space.machine().scheduler().synchronize(FUNC(delayed_response_r), pc + 2, device);
1961	1961	return state->m_sound_response;
1962	1962	}
1963	1963
r18055	r18056
2204	2204	if (!state->m_has_ym2151)
2205	2205	return pit8254_r(device, space, offset | 0x40, mem_mask);
2206	2206	else
2207		return ym2151_r(device->machine().device("ymsnd"), space, offset);
	2207	return ym2151_r(space.machine().device("ymsnd"), space, offset);
2208	2208
2209	2209	case 4:
2210	2210	if (state->m_is_redline)
r18055	r18056
2241	2241	if (!state->m_has_ym2151)
2242	2242	pit8254_w(device, space, offset | 0x40, data, mem_mask);
2243	2243	else
2244		ym2151_w(device->machine().device("ymsnd"), space, offset, data);
	2244	ym2151_w(space.machine().device("ymsnd"), space, offset, data);
2245	2245	break;
2246	2246
2247	2247	case 4:

trunk/src/mame/audio/redalert.c

r18055	r18056
76	76
77	77	static WRITE8_DEVICE_HANDLER( redalert_AY8910_w )
78	78	{
79		redalert_state *state = device->machine().driver_data<redalert_state>();
	79	redalert_state *state = space.machine().driver_data<redalert_state>();
80	80	/* BC2 is connected to a pull-up resistor, so BC2=1 always */
81	81	switch (data & 0x03)
82	82	{

trunk/src/mame/machine/taitoio.c

r18055	r18056
126	126	{
127	127
128	128	case 0x00:
129		device->machine().watchdog_reset();
	129	space.machine().watchdog_reset();
130	130	break;
131	131
132	132	case 0x04:   /* coin counters and lockout, hi nibble irrelevant */
133	133
134		coin_lockout_w(device->machine(), 0, ~data & 0x01);
135		coin_lockout_w(device->machine(), 1, ~data & 0x02);
136		coin_counter_w(device->machine(), 0, data & 0x04);
137		coin_counter_w(device->machine(), 1, data & 0x08);
	134	coin_lockout_w(space.machine(), 0, ~data & 0x01);
	135	coin_lockout_w(space.machine(), 1, ~data & 0x02);
	136	coin_counter_w(space.machine(), 0, data & 0x04);
	137	coin_counter_w(space.machine(), 1, data & 0x08);
138	138
139	139	//if (data & 0xf0)
140	140	//logerror("PC %06x: warning - write %02x to TC0220IOC address %02x\n",space.device().safe_pc(),data,offset);
r18055	r18056
282	282	switch (offset)
283	283	{
284	284	case 0x00:
285		device->machine().watchdog_reset();
	285	space.machine().watchdog_reset();
286	286	break;
287	287
288	288	case 0x04:   /* coin counters and lockout */
289		coin_lockout_w(device->machine(), 0, ~data & 0x01);
290		coin_lockout_w(device->machine(), 1, ~data & 0x02);
291		coin_counter_w(device->machine(), 0, data & 0x04);
292		coin_counter_w(device->machine(), 1, data & 0x08);
	289	coin_lockout_w(space.machine(), 0, ~data & 0x01);
	290	coin_lockout_w(space.machine(), 1, ~data & 0x02);
	291	coin_counter_w(space.machine(), 0, data & 0x04);
	292	coin_counter_w(space.machine(), 1, data & 0x08);
293	293	break;
294	294
295	295	default:
r18055	r18056
432	432	{
433	433
434	434	case 0x00:
435		device->machine().watchdog_reset();
	435	space.machine().watchdog_reset();
436	436	break;
437	437
438	438	case 0x04:   /* coin counters and lockout */
439		coin_lockout_w(device->machine(), 0, ~data & 0x01);
440		coin_lockout_w(device->machine(), 1, ~data & 0x02);
441		coin_counter_w(device->machine(), 0, data & 0x04);
442		coin_counter_w(device->machine(), 1, data & 0x08);
	439	coin_lockout_w(space.machine(), 0, ~data & 0x01);
	440	coin_lockout_w(space.machine(), 1, ~data & 0x02);
	441	coin_counter_w(space.machine(), 0, data & 0x04);
	442	coin_counter_w(space.machine(), 1, data & 0x08);
443	443	break;
444	444
445	445	default:

trunk/src/mame/machine/namco06.c

r18055	r18056
135	135	UINT8 result = 0xff;
136	136	int devnum;
137	137
138		LOG(("%s: 06XX '%s' read offset %d\n",device->machine().describe_context(),device->tag(),offset));
	138	LOG(("%s: 06XX '%s' read offset %d\n",space.machine().describe_context(),device->tag(),offset));
139	139
140	140	if (!(state->m_control & 0x10))
141	141	{
142		logerror("%s: 06XX '%s' read in write mode %02x\n",device->machine().describe_context(),device->tag(),state->m_control);
	142	logerror("%s: 06XX '%s' read in write mode %02x\n",space.machine().describe_context(),device->tag(),state->m_control);
143	143	return 0;
144	144	}
145	145
r18055	r18056
156	156	namco_06xx_state *state = get_safe_token(device);
157	157	int devnum;
158	158
159		LOG(("%s: 06XX '%s' write offset %d = %02x\n",device->machine().describe_context(),device->tag(),offset,data));
	159	LOG(("%s: 06XX '%s' write offset %d = %02x\n",space.machine().describe_context(),device->tag(),offset,data));
160	160
161	161	if (state->m_control & 0x10)
162	162	{
163		logerror("%s: 06XX '%s' write in read mode %02x\n",device->machine().describe_context(),device->tag(),state->m_control);
	163	logerror("%s: 06XX '%s' write in read mode %02x\n",space.machine().describe_context(),device->tag(),state->m_control);
164	164	return;
165	165	}
166	166
r18055	r18056
173	173	READ8_DEVICE_HANDLER( namco_06xx_ctrl_r )
174	174	{
175	175	namco_06xx_state *state = get_safe_token(device);
176		LOG(("%s: 06XX '%s' ctrl_r\n",device->machine().describe_context(),device->tag()));
	176	LOG(("%s: 06XX '%s' ctrl_r\n",space.machine().describe_context(),device->tag()));
177	177	return state->m_control;
178	178	}
179	179
r18055	r18056
182	182	namco_06xx_state *state = get_safe_token(device);
183	183	int devnum;
184	184
185		LOG(("%s: 06XX '%s' control %02x\n",device->machine().describe_context(),device->tag(),data));
	185	LOG(("%s: 06XX '%s' control %02x\n",space.machine().describe_context(),device->tag(),data));
186	186
187	187	state->m_control = data;
188	188

trunk/src/mame/machine/carpolo.c

r18055	r18056
356	356
357	357	static WRITE8_DEVICE_HANDLER( pia_0_port_a_w )
358	358	{
359		carpolo_state *state = device->machine().driver_data<carpolo_state>();
	359	carpolo_state *state = space.machine().driver_data<carpolo_state>();
360	360	/* bit 0 - Coin counter
361	361	bit 1 - Player 4 crash sound
362	362	bit 2 - Player 3 crash sound
r18055	r18056
366	366	bit 6 - Player 1 crash sound
367	367	bit 7 - Ball hit pulse sound */
368	368
369		coin_counter_w(device->machine(), 0, data & 0x01);
	369	coin_counter_w(space.machine(), 0, data & 0x01);
370	370
371	371
372	372	state->m_ttl7474_1f_1->clear_w((data & 0x08) >> 3);
r18055	r18056
378	378
379	379	static WRITE8_DEVICE_HANDLER( pia_0_port_b_w )
380	380	{
381		carpolo_state *state = device->machine().driver_data<carpolo_state>();
	381	carpolo_state *state = space.machine().driver_data<carpolo_state>();
382	382	/* bit 0 - Strobe speed bits sound
383	383	bit 1 - Speed bit 0 sound
384	384	bit 2 - Speed bit 1 sound
r18055	r18056
394	394
395	395	static READ8_DEVICE_HANDLER( pia_0_port_b_r )
396	396	{
397		carpolo_state *state = device->machine().driver_data<carpolo_state>();
	397	carpolo_state *state = space.machine().driver_data<carpolo_state>();
398	398	/* bit 4 - Pedal bit 0
399	399	bit 5 - Pedal bit 1 */
400	400
r18055	r18056
405	405
406	406	static READ8_DEVICE_HANDLER( pia_1_port_a_r )
407	407	{
408		carpolo_state *state = device->machine().driver_data<carpolo_state>();
	408	carpolo_state *state = space.machine().driver_data<carpolo_state>();
409	409	UINT8 ret;
410	410
411	411	/* bit 0 - Player 4 steering input (left or right)
r18055	r18056
429	429
430	430	static READ8_DEVICE_HANDLER( pia_1_port_b_r )
431	431	{
432		carpolo_state *state = device->machine().driver_data<carpolo_state>();
	432	carpolo_state *state = space.machine().driver_data<carpolo_state>();
433	433	UINT8 ret;
434	434
435	435	/* bit 4 - Player 4 steering input (wheel moving or stopped)

trunk/src/mame/machine/megadriv.c

r18055	r18056
114	114	}
115	115	else
116	116	{
117		logerror("%s: 68000 attempting to access YM2612 (read) without bus\n", device->machine().describe_context());
	117	logerror("%s: 68000 attempting to access YM2612 (read) without bus\n", space.machine().describe_context());
118	118	return 0;
119	119	}
120	120
r18055	r18056
131	131	}
132	132	else
133	133	{
134		logerror("%s: 68000 attempting to access YM2612 (write) without bus\n", device->machine().describe_context());
	134	logerror("%s: 68000 attempting to access YM2612 (write) without bus\n", space.machine().describe_context());
135	135	}
136	136	}
137	137

trunk/src/mame/machine/namco50.c

r18055	r18056
223	223
224	224	WRITE8_DEVICE_HANDLER( namco_50xx_write )
225	225	{
226		device->machine().scheduler().synchronize(FUNC(namco_50xx_latch_callback), data, (void *)device);
	226	space.machine().scheduler().synchronize(FUNC(namco_50xx_latch_callback), data, (void *)device);
227	227
228	228	namco_50xx_irq_set(device);
229	229	}

trunk/src/mame/machine/beezer.c

r18055	r18056
88	88
89	89	static READ8_DEVICE_HANDLER( b_via_0_pa_r )
90	90	{
91		beezer_state *state = device->machine().driver_data<beezer_state>();
	91	beezer_state *state = space.machine().driver_data<beezer_state>();
92	92	return (state->m_banklatch&0x38)<<2; // return X,Y,Z bits TODO: the Z bit connects somewhere else... where?
93	93	}
94	94
95	95	static READ8_DEVICE_HANDLER( b_via_0_pb_r )
96	96	{
97		beezer_state *state = device->machine().driver_data<beezer_state>();
	97	beezer_state *state = space.machine().driver_data<beezer_state>();
98	98	return state->m_pbus;
99	99	}
100	100
101	101	static WRITE8_DEVICE_HANDLER( b_via_0_pa_w )
102	102	{
103		beezer_state *state = device->machine().driver_data<beezer_state>();
	103	beezer_state *state = space.machine().driver_data<beezer_state>();
104	104	if ((data & 0x08) == 0)
105		device->machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	105	space.machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
106	106	else
107		device->machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
	107	space.machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
108	108
109	109	if ((data & 0x04) == 0)
110	110	{
r18055	r18056
128	128
129	129	static WRITE8_DEVICE_HANDLER( b_via_0_pb_w )
130	130	{
131		beezer_state *state = device->machine().driver_data<beezer_state>();
	131	beezer_state *state = space.machine().driver_data<beezer_state>();
132	132	state->m_pbus = data;
133	133	}
134	134
135	135	static READ8_DEVICE_HANDLER( b_via_1_pa_r )
136	136	{
137		beezer_state *state = device->machine().driver_data<beezer_state>();
	137	beezer_state *state = space.machine().driver_data<beezer_state>();
138	138	return state->m_pbus;
139	139	}
140	140
141	141	static READ8_DEVICE_HANDLER( b_via_1_pb_r )
142	142	{
143		return 0x1F | (beezer_noise_r(device->machine().device("custom"), space, 0)?0x40:0);
	143	return 0x1F | (beezer_noise_r(space.machine().device("custom"), space, 0)?0x40:0);
144	144	}
145	145
146	146	static WRITE8_DEVICE_HANDLER( b_via_1_pa_w )
147	147	{
148		beezer_state *state = device->machine().driver_data<beezer_state>();
	148	beezer_state *state = space.machine().driver_data<beezer_state>();
149	149	state->m_pbus = data;
150	150	}
151	151
152	152	static WRITE8_DEVICE_HANDLER( b_via_1_pb_w )
153	153	{
154		beezer_timer1_w(device->machine().device("custom"), space, 0, data&0x80);
	154	beezer_timer1_w(space.machine().device("custom"), space, 0, data&0x80);
155	155	//if ((data&0x1f) != 0x01)
156	156	//  popmessage("via1 pb low write of 0x%02x is not supported! contact mamedev!", data&0x1f);
157	157	}

trunk/src/mame/machine/mcr68.c

r18055	r18056
41	41
42	42	static READ8_DEVICE_HANDLER( zwackery_port_1_r )
43	43	{
44		UINT8 ret = device->machine().root_device().ioport("IN1")->read();
	44	UINT8 ret = space.machine().root_device().ioport("IN1")->read();
45	45
46	46	downcast<pia6821_device *>(device)->set_port_a_z_mask(ret);
47	47
r18055	r18056
51	51
52	52	static READ8_DEVICE_HANDLER( zwackery_port_3_r )
53	53	{
54		UINT8 ret = device->machine().root_device().ioport("IN3")->read();
	54	UINT8 ret = space.machine().root_device().ioport("IN3")->read();
55	55
56	56	downcast<pia6821_device *>(device)->set_port_a_z_mask(ret);
57	57
r18055	r18056
270	270	WRITE8_DEVICE_HANDLER( zwackery_pia0_w )
271	271	{
272	272	/* bit 7 is the watchdog */
273		if (!(data & 0x80)) device->machine().watchdog_reset();
	273	if (!(data & 0x80)) space.machine().watchdog_reset();
274	274
275	275	/* bits 5 and 6 control hflip/vflip */
276	276	/* bits 3 and 4 control coin counters? */
r18055	r18056
280	280
281	281	WRITE8_DEVICE_HANDLER( zwackery_pia1_w )
282	282	{
283		mcr68_state *state = device->machine().driver_data<mcr68_state>();
	283	mcr68_state *state = space.machine().driver_data<mcr68_state>();
284	284	state->m_zwackery_sound_data = (data >> 4) & 0x0f;
285	285	}
286	286

trunk/src/mame/machine/namco51.c

r18055	r18056
100	100
101	101	data &= 0x07;
102	102
103		LOG(("%s: custom 51XX write %02x\n",device->machine().describe_context(),data));
	103	LOG(("%s: custom 51XX write %02x\n",space.machine().describe_context(),data));
104	104
105	105	if (state->m_coincred_mode)
106	106	{
r18055	r18056
130	130	static int namcoio_51XX_kludge = 0;
131	131
132	132	/* Only compute namcoio_51XX_kludge when gamedrv changes */
133		if (namcoio_51XX_driver != &device->machine().system())
	133	if (namcoio_51XX_driver != &space.machine().system())
134	134	{
135		namcoio_51XX_driver = &device->machine().system();
	135	namcoio_51XX_driver = &space.machine().system();
136	136	if (strcmp(namcoio_51XX_driver->name, "xevious") == 0 ||
137	137	strcmp(namcoio_51XX_driver->parent, "xevious") == 0)
138	138	namcoio_51XX_kludge = 1;
r18055	r18056
198	198	{
199	199	namco_51xx_state *state = get_safe_token(device);
200	200
201		LOG(("%s: custom 51XX read\n",device->machine().describe_context()));
	201	LOG(("%s: custom 51XX read\n",space.machine().describe_context()));
202	202
203	203	if (state->m_mode == 0)   /* switch mode */
204	204	{
r18055	r18056
265	265
266	266	if (state->m_mode == 1)
267	267	{
268		int on = (device->machine().primary_screen->frame_number() & 0x10) >> 4;
	268	int on = (space.machine().primary_screen->frame_number() & 0x10) >> 4;
269	269
270	270	if (state->m_credits >= 2)
271	271	WRITE_PORT(state,0,0x0c | 3*on);   // lamps

trunk/src/mame/machine/atari.c

r18055	r18056
64	64
65	65	READ8_DEVICE_HANDLER(atari_pia_pa_r)
66	66	{
67		return device->machine().root_device().ioport("djoy_0_1")->read_safe(0);
	67	return space.machine().root_device().ioport("djoy_0_1")->read_safe(0);
68	68	}
69	69
70	70	READ8_DEVICE_HANDLER(atari_pia_pb_r)
71	71	{
72		return device->machine().root_device().ioport("djoy_2_3")->read_safe(0);
	72	return space.machine().root_device().ioport("djoy_2_3")->read_safe(0);
73	73	}
74	74
75	75	WRITE8_DEVICE_HANDLER(a600xl_pia_pb_w) { a600xl_mmu(device->machine(), data); }

trunk/src/mame/machine/konppc.c

r18055	r18056
443	443	{
444	444	if (nwk_device_sel[0] & 0x01)
445	445	{
446		nwk_fifo_w(device->machine(), 0, data);
	446	nwk_fifo_w(space.machine(), 0, data);
447	447	}
448	448	else if (nwk_device_sel[0] & 0x02)
449	449	{
r18055	r18056
460	460	{
461	461	if (nwk_device_sel[1] & 0x01)
462	462	{
463		nwk_fifo_w(device->machine(), 1, data);
	463	nwk_fifo_w(space.machine(), 1, data);
464	464	}
465	465	else if (nwk_device_sel[1] & 0x02)
466	466	{
r18055	r18056
501	501	{
502	502	if (nwk_device_sel[0] & 0x01)
503	503	{
504		nwk_fifo_w(device->machine(), 0, data);
	504	nwk_fifo_w(space.machine(), 0, data);
505	505	}
506	506	else if (nwk_device_sel[0] & 0x02)
507	507	{
r18055	r18056
518	518	{
519	519	if (nwk_device_sel[1] & 0x01)
520	520	{
521		nwk_fifo_w(device->machine(), 1, data);
	521	nwk_fifo_w(space.machine(), 1, data);
522	522	}
523	523	else if (nwk_device_sel[1] & 0x02)
524	524	{

trunk/src/mame/machine/leland.c

r18055	r18056
821	821
822	822	READ8_DEVICE_HANDLER( ataxx_eeprom_r )
823	823	{
824		int port = device->machine().root_device().ioport("IN2")->read();
825		if (LOG_EEPROM) logerror("%s:EE read\n", device->machine().describe_context());
	824	int port = space.machine().root_device().ioport("IN2")->read();
	825	if (LOG_EEPROM) logerror("%s:EE read\n", space.machine().describe_context());
826	826	return port;
827	827	}
828	828
829	829
830	830	WRITE8_DEVICE_HANDLER( ataxx_eeprom_w )
831	831	{
832		if (LOG_EEPROM) logerror("%s:EE write %d%d%d\n", device->machine().describe_context(),
	832	if (LOG_EEPROM) logerror("%s:EE write %d%d%d\n", space.machine().describe_context(),
833	833	(data >> 6) & 1, (data >> 5) & 1, (data >> 4) & 1);
834	834	eeprom_device *eeprom = downcast<eeprom_device *>(device);
835	835	eeprom->write_bit     ((data & 0x10) >> 4);
r18055	r18056
1306	1306
1307	1307	READ8_DEVICE_HANDLER( leland_sound_port_r )
1308	1308	{
1309		leland_state *state = device->machine().driver_data<leland_state>();
	1309	leland_state *state = space.machine().driver_data<leland_state>();
1310	1310	return state->m_gfx_control;
1311	1311	}
1312	1312
1313	1313
1314	1314	WRITE8_DEVICE_HANDLER( leland_sound_port_w )
1315	1315	{
1316		leland_state *state = device->machine().driver_data<leland_state>();
	1316	leland_state *state = space.machine().driver_data<leland_state>();
1317	1317	/* update the graphics banking */
1318	1318	leland_gfx_port_w(device, space, 0, data);
1319	1319
r18055	r18056
1324	1324	/* some bankswitching occurs here */
1325	1325	if (LOG_BANKSWITCHING_M)
1326	1326	if ((state->m_sound_port_bank ^ data) & 0x24)
1327		logerror("%s:sound_port_bank = %02X\n", device->machine().describe_context(), data & 0x24);
	1327	logerror("%s:sound_port_bank = %02X\n", space.machine().describe_context(), data & 0x24);
1328	1328	state->m_sound_port_bank = data & 0x24;
1329		(*state->m_update_master_bank)(device->machine());
	1329	(*state->m_update_master_bank)(space.machine());
1330	1330	}
1331	1331
1332	1332

trunk/src/mame/machine/vectrex.c

r18055	r18056
229	229
230	230	READ8_DEVICE_HANDLER(vectrex_via_pb_r)
231	231	{
232		vectrex_state *state = device->machine().driver_data<vectrex_state>();
	232	vectrex_state *state = space.machine().driver_data<vectrex_state>();
233	233	int pot;
234	234	static const char *const ctrlnames[] = { "CONTR1X", "CONTR1Y", "CONTR2X", "CONTR2Y" };
235	235
236		pot = device->machine().root_device().ioport(ctrlnames[(state->m_via_out[PORTB] & 0x6) >> 1])->read() - 0x80;
	236	pot = space.machine().root_device().ioport(ctrlnames[(state->m_via_out[PORTB] & 0x6) >> 1])->read() - 0x80;
237	237
238	238	if (pot > (signed char)state->m_via_out[PORTA])
239	239	state->m_via_out[PORTB] |= 0x20;
r18055	r18056
246	246
247	247	READ8_DEVICE_HANDLER(vectrex_via_pa_r)
248	248	{
249		vectrex_state *state = device->machine().driver_data<vectrex_state>();
	249	vectrex_state *state = space.machine().driver_data<vectrex_state>();
250	250	if ((!(state->m_via_out[PORTB] & 0x10)) && (state->m_via_out[PORTB] & 0x08))
251	251	/* BDIR inactive, we can read the PSG. BC1 has to be active. */
252	252	{
253		device_t *ay = device->machine().device("ay8912");
	253	device_t *ay = space.machine().device("ay8912");
254	254
255	255	state->m_via_out[PORTA] = ay8910_r(ay, space, 0)
256	256	& ~(state->m_imager_pinlevel & 0x80);
r18055	r18056
261	261
262	262	READ8_DEVICE_HANDLER(vectrex_s1_via_pb_r)
263	263	{
264		vectrex_state *state = device->machine().driver_data<vectrex_state>();
	264	vectrex_state *state = space.machine().driver_data<vectrex_state>();
265	265	return (state->m_via_out[PORTB] & ~0x40) | (state->ioport("COIN")->read() & 0x40);
266	266	}
267	267

trunk/src/mame/machine/dc.c

r18055	r18056
835	835
836	836	READ64_DEVICE_HANDLER( dc_aica_reg_r )
837	837	{
838		//  dc_state *state = device->machine().driver_data<dc_state>();
	838	//  dc_state *state = space.machine().driver_data<dc_state>();
839	839	//int reg;
840	840	UINT64 shift;
841	841
842		/*reg = */decode_reg32_64(device->machine(), offset, mem_mask, &shift);
	842	/*reg = */decode_reg32_64(space.machine(), offset, mem_mask, &shift);
843	843
844	844	//  mame_printf_verbose("AICA REG: [%08x] read %" I64FMT "x, mask %" I64FMT "x\n", 0x700000+reg*4, (UINT64)offset, mem_mask);
845	845
r18055	r18056
848	848
849	849	WRITE64_DEVICE_HANDLER( dc_aica_reg_w )
850	850	{
851		//  dc_state *state = device->machine().driver_data<dc_state>();
	851	//  dc_state *state = space.machine().driver_data<dc_state>();
852	852	int reg;
853	853	UINT64 shift;
854	854	UINT32 dat;
855	855
856		reg = decode_reg32_64(device->machine(), offset, mem_mask, &shift);
	856	reg = decode_reg32_64(space.machine(), offset, mem_mask, &shift);
857	857	dat = (UINT32)(data >> shift);
858	858
859	859	if (reg == (0x2c00/4))
r18055	r18056
861	861	if (dat & 1)
862	862	{
863	863	/* halt the ARM7 */
864		device->machine().device("soundcpu")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	864	space.machine().device("soundcpu")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
865	865	}
866	866	else
867	867	{
868	868	/* it's alive ! */
869		device->machine().device("soundcpu")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
	869	space.machine().device("soundcpu")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
870	870	}
871	871	}
872	872

trunk/src/mame/machine/scramble.c

r18055	r18056
51	51
52	52	WRITE8_DEVICE_HANDLER( scramble_protection_w )
53	53	{
54		scramble_state *state = device->machine().driver_data<scramble_state>();
	54	scramble_state *state = space.machine().driver_data<scramble_state>();
55	55	state->m_xb = data;
56	56	}
57	57
58	58	READ8_DEVICE_HANDLER( scramble_protection_r )
59	59	{
60		switch (device->machine().device("maincpu")->safe_pc())
	60	switch (space.machine().device("maincpu")->safe_pc())
61	61	{
62	62	case 0x00a8: return 0xf0;
63	63	case 0x00be: return 0xb0;
r18055	r18056
68	68	case 0x1ca2: return 0x00;  /* I don't think it's checked */
69	69	case 0x1d7e: return 0xb0;
70	70	default:
71		logerror("%s: read protection\n",device->machine().describe_context());
	71	logerror("%s: read protection\n",space.machine().describe_context());
72	72	return 0;
73	73	}
74	74	}

trunk/src/mame/machine/n64.c

r18055	r18056
683	683
684	684	READ32_DEVICE_HANDLER( n64_sp_reg_r )
685	685	{
686		return device->machine().device<n64_periphs>("rcp")->sp_reg_r(offset);
	686	return space.machine().device<n64_periphs>("rcp")->sp_reg_r(offset);
687	687	}
688	688
689	689	void n64_periphs::sp_reg_w(UINT32 offset, UINT32 data, UINT32 mem_mask)
r18055	r18056
896	896
897	897	WRITE32_DEVICE_HANDLER( n64_sp_reg_w )
898	898	{
899		device->machine().device<n64_periphs>("rcp")->sp_reg_w(offset, data, mem_mask);
	899	space.machine().device<n64_periphs>("rcp")->sp_reg_w(offset, data, mem_mask);
900	900	}
901	901
902	902	// RDP Interface
r18055	r18056
908	908
909	909	READ32_DEVICE_HANDLER( n64_dp_reg_r )
910	910	{
911		n64_state *state = device->machine().driver_data<n64_state>();
912		n64_periphs *periphs = device->machine().device<n64_periphs>("rcp");
	911	n64_state *state = space.machine().driver_data<n64_state>();
	912	n64_periphs *periphs = space.machine().device<n64_periphs>("rcp");
913	913	UINT32 ret = 0;
914	914	switch (offset)
915	915	{
r18055	r18056
944	944	break;
945	945	}
946	946
947		//printf("%08x dp_reg_r %08x = %08x\n", (UINT32)device->machine().device("rsp")->state().state_int(RSP_PC), offset, ret); fflush(stdout);
	947	//printf("%08x dp_reg_r %08x = %08x\n", (UINT32)space.machine().device("rsp")->state().state_int(RSP_PC), offset, ret); fflush(stdout);
948	948	return ret;
949	949	}
950	950
951	951	WRITE32_DEVICE_HANDLER( n64_dp_reg_w )
952	952	{
953		n64_state *state = device->machine().driver_data<n64_state>();
954		n64_periphs *periphs = device->machine().device<n64_periphs>("rcp");
	953	n64_state *state = space.machine().driver_data<n64_state>();
	954	n64_periphs *periphs = space.machine().device<n64_periphs>("rcp");
955	955
956		//printf("%08x dp_reg_w %08x %08x %08x\n", (UINT32)device->machine().device("rsp")->state().state_int(RSP_PC), offset, data, mem_mask); fflush(stdout);
	956	//printf("%08x dp_reg_w %08x %08x %08x\n", (UINT32)space.machine().device("rsp")->state().state_int(RSP_PC), offset, data, mem_mask); fflush(stdout);
957	957	switch (offset)
958	958	{
959	959	case 0x00/4:      // DP_START_REG

trunk/src/mame/machine/stfight.c

r18055	r18056
212	212
213	213	WRITE8_DEVICE_HANDLER( stfight_adpcm_control_w )
214	214	{
215		stfight_state *state = device->machine().driver_data<stfight_state>();
	215	stfight_state *state = space.machine().driver_data<stfight_state>();
216	216	if( data < 0x08 )
217	217	{
218	218	state->m_adpcm_data_offs = sampleLimits[data];

trunk/src/mame/machine/qix.c

r18055	r18056
346	346
347	347	READ8_DEVICE_HANDLER( qixmcu_coin_r )
348	348	{
349		qix_state *state = device->machine().driver_data<qix_state>();
	349	qix_state *state = space.machine().driver_data<qix_state>();
350	350
351	351	logerror("6809:qixmcu_coin_r = %02X\n", state->m_68705_port_out[0]);
352	352	return state->m_68705_port_out[0];
r18055	r18056
355	355
356	356	static WRITE8_DEVICE_HANDLER( qixmcu_coin_w )
357	357	{
358		qix_state *state = device->machine().driver_data<qix_state>();
	358	qix_state *state = space.machine().driver_data<qix_state>();
359	359
360	360	logerror("6809:qixmcu_coin_w = %02X\n", data);
361	361	/* this is a callback called by pia6821_device::write(), so I don't need to synchronize */
r18055	r18056
366	366
367	367	static WRITE8_DEVICE_HANDLER( qixmcu_coinctrl_w )
368	368	{
369		qix_state *state = device->machine().driver_data<qix_state>();
	369	qix_state *state = space.machine().driver_data<qix_state>();
370	370
371	371	/* if (!(data & 0x04)) */
372	372	if (data & 0x04)
373	373	{
374		device->machine().device("mcu")->execute().set_input_line(M68705_IRQ_LINE, ASSERT_LINE);
	374	space.machine().device("mcu")->execute().set_input_line(M68705_IRQ_LINE, ASSERT_LINE);
375	375	/* temporarily boost the interleave to sync things up */
376	376	/* note: I'm using 50 because 30 is not enough for space dungeon at game over */
377		device->machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(50));
	377	space.machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(50));
378	378	}
379	379	else
380		device->machine().device("mcu")->execute().set_input_line(M68705_IRQ_LINE, CLEAR_LINE);
	380	space.machine().device("mcu")->execute().set_input_line(M68705_IRQ_LINE, CLEAR_LINE);
381	381
382	382	/* this is a callback called by pia6821_device::write(), so I don't need to synchronize */
383	383	/* the CPUs - they have already been synchronized by qix_pia_w() */
r18055	r18056
473	473	{
474	474	/* make all the CPUs synchronize, and only AFTER that write the command to the PIA */
475	475	/* otherwise the 68705 will miss commands */
476		device->machine().scheduler().synchronize(FUNC(pia_w_callback), data | (offset << 8), (void *)downcast<pia6821_device *>(device));
	476	space.machine().scheduler().synchronize(FUNC(pia_w_callback), data | (offset << 8), (void *)downcast<pia6821_device *>(device));
477	477	}
478	478
479	479
r18055	r18056
486	486
487	487	static WRITE8_DEVICE_HANDLER( qix_coinctl_w )
488	488	{
489		coin_lockout_w(device->machine(), 0, (~data >> 2) & 1);
490		coin_counter_w(device->machine(), 0, (data >> 1) & 1);
	489	coin_lockout_w(space.machine(), 0, (~data >> 2) & 1);
	490	coin_counter_w(space.machine(), 0, (data >> 1) & 1);
491	491	}
492	492
493	493
r18055	r18056
500	500
501	501	static WRITE8_DEVICE_HANDLER( slither_76489_0_w )
502	502	{
503		qix_state *state = device->machine().driver_data<qix_state>();
	503	qix_state *state = space.machine().driver_data<qix_state>();
504	504
505	505	/* write to the sound chip */
506		state->m_sn1->write(device->machine().device<legacy_cpu_device>("maincpu")->space(), 0, data);
	506	state->m_sn1->write(space.machine().device<legacy_cpu_device>("maincpu")->space(), 0, data);
507	507
508	508	/* clock the ready line going back into CB1 */
509	509	pia6821_device *pia = downcast<pia6821_device *>(device);
r18055	r18056
514	514
515	515	static WRITE8_DEVICE_HANDLER( slither_76489_1_w )
516	516	{
517		qix_state *state = device->machine().driver_data<qix_state>();
	517	qix_state *state = space.machine().driver_data<qix_state>();
518	518
519	519	/* write to the sound chip */
520		state->m_sn2->write(device->machine().device<legacy_cpu_device>("maincpu")->space(), 0, data);
	520	state->m_sn2->write(space.machine().device<legacy_cpu_device>("maincpu")->space(), 0, data);
521	521
522	522	/* clock the ready line going back into CB1 */
523	523	pia6821_device *pia = downcast<pia6821_device *>(device);
r18055	r18056
535	535
536	536	static READ8_DEVICE_HANDLER( slither_trak_lr_r )
537	537	{
538		qix_state *state = device->machine().driver_data<qix_state>();
	538	qix_state *state = space.machine().driver_data<qix_state>();
539	539
540	540	return state->ioport(state->m_flip ? "AN3" : "AN1")->read();
541	541	}
r18055	r18056
543	543
544	544	static READ8_DEVICE_HANDLER( slither_trak_ud_r )
545	545	{
546		qix_state *state = device->machine().driver_data<qix_state>();
	546	qix_state *state = space.machine().driver_data<qix_state>();
547	547
548	548	return state->ioport(state->m_flip ? "AN2" : "AN0")->read();
549	549	}

trunk/src/mame/machine/pcshare.c

r18055	r18056
267	267	static READ8_DEVICE_HANDLER( get_slave_ack )
268	268	{
269	269	if (offset==2) { // IRQ = 2
270		return pic8259_acknowledge(device->machine().device("pic8259_2"));
	270	return pic8259_acknowledge(space.machine().device("pic8259_2"));
271	271	}
272	272	return 0x00;
273	273	}

trunk/src/mame/machine/williams.c

r18055	r18056
561	561	WRITE8_DEVICE_HANDLER( williams_snd_cmd_w )
562	562	{
563	563	/* the high two bits are set externally, and should be 1 */
564		device->machine().scheduler().synchronize(FUNC(williams_deferred_snd_cmd_w), data | 0xc0);
	564	space.machine().scheduler().synchronize(FUNC(williams_deferred_snd_cmd_w), data | 0xc0);
565	565	}
566	566
567	567	WRITE8_DEVICE_HANDLER( playball_snd_cmd_w )
568	568	{
569		device->machine().scheduler().synchronize(FUNC(williams_deferred_snd_cmd_w), data);
	569	space.machine().scheduler().synchronize(FUNC(williams_deferred_snd_cmd_w), data);
570	570	}
571	571
572	572	static TIMER_CALLBACK( blaster_deferred_snd_cmd_w )
r18055	r18056
582	582
583	583	WRITE8_DEVICE_HANDLER( blaster_snd_cmd_w )
584	584	{
585		device->machine().scheduler().synchronize(FUNC(blaster_deferred_snd_cmd_w), data);
	585	space.machine().scheduler().synchronize(FUNC(blaster_deferred_snd_cmd_w), data);
586	586	}
587	587
588	588
r18055	r18056
595	595
596	596	static WRITE8_DEVICE_HANDLER( williams2_snd_cmd_w )
597	597	{
598		device->machine().scheduler().synchronize(FUNC(williams2_deferred_snd_cmd_w), data);
	598	space.machine().scheduler().synchronize(FUNC(williams2_deferred_snd_cmd_w), data);
599	599	}
600	600
601	601
r18055	r18056
608	608
609	609	WRITE8_DEVICE_HANDLER( williams_port_select_w )
610	610	{
611		williams_state *state = device->machine().driver_data<williams_state>();
	611	williams_state *state = space.machine().driver_data<williams_state>();
612	612	state->m_port_select = data;
613	613	}
614	614
r18055	r18056
650	650	READ8_DEVICE_HANDLER( williams_49way_port_0_r )
651	651	{
652	652	static const UINT8 translate49[7] = { 0x0, 0x4, 0x6, 0x7, 0xb, 0x9, 0x8 };
653		return (translate49[device->machine().root_device().ioport("49WAYX")->read() >> 4] << 4) | translate49[device->machine().root_device().ioport("49WAYY")->read() >> 4];
	653	return (translate49[space.machine().root_device().ioport("49WAYX")->read() >> 4] << 4) | translate49[space.machine().root_device().ioport("49WAYY")->read() >> 4];
654	654	}
655	655
656	656
657	657	READ8_DEVICE_HANDLER( williams_input_port_49way_0_5_r )
658	658	{
659		williams_state *state = device->machine().driver_data<williams_state>();
	659	williams_state *state = space.machine().driver_data<williams_state>();
660	660	if (state->m_port_select)
661	661	return williams_49way_port_0_r(device, space, 0);
662	662	else
r18055	r18056
927	927
928	928	static WRITE8_DEVICE_HANDLER( lottofun_coin_lock_w )
929	929	{
930		coin_lockout_global_w(device->machine(), data & 1); /* bit 5 of PIC control port A */
	930	coin_lockout_global_w(space.machine(), data & 1); /* bit 5 of PIC control port A */
931	931	}
932	932
933	933
r18055	r18056
941	941	static READ8_DEVICE_HANDLER( tshoot_input_port_0_3_r )
942	942	{
943	943	/* merge in the gun inputs with the standard data */
944		int data = device->machine().root_device().ioport("IN0")->read();
	944	int data = space.machine().root_device().ioport("IN0")->read();
945	945	int gun = (data & 0x3f) ^ ((data & 0x3f) >> 1);
946	946	return (data & 0xc0) | gun;
947	947
r18055	r18056
953	953	static WRITE8_DEVICE_HANDLER( tshoot_maxvol_w )
954	954	{
955	955	/* something to do with the sound volume */
956		logerror("tshoot maxvol = %d (%s)\n", data, device->machine().describe_context());
	956	logerror("tshoot maxvol = %d (%s)\n", data, space.machine().describe_context());
957	957	}
958	958
959	959
r18055	r18056
1000	1000
1001	1001	static WRITE8_DEVICE_HANDLER( joust2_pia_3_cb1_w )
1002	1002	{
1003		joust2_state *state = device->machine().driver_data<joust2_state>();
	1003	joust2_state *state = space.machine().driver_data<joust2_state>();
1004	1004	state->m_joust2_current_sound_data = (state->m_joust2_current_sound_data & ~0x100) | ((data << 8) & 0x100);
1005		state->m_cvsd_sound->write(device->machine().driver_data()->generic_space(), 0, state->m_joust2_current_sound_data);
	1005	state->m_cvsd_sound->write(space.machine().driver_data()->generic_space(), 0, state->m_joust2_current_sound_data);
1006	1006	}
1007	1007
1008	1008
1009	1009	static WRITE8_DEVICE_HANDLER( joust2_snd_cmd_w )
1010	1010	{
1011		joust2_state *state = device->machine().driver_data<joust2_state>();
	1011	joust2_state *state = space.machine().driver_data<joust2_state>();
1012	1012	state->m_joust2_current_sound_data = (state->m_joust2_current_sound_data & ~0xff) | (data & 0xff);
1013		state->m_cvsd_sound->write(device->machine().driver_data()->generic_space(), 0, state->m_joust2_current_sound_data);
1014		device->machine().scheduler().synchronize(FUNC(joust2_deferred_snd_cmd_w), state->m_joust2_current_sound_data);
	1013	state->m_cvsd_sound->write(space.machine().driver_data()->generic_space(), 0, state->m_joust2_current_sound_data);
	1014	space.machine().scheduler().synchronize(FUNC(joust2_deferred_snd_cmd_w), state->m_joust2_current_sound_data);
1015	1015	}

trunk/src/mame/video/system1.c

r18055	r18056
277	277
278	278	WRITE8_DEVICE_HANDLER( system1_videoram_bank_w )
279	279	{
280		system1_state *state = device->machine().driver_data<system1_state>();
	280	system1_state *state = space.machine().driver_data<system1_state>();
281	281	state->m_videoram_bank = data;
282	282	}
283	283

trunk/src/mame/video/taitoic.c

r18055	r18056
1490	1490
1491	1491	if (offset < 0x1000 / 2)
1492	1492	{
1493		device->machine().gfx[tc0080vco->tx_gfx]->mark_dirty(offset / 8);
	1493	space.machine().gfx[tc0080vco->tx_gfx]->mark_dirty(offset / 8);
1494	1494	#if 0
1495	1495	if (!tc0080vco->has_tx)
1496	1496	{
r18055	r18056
1521	1521
1522	1522	else if (offset < 0x11000 / 2)
1523	1523	{
1524		device->machine().gfx[tc0080vco->tx_gfx]->mark_dirty((offset - 0x10000 / 2) / 8);
	1524	space.machine().gfx[tc0080vco->tx_gfx]->mark_dirty((offset - 0x10000 / 2) / 8);
1525	1525	#if 0
1526	1526	if (!tc0080vco->has_tx)
1527	1527	{
r18055	r18056
2246	2246	else if (offset < 0x3000)
2247	2247	tc0100scn->tilemap[2][0]->mark_tile_dirty((offset & 0x0fff));
2248	2248	else if (offset < 0x3800)
2249		device->machine().gfx[tc0100scn->tx_gfx]->mark_dirty((offset - 0x3000) / 8);
	2249	space.machine().gfx[tc0100scn->tx_gfx]->mark_dirty((offset - 0x3000) / 8);
2250	2250	else if (offset >= 0x4000 && offset < 0x6000)
2251	2251	tc0100scn->tilemap[1][0]->mark_tile_dirty((offset & 0x1fff) / 2);
2252	2252	}
r18055	r18056
2257	2257	else if (offset >= 0x4000 && offset < 0x8000)
2258	2258	tc0100scn->tilemap[1][1]->mark_tile_dirty((offset & 0x3fff) / 2);
2259	2259	else if (offset >= 0x8800 && offset < 0x9000)
2260		device->machine().gfx[tc0100scn->tx_gfx]->mark_dirty((offset - 0x8800) / 8);
	2260	space.machine().gfx[tc0100scn->tx_gfx]->mark_dirty((offset - 0x8800) / 8);
2261	2261	else if (offset >= 0x9000)
2262	2262	tc0100scn->tilemap[2][1]->mark_tile_dirty((offset & 0x0fff));
2263	2263	}
r18055	r18056
2319	2319	tc0100scn_dirty_tilemaps(device);
2320	2320
2321	2321	/* reset the pointer to the text characters (and dirty them all) */
2322		device->machine().gfx[tc0100scn->tx_gfx]->set_source((UINT8 *)tc0100scn->char_ram);
	2322	space.machine().gfx[tc0100scn->tx_gfx]->set_source((UINT8 *)tc0100scn->char_ram);
2323	2323	}
2324	2324
2325	2325	break;
r18055	r18056
3126	3126	}
3127	3127	else if (offset <= 0x7fff)
3128	3128	{
3129		device->machine().gfx[tc0480scp->tx_gfx]->mark_dirty((offset - 0x7000) / 16);
	3129	space.machine().gfx[tc0480scp->tx_gfx]->mark_dirty((offset - 0x7000) / 16);
3130	3130	}
3131	3131	}
3132	3132	else
r18055	r18056
3144	3144	}
3145	3145	else if (offset <= 0x7fff)
3146	3146	{
3147		device->machine().gfx[tc0480scp->tx_gfx]->mark_dirty((offset - 0x7000) / 16);
	3147	space.machine().gfx[tc0480scp->tx_gfx]->mark_dirty((offset - 0x7000) / 16);
3148	3148	}
3149	3149	}
3150	3150	}
r18055	r18056
4859	4859
4860	4860	case 1:
4861	4861	tc0110pcr->ram[tc0110pcr->addr] = data & 0xffff;
4862		palette_set_color_rgb(device->machine(), tc0110pcr->addr, pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
	4862	palette_set_color_rgb(space.machine(), tc0110pcr->addr, pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
4863	4863	break;
4864	4864
4865	4865	default:
r18055	r18056
4882	4882
4883	4883	case 1:
4884	4884	tc0110pcr->ram[tc0110pcr->addr] = data & 0xffff;
4885		palette_set_color_rgb(device->machine(), tc0110pcr->addr + (tc0110pcr->pal_offs << 12), pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
	4885	palette_set_color_rgb(space.machine(), tc0110pcr->addr + (tc0110pcr->pal_offs << 12), pal5bit(data >> 0), pal5bit(data >> 5), pal5bit(data >> 10));
4886	4886	break;
4887	4887
4888	4888	default:
r18055	r18056
4907	4907
4908	4908	case 1:
4909	4909	tc0110pcr->ram[tc0110pcr->addr] = data & 0xffff;
4910		palette_set_color_rgb(device->machine(), tc0110pcr->addr, pal5bit(data >> 10), pal5bit(data >> 5), pal5bit(data >> 0));
	4910	palette_set_color_rgb(space.machine(), tc0110pcr->addr, pal5bit(data >> 10), pal5bit(data >> 5), pal5bit(data >> 0));
4911	4911	break;
4912	4912
4913	4913	default:
r18055	r18056
4932	4932
4933	4933	case 1:
4934	4934	tc0110pcr->ram[tc0110pcr->addr] = data & 0xffff;
4935		palette_set_color_rgb(device->machine(), tc0110pcr->addr, pal4bit(data >> 0), pal4bit(data >> 4), pal4bit(data >> 8));
	4935	palette_set_color_rgb(space.machine(), tc0110pcr->addr, pal4bit(data >> 0), pal4bit(data >> 4), pal4bit(data >> 8));
4936	4936	break;
4937	4937
4938	4938	default:

trunk/src/mame/video/leland.c

r18055	r18056
118	118
119	119	WRITE8_DEVICE_HANDLER( leland_gfx_port_w )
120	120	{
121		leland_state *state = device->machine().driver_data<leland_state>();
122		device->machine().primary_screen->update_partial(device->machine().primary_screen->vpos());
	121	leland_state *state = space.machine().driver_data<leland_state>();
	122	space.machine().primary_screen->update_partial(space.machine().primary_screen->vpos());
123	123	state->m_gfxbank = data;
124	124	}
125	125

trunk/src/mame/video/gameplan.c

r18055	r18056
116	116
117	117	static WRITE8_DEVICE_HANDLER( video_data_w )
118	118	{
119		gameplan_state *state = device->machine().driver_data<gameplan_state>();
	119	gameplan_state *state = space.machine().driver_data<gameplan_state>();
120	120
121	121	state->m_video_data = data;
122	122	}
r18055	r18056
124	124
125	125	static WRITE8_DEVICE_HANDLER( gameplan_video_command_w )
126	126	{
127		gameplan_state *state = device->machine().driver_data<gameplan_state>();
	127	gameplan_state *state = space.machine().driver_data<gameplan_state>();
128	128
129	129	state->m_video_command = data & 0x07;
130	130	}
r18055	r18056
132	132
133	133	static WRITE8_DEVICE_HANDLER( leprechn_video_command_w )
134	134	{
135		gameplan_state *state = device->machine().driver_data<gameplan_state>();
	135	gameplan_state *state = space.machine().driver_data<gameplan_state>();
136	136
137	137	state->m_video_command = (data >> 3) & 0x07;
138	138	}

trunk/src/mame/video/qix.c

r18055	r18056
86	86
87	87	WRITE8_DEVICE_HANDLER( qix_flip_screen_w )
88	88	{
89		qix_state *state = device->machine().driver_data<qix_state>();
	89	qix_state *state = space.machine().driver_data<qix_state>();
90	90
91	91	state->m_flip = data;
92	92	}

trunk/src/mame/video/hanaawas.c

r18055	r18056
81	81	WRITE8_DEVICE_HANDLER( hanaawas_portB_w )
82	82	{
83	83	/* bit 7 is flip screen */
84		hanaawas_state *state = device->machine().driver_data<hanaawas_state>();
	84	hanaawas_state *state = space.machine().driver_data<hanaawas_state>();
85	85	if (state->flip_screen() != (~data & 0x80))
86	86	{
87	87	state->flip_screen_set(~data & 0x80);
88		device->machine().tilemap().mark_all_dirty();
	88	space.machine().tilemap().mark_all_dirty();
89	89	}
90	90	}
91	91

trunk/src/mame/video/deco16ic.c

r18055	r18056
571	571	WRITE16_DEVICE_HANDLER( deco16ic_pf_control_w )
572	572	{
573	573	deco16ic_state *deco16ic = get_safe_token(device);
574		device->machine().primary_screen->update_partial(device->machine().primary_screen->vpos());
	574	space.machine().primary_screen->update_partial(space.machine().primary_screen->vpos());
575	575
576	576	COMBINE_DATA(&deco16ic->pf12_control[offset]);
577	577	}

trunk/src/mame/video/decocomn.c

r18055	r18056
46	46	{
47	47	int r,g,b;
48	48
49		driver_device *state = device->machine().driver_data();
	49	driver_device *state = space.machine().driver_data();
50	50	COMBINE_DATA(&state->m_generic_paletteram_16[offset]);
51	51	if (offset&1) offset--;
52	52
r18055	r18056
54	54	g = (state->m_generic_paletteram_16[offset + 1] >> 8) & 0xff;
55	55	r = (state->m_generic_paletteram_16[offset + 1] >> 0) & 0xff;
56	56
57		palette_set_color(device->machine(), offset / 2, MAKE_RGB(r,g,b));
	57	palette_set_color(space.machine(), offset / 2, MAKE_RGB(r,g,b));
58	58	}
59	59
60	60	WRITE16_DEVICE_HANDLER( decocomn_buffered_palette_w )
61	61	{
62	62	decocomn_state *decocomn = get_safe_token(device);
63	63
64		driver_device *state = device->machine().driver_data();
	64	driver_device *state = space.machine().driver_data();
65	65	COMBINE_DATA(&state->m_generic_paletteram_16[offset]);
66	66
67	67	decocomn->dirty_palette[offset / 2] = 1;
r18055	r18056
70	70	WRITE16_DEVICE_HANDLER( decocomn_palette_dma_w )
71	71	{
72	72	decocomn_state *decocomn = get_safe_token(device);
73		driver_device *state = device->machine().driver_data();
74		const int m = device->machine().total_colors();
	73	driver_device *state = space.machine().driver_data();
	74	const int m = space.machine().total_colors();
75	75	int r, g, b, i;
76	76
77	77	for (i = 0; i < m; i++)
r18055	r18056
84	84	g = (state->m_generic_paletteram_16[i * 2 + 1] >> 8) & 0xff;
85	85	r = (state->m_generic_paletteram_16[i * 2 + 1] >> 0) & 0xff;
86	86
87		palette_set_color(device->machine(), i, MAKE_RGB(r,g,b));
	87	palette_set_color(space.machine(), i, MAKE_RGB(r,g,b));
88	88	}
89	89	}
90	90	}

trunk/src/mame/video/phoenix.c

r18055	r18056
426	426
427	427	READ8_DEVICE_HANDLER( survival_protection_r )
428	428	{
429		phoenix_state *state = device->machine().driver_data<phoenix_state>();
	429	phoenix_state *state = space.machine().driver_data<phoenix_state>();
430	430	return state->m_survival_protection_value;
431	431	}
432	432

trunk/src/mame/video/konicdev.c

r18055	r18056
1376	1376	case 6:
1377	1377	/* palette bank change */
1378	1378	if ((k007121->ctrlram[offset] & 0x30) != (data & 0x30))
1379		device->machine().tilemap().mark_all_dirty();
	1379	space.machine().tilemap().mark_all_dirty();
1380	1380	break;
1381	1381	case 7:
1382	1382	k007121->flipscreen = data & 0x08;
r18055	r18056
1702	1702	break;
1703	1703	case 0x01:  /* used for banking in Rock'n'Rage */
1704	1704	if (data != k007342->regs[1])
1705		device->machine().tilemap().mark_all_dirty();
	1705	space.machine().tilemap().mark_all_dirty();
1706	1706	case 0x02:
1707	1707	k007342->scrollx[0] = (k007342->scrollx[0] & 0xff) | ((data & 0x01) << 8);
1708	1708	k007342->scrollx[1] = (k007342->scrollx[1] & 0xff) | ((data & 0x02) << 7);
r18055	r18056
2314	2314	if (k052109->has_extra_video_ram)
2315	2315	code |= color << 8;   /* kludge for X-Men */
2316	2316	else
2317		k052109->callback(device->machine(), 0, bank, &code, &color, &flags, &priority);
	2317	k052109->callback(space.machine(), 0, bank, &code, &color, &flags, &priority);
2318	2318
2319	2319	addr = (code << 5) + (offset & 0x1f);
2320		addr &= device->machine().root_device().memregion(k052109->memory_region)->bytes() - 1;
	2320	addr &= space.machine().root_device().memregion(k052109->memory_region)->bytes() - 1;
2321	2321
2322	2322	//      logerror("%04x: off = %04x sub = %02x (bnk = %x) adr = %06x\n", space.device().safe_pc(), offset, k052109->romsubbank, bank, addr);
2323	2323
2324		return device->machine().root_device().memregion(k052109->memory_region)->base()[addr];
	2324	return space.machine().root_device().memregion(k052109->memory_region)->base()[addr];
2325	2325	}
2326	2326	}
2327	2327
r18055	r18056
3572	3572	READ8_DEVICE_HANDLER( k053244_r )
3573	3573	{
3574	3574	k05324x_state *k053244 = k05324x_get_safe_token(device);
3575		running_machine &machine = device->machine();
	3575	running_machine &machine = space.machine();
3576	3576
3577	3577	if ((k053244->regs[5] & 0x10) && offset >= 0x0c && offset < 0x10)
3578	3578	{
r18055	r18056
3612	3612	//          popmessage("053244 reg 05 = %02x",data);
3613	3613	/* bit 2 = unknown, Parodius uses it */
3614	3614	/* bit 5 = unknown, Rollergames uses it */
3615		//      logerror("%s: write %02x to 053244 address 5\n", device->machine().describe_context(), data);
	3615	//      logerror("%s: write %02x to 053244 address 5\n", space.machine().describe_context(), data);
3616	3616	break;
3617	3617
3618	3618	case 0x06:
r18055	r18056
4474	4474	READ16_DEVICE_HANDLER( k055673_rom_word_r )   // 5bpp
4475	4475	{
4476	4476	k053247_state *k053246 = k053247_get_safe_token(device);
4477		UINT8 *ROM8 = (UINT8 *)device->machine().root_device().memregion(k053246->memory_region)->base();
4478		UINT16 *ROM = (UINT16 *)device->machine().root_device().memregion(k053246->memory_region)->base();
4479		int size4 = (device->machine().root_device().memregion(k053246->memory_region)->bytes() / (1024 * 1024)) / 5;
	4477	UINT8 *ROM8 = (UINT8 *)space.machine().root_device().memregion(k053246->memory_region)->base();
	4478	UINT16 *ROM = (UINT16 *)space.machine().root_device().memregion(k053246->memory_region)->base();
	4479	int size4 = (space.machine().root_device().memregion(k053246->memory_region)->bytes() / (1024 * 1024)) / 5;
4480	4480	int romofs;
4481	4481
4482	4482	size4 *= 4 * 1024 * 1024;   // get offset to 5th bit
r18055	r18056
4513	4513	READ16_DEVICE_HANDLER( k055673_GX6bpp_rom_word_r )
4514	4514	{
4515	4515	k053247_state *k053246 = k053247_get_safe_token(device);
4516		UINT16 *ROM = (UINT16 *)device->machine().root_device().memregion(k053246->memory_region)->base();
	4516	UINT16 *ROM = (UINT16 *)space.machine().root_device().memregion(k053246->memory_region)->base();
4517	4517	int romofs;
4518	4518
4519	4519	romofs = k053246->kx46_regs[6] << 16 | k053246->kx46_regs[7] << 8 | k053246->kx46_regs[4];
r18055	r18056
4553	4553	int addr;
4554	4554
4555	4555	addr = (k053246->kx46_regs[6] << 17) | (k053246->kx46_regs[7] << 9) | (k053246->kx46_regs[4] << 1) | ((offset & 1) ^ 1);
4556		addr &= device->machine().root_device().memregion(k053246->memory_region)->bytes() - 1;
	4556	addr &= space.machine().root_device().memregion(k053246->memory_region)->bytes() - 1;
4557	4557	//      if (VERBOSE)
4558	4558	//          popmessage("%04x: offset %02x addr %06x", space.device().safe_pc(), offset, addr);
4559		return device->machine().root_device().memregion(k053246->memory_region)->base()[addr];
	4559	return space.machine().root_device().memregion(k053246->memory_region)->base()[addr];
4560	4560	}
4561	4561	else
4562	4562	{
r18055	r18056
5438	5438	int addr = offset + (k051316->ctrlram[0x0c] << 11) + (k051316->ctrlram[0x0d] << 19);
5439	5439	if (k051316->bpp <= 4)
5440	5440	addr /= 2;
5441		addr &= device->machine().root_device().memregion(k051316->memory_region)->bytes() - 1;
	5441	addr &= space.machine().root_device().memregion(k051316->memory_region)->bytes() - 1;
5442	5442
5443		//  popmessage("%s: offset %04x addr %04x", device->machine().describe_context(), offset, addr);
	5443	//  popmessage("%s: offset %04x addr %04x", space.machine().describe_context(), offset, addr);
5444	5444
5445		return device->machine().root_device().memregion(k051316->memory_region)->base()[addr];
	5445	return space.machine().root_device().memregion(k051316->memory_region)->base()[addr];
5446	5446	}
5447	5447	else
5448	5448	{
5449		//logerror("%s: read 051316 ROM offset %04x but reg 0x0c bit 0 not clear\n", device->machine().describe_context(), offset);
	5449	//logerror("%s: read 051316 ROM offset %04x but reg 0x0c bit 0 not clear\n", space.machine().describe_context(), offset);
5450	5450	return 0;
5451	5451	}
5452	5452	}
r18055	r18056
5455	5455	{
5456	5456	k051316_state *k051316= k051316_get_safe_token(device);
5457	5457	k051316->ctrlram[offset] = data;
5458		//if (offset >= 0x0c) logerror("%s: write %02x to 051316 reg %x\n", device->machine().describe_context(), data, offset);
	5458	//if (offset >= 0x0c) logerror("%s: write %02x to 051316 reg %x\n", space.machine().describe_context(), data, offset);
5459	5459	}
5460	5460
5461	5461	// a few games (ajax, rollerg, ultraman, etc.) can enable and disable wraparound after start
r18055	r18056
6002	6002	}
6003	6003
6004	6004	if (!k053251->tilemaps_set)
6005		device->machine().tilemap().mark_all_dirty();
	6005	space.machine().tilemap().mark_all_dirty();
6006	6006	}
6007	6007	else if (offset == 10)
6008	6008	{
r18055	r18056
6018	6018	}
6019	6019
6020	6020	if (!k053251->tilemaps_set)
6021		device->machine().tilemap().mark_all_dirty();
	6021	space.machine().tilemap().mark_all_dirty();
6022	6022	}
6023	6023	}
6024	6024	}
r18055	r18056
6888	6888	int addr = 0x2000 * k056832->cur_gfx_banks + 2 * offset;
6889	6889
6890	6890	if (!k056832->rombase)
6891		k056832->rombase = device->machine().root_device().memregion(k056832->memory_region)->base();
	6891	k056832->rombase = space.machine().root_device().memregion(k056832->memory_region)->base();
6892	6892
6893	6893	return k056832->rombase[addr + 1] | (k056832->rombase[addr] << 8);
6894	6894	}
r18055	r18056
6902	6902	int addr;
6903	6903
6904	6904	if (!k056832->rombase)
6905		k056832->rombase = device->machine().root_device().memregion(k056832->memory_region)->base();
	6905	k056832->rombase = space.machine().root_device().memregion(k056832->memory_region)->base();
6906	6906
6907	6907	if (k056832->regsb[2] & 0x8)
6908	6908	{
r18055	r18056
6965	6965	int addr = 0x4000 * k056832->cur_gfx_banks + offset;
6966	6966
6967	6967	if (!k056832->rombase)
6968		k056832->rombase = device->machine().root_device().memregion(k056832->memory_region)->base();
	6968	k056832->rombase = space.machine().root_device().memregion(k056832->memory_region)->base();
6969	6969
6970	6970	return k056832->rombase[addr + 2] | (k056832->rombase[addr] << 8);
6971	6971	}
r18055	r18056
6976	6976	int addr = 0x8000 * k056832->cur_gfx_banks + 2 * offset;
6977	6977
6978	6978	if (!k056832->rombase)
6979		k056832->rombase = device->machine().root_device().memregion(k056832->memory_region)->base();
	6979	k056832->rombase = space.machine().root_device().memregion(k056832->memory_region)->base();
6980	6980
6981	6981	return k056832->rombase[addr + 2] | (k056832->rombase[addr] << 8);
6982	6982	}
r18055	r18056
6987	6987	int addr = 0x2000 * k056832->cur_gfx_banks + 2 * offset;
6988	6988
6989	6989	if (!k056832->rombase)
6990		k056832->rombase = device->machine().root_device().memregion(k056832->memory_region)->base();
	6990	k056832->rombase = space.machine().root_device().memregion(k056832->memory_region)->base();
6991	6991
6992	6992	return k056832->rombase[addr + 1] | (k056832->rombase[addr] << 8);
6993	6993	}
r18055	r18056
9009	9009	{
9010	9010	case 0x0b:      // CG Board ROM read
9011	9011	{
9012		UINT16 *rom = (UINT16*)device->machine().root_device().memregion(k001006->gfx_region)->base();
	9012	UINT16 *rom = (UINT16*)space.machine().root_device().memregion(k001006->gfx_region)->base();
9013	9013	return rom[k001006->addr / 2] << 16;
9014	9014	}
9015	9015	case 0x0d:      // Palette RAM read
r18055	r18056
10380	10380
10381	10381	switch (offset)
10382	10382	{
10383		case 0x54/4:   return device->machine().rand() << 16;
10384		case 0x5c/4:   return device->machine().rand() << 16 | device->machine().rand();
	10383	case 0x54/4:   return space.machine().rand() << 16;
	10384	case 0x5c/4:   return space.machine().rand() << 16 | space.machine().rand();
10385	10385	}
10386	10386
10387	10387	return k001604->reg[offset];
r18055	r18056
10457	10457
10458	10458	COMBINE_DATA(k001604->char_ram + addr);
10459	10459
10460		device->machine().gfx[k001604->gfx_index[0]]->mark_dirty(addr / 32);
10461		device->machine().gfx[k001604->gfx_index[1]]->mark_dirty(addr / 128);
	10460	space.machine().gfx[k001604->gfx_index[0]]->mark_dirty(addr / 32);
	10461	space.machine().gfx[k001604->gfx_index[1]]->mark_dirty(addr / 128);
10462	10462	}
10463	10463
10464	10464	WRITE32_DEVICE_HANDLER( k001604_reg_w )
r18055	r18056
10750	10750	UINT32 addr = offset + (bank * (0x40000/4));
10751	10751
10752	10752	COMBINE_DATA(k037122->char_ram + addr);
10753		device->machine().gfx[k037122->gfx_index]->mark_dirty(addr / 32);
	10753	space.machine().gfx[k037122->gfx_index]->mark_dirty(addr / 32);
10754	10754	}
10755	10755
10756	10756	READ32_DEVICE_HANDLER( k037122_reg_r )

trunk/src/mame/video/vectrex.c

r18055	r18056
323	323
324	324	static WRITE8_DEVICE_HANDLER(v_via_pb_w)
325	325	{
326		vectrex_state *state = device->machine().driver_data<vectrex_state>();
	326	vectrex_state *state = space.machine().driver_data<vectrex_state>();
327	327	if (!(data & 0x80))
328	328	{
329	329	/* RAMP is active */
r18055	r18056
362	362	+(double)(state->m_pen_y - state->m_y_int) * (state->m_pen_y - state->m_y_int);
363	363	d2 = b2 - ab * ab / a2;
364	364	if (d2 < 2e10 && state->m_analog[A_Z] * state->m_blank > 0)
365		state->m_lp_t->adjust(attotime::from_double(ab / a2 / (device->machine().device("maincpu")->unscaled_clock() * INT_PER_CLOCK)));
	365	state->m_lp_t->adjust(attotime::from_double(ab / a2 / (space.machine().device("maincpu")->unscaled_clock() * INT_PER_CLOCK)));
366	366	}
367	367	}
368	368	}
r18055	r18056
370	370	if (!(data & 0x1) && (state->m_via_out[PORTB] & 0x1))
371	371	{
372	372	/* MUX has been enabled */
373		device->machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(update_signal));
	373	space.machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(update_signal));
374	374	}
375	375	}
376	376	else
r18055	r18056
387	387	/* Cartridge bank-switching */
388	388	if (state->m_64k_cart && ((data ^ state->m_via_out[PORTB]) & 0x40))
389	389	{
390		device_t &root_device = device->machine().root_device();
	390	device_t &root_device = space.machine().root_device();
391	391
392	392	root_device.membank("bank1")->set_base(root_device.memregion("maincpu")->base() + ((data & 0x40) ? 0x10000 : 0x0000));
393	393	}
r18055	r18056
395	395	/* Sound */
396	396	if (data & 0x10)
397	397	{
398		device_t *ay8912 = device->machine().device("ay8912");
	398	device_t *ay8912 = space.machine().device("ay8912");
399	399
400	400	if (data & 0x08) /* BC1 (do we select a reg or write it ?) */
401	401	ay8910_address_w(ay8912, space, 0, state->m_via_out[PORTA]);
r18055	r18056
404	404	}
405	405
406	406	if (!(data & 0x1) && (state->m_via_out[PORTB] & 0x1))
407		vectrex_multiplexer (device->machine(), (data >> 1) & 0x3);
	407	vectrex_multiplexer (space.machine(), (data >> 1) & 0x3);
408	408
409	409	state->m_via_out[PORTB] = data;
410		device->machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(update_signal), data & 0x80, &state->m_ramp);
	410	space.machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(update_signal), data & 0x80, &state->m_ramp);
411	411	}
412	412
413	413
414	414	static WRITE8_DEVICE_HANDLER(v_via_pa_w)
415	415	{
416		vectrex_state *state = device->machine().driver_data<vectrex_state>();
	416	vectrex_state *state = space.machine().driver_data<vectrex_state>();
417	417	/* DAC output always goes to Y integrator */
418	418	state->m_via_out[PORTA] = data;
419		device->machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(update_signal), data, &state->m_analog[A_Y]);
	419	space.machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(update_signal), data, &state->m_analog[A_Y]);
420	420
421	421	if (!(state->m_via_out[PORTB] & 0x1))
422		vectrex_multiplexer (device->machine(), (state->m_via_out[PORTB] >> 1) & 0x3);
	422	vectrex_multiplexer (space.machine(), (state->m_via_out[PORTB] >> 1) & 0x3);
423	423	}
424	424
425	425
426	426	static WRITE8_DEVICE_HANDLER(v_via_ca2_w)
427	427	{
428	428	if (data == 0)
429		device->machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(vectrex_zero_integrators));
	429	space.machine().scheduler().timer_set(attotime::from_nsec(ANALOG_DELAY), FUNC(vectrex_zero_integrators));
430	430	}
431	431
432	432
433	433	static WRITE8_DEVICE_HANDLER(v_via_cb2_w)
434	434	{
435		vectrex_state *state = device->machine().driver_data<vectrex_state>();
	435	vectrex_state *state = space.machine().driver_data<vectrex_state>();
436	436	int dx, dy;
437	437
438	438	if (state->m_cb2 != data)
r18055	r18056
451	451	dx = abs(state->m_pen_x - state->m_x_int);
452	452	dy = abs(state->m_pen_y - state->m_y_int);
453	453	if (dx < 500000 && dy < 500000 && data > 0)
454		device->machine().scheduler().timer_set(attotime::zero, FUNC(lightpen_trigger));
	454	space.machine().scheduler().timer_set(attotime::zero, FUNC(lightpen_trigger));
455	455	}
456	456	}
457	457
458		device->machine().scheduler().timer_set(attotime::zero, FUNC(update_signal), data, &state->m_blank);
	458	space.machine().scheduler().timer_set(attotime::zero, FUNC(update_signal), data, &state->m_blank);
459	459	state->m_cb2 = data;
460	460	}
461	461	}

trunk/src/mame/video/xxmissio.c

r18055	r18056
14	14
15	15	WRITE8_DEVICE_HANDLER( xxmissio_scroll_x_w )
16	16	{
17		xxmissio_state *state = device->machine().driver_data<xxmissio_state>();
	17	xxmissio_state *state = space.machine().driver_data<xxmissio_state>();
18	18	state->m_xscroll = data;
19	19	}
20	20	WRITE8_DEVICE_HANDLER( xxmissio_scroll_y_w )
21	21	{
22		xxmissio_state *state = device->machine().driver_data<xxmissio_state>();
	22	xxmissio_state *state = space.machine().driver_data<xxmissio_state>();
23	23	state->m_yscroll = data;
24	24	}
25	25

trunk/src/mame/video/homerun.c

r18055	r18056
37	37
38	38	WRITE8_DEVICE_HANDLER(homerun_banking_w)
39	39	{
40		homerun_state *state = device->machine().driver_data<homerun_state>();
	40	homerun_state *state = space.machine().driver_data<homerun_state>();
41	41
42	42	// games do mid-screen gfx bank switching
43		int vpos = device->machine().primary_screen->vpos();
44		device->machine().primary_screen->update_partial(vpos);
	43	int vpos = space.machine().primary_screen->vpos();
	44	space.machine().primary_screen->update_partial(vpos);
45	45
46	46	// d0-d1: gfx bank
47	47	// d2-d4: ?

trunk/src/mame/video/gp9001.c

r18055	r18056
434	434
435	435	static READ16_DEVICE_HANDLER( gp9001_vdpstatus_r )
436	436	{
437		return ((device->machine().primary_screen->vpos() + 15) % 262) >= 245;
	437	return ((space.machine().primary_screen->vpos() + 15) % 262) >= 245;
438	438	}
439	439
440	440	static WRITE16_DEVICE_HANDLER( gp9001_scroll_reg_select_w )

trunk/src/mame/drivers/ddenlovr.c

r18055	r18056
1524	1524
1525	1525	static WRITE16_DEVICE_HANDLER( quiz365_oki_bank1_w )
1526	1526	{
1527		dynax_state *state = device->machine().driver_data<dynax_state>();
	1527	dynax_state *state = space.machine().driver_data<dynax_state>();
1528	1528
1529	1529	if (ACCESSING_BITS_0_7)
1530	1530	{
r18055	r18056
1536	1536
1537	1537	static WRITE16_DEVICE_HANDLER( quiz365_oki_bank2_w )
1538	1538	{
1539		dynax_state *state = device->machine().driver_data<dynax_state>();
	1539	dynax_state *state = space.machine().driver_data<dynax_state>();
1540	1540
1541	1541	if (ACCESSING_BITS_0_7)
1542	1542	{
r18055	r18056
1561	1561
1562	1562	static WRITE8_DEVICE_HANDLER( ddenlovr_select_w )
1563	1563	{
1564		dynax_state *state = device->machine().driver_data<dynax_state>();
	1564	dynax_state *state = space.machine().driver_data<dynax_state>();
1565	1565	state->m_dsw_sel = data;
1566	1566	}
1567	1567
r18055	r18056
1598	1598
1599	1599	static READ8_DEVICE_HANDLER( quiz365_input_r )
1600	1600	{
1601		dynax_state *state = device->machine().driver_data<dynax_state>();
	1601	dynax_state *state = space.machine().driver_data<dynax_state>();
1602	1602
1603	1603	if (!BIT(state->m_dsw_sel, 0))   return state->ioport("DSW1")->read();
1604	1604	if (!BIT(state->m_dsw_sel, 1))   return state->ioport("DSW2")->read();
1605	1605	if (!BIT(state->m_dsw_sel, 2))   return state->ioport("DSW3")->read();
1606		if (!BIT(state->m_dsw_sel, 3))   return 0xff;//device->machine().rand();
1607		if (!BIT(state->m_dsw_sel, 4))   return 0xff;//device->machine().rand();
	1606	if (!BIT(state->m_dsw_sel, 3))   return 0xff;//space.machine().rand();
	1607	if (!BIT(state->m_dsw_sel, 4))   return 0xff;//space.machine().rand();
1608	1608	return 0xff;
1609	1609	}
1610	1610
r18055	r18056
2812	2812
2813	2813	static READ8_DEVICE_HANDLER( hginga_dsw_r )
2814	2814	{
2815		dynax_state *state = device->machine().driver_data<dynax_state>();
	2815	dynax_state *state = space.machine().driver_data<dynax_state>();
2816	2816
2817	2817	if (!BIT(state->m_dsw_sel, 0))   return state->ioport("DSW4")->read();
2818	2818	if (!BIT(state->m_dsw_sel, 1))   return state->ioport("DSW3")->read();
r18055	r18056
2820	2820	if (!BIT(state->m_dsw_sel, 3))   return state->ioport("DSW1")->read();
2821	2821	if (!BIT(state->m_dsw_sel, 4))   return state->ioport("DSW5")->read();
2822	2822
2823		logerror("%s: warning, unknown bits read, ddenlovr_select = %02x\n", device->machine().describe_context(), state->m_dsw_sel);
	2823	logerror("%s: warning, unknown bits read, ddenlovr_select = %02x\n", space.machine().describe_context(), state->m_dsw_sel);
2824	2824	return 0xff;
2825	2825	}
2826	2826
r18055	r18056
3657	3657
3658	3658	static READ8_DEVICE_HANDLER( seljan2_dsw_r )
3659	3659	{
3660		dynax_state *state = device->machine().driver_data<dynax_state>();
	3660	dynax_state *state = space.machine().driver_data<dynax_state>();
3661	3661
3662	3662	if (!BIT(state->m_dsw_sel, 0))   return state->ioport("DSW1")->read();
3663	3663	if (!BIT(state->m_dsw_sel, 1))   return state->ioport("DSW2")->read();
r18055	r18056
3665	3665	if (!BIT(state->m_dsw_sel, 3))   return state->ioport("DSW4")->read();
3666	3666	if (!BIT(state->m_dsw_sel, 4))   return state->ioport("DSWTOP")->read();
3667	3667
3668		logerror("%s: warning, unknown bits read, ddenlovr_select = %02x\n", device->machine().describe_context(), state->m_dsw_sel);
	3668	logerror("%s: warning, unknown bits read, ddenlovr_select = %02x\n", space.machine().describe_context(), state->m_dsw_sel);
3669	3669	return 0xff;
3670	3670	}
3671	3671

trunk/src/mame/drivers/chinagat.c

r18055	r18056
221	221
222	222	static WRITE8_DEVICE_HANDLER( saiyugoub1_adpcm_control_w )
223	223	{
224		ddragon_state *state = device->machine().driver_data<ddragon_state>();
	224	ddragon_state *state = space.machine().driver_data<ddragon_state>();
225	225
226	226	/* i8748 Port 2 write */
227	227	UINT8 *saiyugoub1_adpcm_rom = state->memregion("adpcm")->base();
r18055	r18056
275	275
276	276	/* Actually, T0 output clk mode is not supported by the i8048 core */
277	277	#if 0
278		ddragon_state *state = device->machine().driver_data<ddragon_state>();
	278	ddragon_state *state = space.machine().driver_data<ddragon_state>();
279	279
280	280	state->m_m5205_clk++;
281	281	if (state->m_m5205_clk == 8)

trunk/src/mame/drivers/othello.c

r18055	r18056
252	252
253	253	static WRITE8_DEVICE_HANDLER( n7751_rom_control_w )
254	254	{
255		othello_state *state = device->machine().driver_data<othello_state>();
	255	othello_state *state = space.machine().driver_data<othello_state>();
256	256
257	257	/* P4 - address lines 0-3 */
258	258	/* P5 - address lines 4-7 */

trunk/src/mame/drivers/chihiro.c

r18055	r18056
1559	1559
1560	1560	static READ8_DEVICE_HANDLER( get_slave_ack )
1561	1561	{
1562		chihiro_state *chst=device->machine().driver_data<chihiro_state>();
	1562	chihiro_state *chst=space.machine().driver_data<chihiro_state>();
1563	1563	if (offset==2) { // IRQ = 2
1564	1564	return pic8259_acknowledge(chst->chihiro_devs.pic8259_2);
1565	1565	}

trunk/src/mame/drivers/r2dtank.c

r18055	r18056
231	231
232	232	static WRITE8_DEVICE_HANDLER( ttl74123_output_changed )
233	233	{
234		r2dtank_state *state = device->machine().driver_data<r2dtank_state>();
235		pia6821_device *pia = device->machine().device<pia6821_device>("pia_main");
	234	r2dtank_state *state = space.machine().driver_data<r2dtank_state>();
	235	pia6821_device *pia = space.machine().device<pia6821_device>("pia_main");
236	236	pia->ca1_w(data);
237	237	state->m_ttl74123_output = data;
238	238	}

trunk/src/mame/drivers/topspeed.c

r18055	r18056
423	423
424	424	static WRITE8_DEVICE_HANDLER( topspeed_tc0140syt_comm_w )
425	425	{
426		device->machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	426	space.machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
427	427	tc0140syt_comm_w(device, space, 0, data);
428	428	}
429	429

trunk/src/mame/drivers/segas16a.c

r18055	r18056
426	426
427	427	WRITE8_DEVICE_HANDLER( segas16a_state::static_n7751_rom_offset_w )
428	428	{
429		segas16a_state *state = device->machine().driver_data<segas16a_state>();
	429	segas16a_state *state = space.machine().driver_data<segas16a_state>();
430	430	state->n7751_rom_offset_w(state->m_maincpu->space(AS_PROGRAM), offset, data);
431	431	}
432	432

trunk/src/mame/drivers/mpu4vid.c

r18055	r18056
425	425
426	426	if (data)
427	427	{
428		acia6850_device *acia_0 = device->machine().device<acia6850_device>("acia6850_0");
429		acia6850_device *acia_1 = device->machine().device<acia6850_device>("acia6850_1");
	428	acia6850_device *acia_0 = space.machine().device<acia6850_device>("acia6850_0");
	429	acia6850_device *acia_1 = space.machine().device<acia6850_device>("acia6850_1");
430	430	acia_0->tx_clock_in();
431	431	acia_0->rx_clock_in();
432	432	acia_1->tx_clock_in();
r18055	r18056
720	720
721	721	static READ8_DEVICE_HANDLER( pia_ic5_porta_track_r )
722	722	{
723		mpu4vid_state *state = device->machine().driver_data<mpu4vid_state>();
	723	mpu4vid_state *state = space.machine().driver_data<mpu4vid_state>();
724	724	/* The SWP trackball interface connects a standard trackball to the AUX1 port on the MPU4
725	725	mainboard. As per usual, they've taken the cheap route here, reading and processing the
726	726	raw quadrature signal from the encoder wheels for a 4 bit interface, rather than use any
r18055	r18056
729	729	We invert the X and Y data at source due to the use of Schmitt triggers in the interface, which
730	730	clean up the pulses and flip the active phase.*/
731	731
732		LOG(("%s: IC5 PIA Read of Port A (AUX1)\n",device->machine().describe_context()));
	732	LOG(("%s: IC5 PIA Read of Port A (AUX1)\n",space.machine().describe_context()));
733	733
734	734
735	735	UINT8 data = state->ioport("AUX1")->read();

trunk/src/mame/drivers/nyny.c

r18055	r18056
264	264
265	265	static WRITE8_DEVICE_HANDLER( ic48_1_74123_output_changed )
266	266	{
267		nyny_state *state = device->machine().driver_data<nyny_state>();
	267	nyny_state *state = space.machine().driver_data<nyny_state>();
268	268	state->m_pia2->ca1_w(data);
269	269	}
270	270

trunk/src/mame/drivers/spiders.c

r18055	r18056
374	374
375	375	static WRITE8_DEVICE_HANDLER( ic60_74123_output_changed)
376	376	{
377		pia6821_device *pia2 = device->machine().device<pia6821_device>("pia2");
	377	pia6821_device *pia2 = space.machine().device<pia6821_device>("pia2");
378	378	pia2->ca1_w(data);
379	379	}
380	380

trunk/src/mame/drivers/ghosteo.c

r18055	r18056
207	207
208	208	static WRITE8_DEVICE_HANDLER( s3c2410_nand_command_w )
209	209	{
210		ghosteo_state *state = device->machine().driver_data<ghosteo_state>();
	210	ghosteo_state *state = space.machine().driver_data<ghosteo_state>();
211	211	struct nand_t &nand = state->m_nand;
212		//  device_t *nand = device->machine().device( "nand");
	212	//  device_t *nand = space.machine().device( "nand");
213	213	#if NAND_LOG
214	214	logerror( "s3c2410_nand_command_w %02X\n", data);
215	215	#endif
r18055	r18056
233	233
234	234	static WRITE8_DEVICE_HANDLER( s3c2410_nand_address_w )
235	235	{
236		ghosteo_state *state = device->machine().driver_data<ghosteo_state>();
	236	ghosteo_state *state = space.machine().driver_data<ghosteo_state>();
237	237	struct nand_t &nand = state->m_nand;
238		//  device_t *nand = device->machine().device( "nand");
	238	//  device_t *nand = space.machine().device( "nand");
239	239	#if NAND_LOG
240	240	logerror( "s3c2410_nand_address_w %02X\n", data);
241	241	#endif
r18055	r18056
269	269
270	270	static READ8_DEVICE_HANDLER( s3c2410_nand_data_r )
271	271	{
272		ghosteo_state *state = device->machine().driver_data<ghosteo_state>();
	272	ghosteo_state *state = space.machine().driver_data<ghosteo_state>();
273	273	struct nand_t &nand = state->m_nand;
274		//  device_t *nand = device->machine().device( "nand");
	274	//  device_t *nand = space.machine().device( "nand");
275	275	UINT8 data = 0;
276	276	switch (nand.mode)
277	277	{
r18055	r18056
282	282	break;
283	283	case NAND_M_READ :
284	284	{
285		UINT8 *flash = (UINT8 *)device->machine().root_device().memregion( "user1")->base();
	285	UINT8 *flash = (UINT8 *)space.machine().root_device().memregion( "user1")->base();
286	286	if (nand.byte_addr < state->m_rom_pagesize)
287	287	{
288	288	data = *(flash + nand.page_addr * state->m_rom_pagesize + nand.byte_addr);
r18055	r18056
318	318
319	319	static WRITE8_DEVICE_HANDLER( s3c2410_nand_data_w )
320	320	{
321		//  device_t *nand = device->machine().device( "nand");
	321	//  device_t *nand = space.machine().device( "nand");
322	322	#if NAND_LOG
323	323	logerror( "s3c2410_nand_data_w %02X\n", data);
324	324	#endif

trunk/src/mame/drivers/trvquest.c

r18055	r18056
50	50
51	51	static WRITE8_DEVICE_HANDLER( trvquest_coin_w )
52	52	{
53		coin_counter_w(device->machine(), 0, ~data & 1);
	53	coin_counter_w(space.machine(), 0, ~data & 1);
54	54	}
55	55
56	56	static WRITE8_DEVICE_HANDLER( trvquest_misc_w )

trunk/src/mame/drivers/powerbal.c

r18055	r18056
36	36	{
37	37	if (ACCESSING_BITS_0_7)
38	38	{
39		coin_counter_w(device->machine(), 0, data & 0x20);
	39	coin_counter_w(space.machine(), 0, data & 0x20);
40	40
41	41	eeprom_device *eeprom = downcast<eeprom_device *>(device);
42	42	eeprom->set_cs_line((data & 8) ? CLEAR_LINE : ASSERT_LINE);
r18055	r18056
70	70	{
71	71	int addr = 0x40000 * ((data & 3) - 1);
72	72
73		if (addr < device->machine().root_device().memregion("oki")->bytes())
	73	if (addr < space.machine().root_device().memregion("oki")->bytes())
74	74	downcast<okim6295_device *>(device)->set_bank_base(addr);
75	75	}
76	76	}

trunk/src/mame/drivers/proconn.c

r18055	r18056
311	311
312	312	static WRITE16_DEVICE_HANDLER( serial_transmit )
313	313	{
314		proconn_state *state = device->machine().driver_data<proconn_state>();
	314	proconn_state *state = space.machine().driver_data<proconn_state>();
315	315
316	316	//Don't like the look of this, should be a clock somewhere
317	317	//  if (offset == 0)

trunk/src/mame/drivers/esripsys.c

r18055	r18056
201	201
202	202	static READ16_DEVICE_HANDLER( fdt_rip_r )
203	203	{
204		esripsys_state *state = device->machine().driver_data<esripsys_state>();
	204	esripsys_state *state = space.machine().driver_data<esripsys_state>();
205	205	offset = (offset & 0x7ff) << 1;
206	206
207	207	if (!state->m_fasel)
r18055	r18056
212	212
213	213	static WRITE16_DEVICE_HANDLER( fdt_rip_w )
214	214	{
215		esripsys_state *state = device->machine().driver_data<esripsys_state>();
	215	esripsys_state *state = space.machine().driver_data<esripsys_state>();
216	216	offset = (offset & 0x7ff) << 1;
217	217
218	218	if (!state->m_fasel)

trunk/src/mame/drivers/dlair.c

r18055	r18056
158	158
159	159	static WRITE16_DEVICE_HANDLER( serial_transmit )
160	160	{
161		dlair_state *state = device->machine().driver_data<dlair_state>();
	161	dlair_state *state = space.machine().driver_data<dlair_state>();
162	162	state->laserdisc_data_w(data);
163	163	}
164	164
165	165
166	166	static READ16_DEVICE_HANDLER( serial_receive )
167	167	{
168		dlair_state *state = device->machine().driver_data<dlair_state>();
	168	dlair_state *state = space.machine().driver_data<dlair_state>();
169	169	/* if we still have data to send, do it now */
170	170	if (offset == 0 && state->laserdisc_data_available_r() == ASSERT_LINE)
171	171	return state->laserdisc_data_r();

trunk/src/mame/drivers/segac2.c

r18055	r18056
165	165	/* handle writes to the UPD7759 */
166	166	static WRITE16_DEVICE_HANDLER( segac2_upd7759_w )
167	167	{
168		segac2_state *state = device->machine().driver_data<segac2_state>();
	168	segac2_state *state = space.machine().driver_data<segac2_state>();
169	169
170	170	/* make sure we have a UPD chip */
171	171	if (!state->m_sound_banks)

trunk/src/mame/drivers/mquake.c

r18055	r18056
35	35	static WRITE8_DEVICE_HANDLER( mquake_cia_0_porta_w )
36	36	{
37	37	/* switch banks as appropriate */
38		device->machine().root_device().membank("bank1")->set_entry(data & 1);
	38	space.machine().root_device().membank("bank1")->set_entry(data & 1);
39	39
40	40	/* swap the write handlers between ROM and bank 1 based on the bit */
41	41	if ((data & 1) == 0)
42	42	/* overlay disabled, map RAM on 0x000000 */
43		device->machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x000000, 0x07ffff, "bank1");
	43	space.machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x000000, 0x07ffff, "bank1");
44	44
45	45	else
46	46	/* overlay enabled, map Amiga system ROM on 0x000000 */
47		device->machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x000000, 0x07ffff);
	47	space.machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x000000, 0x07ffff);
48	48	}
49	49
50	50
r18055	r18056
67	67	static READ8_DEVICE_HANDLER( mquake_cia_0_portb_r )
68	68	{
69	69	/* parallel port */
70		logerror("%s:CIA0_portb_r\n", device->machine().describe_context());
	70	logerror("%s:CIA0_portb_r\n", space.machine().describe_context());
71	71	return 0xff;
72	72	}
73	73
74	74	static WRITE8_DEVICE_HANDLER( mquake_cia_0_portb_w )
75	75	{
76	76	/* parallel port */
77		logerror("%s:CIA0_portb_w(%02x)\n", device->machine().describe_context(), data);
	77	logerror("%s:CIA0_portb_w(%02x)\n", space.machine().describe_context(), data);
78	78	}
79	79
80	80

trunk/src/mame/drivers/m10.c

r18055	r18056
130	130
131	131	static WRITE8_DEVICE_HANDLER( ic8j1_output_changed )
132	132	{
133		m10_state *state = device->machine().driver_data<m10_state>();
134		LOG(("ic8j1: %d %d\n", data, device->machine().primary_screen->vpos()));
	133	m10_state *state = space.machine().driver_data<m10_state>();
	134	LOG(("ic8j1: %d %d\n", data, space.machine().primary_screen->vpos()));
135	135	state->m_maincpu->set_input_line(0, !data ? CLEAR_LINE : ASSERT_LINE);
136	136	}
137	137
138	138	static WRITE8_DEVICE_HANDLER( ic8j2_output_changed )
139	139	{
140		m10_state *state = device->machine().driver_data<m10_state>();
	140	m10_state *state = space.machine().driver_data<m10_state>();
141	141
142	142	/* written from /Q to A with slight delight */
143	143	LOG(("ic8j2: %d\n", data));

trunk/src/mess/audio/wswan.c

r18055	r18056
69	69
70	70	switch( offset ) {
71	71	case 0x80:            /* Audio 1 freq (lo) */
72		wswan_ch_set_freq(device->machine(), &state->audio1, (state->audio1.freq & 0xff00) | data);
	72	wswan_ch_set_freq(space.machine(), &state->audio1, (state->audio1.freq & 0xff00) | data);
73	73	break;
74	74	case 0x81:            /* Audio 1 freq (hi) */
75		wswan_ch_set_freq(device->machine(), &state->audio1, (data << 8 ) | (state->audio1.freq & 0x00ff));
	75	wswan_ch_set_freq(space.machine(), &state->audio1, (data << 8 ) | (state->audio1.freq & 0x00ff));
76	76	break;
77	77	case 0x82:            /* Audio 2 freq (lo) */
78		wswan_ch_set_freq(device->machine(), &state->audio2, (state->audio2.freq & 0xff00) | data);
	78	wswan_ch_set_freq(space.machine(), &state->audio2, (state->audio2.freq & 0xff00) | data);
79	79	break;
80	80	case 0x83:            /* Audio 2 freq (hi) */
81		wswan_ch_set_freq(device->machine(), &state->audio2, (data << 8 ) | (state->audio2.freq & 0x00ff));
	81	wswan_ch_set_freq(space.machine(), &state->audio2, (data << 8 ) | (state->audio2.freq & 0x00ff));
82	82	break;
83	83	case 0x84:            /* Audio 3 freq (lo) */
84		wswan_ch_set_freq(device->machine(), &state->audio3, (state->audio3.freq & 0xff00) | data);
	84	wswan_ch_set_freq(space.machine(), &state->audio3, (state->audio3.freq & 0xff00) | data);
85	85	break;
86	86	case 0x85:            /* Audio 3 freq (hi) */
87		wswan_ch_set_freq(device->machine(), &state->audio3, (data << 8) | (state->audio3.freq & 0x00ff));
	87	wswan_ch_set_freq(space.machine(), &state->audio3, (data << 8) | (state->audio3.freq & 0x00ff));
88	88	break;
89	89	case 0x86:            /* Audio 4 freq (lo) */
90		wswan_ch_set_freq(device->machine(), &state->audio4, (state->audio4.freq & 0xff00) | data);
	90	wswan_ch_set_freq(space.machine(), &state->audio4, (state->audio4.freq & 0xff00) | data);
91	91	break;
92	92	case 0x87:            /* Audio 4 freq (hi) */
93		wswan_ch_set_freq(device->machine(), &state->audio4, (data << 8) | (state->audio4.freq & 0x00ff));
	93	wswan_ch_set_freq(space.machine(), &state->audio4, (data << 8) | (state->audio4.freq & 0x00ff));
94	94	break;
95	95	case 0x88:            /* Audio 1 volume */
96	96	state->audio1.vol_left = ( data & 0xF0 ) >> 4;
r18055	r18056
113	113	state->sweep_step = (INT8)data;
114	114	break;
115	115	case 0x8D:            /* Sweep time */
116		state->sweep_time = device->machine().sample_rate() / ( 3072000 / ( 8192 * (data + 1) ) );
	116	state->sweep_time = space.machine().sample_rate() / ( 3072000 / ( 8192 * (data + 1) ) );
117	117	break;
118	118	case 0x8E:            /* Noise control */
119	119	state->noise_type = data & 0x07;

trunk/src/mess/audio/mea8000.c

r18055	r18056
557	557	case 1:
558	558	/* ready to accept next frame */
559	559	#if 0
560		LOG(( "$%04x %f: mea8000_r ready=%i\n", device->machine().firstcpu->pcbase( ), machine.time().as_double(), mea8000_accept_byte( mea8000 ) ));
	560	LOG(( "$%04x %f: mea8000_r ready=%i\n", space.machine().firstcpu->pcbase( ), machine.time().as_double(), mea8000_accept_byte( mea8000 ) ));
561	561	#endif
562	562	return mea8000_accept_byte(mea8000) << 7;
563	563
564	564	default:
565		logerror( "$%04x mea8000_r invalid read offset %i\n",  device->machine().firstcpu->pcbase( ), offset );
	565	logerror( "$%04x mea8000_r invalid read offset %i\n",  space.machine().firstcpu->pcbase( ), offset );
566	566	}
567	567	return 0;
568	568	}
r18055	r18056
578	578	{
579	579	/* got pitch byte before first frame */
580	580	mea8000->pitch = 2 * data;
581		LOG(( "$%04x %f: mea8000_w pitch %i\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mea8000->pitch ));
	581	LOG(( "$%04x %f: mea8000_w pitch %i\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mea8000->pitch ));
582	582	mea8000->state = MEA8000_WAIT_FIRST;
583	583	mea8000->bufpos = 0;
584	584	}
585	585	else if (mea8000->bufpos == 4)
586	586	{
587	587	/* overflow */
588		LOG(( "$%04x %f: mea8000_w data overflow %02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), data ));
	588	LOG(( "$%04x %f: mea8000_w data overflow %02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), data ));
589	589	}
590	590	else
591	591	{
592	592	/* enqueue frame byte */
593		LOG(( "$%04x %f: mea8000_w data %02X in frame pos %i\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(),
	593	LOG(( "$%04x %f: mea8000_w data %02X in frame pos %i\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(),
594	594	data, mea8000->bufpos ));
595	595	mea8000->buf[mea8000->bufpos] = data;
596	596	mea8000->bufpos++;
r18055	r18056
621	621	mea8000->roe = data & 1;
622	622
623	623	if (stop)
624		mea8000_stop_frame(device->machine(), mea8000);
	624	mea8000_stop_frame(space.machine(), mea8000);
625	625
626	626	LOG(( "$%04x %f: mea8000_w command %02X stop=%i cont=%i roe=%i\n",
627		device->machine().firstcpu->pcbase(), device->machine().time().as_double(), data,
	627	space.machine().firstcpu->pcbase(), space.machine().time().as_double(), data,
628	628	stop, mea8000->cont, mea8000->roe ));
629	629
630	630	mea8000_update_req(device);
r18055	r18056
632	632	}
633	633
634	634	default:
635		logerror( "$%04x mea8000_w invalid write offset %i\n", device->machine().firstcpu->pcbase( ), offset );
	635	logerror( "$%04x mea8000_w invalid write offset %i\n", space.machine().firstcpu->pcbase( ), offset );
636	636	}
637	637	}
638	638

trunk/src/mess/audio/dave.c

r18055	r18056
454	454	count++;
455	455
456	456
457		dave->Period[channel_index] = ((STEP  * device->machine().sample_rate())/125000) * count;
	457	dave->Period[channel_index] = ((STEP  * space.machine().sample_rate())/125000) * count;
458	458
459	459	}
460	460	break;

trunk/src/mess/audio/svision.c

r18055	r18056
82	82	WRITE8_DEVICE_HANDLER( svision_sounddma_w )
83	83	{
84	84	svision_sound_state *state = get_safe_token(device);
85		logerror("%.6f svision snddma write %04x %02x\n", device->machine().time().as_double(),offset+0x18,data);
	85	logerror("%.6f svision snddma write %04x %02x\n", space.machine().time().as_double(),offset+0x18,data);
86	86	state->dma.reg[offset] = data;
87	87	switch (offset)
88	88	{
r18055	r18056
94	94	state->dma.size = (data ? data : 0x100) * 32;
95	95	break;
96	96	case 3:
97		state->dma.step = device->machine().device("maincpu")->unscaled_clock() / (256.0 * device->machine().sample_rate() * (1 + (data & 3)));
	97	state->dma.step = space.machine().device("maincpu")->unscaled_clock() / (256.0 * space.machine().sample_rate() * (1 + (data & 3)));
98	98	state->dma.right = data & 4;
99	99	state->dma.left = data & 8;
100	100	state->dma.ca14to16 = ((data & 0x70) >> 4) << 14;
r18055	r18056
118	118	{
119	119	case 0:
120	120	state->noise.volume=data&0xf;
121		state->noise.step= device->machine().device("maincpu")->unscaled_clock() / (256.0*device->machine().sample_rate()*(1+(data>>4)));
	121	state->noise.step= space.machine().device("maincpu")->unscaled_clock() / (256.0*space.machine().sample_rate()*(1+(data>>4)));
122	122	break;
123	123	case 1:
124	124	state->noise.count = data + 1;

trunk/src/mess/machine/dgn_beta.c

r18055	r18056
565	565
566	566	static READ8_DEVICE_HANDLER(d_pia0_pb_r)
567	567	{
568		dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
	568	dgn_beta_state *state = space.machine().driver_data<dgn_beta_state>();
569	569	int RetVal;
570	570	int Idx;
571	571	int Selected;
r18055	r18056
586	586	{
587	587	for(Idx=0; Idx<NoKeyrows; Idx++)
588	588	{
589		state->m_Keyboard[Idx] = device->machine().root_device().ioport(keynames[Idx])->read();
	589	state->m_Keyboard[Idx] = space.machine().root_device().ioport(keynames[Idx])->read();
590	590
591	591	if(state->m_Keyboard[Idx] != 0x7F)
592	592	state->m_KAny_next = 1;
r18055	r18056
607	607
608	608	static WRITE8_DEVICE_HANDLER(d_pia0_pb_w)
609	609	{
610		dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
	610	dgn_beta_state *state = space.machine().driver_data<dgn_beta_state>();
611	611	int   InClkState;
612	612	//int   OutClkState;
613	613
r18055	r18056
635	635
636	636	static WRITE8_DEVICE_HANDLER(d_pia0_cb2_w)
637	637	{
638		dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
	638	dgn_beta_state *state = space.machine().driver_data<dgn_beta_state>();
639	639	int   RowNo;
640	640	LOG_KEYBOARD(("\nCB2 Write\n"));
641	641
r18055	r18056
650	650	state->m_RowShifter = (state->m_RowShifter<<1) | ((state->m_d_pia0_pb_last & KOutDat)>>4);
651	651	state->m_RowShifter &= 0x3FF;
652	652	LOG_KEYBOARD(("Rowshifter=$%02X Keyrow=$%02X\n",state->m_RowShifter,state->m_Keyrow));
653		if (VERBOSE) debug_console_printf(device->machine(), "rowshifter clocked, value=%3X, RowNo=%d, Keyrow=%2X\n",state->m_RowShifter,RowNo,state->m_Keyrow);
	653	if (VERBOSE) debug_console_printf(space.machine(), "rowshifter clocked, value=%3X, RowNo=%d, Keyrow=%2X\n",state->m_RowShifter,RowNo,state->m_Keyrow);
654	654	}
655	655
656	656	state->m_d_pia0_cb2_last=data;
r18055	r18056
684	684
685	685	static WRITE8_DEVICE_HANDLER(d_pia1_pa_w)
686	686	{
687		dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
	687	dgn_beta_state *state = space.machine().driver_data<dgn_beta_state>();
688	688	int   HALT_DMA;
689		device_t *fdc = device->machine().device(FDC_TAG);
	689	device_t *fdc = space.machine().device(FDC_TAG);
690	690
691	691	/* Only play with halt line if halt bit changed since last write */
692	692	if((data & 0x80) != state->m_d_pia1_pa_last)
r18055	r18056
698	698	HALT_DMA = CLEAR_LINE;
699	699
700	700	LOG_HALT(("DMA_CPU HALT=%d\n", HALT_DMA));
701		device->machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_HALT, HALT_DMA);
	701	space.machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_HALT, HALT_DMA);
702	702
703	703	/* CPU un-halted let it run ! */
704	704	if (HALT_DMA == CLEAR_LINE)
705		device->machine().device(MAINCPU_TAG)->execute().yield();
	705	space.machine().device(MAINCPU_TAG)->execute().yield();
706	706
707	707	state->m_d_pia1_pa_last = data & 0x80;
708	708	}
r18055	r18056
722	722
723	723	static WRITE8_DEVICE_HANDLER(d_pia1_pb_w)
724	724	{
725		dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
	725	dgn_beta_state *state = space.machine().driver_data<dgn_beta_state>();
726	726	int   HALT_CPU;
727	727
728	728	/* Only play with halt line if halt bit changed since last write */
r18055	r18056
735	735	HALT_CPU = ASSERT_LINE;
736	736
737	737	LOG_HALT(("MAIN_CPU HALT=%d\n", HALT_CPU));
738		device->machine().device(MAINCPU_TAG)->execute().set_input_line(INPUT_LINE_HALT, HALT_CPU);
	738	space.machine().device(MAINCPU_TAG)->execute().set_input_line(INPUT_LINE_HALT, HALT_CPU);
739	739
740	740	state->m_d_pia1_pb_last = data & 0x02;
741	741
742	742	/* CPU un-halted let it run ! */
743	743	if (HALT_CPU == CLEAR_LINE)
744		device->machine().device(DMACPU_TAG)->execute().yield();
	744	space.machine().device(DMACPU_TAG)->execute().yield();
745	745	}
746	746	}
747	747
r18055	r18056
771	771
772	772	static WRITE8_DEVICE_HANDLER(d_pia2_pa_w)
773	773	{
774		dgn_beta_state *state = device->machine().driver_data<dgn_beta_state>();
	774	dgn_beta_state *state = space.machine().driver_data<dgn_beta_state>();
775	775	int OldTask;
776	776	int OldEnableMap;
777	777	int NMI;
r18055	r18056
787	787	LOG_INTS(("cpu1 NMI : %d\n", NMI));
788	788	if(!NMI)
789	789	{
790		device->machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	790	space.machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
791	791	logerror("device_yield()\n");
792		device->machine().device(DMACPU_TAG)->execute().yield();   /* Let DMA CPU run */
	792	space.machine().device(DMACPU_TAG)->execute().yield();   /* Let DMA CPU run */
793	793	}
794	794	else
795	795	{
796		device->machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
	796	space.machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
797	797	}
798	798
799	799	state->m_DMA_NMI_LAST = NMI;   /* Save it for next time */
r18055	r18056
821	821	else
822	822	state->m_TaskReg = NoPagingTask;
823	823
824		UpdateBanks(device->machine(), 0, IOPage + 1);
	824	UpdateBanks(space.machine(), 0, IOPage + 1);
825	825	}
826	826	else
827	827	{
r18055	r18056
829	829	if ((state->m_PIATaskReg != OldTask) && (state->m_EnableMapRegs))
830	830	{
831	831	state->m_TaskReg = state->m_PIATaskReg;
832		UpdateBanks(device->machine(), 0, IOPage + 1);
	832	UpdateBanks(space.machine(), 0, IOPage + 1);
833	833	}
834	834	}
835	835	LOG_TASK(("TaskReg=$%02X PIATaskReg=$%02X\n", state->m_TaskReg, state->m_PIATaskReg));
r18055	r18056
843	843	static WRITE8_DEVICE_HANDLER(d_pia2_pb_w)
844	844	{
845	845	/* Update top video address lines */
846		dgnbeta_vid_set_gctrl(device->machine(), data);
	846	dgnbeta_vid_set_gctrl(space.machine(), data);
847	847	}
848	848
849	849	static WRITE_LINE_DEVICE_HANDLER( d_pia2_irq_a )

trunk/src/mess/machine/apple3.c

r18055	r18056
472	472
473	473	static WRITE8_DEVICE_HANDLER(apple3_via_0_out_a)
474	474	{
475		apple3_state *state = device->machine().driver_data<apple3_state>();
476		apple3_via_out(device->machine(), &state->m_via_0_a, data);
	475	apple3_state *state = space.machine().driver_data<apple3_state>();
	476	apple3_via_out(space.machine(), &state->m_via_0_a, data);
477	477	}
478	478
479	479	static WRITE8_DEVICE_HANDLER(apple3_via_0_out_b)
480	480	{
481		apple3_state *state = device->machine().driver_data<apple3_state>();
482		apple3_via_out(device->machine(), &state->m_via_0_b, data);
	481	apple3_state *state = space.machine().driver_data<apple3_state>();
	482	apple3_via_out(space.machine(), &state->m_via_0_b, data);
483	483	}
484	484
485	485	static WRITE8_DEVICE_HANDLER(apple3_via_1_out_a)
486	486	{
487		apple3_state *state = device->machine().driver_data<apple3_state>();
488		apple3_via_out(device->machine(), &state->m_via_1_a, data);
	487	apple3_state *state = space.machine().driver_data<apple3_state>();
	488	apple3_via_out(space.machine(), &state->m_via_1_a, data);
489	489	}
490	490
491	491	static WRITE8_DEVICE_HANDLER(apple3_via_1_out_b)
492	492	{
493		apple3_state *state = device->machine().driver_data<apple3_state>();
494		apple3_via_out(device->machine(), &state->m_via_1_b, data);
	493	apple3_state *state = space.machine().driver_data<apple3_state>();
	494	apple3_via_out(space.machine(), &state->m_via_1_b, data);
495	495	}
496	496
497	497	static void apple2_via_1_irq_func(device_t *device, int state)

trunk/src/mess/machine/isa_fdc.c

r18055	r18056
226	226	int selected_drive;
227	227	int floppy_count;
228	228
229		floppy_count = floppy_get_count(device->machine());
	229	floppy_count = floppy_get_count(space.machine());
230	230
231	231	if (floppy_count > (fdc->digital_output_register & 0x03))
232	232	floppy_drive_set_ready_state(get_floppy_subdevice(device, fdc->digital_output_register & 0x03), 1, 0);
r18055	r18056
359	359	data = upd765_data_r(fdc->m_upd765, space, offset);
360	360	break;
361	361	case 6: /* FDC reserved */
362		hdd = device->machine().device(":board3:ide:ide");
	362	hdd = space.machine().device(":board3:ide:ide");
363	363	if (hdd)
364	364	data = ide_controller16_r(hdd, space, 0x3f6/2, 0x00ff);
365	365	break;
r18055	r18056
371	371	}
372	372
373	373	if (LOG_FDC)
374		logerror("pc_fdc_r(): pc=0x%08x offset=%d result=0x%02X\n", (unsigned) device->machine().firstcpu->pc(), offset, data);
	374	logerror("pc_fdc_r(): pc=0x%08x offset=%d result=0x%02X\n", (unsigned) space.machine().firstcpu->pc(), offset, data);
375	375	return data;
376	376	}
377	377
r18055	r18056
382	382	isa8_fdc_device   *fdc  = downcast<isa8_fdc_device *>(device);
383	383
384	384	if (LOG_FDC)
385		logerror("pc_fdc_w(): pc=0x%08x offset=%d data=0x%02X\n", (unsigned) device->machine().firstcpu->pc(), offset, data);
386		pc_fdc_check_data_rate(fdc,device->machine());  // check every time a command may start
	385	logerror("pc_fdc_w(): pc=0x%08x offset=%d data=0x%02X\n", (unsigned) space.machine().firstcpu->pc(), offset, data);
	386	pc_fdc_check_data_rate(fdc,space.machine());  // check every time a command may start
387	387	device_t *hdd = NULL;
388	388
389	389	switch(offset)
r18055	r18056
405	405	break;
406	406	case 6:
407	407	/* FDC reserved */
408		hdd = device->machine().device(":board3:ide:ide");
	408	hdd = space.machine().device(":board3:ide:ide");
409	409	if (hdd)
410	410	ide_controller16_w(hdd, space, 0x3f6/2, data, 0x00ff);
411	411	break;

trunk/src/mess/machine/cbmb.c

r18055	r18056
59	59	*/
60	60	READ8_DEVICE_HANDLER( cbmb_tpi0_port_a_r )
61	61	{
62		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	62	cbmb_state *state = space.machine().driver_data<cbmb_state>();
63	63	UINT8 data = 0;
64	64
65	65	if (state->m_ieee->nrfd_r())
r18055	r18056
85	85
86	86	WRITE8_DEVICE_HANDLER( cbmb_tpi0_port_a_w )
87	87	{
88		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	88	cbmb_state *state = space.machine().driver_data<cbmb_state>();
89	89
90	90	state->m_ieee->nrfd_w(BIT(data, 7));
91	91	state->m_ieee->ndac_w(BIT(data, 6));
r18055	r18056
97	97
98	98	READ8_DEVICE_HANDLER( cbmb_tpi0_port_b_r )
99	99	{
100		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	100	cbmb_state *state = space.machine().driver_data<cbmb_state>();
101	101	UINT8 data = 0;
102	102
103	103	if (state->m_ieee->srq_r())
r18055	r18056
111	111
112	112	WRITE8_DEVICE_HANDLER( cbmb_tpi0_port_b_w )
113	113	{
114		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	114	cbmb_state *state = space.machine().driver_data<cbmb_state>();
115	115
116	116	state->m_ieee->srq_w(BIT(data, 1));
117	117	state->m_ieee->ifc_w(BIT(data, 0));
r18055	r18056
131	131	port a7..a0 b7..b0 keyboard input */
132	132	WRITE8_DEVICE_HANDLER( cbmb_keyboard_line_select_a )
133	133	{
134		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	134	cbmb_state *state = space.machine().driver_data<cbmb_state>();
135	135	state->m_keyline_a = data;
136	136	}
137	137
138	138	WRITE8_DEVICE_HANDLER( cbmb_keyboard_line_select_b )
139	139	{
140		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	140	cbmb_state *state = space.machine().driver_data<cbmb_state>();
141	141	state->m_keyline_b = data;
142	142	}
143	143
144	144	WRITE8_DEVICE_HANDLER( cbmb_keyboard_line_select_c )
145	145	{
146		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	146	cbmb_state *state = space.machine().driver_data<cbmb_state>();
147	147	state->m_keyline_c = data;
148	148	}
149	149
150	150	READ8_DEVICE_HANDLER( cbmb_keyboard_line_a )
151	151	{
152		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	152	cbmb_state *state = space.machine().driver_data<cbmb_state>();
153	153	int data = 0;
154	154	if (!(state->m_keyline_c & 0x01))
155		data |= device->machine().root_device().ioport("ROW0")->read();
	155	data |= space.machine().root_device().ioport("ROW0")->read();
156	156
157	157	if (!(state->m_keyline_c & 0x02))
158		data |= device->machine().root_device().ioport("ROW2")->read();
	158	data |= space.machine().root_device().ioport("ROW2")->read();
159	159
160	160	if (!(state->m_keyline_c & 0x04))
161		data |= device->machine().root_device().ioport("ROW4")->read();
	161	data |= space.machine().root_device().ioport("ROW4")->read();
162	162
163	163	if (!(state->m_keyline_c & 0x08))
164		data |= device->machine().root_device().ioport("ROW6")->read();
	164	data |= space.machine().root_device().ioport("ROW6")->read();
165	165
166	166	if (!(state->m_keyline_c & 0x10))
167		data |= device->machine().root_device().ioport("ROW8")->read();
	167	data |= space.machine().root_device().ioport("ROW8")->read();
168	168
169	169	if (!(state->m_keyline_c & 0x20))
170	170	data |= state->ioport("ROW10")->read();
r18055	r18056
174	174
175	175	READ8_DEVICE_HANDLER( cbmb_keyboard_line_b )
176	176	{
177		cbmb_state *state = device->machine().driver_data<cbmb_state>();
	177	cbmb_state *state = space.machine().driver_data<cbmb_state>();
178	178	int data = 0;
179	179	if (!(state->m_keyline_c & 0x01))
180		data |= device->machine().root_device().ioport("ROW1")->read();
	180	data |= space.machine().root_device().ioport("ROW1")->read();
181	181
182	182	if (!(state->m_keyline_c & 0x02))
183		data |= device->machine().root_device().ioport("ROW3")->read();
	183	data |= space.machine().root_device().ioport("ROW3")->read();
184	184
185	185	if (!(state->m_keyline_c & 0x04))
186		data |= device->machine().root_device().ioport("ROW5")->read();
	186	data |= space.machine().root_device().ioport("ROW5")->read();
187	187
188	188	if (!(state->m_keyline_c & 0x08))
189		data |= device->machine().root_device().ioport("ROW7")->read();
	189	data |= space.machine().root_device().ioport("ROW7")->read();
190	190
191	191	if (!(state->m_keyline_c & 0x10))
192		data |= device->machine().root_device().ioport("ROW9")->read() | ((device->machine().root_device().ioport("SPECIAL")->read() & 0x04) ? 1 : 0 );
	192	data |= space.machine().root_device().ioport("ROW9")->read() | ((space.machine().root_device().ioport("SPECIAL")->read() & 0x04) ? 1 : 0 );
193	193
194	194	if (!(state->m_keyline_c & 0x20))
195	195	data |= state->ioport("ROW11")->read();
r18055	r18056
200	200	READ8_DEVICE_HANDLER( cbmb_keyboard_line_c )
201	201	{
202	202	int data = 0;
203		cbmb_state *state = device->machine().driver_data<cbmb_state>();
204		if ((device->machine().root_device().ioport("ROW0")->read() & ~state->m_keyline_a) ||
205		(device->machine().root_device().ioport("ROW1")->read() & ~state->m_keyline_b))
	203	cbmb_state *state = space.machine().driver_data<cbmb_state>();
	204	if ((space.machine().root_device().ioport("ROW0")->read() & ~state->m_keyline_a) ||
	205	(space.machine().root_device().ioport("ROW1")->read() & ~state->m_keyline_b))
206	206	data |= 0x01;
207	207
208		if ((device->machine().root_device().ioport("ROW2")->read() & ~state->m_keyline_a) ||
209		(device->machine().root_device().ioport("ROW3")->read() & ~state->m_keyline_b))
	208	if ((space.machine().root_device().ioport("ROW2")->read() & ~state->m_keyline_a) ||
	209	(space.machine().root_device().ioport("ROW3")->read() & ~state->m_keyline_b))
210	210	data |= 0x02;
211	211
212		if ((device->machine().root_device().ioport("ROW4")->read() & ~state->m_keyline_a) ||
213		(device->machine().root_device().ioport("ROW5")->read() & ~state->m_keyline_b))
	212	if ((space.machine().root_device().ioport("ROW4")->read() & ~state->m_keyline_a) ||
	213	(space.machine().root_device().ioport("ROW5")->read() & ~state->m_keyline_b))
214	214	data |= 0x04;
215	215
216		if ((device->machine().root_device().ioport("ROW6")->read() & ~state->m_keyline_a) ||
217		(device->machine().root_device().ioport("ROW7")->read() & ~state->m_keyline_b))
	216	if ((space.machine().root_device().ioport("ROW6")->read() & ~state->m_keyline_a) ||
	217	(space.machine().root_device().ioport("ROW7")->read() & ~state->m_keyline_b))
218	218	data |= 0x08;
219	219
220		if ((device->machine().root_device().ioport("ROW8")->read() & ~state->m_keyline_a) ||
221		((device->machine().root_device().ioport("ROW9")->read() | ((device->machine().root_device().ioport("SPECIAL")->read() & 0x04) ? 1 : 0)) & ~state->m_keyline_b))
	220	if ((space.machine().root_device().ioport("ROW8")->read() & ~state->m_keyline_a) ||
	221	((space.machine().root_device().ioport("ROW9")->read() | ((space.machine().root_device().ioport("SPECIAL")->read() & 0x04) ? 1 : 0)) & ~state->m_keyline_b))
222	222	data |= 0x10;
223	223
224		if ((device->machine().root_device().ioport("ROW10")->read() & ~state->m_keyline_a) ||
	224	if ((space.machine().root_device().ioport("ROW10")->read() & ~state->m_keyline_a) ||
225	225	(state->ioport("ROW11")->read() & ~state->m_keyline_b))
226	226	data |= 0x20;
227	227

trunk/src/mess/machine/pokemini.c

r18055	r18056
391	391
392	392	WRITE8_DEVICE_HANDLER( pokemini_hwreg_w )
393	393	{
394		pokemini_state *state = device->machine().driver_data<pokemini_state>();
	394	pokemini_state *state = space.machine().driver_data<pokemini_state>();
395	395	static const int timer_to_cycles_fast[8] = { 2, 8, 32, 64, 128, 256, 1024, 4096 };
396	396	static const int timer_to_cycles_slow[8] = { 128, 256, 512, 1024, 2048, 4096, 8192, 16384 };
397	397
r18055	r18056
409	409	case 0x02:   /* CPU related?
410	410	Bit 0-7 R/W Unknown
411	411	*/
412		logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", device->machine().firstcpu->pc( ), offset, data );
	412	logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", space.machine().firstcpu->pc( ), offset, data );
413	413	break;
414	414	case 0x08:   /* Seconds-timer control
415	415	Bit 0   R/W Timer enable
r18055	r18056
441	441	Bit 5   R   Battery status: 0 - battery OK, 1 - battery low
442	442	Bit 6-7     Unused
443	443	*/
444		logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", device->machine().firstcpu->pc( ), offset, data );
	444	logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", space.machine().firstcpu->pc( ), offset, data );
445	445	break;
446	446	case 0x18:   /* Timer 1 pre-scale + enable
447	447	Bit 0-2 R/W low timer 1 prescaler select
r18055	r18056
463	463	int index = data & 0x07;
464	464	int cycles = ( state->m_pm_reg[0x19] & 0x01 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
465	465
466		state->m_timers.timer1->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	466	state->m_timers.timer1->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
467	467	}
468	468
469	469	/* Check for prescaler change for the high counter */
r18055	r18056
472	472	int index = ( data >> 4 ) & 0x07;
473	473	int cycles = ( state->m_pm_reg[0x19] & 0x02 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
474	474
475		state->m_timers.timer1_hi->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	475	state->m_timers.timer1_hi->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
476	476	}
477	477
478	478	/* Check if timer1 low should be enabled */
r18055	r18056
513	513	int index = state->m_pm_reg[0x18] & 0x07;
514	514	int cycles = ( data & 0x01 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
515	515
516		state->m_timers.timer1->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	516	state->m_timers.timer1->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
517	517	}
518	518
519	519	/* Check for prescaler change for the low counter */
r18055	r18056
522	522	int index = ( state->m_pm_reg[0x18] >> 4 ) & 0x07;
523	523	int cycles = ( data & 0x02 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
524	524
525		state->m_timers.timer1_hi->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	525	state->m_timers.timer1_hi->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
526	526	}
527	527
528	528	{
r18055	r18056
592	592	int index = data & 0x07;
593	593	int cycles = ( state->m_pm_reg[0x1B] & 0x01 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
594	594
595		state->m_timers.timer2->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	595	state->m_timers.timer2->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
596	596	}
597	597
598	598	/* Check for prescaler change for the high counter */
r18055	r18056
601	601	int index = ( data >> 4 ) & 0x07;
602	602	int cycles = ( state->m_pm_reg[0x1B] & 0x02 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
603	603
604		state->m_timers.timer2_hi->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	604	state->m_timers.timer2_hi->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
605	605	}
606	606
607	607	/* Check if timer2 low should be enabled */
r18055	r18056
638	638	int index = state->m_pm_reg[0x1A] & 0x07;
639	639	int cycles = ( data & 0x01 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
640	640
641		state->m_timers.timer2->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	641	state->m_timers.timer2->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
642	642
643	643	if ( ( state->m_pm_reg[0x1A] & 0x08 ) && ( state->m_pm_reg[0x38] & 0x04 ) &&
644	644	( ( ( state->m_pm_reg[0x19] & 0x10 ) && ( data & 0x01 ) ) ||
r18055	r18056
658	658	int index = ( state->m_pm_reg[0x1A] >> 4 ) & 0x07;
659	659	int cycles = ( data & 0x02 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
660	660
661		state->m_timers.timer2_hi->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	661	state->m_timers.timer2_hi->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
662	662
663	663	if ( ( state->m_pm_reg[0x1A] & 0x80 ) && ( state->m_pm_reg[0x39] & 0x04 ) && ! ( state->m_pm_reg[0x38] & 0x80 ) &&
664	664	( ( ( state->m_pm_reg[0x19] & 0x10 ) && ( data & 0x02 ) ) ||
r18055	r18056
692	692	int index = data & 0x07;
693	693	int cycles = ( state->m_pm_reg[0x1D] & 0x01 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
694	694
695		state->m_timers.timer3->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	695	state->m_timers.timer3->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
696	696	}
697	697
698	698	/* Check for prescaler change for the high counter */
r18055	r18056
701	701	int index = ( data >> 4 ) & 0x07;
702	702	int cycles = ( state->m_pm_reg[0x1D] & 0x02 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
703	703
704		state->m_timers.timer3_hi->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	704	state->m_timers.timer3_hi->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
705	705	}
706	706
707	707	/* Check if timer2 low should be enabled */
r18055	r18056
738	738	int index = state->m_pm_reg[0x1C] & 0x07;
739	739	int cycles = ( data & 0x01 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
740	740
741		state->m_timers.timer3->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	741	state->m_timers.timer3->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
742	742
743	743	if ( ( state->m_pm_reg[0x1C] & 0x08 ) && ( state->m_pm_reg[0x48] & 0x04 ) &&
744	744	( ( ( state->m_pm_reg[0x19] & 0x10 ) && ( data & 0x01 ) ) ||
r18055	r18056
758	758	int index = ( state->m_pm_reg[0x1C] >> 4 ) & 0x07;
759	759	int cycles = ( data & 0x02 ) ? timer_to_cycles_slow[index] : timer_to_cycles_fast[index];
760	760
761		state->m_timers.timer3_hi->adjust(attotime::zero, 0, device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
	761	state->m_timers.timer3_hi->adjust(attotime::zero, 0, space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(cycles));
762	762
763	763	if ( ( state->m_pm_reg[0x1C] & 0x80 ) && ( state->m_pm_reg[0x49] & 0x04 ) && ! ( state->m_pm_reg[0x48] & 0x80 ) &&
764	764	( ( ( state->m_pm_reg[0x19] & 0x10 ) && ( data & 0x02 ) ) ||
r18055	r18056
779	779	Bit 6-7 R/W VDraw/VBlank trigger Interrupt #1-#2
780	780	*/
781	781	state->m_pm_reg[0x20] = data;
782		pokemini_check_irqs(device->machine());
	782	pokemini_check_irqs(space.machine());
783	783	break;
784	784	case 0x21:   /* Event #15-#22 priority
785	785	Bit 0-1 R/W Unknown
r18055	r18056
787	787	Bit 4-7 R/W Unknown
788	788	*/
789	789	state->m_pm_reg[0x21] = data;
790		pokemini_check_irqs(device->machine());
	790	pokemini_check_irqs(space.machine());
791	791	break;
792	792	case 0x22:   /* Event #9-#14 priority
793	793	Bit 0-1 R/W All #9 - #14 events - Interrupt #9-#14
794	794	Bit 2-7     Unused
795	795	*/
796	796	state->m_pm_reg[0x22] = data;
797		pokemini_check_irqs(device->machine());
	797	pokemini_check_irqs(space.machine());
798	798	break;
799	799	case 0x23:   /* Event #1-#8 enable
800	800	Bit 0   R/W Timer 3 overflow (mirror) - Enable Interrupt #8
r18055	r18056
807	807	Bit 7   R/W V-Blank trigger - Enable Interrupt #1
808	808	*/
809	809	state->m_pm_reg[0x23] = data;
810		pokemini_check_irqs(device->machine());
	810	pokemini_check_irqs(space.machine());
811	811	break;
812	812	case 0x24:   /* Event #9-#12 enable
813	813	Bit 0-5 R/W Unknown
814	814	Bit 6-7     Unused
815	815	*/
816	816	state->m_pm_reg[0x24] = data;
817		pokemini_check_irqs(device->machine());
	817	pokemini_check_irqs(space.machine());
818	818	break;
819	819	case 0x25:   /* Event #15-#22 enable
820	820	Bit 0   R/W Press key "A" event - Enable interrupt #22
r18055	r18056
827	827	Bit 7   R/W Press power button event - Enable interrupt #15
828	828	*/
829	829	state->m_pm_reg[0x25] = data;
830		pokemini_check_irqs(device->machine());
	830	pokemini_check_irqs(space.machine());
831	831	break;
832	832	case 0x26:   /* Event #13-#14 enable
833	833	Bit 0-2 R/W Unknown
r18055	r18056
837	837	Bit 7   R/W IR receiver - low to high trigger - Enable interrupt #13
838	838	*/
839	839	state->m_pm_reg[0x26] = data;
840		pokemini_check_irqs(device->machine());
	840	pokemini_check_irqs(space.machine());
841	841	break;
842	842	case 0x27:   /* Interrupt active flag #1-#8
843	843	Bit 0       Timer 3 overflow (mirror) / Clear interrupt #8
r18055	r18056
850	850	Bit 7       VBlank trigger / Clear interrupt #1
851	851	*/
852	852	state->m_pm_reg[0x27] &= ~data;
853		pokemini_check_irqs(device->machine());
	853	pokemini_check_irqs(space.machine());
854	854	return;
855	855	case 0x28:   /* Interrupt active flag #9-#12
856	856	Bit 0-1     Unknown
r18055	r18056
861	861	Bit 6-7     Unknown
862	862	*/
863	863	state->m_pm_reg[0x28] &= ~data;
864		pokemini_check_irqs(device->machine());
	864	pokemini_check_irqs(space.machine());
865	865	return;
866	866	case 0x29:   /* Interrupt active flag #15-#22
867	867	Bit 0       Press key "A" event / Clear interrupt #22
r18055	r18056
874	874	Bit 7       Press power button event / Clear interrupt #15
875	875	*/
876	876	state->m_pm_reg[0x29] &= ~data;
877		pokemini_check_irqs(device->machine());
	877	pokemini_check_irqs(space.machine());
878	878	return;
879	879	case 0x2A:   /* Interrupt active flag #13-#14
880	880	Bit 0-5     Unknown
r18055	r18056
882	882	Bit 7       Unknown / Clear interrupt #13
883	883	*/
884	884	state->m_pm_reg[0x2A] &= ~data;
885		pokemini_check_irqs(device->machine());
	885	pokemini_check_irqs(space.machine());
886	886	return;
887	887	case 0x30:   /* Timer 1 control 1
888	888	Bit 0   R/W Unknown
r18055	r18056
956	956	*/
957	957	case 0x35:   /* Timer 1 sound-pivot (high, unused)
958	958	*/
959		logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", device->machine().firstcpu->pc( ), offset, data );
	959	logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", space.machine().firstcpu->pc( ), offset, data );
960	960	break;
961	961	case 0x36:   /* Timer 1 counter (low), read only
962	962	*/
r18055	r18056
1035	1035	*/
1036	1036	case 0x3D:   /* Timer 2 sound-pivot (high, unused)
1037	1037	*/
1038		logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", device->machine().firstcpu->pc( ), offset, data );
	1038	logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", space.machine().firstcpu->pc( ), offset, data );
1039	1039	break;
1040	1040	case 0x3E:   /* Timer 2 counter (low), read only
1041	1041	Bit 0-7 R/W Timer 2 counter value bit 0-7
r18055	r18056
1095	1095	state->m_timers.timer3_hi->enable( 0 );
1096	1096	}
1097	1097	state->m_pm_reg[0x48] = data;
1098		pokemini_update_sound(device->machine());
	1098	pokemini_update_sound(space.machine());
1099	1099	break;
1100	1100	case 0x49:   /* Timer 3 control 2
1101	1101	Bit 0   R/W Unknown
r18055	r18056
1121	1121	state->m_timers.timer3_hi->enable( 0 );
1122	1122	}
1123	1123	state->m_pm_reg[0x49] = data;
1124		pokemini_update_sound(device->machine());
	1124	pokemini_update_sound(space.machine());
1125	1125	break;
1126	1126	case 0x4A:   /* Timer 3 preset value (low)
1127	1127	Bit 0-7 R/W Timer 3 preset value bit 0-7
1128	1128	*/
1129	1129	state->m_pm_reg[0x4A] = data;
1130		pokemini_update_sound(device->machine());
	1130	pokemini_update_sound(space.machine());
1131	1131	break;
1132	1132	case 0x4B:   /* Timer 3 preset value (high)
1133	1133	Bit 0-7 R/W Timer 3 preset value bit 8-15
1134	1134	*/
1135	1135	state->m_pm_reg[0x4B] = data;
1136		pokemini_update_sound(device->machine());
	1136	pokemini_update_sound(space.machine());
1137	1137	break;
1138	1138	case 0x4C:   /* Timer 3 sound-pivot (low)
1139	1139	Bit 0-7 R/W Timer 3 sound-pivot value bit 0-7
1140	1140	*/
1141	1141	state->m_pm_reg[0x4C] = data;
1142		pokemini_update_sound(device->machine());
	1142	pokemini_update_sound(space.machine());
1143	1143	break;
1144	1144	case 0x4D:   /* Timer 3 sound-pivot (high)
1145	1145	Bit 0-7 R/W Timer 3 sound-pivot value bit 8-15
r18055	r18056
1150	1150	Pulse-Width of 100% = Same as preset-value
1151	1151	*/
1152	1152	state->m_pm_reg[0x4D] = data;
1153		pokemini_update_sound(device->machine());
	1153	pokemini_update_sound(space.machine());
1154	1154	break;
1155	1155	case 0x4E:   /* Timer 3 counter (low), read only
1156	1156	Bit 0-7 R/W Timer 3 counter value bit 0-7
r18055	r18056
1200	1200	break;
1201	1201	case 0x70:   /* Sound related */
1202	1202	state->m_pm_reg[0x70] = data;
1203		pokemini_update_sound(device->machine());
	1203	pokemini_update_sound(space.machine());
1204	1204	break;
1205	1205	case 0x71:   /* Sound volume
1206	1206	Bit 0-1 R/W Sound volume
r18055	r18056
1212	1212	Bit 3-7     Unused
1213	1213	*/
1214	1214	state->m_pm_reg[0x71] = data;
1215		pokemini_update_sound(device->machine());
	1215	pokemini_update_sound(space.machine());
1216	1216	break;
1217	1217	case 0x80:   /* LCD control
1218	1218	Bit 0   R/W Invert colors; 0 - normal, 1 - inverted
r18055	r18056
1300	1300	Map size 2: 0x00 to 0x60
1301	1301	Bit 7       Unused
1302	1302	*/
1303		logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", device->machine().firstcpu->pc( ), offset, data );
	1303	logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", space.machine().firstcpu->pc( ), offset, data );
1304	1304	break;
1305	1305	case 0x87:   /* Sprite tile data memory offset (low)
1306	1306	Bit 0-5     Always "0"
r18055	r18056
1341	1341	//      lcd_data_w( data );
1342	1342	break;
1343	1343	default:
1344		logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", device->machine().firstcpu->pc( ), offset, data );
	1344	logerror( "%0X: Write to unknown hardware address: %02X, %02X\n", space.machine().firstcpu->pc( ), offset, data );
1345	1345	break;
1346	1346	}
1347	1347	state->m_pm_reg[offset] = data;
r18055	r18056
1349	1349
1350	1350	READ8_DEVICE_HANDLER( pokemini_hwreg_r )
1351	1351	{
1352		pokemini_state *state = device->machine().driver_data<pokemini_state>();
	1352	pokemini_state *state = space.machine().driver_data<pokemini_state>();
1353	1353	UINT8 data = state->m_pm_reg[offset];
1354	1354
1355	1355	switch( offset )

trunk/src/mess/machine/mos6530.c

r18055	r18056
177	177	if (offset & 0x04)
178	178	{
179	179	static const UINT8 timershift[4] = { 0, 3, 6, 10 };
180		attotime curtime = device->machine().time();
	180	attotime curtime = space.machine().time();
181	181	INT64 target;
182	182
183	183	/* A0-A1 contain the timer divisor */
r18055	r18056
225	225	if (!port->out_port_func.isnull())
226	226	port->out_port_func(0, data);
227	227	else
228		logerror("6530MIOT chip %s: Port %c is being written to but has no handler.  PC: %08X - %02X\n", device->tag(), 'A' + (offset & 1), device->machine().firstcpu->pc(), data);
	228	logerror("6530MIOT chip %s: Port %c is being written to but has no handler.  PC: %08X - %02X\n", device->tag(), 'A' + (offset & 1), space.machine().firstcpu->pc(), data);
229	229	}
230	230	}
231	231	}
r18055	r18056
287	287	port->in = port->in_port_func(0);
288	288	}
289	289	else
290		logerror("6530MIOT chip %s: Port %c is being read but has no handler.  PC: %08X\n", device->tag(), 'A' + (offset & 1), device->machine().firstcpu->pc());
	290	logerror("6530MIOT chip %s: Port %c is being read but has no handler.  PC: %08X\n", device->tag(), 'A' + (offset & 1), space.machine().firstcpu->pc());
291	291
292	292	/* apply the DDR to the result */
293	293	val = (out & port->ddr) | (port->in & ~port->ddr);

trunk/src/mess/machine/mc6854.c

r18055	r18056
808	808	case 0: /* status register 1 */
809	809	mc6854_update_sr1( mc6854 );
810	810	LOG(( "%f $%04x mc6854_r: get SR1=$%02X (rda=%i,s2rq=%i,fd=%i,cts=%i,tu=%i,tdra=%i,irq=%i)\n",
811		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6854->sr1,
	811	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6854->sr1,
812	812	( mc6854->sr1 & RDA) ? 1 : 0, ( mc6854->sr1 & S2RQ) ? 1 : 0,
813	813	( mc6854->sr1 & FD ) ? 1 : 0, ( mc6854->sr1 & CTS ) ? 1 : 0,
814	814	( mc6854->sr1 & TU ) ? 1 : 0, ( mc6854->sr1 & TDRA) ? 1 : 0,
r18055	r18056
818	818	case 1: /* status register 2 */
819	819	mc6854_update_sr2( mc6854 );
820	820	LOG(( "%f $%04x mc6854_r: get SR2=$%02X (ap=%i,fv=%i,ridle=%i,rabt=%i,err=%i,dcd=%i,ovrn=%i,rda2=%i)\n",
821		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6854->sr2,
	821	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6854->sr2,
822	822	( mc6854->sr2 & AP   ) ? 1 : 0, ( mc6854->sr2 & FV  ) ? 1 : 0,
823	823	( mc6854->sr2 & RIDLE) ? 1 : 0, ( mc6854->sr2 & RABT) ? 1 : 0,
824	824	( mc6854->sr2 & ERR  ) ? 1 : 0, ( mc6854->sr2 & DCD ) ? 1 : 0,
r18055	r18056
830	830	{
831	831	UINT8 data = mc6854_rfifo_pop( device );
832	832	LOG(( "%f $%04x mc6854_r: get data $%02X\n",
833		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data ));
	833	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data ));
834	834	return data;
835	835	}
836	836
837	837	default:
838		logerror( "$%04x mc6854 invalid read offset %i\n", device->machine().firstcpu->pcbase( ), offset );
	838	logerror( "$%04x mc6854 invalid read offset %i\n", space.machine().firstcpu->pcbase( ), offset );
839	839	}
840	840	return 0;
841	841	}
r18055	r18056
851	851	case 0: /* control register 1 */
852	852	mc6854->cr1 = data;
853	853	LOG(( "%f $%04x mc6854_w: set CR1=$%02X (ac=%i,irq=%c%c,%sreset=%c%c)\n",
854		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6854->cr1,
	854	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6854->cr1,
855	855	AC ? 1 : 0,
856	856	RIE ? 'r' : '-', TIE ? 't' : '-',
857	857	DISCONTINUE ? "discontinue," : "",
r18055	r18056
859	859	));
860	860	if ( mc6854->cr1 & 0xc )
861	861	logerror( "$%04x mc6854 DMA not handled (CR1=$%02X)\n",
862		device->machine().firstcpu->pcbase( ), mc6854->cr1 );
	862	space.machine().firstcpu->pcbase( ), mc6854->cr1 );
863	863	if ( DISCONTINUE )
864	864	{
865	865	/* abort receive FIFO but keeps shift register & synchro */
r18055	r18056
888	888	/* control register 3 */
889	889	mc6854->cr3 = data;
890	890	LOG(( "%f $%04x mc6854_w: set CR3=$%02X (lcf=%i,aex=%i,idl=%i,fdse=%i,loop=%i,tst=%i,dtr=%i)\n",
891		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6854->cr3,
	891	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6854->cr3,
892	892	LCF ? (CEX ? 16 : 8) : 0,  AEX ? 1 : 0,
893	893	IDL0 ? 0 : 1, FDSE ? 1 : 0, LOOP ? 1 : 0,
894	894	TST ? 1 : 0, DTR ? 1 : 0
895	895	));
896	896	if ( LOOP )
897		logerror( "$%04x mc6854 loop mode not handled (CR3=$%02X)\n", device->machine().firstcpu->pcbase( ), mc6854->cr3 );
	897	logerror( "$%04x mc6854 loop mode not handled (CR3=$%02X)\n", space.machine().firstcpu->pcbase( ), mc6854->cr3 );
898	898	if ( TST )
899		logerror( "$%04x mc6854 test mode not handled (CR3=$%02X)\n", device->machine().firstcpu->pcbase( ), mc6854->cr3 );
	899	logerror( "$%04x mc6854 test mode not handled (CR3=$%02X)\n", space.machine().firstcpu->pcbase( ), mc6854->cr3 );
900	900
901	901	mc6854->out_dtr_func( DTR ? 1 : 0 );
902	902
r18055	r18056
906	906	/* control register 2 */
907	907	mc6854->cr2 = data;
908	908	LOG(( "%f $%04x mc6854_w: set CR2=$%02X (pse=%i,bytes=%i,fmidle=%i,%s,tlast=%i,clr=%c%c,rts=%i)\n",
909		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6854->cr2,
	909	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6854->cr2,
910	910	PSE ? 1 : 0,  TWOBYTES ? 2 : 1,  FMIDLE ? 1 : 0,
911	911	FCTDRA ? "fc" : "tdra", TLAST ? 1 : 0,
912	912	data & 0x20 ? 'r' : '-',  data & 0x40 ? 't' : '-',
913	913	RTS ? 1 : 0 ));
914	914	if ( PSE )
915		logerror( "$%04x mc6854 status prioritization not handled (CR2=$%02X)\n", device->machine().firstcpu->pcbase( ), mc6854->cr2 );
	915	logerror( "$%04x mc6854 status prioritization not handled (CR2=$%02X)\n", space.machine().firstcpu->pcbase( ), mc6854->cr2 );
916	916	if ( TLAST )
917	917	mc6854_tfifo_terminate( device );
918	918	if ( data & 0x20 )
r18055	r18056
936	936	break;
937	937
938	938	case 2: /* transmitter data: continue data */
939		LOG(( "%f $%04xmc6854_w: push data=$%02X\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data ));
	939	LOG(( "%f $%04xmc6854_w: push data=$%02X\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data ));
940	940	mc6854_tfifo_push( device, data );
941	941	break;
942	942
r18055	r18056
945	945	{
946	946	/* control register 4 */
947	947	mc6854->cr4 = data;
948		LOG(( "%f $%04x mc6854_w: set CR4=$%02X (interframe=%i,tlen=%i,rlen=%i,%s%s)\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6854->cr4,
	948	LOG(( "%f $%04x mc6854_w: set CR4=$%02X (interframe=%i,tlen=%i,rlen=%i,%s%s)\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6854->cr4,
949	949	TWOINTER ? 2 : 1,
950	950	TWL, RWL,
951	951	ABT ? ( ABTEX ? "abort-ext," : "abort,") : "",
r18055	r18056
960	960	else
961	961	{
962	962	/* transmitter data: last data */
963		LOG(( "%f $%04x mc6854_w: push last-data=$%02X\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data ));
	963	LOG(( "%f $%04x mc6854_w: push last-data=$%02X\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data ));
964	964	mc6854_tfifo_push( device, data );
965	965	mc6854_tfifo_terminate( device );
966	966	}
967	967	break;
968	968
969	969	default:
970		logerror( "$%04x mc6854 invalid write offset %i (data=$%02X)\n", device->machine().firstcpu->pcbase( ), offset, data );
	970	logerror( "$%04x mc6854 invalid write offset %i (data=$%02X)\n", space.machine().firstcpu->pcbase( ), offset, data );
971	971	}
972	972	}
973	973

trunk/src/mess/machine/mc6846.c

r18055	r18056
281	281	case 0:
282	282	case 4:
283	283	LOG (( "$%04x %f: mc6846 CSR read $%02X intr=%i (timer=%i, cp1=%i, cp2=%i)\n",
284		device->machine().firstcpu->pcbase( ), device->machine().time().as_double(),
	284	space.machine().firstcpu->pcbase( ), space.machine().time().as_double(),
285	285	mc6846->csr, (mc6846->csr >> 7) & 1,
286	286	mc6846->csr & 1, (mc6846->csr >> 1) & 1, (mc6846->csr >> 2) & 1 ));
287	287	mc6846->csr0_to_be_cleared = mc6846->csr & 1;
r18055	r18056
290	290	return mc6846->csr;
291	291
292	292	case 1:
293		LOG (( "$%04x %f: mc6846 PCR read $%02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mc6846->pcr ));
	293	LOG (( "$%04x %f: mc6846 PCR read $%02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mc6846->pcr ));
294	294	return mc6846->pcr;
295	295
296	296	case 2:
297		LOG (( "$%04x %f: mc6846 DDR read $%02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mc6846->ddr ));
	297	LOG (( "$%04x %f: mc6846 DDR read $%02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mc6846->ddr ));
298	298	return mc6846->ddr;
299	299
300	300	case 3:
301		LOG (( "$%04x %f: mc6846 PORT read $%02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), PORT ));
	301	LOG (( "$%04x %f: mc6846 PORT read $%02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), PORT ));
302	302	if ( ! (mc6846->pcr & 0x80) )
303	303	{
304	304	if ( mc6846->csr1_to_be_cleared )
r18055	r18056
312	312	return PORT;
313	313
314	314	case 5:
315		LOG (( "$%04x %f: mc6846 TCR read $%02X\n",device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mc6846->tcr ));
	315	LOG (( "$%04x %f: mc6846 TCR read $%02X\n",space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mc6846->tcr ));
316	316	return mc6846->tcr;
317	317
318	318	case 6:
319		LOG (( "$%04x %f: mc6846 COUNTER hi read $%02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mc6846_counter( device ) >> 8 ));
	319	LOG (( "$%04x %f: mc6846 COUNTER hi read $%02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mc6846_counter( device ) >> 8 ));
320	320	if ( mc6846->csr0_to_be_cleared )
321	321	{
322	322	mc6846->csr &= ~1;
r18055	r18056
326	326	return mc6846_counter( device ) >> 8;
327	327
328	328	case 7:
329		LOG (( "$%04x %f: mc6846 COUNTER low read $%02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mc6846_counter( device ) & 0xff ));
	329	LOG (( "$%04x %f: mc6846 COUNTER low read $%02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mc6846_counter( device ) & 0xff ));
330	330	if ( mc6846->csr0_to_be_cleared )
331	331	{
332	332	mc6846->csr &= ~1;
r18055	r18056
336	336	return mc6846_counter( device ) & 0xff;
337	337
338	338	default:
339		logerror( "$%04x mc6846 invalid read offset %i\n", device->machine().firstcpu->pcbase( ), offset );
	339	logerror( "$%04x mc6846 invalid read offset %i\n", space.machine().firstcpu->pcbase( ), offset );
340	340	}
341	341	return 0;
342	342	}
r18055	r18056
367	367	"latcged,pos-edge", "latcged,pos-edge,intr"
368	368	};
369	369	LOG (( "$%04x %f: mc6846 PCR write $%02X reset=%i cp2=%s cp1=%s\n",
370		device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), data,
	370	space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), data,
371	371	(data >> 7) & 1, cp2[ (data >> 3) & 7 ], cp1[ data & 7 ] ));
372	372
373	373	}
r18055	r18056
380	380	mc6846_update_irq( device );
381	381	}
382	382	if ( data & 4 )
383		logerror( "$%04x mc6846 CP1 latching not implemented\n", device->machine().firstcpu->pcbase( ) );
	383	logerror( "$%04x mc6846 CP1 latching not implemented\n", space.machine().firstcpu->pcbase( ) );
384	384	if (data & 0x20)
385	385	{
386	386	if (data & 0x10)
r18055	r18056
390	390	mc6846->out_cp2( 0, mc6846->cp2_cpu );
391	391	}
392	392	else
393		logerror( "$%04x mc6846 acknowledge not implemented\n", device->machine().firstcpu->pcbase( ) );
	393	logerror( "$%04x mc6846 acknowledge not implemented\n", space.machine().firstcpu->pcbase( ) );
394	394	}
395	395	break;
396	396
397	397	case 2:
398		LOG (( "$%04x %f: mc6846 DDR write $%02X\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), data ));
	398	LOG (( "$%04x %f: mc6846 DDR write $%02X\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), data ));
399	399	if ( ! (mc6846->pcr & 0x80) )
400	400	{
401	401	mc6846->ddr = data;
r18055	r18056
405	405	break;
406	406
407	407	case 3:
408		LOG (( "$%04x %f: mc6846 PORT write $%02X (mask=$%02X)\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), data,mc6846->ddr ));
	408	LOG (( "$%04x %f: mc6846 PORT write $%02X (mask=$%02X)\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), data,mc6846->ddr ));
409	409	if ( ! (mc6846->pcr & 0x80) )
410	410	{
411	411	mc6846->pdr = data;
r18055	r18056
414	414	if ( mc6846->csr1_to_be_cleared && (mc6846->csr & 2) )
415	415	{
416	416	mc6846->csr &= ~2;
417		LOG (( "$%04x %f: mc6846 CP1 intr reset\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double() ));
	417	LOG (( "$%04x %f: mc6846 CP1 intr reset\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double() ));
418	418	}
419	419	if ( mc6846->csr2_to_be_cleared && (mc6846->csr & 4) )
420	420	{
421	421	mc6846->csr &= ~4;
422		LOG (( "$%04x %f: mc6846 CP2 intr reset\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double() ));
	422	LOG (( "$%04x %f: mc6846 CP2 intr reset\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double() ));
423	423	}
424	424	mc6846->csr1_to_be_cleared = 0;
425	425	mc6846->csr2_to_be_cleared = 0;
r18055	r18056
435	435	"freq-cmp", "freq-cmp", "pulse-cmp", "pulse-cmp"
436	436	};
437	437	LOG (( "$%04x %f: mc6846 TCR write $%02X reset=%i clock=%s scale=%i mode=%s out=%s\n",
438		device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), data,
	438	space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), data,
439	439	(data >> 7) & 1, (data & 0x40) ? "extern" : "sys",
440	440	(data & 0x40) ? 1 : 8, mode[ (data >> 1) & 7 ],
441	441	(data & 1) ? "enabled" : "0" ));
r18055	r18056
469	469
470	470	case 7:
471	471	mc6846->latch = ( ((UINT16) mc6846->time_MSB) << 8 ) + data;
472		LOG (( "$%04x %f: mc6846 COUNT write %i\n", device->machine().firstcpu->pcbase( ), device->machine().time().as_double(), mc6846->latch  ));
	472	LOG (( "$%04x %f: mc6846 COUNT write %i\n", space.machine().firstcpu->pcbase( ), space.machine().time().as_double(), mc6846->latch  ));
473	473	if (!(mc6846->tcr & 0x38))
474	474	{
475	475	/* timer initialization */
r18055	r18056
485	485	break;
486	486
487	487	default:
488		logerror( "$%04x mc6846 invalid write offset %i\n", device->machine().firstcpu->pcbase( ), offset );
	488	logerror( "$%04x mc6846 invalid write offset %i\n", space.machine().firstcpu->pcbase( ), offset );
489	489	}
490	490	}
491	491

trunk/src/mess/machine/pmd85.c

r18055	r18056
261	261
262	262	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_0_porta_w )
263	263	{
264		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	264	pmd85_state *state = space.machine().driver_data<pmd85_state>();
265	265	state->m_ppi_port_outputs[0][0] = data;
266	266	}
267	267
268	268	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_0_portb_w )
269	269	{
270		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	270	pmd85_state *state = space.machine().driver_data<pmd85_state>();
271	271	state->m_ppi_port_outputs[0][1] = data;
272	272	}
273	273
274	274	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_0_portc_w )
275	275	{
276		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	276	pmd85_state *state = space.machine().driver_data<pmd85_state>();
277	277	state->m_ppi_port_outputs[0][2] = data;
278		set_led_status(device->machine(), PMD85_LED_2, (data & 0x08) ? 1 : 0);
279		set_led_status(device->machine(), PMD85_LED_3, (data & 0x04) ? 1 : 0);
	278	set_led_status(space.machine(), PMD85_LED_2, (data & 0x08) ? 1 : 0);
	279	set_led_status(space.machine(), PMD85_LED_3, (data & 0x04) ? 1 : 0);
280	280	}
281	281
282	282	/*******************************************************************************
r18055	r18056
309	309
310	310	static WRITE8_DEVICE_HANDLER ( mato_ppi_0_portc_w )
311	311	{
312		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	312	pmd85_state *state = space.machine().driver_data<pmd85_state>();
313	313	state->m_ppi_port_outputs[0][2] = data;
314		set_led_status(device->machine(), PMD85_LED_2, BIT(data, 3));
315		set_led_status(device->machine(), PMD85_LED_3, BIT(data, 2));
	314	set_led_status(space.machine(), PMD85_LED_2, BIT(data, 3));
	315	set_led_status(space.machine(), PMD85_LED_3, BIT(data, 2));
316	316	}
317	317
318	318	/*******************************************************************************
r18055	r18056
340	340
341	341	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_1_porta_w )
342	342	{
343		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	343	pmd85_state *state = space.machine().driver_data<pmd85_state>();
344	344	state->m_ppi_port_outputs[1][0] = data;
345	345	}
346	346
347	347	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_1_portb_w )
348	348	{
349		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	349	pmd85_state *state = space.machine().driver_data<pmd85_state>();
350	350	state->m_ppi_port_outputs[1][1] = data;
351	351	}
352	352
353	353	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_1_portc_w )
354	354	{
355		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	355	pmd85_state *state = space.machine().driver_data<pmd85_state>();
356	356	state->m_ppi_port_outputs[1][2] = data;
357	357	}
358	358
r18055	r18056
385	385
386	386	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_2_porta_w )
387	387	{
388		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	388	pmd85_state *state = space.machine().driver_data<pmd85_state>();
389	389	state->m_ppi_port_outputs[2][0] = data;
390	390	}
391	391
392	392	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_2_portb_w )
393	393	{
394		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	394	pmd85_state *state = space.machine().driver_data<pmd85_state>();
395	395	state->m_ppi_port_outputs[2][1] = data;
396	396	}
397	397
398	398	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_2_portc_w )
399	399	{
400		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	400	pmd85_state *state = space.machine().driver_data<pmd85_state>();
401	401	state->m_ppi_port_outputs[2][2] = data;
402	402	}
403	403
r18055	r18056
458	458
459	459	static READ8_DEVICE_HANDLER ( pmd85_ppi_3_porta_r )
460	460	{
461		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	461	pmd85_state *state = space.machine().driver_data<pmd85_state>();
462	462	if (state->memregion("user1")->base() != NULL)
463	463	return state->memregion("user1")->base()[state->m_ppi_port_outputs[3][1] | (state->m_ppi_port_outputs[3][2] << 8)];
464	464	else
r18055	r18056
477	477
478	478	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_3_porta_w )
479	479	{
480		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	480	pmd85_state *state = space.machine().driver_data<pmd85_state>();
481	481	state->m_ppi_port_outputs[3][0] = data;
482	482	}
483	483
484	484	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_3_portb_w )
485	485	{
486		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	486	pmd85_state *state = space.machine().driver_data<pmd85_state>();
487	487	state->m_ppi_port_outputs[3][1] = data;
488	488	}
489	489
490	490	static WRITE8_DEVICE_HANDLER ( pmd85_ppi_3_portc_w )
491	491	{
492		pmd85_state *state = device->machine().driver_data<pmd85_state>();
	492	pmd85_state *state = space.machine().driver_data<pmd85_state>();
493	493	state->m_ppi_port_outputs[3][2] = data;
494	494	}
495	495

trunk/src/mess/machine/kramermc.c

r18055	r18056
19	19
20	20	static READ8_DEVICE_HANDLER (kramermc_port_b_r)
21	21	{
22		kramermc_state *state = device->machine().driver_data<kramermc_state>();
	22	kramermc_state *state = space.machine().driver_data<kramermc_state>();
23	23	static const char *const keynames[] = { "LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7" };
24	24
25		return device->machine().root_device().ioport(keynames[state->m_key_row])->read();
	25	return space.machine().root_device().ioport(keynames[state->m_key_row])->read();
26	26	}
27	27
28	28	static WRITE8_DEVICE_HANDLER (kramermc_port_a_w)
29	29	{
30		kramermc_state *state = device->machine().driver_data<kramermc_state>();
	30	kramermc_state *state = space.machine().driver_data<kramermc_state>();
31	31	state->m_key_row = ((data >> 1) & 0x07);
32	32	}
33	33

trunk/src/mess/machine/orion.c

r18055	r18056
29	29
30	30	static READ8_DEVICE_HANDLER (orion_romdisk_porta_r )
31	31	{
32		orion_state *state = device->machine().driver_data<orion_state>();
	32	orion_state *state = space.machine().driver_data<orion_state>();
33	33	UINT8 *romdisk = state->memregion("maincpu")->base() + 0x10000;
34	34	return romdisk[state->m_romdisk_msb*256+state->m_romdisk_lsb];
35	35	}
36	36
37	37	static WRITE8_DEVICE_HANDLER (orion_romdisk_portb_w )
38	38	{
39		orion_state *state = device->machine().driver_data<orion_state>();
	39	orion_state *state = space.machine().driver_data<orion_state>();
40	40	state->m_romdisk_lsb = data;
41	41	}
42	42
43	43	static WRITE8_DEVICE_HANDLER (orion_romdisk_portc_w )
44	44	{
45		orion_state *state = device->machine().driver_data<orion_state>();
	45	orion_state *state = space.machine().driver_data<orion_state>();
46	46	state->m_romdisk_msb = data;
47	47	}
48	48

trunk/src/mess/machine/e05a03.c

r18055	r18056
117	117	{
118	118	e05a03_state *e05a03 = get_safe_token(device);
119	119
120		logerror("%s: e05a03_w(%02x): %02x\n", device->machine().describe_context(), offset, data);
	120	logerror("%s: e05a03_w(%02x): %02x\n", space.machine().describe_context(), offset, data);
121	121
122	122	switch (offset)
123	123	{
r18055	r18056
157	157	e05a03_state *e05a03 = get_safe_token(device);
158	158	UINT8 result = 0;
159	159
160		logerror("%s: e05a03_r(%02x)\n", device->machine().describe_context(), offset);
	160	logerror("%s: e05a03_r(%02x)\n", space.machine().describe_context(), offset);
161	161
162	162	switch (offset)
163	163	{

trunk/src/mess/machine/a7800.c

r18055	r18056
40	40
41	41	static READ8_DEVICE_HANDLER( riot_joystick_r )
42	42	{
43		return device->machine().root_device().ioport("joysticks")->read();
	43	return space.machine().root_device().ioport("joysticks")->read();
44	44	}
45	45
46	46	static READ8_DEVICE_HANDLER( riot_console_button_r )
47	47	{
48		return device->machine().root_device().ioport("console_buttons")->read();
	48	return space.machine().root_device().ioport("console_buttons")->read();
49	49	}
50	50
51	51	static WRITE8_DEVICE_HANDLER( riot_button_pullup_w )
52	52	{
53		a7800_state *state = device->machine().driver_data<a7800_state>();
	53	a7800_state *state = space.machine().driver_data<a7800_state>();
54	54	state->m_p1_one_button = data & 0x04; // pin 6 of the controller port is held high by the riot chip when reading two-button controllers (from schematic)
55	55	state->m_p2_one_button = data & 0x10;
56	56	}

trunk/src/mess/machine/microtan.c

r18055	r18056
163	163	**************************************************************/
164	164	static READ8_DEVICE_HANDLER (via_0_in_a )
165	165	{
166		int data = device->machine().root_device().ioport("JOY")->read();
	166	int data = space.machine().root_device().ioport("JOY")->read();
167	167	LOG(("microtan_via_0_in_a %02X\n", data));
168	168	return data;
169	169	}
r18055	r18056
212	212	{
213	213	LOG(("microtan_via_0_out_b %02X\n", data));
214	214	/* bit #7 is the cassette output signal */
215		cassette_device_image(device->machine())->output(data & 0x80 ? +1.0 : -1.0);
	215	cassette_device_image(space.machine())->output(data & 0x80 ? +1.0 : -1.0);
216	216	}
217	217
218	218	static WRITE8_DEVICE_HANDLER ( via_0_out_ca2 )

trunk/src/mess/machine/samcoupe.c

r18055	r18056
160	160
161	161	static READ8_DEVICE_HANDLER( samcoupe_rtc_r )
162	162	{
163		address_space &spaceio = device->machine().device("maincpu")->memory().space(AS_IO);
	163	address_space &spaceio = space.machine().device("maincpu")->memory().space(AS_IO);
164	164	msm6242_device *rtc = dynamic_cast<msm6242_device*>(device);
165	165	return rtc->read(spaceio,offset >> 12);
166	166	}
r18055	r18056
168	168
169	169	static WRITE8_DEVICE_HANDLER( samcoupe_rtc_w )
170	170	{
171		address_space &spaceio = device->machine().device("maincpu")->memory().space(AS_IO);
	171	address_space &spaceio = space.machine().device("maincpu")->memory().space(AS_IO);
172	172	msm6242_device *rtc = dynamic_cast<msm6242_device*>(device);
173	173	rtc->write(spaceio,offset >> 12, data);
174	174	}

trunk/src/mess/machine/svi318.c

r18055	r18056
148	148	{
149	149	int data = 0x0f;
150	150
151		if ((device->machine().device<cassette_image_device>(CASSETTE_TAG))->input() > 0.0038)
	151	if ((space.machine().device<cassette_image_device>(CASSETTE_TAG))->input() > 0.0038)
152	152	data |= 0x80;
153		if (!svi318_cassette_present(device->machine(), 0))
	153	if (!svi318_cassette_present(space.machine(), 0))
154	154	data |= 0x40;
155		data |= device->machine().root_device().ioport("BUTTONS")->read() & 0x30;
	155	data |= space.machine().root_device().ioport("BUTTONS")->read() & 0x30;
156	156
157	157	return data;
158	158	}
r18055	r18056
172	172
173	173	static READ8_DEVICE_HANDLER ( svi318_ppi_port_b_r )
174	174	{
175		svi318_state *state = device->machine().driver_data<svi318_state>();
	175	svi318_state *state = space.machine().driver_data<svi318_state>();
176	176	int row;
177	177	static const char *const keynames[] = {
178	178	"LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5",
r18055	r18056
181	181
182	182	row = state->m_svi.keyboard_row;
183	183	if (row <= 10)
184		return device->machine().root_device().ioport(keynames[row])->read();
	184	return space.machine().root_device().ioport(keynames[row])->read();
185	185
186	186	return 0xff;
187	187	}
r18055	r18056
201	201
202	202	static WRITE8_DEVICE_HANDLER ( svi318_ppi_port_c_w )
203	203	{
204		svi318_state *state = device->machine().driver_data<svi318_state>();
	204	svi318_state *state = space.machine().driver_data<svi318_state>();
205	205	int val;
206	206
207	207	/* key click */
208	208	val = (data & 0x80) ? 0x3e : 0;
209	209	val += (data & 0x40) ? 0x3e : 0;
210		device->machine().device<dac_device>("dac")->write_signed8(val);
	210	space.machine().device<dac_device>("dac")->write_signed8(val);
211	211
212	212	/* cassette motor on/off */
213		if (svi318_cassette_present(device->machine(), 0))
	213	if (svi318_cassette_present(space.machine(), 0))
214	214	{
215	215
216		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(
	216	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(
217	217	(data & 0x10) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED,
218	218	CASSETTE_MOTOR_DISABLED);
219	219	}
220	220
221	221	/* cassette signal write */
222		device->machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x20) ? -1.0 : +1.0);
	222	space.machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x20) ? -1.0 : +1.0);
223	223
224	224	state->m_svi.keyboard_row = data & 0x0F;
225	225	}

trunk/src/mess/machine/z80ne.c

r18055	r18056
613	613
614	614	READ8_DEVICE_HANDLER( lx388_mc6847_videoram_r )
615	615	{
616		z80ne_state *state = device->machine().driver_data<z80ne_state>();
	616	z80ne_state *state = space.machine().driver_data<z80ne_state>();
617	617	if (offset == ~0) return 0xff;
618	618
619	619	UINT8 *videoram = state->m_videoram;
r18055	r18056
652	652
653	653	WRITE8_DEVICE_HANDLER(lx390_motor_w)
654	654	{
655		z80ne_state *state = device->machine().driver_data<z80ne_state>();
	655	z80ne_state *state = space.machine().driver_data<z80ne_state>();
656	656	/* Selection of drive and parameters
657	657	A write also causes the selected drive motor to turn on for about 3 seconds.
658	658	When the motor turns off, the drive is deselected.
r18055	r18056
700	700
701	701	READ8_DEVICE_HANDLER(lx390_reset_bank)
702	702	{
703		z80ne_state *state = device->machine().driver_data<z80ne_state>();
	703	z80ne_state *state = space.machine().driver_data<z80ne_state>();
704	704	offs_t pc;
705	705
706	706	/* if PC is not in range, we are under integrated debugger control, DON'T SWAP */
707		pc = device->machine().device("z80ne")->safe_pc();
	707	pc = space.machine().device("z80ne")->safe_pc();
708	708	if((pc >= 0xf000) && (pc <=0xffff))
709	709	{
710	710	LOG(("lx390_reset_bank, reset memory bank 1\n"));
r18055	r18056
755	755
756	756	WRITE8_DEVICE_HANDLER(lx390_fdc_w)
757	757	{
758		z80ne_state *state = device->machine().driver_data<z80ne_state>();
	758	z80ne_state *state = space.machine().driver_data<z80ne_state>();
759	759	UINT8 d;
760	760
761	761	d = data;

trunk/src/mess/machine/isa_hdc.c

r18055	r18056
796	796	}
797	797
798	798	if (LOG_HDC_CALL)
799		logerror("pc_HDC_r(): pc=%06X offs=%d result=0x%02x\n", device->machine().firstcpu->pc(), offset, data);
	799	logerror("pc_HDC_r(): pc=%06X offs=%d result=0x%02x\n", space.machine().firstcpu->pc(), offset, data);
800	800
801	801	return data;
802	802	}
r18055	r18056
805	805	{
806	806	isa8_hdc_device   *hdc  = downcast<isa8_hdc_device *>(device);
807	807	if (LOG_HDC_CALL)
808		logerror("pc_HDC_w(): pc=%06X offs=%d data=0x%02x\n", device->machine().firstcpu->pc(), offset, data);
	808	logerror("pc_HDC_w(): pc=%06X offs=%d data=0x%02x\n", space.machine().firstcpu->pc(), offset, data);
809	809
810	810	switch( offset )
811	811	{

trunk/src/mess/machine/ac1.c

r18055	r18056
13	13
14	14	static READ8_DEVICE_HANDLER (ac1_port_b_r)
15	15	{
16		ac1_state *state = device->machine().driver_data<ac1_state>();
	16	ac1_state *state = space.machine().driver_data<ac1_state>();
17	17	UINT8 data = 0x7f;
18	18
19	19	if (state->m_cassette->input() > 0.03)
r18055	r18056
26	26
27	27	static READ8_DEVICE_HANDLER (ac1_port_a_r)
28	28	{
29		UINT8 line0 = device->machine().root_device().ioport("LINE0")->read();
30		UINT8 line1 = device->machine().root_device().ioport("LINE1")->read();
31		UINT8 line2 = device->machine().root_device().ioport("LINE2")->read();
32		UINT8 line3 = device->machine().root_device().ioport("LINE3")->read();
33		UINT8 line4 = device->machine().root_device().ioport("LINE4")->read();
34		UINT8 line5 = device->machine().root_device().ioport("LINE5")->read();
35		UINT8 line6 = device->machine().root_device().ioport("LINE6")->read();
	29	UINT8 line0 = space.machine().root_device().ioport("LINE0")->read();
	30	UINT8 line1 = space.machine().root_device().ioport("LINE1")->read();
	31	UINT8 line2 = space.machine().root_device().ioport("LINE2")->read();
	32	UINT8 line3 = space.machine().root_device().ioport("LINE3")->read();
	33	UINT8 line4 = space.machine().root_device().ioport("LINE4")->read();
	34	UINT8 line5 = space.machine().root_device().ioport("LINE5")->read();
	35	UINT8 line6 = space.machine().root_device().ioport("LINE6")->read();
36	36
37	37	UINT8 SH    = BNOT(BIT(line6,0));
38	38	UINT8 CTRL  = BNOT(BIT(line6,1));
r18055	r18056
94	94	7       cassette in
95	95
96	96	*/
97		ac1_state *state = device->machine().driver_data<ac1_state>();
	97	ac1_state *state = space.machine().driver_data<ac1_state>();
98	98	state->m_cassette->output((data & 0x40) ? -1.0 : +1.0);
99	99	}
100	100

trunk/src/mess/machine/apollo.c

r18055	r18056
507	507
508	508	static READ8_DEVICE_HANDLER( apollo_dma8237_ctape_dack_r ) {
509	509
510		UINT8 data = sc499_dack_r(&device->machine());
	510	UINT8 data = sc499_dack_r(&space.machine());
511	511	DLOG2(("dma ctape dack read %02x",data));
512	512
513	513	// hack for DN3000: select appropriate DMA channel No.
r18055	r18056
518	518
519	519	static WRITE8_DEVICE_HANDLER( apollo_dma8237_ctape_dack_w ) {
520	520	DLOG2(("dma ctape dack write %02x", data));
521		sc499_dack_w(&device->machine(), data);
	521	sc499_dack_w(&space.machine(), data);
522	522
523	523	// hack for DN3000: select appropriate DMA channel No.
524	524	// Note: too late for this byte, but next bytes will be ok
r18055	r18056
526	526	}
527	527
528	528	static READ8_DEVICE_HANDLER( apollo_dma8237_fdc_dack_r ) {
529		UINT8 data = pc_fdc_dack_r(device->machine(), space);
	529	UINT8 data = pc_fdc_dack_r(space.machine(), space);
530	530	//  DLOG2(("dma fdc dack read %02x",data));
531	531
532	532	// hack for DN3000: select appropriate DMA channel No.
r18055	r18056
537	537
538	538	static WRITE8_DEVICE_HANDLER( apollo_dma8237_fdc_dack_w ) {
539	539	// DLOG2(("dma fdc dack write %02x", data));
540		pc_fdc_dack_w(device->machine(), space, data);
	540	pc_fdc_dack_w(space.machine(), space, data);
541	541
542	542	// hack for DN3000: select appropriate DMA channel No.
543	543	// Note: too late for this byte, but next bytes will be ok

trunk/src/mess/machine/sym1.c

r18055	r18056
82	82
83	83	static READ8_DEVICE_HANDLER(sym1_riot_a_r)
84	84	{
85		sym1_state *state = device->machine().driver_data<sym1_state>();
	85	sym1_state *state = space.machine().driver_data<sym1_state>();
86	86	int data = 0x7f;
87	87
88	88	/* scan keypad rows */
89		if (!(state->m_riot_port_a & 0x80)) data &= device->machine().root_device().ioport("ROW-0")->read();
90		if (!(state->m_riot_port_b & 0x01)) data &= device->machine().root_device().ioport("ROW-1")->read();
91		if (!(state->m_riot_port_b & 0x02)) data &= device->machine().root_device().ioport("ROW-2")->read();
92		if (!(state->m_riot_port_b & 0x04)) data &= device->machine().root_device().ioport("ROW-3")->read();
	89	if (!(state->m_riot_port_a & 0x80)) data &= space.machine().root_device().ioport("ROW-0")->read();
	90	if (!(state->m_riot_port_b & 0x01)) data &= space.machine().root_device().ioport("ROW-1")->read();
	91	if (!(state->m_riot_port_b & 0x02)) data &= space.machine().root_device().ioport("ROW-2")->read();
	92	if (!(state->m_riot_port_b & 0x04)) data &= space.machine().root_device().ioport("ROW-3")->read();
93	93
94	94	/* determine column */
95	95	if ( ((state->m_riot_port_a ^ 0xff) & (state->ioport("ROW-0")->read() ^ 0xff)) & 0x7f )
r18055	r18056
101	101
102	102	static READ8_DEVICE_HANDLER(sym1_riot_b_r)
103	103	{
104		sym1_state *state = device->machine().driver_data<sym1_state>();
	104	sym1_state *state = space.machine().driver_data<sym1_state>();
105	105	int data = 0xff;
106	106
107	107	/* determine column */
108		if ( ((state->m_riot_port_a ^ 0xff) & (device->machine().root_device().ioport("ROW-1")->read() ^ 0xff)) & 0x7f )
	108	if ( ((state->m_riot_port_a ^ 0xff) & (space.machine().root_device().ioport("ROW-1")->read() ^ 0xff)) & 0x7f )
109	109	data &= ~0x01;
110	110
111		if ( ((state->m_riot_port_a ^ 0xff) & (device->machine().root_device().ioport("ROW-2")->read() ^ 0xff)) & 0x3f )
	111	if ( ((state->m_riot_port_a ^ 0xff) & (space.machine().root_device().ioport("ROW-2")->read() ^ 0xff)) & 0x3f )
112	112	data &= ~0x02;
113	113
114	114	if ( ((state->m_riot_port_a ^ 0xff) & (state->ioport("ROW-3")->read() ^ 0xff)) & 0x1f )
r18055	r18056
122	122
123	123	static WRITE8_DEVICE_HANDLER(sym1_riot_a_w)
124	124	{
125		sym1_state *state = device->machine().driver_data<sym1_state>();
126		logerror("%x: riot_a_w 0x%02x\n", device->machine().device("maincpu") ->safe_pc( ), data);
	125	sym1_state *state = space.machine().driver_data<sym1_state>();
	126	logerror("%x: riot_a_w 0x%02x\n", space.machine().device("maincpu") ->safe_pc( ), data);
127	127
128	128	/* save for later use */
129	129	state->m_riot_port_a = data;
r18055	r18056
132	132
133	133	static WRITE8_DEVICE_HANDLER(sym1_riot_b_w)
134	134	{
135		sym1_state *state = device->machine().driver_data<sym1_state>();
136		logerror("%x: riot_b_w 0x%02x\n", device->machine().device("maincpu") ->safe_pc( ), data);
	135	sym1_state *state = space.machine().driver_data<sym1_state>();
	136	logerror("%x: riot_b_w 0x%02x\n", space.machine().device("maincpu") ->safe_pc( ), data);
137	137
138	138	/* save for later use */
139	139	state->m_riot_port_b = data;
140	140
141	141	/* first 4 pins are connected to the 74145 */
142		device->machine().device<ttl74145_device>("ttl74145")->write(data & 0x0f);
	142	space.machine().device<ttl74145_device>("ttl74145")->write(data & 0x0f);
143	143	}
144	144
145	145
r18055	r18056
186	186
187	187	static WRITE8_DEVICE_HANDLER( sym1_via0_b_w )
188	188	{
189		logerror("%s: via0_b_w 0x%02x\n", device->machine().describe_context(), data);
	189	logerror("%s: via0_b_w 0x%02x\n", space.machine().describe_context(), data);
190	190	}
191	191
192	192
r18055	r18056
197	197	*/
198	198	static WRITE8_DEVICE_HANDLER( sym1_via2_a_w )
199	199	{
200		address_space &cpu0space = device->machine().device( "maincpu")->memory().space( AS_PROGRAM );
	200	address_space &cpu0space = space.machine().device( "maincpu")->memory().space( AS_PROGRAM );
201	201
202	202	logerror("SYM1 VIA2 W 0x%02x\n", data);
203	203
204		if ((device->machine().root_device().ioport("WP")->read() & 0x01) && !(data & 0x01)) {
	204	if ((space.machine().root_device().ioport("WP")->read() & 0x01) && !(data & 0x01)) {
205	205	cpu0space.nop_write(0xa600, 0xa67f);
206	206	} else {
207	207	cpu0space.install_write_bank(0xa600, 0xa67f, "bank5");
208	208	}
209		if ((device->machine().root_device().ioport("WP")->read() & 0x02) && !(data & 0x02)) {
	209	if ((space.machine().root_device().ioport("WP")->read() & 0x02) && !(data & 0x02)) {
210	210	cpu0space.nop_write(0x0400, 0x07ff);
211	211	} else {
212	212	cpu0space.install_write_bank(0x0400, 0x07ff, "bank2");
213	213	}
214		if ((device->machine().root_device().ioport("WP")->read() & 0x04) && !(data & 0x04)) {
	214	if ((space.machine().root_device().ioport("WP")->read() & 0x04) && !(data & 0x04)) {
215	215	cpu0space.nop_write(0x0800, 0x0bff);
216	216	} else {
217	217	cpu0space.install_write_bank(0x0800, 0x0bff, "bank3");
218	218	}
219		if ((device->machine().root_device().ioport("WP")->read() & 0x08) && !(data & 0x08)) {
	219	if ((space.machine().root_device().ioport("WP")->read() & 0x08) && !(data & 0x08)) {
220	220	cpu0space.nop_write(0x0c00, 0x0fff);
221	221	} else {
222	222	cpu0space.install_write_bank(0x0c00, 0x0fff, "bank4");

trunk/src/mess/machine/kaypro.c

r18055	r18056
242	242	else
243	243	if (offset == 1)
244	244	//      return z80sio_d_r(device, 1);
245		return kay_kbd_d_r(device->machine());
	245	return kay_kbd_d_r(space.machine());
246	246	else
247	247	if (offset == 2)
248	248	return dynamic_cast<z80sio_device*>(device)->control_read(0);
249	249	else
250	250	//      return z80sio_c_r(device, 1);
251		return kay_kbd_c_r(device->machine());
	251	return kay_kbd_c_r(space.machine());
252	252	}
253	253
254	254	WRITE8_DEVICE_HANDLER( kaypro_sio_w )
r18055	r18056
258	258	else
259	259	if (offset == 1)
260	260	//      z80sio_d_w(device, 1, data);
261		kay_kbd_d_w(device->machine(), data);
	261	kay_kbd_d_w(space.machine(), data);
262	262	else
263	263	if (offset == 2)
264	264	dynamic_cast<z80sio_device*>(device)->control_write(0, data);

trunk/src/mess/machine/pc_lpt.c

r18055	r18056
137	137	{
138	138	pc_lpt_state *lpt = get_safe_token(device);
139	139	// pull up mechanism for input lines, zeros are provided by pheripherial
140		return lpt->data & ~lpt->centronics->read(device->machine().driver_data()->generic_space(), 0);
	140	return lpt->data & ~lpt->centronics->read(space.machine().driver_data()->generic_space(), 0);
141	141	}
142	142
143	143
r18055	r18056
145	145	{
146	146	pc_lpt_state *lpt = get_safe_token(device);
147	147	lpt->data = data;
148		lpt->centronics->write(device->machine().driver_data()->generic_space(), 0, data);
	148	lpt->centronics->write(space.machine().driver_data()->generic_space(), 0, data);
149	149	}
150	150
151	151

trunk/src/mess/machine/s3c44b0.c

r18055	r18056
346	346	}
347	347	break;
348	348	}
349		//  verboselog( device->machine(), 9, "(LCD) %08X -> %08X\n", S3C44B0_BASE_LCD + (offset << 2), data);
	349	//  verboselog( space.machine(), 9, "(LCD) %08X -> %08X\n", S3C44B0_BASE_LCD + (offset << 2), data);
350	350	return data;
351	351	}
352	352
r18055	r18056
442	442	{
443	443	s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
444	444	UINT32 old_value = ((UINT32*)&lcd->regs)[offset];
445		//  verboselog( device->machine(), 9, "(LCD) %08X <- %08X\n", S3C44B0_BASE_LCD + (offset << 2), data);
	445	//  verboselog( space.machine(), 9, "(LCD) %08X <- %08X\n", S3C44B0_BASE_LCD + (offset << 2), data);
446	446	COMBINE_DATA(&((UINT32*)&lcd->regs)[offset]);
447	447	switch (offset)
448	448	{
r18055	r18056
474	474	{
475	475	s3c44b0_t *s3c44b0 = get_token( device);
476	476	UINT32 data = ((UINT32*)&s3c44b0->clkpow.regs)[offset];
477		verboselog( device->machine(), 9, "(CLKPOW) %08X -> %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data);
	477	verboselog( space.machine(), 9, "(CLKPOW) %08X -> %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data);
478	478	return data;
479	479	}
480	480
481	481	static WRITE32_DEVICE_HANDLER( s3c44b0_clkpow_w )
482	482	{
483	483	s3c44b0_t *s3c44b0 = get_token( device);
484		verboselog( device->machine(), 9, "(CLKPOW) %08X <- %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data);
	484	verboselog( space.machine(), 9, "(CLKPOW) %08X <- %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data);
485	485	COMBINE_DATA(&((UINT32*)&s3c44b0->clkpow.regs)[offset]);
486	486	switch (offset)
487	487	{
488	488	case S3C44B0_PLLCON :
489	489	{
490		verboselog( device->machine(), 5, "CLKPOW - mclk %d\n", s3c44b0_get_mclk( device));
	490	verboselog( space.machine(), 5, "CLKPOW - mclk %d\n", s3c44b0_get_mclk( device));
491	491	s3c44b0->cpu->set_unscaled_clock( s3c44b0_get_mclk( device) * CLOCK_MULTIPLIER);
492	492	}
493	493	break;
r18055	r18056
602	602	{
603	603	s3c44b0_t *s3c44b0 = get_token( device);
604	604	UINT32 data = ((UINT32*)&s3c44b0->irq.regs)[offset];
605		verboselog( device->machine(), 9, "(IRQ) %08X -> %08X\n", S3C44B0_BASE_INT + (offset << 2), data);
	605	verboselog( space.machine(), 9, "(IRQ) %08X -> %08X\n", S3C44B0_BASE_INT + (offset << 2), data);
606	606	return data;
607	607	}
608	608
609	609	static WRITE32_DEVICE_HANDLER( s3c44b0_irq_w )
610	610	{
611	611	s3c44b0_t *s3c44b0 = get_token( device);
612		verboselog( device->machine(), 9, "(IRQ) %08X <- %08X\n", S3C44B0_BASE_INT + (offset << 2), data);
	612	verboselog( space.machine(), 9, "(IRQ) %08X <- %08X\n", S3C44B0_BASE_INT + (offset << 2), data);
613	613	COMBINE_DATA(&((UINT32*)&s3c44b0->irq.regs)[offset]);
614	614	switch (offset)
615	615	{
r18055	r18056
688	688	}
689	689	break;
690	690	}
691		verboselog( device->machine(), 9, "(PWM) %08X -> %08X\n", S3C44B0_BASE_PWM + (offset << 2), data);
	691	verboselog( space.machine(), 9, "(PWM) %08X -> %08X\n", S3C44B0_BASE_PWM + (offset << 2), data);
692	692	return data;
693	693	}
694	694
r18055	r18056
818	818	{
819	819	s3c44b0_t *s3c44b0 = get_token( device);
820	820	UINT32 old_value = ((UINT32*)&s3c44b0->pwm.regs)[offset];
821		verboselog( device->machine(), 9, "(PWM) %08X <- %08X\n", S3C44B0_BASE_PWM + (offset << 2), data);
	821	verboselog( space.machine(), 9, "(PWM) %08X <- %08X\n", S3C44B0_BASE_PWM + (offset << 2), data);
822	822	COMBINE_DATA(&((UINT32*)&s3c44b0->pwm.regs)[offset]);
823	823	switch (offset)
824	824	{
r18055	r18056
1009	1009	}
1010	1010	break;
1011	1011	}
1012		verboselog( device->machine(), 9, "(IIC) %08X -> %08X\n", S3C44B0_BASE_IIC + (offset << 2), data);
	1012	verboselog( space.machine(), 9, "(IIC) %08X -> %08X\n", S3C44B0_BASE_IIC + (offset << 2), data);
1013	1013	return data;
1014	1014	}
1015	1015
r18055	r18056
1017	1017	{
1018	1018	s3c44b0_t *s3c44b0 = get_token( device);
1019	1019	UINT32 old_value = ((UINT32*)&s3c44b0->iic.regs)[offset];
1020		verboselog( device->machine(), 9, "(IIC) %08X <- %08X\n", S3C44B0_BASE_IIC + (offset << 2), data);
	1020	verboselog( space.machine(), 9, "(IIC) %08X <- %08X\n", S3C44B0_BASE_IIC + (offset << 2), data);
1021	1021	COMBINE_DATA(&((UINT32*)&s3c44b0->iic.regs)[offset]);
1022	1022	switch (offset)
1023	1023	{
r18055	r18056
1176	1176	}
1177	1177	break;
1178	1178	}
1179		verboselog( device->machine(), 9, "(GPIO) %08X -> %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data);
	1179	verboselog( space.machine(), 9, "(GPIO) %08X -> %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data);
1180	1180	return data;
1181	1181	}
1182	1182
r18055	r18056
1184	1184	{
1185	1185	s3c44b0_t *s3c44b0 = get_token( device);
1186	1186	UINT32 old_value = ((UINT32*)&s3c44b0->gpio.regs)[offset];
1187		verboselog( device->machine(), 9, "(GPIO) %08X <- %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data);
	1187	verboselog( space.machine(), 9, "(GPIO) %08X <- %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data);
1188	1188	COMBINE_DATA(&((UINT32*)&s3c44b0->gpio.regs)[offset]);
1189	1189	switch (offset)
1190	1190	{
r18055	r18056
1287	1287	static READ32_DEVICE_HANDLER( s3c44b0_uart_0_r )
1288	1288	{
1289	1289	UINT32 data = s3c44b0_uart_r( device, 0, offset);
1290		//  verboselog( device->machine(), 9, "(UART 0) %08X -> %08X\n", S3C44B0_BASE_UART_0 + (offset << 2), data);
	1290	//  verboselog( space.machine(), 9, "(UART 0) %08X -> %08X\n", S3C44B0_BASE_UART_0 + (offset << 2), data);
1291	1291	return data;
1292	1292	}
1293	1293
1294	1294	static READ32_DEVICE_HANDLER( s3c44b0_uart_1_r )
1295	1295	{
1296	1296	UINT32 data = s3c44b0_uart_r( device, 1, offset);
1297		//  verboselog( device->machine(), 9, "(UART 1) %08X -> %08X\n", S3C44B0_BASE_UART_1 + (offset << 2), data);
	1297	//  verboselog( space.machine(), 9, "(UART 1) %08X -> %08X\n", S3C44B0_BASE_UART_1 + (offset << 2), data);
1298	1298	return data;
1299	1299	}
1300	1300
1301	1301	static WRITE32_DEVICE_HANDLER( s3c44b0_uart_0_w )
1302	1302	{
1303		verboselog( device->machine(), 9, "(UART 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_0 + (offset << 2), data, mem_mask);
	1303	verboselog( space.machine(), 9, "(UART 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_0 + (offset << 2), data, mem_mask);
1304	1304	s3c44b0_uart_w( device, 0, offset, data, mem_mask);
1305	1305	}
1306	1306
1307	1307	static WRITE32_DEVICE_HANDLER( s3c44b0_uart_1_w )
1308	1308	{
1309		verboselog( device->machine(), 9, "(UART 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_1 + (offset << 2), data, mem_mask);
	1309	verboselog( space.machine(), 9, "(UART 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_1 + (offset << 2), data, mem_mask);
1310	1310	s3c44b0_uart_w( device, 1, offset, data, mem_mask);
1311	1311	}
1312	1312
r18055	r18056
1355	1355	}
1356	1356	break;
1357	1357	}
1358		verboselog( device->machine(), 9, "(WDT) %08X -> %08X\n", S3C44B0_BASE_WDT + (offset << 2), data);
	1358	verboselog( space.machine(), 9, "(WDT) %08X -> %08X\n", S3C44B0_BASE_WDT + (offset << 2), data);
1359	1359	return data;
1360	1360	}
1361	1361
r18055	r18056
1399	1399	{
1400	1400	s3c44b0_t *s3c44b0 = get_token( device);
1401	1401	UINT32 old_value = ((UINT32*)&s3c44b0->wdt.regs)[offset];
1402		verboselog( device->machine(), 9, "(WDT) %08X <- %08X\n", S3C44B0_BASE_WDT + (offset << 2), data);
	1402	verboselog( space.machine(), 9, "(WDT) %08X <- %08X\n", S3C44B0_BASE_WDT + (offset << 2), data);
1403	1403	COMBINE_DATA(&((UINT32*)&s3c44b0->wdt.regs)[offset]);
1404	1404	switch (offset)
1405	1405	{
r18055	r18056
1435	1435	{
1436	1436	s3c44b0_t *s3c44b0 = get_token( device);
1437	1437	UINT32 data = ((UINT32*)&s3c44b0->cpuwrap.regs)[offset];
1438		verboselog( device->machine(), 9, "(CPUWRAP) %08X -> %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data);
	1438	verboselog( space.machine(), 9, "(CPUWRAP) %08X -> %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data);
1439	1439	return data;
1440	1440	}
1441	1441
1442	1442	static WRITE32_DEVICE_HANDLER( s3c44b0_cpuwrap_w )
1443	1443	{
1444	1444	s3c44b0_t *s3c44b0 = get_token( device);
1445		verboselog( device->machine(), 9, "(CPUWRAP) %08X <- %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data);
	1445	verboselog( space.machine(), 9, "(CPUWRAP) %08X <- %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data);
1446	1446	COMBINE_DATA(&((UINT32*)&s3c44b0->cpuwrap.regs)[offset]);
1447	1447	}
1448	1448
r18055	r18056
1452	1452	{
1453	1453	s3c44b0_t *s3c44b0 = get_token( device);
1454	1454	UINT32 data = ((UINT32*)&s3c44b0->adc.regs)[offset];
1455		verboselog( device->machine(), 9, "(ADC) %08X -> %08X\n", S3C44B0_BASE_ADC + (offset << 2), data);
	1455	verboselog( space.machine(), 9, "(ADC) %08X -> %08X\n", S3C44B0_BASE_ADC + (offset << 2), data);
1456	1456	return data;
1457	1457	}
1458	1458
r18055	r18056
1494	1494	{
1495	1495	s3c44b0_t *s3c44b0 = get_token( device);
1496	1496	UINT32 old_value = ((UINT32*)&s3c44b0->wdt.regs)[offset];
1497		verboselog( device->machine(), 9, "(ADC) %08X <- %08X\n", S3C44B0_BASE_ADC + (offset << 2), data);
	1497	verboselog( space.machine(), 9, "(ADC) %08X <- %08X\n", S3C44B0_BASE_ADC + (offset << 2), data);
1498	1498	COMBINE_DATA(&((UINT32*)&s3c44b0->adc.regs)[offset]);
1499	1499	switch (offset)
1500	1500	{
r18055	r18056
1525	1525	{
1526	1526	s3c44b0_t *s3c44b0 = get_token( device);
1527	1527	UINT32 data = ((UINT32*)&s3c44b0->sio.regs)[offset];
1528		verboselog( device->machine(), 9, "(SIO) %08X -> %08X\n", S3C44B0_BASE_SIO + (offset << 2), data);
	1528	verboselog( space.machine(), 9, "(SIO) %08X -> %08X\n", S3C44B0_BASE_SIO + (offset << 2), data);
1529	1529	return data;
1530	1530	}
1531	1531
r18055	r18056
1569	1569	{
1570	1570	s3c44b0_t *s3c44b0 = get_token( device);
1571	1571	UINT32 old_value = ((UINT32*)&s3c44b0->sio.regs)[offset];
1572		verboselog( device->machine(), 9, "(SIO) %08X <- %08X\n", S3C44B0_BASE_SIO + (offset << 2), data);
	1572	verboselog( space.machine(), 9, "(SIO) %08X <- %08X\n", S3C44B0_BASE_SIO + (offset << 2), data);
1573	1573	COMBINE_DATA(&((UINT32*)&s3c44b0->sio.regs)[offset]);
1574	1574	switch (offset)
1575	1575	{
r18055	r18056
1637	1637	{
1638	1638	s3c44b0_t *s3c44b0 = get_token( device);
1639	1639	UINT32 data = ((UINT32*)&s3c44b0->iis.regs)[offset];
1640		verboselog( device->machine(), 9, "(IIS) %08X -> %08X\n", S3C44B0_BASE_IIS + (offset << 2), data);
	1640	verboselog( space.machine(), 9, "(IIS) %08X -> %08X\n", S3C44B0_BASE_IIS + (offset << 2), data);
1641	1641	return data;
1642	1642	}
1643	1643
r18055	r18056
1645	1645	{
1646	1646	s3c44b0_t *s3c44b0 = get_token( device);
1647	1647	UINT32 old_value = ((UINT32*)&s3c44b0->iis.regs)[offset];
1648		verboselog( device->machine(), 9, "(IIS) %08X <- %08X\n", S3C44B0_BASE_IIS + (offset << 2), data);
	1648	verboselog( space.machine(), 9, "(IIS) %08X <- %08X\n", S3C44B0_BASE_IIS + (offset << 2), data);
1649	1649	COMBINE_DATA(&((UINT32*)&s3c44b0->iis.regs)[offset]);
1650	1650	switch (offset)
1651	1651	{
r18055	r18056
1793	1793	static READ32_DEVICE_HANDLER( s3c44b0_zdma_0_r )
1794	1794	{
1795	1795	UINT32 data = s3c44b0_zdma_r( device, 0, offset);
1796		verboselog( device->machine(), 9, "(ZDMA 0) %08X -> %08X\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data);
	1796	verboselog( space.machine(), 9, "(ZDMA 0) %08X -> %08X\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data);
1797	1797	return data;
1798	1798	}
1799	1799
1800	1800	static READ32_DEVICE_HANDLER( s3c44b0_zdma_1_r )
1801	1801	{
1802	1802	UINT32 data = s3c44b0_zdma_r( device, 1, offset);
1803		verboselog( device->machine(), 9, "(ZDMA 1) %08X -> %08X\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data);
	1803	verboselog( space.machine(), 9, "(ZDMA 1) %08X -> %08X\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data);
1804	1804	return data;
1805	1805	}
1806	1806
1807	1807	static WRITE32_DEVICE_HANDLER( s3c44b0_zdma_0_w )
1808	1808	{
1809		verboselog( device->machine(), 9, "(ZDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data, mem_mask);
	1809	verboselog( space.machine(), 9, "(ZDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data, mem_mask);
1810	1810	s3c44b0_zdma_w( device, 0, offset, data, mem_mask);
1811	1811	}
1812	1812
1813	1813	static WRITE32_DEVICE_HANDLER( s3c44b0_zdma_1_w )
1814	1814	{
1815		verboselog( device->machine(), 9, "(ZDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data, mem_mask);
	1815	verboselog( space.machine(), 9, "(ZDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data, mem_mask);
1816	1816	s3c44b0_zdma_w( device, 1, offset, data, mem_mask);
1817	1817	}
1818	1818
r18055	r18056
1942	1942	static READ32_DEVICE_HANDLER( s3c44b0_bdma_0_r )
1943	1943	{
1944	1944	UINT32 data = s3c44b0_bdma_r( device, 0, offset);
1945		verboselog( device->machine(), 9, "(BDMA 0) %08X -> %08X\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data);
	1945	verboselog( space.machine(), 9, "(BDMA 0) %08X -> %08X\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data);
1946	1946	return data;
1947	1947	}
1948	1948
1949	1949	static READ32_DEVICE_HANDLER( s3c44b0_bdma_1_r )
1950	1950	{
1951	1951	UINT32 data = s3c44b0_bdma_r( device, 1, offset);
1952		verboselog( device->machine(), 9, "(BDMA 1) %08X -> %08X\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data);
	1952	verboselog( space.machine(), 9, "(BDMA 1) %08X -> %08X\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data);
1953	1953	return data;
1954	1954	}
1955	1955
1956	1956	static WRITE32_DEVICE_HANDLER( s3c44b0_bdma_0_w )
1957	1957	{
1958		verboselog( device->machine(), 9, "(BDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data, mem_mask);
	1958	verboselog( space.machine(), 9, "(BDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data, mem_mask);
1959	1959	s3c44b0_bdma_w( device, 0, offset, data, mem_mask);
1960	1960	}
1961	1961
1962	1962	static WRITE32_DEVICE_HANDLER( s3c44b0_bdma_1_w )
1963	1963	{
1964		verboselog( device->machine(), 9, "(BDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data, mem_mask);
	1964	verboselog( space.machine(), 9, "(BDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data, mem_mask);
1965	1965	s3c44b0_bdma_w( device, 1, offset, data, mem_mask);
1966	1966	}
1967	1967

trunk/src/mess/machine/mc68328.c

r18055	r18056
416	416	case 0x000:
417	417	if( mem_mask & 0x00ff )
418	418	{
419		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff001) = %02x\n", data & 0x00ff);
	419	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff001) = %02x\n", data & 0x00ff);
420	420	}
421	421	else
422	422	{
423		verboselog(device->machine(), 2, "mc68328_w: SCR = %02x\n", (data >> 8) & 0x00ff);
	423	verboselog(space.machine(), 2, "mc68328_w: SCR = %02x\n", (data >> 8) & 0x00ff);
424	424	}
425	425	break;
426	426
427	427	case 0x100:
428		verboselog(device->machine(), 2, "mc68328_w: GRPBASEA = %04x\n", data);
	428	verboselog(space.machine(), 2, "mc68328_w: GRPBASEA = %04x\n", data);
429	429	mc68328->regs.grpbasea = data;
430	430	break;
431	431
432	432	case 0x102:
433		verboselog(device->machine(), 2, "mc68328_w: GRPBASEB = %04x\n", data);
	433	verboselog(space.machine(), 2, "mc68328_w: GRPBASEB = %04x\n", data);
434	434	mc68328->regs.grpbaseb = data;
435	435	break;
436	436
437	437	case 0x104:
438		verboselog(device->machine(), 2, "mc68328_w: GRPBASEC = %04x\n", data);
	438	verboselog(space.machine(), 2, "mc68328_w: GRPBASEC = %04x\n", data);
439	439	mc68328->regs.grpbasec = data;
440	440	break;
441	441
442	442	case 0x106:
443		verboselog(device->machine(), 2, "mc68328_w: GRPBASED = %04x\n", data);
	443	verboselog(space.machine(), 2, "mc68328_w: GRPBASED = %04x\n", data);
444	444	mc68328->regs.grpbased = data;
445	445	break;
446	446
447	447	case 0x108:
448		verboselog(device->machine(), 2, "mc68328_w: GRPMASKA = %04x\n", data);
	448	verboselog(space.machine(), 2, "mc68328_w: GRPMASKA = %04x\n", data);
449	449	mc68328->regs.grpmaska = data;
450	450	break;
451	451
452	452	case 0x10a:
453		verboselog(device->machine(), 2, "mc68328_w: GRPMASKB = %04x\n", data);
	453	verboselog(space.machine(), 2, "mc68328_w: GRPMASKB = %04x\n", data);
454	454	mc68328->regs.grpmaskb = data;
455	455	break;
456	456
457	457	case 0x10c:
458		verboselog(device->machine(), 2, "mc68328_w: GRPMASKC = %04x\n", data);
	458	verboselog(space.machine(), 2, "mc68328_w: GRPMASKC = %04x\n", data);
459	459	mc68328->regs.grpmaskc = data;
460	460	break;
461	461
462	462	case 0x10e:
463		verboselog(device->machine(), 2, "mc68328_w: GRPMASKD = %04x\n", data);
	463	verboselog(space.machine(), 2, "mc68328_w: GRPMASKD = %04x\n", data);
464	464	mc68328->regs.grpmaskd = data;
465	465	break;
466	466
467	467	case 0x110:
468		verboselog(device->machine(), 5, "mc68328_w: CSA0(0) = %04x\n", data);
	468	verboselog(space.machine(), 5, "mc68328_w: CSA0(0) = %04x\n", data);
469	469	mc68328->regs.csa0 &= 0xffff0000 | (~mem_mask);
470	470	mc68328->regs.csa0 |= data & mem_mask;
471	471	break;
472	472
473	473	case 0x112:
474		verboselog(device->machine(), 5, "mc68328_w: CSA0(16) = %04x\n", data);
	474	verboselog(space.machine(), 5, "mc68328_w: CSA0(16) = %04x\n", data);
475	475	mc68328->regs.csa0 &= ~(mem_mask << 16);
476	476	mc68328->regs.csa0 |= (data & mem_mask) << 16;
477	477	break;
478	478
479	479	case 0x114:
480		verboselog(device->machine(), 5, "mc68328_w: CSA1(0) = %04x\n", data);
	480	verboselog(space.machine(), 5, "mc68328_w: CSA1(0) = %04x\n", data);
481	481	mc68328->regs.csa1 &= 0xffff0000 | (~mem_mask);
482	482	mc68328->regs.csa1 |= data & mem_mask;
483	483	break;
484	484
485	485	case 0x116:
486		verboselog(device->machine(), 5, "mc68328_w: CSA1(16) = %04x\n", data);
	486	verboselog(space.machine(), 5, "mc68328_w: CSA1(16) = %04x\n", data);
487	487	mc68328->regs.csa1 &= ~(mem_mask << 16);
488	488	mc68328->regs.csa1 |= (data & mem_mask) << 16;
489	489	break;
490	490
491	491	case 0x118:
492		verboselog(device->machine(), 5, "mc68328_w: CSA2(0) = %04x\n", data);
	492	verboselog(space.machine(), 5, "mc68328_w: CSA2(0) = %04x\n", data);
493	493	mc68328->regs.csa2 &= 0xffff0000 | (~mem_mask);
494	494	mc68328->regs.csa2 |= data & mem_mask;
495	495	break;
496	496
497	497	case 0x11a:
498		verboselog(device->machine(), 5, "mc68328_w: CSA2(16) = %04x\n", data);
	498	verboselog(space.machine(), 5, "mc68328_w: CSA2(16) = %04x\n", data);
499	499	mc68328->regs.csa2 &= ~(mem_mask << 16);
500	500	mc68328->regs.csa2 |= (data & mem_mask) << 16;
501	501	break;
502	502
503	503	case 0x11c:
504		verboselog(device->machine(), 5, "mc68328_w: CSA3(0) = %04x\n", data);
	504	verboselog(space.machine(), 5, "mc68328_w: CSA3(0) = %04x\n", data);
505	505	mc68328->regs.csa3 &= 0xffff0000 | (~mem_mask);
506	506	mc68328->regs.csa3 |= data & mem_mask;
507	507	break;
508	508
509	509	case 0x11e:
510		verboselog(device->machine(), 5, "mc68328_w: CSA3(16) = %04x\n", data);
	510	verboselog(space.machine(), 5, "mc68328_w: CSA3(16) = %04x\n", data);
511	511	mc68328->regs.csa3 &= ~(mem_mask << 16);
512	512	mc68328->regs.csa3 |= (data & mem_mask) << 16;
513	513	break;
514	514
515	515	case 0x120:
516		verboselog(device->machine(), 5, "mc68328_w: CSB0(0) = %04x\n", data);
	516	verboselog(space.machine(), 5, "mc68328_w: CSB0(0) = %04x\n", data);
517	517	mc68328->regs.csb0 &= 0xffff0000 | (~mem_mask);
518	518	mc68328->regs.csb0 |= data & mem_mask;
519	519	break;
520	520
521	521	case 0x122:
522		verboselog(device->machine(), 5, "mc68328_w: CSB0(16) = %04x\n", data);
	522	verboselog(space.machine(), 5, "mc68328_w: CSB0(16) = %04x\n", data);
523	523	mc68328->regs.csb0 &= ~(mem_mask << 16);
524	524	mc68328->regs.csb0 |= (data & mem_mask) << 16;
525	525	break;
526	526
527	527	case 0x124:
528		verboselog(device->machine(), 5, "mc68328_w: CSB1(0) = %04x\n", data);
	528	verboselog(space.machine(), 5, "mc68328_w: CSB1(0) = %04x\n", data);
529	529	mc68328->regs.csb1 &= 0xffff0000 | (~mem_mask);
530	530	mc68328->regs.csb1 |= data & mem_mask;
531	531	break;
532	532
533	533	case 0x126:
534		verboselog(device->machine(), 5, "mc68328_w: CSB1(16) = %04x\n", data);
	534	verboselog(space.machine(), 5, "mc68328_w: CSB1(16) = %04x\n", data);
535	535	mc68328->regs.csb1 &= ~(mem_mask << 16);
536	536	mc68328->regs.csb1 |= (data & mem_mask) << 16;
537	537	break;
538	538
539	539	case 0x128:
540		verboselog(device->machine(), 5, "mc68328_w: CSB2(0) = %04x\n", data);
	540	verboselog(space.machine(), 5, "mc68328_w: CSB2(0) = %04x\n", data);
541	541	mc68328->regs.csb2 &= 0xffff0000 | (~mem_mask);
542	542	mc68328->regs.csb2 |= data & mem_mask;
543	543	break;
544	544
545	545	case 0x12a:
546		verboselog(device->machine(), 5, "mc68328_w: CSB2(16) = %04x\n", data);
	546	verboselog(space.machine(), 5, "mc68328_w: CSB2(16) = %04x\n", data);
547	547	mc68328->regs.csb2 &= ~(mem_mask << 16);
548	548	mc68328->regs.csb2 |= (data & mem_mask) << 16;
549	549	break;
550	550
551	551	case 0x12c:
552		verboselog(device->machine(), 5, "mc68328_w: CSB3(0) = %04x\n", data);
	552	verboselog(space.machine(), 5, "mc68328_w: CSB3(0) = %04x\n", data);
553	553	mc68328->regs.csb3 &= 0xffff0000 | (~mem_mask);
554	554	mc68328->regs.csb3 |= data & mem_mask;
555	555	break;
556	556
557	557	case 0x12e:
558		verboselog(device->machine(), 5, "mc68328_w: CSB3(16) = %04x\n", data);
	558	verboselog(space.machine(), 5, "mc68328_w: CSB3(16) = %04x\n", data);
559	559	mc68328->regs.csb3 &= ~(mem_mask << 16);
560	560	mc68328->regs.csb3 |= (data & mem_mask) << 16;
561	561	break;
562	562
563	563	case 0x130:
564		verboselog(device->machine(), 5, "mc68328_w: CSC0(0) = %04x\n", data);
	564	verboselog(space.machine(), 5, "mc68328_w: CSC0(0) = %04x\n", data);
565	565	mc68328->regs.csc0 &= 0xffff0000 | (~mem_mask);
566	566	mc68328->regs.csc0 |= data & mem_mask;
567	567	break;
568	568
569	569	case 0x132:
570		verboselog(device->machine(), 5, "mc68328_w: CSC0(16) = %04x\n", data);
	570	verboselog(space.machine(), 5, "mc68328_w: CSC0(16) = %04x\n", data);
571	571	mc68328->regs.csc0 &= ~(mem_mask << 16);
572	572	mc68328->regs.csc0 |= (data & mem_mask) << 16;
573	573	break;
574	574
575	575	case 0x134:
576		verboselog(device->machine(), 5, "mc68328_w: CSC1(0) = %04x\n", data);
	576	verboselog(space.machine(), 5, "mc68328_w: CSC1(0) = %04x\n", data);
577	577	mc68328->regs.csc1 &= 0xffff0000 | (~mem_mask);
578	578	mc68328->regs.csc1 |= data & mem_mask;
579	579	break;
580	580
581	581	case 0x136:
582		verboselog(device->machine(), 5, "mc68328_w: CSC1(16) = %04x\n", data);
	582	verboselog(space.machine(), 5, "mc68328_w: CSC1(16) = %04x\n", data);
583	583	mc68328->regs.csc1 &= ~(mem_mask << 16);
584	584	mc68328->regs.csc1 |= (data & mem_mask) << 16;
585	585	break;
586	586
587	587	case 0x138:
588		verboselog(device->machine(), 5, "mc68328_w: CSC2(0) = %04x\n", data);
	588	verboselog(space.machine(), 5, "mc68328_w: CSC2(0) = %04x\n", data);
589	589	mc68328->regs.csc2 &= 0xffff0000 | (~mem_mask);
590	590	mc68328->regs.csc2 |= data & mem_mask;
591	591	break;
592	592
593	593	case 0x13a:
594		verboselog(device->machine(), 5, "mc68328_w: CSC2(16) = %04x\n", data);
	594	verboselog(space.machine(), 5, "mc68328_w: CSC2(16) = %04x\n", data);
595	595	mc68328->regs.csc2 &= ~(mem_mask << 16);
596	596	mc68328->regs.csc2 |= (data & mem_mask) << 16;
597	597	break;
598	598
599	599	case 0x13c:
600		verboselog(device->machine(), 5, "mc68328_w: CSC3(0) = %04x\n", data);
	600	verboselog(space.machine(), 5, "mc68328_w: CSC3(0) = %04x\n", data);
601	601	mc68328->regs.csc3 &= 0xffff0000 | (~mem_mask);
602	602	mc68328->regs.csc3 |= data & mem_mask;
603	603	break;
604	604
605	605	case 0x13e:
606		verboselog(device->machine(), 5, "mc68328_w: CSC3(16) = %04x\n", data);
	606	verboselog(space.machine(), 5, "mc68328_w: CSC3(16) = %04x\n", data);
607	607	mc68328->regs.csc3 &= ~(mem_mask << 16);
608	608	mc68328->regs.csc3 |= (data & mem_mask) << 16;
609	609	break;
610	610
611	611	case 0x140:
612		verboselog(device->machine(), 5, "mc68328_w: CSD0(0) = %04x\n", data);
	612	verboselog(space.machine(), 5, "mc68328_w: CSD0(0) = %04x\n", data);
613	613	mc68328->regs.csd0 &= 0xffff0000 | (~mem_mask);
614	614	mc68328->regs.csd0 |= data & mem_mask;
615	615	break;
616	616
617	617	case 0x142:
618		verboselog(device->machine(), 5, "mc68328_w: CSD0(16) = %04x\n", data);
	618	verboselog(space.machine(), 5, "mc68328_w: CSD0(16) = %04x\n", data);
619	619	mc68328->regs.csd0 &= ~(mem_mask << 16);
620	620	mc68328->regs.csd0 |= (data & mem_mask) << 16;
621	621	break;
622	622
623	623	case 0x144:
624		verboselog(device->machine(), 5, "mc68328_w: CSD1(0) = %04x\n", data);
	624	verboselog(space.machine(), 5, "mc68328_w: CSD1(0) = %04x\n", data);
625	625	mc68328->regs.csd1 &= 0xffff0000 | (~mem_mask);
626	626	mc68328->regs.csd1 |= data & mem_mask;
627	627	break;
628	628
629	629	case 0x146:
630		verboselog(device->machine(), 5, "mc68328_w: CSD1(16) = %04x\n", data);
	630	verboselog(space.machine(), 5, "mc68328_w: CSD1(16) = %04x\n", data);
631	631	mc68328->regs.csd1 &= ~(mem_mask << 16);
632	632	mc68328->regs.csd1 |= (data & mem_mask) << 16;
633	633	break;
634	634
635	635	case 0x148:
636		verboselog(device->machine(), 5, "mc68328_w: CSD2(0) = %04x\n", data);
	636	verboselog(space.machine(), 5, "mc68328_w: CSD2(0) = %04x\n", data);
637	637	mc68328->regs.csd2 &= 0xffff0000 | (~mem_mask);
638	638	mc68328->regs.csd2 |= data & mem_mask;
639	639	break;
640	640
641	641	case 0x14a:
642		verboselog(device->machine(), 5, "mc68328_w: CSD2(16) = %04x\n", data);
	642	verboselog(space.machine(), 5, "mc68328_w: CSD2(16) = %04x\n", data);
643	643	mc68328->regs.csd2 &= ~(mem_mask << 16);
644	644	mc68328->regs.csd2 |= (data & mem_mask) << 16;
645	645	break;
646	646
647	647	case 0x14c:
648		verboselog(device->machine(), 5, "mc68328_w: CSD3(0) = %04x\n", data);
	648	verboselog(space.machine(), 5, "mc68328_w: CSD3(0) = %04x\n", data);
649	649	mc68328->regs.csd3 &= 0xffff0000 | (~mem_mask);
650	650	mc68328->regs.csd3 |= data & mem_mask;
651	651	break;
652	652
653	653	case 0x14e:
654		verboselog(device->machine(), 5, "mc68328_w: CSD3(16) = %04x\n", data);
	654	verboselog(space.machine(), 5, "mc68328_w: CSD3(16) = %04x\n", data);
655	655	mc68328->regs.csd3 &= ~(mem_mask << 16);
656	656	mc68328->regs.csd3 |= (data & mem_mask) << 16;
657	657	break;
658	658
659	659	case 0x200:
660		verboselog(device->machine(), 2, "mc68328_w: PLLCR = %04x\n", data);
	660	verboselog(space.machine(), 2, "mc68328_w: PLLCR = %04x\n", data);
661	661	mc68328->regs.pllcr = data;
662	662	break;
663	663
664	664	case 0x202:
665		verboselog(device->machine(), 2, "mc68328_w: PLLFSR = %04x\n", data);
	665	verboselog(space.machine(), 2, "mc68328_w: PLLFSR = %04x\n", data);
666	666	mc68328->regs.pllfsr = data;
667	667	break;
668	668
669	669	case 0x206:
670	670	if( mem_mask & 0x00ff )
671	671	{
672		verboselog(device->machine(), 2, "mc68328_w: PCTLR = %02x\n", data & 0x00ff);
	672	verboselog(space.machine(), 2, "mc68328_w: PCTLR = %02x\n", data & 0x00ff);
673	673	mc68328->regs.pctlr = data & 0x00ff;
674	674	}
675	675	else
676	676	{
677		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff206) = %02x\n", (data >> 8) & 0x00ff);
	677	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff206) = %02x\n", (data >> 8) & 0x00ff);
678	678	}
679	679	break;
680	680
681	681	case 0x300:
682	682	if( mem_mask & 0x00ff )
683	683	{
684		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff301) = %02x\n", data & 0x00ff);
	684	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff301) = %02x\n", data & 0x00ff);
685	685	}
686	686	else
687	687	{
688		verboselog(device->machine(), 2, "mc68328_w: IVR = %02x\n", (data >> 8) & 0x00ff);
	688	verboselog(space.machine(), 2, "mc68328_w: IVR = %02x\n", (data >> 8) & 0x00ff);
689	689	mc68328->regs.ivr = (data >> 8) & 0x00ff;
690	690	}
691	691	break;
692	692
693	693	case 0x302:
694		verboselog(device->machine(), 2, "mc68328_w: ICR = %04x\n", data);
	694	verboselog(space.machine(), 2, "mc68328_w: ICR = %04x\n", data);
695	695	mc68328->regs.icr = data;
696	696	break;
697	697
698	698	case 0x304:
699		verboselog(device->machine(), 2, "mc68328_w: IMR(16) = %04x\n", data);
	699	verboselog(space.machine(), 2, "mc68328_w: IMR(16) = %04x\n", data);
700	700	mc68328->regs.imr &= ~(mem_mask << 16);
701	701	mc68328->regs.imr |= (data & mem_mask) << 16;
702	702	mc68328->regs.isr &= ~((data & mem_mask) << 16);
r18055	r18056
706	706	break;
707	707
708	708	case 0x306:
709		verboselog(device->machine(), 2, "mc68328_w: IMR(0) = %04x\n", data);
	709	verboselog(space.machine(), 2, "mc68328_w: IMR(0) = %04x\n", data);
710	710	mc68328->regs.imr &= 0xffff0000 | (~mem_mask);
711	711	mc68328->regs.imr |= data & mem_mask;
712	712	mc68328->regs.isr &= ~(data & mem_mask);
r18055	r18056
717	717
718	718	case 0x308:
719	719	{
720		verboselog(device->machine(), 2, "mc68328_w: IWR(16) = %04x\n", data);
	720	verboselog(space.machine(), 2, "mc68328_w: IWR(16) = %04x\n", data);
721	721	mc68328->regs.iwr &= ~(mem_mask << 16);
722	722	mc68328->regs.iwr |= (data & mem_mask) << 16;
723	723	}
724	724	break;
725	725
726	726	case 0x30a:
727		verboselog(device->machine(), 2, "mc68328_w: IWR(0) = %04x\n", data);
	727	verboselog(space.machine(), 2, "mc68328_w: IWR(0) = %04x\n", data);
728	728	mc68328->regs.iwr &= 0xffff0000 | (~mem_mask);
729	729	mc68328->regs.iwr |= data & mem_mask;
730	730	break;
731	731
732	732	case 0x30c:
733		verboselog(device->machine(), 2, "mc68328_w: ISR(16) = %04x\n", data);
	733	verboselog(space.machine(), 2, "mc68328_w: ISR(16) = %04x\n", data);
734	734	// Clear edge-triggered IRQ1
735	735	if((mc68328->regs.icr & ICR_ET1) == ICR_ET1 && (data & INT_IRQ1_SHIFT) == INT_IRQ1_SHIFT)
736	736	{
r18055	r18056
763	763	break;
764	764
765	765	case 0x30e:
766		verboselog(device->machine(), 2, "mc68328_w: ISR(0) = %04x (Ignored)\n", data);
	766	verboselog(space.machine(), 2, "mc68328_w: ISR(0) = %04x (Ignored)\n", data);
767	767	break;
768	768
769	769	case 0x310:
770		verboselog(device->machine(), 2, "mc68328_w: IPR(16) = %04x (Ignored)\n");
	770	verboselog(space.machine(), 2, "mc68328_w: IPR(16) = %04x (Ignored)\n");
771	771	break;
772	772
773	773	case 0x312:
774		verboselog(device->machine(), 2, "mc68328_w: IPR(0) = %04x (Ignored)\n");
	774	verboselog(space.machine(), 2, "mc68328_w: IPR(0) = %04x (Ignored)\n");
775	775	break;
776	776
777	777	case 0x400:
778	778	if( mem_mask & 0x00ff )
779	779	{
780		verboselog(device->machine(), 2, "mc68328_w: PADATA = %02x\n", data & 0x00ff);
	780	verboselog(space.machine(), 2, "mc68328_w: PADATA = %02x\n", data & 0x00ff);
781	781	mc68328->regs.padata = data & 0x00ff;
782	782	if(!mc68328->out_port_a.isnull())
783	783	{
r18055	r18056
786	786	}
787	787	else
788	788	{
789		verboselog(device->machine(), 2, "mc68328_w: PADIR = %02x\n", (data >> 8) & 0x00ff);
	789	verboselog(space.machine(), 2, "mc68328_w: PADIR = %02x\n", (data >> 8) & 0x00ff);
790	790	mc68328->regs.padir = (data >> 8) & 0x00ff;
791	791	}
792	792	break;
r18055	r18056
794	794	case 0x402:
795	795	if( mem_mask & 0x00ff )
796	796	{
797		verboselog(device->machine(), 2, "mc68328_w: PASEL = %02x\n", data & 0x00ff);
	797	verboselog(space.machine(), 2, "mc68328_w: PASEL = %02x\n", data & 0x00ff);
798	798	mc68328->regs.pasel = data & 0x00ff;
799	799	}
800	800	else
801	801	{
802		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff402) = %02x\n", (data >> 8) & 0x00ff);
	802	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff402) = %02x\n", (data >> 8) & 0x00ff);
803	803	}
804	804	break;
805	805
806	806	case 0x408:
807	807	if( mem_mask & 0x00ff )
808	808	{
809		verboselog(device->machine(), 2, "mc68328_w: PBDATA = %02x\n", data & 0x00ff);
	809	verboselog(space.machine(), 2, "mc68328_w: PBDATA = %02x\n", data & 0x00ff);
810	810	mc68328->regs.pbdata = data & 0x00ff;
811	811	if(!mc68328->out_port_b.isnull())
812	812	{
r18055	r18056
815	815	}
816	816	else
817	817	{
818		verboselog(device->machine(), 2, "mc68328_w: PBDIR = %02x\n", (data >> 8) & 0x00ff);
	818	verboselog(space.machine(), 2, "mc68328_w: PBDIR = %02x\n", (data >> 8) & 0x00ff);
819	819	mc68328->regs.pbdir = (data >> 8) & 0x00ff;
820	820	}
821	821	break;
r18055	r18056
823	823	case 0x40a:
824	824	if( mem_mask & 0x00ff )
825	825	{
826		verboselog(device->machine(), 2, "mc68328_w: PBSEL = %02x\n", data & 0x00ff);
	826	verboselog(space.machine(), 2, "mc68328_w: PBSEL = %02x\n", data & 0x00ff);
827	827	mc68328->regs.pbsel = data & 0x00ff;
828	828	}
829	829	else
830	830	{
831		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff40a) = %02x\n", (data >> 8) & 0x00ff);
	831	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff40a) = %02x\n", (data >> 8) & 0x00ff);
832	832	}
833	833	break;
834	834
835	835	case 0x410:
836	836	if( mem_mask & 0x00ff )
837	837	{
838		verboselog(device->machine(), 2, "mc68328_w: PCDATA = %02x\n", data & 0x00ff);
	838	verboselog(space.machine(), 2, "mc68328_w: PCDATA = %02x\n", data & 0x00ff);
839	839	mc68328->regs.pcdata = data & 0x00ff;
840	840	if(!mc68328->out_port_c.isnull())
841	841	{
r18055	r18056
844	844	}
845	845	else
846	846	{
847		verboselog(device->machine(), 2, "mc68328_w: PCDIR = %02x\n", (data >> 8) & 0x00ff);
	847	verboselog(space.machine(), 2, "mc68328_w: PCDIR = %02x\n", (data >> 8) & 0x00ff);
848	848	mc68328->regs.pcdir = (data >> 8) & 0x00ff;
849	849	}
850	850	break;
r18055	r18056
852	852	case 0x412:
853	853	if( mem_mask & 0x00ff )
854	854	{
855		verboselog(device->machine(), 2, "mc68328_w: PCSEL = %02x\n", data & 0x00ff);
	855	verboselog(space.machine(), 2, "mc68328_w: PCSEL = %02x\n", data & 0x00ff);
856	856	mc68328->regs.pcsel = data & 0x00ff;
857	857	}
858	858	else
859	859	{
860		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff412) = %02x\n", (data >> 8) & 0x00ff);
	860	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff412) = %02x\n", (data >> 8) & 0x00ff);
861	861	}
862	862	break;
863	863
864	864	case 0x418:
865	865	if( mem_mask & 0x00ff )
866	866	{
867		verboselog(device->machine(), 2, "mc68328_w: PDDATA = %02x\n", data & 0x00ff);
	867	verboselog(space.machine(), 2, "mc68328_w: PDDATA = %02x\n", data & 0x00ff);
868	868
869	869	mc68328->regs.pddataedge &= ~(data & 0x00ff);
870	870	mc68328_poll_port_d_interrupts(device);
871	871	}
872	872	else
873	873	{
874		verboselog(device->machine(), 2, "mc68328_w: PDDIR = %02x\n", (data >> 8) & 0x00ff);
	874	verboselog(space.machine(), 2, "mc68328_w: PDDIR = %02x\n", (data >> 8) & 0x00ff);
875	875	mc68328->regs.pddir = (data >> 8) & 0x00ff;
876	876	}
877	877	break;
r18055	r18056
879	879	case 0x41a:
880	880	if( mem_mask & 0x00ff )
881	881	{
882		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff41b) = %02x\n", data & 0x00ff);
	882	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff41b) = %02x\n", data & 0x00ff);
883	883	}
884	884	else
885	885	{
886		verboselog(device->machine(), 2, "mc68328_w: PDPUEN = %02x\n", (data >> 8) & 0x00ff);
	886	verboselog(space.machine(), 2, "mc68328_w: PDPUEN = %02x\n", (data >> 8) & 0x00ff);
887	887	mc68328->regs.pdpuen = (data >> 8) & 0x00ff;
888	888	}
889	889	break;
r18055	r18056
891	891	case 0x41c:
892	892	if( mem_mask & 0x00ff )
893	893	{
894		verboselog(device->machine(), 2, "mc68328_w: PDIRQEN = %02x\n", data & 0x00ff);
	894	verboselog(space.machine(), 2, "mc68328_w: PDIRQEN = %02x\n", data & 0x00ff);
895	895	mc68328->regs.pdirqen = data & 0x00ff;
896	896
897	897	mc68328_poll_port_d_interrupts(device);
898	898	}
899	899	else
900	900	{
901		verboselog(device->machine(), 2, "mc68328_w: PDPOL = %02x\n", (data >> 8) & 0x00ff);
	901	verboselog(space.machine(), 2, "mc68328_w: PDPOL = %02x\n", (data >> 8) & 0x00ff);
902	902	mc68328->regs.pdpol = (data >> 8) & 0x00ff;
903	903	}
904	904	break;
r18055	r18056
906	906	case 0x41e:
907	907	if( mem_mask & 0x00ff )
908	908	{
909		verboselog(device->machine(), 2, "mc68328_w: PDIRQEDGE = %02x\n", data & 0x00ff);
	909	verboselog(space.machine(), 2, "mc68328_w: PDIRQEDGE = %02x\n", data & 0x00ff);
910	910	mc68328->regs.pdirqedge = data & 0x00ff;
911	911	}
912	912	else
913	913	{
914		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff41e) = %02x\n", (data >> 8) & 0x00ff);
	914	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff41e) = %02x\n", (data >> 8) & 0x00ff);
915	915	}
916	916	break;
917	917
918	918	case 0x420:
919	919	if( mem_mask & 0x00ff )
920	920	{
921		verboselog(device->machine(), 2, "mc68328_w: PEDATA = %02x\n", data & 0x00ff);
	921	verboselog(space.machine(), 2, "mc68328_w: PEDATA = %02x\n", data & 0x00ff);
922	922	mc68328->regs.pedata = data & 0x00ff;
923	923	if(!mc68328->out_port_e.isnull())
924	924	{
r18055	r18056
927	927	}
928	928	else
929	929	{
930		verboselog(device->machine(), 2, "mc68328_w: PEDIR = %02x\n", (data >> 8) & 0x00ff);
	930	verboselog(space.machine(), 2, "mc68328_w: PEDIR = %02x\n", (data >> 8) & 0x00ff);
931	931	mc68328->regs.pedir = (data >> 8) & 0x00ff;
932	932	}
933	933	break;
r18055	r18056
935	935	case 0x422:
936	936	if( mem_mask & 0x00ff )
937	937	{
938		verboselog(device->machine(), 2, "mc68328_w: PESEL = %02x\n", data & 0x00ff);
	938	verboselog(space.machine(), 2, "mc68328_w: PESEL = %02x\n", data & 0x00ff);
939	939	mc68328->regs.pesel = data & 0x00ff;
940	940	}
941	941	else
942	942	{
943		verboselog(device->machine(), 2, "mc68328_w: PEPUEN = %02x\n", (data >> 8) & 0x00ff);
	943	verboselog(space.machine(), 2, "mc68328_w: PEPUEN = %02x\n", (data >> 8) & 0x00ff);
944	944	mc68328->regs.pepuen = (data >> 8) & 0x00ff;
945	945	mc68328->regs.pedata |= mc68328->regs.pepuen;
946	946	}
r18055	r18056
949	949	case 0x428:
950	950	if( mem_mask & 0x00ff )
951	951	{
952		verboselog(device->machine(), 2, "mc68328_w: PFDATA = %02x\n", data & 0x00ff);
	952	verboselog(space.machine(), 2, "mc68328_w: PFDATA = %02x\n", data & 0x00ff);
953	953	mc68328->regs.pfdata = data & 0x00ff;
954	954	if(!mc68328->out_port_f.isnull())
955	955	{
r18055	r18056
958	958	}
959	959	else
960	960	{
961		verboselog(device->machine(), 2, "mc68328_w: PFDIR = %02x\n", (data >> 8) & 0x00ff);
	961	verboselog(space.machine(), 2, "mc68328_w: PFDIR = %02x\n", (data >> 8) & 0x00ff);
962	962	mc68328->regs.pfdir = (data >> 8) & 0x00ff;
963	963	}
964	964	break;
r18055	r18056
966	966	case 0x42a:
967	967	if( mem_mask & 0x00ff )
968	968	{
969		verboselog(device->machine(), 2, "mc68328_w: PFSEL = %02x\n", data & 0x00ff);
	969	verboselog(space.machine(), 2, "mc68328_w: PFSEL = %02x\n", data & 0x00ff);
970	970	mc68328->regs.pfsel = data & 0x00ff;
971	971	}
972	972	else
973	973	{
974		verboselog(device->machine(), 2, "mc68328_w: PFPUEN = %02x\n", (data >> 8) & 0x00ff);
	974	verboselog(space.machine(), 2, "mc68328_w: PFPUEN = %02x\n", (data >> 8) & 0x00ff);
975	975	mc68328->regs.pfpuen = (data >> 8) & 0x00ff;
976	976	}
977	977	break;
r18055	r18056
979	979	case 0x430:
980	980	if( mem_mask & 0x00ff )
981	981	{
982		verboselog(device->machine(), 2, "mc68328_w: PGDATA = %02x\n", data & 0x00ff);
	982	verboselog(space.machine(), 2, "mc68328_w: PGDATA = %02x\n", data & 0x00ff);
983	983	mc68328->regs.pgdata = data & 0x00ff;
984	984	if(!mc68328->out_port_g.isnull())
985	985	{
r18055	r18056
988	988	}
989	989	else
990	990	{
991		verboselog(device->machine(), 2, "mc68328_w: PGDIR = %02x\n", (data >> 8) & 0x00ff);
	991	verboselog(space.machine(), 2, "mc68328_w: PGDIR = %02x\n", (data >> 8) & 0x00ff);
992	992	mc68328->regs.pgdir = (data >> 8) & 0x00ff;
993	993	}
994	994	break;
r18055	r18056
996	996	case 0x432:
997	997	if( mem_mask & 0x00ff )
998	998	{
999		verboselog(device->machine(), 2, "mc68328_w: PGSEL = %02x\n", data & 0x00ff);
	999	verboselog(space.machine(), 2, "mc68328_w: PGSEL = %02x\n", data & 0x00ff);
1000	1000	mc68328->regs.pgsel = data & 0x00ff;
1001	1001	}
1002	1002	else
1003	1003	{
1004		verboselog(device->machine(), 2, "mc68328_w: PGPUEN = %02x\n", (data >> 8) & 0x00ff);
	1004	verboselog(space.machine(), 2, "mc68328_w: PGPUEN = %02x\n", (data >> 8) & 0x00ff);
1005	1005	mc68328->regs.pgpuen = (data >> 8) & 0x00ff;
1006	1006	}
1007	1007	break;
r18055	r18056
1009	1009	case 0x438:
1010	1010	if( mem_mask & 0x00ff )
1011	1011	{
1012		verboselog(device->machine(), 2, "mc68328_w: PJDATA = %02x\n", data & 0x00ff);
	1012	verboselog(space.machine(), 2, "mc68328_w: PJDATA = %02x\n", data & 0x00ff);
1013	1013	mc68328->regs.pjdata = data & 0x00ff;
1014	1014	if(!mc68328->out_port_j.isnull())
1015	1015	{
r18055	r18056
1018	1018	}
1019	1019	else
1020	1020	{
1021		verboselog(device->machine(), 2, "mc68328_w: PJDIR = %02x\n", (data >> 8) & 0x00ff);
	1021	verboselog(space.machine(), 2, "mc68328_w: PJDIR = %02x\n", (data >> 8) & 0x00ff);
1022	1022	mc68328->regs.pjdir = (data >> 8) & 0x00ff;
1023	1023	}
1024	1024	break;
r18055	r18056
1026	1026	case 0x43a:
1027	1027	if( mem_mask & 0x00ff )
1028	1028	{
1029		verboselog(device->machine(), 2, "mc68328_w: PJSEL = %02x\n", data & 0x00ff);
	1029	verboselog(space.machine(), 2, "mc68328_w: PJSEL = %02x\n", data & 0x00ff);
1030	1030	mc68328->regs.pjsel = data & 0x00ff;
1031	1031	}
1032	1032	else
1033	1033	{
1034		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfff43a) = %02x\n", (data >> 8) & 0x00ff);
	1034	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfff43a) = %02x\n", (data >> 8) & 0x00ff);
1035	1035	}
1036	1036	break;
1037	1037
1038	1038	case 0x440:
1039	1039	if( mem_mask & 0x00ff )
1040	1040	{
1041		verboselog(device->machine(), 2, "mc68328_w: PKDATA = %02x\n", data & 0x00ff);
	1041	verboselog(space.machine(), 2, "mc68328_w: PKDATA = %02x\n", data & 0x00ff);
1042	1042	mc68328->regs.pkdata = data & 0x00ff;
1043	1043	if(!mc68328->out_port_k.isnull())
1044	1044	{
r18055	r18056
1047	1047	}
1048	1048	else
1049	1049	{
1050		verboselog(device->machine(), 2, "mc68328_w: PKDIR = %02x\n", (data >> 8) & 0x00ff);
	1050	verboselog(space.machine(), 2, "mc68328_w: PKDIR = %02x\n", (data >> 8) & 0x00ff);
1051	1051	mc68328->regs.pkdir = (data >> 8) & 0x00ff;
1052	1052	}
1053	1053	break;
r18055	r18056
1055	1055	case 0x442:
1056	1056	if( mem_mask & 0x00ff )
1057	1057	{
1058		verboselog(device->machine(), 2, "mc68328_w: PKSEL = %02x\n", data & 0x00ff);
	1058	verboselog(space.machine(), 2, "mc68328_w: PKSEL = %02x\n", data & 0x00ff);
1059	1059	mc68328->regs.pksel = data & 0x00ff;
1060	1060	}
1061	1061	else
1062	1062	{
1063		verboselog(device->machine(), 2, "mc68328_w: PKPUEN = %02x\n", (data >> 8) & 0x00ff);
	1063	verboselog(space.machine(), 2, "mc68328_w: PKPUEN = %02x\n", (data >> 8) & 0x00ff);
1064	1064	mc68328->regs.pgpuen = (data >> 8) & 0x00ff;
1065	1065	}
1066	1066	break;
r18055	r18056
1068	1068	case 0x448:
1069	1069	if( mem_mask & 0x00ff )
1070	1070	{
1071		verboselog(device->machine(), 2, "mc68328_w: PMDATA = %02x\n", data & 0x00ff);
	1071	verboselog(space.machine(), 2, "mc68328_w: PMDATA = %02x\n", data & 0x00ff);
1072	1072	mc68328->regs.pmdata = data & 0x00ff;
1073	1073	if(!mc68328->out_port_m.isnull())
1074	1074	{
r18055	r18056
1077	1077	}
1078	1078	else
1079	1079	{
1080		verboselog(device->machine(), 2, "mc68328_w: PMDIR = %02x\n", (data >> 8) & 0x00ff);
	1080	verboselog(space.machine(), 2, "mc68328_w: PMDIR = %02x\n", (data >> 8) & 0x00ff);
1081	1081	mc68328->regs.pmdir = (data >> 8) & 0x00ff;
1082	1082	}
1083	1083	break;
r18055	r18056
1085	1085	case 0x44a:
1086	1086	if( mem_mask & 0x00ff )
1087	1087	{
1088		verboselog(device->machine(), 2, "mc68328_w: PMSEL = %02x\n", data & 0x00ff);
	1088	verboselog(space.machine(), 2, "mc68328_w: PMSEL = %02x\n", data & 0x00ff);
1089	1089	mc68328->regs.pmsel = data & 0x00ff;
1090	1090	}
1091	1091	else
1092	1092	{
1093		verboselog(device->machine(), 2, "mc68328_w: PMPUEN = %02x\n", (data >> 8) & 0x00ff);
	1093	verboselog(space.machine(), 2, "mc68328_w: PMPUEN = %02x\n", (data >> 8) & 0x00ff);
1094	1094	mc68328->regs.pmpuen = (data >> 8) & 0x00ff;
1095	1095	}
1096	1096	break;
1097	1097
1098	1098	case 0x500:
1099		verboselog(device->machine(), 2, "mc68328_w: PWMC = %04x\n", data);
	1099	verboselog(space.machine(), 2, "mc68328_w: PWMC = %04x\n", data);
1100	1100
1101	1101	mc68328->regs.pwmc = data;
1102	1102
r18055	r18056
1128	1128	break;
1129	1129
1130	1130	case 0x502:
1131		verboselog(device->machine(), 2, "mc68328_w: PWMP = %04x\n", data);
	1131	verboselog(space.machine(), 2, "mc68328_w: PWMP = %04x\n", data);
1132	1132	mc68328->regs.pwmp = data;
1133	1133	break;
1134	1134
1135	1135	case 0x504:
1136		verboselog(device->machine(), 2, "mc68328_w: PWMW = %04x\n", data);
	1136	verboselog(space.machine(), 2, "mc68328_w: PWMW = %04x\n", data);
1137	1137	mc68328->regs.pwmw = data;
1138	1138	break;
1139	1139
1140	1140	case 0x506:
1141		verboselog(device->machine(), 2, "mc68328_w: PWMCNT = %04x\n", data);
	1141	verboselog(space.machine(), 2, "mc68328_w: PWMCNT = %04x\n", data);
1142	1142	mc68328->regs.pwmcnt = 0;
1143	1143	break;
1144	1144
1145	1145	case 0x600:
1146		verboselog(device->machine(), 2, "mc68328_w: TCTL1 = %04x\n", data);
	1146	verboselog(space.machine(), 2, "mc68328_w: TCTL1 = %04x\n", data);
1147	1147	temp16[0] = mc68328->regs.tctl[0];
1148	1148	mc68328->regs.tctl[0] = data;
1149	1149	if((temp16[0] & TCTL_TEN) == (mc68328->regs.tctl[0] & TCTL_TEN))
r18055	r18056
1157	1157	break;
1158	1158
1159	1159	case 0x602:
1160		verboselog(device->machine(), 2, "mc68328_w: TPRER1 = %04x\n", data);
	1160	verboselog(space.machine(), 2, "mc68328_w: TPRER1 = %04x\n", data);
1161	1161	mc68328->regs.tprer[0] = data;
1162	1162	mc68328_maybe_start_timer(device, 0, 0);
1163	1163	break;
1164	1164
1165	1165	case 0x604:
1166		verboselog(device->machine(), 2, "mc68328_w: TCMP1 = %04x\n", data);
	1166	verboselog(space.machine(), 2, "mc68328_w: TCMP1 = %04x\n", data);
1167	1167	mc68328->regs.tcmp[0] = data;
1168	1168	mc68328_maybe_start_timer(device, 0, 0);
1169	1169	break;
1170	1170
1171	1171	case 0x606:
1172		verboselog(device->machine(), 2, "mc68328_w: TCR1 = %04x (Ignored)\n", data);
	1172	verboselog(space.machine(), 2, "mc68328_w: TCR1 = %04x (Ignored)\n", data);
1173	1173	break;
1174	1174
1175	1175	case 0x608:
1176		verboselog(device->machine(), 2, "mc68328_w: TCN1 = %04x (Ignored)\n", data);
	1176	verboselog(space.machine(), 2, "mc68328_w: TCN1 = %04x (Ignored)\n", data);
1177	1177	break;
1178	1178
1179	1179	case 0x60a:
1180		verboselog(device->machine(), 5, "mc68328_w: TSTAT1 = %04x\n", data);
	1180	verboselog(space.machine(), 5, "mc68328_w: TSTAT1 = %04x\n", data);
1181	1181	mc68328->regs.tstat[0] &= ~mc68328->regs.tclear[0];
1182	1182	if(!(mc68328->regs.tstat[0] & TSTAT_COMP))
1183	1183	{
r18055	r18056
1186	1186	break;
1187	1187
1188	1188	case 0x60c:
1189		verboselog(device->machine(), 2, "mc68328_w: TCTL2 = %04x\n", data);
	1189	verboselog(space.machine(), 2, "mc68328_w: TCTL2 = %04x\n", data);
1190	1190	temp16[0] = mc68328->regs.tctl[1];
1191	1191	mc68328->regs.tctl[1] = data;
1192	1192	if((temp16[0] & TCTL_TEN) == (mc68328->regs.tctl[1] & TCTL_TEN))
r18055	r18056
1200	1200	break;
1201	1201
1202	1202	case 0x60e:
1203		verboselog(device->machine(), 2, "mc68328_w: TPRER2 = %04x\n", data);
	1203	verboselog(space.machine(), 2, "mc68328_w: TPRER2 = %04x\n", data);
1204	1204	mc68328->regs.tprer[1] = data;
1205	1205	mc68328_maybe_start_timer(device, 1, 0);
1206	1206	break;
1207	1207
1208	1208	case 0x610:
1209		verboselog(device->machine(), 2, "mc68328_w: TCMP2 = %04x\n", data);
	1209	verboselog(space.machine(), 2, "mc68328_w: TCMP2 = %04x\n", data);
1210	1210	mc68328->regs.tcmp[1] = data;
1211	1211	mc68328_maybe_start_timer(device, 1, 0);
1212	1212	break;
1213	1213
1214	1214	case 0x612:
1215		verboselog(device->machine(), 2, "mc68328_w: TCR2 = %04x (Ignored)\n", data);
	1215	verboselog(space.machine(), 2, "mc68328_w: TCR2 = %04x (Ignored)\n", data);
1216	1216	break;
1217	1217
1218	1218	case 0x614:
1219		verboselog(device->machine(), 2, "mc68328_w: TCN2 = %04x (Ignored)\n", data);
	1219	verboselog(space.machine(), 2, "mc68328_w: TCN2 = %04x (Ignored)\n", data);
1220	1220	break;
1221	1221
1222	1222	case 0x616:
1223		verboselog(device->machine(), 2, "mc68328_w: TSTAT2 = %04x\n", data);
	1223	verboselog(space.machine(), 2, "mc68328_w: TSTAT2 = %04x\n", data);
1224	1224	mc68328->regs.tstat[1] &= ~mc68328->regs.tclear[1];
1225	1225	if(!(mc68328->regs.tstat[1] & TSTAT_COMP))
1226	1226	{
r18055	r18056
1229	1229	break;
1230	1230
1231	1231	case 0x618:
1232		verboselog(device->machine(), 2, "mc68328_w: WCTLR = %04x\n", data);
	1232	verboselog(space.machine(), 2, "mc68328_w: WCTLR = %04x\n", data);
1233	1233	mc68328->regs.wctlr = data;
1234	1234	break;
1235	1235
1236	1236	case 0x61a:
1237		verboselog(device->machine(), 2, "mc68328_w: WCMPR = %04x\n", data);
	1237	verboselog(space.machine(), 2, "mc68328_w: WCMPR = %04x\n", data);
1238	1238	mc68328->regs.wcmpr = data;
1239	1239	break;
1240	1240
1241	1241	case 0x61c:
1242		verboselog(device->machine(), 2, "mc68328_w: WCN = %04x (Ignored)\n", data);
	1242	verboselog(space.machine(), 2, "mc68328_w: WCN = %04x (Ignored)\n", data);
1243	1243	break;
1244	1244
1245	1245	case 0x700:
1246		verboselog(device->machine(), 2, "mc68328_w: SPISR = %04x\n", data);
	1246	verboselog(space.machine(), 2, "mc68328_w: SPISR = %04x\n", data);
1247	1247	mc68328->regs.spisr = data;
1248	1248	break;
1249	1249
1250	1250	case 0x800:
1251		verboselog(device->machine(), 2, "mc68328_w: SPIMDATA = %04x\n", data);
	1251	verboselog(space.machine(), 2, "mc68328_w: SPIMDATA = %04x\n", data);
1252	1252	if(!mc68328->out_spim.isnull())
1253	1253	{
1254	1254	mc68328->out_spim( 0, data, 0xffff );
r18055	r18056
1260	1260	break;
1261	1261
1262	1262	case 0x802:
1263		verboselog(device->machine(), 2, "mc68328_w: SPIMCONT = %04x\n", data);
1264		verboselog(device->machine(), 3, "           Count = %d\n", data & SPIM_CLOCK_COUNT);
1265		verboselog(device->machine(), 3, "           Polarity = %s\n", (data & SPIM_POL) ? "Inverted" : "Active-high");
1266		verboselog(device->machine(), 3, "           Phase = %s\n", (data & SPIM_PHA) ? "Opposite" : "Normal");
1267		verboselog(device->machine(), 3, "           IRQ Enable = %s\n", (data & SPIM_IRQEN) ? "Enable" : "Disable");
1268		verboselog(device->machine(), 3, "           IRQ Pending = %s\n", (data & SPIM_SPIMIRQ) ? "Yes" : "No");
1269		verboselog(device->machine(), 3, "           Exchange = %s\n", (data & SPIM_XCH) ? "Initiate" : "Idle");
1270		verboselog(device->machine(), 3, "           SPIM Enable = %s\n", (data & SPIM_SPMEN) ? "Enable" : "Disable");
1271		verboselog(device->machine(), 3, "           Data Rate = Divide By %d\n", 1 << ((((data & SPIM_RATE) >> 13) & 0x0007) + 2) );
	1263	verboselog(space.machine(), 2, "mc68328_w: SPIMCONT = %04x\n", data);
	1264	verboselog(space.machine(), 3, "           Count = %d\n", data & SPIM_CLOCK_COUNT);
	1265	verboselog(space.machine(), 3, "           Polarity = %s\n", (data & SPIM_POL) ? "Inverted" : "Active-high");
	1266	verboselog(space.machine(), 3, "           Phase = %s\n", (data & SPIM_PHA) ? "Opposite" : "Normal");
	1267	verboselog(space.machine(), 3, "           IRQ Enable = %s\n", (data & SPIM_IRQEN) ? "Enable" : "Disable");
	1268	verboselog(space.machine(), 3, "           IRQ Pending = %s\n", (data & SPIM_SPIMIRQ) ? "Yes" : "No");
	1269	verboselog(space.machine(), 3, "           Exchange = %s\n", (data & SPIM_XCH) ? "Initiate" : "Idle");
	1270	verboselog(space.machine(), 3, "           SPIM Enable = %s\n", (data & SPIM_SPMEN) ? "Enable" : "Disable");
	1271	verboselog(space.machine(), 3, "           Data Rate = Divide By %d\n", 1 << ((((data & SPIM_RATE) >> 13) & 0x0007) + 2) );
1272	1272	mc68328->regs.spimcont = data;
1273	1273	// $$HACK$$ We should probably emulate the ADS7843 A/D device properly.
1274	1274	if(data & SPIM_XCH)
r18055	r18056
1281	1281	if(data & SPIM_IRQEN)
1282	1282	{
1283	1283	mc68328->regs.spimcont |= SPIM_SPIMIRQ;
1284		verboselog(device->machine(), 3, "Triggering SPIM Interrupt\n" );
	1284	verboselog(space.machine(), 3, "Triggering SPIM Interrupt\n" );
1285	1285	mc68328_set_interrupt_line(device, INT_SPIM, 1);
1286	1286	}
1287	1287	}
r18055	r18056
1292	1292	break;
1293	1293
1294	1294	case 0x900:
1295		verboselog(device->machine(), 2, "mc68328_w: USTCNT = %04x\n", data);
	1295	verboselog(space.machine(), 2, "mc68328_w: USTCNT = %04x\n", data);
1296	1296	mc68328->regs.ustcnt = data;
1297	1297	break;
1298	1298
1299	1299	case 0x902:
1300		verboselog(device->machine(), 2, "mc68328_w: UBAUD = %04x\n", data);
	1300	verboselog(space.machine(), 2, "mc68328_w: UBAUD = %04x\n", data);
1301	1301	mc68328->regs.ubaud = data;
1302	1302	break;
1303	1303
1304	1304	case 0x904:
1305		verboselog(device->machine(), 2, "mc68328_w: URX = %04x\n", data);
	1305	verboselog(space.machine(), 2, "mc68328_w: URX = %04x\n", data);
1306	1306	break;
1307	1307
1308	1308	case 0x906:
1309		verboselog(device->machine(), 2, "mc68328_w: UTX = %04x\n", data);
	1309	verboselog(space.machine(), 2, "mc68328_w: UTX = %04x\n", data);
1310	1310	break;
1311	1311
1312	1312	case 0x908:
1313		verboselog(device->machine(), 2, "mc68328_w: UMISC = %04x\n", data);
	1313	verboselog(space.machine(), 2, "mc68328_w: UMISC = %04x\n", data);
1314	1314	mc68328->regs.umisc = data;
1315	1315	break;
1316	1316
1317	1317	case 0xa00:
1318		verboselog(device->machine(), 2, "mc68328_w: LSSA(16) = %04x\n", data);
	1318	verboselog(space.machine(), 2, "mc68328_w: LSSA(16) = %04x\n", data);
1319	1319	mc68328->regs.lssa &= ~(mem_mask << 16);
1320	1320	mc68328->regs.lssa |= (data & mem_mask) << 16;
1321		verboselog(device->machine(), 3, "              Address: %08x\n", mc68328->regs.lssa);
	1321	verboselog(space.machine(), 3, "              Address: %08x\n", mc68328->regs.lssa);
1322	1322	break;
1323	1323
1324	1324	case 0xa02:
1325		verboselog(device->machine(), 2, "mc68328_w: LSSA(0) = %04x\n", data);
	1325	verboselog(space.machine(), 2, "mc68328_w: LSSA(0) = %04x\n", data);
1326	1326	mc68328->regs.lssa &= 0xffff0000 | (~mem_mask);
1327	1327	mc68328->regs.lssa |= data & mem_mask;
1328		verboselog(device->machine(), 3, "              Address: %08x\n", mc68328->regs.lssa);
	1328	verboselog(space.machine(), 3, "              Address: %08x\n", mc68328->regs.lssa);
1329	1329	break;
1330	1330
1331	1331	case 0xa04:
1332	1332	if( mem_mask & 0x00ff )
1333	1333	{
1334		verboselog(device->machine(), 2, "mc68328_w: LVPW = %02x\n", data & 0x00ff);
	1334	verboselog(space.machine(), 2, "mc68328_w: LVPW = %02x\n", data & 0x00ff);
1335	1335	mc68328->regs.lvpw = data & 0x00ff;
1336		verboselog(device->machine(), 3, "              Page Width: %d or %d\n", (mc68328->regs.lvpw + 1) * ((mc68328->regs.lpicf & 0x01) ? 8 : 16));
	1336	verboselog(space.machine(), 3, "              Page Width: %d or %d\n", (mc68328->regs.lvpw + 1) * ((mc68328->regs.lpicf & 0x01) ? 8 : 16));
1337	1337	}
1338	1338	else
1339	1339	{
1340		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa04) = %02x\n", (data >> 8) & 0x00ff);
	1340	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa04) = %02x\n", (data >> 8) & 0x00ff);
1341	1341	}
1342	1342	break;
1343	1343
1344	1344	case 0xa08:
1345		verboselog(device->machine(), 2, "mc68328_w: LXMAX = %04x\n", data);
	1345	verboselog(space.machine(), 2, "mc68328_w: LXMAX = %04x\n", data);
1346	1346	mc68328->regs.lxmax = data;
1347		verboselog(device->machine(), 3, "              Width: %d\n", (data & 0x03ff) + 1);
	1347	verboselog(space.machine(), 3, "              Width: %d\n", (data & 0x03ff) + 1);
1348	1348	break;
1349	1349
1350	1350	case 0xa0a:
1351		verboselog(device->machine(), 2, "mc68328_w: LYMAX = %04x\n", data);
	1351	verboselog(space.machine(), 2, "mc68328_w: LYMAX = %04x\n", data);
1352	1352	mc68328->regs.lymax = data;
1353		verboselog(device->machine(), 3, "              Height: %d\n", (data & 0x03ff) + 1);
	1353	verboselog(space.machine(), 3, "              Height: %d\n", (data & 0x03ff) + 1);
1354	1354	break;
1355	1355
1356	1356	case 0xa18:
1357		verboselog(device->machine(), 2, "mc68328_w: LCXP = %04x\n", data);
	1357	verboselog(space.machine(), 2, "mc68328_w: LCXP = %04x\n", data);
1358	1358	mc68328->regs.lcxp = data;
1359		verboselog(device->machine(), 3, "              X Position: %d\n", data & 0x03ff);
	1359	verboselog(space.machine(), 3, "              X Position: %d\n", data & 0x03ff);
1360	1360	switch(mc68328->regs.lcxp >> 14)
1361	1361	{
1362	1362	case 0:
1363		verboselog(device->machine(), 3, "              Cursor Control: Transparent\n");
	1363	verboselog(space.machine(), 3, "              Cursor Control: Transparent\n");
1364	1364	break;
1365	1365
1366	1366	case 1:
1367		verboselog(device->machine(), 3, "              Cursor Control: Black\n");
	1367	verboselog(space.machine(), 3, "              Cursor Control: Black\n");
1368	1368	break;
1369	1369
1370	1370	case 2:
1371		verboselog(device->machine(), 3, "              Cursor Control: Reverse\n");
	1371	verboselog(space.machine(), 3, "              Cursor Control: Reverse\n");
1372	1372	break;
1373	1373
1374	1374	case 3:
1375		verboselog(device->machine(), 3, "              Cursor Control: Invalid\n");
	1375	verboselog(space.machine(), 3, "              Cursor Control: Invalid\n");
1376	1376	break;
1377	1377	}
1378	1378	break;
1379	1379
1380	1380	case 0xa1a:
1381		verboselog(device->machine(), 2, "mc68328_w: LCYP = %04x\n", data);
	1381	verboselog(space.machine(), 2, "mc68328_w: LCYP = %04x\n", data);
1382	1382	mc68328->regs.lcyp = data;
1383		verboselog(device->machine(), 3, "              Y Position: %d\n", data & 0x01ff);
	1383	verboselog(space.machine(), 3, "              Y Position: %d\n", data & 0x01ff);
1384	1384	break;
1385	1385
1386	1386	case 0xa1c:
1387		verboselog(device->machine(), 2, "mc68328_w: LCWCH = %04x\n", data);
	1387	verboselog(space.machine(), 2, "mc68328_w: LCWCH = %04x\n", data);
1388	1388	mc68328->regs.lcwch = data;
1389		verboselog(device->machine(), 3, "              Width:  %d\n", (data >> 8) & 0x1f);
1390		verboselog(device->machine(), 3, "              Height: %d\n", data & 0x1f);
	1389	verboselog(space.machine(), 3, "              Width:  %d\n", (data >> 8) & 0x1f);
	1390	verboselog(space.machine(), 3, "              Height: %d\n", data & 0x1f);
1391	1391	break;
1392	1392
1393	1393	case 0xa1e:
1394	1394	if( mem_mask & 0x00ff )
1395	1395	{
1396		verboselog(device->machine(), 2, "mc68328_w: LBLKC = %02x\n", data & 0x00ff);
	1396	verboselog(space.machine(), 2, "mc68328_w: LBLKC = %02x\n", data & 0x00ff);
1397	1397	mc68328->regs.lblkc = data & 0x00ff;
1398		verboselog(device->machine(), 3, "              Blink Enable:  %d\n", mc68328->regs.lblkc >> 7);
1399		verboselog(device->machine(), 3, "              Blink Divisor: %d\n", mc68328->regs.lblkc & 0x7f);
	1398	verboselog(space.machine(), 3, "              Blink Enable:  %d\n", mc68328->regs.lblkc >> 7);
	1399	verboselog(space.machine(), 3, "              Blink Divisor: %d\n", mc68328->regs.lblkc & 0x7f);
1400	1400	}
1401	1401	else
1402	1402	{
1403		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa1e) = %02x\n", (data >> 8) & 0x00ff);
	1403	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa1e) = %02x\n", (data >> 8) & 0x00ff);
1404	1404	}
1405	1405	break;
1406	1406
1407	1407	case 0xa20:
1408	1408	if( mem_mask & 0x00ff )
1409	1409	{
1410		verboselog(device->machine(), 2, "mc68328_w: LPOLCF = %02x\n", data & 0x00ff);
	1410	verboselog(space.machine(), 2, "mc68328_w: LPOLCF = %02x\n", data & 0x00ff);
1411	1411	mc68328->regs.lpolcf = data & 0x00ff;
1412		verboselog(device->machine(), 3, "              LCD Shift Clock Polarity: %s\n", (mc68328->regs.lpicf & 0x08) ? "Active positive edge of LCLK" : "Active negative edge of LCLK");
1413		verboselog(device->machine(), 3, "              First-line marker polarity: %s\n", (mc68328->regs.lpicf & 0x04) ? "Active Low" : "Active High");
1414		verboselog(device->machine(), 3, "              Line-pulse polarity: %s\n", (mc68328->regs.lpicf & 0x02) ? "Active Low" : "Active High");
1415		verboselog(device->machine(), 3, "              Pixel polarity: %s\n", (mc68328->regs.lpicf & 0x01) ? "Active Low" : "Active High");
	1412	verboselog(space.machine(), 3, "              LCD Shift Clock Polarity: %s\n", (mc68328->regs.lpicf & 0x08) ? "Active positive edge of LCLK" : "Active negative edge of LCLK");
	1413	verboselog(space.machine(), 3, "              First-line marker polarity: %s\n", (mc68328->regs.lpicf & 0x04) ? "Active Low" : "Active High");
	1414	verboselog(space.machine(), 3, "              Line-pulse polarity: %s\n", (mc68328->regs.lpicf & 0x02) ? "Active Low" : "Active High");
	1415	verboselog(space.machine(), 3, "              Pixel polarity: %s\n", (mc68328->regs.lpicf & 0x01) ? "Active Low" : "Active High");
1416	1416	}
1417	1417	else
1418	1418	{
1419		verboselog(device->machine(), 2, "mc68328_w: LPICF = %02x\n", (data >> 8) & 0x00ff);
	1419	verboselog(space.machine(), 2, "mc68328_w: LPICF = %02x\n", (data >> 8) & 0x00ff);
1420	1420	mc68328->regs.lpicf = (data >> 8) & 0x00ff;
1421	1421	switch((mc68328->regs.lpicf >> 1) & 0x03)
1422	1422	{
1423	1423	case 0:
1424		verboselog(device->machine(), 3, "              Bus Size: 1-bit\n");
	1424	verboselog(space.machine(), 3, "              Bus Size: 1-bit\n");
1425	1425	break;
1426	1426
1427	1427	case 1:
1428		verboselog(device->machine(), 3, "              Bus Size: 2-bit\n");
	1428	verboselog(space.machine(), 3, "              Bus Size: 2-bit\n");
1429	1429	break;
1430	1430
1431	1431	case 2:
1432		verboselog(device->machine(), 3, "              Bus Size: 4-bit\n");
	1432	verboselog(space.machine(), 3, "              Bus Size: 4-bit\n");
1433	1433	break;
1434	1434
1435	1435	case 3:
1436		verboselog(device->machine(), 3, "              Bus Size: unused\n");
	1436	verboselog(space.machine(), 3, "              Bus Size: unused\n");
1437	1437	break;
1438	1438	}
1439		verboselog(device->machine(), 3, "              Gray scale enable: %d\n", mc68328->regs.lpicf & 0x01);
	1439	verboselog(space.machine(), 3, "              Gray scale enable: %d\n", mc68328->regs.lpicf & 0x01);
1440	1440	}
1441	1441	break;
1442	1442
1443	1443	case 0xa22:
1444	1444	if( mem_mask & 0x00ff )
1445	1445	{
1446		verboselog(device->machine(), 2, "mc68328_w: LACDRC = %02x\n", data & 0x00ff);
	1446	verboselog(space.machine(), 2, "mc68328_w: LACDRC = %02x\n", data & 0x00ff);
1447	1447	mc68328->regs.lacdrc = data & 0x00ff;
1448	1448	}
1449	1449	else
1450	1450	{
1451		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa22) = %02x\n", (data >> 8) & 0x00ff);
	1451	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa22) = %02x\n", (data >> 8) & 0x00ff);
1452	1452	}
1453	1453	break;
1454	1454
1455	1455	case 0xa24:
1456	1456	if( mem_mask & 0x00ff )
1457	1457	{
1458		verboselog(device->machine(), 2, "mc68328_w: LPXCD = %02x\n", data & 0x00ff);
	1458	verboselog(space.machine(), 2, "mc68328_w: LPXCD = %02x\n", data & 0x00ff);
1459	1459	mc68328->regs.lpxcd = data & 0x00ff;
1460		verboselog(device->machine(), 3, "              Clock Divisor: %d\n", mc68328->regs.lpxcd + 1);
	1460	verboselog(space.machine(), 3, "              Clock Divisor: %d\n", mc68328->regs.lpxcd + 1);
1461	1461	}
1462	1462	else
1463	1463	{
1464		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa24) = %02x\n", (data >> 8) & 0x00ff);
	1464	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa24) = %02x\n", (data >> 8) & 0x00ff);
1465	1465	}
1466	1466	break;
1467	1467
1468	1468	case 0xa26:
1469	1469	if( mem_mask & 0x00ff )
1470	1470	{
1471		verboselog(device->machine(), 2, "mc68328_w: LCKCON = %02x\n", data & 0x00ff);
	1471	verboselog(space.machine(), 2, "mc68328_w: LCKCON = %02x\n", data & 0x00ff);
1472	1472	mc68328->regs.lckcon = data & 0x00ff;
1473		verboselog(device->machine(), 3, "              LCDC Enable: %d\n", (mc68328->regs.lckcon >> 7) & 0x01);
1474		verboselog(device->machine(), 3, "              DMA Burst Length: %d\n", ((mc68328->regs.lckcon >> 6) & 0x01) ? 16 : 8);
1475		verboselog(device->machine(), 3, "              DMA Bursting Clock Control: %d\n", ((mc68328->regs.lckcon >> 4) & 0x03) + 1);
1476		verboselog(device->machine(), 3, "              Bus Width: %d\n", ((mc68328->regs.lckcon >> 1) & 0x01) ? 8 : 16);
1477		verboselog(device->machine(), 3, "              Pixel Clock Divider Source: %s\n", (mc68328->regs.lckcon & 0x01) ? "PIX" : "SYS");
	1473	verboselog(space.machine(), 3, "              LCDC Enable: %d\n", (mc68328->regs.lckcon >> 7) & 0x01);
	1474	verboselog(space.machine(), 3, "              DMA Burst Length: %d\n", ((mc68328->regs.lckcon >> 6) & 0x01) ? 16 : 8);
	1475	verboselog(space.machine(), 3, "              DMA Bursting Clock Control: %d\n", ((mc68328->regs.lckcon >> 4) & 0x03) + 1);
	1476	verboselog(space.machine(), 3, "              Bus Width: %d\n", ((mc68328->regs.lckcon >> 1) & 0x01) ? 8 : 16);
	1477	verboselog(space.machine(), 3, "              Pixel Clock Divider Source: %s\n", (mc68328->regs.lckcon & 0x01) ? "PIX" : "SYS");
1478	1478	}
1479	1479	else
1480	1480	{
1481		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa26) = %02x\n", (data >> 8) & 0x00ff);
	1481	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa26) = %02x\n", (data >> 8) & 0x00ff);
1482	1482	}
1483	1483	break;
1484	1484
1485	1485	case 0xa28:
1486	1486	if( mem_mask & 0x00ff )
1487	1487	{
1488		verboselog(device->machine(), 2, "mc68328_w: LLBAR = %02x\n", data & 0x00ff);
	1488	verboselog(space.machine(), 2, "mc68328_w: LLBAR = %02x\n", data & 0x00ff);
1489	1489	mc68328->regs.llbar = data & 0x00ff;
1490		verboselog(device->machine(), 3, "              Address: %d\n", (mc68328->regs.llbar & 0x7f) * ((mc68328->regs.lpicf & 0x01) ? 8 : 16));
	1490	verboselog(space.machine(), 3, "              Address: %d\n", (mc68328->regs.llbar & 0x7f) * ((mc68328->regs.lpicf & 0x01) ? 8 : 16));
1491	1491	}
1492	1492	else
1493	1493	{
1494		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa28) = %02x\n", (data >> 8) & 0x00ff);
	1494	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa28) = %02x\n", (data >> 8) & 0x00ff);
1495	1495	}
1496	1496	break;
1497	1497
1498	1498	case 0xa2a:
1499	1499	if( mem_mask & 0x00ff )
1500	1500	{
1501		verboselog(device->machine(), 2, "mc68328_w: LOTCR = %02x\n", data & 0x00ff);
	1501	verboselog(space.machine(), 2, "mc68328_w: LOTCR = %02x\n", data & 0x00ff);
1502	1502	}
1503	1503	else
1504	1504	{
1505		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa2a) = %02x\n", (data >> 8) & 0x00ff);
	1505	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa2a) = %02x\n", (data >> 8) & 0x00ff);
1506	1506	}
1507	1507	break;
1508	1508
1509	1509	case 0xa2c:
1510	1510	if( mem_mask & 0x00ff )
1511	1511	{
1512		verboselog(device->machine(), 2, "mc68328_w: LPOSR = %02x\n", data & 0x00ff);
	1512	verboselog(space.machine(), 2, "mc68328_w: LPOSR = %02x\n", data & 0x00ff);
1513	1513	mc68328->regs.lposr = data & 0x00ff;
1514		verboselog(device->machine(), 3, "              Byte Offset: %d\n", (mc68328->regs.lposr >> 3) & 0x01);
1515		verboselog(device->machine(), 3, "              Pixel Offset: %d\n", mc68328->regs.lposr & 0x07);
	1514	verboselog(space.machine(), 3, "              Byte Offset: %d\n", (mc68328->regs.lposr >> 3) & 0x01);
	1515	verboselog(space.machine(), 3, "              Pixel Offset: %d\n", mc68328->regs.lposr & 0x07);
1516	1516	}
1517	1517	else
1518	1518	{
1519		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa2c) = %02x\n", (data >> 8) & 0x00ff);
	1519	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa2c) = %02x\n", (data >> 8) & 0x00ff);
1520	1520	}
1521	1521	break;
1522	1522
1523	1523	case 0xa30:
1524	1524	if( mem_mask & 0x00ff )
1525	1525	{
1526		verboselog(device->machine(), 2, "mc68328_w: LFRCM = %02x\n", data & 0x00ff);
	1526	verboselog(space.machine(), 2, "mc68328_w: LFRCM = %02x\n", data & 0x00ff);
1527	1527	mc68328->regs.lfrcm = data & 0x00ff;
1528		verboselog(device->machine(), 3, "              X Modulation: %d\n", (mc68328->regs.lfrcm >> 4) & 0x0f);
1529		verboselog(device->machine(), 3, "              Y Modulation: %d\n", mc68328->regs.lfrcm & 0x0f);
	1528	verboselog(space.machine(), 3, "              X Modulation: %d\n", (mc68328->regs.lfrcm >> 4) & 0x0f);
	1529	verboselog(space.machine(), 3, "              Y Modulation: %d\n", mc68328->regs.lfrcm & 0x0f);
1530	1530	}
1531	1531	else
1532	1532	{
1533		verboselog(device->machine(), 2, "mc68328_w: Unknown address (0xfffa30) = %02x\n", (data >> 8) & 0x00ff);
	1533	verboselog(space.machine(), 2, "mc68328_w: Unknown address (0xfffa30) = %02x\n", (data >> 8) & 0x00ff);
1534	1534	}
1535	1535	break;
1536	1536
1537	1537	case 0xa32:
1538		verboselog(device->machine(), 2, "mc68328_w: LGPMR = %04x\n", data);
	1538	verboselog(space.machine(), 2, "mc68328_w: LGPMR = %04x\n", data);
1539	1539	mc68328->regs.lgpmr = data;
1540		verboselog(device->machine(), 3, "              Palette 0: %d\n", (mc68328->regs.lgpmr >>  8) & 0x07);
1541		verboselog(device->machine(), 3, "              Palette 1: %d\n", (mc68328->regs.lgpmr >> 12) & 0x07);
1542		verboselog(device->machine(), 3, "              Palette 2: %d\n", (mc68328->regs.lgpmr >>  0) & 0x07);
1543		verboselog(device->machine(), 3, "              Palette 3: %d\n", (mc68328->regs.lgpmr >>  4) & 0x07);
	1540	verboselog(space.machine(), 3, "              Palette 0: %d\n", (mc68328->regs.lgpmr >>  8) & 0x07);
	1541	verboselog(space.machine(), 3, "              Palette 1: %d\n", (mc68328->regs.lgpmr >> 12) & 0x07);
	1542	verboselog(space.machine(), 3, "              Palette 2: %d\n", (mc68328->regs.lgpmr >>  0) & 0x07);
	1543	verboselog(space.machine(), 3, "              Palette 3: %d\n", (mc68328->regs.lgpmr >>  4) & 0x07);
1544	1544	break;
1545	1545
1546	1546	case 0xb00:
1547		verboselog(device->machine(), 2, "mc68328_w: HMSR(0) = %04x\n", data);
	1547	verboselog(space.machine(), 2, "mc68328_w: HMSR(0) = %04x\n", data);
1548	1548	mc68328->regs.hmsr &= ~(mem_mask << 16);
1549	1549	mc68328->regs.hmsr |= (data & mem_mask) << 16;
1550	1550	mc68328->regs.hmsr &= 0x1f3f003f;
1551	1551	break;
1552	1552
1553	1553	case 0xb02:
1554		verboselog(device->machine(), 2, "mc68328_w: HMSR(16) = %04x\n", data);
	1554	verboselog(space.machine(), 2, "mc68328_w: HMSR(16) = %04x\n", data);
1555	1555	mc68328->regs.hmsr &= 0xffff0000 | (~mem_mask);
1556	1556	mc68328->regs.hmsr |= data & mem_mask;
1557	1557	mc68328->regs.hmsr &= 0x1f3f003f;
1558	1558	break;
1559	1559
1560	1560	case 0xb04:
1561		verboselog(device->machine(), 2, "mc68328_w: ALARM(0) = %04x\n", data);
	1561	verboselog(space.machine(), 2, "mc68328_w: ALARM(0) = %04x\n", data);
1562	1562	mc68328->regs.alarm &= ~(mem_mask << 16);
1563	1563	mc68328->regs.alarm |= (data & mem_mask) << 16;
1564	1564	mc68328->regs.alarm &= 0x1f3f003f;
1565	1565	break;
1566	1566
1567	1567	case 0xb06:
1568		verboselog(device->machine(), 2, "mc68328_w: ALARM(16) = %04x\n", data);
	1568	verboselog(space.machine(), 2, "mc68328_w: ALARM(16) = %04x\n", data);
1569	1569	mc68328->regs.alarm &= 0xffff0000 | (~mem_mask);
1570	1570	mc68328->regs.alarm |= data & mem_mask;
1571	1571	mc68328->regs.alarm &= 0x1f3f003f;
1572	1572	break;
1573	1573
1574	1574	case 0xb0c:
1575		verboselog(device->machine(), 2, "mc68328_w: RTCCTL = %04x\n", data);
	1575	verboselog(space.machine(), 2, "mc68328_w: RTCCTL = %04x\n", data);
1576	1576	mc68328->regs.rtcctl = data & 0x00a0;
1577	1577	break;
1578	1578
1579	1579	case 0xb0e:
1580		verboselog(device->machine(), 2, "mc68328_w: RTCISR = %04x\n", data);
	1580	verboselog(space.machine(), 2, "mc68328_w: RTCISR = %04x\n", data);
1581	1581	mc68328->regs.rtcisr &= ~data;
1582	1582	if(mc68328->regs.rtcisr == 0)
1583	1583	{
r18055	r18056
1586	1586	break;
1587	1587
1588	1588	case 0xb10:
1589		verboselog(device->machine(), 2, "mc68328_w: RTCIENR = %04x\n", data);
	1589	verboselog(space.machine(), 2, "mc68328_w: RTCIENR = %04x\n", data);
1590	1590	mc68328->regs.rtcienr = data & 0x001f;
1591	1591	break;
1592	1592
1593	1593	case 0xb12:
1594		verboselog(device->machine(), 2, "mc68328_w: STPWTCH = %04x\n", data);
	1594	verboselog(space.machine(), 2, "mc68328_w: STPWTCH = %04x\n", data);
1595	1595	mc68328->regs.stpwtch = data & 0x003f;
1596	1596	break;
1597	1597
1598	1598	default:
1599		verboselog(device->machine(), 0, "mc68328_w: Unknown address (0x%06x) = %04x (%04x)\n", 0xfff000 + address, data, mem_mask);
	1599	verboselog(space.machine(), 0, "mc68328_w: Unknown address (0x%06x) = %04x (%04x)\n", 0xfff000 + address, data, mem_mask);
1600	1600	break;
1601	1601	}
1602	1602	}
r18055	r18056
1612	1612	case 0x000:
1613	1613	if( mem_mask & 0x00ff )
1614	1614	{
1615		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff001)\n", mem_mask);
	1615	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff001)\n", mem_mask);
1616	1616	}
1617	1617	else
1618	1618	{
1619		verboselog(device->machine(), 2, "mc68328_r (%04x): SCR = %02x\n", mem_mask, mc68328->regs.scr);
	1619	verboselog(space.machine(), 2, "mc68328_r (%04x): SCR = %02x\n", mem_mask, mc68328->regs.scr);
1620	1620	return mc68328->regs.scr << 8;
1621	1621	}
1622	1622	break;
1623	1623
1624	1624	case 0x100:
1625		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPBASEA = %04x\n", mem_mask, mc68328->regs.grpbasea);
	1625	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPBASEA = %04x\n", mem_mask, mc68328->regs.grpbasea);
1626	1626	return mc68328->regs.grpbasea;
1627	1627
1628	1628	case 0x102:
1629		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPBASEB = %04x\n", mem_mask, mc68328->regs.grpbaseb);
	1629	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPBASEB = %04x\n", mem_mask, mc68328->regs.grpbaseb);
1630	1630	return mc68328->regs.grpbaseb;
1631	1631
1632	1632	case 0x104:
1633		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPBASEC = %04x\n", mem_mask, mc68328->regs.grpbasec);
	1633	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPBASEC = %04x\n", mem_mask, mc68328->regs.grpbasec);
1634	1634	return mc68328->regs.grpbasec;
1635	1635
1636	1636	case 0x106:
1637		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPBASED = %04x\n", mem_mask, mc68328->regs.grpbased);
	1637	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPBASED = %04x\n", mem_mask, mc68328->regs.grpbased);
1638	1638	return mc68328->regs.grpbased;
1639	1639
1640	1640	case 0x108:
1641		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPMASKA = %04x\n", mem_mask, mc68328->regs.grpmaska);
	1641	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPMASKA = %04x\n", mem_mask, mc68328->regs.grpmaska);
1642	1642	return mc68328->regs.grpmaska;
1643	1643
1644	1644	case 0x10a:
1645		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPMASKB = %04x\n", mem_mask, mc68328->regs.grpmaskb);
	1645	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPMASKB = %04x\n", mem_mask, mc68328->regs.grpmaskb);
1646	1646	return mc68328->regs.grpmaskb;
1647	1647
1648	1648	case 0x10c:
1649		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPMASKC = %04x\n", mem_mask, mc68328->regs.grpmaskc);
	1649	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPMASKC = %04x\n", mem_mask, mc68328->regs.grpmaskc);
1650	1650	return mc68328->regs.grpmaskc;
1651	1651
1652	1652	case 0x10e:
1653		verboselog(device->machine(), 2, "mc68328_r (%04x): GRPMASKD = %04x\n", mem_mask, mc68328->regs.grpmaskd);
	1653	verboselog(space.machine(), 2, "mc68328_r (%04x): GRPMASKD = %04x\n", mem_mask, mc68328->regs.grpmaskd);
1654	1654	return mc68328->regs.grpmaskd;
1655	1655
1656	1656	case 0x110:
1657		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA0(0) = %04x\n", mem_mask, mc68328->regs.csa0 & 0x0000ffff);
	1657	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA0(0) = %04x\n", mem_mask, mc68328->regs.csa0 & 0x0000ffff);
1658	1658	return mc68328->regs.csa0 & 0x0000ffff;
1659	1659
1660	1660	case 0x112:
1661		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA0(16) = %04x\n", mem_mask, mc68328->regs.csa0 >> 16);
	1661	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA0(16) = %04x\n", mem_mask, mc68328->regs.csa0 >> 16);
1662	1662	return mc68328->regs.csa0 >> 16;
1663	1663
1664	1664	case 0x114:
1665		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA1(0) = %04x\n", mem_mask, mc68328->regs.csa1 & 0x0000ffff);
	1665	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA1(0) = %04x\n", mem_mask, mc68328->regs.csa1 & 0x0000ffff);
1666	1666	return mc68328->regs.csa1 & 0x0000ffff;
1667	1667
1668	1668	case 0x116:
1669		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA1(16) = %04x\n", mem_mask, mc68328->regs.csa1 >> 16);
	1669	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA1(16) = %04x\n", mem_mask, mc68328->regs.csa1 >> 16);
1670	1670	return mc68328->regs.csa1 >> 16;
1671	1671
1672	1672	case 0x118:
1673		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA2(0) = %04x\n", mem_mask, mc68328->regs.csa2 & 0x0000ffff);
	1673	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA2(0) = %04x\n", mem_mask, mc68328->regs.csa2 & 0x0000ffff);
1674	1674	return mc68328->regs.csa2 & 0x0000ffff;
1675	1675
1676	1676	case 0x11a:
1677		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA2(16) = %04x\n", mem_mask, mc68328->regs.csa2 >> 16);
	1677	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA2(16) = %04x\n", mem_mask, mc68328->regs.csa2 >> 16);
1678	1678	return mc68328->regs.csa2 >> 16;
1679	1679
1680	1680	case 0x11c:
1681		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA3(0) = %04x\n", mem_mask, mc68328->regs.csa3 & 0x0000ffff);
	1681	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA3(0) = %04x\n", mem_mask, mc68328->regs.csa3 & 0x0000ffff);
1682	1682	return mc68328->regs.csa3 & 0x0000ffff;
1683	1683
1684	1684	case 0x11e:
1685		verboselog(device->machine(), 5, "mc68328_r (%04x): CSA3(16) = %04x\n", mem_mask, mc68328->regs.csa3 >> 16);
	1685	verboselog(space.machine(), 5, "mc68328_r (%04x): CSA3(16) = %04x\n", mem_mask, mc68328->regs.csa3 >> 16);
1686	1686	return mc68328->regs.csa3 >> 16;
1687	1687
1688	1688	case 0x120:
1689		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB0(0) = %04x\n", mem_mask, mc68328->regs.csb0 & 0x0000ffff);
	1689	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB0(0) = %04x\n", mem_mask, mc68328->regs.csb0 & 0x0000ffff);
1690	1690	return mc68328->regs.csb0 & 0x0000ffff;
1691	1691
1692	1692	case 0x122:
1693		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB0(16) = %04x\n", mem_mask, mc68328->regs.csb0 >> 16);
	1693	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB0(16) = %04x\n", mem_mask, mc68328->regs.csb0 >> 16);
1694	1694	return mc68328->regs.csb0 >> 16;
1695	1695
1696	1696	case 0x124:
1697		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB1(0) = %04x\n", mem_mask, mc68328->regs.csb1 & 0x0000ffff);
	1697	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB1(0) = %04x\n", mem_mask, mc68328->regs.csb1 & 0x0000ffff);
1698	1698	return mc68328->regs.csb1 & 0x0000ffff;
1699	1699
1700	1700	case 0x126:
1701		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB1(16) = %04x\n", mem_mask, mc68328->regs.csb1 >> 16);
	1701	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB1(16) = %04x\n", mem_mask, mc68328->regs.csb1 >> 16);
1702	1702	return mc68328->regs.csb1 >> 16;
1703	1703
1704	1704	case 0x128:
1705		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB2(0) = %04x\n", mem_mask, mc68328->regs.csb2 & 0x0000ffff);
	1705	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB2(0) = %04x\n", mem_mask, mc68328->regs.csb2 & 0x0000ffff);
1706	1706	return mc68328->regs.csb2 & 0x0000ffff;
1707	1707
1708	1708	case 0x12a:
1709		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB2(16) = %04x\n", mem_mask, mc68328->regs.csb2 >> 16);
	1709	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB2(16) = %04x\n", mem_mask, mc68328->regs.csb2 >> 16);
1710	1710	return mc68328->regs.csb2 >> 16;
1711	1711
1712	1712	case 0x12c:
1713		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB3(0) = %04x\n", mem_mask, mc68328->regs.csb3 & 0x0000ffff);
	1713	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB3(0) = %04x\n", mem_mask, mc68328->regs.csb3 & 0x0000ffff);
1714	1714	return mc68328->regs.csb3 & 0x0000ffff;
1715	1715
1716	1716	case 0x12e:
1717		verboselog(device->machine(), 5, "mc68328_r (%04x): CSB3(16) = %04x\n", mem_mask, mc68328->regs.csb3 >> 16);
	1717	verboselog(space.machine(), 5, "mc68328_r (%04x): CSB3(16) = %04x\n", mem_mask, mc68328->regs.csb3 >> 16);
1718	1718	return mc68328->regs.csb3 >> 16;
1719	1719
1720	1720	case 0x130:
1721		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC0(0) = %04x\n", mem_mask, mc68328->regs.csc0 & 0x0000ffff);
	1721	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC0(0) = %04x\n", mem_mask, mc68328->regs.csc0 & 0x0000ffff);
1722	1722	return mc68328->regs.csc0 & 0x0000ffff;
1723	1723
1724	1724	case 0x132:
1725		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC0(16) = %04x\n", mem_mask, mc68328->regs.csc0 >> 16);
	1725	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC0(16) = %04x\n", mem_mask, mc68328->regs.csc0 >> 16);
1726	1726	return mc68328->regs.csc0 >> 16;
1727	1727
1728	1728	case 0x134:
1729		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC1(0) = %04x\n", mem_mask, mc68328->regs.csc1 & 0x0000ffff);
	1729	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC1(0) = %04x\n", mem_mask, mc68328->regs.csc1 & 0x0000ffff);
1730	1730	return mc68328->regs.csc1 & 0x0000ffff;
1731	1731
1732	1732	case 0x136:
1733		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC1(16) = %04x\n", mem_mask, mc68328->regs.csc1 >> 16);
	1733	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC1(16) = %04x\n", mem_mask, mc68328->regs.csc1 >> 16);
1734	1734	return mc68328->regs.csc1 >> 16;
1735	1735
1736	1736	case 0x138:
1737		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC2(0) = %04x\n", mem_mask, mc68328->regs.csc2 & 0x0000ffff);
	1737	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC2(0) = %04x\n", mem_mask, mc68328->regs.csc2 & 0x0000ffff);
1738	1738	return mc68328->regs.csc2 & 0x0000ffff;
1739	1739
1740	1740	case 0x13a:
1741		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC2(16) = %04x\n", mem_mask, mc68328->regs.csc2 >> 16);
	1741	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC2(16) = %04x\n", mem_mask, mc68328->regs.csc2 >> 16);
1742	1742	return mc68328->regs.csc2 >> 16;
1743	1743
1744	1744	case 0x13c:
1745		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC3(0) = %04x\n", mem_mask, mc68328->regs.csc3 & 0x0000ffff);
	1745	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC3(0) = %04x\n", mem_mask, mc68328->regs.csc3 & 0x0000ffff);
1746	1746	return mc68328->regs.csc3 & 0x0000ffff;
1747	1747
1748	1748	case 0x13e:
1749		verboselog(device->machine(), 5, "mc68328_r (%04x): CSC3(16) = %04x\n", mem_mask, mc68328->regs.csc3 >> 16);
	1749	verboselog(space.machine(), 5, "mc68328_r (%04x): CSC3(16) = %04x\n", mem_mask, mc68328->regs.csc3 >> 16);
1750	1750	return mc68328->regs.csc3 >> 16;
1751	1751
1752	1752	case 0x140:
1753		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD0(0) = %04x\n", mem_mask, mc68328->regs.csd0 & 0x0000ffff);
	1753	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD0(0) = %04x\n", mem_mask, mc68328->regs.csd0 & 0x0000ffff);
1754	1754	return mc68328->regs.csd0 & 0x0000ffff;
1755	1755
1756	1756	case 0x142:
1757		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD0(16) = %04x\n", mem_mask, mc68328->regs.csd0 >> 16);
	1757	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD0(16) = %04x\n", mem_mask, mc68328->regs.csd0 >> 16);
1758	1758	return mc68328->regs.csd0 >> 16;
1759	1759
1760	1760	case 0x144:
1761		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD1(0) = %04x\n", mem_mask, mc68328->regs.csd1 & 0x0000ffff);
	1761	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD1(0) = %04x\n", mem_mask, mc68328->regs.csd1 & 0x0000ffff);
1762	1762	return mc68328->regs.csd1 & 0x0000ffff;
1763	1763
1764	1764	case 0x146:
1765		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD1(16) = %04x\n", mem_mask, mc68328->regs.csd1 >> 16);
	1765	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD1(16) = %04x\n", mem_mask, mc68328->regs.csd1 >> 16);
1766	1766	return mc68328->regs.csd1 >> 16;
1767	1767
1768	1768	case 0x148:
1769		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD2(0) = %04x\n", mem_mask, mc68328->regs.csd2 & 0x0000ffff);
	1769	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD2(0) = %04x\n", mem_mask, mc68328->regs.csd2 & 0x0000ffff);
1770	1770	return mc68328->regs.csd2 & 0x0000ffff;
1771	1771
1772	1772	case 0x14a:
1773		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD2(16) = %04x\n", mem_mask, mc68328->regs.csd2 >> 16);
	1773	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD2(16) = %04x\n", mem_mask, mc68328->regs.csd2 >> 16);
1774	1774	return mc68328->regs.csd2 >> 16;
1775	1775
1776	1776	case 0x14c:
1777		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD3(0) = %04x\n", mem_mask, mc68328->regs.csd3 & 0x0000ffff);
	1777	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD3(0) = %04x\n", mem_mask, mc68328->regs.csd3 & 0x0000ffff);
1778	1778	return mc68328->regs.csd3 & 0x0000ffff;
1779	1779
1780	1780	case 0x14e:
1781		verboselog(device->machine(), 5, "mc68328_r (%04x): CSD3(16) = %04x\n", mem_mask, mc68328->regs.csd3 >> 16);
	1781	verboselog(space.machine(), 5, "mc68328_r (%04x): CSD3(16) = %04x\n", mem_mask, mc68328->regs.csd3 >> 16);
1782	1782	return mc68328->regs.csd3 >> 16;
1783	1783
1784	1784	case 0x200:
1785		verboselog(device->machine(), 2, "mc68328_r (%04x): PLLCR = %04x\n", mem_mask, mc68328->regs.pllcr);
	1785	verboselog(space.machine(), 2, "mc68328_r (%04x): PLLCR = %04x\n", mem_mask, mc68328->regs.pllcr);
1786	1786	return mc68328->regs.pllcr;
1787	1787
1788	1788	case 0x202:
1789		verboselog(device->machine(), 2, "mc68328_r (%04x): PLLFSR = %04x\n", mem_mask, mc68328->regs.pllfsr);
	1789	verboselog(space.machine(), 2, "mc68328_r (%04x): PLLFSR = %04x\n", mem_mask, mc68328->regs.pllfsr);
1790	1790	mc68328->regs.pllfsr ^= 0x8000;
1791	1791	return mc68328->regs.pllfsr;
1792	1792
1793	1793	case 0x206:
1794	1794	if( mem_mask & 0x00ff )
1795	1795	{
1796		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff206)\n", mem_mask);
	1796	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff206)\n", mem_mask);
1797	1797	}
1798	1798	else
1799	1799	{
1800		verboselog(device->machine(), 2, "mc68328_r (%04x): PCTLR = %02x\n", mem_mask, mc68328->regs.pctlr);
	1800	verboselog(space.machine(), 2, "mc68328_r (%04x): PCTLR = %02x\n", mem_mask, mc68328->regs.pctlr);
1801	1801	return mc68328->regs.pctlr << 8;
1802	1802	}
1803	1803	break;
r18055	r18056
1805	1805	case 0x300:
1806	1806	if( mem_mask & 0x00ff )
1807	1807	{
1808		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff301)\n", mem_mask);
	1808	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff301)\n", mem_mask);
1809	1809	}
1810	1810	else
1811	1811	{
1812		verboselog(device->machine(), 2, "mc68328_r (%04x): IVR = %02x\n", mem_mask, mc68328->regs.ivr);
	1812	verboselog(space.machine(), 2, "mc68328_r (%04x): IVR = %02x\n", mem_mask, mc68328->regs.ivr);
1813	1813	return mc68328->regs.ivr << 8;
1814	1814	}
1815	1815	break;
1816	1816
1817	1817	case 0x302:
1818		verboselog(device->machine(), 2, "mc68328_r (%04x): ICR = %04x\n", mem_mask, mc68328->regs.icr);
	1818	verboselog(space.machine(), 2, "mc68328_r (%04x): ICR = %04x\n", mem_mask, mc68328->regs.icr);
1819	1819	return mc68328->regs.icr;
1820	1820
1821	1821	case 0x304:
1822		verboselog(device->machine(), 2, "mc68328_r (%04x): IMR(16) = %04x\n", mem_mask, mc68328->regs.imr >> 16);
	1822	verboselog(space.machine(), 2, "mc68328_r (%04x): IMR(16) = %04x\n", mem_mask, mc68328->regs.imr >> 16);
1823	1823	return mc68328->regs.imr >> 16;
1824	1824
1825	1825	case 0x306:
1826		verboselog(device->machine(), 2, "mc68328_r (%04x): IMR(0) = %04x\n", mem_mask, mc68328->regs.imr & 0x0000ffff);
	1826	verboselog(space.machine(), 2, "mc68328_r (%04x): IMR(0) = %04x\n", mem_mask, mc68328->regs.imr & 0x0000ffff);
1827	1827	return mc68328->regs.imr & 0x0000ffff;
1828	1828
1829	1829	case 0x308:
1830		verboselog(device->machine(), 2, "mc68328_r (%04x): IWR(16) = %04x\n", mem_mask, mc68328->regs.iwr >> 16);
	1830	verboselog(space.machine(), 2, "mc68328_r (%04x): IWR(16) = %04x\n", mem_mask, mc68328->regs.iwr >> 16);
1831	1831	return mc68328->regs.iwr >> 16;
1832	1832
1833	1833	case 0x30a:
1834		verboselog(device->machine(), 2, "mc68328_r (%04x): IWR(0) = %04x\n", mem_mask, mc68328->regs.iwr & 0x0000ffff);
	1834	verboselog(space.machine(), 2, "mc68328_r (%04x): IWR(0) = %04x\n", mem_mask, mc68328->regs.iwr & 0x0000ffff);
1835	1835	return mc68328->regs.iwr & 0x0000ffff;
1836	1836
1837	1837	case 0x30c:
1838		verboselog(device->machine(), 2, "mc68328_r (%04x): ISR(16) = %04x\n", mem_mask, mc68328->regs.isr >> 16);
	1838	verboselog(space.machine(), 2, "mc68328_r (%04x): ISR(16) = %04x\n", mem_mask, mc68328->regs.isr >> 16);
1839	1839	return mc68328->regs.isr >> 16;
1840	1840
1841	1841	case 0x30e:
1842		verboselog(device->machine(), 2, "mc68328_r (%04x): ISR(0) = %04x\n", mem_mask, mc68328->regs.isr & 0x0000ffff);
	1842	verboselog(space.machine(), 2, "mc68328_r (%04x): ISR(0) = %04x\n", mem_mask, mc68328->regs.isr & 0x0000ffff);
1843	1843	return mc68328->regs.isr & 0x0000ffff;
1844	1844
1845	1845	case 0x310:
1846		verboselog(device->machine(), 2, "mc68328_r (%04x): IPR(16) = %04x\n", mem_mask, mc68328->regs.ipr >> 16);
	1846	verboselog(space.machine(), 2, "mc68328_r (%04x): IPR(16) = %04x\n", mem_mask, mc68328->regs.ipr >> 16);
1847	1847	return mc68328->regs.ipr >> 16;
1848	1848
1849	1849	case 0x312:
1850		verboselog(device->machine(), 2, "mc68328_r (%04x): IPR(0) = %04x\n", mem_mask, mc68328->regs.ipr & 0x0000ffff);
	1850	verboselog(space.machine(), 2, "mc68328_r (%04x): IPR(0) = %04x\n", mem_mask, mc68328->regs.ipr & 0x0000ffff);
1851	1851	return mc68328->regs.ipr & 0x0000ffff;
1852	1852
1853	1853	case 0x400:
1854	1854	if( mem_mask & 0x00ff )
1855	1855	{
1856		verboselog(device->machine(), 2, "mc68328_r (%04x): PADATA = %02x\n", mem_mask, mc68328->regs.padata);
	1856	verboselog(space.machine(), 2, "mc68328_r (%04x): PADATA = %02x\n", mem_mask, mc68328->regs.padata);
1857	1857	if(!mc68328->in_port_a.isnull())
1858	1858	{
1859	1859	return mc68328->in_port_a( 0 );
r18055	r18056
1865	1865	}
1866	1866	else
1867	1867	{
1868		verboselog(device->machine(), 2, "mc68328_r (%04x): PADIR = %02x\n", mem_mask, mc68328->regs.padir);
	1868	verboselog(space.machine(), 2, "mc68328_r (%04x): PADIR = %02x\n", mem_mask, mc68328->regs.padir);
1869	1869	return mc68328->regs.padir << 8;
1870	1870	}
1871	1871	break;
r18055	r18056
1873	1873	case 0x402:
1874	1874	if( mem_mask & 0x00ff )
1875	1875	{
1876		verboselog(device->machine(), 2, "mc68328_r (%04x): PASEL = %02x\n", mem_mask, mc68328->regs.pasel);
	1876	verboselog(space.machine(), 2, "mc68328_r (%04x): PASEL = %02x\n", mem_mask, mc68328->regs.pasel);
1877	1877	return mc68328->regs.pasel;
1878	1878	}
1879	1879	else
1880	1880	{
1881		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff402)\n", mem_mask);
	1881	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff402)\n", mem_mask);
1882	1882	}
1883	1883	break;
1884	1884
1885	1885	case 0x408:
1886	1886	if( mem_mask & 0x00ff )
1887	1887	{
1888		verboselog(device->machine(), 2, "mc68328_r (%04x): PBDATA = %02x\n", mem_mask, mc68328->regs.pbdata);
	1888	verboselog(space.machine(), 2, "mc68328_r (%04x): PBDATA = %02x\n", mem_mask, mc68328->regs.pbdata);
1889	1889	if(!mc68328->in_port_b.isnull())
1890	1890	{
1891	1891	return mc68328->in_port_b( 0 );
r18055	r18056
1897	1897	}
1898	1898	else
1899	1899	{
1900		verboselog(device->machine(), 2, "mc68328_r (%04x): PBDIR = %02x\n", mem_mask, mc68328->regs.pbdir);
	1900	verboselog(space.machine(), 2, "mc68328_r (%04x): PBDIR = %02x\n", mem_mask, mc68328->regs.pbdir);
1901	1901	return mc68328->regs.pbdir << 8;
1902	1902	}
1903	1903	break;
r18055	r18056
1905	1905	case 0x40a:
1906	1906	if( mem_mask & 0x00ff )
1907	1907	{
1908		verboselog(device->machine(), 2, "mc68328_r (%04x): PBSEL = %02x\n", mem_mask, mc68328->regs.pbsel);
	1908	verboselog(space.machine(), 2, "mc68328_r (%04x): PBSEL = %02x\n", mem_mask, mc68328->regs.pbsel);
1909	1909	return mc68328->regs.pbsel;
1910	1910	}
1911	1911	else
1912	1912	{
1913		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff40a)\n", mem_mask);
	1913	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff40a)\n", mem_mask);
1914	1914	}
1915	1915	break;
1916	1916
1917	1917	case 0x410:
1918	1918	if( mem_mask & 0x00ff )
1919	1919	{
1920		verboselog(device->machine(), 2, "mc68328_r (%04x): PCDATA = %02x\n", mem_mask, mc68328->regs.pcdata);
	1920	verboselog(space.machine(), 2, "mc68328_r (%04x): PCDATA = %02x\n", mem_mask, mc68328->regs.pcdata);
1921	1921	if(!mc68328->in_port_c.isnull())
1922	1922	{
1923	1923	return mc68328->in_port_c( 0 );
r18055	r18056
1929	1929	}
1930	1930	else
1931	1931	{
1932		verboselog(device->machine(), 2, "mc68328_r (%04x): PCDIR = %02x\n", mem_mask, mc68328->regs.pcdir);
	1932	verboselog(space.machine(), 2, "mc68328_r (%04x): PCDIR = %02x\n", mem_mask, mc68328->regs.pcdir);
1933	1933	return mc68328->regs.pcdir << 8;
1934	1934	}
1935	1935	break;
r18055	r18056
1937	1937	case 0x412:
1938	1938	if( mem_mask & 0x00ff )
1939	1939	{
1940		verboselog(device->machine(), 2, "mc68328_r (%04x): PCSEL = %02x\n", mem_mask, mc68328->regs.pcsel);
	1940	verboselog(space.machine(), 2, "mc68328_r (%04x): PCSEL = %02x\n", mem_mask, mc68328->regs.pcsel);
1941	1941	return mc68328->regs.pcsel;
1942	1942	}
1943	1943	else
1944	1944	{
1945		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff412)\n", mem_mask);
	1945	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff412)\n", mem_mask);
1946	1946	}
1947	1947	break;
1948	1948
1949	1949	case 0x418:
1950	1950	if( mem_mask & 0x00ff )
1951	1951	{
1952		verboselog(device->machine(), 2, "mc68328_r (%04x): PDDATA = %02x\n", mem_mask, mc68328->regs.pddata);
	1952	verboselog(space.machine(), 2, "mc68328_r (%04x): PDDATA = %02x\n", mem_mask, mc68328->regs.pddata);
1953	1953	if(!mc68328->in_port_d.isnull())
1954	1954	{
1955	1955	return mc68328->in_port_d( 0 );
r18055	r18056
1961	1961	}
1962	1962	else
1963	1963	{
1964		verboselog(device->machine(), 2, "mc68328_r (%04x): PDDIR = %02x\n", mem_mask, mc68328->regs.pddir);
	1964	verboselog(space.machine(), 2, "mc68328_r (%04x): PDDIR = %02x\n", mem_mask, mc68328->regs.pddir);
1965	1965	return mc68328->regs.pddir << 8;
1966	1966	}
1967	1967	break;
r18055	r18056
1969	1969	case 0x41a:
1970	1970	if( mem_mask & 0x00ff )
1971	1971	{
1972		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff41b)\n", mem_mask);
	1972	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff41b)\n", mem_mask);
1973	1973	}
1974	1974	else
1975	1975	{
1976		verboselog(device->machine(), 2, "mc68328_r (%04x): PDPUEN = %02x\n", mem_mask, mc68328->regs.pdpuen);
	1976	verboselog(space.machine(), 2, "mc68328_r (%04x): PDPUEN = %02x\n", mem_mask, mc68328->regs.pdpuen);
1977	1977	return mc68328->regs.pdpuen << 8;
1978	1978	}
1979	1979	break;
r18055	r18056
1981	1981	case 0x41c:
1982	1982	if( mem_mask & 0x00ff )
1983	1983	{
1984		verboselog(device->machine(), 2, "mc68328_r (%04x): PDIRQEN = %02x\n", mem_mask, mc68328->regs.pdirqen);
	1984	verboselog(space.machine(), 2, "mc68328_r (%04x): PDIRQEN = %02x\n", mem_mask, mc68328->regs.pdirqen);
1985	1985	return mc68328->regs.pdirqen;
1986	1986	}
1987	1987	else
1988	1988	{
1989		verboselog(device->machine(), 2, "mc68328_r (%04x): PDPOL = %02x\n", mem_mask, mc68328->regs.pdpol);
	1989	verboselog(space.machine(), 2, "mc68328_r (%04x): PDPOL = %02x\n", mem_mask, mc68328->regs.pdpol);
1990	1990	return mc68328->regs.pdpol << 8;
1991	1991	}
1992	1992	break;
r18055	r18056
1994	1994	case 0x41e:
1995	1995	if( mem_mask & 0x00ff )
1996	1996	{
1997		verboselog(device->machine(), 2, "mc68328_r (%04x): PDIRQEDGE = %02x\n", mem_mask, mc68328->regs.pdirqedge);
	1997	verboselog(space.machine(), 2, "mc68328_r (%04x): PDIRQEDGE = %02x\n", mem_mask, mc68328->regs.pdirqedge);
1998	1998	return mc68328->regs.pdirqedge;
1999	1999	}
2000	2000	else
2001	2001	{
2002		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff41e)\n", mem_mask);
	2002	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff41e)\n", mem_mask);
2003	2003	}
2004	2004	break;
2005	2005
2006	2006	case 0x420:
2007	2007	if( mem_mask & 0x00ff )
2008	2008	{
2009		verboselog(device->machine(), 2, "mc68328_r (%04x): PEDATA = %02x\n", mem_mask, mc68328->regs.pedata);
	2009	verboselog(space.machine(), 2, "mc68328_r (%04x): PEDATA = %02x\n", mem_mask, mc68328->regs.pedata);
2010	2010	if(!mc68328->in_port_e.isnull())
2011	2011	{
2012	2012	return mc68328->in_port_e( 0 );
r18055	r18056
2018	2018	}
2019	2019	else
2020	2020	{
2021		verboselog(device->machine(), 2, "mc68328_r (%04x): PEDIR = %02x\n", mem_mask, mc68328->regs.pedir);
	2021	verboselog(space.machine(), 2, "mc68328_r (%04x): PEDIR = %02x\n", mem_mask, mc68328->regs.pedir);
2022	2022	return mc68328->regs.pedir << 8;
2023	2023	}
2024	2024	break;
r18055	r18056
2026	2026	case 0x422:
2027	2027	if( mem_mask & 0x00ff )
2028	2028	{
2029		verboselog(device->machine(), 2, "mc68328_r (%04x): PESEL = %02x\n", mem_mask, mc68328->regs.pesel);
	2029	verboselog(space.machine(), 2, "mc68328_r (%04x): PESEL = %02x\n", mem_mask, mc68328->regs.pesel);
2030	2030	return mc68328->regs.pesel;
2031	2031	}
2032	2032	else
2033	2033	{
2034		verboselog(device->machine(), 2, "mc68328_r (%04x): PEPUEN = %02x\n", mem_mask, mc68328->regs.pepuen);
	2034	verboselog(space.machine(), 2, "mc68328_r (%04x): PEPUEN = %02x\n", mem_mask, mc68328->regs.pepuen);
2035	2035	return mc68328->regs.pepuen << 8;
2036	2036	}
2037	2037	break;
r18055	r18056
2039	2039	case 0x428:
2040	2040	if( mem_mask & 0x00ff )
2041	2041	{
2042		verboselog(device->machine(), 2, "mc68328_r (%04x): PFDATA = %02x\n", mem_mask, mc68328->regs.pfdata);
	2042	verboselog(space.machine(), 2, "mc68328_r (%04x): PFDATA = %02x\n", mem_mask, mc68328->regs.pfdata);
2043	2043	if(!mc68328->in_port_f.isnull())
2044	2044	{
2045	2045	return mc68328->in_port_f( 0 );
r18055	r18056
2051	2051	}
2052	2052	else
2053	2053	{
2054		verboselog(device->machine(), 2, "mc68328_r (%04x): PFDIR = %02x\n", mem_mask, mc68328->regs.pfdir);
	2054	verboselog(space.machine(), 2, "mc68328_r (%04x): PFDIR = %02x\n", mem_mask, mc68328->regs.pfdir);
2055	2055	return mc68328->regs.pfdir << 8;
2056	2056	}
2057	2057	break;
r18055	r18056
2059	2059	case 0x42a:
2060	2060	if( mem_mask & 0x00ff )
2061	2061	{
2062		verboselog(device->machine(), 2, "mc68328_r (%04x): PFSEL = %02x\n", mem_mask, mc68328->regs.pfsel);
	2062	verboselog(space.machine(), 2, "mc68328_r (%04x): PFSEL = %02x\n", mem_mask, mc68328->regs.pfsel);
2063	2063	return mc68328->regs.pfsel;
2064	2064	}
2065	2065	else
2066	2066	{
2067		verboselog(device->machine(), 2, "mc68328_r (%04x): PFPUEN = %02x\n", mem_mask, mc68328->regs.pfpuen);
	2067	verboselog(space.machine(), 2, "mc68328_r (%04x): PFPUEN = %02x\n", mem_mask, mc68328->regs.pfpuen);
2068	2068	return mc68328->regs.pfpuen << 8;
2069	2069	}
2070	2070	break;
r18055	r18056
2072	2072	case 0x430:
2073	2073	if( mem_mask & 0x00ff )
2074	2074	{
2075		verboselog(device->machine(), 2, "mc68328_r (%04x): PGDATA = %02x\n", mem_mask, mc68328->regs.pgdata);
	2075	verboselog(space.machine(), 2, "mc68328_r (%04x): PGDATA = %02x\n", mem_mask, mc68328->regs.pgdata);
2076	2076	if(!mc68328->in_port_g.isnull())
2077	2077	{
2078	2078	return mc68328->in_port_g( 0 );
r18055	r18056
2084	2084	}
2085	2085	else
2086	2086	{
2087		verboselog(device->machine(), 2, "mc68328_r (%04x): PGDIR = %02x\n", mem_mask, mc68328->regs.pgdir);
	2087	verboselog(space.machine(), 2, "mc68328_r (%04x): PGDIR = %02x\n", mem_mask, mc68328->regs.pgdir);
2088	2088	return mc68328->regs.pgdir << 8;
2089	2089	}
2090	2090	break;
r18055	r18056
2092	2092	case 0x432:
2093	2093	if( mem_mask & 0x00ff )
2094	2094	{
2095		verboselog(device->machine(), 2, "mc68328_r (%04x): PGSEL = %02x\n", mem_mask, mc68328->regs.pgsel);
	2095	verboselog(space.machine(), 2, "mc68328_r (%04x): PGSEL = %02x\n", mem_mask, mc68328->regs.pgsel);
2096	2096	return mc68328->regs.pgsel;
2097	2097	}
2098	2098	else
2099	2099	{
2100		verboselog(device->machine(), 2, "mc68328_r (%04x): PGPUEN = %02x\n", mem_mask, mc68328->regs.pgpuen);
	2100	verboselog(space.machine(), 2, "mc68328_r (%04x): PGPUEN = %02x\n", mem_mask, mc68328->regs.pgpuen);
2101	2101	return mc68328->regs.pgpuen << 8;
2102	2102	}
2103	2103	break;
r18055	r18056
2105	2105	case 0x438:
2106	2106	if( mem_mask & 0x00ff )
2107	2107	{
2108		verboselog(device->machine(), 2, "mc68328_r (%04x): PJDATA = %02x\n", mem_mask, mc68328->regs.pjdata);
	2108	verboselog(space.machine(), 2, "mc68328_r (%04x): PJDATA = %02x\n", mem_mask, mc68328->regs.pjdata);
2109	2109	if(!mc68328->in_port_j.isnull())
2110	2110	{
2111	2111	return mc68328->in_port_j( 0 );
r18055	r18056
2117	2117	}
2118	2118	else
2119	2119	{
2120		verboselog(device->machine(), 2, "mc68328_r (%04x): PJDIR = %02x\n", mem_mask, mc68328->regs.pjdir);
	2120	verboselog(space.machine(), 2, "mc68328_r (%04x): PJDIR = %02x\n", mem_mask, mc68328->regs.pjdir);
2121	2121	return mc68328->regs.pjdir << 8;
2122	2122	}
2123	2123	break;
r18055	r18056
2125	2125	case 0x43a:
2126	2126	if( mem_mask & 0x00ff )
2127	2127	{
2128		verboselog(device->machine(), 2, "mc68328_r (%04x): PJSEL = %02x\n", mem_mask, mc68328->regs.pjsel);
	2128	verboselog(space.machine(), 2, "mc68328_r (%04x): PJSEL = %02x\n", mem_mask, mc68328->regs.pjsel);
2129	2129	return mc68328->regs.pjsel;
2130	2130	}
2131	2131	else
2132	2132	{
2133		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfff43a)\n", mem_mask);
	2133	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfff43a)\n", mem_mask);
2134	2134	}
2135	2135	break;
2136	2136
2137	2137	case 0x440:
2138	2138	if( mem_mask & 0x00ff )
2139	2139	{
2140		verboselog(device->machine(), 2, "mc68328_r (%04x): PKDATA = %02x\n", mem_mask, mc68328->regs.pkdata);
	2140	verboselog(space.machine(), 2, "mc68328_r (%04x): PKDATA = %02x\n", mem_mask, mc68328->regs.pkdata);
2141	2141	if(!mc68328->in_port_k.isnull())
2142	2142	{
2143	2143	return mc68328->in_port_k( 0 );
r18055	r18056
2149	2149	}
2150	2150	else
2151	2151	{
2152		verboselog(device->machine(), 2, "mc68328_r (%04x): PKDIR = %02x\n", mem_mask, mc68328->regs.pkdir);
	2152	verboselog(space.machine(), 2, "mc68328_r (%04x): PKDIR = %02x\n", mem_mask, mc68328->regs.pkdir);
2153	2153	return mc68328->regs.pkdir << 8;
2154	2154	}
2155	2155	break;
r18055	r18056
2157	2157	case 0x442:
2158	2158	if( mem_mask & 0x00ff )
2159	2159	{
2160		verboselog(device->machine(), 2, "mc68328_r (%04x): PKSEL = %02x\n", mem_mask, mc68328->regs.pksel);
	2160	verboselog(space.machine(), 2, "mc68328_r (%04x): PKSEL = %02x\n", mem_mask, mc68328->regs.pksel);
2161	2161	return mc68328->regs.pksel;
2162	2162	}
2163	2163	else
2164	2164	{
2165		verboselog(device->machine(), 2, "mc68328_r (%04x): PKPUEN = %02x\n", mem_mask, mc68328->regs.pkpuen);
	2165	verboselog(space.machine(), 2, "mc68328_r (%04x): PKPUEN = %02x\n", mem_mask, mc68328->regs.pkpuen);
2166	2166	return mc68328->regs.pkpuen << 8;
2167	2167	}
2168	2168	break;
r18055	r18056
2170	2170	case 0x448:
2171	2171	if( mem_mask & 0x00ff )
2172	2172	{
2173		verboselog(device->machine(), 2, "mc68328_r (%04x): PMDATA = %02x\n", mem_mask, mc68328->regs.pmdata);
	2173	verboselog(space.machine(), 2, "mc68328_r (%04x): PMDATA = %02x\n", mem_mask, mc68328->regs.pmdata);
2174	2174	if(!mc68328->in_port_m.isnull())
2175	2175	{
2176	2176	return mc68328->in_port_m( 0 );
r18055	r18056
2182	2182	}
2183	2183	else
2184	2184	{
2185		verboselog(device->machine(), 2, "mc68328_r (%04x): PMDIR = %02x\n", mem_mask, mc68328->regs.pmdir);
	2185	verboselog(space.machine(), 2, "mc68328_r (%04x): PMDIR = %02x\n", mem_mask, mc68328->regs.pmdir);
2186	2186	return mc68328->regs.pmdir << 8;
2187	2187	}
2188	2188	break;
r18055	r18056
2190	2190	case 0x44a:
2191	2191	if( mem_mask & 0x00ff )
2192	2192	{
2193		verboselog(device->machine(), 2, "mc68328_r (%04x): PMSEL = %02x\n", mem_mask, mc68328->regs.pmsel);
	2193	verboselog(space.machine(), 2, "mc68328_r (%04x): PMSEL = %02x\n", mem_mask, mc68328->regs.pmsel);
2194	2194	return mc68328->regs.pmsel;
2195	2195	}
2196	2196	else
2197	2197	{
2198		verboselog(device->machine(), 2, "mc68328_r (%04x): PMPUEN = %02x\n", mem_mask, mc68328->regs.pmpuen);
	2198	verboselog(space.machine(), 2, "mc68328_r (%04x): PMPUEN = %02x\n", mem_mask, mc68328->regs.pmpuen);
2199	2199	return mc68328->regs.pmpuen << 8;
2200	2200	}
2201	2201	break;
2202	2202
2203	2203	case 0x500:
2204		verboselog(device->machine(), 2, "mc68328_r (%04x): PWMC = %04x\n", mem_mask, mc68328->regs.pwmc);
	2204	verboselog(space.machine(), 2, "mc68328_r (%04x): PWMC = %04x\n", mem_mask, mc68328->regs.pwmc);
2205	2205	temp16 = mc68328->regs.pwmc;
2206	2206	if(mc68328->regs.pwmc & PWMC_PWMIRQ)
2207	2207	{
r18055	r18056
2211	2211	return temp16;
2212	2212
2213	2213	case 0x502:
2214		verboselog(device->machine(), 2, "mc68328_r (%04x): PWMP = %04x\n", mem_mask, mc68328->regs.pwmp);
	2214	verboselog(space.machine(), 2, "mc68328_r (%04x): PWMP = %04x\n", mem_mask, mc68328->regs.pwmp);
2215	2215	return mc68328->regs.pwmp;
2216	2216
2217	2217	case 0x504:
2218		verboselog(device->machine(), 2, "mc68328_r (%04x): PWMW = %04x\n", mem_mask, mc68328->regs.pwmw);
	2218	verboselog(space.machine(), 2, "mc68328_r (%04x): PWMW = %04x\n", mem_mask, mc68328->regs.pwmw);
2219	2219	return mc68328->regs.pwmw;
2220	2220
2221	2221	case 0x506:
2222		verboselog(device->machine(), 2, "mc68328_r (%04x): PWMCNT = %04x\n", mem_mask, mc68328->regs.pwmcnt);
	2222	verboselog(space.machine(), 2, "mc68328_r (%04x): PWMCNT = %04x\n", mem_mask, mc68328->regs.pwmcnt);
2223	2223	return mc68328->regs.pwmcnt;
2224	2224
2225	2225	case 0x600:
2226		verboselog(device->machine(), 2, "mc68328_r (%04x): TCTL1 = %04x\n", mem_mask, mc68328->regs.tctl[0]);
	2226	verboselog(space.machine(), 2, "mc68328_r (%04x): TCTL1 = %04x\n", mem_mask, mc68328->regs.tctl[0]);
2227	2227	return mc68328->regs.tctl[0];
2228	2228
2229	2229	case 0x602:
2230		verboselog(device->machine(), 2, "mc68328_r (%04x): TPRER1 = %04x\n", mem_mask, mc68328->regs.tprer[0]);
	2230	verboselog(space.machine(), 2, "mc68328_r (%04x): TPRER1 = %04x\n", mem_mask, mc68328->regs.tprer[0]);
2231	2231	return mc68328->regs.tprer[0];
2232	2232
2233	2233	case 0x604:
2234		verboselog(device->machine(), 2, "mc68328_r (%04x): TCMP1 = %04x\n", mem_mask, mc68328->regs.tcmp[0]);
	2234	verboselog(space.machine(), 2, "mc68328_r (%04x): TCMP1 = %04x\n", mem_mask, mc68328->regs.tcmp[0]);
2235	2235	return mc68328->regs.tcmp[0];
2236	2236
2237	2237	case 0x606:
2238		verboselog(device->machine(), 2, "mc68328_r (%04x): TCR1 = %04x\n", mem_mask, mc68328->regs.tcr[0]);
	2238	verboselog(space.machine(), 2, "mc68328_r (%04x): TCR1 = %04x\n", mem_mask, mc68328->regs.tcr[0]);
2239	2239	return mc68328->regs.tcr[0];
2240	2240
2241	2241	case 0x608:
2242		verboselog(device->machine(), 2, "mc68328_r (%04x): TCN1 = %04x\n", mem_mask, mc68328->regs.tcn[0]);
	2242	verboselog(space.machine(), 2, "mc68328_r (%04x): TCN1 = %04x\n", mem_mask, mc68328->regs.tcn[0]);
2243	2243	return mc68328->regs.tcn[0];
2244	2244
2245	2245	case 0x60a:
2246		verboselog(device->machine(), 5, "mc68328_r (%04x): TSTAT1 = %04x\n", mem_mask, mc68328->regs.tstat[0]);
	2246	verboselog(space.machine(), 5, "mc68328_r (%04x): TSTAT1 = %04x\n", mem_mask, mc68328->regs.tstat[0]);
2247	2247	mc68328->regs.tclear[0] |= mc68328->regs.tstat[0];
2248	2248	return mc68328->regs.tstat[0];
2249	2249
2250	2250	case 0x60c:
2251		verboselog(device->machine(), 2, "mc68328_r (%04x): TCTL2 = %04x\n", mem_mask, mc68328->regs.tctl[1]);
	2251	verboselog(space.machine(), 2, "mc68328_r (%04x): TCTL2 = %04x\n", mem_mask, mc68328->regs.tctl[1]);
2252	2252	return mc68328->regs.tctl[1];
2253	2253
2254	2254	case 0x60e:
2255		verboselog(device->machine(), 2, "mc68328_r (%04x): TPREP2 = %04x\n", mem_mask, mc68328->regs.tprer[1]);
	2255	verboselog(space.machine(), 2, "mc68328_r (%04x): TPREP2 = %04x\n", mem_mask, mc68328->regs.tprer[1]);
2256	2256	return mc68328->regs.tprer[1];
2257	2257
2258	2258	case 0x610:
2259		verboselog(device->machine(), 2, "mc68328_r (%04x): TCMP2 = %04x\n", mem_mask, mc68328->regs.tcmp[1]);
	2259	verboselog(space.machine(), 2, "mc68328_r (%04x): TCMP2 = %04x\n", mem_mask, mc68328->regs.tcmp[1]);
2260	2260	return mc68328->regs.tcmp[1];
2261	2261
2262	2262	case 0x612:
2263		verboselog(device->machine(), 2, "mc68328_r (%04x): TCR2 = %04x\n", mem_mask, mc68328->regs.tcr[1]);
	2263	verboselog(space.machine(), 2, "mc68328_r (%04x): TCR2 = %04x\n", mem_mask, mc68328->regs.tcr[1]);
2264	2264	return mc68328->regs.tcr[1];
2265	2265
2266	2266	case 0x614:
2267		verboselog(device->machine(), 2, "mc68328_r (%04x): TCN2 = %04x\n", mem_mask, mc68328->regs.tcn[1]);
	2267	verboselog(space.machine(), 2, "mc68328_r (%04x): TCN2 = %04x\n", mem_mask, mc68328->regs.tcn[1]);
2268	2268	return mc68328->regs.tcn[1];
2269	2269
2270	2270	case 0x616:
2271		verboselog(device->machine(), 2, "mc68328_r (%04x): TSTAT2 = %04x\n", mem_mask, mc68328->regs.tstat[1]);
	2271	verboselog(space.machine(), 2, "mc68328_r (%04x): TSTAT2 = %04x\n", mem_mask, mc68328->regs.tstat[1]);
2272	2272	mc68328->regs.tclear[1] |= mc68328->regs.tstat[1];
2273	2273	return mc68328->regs.tstat[1];
2274	2274
2275	2275	case 0x618:
2276		verboselog(device->machine(), 2, "mc68328_r (%04x): WCTLR = %04x\n", mem_mask, mc68328->regs.wctlr);
	2276	verboselog(space.machine(), 2, "mc68328_r (%04x): WCTLR = %04x\n", mem_mask, mc68328->regs.wctlr);
2277	2277	return mc68328->regs.wctlr;
2278	2278
2279	2279	case 0x61a:
2280		verboselog(device->machine(), 2, "mc68328_r (%04x): WCMPR = %04x\n", mem_mask, mc68328->regs.wcmpr);
	2280	verboselog(space.machine(), 2, "mc68328_r (%04x): WCMPR = %04x\n", mem_mask, mc68328->regs.wcmpr);
2281	2281	return mc68328->regs.wcmpr;
2282	2282
2283	2283	case 0x61c:
2284		verboselog(device->machine(), 2, "mc68328_r (%04x): WCN = %04x\n", mem_mask, mc68328->regs.wcn);
	2284	verboselog(space.machine(), 2, "mc68328_r (%04x): WCN = %04x\n", mem_mask, mc68328->regs.wcn);
2285	2285	return mc68328->regs.wcn;
2286	2286
2287	2287	case 0x700:
2288		verboselog(device->machine(), 2, "mc68328_r (%04x): SPISR = %04x\n", mem_mask, mc68328->regs.spisr);
	2288	verboselog(space.machine(), 2, "mc68328_r (%04x): SPISR = %04x\n", mem_mask, mc68328->regs.spisr);
2289	2289	return mc68328->regs.spisr;
2290	2290
2291	2291	case 0x800:
2292		verboselog(device->machine(), 2, "mc68328_r (%04x): SPIMDATA = %04x\n", mem_mask, mc68328->regs.spimdata);
	2292	verboselog(space.machine(), 2, "mc68328_r (%04x): SPIMDATA = %04x\n", mem_mask, mc68328->regs.spimdata);
2293	2293	if(!mc68328->in_spim.isnull())
2294	2294	{
2295	2295	return mc68328->in_spim( 0, 0xffff );
r18055	r18056
2297	2297	return mc68328->regs.spimdata;
2298	2298
2299	2299	case 0x802:
2300		verboselog(device->machine(), 2, "mc68328_r (%04x): SPIMCONT = %04x\n", mem_mask, mc68328->regs.spimcont);
	2300	verboselog(space.machine(), 2, "mc68328_r (%04x): SPIMCONT = %04x\n", mem_mask, mc68328->regs.spimcont);
2301	2301	if(mc68328->regs.spimcont & SPIM_XCH)
2302	2302	{
2303	2303	mc68328->regs.spimcont &= ~SPIM_XCH;
r18055	r18056
2307	2307	return mc68328->regs.spimcont;
2308	2308
2309	2309	case 0x900:
2310		verboselog(device->machine(), 2, "mc68328_r (%04x): USTCNT = %04x\n", mem_mask, mc68328->regs.ustcnt);
	2310	verboselog(space.machine(), 2, "mc68328_r (%04x): USTCNT = %04x\n", mem_mask, mc68328->regs.ustcnt);
2311	2311	return mc68328->regs.ustcnt;
2312	2312
2313	2313	case 0x902:
2314		verboselog(device->machine(), 2, "mc68328_r (%04x): UBAUD = %04x\n", mem_mask, mc68328->regs.ubaud);
	2314	verboselog(space.machine(), 2, "mc68328_r (%04x): UBAUD = %04x\n", mem_mask, mc68328->regs.ubaud);
2315	2315	return mc68328->regs.ubaud;
2316	2316
2317	2317	case 0x904:
2318		verboselog(device->machine(), 5, "mc68328_r (%04x): URX = %04x\n", mem_mask, mc68328->regs.urx);
	2318	verboselog(space.machine(), 5, "mc68328_r (%04x): URX = %04x\n", mem_mask, mc68328->regs.urx);
2319	2319	return mc68328->regs.urx;
2320	2320
2321	2321	case 0x906:
2322		verboselog(device->machine(), 5, "mc68328_r (%04x): UTX = %04x\n", mem_mask, mc68328->regs.utx);
	2322	verboselog(space.machine(), 5, "mc68328_r (%04x): UTX = %04x\n", mem_mask, mc68328->regs.utx);
2323	2323	return mc68328->regs.utx | UTX_FIFO_EMPTY | UTX_FIFO_HALF | UTX_TX_AVAIL;
2324	2324
2325	2325	case 0x908:
2326		verboselog(device->machine(), 2, "mc68328_r (%04x): UMISC = %04x\n", mem_mask, mc68328->regs.umisc);
	2326	verboselog(space.machine(), 2, "mc68328_r (%04x): UMISC = %04x\n", mem_mask, mc68328->regs.umisc);
2327	2327	return mc68328->regs.umisc;
2328	2328
2329	2329	case 0xa00:
2330		verboselog(device->machine(), 2, "mc68328_r (%04x): LSSA(16) = %04x\n", mem_mask, mc68328->regs.lssa >> 16);
	2330	verboselog(space.machine(), 2, "mc68328_r (%04x): LSSA(16) = %04x\n", mem_mask, mc68328->regs.lssa >> 16);
2331	2331	return mc68328->regs.lssa >> 16;
2332	2332
2333	2333	case 0xa02:
2334		verboselog(device->machine(), 2, "mc68328_r (%04x): LSSA(0) = %04x\n", mem_mask, mc68328->regs.lssa & 0x0000ffff);
	2334	verboselog(space.machine(), 2, "mc68328_r (%04x): LSSA(0) = %04x\n", mem_mask, mc68328->regs.lssa & 0x0000ffff);
2335	2335	return mc68328->regs.lssa & 0x0000ffff;
2336	2336
2337	2337	case 0xa04:
2338	2338	if( mem_mask & 0x00ff )
2339	2339	{
2340		verboselog(device->machine(), 2, "mc68328_r (%04x): LVPW = %02x\n", mem_mask, mc68328->regs.lvpw);
	2340	verboselog(space.machine(), 2, "mc68328_r (%04x): LVPW = %02x\n", mem_mask, mc68328->regs.lvpw);
2341	2341	return mc68328->regs.lvpw;
2342	2342	}
2343	2343	else
2344	2344	{
2345		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa04)\n", mem_mask);
	2345	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa04)\n", mem_mask);
2346	2346	}
2347	2347	break;
2348	2348
2349	2349	case 0xa08:
2350		verboselog(device->machine(), 2, "mc68328_r (%04x): LXMAX = %04x\n", mem_mask, mc68328->regs.lxmax);
	2350	verboselog(space.machine(), 2, "mc68328_r (%04x): LXMAX = %04x\n", mem_mask, mc68328->regs.lxmax);
2351	2351	return mc68328->regs.lxmax;
2352	2352
2353	2353	case 0xa0a:
2354		verboselog(device->machine(), 2, "mc68328_r (%04x): LYMAX = %04x\n", mem_mask, mc68328->regs.lymax);
	2354	verboselog(space.machine(), 2, "mc68328_r (%04x): LYMAX = %04x\n", mem_mask, mc68328->regs.lymax);
2355	2355	return mc68328->regs.lymax;
2356	2356
2357	2357	case 0xa18:
2358		verboselog(device->machine(), 2, "mc68328_r (%04x): LCXP = %04x\n", mem_mask, mc68328->regs.lcxp);
	2358	verboselog(space.machine(), 2, "mc68328_r (%04x): LCXP = %04x\n", mem_mask, mc68328->regs.lcxp);
2359	2359	return mc68328->regs.lcxp;
2360	2360
2361	2361	case 0xa1a:
2362		verboselog(device->machine(), 2, "mc68328_r (%04x): LCYP = %04x\n", mem_mask, mc68328->regs.lcyp);
	2362	verboselog(space.machine(), 2, "mc68328_r (%04x): LCYP = %04x\n", mem_mask, mc68328->regs.lcyp);
2363	2363	return mc68328->regs.lcyp;
2364	2364
2365	2365	case 0xa1c:
2366		verboselog(device->machine(), 2, "mc68328_r (%04x): LCWCH = %04x\n", mem_mask, mc68328->regs.lcwch);
	2366	verboselog(space.machine(), 2, "mc68328_r (%04x): LCWCH = %04x\n", mem_mask, mc68328->regs.lcwch);
2367	2367	return mc68328->regs.lcwch;
2368	2368
2369	2369	case 0xa1e:
2370	2370	if( mem_mask & 0x00ff )
2371	2371	{
2372		verboselog(device->machine(), 2, "mc68328_r (%04x): LBLKC = %02x\n", mem_mask, mc68328->regs.lblkc);
	2372	verboselog(space.machine(), 2, "mc68328_r (%04x): LBLKC = %02x\n", mem_mask, mc68328->regs.lblkc);
2373	2373	return mc68328->regs.lblkc;
2374	2374	}
2375	2375	else
2376	2376	{
2377		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa1e)\n", mem_mask);
	2377	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa1e)\n", mem_mask);
2378	2378	}
2379	2379	break;
2380	2380
2381	2381	case 0xa20:
2382	2382	if( mem_mask & 0x00ff )
2383	2383	{
2384		verboselog(device->machine(), 2, "mc68328_r (%04x): LPOLCF = %02x\n", mem_mask, mc68328->regs.lpolcf);
	2384	verboselog(space.machine(), 2, "mc68328_r (%04x): LPOLCF = %02x\n", mem_mask, mc68328->regs.lpolcf);
2385	2385	return mc68328->regs.lpolcf;
2386	2386	}
2387	2387	else
2388	2388	{
2389		verboselog(device->machine(), 2, "mc68328_r (%04x): LPICF = %02x\n", mem_mask, mc68328->regs.lpicf);
	2389	verboselog(space.machine(), 2, "mc68328_r (%04x): LPICF = %02x\n", mem_mask, mc68328->regs.lpicf);
2390	2390	return mc68328->regs.lpicf << 8;
2391	2391	}
2392	2392	break;
r18055	r18056
2394	2394	case 0xa22:
2395	2395	if( mem_mask & 0x00ff )
2396	2396	{
2397		verboselog(device->machine(), 2, "mc68328_r (%04x): LACDRC = %02x\n", mem_mask, mc68328->regs.lacdrc);
	2397	verboselog(space.machine(), 2, "mc68328_r (%04x): LACDRC = %02x\n", mem_mask, mc68328->regs.lacdrc);
2398	2398	return mc68328->regs.lacdrc;
2399	2399	}
2400	2400	else
2401	2401	{
2402		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa22)\n", mem_mask);
	2402	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa22)\n", mem_mask);
2403	2403	}
2404	2404	break;
2405	2405
2406	2406	case 0xa24:
2407	2407	if( mem_mask & 0x00ff )
2408	2408	{
2409		verboselog(device->machine(), 2, "mc68328_r (%04x): LPXCD = %02x\n", mem_mask, mc68328->regs.lpxcd);
	2409	verboselog(space.machine(), 2, "mc68328_r (%04x): LPXCD = %02x\n", mem_mask, mc68328->regs.lpxcd);
2410	2410	return mc68328->regs.lpxcd;
2411	2411	}
2412	2412	else
2413	2413	{
2414		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa24)\n", mem_mask);
	2414	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa24)\n", mem_mask);
2415	2415	}
2416	2416	break;
2417	2417
2418	2418	case 0xa26:
2419	2419	if( mem_mask & 0x00ff )
2420	2420	{
2421		verboselog(device->machine(), 2, "mc68328_r (%04x): LCKCON = %02x\n", mem_mask, mc68328->regs.lckcon);
	2421	verboselog(space.machine(), 2, "mc68328_r (%04x): LCKCON = %02x\n", mem_mask, mc68328->regs.lckcon);
2422	2422	return mc68328->regs.lckcon;
2423	2423	}
2424	2424	else
2425	2425	{
2426		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa26)\n", mem_mask);
	2426	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa26)\n", mem_mask);
2427	2427	}
2428	2428	break;
2429	2429
2430	2430	case 0xa28:
2431	2431	if( mem_mask & 0x00ff )
2432	2432	{
2433		verboselog(device->machine(), 2, "mc68328_r (%04x): LLBAR = %02x\n", mem_mask, mc68328->regs.llbar);
	2433	verboselog(space.machine(), 2, "mc68328_r (%04x): LLBAR = %02x\n", mem_mask, mc68328->regs.llbar);
2434	2434	return mc68328->regs.llbar;
2435	2435	}
2436	2436	else
2437	2437	{
2438		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa28)\n", mem_mask);
	2438	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa28)\n", mem_mask);
2439	2439	}
2440	2440	break;
2441	2441
2442	2442	case 0xa2a:
2443	2443	if( mem_mask & 0x00ff )
2444	2444	{
2445		verboselog(device->machine(), 2, "mc68328_r (%04x): LOTCR = %02x\n", mem_mask, mc68328->regs.lotcr);
	2445	verboselog(space.machine(), 2, "mc68328_r (%04x): LOTCR = %02x\n", mem_mask, mc68328->regs.lotcr);
2446	2446	return mc68328->regs.lotcr;
2447	2447	}
2448	2448	else
2449	2449	{
2450		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa2a)\n", mem_mask);
	2450	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa2a)\n", mem_mask);
2451	2451	}
2452	2452	break;
2453	2453
2454	2454	case 0xa2c:
2455	2455	if( mem_mask & 0x00ff )
2456	2456	{
2457		verboselog(device->machine(), 2, "mc68328_r (%04x): LPOSR = %02x\n", mem_mask, mc68328->regs.lposr);
	2457	verboselog(space.machine(), 2, "mc68328_r (%04x): LPOSR = %02x\n", mem_mask, mc68328->regs.lposr);
2458	2458	return mc68328->regs.lposr;
2459	2459	}
2460	2460	else
2461	2461	{
2462		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa2c)\n", mem_mask);
	2462	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa2c)\n", mem_mask);
2463	2463	}
2464	2464	break;
2465	2465
2466	2466	case 0xa30:
2467	2467	if( mem_mask & 0x00ff )
2468	2468	{
2469		verboselog(device->machine(), 2, "mc68328_r (%04x): LFRCM = %02x\n", mem_mask, mc68328->regs.lfrcm);
	2469	verboselog(space.machine(), 2, "mc68328_r (%04x): LFRCM = %02x\n", mem_mask, mc68328->regs.lfrcm);
2470	2470	return mc68328->regs.lfrcm;
2471	2471	}
2472	2472	else
2473	2473	{
2474		verboselog(device->machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa30)\n", mem_mask);
	2474	verboselog(space.machine(), 2, "mc68328_r (%04x): Unknown address (0xfffa30)\n", mem_mask);
2475	2475	}
2476	2476	break;
2477	2477
2478	2478	case 0xa32:
2479		verboselog(device->machine(), 2, "mc68328_r (%04x): LGPMR = %04x\n", mem_mask, mc68328->regs.lgpmr);
	2479	verboselog(space.machine(), 2, "mc68328_r (%04x): LGPMR = %04x\n", mem_mask, mc68328->regs.lgpmr);
2480	2480	return mc68328->regs.lgpmr;
2481	2481
2482	2482	case 0xb00:
2483		verboselog(device->machine(), 2, "mc68328_r (%04x): HMSR(0) = %04x\n", mem_mask, mc68328->regs.hmsr & 0x0000ffff);
	2483	verboselog(space.machine(), 2, "mc68328_r (%04x): HMSR(0) = %04x\n", mem_mask, mc68328->regs.hmsr & 0x0000ffff);
2484	2484	return mc68328->regs.hmsr & 0x0000ffff;
2485	2485
2486	2486	case 0xb02:
2487		verboselog(device->machine(), 2, "mc68328_r (%04x): HMSR(16) = %04x\n", mem_mask, mc68328->regs.hmsr >> 16);
	2487	verboselog(space.machine(), 2, "mc68328_r (%04x): HMSR(16) = %04x\n", mem_mask, mc68328->regs.hmsr >> 16);
2488	2488	return mc68328->regs.hmsr >> 16;
2489	2489
2490	2490	case 0xb04:
2491		verboselog(device->machine(), 2, "mc68328_r (%04x): ALARM(0) = %04x\n", mem_mask, mc68328->regs.alarm & 0x0000ffff);
	2491	verboselog(space.machine(), 2, "mc68328_r (%04x): ALARM(0) = %04x\n", mem_mask, mc68328->regs.alarm & 0x0000ffff);
2492	2492	return mc68328->regs.alarm & 0x0000ffff;
2493	2493
2494	2494	case 0xb06:
2495		verboselog(device->machine(), 2, "mc68328_r (%04x): ALARM(16) = %04x\n", mem_mask, mc68328->regs.alarm >> 16);
	2495	verboselog(space.machine(), 2, "mc68328_r (%04x): ALARM(16) = %04x\n", mem_mask, mc68328->regs.alarm >> 16);
2496	2496	return mc68328->regs.alarm >> 16;
2497	2497
2498	2498	case 0xb0c:
2499		verboselog(device->machine(), 2, "mc68328_r (%04x): RTCCTL = %04x\n", mem_mask, mc68328->regs.rtcctl);
	2499	verboselog(space.machine(), 2, "mc68328_r (%04x): RTCCTL = %04x\n", mem_mask, mc68328->regs.rtcctl);
2500	2500	return mc68328->regs.rtcctl;
2501	2501
2502	2502	case 0xb0e:
2503		verboselog(device->machine(), 2, "mc68328_r (%04x): RTCISR = %04x\n", mem_mask, mc68328->regs.rtcisr);
	2503	verboselog(space.machine(), 2, "mc68328_r (%04x): RTCISR = %04x\n", mem_mask, mc68328->regs.rtcisr);
2504	2504	return mc68328->regs.rtcisr;
2505	2505
2506	2506	case 0xb10:
2507		verboselog(device->machine(), 2, "mc68328_r (%04x): RTCIENR = %04x\n", mem_mask, mc68328->regs.rtcienr);
	2507	verboselog(space.machine(), 2, "mc68328_r (%04x): RTCIENR = %04x\n", mem_mask, mc68328->regs.rtcienr);
2508	2508	return mc68328->regs.rtcienr;
2509	2509
2510	2510	case 0xb12:
2511		verboselog(device->machine(), 2, "mc68328_r (%04x): STPWTCH = %04x\n", mem_mask, mc68328->regs.stpwtch);
	2511	verboselog(space.machine(), 2, "mc68328_r (%04x): STPWTCH = %04x\n", mem_mask, mc68328->regs.stpwtch);
2512	2512	return mc68328->regs.stpwtch;
2513	2513
2514	2514	default:
2515		verboselog(device->machine(), 0, "mc68328_r (%04x): Unknown address (0x%06x)\n", mem_mask, 0xfff000 + address);
	2515	verboselog(space.machine(), 0, "mc68328_r (%04x): Unknown address (0x%06x)\n", mem_mask, 0xfff000 + address);
2516	2516	break;
2517	2517	}
2518	2518	return 0;

trunk/src/mess/machine/bebox.c

r18055	r18056
481	481
482	482	static READ8_DEVICE_HANDLER( get_slave_ack )
483	483	{
484		bebox_state *state = device->machine().driver_data<bebox_state>();
	484	bebox_state *state = space.machine().driver_data<bebox_state>();
485	485	if (offset==2) { // IRQ = 2
486	486	return pic8259_acknowledge(state->m_devices.pic8259_slave);
487	487	}
r18055	r18056
696	696
697	697
698	698	static READ8_DEVICE_HANDLER( bebox_dma8237_fdc_dack_r ) {
699		return pc_fdc_dack_r(device->machine(),space);
	699	return pc_fdc_dack_r(space.machine(),space);
700	700	}
701	701
702	702
703	703	static WRITE8_DEVICE_HANDLER( bebox_dma8237_fdc_dack_w ) {
704		pc_fdc_dack_w( device->machine(), space, data );
	704	pc_fdc_dack_w( space.machine(), space, data );
705	705	}
706	706
707	707

trunk/src/mess/machine/micropolis.c

r18055	r18056
295	295	else
296	296	{
297	297	if (VERBOSE)
298		logerror("%s: micropolis_data_w $%02X\n", device->machine().describe_context(), data);
	298	logerror("%s: micropolis_data_w $%02X\n", space.machine().describe_context(), data);
299	299	}
300	300	w->data = data;
301	301	}

trunk/src/mess/machine/tf20.c

r18055	r18056
94	94
95	95	static READ8_DEVICE_HANDLER( tf20_upd765_tc_r )
96	96	{
97		logerror("%s: tf20_upd765_tc_r\n", device->machine().describe_context());
	97	logerror("%s: tf20_upd765_tc_r\n", space.machine().describe_context());
98	98
99	99	/* toggle tc on read */
100	100	upd765_tc_w(device, ASSERT_LINE);
101		device->machine().scheduler().timer_set(attotime::zero, FUNC(tf20_upd765_tc_reset), 0, device);
	101	space.machine().scheduler().timer_set(attotime::zero, FUNC(tf20_upd765_tc_reset), 0, device);
102	102
103	103	return 0xff;
104	104	}

trunk/src/mess/machine/c64.c

r18055	r18056
80	80
81	81	static READ8_DEVICE_HANDLER( c64_cia0_port_a_r )
82	82	{
83		UINT8 cia0portb = mos6526_pb_r(device->machine().device("cia_0"), space, 0);
	83	UINT8 cia0portb = mos6526_pb_r(space.machine().device("cia_0"), space, 0);
84	84
85	85	return cbm_common_cia0_port_a_r(device, cia0portb);
86	86	}
87	87
88	88	static READ8_DEVICE_HANDLER( c64_cia0_port_b_r )
89	89	{
90		UINT8 cia0porta = mos6526_pa_r(device->machine().device("cia_0"), space, 0);
	90	UINT8 cia0porta = mos6526_pa_r(space.machine().device("cia_0"), space, 0);
91	91
92	92	return cbm_common_cia0_port_b_r(device, cia0porta);
93	93	}
94	94
95	95	static WRITE8_DEVICE_HANDLER( c64_cia0_port_b_w )
96	96	{
97		device_t *vic2 = device->machine().device("vic2");
	97	device_t *vic2 = space.machine().device("vic2");
98	98	vic2_lightpen_write(vic2, data & 0x10);
99	99	}
100	100
r18055	r18056
177	177	*/
178	178	static READ8_DEVICE_HANDLER( c64_cia1_port_a_r )
179	179	{
180		legacy_c64_state *state = device->machine().driver_data<legacy_c64_state>();
	180	legacy_c64_state *state = space.machine().driver_data<legacy_c64_state>();
181	181
182	182	UINT8 value = 0xff;
183	183
r18055	r18056
192	192
193	193	static WRITE8_DEVICE_HANDLER( c64_cia1_port_a_w )
194	194	{
195		legacy_c64_state *state = device->machine().driver_data<legacy_c64_state>();
	195	legacy_c64_state *state = space.machine().driver_data<legacy_c64_state>();
196	196	static const int helper[4] = {0xc000, 0x8000, 0x4000, 0x0000};
197	197
198	198	state->m_iec->clk_w(!(data & 0x10));
r18055	r18056
545	545
546	546	WRITE8_DEVICE_HANDLER(c64_m6510_port_write)
547	547	{
548		legacy_c64_state *state = device->machine().driver_data<legacy_c64_state>();
	548	legacy_c64_state *state = space.machine().driver_data<legacy_c64_state>();
549	549
550	550	UINT8 direction = offset; // HACK ALERT!
551	551
r18055	r18056
568	568	{
569	569	if (direction & 0x08)
570	570	{
571		device->machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x08) ? -(0x5a9e >> 1) : +(0x5a9e >> 1));
	571	space.machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x08) ? -(0x5a9e >> 1) : +(0x5a9e >> 1));
572	572	}
573	573
574	574	if (direction & 0x20)
575	575	{
576	576	if(!(data & 0x20))
577	577	{
578		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR);
	578	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR);
579	579	state->m_datasette_timer->adjust(attotime::zero, 0, attotime::from_hz(44100));
580	580	}
581	581	else
582	582	{
583		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR);
	583	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR);
584	584	state->m_datasette_timer->reset();
585	585	}
586	586	}
587	587	}
588	588
589	589	if (!state->m_ultimax)
590		c64_bankswitch(device->machine(), 0);
	590	c64_bankswitch(space.machine(), 0);
591	591
592	592	state->m_memory[0x000] = device->memory().space(AS_PROGRAM).read_byte(0);
593	593	state->m_memory[0x001] = device->memory().space(AS_PROGRAM).read_byte(1);
r18055	r18056
596	596
597	597	READ8_DEVICE_HANDLER(c64_m6510_port_read)
598	598	{
599		legacy_c64_state *state = device->machine().driver_data<legacy_c64_state>();
	599	legacy_c64_state *state = space.machine().driver_data<legacy_c64_state>();
600	600	UINT8 data = state->m_port_data;
601	601
602	602	if (state->m_tape_on)
603	603	{
604		if ((device->machine().device<cassette_image_device>(CASSETTE_TAG)->get_state() & CASSETTE_MASK_UISTATE) != CASSETTE_STOPPED)
	604	if ((space.machine().device<cassette_image_device>(CASSETTE_TAG)->get_state() & CASSETTE_MASK_UISTATE) != CASSETTE_STOPPED)
605	605	data &= ~0x10;
606	606	else
607	607	data |=  0x10;

trunk/src/mess/machine/pc.c

r18055	r18056
200	200
201	201	static READ8_DEVICE_HANDLER( pc_dma8237_fdc_dack_r )
202	202	{
203		return pc_fdc_dack_r(device->machine(), space);
	203	return pc_fdc_dack_r(space.machine(), space);
204	204	}
205	205
206	206
r18055	r18056
212	212
213	213	static WRITE8_DEVICE_HANDLER( pc_dma8237_fdc_dack_w )
214	214	{
215		pc_fdc_dack_w( device->machine(), space, data );
	215	pc_fdc_dack_w( space.machine(), space, data );
216	216	}
217	217
218	218
r18055	r18056
223	223
224	224	static WRITE8_DEVICE_HANDLER( pc_dma8237_0_dack_w )
225	225	{
226		pc_state *st = device->machine().driver_data<pc_state>();
	226	pc_state *st = space.machine().driver_data<pc_state>();
227	227	st->m_u73_q2 = 0;
228	228	i8237_dreq0_w( st->m_dma8237, st->m_u73_q2 );
229	229	}
r18055	r18056
757	757	static READ8_DEVICE_HANDLER (ibm5160_ppi_porta_r)
758	758	{
759	759	int data = 0xFF;
760		running_machine &machine = device->machine();
761		pc_state *st = device->machine().driver_data<pc_state>();
	760	running_machine &machine = space.machine();
	761	pc_state *st = space.machine().driver_data<pc_state>();
762	762
763	763	/* KB port A */
764	764	if (st->m_ppi_keyboard_clear)
r18055	r18056
772	772	*      01 - color 40x25
773	773	* 6-7  The number of floppy disk drives
774	774	*/
775		data = device->machine().root_device().ioport("DSW0")->read();
	775	data = space.machine().root_device().ioport("DSW0")->read();
776	776	}
777	777	else
778	778	{
r18055	r18056
785	785
786	786	static READ8_DEVICE_HANDLER ( ibm5160_ppi_portc_r )
787	787	{
788		pc_state *st = device->machine().driver_data<pc_state>();
	788	pc_state *st = space.machine().driver_data<pc_state>();
789	789	int timer2_output = pit8253_get_output( st->m_pit8253, 2 );
790	790	int data=0xff;
791		running_machine &machine = device->machine();
	791	running_machine &machine = space.machine();
792	792
793	793	data&=~0x80; // no parity error
794	794	data&=~0x40; // no error on expansion board
r18055	r18056
797	797	if (st->m_ppi_portc_switch_high)
798	798	{
799	799	/* read hi nibble of S2 */
800		data = (data & 0xf0) | ((device->machine().root_device().ioport("DSW0")->read() >> 4) & 0x0f);
	800	data = (data & 0xf0) | ((space.machine().root_device().ioport("DSW0")->read() >> 4) & 0x0f);
801	801	PIO_LOG(1,"PIO_C_r (hi)",("$%02x\n", data));
802	802	}
803	803	else
804	804	{
805	805	/* read lo nibble of S2 */
806		data = (data & 0xf0) | (device->machine().root_device().ioport("DSW0")->read() & 0x0f);
	806	data = (data & 0xf0) | (space.machine().root_device().ioport("DSW0")->read() & 0x0f);
807	807	PIO_LOG(1,"PIO_C_r (lo)",("$%02x\n", data));
808	808	}
809	809
r18055	r18056
819	819
820	820	static WRITE8_DEVICE_HANDLER( ibm5160_ppi_portb_w )
821	821	{
822		pc_state *st = device->machine().driver_data<pc_state>();
	822	pc_state *st = space.machine().driver_data<pc_state>();
823	823
824	824	/* PPI controller port B*/
825	825	st->m_ppi_portb = data;
r18055	r18056
827	827	st->m_ppi_keyboard_clear = data & 0x80;
828	828	st->m_ppi_keyb_clock = data & 0x40;
829	829	pit8253_gate2_w(st->m_pit8253, BIT(data, 0));
830		pc_speaker_set_spkrdata( device->machine(), data & 0x02 );
	830	pc_speaker_set_spkrdata( space.machine(), data & 0x02 );
831	831
832	832	st->m_ppi_clock_signal = ( st->m_ppi_keyb_clock ) ? 1 : 0;
833	833	st->m_pc_kbdc->clock_write_from_mb(st->m_ppi_clock_signal);
r18055	r18056
856	856	static READ8_DEVICE_HANDLER (pc_ppi_porta_r)
857	857	{
858	858	int data = 0xFF;
859		running_machine &machine = device->machine();
860		pc_state *st = device->machine().driver_data<pc_state>();
	859	running_machine &machine = space.machine();
	860	pc_state *st = space.machine().driver_data<pc_state>();
861	861
862	862	/* KB port A */
863	863	if (st->m_ppi_keyboard_clear)
r18055	r18056
871	871	*      01 - color 40x25
872	872	* 6-7  The number of floppy disk drives
873	873	*/
874		data = device->machine().root_device().ioport("DSW0")->read();
	874	data = space.machine().root_device().ioport("DSW0")->read();
875	875	}
876	876	else
877	877	{
r18055	r18056
884	884
885	885	static WRITE8_DEVICE_HANDLER( pc_ppi_portb_w )
886	886	{
887		pc_state *st = device->machine().driver_data<pc_state>();
	887	pc_state *st = space.machine().driver_data<pc_state>();
888	888	/* PPI controller port B*/
889	889	st->m_ppi_portb = data;
890	890	st->m_ppi_portc_switch_high = data & 0x08;
891	891	st->m_ppi_keyboard_clear = data & 0x80;
892	892	st->m_ppi_keyb_clock = data & 0x40;
893	893	pit8253_gate2_w(st->m_pit8253, BIT(data, 0));
894		pc_speaker_set_spkrdata( device->machine(), data & 0x02 );
	894	pc_speaker_set_spkrdata( space.machine(), data & 0x02 );
895	895	pc_keyb_set_clock( st->m_ppi_keyb_clock );
896	896
897	897	if ( st->m_ppi_keyboard_clear )
r18055	r18056
959	959
960	960	static READ8_DEVICE_HANDLER ( mc1502_ppi_porta_r )
961	961	{
962		running_machine &machine = device->machine();
	962	running_machine &machine = space.machine();
963	963
964	964	DBG_LOG(1,"mc1502_ppi_porta_r",("= %02X\n", mc1502_keyb.latch));
965	965	return mc1502_keyb.latch;
r18055	r18056
967	967
968	968	static WRITE8_DEVICE_HANDLER ( mc1502_ppi_porta_w )
969	969	{
970		pc_state *st = device->machine().driver_data<pc_state>();
971		running_machine &machine = device->machine();
	970	pc_state *st = space.machine().driver_data<pc_state>();
	971	running_machine &machine = space.machine();
972	972
973	973	DBG_LOG(1,"mc1502_ppi_porta_w",("( %02X )\n", data));
974	974	mc1502_keyb.latch = data;
r18055	r18056
979	979
980	980	static WRITE8_DEVICE_HANDLER ( mc1502_ppi_portb_w )
981	981	{
982		pc_state *st = device->machine().driver_data<pc_state>();
983		running_machine &machine = device->machine();
	982	pc_state *st = space.machine().driver_data<pc_state>();
	983	running_machine &machine = space.machine();
984	984
985	985	DBG_LOG(2,"mc1502_ppi_portb_w",("( %02X )\n", data));
986	986	st->m_ppi_portb = data;
987		pit8253_gate2_w(device->machine().device("pit8253"), BIT(data, 0));
988		pc_speaker_set_spkrdata( device->machine(), data & 0x02 );
	987	pit8253_gate2_w(space.machine().device("pit8253"), BIT(data, 0));
	988	pc_speaker_set_spkrdata( space.machine(), data & 0x02 );
989	989	}
990	990
991	991	static READ8_DEVICE_HANDLER ( mc1502_ppi_portc_r )
992	992	{
993		running_machine &machine = device->machine();
994		pc_state *st = device->machine().driver_data<pc_state>();
995		int timer2_output = pit8253_get_output( device->machine().device("pit8253"), 2 );
	993	running_machine &machine = space.machine();
	994	pc_state *st = space.machine().driver_data<pc_state>();
	995	int timer2_output = pit8253_get_output( space.machine().device("pit8253"), 2 );
996	996	int data = 0xff;
997		double tap_val = (device->machine().device<cassette_image_device>(CASSETTE_TAG)->input());
	997	double tap_val = (space.machine().device<cassette_image_device>(CASSETTE_TAG)->input());
998	998
999	999	//  0x80 -- serial RxD
1000	1000	//  0x40 -- CASS IN, also loops back T2OUT (gated by CASWR)
r18055	r18056
1011	1011
1012	1012	static READ8_DEVICE_HANDLER ( mc1502_kppi_porta_r )
1013	1013	{
1014		running_machine &machine = device->machine();
	1014	running_machine &machine = space.machine();
1015	1015	UINT8 key = 0;
1016	1016
1017	1017	if (mc1502_keyb.mask & 0x0001) { key |= machine.root_device().ioport("Y1")->read(); }
r18055	r18056
1033	1033
1034	1034	static WRITE8_DEVICE_HANDLER ( mc1502_kppi_portb_w )
1035	1035	{
1036		running_machine &machine = device->machine();
	1036	running_machine &machine = space.machine();
1037	1037
1038	1038	mc1502_keyb.mask &= ~255;
1039	1039	mc1502_keyb.mask |= data ^ 255;
r18055	r18056
1046	1046
1047	1047	static WRITE8_DEVICE_HANDLER ( mc1502_kppi_portc_w )
1048	1048	{
1049		running_machine &machine = device->machine();
	1049	running_machine &machine = space.machine();
1050	1050
1051	1051	mc1502_keyb.mask &= ~(7 << 8);
1052	1052	mc1502_keyb.mask |= ((data ^ 7) & 7) << 8;
r18055	r18056
1056	1056
1057	1057	static WRITE8_DEVICE_HANDLER ( pcjr_ppi_portb_w )
1058	1058	{
1059		pc_state *st = device->machine().driver_data<pc_state>();
	1059	pc_state *st = space.machine().driver_data<pc_state>();
1060	1060	/* KB controller port B */
1061	1061	st->m_ppi_portb = data;
1062	1062	st->m_ppi_portc_switch_high = data & 0x08;
1063		pit8253_gate2_w(device->machine().device("pit8253"), BIT(data, 0));
1064		pc_speaker_set_spkrdata( device->machine(), data & 0x02 );
	1063	pit8253_gate2_w(space.machine().device("pit8253"), BIT(data, 0));
	1064	pc_speaker_set_spkrdata( space.machine(), data & 0x02 );
1065	1065
1066		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(( data & 0x08 ) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED,CASSETTE_MASK_MOTOR);
	1066	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(( data & 0x08 ) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED,CASSETTE_MASK_MOTOR);
1067	1067	}
1068	1068
1069	1069
r18055	r18056
1073	1073	static READ8_DEVICE_HANDLER (pcjr_ppi_porta_r )
1074	1074	{
1075	1075	int data;
1076		running_machine &machine = device->machine();
	1076	running_machine &machine = space.machine();
1077	1077
1078	1078	data = 0xff;
1079	1079	PIO_LOG(1,"PIO_A_r",("$%02x\n", data));
r18055	r18056
1094	1094	*/
1095	1095	static READ8_DEVICE_HANDLER ( pcjr_ppi_portc_r )
1096	1096	{
1097		pc_state *st = device->machine().driver_data<pc_state>();
1098		int timer2_output = pit8253_get_output( device->machine().device("pit8253"), 2 );
	1097	pc_state *st = space.machine().driver_data<pc_state>();
	1098	int timer2_output = pit8253_get_output( space.machine().device("pit8253"), 2 );
1099	1099	int data=0xff;
1100	1100
1101	1101	data&=~0x80;
1102	1102	data &= ~0x04;      /* floppy drive installed */
1103		if ( device->machine().device<ram_device>(RAM_TAG)->size() > 64 * 1024 )   /* more than 64KB ram installed */
	1103	if ( space.machine().device<ram_device>(RAM_TAG)->size() > 64 * 1024 )   /* more than 64KB ram installed */
1104	1104	data &= ~0x08;
1105	1105	data = ( data & ~0x01 ) | ( pcjr_keyb.latch ? 0x01: 0x00 );
1106	1106	if ( ! ( st->m_ppi_portb & 0x08 ) )
1107	1107	{
1108		double tap_val = (device->machine().device<cassette_image_device>(CASSETTE_TAG)->input());
	1108	double tap_val = (space.machine().device<cassette_image_device>(CASSETTE_TAG)->input());
1109	1109
1110	1110	if ( tap_val < 0 )
1111	1111	{
r18055	r18056
1265	1265	data = wd17xx_drq_r(device);
1266	1266	if (!data && !wd17xx_intrq_r(device)) {
1267	1267	/* fake cpu halt by resetting PC one insn back */
1268		newpc = device->machine().firstcpu->pc();
1269		device->machine().firstcpu->set_pc( newpc - 1 );
	1268	newpc = space.machine().firstcpu->pc();
	1269	space.machine().firstcpu->set_pc( newpc - 1 );
1270	1270	}
1271	1271
1272	1272	return data;

trunk/src/mess/machine/bbc.c

r18055	r18056
908	908
909	909	static WRITE8_DEVICE_HANDLER( bbcb_via_system_write_porta )
910	910	{
911		bbc_state *state = device->machine().driver_data<bbc_state>();
	911	bbc_state *state = space.machine().driver_data<bbc_state>();
912	912	//logerror("SYSTEM write porta %d\n",data);
913	913
914	914	state->m_via_system_porta = data;
r18055	r18056
928	928
929	929	static WRITE8_DEVICE_HANDLER( bbcb_via_system_write_portb )
930	930	{
931		bbc_state *state = device->machine().driver_data<bbc_state>();
	931	bbc_state *state = space.machine().driver_data<bbc_state>();
932	932	int bit, value;
933	933	bit = data & 0x07;
934	934	value = (data >> 3) & 0x01;
r18055	r18056
1127	1127
1128	1128	static READ8_DEVICE_HANDLER( bbcb_via_system_read_porta )
1129	1129	{
1130		bbc_state *state = device->machine().driver_data<bbc_state>();
	1130	bbc_state *state = space.machine().driver_data<bbc_state>();
1131	1131	//logerror("SYSTEM read porta %d\n",state->m_via_system_porta);
1132	1132	return state->m_via_system_porta;
1133	1133	}
r18055	r18056
1158	1158
1159	1159	//logerror("SYSTEM read portb %d\n",0xf | input_port(machine, "IN0")|(TMSint<<6)|(TMSrdy<<7));
1160	1160
1161		return (0xf | device->machine().root_device().ioport("IN0")->read()|(TMSint<<6)|(TMSrdy<<7));
	1161	return (0xf | space.machine().root_device().ioport("IN0")->read()|(TMSint<<6)|(TMSrdy<<7));
1162	1162	}
1163	1163
1164	1164
r18055	r18056
1172	1172	/* joystick EOC */
1173	1173	static READ8_DEVICE_HANDLER( bbcb_via_system_read_cb1 )
1174	1174	{
1175		return uPD7002_EOC_r(device->machine().device("upd7002"),space,0);
	1175	return uPD7002_EOC_r(space.machine().device("upd7002"),space,0);
1176	1176	}
1177	1177
1178	1178
r18055	r18056
1233	1233
1234	1234	static WRITE8_DEVICE_HANDLER( bbcb_via_user_write_portb )
1235	1235	{
1236		bbc_state *state = device->machine().driver_data<bbc_state>();
	1236	bbc_state *state = space.machine().driver_data<bbc_state>();
1237	1237	state->m_userport = data;
1238	1238	}
1239	1239

trunk/src/mess/machine/upd765.c

r18055	r18056
803	803	{
804	804	upd765_t *fdc = get_safe_token(device);
805	805	if (LOG_EXTRA)
806		logerror("%s: upd765_status_r: %02x\n", device->machine().describe_context(), fdc->FDC_main);
	806	logerror("%s: upd765_status_r: %02x\n", space.machine().describe_context(), fdc->FDC_main);
807	807	return fdc->FDC_main;
808	808	}
809	809

trunk/src/mess/machine/macpci.c

r18055	r18056
51	51
52	52	static READ8_DEVICE_HANDLER(mac_via_in_a)
53	53	{
54		//  macpci_state *mac = device->machine().driver_data<macpci_state>();
	54	//  macpci_state *mac = space.machine().driver_data<macpci_state>();
55	55
56	56	//    printf("VIA1 IN_A (PC %x)\n", mac->m_maincpu->pc());
57	57
r18055	r18056
61	61	static READ8_DEVICE_HANDLER(mac_via_in_b)
62	62	{
63	63	int val = 0;
64		macpci_state *mac = device->machine().driver_data<macpci_state>();
	64	macpci_state *mac = space.machine().driver_data<macpci_state>();
65	65
66	66	val |= mac->m_cuda->get_treq()<<3;
67	67
r18055	r18056
72	72
73	73	static WRITE8_DEVICE_HANDLER(mac_via_out_a)
74	74	{
75		//  macpci_state *mac = device->machine().driver_data<macpci_state>();
	75	//  macpci_state *mac = space.machine().driver_data<macpci_state>();
76	76
77	77	//    printf("VIA1 OUT A: %02x (PC %x)\n", data, mac->m_maincpu->pc());
78	78	}
79	79
80	80	static WRITE8_DEVICE_HANDLER(mac_via_out_b)
81	81	{
82		macpci_state *mac = device->machine().driver_data<macpci_state>();
	82	macpci_state *mac = space.machine().driver_data<macpci_state>();
83	83
84	84	//    printf("VIA1 OUT B: %02x (PC %x)\n", data, mac->m_maincpu->pc());
85	85
r18055	r18056
125	125	static READ8_DEVICE_HANDLER(mac_adb_via_in_cb2)
126	126	{
127	127	UINT8 ret;
128		macpci_state *mac = device->machine().driver_data<macpci_state>();
	128	macpci_state *mac = space.machine().driver_data<macpci_state>();
129	129
130	130	ret = mac->m_cuda->get_via_data();
131	131	#if LOG_ADB
r18055	r18056
137	137
138	138	static WRITE8_DEVICE_HANDLER(mac_adb_via_out_cb2)
139	139	{
140		macpci_state *mac = device->machine().driver_data<macpci_state>();
	140	macpci_state *mac = space.machine().driver_data<macpci_state>();
141	141
142	142	mac->m_cuda->set_via_data(data & 1);
143	143	}

trunk/src/mess/machine/c65.c

r18055	r18056
72	72
73	73	static READ8_DEVICE_HANDLER( c65_cia0_port_a_r )
74	74	{
75		UINT8 cia0portb = mos6526_pb_r(device->machine().device("cia_0"), space, 0);
	75	UINT8 cia0portb = mos6526_pb_r(space.machine().device("cia_0"), space, 0);
76	76
77	77	return cbm_common_cia0_port_a_r(device, cia0portb);
78	78	}
79	79
80	80	static READ8_DEVICE_HANDLER( c65_cia0_port_b_r )
81	81	{
82		c65_state *state = device->machine().driver_data<c65_state>();
	82	c65_state *state = space.machine().driver_data<c65_state>();
83	83	UINT8 value = 0xff;
84		UINT8 cia0porta = mos6526_pa_r(device->machine().device("cia_0"), space, 0);
	84	UINT8 cia0porta = mos6526_pa_r(space.machine().device("cia_0"), space, 0);
85	85
86	86	value &= cbm_common_cia0_port_b_r(device, cia0porta);
87	87
r18055	r18056
94	94	static WRITE8_DEVICE_HANDLER( c65_cia0_port_b_w )
95	95	{
96	96	//  was there lightpen support in c65 video chip?
97		//  device_t *vic3 = device->machine().device("vic3");
	97	//  device_t *vic3 = space.machine().device("vic3");
98	98	//  vic3_lightpen_write(vic3, data & 0x10);
99	99	}
100	100
r18055	r18056
167	167	*/
168	168	static READ8_DEVICE_HANDLER( c65_cia1_port_a_r )
169	169	{
170		c65_state *state = device->machine().driver_data<c65_state>();
	170	c65_state *state = space.machine().driver_data<c65_state>();
171	171	UINT8 value = 0xff;
172	172
173	173	if (!state->m_iec->clk_r())
r18055	r18056
181	181
182	182	static WRITE8_DEVICE_HANDLER( c65_cia1_port_a_w )
183	183	{
184		c65_state *state = device->machine().driver_data<c65_state>();
	184	c65_state *state = space.machine().driver_data<c65_state>();
185	185	static const int helper[4] = {0xc000, 0x8000, 0x4000, 0x0000};
186	186
187	187	state->m_iec->atn_w(!BIT(data, 3));

trunk/src/mess/machine/radio86.c

r18055	r18056
43	43	}
44	44	static READ8_DEVICE_HANDLER (radio86_8255_portb_r2 )
45	45	{
46		radio86_state *state = device->machine().driver_data<radio86_state>();
	46	radio86_state *state = space.machine().driver_data<radio86_state>();
47	47	UINT8 key = 0xff;
48	48	if ((state->m_keyboard_mask & 0x01)!=0) { key &= state->ioport("LINE0")->read(); }
49		if ((state->m_keyboard_mask & 0x02)!=0) { key &= device->machine().root_device().ioport("LINE1")->read(); }
50		if ((state->m_keyboard_mask & 0x04)!=0) { key &= device->machine().root_device().ioport("LINE2")->read(); }
51		if ((state->m_keyboard_mask & 0x08)!=0) { key &= device->machine().root_device().ioport("LINE3")->read(); }
52		if ((state->m_keyboard_mask & 0x10)!=0) { key &= device->machine().root_device().ioport("LINE4")->read(); }
53		if ((state->m_keyboard_mask & 0x20)!=0) { key &= device->machine().root_device().ioport("LINE5")->read(); }
54		if ((state->m_keyboard_mask & 0x40)!=0) { key &= device->machine().root_device().ioport("LINE6")->read(); }
55		if ((state->m_keyboard_mask & 0x80)!=0) { key &= device->machine().root_device().ioport("LINE7")->read(); }
	49	if ((state->m_keyboard_mask & 0x02)!=0) { key &= space.machine().root_device().ioport("LINE1")->read(); }
	50	if ((state->m_keyboard_mask & 0x04)!=0) { key &= space.machine().root_device().ioport("LINE2")->read(); }
	51	if ((state->m_keyboard_mask & 0x08)!=0) { key &= space.machine().root_device().ioport("LINE3")->read(); }
	52	if ((state->m_keyboard_mask & 0x10)!=0) { key &= space.machine().root_device().ioport("LINE4")->read(); }
	53	if ((state->m_keyboard_mask & 0x20)!=0) { key &= space.machine().root_device().ioport("LINE5")->read(); }
	54	if ((state->m_keyboard_mask & 0x40)!=0) { key &= space.machine().root_device().ioport("LINE6")->read(); }
	55	if ((state->m_keyboard_mask & 0x80)!=0) { key &= space.machine().root_device().ioport("LINE7")->read(); }
56	56	return key;
57	57	}
58	58
59	59	static READ8_DEVICE_HANDLER (radio86_8255_portc_r2 )
60	60	{
61		radio86_state *state = device->machine().driver_data<radio86_state>();
62		double level = (device->machine().device<cassette_image_device>(CASSETTE_TAG)->input());
	61	radio86_state *state = space.machine().driver_data<radio86_state>();
	62	double level = (space.machine().device<cassette_image_device>(CASSETTE_TAG)->input());
63	63	UINT8 dat = state->ioport("LINE8")->read();
64	64	if (level <  0) {
65	65	dat ^= state->m_tape_value;
r18055	r18056
69	69
70	70	static WRITE8_DEVICE_HANDLER (radio86_8255_porta_w2 )
71	71	{
72		radio86_state *state = device->machine().driver_data<radio86_state>();
	72	radio86_state *state = space.machine().driver_data<radio86_state>();
73	73	state->m_keyboard_mask = data ^ 0xff;
74	74	}
75	75
76	76	static WRITE8_DEVICE_HANDLER (radio86_8255_portc_w2 )
77	77	{
78		device->machine().device<cassette_image_device>(CASSETTE_TAG)->output(data & 0x01 ? 1 : -1);
	78	space.machine().device<cassette_image_device>(CASSETTE_TAG)->output(data & 0x01 ? 1 : -1);
79	79	}
80	80
81	81
r18055	r18056
103	103
104	104	static READ8_DEVICE_HANDLER (rk7007_8255_portc_r )
105	105	{
106		radio86_state *state = device->machine().driver_data<radio86_state>();
107		double level = (device->machine().device<cassette_image_device>(CASSETTE_TAG)->input());
	106	radio86_state *state = space.machine().driver_data<radio86_state>();
	107	double level = (space.machine().device<cassette_image_device>(CASSETTE_TAG)->input());
108	108	UINT8 key = 0xff;
109	109	if ((state->m_keyboard_mask & 0x01)!=0) { key &= state->ioport("CLINE0")->read(); }
110		if ((state->m_keyboard_mask & 0x02)!=0) { key &= device->machine().root_device().ioport("CLINE1")->read(); }
111		if ((state->m_keyboard_mask & 0x04)!=0) { key &= device->machine().root_device().ioport("CLINE2")->read(); }
112		if ((state->m_keyboard_mask & 0x08)!=0) { key &= device->machine().root_device().ioport("CLINE3")->read(); }
113		if ((state->m_keyboard_mask & 0x10)!=0) { key &= device->machine().root_device().ioport("CLINE4")->read(); }
114		if ((state->m_keyboard_mask & 0x20)!=0) { key &= device->machine().root_device().ioport("CLINE5")->read(); }
115		if ((state->m_keyboard_mask & 0x40)!=0) { key &= device->machine().root_device().ioport("CLINE6")->read(); }
116		if ((state->m_keyboard_mask & 0x80)!=0) { key &= device->machine().root_device().ioport("CLINE7")->read(); }
	110	if ((state->m_keyboard_mask & 0x02)!=0) { key &= space.machine().root_device().ioport("CLINE1")->read(); }
	111	if ((state->m_keyboard_mask & 0x04)!=0) { key &= space.machine().root_device().ioport("CLINE2")->read(); }
	112	if ((state->m_keyboard_mask & 0x08)!=0) { key &= space.machine().root_device().ioport("CLINE3")->read(); }
	113	if ((state->m_keyboard_mask & 0x10)!=0) { key &= space.machine().root_device().ioport("CLINE4")->read(); }
	114	if ((state->m_keyboard_mask & 0x20)!=0) { key &= space.machine().root_device().ioport("CLINE5")->read(); }
	115	if ((state->m_keyboard_mask & 0x40)!=0) { key &= space.machine().root_device().ioport("CLINE6")->read(); }
	116	if ((state->m_keyboard_mask & 0x80)!=0) { key &= space.machine().root_device().ioport("CLINE7")->read(); }
117	117	key &= 0xe0;
118	118	if (level <  0) {
119	119	key ^= state->m_tape_value;
r18055	r18056
193	193
194	194	static READ8_DEVICE_HANDLER (radio86_romdisk_porta_r )
195	195	{
196		radio86_state *state = device->machine().driver_data<radio86_state>();
	196	radio86_state *state = space.machine().driver_data<radio86_state>();
197	197	UINT8 *romdisk = state->memregion("maincpu")->base() + 0x10000;
198	198	if ((state->m_disk_sel & 0x0f) ==0) {
199	199	return romdisk[state->m_romdisk_msb*256+state->m_romdisk_lsb];
r18055	r18056
208	208
209	209	static WRITE8_DEVICE_HANDLER (radio86_romdisk_portb_w )
210	210	{
211		radio86_state *state = device->machine().driver_data<radio86_state>();
	211	radio86_state *state = space.machine().driver_data<radio86_state>();
212	212	state->m_romdisk_lsb = data;
213	213	}
214	214
215	215	static WRITE8_DEVICE_HANDLER (radio86_romdisk_portc_w )
216	216	{
217		radio86_state *state = device->machine().driver_data<radio86_state>();
	217	radio86_state *state = space.machine().driver_data<radio86_state>();
218	218	state->m_romdisk_msb = data;
219	219	}
220	220
r18055	r18056
230	230
231	231	static WRITE8_DEVICE_HANDLER (mikrosha_8255_font_page_w )
232	232	{
233		radio86_state *state = device->machine().driver_data<radio86_state>();
	233	radio86_state *state = space.machine().driver_data<radio86_state>();
234	234	state->m_mikrosha_font_page = (data  > 7) & 1;
235	235	}
236	236

trunk/src/mess/machine/b2m.c

r18055	r18056
172	172
173	173	static WRITE8_DEVICE_HANDLER (b2m_8255_porta_w )
174	174	{
175		b2m_state *state = device->machine().driver_data<b2m_state>();
	175	b2m_state *state = space.machine().driver_data<b2m_state>();
176	176	state->m_b2m_8255_porta = data;
177	177	}
178	178	static WRITE8_DEVICE_HANDLER (b2m_8255_portb_w )
179	179	{
180		b2m_state *state = device->machine().driver_data<b2m_state>();
	180	b2m_state *state = space.machine().driver_data<b2m_state>();
181	181	state->m_b2m_video_scroll = data;
182	182	}
183	183
184	184	static WRITE8_DEVICE_HANDLER (b2m_8255_portc_w )
185	185	{
186		b2m_state *state = device->machine().driver_data<b2m_state>();
	186	b2m_state *state = space.machine().driver_data<b2m_state>();
187	187
188	188	state->m_b2m_8255_portc = data;
189		b2m_set_bank(device->machine(), state->m_b2m_8255_portc & 7);
	189	b2m_set_bank(space.machine(), state->m_b2m_8255_portc & 7);
190	190	state->m_b2m_video_page = (state->m_b2m_8255_portc >> 7) & 1;
191	191	}
192	192
193	193	static READ8_DEVICE_HANDLER (b2m_8255_portb_r )
194	194	{
195		b2m_state *state = device->machine().driver_data<b2m_state>();
	195	b2m_state *state = space.machine().driver_data<b2m_state>();
196	196	return state->m_b2m_video_scroll;
197	197	}
198	198
r18055	r18056
212	212	{
213	213	UINT8 drive = ((data >> 1) & 1) ^ 1;
214	214	UINT8 side  = (data  & 1) ^ 1;
215		b2m_state *state = device->machine().driver_data<b2m_state>();
216		floppy_mon_w(floppy_get_device(device->machine(), 0), 1);
217		floppy_mon_w(floppy_get_device(device->machine(), 1), 1);
	215	b2m_state *state = space.machine().driver_data<b2m_state>();
	216	floppy_mon_w(floppy_get_device(space.machine(), 0), 1);
	217	floppy_mon_w(floppy_get_device(space.machine(), 1), 1);
218	218
219	219	if (state->m_b2m_drive!=drive) {
220	220	wd17xx_set_drive(state->m_fdc,drive);
221		floppy_mon_w(floppy_get_device(device->machine(), 0), 0);
222		floppy_drive_set_ready_state(floppy_get_device(device->machine(), 0), 1, 1);
	221	floppy_mon_w(floppy_get_device(space.machine(), 0), 0);
	222	floppy_drive_set_ready_state(floppy_get_device(space.machine(), 0), 1, 1);
223	223	state->m_b2m_drive = drive;
224	224	}
225	225	if (state->m_b2m_side!=side) {
226	226	wd17xx_set_side(state->m_fdc,side);
227		floppy_mon_w(floppy_get_device(device->machine(), 1), 0);
228		floppy_drive_set_ready_state(floppy_get_device(device->machine(), 1), 1, 1);
	227	floppy_mon_w(floppy_get_device(space.machine(), 1), 0);
	228	floppy_drive_set_ready_state(floppy_get_device(space.machine(), 1), 1, 1);
229	229	state->m_b2m_side = side;
230	230	}
231	231	wd17xx_dden_w(state->m_fdc, 0);
r18055	r18056
243	243
244	244	static READ8_DEVICE_HANDLER (b2m_romdisk_porta_r )
245	245	{
246		b2m_state *state = device->machine().driver_data<b2m_state>();
	246	b2m_state *state = space.machine().driver_data<b2m_state>();
247	247
248	248	UINT8 *romdisk = state->memregion("maincpu")->base() + 0x12000;
249	249	return romdisk[state->m_b2m_romdisk_msb*256+state->m_b2m_romdisk_lsb];
r18055	r18056
251	251
252	252	static WRITE8_DEVICE_HANDLER (b2m_romdisk_portb_w )
253	253	{
254		b2m_state *state = device->machine().driver_data<b2m_state>();
	254	b2m_state *state = space.machine().driver_data<b2m_state>();
255	255	state->m_b2m_romdisk_lsb = data;
256	256	}
257	257
258	258	static WRITE8_DEVICE_HANDLER (b2m_romdisk_portc_w )
259	259	{
260		b2m_state *state = device->machine().driver_data<b2m_state>();
	260	b2m_state *state = space.machine().driver_data<b2m_state>();
261	261	state->m_b2m_romdisk_msb = data & 0x7f;
262	262	}
263	263

trunk/src/mess/machine/thomson.c

r18055	r18056
147	147
148	148	static WRITE8_DEVICE_HANDLER ( to7_set_cassette_motor )
149	149	{
150		cassette_image_device* img = thom_cassette_img(device->machine());
	150	cassette_image_device* img = thom_cassette_img(space.machine());
151	151	cassette_state state =  img->get_state();
152	152	double pos = img->get_position();
153	153
154	154	LOG (( "$%04x %f to7_set_cassette_motor: cassette motor %s bitpos=%i\n",
155		device->machine().device("maincpu")->safe_pcbase(), img->machine().time().as_double(), data ? "off" : "on",
	155	space.machine().device("maincpu")->safe_pcbase(), img->machine().time().as_double(), data ? "off" : "on",
156	156	(int) (pos / TO7_BIT_LENGTH) ));
157	157
158	158	if ( (state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_DISABLED && !data && pos > 0.3 )
r18055	r18056
223	223
224	224	static WRITE8_DEVICE_HANDLER ( mo5_set_cassette_motor )
225	225	{
226		cassette_image_device* img = thom_cassette_img(device->machine());
	226	cassette_image_device* img = thom_cassette_img(space.machine());
227	227	cassette_state state = img->get_state();
228	228	double pos = img->get_position();
229	229
230	230	LOG (( "$%04x %f mo5_set_cassette_motor: cassette motor %s hbitpos=%i\n",
231		device->machine().device("maincpu")->safe_pcbase(), device->machine().time().as_double(), data ? "off" : "on",
	231	space.machine().device("maincpu")->safe_pcbase(), space.machine().time().as_double(), data ? "off" : "on",
232	232	(int) (pos / MO5_HBIT_LENGTH) ));
233	233
234	234	if ( (state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_DISABLED &&  !data && pos > 0.3 )
r18055	r18056
507	507
508	508	static WRITE8_DEVICE_HANDLER ( to7_timer_port_out )
509	509	{
510		thom_set_mode_point( device->machine(), data & 1 );          /* bit 0: video bank switch */
511		thom_set_caps_led( device->machine(), (data & 8) ? 1 : 0 ) ; /* bit 3: keyboard led */
512		thom_set_border_color( device->machine(),
	510	thom_set_mode_point( space.machine(), data & 1 );          /* bit 0: video bank switch */
	511	thom_set_caps_led( space.machine(), (data & 8) ? 1 : 0 ) ; /* bit 3: keyboard led */
	512	thom_set_border_color( space.machine(),
513	513	((data & 0x10) ? 1 : 0) |           /* bits 4-6: border color */
514	514	((data & 0x20) ? 2 : 0) |
515	515	((data & 0x40) ? 4 : 0) );
r18055	r18056
519	519
520	520	static WRITE8_DEVICE_HANDLER ( to7_timer_cp2_out )
521	521	{
522		device->machine().device<dac_device>("buzzer")->write_unsigned8(data ? 0x80 : 0); /* 1-bit buzzer */
	522	space.machine().device<dac_device>("buzzer")->write_unsigned8(data ? 0x80 : 0); /* 1-bit buzzer */
523	523	}
524	524
525	525
526	526
527	527	static READ8_DEVICE_HANDLER ( to7_timer_port_in )
528	528	{
529		int lightpen = (device->machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0;
530		int cass = to7_get_cassette(device->machine()) ? 0x80 : 0;
	529	int lightpen = (space.machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0;
	530	int cass = to7_get_cassette(space.machine()) ? 0x80 : 0;
531	531	return lightpen | cass;
532	532	}
533	533
r18055	r18056
536	536	static WRITE8_DEVICE_HANDLER ( to7_timer_tco_out )
537	537	{
538	538	/* 1-bit cassette output */
539		to7_set_cassette( device->machine(), data );
	539	to7_set_cassette( space.machine(), data );
540	540	}
541	541
542	542
r18055	r18056
617	617	if ( to7_lightpen )
618	618	{
619	619	/* lightpen hi */
620		return to7_lightpen_gpl( device->machine(), TO7_LIGHTPEN_DECAL, to7_lightpen_step ) >> 8;
	620	return to7_lightpen_gpl( space.machine(), TO7_LIGHTPEN_DECAL, to7_lightpen_step ) >> 8;
621	621	}
622	622	else
623	623	{
r18055	r18056
633	633	for ( i = 0; i < 8; i++ )
634	634	{
635	635	if ( ! (keyline & (1 << i)) )
636		val &= device->machine().root_device().ioport(keynames[i])->read();
	636	val &= space.machine().root_device().ioport(keynames[i])->read();
637	637	}
638	638	return val;
639	639	}
r18055	r18056
644	644	static READ8_DEVICE_HANDLER ( to7_sys_portb_in )
645	645	{
646	646	/* lightpen low */
647		return to7_lightpen_gpl( device->machine(), TO7_LIGHTPEN_DECAL, to7_lightpen_step ) & 0xff;
	647	return to7_lightpen_gpl( space.machine(), TO7_LIGHTPEN_DECAL, to7_lightpen_step ) & 0xff;
648	648	}
649	649
650	650
r18055	r18056
767	767
768	768	static WRITE8_DEVICE_HANDLER( to7_io_portb_out )
769	769	{
770		centronics_device *printer = device->machine().device<centronics_device>("centronics");
	770	centronics_device *printer = space.machine().device<centronics_device>("centronics");
771	771
772		LOG_IO(( "$%04x %f to7_io_portb_out: CENTRONICS set data=$%02X\n", device->machine().device("maincpu")->safe_pcbase(), device->machine().time().as_double(), data ));
	772	LOG_IO(( "$%04x %f to7_io_portb_out: CENTRONICS set data=$%02X\n", space.machine().device("maincpu")->safe_pcbase(), space.machine().time().as_double(), data ));
773	773
774	774	/* set 8-bit data */
775		printer->write( device->machine().driver_data()->generic_space(), 0, data);
	775	printer->write( space.machine().driver_data()->generic_space(), 0, data);
776	776	}
777	777
778	778
779	779
780	780	static WRITE8_DEVICE_HANDLER( to7_io_cb2_out )
781	781	{
782		centronics_device *printer = device->machine().device<centronics_device>("centronics");
	782	centronics_device *printer = space.machine().device<centronics_device>("centronics");
783	783
784		LOG_IO(( "$%04x %f to7_io_cb2_out: CENTRONICS set strobe=%i\n", device->machine().device("maincpu")->safe_pcbase(), device->machine().time().as_double(), data ));
	784	LOG_IO(( "$%04x %f to7_io_cb2_out: CENTRONICS set strobe=%i\n", space.machine().device("maincpu")->safe_pcbase(), space.machine().time().as_double(), data ));
785	785
786	786	/* send STROBE to printer */
787	787	printer->strobe_w(data);
r18055	r18056
1037	1037	static READ8_DEVICE_HANDLER ( to7_game_porta_in )
1038	1038	{
1039	1039	UINT8 data;
1040		if ( device->machine().root_device().ioport("config")->read() & 1 )
	1040	if ( space.machine().root_device().ioport("config")->read() & 1 )
1041	1041	{
1042	1042	/* mouse */
1043		data = to7_get_mouse_signal(device->machine()) & 0x0c;             /* XB, YB */
1044		data |= device->machine().root_device().ioport("mouse_button")->read() & 3; /* buttons */
	1043	data = to7_get_mouse_signal(space.machine()) & 0x0c;             /* XB, YB */
	1044	data |= space.machine().root_device().ioport("mouse_button")->read() & 3; /* buttons */
1045	1045	}
1046	1046	else
1047	1047	{
1048	1048	/* joystick */
1049		data = device->machine().root_device().ioport("game_port_directions")->read();
	1049	data = space.machine().root_device().ioport("game_port_directions")->read();
1050	1050	/* bit 0=0 => P1 up      bit 4=0 => P2 up
1051	1051	bit 1=0 => P1 down    bit 5=0 => P2 down
1052	1052	bit 2=0 => P1 left    bit 6=0 => P2 left
r18055	r18056
1078	1078	static READ8_DEVICE_HANDLER ( to7_game_portb_in )
1079	1079	{
1080	1080	UINT8 data;
1081		if ( device->machine().root_device().ioport("config")->read() & 1 )
	1081	if ( space.machine().root_device().ioport("config")->read() & 1 )
1082	1082	{
1083	1083	/* mouse */
1084		UINT8 mouse =  to7_get_mouse_signal(device->machine());
	1084	UINT8 mouse =  to7_get_mouse_signal(space.machine());
1085	1085	data = 0;
1086	1086	if ( mouse & 1 )
1087	1087	data |= 0x04; /* XA */
r18055	r18056
1095	1095	/* bits 2-3: action buttons B (0=pressed) */
1096	1096	/* bits 4-5: unused (ouput) */
1097	1097	/* bits 0-1: unknown! */
1098		data = device->machine().root_device().ioport("game_port_buttons")->read();
	1098	data = space.machine().root_device().ioport("game_port_buttons")->read();
1099	1099	}
1100	1100	return data;
1101	1101	}
r18055	r18056
1106	1106	{
1107	1107	/* 6-bit DAC sound */
1108	1108	to7_game_sound = data & 0x3f;
1109		to7_game_sound_update(device->machine());
	1109	to7_game_sound_update(space.machine());
1110	1110	}
1111	1111
1112	1112
r18055	r18056
1546	1546	static WRITE8_DEVICE_HANDLER ( to770_sys_cb2_out )
1547	1547	{
1548	1548	/* video overlay: black pixels are transparent and show TV image underneath */
1549		LOG(( "$%04x to770_sys_cb2_out: video overlay %i\n", device->machine().device("maincpu")->safe_pcbase(), data ));
	1549	LOG(( "$%04x to770_sys_cb2_out: video overlay %i\n", space.machine().device("maincpu")->safe_pcbase(), data ));
1550	1550	}
1551	1551
1552	1552
r18055	r18056
1560	1560	};
1561	1561	int keyline = downcast<pia6821_device *>(device)->b_output() & 7;
1562	1562
1563		return device->machine().root_device().ioport(keynames[7 - keyline])->read();
	1563	return space.machine().root_device().ioport(keynames[7 - keyline])->read();
1564	1564	}
1565	1565
1566	1566
r18055	r18056
1620	1620
1621	1621	static WRITE8_DEVICE_HANDLER ( to770_sys_portb_out )
1622	1622	{
1623		to770_update_ram_bank(device->machine());
	1623	to770_update_ram_bank(space.machine());
1624	1624	}
1625	1625
1626	1626
r18055	r18056
1649	1649
1650	1650	static WRITE8_DEVICE_HANDLER ( to770_timer_port_out )
1651	1651	{
1652		thom_set_mode_point( device->machine(), data & 1 );          /* bit 0: video bank switch */
1653		thom_set_caps_led( device->machine(), (data & 8) ? 1 : 0 ) ; /* bit 3: keyboard led */
1654		thom_set_border_color( device->machine(),
	1652	thom_set_mode_point( space.machine(), data & 1 );          /* bit 0: video bank switch */
	1653	thom_set_caps_led( space.machine(), (data & 8) ? 1 : 0 ) ; /* bit 3: keyboard led */
	1654	thom_set_border_color( space.machine(),
1655	1655	((data & 0x10) ? 1 : 0) |          /* 4-bit border color */
1656	1656	((data & 0x20) ? 2 : 0) |
1657	1657	((data & 0x40) ? 4 : 0) |
r18055	r18056
1840	1840
1841	1841	static WRITE8_DEVICE_HANDLER ( mo5_sys_porta_out )
1842	1842	{
1843		thom_set_mode_point( device->machine(), data & 1 );      /* bit 0: video bank switch */
1844		thom_set_border_color( device->machine(), (data >> 1) & 15 );   /* bit 1-4: border color */
1845		mo5_set_cassette( device->machine(), (data & 0x40) ? 1 : 0 );   /* bit 6: cassette output */
	1843	thom_set_mode_point( space.machine(), data & 1 );      /* bit 0: video bank switch */
	1844	thom_set_border_color( space.machine(), (data >> 1) & 15 );   /* bit 1-4: border color */
	1845	mo5_set_cassette( space.machine(), (data & 0x40) ? 1 : 0 );   /* bit 6: cassette output */
1846	1846	}
1847	1847
1848	1848
r18055	r18056
1850	1850	static READ8_DEVICE_HANDLER ( mo5_sys_porta_in )
1851	1851	{
1852	1852	return
1853		(mo5_get_cassette(device->machine()) ? 0x80 : 0) |     /* bit 7: cassette input */
1854		((device->machine().root_device().ioport("lightpen_button")->read() & 1) ? 0x20 : 0)
	1853	(mo5_get_cassette(space.machine()) ? 0x80 : 0) |     /* bit 7: cassette input */
	1854	((space.machine().root_device().ioport("lightpen_button")->read() & 1) ? 0x20 : 0)
1855	1855	/* bit 5: lightpen button */;
1856	1856	}
1857	1857
r18055	r18056
1859	1859
1860	1860	static WRITE8_DEVICE_HANDLER ( mo5_sys_portb_out )
1861	1861	{
1862		device->machine().device<dac_device>("buzzer")->write_unsigned8((data & 1) ? 0x80 : 0); /* 1-bit buzzer */
	1862	space.machine().device<dac_device>("buzzer")->write_unsigned8((data & 1) ? 0x80 : 0); /* 1-bit buzzer */
1863	1863	}
1864	1864
1865	1865
r18055	r18056
1874	1874	"keyboard_4", "keyboard_5", "keyboard_6", "keyboard_7"
1875	1875	};
1876	1876
1877		return ( device->machine().root_device().ioport(keynames[lin])->read() & (1 << col) ) ? 0x80 : 0;
	1877	return ( space.machine().root_device().ioport(keynames[lin])->read() & (1 << col) ) ? 0x80 : 0;
1878	1878	}
1879	1879
1880	1880
r18055	r18056
3037	3037
3038	3038	static READ8_DEVICE_HANDLER ( to9_sys_porta_in )
3039	3039	{
3040		UINT8 ktest = to9_kbd_ktest(device->machine());
	3040	UINT8 ktest = to9_kbd_ktest(space.machine());
3041	3041
3042	3042	LOG_KBD(( "to9_sys_porta_in: ktest=%i\n", ktest ));
3043	3043
r18055	r18056
3048	3048
3049	3049	static WRITE8_DEVICE_HANDLER ( to9_sys_porta_out )
3050	3050	{
3051		centronics_device *printer = device->machine().device<centronics_device>("centronics");
3052		printer->write(device->machine().driver_data()->generic_space(), 0, data & 0xfe);
	3051	centronics_device *printer = space.machine().device<centronics_device>("centronics");
	3052	printer->write(space.machine().driver_data()->generic_space(), 0, data & 0xfe);
3053	3053	}
3054	3054
3055	3055
3056	3056
3057	3057	static WRITE8_DEVICE_HANDLER ( to9_sys_portb_out )
3058	3058	{
3059		centronics_device *printer = device->machine().device<centronics_device>("centronics");
	3059	centronics_device *printer = space.machine().device<centronics_device>("centronics");
3060	3060
3061	3061	printer->d0_w(BIT(data, 0));
3062	3062	printer->strobe_w(BIT(data, 1));
3063	3063
3064		to9_update_ram_bank(device->machine());
	3064	to9_update_ram_bank(space.machine());
3065	3065
3066	3066	if ( data & 4 ) /* bit 2: video overlay (TODO) */
3067	3067	LOG(( "to9_sys_portb_out: video overlay not handled\n" ));
r18055	r18056
3095	3095
3096	3096	static WRITE8_DEVICE_HANDLER ( to9_timer_port_out )
3097	3097	{
3098		thom_set_mode_point( device->machine(), data & 1 ); /* bit 0: video bank */
3099		to9_update_ram_bank(device->machine());
3100		to9_update_cart_bank(device->machine());
	3098	thom_set_mode_point( space.machine(), data & 1 ); /* bit 0: video bank */
	3099	to9_update_ram_bank(space.machine());
	3100	to9_update_cart_bank(space.machine());
3101	3101	}
3102	3102
3103	3103
r18055	r18056
4073	4073
4074	4074	static READ8_DEVICE_HANDLER ( to8_sys_porta_in )
4075	4075	{
4076		int ktest = to8_kbd_ktest (device->machine());
	4076	int ktest = to8_kbd_ktest (space.machine());
4077	4077
4078		LOG_KBD(( "$%04x %f: to8_sys_porta_in ktest=%i\n", device->machine().device("maincpu")->safe_pcbase(), device->machine().time().as_double(), ktest ));
	4078	LOG_KBD(( "$%04x %f: to8_sys_porta_in ktest=%i\n", space.machine().device("maincpu")->safe_pcbase(), space.machine().time().as_double(), ktest ));
4079	4079
4080	4080	return ktest;
4081	4081	}
r18055	r18056
4084	4084
4085	4085	static WRITE8_DEVICE_HANDLER ( to8_sys_portb_out )
4086	4086	{
4087		centronics_device *printer = device->machine().device<centronics_device>("centronics");
	4087	centronics_device *printer = space.machine().device<centronics_device>("centronics");
4088	4088
4089	4089	printer->d0_w(BIT(data, 0));
4090	4090	printer->strobe_w(BIT(data, 1));
4091	4091
4092		to8_update_ram_bank(device->machine());
	4092	to8_update_ram_bank(space.machine());
4093	4093
4094	4094	if ( data & 4 ) /* bit 2: video overlay (TODO) */
4095	4095	LOG(( "to8_sys_portb_out: video overlay not handled\n" ));
r18055	r18056
4121	4121
4122	4122	static READ8_DEVICE_HANDLER ( to8_timer_port_in )
4123	4123	{
4124		centronics_device *printer = device->machine().device<centronics_device>("centronics");
4125		int lightpen = (device->machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0;
4126		int cass = to7_get_cassette(device->machine()) ? 0x80 : 0;
	4124	centronics_device *printer = space.machine().device<centronics_device>("centronics");
	4125	int lightpen = (space.machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0;
	4126	int cass = to7_get_cassette(space.machine()) ? 0x80 : 0;
4127	4127	int dtr = printer->busy_r() << 6;
4128	4128	int lock = to8_kbd_caps ? 0 : 8; /* undocumented! */
4129	4129	return lightpen | cass | dtr | lock;
r18055	r18056
4135	4135	{
4136	4136	int ack = (data & 0x20) ? 1 : 0;       /* bit 5: keyboard ACK */
4137	4137	to8_bios_bank = (data & 0x10) ? 1 : 0; /* bit 4: BIOS bank*/
4138		thom_set_mode_point( device->machine(), data & 1 );       /* bit 0: video bank switch */
4139		device->machine().root_device().membank( TO8_BIOS_BANK )->set_entry( to8_bios_bank );
	4138	thom_set_mode_point( space.machine(), data & 1 );       /* bit 0: video bank switch */
	4139	space.machine().root_device().membank( TO8_BIOS_BANK )->set_entry( to8_bios_bank );
4140	4140	to8_soft_select = (data & 0x04) ? 1 : 0; /* bit 2: internal ROM select */
4141		to8_update_floppy_bank(device->machine());
4142		to8_update_cart_bank(device->machine());
4143		to8_kbd_set_ack(device->machine(), ack);
	4141	to8_update_floppy_bank(space.machine());
	4142	to8_update_cart_bank(space.machine());
	4143	to8_kbd_set_ack(space.machine(), ack);
4144	4144	}
4145	4145
4146	4146
r18055	r18056
4149	4149	{
4150	4150	/* mute */
4151	4151	to7_game_mute = data;
4152		to7_game_sound_update(device->machine());
	4152	to7_game_sound_update(space.machine());
4153	4153	}
4154	4154
4155	4155
r18055	r18056
4322	4322
4323	4323	static READ8_DEVICE_HANDLER ( to9p_timer_port_in )
4324	4324	{
4325		centronics_device *printer = device->machine().device<centronics_device>("centronics");
4326		int lightpen = (device->machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0;
4327		int cass = to7_get_cassette(device->machine()) ? 0x80 : 0;
	4325	centronics_device *printer = space.machine().device<centronics_device>("centronics");
	4326	int lightpen = (space.machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0;
	4327	int cass = to7_get_cassette(space.machine()) ? 0x80 : 0;
4328	4328	int dtr = printer->busy_r() << 6;
4329	4329	return lightpen | cass | dtr;
4330	4330	}
r18055	r18056
4334	4334	static WRITE8_DEVICE_HANDLER ( to9p_timer_port_out )
4335	4335	{
4336	4336	int bios_bank = (data & 0x10) ? 1 : 0; /* bit 4: BIOS bank */
4337		thom_set_mode_point( device->machine(), data & 1 );       /* bit 0: video bank switch */
4338		device->machine().root_device().membank( TO8_BIOS_BANK )->set_entry( bios_bank );
	4337	thom_set_mode_point( space.machine(), data & 1 );       /* bit 0: video bank switch */
	4338	space.machine().root_device().membank( TO8_BIOS_BANK )->set_entry( bios_bank );
4339	4339	to8_soft_select = (data & 0x04) ? 1 : 0; /* bit 2: internal ROM select */
4340		to8_update_floppy_bank(device->machine());
4341		to8_update_cart_bank(device->machine());
	4340	to8_update_floppy_bank(space.machine());
	4341	to8_update_cart_bank(space.machine());
4342	4342	}
4343	4343
4344	4344
r18055	r18056
4755	4755
4756	4756	static WRITE8_DEVICE_HANDLER ( mo6_game_porta_out )
4757	4757	{
4758		centronics_device *printer = device->machine().device<centronics_device>("centronics");
	4758	centronics_device *printer = space.machine().device<centronics_device>("centronics");
4759	4759
4760		LOG (( "$%04x %f mo6_game_porta_out: CENTRONICS set data=$%02X\n", device->machine().device("maincpu")->safe_pcbase(), device->machine().time().as_double(), data ));
	4760	LOG (( "$%04x %f mo6_game_porta_out: CENTRONICS set data=$%02X\n", space.machine().device("maincpu")->safe_pcbase(), space.machine().time().as_double(), data ));
4761	4761
4762	4762	/* centronics data */
4763		printer->write( device->machine().driver_data()->generic_space(), 0, data);
	4763	printer->write( space.machine().driver_data()->generic_space(), 0, data);
4764	4764	}
4765	4765
4766	4766
4767	4767
4768	4768	static WRITE8_DEVICE_HANDLER ( mo6_game_cb2_out )
4769	4769	{
4770		centronics_device *printer = device->machine().device<centronics_device>("centronics");
	4770	centronics_device *printer = space.machine().device<centronics_device>("centronics");
4771	4771
4772		LOG (( "$%04x %f mo6_game_cb2_out: CENTRONICS set strobe=%i\n", device->machine().device("maincpu")->safe_pcbase(), device->machine().time().as_double(), data ));
	4772	LOG (( "$%04x %f mo6_game_cb2_out: CENTRONICS set strobe=%i\n", space.machine().device("maincpu")->safe_pcbase(), space.machine().time().as_double(), data ));
4773	4773
4774	4774	/* centronics strobe */
4775	4775	printer->strobe_w(data);
r18055	r18056
4847	4847	static READ8_DEVICE_HANDLER ( mo6_sys_porta_in )
4848	4848	{
4849	4849	return
4850		(mo5_get_cassette(device->machine()) ? 0x80 : 0) |     /* bit 7: cassette input */
	4850	(mo5_get_cassette(space.machine()) ? 0x80 : 0) |     /* bit 7: cassette input */
4851	4851	8 |                                   /* bit 3: kbd-line float up to 1 */
4852		((device->machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0);
	4852	((space.machine().root_device().ioport("lightpen_button")->read() & 1) ? 2 : 0);
4853	4853	/* bit 1: lightpen button */;
4854	4854	}
4855	4855
r18055	r18056
4871	4871	lin = 8;     /* A bit 3: 9-th kbd line select */
4872	4872
4873	4873	return
4874		( device->machine().root_device().ioport(keynames[lin])->read() & (1 << col) ) ?  0x80 : 0;
	4874	( space.machine().root_device().ioport(keynames[lin])->read() & (1 << col) ) ?  0x80 : 0;
4875	4875	/* bit 7: key up */
4876	4876	}
4877	4877
r18055	r18056
4879	4879
4880	4880	static WRITE8_DEVICE_HANDLER ( mo6_sys_porta_out )
4881	4881	{
4882		thom_set_mode_point( device->machine(),data & 1 );            /* bit 0: video bank switch */
	4882	thom_set_mode_point( space.machine(),data & 1 );            /* bit 0: video bank switch */
4883	4883	to7_game_mute = data & 4;                  /* bit 2: sound mute */
4884		thom_set_caps_led( device->machine(),(data & 16) ? 0 : 1 ) ;      /* bit 4: keyboard led */
4885		mo5_set_cassette( device->machine(), (data & 0x40) ? 1 : 0 );      /* bit 6: cassette output */
4886		mo6_update_cart_bank(device->machine());               /* bit 5: rom bank */
4887		to7_game_sound_update(device->machine());
	4884	thom_set_caps_led( space.machine(),(data & 16) ? 0 : 1 ) ;      /* bit 4: keyboard led */
	4885	mo5_set_cassette( space.machine(), (data & 0x40) ? 1 : 0 );      /* bit 6: cassette output */
	4886	mo6_update_cart_bank(space.machine());               /* bit 5: rom bank */
	4887	to7_game_sound_update(space.machine());
4888	4888	}
4889	4889
4890	4890
4891	4891
4892	4892	static WRITE8_DEVICE_HANDLER ( mo6_sys_portb_out )
4893	4893	{
4894		device->machine().device<dac_device>("buzzer")->write_unsigned8((data & 1) ? 0x80 : 0); /* bit 0: buzzer */
	4894	space.machine().device<dac_device>("buzzer")->write_unsigned8((data & 1) ? 0x80 : 0); /* bit 0: buzzer */
4895	4895	}
4896	4896
4897	4897
r18055	r18056
5279	5279	"keyboard_4", "keyboard_5", "keyboard_6", "keyboard_7"
5280	5280	};
5281	5281
5282		return ( device->machine().root_device().ioport(keynames[lin])->read() & (1 << col) ) ? 0x80 : 0;
	5282	return ( space.machine().root_device().ioport(keynames[lin])->read() & (1 << col) ) ? 0x80 : 0;
5283	5283	/* bit 7: key up */
5284	5284	}
5285	5285
r18055	r18056
5288	5288	static WRITE8_DEVICE_HANDLER ( mo5nr_sys_porta_out )
5289	5289	{
5290	5290	/* no keyboard LED */
5291		thom_set_mode_point( device->machine(), data & 1 );         /* bit 0: video bank switch */
	5291	thom_set_mode_point( space.machine(), data & 1 );         /* bit 0: video bank switch */
5292	5292	to7_game_mute = data & 4;                  /* bit 2: sound mute */
5293		mo5_set_cassette( device->machine(), (data & 0x40) ? 1 : 0 );      /* bit 6: cassette output */
5294		mo6_update_cart_bank(device->machine());               /* bit 5: rom bank */
5295		to7_game_sound_update(device->machine());
	5293	mo5_set_cassette( space.machine(), (data & 0x40) ? 1 : 0 );      /* bit 6: cassette output */
	5294	mo6_update_cart_bank(space.machine());               /* bit 5: rom bank */
	5295	to7_game_sound_update(space.machine());
5296	5296	}
5297	5297
5298	5298

trunk/src/mess/machine/pet.c

r18055	r18056
47	47	*/
48	48	static READ8_DEVICE_HANDLER( pia0_pa_r )
49	49	{
50		pet_state *state = device->machine().driver_data<pet_state>();
	50	pet_state *state = space.machine().driver_data<pet_state>();
51	51	/*
52	52
53	53	bit     description
r18055	r18056
69	69	data |= state->m_keyline_select;
70	70
71	71	/* #1 cassette switch */
72		data |= ((device->machine().device<cassette_image_device>(CASSETTE_TAG)->get_state() & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED) << 4;
	72	data |= ((space.machine().device<cassette_image_device>(CASSETTE_TAG)->get_state() & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED) << 4;
73	73
74	74	/* #2 cassette switch */
75		data |= ((device->machine().device<cassette_image_device>(CASSETTE2_TAG)->get_state() & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED) << 5;
	75	data |= ((space.machine().device<cassette_image_device>(CASSETTE2_TAG)->get_state() & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED) << 5;
76	76
77	77	/* end or identify in */
78	78	data |= state->m_ieee->eoi_r() << 6;
r18055	r18056
85	85
86	86	static WRITE8_DEVICE_HANDLER( pia0_pa_w )
87	87	{
88		pet_state *state = device->machine().driver_data<pet_state>();
	88	pet_state *state = space.machine().driver_data<pet_state>();
89	89	/*
90	90
91	91	bit     description
r18055	r18056
108	108	/* Keyboard reading/handling for regular keyboard */
109	109	static READ8_DEVICE_HANDLER( kin_r )
110	110	{
111		pet_state *state = device->machine().driver_data<pet_state>();
	111	pet_state *state = space.machine().driver_data<pet_state>();
112	112	/*
113	113
114	114	bit     description
r18055	r18056
132	132
133	133	if (state->m_keyline_select < 10)
134	134	{
135		data = device->machine().root_device().ioport(keynames[state->m_keyline_select])->read();
	135	data = space.machine().root_device().ioport(keynames[state->m_keyline_select])->read();
136	136	/* Check for left-shift lock */
137		if ((state->m_keyline_select == 8) && (device->machine().root_device().ioport("SPECIAL")->read() & 0x80))
	137	if ((state->m_keyline_select == 8) && (space.machine().root_device().ioport("SPECIAL")->read() & 0x80))
138	138	data &= 0xfe;
139	139	}
140	140	return data;
r18055	r18056
144	144	static READ8_DEVICE_HANDLER( petb_kin_r )
145	145	{
146	146	UINT8 data = 0xff;
147		pet_state *state = device->machine().driver_data<pet_state>();
	147	pet_state *state = space.machine().driver_data<pet_state>();
148	148	static const char *const keynames[] = {
149	149	"ROW0", "ROW1", "ROW2", "ROW3", "ROW4",
150	150	"ROW5", "ROW6", "ROW7", "ROW8", "ROW9"
r18055	r18056
152	152
153	153	if (state->m_keyline_select < 10)
154	154	{
155		data = device->machine().root_device().ioport(keynames[state->m_keyline_select])->read();
	155	data = space.machine().root_device().ioport(keynames[state->m_keyline_select])->read();
156	156	/* Check for left-shift lock */
157	157	/* 2008-05 FP: For some reason, superpet read it in the opposite way!! */
158	158	/* While waiting for confirmation from docs, we add a workaround here. */
159	159	if (state->m_superpet)
160	160	{
161		if ((state->m_keyline_select == 6) && !(device->machine().root_device().ioport("SPECIAL")->read() & 0x80))
	161	if ((state->m_keyline_select == 6) && !(space.machine().root_device().ioport("SPECIAL")->read() & 0x80))
162	162	data &= 0xfe;
163	163	}
164	164	else
165	165	{
166		if ((state->m_keyline_select == 6) && (device->machine().root_device().ioport("SPECIAL")->read() & 0x80))
	166	if ((state->m_keyline_select == 6) && (space.machine().root_device().ioport("SPECIAL")->read() & 0x80))
167	167	data &= 0xfe;
168	168	}
169	169	}
r18055	r18056
173	173	static READ8_DEVICE_HANDLER( cass1_r )
174	174	{
175	175	// cassette 1 read
176		return (device->machine().device<cassette_image_device>(CASSETTE_TAG)->input() > +0.0) ? 1 : 0;
	176	return (space.machine().device<cassette_image_device>(CASSETTE_TAG)->input() > +0.0) ? 1 : 0;
177	177	}
178	178
179	179	static WRITE8_DEVICE_HANDLER( cass1_motor_w )
180	180	{
181		pet_state *state = device->machine().driver_data<pet_state>();
	181	pet_state *state = space.machine().driver_data<pet_state>();
182	182	if (!data)
183	183	{
184		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_ENABLED,CASSETTE_MASK_MOTOR);
	184	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_ENABLED,CASSETTE_MASK_MOTOR);
185	185	state->m_datasette1_timer->adjust(attotime::zero, 0, attotime::from_hz(48000));   // I put 48000 because I was given some .wav with this freq
186	186	}
187	187	else
188	188	{
189		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_DISABLED ,CASSETTE_MASK_MOTOR);
	189	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(CASSETTE_MOTOR_DISABLED ,CASSETTE_MASK_MOTOR);
190	190	state->m_datasette1_timer->reset();
191	191	}
192	192	}
r18055	r18056
302	302
303	303	*/
304	304
305		pet_state *state = device->machine().driver_data<pet_state>();
	305	pet_state *state = space.machine().driver_data<pet_state>();
306	306	UINT8 data = 0;
307	307
308	308	/* not data accepted in */
r18055	r18056
342	342
343	343	*/
344	344
345		pet_state *state = device->machine().driver_data<pet_state>();
	345	pet_state *state = space.machine().driver_data<pet_state>();
346	346
347	347	/* not ready for data out */
348	348	state->m_ieee->nrfd_w(BIT(data, 1));
r18055	r18056
351	351	state->m_ieee->atn_w(BIT(data, 2));
352	352
353	353	/* cassette write */
354		device->machine().device<cassette_image_device>(CASSETTE_TAG)->output(BIT(data, 3) ? -(0x5a9e >> 1) : +(0x5a9e >> 1));
355		device->machine().device<cassette_image_device>(CASSETTE2_TAG)->output(BIT(data, 3) ? -(0x5a9e >> 1) : +(0x5a9e >> 1));
	354	space.machine().device<cassette_image_device>(CASSETTE_TAG)->output(BIT(data, 3) ? -(0x5a9e >> 1) : +(0x5a9e >> 1));
	355	space.machine().device<cassette_image_device>(CASSETTE2_TAG)->output(BIT(data, 3) ? -(0x5a9e >> 1) : +(0x5a9e >> 1));
356	356
357	357	/* #2 cassette motor */
358	358	if (BIT(data, 4))
359	359	{
360		device->machine().device<cassette_image_device>(CASSETTE2_TAG)->change_state(CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR);
	360	space.machine().device<cassette_image_device>(CASSETTE2_TAG)->change_state(CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR);
361	361	state->m_datasette2_timer->adjust(attotime::zero, 0, attotime::from_hz(48000));   // I put 48000 because I was given some .wav with this freq
362	362	}
363	363	else
364	364	{
365		device->machine().device<cassette_image_device>(CASSETTE2_TAG)->change_state(CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR);
	365	space.machine().device<cassette_image_device>(CASSETTE2_TAG)->change_state(CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR);
366	366	state->m_datasette2_timer->reset();
367	367	}
368	368	}

trunk/src/mess/machine/oric.c

r18055	r18056
136	136	/* this port is also used to read printer data */
137	137	static READ8_DEVICE_HANDLER ( oric_via_in_a_func )
138	138	{
139		oric_state *state = device->machine().driver_data<oric_state>();
	139	oric_state *state = space.machine().driver_data<oric_state>();
140	140
141	141	/*logerror("port a read\r\n"); */
142	142
r18055	r18056
157	157
158	158	static READ8_DEVICE_HANDLER ( oric_via_in_b_func )
159	159	{
160		oric_state *state = device->machine().driver_data<oric_state>();
	160	oric_state *state = space.machine().driver_data<oric_state>();
161	161	int data;
162	162
163		oric_keyboard_sense_refresh(device->machine());
	163	oric_keyboard_sense_refresh(space.machine());
164	164
165	165	data = state->m_key_sense_bit;
166	166	data |= state->m_keyboard_line & 0x07;
r18055	r18056
211	211
212	212	static WRITE8_DEVICE_HANDLER ( oric_via_out_a_func )
213	213	{
214		oric_state *state = device->machine().driver_data<oric_state>();
	214	oric_state *state = space.machine().driver_data<oric_state>();
215	215	state->m_via_port_a_data = data;
216	216
217	217	oric_psg_connection_refresh(space);
r18055	r18056
220	220	if (state->m_psg_control==0)
221	221	{
222	222	/* if psg not selected, write to printer */
223		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
224		centronics->write(device->machine().driver_data()->generic_space(), 0, data);
	223	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
	224	centronics->write(space.machine().driver_data()->generic_space(), 0, data);
225	225	}
226	226	}
227	227
r18055	r18056
283	283
284	284	static WRITE8_DEVICE_HANDLER ( oric_via_out_b_func )
285	285	{
286		oric_state *state = device->machine().driver_data<oric_state>();
287		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	286	oric_state *state = space.machine().driver_data<oric_state>();
	287	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
288	288
289	289	/* KEYBOARD */
290	290	state->m_keyboard_line = data & 0x07;
291	291
292	292	/* CASSETTE */
293	293	/* cassette motor control */
294		cassette_device_image(device->machine())->change_state(
	294	cassette_device_image(space.machine())->change_state(
295	295	(data & 0x40) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED,
296	296	CASSETTE_MOTOR_DISABLED);
297	297
298	298	/* cassette data out */
299		cassette_device_image(device->machine())->output((data & (1<<7)) ? -1.0 : +1.0);
	299	cassette_device_image(space.machine())->output((data & (1<<7)) ? -1.0 : +1.0);
300	300
301	301	/* centronics STROBE is connected to PB4 */
302	302	centronics->strobe_w(BIT(data, 4));
r18055	r18056
308	308
309	309	static READ8_DEVICE_HANDLER ( oric_via_in_ca2_func )
310	310	{
311		oric_state *state = device->machine().driver_data<oric_state>();
	311	oric_state *state = space.machine().driver_data<oric_state>();
312	312	return state->m_psg_control & 1;
313	313	}
314	314
315	315	static READ8_DEVICE_HANDLER ( oric_via_in_cb2_func )
316	316	{
317		oric_state *state = device->machine().driver_data<oric_state>();
	317	oric_state *state = space.machine().driver_data<oric_state>();
318	318	return (state->m_psg_control>>1) & 1;
319	319	}
320	320
321	321	static WRITE8_DEVICE_HANDLER ( oric_via_out_ca2_func )
322	322	{
323		oric_state *state = device->machine().driver_data<oric_state>();
	323	oric_state *state = space.machine().driver_data<oric_state>();
324	324	state->m_psg_control &=~1;
325	325
326	326	if (data)
r18055	r18056
331	331
332	332	static WRITE8_DEVICE_HANDLER ( oric_via_out_cb2_func )
333	333	{
334		oric_state *state = device->machine().driver_data<oric_state>();
	334	oric_state *state = space.machine().driver_data<oric_state>();
335	335	state->m_psg_control &=~2;
336	336
337	337	if (data)
r18055	r18056
1280	1280
1281	1281	static READ8_DEVICE_HANDLER(telestrat_via2_in_a_func)
1282	1282	{
1283		oric_state *state = device->machine().driver_data<oric_state>();
	1283	oric_state *state = space.machine().driver_data<oric_state>();
1284	1284	//logerror("via 2 - port a %02x\n",state->m_telestrat_via2_port_a_data);
1285	1285	return state->m_telestrat_via2_port_a_data;
1286	1286	}
r18055	r18056
1288	1288
1289	1289	static WRITE8_DEVICE_HANDLER(telestrat_via2_out_a_func)
1290	1290	{
1291		oric_state *state = device->machine().driver_data<oric_state>();
	1291	oric_state *state = space.machine().driver_data<oric_state>();
1292	1292	//logerror("via 2 - port a w: %02x\n",data);
1293	1293
1294	1294	state->m_telestrat_via2_port_a_data = data;
r18055	r18056
1297	1297	{
1298	1298	state->m_telestrat_bank_selection = data & 0x07;
1299	1299
1300		telestrat_refresh_mem(device->machine());
	1300	telestrat_refresh_mem(space.machine());
1301	1301	}
1302	1302	}
1303	1303
1304	1304	static READ8_DEVICE_HANDLER(telestrat_via2_in_b_func)
1305	1305	{
1306		oric_state *state = device->machine().driver_data<oric_state>();
	1306	oric_state *state = space.machine().driver_data<oric_state>();
1307	1307	unsigned char data = 0x01f;
1308	1308
1309	1309	/* left joystick selected? */
r18055	r18056
1315	1315	/* right joystick selected? */
1316	1316	if (state->m_telestrat_via2_port_b_data & (1<<7))
1317	1317	{
1318		data &= device->machine().root_device().ioport("JOY1")->read();
	1318	data &= space.machine().root_device().ioport("JOY1")->read();
1319	1319	}
1320	1320
1321	1321	data |= state->m_telestrat_via2_port_b_data & ((1<<7) | (1<<6) | (1<<5));
r18055	r18056
1325	1325
1326	1326	static WRITE8_DEVICE_HANDLER(telestrat_via2_out_b_func)
1327	1327	{
1328		oric_state *state = device->machine().driver_data<oric_state>();
	1328	oric_state *state = space.machine().driver_data<oric_state>();
1329	1329	state->m_telestrat_via2_port_b_data = data;
1330	1330	}
1331	1331

trunk/src/mess/machine/amstrad.c

r18055	r18056
2508	2508	/* Read/Write 8255 PPI port A (connected to AY-3-8912 databus) */
2509	2509	READ8_DEVICE_HANDLER ( amstrad_ppi_porta_r )
2510	2510	{
2511		amstrad_state *state = device->machine().driver_data<amstrad_state>();
2512		update_psg(device->machine());
	2511	amstrad_state *state = space.machine().driver_data<amstrad_state>();
	2512	update_psg(space.machine());
2513	2513	return state->m_ppi_port_inputs[amstrad_ppi_PortA];
2514	2514	}
2515	2515
2516	2516
2517	2517	WRITE8_DEVICE_HANDLER ( amstrad_ppi_porta_w )
2518	2518	{
2519		amstrad_state *state = device->machine().driver_data<amstrad_state>();
	2519	amstrad_state *state = space.machine().driver_data<amstrad_state>();
2520	2520	state->m_ppi_port_outputs[amstrad_ppi_PortA] = data;
2521		update_psg(device->machine());
	2521	update_psg(space.machine());
2522	2522	}
2523	2523
2524	2524
r18055	r18056
2550	2550
2551	2551	READ8_DEVICE_HANDLER (amstrad_ppi_portb_r)
2552	2552	{
2553		amstrad_state *state = device->machine().driver_data<amstrad_state>();
	2553	amstrad_state *state = space.machine().driver_data<amstrad_state>();
2554	2554	int data = 0;
2555	2555	/* Set b7 with cassette tape input */
2556	2556	if(state->m_system_type != SYSTEM_GX4000)
r18055	r18056
2582	2582
2583	2583	logerror("amstrad_ppi_portb_r\n");
2584	2584	/* Schedule a write to PC2 */
2585		device->machine().scheduler().timer_set( attotime::zero, FUNC(amstrad_pc2_low));
	2585	space.machine().scheduler().timer_set( attotime::zero, FUNC(amstrad_pc2_low));
2586	2586
2587	2587	return data;
2588	2588	}
r18055	r18056
2604	2604
2605	2605	WRITE8_DEVICE_HANDLER ( amstrad_ppi_portc_w )
2606	2606	{
2607		amstrad_state *state = device->machine().driver_data<amstrad_state>();
	2607	amstrad_state *state = space.machine().driver_data<amstrad_state>();
2608	2608	int changed_data;
2609	2609
2610	2610	state->m_previous_ppi_portc_w = state->m_ppi_port_outputs[amstrad_ppi_PortC];
r18055	r18056
2620	2620	state->m_aleste_rtc_function = data & 0x07;
2621	2621
2622	2622	/* Perform PSG function */
2623		update_psg(device->machine());
	2623	update_psg(space.machine());
2624	2624
2625	2625	/* b5 Cassette Write data */
2626	2626	if(state->m_system_type != SYSTEM_GX4000)

trunk/src/mess/machine/mac.c

r18055	r18056
738	738
739	739	static WRITE8_DEVICE_HANDLER(mac_via_out_cb2)
740	740	{
741		mac_state *mac = device->machine().driver_data<mac_state>();
	741	mac_state *mac = space.machine().driver_data<mac_state>();
742	742
743	743	if (mac->m_kbd_comm == FALSE && data == 0)
744	744	{
745	745	/* Mac pulls CB2 down to initiate communication */
746	746	mac->m_kbd_comm = TRUE;
747	747	mac->m_kbd_receive = TRUE;
748		device->machine().scheduler().timer_set(attotime::from_usec(100), FUNC(kbd_clock));
	748	space.machine().scheduler().timer_set(attotime::from_usec(100), FUNC(kbd_clock));
749	749	}
750	750	if (mac->m_kbd_comm == TRUE && mac->m_kbd_receive == TRUE)
751	751	{
r18055	r18056
1179	1179	static READ8_DEVICE_HANDLER(mac_adb_via_in_cb2)
1180	1180	{
1181	1181	UINT8 ret;
1182		mac_state *mac = device->machine().driver_data<mac_state>();
	1182	mac_state *mac = space.machine().driver_data<mac_state>();
1183	1183
1184	1184	if (ADB_IS_EGRET)
1185	1185	{
r18055	r18056
1208	1208
1209	1209	static WRITE8_DEVICE_HANDLER(mac_adb_via_out_cb2)
1210	1210	{
1211		mac_state *mac = device->machine().driver_data<mac_state>();
	1211	mac_state *mac = space.machine().driver_data<mac_state>();
1212	1212
1213	1213	//        printf("VIA OUT CB2 = %x\n", data);
1214	1214	if (ADB_IS_EGRET)
r18055	r18056
1264	1264
1265	1265	static READ8_DEVICE_HANDLER(mac_via_in_a)
1266	1266	{
1267		mac_state *mac = device->machine().driver_data<mac_state>();
	1267	mac_state *mac = space.machine().driver_data<mac_state>();
1268	1268
1269		//  printf("VIA1 IN_A (PC %x)\n", device->machine().device("maincpu")->safe_pc());
	1269	//  printf("VIA1 IN_A (PC %x)\n", space.machine().device("maincpu")->safe_pc());
1270	1270
1271	1271	switch (mac->m_model)
1272	1272	{
r18055	r18056
1332	1332	static READ8_DEVICE_HANDLER(mac_via_in_b)
1333	1333	{
1334	1334	int val = 0;
1335		mac_state *mac = device->machine().driver_data<mac_state>();
	1335	mac_state *mac = space.machine().driver_data<mac_state>();
1336	1336
1337	1337	// portable/PB100 is pretty different
1338	1338	if (mac->m_model >= MODEL_MAC_PORTABLE && mac->m_model <= MODEL_MAC_PB100)
r18055	r18056
1343	1343	else
1344	1344	{
1345	1345	/* video beam in display (! VBLANK && ! HBLANK basically) */
1346		if (device->machine().primary_screen->vpos() >= MAC_V_VIS)
	1346	if (space.machine().primary_screen->vpos() >= MAC_V_VIS)
1347	1347	val |= 0x40;
1348	1348
1349	1349	if (ADB_IS_BITBANG)
r18055	r18056
1369	1369	val |= 0x20;
1370	1370	if (mac->m_mouse_bit_x)   /* Mouse X2 */
1371	1371	val |= 0x10;
1372		if ((device->machine().root_device().ioport("MOUSE0")->read() & 0x01) == 0)
	1372	if ((space.machine().root_device().ioport("MOUSE0")->read() & 0x01) == 0)
1373	1373	val |= 0x08;
1374	1374	}
1375	1375	if (mac->m_rtc_data_out)
1376	1376	val |= 1;
1377	1377	}
1378	1378
1379		//  printf("VIA1 IN_B = %02x (PC %x)\n", val, device->machine().device("maincpu")->safe_pc());
	1379	//  printf("VIA1 IN_B = %02x (PC %x)\n", val, space.machine().device("maincpu")->safe_pc());
1380	1380
1381	1381	return val;
1382	1382	}
1383	1383
1384	1384	static WRITE8_DEVICE_HANDLER(mac_via_out_a)
1385	1385	{
1386		device_t *sound = device->machine().device("custom");
1387		device_t *fdc = device->machine().device("fdc");
1388		mac_state *mac = device->machine().driver_data<mac_state>();
	1386	device_t *sound = space.machine().device("custom");
	1387	device_t *fdc = space.machine().device("fdc");
	1388	mac_state *mac = space.machine().driver_data<mac_state>();
1389	1389
1390		//  printf("VIA1 OUT A: %02x (PC %x)\n", data, device->machine().device("maincpu")->safe_pc());
	1390	//  printf("VIA1 OUT A: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
1391	1391
1392	1392	if (ADB_IS_PM_VIA1)
1393	1393	{
r18055	r18056
1427	1427
1428	1428	static WRITE8_DEVICE_HANDLER(mac_via_out_b)
1429	1429	{
1430		device_t *sound = device->machine().device("custom");
	1430	device_t *sound = space.machine().device("custom");
1431	1431	int new_rtc_rTCClk;
1432		mac_state *mac = device->machine().driver_data<mac_state>();
	1432	mac_state *mac = space.machine().driver_data<mac_state>();
1433	1433
1434		//  printf("VIA1 OUT B: %02x (PC %x)\n", data, device->machine().device("maincpu")->safe_pc());
	1434	//  printf("VIA1 OUT B: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
1435	1435
1436	1436	if (ADB_IS_PM_VIA1)
1437	1437	{
1438		device_t *fdc = device->machine().device("fdc");
	1438	device_t *fdc = space.machine().device("fdc");
1439	1439
1440	1440	sony_set_sel_line(fdc,(data & 0x20) >> 5);
1441	1441	mac->m_drive_select = ((data & 0x10) >> 4);
r18055	r18056
1632	1632	static READ8_DEVICE_HANDLER(mac_via2_in_a)
1633	1633	{
1634	1634	UINT8 result;
1635		mac_state *mac = device->machine().driver_data<mac_state>();
	1635	mac_state *mac = space.machine().driver_data<mac_state>();
1636	1636
1637	1637	if (ADB_IS_PM_VIA2)
1638	1638	{
r18055	r18056
1652	1652
1653	1653	static READ8_DEVICE_HANDLER(mac_via2_in_b)
1654	1654	{
1655		mac_state *mac =device->machine().driver_data<mac_state>();
	1655	mac_state *mac =space.machine().driver_data<mac_state>();
1656	1656
1657		//  logerror("VIA2 IN B (PC %x)\n", device->machine().device("maincpu")->safe_pc());
	1657	//  logerror("VIA2 IN B (PC %x)\n", space.machine().device("maincpu")->safe_pc());
1658	1658
1659	1659	if (ADB_IS_PM_VIA2)
1660	1660	{
r18055	r18056
1683	1683
1684	1684	static WRITE8_DEVICE_HANDLER(mac_via2_out_a)
1685	1685	{
1686		mac_state *mac = device->machine().driver_data<mac_state>();
	1686	mac_state *mac = space.machine().driver_data<mac_state>();
1687	1687
1688		//  logerror("VIA2 OUT A: %02x (PC %x)\n", data, device->machine().device("maincpu")->safe_pc());
	1688	//  logerror("VIA2 OUT A: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
1689	1689	if (ADB_IS_PM_VIA2)
1690	1690	{
1691	1691	mac->m_pm_data_send = data;
r18055	r18056
1695	1695
1696	1696	static WRITE8_DEVICE_HANDLER(mac_via2_out_b)
1697	1697	{
1698		mac_state *mac = device->machine().driver_data<mac_state>();
	1698	mac_state *mac = space.machine().driver_data<mac_state>();
1699	1699
1700		//  logerror("VIA2 OUT B: %02x (PC %x)\n", data, device->machine().device("maincpu")->safe_pc());
	1700	//  logerror("VIA2 OUT B: %02x (PC %x)\n", data, space.machine().device("maincpu")->safe_pc());
1701	1701
1702	1702	if (ADB_IS_PM_VIA2)
1703	1703	{

trunk/src/mess/machine/concept.c

r18055	r18056
223	223	{
224	224	UINT8 status;
225	225
226		status = ((device->machine().root_device().ioport("DSW0")->read() & 0x80) >> 1) | ((device->machine().root_device().ioport("DSW0")->read() & 0x40) << 1);
	226	status = ((space.machine().root_device().ioport("DSW0")->read() & 0x80) >> 1) | ((space.machine().root_device().ioport("DSW0")->read() & 0x40) << 1);
227	227	LOG(("via_in_b: VIA port B (DIP switches, Video, Comm Rate) - status: 0x%2.2x\n", status));
228	228	return status;
229	229	}

trunk/src/mess/machine/upd7002.c

r18055	r18056
152	152	if (uPD7002->status & 0x08)
153	153	{
154	154	// 12 bit conversion takes 10ms
155		device->machine().scheduler().timer_set(attotime::from_msec(10), FUNC(uPD7002_conversioncomplete), uPD7002->conversion_counter, (void *)device);
	155	space.machine().scheduler().timer_set(attotime::from_msec(10), FUNC(uPD7002_conversioncomplete), uPD7002->conversion_counter, (void *)device);
156	156	} else {
157	157	// 8 bit conversion takes 4ms
158		device->machine().scheduler().timer_set(attotime::from_msec(4), FUNC(uPD7002_conversioncomplete), uPD7002->conversion_counter, (void *)device);
	158	space.machine().scheduler().timer_set(attotime::from_msec(4), FUNC(uPD7002_conversioncomplete), uPD7002->conversion_counter, (void *)device);
159	159	}
160	160	break;
161	161

trunk/src/mess/machine/msx.c

r18055	r18056
625	625
626	626	WRITE8_DEVICE_HANDLER( msx_printer_strobe_w )
627	627	{
628		device->machine().device<centronics_device>("centronics")->strobe_w(BIT(data, 1));
	628	space.machine().device<centronics_device>("centronics")->strobe_w(BIT(data, 1));
629	629	}
630	630
631	631	WRITE8_DEVICE_HANDLER( msx_printer_data_w )
632	632	{
633		if (device->machine().root_device().ioport("DSW")->read() & 0x80)
	633	if (space.machine().root_device().ioport("DSW")->read() & 0x80)
634	634	/* SIMPL emulation */
635		device->machine().device<dac_device>("dac")->write_signed8(data);
	635	space.machine().device<dac_device>("dac")->write_signed8(data);
636	636	else
637		device->machine().device<centronics_device>("centronics")->write(device->machine().driver_data()->generic_space(), 0, data);
	637	space.machine().device<centronics_device>("centronics")->write(space.machine().driver_data()->generic_space(), 0, data);
638	638	}
639	639
640	640	READ8_DEVICE_HANDLER( msx_printer_status_r )
641	641	{
642	642	UINT8 result = 0xfd;
643	643
644		if (device->machine().root_device().ioport("DSW")->read() & 0x80)
	644	if (space.machine().root_device().ioport("DSW")->read() & 0x80)
645	645	return 0xff;
646	646
647		result |= device->machine().device<centronics_device>("centronics")->busy_r() << 1;
	647	result |= space.machine().device<centronics_device>("centronics")->busy_r() << 1;
648	648
649	649	return result;
650	650	}

trunk/src/mess/machine/mz700.c

r18055	r18056
442	442	for(i=0;i<10;i++)
443	443	{
444	444	if(key_line & (1 << i))
445		res |= device->machine().root_device().ioport(keynames[i])->read();
	445	res |= space.machine().root_device().ioport(keynames[i])->read();
446	446	}
447	447
448	448	return res;
r18055	r18056
456	456	*/
457	457	static READ8_DEVICE_HANDLER( pio_port_c_r )
458	458	{
459		cassette_image_device *cas = device->machine().device<cassette_image_device>(CASSETTE_TAG);
460		mz_state *mz = device->machine().driver_data<mz_state>();
	459	cassette_image_device *cas = space.machine().device<cassette_image_device>(CASSETTE_TAG);
	460	mz_state *mz = space.machine().driver_data<mz_state>();
461	461	UINT8 data = 0;
462	462
463	463	/* note: this is actually connected to Q output of the motor-control flip-flop (see below) */
r18055	r18056
468	468	data |= 0x20;       /* set the RDATA status */
469	469
470	470	data |= mz->m_cursor_timer << 6;
471		data |= device->machine().primary_screen->vblank() << 7;
	471	data |= space.machine().primary_screen->vblank() << 7;
472	472
473		LOG(2,"mz700_pio_port_c_r",("%02X\n", data),device->machine());
	473	LOG(2,"mz700_pio_port_c_r",("%02X\n", data),space.machine());
474	474
475	475	return data;
476	476	}
r18055	r18056
478	478
479	479	static WRITE8_DEVICE_HANDLER( pio_port_a_w )
480	480	{
481		timer_device *timer = device->machine().device<timer_device>("cursor");
	481	timer_device *timer = space.machine().device<timer_device>("cursor");
482	482
483		LOG(2,"mz700_pio_port_a_w",("%02X\n", data),device->machine());
	483	LOG(2,"mz700_pio_port_a_w",("%02X\n", data),space.machine());
484	484
485	485	/* the ls145 is connected to PA0-PA3 */
486	486	dynamic_cast<ttl74145_device *>(device)->write(data & 0x07);
r18055	r18056
499	499	* bit 0 out    unused
500	500	*/
501	501
502		//  UINT8 state = cassette_get_state(device->machine().device<cassette_image_device>(CASSETTE_TAG));
	502	//  UINT8 state = cassette_get_state(space.machine().device<cassette_image_device>(CASSETTE_TAG));
503	503	//  UINT8 action = ((~pio_port_c_output & 8) & (data & 8));     /* detect low-to-high transition */
504	504
505	505	/* The motor control circuit consists of a resistor, capacitor, invertor, nand-gate, and D flip-flop.
r18055	r18056
512	512	If you load from the command-line or the software-picker, type in L <enter> immediately. */
513	513	#if 0
514	514
515		device->machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(
	515	space.machine().device<cassette_image_device>(CASSETTE_TAG)->change_state(
516	516	((data & 0x08) && mz700_motor_on) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED,
517	517	CASSETTE_MOTOR_DISABLED);
518	518
519	519	#endif
520	520
521		LOG(2,"mz700_pio_port_c_w",("%02X\n", data),device->machine());
	521	LOG(2,"mz700_pio_port_c_w",("%02X\n", data),space.machine());
522	522
523		device->machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x02) ? +1.0 : -1.0);
	523	space.machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x02) ? +1.0 : -1.0);
524	524	}
525	525
526	526
r18055	r18056
545	545
546	546	static READ8_DEVICE_HANDLER( mz800_z80pio_port_a_r )
547	547	{
548		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	548	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
549	549	UINT8 result = 0;
550	550
551	551	result |= centronics->busy_r();
552	552	result |= centronics->pe_r() << 1;
553		result |= device->machine().primary_screen->hblank() << 5;
	553	result |= space.machine().primary_screen->hblank() << 5;
554	554
555	555	return result;
556	556	}
557	557
558	558	static WRITE8_DEVICE_HANDLER( mz800_z80pio_port_a_w )
559	559	{
560		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	560	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
561	561
562	562	centronics->init_prime_w(BIT(data, 6));
563	563	centronics->strobe_w(BIT(data, 7));

trunk/src/mess/machine/lisa.c

r18055	r18056
681	681	*/
682	682	static WRITE8_DEVICE_HANDLER(COPS_via_out_a)
683	683	{
684		lisa_state *state = device->machine().driver_data<lisa_state>();
	684	lisa_state *state = space.machine().driver_data<lisa_state>();
685	685	//    printf("VIA A = %02x\n", data);
686	686	state->m_COPS_command = data;
687	687	}
688	688
689	689	static WRITE8_DEVICE_HANDLER(COPS_via_out_ca2)
690	690	{
691		lisa_state *state = device->machine().driver_data<lisa_state>();
	691	lisa_state *state = space.machine().driver_data<lisa_state>();
692	692	state->m_hold_COPS_data = data;
693	693
694	694	/*logerror("COPS CA2 line state : %d\n", val);*/
695	695
696	696	/*logerror("COPS_via_out_ca2 : trying to send data to VIA\n");*/
697		COPS_send_data_if_possible(device->machine());
	697	COPS_send_data_if_possible(space.machine());
698	698	}
699	699
700	700	/*
r18055	r18056
713	713	*/
714	714	static READ8_DEVICE_HANDLER(COPS_via_in_b)
715	715	{
716		lisa_state *state = device->machine().driver_data<lisa_state>();
	716	lisa_state *state = space.machine().driver_data<lisa_state>();
717	717	int val = 0;
718	718
719	719	if (state->m_COPS_Ready)
r18055	r18056
727	727
728	728	static WRITE8_DEVICE_HANDLER(COPS_via_out_b)
729	729	{
730		lisa_state *state = device->machine().driver_data<lisa_state>();
731		via6522_device *via_0 = device->machine().device<via6522_device>("via6522_0");
	730	lisa_state *state = space.machine().driver_data<lisa_state>();
	731	via6522_device *via_0 = space.machine().device<via6522_device>("via6522_0");
732	732
733	733	/* pull-up */
734	734	data |= (~ via_0->read(space,VIA_DDRA)) & 0x01;
r18055	r18056
738	738	if (state->m_COPS_force_unplug)
739	739	{
740	740	state->m_COPS_force_unplug = 0;
741		plug_keyboard(device->machine());
	741	plug_keyboard(space.machine());
742	742	}
743	743	}
744	744	else
r18055	r18056
746	746	if (! state->m_COPS_force_unplug)
747	747	{
748	748	state->m_COPS_force_unplug = 1;
749		unplug_keyboard(device->machine());
	749	unplug_keyboard(space.machine());
750	750	//reset_COPS(state);
751	751	}
752	752	}
r18055	r18056
754	754
755	755	static WRITE8_DEVICE_HANDLER(COPS_via_out_cb2)
756	756	{
757		device_t *speaker = device->machine().device(SPEAKER_TAG);
	757	device_t *speaker = space.machine().device(SPEAKER_TAG);
758	758	speaker_level_w(speaker, data);
759	759	}
760	760
r18055	r18056
790	790	*/
791	791	static READ8_DEVICE_HANDLER(parallel_via_in_b)
792	792	{
793		lisa_state *state = device->machine().driver_data<lisa_state>();
	793	lisa_state *state = space.machine().driver_data<lisa_state>();
794	794	int val = 0;
795	795
796	796	if (state->m_DISK_DIAG)

trunk/src/mess/machine/cgenie.c

r18055	r18056
604	604
605	605	READ8_DEVICE_HANDLER( cgenie_sh_control_port_r )
606	606	{
607		cgenie_state *state = device->machine().driver_data<cgenie_state>();
	607	cgenie_state *state = space.machine().driver_data<cgenie_state>();
608	608	return state->m_control_port;
609	609	}
610	610
611	611	WRITE8_DEVICE_HANDLER( cgenie_sh_control_port_w )
612	612	{
613		cgenie_state *state = device->machine().driver_data<cgenie_state>();
	613	cgenie_state *state = space.machine().driver_data<cgenie_state>();
614	614	state->m_control_port = data;
615	615	ay8910_address_w(device, space, offset, data);
616	616	}

trunk/src/mess/machine/super80.c

r18055	r18056
14	14
15	15	static READ8_DEVICE_HANDLER( pio_port_b_r ) // cannot be modernised yet as super80 hangs at start
16	16	{
17		super80_state *state = device->machine().driver_data<super80_state>();
	17	super80_state *state = space.machine().driver_data<super80_state>();
18	18	char kbdrow[6];
19	19	UINT8 i;
20	20	UINT8 data = 0xff;

trunk/src/mess/machine/lviv.c

r18055	r18056
65	65
66	66	static READ8_DEVICE_HANDLER ( lviv_ppi_0_portc_r )
67	67	{
68		lviv_state *state = device->machine().driver_data<lviv_state>();
	68	lviv_state *state = space.machine().driver_data<lviv_state>();
69	69	UINT8 data = state->m_ppi_port_outputs[0][2] & 0x0f;
70		if (device->machine().device<cassette_image_device>(CASSETTE_TAG)->input() > 0.038)
	70	if (space.machine().device<cassette_image_device>(CASSETTE_TAG)->input() > 0.038)
71	71	data |= 0x10;
72	72	if (state->m_ppi_port_outputs[0][0] & state->ioport("JOY")->read())
73	73	data |= 0x80;
r18055	r18056
76	76
77	77	static WRITE8_DEVICE_HANDLER ( lviv_ppi_0_porta_w )
78	78	{
79		lviv_state *state = device->machine().driver_data<lviv_state>();
	79	lviv_state *state = space.machine().driver_data<lviv_state>();
80	80	state->m_ppi_port_outputs[0][0] = data;
81	81	}
82	82
83	83	static WRITE8_DEVICE_HANDLER ( lviv_ppi_0_portb_w )
84	84	{
85		lviv_state *state = device->machine().driver_data<lviv_state>();
	85	lviv_state *state = space.machine().driver_data<lviv_state>();
86	86	state->m_ppi_port_outputs[0][1] = data;
87		lviv_update_palette(device->machine(), data&0x7f);
	87	lviv_update_palette(space.machine(), data&0x7f);
88	88	}
89	89
90	90	static WRITE8_DEVICE_HANDLER ( lviv_ppi_0_portc_w )   /* tape in/out, video memory on/off */
91	91	{
92		lviv_state *state = device->machine().driver_data<lviv_state>();
93		device_t *speaker = device->machine().device(SPEAKER_TAG);
	92	lviv_state *state = space.machine().driver_data<lviv_state>();
	93	device_t *speaker = space.machine().device(SPEAKER_TAG);
94	94	state->m_ppi_port_outputs[0][2] = data;
95	95	if (state->m_ppi_port_outputs[0][1]&0x80)
96	96	speaker_level_w(speaker, data&0x01);
97		device->machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x01) ? -1.0 : 1.0);
98		lviv_update_memory(device->machine());
	97	space.machine().device<cassette_image_device>(CASSETTE_TAG)->output((data & 0x01) ? -1.0 : 1.0);
	98	lviv_update_memory(space.machine());
99	99	}
100	100
101	101	static READ8_DEVICE_HANDLER ( lviv_ppi_1_porta_r )
r18055	r18056
105	105
106	106	static READ8_DEVICE_HANDLER ( lviv_ppi_1_portb_r )   /* keyboard reading */
107	107	{
108		lviv_state *state = device->machine().driver_data<lviv_state>();
109		return   ((state->m_ppi_port_outputs[1][0] & 0x01) ? 0xff : device->machine().root_device().ioport("KEY0")->read()) &
110		((state->m_ppi_port_outputs[1][0] & 0x02) ? 0xff : device->machine().root_device().ioport("KEY1")->read()) &
111		((state->m_ppi_port_outputs[1][0] & 0x04) ? 0xff : device->machine().root_device().ioport("KEY2")->read()) &
112		((state->m_ppi_port_outputs[1][0] & 0x08) ? 0xff : device->machine().root_device().ioport("KEY3")->read()) &
113		((state->m_ppi_port_outputs[1][0] & 0x10) ? 0xff : device->machine().root_device().ioport("KEY4")->read()) &
114		((state->m_ppi_port_outputs[1][0] & 0x20) ? 0xff : device->machine().root_device().ioport("KEY5")->read()) &
115		((state->m_ppi_port_outputs[1][0] & 0x40) ? 0xff : device->machine().root_device().ioport("KEY6")->read()) &
	108	lviv_state *state = space.machine().driver_data<lviv_state>();
	109	return   ((state->m_ppi_port_outputs[1][0] & 0x01) ? 0xff : space.machine().root_device().ioport("KEY0")->read()) &
	110	((state->m_ppi_port_outputs[1][0] & 0x02) ? 0xff : space.machine().root_device().ioport("KEY1")->read()) &
	111	((state->m_ppi_port_outputs[1][0] & 0x04) ? 0xff : space.machine().root_device().ioport("KEY2")->read()) &
	112	((state->m_ppi_port_outputs[1][0] & 0x08) ? 0xff : space.machine().root_device().ioport("KEY3")->read()) &
	113	((state->m_ppi_port_outputs[1][0] & 0x10) ? 0xff : space.machine().root_device().ioport("KEY4")->read()) &
	114	((state->m_ppi_port_outputs[1][0] & 0x20) ? 0xff : space.machine().root_device().ioport("KEY5")->read()) &
	115	((state->m_ppi_port_outputs[1][0] & 0x40) ? 0xff : space.machine().root_device().ioport("KEY6")->read()) &
116	116	((state->m_ppi_port_outputs[1][0] & 0x80) ? 0xff : state->ioport("KEY7")->read());
117	117	}
118	118
119	119	static READ8_DEVICE_HANDLER ( lviv_ppi_1_portc_r )     /* keyboard reading */
120	120	{
121		lviv_state *state = device->machine().driver_data<lviv_state>();
122		return   ((state->m_ppi_port_outputs[1][2] & 0x01) ? 0xff : device->machine().root_device().ioport("KEY8")->read()) &
123		((state->m_ppi_port_outputs[1][2] & 0x02) ? 0xff : device->machine().root_device().ioport("KEY9" )->read()) &
124		((state->m_ppi_port_outputs[1][2] & 0x04) ? 0xff : device->machine().root_device().ioport("KEY10")->read()) &
	121	lviv_state *state = space.machine().driver_data<lviv_state>();
	122	return   ((state->m_ppi_port_outputs[1][2] & 0x01) ? 0xff : space.machine().root_device().ioport("KEY8")->read()) &
	123	((state->m_ppi_port_outputs[1][2] & 0x02) ? 0xff : space.machine().root_device().ioport("KEY9" )->read()) &
	124	((state->m_ppi_port_outputs[1][2] & 0x04) ? 0xff : space.machine().root_device().ioport("KEY10")->read()) &
125	125	((state->m_ppi_port_outputs[1][2] & 0x08) ? 0xff : state->ioport("KEY11")->read());
126	126	}
127	127
128	128	static WRITE8_DEVICE_HANDLER ( lviv_ppi_1_porta_w )   /* kayboard scaning */
129	129	{
130		lviv_state *state = device->machine().driver_data<lviv_state>();
	130	lviv_state *state = space.machine().driver_data<lviv_state>();
131	131	state->m_ppi_port_outputs[1][0] = data;
132	132	}
133	133
134	134	static WRITE8_DEVICE_HANDLER ( lviv_ppi_1_portb_w )
135	135	{
136		lviv_state *state = device->machine().driver_data<lviv_state>();
	136	lviv_state *state = space.machine().driver_data<lviv_state>();
137	137	state->m_ppi_port_outputs[1][1] = data;
138	138	}
139	139
140	140	static WRITE8_DEVICE_HANDLER ( lviv_ppi_1_portc_w )   /* kayboard scaning */
141	141	{
142		lviv_state *state = device->machine().driver_data<lviv_state>();
	142	lviv_state *state = space.machine().driver_data<lviv_state>();
143	143	state->m_ppi_port_outputs[1][2] = data;
144	144	}
145	145

trunk/src/mess/machine/apple1.c

r18055	r18056
384	384	*****************************************************************************/
385	385	static READ8_DEVICE_HANDLER( apple1_pia0_kbdin )
386	386	{
387		apple1_state *state = device->machine().driver_data<apple1_state>();
	387	apple1_state *state = space.machine().driver_data<apple1_state>();
388	388	/* Bit 7 of the keyboard input is permanently wired high.  This is
389	389	what the ROM Monitor software expects. */
390	390	return state->m_kbd_data | 0x80;
r18055	r18056
393	393	static WRITE8_DEVICE_HANDLER( apple1_pia0_dspout )
394	394	{
395	395	/* Send an ASCII character to the video hardware. */
396		apple1_vh_dsp_w(device->machine(), data);
	396	apple1_vh_dsp_w(space.machine(), data);
397	397	}
398	398
399	399	static WRITE8_DEVICE_HANDLER( apple1_pia0_dsp_write_signal )
r18055	r18056
413	413	write.  Thus the write delay depends on the cursor position and
414	414	where the display is in the refresh cycle. */
415	415	if (!data)
416		device->machine().scheduler().timer_set(apple1_vh_dsp_time_to_ready(device->machine()), FUNC(apple1_dsp_ready_start));
	416	space.machine().scheduler().timer_set(apple1_vh_dsp_time_to_ready(space.machine()), FUNC(apple1_dsp_ready_start));
417	417	}
418	418
419	419	static TIMER_CALLBACK(apple1_dsp_ready_start)

trunk/src/mess/machine/mc6843.c

r18055	r18056
427	427	int cmd = mc6843->CMR & 0x0f;
428	428
429	429	LOG(( "%f $%04x mc6843_r: data input cmd=%s(%i), pos=%i/%i, GCR=%i, ",
430		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ),
	430	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ),
431	431	mc6843_cmd[cmd], cmd, mc6843->data_idx,
432	432	mc6843->data_size, mc6843->GCR ));
433	433
r18055	r18056
480	480	{
481	481	/* XXX TODO: other read modes */
482	482	data = mc6843->data[0];
483		logerror( "$%04x mc6843 read in unsupported command mode %i\n", device->machine().firstcpu->pcbase( ), cmd );
	483	logerror( "$%04x mc6843 read in unsupported command mode %i\n", space.machine().firstcpu->pcbase( ), cmd );
484	484	}
485	485
486	486	LOG(( "data=%02X\n", data ));
r18055	r18056
491	491	case 1: /* Current-Track Address Register (CTAR) */
492	492	data = mc6843->CTAR;
493	493	LOG(( "%f $%04x mc6843_r: read CTAR %i (actual=%i)\n",
494		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data,
	494	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data,
495	495	floppy_drive_get_current_track( mc6843_floppy_image( device ) ) ));
496	496	break;
497	497
498	498	case 2: /* Interrupt Status Register (ISR) */
499	499	data = mc6843->ISR;
500	500	LOG(( "%f $%04x mc6843_r: read ISR %02X: cmd=%scomplete settle=%scomplete sense-rq=%i STRB=%i\n",
501		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data,
	501	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data,
502	502	(data & 1) ? "" : "not-" , (data & 2) ? "" : "not-",
503	503	(data >> 2) & 1, (data >> 3) & 1 ));
504	504
r18055	r18056
524	524
525	525	data = mc6843->STRA;
526	526	LOG(( "%f $%04x mc6843_r: read STRA %02X: data-rq=%i del-dta=%i ready=%i t0=%i wp=%i trk-dif=%i idx=%i busy=%i\n",
527		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data,
	527	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data,
528	528	data & 1, (data >> 1) & 1, (data >> 2) & 1, (data >> 3) & 1,
529	529	(data >> 4) & 1, (data >> 5) & 1, (data >> 6) & 1, (data >> 7) & 1 ));
530	530	break;
r18055	r18056
533	533	case 4: /* Status Register B (STRB) */
534	534	data = mc6843->STRB;
535	535	LOG(( "%f $%04x mc6843_r: read STRB %02X: data-err=%i CRC-err=%i dta--mrk-err=%i sect-mrk-err=%i seek-err=%i fi=%i wr-err=%i hard-err=%i\n",
536		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data,
	536	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data,
537	537	data & 1, (data >> 1) & 1, (data >> 2) & 1, (data >> 3) & 1,
538	538	(data >> 4) & 1, (data >> 5) & 1, (data >> 6) & 1, (data >> 7) & 1 ));
539	539
r18055	r18056
545	545	case 7: /* Logical-Track Address Register (LTAR) */
546	546	data = mc6843->LTAR;
547	547	LOG(( "%f $%04x mc6843_r: read LTAR %i (actual=%i)\n",
548		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data,
	548	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data,
549	549	floppy_drive_get_current_track( mc6843_floppy_image( device ) ) ));
550	550	break;
551	551
552	552	default:
553		logerror( "$%04x mc6843 invalid read offset %i\n", device->machine().firstcpu->pcbase( ), offset );
	553	logerror( "$%04x mc6843 invalid read offset %i\n", space.machine().firstcpu->pcbase( ), offset );
554	554	}
555	555
556	556	return data;
r18055	r18056
567	567	int FWF = (mc6843->CMR >> 4) & 1;
568	568
569	569	LOG(( "%f $%04x mc6843_w: data output cmd=%s(%i), pos=%i/%i, GCR=%i, data=%02X\n",
570		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ),
	570	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ),
571	571	mc6843_cmd[cmd], cmd, mc6843->data_idx,
572	572	mc6843->data_size, mc6843->GCR, data ));
573	573
r18055	r18056
584	584	/* end of sector write */
585	585	device_t* img = mc6843_floppy_image( device );
586	586
587		LOG(( "%f $%04x mc6843_w: write sector %i\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6843->data_id ));
	587	LOG(( "%f $%04x mc6843_w: write sector %i\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6843->data_id ));
588	588
589	589	floppy_drive_write_sector_data(
590	590	img, mc6843->side, mc6843->data_id,
r18055	r18056
648	648	UINT8 track  = mc6843->data[1];
649	649	UINT8 sector = mc6843->data[3];
650	650	UINT8 filler = 0xe5; /* standard Thomson filler */
651		LOG(( "%f $%04x mc6843_w: address id detected track=%i sector=%i\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), track, sector));
	651	LOG(( "%f $%04x mc6843_w: address id detected track=%i sector=%i\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), track, sector));
652	652	floppy_drive_format_sector( img, mc6843->side, sector, track, 0, sector, 0, filler );
653	653	}
654	654	else
r18055	r18056
670	670	else
671	671	{
672	672	/* XXX TODO: other write modes */
673		logerror( "$%04x mc6843 write %02X in unsupported command mode %i (FWF=%i)\n", device->machine().firstcpu->pcbase( ), data, cmd, FWF );
	673	logerror( "$%04x mc6843 write %02X in unsupported command mode %i (FWF=%i)\n", space.machine().firstcpu->pcbase( ), data, cmd, FWF );
674	674	}
675	675	break;
676	676	}
r18055	r18056
678	678	case 1: /* Current-Track Address Register (CTAR) */
679	679	mc6843->CTAR = data & 0x7f;
680	680	LOG(( "%f $%04x mc6843_w: set CTAR to %i %02X (actual=%i) \n",
681		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6843->CTAR, data,
	681	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6843->CTAR, data,
682	682	floppy_drive_get_current_track( mc6843_floppy_image( device ) ) ));
683	683	break;
684	684
r18055	r18056
687	687	int cmd = data & 15;
688	688
689	689	LOG(( "%f $%04x mc6843_w: set CMR to $%02X: cmd=%s(%i) FWF=%i DMA=%i ISR3-intr=%i fun-intr=%i\n",
690		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ),
	690	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ),
691	691	data, mc6843_cmd[cmd], cmd, (data >> 4) & 1, (data >> 5) & 1,
692	692	(data >> 6) & 1, (data >> 7) & 1 ));
693	693
r18055	r18056
734	734
735	735	/* assume CLK freq = 1MHz (IBM 3740 compatibility) */
736	736	LOG(( "%f $%04x mc6843_w: set SUR to $%02X: head settling time=%fms, track-to-track seek time=%f\n",
737		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ),
	737	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ),
738	738	data, 4.096 * (data & 15), 1.024 * ((data >> 4) & 15) ));
739	739	break;
740	740
741	741	case 4: /* Sector Address Register (SAR) */
742	742	mc6843->SAR = data & 0x1f;
743		LOG(( "%f $%04x mc6843_w: set SAR to %i (%02X)\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6843->SAR, data ));
	743	LOG(( "%f $%04x mc6843_w: set SAR to %i (%02X)\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6843->SAR, data ));
744	744	break;
745	745
746	746	case 5: /* General Count Register (GCR) */
747	747	mc6843->GCR = data & 0x7f;
748		LOG(( "%f $%04x mc6843_w: set GCR to %i (%02X)\n", device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6843->GCR, data ));
	748	LOG(( "%f $%04x mc6843_w: set GCR to %i (%02X)\n", space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6843->GCR, data ));
749	749	break;
750	750
751	751	case 6: /* CRC Control Register (CCR) */
752	752	mc6843->CCR = data & 3;
753	753	LOG(( "%f $%04x mc6843_w: set CCR to %02X: CRC=%s shift=%i\n",
754		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), data,
	754	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), data,
755	755	(data & 1) ? "enabled" : "disabled", (data >> 1) & 1 ));
756	756	break;
757	757
758	758	case 7: /* Logical-Track Address Register (LTAR) */
759	759	mc6843->LTAR = data & 0x7f;
760	760	LOG(( "%f $%04x mc6843_w: set LTAR to %i %02X (actual=%i)\n",
761		device->machine().time().as_double(), device->machine().firstcpu->pcbase( ), mc6843->LTAR, data,
	761	space.machine().time().as_double(), space.machine().firstcpu->pcbase( ), mc6843->LTAR, data,
762	762	floppy_drive_get_current_track( mc6843_floppy_image( device ) ) ));
763	763	break;
764	764
765	765	default:
766		logerror( "$%04x mc6843 invalid write offset %i (data=$%02X)\n", device->machine().firstcpu->pcbase( ), offset, data );
	766	logerror( "$%04x mc6843 invalid write offset %i (data=$%02X)\n", space.machine().firstcpu->pcbase( ), offset, data );
767	767	}
768	768	}
769	769

trunk/src/mess/machine/mtx.c

r18055	r18056
29	29
30	30	READ8_DEVICE_HANDLER( mtx_strobe_r )
31	31	{
32		centronics_device *centronics = device->machine().device<centronics_device>(CENTRONICS_TAG);
	32	centronics_device *centronics = space.machine().device<centronics_device>(CENTRONICS_TAG);
33	33	/* set STROBE low */
34	34	centronics->strobe_w(FALSE);
35	35
r18055	r18056
116	116
117	117	READ8_DEVICE_HANDLER( mtx_sound_strobe_r )
118	118	{
119		mtx_state *state = device->machine().driver_data<mtx_state>();
	119	mtx_state *state = space.machine().driver_data<mtx_state>();
120	120
121	121	sn76496_w(device, space, 0, state->m_sound_latch);
122	122
r18055	r18056
148	148
149	149	READ8_DEVICE_HANDLER( mtx_prt_r )
150	150	{
151		centronics_device *centronics = device->machine().device<centronics_device>(CENTRONICS_TAG);
	151	centronics_device *centronics = space.machine().device<centronics_device>(CENTRONICS_TAG);
152	152
153	153	/*
154	154

trunk/src/mess/machine/rmnimbus.c

r18055	r18056
2217	2217	{
2218	2218	if(offset==0)
2219	2219	{
2220		return keyboard_queue_read(device->machine());
	2220	return keyboard_queue_read(space.machine());
2221	2221	}
2222	2222	else
2223	2223	return -1;

trunk/src/mess/machine/pp01.c

r18055	r18056
187	187
188	188	static READ8_DEVICE_HANDLER (pp01_8255_porta_r )
189	189	{
190		pp01_state *state = device->machine().driver_data<pp01_state>();
	190	pp01_state *state = space.machine().driver_data<pp01_state>();
191	191	return state->m_video_scroll;
192	192	}
193	193	static WRITE8_DEVICE_HANDLER (pp01_8255_porta_w )
194	194	{
195		pp01_state *state = device->machine().driver_data<pp01_state>();
	195	pp01_state *state = space.machine().driver_data<pp01_state>();
196	196	state->m_video_scroll = data;
197	197	}
198	198
199	199	static READ8_DEVICE_HANDLER (pp01_8255_portb_r )
200	200	{
201		pp01_state *state = device->machine().driver_data<pp01_state>();
	201	pp01_state *state = space.machine().driver_data<pp01_state>();
202	202	static const char *const keynames[] = {
203	203	"LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7",
204	204	"LINE8", "LINE9", "LINEA", "LINEB", "LINEC", "LINED", "LINEE", "LINEF"
205	205	};
206	206
207		return (device->machine().root_device().ioport(keynames[state->m_key_line])->read() & 0x3F) | (device->machine().root_device().ioport("LINEALL")->read() & 0xC0);
	207	return (space.machine().root_device().ioport(keynames[state->m_key_line])->read() & 0x3F) | (space.machine().root_device().ioport("LINEALL")->read() & 0xC0);
208	208	}
209	209	static WRITE8_DEVICE_HANDLER (pp01_8255_portb_w )
210	210	{
r18055	r18056
214	214
215	215	static WRITE8_DEVICE_HANDLER (pp01_8255_portc_w )
216	216	{
217		pp01_state *state = device->machine().driver_data<pp01_state>();
	217	pp01_state *state = space.machine().driver_data<pp01_state>();
218	218	state->m_key_line = data & 0x0f;
219	219	}
220	220

trunk/src/mess/machine/atarifdc.c

r18055	r18056
702	702
703	703	if (fdc->serin_count)
704	704	{
705		pokey_device *pokey = device->machine().device<pokey_device>("pokey");
	705	pokey_device *pokey = space.machine().device<pokey_device>("pokey");
706	706
707	707	data = fdc->serin_buff[fdc->serin_offs];
708	708	ser_delay = 2 * 40;
r18055	r18056
727	727
728	728	WRITE8_DEVICE_HANDLER ( atari_serout_w )
729	729	{
730		pia6821_device *pia = device->machine().device<pia6821_device>( "pia" );
	730	pia6821_device *pia = space.machine().device<pia6821_device>( "pia" );
731	731	atari_fdc_t *fdc = get_safe_token(device);
732	732
733	733	/* ignore serial commands if no floppy image is specified */

trunk/src/mess/machine/pk8020.c

r18055	r18056
848	848
849	849	static READ8_DEVICE_HANDLER(pk8020_porta_r)
850	850	{
851		pk8020_state *state = device->machine().driver_data<pk8020_state>();
	851	pk8020_state *state = space.machine().driver_data<pk8020_state>();
852	852	return 0xf0 | (state->m_takt <<1) | (state->m_text_attr)<<3;
853	853	}
854	854
855	855	static WRITE8_DEVICE_HANDLER(pk8020_portc_w)
856	856	{
857		pk8020_state *state = device->machine().driver_data<pk8020_state>();
	857	pk8020_state *state = space.machine().driver_data<pk8020_state>();
858	858	state->m_video_page_access =(data>>6) & 3;
859	859	state->m_attr = (data >> 4) & 3;
860	860	state->m_wide = (data >> 3) & 1;
r18055	r18056
867	867
868	868	static WRITE8_DEVICE_HANDLER(pk8020_portb_w)
869	869	{
870		device_t *fdc = device->machine().device("wd1793");
	870	device_t *fdc = space.machine().device("wd1793");
871	871	// Turn all motors off
872		floppy_mon_w(floppy_get_device(device->machine(), 0), 1);
873		floppy_mon_w(floppy_get_device(device->machine(), 1), 1);
874		floppy_mon_w(floppy_get_device(device->machine(), 2), 1);
875		floppy_mon_w(floppy_get_device(device->machine(), 3), 1);
	872	floppy_mon_w(floppy_get_device(space.machine(), 0), 1);
	873	floppy_mon_w(floppy_get_device(space.machine(), 1), 1);
	874	floppy_mon_w(floppy_get_device(space.machine(), 2), 1);
	875	floppy_mon_w(floppy_get_device(space.machine(), 3), 1);
876	876	wd17xx_set_side(fdc,BIT(data,4));
877	877	if (BIT(data,0)) {
878	878	wd17xx_set_drive(fdc,0);
879		floppy_mon_w(floppy_get_device(device->machine(), 0), 0);
880		floppy_drive_set_ready_state(floppy_get_device(device->machine(), 0), 1, 1);
	879	floppy_mon_w(floppy_get_device(space.machine(), 0), 0);
	880	floppy_drive_set_ready_state(floppy_get_device(space.machine(), 0), 1, 1);
881	881	} else if (BIT(data,1)) {
882	882	wd17xx_set_drive(fdc,1);
883		floppy_mon_w(floppy_get_device(device->machine(), 1), 0);
884		floppy_drive_set_ready_state(floppy_get_device(device->machine(), 1), 1, 1);
	883	floppy_mon_w(floppy_get_device(space.machine(), 1), 0);
	884	floppy_drive_set_ready_state(floppy_get_device(space.machine(), 1), 1, 1);
885	885	} else if (BIT(data,2)) {
886	886	wd17xx_set_drive(fdc,2);
887		floppy_mon_w(floppy_get_device(device->machine(), 2), 0);
888		floppy_drive_set_ready_state(floppy_get_device(device->machine(), 2), 1, 1);
	887	floppy_mon_w(floppy_get_device(space.machine(), 2), 0);
	888	floppy_drive_set_ready_state(floppy_get_device(space.machine(), 2), 1, 1);
889	889	} else if (BIT(data,3)) {
890	890	wd17xx_set_drive(fdc,3);
891		floppy_mon_w(floppy_get_device(device->machine(), 3), 0);
892		floppy_drive_set_ready_state(floppy_get_device(device->machine(), 3), 1, 1);
	891	floppy_mon_w(floppy_get_device(space.machine(), 3), 0);
	892	floppy_drive_set_ready_state(floppy_get_device(space.machine(), 3), 1, 1);
893	893	}
894	894	}
895	895
896	896	static READ8_DEVICE_HANDLER(pk8020_portc_r)
897	897	{
898		pk8020_state *state = device->machine().driver_data<pk8020_state>();
	898	pk8020_state *state = space.machine().driver_data<pk8020_state>();
899	899	return state->m_portc_data;
900	900	}
901	901
r18055	r18056
912	912
913	913	static WRITE8_DEVICE_HANDLER(pk8020_2_portc_w)
914	914	{
915		pk8020_state *state = device->machine().driver_data<pk8020_state>();
916		device_t *speaker = device->machine().device(SPEAKER_TAG);
	915	pk8020_state *state = space.machine().driver_data<pk8020_state>();
	916	device_t *speaker = space.machine().device(SPEAKER_TAG);
917	917
918	918	state->m_sound_gate = BIT(data,3);
919	919

trunk/src/mess/video/911_vdt.c

r18055	r18056
420	420	case 0xc:
421	421	/* keyboard interrupt enable */
422	422	vdt->keyboard_interrupt_enable = data;
423		(*vdt->int_callback)(device->machine(), vdt->keyboard_interrupt_enable && vdt->keyboard_data_ready);
	423	(*vdt->int_callback)(space.machine(), vdt->keyboard_interrupt_enable && vdt->keyboard_data_ready);
424	424	break;
425	425
426	426	case 0xd:
r18055	r18056
478	478	{
479	479	vdt->keyboard_data_ready = 0;
480	480	if (vdt->keyboard_interrupt_enable)
481		(*vdt->int_callback)(device->machine(), 0);
	481	(*vdt->int_callback)(space.machine(), 0);
482	482	}
483	483	/*vdt->keyboard_parity_error = 0;*/
484	484	break;
485	485
486	486	case 0xe:
487	487	/* beep enable strobe - not tested */
488		beep_set_state(device->machine().device(BEEPER_TAG), 1);
	488	beep_set_state(space.machine().device(BEEPER_TAG), 1);
489	489
490	490	vdt->beep_timer->adjust(attotime::from_usec(300));
491	491	break;

trunk/src/mess/video/cirrus.c

r18055	r18056
229	229	WRITE8_DEVICE_HANDLER( cirrus_42E8_w )
230	230	{
231	231	if (data & 0x80)
232		pc_vga_reset(device->machine());
	232	pc_vga_reset(space.machine());
233	233	}

trunk/src/mess/video/vic4567.c

r18055	r18056
1281	1281	break;
1282	1282
1283	1283	case 0x19:
1284		vic3_clear_interrupt(device->machine(), data & 0x0f, vic3);
	1284	vic3_clear_interrupt(space.machine(), data & 0x0f, vic3);
1285	1285	break;
1286	1286
1287	1287	case 0x1a:                     /* irq mask */
1288	1288	vic3->reg[offset] = data;
1289		vic3_set_interrupt(device->machine(), 0, vic3);   // beamrider needs this
	1289	vic3_set_interrupt(space.machine(), 0, vic3);   // beamrider needs this
1290	1290	break;
1291	1291
1292	1292	case 0x11:
r18055	r18056
1380	1380	if (vic3->port_changed!=NULL) {
1381	1381	DBG_LOG(2, "vic write", ("%.2x:%.2x\n", offset, data));
1382	1382	vic3->reg[offset] = data;
1383		vic3->port_changed(device->machine(), data);
	1383	vic3->port_changed(space.machine(), data);
1384	1384	}
1385	1385	break;
1386	1386	case 0x31:
r18055	r18056
1460	1460	case 0x1e:                     /* sprite to sprite collision detect */
1461	1461	val = vic3->reg[offset];
1462	1462	vic3->reg[offset] = 0;
1463		vic3_clear_interrupt(device->machine(), 4, vic3);
	1463	vic3_clear_interrupt(space.machine(), 4, vic3);
1464	1464	break;
1465	1465
1466	1466	case 0x1f:                     /* sprite to background collision detect */
1467	1467	val = vic3->reg[offset];
1468	1468	vic3->reg[offset] = 0;
1469		vic3_clear_interrupt(device->machine(), 2, vic3);
	1469	vic3_clear_interrupt(space.machine(), 2, vic3);
1470	1470	break;
1471	1471
1472	1472	case 0x20:

trunk/src/mess/video/vtvideo.c

r18055	r18056
172	172
173	173	WRITE8_DEVICE_HANDLER( vt_video_brightness_w )
174	174	{
175		//palette_set_color_rgb(device->machine(), 1, data, data, data);
	175	//palette_set_color_rgb(space.machine(), 1, data, data, data);
176	176	}
177	177
178	178	static void vt_video_display_char(device_t *device,bitmap_ind16 &bitmap, UINT8 code,

trunk/src/mess/video/vic6567.c

r18055	r18056
2226	2226	WRITE8_DEVICE_HANDLER( vic2_port_w )
2227	2227	{
2228	2228	vic2_state *vic2 = get_safe_token(device);
2229		running_machine &machine = device->machine();
	2229	running_machine &machine = space.machine();
2230	2230
2231	2231	DBG_LOG(2, "vic write", ("%.2x:%.2x\n", offset, data));
2232	2232	offset &= 0x3f;
r18055	r18056
2451	2451	READ8_DEVICE_HANDLER( vic2_port_r )
2452	2452	{
2453	2453	vic2_state *vic2 = get_safe_token(device);
2454		running_machine &machine = device->machine();
	2454	running_machine &machine = space.machine();
2455	2455	int val = 0;
2456	2456
2457	2457	offset &= 0x3f;

trunk/src/mess/drivers/dectalk.c

r18055	r18056
719	719
720	720	static WRITE8_DEVICE_HANDLER( dectalk_kbd_put )
721	721	{
722		duart68681_rx_data(device->machine().device("duart68681"), 1, data);
	722	duart68681_rx_data(space.machine().device("duart68681"), 1, data);
723	723	}
724	724
725	725	static GENERIC_TERMINAL_INTERFACE( dectalk_terminal_intf )

trunk/src/mess/drivers/pc9801.c

r18055	r18056
2207	2207	static READ8_DEVICE_HANDLER( get_slave_ack )
2208	2208	{
2209	2209	if (offset==7) { // IRQ = 7
2210		return   pic8259_acknowledge( device->machine().device( "pic8259_slave" ));
	2210	return   pic8259_acknowledge( space.machine().device( "pic8259_slave" ));
2211	2211	}
2212	2212	return 0x00;
2213	2213	}
r18055	r18056
2348	2348
2349	2349	static WRITE8_DEVICE_HANDLER( ppi_sys_portc_w )
2350	2350	{
2351		beep_set_state(device->machine().device(BEEPER_TAG),!(data & 0x08));
	2351	beep_set_state(space.machine().device(BEEPER_TAG),!(data & 0x08));
2352	2352	}
2353	2353
2354	2354	static I8255A_INTERFACE( ppi_system_intf )
r18055	r18056
2378	2378
2379	2379	static READ8_DEVICE_HANDLER( ppi_fdd_portb_r )
2380	2380	{
2381		return 0xff; //upd765_status_r(device->machine().device("upd765_2dd"),space, 0);
	2381	return 0xff; //upd765_status_r(space.machine().device("upd765_2dd"),space, 0);
2382	2382	}
2383	2383
2384	2384	static READ8_DEVICE_HANDLER( ppi_fdd_portc_r )
2385	2385	{
2386		return 0xff; //upd765_data_r(device->machine().device("upd765_2dd"),space, 0);
	2386	return 0xff; //upd765_data_r(space.machine().device("upd765_2dd"),space, 0);
2387	2387	}
2388	2388
2389	2389	static WRITE8_DEVICE_HANDLER( ppi_fdd_portc_w )
2390	2390	{
2391		//upd765_data_w(device->machine().device("upd765_2dd"),space, 0,data);
	2391	//upd765_data_w(space.machine().device("upd765_2dd"),space, 0,data);
2392	2392	}
2393	2393
2394	2394	static I8255A_INTERFACE( ppi_fdd_intf )

trunk/src/mess/drivers/atari400.c

r18055	r18056
909	909	static WRITE8_DEVICE_HANDLER(a800xl_pia_pb_w)
910	910	{
911	911	if (downcast<pia6821_device *>(device)->port_b_z_mask() != 0xff)
912		a800xl_mmu(device->machine(), data);
	912	a800xl_mmu(space.machine(), data);
913	913	}
914	914
915	915	static WRITE8_DEVICE_HANDLER(xegs_pia_pb_w)
916	916	{
917	917	if (downcast<pia6821_device *>(device)->port_b_z_mask() != 0xff)
918		xegs_mmu(device->machine(), data);
	918	xegs_mmu(space.machine(), data);
919	919	}
920	920
921	921	static const pokey_interface atari_pokey_interface =

trunk/src/mess/drivers/osbexec.c

r18055	r18056
349	349
350	350	static READ8_DEVICE_HANDLER( osbexec_pia0_a_r )
351	351	{
352		osbexec_state *state = device->machine().driver_data<osbexec_state>();
	352	osbexec_state *state = space.machine().driver_data<osbexec_state>();
353	353
354	354	return state->m_pia0_porta;
355	355	}
r18055	r18056
357	357
358	358	static WRITE8_DEVICE_HANDLER( osbexec_pia0_a_w )
359	359	{
360		osbexec_state *state = device->machine().driver_data<osbexec_state>();
	360	osbexec_state *state = space.machine().driver_data<osbexec_state>();
361	361
362	362	logerror("osbexec_pia0_a_w: %02x\n", data );
363	363
364	364	state->m_pia0_porta = data;
365	365
366		state->set_banks(device->machine());
	366	state->set_banks(space.machine());
367	367	}
368	368
369	369
370	370	static READ8_DEVICE_HANDLER( osbexec_pia0_b_r )
371	371	{
372		osbexec_state *state = device->machine().driver_data<osbexec_state>();
	372	osbexec_state *state = space.machine().driver_data<osbexec_state>();
373	373
374	374	return state->m_pia0_portb;
375	375	}
r18055	r18056
377	377
378	378	static WRITE8_DEVICE_HANDLER( osbexec_pia0_b_w )
379	379	{
380		osbexec_state *state = device->machine().driver_data<osbexec_state>();
	380	osbexec_state *state = space.machine().driver_data<osbexec_state>();
381	381
382	382	state->m_pia0_portb = data;
383	383

trunk/src/mess/drivers/mz2000.c

r18055	r18056
290	290
291	291	static READ8_DEVICE_HANDLER( mz2000_wd17xx_r )
292	292	{
293		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	293	mz2000_state *state = space.machine().driver_data<mz2000_state>();
294	294
295	295	if(state->m_has_fdc)
296	296	return wd17xx_r(device, space, offset) ^ 0xff;
r18055	r18056
300	300
301	301	static WRITE8_DEVICE_HANDLER( mz2000_wd17xx_w )
302	302	{
303		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	303	mz2000_state *state = space.machine().driver_data<mz2000_state>();
304	304
305	305	if(state->m_has_fdc)
306	306	wd17xx_w(device, space, offset, data ^ 0xff);
r18055	r18056
573	573
574	574	static READ8_DEVICE_HANDLER( mz2000_portb_r )
575	575	{
576		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	576	mz2000_state *state = space.machine().driver_data<mz2000_state>();
577	577	/*
578	578	x--- ---- break key
579	579	-x-- ---- read tape data
r18055	r18056
593	593	else
594	594	res |= 0x20;
595	595
596		res |= (device->machine().primary_screen->vblank()) ? 0x00 : 0x01;
	596	res |= (space.machine().primary_screen->vblank()) ? 0x00 : 0x01;
597	597
598	598	return res;
599	599	}
r18055	r18056
617	617	---- --x- tape ff
618	618	---- ---x tape rewind
619	619	*/
620		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	620	mz2000_state *state = space.machine().driver_data<mz2000_state>();
621	621
622	622	if((state->m_tape_ctrl & 0x80) == 0 && data & 0x80)
623	623	{
r18055	r18056
673	673
674	674	static WRITE8_DEVICE_HANDLER( mz2000_portc_w )
675	675	{
676		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	676	mz2000_state *state = space.machine().driver_data<mz2000_state>();
677	677	/*
678	678	x--- ---- tape data write
679	679	-x-- ---- tape rec
r18055	r18056
692	692	{
693	693	state->m_ipl_enable = 0;
694	694	/* correct? */
695		device->machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
	695	space.machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
696	696	}
697	697
698		beep_set_state(device->machine().device(BEEPER_TAG),data & 0x04);
	698	beep_set_state(space.machine().device(BEEPER_TAG),data & 0x04);
699	699
700	700	state->m_old_portc = data;
701	701	}
r18055	r18056
712	712
713	713	static WRITE8_DEVICE_HANDLER( mz2000_pio1_porta_w )
714	714	{
715		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	715	mz2000_state *state = space.machine().driver_data<mz2000_state>();
716	716	state->m_tvram_enable = ((data & 0xc0) == 0xc0);
717	717	state->m_gvram_enable = ((data & 0xc0) == 0x80);
718	718	state->m_width80 = ((data & 0x20) >> 5);
r18055	r18056
723	723
724	724	static READ8_DEVICE_HANDLER( mz2000_pio1_portb_r )
725	725	{
726		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	726	mz2000_state *state = space.machine().driver_data<mz2000_state>();
727	727	static const char *const keynames[] = { "KEY0", "KEY1", "KEY2", "KEY3",
728	728	"KEY4", "KEY5", "KEY6", "KEY7",
729	729	"KEY8", "KEY9", "KEYA", "KEYB",
r18055	r18056
735	735
736	736	res = 0xff;
737	737	for(i=0;i<0xe;i++)
738		res &= device->machine().root_device().ioport(keynames[i])->read();
	738	res &= space.machine().root_device().ioport(keynames[i])->read();
739	739
740	740	return res;
741	741	}
742	742
743		return device->machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read();
	743	return space.machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read();
744	744	}
745	745
746	746	static READ8_DEVICE_HANDLER( mz2000_pio1_porta_r )
747	747	{
748		mz2000_state *state = device->machine().driver_data<mz2000_state>();
	748	mz2000_state *state = space.machine().driver_data<mz2000_state>();
749	749
750	750	return state->m_porta_latch;
751	751	}

trunk/src/mess/drivers/mini2440.c

r18055	r18056
113	113
114	114	static WRITE8_DEVICE_HANDLER( s3c2440_nand_command_w )
115	115	{
116		mini2440_state *state = device->machine().driver_data<mini2440_state>();
	116	mini2440_state *state = space.machine().driver_data<mini2440_state>();
117	117	state->m_nand->command_w(data);
118	118	}
119	119
120	120	static WRITE8_DEVICE_HANDLER( s3c2440_nand_address_w )
121	121	{
122		mini2440_state *state = device->machine().driver_data<mini2440_state>();
	122	mini2440_state *state = space.machine().driver_data<mini2440_state>();
123	123	state->m_nand->address_w(data);
124	124	}
125	125
126	126	static READ8_DEVICE_HANDLER( s3c2440_nand_data_r )
127	127	{
128		mini2440_state *state = device->machine().driver_data<mini2440_state>();
	128	mini2440_state *state = space.machine().driver_data<mini2440_state>();
129	129	return state->m_nand->data_r();
130	130	}
131	131
132	132	static WRITE8_DEVICE_HANDLER( s3c2440_nand_data_w )
133	133	{
134		mini2440_state *state = device->machine().driver_data<mini2440_state>();
	134	mini2440_state *state = space.machine().driver_data<mini2440_state>();
135	135	state->m_nand->data_w(data);
136	136	}
137	137
r18055	r18056
139	139
140	140	static WRITE16_DEVICE_HANDLER( s3c2440_i2s_data_w )
141	141	{
142		mini2440_state *state = device->machine().driver_data<mini2440_state>();
	142	mini2440_state *state = space.machine().driver_data<mini2440_state>();
143	143	state->m_dac[offset]->write_signed16(data + 0x8000);
144	144	}
145	145
r18055	r18056
150	150	UINT32 data = 0;
151	151	switch (offset)
152	152	{
153		case 2 + 0 : data = device->machine().root_device().ioport( "PENX")->read(); break;
154		case 2 + 1 : data = 915 - device->machine().root_device().ioport( "PENY")->read() + 90; break;
	153	case 2 + 0 : data = space.machine().root_device().ioport( "PENX")->read(); break;
	154	case 2 + 1 : data = 915 - space.machine().root_device().ioport( "PENY")->read() + 90; break;
155	155	}
156		verboselog( device->machine(), 5,  "s3c2440_adc_data_r %08X\n", data);
	156	verboselog( space.machine(), 5,  "s3c2440_adc_data_r %08X\n", data);
157	157	return data;
158	158	}
159	159

trunk/src/mess/drivers/pc88va.c

r18055	r18056
1398	1398
1399	1399	static READ8_DEVICE_HANDLER( cpu_8255_c_r )
1400	1400	{
1401		pc88va_state *state = device->machine().driver_data<pc88va_state>();
	1401	pc88va_state *state = space.machine().driver_data<pc88va_state>();
1402	1402
1403	1403	return state->m_i8255_1_pc >> 4;
1404	1404	}
1405	1405
1406	1406	static WRITE8_DEVICE_HANDLER( cpu_8255_c_w )
1407	1407	{
1408		pc88va_state *state = device->machine().driver_data<pc88va_state>();
	1408	pc88va_state *state = space.machine().driver_data<pc88va_state>();
1409	1409
1410	1410	state->m_i8255_0_pc = data;
1411	1411	}
r18055	r18056
1422	1422
1423	1423	static READ8_DEVICE_HANDLER( fdc_8255_c_r )
1424	1424	{
1425		pc88va_state *state = device->machine().driver_data<pc88va_state>();
	1425	pc88va_state *state = space.machine().driver_data<pc88va_state>();
1426	1426
1427	1427	return state->m_i8255_0_pc >> 4;
1428	1428	}
1429	1429
1430	1430	static WRITE8_DEVICE_HANDLER( fdc_8255_c_w )
1431	1431	{
1432		pc88va_state *state = device->machine().driver_data<pc88va_state>();
	1432	pc88va_state *state = space.machine().driver_data<pc88va_state>();
1433	1433
1434	1434	state->m_i8255_1_pc = data;
1435	1435	}
r18055	r18056
1448	1448	{
1449	1449	UINT8 sw5, sw4, sw3, sw2,speed_sw;
1450	1450
1451		speed_sw = (device->machine().root_device().ioport("SPEED_SW")->read() & 1) ? 0x20 : 0x00;
1452		sw5 = (device->machine().root_device().ioport("DSW")->read() & 0x10);
1453		sw4 = (device->machine().root_device().ioport("DSW")->read() & 0x08);
1454		sw3 = (device->machine().root_device().ioport("DSW")->read() & 0x04);
1455		sw2 = (device->machine().root_device().ioport("DSW")->read() & 0x02);
	1451	speed_sw = (space.machine().root_device().ioport("SPEED_SW")->read() & 1) ? 0x20 : 0x00;
	1452	sw5 = (space.machine().root_device().ioport("DSW")->read() & 0x10);
	1453	sw4 = (space.machine().root_device().ioport("DSW")->read() & 0x08);
	1454	sw3 = (space.machine().root_device().ioport("DSW")->read() & 0x04);
	1455	sw2 = (space.machine().root_device().ioport("DSW")->read() & 0x02);
1456	1456
1457	1457	return 0xc1 | sw5 | sw4 | sw3 | sw2 | speed_sw;
1458	1458	}
r18055	r18056
1461	1461	{
1462	1462	UINT8 xsw1;
1463	1463
1464		xsw1 = (device->machine().root_device().ioport("DSW")->read() & 1) ? 0 : 8;
	1464	xsw1 = (space.machine().root_device().ioport("DSW")->read() & 1) ? 0 : 8;
1465	1465
1466	1466	return 0xf7 | xsw1;
1467	1467	}
r18055	r18056
1510	1510	static READ8_DEVICE_HANDLER( get_slave_ack )
1511	1511	{
1512	1512	if (offset==7) { // IRQ = 7
1513		return pic8259_acknowledge(device->machine().device( "pic8259_slave"));
	1513	return pic8259_acknowledge(space.machine().device( "pic8259_slave"));
1514	1514	}
1515	1515	return 0x00;
1516	1516	}

trunk/src/mess/drivers/mycom.c

r18055	r18056
420	420
421	421	static WRITE8_DEVICE_HANDLER( mycom_rtc_w )
422	422	{
423		mycom_state *state = device->machine().driver_data<mycom_state>();
	423	mycom_state *state = space.machine().driver_data<mycom_state>();
424	424
425	425	state->m_rtc->address_w(data & 0x0f);
426	426

trunk/src/mess/drivers/spc1000.c

r18055	r18056
100	100
101	101	static WRITE8_DEVICE_HANDLER(spc1000_gmode_w)
102	102	{
103		spc1000_state *state = device->machine().driver_data<spc1000_state>();
	103	spc1000_state *state = space.machine().driver_data<spc1000_state>();
104	104	state->m_GMODE = data;
105	105
106	106	// state->m_GMODE layout: CSS|NA|PS2|PS1|~A/G|GM0|GM1|NA
r18055	r18056
113	113
114	114	static READ8_DEVICE_HANDLER(spc1000_gmode_r)
115	115	{
116		spc1000_state *state = device->machine().driver_data<spc1000_state>();
	116	spc1000_state *state = space.machine().driver_data<spc1000_state>();
117	117	return state->m_GMODE;
118	118	}
119	119
r18055	r18056
244	244
245	245	static READ8_DEVICE_HANDLER( spc1000_mc6847_videoram_r )
246	246	{
247		spc1000_state *state = device->machine().driver_data<spc1000_state>();
	247	spc1000_state *state = space.machine().driver_data<spc1000_state>();
248	248	if (offset == ~0) return 0xff;
249	249
250	250	// state->m_GMODE layout: CSS|NA|PS2|PS1|~A/G|GM0|GM1|NA

trunk/src/mess/drivers/pes.c

r18055	r18056
67	67	/* Devices */
68	68	static WRITE8_DEVICE_HANDLER( pes_kbd_input )
69	69	{
70		pes_state *state = device->machine().driver_data<pes_state>();
	70	pes_state *state = space.machine().driver_data<pes_state>();
71	71	#ifdef DEBUG_FIFO
72	72	fprintf(stderr,"keyboard input: %c, ", data);
73	73	#endif
r18055	r18056
87	87	fprintf(stderr,"kb input fifo fullness: %d\n",(state->m_infifo_head_ptr-state->m_infifo_tail_ptr)&0x1F);
88	88	#endif
89	89	// todo: following two should be set so clear happens after one cpu cycle
90		device->machine().device("maincpu")->execute().set_input_line(MCS51_RX_LINE, ASSERT_LINE);
91		device->machine().device("maincpu")->execute().set_input_line(MCS51_RX_LINE, CLEAR_LINE);
	90	space.machine().device("maincpu")->execute().set_input_line(MCS51_RX_LINE, ASSERT_LINE);
	91	space.machine().device("maincpu")->execute().set_input_line(MCS51_RX_LINE, CLEAR_LINE);
92	92	}
93	93
94	94	static GENERIC_TERMINAL_INTERFACE( pes_terminal_intf )

trunk/src/mess/drivers/palm.c

r18055	r18056
73	73
74	74	static WRITE8_DEVICE_HANDLER( palm_port_f_out )
75	75	{
76		palm_state *state = device->machine().driver_data<palm_state>();
	76	palm_state *state = space.machine().driver_data<palm_state>();
77	77	state->m_port_f_latch = data;
78	78	}
79	79
r18055	r18056
84	84
85	85	static READ8_DEVICE_HANDLER( palm_port_f_in )
86	86	{
87		palm_state *state = device->machine().driver_data<palm_state>();
	87	palm_state *state = space.machine().driver_data<palm_state>();
88	88	return state->m_port_f_latch;
89	89	}
90	90
91	91	static WRITE16_DEVICE_HANDLER( palm_spim_out )
92	92	{
93		palm_state *state = device->machine().driver_data<palm_state>();
	93	palm_state *state = space.machine().driver_data<palm_state>();
94	94	state->m_spim_data = data;
95	95	}
96	96
97	97	static READ16_DEVICE_HANDLER( palm_spim_in )
98	98	{
99		palm_state *state = device->machine().driver_data<palm_state>();
	99	palm_state *state = space.machine().driver_data<palm_state>();
100	100	return state->m_spim_data;
101	101	}
102	102
r18055	r18056
159	159
160	160	static WRITE8_DEVICE_HANDLER( palm_dac_transition )
161	161	{
162		palm_state *state = device->machine().driver_data<palm_state>();
	162	palm_state *state = space.machine().driver_data<palm_state>();
163	163	state->m_dac->write_unsigned8(0x7f * data );
164	164	}
165	165

trunk/src/mess/drivers/xor100.c

r18055	r18056
417	417
418	418	static READ8_DEVICE_HANDLER( i8255_pc_r )
419	419	{
420		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	420	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
421	421	/*
422	422
423	423	bit     description

trunk/src/mess/drivers/a2600.c

r18055	r18056
1177	1177
1178	1178	static WRITE8_DEVICE_HANDLER(switch_A_w)
1179	1179	{
1180		a2600_state *state = device->machine().driver_data<a2600_state>();
1181		running_machine &machine = device->machine();
	1180	a2600_state *state = space.machine().driver_data<a2600_state>();
	1181	running_machine &machine = space.machine();
1182	1182
1183	1183	/* Left controller port */
1184	1184	if ( machine.root_device().ioport("CONTROLLERS")->read() / CATEGORY_SELECT == 0x03 )
r18055	r18056
1201	1201	static READ8_DEVICE_HANDLER( switch_A_r )
1202	1202	{
1203	1203	static const UINT8 driving_lookup[4] = { 0x00, 0x02, 0x03, 0x01 };
1204		running_machine &machine = device->machine();
	1204	running_machine &machine = space.machine();
1205	1205	UINT8 val = 0;
1206	1206
1207	1207	/* Left controller port PINs 1-4 ( 4321 ) */
r18055	r18056
1261	1261
1262	1262	static READ8_DEVICE_HANDLER( riot_input_port_8_r )
1263	1263	{
1264		return device->machine().root_device().ioport("SWB")->read();
	1264	return space.machine().root_device().ioport("SWB")->read();
1265	1265	}
1266	1266
1267	1267	static const riot6532_interface r6532_interface =

trunk/src/mess/drivers/mirage.c

r18055	r18056
165	165	static WRITE8_DEVICE_HANDLER( mirage_via_write_portb )
166	166	{
167	167	int bank = 0;
168		mirage_state *state = device->machine().driver_data<mirage_state>();
	168	mirage_state *state = space.machine().driver_data<mirage_state>();
169	169
170	170	// handle sound RAM bank switching
171	171	bank = (data & 2) ? (64*1024) : 0;

trunk/src/mess/drivers/v1050.c

r18055	r18056
701	701
702	702	static WRITE8_DEVICE_HANDLER( misc_ppi_pb_w )
703	703	{
704		centronics_device *centronics = device->machine().device<centronics_device>(CENTRONICS_TAG);
705		centronics->write( device->machine().driver_data()->generic_space() , 0, ~data & 0xff);
	704	centronics_device *centronics = space.machine().device<centronics_device>(CENTRONICS_TAG);
	705	centronics->write( space.machine().driver_data()->generic_space() , 0, ~data & 0xff);
706	706	}
707	707
708	708	static READ8_DEVICE_HANDLER( misc_ppi_pc_r )
r18055	r18056
723	723	*/
724	724
725	725	UINT8 data = 0;
726		centronics_device *centronics = device->machine().device<centronics_device>(CENTRONICS_TAG);
	726	centronics_device *centronics = space.machine().device<centronics_device>(CENTRONICS_TAG);
727	727	data |= centronics->not_busy_r() << 4;
728	728	data |= centronics->pe_r() << 5;
729	729

trunk/src/mess/drivers/amiga.c

r18055	r18056
76	76
77	77	static READ8_DEVICE_HANDLER( amiga_cia_1_porta_r )
78	78	{
79		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	79	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
80	80	UINT8 result = 0;
81	81
82	82	/* centronics status is stored in PA0 to PA2 */
r18055	r18056
523	523
524	524	static READ8_DEVICE_HANDLER( amiga_cia_0_portA_r )
525	525	{
526		UINT8 ret = device->machine().root_device().ioport("CIA0PORTA")->read() & 0xc0;   /* Gameport 1 and 0 buttons */
527		ret |= device->machine().device<amiga_fdc>("fdc")->ciaapra_r();
	526	UINT8 ret = space.machine().root_device().ioport("CIA0PORTA")->read() & 0xc0;   /* Gameport 1 and 0 buttons */
	527	ret |= space.machine().device<amiga_fdc>("fdc")->ciaapra_r();
528	528	return ret;
529	529	}
530	530
531	531
532	532	static READ8_DEVICE_HANDLER( amiga_cia_0_cdtv_portA_r )
533	533	{
534		return device->machine().root_device().ioport("CIA0PORTA")->read() & 0xc0;   /* Gameport 1 and 0 buttons */
	534	return space.machine().root_device().ioport("CIA0PORTA")->read() & 0xc0;   /* Gameport 1 and 0 buttons */
535	535	}
536	536
537	537
538	538	static WRITE8_DEVICE_HANDLER( amiga_cia_0_portA_w )
539	539	{
540		amiga_state *state = device->machine().driver_data<amiga_state>();
	540	amiga_state *state = space.machine().driver_data<amiga_state>();
541	541	/* switch banks as appropriate */
542	542	state->membank("bank1")->set_entry(data & 1);
543	543
r18055	r18056
550	550	}
551	551
552	552	/* overlay disabled, map RAM on 0x000000 */
553		device->machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x000000, state->m_chip_ram.bytes() - 1, 0, mirror_mask, "bank1");
	553	space.machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x000000, state->m_chip_ram.bytes() - 1, 0, mirror_mask, "bank1");
554	554
555	555	/* if there is a cart region, check for cart overlay */
556		if (device->machine().root_device().memregion("user2")->base() != NULL)
557		amiga_cart_check_overlay(device->machine());
	556	if (space.machine().root_device().memregion("user2")->base() != NULL)
	557	amiga_cart_check_overlay(space.machine());
558	558	}
559	559	else
560	560	/* overlay enabled, map Amiga system ROM on 0x000000 */
561		device->machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x000000, state->m_chip_ram.bytes() - 1);
	561	space.machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x000000, state->m_chip_ram.bytes() - 1);
562	562
563		set_led_status( device->machine(), 0, ( data & 2 ) ? 0 : 1 ); /* bit 2 = Power Led on Amiga */
	563	set_led_status( space.machine(), 0, ( data & 2 ) ? 0 : 1 ); /* bit 2 = Power Led on Amiga */
564	564	output_set_value("power_led", ( data & 2 ) ? 0 : 1);
565	565	}
566	566

trunk/src/mess/drivers/mz2500.c

r18055	r18056
1253	1253
1254	1254	static READ8_DEVICE_HANDLER( mz2500_wd17xx_r )
1255	1255	{
1256		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1256	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1257	1257	return wd17xx_r(device, space, offset) ^ state->m_fdc_reverse;
1258	1258	}
1259	1259
1260	1260	static WRITE8_DEVICE_HANDLER( mz2500_wd17xx_w )
1261	1261	{
1262		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1262	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1263	1263	wd17xx_w(device, space, offset, data ^ state->m_fdc_reverse);
1264	1264	}
1265	1265
r18055	r18056
1841	1841	{
1842	1842	UINT8 vblank_bit;
1843	1843
1844		vblank_bit = device->machine().primary_screen->vblank() ? 0 : 1; //Guess: NOBO wants this bit to be high/low
	1844	vblank_bit = space.machine().primary_screen->vblank() ? 0 : 1; //Guess: NOBO wants this bit to be high/low
1845	1845
1846	1846	return 0xfe | vblank_bit;
1847	1847	}
r18055	r18056
1865	1865
1866	1866	static WRITE8_DEVICE_HANDLER( mz2500_portc_w )
1867	1867	{
1868		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1868	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1869	1869	/*
1870	1870	---- x--- 0->1 transition = IPL reset
1871	1871	---- -x-- beeper state
r18055	r18056
1877	1877	{
1878	1878	mz2500_reset(state, WRAM_RESET);
1879	1879	/* correct? */
1880		device->machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
	1880	space.machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
1881	1881	}
1882	1882
1883	1883	/* bit 2 is speaker */
r18055	r18056
1888	1888
1889	1889	state->m_old_portc = data;
1890	1890
1891		beep_set_state(device->machine().device(BEEPER_TAG),data & 0x04);
	1891	beep_set_state(space.machine().device(BEEPER_TAG),data & 0x04);
1892	1892
1893	1893	if(data & ~0x0e)
1894	1894	logerror("PPI PORTC W %02x\n",data & ~0x0e);
r18055	r18056
1906	1906
1907	1907	static WRITE8_DEVICE_HANDLER( mz2500_pio1_porta_w )
1908	1908	{
1909		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1909	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1910	1910	//  printf("%02x\n",data);
1911	1911
1912	1912	if(state->m_prev_col_val != ((data & 0x20) >> 5))
1913	1913	{
1914	1914	state->m_text_col_size = ((data & 0x20) >> 5);
1915	1915	state->m_prev_col_val = state->m_text_col_size;
1916		mz2500_reconfigure_screen(device->machine());
	1916	mz2500_reconfigure_screen(space.machine());
1917	1917	}
1918	1918	state->m_key_mux = data & 0x1f;
1919	1919	}
r18055	r18056
1921	1921
1922	1922	static READ8_DEVICE_HANDLER( mz2500_pio1_porta_r )
1923	1923	{
1924		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1924	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1925	1925	static const char *const keynames[] = { "KEY0", "KEY1", "KEY2", "KEY3",
1926	1926	"KEY4", "KEY5", "KEY6", "KEY7",
1927	1927	"KEY8", "KEY9", "KEYA", "KEYB",
r18055	r18056
1933	1933
1934	1934	res = 0xff;
1935	1935	for(i=0;i<0xe;i++)
1936		res &= device->machine().root_device().ioport(keynames[i])->read();
	1936	res &= space.machine().root_device().ioport(keynames[i])->read();
1937	1937
1938	1938	state->m_pio_latchb = res;
1939	1939
1940	1940	return res;
1941	1941	}
1942	1942
1943		state->m_pio_latchb = device->machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read();
	1943	state->m_pio_latchb = space.machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read();
1944	1944
1945		return device->machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read();
	1945	return space.machine().root_device().ioport(keynames[state->m_key_mux & 0xf])->read();
1946	1946	}
1947	1947
1948	1948	#if 0
1949	1949	static READ8_DEVICE_HANDLER( mz2500_pio1_portb_r )
1950	1950	{
1951		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1951	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1952	1952	return state->m_pio_latchb;
1953	1953	}
1954	1954	#endif
r18055	r18056
1967	1967
1968	1968	static READ8_DEVICE_HANDLER( opn_porta_r )
1969	1969	{
1970		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1970	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1971	1971	return state->m_ym_porta;
1972	1972	}
1973	1973
1974	1974	static WRITE8_DEVICE_HANDLER( opn_porta_w )
1975	1975	{
1976		mz2500_state *state = device->machine().driver_data<mz2500_state>();
	1976	mz2500_state *state = space.machine().driver_data<mz2500_state>();
1977	1977	/*
1978	1978	---- x--- mouse select
1979	1979	---- -x-- palette bit (16/4096 colors)

trunk/src/mess/drivers/fmtowns.c

r18055	r18056
2555	2555
2556	2556	static READ8_DEVICE_HANDLER( get_slave_ack )
2557	2557	{
2558		towns_state* state = device->machine().driver_data<towns_state>();
	2558	towns_state* state = space.machine().driver_data<towns_state>();
2559	2559	if (offset==7) { // IRQ = 7
2560	2560	return pic8259_acknowledge(state->m_pic_slave);
2561	2561	}

trunk/src/mess/drivers/einstein.c

r18055	r18056
240	240
241	241	static WRITE8_DEVICE_HANDLER( einstein_drsel_w )
242	242	{
243		einstein_state *einstein = device->machine().driver_data<einstein_state>();
	243	einstein_state *einstein = space.machine().driver_data<einstein_state>();
244	244	if(VERBOSE_DISK)
245		logerror("%s: einstein_drsel_w %02x\n", device->machine().describe_context(), data);
	245	logerror("%s: einstein_drsel_w %02x\n", space.machine().describe_context(), data);
246	246
247	247	/* bit 0 to 3 select the drive */
248	248	static const char *names[] = { "fd0", "fd1", "fd2", "fd3" };
249	249	floppy_image_device *floppy = 0;
250	250	for(int i=0; i<4; i++) {
251	251	if(BIT(data, i)) {
252		floppy_connector *con = device->machine().device<floppy_connector>(names[i]);
	252	floppy_connector *con = space.machine().device<floppy_connector>(names[i]);
253	253	if(con)
254	254	floppy = con->get_device();
255	255	}
256	256	}
257	257
258	258	/* double sided drive connected? */
259		if (device->machine().root_device().ioport("config")->read() & data)
	259	if (space.machine().root_device().ioport("config")->read() & data)
260	260	{
261	261	/* bit 4 selects the side then */
262	262	//floppy->ss_w(BIT(data, 4));

trunk/src/mess/drivers/vtech1.c

r18055	r18056
482	482
483	483	static READ8_DEVICE_HANDLER( vtech1_printer_r )
484	484	{
485		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	485	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
486	486	return 0xfe | centronics->busy_r();
487	487	}
488	488
489	489	/* TODO: figure out how this really works */
490	490	static WRITE8_DEVICE_HANDLER( vtech1_strobe_w )
491	491	{
492		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	492	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
493	493	centronics->strobe_w(TRUE);
494	494	centronics->strobe_w(FALSE);
495	495	}
r18055	r18056
613	613
614	614	static READ8_DEVICE_HANDLER( vtech1_mc6847_videoram_r )
615	615	{
616		vtech1_state *vtech1 = device->machine().driver_data<vtech1_state>();
	616	vtech1_state *vtech1 = space.machine().driver_data<vtech1_state>();
617	617	if (offset == ~0) return 0xff;
618	618	vtech1->m_mc6847->inv_w(BIT(vtech1->m_videoram[offset], 6));
619	619	vtech1->m_mc6847->as_w(BIT(vtech1->m_videoram[offset], 7));

trunk/src/mess/drivers/ssystem3.c

r18055	r18056
119	119
120	120	static WRITE8_DEVICE_HANDLER(ssystem3_via_write_a)
121	121	{
122		ssystem3_state *state = device->machine().driver_data<ssystem3_state>();
	122	ssystem3_state *state = space.machine().driver_data<ssystem3_state>();
123	123	state->m_porta=data;
124	124	//  logerror("%.4x via port a write %02x\n",(int)activecpu_get_pc(), data);
125	125	}
126	126
127	127	static READ8_DEVICE_HANDLER(ssystem3_via_read_a)
128	128	{
129		ssystem3_state *state = device->machine().driver_data<ssystem3_state>();
	129	ssystem3_state *state = space.machine().driver_data<ssystem3_state>();
130	130	UINT8 data=0xff;
131	131	#if 1 // time switch
132		if (!(state->m_porta&0x10)) data&=device->machine().root_device().ioport("matrix1")->read()|0xf1;
133		if (!(state->m_porta&0x20)) data&=device->machine().root_device().ioport("matrix2")->read()|0xf1;
134		if (!(state->m_porta&0x40)) data&=device->machine().root_device().ioport("matrix3")->read()|0xf1;
135		if (!(state->m_porta&0x80)) data&=device->machine().root_device().ioport("matrix4")->read()|0xf1;
	132	if (!(state->m_porta&0x10)) data&=space.machine().root_device().ioport("matrix1")->read()|0xf1;
	133	if (!(state->m_porta&0x20)) data&=space.machine().root_device().ioport("matrix2")->read()|0xf1;
	134	if (!(state->m_porta&0x40)) data&=space.machine().root_device().ioport("matrix3")->read()|0xf1;
	135	if (!(state->m_porta&0x80)) data&=space.machine().root_device().ioport("matrix4")->read()|0xf1;
136	136	#else
137		if (!(state->m_porta&0x10)) data&=device->machine().root_device().ioport("matrix1")->read()|0xf0;
138		if (!(state->m_porta&0x20)) data&=device->machine().root_device().ioport("matrix2")->read()|0xf0;
139		if (!(state->m_porta&0x40)) data&=device->machine().root_device().ioport("matrix3")->read()|0xf0;
140		if (!(state->m_porta&0x80)) data&=device->machine().root_device().ioport("matrix4")->read()|0xf0;
	137	if (!(state->m_porta&0x10)) data&=space.machine().root_device().ioport("matrix1")->read()|0xf0;
	138	if (!(state->m_porta&0x20)) data&=space.machine().root_device().ioport("matrix2")->read()|0xf0;
	139	if (!(state->m_porta&0x40)) data&=space.machine().root_device().ioport("matrix3")->read()|0xf0;
	140	if (!(state->m_porta&0x80)) data&=space.machine().root_device().ioport("matrix4")->read()|0xf0;
141	141	#endif
142	142	if (!(state->m_porta&1)) {
143		if (!(device->machine().root_device().ioport("matrix1")->read()&1)) data&=~0x10;
144		if (!(device->machine().root_device().ioport("matrix2")->read()&1)) data&=~0x20;
145		if (!(device->machine().root_device().ioport("matrix3")->read()&1)) data&=~0x40;
	143	if (!(space.machine().root_device().ioport("matrix1")->read()&1)) data&=~0x10;
	144	if (!(space.machine().root_device().ioport("matrix2")->read()&1)) data&=~0x20;
	145	if (!(space.machine().root_device().ioport("matrix3")->read()&1)) data&=~0x40;
146	146	if (!(state->ioport("matrix4")->read()&1)) data&=~0x80;
147	147	}
148	148	if (!(state->m_porta&2)) {
149		if (!(device->machine().root_device().ioport("matrix1")->read()&2)) data&=~0x10;
150		if (!(device->machine().root_device().ioport("matrix2")->read()&2)) data&=~0x20;
151		if (!(device->machine().root_device().ioport("matrix3")->read()&2)) data&=~0x40;
152		if (!(device->machine().root_device().ioport("matrix4")->read()&2)) data&=~0x80;
	149	if (!(space.machine().root_device().ioport("matrix1")->read()&2)) data&=~0x10;
	150	if (!(space.machine().root_device().ioport("matrix2")->read()&2)) data&=~0x20;
	151	if (!(space.machine().root_device().ioport("matrix3")->read()&2)) data&=~0x40;
	152	if (!(space.machine().root_device().ioport("matrix4")->read()&2)) data&=~0x80;
153	153	}
154	154	if (!(state->m_porta&4)) {
155		if (!(device->machine().root_device().ioport("matrix1")->read()&4)) data&=~0x10;
156		if (!(device->machine().root_device().ioport("matrix2")->read()&4)) data&=~0x20;
157		if (!(device->machine().root_device().ioport("matrix3")->read()&4)) data&=~0x40;
158		if (!(device->machine().root_device().ioport("matrix4")->read()&4)) data&=~0x80;
	155	if (!(space.machine().root_device().ioport("matrix1")->read()&4)) data&=~0x10;
	156	if (!(space.machine().root_device().ioport("matrix2")->read()&4)) data&=~0x20;
	157	if (!(space.machine().root_device().ioport("matrix3")->read()&4)) data&=~0x40;
	158	if (!(space.machine().root_device().ioport("matrix4")->read()&4)) data&=~0x80;
159	159	}
160	160	if (!(state->m_porta&8)) {
161		if (!(device->machine().root_device().ioport("matrix1")->read()&8)) data&=~0x10;
162		if (!(device->machine().root_device().ioport("matrix2")->read()&8)) data&=~0x20;
163		if (!(device->machine().root_device().ioport("matrix3")->read()&8)) data&=~0x40;
164		if (!(device->machine().root_device().ioport("matrix4")->read()&8)) data&=~0x80;
	161	if (!(space.machine().root_device().ioport("matrix1")->read()&8)) data&=~0x10;
	162	if (!(space.machine().root_device().ioport("matrix2")->read()&8)) data&=~0x20;
	163	if (!(space.machine().root_device().ioport("matrix3")->read()&8)) data&=~0x40;
	164	if (!(space.machine().root_device().ioport("matrix4")->read()&8)) data&=~0x80;
165	165	}
166	166	//  logerror("%.4x via port a read %02x\n",(int)activecpu_get_pc(), data);
167	167	return data;
r18055	r18056
193	193	{
194	194	UINT8 data=0xff;
195	195	int on, ready;
196		ssystem3_playfield_read(device->machine(), &on, &ready);
	196	ssystem3_playfield_read(space.machine(), &on, &ready);
197	197	if (!on) data&=~0x20;
198	198	if (!ready) data&=~0x10;
199	199	return data;
r18055	r18056
201	201
202	202	static WRITE8_DEVICE_HANDLER(ssystem3_via_write_b)
203	203	{
204		via6522_device *via_0 = device->machine().device<via6522_device>("via6522_0");
	204	via6522_device *via_0 = space.machine().device<via6522_device>("via6522_0");
205	205	UINT8 d;
206	206
207		ssystem3_playfield_write(device->machine(), data&1, data&8);
208		ssystem3_lcd_write(device->machine(), data&4, data&2);
	207	ssystem3_playfield_write(space.machine(), data&1, data&8);
	208	ssystem3_lcd_write(space.machine(), data&4, data&2);
209	209
210	210	d=ssystem3_via_read_b(via_0, space, 0, mem_mask)&~0x40;
211	211	if (data&0x80) d|=0x40;

trunk/src/mess/drivers/bml3.c

r18055	r18056
330	330
331	331	static READ8_DEVICE_HANDLER( bml3_ym2203_r )
332	332	{
333		bml3_state *state = device->machine().driver_data<bml3_state>();
	333	bml3_state *state = space.machine().driver_data<bml3_state>();
334	334	UINT8 dev_offs = ((state->m_psg_latch & 3) != 3);
335	335
336	336	return ym2203_r(device,space, dev_offs);
r18055	r18056
338	338
339	339	static WRITE8_DEVICE_HANDLER( bml3_ym2203_w )
340	340	{
341		bml3_state *state = device->machine().driver_data<bml3_state>();
	341	bml3_state *state = space.machine().driver_data<bml3_state>();
342	342	UINT8 dev_offs = ((state->m_psg_latch & 3) != 3);
343	343
344	344	ym2203_w(device,space, dev_offs,data);

trunk/src/mess/drivers/samcoupe.c

r18055	r18056
267	267
268	268	static READ8_DEVICE_HANDLER( samcoupe_lpt1_busy_r )
269	269	{
270		centronics_device *centronics = device->machine().device<centronics_device>("lpt1");
	270	centronics_device *centronics = space.machine().device<centronics_device>("lpt1");
271	271	return centronics->busy_r();
272	272	}
273	273
274	274	static WRITE8_DEVICE_HANDLER( samcoupe_lpt1_strobe_w )
275	275	{
276		centronics_device *centronics = device->machine().device<centronics_device>("lpt1");
	276	centronics_device *centronics = space.machine().device<centronics_device>("lpt1");
277	277	centronics->strobe_w(data);
278	278	}
279	279
280	280	static READ8_DEVICE_HANDLER( samcoupe_lpt2_busy_r )
281	281	{
282		centronics_device *centronics = device->machine().device<centronics_device>("lpt2");
	282	centronics_device *centronics = space.machine().device<centronics_device>("lpt2");
283	283	return centronics->busy_r();
284	284	}
285	285
286	286	static WRITE8_DEVICE_HANDLER( samcoupe_lpt2_strobe_w )
287	287	{
288		centronics_device *centronics = device->machine().device<centronics_device>("lpt2");
	288	centronics_device *centronics = space.machine().device<centronics_device>("lpt2");
289	289	centronics->strobe_w(data);
290	290	}
291	291

trunk/src/mess/drivers/digel804.c

r18055	r18056
560	560	******************************************************************************/
561	561	static WRITE8_DEVICE_HANDLER( digel804_serial_put )
562	562	{
563		digel804_state *state = device->machine().driver_data<digel804_state>();
	563	digel804_state *state = space.machine().driver_data<digel804_state>();
564	564	state->m_acia->receive_character(data);
565	565	}
566	566

trunk/src/mess/drivers/nanos.c

r18055	r18056
308	308
309	309	static READ8_DEVICE_HANDLER (nanos_port_a_r)
310	310	{
311		nanos_state *state = device->machine().driver_data<nanos_state>();
	311	nanos_state *state = space.machine().driver_data<nanos_state>();
312	312	UINT8 retVal;
313	313	if (state->m_key_command==0)  {
314	314	return state->m_key_pressed;
r18055	r18056
327	327
328	328	static WRITE8_DEVICE_HANDLER (nanos_port_b_w)
329	329	{
330		nanos_state *state = device->machine().driver_data<nanos_state>();
	330	nanos_state *state = space.machine().driver_data<nanos_state>();
331	331	state->m_key_command = BIT(data,1);
332	332	if (BIT(data,7)) {
333	333	state->membank("bank1")->set_base(state->memregion("maincpu")->base());
334	334	} else {
335		state->membank("bank1")->set_base(device->machine().device<ram_device>(RAM_TAG)->pointer());
	335	state->membank("bank1")->set_base(space.machine().device<ram_device>(RAM_TAG)->pointer());
336	336	}
337	337	}
338	338

trunk/src/mess/drivers/fm7.c

r18055	r18056
943	943
944	944	static READ8_DEVICE_HANDLER( fm77av_joy_1_r )
945	945	{
946		return device->machine().root_device().ioport("joy1")->read();
	946	return space.machine().root_device().ioport("joy1")->read();
947	947	}
948	948
949	949	static READ8_DEVICE_HANDLER( fm77av_joy_2_r )
950	950	{
951		return device->machine().root_device().ioport("joy2")->read();
	951	return space.machine().root_device().ioport("joy2")->read();
952	952	}
953	953
954	954	READ8_MEMBER(fm7_state::fm7_unknown_r)

trunk/src/mess/drivers/jr100.c

r18055	r18056
229	229
230	230	static READ8_DEVICE_HANDLER(jr100_via_read_b)
231	231	{
232		jr100_state *state = device->machine().driver_data<jr100_state>();
	232	jr100_state *state = space.machine().driver_data<jr100_state>();
233	233	UINT8 val = 0x1f;
234	234	if (keynames[state->m_keyboard_line]) {
235	235	val = state->ioport(keynames[state->m_keyboard_line])->read();
r18055	r18056
239	239
240	240	static WRITE8_DEVICE_HANDLER(jr100_via_write_a )
241	241	{
242		jr100_state *state = device->machine().driver_data<jr100_state>();
	242	jr100_state *state = space.machine().driver_data<jr100_state>();
243	243	state->m_keyboard_line = data & 0x0f;
244	244	}
245	245
246	246	static WRITE8_DEVICE_HANDLER(jr100_via_write_b )
247	247	{
248		jr100_state *state = device->machine().driver_data<jr100_state>();
	248	jr100_state *state = space.machine().driver_data<jr100_state>();
249	249	state->m_use_pcg = (data & 0x20) ? TRUE : FALSE;
250	250	state->m_speaker = data>>7;
251	251	}

trunk/src/mess/drivers/ami1200.c

r18055	r18056
85	85
86	86	static WRITE8_DEVICE_HANDLER( ami1200_cia_0_porta_w )
87	87	{
88		ami1200_state *state = device->machine().driver_data<ami1200_state>();
	88	ami1200_state *state = space.machine().driver_data<ami1200_state>();
89	89
90	90	/* bit 2 = Power Led on Amiga */
91		set_led_status(device->machine(), 0, !BIT(data, 1));
	91	set_led_status(space.machine(), 0, !BIT(data, 1));
92	92
93	93	handle_cd32_joystick_cia(state, data, mos6526_r(device, space, 2));
94	94	}
r18055	r18056
111	111	static READ8_DEVICE_HANDLER( ami1200_cia_0_portb_r )
112	112	{
113	113	/* parallel port */
114		logerror("%s:CIA0_portb_r\n", device->machine().describe_context());
	114	logerror("%s:CIA0_portb_r\n", space.machine().describe_context());
115	115	return 0xff;
116	116	}
117	117
118	118	static WRITE8_DEVICE_HANDLER( ami1200_cia_0_portb_w )
119	119	{
120	120	/* parallel port */
121		logerror("%s:CIA0_portb_w(%02x)\n", device->machine().describe_context(), data);
	121	logerror("%s:CIA0_portb_w(%02x)\n", space.machine().describe_context(), data);
122	122	}
123	123
124	124	static ADDRESS_MAP_START( a1200_map, AS_PROGRAM, 32, ami1200_state )
r18055	r18056
246	246
247	247	static READ8_DEVICE_HANDLER( a1200_cia_0_portA_r )
248	248	{
249		UINT8 ret = device->machine().root_device().ioport("CIA0PORTA")->read() & 0xc0;   /* Gameport 1 and 0 buttons */
250		ret |= device->machine().device<amiga_fdc>("fdc")->ciaapra_r();
	249	UINT8 ret = space.machine().root_device().ioport("CIA0PORTA")->read() & 0xc0;   /* Gameport 1 and 0 buttons */
	250	ret |= space.machine().device<amiga_fdc>("fdc")->ciaapra_r();
251	251	return ret;
252	252	}
253	253

trunk/src/mess/drivers/apple2gs.c

r18055	r18056
186	186	{
187	187	if (data)
188	188	{
189		apple2gs_add_irq(device->machine(), IRQ_SLOT);
	189	apple2gs_add_irq(space.machine(), IRQ_SLOT);
190	190	}
191	191	else
192	192	{
193		apple2gs_remove_irq(device->machine(), IRQ_SLOT);
	193	apple2gs_remove_irq(space.machine(), IRQ_SLOT);
194	194	}
195	195	}
196	196
197	197	static WRITE8_DEVICE_HANDLER(a2bus_nmi_w)
198	198	{
199		apple2gs_state *a2 = device->machine().driver_data<apple2gs_state>();
	199	apple2gs_state *a2 = space.machine().driver_data<apple2gs_state>();
200	200
201	201	a2->m_maincpu->set_input_line(INPUT_LINE_NMI, data);
202	202	}
203	203
204	204	static WRITE8_DEVICE_HANDLER(a2bus_inh_w)
205	205	{
206		apple2_state *a2 = device->machine().driver_data<apple2_state>();
	206	apple2_state *a2 = space.machine().driver_data<apple2_state>();
207	207
208	208	a2->m_inh_slot = data;
209		apple2_update_memory(device->machine());
	209	apple2_update_memory(space.machine());
210	210	}
211	211
212	212	static const struct a2bus_interface a2bus_intf =

trunk/src/mess/drivers/palmz22.c

r18055	r18056
112	112
113	113	static WRITE8_DEVICE_HANDLER( s3c2410_nand_command_w )
114	114	{
115		palmz22_state *state = device->machine().driver_data<palmz22_state>();
116		verboselog( device->machine(), 9, "s3c2410_nand_command_w %02X\n", data);
	115	palmz22_state *state = space.machine().driver_data<palmz22_state>();
	116	verboselog( space.machine(), 9, "s3c2410_nand_command_w %02X\n", data);
117	117	state->m_nand->command_w(data);
118	118	}
119	119
120	120	static WRITE8_DEVICE_HANDLER( s3c2410_nand_address_w )
121	121	{
122		palmz22_state *state = device->machine().driver_data<palmz22_state>();
123		verboselog( device->machine(), 9, "s3c2410_nand_address_w %02X\n", data);
	122	palmz22_state *state = space.machine().driver_data<palmz22_state>();
	123	verboselog( space.machine(), 9, "s3c2410_nand_address_w %02X\n", data);
124	124	state->m_nand->address_w(data);
125	125	}
126	126
127	127	static READ8_DEVICE_HANDLER( s3c2410_nand_data_r )
128	128	{
129		palmz22_state *state = device->machine().driver_data<palmz22_state>();
	129	palmz22_state *state = space.machine().driver_data<palmz22_state>();
130	130	UINT8 data = state->m_nand->data_r();
131		verboselog( device->machine(), 9, "s3c2410_nand_data_r %02X\n", data);
	131	verboselog( space.machine(), 9, "s3c2410_nand_data_r %02X\n", data);
132	132	return data;
133	133	}
134	134
135	135	static WRITE8_DEVICE_HANDLER( s3c2410_nand_data_w )
136	136	{
137		palmz22_state *state = device->machine().driver_data<palmz22_state>();
138		verboselog( device->machine(), 9, "s3c2410_nand_data_w %02X\n", data);
	137	palmz22_state *state = space.machine().driver_data<palmz22_state>();
	138	verboselog( space.machine(), 9, "s3c2410_nand_data_w %02X\n", data);
139	139	state->m_nand->data_w(data);
140	140	}
141	141
r18055	r18056
217	217	{
218	218	case 0 + 0 : data = 0x2EE + (PALM_Z22_BATTERY_LEVEL * 0xFF / 100); break;
219	219	case 0 + 1 : data = 0; break;
220		case 2 + 0 : data = device->machine().root_device().ioport( "PENX")->read(); break;
221		case 2 + 1 : data = 0x3FF - device->machine().root_device().ioport( "PENY")->read(); break;
	220	case 2 + 0 : data = space.machine().root_device().ioport( "PENX")->read(); break;
	221	case 2 + 1 : data = 0x3FF - space.machine().root_device().ioport( "PENY")->read(); break;
222	222	}
223		verboselog( device->machine(), 5,  "s3c2410_adc_data_r %08X\n", data);
	223	verboselog( space.machine(), 5,  "s3c2410_adc_data_r %08X\n", data);
224	224	return data;
225	225	}
226	226

trunk/src/mess/drivers/p8k.c

r18055	r18056
513	513
514	514	static READ16_DEVICE_HANDLER( p8k_16_ctc_r )
515	515	{
516		return (UINT16)downcast<z80ctc_device *>(device)->read(device->machine().driver_data()->generic_space(),(offset & 0x06) >> 1);
	516	return (UINT16)downcast<z80ctc_device *>(device)->read(space.machine().driver_data()->generic_space(),(offset & 0x06) >> 1);
517	517	}
518	518
519	519	static WRITE16_DEVICE_HANDLER( p8k_16_ctc_w )
520	520	{
521		downcast<z80ctc_device *>(device)->write(device->machine().driver_data()->generic_space(), (offset & 0x06) >> 1, (UINT8)(data & 0xff));
	521	downcast<z80ctc_device *>(device)->write(space.machine().driver_data()->generic_space(), (offset & 0x06) >> 1, (UINT8)(data & 0xff));
522	522	}
523	523
524	524	READ16_MEMBER( p8k_state::portff82_r )

trunk/src/mess/drivers/pk8000.c

r18055	r18056
102	102	}
103	103	static WRITE8_DEVICE_HANDLER(pk8000_80_porta_w)
104	104	{
105		pk8000_set_bank(device->machine(),data);
	105	pk8000_set_bank(space.machine(),data);
106	106	}
107	107
108	108	static READ8_DEVICE_HANDLER(pk8000_80_portb_r)
109	109	{
110		pk8000_state *state = device->machine().driver_data<pk8000_state>();
	110	pk8000_state *state = space.machine().driver_data<pk8000_state>();
111	111	static const char *const keynames[] = { "LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" };
112	112	if(state->m_keyboard_line>9) {
113	113	return 0xff;
114	114	}
115		return device->machine().root_device().ioport(keynames[state->m_keyboard_line])->read();
	115	return space.machine().root_device().ioport(keynames[state->m_keyboard_line])->read();
116	116	}
117	117
118	118	static WRITE8_DEVICE_HANDLER(pk8000_80_portc_w)
119	119	{
120		pk8000_state *state = device->machine().driver_data<pk8000_state>();
	120	pk8000_state *state = space.machine().driver_data<pk8000_state>();
121	121	state->m_keyboard_line = data & 0x0f;
122	122
123		speaker_level_w(device->machine().device(SPEAKER_TAG), BIT(data,7));
	123	speaker_level_w(space.machine().device(SPEAKER_TAG), BIT(data,7));
124	124
125		cassette_device_image(device->machine())->change_state(
	125	cassette_device_image(space.machine())->change_state(
126	126	(BIT(data,4)) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED,
127	127	CASSETTE_MASK_MOTOR);
128		cassette_device_image(device->machine())->output((BIT(data,6)) ? +1.0 : 0.0);
	128	cassette_device_image(space.machine())->output((BIT(data,6)) ? +1.0 : 0.0);
129	129	}
130	130
131	131	static I8255_INTERFACE( pk8000_ppi8255_interface_1 )

trunk/src/mess/drivers/sgi_ip2.c

r18055	r18056
359	359
360	360	static WRITE8_DEVICE_HANDLER( sgi_kbd_put )
361	361	{
362		duart68681_rx_data(device->machine().device("duart68681a"), 1, data);
	362	duart68681_rx_data(space.machine().device("duart68681a"), 1, data);
363	363	}
364	364
365	365	static GENERIC_TERMINAL_INTERFACE( sgi_terminal_intf )

trunk/src/mess/drivers/apollo.c

r18055	r18056
1158	1158	static WRITE8_DEVICE_HANDLER( apollo_kbd_putchar ) {
1159	1159	// put keyboard character to the keyboard sio
1160	1160	//  DLOG1(("apollo_kbd_putchar: 0x%02x", data));
1161		apollo_sio_rx_data(device->machine().device(APOLLO_SIO_TAG), 0, data);
	1161	apollo_sio_rx_data(space.machine().device(APOLLO_SIO_TAG), 0, data);
1162	1162	}
1163	1163
1164	1164	static READ8_DEVICE_HANDLER( apollo_kbd_has_beeper ) {
r18055	r18056
1181	1181	// FIXME: as of mess0145u1, terminal.c will append a null character after each input character
1182	1182	if (data != 0)
1183	1183	{
1184		apollo_sio_rx_data(device->machine().device(APOLLO_SIO_TAG), 1, data);
	1184	apollo_sio_rx_data(space.machine().device(APOLLO_SIO_TAG), 1, data);
1185	1185	}
1186	1186	}
1187	1187

trunk/src/mess/drivers/apexc.c

r18055	r18056
283	283	if (image->exists())
284	284	image->fwrite(& data5, 1);
285	285
286		apexc_teletyper_putchar(device->machine(), data & 0x1f);   /* display on screen */
	286	apexc_teletyper_putchar(space.machine(), data & 0x1f);   /* display on screen */
287	287	}
288	288
289	289	/*

trunk/src/mess/drivers/x68k.c

r18055	r18056
868	868	// Judging from the XM6 source code, PPI ports A and B are joystick inputs
869	869	static READ8_DEVICE_HANDLER( ppi_port_a_r )
870	870	{
871		x68k_state *state = device->machine().driver_data<x68k_state>();
872		int ctrl = device->machine().root_device().ioport("ctrltype")->read() & 0x0f;
	871	x68k_state *state = space.machine().driver_data<x68k_state>();
	872	int ctrl = space.machine().root_device().ioport("ctrltype")->read() & 0x0f;
873	873
874	874	switch(ctrl)
875	875	{
r18055	r18056
891	891
892	892	static READ8_DEVICE_HANDLER( ppi_port_b_r )
893	893	{
894		x68k_state *state = device->machine().driver_data<x68k_state>();
895		int ctrl = device->machine().root_device().ioport("ctrltype")->read() & 0xf0;
	894	x68k_state *state = space.machine().driver_data<x68k_state>();
	895	int ctrl = space.machine().root_device().ioport("ctrltype")->read() & 0xf0;
896	896
897	897	switch(ctrl)
898	898	{
r18055	r18056
914	914
915	915	static READ8_DEVICE_HANDLER( ppi_port_c_r )
916	916	{
917		x68k_state *state = device->machine().driver_data<x68k_state>();
	917	x68k_state *state = space.machine().driver_data<x68k_state>();
918	918	return state->m_ppi_port[2];
919	919	}
920	920
r18055	r18056
928	928	*/
929	929	static WRITE8_DEVICE_HANDLER( ppi_port_c_w )
930	930	{
931		x68k_state *state = device->machine().driver_data<x68k_state>();
	931	x68k_state *state = space.machine().driver_data<x68k_state>();
932	932	// ADPCM / Joystick control
933		device_t *oki = device->machine().device("okim6258");
	933	device_t *oki = space.machine().device("okim6258");
934	934
935	935	state->m_ppi_port[2] = data;
936	936	if((data & 0x0f) != (state->m_ppi_prev & 0x0f))
937	937	{
938	938	state->m_adpcm.pan = data & 0x03;
939	939	state->m_adpcm.rate = data & 0x0c;
940		x68k_set_adpcm(device->machine());
	940	x68k_set_adpcm(space.machine());
941	941	okim6258_set_divider(oki, (data >> 2) & 3);
942	942	}
943	943
r18055	r18056
947	947	if((state->m_ppi_prev & 0x10) == 0x00 && (data & 0x10) == 0x10)
948	948	{
949	949	state->m_mdctrl.seq1++;
950		state->m_mdctrl.io_timeout1->adjust(device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(8192));
	950	state->m_mdctrl.io_timeout1->adjust(space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(8192));
951	951	}
952	952
953	953	state->m_joy.joy2_enable = data & 0x20;
r18055	r18056
955	955	if((state->m_ppi_prev & 0x20) == 0x00 && (data & 0x20) == 0x20)
956	956	{
957	957	state->m_mdctrl.seq2++;
958		state->m_mdctrl.io_timeout2->adjust(device->machine().device<cpu_device>("maincpu")->cycles_to_attotime(8192));
	958	state->m_mdctrl.io_timeout2->adjust(space.machine().device<cpu_device>("maincpu")->cycles_to_attotime(8192));
959	959	}
960	960	state->m_ppi_prev = data;
961	961
r18055	r18056
1141	1141
1142	1142	static WRITE8_DEVICE_HANDLER( x68k_ct_w )
1143	1143	{
1144		x68k_state *state = device->machine().driver_data<x68k_state>();
1145		device_t *fdc = device->machine().device("upd72065");
1146		device_t *okim = device->machine().device("okim6258");
	1144	x68k_state *state = space.machine().driver_data<x68k_state>();
	1145	device_t *fdc = space.machine().device("upd72065");
	1146	device_t *okim = space.machine().device("okim6258");
1147	1147
1148	1148	// CT1 and CT2 bits from YM2151 port 0x1b
1149	1149	// CT1 - ADPCM clock - 0 = 8MHz, 1 = 4MHz
1150	1150	// CT2 - 1 = Set ready state of FDC
1151	1151	upd765_ready_w(fdc,data & 0x01);
1152	1152	state->m_adpcm.clock = data & 0x02;
1153		x68k_set_adpcm(device->machine());
	1153	x68k_set_adpcm(space.machine());
1154	1154	okim6258_set_clock(okim, data & 0x02 ? 4000000 : 8000000);
1155	1155	}
1156	1156

trunk/src/mess/drivers/pc8801.c

r18055	r18056
1820	1820
1821	1821	static READ8_DEVICE_HANDLER( cpu_8255_c_r )
1822	1822	{
1823		pc8801_state *state = device->machine().driver_data<pc8801_state>();
1824		//  device->machine().scheduler().synchronize(); // force resync
	1823	pc8801_state *state = space.machine().driver_data<pc8801_state>();
	1824	//  space.machine().scheduler().synchronize(); // force resync
1825	1825
1826	1826	return state->m_i8255_1_pc >> 4;
1827	1827	}
1828	1828
1829	1829	static WRITE8_DEVICE_HANDLER( cpu_8255_c_w )
1830	1830	{
1831		pc8801_state *state = device->machine().driver_data<pc8801_state>();
1832		//  device->machine().scheduler().synchronize(); // force resync
	1831	pc8801_state *state = space.machine().driver_data<pc8801_state>();
	1832	//  space.machine().scheduler().synchronize(); // force resync
1833	1833
1834	1834	state->m_i8255_0_pc = data;
1835	1835	}
r18055	r18056
1847	1847
1848	1848	static READ8_DEVICE_HANDLER( fdc_8255_c_r )
1849	1849	{
1850		pc8801_state *state = device->machine().driver_data<pc8801_state>();
1851		//  device->machine().scheduler().synchronize(); // force resync
	1850	pc8801_state *state = space.machine().driver_data<pc8801_state>();
	1851	//  space.machine().scheduler().synchronize(); // force resync
1852	1852
1853	1853	return state->m_i8255_0_pc >> 4;
1854	1854	}
1855	1855
1856	1856	static WRITE8_DEVICE_HANDLER( fdc_8255_c_w )
1857	1857	{
1858		pc8801_state *state = device->machine().driver_data<pc8801_state>();
1859		//  device->machine().scheduler().synchronize(); // force resync
	1858	pc8801_state *state = space.machine().driver_data<pc8801_state>();
	1859	//  space.machine().scheduler().synchronize(); // force resync
1860	1860
1861	1861	state->m_i8255_1_pc = data;
1862	1862	}
r18055	r18056
2569	2569
2570	2570	static READ8_DEVICE_HANDLER( opn_porta_r )
2571	2571	{
2572		pc8801_state *state = device->machine().driver_data<pc8801_state>();
	2572	pc8801_state *state = space.machine().driver_data<pc8801_state>();
2573	2573
2574		if(device->machine().root_device().ioport("BOARD_CONFIG")->read() & 2)
	2574	if(space.machine().root_device().ioport("BOARD_CONFIG")->read() & 2)
2575	2575	{
2576	2576	UINT8 shift,res;
2577	2577
r18055	r18056
2583	2583	return ((res >> shift) & 0x0f) | 0xf0;
2584	2584	}
2585	2585
2586		return device->machine().root_device().ioport("OPN_PA")->read();
	2586	return space.machine().root_device().ioport("OPN_PA")->read();
2587	2587	}
2588	2588	static READ8_DEVICE_HANDLER( opn_portb_r ) { return device->machine().root_device().ioport("OPN_PB")->read(); }
2589	2589

trunk/src/mess/drivers/enterp.c

r18055	r18056
100	100	/* EP specific handling of dave register write */
101	101	static WRITE8_DEVICE_HANDLER( enterprise_dave_reg_write )
102	102	{
103		ep_state *ep = device->machine().driver_data<ep_state>();
	103	ep_state *ep = space.machine().driver_data<ep_state>();
104	104
105	105	switch (offset)
106	106	{
r18055	r18056
108	108	case 0x11:
109	109	case 0x12:
110	110	case 0x13:
111		enterprise_update_memory_page(device->machine().device("maincpu")->memory().space(AS_PROGRAM), offset - 0x0f, data);
	111	enterprise_update_memory_page(space.machine().device("maincpu")->memory().space(AS_PROGRAM), offset - 0x0f, data);
112	112	break;
113	113
114	114	case 0x15:
r18055	r18056
126	126	"LINE5", "LINE6", "LINE7", "LINE8", "LINE9"
127	127	};
128	128
129		ep_state *ep = device->machine().driver_data<ep_state>();
	129	ep_state *ep = space.machine().driver_data<ep_state>();
130	130
131	131	switch (offset)
132	132	{
133	133	case 0x015:
134	134	/* read keyboard line */
135		dave_set_reg(device, 0x015, device->machine().root_device().ioport(keynames[ep->keyboard_line])->read());
	135	dave_set_reg(device, 0x015, space.machine().root_device().ioport(keynames[ep->keyboard_line])->read());
136	136	break;
137	137
138	138	case 0x016:
139	139	{
140	140	int ExternalJoystickInputs;
141		int ExternalJoystickPortInput = device->machine().root_device().ioport("JOY1")->read();
	141	int ExternalJoystickPortInput = space.machine().root_device().ioport("JOY1")->read();
142	142
143	143	if (ep->keyboard_line <= 4)
144	144	{

trunk/src/mess/drivers/portfoli.c

r18055	r18056
658	658	static READ8_DEVICE_HANDLER( hd61830_rd_r )
659	659	{
660	660	UINT16 address = ((offset & 0xff) << 3) | ((offset >> 12) & 0x07);
661		UINT8 data = device->machine().root_device().memregion(HD61830_TAG)->base()[address];
	661	UINT8 data = space.machine().root_device().memregion(HD61830_TAG)->base()[address];
662	662
663	663	return data;
664	664	}

trunk/src/mess/drivers/dm7000.c

r18055	r18056
270	270
271	271	static READ32_DEVICE_HANDLER( dcr_r )
272	272	{
273		dm7000_state *state = device->machine().driver_data<dm7000_state>();
	273	dm7000_state *state = space.machine().driver_data<dm7000_state>();
274	274	mame_printf_debug("DCR %03X read\n", offset);
275	275	if(offset>=1024) {printf("get %04X\n", offset); return 0;} else
276	276	switch(offset) {
r18055	r18056
285	285	static WRITE32_DEVICE_HANDLER( dcr_w )
286	286	{
287	287	mame_printf_debug("DCR %03X write = %08X\n", offset, data);
288		dm7000_state *state = device->machine().driver_data<dm7000_state>();
	288	dm7000_state *state = space.machine().driver_data<dm7000_state>();
289	289	if(offset>=1024) {printf("get %04X\n", offset); } else
290	290	state->dcr[offset] = data;
291	291	}

trunk/src/mess/drivers/elwro800.c

r18055	r18056
176	176
177	177	static READ8_DEVICE_HANDLER(i8255_port_c_r)
178	178	{
179		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	179	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
180	180	return (centronics->ack_r() << 2);
181	181	}
182	182
183	183	static WRITE8_DEVICE_HANDLER(i8255_port_c_w)
184	184	{
185		centronics_device *centronics = device->machine().device<centronics_device>("centronics");
	185	centronics_device *centronics = space.machine().device<centronics_device>("centronics");
186	186	centronics->strobe_w((data >> 7) & 0x01);
187	187	}
188	188

trunk/src/mess/drivers/fidelz80.c

r18055	r18056
943	943
944	944	static WRITE8_DEVICE_HANDLER( digit_w )
945	945	{
946		fidelz80_state *state = device->machine().driver_data<fidelz80_state>();
	946	fidelz80_state *state = space.machine().driver_data<fidelz80_state>();
947	947
948	948	if (state->m_digit_line_status[offset])
949	949	return;

trunk/src/mess/drivers/ms0515.c

r18055	r18056
236	236
237	237	static WRITE8_DEVICE_HANDLER(ms0515_portc_w)
238	238	{
239		ms0515_state *state = device->machine().driver_data<ms0515_state>();
	239	ms0515_state *state = space.machine().driver_data<ms0515_state>();
240	240	state->m_sysreg = data;
241	241	}
242	242	I8255A_INTERFACE( ms0515_ppi8255_interface_1 )

trunk/src/mess/drivers/juicebox.c

r18055	r18056
233	233
234	234	static WRITE16_DEVICE_HANDLER( s3c44b0_i2s_data_w )
235	235	{
236		juicebox_state *juicebox = device->machine().driver_data<juicebox_state>();
	236	juicebox_state *juicebox = space.machine().driver_data<juicebox_state>();
237	237	juicebox->dac->write_signed16(data ^ 0x8000);
238	238	}
239	239

trunk/src/mess/drivers/apple2.c

r18055	r18056
223	223
224	224	static WRITE8_DEVICE_HANDLER(a2bus_irq_w)
225	225	{
226		apple2_state *a2 = device->machine().driver_data<apple2_state>();
	226	apple2_state *a2 = space.machine().driver_data<apple2_state>();
227	227
228	228	a2->m_maincpu->set_input_line(M6502_IRQ_LINE, data);
229	229	}
230	230
231	231	static WRITE8_DEVICE_HANDLER(a2bus_nmi_w)
232	232	{
233		apple2_state *a2 = device->machine().driver_data<apple2_state>();
	233	apple2_state *a2 = space.machine().driver_data<apple2_state>();
234	234
235	235	a2->m_maincpu->set_input_line(INPUT_LINE_NMI, data);
236	236	}
237	237
238	238	static WRITE8_DEVICE_HANDLER(a2bus_inh_w)
239	239	{
240		apple2_state *a2 = device->machine().driver_data<apple2_state>();
	240	apple2_state *a2 = space.machine().driver_data<apple2_state>();
241	241
242	242	a2->m_inh_slot = data;
243		apple2_update_memory(device->machine());
	243	apple2_update_memory(space.machine());
244	244	}
245	245
246	246	/***************************************************************************

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team