Previous

199869 Revisions

Next

r18038 Thursday 20th September, 2012 at 12:00:57 UTC by Miodrag Milanović
decocass modernized and cleaned (no whatsnew)

[src/mame]	mame.mak
[src/mame/drivers]	decocass.c
[src/mame/includes]	decocass.h*
[src/mame/machine]	decocass.c decocass.h decocass_tape.c* decocass_tape.h*
[src/mame/video]	decocass.c

trunk/src/mame/machine/decocass.h

r18037	r18038
1		#include "devlegcy.h"
2
3		#ifdef MAME_DEBUG
4		#define LOGLEVEL  5
5		#else
6		#define LOGLEVEL  0
7		#endif
8		#define LOG(n,x)  do { if (LOGLEVEL >= n) logerror x; } while (0)
9
10
11		class decocass_tape_device : public device_t
12		{
13		public:
14		decocass_tape_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
15		~decocass_tape_device() { global_free(m_token); }
16
17		// access to legacy token
18		void *token() const { assert(m_token != NULL); return m_token; }
19		protected:
20		// device-level overrides
21		virtual void device_config_complete();
22		virtual void device_start();
23		virtual void device_reset();
24		private:
25		// internal state
26		void *m_token;
27		};
28
29		extern const device_type DECOCASS_TAPE;
30
31
32		#define MCFG_DECOCASS_TAPE_ADD(_tag) \
33		MCFG_DEVICE_ADD(_tag, DECOCASS_TAPE, 0)
34
35
36
37
38		class decocass_state : public driver_device
39		{
40		public:
41		decocass_state(const machine_config &mconfig, device_type type, const char *tag)
42		: driver_device(mconfig, type, tag),
43		m_rambase(*this, "rambase"),
44		m_charram(*this, "charram"),
45		m_fgvideoram(*this, "fgvideoram"),
46		m_colorram(*this, "colorram"),
47		m_tileram(*this, "tileram"),
48		m_objectram(*this, "objectram"),
49		m_paletteram(*this, "paletteram") { }
50
51		/* memory pointers */
52		required_shared_ptr<UINT8> m_rambase;
53		required_shared_ptr<UINT8> m_charram;
54		required_shared_ptr<UINT8> m_fgvideoram;
55		required_shared_ptr<UINT8> m_colorram;
56		UINT8 *   m_bgvideoram;   /* shares bits D0-3 with tileram! */
57		required_shared_ptr<UINT8> m_tileram;
58		required_shared_ptr<UINT8> m_objectram;
59		required_shared_ptr<UINT8> m_paletteram;
60		size_t    m_bgvideoram_size;
61
62		/* video-related */
63		tilemap_t   *m_fg_tilemap;
64		tilemap_t   *m_bg_tilemap_l;
65		tilemap_t   *m_bg_tilemap_r;
66		INT32     m_watchdog_count;
67		INT32     m_watchdog_flip;
68		INT32     m_color_missiles;
69		INT32     m_color_center_bot;
70		INT32     m_mode_set;
71		INT32     m_back_h_shift;
72		INT32     m_back_vl_shift;
73		INT32     m_back_vr_shift;
74		INT32     m_part_h_shift;
75		INT32     m_part_v_shift;
76		INT32     m_center_h_shift_space;
77		INT32     m_center_v_shift;
78		rectangle m_bg_tilemap_l_clip;
79		rectangle m_bg_tilemap_r_clip;
80
81		/* sound-related */
82		UINT8     m_sound_ack;   /* sound latches, ACK status bits and NMI timer */
83		UINT8     m_audio_nmi_enabled;
84		UINT8     m_audio_nmi_state;
85
86		/* misc */
87		UINT8     *m_decrypted;
88		UINT8     *m_decrypted2;
89		INT32     m_firsttime;
90		UINT8     m_latch1;
91		UINT8     m_decocass_reset;
92		INT32     m_de0091_enable;   /* DE-0091xx daughter board enable */
93		UINT8     m_quadrature_decoder[4];   /* four inputs from the quadrature decoder (H1, V1, H2, V2) */
94		int       m_showmsg;      // for debugging purposes
95
96		/* i8041 */
97		UINT8     m_i8041_p1;
98		UINT8     m_i8041_p2;
99		int       m_i8041_p1_write_latch;
100		int       m_i8041_p1_read_latch;
101		int       m_i8041_p2_write_latch;
102		int       m_i8041_p2_read_latch;
103
104		/* dongles-related */
105		read8_space_func    m_dongle_r;
106		write8_space_func   m_dongle_w;
107
108		/* dongle type #1 */
109		UINT32    m_type1_inmap;
110		UINT32    m_type1_outmap;
111
112		/* dongle type #2: status of the latches */
113		INT32     m_type2_d2_latch;   /* latched 8041-STATUS D2 value */
114		INT32     m_type2_xx_latch;   /* latched value (D7-4 == 0xc0) ? 1 : 0 */
115		INT32     m_type2_promaddr;   /* latched PROM address A0-A7 */
116
117		/* dongle type #3: status and patches */
118		INT32     m_type3_ctrs;      /* 12 bit counter stage */
119		INT32     m_type3_d0_latch;   /* latched 8041-D0 value */
120		INT32     m_type3_pal_19;      /* latched 1 for PAL input pin-19 */
121		INT32     m_type3_swap;
122
123		/* dongle type #4: status */
124		INT32     m_type4_ctrs;      /* latched PROM address (E5x0 LSB, E5x1 MSB) */
125		INT32     m_type4_latch;      /* latched enable PROM (1100xxxx written to E5x1) */
126
127		/* dongle type #5: status */
128		INT32     m_type5_latch;      /* latched enable PROM (1100xxxx written to E5x1) */
129
130		/* DS Telejan */
131		UINT8     m_mux_data;
132
133		/* devices */
134		cpu_device *m_maincpu;
135		cpu_device *m_audiocpu;
136		device_t *m_mcu;
137		device_t *m_cassette;
138		DECLARE_DRIVER_INIT(decocass);
139		DECLARE_DRIVER_INIT(decocrom);
140		DECLARE_DRIVER_INIT(cdsteljn);
141		TILEMAP_MAPPER_MEMBER(fgvideoram_scan_cols);
142		TILEMAP_MAPPER_MEMBER(bgvideoram_scan_cols);
143		TILE_GET_INFO_MEMBER(get_bg_l_tile_info);
144		TILE_GET_INFO_MEMBER(get_bg_r_tile_info);
145		TILE_GET_INFO_MEMBER(get_fg_tile_info);
146		virtual void machine_start();
147		virtual void machine_reset();
148		virtual void video_start();
149		virtual void palette_init();
150		DECLARE_MACHINE_RESET(ctsttape);
151		DECLARE_MACHINE_RESET(cprogolfj);
152		DECLARE_MACHINE_RESET(cdsteljn);
153		DECLARE_MACHINE_RESET(cfishing);
154		DECLARE_MACHINE_RESET(chwy);
155		DECLARE_MACHINE_RESET(cterrani);
156		DECLARE_MACHINE_RESET(castfant);
157		DECLARE_MACHINE_RESET(csuperas);
158		DECLARE_MACHINE_RESET(clocknch);
159		DECLARE_MACHINE_RESET(cprogolf);
160		DECLARE_MACHINE_RESET(cluckypo);
161		DECLARE_MACHINE_RESET(ctisland);
162		DECLARE_MACHINE_RESET(cexplore);
163		DECLARE_MACHINE_RESET(cdiscon1);
164		DECLARE_MACHINE_RESET(ctornado);
165		DECLARE_MACHINE_RESET(cmissnx);
166		DECLARE_MACHINE_RESET(cptennis);
167		DECLARE_MACHINE_RESET(cbtime);
168		DECLARE_MACHINE_RESET(cburnrub);
169		DECLARE_MACHINE_RESET(cgraplop);
170		DECLARE_MACHINE_RESET(cgraplop2);
171		DECLARE_MACHINE_RESET(clapapa);
172		DECLARE_MACHINE_RESET(cskater);
173		DECLARE_MACHINE_RESET(cprobowl);
174		DECLARE_MACHINE_RESET(cnightst);
175		DECLARE_MACHINE_RESET(cpsoccer);
176		DECLARE_MACHINE_RESET(csdtenis);
177		DECLARE_MACHINE_RESET(czeroize);
178		DECLARE_MACHINE_RESET(cppicf);
179		DECLARE_MACHINE_RESET(cfghtice);
180		DECLARE_MACHINE_RESET(type4);
181		DECLARE_MACHINE_RESET(cbdash);
182		DECLARE_MACHINE_RESET(cflyball);
183		UINT32 screen_update_decocass(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
184		};
185
186
187
188		DECLARE_WRITE8_HANDLER( decocass_coin_counter_w );
189		DECLARE_WRITE8_HANDLER( decocass_sound_command_w );
190		DECLARE_READ8_HANDLER( decocass_sound_data_r );
191		DECLARE_READ8_HANDLER( decocass_sound_ack_r );
192		DECLARE_WRITE8_HANDLER( decocass_sound_data_w );
193		DECLARE_READ8_HANDLER( decocass_sound_command_r );
194		TIMER_DEVICE_CALLBACK( decocass_audio_nmi_gen );
195		DECLARE_WRITE8_HANDLER( decocass_sound_nmi_enable_w );
196		DECLARE_READ8_HANDLER( decocass_sound_nmi_enable_r );
197		DECLARE_READ8_HANDLER( decocass_sound_data_ack_reset_r );
198		DECLARE_WRITE8_HANDLER( decocass_sound_data_ack_reset_w );
199		DECLARE_WRITE8_HANDLER( decocass_nmi_reset_w );
200		DECLARE_WRITE8_HANDLER( decocass_quadrature_decoder_reset_w );
201		DECLARE_WRITE8_HANDLER( decocass_adc_w );
202		DECLARE_READ8_HANDLER( decocass_input_r );
203
204		DECLARE_WRITE8_HANDLER( decocass_reset_w );
205
206		DECLARE_READ8_HANDLER( decocass_e5xx_r );
207		DECLARE_WRITE8_HANDLER( decocass_e5xx_w );
208		DECLARE_WRITE8_HANDLER( decocass_de0091_w );
209		DECLARE_WRITE8_HANDLER( decocass_e900_w );
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247		DECLARE_WRITE8_HANDLER( i8041_p1_w );
248		DECLARE_READ8_HANDLER( i8041_p1_r );
249		DECLARE_WRITE8_HANDLER( i8041_p2_w );
250		DECLARE_READ8_HANDLER( i8041_p2_r );
251
252		void decocass_machine_state_save_init(running_machine &machine);
253
254
255		/*----------- defined in video/decocass.c -----------*/
256
257		DECLARE_WRITE8_HANDLER( decocass_paletteram_w );
258		DECLARE_WRITE8_HANDLER( decocass_charram_w );
259		DECLARE_WRITE8_HANDLER( decocass_fgvideoram_w );
260		DECLARE_WRITE8_HANDLER( decocass_colorram_w );
261		DECLARE_WRITE8_HANDLER( decocass_bgvideoram_w );
262		DECLARE_WRITE8_HANDLER( decocass_tileram_w );
263		DECLARE_WRITE8_HANDLER( decocass_objectram_w );
264
265		DECLARE_WRITE8_HANDLER( decocass_watchdog_count_w );
266		DECLARE_WRITE8_HANDLER( decocass_watchdog_flip_w );
267		DECLARE_WRITE8_HANDLER( decocass_color_missiles_w );
268		DECLARE_WRITE8_HANDLER( decocass_mode_set_w );
269		DECLARE_WRITE8_HANDLER( decocass_color_center_bot_w );
270		DECLARE_WRITE8_HANDLER( decocass_back_h_shift_w );
271		DECLARE_WRITE8_HANDLER( decocass_back_vl_shift_w );
272		DECLARE_WRITE8_HANDLER( decocass_back_vr_shift_w );
273		DECLARE_WRITE8_HANDLER( decocass_part_h_shift_w );
274		DECLARE_WRITE8_HANDLER( decocass_part_v_shift_w );
275		DECLARE_WRITE8_HANDLER( decocass_center_h_shift_space_w );
276		DECLARE_WRITE8_HANDLER( decocass_center_v_shift_w );
277
278
279
280
281		void decocass_video_state_save_init(running_machine &machine);

trunk/src/mame/machine/decocass.c

r18037	r18038
7	7	#include "emu.h"
8	8	#include "cpu/m6502/m6502.h"
9	9	#include "cpu/mcs48/mcs48.h"
10		#include "machine/decocass.h"
	10	#include "includes/decocass.h"
	11	#include "machine/decocass_tape.h"
11	12
12		#define LOG_CASSETTE_STATE      0
13
14	13	/* dongle type #1: jumpers C and D assignments */
15	14	#define MAKE_MAP(m0,m1,m2,m3,m4,m5,m6,m7)   \
16	15	((UINT32)(m0)) | \
r18037	r18038
47	46	};
48	47
49	48
50
51		static UINT8 tape_get_status_bits(device_t *device);
52		static UINT8 tape_is_present(device_t *device);
53		static void tape_change_speed(device_t *device, INT8 newspeed);
54
55
56		WRITE8_HANDLER( decocass_coin_counter_w )
	49	WRITE8_MEMBER(decocass_state::decocass_coin_counter_w)
57	50	{
58	51	}
59	52
60		WRITE8_HANDLER( decocass_sound_command_w )
	53	WRITE8_MEMBER(decocass_state::decocass_sound_command_w)
61	54	{
62		decocass_state *state = space.machine().driver_data<decocass_state>();
63	55	LOG(2,("CPU %s sound command -> $%02x\n", space.device().tag(), data));
64		state->soundlatch_byte_w(space, 0, data);
65		state->m_sound_ack |= 0x80;
	56	soundlatch_byte_w(space, 0, data);
	57	m_sound_ack |= 0x80;
66	58	/* remove snd cpu data ack bit. i don't see it in the schems, but... */
67		state->m_sound_ack &= ~0x40;
68		state->m_audiocpu->set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
	59	m_sound_ack &= ~0x40;
	60	m_audiocpu->set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
69	61	}
70	62
71		READ8_HANDLER( decocass_sound_data_r )
	63	READ8_MEMBER(decocass_state::decocass_sound_data_r)
72	64	{
73		decocass_state *state = space.machine().driver_data<decocass_state>();
74		UINT8 data = state->soundlatch2_byte_r(space, 0);
	65	UINT8 data = soundlatch2_byte_r(space, 0);
75	66	LOG(2,("CPU %s sound data    <- $%02x\n", space.device().tag(), data));
76	67	return data;
77	68	}
78	69
79		READ8_HANDLER( decocass_sound_ack_r )
	70	READ8_MEMBER(decocass_state::decocass_sound_ack_r)
80	71	{
81		decocass_state *state = space.machine().driver_data<decocass_state>();
82		UINT8 data = state->m_sound_ack;   /* D6+D7 */
	72	UINT8 data = m_sound_ack;   /* D6+D7 */
83	73	LOG(4,("CPU %s sound ack     <- $%02x\n", space.device().tag(), data));
84	74	return data;
85	75	}
86	76
87		WRITE8_HANDLER( decocass_sound_data_w )
	77	WRITE8_MEMBER(decocass_state::decocass_sound_data_w)
88	78	{
89		decocass_state *state = space.machine().driver_data<decocass_state>();
90	79	LOG(2,("CPU %s sound data    -> $%02x\n", space.device().tag(), data));
91		state->soundlatch2_byte_w(space, 0, data);
92		state->m_sound_ack |= 0x40;
	80	soundlatch2_byte_w(space, 0, data);
	81	m_sound_ack |= 0x40;
93	82	}
94	83
95		READ8_HANDLER( decocass_sound_command_r )
	84	READ8_MEMBER(decocass_state::decocass_sound_command_r)
96	85	{
97		decocass_state *state = space.machine().driver_data<decocass_state>();
98		UINT8 data = state->soundlatch_byte_r(space, 0);
	86	UINT8 data = soundlatch_byte_r(space, 0);
99	87	LOG(4,("CPU %s sound command <- $%02x\n", space.device().tag(), data));
100		state->m_audiocpu->set_input_line(M6502_IRQ_LINE, CLEAR_LINE);
101		state->m_sound_ack &= ~0x80;
	88	m_audiocpu->set_input_line(M6502_IRQ_LINE, CLEAR_LINE);
	89	m_sound_ack &= ~0x80;
102	90	return data;
103	91	}
104	92
r18037	r18038
110	98	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
111	99	}
112	100
113		WRITE8_HANDLER( decocass_sound_nmi_enable_w )
	101	WRITE8_MEMBER(decocass_state::decocass_sound_nmi_enable_w)
114	102	{
115		decocass_state *state = space.machine().driver_data<decocass_state>();
116		state->m_audio_nmi_enabled = 1;
117		state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	103	m_audio_nmi_enabled = 1;
	104	m_audiocpu->set_input_line(INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
118	105	}
119	106
120		READ8_HANDLER( decocass_sound_nmi_enable_r )
	107	READ8_MEMBER(decocass_state::decocass_sound_nmi_enable_r)
121	108	{
122		decocass_state *state = space.machine().driver_data<decocass_state>();
123		state->m_audio_nmi_enabled = 1;
124		state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	109	m_audio_nmi_enabled = 1;
	110	m_audiocpu->set_input_line(INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
125	111	return 0xff;
126	112	}
127	113
128		READ8_HANDLER( decocass_sound_data_ack_reset_r )
	114	READ8_MEMBER(decocass_state::decocass_sound_data_ack_reset_r)
129	115	{
130		decocass_state *state = space.machine().driver_data<decocass_state>();
131	116	UINT8 data = 0xff;
132	117	LOG(2,("CPU %s sound ack rst <- $%02x\n", space.device().tag(), data));
133		state->m_sound_ack &= ~0x40;
	118	m_sound_ack &= ~0x40;
134	119	return data;
135	120	}
136	121
137		WRITE8_HANDLER( decocass_sound_data_ack_reset_w )
	122	WRITE8_MEMBER(decocass_state::decocass_sound_data_ack_reset_w)
138	123	{
139		decocass_state *state = space.machine().driver_data<decocass_state>();
140	124	LOG(2,("CPU %s sound ack rst -> $%02x\n", space.device().tag(), data));
141		state->m_sound_ack &= ~0x40;
	125	m_sound_ack &= ~0x40;
142	126	}
143	127
144		WRITE8_HANDLER( decocass_nmi_reset_w )
	128	WRITE8_MEMBER(decocass_state::decocass_nmi_reset_w)
145	129	{
146		decocass_state *state = space.machine().driver_data<decocass_state>();
147		state->m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE );
	130	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE );
148	131	}
149	132
150		WRITE8_HANDLER( decocass_quadrature_decoder_reset_w )
	133	WRITE8_MEMBER(decocass_state::decocass_quadrature_decoder_reset_w)
151	134	{
152		decocass_state *state = space.machine().driver_data<decocass_state>();
153	135
154	136	/* just latch the analog controls here */
155		state->m_quadrature_decoder[0] = state->ioport("AN0")->read();
156		state->m_quadrature_decoder[1] = state->ioport("AN1")->read();
157		state->m_quadrature_decoder[2] = state->ioport("AN2")->read();
158		state->m_quadrature_decoder[3] = state->ioport("AN3")->read();
	137	m_quadrature_decoder[0] = ioport("AN0")->read();
	138	m_quadrature_decoder[1] = ioport("AN1")->read();
	139	m_quadrature_decoder[2] = ioport("AN2")->read();
	140	m_quadrature_decoder[3] = ioport("AN3")->read();
159	141	}
160	142
161		WRITE8_HANDLER( decocass_adc_w )
	143	WRITE8_MEMBER(decocass_state::decocass_adc_w)
162	144	{
163	145	}
164	146
r18037	r18038
172	154	* E6x6    ""
173	155	* E6x7    a/d converter read
174	156	*/
175		READ8_HANDLER( decocass_input_r )
	157	READ8_MEMBER(decocass_state::decocass_input_r)
176	158	{
177		decocass_state *state = space.machine().driver_data<decocass_state>();
178	159	UINT8 data = 0xff;
179	160	static const char *const portnames[] = { "IN0", "IN1", "IN2" };
180	161
r18037	r18038
184	165	data = space.machine().root_device().ioport(portnames[offset & 7])->read();
185	166	break;
186	167	case 3: case 4: case 5: case 6:
187		data = state->m_quadrature_decoder[(offset & 7) - 3];
	168	data = m_quadrature_decoder[(offset & 7) - 3];
188	169	break;
189	170	default:
190	171	break;
r18037	r18038
207	188	#define E5XX_MASK   0x02   /* use 0x0e for old style board */
208	189
209	190
210		WRITE8_HANDLER( decocass_reset_w )
	191	WRITE8_MEMBER(decocass_state::decocass_reset_w)
211	192	{
212		decocass_state *state = space.machine().driver_data<decocass_state>();
213	193	LOG(1,("%10s 6502-PC: %04x decocass_reset_w(%02x): $%02x\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
214		state->m_decocass_reset = data;
	194	m_decocass_reset = data;
215	195
216	196	/* CPU #1 active high reset */
217		state->m_audiocpu->set_input_line(INPUT_LINE_RESET, data & 0x01);
	197	m_audiocpu->set_input_line(INPUT_LINE_RESET, data & 0x01);
218	198
219	199	/* on reset also disable audio NMI */
220	200	if (data & 1)
221	201	{
222		state->m_audio_nmi_enabled = 0;
223		state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	202	m_audio_nmi_enabled = 0;
	203	m_audiocpu->set_input_line(INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
224	204	}
225	205
226	206	/* 8041 active low reset */
227		state->m_mcu->execute().set_input_line(INPUT_LINE_RESET, (data & 0x08) ? ASSERT_LINE : CLEAR_LINE);
	207	m_mcu->set_input_line(INPUT_LINE_RESET, (data & 0x08) ? ASSERT_LINE : CLEAR_LINE);
228	208	}
229	209
230	210
r18037	r18038
233	213	{
234	214	decocass_state *state = machine.driver_data<decocass_state>();
235	215	/* 8041ENA/ and is this a FNO write (function number)? */
236		if (0 == (state->m_i8041_p2 & 0x01))
	216	if (0 == (m_i8041_p2 & 0x01))
237	217	{
238	218	switch (data)
239	219	{
r18037	r18038
275	255	*
276	256	***************************************************************************/
277	257
278		static READ8_HANDLER( decocass_type1_latch_26_pass_3_inv_2_r )
	258	READ8_MEMBER(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r)
279	259	{
280		decocass_state *state = space.machine().driver_data<decocass_state>();
281	260	UINT8 data;
282	261
283	262	if (1 == (offset & 1))
284	263	{
285	264	if (0 == (offset & E5XX_MASK))
286		data = upi41_master_r(state->m_mcu, 1);
	265	data = upi41_master_r(m_mcu, 1);
287	266	else
288	267	data = 0xff;
289	268
r18037	r18038
299	278	UINT8 save;
300	279	UINT8 *prom = space.machine().root_device().memregion("dongle")->base();
301	280
302		if (state->m_firsttime)
	281	if (m_firsttime)
303	282	{
304	283	LOG(3,("prom data:\n"));
305	284	for (promaddr = 0; promaddr < 32; promaddr++)
r18037	r18038
308	287	LOG(3,("  %02x:", promaddr));
309	288	LOG(3,(" %02x%s", prom[promaddr], (promaddr % 8) == 7 ? "\n" : ""));
310	289	}
311		state->m_firsttime = 0;
312		state->m_latch1 = 0;    /* reset latch (??) */
	290	m_firsttime = 0;
	291	m_latch1 = 0;    /* reset latch (??) */
313	292	}
314	293
315	294	if (0 == (offset & E5XX_MASK))
316		data = upi41_master_r(state->m_mcu, 0);
	295	data = upi41_master_r(m_mcu, 0);
317	296	else
318	297	data = 0xff;
319	298
320	299	save = data;   /* save the unmodifed data for the latch */
321	300
322	301	promaddr =
323		(((data >> MAP0(state->m_type1_inmap)) & 1) << 0) |
324		(((data >> MAP1(state->m_type1_inmap)) & 1) << 1) |
325		(((data >> MAP4(state->m_type1_inmap)) & 1) << 2) |
326		(((data >> MAP5(state->m_type1_inmap)) & 1) << 3) |
327		(((data >> MAP7(state->m_type1_inmap)) & 1) << 4);
	302	(((data >> MAP0(m_type1_inmap)) & 1) << 0) |
	303	(((data >> MAP1(m_type1_inmap)) & 1) << 1) |
	304	(((data >> MAP4(m_type1_inmap)) & 1) << 2) |
	305	(((data >> MAP5(m_type1_inmap)) & 1) << 3) |
	306	(((data >> MAP7(m_type1_inmap)) & 1) << 4);
328	307	/* latch bits 2 and 6, pass bit 3, invert bit 2 */
329	308	data =
330		(((prom[promaddr] >> 0) & 1)            << MAP0(state->m_type1_outmap)) |
331		(((prom[promaddr] >> 1) & 1)            << MAP1(state->m_type1_outmap)) |
332		((1 - ((state->m_latch1 >> MAP2(state->m_type1_inmap)) & 1)) << MAP2(state->m_type1_outmap)) |
333		(((data >> MAP3(state->m_type1_inmap)) & 1)         << MAP3(state->m_type1_outmap)) |
334		(((prom[promaddr] >> 2) & 1)            << MAP4(state->m_type1_outmap)) |
335		(((prom[promaddr] >> 3) & 1)            << MAP5(state->m_type1_outmap)) |
336		(((state->m_latch1 >> MAP6(state->m_type1_inmap)) & 1)      << MAP6(state->m_type1_outmap)) |
337		(((prom[promaddr] >> 4) & 1)            << MAP7(state->m_type1_outmap));
	309	(((prom[promaddr] >> 0) & 1)            << MAP0(m_type1_outmap)) |
	310	(((prom[promaddr] >> 1) & 1)            << MAP1(m_type1_outmap)) |
	311	((1 - ((m_latch1 >> MAP2(m_type1_inmap)) & 1)) << MAP2(m_type1_outmap)) |
	312	(((data >> MAP3(m_type1_inmap)) & 1)         << MAP3(m_type1_outmap)) |
	313	(((prom[promaddr] >> 2) & 1)            << MAP4(m_type1_outmap)) |
	314	(((prom[promaddr] >> 3) & 1)            << MAP5(m_type1_outmap)) |
	315	(((m_latch1 >> MAP6(m_type1_inmap)) & 1)      << MAP6(m_type1_outmap)) |
	316	(((prom[promaddr] >> 4) & 1)            << MAP7(m_type1_outmap));
338	317
339	318	LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_26_pass_3_inv_2_r(%02x): $%02x\n",
340	319	space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
341	320
342		state->m_latch1 = save;      /* latch the data for the next A0 == 0 read */
	321	m_latch1 = save;      /* latch the data for the next A0 == 0 read */
343	322	}
344	323	return data;
345	324	}
r18037	r18038
355	334	*
356	335	***************************************************************************/
357	336
358		static READ8_HANDLER( decocass_type1_pass_136_r )
	337	READ8_MEMBER(decocass_state::decocass_type1_pass_136_r)
359	338	{
360		decocass_state *state = space.machine().driver_data<decocass_state>();
361	339	UINT8 data;
362	340
363	341	if (1 == (offset & 1))
364	342	{
365	343	if (0 == (offset & E5XX_MASK))
366		data = upi41_master_r(state->m_mcu, 1);
	344	data = upi41_master_r(m_mcu, 1);
367	345	else
368	346	data = 0xff;
369	347
r18037	r18038
379	357	UINT8 save;
380	358	UINT8 *prom = space.machine().root_device().memregion("dongle")->base();
381	359
382		if (state->m_firsttime)
	360	if (m_firsttime)
383	361	{
384	362	LOG(3,("prom data:\n"));
385	363	for (promaddr = 0; promaddr < 32; promaddr++)
r18037	r18038
388	366	LOG(3,("  %02x:", promaddr));
389	367	LOG(3,(" %02x%s", prom[promaddr], (promaddr % 8) == 7 ? "\n" : ""));
390	368	}
391		state->m_firsttime = 0;
392		state->m_latch1 = 0;    /* reset latch (??) */
	369	m_firsttime = 0;
	370	m_latch1 = 0;    /* reset latch (??) */
393	371	}
394	372
395	373	if (0 == (offset & E5XX_MASK))
396		data = upi41_master_r(state->m_mcu, 0);
	374	data = upi41_master_r(m_mcu, 0);
397	375	else
398	376	data = 0xff;
399	377
400	378	save = data;   /* save the unmodifed data for the latch */
401	379
402	380	promaddr =
403		(((data >> MAP0(state->m_type1_inmap)) & 1) << 0) |
404		(((data >> MAP2(state->m_type1_inmap)) & 1) << 1) |
405		(((data >> MAP4(state->m_type1_inmap)) & 1) << 2) |
406		(((data >> MAP5(state->m_type1_inmap)) & 1) << 3) |
407		(((data >> MAP7(state->m_type1_inmap)) & 1) << 4);
	381	(((data >> MAP0(m_type1_inmap)) & 1) << 0) |
	382	(((data >> MAP2(m_type1_inmap)) & 1) << 1) |
	383	(((data >> MAP4(m_type1_inmap)) & 1) << 2) |
	384	(((data >> MAP5(m_type1_inmap)) & 1) << 3) |
	385	(((data >> MAP7(m_type1_inmap)) & 1) << 4);
408	386	/* latch bits 1 and 6, pass bit 3, invert bit 1 */
409	387	data =
410		(((prom[promaddr] >> 0) & 1)            << MAP0(state->m_type1_outmap)) |
411		(((data >> MAP1(state->m_type1_inmap)) & 1)         << MAP1(state->m_type1_outmap)) |
412		(((prom[promaddr] >> 1) & 1)            << MAP2(state->m_type1_outmap)) |
413		(((data >> MAP3(state->m_type1_inmap)) & 1)         << MAP3(state->m_type1_outmap)) |
414		(((prom[promaddr] >> 2) & 1)            << MAP4(state->m_type1_outmap)) |
415		(((prom[promaddr] >> 3) & 1)            << MAP5(state->m_type1_outmap)) |
416		(((data >> MAP6(state->m_type1_inmap)) & 1)          << MAP6(state->m_type1_outmap)) |
417		(((prom[promaddr] >> 4) & 1)            << MAP7(state->m_type1_outmap));
	388	(((prom[promaddr] >> 0) & 1)            << MAP0(m_type1_outmap)) |
	389	(((data >> MAP1(m_type1_inmap)) & 1)         << MAP1(m_type1_outmap)) |
	390	(((prom[promaddr] >> 1) & 1)            << MAP2(m_type1_outmap)) |
	391	(((data >> MAP3(m_type1_inmap)) & 1)         << MAP3(m_type1_outmap)) |
	392	(((prom[promaddr] >> 2) & 1)            << MAP4(m_type1_outmap)) |
	393	(((prom[promaddr] >> 3) & 1)            << MAP5(m_type1_outmap)) |
	394	(((data >> MAP6(m_type1_inmap)) & 1)          << MAP6(m_type1_outmap)) |
	395	(((prom[promaddr] >> 4) & 1)            << MAP7(m_type1_outmap));
418	396
419	397	LOG(3,("%10s 6502-PC: %04x decocass_type1_pass_136_r(%02x): $%02x\n",
420	398	space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
421	399
422		state->m_latch1 = save;      /* latch the data for the next A0 == 0 read */
	400	m_latch1 = save;      /* latch the data for the next A0 == 0 read */
423	401	}
424	402	return data;
425	403	}
r18037	r18038
435	413	*
436	414	***************************************************************************/
437	415
438		static READ8_HANDLER( decocass_type1_latch_27_pass_3_inv_2_r )
	416	READ8_MEMBER(decocass_state::decocass_type1_latch_27_pass_3_inv_2_r)
439	417	{
440		decocass_state *state = space.machine().driver_data<decocass_state>();
441	418	UINT8 data;
442	419
443	420	if (1 == (offset & 1))
444	421	{
445	422	if (0 == (offset & E5XX_MASK))
446		data = upi41_master_r(state->m_mcu, 1);
	423	data = upi41_master_r(m_mcu, 1);
447	424	else
448	425	data = 0xff;
449	426
r18037	r18038
459	436	UINT8 save;
460	437	UINT8 *prom = space.machine().root_device().memregion("dongle")->base();
461	438
462		if (state->m_firsttime)
	439	if (m_firsttime)
463	440	{
464	441	LOG(3,("prom data:\n"));
465	442	for (promaddr = 0; promaddr < 32; promaddr++)
r18037	r18038
468	445	LOG(3,("  %02x:", promaddr));
469	446	LOG(3,(" %02x%s", prom[promaddr], (promaddr % 8) == 7 ? "\n" : ""));
470	447	}
471		state->m_firsttime = 0;
472		state->m_latch1 = 0;    /* reset latch (??) */
	448	m_firsttime = 0;
	449	m_latch1 = 0;    /* reset latch (??) */
473	450	}
474	451
475	452	if (0 == (offset & E5XX_MASK))
476		data = upi41_master_r(state->m_mcu, 0);
	453	data = upi41_master_r(m_mcu, 0);
477	454	else
478	455	data = 0xff;
479	456
480	457	save = data;   /* save the unmodifed data for the latch */
481	458
482	459	promaddr =
483		(((data >> MAP0(state->m_type1_inmap)) & 1) << 0) |
484		(((data >> MAP1(state->m_type1_inmap)) & 1) << 1) |
485		(((data >> MAP4(state->m_type1_inmap)) & 1) << 2) |
486		(((data >> MAP5(state->m_type1_inmap)) & 1) << 3) |
487		(((data >> MAP6(state->m_type1_inmap)) & 1) << 4);
	460	(((data >> MAP0(m_type1_inmap)) & 1) << 0) |
	461	(((data >> MAP1(m_type1_inmap)) & 1) << 1) |
	462	(((data >> MAP4(m_type1_inmap)) & 1) << 2) |
	463	(((data >> MAP5(m_type1_inmap)) & 1) << 3) |
	464	(((data >> MAP6(m_type1_inmap)) & 1) << 4);
488	465	/* latch bits 2 and 7, pass bit 3, invert bit 2 */
489	466	data =
490		(((prom[promaddr] >> 0) & 1)            << MAP0(state->m_type1_outmap)) |
491		(((prom[promaddr] >> 1) & 1)            << MAP1(state->m_type1_outmap)) |
492		((1 - ((state->m_latch1 >> MAP2(state->m_type1_inmap)) & 1)) << MAP2(state->m_type1_outmap)) |
493		(((data >> MAP3(state->m_type1_inmap)) & 1)         << MAP3(state->m_type1_outmap)) |
494		(((prom[promaddr] >> 2) & 1)            << MAP4(state->m_type1_outmap)) |
495		(((prom[promaddr] >> 3) & 1)            << MAP5(state->m_type1_outmap)) |
496		(((prom[promaddr] >> 4) & 1)            << MAP6(state->m_type1_outmap)) |
497		(((state->m_latch1 >> MAP7(state->m_type1_inmap)) & 1)      << MAP7(state->m_type1_outmap));
	467	(((prom[promaddr] >> 0) & 1)            << MAP0(m_type1_outmap)) |
	468	(((prom[promaddr] >> 1) & 1)            << MAP1(m_type1_outmap)) |
	469	((1 - ((m_latch1 >> MAP2(m_type1_inmap)) & 1)) << MAP2(m_type1_outmap)) |
	470	(((data >> MAP3(m_type1_inmap)) & 1)         << MAP3(m_type1_outmap)) |
	471	(((prom[promaddr] >> 2) & 1)            << MAP4(m_type1_outmap)) |
	472	(((prom[promaddr] >> 3) & 1)            << MAP5(m_type1_outmap)) |
	473	(((prom[promaddr] >> 4) & 1)            << MAP6(m_type1_outmap)) |
	474	(((m_latch1 >> MAP7(m_type1_inmap)) & 1)      << MAP7(m_type1_outmap));
498	475
499	476	LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_27_pass_3_inv_2_r(%02x): $%02x\n",
500	477	space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
501	478
502		state->m_latch1 = save;      /* latch the data for the next A0 == 0 read */
	479	m_latch1 = save;      /* latch the data for the next A0 == 0 read */
503	480	}
504	481	return data;
505	482	}
r18037	r18038
515	492	*
516	493	***************************************************************************/
517	494
518		static READ8_HANDLER( decocass_type1_latch_26_pass_5_inv_2_r )
	495	READ8_MEMBER(decocass_state::decocass_type1_latch_26_pass_5_inv_2_r)
519	496	{
520		decocass_state *state = space.machine().driver_data<decocass_state>();
521	497	UINT8 data;
522	498
523	499	if (1 == (offset & 1))
524	500	{
525	501	if (0 == (offset & E5XX_MASK))
526		data = upi41_master_r(state->m_mcu, 1);
	502	data = upi41_master_r(m_mcu, 1);
527	503	else
528	504	data = 0xff;
529	505
r18037	r18038
539	515	UINT8 save;
540	516	UINT8 *prom = space.machine().root_device().memregion("dongle")->base();
541	517
542		if (state->m_firsttime)
	518	if (m_firsttime)
543	519	{
544	520	LOG(3,("prom data:\n"));
545	521	for (promaddr = 0; promaddr < 32; promaddr++)
r18037	r18038
548	524	LOG(3,("  %02x:", promaddr));
549	525	LOG(3,(" %02x%s", prom[promaddr], (promaddr % 8) == 7 ? "\n" : ""));
550	526	}
551		state->m_firsttime = 0;
552		state->m_latch1 = 0;    /* reset latch (??) */
	527	m_firsttime = 0;
	528	m_latch1 = 0;    /* reset latch (??) */
553	529	}
554	530
555	531	if (0 == (offset & E5XX_MASK))
556		data = upi41_master_r(state->m_mcu, 0);
	532	data = upi41_master_r(m_mcu, 0);
557	533	else
558	534	data = 0xff;
559	535
560	536	save = data;   /* save the unmodifed data for the latch */
561	537
562	538	promaddr =
563		(((data >> MAP0(state->m_type1_inmap)) & 1) << 0) |
564		(((data >> MAP1(state->m_type1_inmap)) & 1) << 1) |
565		(((data >> MAP3(state->m_type1_inmap)) & 1) << 2) |
566		(((data >> MAP4(state->m_type1_inmap)) & 1) << 3) |
567		(((data >> MAP7(state->m_type1_inmap)) & 1) << 4);
	539	(((data >> MAP0(m_type1_inmap)) & 1) << 0) |
	540	(((data >> MAP1(m_type1_inmap)) & 1) << 1) |
	541	(((data >> MAP3(m_type1_inmap)) & 1) << 2) |
	542	(((data >> MAP4(m_type1_inmap)) & 1) << 3) |
	543	(((data >> MAP7(m_type1_inmap)) & 1) << 4);
568	544	/* latch bits 2 and 6, pass bit 5, invert bit 2 */
569	545	data =
570		(((prom[promaddr] >> 0) & 1)            << MAP0(state->m_type1_outmap)) |
571		(((prom[promaddr] >> 1) & 1)            << MAP1(state->m_type1_outmap)) |
572		((1 - ((state->m_latch1 >> MAP2(state->m_type1_inmap)) & 1)) << MAP2(state->m_type1_outmap)) |
573		(((prom[promaddr] >> 2) & 1)            << MAP3(state->m_type1_outmap)) |
574		(((prom[promaddr] >> 3) & 1)            << MAP4(state->m_type1_outmap)) |
575		(((data >> MAP5(state->m_type1_inmap)) & 1)         << MAP5(state->m_type1_outmap)) |
576		(((state->m_latch1 >> MAP6(state->m_type1_inmap)) & 1)         << MAP6(state->m_type1_outmap)) |
577		(((prom[promaddr] >> 4) & 1)            << MAP7(state->m_type1_outmap));
	546	(((prom[promaddr] >> 0) & 1)            << MAP0(m_type1_outmap)) |
	547	(((prom[promaddr] >> 1) & 1)            << MAP1(m_type1_outmap)) |
	548	((1 - ((m_latch1 >> MAP2(m_type1_inmap)) & 1)) << MAP2(m_type1_outmap)) |
	549	(((prom[promaddr] >> 2) & 1)            << MAP3(m_type1_outmap)) |
	550	(((prom[promaddr] >> 3) & 1)            << MAP4(m_type1_outmap)) |
	551	(((data >> MAP5(m_type1_inmap)) & 1)         << MAP5(m_type1_outmap)) |
	552	(((m_latch1 >> MAP6(m_type1_inmap)) & 1)         << MAP6(m_type1_outmap)) |
	553	(((prom[promaddr] >> 4) & 1)            << MAP7(m_type1_outmap));
578	554
579	555	LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_26_pass_5_inv_2_r(%02x): $%02x\n",
580	556	space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
581	557
582		state->m_latch1 = save;      /* latch the data for the next A0 == 0 read */
	558	m_latch1 = save;      /* latch the data for the next A0 == 0 read */
583	559	}
584	560	return data;
585	561	}
r18037	r18038
597	573	*
598	574	***************************************************************************/
599	575
600		static READ8_HANDLER( decocass_type1_latch_16_pass_3_inv_1_r )
	576	READ8_MEMBER(decocass_state::decocass_type1_latch_16_pass_3_inv_1_r)
601	577	{
602		decocass_state *state = space.machine().driver_data<decocass_state>();
603	578	UINT8 data;
604	579
605	580	if (1 == (offset & 1))
606	581	{
607	582	if (0 == (offset & E5XX_MASK))
608		data = upi41_master_r(state->m_mcu, 1);
	583	data = upi41_master_r(m_mcu, 1);
609	584	else
610	585	data = 0xff;
611	586
r18037	r18038
621	596	UINT8 save;
622	597	UINT8 *prom = space.machine().root_device().memregion("dongle")->base();
623	598
624		if (state->m_firsttime)
	599	if (m_firsttime)
625	600	{
626	601	LOG(3,("prom data:\n"));
627	602	for (promaddr = 0; promaddr < 32; promaddr++)
r18037	r18038
630	605	LOG(3,("  %02x:", promaddr));
631	606	LOG(3,(" %02x%s", prom[promaddr], (promaddr % 8) == 7 ? "\n" : ""));
632	607	}
633		state->m_firsttime = 0;
634		state->m_latch1 = 0;    /* reset latch (??) */
	608	m_firsttime = 0;
	609	m_latch1 = 0;    /* reset latch (??) */
635	610	}
636	611
637	612	if (0 == (offset & E5XX_MASK))
638		data = upi41_master_r(state->m_mcu, 0);
	613	data = upi41_master_r(m_mcu, 0);
639	614	else
640	615	data = 0xff;
641	616
642	617	save = data;   /* save the unmodifed data for the latch */
643	618
644	619	promaddr =
645		(((data >> MAP0(state->m_type1_inmap)) & 1) << 0) |
646		(((data >> MAP2(state->m_type1_inmap)) & 1) << 1) |
647		(((data >> MAP4(state->m_type1_inmap)) & 1) << 2) |
648		(((data >> MAP5(state->m_type1_inmap)) & 1) << 3) |
649		(((data >> MAP7(state->m_type1_inmap)) & 1) << 4);
	620	(((data >> MAP0(m_type1_inmap)) & 1) << 0) |
	621	(((data >> MAP2(m_type1_inmap)) & 1) << 1) |
	622	(((data >> MAP4(m_type1_inmap)) & 1) << 2) |
	623	(((data >> MAP5(m_type1_inmap)) & 1) << 3) |
	624	(((data >> MAP7(m_type1_inmap)) & 1) << 4);
650	625	/* latch bits 1 and 6, pass bit 3, invert bit 1 */
651	626	data =
652		(((prom[promaddr] >> 0) & 1)            << MAP0(state->m_type1_outmap)) |
653		((1 - ((state->m_latch1 >> MAP1(state->m_type1_inmap)) & 1)) << MAP1(state->m_type1_outmap)) |
654		(((prom[promaddr] >> 1) & 1)            << MAP2(state->m_type1_outmap)) |
655		(((data >> MAP3(state->m_type1_inmap)) & 1)         << MAP3(state->m_type1_outmap)) |
656		(((prom[promaddr] >> 2) & 1)            << MAP4(state->m_type1_outmap)) |
657		(((prom[promaddr] >> 3) & 1)            << MAP5(state->m_type1_outmap)) |
658		(((state->m_latch1 >> MAP6(state->m_type1_inmap)) & 1)      << MAP6(state->m_type1_outmap)) |
659		(((prom[promaddr] >> 4) & 1)            << MAP7(state->m_type1_outmap));
	627	(((prom[promaddr] >> 0) & 1)            << MAP0(m_type1_outmap)) |
	628	((1 - ((m_latch1 >> MAP1(m_type1_inmap)) & 1)) << MAP1(m_type1_outmap)) |
	629	(((prom[promaddr] >> 1) & 1)            << MAP2(m_type1_outmap)) |
	630	(((data >> MAP3(m_type1_inmap)) & 1)         << MAP3(m_type1_outmap)) |
	631	(((prom[promaddr] >> 2) & 1)            << MAP4(m_type1_outmap)) |
	632	(((prom[promaddr] >> 3) & 1)            << MAP5(m_type1_outmap)) |
	633	(((m_latch1 >> MAP6(m_type1_inmap)) & 1)      << MAP6(m_type1_outmap)) |
	634	(((prom[promaddr] >> 4) & 1)            << MAP7(m_type1_outmap));
660	635
661	636	LOG(3,("%10s 6502-PC: %04x decocass_type1_latch_16_pass_3_inv_1_r(%02x): $%02x\n",
662	637	space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
663	638
664		state->m_latch1 = save;      /* latch the data for the next A0 == 0 read */
	639	m_latch1 = save;      /* latch the data for the next A0 == 0 read */
665	640	}
666	641	return data;
667	642	}
r18037	r18038
678	653	*  - Pro Tennis
679	654	*
680	655	***************************************************************************/
681		static READ8_HANDLER( decocass_type2_r )
	656	READ8_MEMBER(decocass_state::decocass_type2_r)
682	657	{
683		decocass_state *state = space.machine().driver_data<decocass_state>();
684	658	UINT8 data;
685	659
686		if (1 == state->m_type2_xx_latch)
	660	if (1 == m_type2_xx_latch)
687	661	{
688	662	if (1 == (offset & 1))
689	663	{
690		UINT8 *prom = state->memregion("dongle")->base();
691		data = prom[256 * state->m_type2_d2_latch + state->m_type2_promaddr];
692		LOG(3,("%10s 6502-PC: %04x decocass_type2_r(%02x): $%02x <- prom[%03x]\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, 256 * state->m_type2_d2_latch + state->m_type2_promaddr));
	664	UINT8 *prom = memregion("dongle")->base();
	665	data = prom[256 * m_type2_d2_latch + m_type2_promaddr];
	666	LOG(3,("%10s 6502-PC: %04x decocass_type2_r(%02x): $%02x <- prom[%03x]\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, 256 * m_type2_d2_latch + m_type2_promaddr));
693	667	}
694	668	else
695	669	{
r18037	r18038
699	673	else
700	674	{
701	675	if (0 == (offset & E5XX_MASK))
702		data = upi41_master_r(state->m_mcu, offset);
	676	data = upi41_master_r(m_mcu, offset);
703	677	else
704	678	data = offset & 0xff;
705	679
r18037	r18038
708	682	return data;
709	683	}
710	684
711		static WRITE8_HANDLER( decocass_type2_w )
	685	WRITE8_MEMBER(decocass_state::decocass_type2_w)
712	686	{
713		decocass_state *state = space.machine().driver_data<decocass_state>();
714		if (1 == state->m_type2_xx_latch)
	687	if (1 == m_type2_xx_latch)
715	688	{
716	689	if (1 == (offset & 1))
717	690	{
r18037	r18038
719	692	}
720	693	else
721	694	{
722		state->m_type2_promaddr = data;
723		LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> set PROM addr $%02x\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, state->m_type2_promaddr));
	695	m_type2_promaddr = data;
	696	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> set PROM addr $%02x\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, m_type2_promaddr));
724	697	return;
725	698	}
726	699	}
r18037	r18038
732	705	{
733	706	if (0xc0 == (data & 0xf0))
734	707	{
735		state->m_type2_xx_latch = 1;
736		state->m_type2_d2_latch = (data & 0x04) ? 1 : 0;
737		LOG(3,("PROM:%s D2:%d", state->m_type2_xx_latch ? "on" : "off", state->m_type2_d2_latch));
	708	m_type2_xx_latch = 1;
	709	m_type2_d2_latch = (data & 0x04) ? 1 : 0;
	710	LOG(3,("PROM:%s D2:%d", m_type2_xx_latch ? "on" : "off", m_type2_d2_latch));
738	711	}
739	712	}
740		upi41_master_w(state->m_mcu, offset & 1, data);
	713	upi41_master_w(m_mcu, offset & 1, data);
741	714
742	715	#ifdef MAME_DEBUG
743	716	decocass_fno(space.machine(), offset, data);
r18037	r18038
762	735	*  - Fighting Ice Hockey
763	736	*
764	737	***************************************************************************/
765		static READ8_HANDLER( decocass_type3_r )
	738	READ8_MEMBER(decocass_state::decocass_type3_r)
766	739	{
767		decocass_state *state = space.machine().driver_data<decocass_state>();
768	740	UINT8 data, save;
769	741
770	742	if (1 == (offset & 1))
771	743	{
772		if (1 == state->m_type3_pal_19)
	744	if (1 == m_type3_pal_19)
773	745	{
774		UINT8 *prom = state->memregion("dongle")->base();
775		data = prom[state->m_type3_ctrs];
776		LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- prom[$%03x]\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, state->m_type3_ctrs));
777		if (++state->m_type3_ctrs == 4096)
778		state->m_type3_ctrs = 0;
	746	UINT8 *prom = memregion("dongle")->base();
	747	data = prom[m_type3_ctrs];
	748	LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- prom[$%03x]\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, m_type3_ctrs));
	749	if (++m_type3_ctrs == 4096)
	750	m_type3_ctrs = 0;
779	751	}
780	752	else
781	753	{
782	754	if (0 == (offset & E5XX_MASK))
783	755	{
784		data = upi41_master_r(state->m_mcu, 1);
	756	data = upi41_master_r(m_mcu, 1);
785	757	LOG(4,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- 8041 STATUS\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
786	758	}
787	759	else
r18037	r18038
793	765	}
794	766	else
795	767	{
796		if (1 == state->m_type3_pal_19)
	768	if (1 == m_type3_pal_19)
797	769	{
798	770	save = data = 0xff;    /* open data bus? */
799	771	LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x <- open bus", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
r18037	r18038
802	774	{
803	775	if (0 == (offset & E5XX_MASK))
804	776	{
805		save = upi41_master_r(state->m_mcu, 0);
806		switch (state->m_type3_swap)
	777	save = upi41_master_r(m_mcu, 0);
	778	switch (m_type3_swap)
807	779	{
808	780	case TYPE3_SWAP_01:
809	781	data =
810	782	(BIT(save, 1) << 0) |
811		(state->m_type3_d0_latch << 1) |
	783	(m_type3_d0_latch << 1) |
812	784	(BIT(save, 2) << 2) |
813	785	(BIT(save, 3) << 3) |
814	786	(BIT(save, 4) << 4) |
r18037	r18038
818	790	break;
819	791	case TYPE3_SWAP_12:
820	792	data =
821		(state->m_type3_d0_latch << 0) |
	793	(m_type3_d0_latch << 0) |
822	794	(BIT(save, 2) << 1) |
823	795	(BIT(save, 1) << 2) |
824	796	(BIT(save, 3) << 3) |
r18037	r18038
829	801	break;
830	802	case TYPE3_SWAP_13:
831	803	data =
832		(state->m_type3_d0_latch << 0) |
	804	(m_type3_d0_latch << 0) |
833	805	(BIT(save, 3) << 1) |
834	806	(BIT(save, 2) << 2) |
835	807	(BIT(save, 1) << 3) |
r18037	r18038
840	812	break;
841	813	case TYPE3_SWAP_24:
842	814	data =
843		(state->m_type3_d0_latch << 0) |
	815	(m_type3_d0_latch << 0) |
844	816	(BIT(save, 1) << 1) |
845	817	(BIT(save, 4) << 2) |
846	818	(BIT(save, 3) << 3) |
r18037	r18038
851	823	break;
852	824	case TYPE3_SWAP_25:
853	825	data =
854		(state->m_type3_d0_latch << 0) |
	826	(m_type3_d0_latch << 0) |
855	827	(BIT(save, 1) << 1) |
856	828	(BIT(save, 5) << 2) |
857	829	(BIT(save, 3) << 3) |
r18037	r18038
862	834	break;
863	835	case TYPE3_SWAP_34_0:
864	836	data =
865		(state->m_type3_d0_latch << 0) |
	837	(m_type3_d0_latch << 0) |
866	838	(BIT(save, 1) << 1) |
867	839	(BIT(save, 2) << 2) |
868	840	(BIT(save, 3) << 4) |
r18037	r18038
880	852	(BIT(save, 3) << 4) |
881	853	(BIT(save, 5) << 5) |
882	854	(BIT(save, 6) << 6) |
883		(state->m_type3_d0_latch << 7);
	855	(m_type3_d0_latch << 7);
884	856	break;
885	857	case TYPE3_SWAP_45:
886	858	data =
887		state->m_type3_d0_latch |
	859	m_type3_d0_latch |
888	860	(BIT(save, 1) << 1) |
889	861	(BIT(save, 2) << 2) |
890	862	(BIT(save, 3) << 3) |
r18037	r18038
895	867	break;
896	868	case TYPE3_SWAP_23_56:
897	869	data =
898		(state->m_type3_d0_latch << 0) |
	870	(m_type3_d0_latch << 0) |
899	871	(BIT(save, 1) << 1) |
900	872	(BIT(save, 3) << 2) |
901	873	(BIT(save, 2) << 3) |
r18037	r18038
906	878	break;
907	879	case TYPE3_SWAP_56:
908	880	data =
909		state->m_type3_d0_latch |
	881	m_type3_d0_latch |
910	882	(BIT(save, 1) << 1) |
911	883	(BIT(save, 2) << 2) |
912	884	(BIT(save, 3) << 3) |
r18037	r18038
917	889	break;
918	890	case TYPE3_SWAP_67:
919	891	data =
920		state->m_type3_d0_latch |
	892	m_type3_d0_latch |
921	893	(BIT(save, 1) << 1) |
922	894	(BIT(save, 2) << 2) |
923	895	(BIT(save, 3) << 3) |
r18037	r18038
928	900	break;
929	901	default:
930	902	data =
931		state->m_type3_d0_latch |
	903	m_type3_d0_latch |
932	904	(BIT(save, 1) << 1) |
933	905	(BIT(save, 2) << 2) |
934	906	(BIT(save, 3) << 3) |
r18037	r18038
937	909	(BIT(save, 6) << 6) |
938	910	(BIT(save, 7) << 7);
939	911	}
940		state->m_type3_d0_latch = save & 1;
	912	m_type3_d0_latch = save & 1;
941	913	LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x '%c' <- 8041-DATA\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.'));
942	914	}
943	915	else
944	916	{
945	917	save = 0xff;   /* open data bus? */
946	918	data =
947		state->m_type3_d0_latch |
	919	m_type3_d0_latch |
948	920	(BIT(save, 1) << 1) |
949	921	(BIT(save, 2) << 2) |
950	922	(BIT(save, 3) << 3) |
r18037	r18038
953	925	(BIT(save, 6) << 7) |
954	926	(BIT(save, 7) << 6);
955	927	LOG(3,("%10s 6502-PC: %04x decocass_type3_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.'));
956		state->m_type3_d0_latch = save & 1;
	928	m_type3_d0_latch = save & 1;
957	929	}
958	930	}
959	931	}
r18037	r18038
961	933	return data;
962	934	}
963	935
964		static WRITE8_HANDLER( decocass_type3_w )
	936	WRITE8_MEMBER(decocass_state::decocass_type3_w)
965	937	{
966		decocass_state *state = space.machine().driver_data<decocass_state>();
967	938	if (1 == (offset & 1))
968	939	{
969		if (1 == state->m_type3_pal_19)
	940	if (1 == m_type3_pal_19)
970	941	{
971		state->m_type3_ctrs = data << 4;
	942	m_type3_ctrs = data << 4;
972	943	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, "LDCTRS"));
973	944	return;
974	945	}
975	946	else
976	947	if (0xc0 == (data & 0xf0))
977		state->m_type3_pal_19 = 1;
	948	m_type3_pal_19 = 1;
978	949	}
979	950	else
980	951	{
981		if (1 == state->m_type3_pal_19)
	952	if (1 == m_type3_pal_19)
982	953	{
983	954	/* write nowhere?? */
984	955	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, "nowhere?"));
r18037	r18038
986	957	}
987	958	}
988	959	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
989		upi41_master_w(state->m_mcu, offset, data);
	960	upi41_master_w(m_mcu, offset, data);
990	961	}
991	962
992	963	/***************************************************************************
r18037	r18038
1002	973	*
1003	974	***************************************************************************/
1004	975
1005		static READ8_HANDLER( decocass_type4_r )
	976	READ8_MEMBER(decocass_state::decocass_type4_r)
1006	977	{
1007		decocass_state *state = space.machine().driver_data<decocass_state>();
1008	978	UINT8 data;
1009	979
1010	980	if (1 == (offset & 1))
1011	981	{
1012	982	if (0 == (offset & E5XX_MASK))
1013	983	{
1014		data = upi41_master_r(state->m_mcu, 1);
	984	data = upi41_master_r(m_mcu, 1);
1015	985	LOG(4,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x <- 8041 STATUS\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
1016	986	}
1017	987	else
r18037	r18038
1022	992	}
1023	993	else
1024	994	{
1025		if (state->m_type4_latch)
	995	if (m_type4_latch)
1026	996	{
1027	997	UINT8 *prom = space.machine().root_device().memregion("dongle")->base();
1028	998
1029		data = prom[state->m_type4_ctrs];
1030		LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- PROM[%04x]\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.', state->m_type4_ctrs));
1031		state->m_type4_ctrs = (state->m_type4_ctrs + 1) & 0x7fff;
	999	data = prom[m_type4_ctrs];
	1000	LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- PROM[%04x]\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.', m_type4_ctrs));
	1001	m_type4_ctrs = (m_type4_ctrs + 1) & 0x7fff;
1032	1002	}
1033	1003	else
1034	1004	{
1035	1005	if (0 == (offset & E5XX_MASK))
1036	1006	{
1037		data = upi41_master_r(state->m_mcu, 0);
	1007	data = upi41_master_r(m_mcu, 0);
1038	1008	LOG(3,("%10s 6502-PC: %04x decocass_type4_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.'));
1039	1009	}
1040	1010	else
r18037	r18038
1048	1018	return data;
1049	1019	}
1050	1020
1051		static WRITE8_HANDLER( decocass_type4_w )
	1021	WRITE8_MEMBER(decocass_state::decocass_type4_w)
1052	1022	{
1053		decocass_state *state = space.machine().driver_data<decocass_state>();
1054	1023	if (1 == (offset & 1))
1055	1024	{
1056		if (1 == state->m_type4_latch)
	1025	if (1 == m_type4_latch)
1057	1026	{
1058		state->m_type4_ctrs = (state->m_type4_ctrs & 0x00ff) | ((data & 0x7f) << 8);
1059		LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS MSB (%04x)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, state->m_type4_ctrs));
	1027	m_type4_ctrs = (m_type4_ctrs & 0x00ff) | ((data & 0x7f) << 8);
	1028	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS MSB (%04x)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, m_type4_ctrs));
1060	1029	return;
1061	1030	}
1062	1031	else
1063	1032	if (0xc0 == (data & 0xf0))
1064	1033	{
1065		state->m_type4_latch = 1;
	1034	m_type4_latch = 1;
1066	1035	}
1067	1036	}
1068	1037	else
1069	1038	{
1070		if (state->m_type4_latch)
	1039	if (m_type4_latch)
1071	1040	{
1072		state->m_type4_ctrs = (state->m_type4_ctrs & 0xff00) | data;
1073		LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS LSB (%04x)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, state->m_type4_ctrs));
	1041	m_type4_ctrs = (m_type4_ctrs & 0xff00) | data;
	1042	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> CTRS LSB (%04x)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, m_type4_ctrs));
1074	1043	return;
1075	1044	}
1076	1045	}
1077	1046	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
1078		upi41_master_w(state->m_mcu, offset, data);
	1047	upi41_master_w(m_mcu, offset, data);
1079	1048	}
1080	1049
1081	1050	/***************************************************************************
r18037	r18038
1087	1056	*
1088	1057	***************************************************************************/
1089	1058
1090		static READ8_HANDLER( decocass_type5_r )
	1059	READ8_MEMBER(decocass_state::decocass_type5_r)
1091	1060	{
1092		decocass_state *state = space.machine().driver_data<decocass_state>();
1093	1061	UINT8 data;
1094	1062
1095	1063	if (1 == (offset & 1))
1096	1064	{
1097	1065	if (0 == (offset & E5XX_MASK))
1098	1066	{
1099		data = upi41_master_r(state->m_mcu, 1);
	1067	data = upi41_master_r(m_mcu, 1);
1100	1068	LOG(4,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x <- 8041 STATUS\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
1101	1069	}
1102	1070	else
r18037	r18038
1107	1075	}
1108	1076	else
1109	1077	{
1110		if (state->m_type5_latch)
	1078	if (m_type5_latch)
1111	1079	{
1112	1080	data = 0x55;   /* Only a fixed value? It looks like this is all we need to do */
1113	1081	LOG(3,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x '%c' <- fixed value???\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.'));
r18037	r18038
1116	1084	{
1117	1085	if (0 == (offset & E5XX_MASK))
1118	1086	{
1119		data = upi41_master_r(state->m_mcu, 0);
	1087	data = upi41_master_r(m_mcu, 0);
1120	1088	LOG(3,("%10s 6502-PC: %04x decocass_type5_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.'));
1121	1089	}
1122	1090	else
r18037	r18038
1130	1098	return data;
1131	1099	}
1132	1100
1133		static WRITE8_HANDLER( decocass_type5_w )
	1101	WRITE8_MEMBER(decocass_state::decocass_type5_w)
1134	1102	{
1135		decocass_state *state = space.machine().driver_data<decocass_state>();
1136	1103	if (1 == (offset & 1))
1137	1104	{
1138		if (1 == state->m_type5_latch)
	1105	if (1 == m_type5_latch)
1139	1106	{
1140	1107	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, "latch #2??"));
1141	1108	return;
1142	1109	}
1143	1110	else
1144	1111	if (0xc0 == (data & 0xf0))
1145		state->m_type5_latch = 1;
	1112	m_type5_latch = 1;
1146	1113	}
1147	1114	else
1148	1115	{
1149		if (state->m_type5_latch)
	1116	if (m_type5_latch)
1150	1117	{
1151	1118	/* write nowhere?? */
1152	1119	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, "nowhere?"));
r18037	r18038
1154	1121	}
1155	1122	}
1156	1123	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
1157		upi41_master_w(state->m_mcu, offset, data);
	1124	upi41_master_w(m_mcu, offset, data);
1158	1125	}
1159	1126
1160	1127	/***************************************************************************
r18037	r18038
1165	1132	*
1166	1133	***************************************************************************/
1167	1134
1168		static READ8_HANDLER( decocass_nodong_r )
	1135	READ8_MEMBER(decocass_state::decocass_nodong_r)
1169	1136	{
1170		decocass_state *state = space.machine().driver_data<decocass_state>();
1171	1137	UINT8 data;
1172	1138
1173	1139	if (1 == (offset & 1))
1174	1140	{
1175	1141	if (0 == (offset & E5XX_MASK))
1176	1142	{
1177		data = upi41_master_r(state->m_mcu, 1);
	1143	data = upi41_master_r(m_mcu, 1);
1178	1144	LOG(4,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x <- 8041 STATUS\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data));
1179	1145	}
1180	1146	else
r18037	r18038
1187	1153	{
1188	1154	if (0 == (offset & E5XX_MASK))
1189	1155	{
1190		data = upi41_master_r(state->m_mcu, 0);
	1156	data = upi41_master_r(m_mcu, 0);
1191	1157	LOG(3,("%10s 6502-PC: %04x decocass_nodong_r(%02x): $%02x '%c' <- open bus (D0 replaced with latch)\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, (data >= 32) ? data : '.'));
1192	1158	}
1193	1159	else
r18037	r18038
1206	1172	*
1207	1173	***************************************************************************/
1208	1174
1209		READ8_HANDLER( decocass_e5xx_r )
	1175	READ8_MEMBER(decocass_state::decocass_e5xx_r)
1210	1176	{
1211		decocass_state *state = space.machine().driver_data<decocass_state>();
1212	1177	UINT8 data;
1213	1178
1214	1179	/* E5x2-E5x3 and mirrors */
1215	1180	if (2 == (offset & E5XX_MASK))
1216	1181	{
1217		UINT8 bot_eot = (tape_get_status_bits(state->m_cassette) >> 5) & 1;
	1182	UINT8 bot_eot = (tape_get_status_bits(m_cassette) >> 5) & 1;
1218	1183
1219	1184	data =
1220		(BIT(state->m_i8041_p1, 7)     << 0) |   /* D0 = P17 - REQ/ */
1221		(BIT(state->m_i8041_p2, 0)     << 1) |   /* D1 = P20 - FNO/ */
1222		(BIT(state->m_i8041_p2, 1)     << 2) |   /* D2 = P21 - EOT/ */
1223		(BIT(state->m_i8041_p2, 2)     << 3) |   /* D3 = P22 - ERR/ */
	1185	(BIT(m_i8041_p1, 7)     << 0) |   /* D0 = P17 - REQ/ */
	1186	(BIT(m_i8041_p2, 0)     << 1) |   /* D1 = P20 - FNO/ */
	1187	(BIT(m_i8041_p2, 1)     << 2) |   /* D2 = P21 - EOT/ */
	1188	(BIT(m_i8041_p2, 2)     << 3) |   /* D3 = P22 - ERR/ */
1224	1189	((bot_eot)             << 4) |   /* D4 = BOT/EOT (direct from drive) */
1225	1190	(1                 << 5) |   /* D5 floating input */
1226	1191	(1                 << 6) |   /* D6 floating input */
1227		(!tape_is_present(state->m_cassette) << 7);   /* D7 = cassette present */
	1192	(!tape_is_present(m_cassette) << 7);   /* D7 = cassette present */
1228	1193
1229	1194	LOG(4,("%10s 6502-PC: %04x decocass_e5xx_r(%02x): $%02x <- STATUS (%s%s%s%s%s%s%s%s)\n",
1230	1195	space.machine().time().as_string(6),
r18037	r18038
1241	1206	}
1242	1207	else
1243	1208	{
1244		if (state->m_dongle_r)
1245		data = (*state->m_dongle_r)(space, offset, mem_mask);
	1209	if (!m_dongle_r.isnull())
	1210	data = (m_dongle_r)(space, offset, mem_mask);
1246	1211	else
1247	1212	data = 0xff;
1248	1213	}
1249	1214	return data;
1250	1215	}
1251	1216
1252		WRITE8_HANDLER( decocass_e5xx_w )
	1217	WRITE8_MEMBER(decocass_state::decocass_e5xx_w)
1253	1218	{
1254		decocass_state *state = space.machine().driver_data<decocass_state>();
1255		if (state->m_dongle_w)
	1219	if (!m_dongle_w.isnull())
1256	1220	{
1257		(*state->m_dongle_w)(space, offset, data, mem_mask);
	1221	(m_dongle_w)(space, offset, data, mem_mask);
1258	1222	return;
1259	1223	}
1260	1224
1261	1225	if (0 == (offset & E5XX_MASK))
1262	1226	{
1263	1227	LOG(3,("%10s 6502-PC: %04x decocass_e5xx_w(%02x): $%02x -> %s\n", space.machine().time().as_string(6), space.device().safe_pcbase(), offset, data, offset & 1 ? "8041-CMND" : "8041-DATA"));
1264		upi41_master_w(state->m_mcu, offset & 1, data);
	1228	upi41_master_w(m_mcu, offset & 1, data);
1265	1229	#ifdef MAME_DEBUG
1266	1230	decocass_fno(space.machine(), offset, data);
1267	1231	#endif
r18037	r18038
1284	1248	*
1285	1249	***************************************************************************/
1286	1250
1287		WRITE8_HANDLER( decocass_e900_w )
	1251	WRITE8_MEMBER(decocass_state::decocass_e900_w)
1288	1252	{
1289		decocass_state *state = space.machine().driver_data<decocass_state>();
1290		state->m_de0091_enable = data & 1;
1291		state->membank("bank1")->set_entry(data & 1);
	1253	m_de0091_enable = data & 1;
	1254	membank("bank1")->set_entry(data & 1);
1292	1255	/* Perhaps the second row of ROMs is enabled by another bit.
1293	1256	* There is no way to verify this yet, so for now just look
1294	1257	* at bit 0 to enable the daughter board at reads between
r18037	r18038
1296	1259	*/
1297	1260	}
1298	1261
1299		WRITE8_HANDLER( decocass_de0091_w )
	1262	WRITE8_MEMBER(decocass_state::decocass_de0091_w)
1300	1263	{
1301		decocass_state *state = space.machine().driver_data<decocass_state>();
1302	1264	/* don't allow writes to the ROMs */
1303		if (!state->m_de0091_enable)
	1265	if (!m_de0091_enable)
1304	1266	decocass_charram_w(space, offset, data);
1305	1267	}
1306	1268
r18037	r18038
1310	1272	*
1311	1273	***************************************************************************/
1312	1274	/* To be called once from driver_init, i.e. decocass_init */
1313		void decocass_machine_state_save_init( running_machine &machine )
	1275	void decocass_state::decocass_machine_state_save_init()
1314	1276	{
1315		decocass_state *state = machine.driver_data<decocass_state>();
1316		state->save_item(NAME(state->m_firsttime));
1317		state->save_item(NAME(state->m_decocass_reset));
1318		state->save_item(NAME(state->m_i8041_p1));
1319		state->save_item(NAME(state->m_i8041_p2));
1320		state->save_item(NAME(state->m_de0091_enable));
1321		state->save_item(NAME(state->m_type1_inmap));
1322		state->save_item(NAME(state->m_type1_outmap));
1323		state->save_item(NAME(state->m_type2_d2_latch));
1324		state->save_item(NAME(state->m_type2_xx_latch));
1325		state->save_item(NAME(state->m_type2_promaddr));
1326		state->save_item(NAME(state->m_type3_ctrs));
1327		state->save_item(NAME(state->m_type3_d0_latch));
1328		state->save_item(NAME(state->m_type3_pal_19));
1329		state->save_item(NAME(state->m_type3_swap));
1330		state->save_item(NAME(state->m_type4_ctrs));
1331		state->save_item(NAME(state->m_type4_latch));
1332		state->save_item(NAME(state->m_type5_latch));
1333		state->save_item(NAME(state->m_sound_ack));
	1277	save_item(NAME(m_firsttime));
	1278	save_item(NAME(m_decocass_reset));
	1279	save_item(NAME(m_i8041_p1));
	1280	save_item(NAME(m_i8041_p2));
	1281	save_item(NAME(m_de0091_enable));
	1282	save_item(NAME(m_type1_inmap));
	1283	save_item(NAME(m_type1_outmap));
	1284	save_item(NAME(m_type2_d2_latch));
	1285	save_item(NAME(m_type2_xx_latch));
	1286	save_item(NAME(m_type2_promaddr));
	1287	save_item(NAME(m_type3_ctrs));
	1288	save_item(NAME(m_type3_d0_latch));
	1289	save_item(NAME(m_type3_pal_19));
	1290	save_item(NAME(m_type3_swap));
	1291	save_item(NAME(m_type4_ctrs));
	1292	save_item(NAME(m_type4_latch));
	1293	save_item(NAME(m_type5_latch));
	1294	save_item(NAME(m_sound_ack));
1334	1295
1335		state->save_item(NAME(state->m_quadrature_decoder));
1336		state->save_item(NAME(state->m_latch1));
1337		state->save_item(NAME(state->m_audio_nmi_enabled));
1338		state->save_item(NAME(state->m_audio_nmi_state));
1339		state->save_item(NAME(state->m_i8041_p1_write_latch));
1340		state->save_item(NAME(state->m_i8041_p2_write_latch));
1341		state->save_item(NAME(state->m_i8041_p1_read_latch));
1342		state->save_item(NAME(state->m_i8041_p2_read_latch));
	1296	save_item(NAME(m_quadrature_decoder));
	1297	save_item(NAME(m_latch1));
	1298	save_item(NAME(m_audio_nmi_enabled));
	1299	save_item(NAME(m_audio_nmi_state));
	1300	save_item(NAME(m_i8041_p1_write_latch));
	1301	save_item(NAME(m_i8041_p2_write_latch));
	1302	save_item(NAME(m_i8041_p1_read_latch));
	1303	save_item(NAME(m_i8041_p2_read_latch));
1343	1304	}
1344	1305
1345	1306	/***************************************************************************
r18037	r18038
1350	1311
1351	1312	void decocass_state::machine_start()
1352	1313	{
1353
1354		m_maincpu = machine().device<cpu_device>("maincpu");
1355		m_audiocpu = machine().device<cpu_device>("audiocpu");
1356		m_mcu = machine().device("mcu");
1357		m_cassette = machine().device("cassette");
1358	1314	}
1359	1315
1360		static void decocass_reset_common( running_machine &machine )
	1316	void decocass_state::machine_reset()
1361	1317	{
1362		decocass_state *state = machine.driver_data<decocass_state>();
1363		state->m_firsttime = 1;
1364		state->m_latch1 = 0;
	1318	m_firsttime = 1;
	1319	m_latch1 = 0;
1365	1320
1366		state->m_dongle_r = NULL;
1367		state->m_dongle_w = NULL;
	1321	m_dongle_r = read8_delegate();
	1322	m_dongle_w = write8_delegate();
1368	1323
1369		state->m_decocass_reset = 0;
1370		state->m_i8041_p1 = 0xff;
1371		state->m_i8041_p2 = 0xff;
1372		state->m_i8041_p1_write_latch = 0xff;
1373		state->m_i8041_p2_write_latch = 0xff;
1374		state->m_i8041_p1_read_latch = 0xff;
1375		state->m_i8041_p2_read_latch = 0xff;
1376		state->m_de0091_enable = 0;
	1324	m_decocass_reset = 0;
	1325	m_i8041_p1 = 0xff;
	1326	m_i8041_p2 = 0xff;
	1327	m_i8041_p1_write_latch = 0xff;
	1328	m_i8041_p2_write_latch = 0xff;
	1329	m_i8041_p1_read_latch = 0xff;
	1330	m_i8041_p2_read_latch = 0xff;
	1331	m_de0091_enable = 0;
1377	1332
1378		state->m_type1_inmap = MAKE_MAP(0,1,2,3,4,5,6,7);
1379		state->m_type1_outmap = MAKE_MAP(0,1,2,3,4,5,6,7);
	1333	m_type1_inmap = MAKE_MAP(0,1,2,3,4,5,6,7);
	1334	m_type1_outmap = MAKE_MAP(0,1,2,3,4,5,6,7);
1380	1335
1381		state->m_type2_d2_latch = 0;
1382		state->m_type2_xx_latch = 0;
1383		state->m_type2_promaddr = 0;
	1336	m_type2_d2_latch = 0;
	1337	m_type2_xx_latch = 0;
	1338	m_type2_promaddr = 0;
1384	1339
1385		state->m_type3_ctrs = 0;
1386		state->m_type3_d0_latch = 0;
1387		state->m_type3_pal_19 = 0;
1388		state->m_type3_swap = 0;
	1340	m_type3_ctrs = 0;
	1341	m_type3_d0_latch = 0;
	1342	m_type3_pal_19 = 0;
	1343	m_type3_swap = 0;
1389	1344
1390		state->m_type4_ctrs = 0;
1391		state->m_type4_latch = 0;
	1345	m_type4_ctrs = 0;
	1346	m_type4_latch = 0;
1392	1347
1393		state->m_type5_latch = 0;
	1348	m_type5_latch = 0;
1394	1349
1395		memset(state->m_quadrature_decoder, 0, sizeof(state->m_quadrature_decoder));
1396		state->m_sound_ack = 0;
1397		state->m_audio_nmi_enabled = 0;
1398		state->m_audio_nmi_state = 0;
	1350	memset(m_quadrature_decoder, 0, sizeof(m_quadrature_decoder));
	1351	m_sound_ack = 0;
	1352	m_audio_nmi_enabled = 0;
	1353	m_audio_nmi_state = 0;
1399	1354
1400	1355	/* video-related */
1401		state->m_watchdog_flip = 0;
1402		state->m_color_missiles = 0;
1403		state->m_color_center_bot = 0;
1404		state->m_mode_set = 0;
1405		state->m_back_h_shift = 0;
1406		state->m_back_vl_shift = 0;
1407		state->m_back_vr_shift = 0;
1408		state->m_part_h_shift = 0;
1409		state->m_part_v_shift = 0;
1410		state->m_center_h_shift_space = 0;
1411		state->m_center_v_shift = 0;
	1356	m_watchdog_flip = 0;
	1357	m_color_missiles = 0;
	1358	m_color_center_bot = 0;
	1359	m_mode_set = 0;
	1360	m_back_h_shift = 0;
	1361	m_back_vl_shift = 0;
	1362	m_back_vr_shift = 0;
	1363	m_part_h_shift = 0;
	1364	m_part_v_shift = 0;
	1365	m_center_h_shift_space = 0;
	1366	m_center_v_shift = 0;
1412	1367	}
1413	1368
1414		void decocass_state::machine_reset()
1415		{
1416		decocass_reset_common(machine());
1417		}
1418
1419	1369	MACHINE_RESET_MEMBER(decocass_state,ctsttape)
1420	1370	{
1421		decocass_reset_common(machine());
	1371	decocass_state::machine_reset();
1422	1372	LOG(0,("dongle type #1 (DE-0061)\n"));
1423		m_dongle_r = decocass_type1_pass_136_r;
	1373	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_pass_136_r),this);
1424	1374	}
1425	1375
1426	1376	MACHINE_RESET_MEMBER(decocass_state,chwy)
1427	1377	{
1428		decocass_reset_common(machine());
	1378	decocass_state::machine_reset();
1429	1379	LOG(0,("dongle type #1 (DE-0061 own PROM)\n"));
1430		m_dongle_r = decocass_type1_latch_27_pass_3_inv_2_r;
	1380	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_27_pass_3_inv_2_r),this);
1431	1381	}
1432	1382
1433	1383	MACHINE_RESET_MEMBER(decocass_state,cdsteljn)
1434	1384	{
1435		decocass_reset_common(machine());
	1385	decocass_state::machine_reset();
1436	1386	LOG(0,("dongle type #1 (A-0061)\n"));
1437		m_dongle_r = decocass_type1_latch_27_pass_3_inv_2_r;
	1387	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_27_pass_3_inv_2_r),this);
1438	1388	}
1439	1389
1440	1390	MACHINE_RESET_MEMBER(decocass_state,cterrani)
1441	1391	{
1442		decocass_reset_common(machine());
	1392	decocass_state::machine_reset();
1443	1393	LOG(0,("dongle type #1 (DE-0061 straight)\n"));
1444		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1394	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1445	1395	m_type1_inmap = MAKE_MAP(0,1,2,3,4,5,6,7);
1446	1396	m_type1_outmap = MAKE_MAP(0,1,2,3,4,5,6,7);
1447	1397	}
1448	1398
1449	1399	MACHINE_RESET_MEMBER(decocass_state,castfant)
1450	1400	{
1451		decocass_reset_common(machine());
	1401	decocass_state::machine_reset();
1452	1402	LOG(0,("dongle type #1 (DE-0061)\n"));
1453		m_dongle_r = decocass_type1_latch_16_pass_3_inv_1_r;
	1403	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_16_pass_3_inv_1_r),this);
1454	1404	}
1455	1405
1456	1406	MACHINE_RESET_MEMBER(decocass_state,csuperas)
1457	1407	{
1458		decocass_reset_common(machine());
	1408	decocass_state::machine_reset();
1459	1409	LOG(0,("dongle type #1 (DE-0061 flip 4-5)\n"));
1460		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1410	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1461	1411	m_type1_inmap = MAKE_MAP(0,1,2,3,5,4,6,7);
1462	1412	m_type1_outmap = MAKE_MAP(0,1,2,3,5,4,6,7);
1463	1413	}
1464	1414
1465	1415	MACHINE_RESET_MEMBER(decocass_state,clocknch)
1466	1416	{
1467		decocass_reset_common(machine());
	1417	decocass_state::machine_reset();
1468	1418	LOG(0,("dongle type #1 (DE-0061 flip 2-3)\n"));
1469		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1419	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1470	1420	m_type1_inmap = MAKE_MAP(0,1,3,2,4,5,6,7);
1471	1421	m_type1_outmap = MAKE_MAP(0,1,3,2,4,5,6,7);
1472	1422	}
1473	1423
1474	1424	MACHINE_RESET_MEMBER(decocass_state,cprogolf)
1475	1425	{
1476		decocass_reset_common(machine());
	1426	decocass_state::machine_reset();
1477	1427	LOG(0,("dongle type #1 (DE-0061 flip 0-1)\n"));
1478		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1428	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1479	1429	m_type1_inmap = MAKE_MAP(1,0,2,3,4,5,6,7);
1480	1430	m_type1_outmap = MAKE_MAP(1,0,2,3,4,5,6,7);
1481	1431	}
1482	1432
1483	1433	MACHINE_RESET_MEMBER(decocass_state,cprogolfj)
1484	1434	{
1485		decocass_reset_common(machine());
	1435	decocass_state::machine_reset();
1486	1436	LOG(0,("dongle type #1 (A-0061 flip 0-1)\n"));
1487		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1437	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1488	1438	m_type1_inmap = MAKE_MAP(1,0,2,3,4,5,6,7);
1489	1439	m_type1_outmap = MAKE_MAP(1,0,2,3,4,5,6,7);
1490	1440	}
1491	1441
1492	1442	MACHINE_RESET_MEMBER(decocass_state,cluckypo)
1493	1443	{
1494		decocass_reset_common(machine());
	1444	decocass_state::machine_reset();
1495	1445	LOG(0,("dongle type #1 (DE-0061 flip 1-3)\n"));
1496		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1446	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1497	1447	m_type1_inmap = MAKE_MAP(0,3,2,1,4,5,6,7);
1498	1448	m_type1_outmap = MAKE_MAP(0,3,2,1,4,5,6,7);
1499	1449	}
1500	1450
1501	1451	MACHINE_RESET_MEMBER(decocass_state,ctisland)
1502	1452	{
1503		decocass_reset_common(machine());
	1453	decocass_state::machine_reset();
1504	1454	LOG(0,("dongle type #1 (DE-0061 flip 0-2)\n"));
1505		m_dongle_r = decocass_type1_latch_26_pass_3_inv_2_r;
	1455	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_3_inv_2_r),this);
1506	1456	m_type1_inmap = MAKE_MAP(2,1,0,3,4,5,6,7);
1507	1457	m_type1_outmap = MAKE_MAP(2,1,0,3,4,5,6,7);
1508	1458	}
1509	1459
1510	1460	MACHINE_RESET_MEMBER(decocass_state,cexplore)
1511	1461	{
1512		decocass_reset_common(machine());
	1462	decocass_state::machine_reset();
1513	1463	LOG(0,("dongle type #1 (DE-0061 own PROM)\n"));
1514		m_dongle_r = decocass_type1_latch_26_pass_5_inv_2_r;
	1464	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type1_latch_26_pass_5_inv_2_r),this);
1515	1465	}
1516	1466
1517	1467	MACHINE_RESET_MEMBER(decocass_state,cdiscon1)
1518	1468	{
1519		decocass_reset_common(machine());
	1469	decocass_state::machine_reset();
1520	1470	LOG(0,("dongle type #2 (CS82-007)\n"));
1521		m_dongle_r = decocass_type2_r;
1522		m_dongle_w = decocass_type2_w;
	1471	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type2_r),this);
	1472	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type2_w),this);
1523	1473	}
1524	1474
1525	1475	MACHINE_RESET_MEMBER(decocass_state,ctornado)
1526	1476	{
1527		decocass_reset_common(machine());
	1477	decocass_state::machine_reset();
1528	1478	LOG(0,("dongle type #2 (CS82-007)\n"));
1529		m_dongle_r = decocass_type2_r;
1530		m_dongle_w = decocass_type2_w;
	1479	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type2_r),this);
	1480	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type2_w),this);
1531	1481	}
1532	1482
1533	1483	MACHINE_RESET_MEMBER(decocass_state,cmissnx)
1534	1484	{
1535		decocass_reset_common(machine());
	1485	decocass_state::machine_reset();
1536	1486	LOG(0,("dongle type #2 (CS82-007)\n"));
1537		m_dongle_r = decocass_type2_r;
1538		m_dongle_w = decocass_type2_w;
	1487	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type2_r),this);
	1488	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type2_w),this);
1539	1489	}
1540	1490
1541	1491	MACHINE_RESET_MEMBER(decocass_state,cptennis)
1542	1492	{
1543		decocass_reset_common(machine());
	1493	decocass_state::machine_reset();
1544	1494	LOG(0,("dongle type #2 (CS82-007)\n"));
1545		m_dongle_r = decocass_type2_r;
1546		m_dongle_w = decocass_type2_w;
	1495	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type2_r),this);
	1496	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type2_w),this);
1547	1497	}
1548	1498
1549	1499	MACHINE_RESET_MEMBER(decocass_state,cfishing)
1550	1500	{
1551		decocass_reset_common(machine());
	1501	decocass_state::machine_reset();
1552	1502	LOG(0,("dongle type #3 (PAL)\n"));
1553		m_dongle_r = decocass_type3_r;
1554		m_dongle_w = decocass_type3_w;
	1503	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1504	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1555	1505	m_type3_swap = TYPE3_SWAP_01;
1556	1506
1557	1507	}
1558	1508
1559	1509	MACHINE_RESET_MEMBER(decocass_state,cbtime)
1560	1510	{
1561		decocass_reset_common(machine());
	1511	decocass_state::machine_reset();
1562	1512	LOG(0,("dongle type #3 (PAL)\n"));
1563		m_dongle_r = decocass_type3_r;
1564		m_dongle_w = decocass_type3_w;
	1513	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1514	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1565	1515	m_type3_swap = TYPE3_SWAP_12;
1566	1516
1567	1517	}
1568	1518
1569	1519	MACHINE_RESET_MEMBER(decocass_state,cburnrub)
1570	1520	{
1571		decocass_reset_common(machine());
	1521	decocass_state::machine_reset();
1572	1522	LOG(0,("dongle type #3 (PAL)\n"));
1573		m_dongle_r = decocass_type3_r;
1574		m_dongle_w = decocass_type3_w;
	1523	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1524	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1575	1525	m_type3_swap = TYPE3_SWAP_67;
1576	1526	}
1577	1527
1578	1528	MACHINE_RESET_MEMBER(decocass_state,cgraplop)
1579	1529	{
1580		decocass_reset_common(machine());
	1530	decocass_state::machine_reset();
1581	1531	LOG(0,("dongle type #3 (PAL)\n"));
1582		m_dongle_r = decocass_type3_r;
1583		m_dongle_w = decocass_type3_w;
	1532	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1533	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1584	1534	m_type3_swap = TYPE3_SWAP_56;
1585	1535	}
1586	1536
1587	1537	MACHINE_RESET_MEMBER(decocass_state,cgraplop2)
1588	1538	{
1589		decocass_reset_common(machine());
	1539	decocass_state::machine_reset();
1590	1540	LOG(0,("dongle type #3 (PAL)\n"));
1591		m_dongle_r = decocass_type3_r;
1592		m_dongle_w = decocass_type3_w;
	1541	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1542	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1593	1543	m_type3_swap = TYPE3_SWAP_67;
1594	1544	}
1595	1545
1596	1546	MACHINE_RESET_MEMBER(decocass_state,clapapa)
1597	1547	{
1598		decocass_reset_common(machine());
	1548	decocass_state::machine_reset();
1599	1549	LOG(0,("dongle type #3 (PAL)\n"));
1600		m_dongle_r = decocass_type3_r;
1601		m_dongle_w = decocass_type3_w;
	1550	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1551	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1602	1552	m_type3_swap = TYPE3_SWAP_34_7;
1603	1553	}
1604	1554
1605	1555	MACHINE_RESET_MEMBER(decocass_state,cskater)
1606	1556	{
1607		decocass_reset_common(machine());
	1557	decocass_state::machine_reset();
1608	1558	LOG(0,("dongle type #3 (PAL)\n"));
1609		m_dongle_r = decocass_type3_r;
1610		m_dongle_w = decocass_type3_w;
	1559	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1560	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1611	1561	m_type3_swap = TYPE3_SWAP_45;
1612	1562	}
1613	1563
1614	1564	MACHINE_RESET_MEMBER(decocass_state,cprobowl)
1615	1565	{
1616		decocass_reset_common(machine());
	1566	decocass_state::machine_reset();
1617	1567	LOG(0,("dongle type #3 (PAL)\n"));
1618		m_dongle_r = decocass_type3_r;
1619		m_dongle_w = decocass_type3_w;
	1568	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1569	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1620	1570	m_type3_swap = TYPE3_SWAP_34_0;
1621	1571	}
1622	1572
1623	1573	MACHINE_RESET_MEMBER(decocass_state,cnightst)
1624	1574	{
1625		decocass_reset_common(machine());
	1575	decocass_state::machine_reset();
1626	1576	LOG(0,("dongle type #3 (PAL)\n"));
1627		m_dongle_r = decocass_type3_r;
1628		m_dongle_w = decocass_type3_w;
	1577	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1578	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1629	1579	m_type3_swap = TYPE3_SWAP_13;
1630	1580	}
1631	1581
1632	1582	MACHINE_RESET_MEMBER(decocass_state,cpsoccer)
1633	1583	{
1634		decocass_reset_common(machine());
	1584	decocass_state::machine_reset();
1635	1585	LOG(0,("dongle type #3 (PAL)\n"));
1636		m_dongle_r = decocass_type3_r;
1637		m_dongle_w = decocass_type3_w;
	1586	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1587	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1638	1588	m_type3_swap = TYPE3_SWAP_24;
1639	1589	}
1640	1590
1641	1591	MACHINE_RESET_MEMBER(decocass_state,csdtenis)
1642	1592	{
1643		decocass_reset_common(machine());
	1593	decocass_state::machine_reset();
1644	1594	LOG(0,("dongle type #3 (PAL)\n"));
1645		m_dongle_r = decocass_type3_r;
1646		m_dongle_w = decocass_type3_w;
	1595	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1596	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1647	1597	m_type3_swap = TYPE3_SWAP_23_56;
1648	1598	}
1649	1599
1650	1600	MACHINE_RESET_MEMBER(decocass_state,czeroize)
1651	1601	{
1652	1602	UINT8 *mem = memregion("dongle")->base();
1653		decocass_reset_common(machine());
	1603	decocass_state::machine_reset();
1654	1604	LOG(0,("dongle type #3 (PAL)\n"));
1655		m_dongle_r = decocass_type3_r;
1656		m_dongle_w = decocass_type3_w;
	1605	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1606	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1657	1607	m_type3_swap = TYPE3_SWAP_23_56;
1658	1608
1659	1609	/*
r18037	r18038
1672	1622
1673	1623	MACHINE_RESET_MEMBER(decocass_state,cppicf)
1674	1624	{
1675		decocass_reset_common(machine());
	1625	decocass_state::machine_reset();
1676	1626	LOG(0,("dongle type #3 (PAL)\n"));
1677		m_dongle_r = decocass_type3_r;
1678		m_dongle_w = decocass_type3_w;
	1627	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1628	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1679	1629	m_type3_swap = TYPE3_SWAP_01;
1680	1630	}
1681	1631
1682	1632	MACHINE_RESET_MEMBER(decocass_state,cfghtice)
1683	1633	{
1684		decocass_reset_common(machine());
	1634	decocass_state::machine_reset();
1685	1635	LOG(0,("dongle type #3 (PAL)\n"));
1686		m_dongle_r = decocass_type3_r;
1687		m_dongle_w = decocass_type3_w;
	1636	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type3_r),this);
	1637	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type3_w),this);
1688	1638	m_type3_swap = TYPE3_SWAP_25;
1689	1639	}
1690	1640
1691	1641	MACHINE_RESET_MEMBER(decocass_state,type4)
1692	1642	{
1693		decocass_reset_common(machine());
	1643	decocass_state::machine_reset();
1694	1644	LOG(0,("dongle type #4 (32K ROM)\n"));
1695		m_dongle_r = decocass_type4_r;
1696		m_dongle_w = decocass_type4_w;
	1645	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type4_r),this);
	1646	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type4_w),this);
1697	1647	}
1698	1648
1699	1649	MACHINE_RESET_MEMBER(decocass_state,cbdash)
1700	1650	{
1701		decocass_reset_common(machine());
	1651	decocass_state::machine_reset();
1702	1652	LOG(0,("dongle type #5 (NOP)\n"));
1703		m_dongle_r = decocass_type5_r;
1704		m_dongle_w = decocass_type5_w;
	1653	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_type5_r),this);
	1654	m_dongle_w = write8_delegate(FUNC(decocass_state::decocass_type5_w),this);
1705	1655	}
1706	1656
1707	1657	MACHINE_RESET_MEMBER(decocass_state,cflyball)
1708	1658	{
1709		decocass_reset_common(machine());
	1659	decocass_state::machine_reset();
1710	1660	LOG(0,("no dongle\n"));
1711		m_dongle_r = decocass_nodong_r;
	1661	m_dongle_r = read8_delegate(FUNC(decocass_state::decocass_nodong_r),this);
1712	1662	}
1713	1663
1714	1664	/***************************************************************************
r18037	r18038
1717	1667	*
1718	1668	***************************************************************************/
1719	1669
1720		WRITE8_HANDLER( i8041_p1_w )
	1670	WRITE8_MEMBER(decocass_state::i8041_p1_w)
1721	1671	{
1722		decocass_state *state = space.machine().driver_data<decocass_state>();
1723		if (data != state->m_i8041_p1_write_latch)
	1672	if (data != m_i8041_p1_write_latch)
1724	1673	{
1725	1674	LOG(4,("%10s 8041-PC: %03x i8041_p1_w: $%02x (%s%s%s%s%s%s%s%s)\n",
1726	1675	space.machine().time().as_string(6),
r18037	r18038
1734	1683	data & 0x20 ? "" : " FWD",
1735	1684	data & 0x40 ? "" : " WREN",
1736	1685	data & 0x80 ? "" : " REQ"));
1737		state->m_i8041_p1_write_latch = data;
	1686	m_i8041_p1_write_latch = data;
1738	1687	}
1739	1688
1740	1689	/* change in FAST/REW/FWD signals? */
1741		if ((data ^ state->m_i8041_p1) & 0x34)
	1690	if ((data ^ m_i8041_p1) & 0x34)
1742	1691	{
1743	1692	int newspeed = 0;
1744	1693
r18037	r18038
1746	1695	newspeed = (data & 0x04) ? -1 : -7;
1747	1696	else if ((data & 0x30) == 0x10)
1748	1697	newspeed = (data & 0x04) ? 1 : 7;
1749		tape_change_speed(state->m_cassette, newspeed);
	1698	tape_change_speed(m_cassette, newspeed);
1750	1699	}
1751	1700
1752		state->m_i8041_p1 = data;
	1701	m_i8041_p1 = data;
1753	1702	}
1754	1703
1755		READ8_HANDLER( i8041_p1_r )
	1704	READ8_MEMBER(decocass_state::i8041_p1_r)
1756	1705	{
1757		decocass_state *state = space.machine().driver_data<decocass_state>();
1758		UINT8 data = state->m_i8041_p1;
	1706	UINT8 data = m_i8041_p1;
1759	1707
1760		if (data != state->m_i8041_p1_read_latch)
	1708	if (data != m_i8041_p1_read_latch)
1761	1709	{
1762	1710	LOG(4,("%10s 8041-PC: %03x i8041_p1_r: $%02x (%s%s%s%s%s%s%s%s)\n",
1763	1711	space.machine().time().as_string(6),
r18037	r18038
1771	1719	data & 0x20 ? "" : " FWD",
1772	1720	data & 0x40 ? "" : " WREN",
1773	1721	data & 0x80 ? "" : " REQ"));
1774		state->m_i8041_p1_read_latch = data;
	1722	m_i8041_p1_read_latch = data;
1775	1723	}
1776	1724	return data;
1777	1725	}
1778	1726
1779		WRITE8_HANDLER( i8041_p2_w )
	1727	WRITE8_MEMBER(decocass_state::i8041_p2_w)
1780	1728	{
1781		decocass_state *state = space.machine().driver_data<decocass_state>();
1782		if (data != state->m_i8041_p2_write_latch)
	1729	if (data != m_i8041_p2_write_latch)
1783	1730	{
1784	1731	LOG(4,("%10s 8041-PC: %03x i8041_p2_w: $%02x (%s%s%s%s%s%s%s%s)\n",
1785	1732	space.machine().time().as_string(6),
r18037	r18038
1793	1740	data & 0x20 ? " [BOT-EOT]" : "",
1794	1741	data & 0x40 ? " [RCLK]" : "",
1795	1742	data & 0x80 ? " [RDATA]" : ""));
1796		state->m_i8041_p2_write_latch = data;
	1743	m_i8041_p2_write_latch = data;
1797	1744	}
1798		state->m_i8041_p2 = (state->m_i8041_p2 & 0xe0) | (data & ~0xe0);
	1745	m_i8041_p2 = (m_i8041_p2 & 0xe0) | (data & ~0xe0);
1799	1746	}
1800	1747
1801		READ8_HANDLER( i8041_p2_r )
	1748	READ8_MEMBER(decocass_state::i8041_p2_r)
1802	1749	{
1803		decocass_state *state = space.machine().driver_data<decocass_state>();
1804	1750	UINT8 data;
1805	1751
1806		data = (state->m_i8041_p2 & ~0xe0) | tape_get_status_bits(state->m_cassette);
	1752	data = (m_i8041_p2 & ~0xe0) | tape_get_status_bits(m_cassette);
1807	1753
1808		if (data != state->m_i8041_p2_read_latch)
	1754	if (data != m_i8041_p2_read_latch)
1809	1755	{
1810	1756	LOG(4,("%10s 8041-PC: %03x i8041_p2_r: $%02x (%s%s%s%s%s%s%s%s)\n",
1811	1757	space.machine().time().as_string(6),
r18037	r18038
1819	1765	data & 0x20 ? " [BOT-EOT]" : "",
1820	1766	data & 0x40 ? " [RCLK]" : "",
1821	1767	data & 0x80 ? " [RDATA]" : ""));
1822		state->m_i8041_p2_read_latch = data;
	1768	m_i8041_p2_read_latch = data;
1823	1769	}
1824	1770	return data;
1825	1771	}
1826
1827
1828
1829		/***************************************************************************
1830		CASSETTE DEVICE INTERFACE
1831		***************************************************************************/
1832
1833		/* regions within the virtual tape */
1834		enum tape_region
1835		{
1836		REGION_LEADER,            /* in clear leader section */
1837		REGION_LEADER_GAP,         /* in gap between leader and BOT */
1838		REGION_BOT,               /* in BOT hole */
1839		REGION_BOT_GAP,            /* in gap between BOT hole and data */
1840		REGION_DATA_BLOCK_0,      /* in data block 0 */
1841		REGION_DATA_BLOCK_255 = REGION_DATA_BLOCK_0 + 255,
1842		REGION_EOT_GAP,            /* in gap between data and EOT hole */
1843		REGION_EOT,               /* in EOT hole */
1844		REGION_TRAILER_GAP,         /* in gap between trailer and EOT */
1845		REGION_TRAILER            /* in clear trailer section */
1846		};
1847
1848
1849		/* bytes within a data block on a virtual tape */
1850		enum tape_byte
1851		{
1852		BYTE_PRE_GAP_0,            /* 34 bytes of gap, clock held to 0, no data */
1853		BYTE_PRE_GAP_33 = BYTE_PRE_GAP_0 + 33,
1854		BYTE_LEADIN,            /* 1 leadin byte, clocked value 0x00 */
1855		BYTE_HEADER,            /* 1 header byte, clocked value 0xAA */
1856		BYTE_DATA_0,            /* 256 bytes of data, clocked */
1857		BYTE_DATA_255 = BYTE_DATA_0 + 255,
1858		BYTE_CRC16_MSB,            /* 2 bytes of CRC, clocked MSB first, then LSB */
1859		BYTE_CRC16_LSB,
1860		BYTE_TRAILER,            /* 1 trailer byte, clocked value 0xAA */
1861		BYTE_LEADOUT,            /* 1 leadout byte, clocked value 0x00 */
1862		BYTE_LONGCLOCK,            /* 1 longclock byte, clock held to 1, no data */
1863		BYTE_POSTGAP_0,            /* 34 bytes of gap, no clock, no data */
1864		BYTE_POSTGAP_33 = BYTE_POSTGAP_0 + 33,
1865		BYTE_BLOCK_TOTAL         /* total number of bytes in block */
1866		};
1867
1868
1869		/* state of the tape */
1870		struct tape_state
1871		{
1872		running_machine *   machine;         /* pointer back to the machine */
1873		emu_timer *         timer;            /* timer for running the tape */
1874		INT8            speed;            /* speed: <-1=fast rewind, -1=reverse, 0=stopped, 1=normal, >1=fast forward */
1875		tape_region         region;            /* current region */
1876		tape_byte         bytenum;         /* byte number within a datablock */
1877		UINT8            bitnum;            /* bit number within a byte */
1878		UINT32            clockpos;         /* the current clock position of the tape */
1879		UINT32            numclocks;         /* total number of clocks on the entire tape */
1880		UINT16            crc16[256];         /* CRC16 for each block */
1881		};
1882
1883
1884		/* number of tape clock pulses per second */
1885		#define TAPE_CLOCKRATE               4800
1886		#define TAPE_CLOCKS_PER_BIT            2
1887		#define TAPE_CLOCKS_PER_BYTE         (8 * TAPE_CLOCKS_PER_BIT)
1888		#define TAPE_MSEC_TO_CLOCKS(x)         ((x) * TAPE_CLOCKRATE / 1000)
1889
1890
1891		/* Note on a tapes leader-BOT-data-EOT-trailer format:
1892		* A cassette has a transparent piece of tape on both ends,
1893		* leader and trailer. And data tapes also have BOT and EOT
1894		* holes, shortly before the the leader and trailer.
1895		* The holes and clear tape are detected using a photo-resitor.
1896		* When rewinding, the BOT/EOT signal will show a short
1897		* pulse and if rewind continues a constant high signal later.
1898		* The specs say the holes are "> 2ms" in length.
1899		*/
1900
1901		/* duration of the clear LEADER (and trailer) of the tape */
1902		#define REGION_LEADER_START_CLOCK      0
1903		#define REGION_LEADER_LEN_CLOCKS      TAPE_MSEC_TO_CLOCKS(1000)   /* 1s */
1904		#define REGION_LEADER_END_CLOCK         (REGION_LEADER_START_CLOCK+REGION_LEADER_LEN_CLOCKS)
1905
1906		/* duration of the GAP between leader and BOT/EOT */
1907		#define REGION_LEADER_GAP_START_CLOCK   REGION_LEADER_END_CLOCK
1908		#define REGION_LEADER_GAP_LEN_CLOCKS   TAPE_MSEC_TO_CLOCKS(1500)   /* 1.5s */
1909		#define REGION_LEADER_GAP_END_CLOCK      (REGION_LEADER_GAP_START_CLOCK+REGION_LEADER_GAP_LEN_CLOCKS)
1910
1911		/* duration of BOT/EOT holes */
1912		#define REGION_BOT_START_CLOCK         REGION_LEADER_GAP_END_CLOCK
1913		#define REGION_BOT_LEN_CLOCKS         TAPE_MSEC_TO_CLOCKS(2.5)   /* 0.0025s */
1914		#define REGION_BOT_END_CLOCK         (REGION_BOT_START_CLOCK+REGION_BOT_LEN_CLOCKS)
1915
1916		/* gap between BOT/EOT and first/last data block */
1917		#define REGION_BOT_GAP_START_CLOCK      REGION_BOT_END_CLOCK
1918		#define REGION_BOT_GAP_LEN_CLOCKS      TAPE_MSEC_TO_CLOCKS(300)   /* 300ms */
1919		#define REGION_BOT_GAP_END_CLOCK      (REGION_BOT_GAP_START_CLOCK+REGION_BOT_GAP_LEN_CLOCKS)
1920
1921
1922		/*-------------------------------------------------
1923		get_safe_token - makes sure that the passed
1924		in device is, in fact, an IDE controller
1925		-------------------------------------------------*/
1926
1927		INLINE tape_state *get_safe_token(device_t *device)
1928		{
1929		assert(device != NULL);
1930		assert(device->type() == DECOCASS_TAPE);
1931
1932		return (tape_state *)downcast<decocass_tape_device *>(device)->token();
1933		}
1934
1935
1936		/*-------------------------------------------------
1937		tape_crc16_byte - accumulate 8 bits worth of
1938		CRC data
1939		-------------------------------------------------*/
1940
1941		static UINT16 tape_crc16_byte(UINT16 crc, UINT8 data)
1942		{
1943		int bit;
1944
1945		for (bit = 0; bit < 8; bit++)
1946		{
1947		crc = (crc >> 1) | (crc << 15);
1948		crc ^= (data << 7) & 0x80;
1949		if (crc & 0x80)
1950		crc ^= 0x0120;
1951		data >>= 1;
1952		}
1953		return crc;
1954		}
1955
1956
1957		/*-------------------------------------------------
1958		tape_describe_state - create a string that
1959		describes the state of the tape
1960		-------------------------------------------------*/
1961
1962		static const char *tape_describe_state(tape_state *tape)
1963		{
1964		static char buffer[40];
1965		char temprname[40];
1966		const char *rname = temprname;
1967
1968		if (tape->region == REGION_LEADER)
1969		rname = "LEAD";
1970		else if (tape->region == REGION_LEADER_GAP)
1971		rname = "LGAP";
1972		else if (tape->region == REGION_BOT)
1973		rname = "BOT ";
1974		else if (tape->region == REGION_BOT_GAP)
1975		rname = "BGAP";
1976		else if (tape->region == REGION_TRAILER)
1977		rname = "TRLR";
1978		else if (tape->region == REGION_TRAILER_GAP)
1979		rname = "TGAP";
1980		else if (tape->region == REGION_EOT)
1981		rname = "EOT ";
1982		else if (tape->region == REGION_EOT_GAP)
1983		rname = "EGAP";
1984		else
1985		{
1986		char tempbname[40];
1987		const char *bname = tempbname;
1988		int clk;
1989
1990		if (tape->bytenum <= BYTE_PRE_GAP_33)
1991		sprintf(tempbname, "PR%02d", tape->bytenum - BYTE_PRE_GAP_0);
1992		else if (tape->bytenum == BYTE_LEADIN)
1993		bname = "LDIN";
1994		else if (tape->bytenum == BYTE_HEADER)
1995		bname = "HEAD";
1996		else if (tape->bytenum <= BYTE_DATA_255)
1997		sprintf(tempbname, "BY%02X", tape->bytenum - BYTE_DATA_0);
1998		else if (tape->bytenum == BYTE_CRC16_MSB)
1999		bname = "CRCM";
2000		else if (tape->bytenum == BYTE_CRC16_LSB)
2001		bname = "CRCL";
2002		else if (tape->bytenum == BYTE_TRAILER)
2003		bname = "TRLR";
2004		else if (tape->bytenum == BYTE_LEADOUT)
2005		bname = "LOUT";
2006		else if (tape->bytenum == BYTE_LONGCLOCK)
2007		bname = "LONG";
2008		else
2009		sprintf(tempbname, "PO%02d", tape->bytenum - BYTE_POSTGAP_0);
2010
2011		/* in the main data area, the clock alternates at the clock rate */
2012		if (tape->bytenum >= BYTE_LEADIN && tape->bytenum <= BYTE_LEADOUT)
2013		clk = ((UINT32)(tape->clockpos - REGION_BOT_GAP_END_CLOCK) & 1) ? 0 : 1;
2014		else if (tape->bytenum == BYTE_LONGCLOCK)
2015		clk = 1;
2016		else
2017		clk = 0;
2018
2019		sprintf(temprname, "BL%02X.%4s.%d.%d", tape->region - REGION_DATA_BLOCK_0, bname, tape->bitnum, clk);
2020		}
2021
2022		sprintf(buffer, "{%9d=%s}", tape->clockpos, rname);
2023		return buffer;
2024		}
2025
2026
2027		/*-------------------------------------------------
2028		tape_clock_callback - called once per clock
2029		to increment/decrement the tape location
2030		-------------------------------------------------*/
2031
2032		static TIMER_CALLBACK( tape_clock_callback )
2033		{
2034		device_t *device = (device_t *)ptr;
2035		tape_state *tape = get_safe_token(device);
2036
2037		/* advance by one clock in the desired direction */
2038		if (tape->speed < 0 && tape->clockpos > 0)
2039		tape->clockpos--;
2040		else if (tape->speed > 0 && tape->clockpos < tape->numclocks)
2041		tape->clockpos++;
2042
2043		/* look for states before the start of data */
2044		if (tape->clockpos < REGION_LEADER_END_CLOCK)
2045		tape->region = REGION_LEADER;
2046		else if (tape->clockpos < REGION_LEADER_GAP_END_CLOCK)
2047		tape->region = REGION_LEADER_GAP;
2048		else if (tape->clockpos < REGION_BOT_END_CLOCK)
2049		tape->region = REGION_BOT;
2050		else if (tape->clockpos < REGION_BOT_GAP_END_CLOCK)
2051		tape->region = REGION_BOT_GAP;
2052
2053		/* look for states after the end of data */
2054		else if (tape->clockpos >= tape->numclocks - REGION_LEADER_END_CLOCK)
2055		tape->region = REGION_TRAILER;
2056		else if (tape->clockpos >= tape->numclocks - REGION_LEADER_GAP_END_CLOCK)
2057		tape->region = REGION_TRAILER_GAP;
2058		else if (tape->clockpos >= tape->numclocks - REGION_BOT_END_CLOCK)
2059		tape->region = REGION_EOT;
2060		else if (tape->clockpos >= tape->numclocks - REGION_BOT_GAP_END_CLOCK)
2061		tape->region = REGION_EOT_GAP;
2062
2063		/* everything else is data */
2064		else
2065		{
2066		UINT32 dataclock = tape->clockpos - REGION_BOT_GAP_END_CLOCK;
2067
2068		/* compute the block number */
2069		tape->region = (tape_region)(REGION_DATA_BLOCK_0 + dataclock / (TAPE_CLOCKS_PER_BYTE * BYTE_BLOCK_TOTAL));
2070		dataclock -= (tape->region - REGION_DATA_BLOCK_0) * TAPE_CLOCKS_PER_BYTE * BYTE_BLOCK_TOTAL;
2071
2072		/* compute the byte within the block */
2073		tape->bytenum = (tape_byte)(dataclock / TAPE_CLOCKS_PER_BYTE);
2074		dataclock -= tape->bytenum * TAPE_CLOCKS_PER_BYTE;
2075
2076		/* compute the bit within the byte */
2077		tape->bitnum = dataclock / TAPE_CLOCKS_PER_BIT;
2078		}
2079
2080		/* log */
2081		if (LOG_CASSETTE_STATE)
2082		tape_describe_state(tape);
2083		}
2084
2085
2086		/*-------------------------------------------------
2087		tape_get_status_bits - return the 3 status
2088		bits from the tape
2089		-------------------------------------------------*/
2090
2091		static UINT8 tape_get_status_bits(device_t *device)
2092		{
2093		tape_state *tape = get_safe_token(device);
2094		UINT8 tape_bits = 0;
2095
2096		/* bit 0x20 is the BOT/EOT signal, which is also set in the leader/trailer area */
2097		if (tape->region == REGION_LEADER || tape->region == REGION_BOT || tape->region == REGION_EOT || tape->region == REGION_TRAILER)
2098		tape_bits |= 0x20;
2099
2100		/* bit 0x40 is the clock, which is only valid in some areas of the data block */
2101		/* bit 0x80 is the data, which is only valid in some areas of the data block */
2102		if (tape->region >= REGION_DATA_BLOCK_0 && tape->region <= REGION_DATA_BLOCK_255)
2103		{
2104		int blocknum = tape->region - REGION_DATA_BLOCK_0;
2105		UINT8 byteval = 0x00;
2106
2107		/* in the main data area, the clock alternates at the clock rate */
2108		if (tape->bytenum >= BYTE_LEADIN && tape->bytenum <= BYTE_LEADOUT)
2109		tape_bits |= ((UINT32)(tape->clockpos - REGION_BOT_GAP_END_CLOCK) & 1) ? 0x00 : 0x40;
2110
2111		/* in the longclock area, the clock holds high */
2112		else if (tape->bytenum == BYTE_LONGCLOCK)
2113		tape_bits |= 0x40;
2114
2115		/* everywhere else, the clock holds to 0 */
2116		else
2117		;
2118
2119		/* lead-in and lead-out bytes are 0xAA */
2120		if (tape->bytenum == BYTE_HEADER || tape->bytenum == BYTE_TRAILER)
2121		byteval = 0xaa;
2122
2123		/* data block bytes are data */
2124		else if (tape->bytenum >= BYTE_DATA_0 && tape->bytenum <= BYTE_DATA_255)
2125		byteval = static_cast<UINT8 *>(*device->region())[blocknum * 256 + (tape->bytenum - BYTE_DATA_0)];
2126
2127		/* CRC MSB */
2128		else if (tape->bytenum == BYTE_CRC16_MSB)
2129		byteval = tape->crc16[blocknum] >> 8;
2130
2131		/* CRC LSB */
2132		else if (tape->bytenum == BYTE_CRC16_LSB)
2133		byteval = tape->crc16[blocknum];
2134
2135		/* select the appropriate bit from the byte and move to the upper bit */
2136		if ((byteval >> tape->bitnum) & 1)
2137		tape_bits |= 0x80;
2138		}
2139		return tape_bits;
2140		}
2141
2142
2143		/*-------------------------------------------------
2144		tape_is_present - return TRUE if the tape is
2145		present
2146		-------------------------------------------------*/
2147
2148		static UINT8 tape_is_present(device_t *device)
2149		{
2150		return device->region() != NULL;
2151		}
2152
2153
2154		/*-------------------------------------------------
2155		tape_change_speed - alter the speed of tape
2156		playback
2157		-------------------------------------------------*/
2158
2159		static void tape_change_speed(device_t *device, INT8 newspeed)
2160		{
2161		tape_state *tape = get_safe_token(device);
2162		attotime newperiod;
2163		INT8 absnewspeed;
2164
2165		/* do nothing if speed has not changed */
2166		if (tape->speed == newspeed)
2167		return;
2168
2169		/* compute how fast to run the tape timer */
2170		absnewspeed = (newspeed < 0) ? -newspeed : newspeed;
2171		if (newspeed == 0)
2172		newperiod = attotime::never;
2173		else
2174		newperiod = attotime::from_hz(TAPE_CLOCKRATE * absnewspeed);
2175
2176		/* set the new speed */
2177		tape->timer->adjust(newperiod, 0, newperiod);
2178		tape->speed = newspeed;
2179		}
2180
2181
2182		/*-------------------------------------------------
2183		device start callback
2184		-------------------------------------------------*/
2185
2186		static DEVICE_START( decocass_tape )
2187		{
2188		tape_state *tape = get_safe_token(device);
2189		int curblock, offs, numblocks;
2190
2191		/* validate some basic stuff */
2192		assert(device != NULL);
2193		assert(device->static_config() == NULL);
2194
2195		/* fetch the data pointer */
2196		tape->timer = device->machine().scheduler().timer_alloc(FUNC(tape_clock_callback), (void *)device);
2197		if (device->region() == NULL)
2198		return;
2199		UINT8 *regionbase = *device->region();
2200
2201		/* scan for the first non-empty block in the image */
2202		for (offs = device->region()->bytes() - 1; offs >= 0; offs--)
2203		if (regionbase[offs] != 0)
2204		break;
2205		numblocks = ((offs | 0xff) + 1) / 256;
2206		assert(numblocks < ARRAY_LENGTH(tape->crc16));
2207
2208		/* compute the total length */
2209		tape->numclocks = REGION_BOT_GAP_END_CLOCK + numblocks * BYTE_BLOCK_TOTAL * 16 + REGION_BOT_GAP_END_CLOCK;
2210
2211		/* compute CRCs for each block */
2212		for (curblock = 0; curblock < numblocks; curblock++)
2213		{
2214		UINT16 crc = 0;
2215		int testval;
2216
2217		/* first CRC the 256 bytes of data */
2218		for (offs = 256 * curblock; offs < 256 * curblock + 256; offs++)
2219		crc = tape_crc16_byte(crc, regionbase[offs]);
2220
2221		/* then find a pair of bytes that will bring the CRC to 0 (any better way than brute force?) */
2222		for (testval = 0; testval < 0x10000; testval++)
2223		if (tape_crc16_byte(tape_crc16_byte(crc, testval >> 8), testval) == 0)
2224		break;
2225		tape->crc16[curblock] = testval;
2226		}
2227
2228		/* register states */
2229		device->save_item(NAME(tape->speed));
2230		device->save_item(NAME(tape->bitnum));
2231		device->save_item(NAME(tape->clockpos));
2232		}
2233
2234
2235		/*-------------------------------------------------
2236		device reset callback
2237		-------------------------------------------------*/
2238
2239		static DEVICE_RESET( decocass_tape )
2240		{
2241		/* turn the tape off */
2242		tape_change_speed(device, 0);
2243		}
2244
2245
2246		const device_type DECOCASS_TAPE = &device_creator<decocass_tape_device>;
2247
2248		decocass_tape_device::decocass_tape_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2249		: device_t(mconfig, DECOCASS_TAPE, "DECO Cassette Tape", tag, owner, clock)
2250		{
2251		m_token = global_alloc_clear(tape_state);
2252		}
2253
2254		//-------------------------------------------------
2255		//  device_config_complete - perform any
2256		//  operations now that the configuration is
2257		//  complete
2258		//-------------------------------------------------
2259
2260		void decocass_tape_device::device_config_complete()
2261		{
2262		}
2263
2264		//-------------------------------------------------
2265		//  device_start - device-specific startup
2266		//-------------------------------------------------
2267
2268		void decocass_tape_device::device_start()
2269		{
2270		DEVICE_START_NAME( decocass_tape )(this);
2271		}
2272
2273		//-------------------------------------------------
2274		//  device_reset - device-specific reset
2275		//-------------------------------------------------
2276
2277		void decocass_tape_device::device_reset()
2278		{
2279		DEVICE_RESET_NAME( decocass_tape )(this);
2280		}
2281
2282

trunk/src/mame/machine/decocass_tape.c

r0	r18038
	1	/***********************************************************************
	2
	3	DECO Cassette System machine
	4
	5	***********************************************************************/
	6
	7	#include "emu.h"
	8	#include "cpu/m6502/m6502.h"
	9	#include "cpu/mcs48/mcs48.h"
	10	#include "machine/decocass_tape.h"
	11
	12	#define LOG_CASSETTE_STATE      0
	13
	14	/***************************************************************************
	15	CASSETTE DEVICE INTERFACE
	16	***************************************************************************/
	17
	18	/* regions within the virtual tape */
	19	enum tape_region
	20	{
	21	REGION_LEADER,            /* in clear leader section */
	22	REGION_LEADER_GAP,         /* in gap between leader and BOT */
	23	REGION_BOT,               /* in BOT hole */
	24	REGION_BOT_GAP,            /* in gap between BOT hole and data */
	25	REGION_DATA_BLOCK_0,      /* in data block 0 */
	26	REGION_DATA_BLOCK_255 = REGION_DATA_BLOCK_0 + 255,
	27	REGION_EOT_GAP,            /* in gap between data and EOT hole */
	28	REGION_EOT,               /* in EOT hole */
	29	REGION_TRAILER_GAP,         /* in gap between trailer and EOT */
	30	REGION_TRAILER            /* in clear trailer section */
	31	};
	32
	33
	34	/* bytes within a data block on a virtual tape */
	35	enum tape_byte
	36	{
	37	BYTE_PRE_GAP_0,            /* 34 bytes of gap, clock held to 0, no data */
	38	BYTE_PRE_GAP_33 = BYTE_PRE_GAP_0 + 33,
	39	BYTE_LEADIN,            /* 1 leadin byte, clocked value 0x00 */
	40	BYTE_HEADER,            /* 1 header byte, clocked value 0xAA */
	41	BYTE_DATA_0,            /* 256 bytes of data, clocked */
	42	BYTE_DATA_255 = BYTE_DATA_0 + 255,
	43	BYTE_CRC16_MSB,            /* 2 bytes of CRC, clocked MSB first, then LSB */
	44	BYTE_CRC16_LSB,
	45	BYTE_TRAILER,            /* 1 trailer byte, clocked value 0xAA */
	46	BYTE_LEADOUT,            /* 1 leadout byte, clocked value 0x00 */
	47	BYTE_LONGCLOCK,            /* 1 longclock byte, clock held to 1, no data */
	48	BYTE_POSTGAP_0,            /* 34 bytes of gap, no clock, no data */
	49	BYTE_POSTGAP_33 = BYTE_POSTGAP_0 + 33,
	50	BYTE_BLOCK_TOTAL         /* total number of bytes in block */
	51	};
	52
	53
	54	/* state of the tape */
	55	struct tape_state
	56	{
	57	running_machine *   machine;         /* pointer back to the machine */
	58	emu_timer *         timer;            /* timer for running the tape */
	59	INT8            speed;            /* speed: <-1=fast rewind, -1=reverse, 0=stopped, 1=normal, >1=fast forward */
	60	tape_region         region;            /* current region */
	61	tape_byte         bytenum;         /* byte number within a datablock */
	62	UINT8            bitnum;            /* bit number within a byte */
	63	UINT32            clockpos;         /* the current clock position of the tape */
	64	UINT32            numclocks;         /* total number of clocks on the entire tape */
	65	UINT16            crc16[256];         /* CRC16 for each block */
	66	};
	67
	68
	69	/* number of tape clock pulses per second */
	70	#define TAPE_CLOCKRATE               4800
	71	#define TAPE_CLOCKS_PER_BIT            2
	72	#define TAPE_CLOCKS_PER_BYTE         (8 * TAPE_CLOCKS_PER_BIT)
	73	#define TAPE_MSEC_TO_CLOCKS(x)         ((x) * TAPE_CLOCKRATE / 1000)
	74
	75
	76	/* Note on a tapes leader-BOT-data-EOT-trailer format:
	77	* A cassette has a transparent piece of tape on both ends,
	78	* leader and trailer. And data tapes also have BOT and EOT
	79	* holes, shortly before the the leader and trailer.
	80	* The holes and clear tape are detected using a photo-resitor.
	81	* When rewinding, the BOT/EOT signal will show a short
	82	* pulse and if rewind continues a constant high signal later.
	83	* The specs say the holes are "> 2ms" in length.
	84	*/
	85
	86	/* duration of the clear LEADER (and trailer) of the tape */
	87	#define REGION_LEADER_START_CLOCK      0
	88	#define REGION_LEADER_LEN_CLOCKS      TAPE_MSEC_TO_CLOCKS(1000)   /* 1s */
	89	#define REGION_LEADER_END_CLOCK         (REGION_LEADER_START_CLOCK+REGION_LEADER_LEN_CLOCKS)
	90
	91	/* duration of the GAP between leader and BOT/EOT */
	92	#define REGION_LEADER_GAP_START_CLOCK   REGION_LEADER_END_CLOCK
	93	#define REGION_LEADER_GAP_LEN_CLOCKS   TAPE_MSEC_TO_CLOCKS(1500)   /* 1.5s */
	94	#define REGION_LEADER_GAP_END_CLOCK      (REGION_LEADER_GAP_START_CLOCK+REGION_LEADER_GAP_LEN_CLOCKS)
	95
	96	/* duration of BOT/EOT holes */
	97	#define REGION_BOT_START_CLOCK         REGION_LEADER_GAP_END_CLOCK
	98	#define REGION_BOT_LEN_CLOCKS         TAPE_MSEC_TO_CLOCKS(2.5)   /* 0.0025s */
	99	#define REGION_BOT_END_CLOCK         (REGION_BOT_START_CLOCK+REGION_BOT_LEN_CLOCKS)
	100
	101	/* gap between BOT/EOT and first/last data block */
	102	#define REGION_BOT_GAP_START_CLOCK      REGION_BOT_END_CLOCK
	103	#define REGION_BOT_GAP_LEN_CLOCKS      TAPE_MSEC_TO_CLOCKS(300)   /* 300ms */
	104	#define REGION_BOT_GAP_END_CLOCK      (REGION_BOT_GAP_START_CLOCK+REGION_BOT_GAP_LEN_CLOCKS)
	105
	106
	107	/*-------------------------------------------------
	108	get_safe_token - makes sure that the passed
	109	in device is, in fact, an IDE controller
	110	-------------------------------------------------*/
	111
	112	INLINE tape_state *get_safe_token(device_t *device)
	113	{
	114	assert(device != NULL);
	115	assert(device->type() == DECOCASS_TAPE);
	116
	117	return (tape_state *)downcast<decocass_tape_device *>(device)->token();
	118	}
	119
	120
	121	/*-------------------------------------------------
	122	tape_crc16_byte - accumulate 8 bits worth of
	123	CRC data
	124	-------------------------------------------------*/
	125
	126	static UINT16 tape_crc16_byte(UINT16 crc, UINT8 data)
	127	{
	128	int bit;
	129
	130	for (bit = 0; bit < 8; bit++)
	131	{
	132	crc = (crc >> 1) | (crc << 15);
	133	crc ^= (data << 7) & 0x80;
	134	if (crc & 0x80)
	135	crc ^= 0x0120;
	136	data >>= 1;
	137	}
	138	return crc;
	139	}
	140
	141
	142	/*-------------------------------------------------
	143	tape_describe_state - create a string that
	144	describes the state of the tape
	145	-------------------------------------------------*/
	146
	147	static const char *tape_describe_state(tape_state *tape)
	148	{
	149	static char buffer[40];
	150	char temprname[40];
	151	const char *rname = temprname;
	152
	153	if (tape->region == REGION_LEADER)
	154	rname = "LEAD";
	155	else if (tape->region == REGION_LEADER_GAP)
	156	rname = "LGAP";
	157	else if (tape->region == REGION_BOT)
	158	rname = "BOT ";
	159	else if (tape->region == REGION_BOT_GAP)
	160	rname = "BGAP";
	161	else if (tape->region == REGION_TRAILER)
	162	rname = "TRLR";
	163	else if (tape->region == REGION_TRAILER_GAP)
	164	rname = "TGAP";
	165	else if (tape->region == REGION_EOT)
	166	rname = "EOT ";
	167	else if (tape->region == REGION_EOT_GAP)
	168	rname = "EGAP";
	169	else
	170	{
	171	char tempbname[40];
	172	const char *bname = tempbname;
	173	int clk;
	174
	175	if (tape->bytenum <= BYTE_PRE_GAP_33)
	176	sprintf(tempbname, "PR%02d", tape->bytenum - BYTE_PRE_GAP_0);
	177	else if (tape->bytenum == BYTE_LEADIN)
	178	bname = "LDIN";
	179	else if (tape->bytenum == BYTE_HEADER)
	180	bname = "HEAD";
	181	else if (tape->bytenum <= BYTE_DATA_255)
	182	sprintf(tempbname, "BY%02X", tape->bytenum - BYTE_DATA_0);
	183	else if (tape->bytenum == BYTE_CRC16_MSB)
	184	bname = "CRCM";
	185	else if (tape->bytenum == BYTE_CRC16_LSB)
	186	bname = "CRCL";
	187	else if (tape->bytenum == BYTE_TRAILER)
	188	bname = "TRLR";
	189	else if (tape->bytenum == BYTE_LEADOUT)
	190	bname = "LOUT";
	191	else if (tape->bytenum == BYTE_LONGCLOCK)
	192	bname = "LONG";
	193	else
	194	sprintf(tempbname, "PO%02d", tape->bytenum - BYTE_POSTGAP_0);
	195
	196	/* in the main data area, the clock alternates at the clock rate */
	197	if (tape->bytenum >= BYTE_LEADIN && tape->bytenum <= BYTE_LEADOUT)
	198	clk = ((UINT32)(tape->clockpos - REGION_BOT_GAP_END_CLOCK) & 1) ? 0 : 1;
	199	else if (tape->bytenum == BYTE_LONGCLOCK)
	200	clk = 1;
	201	else
	202	clk = 0;
	203
	204	sprintf(temprname, "BL%02X.%4s.%d.%d", tape->region - REGION_DATA_BLOCK_0, bname, tape->bitnum, clk);
	205	}
	206
	207	sprintf(buffer, "{%9d=%s}", tape->clockpos, rname);
	208	return buffer;
	209	}
	210
	211
	212	/*-------------------------------------------------
	213	tape_clock_callback - called once per clock
	214	to increment/decrement the tape location
	215	-------------------------------------------------*/
	216
	217	static TIMER_CALLBACK( tape_clock_callback )
	218	{
	219	device_t *device = (device_t *)ptr;
	220	tape_state *tape = get_safe_token(device);
	221
	222	/* advance by one clock in the desired direction */
	223	if (tape->speed < 0 && tape->clockpos > 0)
	224	tape->clockpos--;
	225	else if (tape->speed > 0 && tape->clockpos < tape->numclocks)
	226	tape->clockpos++;
	227
	228	/* look for states before the start of data */
	229	if (tape->clockpos < REGION_LEADER_END_CLOCK)
	230	tape->region = REGION_LEADER;
	231	else if (tape->clockpos < REGION_LEADER_GAP_END_CLOCK)
	232	tape->region = REGION_LEADER_GAP;
	233	else if (tape->clockpos < REGION_BOT_END_CLOCK)
	234	tape->region = REGION_BOT;
	235	else if (tape->clockpos < REGION_BOT_GAP_END_CLOCK)
	236	tape->region = REGION_BOT_GAP;
	237
	238	/* look for states after the end of data */
	239	else if (tape->clockpos >= tape->numclocks - REGION_LEADER_END_CLOCK)
	240	tape->region = REGION_TRAILER;
	241	else if (tape->clockpos >= tape->numclocks - REGION_LEADER_GAP_END_CLOCK)
	242	tape->region = REGION_TRAILER_GAP;
	243	else if (tape->clockpos >= tape->numclocks - REGION_BOT_END_CLOCK)
	244	tape->region = REGION_EOT;
	245	else if (tape->clockpos >= tape->numclocks - REGION_BOT_GAP_END_CLOCK)
	246	tape->region = REGION_EOT_GAP;
	247
	248	/* everything else is data */
	249	else
	250	{
	251	UINT32 dataclock = tape->clockpos - REGION_BOT_GAP_END_CLOCK;
	252
	253	/* compute the block number */
	254	tape->region = (tape_region)(REGION_DATA_BLOCK_0 + dataclock / (TAPE_CLOCKS_PER_BYTE * BYTE_BLOCK_TOTAL));
	255	dataclock -= (tape->region - REGION_DATA_BLOCK_0) * TAPE_CLOCKS_PER_BYTE * BYTE_BLOCK_TOTAL;
	256
	257	/* compute the byte within the block */
	258	tape->bytenum = (tape_byte)(dataclock / TAPE_CLOCKS_PER_BYTE);
	259	dataclock -= tape->bytenum * TAPE_CLOCKS_PER_BYTE;
	260
	261	/* compute the bit within the byte */
	262	tape->bitnum = dataclock / TAPE_CLOCKS_PER_BIT;
	263	}
	264
	265	/* log */
	266	if (LOG_CASSETTE_STATE)
	267	tape_describe_state(tape);
	268	}
	269
	270
	271	/*-------------------------------------------------
	272	tape_get_status_bits - return the 3 status
	273	bits from the tape
	274	-------------------------------------------------*/
	275
	276	UINT8 tape_get_status_bits(device_t *device)
	277	{
	278	tape_state *tape = get_safe_token(device);
	279	UINT8 tape_bits = 0;
	280
	281	/* bit 0x20 is the BOT/EOT signal, which is also set in the leader/trailer area */
	282	if (tape->region == REGION_LEADER || tape->region == REGION_BOT || tape->region == REGION_EOT || tape->region == REGION_TRAILER)
	283	tape_bits |= 0x20;
	284
	285	/* bit 0x40 is the clock, which is only valid in some areas of the data block */
	286	/* bit 0x80 is the data, which is only valid in some areas of the data block */
	287	if (tape->region >= REGION_DATA_BLOCK_0 && tape->region <= REGION_DATA_BLOCK_255)
	288	{
	289	int blocknum = tape->region - REGION_DATA_BLOCK_0;
	290	UINT8 byteval = 0x00;
	291
	292	/* in the main data area, the clock alternates at the clock rate */
	293	if (tape->bytenum >= BYTE_LEADIN && tape->bytenum <= BYTE_LEADOUT)
	294	tape_bits |= ((UINT32)(tape->clockpos - REGION_BOT_GAP_END_CLOCK) & 1) ? 0x00 : 0x40;
	295
	296	/* in the longclock area, the clock holds high */
	297	else if (tape->bytenum == BYTE_LONGCLOCK)
	298	tape_bits |= 0x40;
	299
	300	/* everywhere else, the clock holds to 0 */
	301	else
	302	;
	303
	304	/* lead-in and lead-out bytes are 0xAA */
	305	if (tape->bytenum == BYTE_HEADER || tape->bytenum == BYTE_TRAILER)
	306	byteval = 0xaa;
	307
	308	/* data block bytes are data */
	309	else if (tape->bytenum >= BYTE_DATA_0 && tape->bytenum <= BYTE_DATA_255)
	310	byteval = static_cast<UINT8 *>(*device->region())[blocknum * 256 + (tape->bytenum - BYTE_DATA_0)];
	311
	312	/* CRC MSB */
	313	else if (tape->bytenum == BYTE_CRC16_MSB)
	314	byteval = tape->crc16[blocknum] >> 8;
	315
	316	/* CRC LSB */
	317	else if (tape->bytenum == BYTE_CRC16_LSB)
	318	byteval = tape->crc16[blocknum];
	319
	320	/* select the appropriate bit from the byte and move to the upper bit */
	321	if ((byteval >> tape->bitnum) & 1)
	322	tape_bits |= 0x80;
	323	}
	324	return tape_bits;
	325	}
	326
	327
	328	/*-------------------------------------------------
	329	tape_is_present - return TRUE if the tape is
	330	present
	331	-------------------------------------------------*/
	332
	333	UINT8 tape_is_present(device_t *device)
	334	{
	335	return device->region() != NULL;
	336	}
	337
	338
	339	/*-------------------------------------------------
	340	tape_change_speed - alter the speed of tape
	341	playback
	342	-------------------------------------------------*/
	343
	344	void tape_change_speed(device_t *device, INT8 newspeed)
	345	{
	346	tape_state *tape = get_safe_token(device);
	347	attotime newperiod;
	348	INT8 absnewspeed;
	349
	350	/* do nothing if speed has not changed */
	351	if (tape->speed == newspeed)
	352	return;
	353
	354	/* compute how fast to run the tape timer */
	355	absnewspeed = (newspeed < 0) ? -newspeed : newspeed;
	356	if (newspeed == 0)
	357	newperiod = attotime::never;
	358	else
	359	newperiod = attotime::from_hz(TAPE_CLOCKRATE * absnewspeed);
	360
	361	/* set the new speed */
	362	tape->timer->adjust(newperiod, 0, newperiod);
	363	tape->speed = newspeed;
	364	}
	365
	366
	367	/*-------------------------------------------------
	368	device start callback
	369	-------------------------------------------------*/
	370
	371	static DEVICE_START( decocass_tape )
	372	{
	373	tape_state *tape = get_safe_token(device);
	374	int curblock, offs, numblocks;
	375
	376	/* validate some basic stuff */
	377	assert(device != NULL);
	378	assert(device->static_config() == NULL);
	379
	380	/* fetch the data pointer */
	381	tape->timer = device->machine().scheduler().timer_alloc(FUNC(tape_clock_callback), (void *)device);
	382	if (device->region() == NULL)
	383	return;
	384	UINT8 *regionbase = *device->region();
	385
	386	/* scan for the first non-empty block in the image */
	387	for (offs = device->region()->bytes() - 1; offs >= 0; offs--)
	388	if (regionbase[offs] != 0)
	389	break;
	390	numblocks = ((offs | 0xff) + 1) / 256;
	391	assert(numblocks < ARRAY_LENGTH(tape->crc16));
	392
	393	/* compute the total length */
	394	tape->numclocks = REGION_BOT_GAP_END_CLOCK + numblocks * BYTE_BLOCK_TOTAL * 16 + REGION_BOT_GAP_END_CLOCK;
	395
	396	/* compute CRCs for each block */
	397	for (curblock = 0; curblock < numblocks; curblock++)
	398	{
	399	UINT16 crc = 0;
	400	int testval;
	401
	402	/* first CRC the 256 bytes of data */
	403	for (offs = 256 * curblock; offs < 256 * curblock + 256; offs++)
	404	crc = tape_crc16_byte(crc, regionbase[offs]);
	405
	406	/* then find a pair of bytes that will bring the CRC to 0 (any better way than brute force?) */
	407	for (testval = 0; testval < 0x10000; testval++)
	408	if (tape_crc16_byte(tape_crc16_byte(crc, testval >> 8), testval) == 0)
	409	break;
	410	tape->crc16[curblock] = testval;
	411	}
	412
	413	/* register states */
	414	device->save_item(NAME(tape->speed));
	415	device->save_item(NAME(tape->bitnum));
	416	device->save_item(NAME(tape->clockpos));
	417	}
	418
	419
	420	/*-------------------------------------------------
	421	device reset callback
	422	-------------------------------------------------*/
	423
	424	static DEVICE_RESET( decocass_tape )
	425	{
	426	/* turn the tape off */
	427	tape_change_speed(device, 0);
	428	}
	429
	430
	431	const device_type DECOCASS_TAPE = &device_creator<decocass_tape_device>;
	432
	433	decocass_tape_device::decocass_tape_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	434	: device_t(mconfig, DECOCASS_TAPE, "DECO Cassette Tape", tag, owner, clock)
	435	{
	436	m_token = global_alloc_clear(tape_state);
	437	}
	438
	439	//-------------------------------------------------
	440	//  device_config_complete - perform any
	441	//  operations now that the configuration is
	442	//  complete
	443	//-------------------------------------------------
	444
	445	void decocass_tape_device::device_config_complete()
	446	{
	447	}
	448
	449	//-------------------------------------------------
	450	//  device_start - device-specific startup
	451	//-------------------------------------------------
	452
	453	void decocass_tape_device::device_start()
	454	{
	455	DEVICE_START_NAME( decocass_tape )(this);
	456	}
	457
	458	//-------------------------------------------------
	459	//  device_reset - device-specific reset
	460	//-------------------------------------------------
	461
	462	void decocass_tape_device::device_reset()
	463	{
	464	DEVICE_RESET_NAME( decocass_tape )(this);
	465	}
	466
	467

trunk/src/mame/machine/decocass_tape.h

r0	r18038
	1	#ifndef __DECOCASS_TAPE_H__
	2	#define __DECOCASS_TAPE_H__
	3
	4	class decocass_tape_device : public device_t
	5	{
	6	public:
	7	decocass_tape_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	8	~decocass_tape_device() { global_free(m_token); }
	9
	10	// access to legacy token
	11	void *token() const { assert(m_token != NULL); return m_token; }
	12	protected:
	13	// device-level overrides
	14	virtual void device_config_complete();
	15	virtual void device_start();
	16	virtual void device_reset();
	17	private:
	18	// internal state
	19	void *m_token;
	20	};
	21
	22	extern const device_type DECOCASS_TAPE;
	23
	24	UINT8 tape_get_status_bits(device_t *device);
	25	UINT8 tape_is_present(device_t *device);
	26	void tape_change_speed(device_t *device, INT8 newspeed);
	27
	28
	29	#define MCFG_DECOCASS_TAPE_ADD(_tag) \
	30	MCFG_DEVICE_ADD(_tag, DECOCASS_TAPE, 0)
	31
	32	#endif

trunk/src/mame/video/decocass.c

r18037	r18038
5	5	***********************************************************************/
6	6
7	7	#include "emu.h"
8		#include "machine/decocass.h"
	8	#include "includes/decocass.h"
9	9
10	10
11	11	static const UINT32 tile_offset[32*32] = {
r18037	r18038
46	46	/********************************************
47	47	state saving setup
48	48	********************************************/
49		void decocass_video_state_save_init( running_machine &machine )
	49	void decocass_state::decocass_video_state_save_init()
50	50	{
51		decocass_state *state = machine.driver_data<decocass_state>();
52
53		state->save_item(NAME(state->m_watchdog_count));
54		state->save_item(NAME(state->m_watchdog_flip));
55		state->save_item(NAME(state->m_color_missiles));
56		state->save_item(NAME(state->m_color_center_bot));
57		state->save_item(NAME(state->m_mode_set));
58		state->save_item(NAME(state->m_back_h_shift));
59		state->save_item(NAME(state->m_back_vl_shift));
60		state->save_item(NAME(state->m_back_vr_shift));
61		state->save_item(NAME(state->m_part_h_shift));
62		state->save_item(NAME(state->m_part_v_shift));
63		state->save_item(NAME(state->m_center_h_shift_space));
64		state->save_item(NAME(state->m_center_v_shift));
	51	save_item(NAME(m_watchdog_count));
	52	save_item(NAME(m_watchdog_flip));
	53	save_item(NAME(m_color_missiles));
	54	save_item(NAME(m_color_center_bot));
	55	save_item(NAME(m_mode_set));
	56	save_item(NAME(m_back_h_shift));
	57	save_item(NAME(m_back_vl_shift));
	58	save_item(NAME(m_back_vr_shift));
	59	save_item(NAME(m_part_h_shift));
	60	save_item(NAME(m_part_v_shift));
	61	save_item(NAME(m_center_h_shift_space));
	62	save_item(NAME(m_center_v_shift));
65	63	}
66	64
67	65	/********************************************
r18037	r18038
115	113	big object
116	114	********************************************/
117	115
118		static void draw_object( running_machine& machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	116	void decocass_state::draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect)
119	117	{
120		decocass_state *state = machine.driver_data<decocass_state>();
121	118	int sx, sy, color;
122	119
123		if (0 == (state->m_mode_set & 0x80))  /* part_h_enable off? */
	120	if (0 == (m_mode_set & 0x80))  /* part_h_enable off? */
124	121	return;
125	122
126		color = (state->m_color_center_bot >> 4) & 15;
	123	color = (m_color_center_bot >> 4) & 15;
127	124
128		sy = 192 - (state->m_part_v_shift & 0x7f);
	125	sy = 192 - (m_part_v_shift & 0x7f);
129	126
130		if (state->m_part_h_shift & 0x80)
131		sx = (state->m_part_h_shift & 0x7f) + 1;
	127	if (m_part_h_shift & 0x80)
	128	sx = (m_part_h_shift & 0x7f) + 1;
132	129	else
133		sx = 91 - (state->m_part_h_shift & 0x7f);
	130	sx = 91 - (m_part_h_shift & 0x7f);
134	131
135		drawgfx_transpen(bitmap, cliprect, machine.gfx[3], 0, color, 0, 0, sx + 64, sy, 0);
136		drawgfx_transpen(bitmap, cliprect, machine.gfx[3], 1, color, 0, 0, sx, sy, 0);
137		drawgfx_transpen(bitmap, cliprect, machine.gfx[3], 0, color, 0, 1, sx + 64, sy - 64, 0);
138		drawgfx_transpen(bitmap, cliprect, machine.gfx[3], 1, color, 0, 1, sx, sy - 64, 0);
	132	drawgfx_transpen(bitmap, cliprect, machine().gfx[3], 0, color, 0, 0, sx + 64, sy, 0);
	133	drawgfx_transpen(bitmap, cliprect, machine().gfx[3], 1, color, 0, 0, sx, sy, 0);
	134	drawgfx_transpen(bitmap, cliprect, machine().gfx[3], 0, color, 0, 1, sx + 64, sy - 64, 0);
	135	drawgfx_transpen(bitmap, cliprect, machine().gfx[3], 1, color, 0, 1, sx, sy - 64, 0);
139	136	}
140	137
141		static void draw_center( running_machine& machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	138	void decocass_state::draw_center(bitmap_ind16 &bitmap, const rectangle &cliprect)
142	139	{
143		decocass_state *state = machine.driver_data<decocass_state>();
144	140	int sx, sy, x, y, color;
145	141
146	142	color = 0;
147		if (state->m_color_center_bot & 0x10)
	143	if (m_color_center_bot & 0x10)
148	144	color |= 4;
149		if (state->m_color_center_bot & 0x20)
	145	if (m_color_center_bot & 0x20)
150	146	color |= 2;
151		if (state->m_color_center_bot & 0x40)
	147	if (m_color_center_bot & 0x40)
152	148	color |= 1;
153		if (state->m_color_center_bot & 0x80)
	149	if (m_color_center_bot & 0x80)
154	150	color = (color & 4) + ((color << 1) & 2) + ((color >> 1) & 1);
155	151
156		sy = state->m_center_v_shift;
157		sx = (state->m_center_h_shift_space >> 2) & 0x3c;
	152	sy = m_center_v_shift;
	153	sx = (m_center_h_shift_space >> 2) & 0x3c;
158	154
159	155	for (y = 0; y < 4; y++)
160	156	if ((sy + y) >= cliprect.min_y && (sy + y) <= cliprect.max_y)
161	157	{
162		if (((sy + y) & state->m_color_center_bot & 3) == (sy & state->m_color_center_bot & 3))
	158	if (((sy + y) & m_color_center_bot & 3) == (sy & m_color_center_bot & 3))
163	159	for (x = 0; x < 256; x++)
164		if (0 != (x & 16) || 0 != (state->m_center_h_shift_space & 1))
	160	if (0 != (x & 16) || 0 != (m_center_h_shift_space & 1))
165	161	bitmap.pix16(sy + y, (sx + x) & 255) = color;
166	162	}
167	163	}
r18037	r18038
170	166	memory handlers
171	167	********************************************/
172	168
173		WRITE8_HANDLER( decocass_paletteram_w )
	169	WRITE8_MEMBER(decocass_state::decocass_paletteram_w )
174	170	{
175	171	/*
176	172	* RGB output is inverted and A4 is inverted too
177	173	* (ME/ input on 1st paletteram, inverter -> ME/ on 2nd)
178	174	*/
179	175	offset = (offset & 31) ^ 16;
180		colortable_palette_set_color(space.machine().colortable, offset, MAKE_RGB(pal3bit(~data >> 0), pal3bit(~data >> 3), pal2bit(~data >> 6)));
	176	colortable_palette_set_color(machine().colortable, offset, MAKE_RGB(pal3bit(~data >> 0), pal3bit(~data >> 3), pal2bit(~data >> 6)));
181	177	}
182	178
183		WRITE8_HANDLER( decocass_charram_w )
	179	WRITE8_MEMBER(decocass_state::decocass_charram_w )
184	180	{
185		decocass_state *state = space.machine().driver_data<decocass_state>();
186		state->m_charram[offset] = data;
	181	m_charram[offset] = data;
187	182	/* dirty sprite */
188		space.machine().gfx[1]->mark_dirty((offset >> 5) & 255);
	183	machine().gfx[1]->mark_dirty((offset >> 5) & 255);
189	184	/* dirty char */
190		space.machine().gfx[0]->mark_dirty((offset >> 3) & 1023);
	185	machine().gfx[0]->mark_dirty((offset >> 3) & 1023);
191	186	}
192	187
193	188
194		WRITE8_HANDLER( decocass_fgvideoram_w )
	189	WRITE8_MEMBER(decocass_state::decocass_fgvideoram_w )
195	190	{
196		decocass_state *state = space.machine().driver_data<decocass_state>();
197		state->m_fgvideoram[offset] = data;
198		state->m_fg_tilemap->mark_tile_dirty(offset);
	191	m_fgvideoram[offset] = data;
	192	m_fg_tilemap->mark_tile_dirty(offset);
199	193	}
200	194
201		WRITE8_HANDLER( decocass_colorram_w )
	195	WRITE8_MEMBER(decocass_state::decocass_colorram_w )
202	196	{
203		decocass_state *state = space.machine().driver_data<decocass_state>();
204		state->m_colorram[offset] = data;
205		state->m_fg_tilemap->mark_tile_dirty(offset);
	197	m_colorram[offset] = data;
	198	m_fg_tilemap->mark_tile_dirty(offset);
206	199	}
207	200
208		static void mark_bg_tile_dirty( running_machine &machine, offs_t offset )
	201	void decocass_state::mark_bg_tile_dirty(offs_t offset )
209	202	{
210		decocass_state *state = machine.driver_data<decocass_state>();
211	203	if (offset & 0x80)
212		state->m_bg_tilemap_r->mark_tile_dirty(offset);
	204	m_bg_tilemap_r->mark_tile_dirty(offset);
213	205	else
214		state->m_bg_tilemap_l->mark_tile_dirty(offset);
	206	m_bg_tilemap_l->mark_tile_dirty(offset);
215	207	}
216	208
217		WRITE8_HANDLER( decocass_tileram_w )
	209	WRITE8_MEMBER(decocass_state::decocass_tileram_w )
218	210	{
219		decocass_state *state = space.machine().driver_data<decocass_state>();
220		state->m_tileram[offset] = data;
	211	m_tileram[offset] = data;
221	212	/* dirty tile (64 bytes per tile) */
222		space.machine().gfx[2]->mark_dirty((offset / 64) & 15);
	213	machine().gfx[2]->mark_dirty((offset / 64) & 15);
223	214	/* first 1KB of tile RAM is shared with tilemap RAM */
224		if (offset < state->m_bgvideoram_size)
225		mark_bg_tile_dirty(space.machine(), offset);
	215	if (offset < m_bgvideoram_size)
	216	mark_bg_tile_dirty(offset);
226	217	}
227	218
228		WRITE8_HANDLER( decocass_objectram_w )
	219	WRITE8_MEMBER(decocass_state::decocass_objectram_w )
229	220	{
230		decocass_state *state = space.machine().driver_data<decocass_state>();
231		state->m_objectram[offset] = data;
	221	m_objectram[offset] = data;
232	222	/* dirty the object */
233		space.machine().gfx[3]->mark_dirty(0);
234		space.machine().gfx[3]->mark_dirty(1);
	223	machine().gfx[3]->mark_dirty(0);
	224	machine().gfx[3]->mark_dirty(1);
235	225	}
236	226
237		WRITE8_HANDLER( decocass_bgvideoram_w )
	227	WRITE8_MEMBER(decocass_state::decocass_bgvideoram_w )
238	228	{
239		decocass_state *state = space.machine().driver_data<decocass_state>();
240		state->m_bgvideoram[offset] = data;
241		mark_bg_tile_dirty(space.machine(), offset);
	229	m_bgvideoram[offset] = data;
	230	mark_bg_tile_dirty(offset);
242	231	}
243	232
244	233	/* The watchdog is a 4bit counter counting down every frame */
245		WRITE8_HANDLER( decocass_watchdog_count_w )
	234	WRITE8_MEMBER(decocass_state::decocass_watchdog_count_w )
246	235	{
247		decocass_state *state = space.machine().driver_data<decocass_state>();
248	236	LOG(1,("decocass_watchdog_count_w: $%02x\n", data));
249		state->m_watchdog_count = data & 0x0f;
	237	m_watchdog_count = data & 0x0f;
250	238	}
251	239
252		WRITE8_HANDLER( decocass_watchdog_flip_w )
	240	WRITE8_MEMBER(decocass_state::decocass_watchdog_flip_w )
253	241	{
254		decocass_state *state = space.machine().driver_data<decocass_state>();
255	242	LOG(1,("decocass_watchdog_flip_w: $%02x\n", data));
256		state->m_watchdog_flip = data;
	243	m_watchdog_flip = data;
257	244	}
258	245
259		WRITE8_HANDLER( decocass_color_missiles_w )
	246	WRITE8_MEMBER(decocass_state::decocass_color_missiles_w )
260	247	{
261		decocass_state *state = space.machine().driver_data<decocass_state>();
262	248	LOG(1,("decocass_color_missiles_w: $%02x\n", data));
263	249	/* only bits D0-D2 and D4-D6 are connected to
264	250	* the color RAM demux:
265	251	* D0-D2 to the IC0 inputs
266	252	* D4-D6 to the IC1 inputs
267	253	*/
268		state->m_color_missiles = data & 0x77;
	254	m_color_missiles = data & 0x77;
269	255	}
270	256
271	257	/*
r18037	r18038
278	264	* D6 - tunnel
279	265	* D7 - part h enable
280	266	*/
281		WRITE8_HANDLER( decocass_mode_set_w )
	267	WRITE8_MEMBER(decocass_state::decocass_mode_set_w )
282	268	{
283		decocass_state *state = space.machine().driver_data<decocass_state>();
284		if (data == state->m_mode_set)
	269	if (data == m_mode_set)
285	270	return;
286	271	LOG(1,("decocass_mode_set_w: $%02x (%s%s%s%s%s%s%s%s)\n", data,
287	272	(data & 0x01) ? "D0?" : "",
r18037	r18038
293	278	(data & 0x40) ? " tunnel" : "",
294	279	(data & 0x80) ? " part_h_enable" : ""));
295	280
296		state->m_mode_set = data;
	281	m_mode_set = data;
297	282	}
298	283
299		WRITE8_HANDLER( decocass_color_center_bot_w )
	284	WRITE8_MEMBER(decocass_state::decocass_color_center_bot_w )
300	285	{
301		decocass_state *state = space.machine().driver_data<decocass_state>();
302		if (data == state->m_color_center_bot)
	286	if (data == m_color_center_bot)
303	287	return;
304	288	LOG(1,("decocass_color_center_bot_w: $%02x (color:%d, center_bot:%d)\n", data, data & 3, data >> 4));
305	289	/*
r18037	r18038
313	297	* D0   CLD3
314	298	*/
315	299
316		if ((state->m_color_center_bot ^ data) & 0x80)
	300	if ((m_color_center_bot ^ data) & 0x80)
317	301	{
318		state->m_bg_tilemap_r->mark_all_dirty();
319		state->m_bg_tilemap_l->mark_all_dirty();
	302	m_bg_tilemap_r->mark_all_dirty();
	303	m_bg_tilemap_l->mark_all_dirty();
320	304	}
321		if ((state->m_color_center_bot ^ data) & 0x01)
322		state->m_fg_tilemap->mark_all_dirty();
323		state->m_color_center_bot = data;
	305	if ((m_color_center_bot ^ data) & 0x01)
	306	m_fg_tilemap->mark_all_dirty();
	307	m_color_center_bot = data;
324	308	}
325	309
326		WRITE8_HANDLER( decocass_back_h_shift_w )
	310	WRITE8_MEMBER(decocass_state::decocass_back_h_shift_w )
327	311	{
328		decocass_state *state = space.machine().driver_data<decocass_state>();
329		if (data == state->m_back_h_shift)
	312	if (data == m_back_h_shift)
330	313	return;
331	314	LOG(1,("decocass_back_h_shift_w: $%02x\n", data));
332		state->m_back_h_shift = data;
	315	m_back_h_shift = data;
333	316	}
334	317
335		WRITE8_HANDLER( decocass_back_vl_shift_w )
	318	WRITE8_MEMBER(decocass_state::decocass_back_vl_shift_w )
336	319	{
337		decocass_state *state = space.machine().driver_data<decocass_state>();
338		if (data == state->m_back_vl_shift)
	320	if (data == m_back_vl_shift)
339	321	return;
340	322	LOG(1,("decocass_back_vl_shift_w: $%02x\n", data));
341		state->m_back_vl_shift = data;
	323	m_back_vl_shift = data;
342	324	}
343	325
344		WRITE8_HANDLER( decocass_back_vr_shift_w )
	326	WRITE8_MEMBER(decocass_state::decocass_back_vr_shift_w )
345	327	{
346		decocass_state *state = space.machine().driver_data<decocass_state>();
347		if (data == state->m_back_vr_shift)
	328	if (data == m_back_vr_shift)
348	329	return;
349	330	LOG(1,("decocass_back_vr_shift_w: $%02x\n", data));
350		state->m_back_vr_shift = data;
	331	m_back_vr_shift = data;
351	332	}
352	333
353		WRITE8_HANDLER( decocass_part_h_shift_w )
	334	WRITE8_MEMBER(decocass_state::decocass_part_h_shift_w )
354	335	{
355		decocass_state *state = space.machine().driver_data<decocass_state>();
356		if (data == state->m_part_v_shift )
	336	if (data == m_part_v_shift )
357	337	return;
358	338	LOG(1,("decocass_part_h_shift_w: $%02x\n", data));
359		state->m_part_h_shift = data;
	339	m_part_h_shift = data;
360	340	}
361	341
362		WRITE8_HANDLER( decocass_part_v_shift_w )
	342	WRITE8_MEMBER(decocass_state::decocass_part_v_shift_w )
363	343	{
364		decocass_state *state = space.machine().driver_data<decocass_state>();
365		if (data == state->m_part_v_shift )
	344	if (data == m_part_v_shift )
366	345	return;
367	346	LOG(1,("decocass_part_v_shift_w: $%02x\n", data));
368		state->m_part_v_shift = data;
	347	m_part_v_shift = data;
369	348	}
370	349
371		WRITE8_HANDLER( decocass_center_h_shift_space_w )
	350	WRITE8_MEMBER(decocass_state::decocass_center_h_shift_space_w )
372	351	{
373		decocass_state *state = space.machine().driver_data<decocass_state>();
374		if (data == state->m_center_h_shift_space)
	352	if (data == m_center_h_shift_space)
375	353	return;
376	354	LOG(1,("decocass_center_h_shift_space_w: $%02x\n", data));
377		state->m_center_h_shift_space = data;
	355	m_center_h_shift_space = data;
378	356	}
379	357
380		WRITE8_HANDLER( decocass_center_v_shift_w )
	358	WRITE8_MEMBER(decocass_state::decocass_center_v_shift_w )
381	359	{
382		decocass_state *state = space.machine().driver_data<decocass_state>();
383	360	LOG(1,("decocass_center_v_shift_w: $%02x\n", data));
384		state->m_center_v_shift = data;
	361	m_center_v_shift = data;
385	362	}
386	363
387	364	/********************************************
388	365	memory handlers
389	366	********************************************/
390	367
391		static void draw_sprites(running_machine& machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int color,
	368	void decocass_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int color,
392	369	int sprite_y_adjust, int sprite_y_adjust_flip_screen,
393	370	UINT8 *sprite_ram, int interleave)
394	371	{
395		decocass_state *state = machine.driver_data<decocass_state>();
396	372	int i,offs;
397	373
398	374	/* Draw the sprites */
r18037	r18038
409	385	flipx = sprite_ram[offs + 0] & 0x04;
410	386	flipy = sprite_ram[offs + 0] & 0x02;
411	387
412		if (state->flip_screen())
	388	if (flip_screen())
413	389	{
414	390	sx = 240 - sx;
415	391	sy = 240 - sy + sprite_y_adjust_flip_screen;
r18037	r18038
420	396
421	397	sy -= sprite_y_adjust;
422	398
423		drawgfx_transpen(bitmap,cliprect, machine.gfx[1],
	399	drawgfx_transpen(bitmap,cliprect, machine().gfx[1],
424	400	sprite_ram[offs + interleave],
425	401	color,
426	402	flipx,flipy,
427	403	sx,sy, 0);
428	404
429		sy += (state->flip_screen() ? -256 : 256);
	405	sy += (flip_screen() ? -256 : 256);
430	406
431	407	// Wrap around
432		drawgfx_transpen(bitmap,cliprect, machine.gfx[1],
	408	drawgfx_transpen(bitmap,cliprect, machine().gfx[1],
433	409	sprite_ram[offs + interleave],
434	410	color,
435	411	flipx,flipy,
r18037	r18038
438	414	}
439	415
440	416
441		static void draw_missiles(running_machine &machine,bitmap_ind16 &bitmap, const rectangle &cliprect,
	417	void decocass_state::draw_missiles(bitmap_ind16 &bitmap, const rectangle &cliprect,
442	418	int missile_y_adjust, int missile_y_adjust_flip_screen,
443	419	UINT8 *missile_ram, int interleave)
444	420	{
445		decocass_state *state = machine.driver_data<decocass_state>();
446	421	int i, offs, x;
447	422
448	423	/* Draw the missiles (16 of them) seemingly with alternating colors
r18037	r18038
453	428
454	429	sy = 255 - missile_ram[offs + 0 * interleave];
455	430	sx = 255 - missile_ram[offs + 2 * interleave];
456		if (state->flip_screen())
	431	if (flip_screen())
457	432	{
458	433	sx = 240 - sx;
459	434	sy = 240 - sy + missile_y_adjust_flip_screen;
r18037	r18038
463	438	for (x = 0; x < 4; x++)
464	439	{
465	440	if (sx >= cliprect.min_x && sx <= cliprect.max_x)
466		bitmap.pix16(sy, sx) = (state->m_color_missiles >> 4) & 7;
	441	bitmap.pix16(sy, sx) = (m_color_missiles >> 4) & 7;
467	442	sx++;
468	443	}
469	444
470	445	sy = 255 - missile_ram[offs + 1 * interleave];
471	446	sx = 255 - missile_ram[offs + 3 * interleave];
472		if (state->flip_screen())
	447	if (flip_screen())
473	448	{
474	449	sx = 240 - sx;
475	450	sy = 240 - sy + missile_y_adjust_flip_screen;
r18037	r18038
479	454	for (x = 0; x < 4; x++)
480	455	{
481	456	if (sx >= cliprect.min_x && sx <= cliprect.max_x)
482		bitmap.pix16(sy, sx) = state->m_color_missiles & 7;
	457	bitmap.pix16(sy, sx) = m_color_missiles & 7;
483	458	sx++;
484	459	}
485	460	}
r18037	r18038
587	562
588	563	if (m_mode_set & 0x20)
589	564	{
590		draw_object(machine(), bitmap, cliprect);
591		draw_center(machine(), bitmap, cliprect);
	565	draw_object(bitmap, cliprect);
	566	draw_center(bitmap, cliprect);
592	567	}
593	568	else
594	569	{
595		draw_object(machine(), bitmap, cliprect);
596		draw_center(machine(), bitmap, cliprect);
	570	draw_object(bitmap, cliprect);
	571	draw_center(bitmap, cliprect);
597	572	if (m_mode_set & 0x08)   /* bkg_ena on ? */
598	573	{
599	574	clip = m_bg_tilemap_l_clip;
r18037	r18038
606	581	}
607	582	}
608	583	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
609		draw_sprites(machine(), bitmap, cliprect, (m_color_center_bot >> 1) & 1, 0, 0, m_fgvideoram, 0x20);
610		draw_missiles(machine(), bitmap, cliprect, 1, 0, m_colorram, 0x20);
	584	draw_sprites(bitmap, cliprect, (m_color_center_bot >> 1) & 1, 0, 0, m_fgvideoram, 0x20);
	585	draw_missiles(bitmap, cliprect, 1, 0, m_colorram, 0x20);
611	586	return 0;
612	587	}

trunk/src/mame/mame.mak

r18037	r18038
626	626	$(DRIVERS)/deco156.o $(MACHINE)/deco156.o \
627	627	$(DRIVERS)/deco32.o $(VIDEO)/deco32.o $(VIDEO)/dvi.o \
628	628	$(AUDIO)/decobsmt.o \
629		$(DRIVERS)/decocass.o $(MACHINE)/decocass.o $(VIDEO)/decocass.o \
	629	$(DRIVERS)/decocass.o $(MACHINE)/decocass.o $(MACHINE)/decocass_tape.o $(VIDEO)/decocass.o \
630	630	$(DRIVERS)/deshoros.o \
631	631	$(DRIVERS)/dietgo.o $(VIDEO)/dietgo.o \
632	632	$(DRIVERS)/exprraid.o $(VIDEO)/exprraid.o \

trunk/src/mame/includes/decocass.h

r0	r18038
	1	#ifdef MAME_DEBUG
	2	#define LOGLEVEL  5
	3	#else
	4	#define LOGLEVEL  0
	5	#endif
	6	#define LOG(n,x)  do { if (LOGLEVEL >= n) logerror x; } while (0)
	7
	8	#include "machine/decocass_tape.h"
	9
	10	class decocass_state : public driver_device
	11	{
	12	public:
	13	decocass_state(const machine_config &mconfig, device_type type, const char *tag)
	14	: driver_device(mconfig, type, tag),
	15	m_maincpu(*this, "maincpu"),
	16	m_audiocpu(*this, "audiocpu"),
	17	m_mcu(*this, "mcu"),
	18	m_cassette(*this, "cassette"),
	19	m_rambase(*this, "rambase"),
	20	m_charram(*this, "charram"),
	21	m_fgvideoram(*this, "fgvideoram"),
	22	m_colorram(*this, "colorram"),
	23	m_tileram(*this, "tileram"),
	24	m_objectram(*this, "objectram"),
	25	m_paletteram(*this, "paletteram") { }
	26
	27	/* devices */
	28	required_device<cpu_device> m_maincpu;
	29	required_device<cpu_device> m_audiocpu;
	30	required_device<cpu_device> m_mcu;
	31	required_device<decocass_tape_device> m_cassette;
	32
	33	/* memory pointers */
	34	required_shared_ptr<UINT8> m_rambase;
	35	required_shared_ptr<UINT8> m_charram;
	36	required_shared_ptr<UINT8> m_fgvideoram;
	37	required_shared_ptr<UINT8> m_colorram;
	38	UINT8 *   m_bgvideoram;   /* shares bits D0-3 with tileram! */
	39	required_shared_ptr<UINT8> m_tileram;
	40	required_shared_ptr<UINT8> m_objectram;
	41	required_shared_ptr<UINT8> m_paletteram;
	42	size_t    m_bgvideoram_size;
	43
	44	/* video-related */
	45	tilemap_t   *m_fg_tilemap;
	46	tilemap_t   *m_bg_tilemap_l;
	47	tilemap_t   *m_bg_tilemap_r;
	48	INT32     m_watchdog_count;
	49	INT32     m_watchdog_flip;
	50	INT32     m_color_missiles;
	51	INT32     m_color_center_bot;
	52	INT32     m_mode_set;
	53	INT32     m_back_h_shift;
	54	INT32     m_back_vl_shift;
	55	INT32     m_back_vr_shift;
	56	INT32     m_part_h_shift;
	57	INT32     m_part_v_shift;
	58	INT32     m_center_h_shift_space;
	59	INT32     m_center_v_shift;
	60	rectangle m_bg_tilemap_l_clip;
	61	rectangle m_bg_tilemap_r_clip;
	62
	63	/* sound-related */
	64	UINT8     m_sound_ack;   /* sound latches, ACK status bits and NMI timer */
	65	UINT8     m_audio_nmi_enabled;
	66	UINT8     m_audio_nmi_state;
	67
	68	/* misc */
	69	UINT8     *m_decrypted;
	70	UINT8     *m_decrypted2;
	71	INT32     m_firsttime;
	72	UINT8     m_latch1;
	73	UINT8     m_decocass_reset;
	74	INT32     m_de0091_enable;   /* DE-0091xx daughter board enable */
	75	UINT8     m_quadrature_decoder[4];   /* four inputs from the quadrature decoder (H1, V1, H2, V2) */
	76	int       m_showmsg;      // for debugging purposes
	77
	78	/* i8041 */
	79	UINT8     m_i8041_p1;
	80	UINT8     m_i8041_p2;
	81	int       m_i8041_p1_write_latch;
	82	int       m_i8041_p1_read_latch;
	83	int       m_i8041_p2_write_latch;
	84	int       m_i8041_p2_read_latch;
	85
	86	/* dongles-related */
	87	read8_delegate    m_dongle_r;
	88	write8_delegate   m_dongle_w;
	89
	90	/* dongle type #1 */
	91	UINT32    m_type1_inmap;
	92	UINT32    m_type1_outmap;
	93
	94	/* dongle type #2: status of the latches */
	95	INT32     m_type2_d2_latch;   /* latched 8041-STATUS D2 value */
	96	INT32     m_type2_xx_latch;   /* latched value (D7-4 == 0xc0) ? 1 : 0 */
	97	INT32     m_type2_promaddr;   /* latched PROM address A0-A7 */
	98
	99	/* dongle type #3: status and patches */
	100	INT32     m_type3_ctrs;      /* 12 bit counter stage */
	101	INT32     m_type3_d0_latch;   /* latched 8041-D0 value */
	102	INT32     m_type3_pal_19;      /* latched 1 for PAL input pin-19 */
	103	INT32     m_type3_swap;
	104
	105	/* dongle type #4: status */
	106	INT32     m_type4_ctrs;      /* latched PROM address (E5x0 LSB, E5x1 MSB) */
	107	INT32     m_type4_latch;      /* latched enable PROM (1100xxxx written to E5x1) */
	108
	109	/* dongle type #5: status */
	110	INT32     m_type5_latch;      /* latched enable PROM (1100xxxx written to E5x1) */
	111
	112	/* DS Telejan */
	113	UINT8     m_mux_data;
	114
	115	DECLARE_DRIVER_INIT(decocass);
	116	DECLARE_DRIVER_INIT(decocrom);
	117	DECLARE_DRIVER_INIT(cdsteljn);
	118	TILEMAP_MAPPER_MEMBER(fgvideoram_scan_cols);
	119	TILEMAP_MAPPER_MEMBER(bgvideoram_scan_cols);
	120	TILE_GET_INFO_MEMBER(get_bg_l_tile_info);
	121	TILE_GET_INFO_MEMBER(get_bg_r_tile_info);
	122	TILE_GET_INFO_MEMBER(get_fg_tile_info);
	123	virtual void machine_start();
	124	virtual void machine_reset();
	125	virtual void video_start();
	126	virtual void palette_init();
	127	DECLARE_MACHINE_RESET(ctsttape);
	128	DECLARE_MACHINE_RESET(cprogolfj);
	129	DECLARE_MACHINE_RESET(cdsteljn);
	130	DECLARE_MACHINE_RESET(cfishing);
	131	DECLARE_MACHINE_RESET(chwy);
	132	DECLARE_MACHINE_RESET(cterrani);
	133	DECLARE_MACHINE_RESET(castfant);
	134	DECLARE_MACHINE_RESET(csuperas);
	135	DECLARE_MACHINE_RESET(clocknch);
	136	DECLARE_MACHINE_RESET(cprogolf);
	137	DECLARE_MACHINE_RESET(cluckypo);
	138	DECLARE_MACHINE_RESET(ctisland);
	139	DECLARE_MACHINE_RESET(cexplore);
	140	DECLARE_MACHINE_RESET(cdiscon1);
	141	DECLARE_MACHINE_RESET(ctornado);
	142	DECLARE_MACHINE_RESET(cmissnx);
	143	DECLARE_MACHINE_RESET(cptennis);
	144	DECLARE_MACHINE_RESET(cbtime);
	145	DECLARE_MACHINE_RESET(cburnrub);
	146	DECLARE_MACHINE_RESET(cgraplop);
	147	DECLARE_MACHINE_RESET(cgraplop2);
	148	DECLARE_MACHINE_RESET(clapapa);
	149	DECLARE_MACHINE_RESET(cskater);
	150	DECLARE_MACHINE_RESET(cprobowl);
	151	DECLARE_MACHINE_RESET(cnightst);
	152	DECLARE_MACHINE_RESET(cpsoccer);
	153	DECLARE_MACHINE_RESET(csdtenis);
	154	DECLARE_MACHINE_RESET(czeroize);
	155	DECLARE_MACHINE_RESET(cppicf);
	156	DECLARE_MACHINE_RESET(cfghtice);
	157	DECLARE_MACHINE_RESET(type4);
	158	DECLARE_MACHINE_RESET(cbdash);
	159	DECLARE_MACHINE_RESET(cflyball);
	160	UINT32 screen_update_decocass(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	161	DECLARE_WRITE8_MEMBER(decocass_coin_counter_w);
	162	DECLARE_WRITE8_MEMBER(decocass_sound_command_w);
	163	DECLARE_READ8_MEMBER(decocass_sound_data_r);
	164	DECLARE_READ8_MEMBER(decocass_sound_ack_r);
	165	DECLARE_WRITE8_MEMBER(decocass_sound_data_w);
	166	DECLARE_READ8_MEMBER(decocass_sound_command_r);
	167	DECLARE_WRITE8_MEMBER(decocass_sound_nmi_enable_w);
	168	DECLARE_READ8_MEMBER(decocass_sound_nmi_enable_r);
	169	DECLARE_READ8_MEMBER(decocass_sound_data_ack_reset_r);
	170	DECLARE_WRITE8_MEMBER(decocass_sound_data_ack_reset_w);
	171	DECLARE_WRITE8_MEMBER(decocass_nmi_reset_w);
	172	DECLARE_WRITE8_MEMBER(decocass_quadrature_decoder_reset_w);
	173	DECLARE_WRITE8_MEMBER(decocass_adc_w);
	174	DECLARE_READ8_MEMBER(decocass_input_r);
	175
	176	DECLARE_WRITE8_MEMBER(decocass_reset_w);
	177
	178	DECLARE_READ8_MEMBER(decocass_e5xx_r);
	179	DECLARE_WRITE8_MEMBER(decocass_e5xx_w);
	180	DECLARE_WRITE8_MEMBER(decocass_de0091_w);
	181	DECLARE_WRITE8_MEMBER(decocass_e900_w);
	182
	183
	184	DECLARE_WRITE8_MEMBER(i8041_p1_w);
	185	DECLARE_READ8_MEMBER(i8041_p1_r);
	186	DECLARE_WRITE8_MEMBER(i8041_p2_w);
	187	DECLARE_READ8_MEMBER(i8041_p2_r);
	188
	189	void decocass_machine_state_save_init();
	190
	191	DECLARE_WRITE8_MEMBER(decocass_paletteram_w);
	192	DECLARE_WRITE8_MEMBER(decocass_charram_w);
	193	DECLARE_WRITE8_MEMBER(decocass_fgvideoram_w);
	194	DECLARE_WRITE8_MEMBER(decocass_colorram_w);
	195	DECLARE_WRITE8_MEMBER(decocass_bgvideoram_w);
	196	DECLARE_WRITE8_MEMBER(decocass_tileram_w);
	197	DECLARE_WRITE8_MEMBER(decocass_objectram_w);
	198
	199	DECLARE_WRITE8_MEMBER(decocass_watchdog_count_w);
	200	DECLARE_WRITE8_MEMBER(decocass_watchdog_flip_w);
	201	DECLARE_WRITE8_MEMBER(decocass_color_missiles_w);
	202	DECLARE_WRITE8_MEMBER(decocass_mode_set_w);
	203	DECLARE_WRITE8_MEMBER(decocass_color_center_bot_w);
	204	DECLARE_WRITE8_MEMBER(decocass_back_h_shift_w);
	205	DECLARE_WRITE8_MEMBER(decocass_back_vl_shift_w);
	206	DECLARE_WRITE8_MEMBER(decocass_back_vr_shift_w);
	207	DECLARE_WRITE8_MEMBER(decocass_part_h_shift_w);
	208	DECLARE_WRITE8_MEMBER(decocass_part_v_shift_w);
	209	DECLARE_WRITE8_MEMBER(decocass_center_h_shift_space_w);
	210	DECLARE_WRITE8_MEMBER(decocass_center_v_shift_w);
	211
	212	void decocass_video_state_save_init();
	213
	214	DECLARE_WRITE8_MEMBER(ram_w);
	215	DECLARE_WRITE8_MEMBER(charram_w);
	216	DECLARE_WRITE8_MEMBER(fgvideoram_w);
	217	DECLARE_WRITE8_MEMBER(fgcolorram_w);
	218	DECLARE_WRITE8_MEMBER(tileram_w);
	219	DECLARE_WRITE8_MEMBER(objectram_w);
	220	DECLARE_WRITE8_MEMBER(mirrorvideoram_w);
	221	DECLARE_WRITE8_MEMBER(mirrorcolorram_w);
	222	DECLARE_READ8_MEMBER(mirrorvideoram_r);
	223	DECLARE_READ8_MEMBER(mirrorcolorram_r);
	224	DECLARE_READ8_MEMBER(cdsteljn_input_r);
	225	DECLARE_WRITE8_MEMBER(cdsteljn_mux_w);
	226	private:
	227	DECLARE_READ8_MEMBER(decocass_type1_latch_26_pass_3_inv_2_r);
	228	DECLARE_READ8_MEMBER(decocass_type1_pass_136_r);
	229	DECLARE_READ8_MEMBER(decocass_type1_latch_27_pass_3_inv_2_r);
	230	DECLARE_READ8_MEMBER(decocass_type1_latch_26_pass_5_inv_2_r);
	231	DECLARE_READ8_MEMBER(decocass_type1_latch_16_pass_3_inv_1_r);
	232	DECLARE_READ8_MEMBER(decocass_type2_r);
	233	DECLARE_WRITE8_MEMBER(decocass_type2_w);
	234	DECLARE_READ8_MEMBER(decocass_type3_r);
	235	DECLARE_WRITE8_MEMBER(decocass_type3_w);
	236	DECLARE_READ8_MEMBER(decocass_type4_r);
	237	DECLARE_WRITE8_MEMBER(decocass_type4_w);
	238	DECLARE_READ8_MEMBER(decocass_type5_r);
	239	DECLARE_WRITE8_MEMBER(decocass_type5_w);
	240	DECLARE_READ8_MEMBER(decocass_nodong_r);
	241
	242	void draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect);
	243	void draw_center(bitmap_ind16 &bitmap, const rectangle &cliprect);
	244	void mark_bg_tile_dirty(offs_t offset);
	245	void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int color,
	246	int sprite_y_adjust, int sprite_y_adjust_flip_screen,
	247	UINT8 *sprite_ram, int interleave);
	248
	249	void draw_missiles(bitmap_ind16 &bitmap, const rectangle &cliprect,
	250	int missile_y_adjust, int missile_y_adjust_flip_screen,
	251	UINT8 *missile_ram, int interleave);
	252	};
	253
	254	TIMER_DEVICE_CALLBACK(decocass_audio_nmi_gen);

trunk/src/mame/drivers/decocass.c

r18037	r18038
34	34	#include "emu.h"
35	35	#include "cpu/m6502/m6502.h"
36	36	#include "cpu/mcs48/mcs48.h"
37		#include "machine/decocass.h"
	37	#include "includes/decocass.h"
	38	#include "machine/decocass_tape.h"
38	39	#include "sound/ay8910.h"
39	40
40	41	#define MASTER_CLOCK   XTAL_12MHz
r18037	r18038
55	56	return (data & 0x9f) | ((data & 0x20) << 1) | ((data & 0x40) >> 1);
56	57	}
57	58
58		static WRITE8_HANDLER( ram_w )
	59	WRITE8_MEMBER(decocass_state::ram_w)
59	60	{
60		decocass_state *state = space.machine().driver_data<decocass_state>();
61		state->m_decrypted[0x0000 + offset] = swap_bits_5_6(data);
62		state->m_rambase[0x0000 + offset] = data;
	61	m_decrypted[0x0000 + offset] = swap_bits_5_6(data);
	62	m_rambase[0x0000 + offset] = data;
63	63	}
64	64
65		static WRITE8_HANDLER( charram_w )
	65	WRITE8_MEMBER(decocass_state::charram_w)
66	66	{
67		decocass_state *state = space.machine().driver_data<decocass_state>();
68		state->m_decrypted[0x6000 + offset] = swap_bits_5_6(data);
	67	m_decrypted[0x6000 + offset] = swap_bits_5_6(data);
69	68	decocass_charram_w(space, offset, data);
70	69	}
71	70
72		static WRITE8_HANDLER( fgvideoram_w )
	71	WRITE8_MEMBER(decocass_state::fgvideoram_w)
73	72	{
74		decocass_state *state = space.machine().driver_data<decocass_state>();
75		state->m_decrypted[0xc000 + offset] = swap_bits_5_6(data);
	73	m_decrypted[0xc000 + offset] = swap_bits_5_6(data);
76	74	decocass_fgvideoram_w(space, offset, data);
77	75	}
78	76
79		static WRITE8_HANDLER( fgcolorram_w )
	77	WRITE8_MEMBER(decocass_state::fgcolorram_w)
80	78	{
81		decocass_state *state = space.machine().driver_data<decocass_state>();
82		state->m_decrypted[0xc400 + offset] = swap_bits_5_6(data);
	79	m_decrypted[0xc400 + offset] = swap_bits_5_6(data);
83	80	decocass_colorram_w(space, offset, data);
84	81	}
85	82
86		static WRITE8_HANDLER( tileram_w )
	83	WRITE8_MEMBER(decocass_state::tileram_w)
87	84	{
88		decocass_state *state = space.machine().driver_data<decocass_state>();
89		state->m_decrypted[0xd000 + offset] = swap_bits_5_6(data);
	85	m_decrypted[0xd000 + offset] = swap_bits_5_6(data);
90	86	decocass_tileram_w(space, offset, data);
91	87	}
92	88
93		static WRITE8_HANDLER( objectram_w )
	89	WRITE8_MEMBER(decocass_state::objectram_w)
94	90	{
95		decocass_state *state = space.machine().driver_data<decocass_state>();
96		state->m_decrypted[0xd800 + offset] = swap_bits_5_6(data);
	91	m_decrypted[0xd800 + offset] = swap_bits_5_6(data);
97	92	decocass_objectram_w(space, offset, data);
98	93	}
99	94
100		static WRITE8_HANDLER( mirrorvideoram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgvideoram_w(space, offset, data, mem_mask); }
101		static WRITE8_HANDLER( mirrorcolorram_w ) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgcolorram_w(space, offset, data, mem_mask); }
	95	WRITE8_MEMBER(decocass_state::mirrorvideoram_w) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgvideoram_w(space, offset, data, mem_mask); }
	96	WRITE8_MEMBER(decocass_state::mirrorcolorram_w) { offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5); fgcolorram_w(space, offset, data, mem_mask); }
102	97
103		static READ8_HANDLER( mirrorvideoram_r )
	98	READ8_MEMBER(decocass_state::mirrorvideoram_r)
104	99	{
105		decocass_state *state = space.machine().driver_data<decocass_state>();
106	100	offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5);
107		return state->m_fgvideoram[offset];
	101	return m_fgvideoram[offset];
108	102	}
109	103
110		static READ8_HANDLER( mirrorcolorram_r )
	104	READ8_MEMBER(decocass_state::mirrorcolorram_r)
111	105	{
112		decocass_state *state = space.machine().driver_data<decocass_state>();
113	106	offset = ((offset >> 5) & 0x1f) | ((offset & 0x1f) << 5);
114		return state->m_colorram[offset];
	107	return m_colorram[offset];
115	108	}
116	109
117	110
118	111	static ADDRESS_MAP_START( decocass_map, AS_PROGRAM, 8, decocass_state )
119		AM_RANGE(0x0000, 0x5fff) AM_RAM_WRITE_LEGACY(ram_w) AM_SHARE("rambase")
120		AM_RANGE(0x6000, 0xbfff) AM_RAM_WRITE_LEGACY(charram_w) AM_SHARE("charram") /* still RMS3 RAM */
121		AM_RANGE(0xc000, 0xc3ff) AM_RAM_WRITE_LEGACY(fgvideoram_w) AM_SHARE("fgvideoram")  /* DSP3 RAM */
122		AM_RANGE(0xc400, 0xc7ff) AM_RAM_WRITE_LEGACY(fgcolorram_w) AM_SHARE("colorram")
123		AM_RANGE(0xc800, 0xcbff) AM_READWRITE_LEGACY(mirrorvideoram_r, mirrorvideoram_w)
124		AM_RANGE(0xcc00, 0xcfff) AM_READWRITE_LEGACY(mirrorcolorram_r, mirrorcolorram_w)
125		AM_RANGE(0xd000, 0xd7ff) AM_RAM_WRITE_LEGACY(tileram_w) AM_SHARE("tileram")
126		AM_RANGE(0xd800, 0xdbff) AM_RAM_WRITE_LEGACY(objectram_w) AM_SHARE("objectram")
127		AM_RANGE(0xe000, 0xe0ff) AM_RAM_WRITE_LEGACY(decocass_paletteram_w) AM_SHARE("paletteram")
128		AM_RANGE(0xe300, 0xe300) AM_READ_PORT("DSW1") AM_WRITE_LEGACY(decocass_watchdog_count_w)
129		AM_RANGE(0xe301, 0xe301) AM_READ_PORT("DSW2") AM_WRITE_LEGACY(decocass_watchdog_flip_w)
130		AM_RANGE(0xe302, 0xe302) AM_WRITE_LEGACY(decocass_color_missiles_w)
131		AM_RANGE(0xe400, 0xe400) AM_WRITE_LEGACY(decocass_reset_w)
	112	AM_RANGE(0x0000, 0x5fff) AM_RAM_WRITE(ram_w) AM_SHARE("rambase")
	113	AM_RANGE(0x6000, 0xbfff) AM_RAM_WRITE(charram_w) AM_SHARE("charram") /* still RMS3 RAM */
	114	AM_RANGE(0xc000, 0xc3ff) AM_RAM_WRITE(fgvideoram_w) AM_SHARE("fgvideoram")  /* DSP3 RAM */
	115	AM_RANGE(0xc400, 0xc7ff) AM_RAM_WRITE(fgcolorram_w) AM_SHARE("colorram")
	116	AM_RANGE(0xc800, 0xcbff) AM_READWRITE(mirrorvideoram_r, mirrorvideoram_w)
	117	AM_RANGE(0xcc00, 0xcfff) AM_READWRITE(mirrorcolorram_r, mirrorcolorram_w)
	118	AM_RANGE(0xd000, 0xd7ff) AM_RAM_WRITE(tileram_w) AM_SHARE("tileram")
	119	AM_RANGE(0xd800, 0xdbff) AM_RAM_WRITE(objectram_w) AM_SHARE("objectram")
	120	AM_RANGE(0xe000, 0xe0ff) AM_RAM_WRITE(decocass_paletteram_w) AM_SHARE("paletteram")
	121	AM_RANGE(0xe300, 0xe300) AM_READ_PORT("DSW1") AM_WRITE(decocass_watchdog_count_w)
	122	AM_RANGE(0xe301, 0xe301) AM_READ_PORT("DSW2") AM_WRITE(decocass_watchdog_flip_w)
	123	AM_RANGE(0xe302, 0xe302) AM_WRITE(decocass_color_missiles_w)
	124	AM_RANGE(0xe400, 0xe400) AM_WRITE(decocass_reset_w)
132	125
133	126	/* BIO-3 board */
134		AM_RANGE(0xe402, 0xe402) AM_WRITE_LEGACY(decocass_mode_set_w)
135		AM_RANGE(0xe403, 0xe403) AM_WRITE_LEGACY(decocass_back_h_shift_w)
136		AM_RANGE(0xe404, 0xe404) AM_WRITE_LEGACY(decocass_back_vl_shift_w)
137		AM_RANGE(0xe405, 0xe405) AM_WRITE_LEGACY(decocass_back_vr_shift_w)
138		AM_RANGE(0xe406, 0xe406) AM_WRITE_LEGACY(decocass_part_h_shift_w)
139		AM_RANGE(0xe407, 0xe407) AM_WRITE_LEGACY(decocass_part_v_shift_w)
	127	AM_RANGE(0xe402, 0xe402) AM_WRITE(decocass_mode_set_w)
	128	AM_RANGE(0xe403, 0xe403) AM_WRITE(decocass_back_h_shift_w)
	129	AM_RANGE(0xe404, 0xe404) AM_WRITE(decocass_back_vl_shift_w)
	130	AM_RANGE(0xe405, 0xe405) AM_WRITE(decocass_back_vr_shift_w)
	131	AM_RANGE(0xe406, 0xe406) AM_WRITE(decocass_part_h_shift_w)
	132	AM_RANGE(0xe407, 0xe407) AM_WRITE(decocass_part_v_shift_w)
140	133
141		AM_RANGE(0xe410, 0xe410) AM_WRITE_LEGACY(decocass_color_center_bot_w)
142		AM_RANGE(0xe411, 0xe411) AM_WRITE_LEGACY(decocass_center_h_shift_space_w)
143		AM_RANGE(0xe412, 0xe412) AM_WRITE_LEGACY(decocass_center_v_shift_w)
144		AM_RANGE(0xe413, 0xe413) AM_WRITE_LEGACY(decocass_coin_counter_w)
145		AM_RANGE(0xe414, 0xe414) AM_WRITE_LEGACY(decocass_sound_command_w)
146		AM_RANGE(0xe415, 0xe416) AM_WRITE_LEGACY(decocass_quadrature_decoder_reset_w)
147		AM_RANGE(0xe417, 0xe417) AM_WRITE_LEGACY(decocass_nmi_reset_w)
148		AM_RANGE(0xe420, 0xe42f) AM_WRITE_LEGACY(decocass_adc_w)
	134	AM_RANGE(0xe410, 0xe410) AM_WRITE(decocass_color_center_bot_w)
	135	AM_RANGE(0xe411, 0xe411) AM_WRITE(decocass_center_h_shift_space_w)
	136	AM_RANGE(0xe412, 0xe412) AM_WRITE(decocass_center_v_shift_w)
	137	AM_RANGE(0xe413, 0xe413) AM_WRITE(decocass_coin_counter_w)
	138	AM_RANGE(0xe414, 0xe414) AM_WRITE(decocass_sound_command_w)
	139	AM_RANGE(0xe415, 0xe416) AM_WRITE(decocass_quadrature_decoder_reset_w)
	140	AM_RANGE(0xe417, 0xe417) AM_WRITE(decocass_nmi_reset_w)
	141	AM_RANGE(0xe420, 0xe42f) AM_WRITE(decocass_adc_w)
149	142
150		AM_RANGE(0xe500, 0xe5ff) AM_READWRITE_LEGACY(decocass_e5xx_r, decocass_e5xx_w)   /* read data from 8041/status */
	143	AM_RANGE(0xe500, 0xe5ff) AM_READWRITE(decocass_e5xx_r, decocass_e5xx_w)   /* read data from 8041/status */
151	144
152		AM_RANGE(0xe600, 0xe6ff) AM_READ_LEGACY(decocass_input_r)      /* inputs */
153		AM_RANGE(0xe700, 0xe700) AM_READ_LEGACY(decocass_sound_data_r)   /* read sound CPU data */
154		AM_RANGE(0xe701, 0xe701) AM_READ_LEGACY(decocass_sound_ack_r)   /* read sound CPU ack status */
	145	AM_RANGE(0xe600, 0xe6ff) AM_READ(decocass_input_r)      /* inputs */
	146	AM_RANGE(0xe700, 0xe700) AM_READ(decocass_sound_data_r)   /* read sound CPU data */
	147	AM_RANGE(0xe701, 0xe701) AM_READ(decocass_sound_ack_r)   /* read sound CPU ack status */
155	148
156	149	AM_RANGE(0xf000, 0xffff) AM_ROM
157	150	ADDRESS_MAP_END
158	151
159	152	static ADDRESS_MAP_START( decocass_sound_map, AS_PROGRAM, 8, decocass_state )
160	153	AM_RANGE(0x0000, 0x0fff) AM_RAM
161		AM_RANGE(0x1000, 0x17ff) AM_READWRITE_LEGACY(decocass_sound_nmi_enable_r, decocass_sound_nmi_enable_w)
162		AM_RANGE(0x1800, 0x1fff) AM_READWRITE_LEGACY(decocass_sound_data_ack_reset_r, decocass_sound_data_ack_reset_w)
	154	AM_RANGE(0x1000, 0x17ff) AM_READWRITE(decocass_sound_nmi_enable_r, decocass_sound_nmi_enable_w)
	155	AM_RANGE(0x1800, 0x1fff) AM_READWRITE(decocass_sound_data_ack_reset_r, decocass_sound_data_ack_reset_w)
163	156	AM_RANGE(0x2000, 0x2fff) AM_DEVWRITE_LEGACY("ay1", ay8910_data_w)
164	157	AM_RANGE(0x4000, 0x4fff) AM_DEVWRITE_LEGACY("ay1", ay8910_address_w)
165	158	AM_RANGE(0x6000, 0x6fff) AM_DEVWRITE_LEGACY("ay2", ay8910_data_w)
166	159	AM_RANGE(0x8000, 0x8fff) AM_DEVWRITE_LEGACY("ay2", ay8910_address_w)
167		AM_RANGE(0xa000, 0xafff) AM_READ_LEGACY(decocass_sound_command_r)
168		AM_RANGE(0xc000, 0xcfff) AM_WRITE_LEGACY(decocass_sound_data_w)
	160	AM_RANGE(0xa000, 0xafff) AM_READ(decocass_sound_command_r)
	161	AM_RANGE(0xc000, 0xcfff) AM_WRITE(decocass_sound_data_w)
169	162	AM_RANGE(0xf800, 0xffff) AM_ROM
170	163	ADDRESS_MAP_END
171	164
172	165
173	166	static ADDRESS_MAP_START( decocass_mcu_portmap, AS_IO, 8, decocass_state )
174		AM_RANGE(MCS48_PORT_P1, MCS48_PORT_P1) AM_READWRITE_LEGACY(i8041_p1_r, i8041_p1_w)
175		AM_RANGE(MCS48_PORT_P2, MCS48_PORT_P2) AM_READWRITE_LEGACY(i8041_p2_r, i8041_p2_w)
	167	AM_RANGE(MCS48_PORT_P1, MCS48_PORT_P1) AM_READWRITE(i8041_p1_r, i8041_p1_w)
	168	AM_RANGE(MCS48_PORT_P2, MCS48_PORT_P2) AM_READWRITE(i8041_p2_r, i8041_p2_w)
176	169	ADDRESS_MAP_END
177	170
178	171	static INPUT_PORTS_START( decocass )
r18037	r18038
1617	1610	save_pointer(NAME(m_decrypted), 0x10000);
1618	1611
1619	1612	/* Call the state save setup code in machine/decocass.c */
1620		decocass_machine_state_save_init(machine());
	1613	decocass_machine_state_save_init();
1621	1614	/* and in video/decocass.c, too */
1622		decocass_video_state_save_init(machine());
	1615	decocass_video_state_save_init();
1623	1616	}
1624	1617
1625	1618	DRIVER_INIT_MEMBER(decocass_state,decocrom)
r18037	r18038
1639	1632
1640	1633	/* convert charram to a banked ROM */
1641	1634	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x6000, 0xafff, "bank1");
1642		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_write_handler(0x6000, 0xafff, FUNC(decocass_de0091_w));
	1635	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x6000, 0xafff, write8_delegate(FUNC(decocass_state::decocass_de0091_w),this));
1643	1636	membank("bank1")->configure_entry(0, m_charram);
1644	1637	membank("bank1")->configure_entry(1, memregion("user3")->base());
1645	1638	membank("bank1")->configure_decrypted_entry(0, &m_decrypted[0x6000]);
r18037	r18038
1647	1640	membank("bank1")->set_entry(0);
1648	1641
1649	1642	/* install the bank selector */
1650		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_write_handler(0xe900, 0xe900, FUNC(decocass_e900_w));
	1643	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0xe900, 0xe900, write8_delegate(FUNC(decocass_state::decocass_e900_w),this));
1651	1644
1652	1645	save_pointer(NAME(m_decrypted2), romlength);
1653	1646	}
1654	1647
1655		static READ8_HANDLER( cdsteljn_input_r )
	1648	READ8_MEMBER(decocass_state::cdsteljn_input_r )
1656	1649	{
1657		decocass_state *state = space.machine().driver_data<decocass_state>();
1658	1650	UINT8 res;
1659	1651	static const char *const portnames[2][4] = {
1660	1652	{"P1_MP0", "P1_MP1", "P1_MP2", "P1_MP3"},
r18037	r18038
1663	1655	if(offset & 6)
1664	1656	return decocass_input_r(space,offset);
1665	1657
1666		res = space.machine().root_device().ioport(portnames[offset & 1][state->m_mux_data])->read();
	1658	res = machine().root_device().ioport(portnames[offset & 1][m_mux_data])->read();
1667	1659
1668	1660	return res;
1669	1661	}
1670	1662
1671		static WRITE8_HANDLER( cdsteljn_mux_w )
	1663	WRITE8_MEMBER(decocass_state::cdsteljn_mux_w )
1672	1664	{
1673		decocass_state *state = space.machine().driver_data<decocass_state>();
1674
1675		state->m_mux_data = (data & 0xc) >> 2;
	1665	m_mux_data = (data & 0xc) >> 2;
1676	1666	/* bit 0 and 1 are p1/p2 lamps */
1677	1667
1678	1668	if(data & ~0xf)
r18037	r18038
1685	1675	DRIVER_INIT_CALL(decocass);
1686	1676
1687	1677	/* install custom mahjong panel */
1688		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_write_handler(0xe413, 0xe413, FUNC(cdsteljn_mux_w));
1689		machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_read_handler(0xe600, 0xe6ff, FUNC(cdsteljn_input_r));
	1678	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0xe413, 0xe413, write8_delegate(FUNC(decocass_state::cdsteljn_mux_w), this));
	1679	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0xe600, 0xe6ff, read8_delegate(FUNC(decocass_state::cdsteljn_input_r), this));
1690	1680	}
1691	1681
1692	1682	/* -- */ GAME( 1981, decocass,  0,        decocass, decocass, decocass_state, decocass, ROT270, "Data East Corporation", "DECO Cassette System", GAME_IS_BIOS_ROOT )

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team