Previous

199869 Revisions

Next

r32449 Sunday 28th September, 2014 at 15:28:57 UTC by Fabio Priuli
(MESS) consolidation + cleanup, part1. nw.

[src/emu/bus/a7800]	a78_slot.c a78_slot.h
[src/emu/bus/a800]	a800_slot.c a800_slot.h rom.c
[src/emu/bus/gameboy]	gb_slot.c gb_slot.h mbc.c
[src/emu/bus/gba]	gba_slot.c gba_slot.h rom.c rom.h
[src/emu/bus/megadrive]	md_slot.c md_slot.h
[src/emu/bus/pce]	pce_slot.c pce_slot.h
[src/emu/bus/saturn]	rom.c sat_slot.c sat_slot.h
[src/emu/bus/sega8]	rom.c sega8_slot.c sega8_slot.h
[src/emu/bus/snes]	snes_slot.c snes_slot.h
[src/emu/bus/vcs]	rom.c vcs_slot.c vcs_slot.h
[src/mess/drivers]	a2600.c a7800.c atari400.c gba.c megadriv.c segapico.c sg1000.c
[src/mess/includes]	gba.h md_cons.h sg1000.h
[src/mess/machine]	sms.c

trunk/src/emu/bus/gba/gba_slot.c

r32448	r32449
41	41	}
42	42
43	43	//-------------------------------------------------
	44	//  rom_alloc - alloc the space for the cart
	45	//-------------------------------------------------
	46
	47	void device_gba_cart_interface::rom_alloc(UINT32 size, const char *tag)
	48	{
	49	if (m_rom == NULL)
	50	{
	51	astring tempstring(tag);
	52	tempstring.cat(GBASLOT_ROM_REGION_TAG);
	53	// we always alloc 32MB of rom region!
	54	m_rom = (UINT32 *)device().machine().memory().region_alloc(tempstring, 0x2000000, 4, ENDIANNESS_LITTLE)->base();
	55	m_rom_size = size;
	56	}
	57	}
	58
	59
	60	//-------------------------------------------------
44	61	//  nvram_alloc - alloc the space for the ram
45	62	//-------------------------------------------------
46	63
r32448	r32449
150	167	{
151	168	if (m_cart)
152	169	{
153		UINT8 *ROM = (UINT8 *)m_cart->get_rom_base();
154		UINT32 cart_size;
	170	UINT8 *ROM;
	171	UINT32 size = (software_entry() != NULL) ? get_software_region_length("rom") : length();
	172	if (size > 0x2000000)
	173	{
	174	seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");
	175	return IMAGE_INIT_FAIL;
	176	}
155	177
	178	m_cart->rom_alloc(size, tag());
	179	ROM = (UINT8 *)m_cart->get_rom_base();
	180
156	181	if (software_entry() == NULL)
157	182	{
158		cart_size = length();
159		if (cart_size > 0x2000000)
160		{
161		seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");
162		return IMAGE_INIT_FAIL;
163		}
164		fread(ROM, cart_size);
165		m_cart->set_rom_size(cart_size);    // we store the actual game size...
166
167		m_type = get_cart_type(ROM, cart_size);
	183	fread(ROM, size);
	184	m_type = get_cart_type(ROM, size);
168	185	}
169	186	else
170	187	{
171	188	const char *pcb_name = get_feature("slot");
172	189
173		cart_size = get_software_region_length("rom");
174		if (cart_size > 0x2000000)
175		{
176		seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");
177		return IMAGE_INIT_FAIL;
178		}
179		memcpy(ROM, get_software_region("rom"), cart_size);
180		m_cart->set_rom_size(cart_size);    // we store the actual game size...
	190	memcpy(ROM, get_software_region("rom"), size);
181	191
182	192	if (pcb_name)
183	193	m_type = gba_get_pcb_id(pcb_name);
r32448	r32449
191	201	m_cart->nvram_alloc(0x10000);
192	202
193	203	// mirror the ROM
194		switch (cart_size)
	204	switch (size)
195	205	{
196	206	case 2 * 1024 * 1024:
197	207	memcpy(ROM + 0x200000, ROM, 0x200000);
r32448	r32449
452	462	void gba_cart_slot_device::internal_header_logging(UINT8 *ROM, UINT32 len)
453	463	{
454	464	}
455
456
457		/*-------------------------------------------------
458		Install ROM - directly point system address map
459		to the cart ROM region so to avoid the memory
460		system additional load
461		-------------------------------------------------*/
462
463		void gba_cart_slot_device::install_rom()
464		{
465		if (m_cart)
466		{
467		astring tempstring;
468		address_space &space = machine().device<cpu_device>("maincpu")->space(AS_PROGRAM);
469		space.install_read_bank(0x08000000, 0x09ffffff, 0, 0, "rom1");
470		space.install_read_bank(0x0a000000, 0x0bffffff, 0, 0, "rom2");
471		space.install_read_bank(0x0c000000, 0x0cffffff, 0, 0, "rom3");
472		machine().root_device().membank("rom1")->set_base(machine().root_device().memregion(m_cart->device().subtag(tempstring, "cartridge"))->base());
473		machine().root_device().membank("rom2")->set_base(machine().root_device().memregion(m_cart->device().subtag(tempstring, "cartridge"))->base());
474		machine().root_device().membank("rom3")->set_base(machine().root_device().memregion(m_cart->device().subtag(tempstring, "cartridge"))->base());
475		}
476		}

trunk/src/emu/bus/gba/rom.c

r32448	r32449
68	68
69	69
70	70	//-------------------------------------------------
71		//  ROM Region to allow faster access to cart data
72		//-------------------------------------------------
73
74		ROM_START( gba_cart )
75		// cartridge region - 32 MBytes (128 Mbit)
76		ROM_REGION( 0x2000000, "cartridge", ROMREGION_ERASEFF )
77		ROM_END
78
79		const rom_entry *gba_rom_device::device_rom_region() const
80		{
81		return ROM_NAME( gba_cart );
82		}
83
84		//-------------------------------------------------
85	71	//  mapper specific start/reset
86	72	//-------------------------------------------------
87	73
88	74	void gba_rom_device::device_start()
89	75	{
90		astring tempstring;
91		m_rom = (UINT32 *)memregion(this->subtag(tempstring, "cartridge"))->base();
92	76	}
93	77
94	78	void gba_rom_device::device_reset()
r32448	r32449
108	92
109	93	void gba_rom_eeprom_device::device_start()
110	94	{
111		astring tempstring;
112		m_rom = (UINT32 *)memregion(this->subtag(tempstring, "cartridge"))->base();
113
114	95	// for the moment we use a custom eeprom implementation, so we alloc/save it as nvram
115	96	nvram_alloc(0x200);
116	97	m_eeprom.reset(global_alloc(gba_eeprom_device(machine(), (UINT8*)get_nvram_base(), get_nvram_size(), 6)));
r32448	r32449
118	99
119	100	void gba_rom_eeprom64_device::device_start()
120	101	{
121		astring tempstring;
122		m_rom = (UINT32 *)memregion(this->subtag(tempstring, "cartridge"))->base();
123
124	102	// for the moment we use a custom eeprom implementation, so we alloc/save it as nvram
125	103	nvram_alloc(0x2000);
126	104	m_eeprom.reset(global_alloc(gba_eeprom_device(machine(), (UINT8*)get_nvram_base(), get_nvram_size(), 14)));

trunk/src/emu/bus/gba/gba_slot.h

r32448	r32449
34	34	virtual DECLARE_READ32_MEMBER(read_ram) { return 0xffffffff; }
35	35	virtual DECLARE_WRITE32_MEMBER(write_ram) {};
36	36
	37	void rom_alloc(UINT32 size, const char *tag);
37	38	void nvram_alloc(UINT32 size);
38	39	UINT32* get_rom_base() { return m_rom; }
39	40	UINT32* get_nvram_base() { return m_nvram; }
r32448	r32449
45	46
46	47	// internal state
47	48	UINT32 *m_rom;  // this points to the cart rom region
	49	UINT32 m_rom_size;  // this is the actual game size, not the rom region size!
48	50	dynamic_array<UINT32> m_nvram;
49		UINT32 m_rom_size;  // this is the actual game size, not the rom region size!
50	51	};
51	52
52	53
r32448	r32449
70	71	virtual void call_unload();
71	72	virtual bool call_softlist_load(software_list_device &swlist, const char *swname, const rom_entry *start_entry);
72	73
73		void install_rom();
74
75	74	int get_type() { return m_type; }
76	75	int get_cart_type(UINT8 *ROM, UINT32 len);
77	76
r32448	r32449
115	114	DEVICE CONFIGURATION MACROS
116	115	***************************************************************************/
117	116
	117	#define GBASLOT_ROM_REGION_TAG ":cart:rom"
	118
118	119	#define MCFG_GBA_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
119	120	MCFG_DEVICE_ADD(_tag, GBA_CART_SLOT, 0) \
120	121	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/gba/rom.h

r32448	r32449
17	17
18	18	// device-level overrides
19	19	virtual void device_start();
20		virtual const rom_entry *device_rom_region() const;
21	20	virtual void device_reset();
22	21
23	22	// reading and writing

trunk/src/emu/bus/vcs/vcs_slot.c

r32448	r32449
28	28	//-------------------------------------------------
29	29
30	30	device_vcs_cart_interface::device_vcs_cart_interface(const machine_config &mconfig, device_t &device)
31		: device_slot_card_interface(mconfig, device)
	31	: device_slot_card_interface(mconfig, device),
	32	m_rom(NULL),
	33	m_rom_size(0)
32	34	{
33	35	}
34	36
r32448	r32449
45	47	//  rom_alloc - alloc the space for the cart
46	48	//-------------------------------------------------
47	49
48		void device_vcs_cart_interface::rom_alloc(UINT32 size)
	50	void device_vcs_cart_interface::rom_alloc(UINT32 size, const char *tag)
49	51	{
50		m_rom.resize(size);
	52	if (m_rom == NULL)
	53	{
	54	astring tempstring(tag);
	55	tempstring.cat(A26SLOT_ROM_REGION_TAG);
	56	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	57	m_rom_size = size;
	58	}
51	59	}
52	60
53	61	//-------------------------------------------------
r32448	r32449
206	214	return IMAGE_INIT_FAIL;
207	215	}
208	216
209		m_cart->rom_alloc(len);
	217	m_cart->rom_alloc(len, tag());
210	218	ROM = m_cart->get_rom_base();
211	219
212	220	if (software_entry() != NULL)

trunk/src/emu/bus/vcs/rom.c

r32448	r32449
228	228
229	229	void a26_rom_3e_device::device_reset()
230	230	{
231		m_num_bank = m_rom.count() / 0x800;
	231	m_num_bank = m_rom_size / 0x800;
232	232	m_base_bank = m_num_bank - 1;
233	233	m_ram_bank = 0;
234	234	m_ram_enable = 0;
r32448	r32449
236	236
237	237	void a26_rom_3f_device::device_reset()
238	238	{
239		m_num_bank = m_rom.count() / 0x800;
	239	m_num_bank = m_rom_size / 0x800;
240	240	m_base_bank = m_num_bank - 1;
241	241	}
242	242
r32448	r32449
332	332	return m_ram[offset & (m_ram.count() - 1)];
333	333	}
334	334
335		return m_rom[offset & (m_rom.count() - 1)];
	335	return m_rom[offset & (m_rom_size - 1)];
336	336	}
337	337
338	338	/*-------------------------------------------------
r32448	r32449
845	845
846	846	READ8_MEMBER(a26_rom_ua_device::read_rom)
847	847	{
848		return m_rom[(offset + (m_base_bank * 0x1000)) & (m_rom.count() - 1)];
	848	return m_rom[(offset + (m_base_bank * 0x1000)) & (m_rom_size - 1)];
849	849	}
850	850
851	851	READ8_MEMBER(a26_rom_ua_device::read_bank)

trunk/src/emu/bus/vcs/vcs_slot.h

r32448	r32449
59	59
60	60	virtual void setup_addon_ptr(UINT8 *ptr) {}
61	61
62		void rom_alloc(UINT32 size);
	62	void rom_alloc(UINT32 size, const char *tag);
63	63	void ram_alloc(UINT32 size);
64	64	UINT8* get_rom_base() { return m_rom; }
65	65	UINT8*  get_ram_base() { return m_ram; }
66		UINT32  get_rom_size() { return m_rom.bytes(); }
	66	UINT32  get_rom_size() { return m_rom_size; }
67	67	UINT32  get_ram_size() { return m_ram.bytes(); }
68	68
69	69	protected:
70	70	// internal state
71		dynamic_buffer m_rom;
	71	UINT8 *m_rom;
	72	UINT32 m_rom_size;
72	73	dynamic_buffer m_ram;
73	74	};
74	75
r32448	r32449
146	147	DEVICE CONFIGURATION MACROS
147	148	***************************************************************************/
148	149
	150	#define A26SLOT_ROM_REGION_TAG ":cart:rom"
	151
	152
149	153	#define MCFG_VCS_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
150	154	MCFG_DEVICE_ADD(_tag, VCS_CART_SLOT, 0)  \
151	155	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/a800/a800_slot.c

r32448	r32449
40	40
41	41	device_a800_cart_interface::device_a800_cart_interface (const machine_config &mconfig, device_t &device)
42	42	: device_slot_card_interface(mconfig, device),
	43	m_rom(NULL),
	44	m_rom_size(0),
43	45	m_bank_mask(0)
44	46	{
45	47	}
r32448	r32449
57	59	//  rom_alloc - alloc the space for the cart
58	60	//-------------------------------------------------
59	61
60		void device_a800_cart_interface::rom_alloc(UINT32 size)
	62	void device_a800_cart_interface::rom_alloc(UINT32 size, const char *tag)
61	63	{
62		m_rom.resize(size);
63
64		// setup other helpers
65		m_bank_mask = (size / 0x2000) - 1;   // code for XEGS carts makes use of this to simplify banking
	64	if (m_rom == NULL)
	65	{
	66	astring tempstring(tag);
	67	tempstring.cat(A800SLOT_ROM_REGION_TAG);
	68	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	69	m_rom_size = size;
	70
	71	// setup other helpers
	72	m_bank_mask = (size / 0x2000) - 1;   // code for XEGS carts makes use of this to simplify banking
	73	}
66	74	}
67	75
68	76	//-------------------------------------------------
r32448	r32449
234	242	{
235	243	if (m_cart)
236	244	{
237		UINT8 *ROM;
238	245	UINT32 len;
239	246
240	247	if (software_entry() != NULL)
r32448	r32449
242	249	const char *pcb_name;
243	250	len = get_software_region_length("rom");
244	251
245		m_cart->rom_alloc(len);
246		ROM = m_cart->get_rom_base();
247		memcpy(ROM, get_software_region("rom"), len);
	252	m_cart->rom_alloc(len, tag());
	253	memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
248	254
249	255	if ((pcb_name = get_feature("slot")) != NULL)
250	256	m_type = a800_get_pcb_id(pcb_name);
r32448	r32449
275	281	m_type = A5200_4K;
276	282	}
277	283
278		m_cart->rom_alloc(len);
279		ROM = m_cart->get_rom_base();
280		fread(ROM, len);
	284	m_cart->rom_alloc(len, tag());
	285	fread(m_cart->get_rom_base(), len);
281	286	}
282	287	if (m_type == A800_TELELINK2)
283	288	m_cart->nvram_alloc(0x100);

trunk/src/emu/bus/a800/rom.c

r32448	r32449
204	204
205	205	READ8_MEMBER(a800_rom_device::read_80xx)
206	206	{
207		return m_rom[offset & (m_rom.bytes() - 1)];
	207	return m_rom[offset & (m_rom_size - 1)];
208	208	}
209	209
210	210

trunk/src/emu/bus/a800/a800_slot.h

r32448	r32449
56	56	virtual DECLARE_WRITE8_MEMBER(write_80xx) {}
57	57	virtual DECLARE_WRITE8_MEMBER(write_d5xx) {}
58	58
59		void rom_alloc(UINT32 size);
	59	void rom_alloc(UINT32 size, const char *tag);
60	60	void ram_alloc(UINT32 size);
61	61	void nvram_alloc(UINT32 size);
62	62	UINT8* get_rom_base() { return m_rom; }
63	63	UINT8* get_ram_base() { return m_ram; }
64	64	UINT8* get_nvram_base() { return m_nvram; }
65		UINT32 get_rom_size() { return m_rom.bytes(); }
	65	UINT32 get_rom_size() { return m_rom_size; }
66	66	UINT32 get_ram_size() { return m_ram.bytes(); }
67	67	UINT32 get_nvram_size() { return m_nvram.bytes(); }
68	68
69	69	protected:
70	70	// internal state
71		dynamic_buffer m_rom;
	71	UINT8 *m_rom;
	72	UINT32 m_rom_size;
72	73	dynamic_buffer m_ram;
73	74	dynamic_buffer m_nvram;   // HiScore cart can save scores!
74	75	// helpers
r32448	r32449
169	170	DEVICE CONFIGURATION MACROS
170	171	***************************************************************************/
171	172
	173	#define A800SLOT_ROM_REGION_TAG ":cart:rom"
	174
172	175	#define MCFG_A800_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
173	176	MCFG_DEVICE_ADD(_tag, A800_CART_SLOT, 0)  \
174	177	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/sega8/rom.c

r32448	r32449
422	422	if (offset >= 0x8000 && offset < 0xa000)
423	423	return m_ram[offset & 0x7ff];
424	424
425		return m_rom[offset % m_rom.count()];
	425	return m_rom[offset % m_rom_size];
426	426	}
427	427
428	428	WRITE8_MEMBER(sega8_othello_device::write_cart)
r32448	r32449
446	446	if (offset >= 0x8000 && offset < 0xa000)
447	447	return m_ram[offset & 0x1fff];
448	448
449		return m_rom[offset % m_rom.count()];
	449	return m_rom[offset % m_rom_size];
450	450	}
451	451
452	452	WRITE8_MEMBER(sega8_castle_device::write_cart)
r32448	r32449
470	470	if (offset >= 0x8000)
471	471	return m_ram[offset & 0x3fff];
472	472
473		return m_rom[offset % m_rom.count()];
	473	return m_rom[offset % m_rom_size];
474	474	}
475	475
476	476	WRITE8_MEMBER(sega8_basic_l3_device::write_cart)
r32448	r32449
504	504	if (offset >= 0x8000 && offset < 0xa000)
505	505	return m_ram[offset & 0x1fff];
506	506
507		return m_rom[offset % m_rom.count()];
	507	return m_rom[offset % m_rom_size];
508	508	}
509	509
510	510	WRITE8_MEMBER(sega8_music_editor_device::write_cart)
r32448	r32449
623	623	if (offset >= 0x2000 && offset < 0x4000)
624	624	return m_ram[offset & 0x1fff];
625	625
626		return m_rom[offset % m_rom.count()];
	626	return m_rom[offset % m_rom_size];
627	627	}
628	628
629	629	WRITE8_MEMBER(sega8_dahjee_typea_device::write_cart)
r32448	r32449
651	651	// TYPE B
652	652	READ8_MEMBER(sega8_dahjee_typeb_device::read_cart)
653	653	{
654		return m_rom[offset % m_rom.count()];
	654	return m_rom[offset % m_rom_size];
655	655	}
656	656
657	657	READ8_MEMBER(sega8_dahjee_typeb_device::read_ram)

trunk/src/emu/bus/sega8/sega8_slot.h

r32448	r32449
49	49	virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
50	50	virtual DECLARE_WRITE8_MEMBER(write_ram) {}
51	51
52		void rom_alloc(UINT32 size);
	52	void rom_alloc(UINT32 size, const char *tag);
53	53	void ram_alloc(UINT32 size);
54	54
55	55	virtual void late_bank_setup() {}
r32448	r32449
66	66	//protected:
67	67	UINT8* get_rom_base() { return m_rom; }
68	68	UINT8* get_ram_base() { return m_ram; }
69		UINT32 get_rom_size() { return m_rom.count(); }
	69	UINT32 get_rom_size() { return m_rom_size; }
70	70	UINT32 get_ram_size() { return m_ram.count(); }
71	71
72	72	void rom_map_setup(UINT32 size);
r32448	r32449
76	76
77	77	//private:
78	78	// internal state
79		dynamic_buffer m_rom;
	79	UINT8 *m_rom;
	80	UINT32 m_rom_size;
80	81	dynamic_buffer m_ram;
81	82	int m_rom_page_count;
82	83
r32448	r32449
171	172	DEVICE CONFIGURATION MACROS
172	173	***************************************************************************/
173	174
	175	#define S8SLOT_ROM_REGION_TAG ":cart:rom"
	176
	177
174	178	#define MCFG_SG1000_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
175	179	MCFG_DEVICE_ADD(_tag, SEGA8_CART_SLOT, 0) \
176	180	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) \

trunk/src/emu/bus/sega8/sega8_slot.c

r32448	r32449
49	49
50	50	device_sega8_cart_interface::device_sega8_cart_interface(const machine_config &mconfig, device_t &device)
51	51	: device_slot_card_interface(mconfig, device),
	52	m_rom(NULL),
	53	m_rom_size(0),
52	54	m_rom_page_count(0),
53	55	has_battery(FALSE),
54	56	m_late_battery_enable(FALSE),
r32448	r32449
70	72	//  rom_alloc - alloc the space for the cart
71	73	//-------------------------------------------------
72	74
73		void device_sega8_cart_interface::rom_alloc(UINT32 size)
	75	void device_sega8_cart_interface::rom_alloc(UINT32 size, const char *tag)
74	76	{
75		m_rom.resize(size);
76		m_rom_page_count = size / 0x4000;
77		if (!m_rom_page_count)
78		m_rom_page_count = 1;   // we compute rom pages through (XXX % m_rom_page_count)!
79		late_bank_setup();
	77	if (m_rom == NULL)
	78	{
	79	astring tempstring(tag);
	80	tempstring.cat(S8SLOT_ROM_REGION_TAG);
	81	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	82	m_rom_size = size;
	83	m_rom_page_count = size / 0x4000;
	84	if (!m_rom_page_count)
	85	m_rom_page_count = 1;   // we compute rom pages through (XXX % m_rom_page_count)!
	86	late_bank_setup();
	87	}
80	88	}
81	89
82	90
r32448	r32449
353	361	if (len & 0x3fff)
354	362	len = ((len >> 14) + 1) << 14;
355	363
356		m_cart->rom_alloc(len);
	364	m_cart->rom_alloc(len, tag());
357	365	ROM = m_cart->get_rom_base();
358	366
359	367	if (software_entry() == NULL)

trunk/src/emu/bus/snes/snes_slot.c

r32448	r32449
67	67	//-------------------------------------------------
68	68
69	69	device_sns_cart_interface::device_sns_cart_interface(const machine_config &mconfig, device_t &device)
70		: device_slot_card_interface(mconfig, device)
	70	: device_slot_card_interface(mconfig, device),
	71	m_rom(NULL),
	72	m_rom_size(0)
71	73	{
72	74	}
73	75
r32448	r32449
84	86	//  rom_alloc - alloc the space for the cart
85	87	//-------------------------------------------------
86	88
87		void device_sns_cart_interface::rom_alloc(UINT32 size)
	89	void device_sns_cart_interface::rom_alloc(UINT32 size, const char *tag)
88	90	{
89		m_rom.resize(size);
	91	if (m_rom == NULL)
	92	{
	93	astring tempstring(tag);
	94	tempstring.cat(SNSSLOT_ROM_REGION_TAG);
	95	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	96	m_rom_size = size;
	97	}
90	98	}
91	99
92	100
r32448	r32449
612	620
613	621	len = (software_entry() == NULL) ? (length() - offset) : get_software_region_length("rom");
614	622
615		m_cart->rom_alloc(len);
	623	m_cart->rom_alloc(len, tag());
616	624	ROM = m_cart->get_rom_base();
617	625	if (software_entry() == NULL)
618	626	fread(ROM, len);
r32448	r32449
652	660	// by installing read_bank in address space and mapping m_bios there
653	661	m_cart->speedup_addon_bios_access();
654	662
655
656	663	setup_nvram();
657	664
658	665	if (m_cart->get_nvram_size() || m_cart->get_rtc_ram_size())

trunk/src/emu/bus/snes/snes_slot.h

r32448	r32449
111	111	virtual DECLARE_WRITE8_MEMBER(chip_write) {}
112	112	virtual void speedup_addon_bios_access() {};
113	113
114		void rom_alloc(UINT32 size);
	114	void rom_alloc(UINT32 size, const char *tag);
115	115	void nvram_alloc(UINT32 size);
116	116	void rtc_ram_alloc(UINT32 size);
117	117	void addon_bios_alloc(UINT32 size);
r32448	r32449
119	119	UINT8* get_nvram_base() { return m_nvram; };
120	120	UINT8* get_addon_bios_base() { return m_bios; };
121	121	UINT8* get_rtc_ram_base() { return m_rtc_ram; };
122		UINT32 get_rom_size() { return m_rom.count(); };
	122	UINT32 get_rom_size() { return m_rom_size; };
123	123	UINT32 get_nvram_size() { return m_nvram.count(); };
124	124	UINT32 get_addon_bios_size() { return m_bios.count(); };
125	125	UINT32 get_rtc_ram_size() { return m_rtc_ram.count(); };
r32448	r32449
129	129	void save_rtc_ram()   { device().save_item(NAME(m_rtc_ram)); }
130	130
131	131	// internal state
132		dynamic_buffer m_rom;
	132	UINT8 *m_rom;
	133	UINT32 m_rom_size;
133	134	dynamic_buffer m_nvram;
134	135	dynamic_buffer m_bios;
135	136	dynamic_buffer m_rtc_ram;  // temp pointer to save RTC ram to nvram (will disappear when RTCs become devices)
r32448	r32449
252	253	DEVICE CONFIGURATION MACROS
253	254	***************************************************************************/
254	255
	256	#define SNSSLOT_ROM_REGION_TAG ":cart:rom"
	257
	258
255	259	#define MCFG_SNS_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
256	260	MCFG_DEVICE_ADD(_tag, SNS_CART_SLOT, 0) \
257	261	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/megadrive/md_slot.c

r32448	r32449
86	86	if (m_rom == NULL)
87	87	{
88	88	astring tempstring(tag);
	89	tempstring.cat(MDSLOT_ROM_REGION_TAG);
89	90	m_rom = (UINT16 *)device().machine().memory().region_alloc(tempstring, size, 2, ENDIANNESS_LITTLE)->base();
90	91	m_rom_size = size;
91	92	}
r32448	r32449
369	370	// if cart size is not (2^n * 64K), the system will see anyway that size so we need to alloc a bit more space
370	371	length = m_cart->get_padded_size(length);
371	372
372		astring cart_string(tag());
373		cart_string.cat(":cart:rom");
374		m_cart->rom_alloc(length, cart_string.cstr());
	373	m_cart->rom_alloc(length, tag());
375	374	ROM = m_cart->get_rom_base();
376	375	memcpy((UINT8 *)ROM, get_software_region("rom"), get_software_region_length("rom"));
377	376
r32448	r32449
482	481	// STEP 2: allocate space for the real copy of the game
483	482	// if cart size is not (2^n * 64K), the system will see anyway that size so we need to alloc a bit more space
484	483	len = m_cart->get_padded_size(tmplen - offset);
	484
485	485	// this contains an hack for SSF2: its current bankswitch code needs larger rom space to work
486		astring cart_string(tag());
487		cart_string.cat(":cart:rom");
488		m_cart->rom_alloc((len == 0x500000) ? 0x900000 : len, cart_string.cstr());
	486	m_cart->rom_alloc((len == 0x500000) ? 0x900000 : len, tag());
489	487
490
491	488	// STEP 3: copy the game data in the appropriate way
492	489	ROM = (unsigned char *)m_cart->get_rom_base();
493	490

trunk/src/emu/bus/megadrive/md_slot.h

r32448	r32449
237	237	DEVICE CONFIGURATION MACROS
238	238	***************************************************************************/
239	239
	240	#define MDSLOT_ROM_REGION_TAG ":cart:rom"
	241
240	242	#define MCFG_MD_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
241	243	MCFG_DEVICE_ADD(_tag, MD_CART_SLOT, 0) \
242	244	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/gameboy/mbc.c

r32448	r32449
677	677	}
678	678	else if (offset < 0x4000)
679	679	{
680		m_reg = data & ((m_rom.count() / 0x4000) - 1);
	680	m_reg = data & ((m_rom_size / 0x4000) - 1);
681	681	m_bank = m_reg & m_bank_mask;
682	682	if (m_bank == 0)
683	683	m_bank = 1;

trunk/src/emu/bus/gameboy/gb_slot.c

r32448	r32449
36	36
37	37	device_gb_cart_interface::device_gb_cart_interface(const machine_config &mconfig, device_t &device)
38	38	: device_slot_card_interface(mconfig, device),
	39	m_rom(NULL),
	40	m_rom_size(0),
39	41	has_rumble(false),
40	42	has_timer(false),
41	43	has_battery(false)
r32448	r32449
55	57	//  rom_alloc - alloc the space for the cart
56	58	//-------------------------------------------------
57	59
58		void device_gb_cart_interface::rom_alloc(UINT32 size)
	60	void device_gb_cart_interface::rom_alloc(UINT32 size, const char *tag)
59	61	{
60		m_rom.resize(size);
	62	if (m_rom == NULL)
	63	{
	64	astring tempstring(tag);
	65	tempstring.cat(GBSLOT_ROM_REGION_TAG);
	66	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	67	m_rom_size = size;
	68	}
61	69	}
62	70
63	71
r32448	r32449
274	282	}
275	283	}
276	284
277		m_cart->rom_alloc(len);
	285	m_cart->rom_alloc(len, tag());
278	286	ROM = m_cart->get_rom_base();
279	287
280	288	if (software_entry() == NULL)
r32448	r32449
397	405	if (m_cart)
398	406	{
399	407	UINT32 len = (software_entry() == NULL) ? length() : get_software_region_length("rom");
400		UINT8 *ROM;
401	408
402		m_cart->rom_alloc(len);
403		ROM = m_cart->get_rom_base();
	409	m_cart->rom_alloc(len, tag());
404	410
405	411	if (software_entry() == NULL)
406		fread(ROM, len);
	412	fread(m_cart->get_rom_base(), len);
407	413	else
408		memcpy(ROM, get_software_region("rom"), len);
	414	memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
409	415
410	416	// setup rom bank map based on real length, not header value
411	417	m_cart->rom_map_setup(len);

trunk/src/emu/bus/gameboy/gb_slot.h

r32448	r32449
56	56	virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
57	57	virtual DECLARE_WRITE8_MEMBER(write_ram) {}
58	58
59		void rom_alloc(UINT32 size);
	59	void rom_alloc(UINT32 size, const char *tag);
60	60	void ram_alloc(UINT32 size);
61	61	UINT8* get_rom_base() { return m_rom; }
62	62	UINT8* get_ram_base() { return m_ram; }
63		UINT32 get_rom_size() { return m_rom.count(); }
	63	UINT32 get_rom_size() { return m_rom_size; }
64	64	UINT32 get_ram_size() { return m_ram.count(); }
65	65
66	66	void rom_map_setup(UINT32 size);
r32448	r32449
74	74	void save_ram()   { device().save_item(NAME(m_ram)); }
75	75
76	76	// internal state
77		dynamic_buffer m_rom;
	77	UINT8 *m_rom;
	78	UINT32 m_rom_size;
78	79	dynamic_buffer m_ram;
79	80
80	81	// bankswitch variables
r32448	r32449
190	191	DEVICE CONFIGURATION MACROS
191	192	***************************************************************************/
192	193
	194	#define GBSLOT_ROM_REGION_TAG ":cart:rom"
	195
193	196	#define MCFG_GB_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
194	197	MCFG_DEVICE_ADD(_tag, GB_CART_SLOT, 0) \
195	198	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/a7800/a78_slot.c

r32448	r32449
42	42
43	43	device_a78_cart_interface::device_a78_cart_interface (const machine_config &mconfig, device_t &device)
44	44	: device_slot_card_interface(mconfig, device),
	45	m_rom(NULL),
	46	m_rom_size(0),
45	47	m_base_rom(0x8000),
46	48	m_bank_mask(0)
47	49	{
r32448	r32449
60	62	//  rom_alloc - alloc the space for the cart
61	63	//-------------------------------------------------
62	64
63		void device_a78_cart_interface::rom_alloc(UINT32 size)
	65	void device_a78_cart_interface::rom_alloc(UINT32 size, const char *tag)
64	66	{
65		m_rom.resize(size);
66
67		// setup other helpers
68		if ((size / 0x4000) & 1) // compensate for SuperGame carts with 9 x 16K banks (to my knowledge no other cart has m_bank_mask != power of 2)
69		m_bank_mask = (size / 0x4000) - 2;
70		else
71		m_bank_mask = (size / 0x4000) - 1;
72
73		// the rom is mapped to the top of the memory area
74		// so we store the starting point of data to simplify
75		// the access handling
76		m_base_rom = 0x10000 - size;
	67	if (m_rom == NULL)
	68	{
	69	astring tempstring(tag);
	70	tempstring.cat(A78SLOT_ROM_REGION_TAG);
	71	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	72	m_rom_size = size;
	73
	74	// setup other helpers
	75	if ((size / 0x4000) & 1) // compensate for SuperGame carts with 9 x 16K banks (to my knowledge no other cart has m_bank_mask != power of 2)
	76	m_bank_mask = (size / 0x4000) - 2;
	77	else
	78	m_bank_mask = (size / 0x4000) - 1;
	79
	80	// the rom is mapped to the top of the memory area
	81	// so we store the starting point of data to simplify
	82	// the access handling
	83	m_base_rom = 0x10000 - size;
	84	}
77	85	}
78	86
79	87	//-------------------------------------------------
r32448	r32449
340	348	{
341	349	if (m_cart)
342	350	{
343		UINT8 *ROM;
344	351	UINT32 len;
345	352
346	353	if (software_entry() != NULL)
r32448	r32449
350	357	bool has_nvram = get_software_region("nvram") ? TRUE : FALSE;
351	358	len = get_software_region_length("rom");
352	359
353		m_cart->rom_alloc(len);
354		ROM = m_cart->get_rom_base();
355		memcpy(ROM, get_software_region("rom"), len);
	360	m_cart->rom_alloc(len, tag());
	361	memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
356	362
357	363	if ((pcb_name = get_feature("slot")) != NULL)
358	364	m_type = a78_get_pcb_id(pcb_name);
r32448	r32449
447	453
448	454	internal_header_logging((UINT8 *)head, length());
449	455
450		m_cart->rom_alloc(len);
451		ROM = m_cart->get_rom_base();
452		fread(ROM, len);
	456	m_cart->rom_alloc(len, tag());
	457	fread(m_cart->get_rom_base(), len);
453	458
454	459	if (m_type == A78_TYPE6)
455	460	m_cart->ram_alloc(0x4000);

trunk/src/emu/bus/a7800/a78_slot.h

r32448	r32449
53	53	virtual DECLARE_WRITE8_MEMBER(write_30xx) {}
54	54	virtual DECLARE_WRITE8_MEMBER(write_40xx) {}
55	55
56		void rom_alloc(UINT32 size);
	56	void rom_alloc(UINT32 size, const char *tag);
57	57	void ram_alloc(UINT32 size);
58	58	void nvram_alloc(UINT32 size);
59	59	UINT8* get_rom_base() { return m_rom; }
60	60	UINT8* get_ram_base() { return m_ram; }
61	61	UINT8* get_nvram_base() { return m_nvram; }
62		UINT32 get_rom_size() { return m_rom.bytes(); }
	62	UINT32 get_rom_size() { return m_rom_size; }
63	63	UINT32 get_ram_size() { return m_ram.bytes(); }
64	64	UINT32 get_nvram_size() { return m_nvram.bytes(); }
65	65
66	66	protected:
67	67	// internal state
68		dynamic_buffer m_rom;
	68	UINT8 *m_rom;
	69	UINT32 m_rom_size;
69	70	dynamic_buffer m_ram;
70	71	dynamic_buffer m_nvram;   // HiScore cart can save scores!
71	72	// helpers
r32448	r32449
144	145	DEVICE CONFIGURATION MACROS
145	146	***************************************************************************/
146	147
	148	#define A78SLOT_ROM_REGION_TAG ":cart:rom"
	149
147	150	#define MCFG_A78_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
148	151	MCFG_DEVICE_ADD(_tag, A78_CART_SLOT, 0)  \
149	152	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/pce/pce_slot.c

r32448	r32449
25	25	//-------------------------------------------------
26	26
27	27	device_pce_cart_interface::device_pce_cart_interface(const machine_config &mconfig, device_t &device)
28		: device_slot_card_interface(mconfig, device)
	28	: device_slot_card_interface(mconfig, device),
	29	m_rom(NULL),
	30	m_rom_size(0)
29	31	{
30	32	}
31	33
r32448	r32449
42	44	//  rom_alloc - alloc the space for the cart
43	45	//-------------------------------------------------
44	46
45		void device_pce_cart_interface::rom_alloc(UINT32 size)
	47	void device_pce_cart_interface::rom_alloc(UINT32 size, const char *tag)
46	48	{
47		m_rom.resize(size);
	49	if (m_rom == NULL)
	50	{
	51	astring tempstring(tag);
	52	tempstring.cat(PCESLOT_ROM_REGION_TAG);
	53	m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
	54	m_rom_size = size;
	55	}
48	56	}
49	57
50	58
r32448	r32449
216	224	fseek(offset, SEEK_SET);
217	225	}
218	226
219		m_cart->rom_alloc(len);
	227	m_cart->rom_alloc(len, tag());
220	228	ROM = m_cart->get_rom_base();
221	229
222	230	if (software_entry() == NULL)

trunk/src/emu/bus/pce/pce_slot.h

r32448	r32449
30	30	virtual DECLARE_READ8_MEMBER(read_cart) { return 0xff; }
31	31	virtual DECLARE_WRITE8_MEMBER(write_cart) {};
32	32
33		void rom_alloc(UINT32 size);
	33	void rom_alloc(UINT32 size, const char *tag);
34	34	void ram_alloc(UINT32 size);
35	35	UINT8* get_rom_base() { return m_rom; }
36	36	UINT8* get_ram_base() { return m_ram; }
37		UINT32 get_rom_size() { return m_rom.count(); }
	37	UINT32 get_rom_size() { return m_rom_size; }
38	38	UINT32 get_ram_size() { return m_ram.count(); }
39	39
40	40	// internal state
41		dynamic_buffer m_rom;
	41	UINT8 *m_rom;
	42	UINT32 m_rom_size;
42	43	dynamic_buffer m_ram;
43	44
44	45	void rom_map_setup(UINT32 size);
r32448	r32449
110	111	DEVICE CONFIGURATION MACROS
111	112	***************************************************************************/
112	113
	114	#define PCESLOT_ROM_REGION_TAG ":cart:rom"
	115
113	116	#define MCFG_PCE_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
114	117	MCFG_DEVICE_ADD(_tag, PCE_CART_SLOT, 0) \
115	118	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) \

trunk/src/emu/bus/saturn/rom.c

r32448	r32449
49	49
50	50	READ32_MEMBER(saturn_rom_device::read_rom)
51	51	{
52		return m_rom[offset & (m_rom.count() - 1)];
	52	return m_rom[offset & (m_rom_size/4 - 1)];
53	53	}

trunk/src/emu/bus/saturn/sat_slot.h

r32448	r32449
29	29	virtual int get_cart_type() { return m_cart_type; };
30	30
31	31
32		void rom_alloc(UINT32 size);
	32	void rom_alloc(UINT32 size, const char *tag);
33	33	UINT32* get_rom_base() { return m_rom; }
34	34	UINT32* get_ext_dram0_base() { return m_ext_dram0; }
35	35	UINT32* get_ext_dram1_base() { return m_ext_dram1; }
36	36	UINT8*  get_ext_bram_base() { return m_ext_bram; }
37		UINT32  get_rom_size() { return m_rom.bytes(); }
	37	UINT32  get_rom_size() { return m_rom_size; }
38	38	UINT32  get_ext_dram0_size() { return m_ext_dram0.bytes(); }
39	39	UINT32  get_ext_dram1_size() { return m_ext_dram1.bytes(); }
40	40	UINT32  get_ext_bram_size() { return m_ext_bram.bytes(); }
r32448	r32449
43	43	int m_cart_type;
44	44
45	45	// internal state
46		dynamic_array<UINT32> m_rom;
	46	UINT32 *m_rom;
	47	UINT32 m_rom_size;
47	48	dynamic_array<UINT32> m_ext_dram0;
48	49	dynamic_array<UINT32> m_ext_dram1;
49	50	dynamic_buffer m_ext_bram;
r32448	r32449
107	108	DEVICE CONFIGURATION MACROS
108	109	***************************************************************************/
109	110
	111	#define SATSLOT_ROM_REGION_TAG ":cart:rom"
	112
110	113	#define MCFG_SATURN_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
111	114	MCFG_DEVICE_ADD(_tag, SATURN_CART_SLOT, 0)  \
112	115	MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

trunk/src/emu/bus/saturn/sat_slot.c

r32448	r32449
35	35	//-------------------------------------------------
36	36
37	37	device_sat_cart_interface::device_sat_cart_interface(const machine_config &mconfig, device_t &device)
38		: device_slot_card_interface(mconfig, device)
	38	: device_slot_card_interface(mconfig, device),
	39	m_rom(NULL),
	40	m_rom_size(0)
39	41	{
40	42	}
41	43
r32448	r32449
52	54	//  rom_alloc - alloc the space for the cart
53	55	//-------------------------------------------------
54	56
55		void device_sat_cart_interface::rom_alloc(UINT32 size)
	57	void device_sat_cart_interface::rom_alloc(UINT32 size, const char *tag)
56	58	{
57		m_rom.resize(size/sizeof(UINT32));
	59	if (m_rom == NULL)
	60	{
	61	astring tempstring(tag);
	62	tempstring.cat(SATSLOT_ROM_REGION_TAG);
	63	m_rom = (UINT32 *)device().machine().memory().region_alloc(tempstring, size, 4, ENDIANNESS_LITTLE)->base();
	64	m_rom_size = size;
	65	}
58	66	}
59	67
60	68
r32448	r32449
122	130	else
123	131	len = length();
124	132
125		m_cart->rom_alloc(len);
	133	m_cart->rom_alloc(len, tag());
126	134	ROM = m_cart->get_rom_base();
127	135
128	136	if (software_entry() != NULL)

trunk/src/mess/drivers/megadriv.c

r32448	r32449
91	91	else
92	92	{
93	93	UINT8 svp_test = 0;
94		if (m_slotcart)
95		svp_test = m_slotcart->read_test();
	94	if (m_cart)
	95	svp_test = m_cart->read_test();
96	96
97	97	// handle test input for SVP test
98	98	if (portnum == 0 && svp_test)
r32448	r32449
266	266
267	267	m_vdp->stop_timers();
268	268
269		if (m_slotcart)
270		m_slotcart->save_nvram();
	269	if (m_cart)
	270	m_cart->save_nvram();
271	271	}
272	272
273	273	MACHINE_START_MEMBER(md_cons_state, ms_megadriv)
r32448	r32449
275	275	MACHINE_START_CALL_MEMBER( md_common );
276	276
277	277	// the SVP introduces some kind of DMA 'lag', which we have to compensate for, this is obvious even on gfx DMAd from ROM (the Speedometer)
278		if (m_slotcart->get_type() == SEGA_SVP)
	278	if (m_cart->get_type() == SEGA_SVP)
279	279	m_vdp->set_dma_delay(2);
280	280
281	281	// for now m_cartslot is only in MD and not 32x and SegaCD
282		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x000000, 0x7fffff, read16_delegate(FUNC(base_md_cart_slot_device::read),(base_md_cart_slot_device*)m_slotcart), write16_delegate(FUNC(base_md_cart_slot_device::write),(base_md_cart_slot_device*)m_slotcart));
283		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa13000, 0xa130ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a13),(base_md_cart_slot_device*)m_slotcart), write16_delegate(FUNC(base_md_cart_slot_device::write_a13),(base_md_cart_slot_device*)m_slotcart));
284		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa15000, 0xa150ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a15),(base_md_cart_slot_device*)m_slotcart), write16_delegate(FUNC(base_md_cart_slot_device::write_a15),(base_md_cart_slot_device*)m_slotcart));
285		m_maincpu->space(AS_PROGRAM).install_write_handler(0xa14000, 0xa14003, write16_delegate(FUNC(base_md_cart_slot_device::write_tmss_bank),(base_md_cart_slot_device*)m_slotcart));
	282	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x000000, 0x7fffff, read16_delegate(FUNC(base_md_cart_slot_device::read),(base_md_cart_slot_device*)m_cart), write16_delegate(FUNC(base_md_cart_slot_device::write),(base_md_cart_slot_device*)m_cart));
	283	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa13000, 0xa130ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a13),(base_md_cart_slot_device*)m_cart), write16_delegate(FUNC(base_md_cart_slot_device::write_a13),(base_md_cart_slot_device*)m_cart));
	284	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa15000, 0xa150ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a15),(base_md_cart_slot_device*)m_cart), write16_delegate(FUNC(base_md_cart_slot_device::write_a15),(base_md_cart_slot_device*)m_cart));
	285	m_maincpu->space(AS_PROGRAM).install_write_handler(0xa14000, 0xa14003, write16_delegate(FUNC(base_md_cart_slot_device::write_tmss_bank),(base_md_cart_slot_device*)m_cart));
286	286	}
287	287
288	288	MACHINE_START_MEMBER(md_cons_state, ms_megacd)

trunk/src/mess/drivers/a2600.c

r32448	r32449
32	32	m_riot_ram(*this, "riot_ram"),
33	33	m_joy1(*this, CONTROL1_TAG),
34	34	m_joy2(*this, CONTROL2_TAG) ,
35		m_cartslot(*this, "cartslot"),
	35	m_cart(*this, "cartslot"),
36	36	m_tia(*this, "tia_video"),
37	37	m_maincpu(*this, "maincpu"),
38	38	m_screen(*this, "screen") { }
r32448	r32449
58	58	protected:
59	59	required_device<vcs_control_port_device> m_joy1;
60	60	required_device<vcs_control_port_device> m_joy2;
61		required_device<vcs_cart_slot_device> m_cartslot;
	61	required_device<vcs_cart_slot_device> m_cart;
62	62	required_device<tia_video_device> m_tia;
63	63
64	64	unsigned long detect_2600controllers();
r32448	r32449
236	236	READ8_MEMBER(a2600_state::cart_over_riot_r)
237	237	{
238	238	if (!space.debugger_access())
239		if (m_cartslot)
240		m_cartslot->write_bank(space, offset, 0);
	239	m_cart->write_bank(space, offset, 0);
241	240	return m_riot_ram[0x20 + offset];
242	241	}
243	242
244	243	WRITE8_MEMBER(a2600_state::cart_over_riot_w)
245	244	{
246		if (m_cartslot)
247		m_cartslot->write_bank(space, offset, 0);
	245	m_cart->write_bank(space, offset, 0);
248	246	m_riot_ram[0x20 + offset] = data;
249	247
250	248	}
r32448	r32449
252	250	WRITE8_MEMBER(a2600_state::cart_over_tia_w)
253	251	{
254	252	// Both Cart & TIA see these addresses
255		if (m_cartslot)
256		m_cartslot->write_bank(space, offset, data);
257
	253	m_cart->write_bank(space, offset, data);
258	254	m_tia->write(space, offset, data);
259	255	}
260	256
r32448	r32449
263	259	m_current_screen_height = m_screen->height();
264	260	memset(m_riot_ram, 0x00, 0x80);
265	261
266		switch (m_cartslot->get_cart_type())
	262	switch (m_cart->get_cart_type())
267	263	{
268	264	case A26_2K:
269	265	case A26_4K:
r32448	r32449
277	273	case A26_DC:
278	274	case A26_FV:
279	275	case A26_8IN1:
280		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot));
	276	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
281	277	break;
282	278	case A26_F6:
283	279	case A26_DPC:
284		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot));
285		m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(vcs_cart_slot_device::cart_opbase),(vcs_cart_slot_device*)m_cartslot));
	280	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
	281	m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(vcs_cart_slot_device::cart_opbase),(vcs_cart_slot_device*)m_cart));
286	282	break;
287	283	case A26_FE:
288		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cartslot));
289		m_maincpu->space(AS_PROGRAM).install_read_handler(0x01fe, 0x01ff, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cartslot));
290		m_maincpu->space(AS_PROGRAM).install_write_handler(0x01fe, 0x01fe, write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot));
	284	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cart));
	285	m_maincpu->space(AS_PROGRAM).install_read_handler(0x01fe, 0x01ff, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cart));
	286	m_maincpu->space(AS_PROGRAM).install_write_handler(0x01fe, 0x01fe, write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
291	287	break;
292	288	case A26_3E:
293		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cartslot));
	289	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cart));
294	290	m_maincpu->space(AS_PROGRAM).install_write_handler(0x00, 0x3f, write8_delegate(FUNC(a2600_state::cart_over_tia_w), this));
295	291	break;
296	292	case A26_3F:
297		m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot));
	293	m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
298	294	m_maincpu->space(AS_PROGRAM).install_write_handler(0x00, 0x3f, write8_delegate(FUNC(a2600_state::cart_over_tia_w), this));
299	295	break;
300	296	case A26_UA:
301		m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot));
302		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x200, 0x27f, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot));
	297	m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
	298	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x200, 0x27f, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
303	299	break;
304	300	case A26_JVP:
305		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot));
	301	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
306	302	// to verify the actual behavior...
307	303	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xfa0, 0xfc0, read8_delegate(FUNC(a2600_state::cart_over_riot_r), this), write8_delegate(FUNC(a2600_state::cart_over_riot_w), this));
308	304	break;
309	305	case A26_4IN1:
310	306	case A26_32IN1:
311		m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot));
	307	m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
312	308	break;
313	309	case A26_SS:
314		m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot));
	310	m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
315	311	break;
316	312	case A26_CM:
317		m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot));
	313	m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
318	314	break;
319	315	}
320	316

trunk/src/mess/drivers/a7800.c

r32448	r32449
119	119	m_io_buttons(*this, "buttons"),
120	120	m_io_vblank(*this, "vblank"),
121	121	m_io_console_buttons(*this, "console_buttons"),
122		m_cartslot(*this, "cartslot"),
	122	m_cart(*this, "cartslot"),
123	123	m_screen(*this, "screen") { }
124	124
125	125	int m_lines;
r32448	r32449
160	160	required_ioport m_io_buttons;
161	161	required_ioport m_io_vblank;
162	162	required_ioport m_io_console_buttons;
163		required_device<a78_cart_slot_device> m_cartslot;
	163	required_device<a78_cart_slot_device> m_cart;
164	164	required_device<screen_device> m_screen;
165	165	};
166	166
r32448	r32449
272	272	if (!(m_ctrl_reg & 0x04))
273	273	return m_bios[offset];
274	274	else
275		return m_cartslot->read_40xx(space, offset + 0x8000);
	275	return m_cart->read_40xx(space, offset + 0x8000);
276	276	}
277	277
278	278	/***************************************************************************
r32448	r32449
1315	1315	save_item(NAME(m_maria_flag));
1316	1316
1317	1317	// install additional handlers, if needed
1318		if (m_cartslot->exists())
1319		switch (m_cartslot->get_cart_type())
	1318	if (m_cart->exists())
1320	1319	{
1321		case A78_HSC:
1322		// ROM+NVRAM accesses for HiScore
1323		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cartslot));
1324		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cartslot));
1325		break;
1326		case A78_XB_BOARD:
1327		case A78_TYPE0_POK450:
1328		case A78_TYPE1_POK450:
1329		case A78_TYPE6_POK450:
1330		case A78_TYPEA_POK450:
1331		case A78_VERSA_POK450:
1332		// POKEY and RAM regs at 0x400-0x47f
1333		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cartslot));
1334		break;
1335		case A78_XM_BOARD:
1336		// POKEY and RAM and YM regs at 0x400-0x47f
1337		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cartslot));
1338		// ROM+NVRAM accesses for HiScore
1339		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cartslot));
1340		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cartslot));
1341		break;
	1320	switch (m_cart->get_cart_type())
	1321	{
	1322	case A78_HSC:
	1323	// ROM+NVRAM accesses for HiScore
	1324	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cart));
	1325	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cart));
	1326	break;
	1327	case A78_XB_BOARD:
	1328	case A78_TYPE0_POK450:
	1329	case A78_TYPE1_POK450:
	1330	case A78_TYPE6_POK450:
	1331	case A78_TYPEA_POK450:
	1332	case A78_VERSA_POK450:
	1333	// POKEY and RAM regs at 0x400-0x47f
	1334	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cart));
	1335	break;
	1336	case A78_XM_BOARD:
	1337	// POKEY and RAM and YM regs at 0x400-0x47f
	1338	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cart));
	1339	// ROM+NVRAM accesses for HiScore
	1340	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cart));
	1341	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cart));
	1342	break;
	1343	}
1342	1344	}
1343	1345	}
1344	1346

trunk/src/mess/drivers/gba.c

r32448	r32449
2118	2118	m_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(gba_state::handle_irq),this));
2119	2119	m_irq_timer->adjust(attotime::never);
2120	2120
2121		// install the cart ROM into the address map, if present
2122		m_cartslot->install_rom();
	2121	// install the cart ROM & SRAM into the address map, if present
	2122	if (m_cart->exists())
	2123	{
	2124	address_space &space = machine().device<cpu_device>("maincpu")->space(AS_PROGRAM);
	2125	space.install_read_bank(0x08000000, 0x09ffffff, 0, 0, "rom1");
	2126	space.install_read_bank(0x0a000000, 0x0bffffff, 0, 0, "rom2");
	2127	space.install_read_bank(0x0c000000, 0x0cffffff, 0, 0, "rom3");
2123	2128
2124		// add nvram to save state
2125		m_cartslot->save_nvram();
	2129	astring region_tag;
	2130	memory_region *cart_rom = memregion(region_tag.cpy(m_cart->tag()).cat(GBASLOT_ROM_REGION_TAG));
2126	2131
2127		// install the cart NVRAM handlers if necessary
2128		if (m_cartslot->get_type() == GBA_SRAM)
2129		{
2130		m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot));
2131		m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot));
	2132	// install ROM accesses
	2133	membank("rom1")->set_base(cart_rom->base());
	2134	membank("rom2")->set_base(cart_rom->base());
	2135	membank("rom3")->set_base(cart_rom->base());
	2136
	2137	// add nvram to save state
	2138	m_cart->save_nvram();
	2139
	2140	// install the cart NVRAM handlers if necessary
	2141	if (m_cart->get_type() == GBA_SRAM)
	2142	{
	2143	m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
	2144	m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
	2145	}
	2146	if (m_cart->get_type() == GBA_EEPROM || m_cart->get_type() == GBA_EEPROM4 || m_cart->get_type() == GBA_EEPROM64)
	2147	{
	2148	// for games larger than 16MB the actual range is smaller but read_ram/write_ram handles that!
	2149	m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000000, 0xdffffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
	2150	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd000000, 0xdffffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
	2151	}
	2152	// merge the two flash and mask accesses in read_ram?!?
	2153	if (m_cart->get_type() == GBA_FLASH || m_cart->get_type() == GBA_FLASH512)
	2154	{
	2155	m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
	2156	m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
	2157	}
	2158	if (m_cart->get_type() == GBA_FLASH1M)
	2159	{
	2160	m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe01ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
	2161	m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe01ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
	2162	}
2132	2163	}
2133		if (m_cartslot->get_type() == GBA_EEPROM || m_cartslot->get_type() == GBA_EEPROM4 || m_cartslot->get_type() == GBA_EEPROM64)
2134		{
2135		// for games larger than 16MB the actual range is smaller but read_ram/write_ram handles that!
2136		m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000000, 0xdffffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot));
2137		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd000000, 0xdffffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot));
2138		}
2139		// merge the two flash and mask accesses in read_ram?!?
2140		if (m_cartslot->get_type() == GBA_FLASH || m_cartslot->get_type() == GBA_FLASH512)
2141		{
2142		m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot));
2143		m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot));
2144		}
2145		if (m_cartslot->get_type() == GBA_FLASH1M)
2146		{
2147		m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe01ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot));
2148		m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe01ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot));
2149		}
2150	2164
2151	2165	save_item(NAME(m_DISPSTAT));
2152	2166	save_item(NAME(m_BG2X));

trunk/src/mess/drivers/atari400.c

r32448	r32449
251	251	m_0000(*this, "0000"),
252	252	m_8000(*this, "8000"),
253	253	m_a000(*this, "a000"),
254		m_cartslot(*this, "cartleft"),
255		m_cartslot2(*this, "cartright")   { }
	254	m_cart(*this, "cartleft"),
	255	m_cart2(*this, "cartright")   { }
256	256
257	257	DECLARE_MACHINE_START(a400);
258	258	DECLARE_MACHINE_START(a800);
r32448	r32449
296	296	optional_memory_bank m_0000;
297	297	optional_memory_bank m_8000;
298	298	optional_memory_bank m_a000;
299		optional_device<a800_cart_slot_device> m_cartslot;
300		optional_device<a800_cart_slot_device> m_cartslot2;
	299	optional_device<a800_cart_slot_device> m_cart;
	300	optional_device<a800_cart_slot_device> m_cart2;
301	301
302	302	int m_cart_disabled;
303	303	int m_last_offs;
r32448	r32449
1735	1735
1736	1736	WRITE8_MEMBER(a400_state::disable_cart)
1737	1737	{
1738		if (m_cartslot->exists())
1739		switch (m_cartslot->get_cart_type())
	1738	if (m_cart->exists())
1740	1739	{
1741		case A800_PHOENIX:
1742		case A800_BLIZZARD:
1743		if (!m_cart_disabled)
1744		{
1745		m_cart_disabled = 1;
1746		setup_ram(2, m_ram->size());
1747		}
1748		break;
1749		case A800_OSS034M:
1750		case A800_OSS043M:
1751		case A800_EXPRESS:
1752		case A800_DIAMOND:
1753		case A800_WILLIAMS:
1754		// use m_cart_disabled & m_last_offs to avoid continuous remapping of
1755		// the memory space in some games (e.g. dropzone)
1756		if (offset & 0x8 && !m_cart_disabled)
1757		{
1758		m_cart_disabled = 1;
1759		setup_ram(2, m_ram->size());
1760		}
1761		else if (!(offset & 0x8))
1762		{
1763		if (m_cart_disabled)
	1740	switch (m_cart->get_cart_type())
	1741	{
	1742	case A800_PHOENIX:
	1743	case A800_BLIZZARD:
	1744	if (!m_cart_disabled)
1764	1745	{
1765		m_cart_disabled = 0;
1766		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot));
1767		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1746	m_cart_disabled = 1;
	1747	setup_ram(2, m_ram->size());
1768	1748	}
1769
1770		if ((offset & 0x7) != m_last_offs)
	1749	break;
	1750	case A800_OSS034M:
	1751	case A800_OSS043M:
	1752	case A800_EXPRESS:
	1753	case A800_DIAMOND:
	1754	case A800_WILLIAMS:
	1755	// use m_cart_disabled & m_last_offs to avoid continuous remapping of
	1756	// the memory space in some games (e.g. dropzone)
	1757	if (offset & 0x8 && !m_cart_disabled)
1771	1758	{
1772		// we enter here only if we are writing to a different offset than last time
1773		m_last_offs = offset & 0x7;
1774		m_cartslot->write_d5xx(space, offset, data);
	1759	m_cart_disabled = 1;
	1760	setup_ram(2, m_ram->size());
1775	1761	}
1776		}
1777		break;
1778		case A800_TURBO64:
1779		case A800_TURBO128:
1780		if (offset & 0x10 && !m_cart_disabled)
1781		{
1782		m_cart_disabled = 1;
1783		setup_ram(2, m_ram->size());
1784		}
1785		else if (!(offset & 0x10))
1786		{
1787		if (m_cart_disabled)
	1762	else if (!(offset & 0x8))
1788	1763	{
1789		m_cart_disabled = 0;
1790		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot));
	1764	if (m_cart_disabled)
	1765	{
	1766	m_cart_disabled = 0;
	1767	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
	1768	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1769	}
	1770
	1771	if ((offset & 0x7) != m_last_offs)
	1772	{
	1773	// we enter here only if we are writing to a different offset than last time
	1774	m_last_offs = offset & 0x7;
	1775	m_cart->write_d5xx(space, offset, data);
	1776	}
	1777	}
	1778	break;
	1779	case A800_TURBO64:
	1780	case A800_TURBO128:
	1781	if (offset & 0x10 && !m_cart_disabled)
	1782	{
	1783	m_cart_disabled = 1;
	1784	setup_ram(2, m_ram->size());
	1785	}
	1786	else if (!(offset & 0x10))
	1787	{
	1788	if (m_cart_disabled)
	1789	{
	1790	m_cart_disabled = 0;
	1791	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
	1792	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1793	}
	1794
	1795	if ((offset & 0x0f) != m_last_offs)
	1796	{
	1797	// we enter here only if we are writing to a different offset than last time
	1798	m_last_offs = offset & 0x0f;
	1799	m_cart->write_d5xx(space, offset & 0x0f, data);
	1800	}
	1801	}
	1802	break;
	1803	case A800_SPARTADOS:
	1804	// writes with offset & 8 are also used to enable/disable the subcart, so they go through!
	1805	m_cart->write_d5xx(space, offset, data);
	1806	break;
	1807	case A800_OSSM091:
	1808	case A800_OSS8K:
	1809	if ((offset & 0x9) == 0x08)
	1810	setup_ram(2, m_ram->size());
	1811	else
	1812	{
	1813	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
1791	1814	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1815	m_cart->write_d5xx(space, offset, data);
1792	1816	}
1793
1794		if ((offset & 0x0f) != m_last_offs)
	1817	break;
	1818	case A800_MICROCALC:
	1819	m_cart_disabled = (m_cart_disabled + 1) % 5;
	1820	if (m_cart_disabled == 4)
	1821	setup_ram(2, m_ram->size());
	1822	else
1795	1823	{
1796		// we enter here only if we are writing to a different offset than last time
1797		m_last_offs = offset & 0x0f;
1798		m_cartslot->write_d5xx(space, offset & 0x0f, data);
	1824	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
	1825	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1826	m_cart->write_d5xx(space, offset, m_cart_disabled);
1799	1827	}
1800		}
1801		break;
1802		case A800_SPARTADOS:
1803		// writes with offset & 8 are also used to enable/disable the subcart, so they go through!
1804		m_cartslot->write_d5xx(space, offset, data);
1805		break;
1806		case A800_OSSM091:
1807		case A800_OSS8K:
1808		if ((offset & 0x9) == 0x08)
1809		setup_ram(2, m_ram->size());
1810		else
1811		{
1812		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot));
1813		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1814		m_cartslot->write_d5xx(space, offset, data);
1815		}
1816		break;
1817		case A800_MICROCALC:
1818		m_cart_disabled = (m_cart_disabled + 1) % 5;
1819		if (m_cart_disabled == 4)
1820		setup_ram(2, m_ram->size());
1821		else
1822		{
1823		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot));
1824		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1825		m_cartslot->write_d5xx(space, offset, m_cart_disabled);
1826		}
1827		break;
1828		default:
1829		break;
1830		}
	1828	break;
	1829	default:
	1830	break;
	1831	}
	1832	}
1831	1833	}
1832	1834
1833	1835	void a400_state::setup_cart(a800_cart_slot_device *slot)
r32448	r32449
1836	1838	m_last_offs = -1;
1837	1839
1838	1840	if (slot->exists())
1839		switch (slot->get_cart_type())
1840	1841	{
1841		case A800_8K:
1842		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1843		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1844		break;
1845		case A800_8K_RIGHT:
1846		m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0x9fff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1847		m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0x9fff);
1848		break;
1849		case A800_16K:
1850		m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1851		m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
1852		break;
1853		case A800_PHOENIX:
1854		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1855		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1856		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
1857		break;
1858		case A800_BBSB:
1859		m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1860		m_maincpu->space(AS_PROGRAM).install_write_handler(0x8000, 0x9fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
1861		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1862		break;
1863		case A800_OSS034M:
1864		case A800_OSS043M:
1865		case A800_OSSM091:
1866		case A800_OSS8K:
1867		case A800_TURBO64:
1868		case A800_TURBO128:
1869		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1870		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1871		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
1872		break;
1873		case A800_MICROCALC:
1874		// this can also disable ROM when reading in 0xd500-0xd5ff
1875		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1876		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1877		m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xd500, 0xd5ff, read8_delegate(FUNC(a400_state::read_d5xx), this), write8_delegate(FUNC(a400_state::disable_cart), this));
1878		break;
1879		case A800_EXPRESS:
1880		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1881		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1882		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd570, 0xd57f, write8_delegate(FUNC(a400_state::disable_cart), this));
1883		break;
1884		case A800_DIAMOND:
1885		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1886		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1887		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5d0, 0xd5df, write8_delegate(FUNC(a400_state::disable_cart), this));
1888		break;
1889		case A800_WILLIAMS:
1890		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1891		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1892		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd50f, write8_delegate(FUNC(a400_state::disable_cart), this));
1893		break;
1894		case A800_SPARTADOS:
1895		m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1896		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1897		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5e0, 0xd5ef, write8_delegate(FUNC(a400_state::disable_cart), this));
1898		break;
1899		case A800_TELELINK2:
1900		m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1901		m_maincpu->space(AS_PROGRAM).install_write_handler(0x9000, 0x90ff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
1902		m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
1903		m_maincpu->space(AS_PROGRAM).install_read_handler(0xd501, 0xd501, read8_delegate(FUNC(a800_cart_slot_device::read_d5xx),(a800_cart_slot_device*)slot));
1904		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd502, 0xd502, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot));
1905		break;
1906		case A800_BLIZZARD:
1907		m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1908		m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
1909		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
1910		break;
1911		case A800_XEGS:
1912		m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1913		m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
1914		m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot));
1915		break;
1916		case A5200_4K:
1917		case A5200_8K:
1918		case A5200_16K:
1919		case A5200_32K:
1920		case A5200_16K_2CHIPS:
1921		m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1922		m_maincpu->space(AS_PROGRAM).unmap_write(0x4000, 0xbfff);
1923		break;
1924		case A5200_BBSB:
1925		m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
1926		m_maincpu->space(AS_PROGRAM).install_write_handler(0x4000, 0x5fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
1927		m_maincpu->space(AS_PROGRAM).unmap_write(0x6000, 0xbfff);
1928		break;
1929		}
	1842	switch (slot->get_cart_type())
	1843	{
	1844	case A800_8K:
	1845	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1846	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1847	break;
	1848	case A800_8K_RIGHT:
	1849	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0x9fff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1850	m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0x9fff);
	1851	break;
	1852	case A800_16K:
	1853	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1854	m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
	1855	break;
	1856	case A800_PHOENIX:
	1857	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1858	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1859	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
	1860	break;
	1861	case A800_BBSB:
	1862	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1863	m_maincpu->space(AS_PROGRAM).install_write_handler(0x8000, 0x9fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
	1864	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1865	break;
	1866	case A800_OSS034M:
	1867	case A800_OSS043M:
	1868	case A800_OSSM091:
	1869	case A800_OSS8K:
	1870	case A800_TURBO64:
	1871	case A800_TURBO128:
	1872	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1873	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1874	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
	1875	break;
	1876	case A800_MICROCALC:
	1877	// this can also disable ROM when reading in 0xd500-0xd5ff
	1878	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1879	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1880	m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xd500, 0xd5ff, read8_delegate(FUNC(a400_state::read_d5xx), this), write8_delegate(FUNC(a400_state::disable_cart), this));
	1881	break;
	1882	case A800_EXPRESS:
	1883	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1884	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1885	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd570, 0xd57f, write8_delegate(FUNC(a400_state::disable_cart), this));
	1886	break;
	1887	case A800_DIAMOND:
	1888	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1889	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1890	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5d0, 0xd5df, write8_delegate(FUNC(a400_state::disable_cart), this));
	1891	break;
	1892	case A800_WILLIAMS:
	1893	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1894	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1895	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd50f, write8_delegate(FUNC(a400_state::disable_cart), this));
	1896	break;
	1897	case A800_SPARTADOS:
	1898	m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1899	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1900	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5e0, 0xd5ef, write8_delegate(FUNC(a400_state::disable_cart), this));
	1901	break;
	1902	case A800_TELELINK2:
	1903	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1904	m_maincpu->space(AS_PROGRAM).install_write_handler(0x9000, 0x90ff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
	1905	m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
	1906	m_maincpu->space(AS_PROGRAM).install_read_handler(0xd501, 0xd501, read8_delegate(FUNC(a800_cart_slot_device::read_d5xx),(a800_cart_slot_device*)slot));
	1907	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd502, 0xd502, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot));
	1908	break;
	1909	case A800_BLIZZARD:
	1910	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1911	m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
	1912	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
	1913	break;
	1914	case A800_XEGS:
	1915	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1916	m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
	1917	m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot));
	1918	break;
	1919	case A5200_4K:
	1920	case A5200_8K:
	1921	case A5200_16K:
	1922	case A5200_32K:
	1923	case A5200_16K_2CHIPS:
	1924	m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1925	m_maincpu->space(AS_PROGRAM).unmap_write(0x4000, 0xbfff);
	1926	break;
	1927	case A5200_BBSB:
	1928	m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
	1929	m_maincpu->space(AS_PROGRAM).install_write_handler(0x4000, 0x5fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
	1930	m_maincpu->space(AS_PROGRAM).unmap_write(0x6000, 0xbfff);
	1931	break;
	1932	}
	1933	}
1930	1934	}
1931	1935
1932	1936
r32448	r32449
1957	1961	setup_ram(0, m_ram->size());
1958	1962	setup_ram(1, m_ram->size());
1959	1963	setup_ram(2, m_ram->size());
1960		setup_cart(m_cartslot);
	1964	setup_cart(m_cart);
1961	1965
1962	1966	save_item(NAME(m_cart_disabled));
1963	1967	save_item(NAME(m_last_offs));
r32448	r32449
1969	1973	setup_ram(0, m_ram->size());
1970	1974	setup_ram(1, m_ram->size());
1971	1975	setup_ram(2, m_ram->size());
1972		setup_cart(m_cartslot);
1973		setup_cart(m_cartslot2);
	1976	setup_cart(m_cart);
	1977	setup_cart(m_cart2);
1974	1978
1975	1979	save_item(NAME(m_cart_disabled));
1976	1980	save_item(NAME(m_last_offs));
r32448	r32449
1980	1984	{
1981	1985	m_mmu = 0xfd;
1982	1986	m_ext_bank = 0x03;   // only used by a130xe
1983		setup_cart(m_cartslot);
	1987	setup_cart(m_cart);
1984	1988
1985	1989	save_item(NAME(m_cart_disabled));
1986	1990	save_item(NAME(m_last_offs));
r32448	r32449
1991	1995
1992	1996	MACHINE_START_MEMBER( a400_state, a5200 )
1993	1997	{
1994		setup_cart(m_cartslot);
	1998	setup_cart(m_cart);
1995	1999
1996	2000	save_item(NAME(m_cart_disabled));
1997	2001	save_item(NAME(m_last_offs));

trunk/src/mess/drivers/segapico.c

r32448	r32449
156	156	: pico_base_state(mconfig, type, tag),
157	157	m_picocart(*this, "picoslot") { }
158	158
159		optional_device<pico_cart_slot_device> m_picocart;
	159	required_device<pico_cart_slot_device> m_picocart;
160	160	DECLARE_MACHINE_START(pico);
161	161	};
162	162
r32448	r32449
519	519	: pico_base_state(mconfig, type, tag),
520	520	m_picocart(*this, "coperaslot") { }
521	521
522		optional_device<copera_cart_slot_device> m_picocart;
	522	required_device<copera_cart_slot_device> m_picocart;
523	523	DECLARE_MACHINE_START(copera);
524	524	};
525	525

trunk/src/mess/drivers/sg1000.c

r32448	r32449
79	79	// for the moment let assume the latter!
80	80	READ8_MEMBER( sg1000_state::omv_r )
81	81	{
82		if (m_cartslot && m_cartslot->m_cart)
83		return m_cartslot->m_cart->read_cart(space, offset);
	82	if (m_cart && m_cart->exists())
	83	return m_cart->read_cart(space, offset);
84	84	else
85	85	return m_rom->base()[offset];
86	86	}
87	87
88	88	WRITE8_MEMBER( sg1000_state::omv_w )
89	89	{
90		if (m_cartslot && m_cartslot->m_cart)
91		m_cartslot->m_cart->write_cart(space, offset, data);
	90	if (m_cart && m_cart->exists())
	91	m_cart->write_cart(space, offset, data);
92	92	}
93	93
94	94	/*-------------------------------------------------
r32448	r32449
633	633
634	634	void sg1000_state::machine_start()
635	635	{
636		if (m_cartslot->get_type() == SEGA8_DAHJEE_TYPEA || m_cartslot->get_type() == SEGA8_DAHJEE_TYPEB)
	636	if (m_cart->get_type() == SEGA8_DAHJEE_TYPEA || m_cart->get_type() == SEGA8_DAHJEE_TYPEB)
637	637	{
638		m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cartslot));
639		m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cartslot));
	638	m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cart));
	639	m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cart));
640	640	}
641	641
642		if (m_cartslot)
643		m_cartslot->save_ram();
	642	if (m_cart)
	643	m_cart->save_ram();
644	644	}
645	645
646	646	/*-------------------------------------------------
r32448	r32449
673	673	/* register for state saving */
674	674	save_item(NAME(m_keylatch));
675	675
676		if (m_cartslot && (m_cartslot->get_type() == SEGA8_BASIC_L3 || m_cartslot->get_type() == SEGA8_MUSIC_EDITOR
677		|| m_cartslot->get_type() == SEGA8_DAHJEE_TYPEA || m_cartslot->get_type() == SEGA8_DAHJEE_TYPEB))
	676	if (m_cart && m_cart->exists() && (m_cart->get_type() == SEGA8_BASIC_L3 || m_cart->get_type() == SEGA8_MUSIC_EDITOR
	677	|| m_cart->get_type() == SEGA8_DAHJEE_TYPEA || m_cart->get_type() == SEGA8_DAHJEE_TYPEB))
678	678	{
679		m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cartslot));
680		m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cartslot));
	679	m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cart));
	680	m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cart));
681	681	}
682	682
683		if (m_cartslot)
684		m_cartslot->save_ram();
	683	if (m_cart)
	684	m_cart->save_ram();
685	685	}
686	686
687	687

trunk/src/mess/machine/sms.c

r32448	r32449
206	206	*/
207	207	WRITE_LINE_MEMBER(sms_state::sms_pause_callback)
208	208	{
209		if (m_is_gamegear && m_cartslot->m_cart && !m_cartslot->m_cart->get_sms_mode())
	209	if (m_is_gamegear && m_cartslot->exists() && !m_cartslot->m_cart->get_sms_mode())
210	210	return;
211	211
212	212	if ((m_is_gamegear && !(m_port_start->read() & 0x80)) || (!m_is_gamegear && !(m_port_pause->read() & 0x80)))
r32448	r32449
642	642	// (/CART pin) that prioritizes the cartridge slot if it has media
643	643	// inserted. Japanese 3-D cartridges do not connect the /CART pin,
644	644	// to not disable the card adaptor used by the 3-D glasses.
645		if (m_cartslot && m_cartslot->m_cart)
	645	if (m_cartslot && m_cartslot->exists())
646	646	{
647	647	m_mem_device_enabled |= ENABLE_CART;
648	648	logerror("Cartridge ROM/RAM enabled.\n");
649	649	}
650		else if (m_cardslot && m_cardslot->m_cart)
	650	else if (m_cardslot && m_cardslot->exists())
651	651	{
652	652	m_mem_device_enabled |= ENABLE_CARD;
653	653	logerror("Card ROM port enabled.\n");
r32448	r32449
661	661	logerror("Expansion port enabled.\n");
662	662	}
663	663
664		if (!(m_mem_ctrl_reg & IO_CARD) && m_cardslot && m_cardslot->m_cart)
	664	if (!(m_mem_ctrl_reg & IO_CARD) && m_cardslot && m_cardslot->exists())
665	665	{
666	666	m_mem_device_enabled |= ENABLE_CARD;
667	667	logerror("Card ROM port enabled.\n");
668	668	}
669	669
670		if (!(m_mem_ctrl_reg & IO_CARTRIDGE) && m_cartslot && m_cartslot->m_cart)
	670	if (!(m_mem_ctrl_reg & IO_CARTRIDGE) && m_cartslot && m_cartslot->exists())
671	671	{
672	672	m_mem_device_enabled |= ENABLE_CART;
673	673	logerror("Cartridge ROM/RAM enabled.\n");
r32448	r32449
852	852
853	853	if (m_is_gamegear)
854	854	{
855		if (m_cartslot->m_cart && m_cartslot->m_cart->get_sms_mode())
	855	if (m_cartslot->exists() && m_cartslot->m_cart->get_sms_mode())
856	856	m_vdp->set_sega315_5124_compatibility_mode(true);
857	857
858	858	/* Initialize SIO stuff for GG */

trunk/src/mess/includes/md_cons.h

r32448	r32449
13	13	: md_base_state(mconfig, type, tag),
14	14	m_32x(*this,"sega32x"),
15	15	m_segacd(*this,"segacd"),
16		m_slotcart(*this, "mdslot")
	16	m_cart(*this, "mdslot")
17	17	{ }
18	18
19	19	ioport_port *m_io_ctrlr;
r32448	r32449
22	22
23	23	optional_device<sega_32x_device> m_32x;
24	24	optional_device<sega_segacd_device> m_segacd;
25		optional_device<md_cart_slot_device> m_slotcart;
	25	optional_device<md_cart_slot_device> m_cart;
26	26
27	27	DECLARE_DRIVER_INIT(mess_md_common);
28	28	DECLARE_DRIVER_INIT(genesis);

trunk/src/mess/includes/gba.h

r32448	r32449
138	138	m_lbdac(*this, "direct_b_left"),
139	139	m_rbdac(*this, "direct_b_right"),
140	140	m_gbsound(*this, "custom"),
141		m_cartslot(*this, "cartslot"),
	141	m_cart(*this, "cartslot"),
142	142	m_region_maincpu(*this, "maincpu"),
143	143	m_io_in0(*this, "IN0")
144	144	{ }
r32448	r32449
152	152	required_device<dac_device> m_lbdac;
153	153	required_device<dac_device> m_rbdac;
154	154	required_device<gameboy_sound_device> m_gbsound;
155		required_device<gba_cart_slot_device> m_cartslot;
	155	required_device<gba_cart_slot_device> m_cart;
156	156
157	157	void request_irq(UINT32 int_type);
158	158	void dma_exec(FPTR ch);

trunk/src/mess/includes/sg1000.h

r32448	r32449
49	49	m_maincpu(*this, Z80_TAG),
50	50	m_ram(*this, RAM_TAG),
51	51	m_rom(*this, Z80_TAG),
52		m_cartslot(*this, CARTSLOT_TAG)
	52	m_cart(*this, CARTSLOT_TAG)
53	53	{ }
54	54
55	55	required_device<cpu_device> m_maincpu;
56	56	required_device<ram_device> m_ram;
57	57	required_memory_region m_rom;
58		optional_device<sega8_cart_slot_device> m_cartslot;
	58	optional_device<sega8_cart_slot_device> m_cart;
59	59
60	60	virtual void machine_start();
61	61

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team