Previous

199869 Revisions

Next

r21065 Thursday 14th February, 2013 at 13:34:16 UTC by Miodrag Milanović
some more cleanup (nw)

[src/mame/drivers]	itech8.c matmania.c mquake.c
[src/mame/includes]	amiga.h itech8.h matmania.h
[src/mame/machine]	maniach.c slikshot.c

trunk/src/mame/machine/slikshot.c

r21064	r21065
170	170	*
171	171	*************************************/
172	172
173		static void inters_to_vels(UINT16 inter1, UINT16 inter2, UINT16 inter3, UINT8 beams,
	173	void itech8_state::inters_to_vels(UINT16 inter1, UINT16 inter2, UINT16 inter3, UINT8 beams,
174	174	UINT8 *xres, UINT8 *vxres, UINT8 *vyres)
175	175	{
176	176	UINT32 _27d8, _27c2;
r21064	r21065
243	243	*
244	244	*************************************/
245	245
246		static void vels_to_inters(UINT8 x, UINT8 vx, UINT8 vy,
	246	void itech8_state::vels_to_inters(UINT8 x, UINT8 vx, UINT8 vy,
247	247	UINT16 *inter1, UINT16 *inter2, UINT16 *inter3, UINT8 *beams)
248	248	{
249	249	UINT32 _27d8;
r21064	r21065
296	296	*
297	297	*************************************/
298	298
299		static void inters_to_words(UINT16 inter1, UINT16 inter2, UINT16 inter3, UINT8 *beams,
	299	void itech8_state::inters_to_words(UINT16 inter1, UINT16 inter2, UINT16 inter3, UINT8 *beams,
300	300	UINT16 *word1, UINT16 *word2, UINT16 *word3)
301	301	{
302	302	UINT16 word2mod;
r21064	r21065
358	358	*
359	359	*************************************/
360	360
361		static void words_to_sensors(UINT16 word1, UINT16 word2, UINT16 word3, UINT8 beams,
	361	void itech8_state::words_to_sensors(UINT16 word1, UINT16 word2, UINT16 word3, UINT8 beams,
362	362	UINT16 *sens0, UINT16 *sens1, UINT16 *sens2, UINT16 *sens3)
363	363	{
364	364	/* if bit 0 of the beams is set, sensor 1 fired first; otherwise sensor 0 fired */
r21064	r21065
382	382	*
383	383	*************************************/
384	384
385		static void compute_sensors(running_machine &machine)
386		{
387		itech8_state *state = machine.driver_data<itech8_state>();
	385	void itech8_state::compute_sensors()
	386	{
388	387	UINT16 inter1, inter2, inter3;
389	388	UINT16 word1 = 0, word2 = 0, word3 = 0;
390	389	UINT8 beams;
391	390
392	391	/* skip if we're not ready */
393		if (state->m_sensor0 != 0 || state->m_sensor1 != 0 || state->m_sensor2 != 0 || state->m_sensor3 != 0)
	392	if (m_sensor0 != 0 || m_sensor1 != 0 || m_sensor2 != 0 || m_sensor3 != 0)
394	393	return;
395	394
396	395	/* reverse map the inputs */
397		vels_to_inters(state->m_curx, state->m_curvx, state->m_curvy, &inter1, &inter2, &inter3, &beams);
	396	vels_to_inters(m_curx, m_curvx, m_curvy, &inter1, &inter2, &inter3, &beams);
398	397	inters_to_words(inter1, inter2, inter3, &beams, &word1, &word2, &word3);
399		words_to_sensors(word1, word2, word3, beams, &state->m_sensor0, &state->m_sensor1, &state->m_sensor2, &state->m_sensor3);
	398	words_to_sensors(word1, word2, word3, beams, &m_sensor0, &m_sensor1, &m_sensor2, &m_sensor3);
400	399
401		logerror("%15f: Sensor values: %04x %04x %04x %04x\n", machine.time().as_double(), state->m_sensor0, state->m_sensor1, state->m_sensor2, state->m_sensor3);
	400	logerror("%15f: Sensor values: %04x %04x %04x %04x\n", machine().time().as_double(), m_sensor0, m_sensor1, m_sensor2, m_sensor3);
402	401	}
403	402
404	403
r21064	r21065
409	408	*
410	409	*************************************/
411	410
412		READ8_HANDLER( slikz80_port_r )
	411	READ8_MEMBER(itech8_state::slikz80_port_r )
413	412	{
414		itech8_state *state = space.machine().driver_data<itech8_state>();
415	413	int result = 0;
416	414
417	415	/* if we have nothing, return 0x03 */
418		if (!state->m_sensor0 && !state->m_sensor1 && !state->m_sensor2 && !state->m_sensor3)
419		return 0x03 | (state->m_z80_clear_to_send << 7);
	416	if (!m_sensor0 && !m_sensor1 && !m_sensor2 && !m_sensor3)
	417	return 0x03 | (m_z80_clear_to_send << 7);
420	418
421	419	/* 1 bit for each sensor */
422		if (state->m_sensor0)
423		result |= 1, state->m_sensor0--;
424		if (state->m_sensor1)
425		result |= 2, state->m_sensor1--;
426		if (state->m_sensor2)
427		result |= 4, state->m_sensor2--;
428		if (state->m_sensor3)
429		result |= 8, state->m_sensor3--;
430		result |= state->m_z80_clear_to_send << 7;
	420	if (m_sensor0)
	421	result |= 1, m_sensor0--;
	422	if (m_sensor1)
	423	result |= 2, m_sensor1--;
	424	if (m_sensor2)
	425	result |= 4, m_sensor2--;
	426	if (m_sensor3)
	427	result |= 8, m_sensor3--;
	428	result |= m_z80_clear_to_send << 7;
431	429
432	430	return result;
433	431	}
r21064	r21065
440	438	*
441	439	*************************************/
442	440
443		WRITE8_HANDLER( slikz80_port_w )
	441	WRITE8_MEMBER(itech8_state::slikz80_port_w )
444	442	{
445		itech8_state *state = space.machine().driver_data<itech8_state>();
446		state->m_z80_port_val = data;
447		state->m_z80_clear_to_send = 0;
	443	m_z80_port_val = data;
	444	m_z80_clear_to_send = 0;
448	445	}
449	446
450	447
r21064	r21065
455	452	*
456	453	*************************************/
457	454
458		READ8_HANDLER( slikshot_z80_r )
	455	READ8_MEMBER(itech8_state::slikshot_z80_r )
459	456	{
460		itech8_state *state = space.machine().driver_data<itech8_state>();
461	457	/* allow the Z80 to send us stuff now */
462		state->m_z80_clear_to_send = 1;
463		return state->m_z80_port_val;
	458	m_z80_clear_to_send = 1;
	459	return m_z80_port_val;
464	460	}
465	461
466	462
r21064	r21065
471	467	*
472	468	*************************************/
473	469
474		READ8_HANDLER( slikshot_z80_control_r )
	470	READ8_MEMBER(itech8_state::slikshot_z80_control_r )
475	471	{
476		itech8_state *state = space.machine().driver_data<itech8_state>();
477		return state->m_z80_ctrl;
	472	return m_z80_ctrl;
478	473	}
479	474
480	475
r21064	r21065
485	480	*
486	481	*************************************/
487	482
488		static TIMER_CALLBACK( delayed_z80_control_w )
	483	TIMER_CALLBACK_MEMBER( itech8_state::delayed_z80_control_w )
489	484	{
490		itech8_state *state = machine.driver_data<itech8_state>();
491	485	int data = param;
492	486
493	487	/* bit 4 controls the reset line on the Z80 */
494	488
495	489	/* this is a big kludge: only allow a reset if the Z80 is stopped */
496	490	/* at its endpoint; otherwise, we never get a result from the Z80 */
497		if ((data & 0x10) || machine.device("sub")->state().state_int(Z80_PC) == 0x13a)
	491	if ((data & 0x10) || machine().device("sub")->state().state_int(Z80_PC) == 0x13a)
498	492	{
499		machine.device("sub")->execute().set_input_line(INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
	493	machine().device("sub")->execute().set_input_line(INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
500	494
501	495	/* on the rising edge, make the crosshair visible again */
502		if ((data & 0x10) && !(state->m_z80_ctrl & 0x10))
503		state->m_crosshair_vis = 1;
	496	if ((data & 0x10) && !(m_z80_ctrl & 0x10))
	497	m_crosshair_vis = 1;
504	498	}
505	499
506	500	/* boost the interleave whenever this is written to */
507		machine.scheduler().boost_interleave(attotime::zero, attotime::from_usec(100));
	501	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(100));
508	502
509	503	/* stash the new value */
510		state->m_z80_ctrl = data;
	504	m_z80_ctrl = data;
511	505	}
512	506
513	507
514		WRITE8_HANDLER( slikshot_z80_control_w )
	508	WRITE8_MEMBER(itech8_state::slikshot_z80_control_w )
515	509	{
516		space.machine().scheduler().synchronize(FUNC(delayed_z80_control_w), data);
	510	machine().scheduler().synchronize(timer_expired_delegate(FUNC(itech8_state::delayed_z80_control_w),this), data);
517	511	}
518	512
519	513
r21064	r21065
593	587	if (temp >=  0x90) temp =  0x90;
594	588	m_curx = temp;
595	589
596		compute_sensors(machine());
	590	compute_sensors();
597	591	//      popmessage("V=%02x,%02x  X=%02x", m_curvx, m_curvy, m_curx);
598	592	m_crosshair_vis = 0;
599	593	}

trunk/src/mame/machine/maniach.c

r21064	r21065
19	19
20	20	***************************************************************************/
21	21
22		READ8_HANDLER( maniach_68705_port_a_r )
	22	READ8_MEMBER(matmania_state::maniach_68705_port_a_r )
23	23	{
24		matmania_state *state = space.machine().driver_data<matmania_state>();
25
26		//logerror("%04x: 68705 port A read %02x\n", space.device().safe_pc(), state->m_port_a_in);
27		return (state->m_port_a_out & state->m_ddr_a) | (state->m_port_a_in & ~state->m_ddr_a);
	24	//logerror("%04x: 68705 port A read %02x\n", space.device().safe_pc(), m_port_a_in);
	25	return (m_port_a_out & m_ddr_a) | (m_port_a_in & ~m_ddr_a);
28	26	}
29	27
30		WRITE8_HANDLER( maniach_68705_port_a_w )
	28	WRITE8_MEMBER(matmania_state::maniach_68705_port_a_w )
31	29	{
32		matmania_state *state = space.machine().driver_data<matmania_state>();
33
34	30	//logerror("%04x: 68705 port A write %02x\n", space.device().safe_pc(), data);
35		state->m_port_a_out = data;
	31	m_port_a_out = data;
36	32	}
37	33
38		WRITE8_HANDLER( maniach_68705_ddr_a_w )
	34	WRITE8_MEMBER(matmania_state::maniach_68705_ddr_a_w )
39	35	{
40		matmania_state *state = space.machine().driver_data<matmania_state>();
41		state->m_ddr_a = data;
	36	m_ddr_a = data;
42	37	}
43	38
44	39
r21064	r21065
52	47	*  2   W  when 0->1, copies port A to the latch for the main CPU
53	48	*/
54	49
55		READ8_HANDLER( maniach_68705_port_b_r )
	50	READ8_MEMBER(matmania_state::maniach_68705_port_b_r )
56	51	{
57		matmania_state *state = space.machine().driver_data<matmania_state>();
58		return (state->m_port_b_out & state->m_ddr_b) | (state->m_port_b_in & ~state->m_ddr_b);
	52	return (m_port_b_out & m_ddr_b) | (m_port_b_in & ~m_ddr_b);
59	53	}
60	54
61		WRITE8_HANDLER( maniach_68705_port_b_w )
	55	WRITE8_MEMBER(matmania_state::maniach_68705_port_b_w )
62	56	{
63		matmania_state *state = space.machine().driver_data<matmania_state>();
64
65	57	//logerror("%04x: 68705 port B write %02x\n", space.device().safe_pc(), data);
66	58
67		if (BIT(state->m_ddr_b, 1) && BIT(~data, 1) && BIT(state->m_port_b_out, 1))
	59	if (BIT(m_ddr_b, 1) && BIT(~data, 1) && BIT(m_port_b_out, 1))
68	60	{
69		state->m_port_a_in = state->m_from_main;
70		state->m_main_sent = 0;
71		//logerror("read command %02x from main cpu\n", state->m_port_a_in);
	61	m_port_a_in = m_from_main;
	62	m_main_sent = 0;
	63	//logerror("read command %02x from main cpu\n", m_port_a_in);
72	64	}
73		if (BIT(state->m_ddr_b, 2) && BIT(data, 2) && BIT(~state->m_port_b_out, 2))
	65	if (BIT(m_ddr_b, 2) && BIT(data, 2) && BIT(~m_port_b_out, 2))
74	66	{
75		//logerror("send command %02x to main cpu\n", state->m_port_a_out);
76		state->m_from_mcu = state->m_port_a_out;
77		state->m_mcu_sent = 1;
	67	//logerror("send command %02x to main cpu\n", m_port_a_out);
	68	m_from_mcu = m_port_a_out;
	69	m_mcu_sent = 1;
78	70	}
79	71
80		state->m_port_b_out = data;
	72	m_port_b_out = data;
81	73	}
82	74
83		WRITE8_HANDLER( maniach_68705_ddr_b_w )
	75	WRITE8_MEMBER(matmania_state::maniach_68705_ddr_b_w )
84	76	{
85		matmania_state *state = space.machine().driver_data<matmania_state>();
86		state->m_ddr_b = data;
	77	m_ddr_b = data;
87	78	}
88	79
89	80
90		READ8_HANDLER( maniach_68705_port_c_r )
	81	READ8_MEMBER(matmania_state::maniach_68705_port_c_r )
91	82	{
92		matmania_state *state = space.machine().driver_data<matmania_state>();
	83	m_port_c_in = 0;
93	84
94		state->m_port_c_in = 0;
	85	if (m_main_sent)
	86	m_port_c_in |= 0x01;
95	87
96		if (state->m_main_sent)
97		state->m_port_c_in |= 0x01;
	88	if (!m_mcu_sent)
	89	m_port_c_in |= 0x02;
98	90
99		if (!state->m_mcu_sent)
100		state->m_port_c_in |= 0x02;
	91	//logerror("%04x: 68705 port C read %02x\n",m_space->device().safe_pc(), m_port_c_in);
101	92
102		//logerror("%04x: 68705 port C read %02x\n",state->m_space->device().safe_pc(), state->m_port_c_in);
103
104		return (state->m_port_c_out & state->m_ddr_c) | (state->m_port_c_in & ~state->m_ddr_c);
	93	return (m_port_c_out & m_ddr_c) | (m_port_c_in & ~m_ddr_c);
105	94	}
106	95
107		WRITE8_HANDLER( maniach_68705_port_c_w )
	96	WRITE8_MEMBER(matmania_state::maniach_68705_port_c_w )
108	97	{
109		matmania_state *state = space.machine().driver_data<matmania_state>();
110
111	98	//logerror("%04x: 68705 port C write %02x\n", space.device().safe_pc(), data);
112		state->m_port_c_out = data;
	99	m_port_c_out = data;
113	100	}
114	101
115		WRITE8_HANDLER( maniach_68705_ddr_c_w )
	102	WRITE8_MEMBER(matmania_state::maniach_68705_ddr_c_w )
116	103	{
117		matmania_state *state = space.machine().driver_data<matmania_state>();
118		state->m_ddr_c = data;
	104	m_ddr_c = data;
119	105	}
120	106
121	107
122		WRITE8_HANDLER( maniach_mcu_w )
	108	WRITE8_MEMBER(matmania_state::maniach_mcu_w )
123	109	{
124		matmania_state *state = space.machine().driver_data<matmania_state>();
125
126	110	//logerror("%04x: 3040_w %02x\n", space.device().safe_pc(), data);
127		state->m_from_main = data;
128		state->m_main_sent = 1;
	111	m_from_main = data;
	112	m_main_sent = 1;
129	113	}
130	114
131		READ8_HANDLER( maniach_mcu_r )
	115	READ8_MEMBER(matmania_state::maniach_mcu_r )
132	116	{
133		matmania_state *state = space.machine().driver_data<matmania_state>();
134
135		//logerror("%04x: 3040_r %02x\n", space.device().safe_pc(), state->m_from_mcu);
136		state->m_mcu_sent = 0;
137		return state->m_from_mcu;
	117	//logerror("%04x: 3040_r %02x\n", space.device().safe_pc(), m_from_mcu);
	118	m_mcu_sent = 0;
	119	return m_from_mcu;
138	120	}
139	121
140		READ8_HANDLER( maniach_mcu_status_r )
	122	READ8_MEMBER(matmania_state::maniach_mcu_status_r )
141	123	{
142		matmania_state *state = space.machine().driver_data<matmania_state>();
143	124	int res = 0;
144	125
145	126	/* bit 0 = when 0, mcu has sent data to the main cpu */
146	127	/* bit 1 = when 1, mcu is ready to receive data from main cpu */
147	128	//logerror("%04x: 3041_r\n", space.device().safe_pc());
148		if (!state->m_mcu_sent)
	129	if (!m_mcu_sent)
149	130	res |= 0x01;
150		if (!state->m_main_sent)
	131	if (!m_main_sent)
151	132	res |= 0x02;
152	133
153	134	return res;

trunk/src/mame/includes/amiga.h

r21064	r21065
459	459	int m_aga_sprite_dma_used_words[8];
460	460
461	461	DECLARE_CUSTOM_INPUT_MEMBER( amiga_joystick_convert );
462		DECLARE_DRIVER_INIT(mquake);
463	462	DECLARE_DRIVER_INIT(amiga);
464	463	DECLARE_DRIVER_INIT(cdtv);
465	464	DECLARE_DRIVER_INIT(a3000);
466		DECLARE_MACHINE_RESET(mquake);
467	465	DECLARE_MACHINE_RESET(amiga);
468	466	DECLARE_VIDEO_START(amiga);
469	467	DECLARE_PALETTE_INIT(amiga);

trunk/src/mame/includes/matmania.h

r21064	r21065
61	61	DECLARE_MACHINE_RESET(maniach);
62	62	UINT32 screen_update_matmania(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
63	63	UINT32 screen_update_maniach(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	64	/*----------- defined in machine/maniach.c -----------*/
	65	DECLARE_READ8_MEMBER( maniach_68705_port_a_r );
	66	DECLARE_WRITE8_MEMBER( maniach_68705_port_a_w );
	67	DECLARE_READ8_MEMBER( maniach_68705_port_b_r );
	68	DECLARE_WRITE8_MEMBER( maniach_68705_port_b_w );
	69	DECLARE_READ8_MEMBER( maniach_68705_port_c_r );
	70	DECLARE_WRITE8_MEMBER( maniach_68705_port_c_w );
	71	DECLARE_WRITE8_MEMBER( maniach_68705_ddr_a_w );
	72	DECLARE_WRITE8_MEMBER( maniach_68705_ddr_b_w );
	73	DECLARE_WRITE8_MEMBER( maniach_68705_ddr_c_w );
	74	DECLARE_WRITE8_MEMBER( maniach_mcu_w );
	75	DECLARE_READ8_MEMBER( maniach_mcu_r );
	76	DECLARE_READ8_MEMBER( maniach_mcu_status_r );
64	77	};
65
66		/*----------- defined in machine/maniach.c -----------*/
67
68		DECLARE_READ8_HANDLER( maniach_68705_port_a_r );
69		DECLARE_WRITE8_HANDLER( maniach_68705_port_a_w );
70		DECLARE_READ8_HANDLER( maniach_68705_port_b_r );
71		DECLARE_WRITE8_HANDLER( maniach_68705_port_b_w );
72		DECLARE_READ8_HANDLER( maniach_68705_port_c_r );
73		DECLARE_WRITE8_HANDLER( maniach_68705_port_c_w );
74		DECLARE_WRITE8_HANDLER( maniach_68705_ddr_a_w );
75		DECLARE_WRITE8_HANDLER( maniach_68705_ddr_b_w );
76		DECLARE_WRITE8_HANDLER( maniach_68705_ddr_c_w );
77		DECLARE_WRITE8_HANDLER( maniach_mcu_w );
78		DECLARE_READ8_HANDLER( maniach_mcu_r );
79		DECLARE_READ8_HANDLER( maniach_mcu_status_r );

trunk/src/mame/includes/itech8.h

r21064	r21065
110	110	inline void consume_rle(int count);
111	111	void perform_blit(address_space &space);
112	112	void itech8_update_interrupts(int periodic, int tms34061, int blitter);
113		};
	113
	114	/*----------- defined in machine/slikshot.c -----------*/
114	115
115		/*----------- defined in machine/slikshot.c -----------*/
	116	DECLARE_READ8_MEMBER( slikz80_port_r );
	117	DECLARE_WRITE8_MEMBER( slikz80_port_w );
116	118
117		DECLARE_READ8_HANDLER( slikz80_port_r );
118		DECLARE_WRITE8_HANDLER( slikz80_port_w );
	119	DECLARE_READ8_MEMBER( slikshot_z80_r );
	120	DECLARE_READ8_MEMBER( slikshot_z80_control_r );
	121	DECLARE_WRITE8_MEMBER( slikshot_z80_control_w );
119	122
120		DECLARE_READ8_HANDLER( slikshot_z80_r );
121		DECLARE_READ8_HANDLER( slikshot_z80_control_r );
122		DECLARE_WRITE8_HANDLER( slikshot_z80_control_w );
	123	void inters_to_vels(UINT16 inter1, UINT16 inter2, UINT16 inter3, UINT8 beams,
	124	UINT8 *xres, UINT8 *vxres, UINT8 *vyres);
	125	void vels_to_inters(UINT8 x, UINT8 vx, UINT8 vy,
	126	UINT16 *inter1, UINT16 *inter2, UINT16 *inter3, UINT8 *beams);
	127	void inters_to_words(UINT16 inter1, UINT16 inter2, UINT16 inter3, UINT8 *beams,
	128	UINT16 *word1, UINT16 *word2, UINT16 *word3);
	129
	130	void words_to_sensors(UINT16 word1, UINT16 word2, UINT16 word3, UINT8 beams,
	131	UINT16 *sens0, UINT16 *sens1, UINT16 *sens2, UINT16 *sens3);
	132	void compute_sensors();
	133	TIMER_CALLBACK_MEMBER( delayed_z80_control_w );
	134	};
	135

trunk/src/mame/drivers/matmania.c

r21064	r21065
93	93	AM_RANGE(0x3010, 0x3010) AM_READ_PORT("IN1") AM_WRITE(maniach_sh_command_w)
94	94	AM_RANGE(0x3020, 0x3020) AM_READ_PORT("DSW2") AM_WRITEONLY AM_SHARE("scroll")
95	95	AM_RANGE(0x3030, 0x3030) AM_READ_PORT("DSW1") AM_WRITENOP   /* ?? */
96		AM_RANGE(0x3040, 0x3040) AM_READWRITE_LEGACY(maniach_mcu_r,maniach_mcu_w)
97		AM_RANGE(0x3041, 0x3041) AM_READ_LEGACY(maniach_mcu_status_r)
	96	AM_RANGE(0x3040, 0x3040) AM_READWRITE(maniach_mcu_r,maniach_mcu_w)
	97	AM_RANGE(0x3041, 0x3041) AM_READ(maniach_mcu_status_r)
98	98	AM_RANGE(0x3050, 0x307f) AM_WRITE(matmania_paletteram_w) AM_SHARE("paletteram")
99	99	AM_RANGE(0x4000, 0xffff) AM_ROM
100	100	ADDRESS_MAP_END
r21064	r21065
120	120
121	121	static ADDRESS_MAP_START( maniach_mcu_map, AS_PROGRAM, 8, matmania_state )
122	122	ADDRESS_MAP_GLOBAL_MASK(0x7ff)
123		AM_RANGE(0x0000, 0x0000) AM_READWRITE_LEGACY(maniach_68705_port_a_r,maniach_68705_port_a_w)
124		AM_RANGE(0x0001, 0x0001) AM_READWRITE_LEGACY(maniach_68705_port_b_r,maniach_68705_port_b_w)
125		AM_RANGE(0x0002, 0x0002) AM_READWRITE_LEGACY(maniach_68705_port_c_r,maniach_68705_port_c_w)
126		AM_RANGE(0x0004, 0x0004) AM_WRITE_LEGACY(maniach_68705_ddr_a_w)
127		AM_RANGE(0x0005, 0x0005) AM_WRITE_LEGACY(maniach_68705_ddr_b_w)
128		AM_RANGE(0x0006, 0x0006) AM_WRITE_LEGACY(maniach_68705_ddr_c_w)
	123	AM_RANGE(0x0000, 0x0000) AM_READWRITE(maniach_68705_port_a_r,maniach_68705_port_a_w)
	124	AM_RANGE(0x0001, 0x0001) AM_READWRITE(maniach_68705_port_b_r,maniach_68705_port_b_w)
	125	AM_RANGE(0x0002, 0x0002) AM_READWRITE(maniach_68705_port_c_r,maniach_68705_port_c_w)
	126	AM_RANGE(0x0004, 0x0004) AM_WRITE(maniach_68705_ddr_a_w)
	127	AM_RANGE(0x0005, 0x0005) AM_WRITE(maniach_68705_ddr_b_w)
	128	AM_RANGE(0x0006, 0x0006) AM_WRITE(maniach_68705_ddr_c_w)
129	129	AM_RANGE(0x0010, 0x007f) AM_RAM
130	130	AM_RANGE(0x0080, 0x07ff) AM_ROM
131	131	ADDRESS_MAP_END

trunk/src/mame/drivers/itech8.c

r21064	r21065
980	980
981	981	static ADDRESS_MAP_START( slikz80_io_map, AS_IO, 8, itech8_state )
982	982	ADDRESS_MAP_GLOBAL_MASK(0xff)
983		AM_RANGE(0x00, 0x00) AM_READWRITE_LEGACY(slikz80_port_r, slikz80_port_w)
	983	AM_RANGE(0x00, 0x00) AM_READWRITE(slikz80_port_r, slikz80_port_w)
984	984	ADDRESS_MAP_END
985	985
986	986
r21064	r21065
2636	2636
2637	2637	DRIVER_INIT_MEMBER(itech8_state,slikshot)
2638	2638	{
2639		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_read_handler (0x0180, 0x0180, FUNC(slikshot_z80_r));
2640		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_read_handler (0x01cf, 0x01cf, FUNC(slikshot_z80_control_r));
2641		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_write_handler(0x01cf, 0x01cf, FUNC(slikshot_z80_control_w));
	2639	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x0180, 0x0180, read8_delegate(FUNC(itech8_state::slikshot_z80_r),this));
	2640	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x01cf, 0x01cf, read8_delegate(FUNC(itech8_state::slikshot_z80_control_r),this));
	2641	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x01cf, 0x01cf, write8_delegate(FUNC(itech8_state::slikshot_z80_control_w),this));
2642	2642	}
2643	2643
2644	2644
2645	2645	DRIVER_INIT_MEMBER(itech8_state,sstrike)
2646	2646	{
2647		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_read_handler (0x1180, 0x1180, FUNC(slikshot_z80_r));
2648		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_read_handler (0x11cf, 0x11cf, FUNC(slikshot_z80_control_r));
2649		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_write_handler(0x11cf, 0x11cf, FUNC(slikshot_z80_control_w));
	2647	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x1180, 0x1180, read8_delegate(FUNC(itech8_state::slikshot_z80_r),this));
	2648	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x11cf, 0x11cf, read8_delegate(FUNC(itech8_state::slikshot_z80_control_r),this));
	2649	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x11cf, 0x11cf, write8_delegate(FUNC(itech8_state::slikshot_z80_control_w),this));
2650	2650	}
2651	2651
2652	2652

trunk/src/mame/drivers/mquake.c

r21064	r21065
15	15	#include "machine/nvram.h"
16	16	#include "machine/amigafdc.h"
17	17
	18	class mquake_state : public amiga_state
	19	{
	20	public:
	21	mquake_state(const machine_config &mconfig, device_type type, const char *tag)
	22	: amiga_state(mconfig, type, tag) { }
18	23
	24	DECLARE_DRIVER_INIT(mquake);
	25	DECLARE_MACHINE_RESET(mquake);
	26	DECLARE_WRITE8_MEMBER( mquake_cia_0_porta_w );
	27	DECLARE_READ8_MEMBER( mquake_cia_0_portb_r );
	28	DECLARE_WRITE8_MEMBER( mquake_cia_0_portb_w );
	29	DECLARE_READ8_MEMBER( es5503_sample_r );
	30	DECLARE_WRITE16_MEMBER( output_w );
	31	DECLARE_READ16_MEMBER( coin_chip_r );
	32	DECLARE_WRITE16_MEMBER( coin_chip_w );
	33	};
19	34
20	35	/*************************************
21	36	*
r21064	r21065
32	47	*
33	48	*************************************/
34	49
35		static WRITE8_DEVICE_HANDLER( mquake_cia_0_porta_w )
	50	WRITE8_MEMBER(mquake_state::mquake_cia_0_porta_w)
36	51	{
37		amiga_state *sta = device->machine().driver_data<amiga_state>();
38
39	52	/* switch banks as appropriate */
40		sta->m_bank1->set_entry(data & 1);
	53	m_bank1->set_entry(data & 1);
41	54
42	55	/* swap the write handlers between ROM and bank 1 based on the bit */
43	56	if ((data & 1) == 0)
44	57	/* overlay disabled, map RAM on 0x000000 */
45		sta->m_maincpu->space(AS_PROGRAM).install_write_bank(0x000000, 0x07ffff, "bank1");
	58	m_maincpu->space(AS_PROGRAM).install_write_bank(0x000000, 0x07ffff, "bank1");
46	59
47	60	else
48	61	/* overlay enabled, map Amiga system ROM on 0x000000 */
49		sta->m_maincpu->space(AS_PROGRAM).unmap_write(0x000000, 0x07ffff);
	62	m_maincpu->space(AS_PROGRAM).unmap_write(0x000000, 0x07ffff);
50	63	}
51	64
52	65
r21064	r21065
66	79	*
67	80	*************************************/
68	81
69		static READ8_DEVICE_HANDLER( mquake_cia_0_portb_r )
	82	READ8_MEMBER(mquake_state::mquake_cia_0_portb_r)
70	83	{
71	84	/* parallel port */
72		logerror("%s:CIA0_portb_r\n", space.machine().describe_context());
	85	logerror("%s:CIA0_portb_r\n", machine().describe_context());
73	86	return 0xff;
74	87	}
75	88
76		static WRITE8_DEVICE_HANDLER( mquake_cia_0_portb_w )
	89	WRITE8_MEMBER(mquake_state::mquake_cia_0_portb_w)
77	90	{
78	91	/* parallel port */
79		logerror("%s:CIA0_portb_w(%02x)\n", space.machine().describe_context(), data);
	92	logerror("%s:CIA0_portb_w(%02x)\n", machine().describe_context(), data);
80	93	}
81	94
82	95
r21064	r21065
87	100	*
88	101	*************************************/
89	102
90		static READ8_HANDLER( es5503_sample_r )
	103	READ8_MEMBER(mquake_state::es5503_sample_r)
91	104	{
92		UINT8 *rom = space.machine().root_device().memregion("es5503")->base();
93		es5503_device *es5503 = space.machine().device<es5503_device>("es5503");
	105	UINT8 *rom = memregion("es5503")->base();
	106	es5503_device *es5503 = machine().device<es5503_device>("es5503");
94	107
95	108	return rom[offset + (es5503->get_channel_strobe() * 0x10000)];
96	109	}
97	110
98		static ADDRESS_MAP_START( mquake_es5503_map, AS_0, 8, amiga_state )
99		AM_RANGE(0x000000, 0x1ffff) AM_READ_LEGACY(es5503_sample_r)
	111	static ADDRESS_MAP_START( mquake_es5503_map, AS_0, 8, mquake_state )
	112	AM_RANGE(0x000000, 0x1ffff) AM_READ(es5503_sample_r)
100	113	ADDRESS_MAP_END
101	114
102		static WRITE16_HANDLER( output_w )
	115	WRITE16_MEMBER(mquake_state::output_w)
103	116	{
104	117	if (ACCESSING_BITS_0_7)
105	118	logerror("%06x:output_w(%x) = %02x\n", space.device().safe_pc(), offset, data);
106	119	}
107	120
108	121
109		static READ16_HANDLER( coin_chip_r )
	122	READ16_MEMBER(mquake_state::coin_chip_r)
110	123	{
111	124	if (offset == 1)
112		return space.machine().root_device().ioport("COINCHIP")->read();
	125	return ioport("COINCHIP")->read();
113	126	logerror("%06x:coin_chip_r(%02x) & %04x\n", space.device().safe_pc(), offset, mem_mask);
114	127	return 0xffff;
115	128	}
116	129
117		static WRITE16_HANDLER( coin_chip_w )
	130	WRITE16_MEMBER(mquake_state::coin_chip_w)
118	131	{
119	132	logerror("%06x:coin_chip_w(%02x) = %04x & %04x\n", space.device().safe_pc(), offset, data, mem_mask);
120	133	}
r21064	r21065
133	146	*
134	147	*************************************/
135	148
136		static ADDRESS_MAP_START( main_map, AS_PROGRAM, 16, amiga_state )
	149	static ADDRESS_MAP_START( main_map, AS_PROGRAM, 16, mquake_state )
137	150	ADDRESS_MAP_UNMAP_HIGH
138	151	AM_RANGE(0x000000, 0x07ffff) AM_RAMBANK("bank1") AM_SHARE("chip_ram")
139	152	AM_RANGE(0xbfd000, 0xbfefff) AM_READWRITE_LEGACY(amiga_cia_r, amiga_cia_w)
r21064	r21065
145	158	AM_RANGE(0x204000, 0x2041ff) AM_DEVREADWRITE8("es5503", es5503_device, read, write, 0x00ff)
146	159	AM_RANGE(0x282000, 0x282001) AM_READ_PORT("SW.LO")
147	160	AM_RANGE(0x282002, 0x282003) AM_READ_PORT("SW.HI")
148		AM_RANGE(0x284000, 0x28400f) AM_WRITE_LEGACY(output_w)
149		AM_RANGE(0x286000, 0x28600f) AM_READWRITE_LEGACY(coin_chip_r, coin_chip_w)
	161	AM_RANGE(0x284000, 0x28400f) AM_WRITE(output_w)
	162	AM_RANGE(0x286000, 0x28600f) AM_READWRITE(coin_chip_r, coin_chip_w)
150	163	AM_RANGE(0x300000, 0x3bffff) AM_ROM AM_REGION("user2", 0)
151	164	AM_RANGE(0xf00000, 0xfbffff) AM_ROM AM_REGION("user2", 0)           /* Custom ROM */
152	165	ADDRESS_MAP_END
r21064	r21065
166	179	PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(2)         /* JS1SW */
167	180
168	181	PORT_START("JOY0DAT")
169		PORT_BIT( 0x0303, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, amiga_state,amiga_joystick_convert, 0)
	182	PORT_BIT( 0x0303, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, mquake_state,amiga_joystick_convert, 0)
170	183	PORT_BIT( 0xfcfc, IP_ACTIVE_HIGH, IPT_UNKNOWN )
171	184
172	185	PORT_START("JOY1DAT")
173		PORT_BIT( 0x0303, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, amiga_state,amiga_joystick_convert, 1)
	186	PORT_BIT( 0x0303, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, mquake_state,amiga_joystick_convert, 1)
174	187	PORT_BIT( 0xfcfc, IP_ACTIVE_HIGH, IPT_UNKNOWN )
175	188
176	189	PORT_START("P1JOY")
r21064	r21065
304	317	*
305	318	*************************************/
306	319
307		MACHINE_RESET_MEMBER(amiga_state,mquake)
	320	MACHINE_RESET_MEMBER(mquake_state,mquake)
308	321	{
309	322	MACHINE_RESET_CALL_MEMBER(amiga);
310	323	}
r21064	r21065
322	335	DEVCB_NULL,
323	336	DEVCB_NULL,
324	337	DEVCB_INPUT_PORT("CIA0PORTA"),
325		DEVCB_HANDLER(mquake_cia_0_porta_w),    /* port A */
326		DEVCB_HANDLER(mquake_cia_0_portb_r),
327		DEVCB_HANDLER(mquake_cia_0_portb_w) /* port B */
	338	DEVCB_DRIVER_MEMBER(mquake_state,mquake_cia_0_porta_w),    /* port A */
	339	DEVCB_DRIVER_MEMBER(mquake_state,mquake_cia_0_portb_r),
	340	DEVCB_DRIVER_MEMBER(mquake_state,mquake_cia_0_portb_w) /* port B */
328	341	};
329	342
330	343	static const legacy_mos6526_interface cia_1_intf =
r21064	r21065
339	352	DEVCB_NULL
340	353	};
341	354
342		static MACHINE_CONFIG_START( mquake, amiga_state )
	355	static MACHINE_CONFIG_START( mquake, mquake_state )
343	356
344	357	/* basic machine hardware */
345	358	MCFG_CPU_ADD("maincpu", M68000, AMIGA_68000_NTSC_CLOCK)
346	359	MCFG_CPU_PROGRAM_MAP(main_map)
347	360
348		MCFG_MACHINE_RESET_OVERRIDE(amiga_state,mquake)
	361	MCFG_MACHINE_RESET_OVERRIDE(mquake_state,mquake)
349	362	MCFG_NVRAM_ADD_0FILL("nvram")
350	363
351	364	/* video hardware */
r21064	r21065
356	369	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
357	370	MCFG_SCREEN_SIZE(512*2, 262)
358	371	MCFG_SCREEN_VISIBLE_AREA((129-8)*2, (449+8-1)*2, 44-8, 244+8-1)
359		MCFG_SCREEN_UPDATE_DRIVER(amiga_state, screen_update_amiga)
	372	MCFG_SCREEN_UPDATE_DRIVER(mquake_state, screen_update_amiga)
360	373
361	374	MCFG_PALETTE_LENGTH(4096)
362		MCFG_PALETTE_INIT_OVERRIDE(amiga_state,amiga)
	375	MCFG_PALETTE_INIT_OVERRIDE(mquake_state,amiga)
363	376
364		MCFG_VIDEO_START_OVERRIDE(amiga_state,amiga)
	377	MCFG_VIDEO_START_OVERRIDE(mquake_state,amiga)
365	378
366	379	/* sound hardware */
367	380	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
r21064	r21065
427	440	*
428	441	*************************************/
429	442
430		DRIVER_INIT_MEMBER(amiga_state,mquake)
	443	DRIVER_INIT_MEMBER(mquake_state,mquake)
431	444	{
432	445	static const amiga_machine_interface mquake_intf =
433	446	{
r21064	r21065
453	466	*
454	467	*************************************/
455	468
456		GAME( 1987, mquake, 0, mquake, mquake, amiga_state, mquake, 0, "Sente", "Moonquake", GAME_NOT_WORKING | GAME_NO_SOUND | GAME_IMPERFECT_GRAPHICS )
	469	GAME( 1987, mquake, 0, mquake, mquake, mquake_state, mquake, 0, "Sente", "Moonquake", GAME_NOT_WORKING | GAME_NO_SOUND | GAME_IMPERFECT_GRAPHICS )

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team