Previous

199869 Revisions

Next

r29481 Wednesday 9th April, 2014 at 11:22:57 UTC by Fabio Priuli
(MESS) pce_slot.c: nuked some auto_allocs, using dynamic_buffer instead. nw. (MESS) sega8_slot.c: nuked some auto_allocs, using dynamic_buffer instead. nw.

[src/emu/bus/pce]	pce_slot.c pce_slot.h
[src/emu/bus/sega8]	rom.c sega8_slot.c sega8_slot.h
[src/emu/bus/snes]	snes_slot.c

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

r29480	r29481
30	30	virtual DECLARE_READ8_MEMBER(read_cart) { return 0xff; }
31	31	virtual DECLARE_WRITE8_MEMBER(write_cart) {};
32	32
33		void rom_alloc(running_machine &machine, UINT32 size);
34		void ram_alloc(running_machine &machine, UINT32 size);
	33	void rom_alloc(UINT32 size);
	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_size; }
38		UINT32 get_ram_size() { return m_ram_size; }
	37	UINT32 get_rom_size() { return m_rom.count(); }
	38	UINT32 get_ram_size() { return m_ram.count(); }
39	39
40	40	// internal state
41		UINT8 *m_rom;
42		UINT8 *m_ram;
43		UINT32 m_rom_size;
44		UINT32 m_ram_size;
	41	dynamic_buffer m_rom;
	42	dynamic_buffer m_ram;
45	43
46	44	void rom_map_setup(UINT32 size);
47	45

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

r29480	r29481
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),
29		m_rom(NULL),
30		m_ram(NULL),
31		m_rom_size(0),
32		m_ram_size(0)
	28	: device_slot_card_interface(mconfig, device)
33	29	{
34	30	}
35	31
r29480	r29481
46	42	//  rom_alloc - alloc the space for the cart
47	43	//-------------------------------------------------
48	44
49		void device_pce_cart_interface::rom_alloc(running_machine &machine, UINT32 size)
	45	void device_pce_cart_interface::rom_alloc(UINT32 size)
50	46	{
51	47	if (m_rom == NULL)
52		{
53		m_rom = auto_alloc_array_clear(machine, UINT8, size);
54		m_rom_size = size;
55		}
	48	m_rom.resize(size);
56	49	}
57	50
58	51
r29480	r29481
60	53	//  ram_alloc - alloc the space for the ram
61	54	//-------------------------------------------------
62	55
63		void device_pce_cart_interface::ram_alloc(running_machine &machine, UINT32 size)
	56	void device_pce_cart_interface::ram_alloc(UINT32 size)
64	57	{
65	58	if (m_ram == NULL)
66	59	{
67		m_ram = auto_alloc_array_clear(machine, UINT8, size);
68		m_ram_size = size;
69		state_save_register_item_pointer(machine, "PCE_CART", this->device().tag(), 0, m_ram, m_ram_size);
	60	m_ram.resize(size);
	61	device().save_item(NAME(m_ram));
70	62	}
71	63	}
72	64
r29480	r29481
228	220	fseek(offset, SEEK_SET);
229	221	}
230	222
231		m_cart->rom_alloc(machine(), len);
	223	m_cart->rom_alloc(len);
232	224	ROM = m_cart->get_rom_base();
233	225
234	226	if (software_entry() == NULL)
r29480	r29481
263	255	//printf("Type: %s\n", pce_get_slot(m_type));
264	256
265	257	if (m_type == PCE_POPULOUS)
266		m_cart->ram_alloc(machine(), 0x8000);
	258	m_cart->ram_alloc(0x8000);
267	259	if (m_type == PCE_CDSYS3J || m_type == PCE_CDSYS3U)
268		m_cart->ram_alloc(machine(), 0x30000);
	260	m_cart->ram_alloc(0x30000);
269	261
270	262	return IMAGE_INIT_PASS;
271	263	}

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

r29480	r29481
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_ram(NULL),
54		m_rom_size(0),
55		m_ram_size(0),
56	52	m_rom_page_count(0),
57	53	has_battery(FALSE),
58	54	m_late_battery_enable(FALSE),
r29480	r29481
74	70	//  rom_alloc - alloc the space for the cart
75	71	//-------------------------------------------------
76	72
77		void device_sega8_cart_interface::rom_alloc(running_machine &machine, UINT32 size)
	73	void device_sega8_cart_interface::rom_alloc(UINT32 size)
78	74	{
79	75	if (m_rom == NULL)
80	76	{
81		m_rom = auto_alloc_array_clear(machine, UINT8, size);
82		m_rom_size = size;
	77	m_rom.resize(size);
83	78	m_rom_page_count = size / 0x4000;
84	79	if (!m_rom_page_count)
85	80	m_rom_page_count = 1;   // we compute rom pages through (XXX % m_rom_page_count)!
r29480	r29481
92	87	//  ram_alloc - alloc the space for the ram
93	88	//-------------------------------------------------
94	89
95		void device_sega8_cart_interface::ram_alloc(running_machine &machine, UINT32 size)
	90	void device_sega8_cart_interface::ram_alloc(UINT32 size)
96	91	{
97	92	if (m_ram == NULL)
98	93	{
99		m_ram = auto_alloc_array_clear(machine, UINT8, size);
100		m_ram_size = size;
101		state_save_register_item_pointer(machine, "SEGA8_CART", this->device().tag(), 0, m_ram, m_ram_size);
	94	m_ram.resize(size);
	95	device().save_item(NAME(m_ram));
102	96	}
103	97	}
104	98
r29480	r29481
284	278	{
285	279	if (m_type == SEGA8_CASTLE)
286	280	{
287		m_cart->ram_alloc(machine(), 0x2000);
	281	m_cart->ram_alloc(0x2000);
288	282	m_cart->set_has_battery(FALSE);
289	283	}
290	284	else if (m_type == SEGA8_OTHELLO)
291	285	{
292		m_cart->ram_alloc(machine(), 0x800);
	286	m_cart->ram_alloc(0x800);
293	287	m_cart->set_has_battery(FALSE);
294	288	}
295	289	else if (m_type == SEGA8_BASIC_L3)
296	290	{
297		m_cart->ram_alloc(machine(), 0x8000);
	291	m_cart->ram_alloc(0x8000);
298	292	m_cart->set_has_battery(FALSE);
299	293	}
300	294	else if (m_type == SEGA8_MUSIC_EDITOR)
301	295	{
302		m_cart->ram_alloc(machine(), 0x2800);
	296	m_cart->ram_alloc(0x2800);
303	297	m_cart->set_has_battery(FALSE);
304	298	}
305	299	else if (m_type == SEGA8_DAHJEE_TYPEA)
306	300	{
307		m_cart->ram_alloc(machine(), 0x2400);
	301	m_cart->ram_alloc(0x2400);
308	302	m_cart->set_has_battery(FALSE);
309	303	}
310	304	else if (m_type == SEGA8_DAHJEE_TYPEB)
311	305	{
312		m_cart->ram_alloc(machine(), 0x2000);
	306	m_cart->ram_alloc(0x2000);
313	307	m_cart->set_has_battery(FALSE);
314	308	}
315	309	else if (m_type == SEGA8_CODEMASTERS)
316	310	{
317	311	// Codemasters cart can have 64KB of RAM (Ernie Els Golf? or 8KB?) and no battery
318		m_cart->ram_alloc(machine(), 0x10000);
	312	m_cart->ram_alloc(0x10000);
319	313	m_cart->set_has_battery(FALSE);
320	314	}
321	315	else
r29480	r29481
324	318	// how much RAM was in the cart and if there was a battery so we always alloc 32KB and
325	319	// we save its content only if the game enable the RAM
326	320	m_cart->set_late_battery(TRUE);
327		m_cart->ram_alloc(machine(), 0x08000);
	321	m_cart->ram_alloc(0x08000);
328	322	}
329	323	}
330	324	else
r29480	r29481
334	328	m_cart->set_late_battery(FALSE);
335	329
336	330	if (get_software_region_length("ram"))
337		m_cart->ram_alloc(machine(), get_software_region_length("ram"));
	331	m_cart->ram_alloc(get_software_region_length("ram"));
338	332
339	333	if (battery && !strcmp(battery, "yes"))
340	334	m_cart->set_has_battery(TRUE);
r29480	r29481
366	360	if (len & 0x3fff)
367	361	len = ((len >> 14) + 1) << 14;
368	362
369		m_cart->rom_alloc(machine(), len);
	363	m_cart->rom_alloc(len);
370	364	ROM = m_cart->get_rom_base();
371	365
372	366	if (software_entry() == NULL)

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

r29480	r29481
329	329	int bank = offset / 0x4000;
330	330
331	331	if (bank == 2 && m_ram && m_ram_enabled)
332		return m_ram[(m_ram_base * 0x4000 + (offset & 0x3fff)) % m_ram_size];
	332	return m_ram[(m_ram_base * 0x4000 + (offset & 0x3fff)) % m_ram.count()];
333	333
334	334	if (offset < 0x400) // first 1k is hardcoded
335	335	return m_rom[offset];
r29480	r29481
342	342	int bank = offset / 0x4000;
343	343
344	344	if (bank == 2 && m_ram && m_ram_enabled)
345		m_ram[(m_ram_base * 0x4000 + (offset & 0x3fff)) % m_ram_size] = data;
	345	m_ram[(m_ram_base * 0x4000 + (offset & 0x3fff)) % m_ram.count()] = data;
346	346	}
347	347
348	348	WRITE8_MEMBER(sega8_rom_device::write_mapper)
r29480	r29481
422	422	if (offset >= 0x8000 && offset < 0xa000)
423	423	return m_ram[offset & 0x7ff];
424	424
425		return m_rom[offset % m_rom_size];
	425	return m_rom[offset % m_rom.count()];
426	426	}
427	427
428	428	WRITE8_MEMBER(sega8_othello_device::write_cart)
r29480	r29481
446	446	if (offset >= 0x8000 && offset < 0xa000)
447	447	return m_ram[offset & 0x1fff];
448	448
449		return m_rom[offset % m_rom_size];
	449	return m_rom[offset % m_rom.count()];
450	450	}
451	451
452	452	WRITE8_MEMBER(sega8_castle_device::write_cart)
r29480	r29481
470	470	if (offset >= 0x8000)
471	471	return m_ram[offset & 0x3fff];
472	472
473		return m_rom[offset % m_rom_size];
	473	return m_rom[offset % m_rom.count()];
474	474	}
475	475
476	476	WRITE8_MEMBER(sega8_basic_l3_device::write_cart)
r29480	r29481
504	504	if (offset >= 0x8000 && offset < 0xa000)
505	505	return m_ram[offset & 0x1fff];
506	506
507		return m_rom[offset % m_rom_size];
	507	return m_rom[offset % m_rom.count()];
508	508	}
509	509
510	510	WRITE8_MEMBER(sega8_music_editor_device::write_cart)
r29480	r29481
623	623	if (offset >= 0x2000 && offset < 0x4000)
624	624	return m_ram[offset & 0x1fff];
625	625
626		return m_rom[offset % m_rom_size];
	626	return m_rom[offset % m_rom.count()];
627	627	}
628	628
629	629	WRITE8_MEMBER(sega8_dahjee_typea_device::write_cart)
r29480	r29481
651	651	// TYPE B
652	652	READ8_MEMBER(sega8_dahjee_typeb_device::read_cart)
653	653	{
654		return m_rom[offset % m_rom_size];
	654	return m_rom[offset % m_rom.count()];
655	655	}
656	656
657	657	READ8_MEMBER(sega8_dahjee_typeb_device::read_ram)
r29480	r29481
750	750	int bank = offset / 0x2000;
751	751
752	752	if (bank == 5 && m_ram && m_ram_enabled)
753		return m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram_size];
	753	return m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram.count()];
754	754
755	755	return m_rom[m_rom_bank_base[bank/2] * 0x4000 + (offset & 0x3fff)];
756	756	}
r29480	r29481
782	782	}
783	783
784	784	if (bank == 5 && m_ram && m_ram_enabled)
785		m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram_size] = data;
	785	m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram.count()] = data;
786	786	}
787	787
788	788	/*-------------------------------------------------
r29480	r29481
824	824	int bank = offset / 0x2000;
825	825
826	826	if (bank >= 4 && m_ram && m_ram_enabled)
827		return m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram_size];
	827	return m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram.count()];
828	828
829	829	return m_rom[m_rom_bank_base[bank] * 0x2000 + (offset & 0x1fff)];
830	830	}
r29480	r29481
834	834	int bank = offset / 0x2000;
835	835
836	836	if (bank >= 4 && m_ram && m_ram_enabled)
837		m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram_size] = data;
	837	m_ram[(m_ram_base * 0x2000 + (offset & 0x1fff)) % m_ram.count()] = data;
838	838
839	839	if (offset < 4)
840	840	{

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

r29480	r29481
49	49	virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
50	50	virtual DECLARE_WRITE8_MEMBER(write_ram) {}
51	51
52		void rom_alloc(running_machine &machine, UINT32 size);
53		void ram_alloc(running_machine &machine, UINT32 size);
	52	void rom_alloc(UINT32 size);
	53	void ram_alloc(UINT32 size);
54	54
55	55	virtual void late_bank_setup() {}
56	56
r29480	r29481
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_size; }
70		UINT32 get_ram_size() { return m_ram_size; }
	69	UINT32 get_rom_size() { return m_rom.count(); }
	70	UINT32 get_ram_size() { return m_ram.count(); }
71	71
72	72	void rom_map_setup(UINT32 size);
73	73	void ram_map_setup(UINT8 banks);
74	74
75	75	//private:
76	76	// internal state
77		UINT8  *m_rom;
78		UINT8  *m_ram;
79		UINT32 m_rom_size;
80		UINT32 m_ram_size;
	77	dynamic_buffer m_rom;
	78	dynamic_buffer m_ram;
81	79	int m_rom_page_count;
82	80
83	81	bool has_battery;

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

r29480	r29481
86	86
87	87	void device_sns_cart_interface::rom_alloc(UINT32 size)
88	88	{
89		m_rom.resize(size);
	89	if (m_rom == NULL)
	90	m_rom.resize(size);
90	91	}
91	92
92	93
r29480	r29481
128	129
129	130	void device_sns_cart_interface::addon_bios_alloc(UINT32 size)
130	131	{
131		m_bios.resize(size);
	132	if (m_bios == NULL)
	133	m_bios.resize(size);
132	134	}
133	135
134	136

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team