Previous

199869 Revisions

Next

r26673 Friday 20th December, 2013 at 16:04:11 UTC by Curt Coder
(MESS) Used shared_ptr instead of UINT8* in the Commodore cartridges. (nw)

[src/emu/bus/c64]	16kb.c 16kb.h dqbb.c dqbb.h easyflash.c easyflash.h exp.c exp.h fcc.c fcc.h georam.c georam.h ide64.c ide64.h magic_formel.c magic_formel.h neoram.c neoram.h ocean.c pagefox.c pagefox.h partner.c partner.h reu.c reu.h ross.c std.c westermann.c xl80.c xl80.h
[src/emu/bus/cbm2]	24k.c 24k.h exp.c exp.h std.c
[src/emu/bus/plus4]	exp.c exp.h std.c std.h
[src/emu/bus/vic10]	exp.c exp.h std.c std.h
[src/emu/bus/vic20]	exp.c exp.h megacart.c megacart.h vic1110.c vic1110.h vic1111.c vic1111.h vic1210.c vic1210.h

trunk/src/emu/bus/plus4/std.c

r26672	r26673
51	51
52	52	UINT8 plus4_standard_cartridge_device::plus4_cd_r(address_space &space, offs_t offset, UINT8 data, int ba, int cs0, int c1l, int c2l, int cs1, int c1h, int c2h)
53	53	{
54		if (!c1l && m_c1l_mask)
	54	if (!c1l && m_c1l.bytes())
55	55	{
56		data = m_c1l[offset & m_c1l_mask];
	56	data = m_c1l[offset & m_c1l.mask()];
57	57	}
58		else if (!c1h && m_c1h_mask)
	58	else if (!c1h && m_c1h.bytes())
59	59	{
60		data = m_c1h[offset & m_c1h_mask];
	60	data = m_c1h[offset & m_c1h.mask()];
61	61	}
62		else if (!c2l && m_c2l_mask)
	62	else if (!c2l && m_c2l.bytes())
63	63	{
64		data = m_c2l[offset & m_c2l_mask];
	64	data = m_c2l[offset & m_c2l.mask()];
65	65	}
66		else if (!c2h && m_c2h_mask)
	66	else if (!c2h && m_c2h.bytes())
67	67	{
68		data = m_c2h[offset & m_c2h_mask];
	68	data = m_c2h[offset & m_c2h.mask()];
69	69	}
70	70
71	71	return data;

trunk/src/emu/bus/plus4/exp.c

r26672	r26673
39	39
40	40	device_plus4_expansion_card_interface::device_plus4_expansion_card_interface(const machine_config &mconfig, device_t &device)
41	41	: device_slot_card_interface(mconfig, device),
42		m_c1l(NULL),
43		m_c1h(NULL),
44		m_c2l(NULL),
45		m_c2h(NULL),
46		m_ram(NULL),
47		m_nvram(NULL),
48		m_nvram_size(0),
	42	m_c1l(*this, "c1l"),
	43	m_c1h(*this, "c1h"),
	44	m_c2l(*this, "c2l"),
	45	m_c2h(*this, "c2h"),
49	46	m_c1l_mask(0),
50	47	m_c1h_mask(0),
51	48	m_c2l_mask(0),
52		m_c2h_mask(0),
53		m_ram_mask(0)
	49	m_c2h_mask(0)
54	50	{
55	51	m_slot = dynamic_cast<plus4_expansion_slot_device *>(device.owner());
56	52	}
r26672	r26673
65	61	}
66	62
67	63
68		//-------------------------------------------------
69		//  plus4_c1l_pointer - get low ROM 1 pointer
70		//-------------------------------------------------
71	64
72		UINT8* device_plus4_expansion_card_interface::plus4_c1l_pointer(running_machine &machine, size_t size)
73		{
74		if (m_c1l == NULL)
75		{
76		m_c1l = auto_alloc_array(machine, UINT8, size);
77
78		m_c1l_mask = size - 1;
79		}
80
81		return m_c1l;
82		}
83
84
85		//-------------------------------------------------
86		//  plus4_c1h_pointer - get low ROM 1 pointer
87		//-------------------------------------------------
88
89		UINT8* device_plus4_expansion_card_interface::plus4_c1h_pointer(running_machine &machine, size_t size)
90		{
91		if (m_c1h == NULL)
92		{
93		m_c1h = auto_alloc_array(machine, UINT8, size);
94
95		m_c1h_mask = size - 1;
96		}
97
98		return m_c1h;
99		}
100
101
102		//-------------------------------------------------
103		//  plus4_c2l_pointer - get low ROM 1 pointer
104		//-------------------------------------------------
105
106		UINT8* device_plus4_expansion_card_interface::plus4_c2l_pointer(running_machine &machine, size_t size)
107		{
108		if (m_c2l == NULL)
109		{
110		m_c2l = auto_alloc_array(machine, UINT8, size);
111
112		m_c2l_mask = size - 1;
113		}
114
115		return m_c2l;
116		}
117
118
119		//-------------------------------------------------
120		//  plus4_c2h_pointer - get low ROM 1 pointer
121		//-------------------------------------------------
122
123		UINT8* device_plus4_expansion_card_interface::plus4_c2h_pointer(running_machine &machine, size_t size)
124		{
125		if (m_c2h == NULL)
126		{
127		m_c2h = auto_alloc_array(machine, UINT8, size);
128
129		m_c2h_mask = size - 1;
130		}
131
132		return m_c2h;
133		}
134
135
136		//-------------------------------------------------
137		//  plus4_ram_pointer - get RAM pointer
138		//-------------------------------------------------
139
140		UINT8* device_plus4_expansion_card_interface::plus4_ram_pointer(running_machine &machine, size_t size)
141		{
142		if (m_ram == NULL)
143		{
144		m_ram = auto_alloc_array(machine, UINT8, size);
145
146		m_ram_mask = size - 1;
147		}
148
149		return m_ram;
150		}
151
152
153		//-------------------------------------------------
154		//  plus4_ram_pointer - get NVRAM pointer
155		//-------------------------------------------------
156
157		UINT8* device_plus4_expansion_card_interface::plus4_nvram_pointer(running_machine &machine, size_t size)
158		{
159		if (m_nvram == NULL)
160		{
161		m_nvram = auto_alloc_array(machine, UINT8, size);
162
163		m_nvram_mask = size - 1;
164		m_nvram_size = size;
165		}
166
167		return m_nvram;
168		}
169
170
171
172	65	//**************************************************************************
173	66	//  LIVE DEVICE
174	67	//**************************************************************************
r26672	r26673
234	127	{
235	128	if (m_card)
236	129	{
237		size_t size = 0;
238
239	130	if (software_entry() == NULL)
240	131	{
241	132	// TODO
242	133	}
243	134	else
244	135	{
245		size = get_software_region_length("c1l");
246		if (size) memcpy(m_card->plus4_c1l_pointer(machine(), size), get_software_region("c1l"), size);
247
248		size = get_software_region_length("c1h");
249		if (size) memcpy(m_card->plus4_c1h_pointer(machine(), size), get_software_region("c1h"), size);
250
251		size = get_software_region_length("c2l");
252		if (size) memcpy(m_card->plus4_c2l_pointer(machine(), size), get_software_region("c2l"), size);
253
254		size = get_software_region_length("c2h");
255		if (size) memcpy(m_card->plus4_c2h_pointer(machine(), size), get_software_region("c2h"), size);
256
257		size = get_software_region_length("ram");
258		if (size) memset(m_card->plus4_ram_pointer(machine(), size), 0, size);
259
260		size = get_software_region_length("nvram");
261		if (size) memset(m_card->plus4_nvram_pointer(machine(), size), 0, size);
	136	load_software_region("c1l", m_card->m_c1l);
	137	load_software_region("c1h", m_card->m_c1h);
	138	load_software_region("c2l", m_card->m_c2l);
	139	load_software_region("c2h", m_card->m_c2h);
262	140	}
263	141	}
264	142

trunk/src/emu/bus/plus4/std.h

r26672	r26673
39	39
40	40	// device_plus4_expansion_card_interface overrides
41	41	virtual UINT8 plus4_cd_r(address_space &space, offs_t offset, UINT8 data, int ba, int cs0, int c1l, int c2l, int cs1, int c1h, int c2h);
	42
	43
42	44	};
43	45
44	46

trunk/src/emu/bus/plus4/exp.h

r26672	r26673
152	152	device_plus4_expansion_card_interface(const machine_config &mconfig, device_t &device);
153	153	virtual ~device_plus4_expansion_card_interface();
154	154
155		// initialization
156		virtual UINT8* plus4_c1l_pointer(running_machine &machine, size_t size);
157		virtual UINT8* plus4_c1h_pointer(running_machine &machine, size_t size);
158		virtual UINT8* plus4_c2l_pointer(running_machine &machine, size_t size);
159		virtual UINT8* plus4_c2h_pointer(running_machine &machine, size_t size);
160		virtual UINT8* plus4_ram_pointer(running_machine &machine, size_t size);
161		virtual UINT8* plus4_nvram_pointer(running_machine &machine, size_t size);
162
163	155	// runtime
164	156	virtual UINT8 plus4_cd_r(address_space &space, offs_t offset, UINT8 data, int ba, int cs0, int c1l, int c2l, int cs1, int c1h, int c2h) { return data; };
165	157	virtual void plus4_cd_w(address_space &space, offs_t offset, UINT8 data, int ba, int cs0, int c1l, int c2l, int cs1, int c1h, int c2h) { };
166	158
167	159	protected:
168		plus4_expansion_slot_device *m_slot;
	160	optional_shared_ptr<UINT8> m_c1l;
	161	optional_shared_ptr<UINT8> m_c1h;
	162	optional_shared_ptr<UINT8> m_c2l;
	163	optional_shared_ptr<UINT8> m_c2h;
169	164
170		UINT8 *m_c1l;
171		UINT8 *m_c1h;
172		UINT8 *m_c2l;
173		UINT8 *m_c2h;
174		UINT8 *m_ram;
175		UINT8 *m_nvram;
176
177		size_t m_nvram_size;
178
179	165	size_t m_c1l_mask;
180	166	size_t m_c1h_mask;
181	167	size_t m_c2l_mask;
182	168	size_t m_c2h_mask;
183		size_t m_ram_mask;
184		size_t m_nvram_mask;
	169
	170	plus4_expansion_slot_device *m_slot;
185	171	};
186	172
187	173

trunk/src/emu/bus/vic10/exp.h

r26672	r26673
152	152	device_vic10_expansion_card_interface(const machine_config &mconfig, device_t &device);
153	153	virtual ~device_vic10_expansion_card_interface();
154	154
155		protected:
156		// initialization
157		virtual UINT8* vic10_exram_pointer(running_machine &machine, size_t size);
158		virtual UINT8* vic10_lorom_pointer(running_machine &machine, size_t size);
159		virtual UINT8* vic10_uprom_pointer(running_machine &machine, size_t size);
160
161		// runtime
162	155	virtual UINT8 vic10_cd_r(address_space &space, offs_t offset, UINT8 data, int lorom, int uprom, int exram) { return data; };
163	156	virtual void vic10_cd_w(address_space &space, offs_t offset, UINT8 data, int lorom, int uprom, int exram) { };
164	157	virtual int vic10_p0_r() { return 0; };
r26672	r26673
166	159	virtual void vic10_sp_w(int state) { };
167	160	virtual void vic10_cnt_w(int state) { };
168	161
169		vic10_expansion_slot_device *m_slot;
	162	protected:
	163	optional_shared_ptr<UINT8> m_lorom;
	164	optional_shared_ptr<UINT8> m_exram;
	165	optional_shared_ptr<UINT8> m_uprom;
170	166
171		UINT8 *m_exram;
172		UINT8 *m_lorom;
173		UINT8 *m_uprom;
	167	vic10_expansion_slot_device *m_slot;
174	168	};
175	169
176	170

trunk/src/emu/bus/vic10/std.c

r26672	r26673
51	51
52	52	UINT8 vic10_standard_cartridge_device::vic10_cd_r(address_space &space, offs_t offset, UINT8 data, int lorom, int uprom, int exram)
53	53	{
54		if (!lorom && (m_lorom != NULL))
	54	if (!lorom && m_lorom.bytes())
55	55	{
56		data = m_lorom[offset & 0x1fff];
	56	data = m_lorom[offset & m_lorom.mask()];
57	57	}
58		else if (!exram && (m_exram != NULL))
	58	else if (!exram && m_exram.bytes())
59	59	{
60		data = m_exram[offset & 0x7ff];
	60	data = m_exram[offset & m_exram.mask()];
61	61	}
62		else if (!uprom && (m_uprom != NULL))
	62	else if (!uprom && m_uprom.bytes())
63	63	{
64		data = m_uprom[offset & 0x1fff];
	64	data = m_uprom[offset & m_uprom.mask()];
65	65	}
66	66
67	67	return data;
r26672	r26673
74	74
75	75	void vic10_standard_cartridge_device::vic10_cd_w(address_space &space, offs_t offset, UINT8 data, int lorom, int uprom, int exram)
76	76	{
77		if (!exram && (m_exram != NULL))
	77	if (!exram && m_exram.bytes())
78	78	{
79		m_exram[offset & 0x7ff] = data;
	79	m_exram[offset & m_exram.mask()] = data;
80	80	}
81	81	}

trunk/src/emu/bus/vic10/exp.c

r26672	r26673
33	33
34	34	device_vic10_expansion_card_interface::device_vic10_expansion_card_interface(const machine_config &mconfig, device_t &device)
35	35	: device_slot_card_interface(mconfig,device),
36		m_exram(NULL),
37		m_lorom(NULL),
38		m_uprom(NULL)
	36	m_lorom(*this, "lorom"),
	37	m_exram(*this, "exram"),
	38	m_uprom(*this, "uprom")
39	39	{
40	40	m_slot = dynamic_cast<vic10_expansion_slot_device *>(device.owner());
41	41	}
r26672	r26673
51	51
52	52
53	53
54		//-------------------------------------------------
55		//  vic10_lorom_pointer - get lower ROM pointer
56		//-------------------------------------------------
57
58		UINT8* device_vic10_expansion_card_interface::vic10_lorom_pointer(running_machine &machine, size_t size)
59		{
60		if (m_lorom == NULL)
61		{
62		m_lorom = auto_alloc_array(machine, UINT8, size);
63		}
64
65		return m_lorom;
66		}
67
68
69		//-------------------------------------------------
70		//  vic10_uprom_pointer - get upper ROM pointer
71		//-------------------------------------------------
72
73		UINT8* device_vic10_expansion_card_interface::vic10_uprom_pointer(running_machine &machine, size_t size)
74		{
75		if (m_uprom == NULL)
76		{
77		m_uprom = auto_alloc_array(machine, UINT8, size);
78		}
79
80		return m_uprom;
81		}
82
83
84		//-------------------------------------------------
85		//  vic10_exram_pointer - get expanded RAM pointer
86		//-------------------------------------------------
87
88		UINT8* device_vic10_expansion_card_interface::vic10_exram_pointer(running_machine &machine, size_t size)
89		{
90		if (m_exram == NULL)
91		{
92		m_exram = auto_alloc_array(machine, UINT8, size);
93		}
94
95		return m_exram;
96		}
97
98
99
100	54	//**************************************************************************
101	55	//  LIVE DEVICE
102	56	//**************************************************************************
r26672	r26673
170	124
171	125	if (!mame_stricmp(filetype(), "80"))
172	126	{
173		fread(m_card->vic10_lorom_pointer(machine(), 0x2000), 0x2000);
	127	fread(m_card->m_lorom, 0x2000);
174	128
175	129	if (size == 0x4000)
176	130	{
177		fread(m_card->vic10_uprom_pointer(machine(), 0x2000), 0x2000);
	131	fread(m_card->m_uprom, 0x2000);
178	132	}
179	133	}
180		else if (!mame_stricmp(filetype(), "e0")) fread(m_card->vic10_uprom_pointer(machine(), size), size);
	134	else if (!mame_stricmp(filetype(), "e0"))
	135	{
	136	fread(m_card->m_uprom, size);
	137	}
181	138	else if (!mame_stricmp(filetype(), "crt"))
182	139	{
183	140	size_t roml_size = 0;
r26672	r26673
190	147	UINT8 *roml = NULL;
191	148	UINT8 *romh = NULL;
192	149
193		if (roml_size) roml = m_card->vic10_lorom_pointer(machine(), roml_size);
194		if (romh_size) romh = m_card->vic10_uprom_pointer(machine(), romh_size);
	150	m_card->m_lorom.allocate(roml_size);
	151	m_card->m_uprom.allocate(romh_size);
195	152
	153	if (roml_size) roml = m_card->m_lorom;
	154	if (romh_size) romh = m_card->m_lorom;
	155
196	156	cbm_crt_read_data(m_file, roml, romh);
197	157	}
198	158	}
199	159	}
200	160	else
201	161	{
202		size = get_software_region_length("lorom");
203		if (size) memcpy(m_card->vic10_lorom_pointer(machine(), size), get_software_region("lorom"), size);
204
205		size = get_software_region_length("uprom");
206		if (size) memcpy(m_card->vic10_uprom_pointer(machine(), size), get_software_region("uprom"), size);
207
208		size = get_software_region_length("exram");
209		if (size) m_card->vic10_exram_pointer(machine(), size);
	162	load_software_region("lorom", m_card->m_lorom);
	163	load_software_region("exram", m_card->m_exram);
	164	load_software_region("uprom", m_card->m_uprom);
210	165	}
211	166	}
212	167

trunk/src/emu/bus/vic10/std.h

r26672	r26673
26	26	// ======================> vic10_standard_cartridge_device
27	27
28	28	class vic10_standard_cartridge_device :  public device_t,
29		public device_vic10_expansion_card_interface
	29	public device_vic10_expansion_card_interface
30	30	{
31	31	public:
32	32	// construction/destruction

trunk/src/emu/bus/vic20/megacart.c

r26672	r26673
21	21
22	22
23	23	//-------------------------------------------------
24		//  MACHINE_DRIVER( vic1112 )
	24	//  MACHINE_DRIVER( vic20_megacart )
25	25	//-------------------------------------------------
26	26
27		static MACHINE_CONFIG_FRAGMENT( vic1112 )
	27	static MACHINE_CONFIG_FRAGMENT( vic20_megacart )
28	28
29	29	MACHINE_CONFIG_END
30	30
r26672	r26673
36	36
37	37	machine_config_constructor vic20_megacart_device::device_mconfig_additions() const
38	38	{
39		return MACHINE_CONFIG_NAME( vic1112 );
	39	return MACHINE_CONFIG_NAME( vic20_megacart );
40	40	}
41	41
42	42
r26672	r26673
64	64
65	65	void vic20_megacart_device::device_start()
66	66	{
	67	m_nvram.allocate(0x2000);
	68
67	69	// state saving
68	70	save_item(NAME(m_nvram_en));
69	71	}

trunk/src/emu/bus/vic20/vic1110.c

r26672	r26673
71	71	vic1110_device::vic1110_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
72	72	: device_t(mconfig, VIC1110, "VIC1110", tag, owner, clock, "vic1110", __FILE__),
73	73	device_vic20_expansion_card_interface(mconfig, *this),
	74	m_ram(*this, "ram"),
74	75	m_sw(*this, "SW")
75	76	{
76	77	}
r26672	r26673
83	84	void vic1110_device::device_start()
84	85	{
85	86	// allocate memory
86		vic20_ram_pointer(machine(), 0x2000);
	87	m_ram.allocate(0x2000);
87	88	}
88	89
89	90

trunk/src/emu/bus/vic20/vic1111.c

r26672	r26673
31	31
32	32	vic1111_device::vic1111_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
33	33	: device_t(mconfig, VIC1111, "VIC1111", tag, owner, clock, "vic1111", __FILE__),
34		device_vic20_expansion_card_interface(mconfig, *this)
	34	device_vic20_expansion_card_interface(mconfig, *this),
	35	m_ram(*this, "ram")
35	36	{
36	37	}
37	38
r26672	r26673
43	44	void vic1111_device::device_start()
44	45	{
45	46	// allocate memory
46		m_ram = auto_alloc_array(machine(), UINT8, 0x4000);
	47	m_ram.allocate(0x4000);
47	48	}
48	49
49	50

trunk/src/emu/bus/vic20/vic1210.c

r26672	r26673
32	32
33	33	vic1210_device::vic1210_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
34	34	: device_t(mconfig, VIC1210, "VIC1210", tag, owner, clock, "vic1210", __FILE__),
35		device_vic20_expansion_card_interface(mconfig, *this)
	35	device_vic20_expansion_card_interface(mconfig, *this),
	36	m_ram(*this, "ram")
36	37	{
37	38	}
38	39
r26672	r26673
44	45	void vic1210_device::device_start()
45	46	{
46	47	// allocate memory
47		m_ram = auto_alloc_array(machine(), UINT8, 0xc00);
	48	m_ram.allocate(0xc00);
48	49	}
49	50
50	51

trunk/src/emu/bus/vic20/megacart.h

r26672	r26673
43	43
44	44	// device_nvram_interface overrides
45	45	virtual void nvram_default() { }
46		virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram_size); } }
47		virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram_size); } }
	46	virtual void nvram_read(emu_file &file) { file.read(m_nvram, m_nvram.bytes()); }
	47	virtual void nvram_write(emu_file &file) { file.write(m_nvram, m_nvram.bytes()); }
48	48
49	49	// device_vic20_expansion_card_interface overrides
50	50	virtual UINT8 vic20_cd_r(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3);

trunk/src/emu/bus/vic20/vic1110.h

r26672	r26673
44	44	virtual void vic20_cd_w(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3);
45	45
46	46	private:
	47	optional_shared_ptr<UINT8> m_ram;
47	48	required_ioport m_sw;
48	49	};
49	50

trunk/src/emu/bus/vic20/vic1111.h

r26672	r26673
39	39	// device_vic20_expansion_card_interface overrides
40	40	virtual UINT8 vic20_cd_r(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3);
41	41	virtual void vic20_cd_w(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3);
	42
	43	private:
	44	optional_shared_ptr<UINT8> m_ram;
42	45	};
43	46
44	47

trunk/src/emu/bus/vic20/vic1210.h

r26672	r26673
40	40	// device_vic20_expansion_card_interface overrides
41	41	virtual UINT8 vic20_cd_r(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3);
42	42	virtual void vic20_cd_w(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3);
	43
	44	private:
	45	optional_shared_ptr<UINT8> m_ram;
43	46	};
44	47
45	48

trunk/src/emu/bus/vic20/exp.c

r26672	r26673
33	33
34	34	device_vic20_expansion_card_interface::device_vic20_expansion_card_interface(const machine_config &mconfig, device_t &device)
35	35	: device_slot_card_interface(mconfig, device),
36		m_blk1(NULL),
37		m_blk2(NULL),
38		m_blk3(NULL),
39		m_blk5(NULL),
40		m_ram(NULL),
41		m_nvram(NULL),
42		m_nvram_size(0)
	36	m_blk1(*this, "blk1"),
	37	m_blk2(*this, "blk2"),
	38	m_blk3(*this, "blk3"),
	39	m_blk5(*this, "blk5"),
	40	m_nvram(*this, "nvram")
43	41	{
44	42	m_slot = dynamic_cast<vic20_expansion_slot_device *>(device.owner());
45	43	}
46	44
47	45
48	46	//-------------------------------------------------
49		//  vic20_blk1_pointer - get block 1 pointer
50		//-------------------------------------------------
51
52		UINT8* device_vic20_expansion_card_interface::vic20_blk1_pointer(running_machine &machine, size_t size)
53		{
54		if (m_blk1 == NULL)
55		{
56		m_blk1 = auto_alloc_array(machine, UINT8, size);
57		}
58
59		return m_blk1;
60		}
61
62
63		//-------------------------------------------------
64		//  vic20_blk2_pointer - get block 2 pointer
65		//-------------------------------------------------
66
67		UINT8* device_vic20_expansion_card_interface::vic20_blk2_pointer(running_machine &machine, size_t size)
68		{
69		if (m_blk2 == NULL)
70		{
71		m_blk2 = auto_alloc_array(machine, UINT8, size);
72		}
73
74		return m_blk2;
75		}
76
77
78		//-------------------------------------------------
79		//  vic20_blk3_pointer - get block 3 pointer
80		//-------------------------------------------------
81
82		UINT8* device_vic20_expansion_card_interface::vic20_blk3_pointer(running_machine &machine, size_t size)
83		{
84		if (m_blk3 == NULL)
85		{
86		m_blk3 = auto_alloc_array(machine, UINT8, size);
87		}
88
89		return m_blk3;
90		}
91
92
93		//-------------------------------------------------
94		//  vic20_blk5_pointer - get block 5 pointer
95		//-------------------------------------------------
96
97		UINT8* device_vic20_expansion_card_interface::vic20_blk5_pointer(running_machine &machine, size_t size)
98		{
99		if (m_blk5 == NULL)
100		{
101		m_blk5 = auto_alloc_array(machine, UINT8, size);
102		}
103
104		return m_blk5;
105		}
106
107
108		//-------------------------------------------------
109		//  vic20_ram_pointer - get RAM pointer
110		//-------------------------------------------------
111
112		UINT8* device_vic20_expansion_card_interface::vic20_ram_pointer(running_machine &machine, size_t size)
113		{
114		if (m_ram == NULL)
115		{
116		m_ram = auto_alloc_array(machine, UINT8, size);
117		}
118
119		return m_ram;
120		}
121
122
123		//-------------------------------------------------
124		//  vic20_nvram_pointer - get NVRAM pointer
125		//-------------------------------------------------
126
127		UINT8* device_vic20_expansion_card_interface::vic20_nvram_pointer(running_machine &machine, size_t size)
128		{
129		if (m_nvram == NULL)
130		{
131		m_nvram = auto_alloc_array(machine, UINT8, size);
132
133		m_nvram_mask = size - 1;
134		m_nvram_size = size;
135		}
136
137		return m_nvram;
138		}
139
140
141		//-------------------------------------------------
142	47	//  ~device_vic20_expansion_card_interface - destructor
143	48	//-------------------------------------------------
144	49
r26672	r26673
211	116	{
212	117	if (m_card)
213	118	{
214		size_t size = 0;
215
216	119	if (software_entry() == NULL)
217	120	{
218		if (!mame_stricmp(filetype(), "20")) fread(m_card->vic20_blk1_pointer(machine(), 0x2000), 0x2000);
219		else if (!mame_stricmp(filetype(), "40")) fread(m_card->vic20_blk2_pointer(machine(), 0x2000), 0x2000);
220		else if (!mame_stricmp(filetype(), "60")) fread(m_card->vic20_blk3_pointer(machine(), 0x2000), 0x2000);
221		else if (!mame_stricmp(filetype(), "70")) fread(m_card->vic20_blk3_pointer(machine(), 0x2000) + 0x1000, 0x1000);
222		else if (!mame_stricmp(filetype(), "a0")) fread(m_card->vic20_blk5_pointer(machine(), 0x2000), 0x2000);
223		else if (!mame_stricmp(filetype(), "b0")) fread(m_card->vic20_blk5_pointer(machine(), 0x2000) + 0x1000, 0x1000);
	121	if (!mame_stricmp(filetype(), "20")) fread(m_card->m_blk1, 0x2000);
	122	else if (!mame_stricmp(filetype(), "40")) fread(m_card->m_blk2, 0x2000);
	123	else if (!mame_stricmp(filetype(), "60")) fread(m_card->m_blk3, 0x2000);
	124	else if (!mame_stricmp(filetype(), "70")) fread(m_card->m_blk3, 0x2000, 0x1000);
	125	else if (!mame_stricmp(filetype(), "a0")) fread(m_card->m_blk5, 0x2000);
	126	else if (!mame_stricmp(filetype(), "b0")) fread(m_card->m_blk5, 0x2000, 0x1000);
224	127	else if (!mame_stricmp(filetype(), "crt"))
225	128	{
226	129	// read the header
r26672	r26673
230	133
231	134	switch (address)
232	135	{
233		case 0x2000: fread(m_card->vic20_blk1_pointer(machine(), 0x2000), 0x2000); break;
234		case 0x4000: fread(m_card->vic20_blk2_pointer(machine(), 0x2000), 0x2000); break;
235		case 0x6000: fread(m_card->vic20_blk3_pointer(machine(), 0x2000), 0x2000); break;
236		case 0x7000: fread(m_card->vic20_blk3_pointer(machine(), 0x2000) + 0x1000, 0x1000); break;
237		case 0xa000: fread(m_card->vic20_blk5_pointer(machine(), 0x2000), 0x2000); break;
238		case 0xb000: fread(m_card->vic20_blk5_pointer(machine(), 0x2000) + 0x1000, 0x1000); break;
	136	case 0x2000: fread(m_card->m_blk1, 0x2000); break;
	137	case 0x4000: fread(m_card->m_blk2, 0x2000); break;
	138	case 0x6000: fread(m_card->m_blk3, 0x2000); break;
	139	case 0x7000: fread(m_card->m_blk3, 0x2000, 0x1000); break;
	140	case 0xa000: fread(m_card->m_blk5, 0x2000); break;
	141	case 0xb000: fread(m_card->m_blk5, 0x2000, 0x1000); break;
239	142	default: return IMAGE_INIT_FAIL;
240	143	}
241	144	}
242	145	}
243	146	else
244	147	{
245		size = get_software_region_length("blk1");
246		if (size) memcpy(m_card->vic20_blk1_pointer(machine(), size), get_software_region("blk1"), size);
247
248		size = get_software_region_length("blk2");
249		if (size) memcpy(m_card->vic20_blk2_pointer(machine(), size), get_software_region("blk2"), size);
250
251		size = get_software_region_length("blk3");
252		if (size) memcpy(m_card->vic20_blk3_pointer(machine(), size), get_software_region("blk3"), size);
253
254		size = get_software_region_length("blk5");
255		if (size) memcpy(m_card->vic20_blk5_pointer(machine(), size), get_software_region("blk5"), size);
256
257		size = get_software_region_length("ram");
258		if (size) memcpy(m_card->vic20_ram_pointer(machine(), size), get_software_region("ram"), size);
259
260		size = get_software_region_length("nvram");
261		if (size) memcpy(m_card->vic20_nvram_pointer(machine(), size), get_software_region("nvram"), size);
262
	148	load_software_region("blk1", m_card->m_blk1);
	149	load_software_region("blk2", m_card->m_blk2);
	150	load_software_region("blk3", m_card->m_blk3);
	151	load_software_region("blk5", m_card->m_blk5);
263	152	}
264	153	}
265	154

trunk/src/emu/bus/vic20/exp.h

r26672	r26673
144	144	device_vic20_expansion_card_interface(const machine_config &mconfig, device_t &device);
145	145	virtual ~device_vic20_expansion_card_interface();
146	146
147		protected:
148		// initialization
149		virtual UINT8* vic20_blk1_pointer(running_machine &machine, size_t size);
150		virtual UINT8* vic20_blk2_pointer(running_machine &machine, size_t size);
151		virtual UINT8* vic20_blk3_pointer(running_machine &machine, size_t size);
152		virtual UINT8* vic20_blk5_pointer(running_machine &machine, size_t size);
153		virtual UINT8* vic20_ram_pointer(running_machine &machine, size_t size);
154		virtual UINT8* vic20_nvram_pointer(running_machine &machine, size_t size);
155
156		// runtime
157	147	virtual UINT8 vic20_cd_r(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3) { return data; };
158	148	virtual void vic20_cd_w(address_space &space, offs_t offset, UINT8 data, int ram1, int ram2, int ram3, int blk1, int blk2, int blk3, int blk5, int io2, int io3) { };
159	149
160		vic20_expansion_slot_device *m_slot;
	150	protected:
	151	optional_shared_ptr<UINT8> m_blk1;
	152	optional_shared_ptr<UINT8> m_blk2;
	153	optional_shared_ptr<UINT8> m_blk3;
	154	optional_shared_ptr<UINT8> m_blk5;
	155	optional_shared_ptr<UINT8> m_nvram;
161	156
162		UINT8 *m_blk1;
163		UINT8 *m_blk2;
164		UINT8 *m_blk3;
165		UINT8 *m_blk5;
166		UINT8 *m_ram;
167		UINT8 *m_nvram;
168
169		size_t m_nvram_size;
170
171		size_t m_nvram_mask;
	157	vic20_expansion_slot_device *m_slot;
172	158	};
173	159
174	160

trunk/src/emu/bus/cbm2/24k.c

r26672	r26673
31	31
32	32	cbm2_24k_cartridge_device::cbm2_24k_cartridge_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
33	33	device_t(mconfig, CBM2_24K, "24K RAM/ROM cartridge", tag, owner, clock, "cbm2_24k", __FILE__),
34		device_cbm2_expansion_card_interface(mconfig, *this)
	34	device_cbm2_expansion_card_interface(mconfig, *this),
	35	m_ram(*this, "ram")
35	36	{
36	37	}
37	38
r26672	r26673
42	43
43	44	void cbm2_24k_cartridge_device::device_start()
44	45	{
45		cbm2_ram_pointer(machine(), 0x6000);
	46	m_ram.allocate(0x6000);
46	47	}
47	48
48	49

trunk/src/emu/bus/cbm2/exp.h

r26672	r26673
116	116	device_cbm2_expansion_card_interface(const machine_config &mconfig, device_t &device);
117	117	virtual ~device_cbm2_expansion_card_interface();
118	118
119		protected:
120		// initialization
121		virtual UINT8* cbm2_bank1_pointer(running_machine &machine, size_t size);
122		virtual UINT8* cbm2_bank2_pointer(running_machine &machine, size_t size);
123		virtual UINT8* cbm2_bank3_pointer(running_machine &machine, size_t size);
124		virtual UINT8* cbm2_ram_pointer(running_machine &machine, size_t size);
125		virtual UINT8* cbm2_nvram_pointer(running_machine &machine, size_t size);
126
127		// runtime
128	119	virtual UINT8 cbm2_bd_r(address_space &space, offs_t offset, UINT8 data, int csbank1, int csbank2, int csbank3) { return data; };
129	120	virtual void cbm2_bd_w(address_space &space, offs_t offset, UINT8 data, int csbank1, int csbank2, int csbank3) { };
130	121
131		cbm2_expansion_slot_device *m_slot;
	122	protected:
	123	optional_shared_ptr<UINT8> m_bank1;
	124	optional_shared_ptr<UINT8> m_bank2;
	125	optional_shared_ptr<UINT8> m_bank3;
132	126
133		UINT8 *m_bank1;
134		UINT8 *m_bank2;
135		UINT8 *m_bank3;
136		UINT8 *m_ram;
137		UINT8 *m_nvram;
138
139		size_t m_nvram_size;
140
141		size_t m_bank1_mask;
142		size_t m_bank2_mask;
143		size_t m_bank3_mask;
144		size_t m_ram_mask;
145		size_t m_nvram_mask;
	127	cbm2_expansion_slot_device *m_slot;
146	128	};
147	129
148	130

trunk/src/emu/bus/cbm2/24k.h

r26672	r26673
39	39	// device_cbm2_expansion_card_interface overrides
40	40	virtual UINT8 cbm2_bd_r(address_space &space, offs_t offset, UINT8 data, int csbank1, int csbank2, int csbank3);
41	41	virtual void cbm2_bd_w(address_space &space, offs_t offset, UINT8 data, int csbank1, int csbank2, int csbank3);
	42
	43	optional_shared_ptr<UINT8> m_ram;
42	44	};
43	45
44	46

trunk/src/emu/bus/cbm2/std.c

r26672	r26673
51	51
52	52	UINT8 cbm2_standard_cartridge_device::cbm2_bd_r(address_space &space, offs_t offset, UINT8 data, int csbank1, int csbank2, int csbank3)
53	53	{
54		if (!csbank1 && m_bank1_mask)
	54	if (!csbank1 && m_bank1.bytes())
55	55	{
56		data = m_bank1[offset & m_bank1_mask];
	56	data = m_bank1[offset & m_bank1.mask()];
57	57	}
58		else if (!csbank2 && m_bank2_mask)
	58	else if (!csbank2 && m_bank2.bytes())
59	59	{
60		data = m_bank2[offset & m_bank2_mask];
	60	data = m_bank2[offset & m_bank2.mask()];
61	61	}
62		else if (!csbank3 && m_bank3_mask)
	62	else if (!csbank3 && m_bank3.bytes())
63	63	{
64		data = m_bank3[offset & m_bank3_mask];
	64	data = m_bank3[offset & m_bank3.mask()];
65	65	}
66	66
67	67	return data;

trunk/src/emu/bus/cbm2/exp.c

r26672	r26673
39	39
40	40	device_cbm2_expansion_card_interface::device_cbm2_expansion_card_interface(const machine_config &mconfig, device_t &device)
41	41	: device_slot_card_interface(mconfig, device),
42		m_bank1(NULL),
43		m_bank2(NULL),
44		m_bank3(NULL),
45		m_ram(NULL),
46		m_nvram(NULL),
47		m_nvram_size(0),
48		m_bank1_mask(0),
49		m_bank2_mask(0),
50		m_bank3_mask(0),
51		m_ram_mask(0)
	42	m_bank1(*this, "bank1"),
	43	m_bank2(*this, "bank2"),
	44	m_bank3(*this, "bank3")
52	45	{
53	46	m_slot = dynamic_cast<cbm2_expansion_slot_device *>(device.owner());
54	47	}
r26672	r26673
63	56	}
64	57
65	58
66		//-------------------------------------------------
67		//  cbm2_bank1_pointer - get bank 1 pointer
68		//-------------------------------------------------
69	59
70		UINT8* device_cbm2_expansion_card_interface::cbm2_bank1_pointer(running_machine &machine, size_t size)
71		{
72		if (m_bank1 == NULL)
73		{
74		m_bank1 = auto_alloc_array(machine, UINT8, size);
75
76		m_bank1_mask = size - 1;
77		}
78
79		return m_bank1;
80		}
81
82
83		//-------------------------------------------------
84		//  cbm2_bank2_pointer - get bank 2 pointer
85		//-------------------------------------------------
86
87		UINT8* device_cbm2_expansion_card_interface::cbm2_bank2_pointer(running_machine &machine, size_t size)
88		{
89		if (m_bank2 == NULL)
90		{
91		m_bank2 = auto_alloc_array(machine, UINT8, size);
92
93		m_bank2_mask = size - 1;
94		}
95
96		return m_bank2;
97		}
98
99
100		//-------------------------------------------------
101		//  cbm2_bank3_pointer - get bank 3 pointer
102		//-------------------------------------------------
103
104		UINT8* device_cbm2_expansion_card_interface::cbm2_bank3_pointer(running_machine &machine, size_t size)
105		{
106		if (m_bank3 == NULL)
107		{
108		m_bank3 = auto_alloc_array(machine, UINT8, size);
109
110		m_bank3_mask = size - 1;
111		}
112
113		return m_bank3;
114		}
115
116
117		//-------------------------------------------------
118		//  cbm2_ram_pointer - get RAM pointer
119		//-------------------------------------------------
120
121		UINT8* device_cbm2_expansion_card_interface::cbm2_ram_pointer(running_machine &machine, size_t size)
122		{
123		if (m_ram == NULL)
124		{
125		m_ram = auto_alloc_array(machine, UINT8, size);
126
127		m_ram_mask = size - 1;
128		}
129
130		return m_ram;
131		}
132
133
134		//-------------------------------------------------
135		//  cbm2_ram_pointer - get NVRAM pointer
136		//-------------------------------------------------
137
138		UINT8* device_cbm2_expansion_card_interface::cbm2_nvram_pointer(running_machine &machine, size_t size)
139		{
140		if (m_nvram == NULL)
141		{
142		m_nvram = auto_alloc_array(machine, UINT8, size);
143
144		m_nvram_mask = size - 1;
145		m_nvram_size = size;
146		}
147
148		return m_nvram;
149		}
150
151
152
153	60	//**************************************************************************
154	61	//  LIVE DEVICE
155	62	//**************************************************************************
r26672	r26673
209	116
210	117	if (!mame_stricmp(filetype(), "20"))
211	118	{
212		fread(m_card->cbm2_bank1_pointer(machine(), size), size);
	119	m_card->m_bank1.allocate(size);
	120	fread(m_card->m_bank1, size);
213	121	}
214	122	else if (!mame_stricmp(filetype(), "40"))
215	123	{
216		fread(m_card->cbm2_bank2_pointer(machine(), size), size);
	124	m_card->m_bank2.allocate(size);
	125	fread(m_card->m_bank2, size);
217	126	}
218	127	else if (!mame_stricmp(filetype(), "60"))
219	128	{
220		fread(m_card->cbm2_bank3_pointer(machine(), size), size);
	129	m_card->m_bank3.allocate(size);
	130	fread(m_card->m_bank3, size);
221	131	}
222	132	}
223	133	else
224	134	{
225		size = get_software_region_length("bank1");
226		if (size) memcpy(m_card->cbm2_bank1_pointer(machine(), size), get_software_region("bank1"), size);
227
228		size = get_software_region_length("bank2");
229		if (size) memcpy(m_card->cbm2_bank2_pointer(machine(), size), get_software_region("bank2"), size);
230
231		size = get_software_region_length("bank3");
232		if (size) memcpy(m_card->cbm2_bank3_pointer(machine(), size), get_software_region("bank3"), size);
233
234		size = get_software_region_length("ram");
235		if (size) memset(m_card->cbm2_ram_pointer(machine(), size), 0, size);
236
237		size = get_software_region_length("nvram");
238		if (size) memset(m_card->cbm2_nvram_pointer(machine(), size), 0, size);
	135	load_software_region("bank1", m_card->m_bank1);
	136	load_software_region("bank2", m_card->m_bank2);
	137	load_software_region("bank3", m_card->m_bank3);
239	138	}
240	139	}
241	140

trunk/src/emu/bus/c64/dqbb.h

r26672	r26673
42	42
43	43	// device_nvram_interface overrides
44	44	virtual void nvram_default() { }
45		virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram_size); } }
46		virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram_size); } }
	45	virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram.bytes()); } }
	46	virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram.bytes()); } }
47	47
48	48	// device_c64_expansion_card_interface overrides
49	49	virtual UINT8 c64_cd_r(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2);

trunk/src/emu/bus/c64/magic_formel.c

r26672	r26673
182	182	device_t(mconfig, C64_MAGIC_FORMEL, "C64 Magic Formel cartridge", tag, owner, clock, "c64_magic_formel", __FILE__),
183	183	device_c64_expansion_card_interface(mconfig, *this),
184	184	m_pia(*this, MC6821_TAG),
	185	m_ram(*this, "ram"),
185	186	m_rom_bank(0),
186	187	m_ram_bank(0),
187	188	m_pb7_ff(0),
r26672	r26673
199	200
200	201	void c64_magic_formel_cartridge_device::device_start()
201	202	{
	203	// allocate memory
	204	m_ram.allocate(0x2000);
	205
202	206	// state saving
203	207	save_item(NAME(m_rom_bank));
204	208	save_item(NAME(m_ram_bank));

trunk/src/emu/bus/c64/magic_formel.h

r26672	r26673
57	57
58	58	private:
59	59	required_device<pia6821_device> m_pia;
	60	optional_shared_ptr<UINT8> m_ram;
60	61
61	62	UINT8 m_rom_bank;
62	63	UINT8 m_ram_bank;

trunk/src/emu/bus/c64/partner.c

r26672	r26673
82	82	c64_partner_cartridge_device::c64_partner_cartridge_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
83	83	device_t(mconfig, C64_PARTNER, "C64 PARTNER 64 cartridge", tag, owner, clock, "c64_partner", __FILE__),
84	84	device_c64_expansion_card_interface(mconfig, *this),
	85	m_ram(*this, "ram"),
85	86	m_a0(1),
86	87	m_a6(1),
87	88	m_nmi(0)
r26672	r26673
96	97	void c64_partner_cartridge_device::device_start()
97	98	{
98	99	// allocate memory
99		c64_ram_pointer(machine(), 0x2000);
	100	m_ram.allocate(0x2000);
100	101	}
101	102
102	103

trunk/src/emu/bus/c64/partner.h

r26672	r26673
48	48	virtual int c64_game_r(offs_t offset, int sphi2, int ba, int rw);
49	49
50	50	private:
	51	optional_shared_ptr<UINT8> m_ram;
	52
51	53	int m_a0;
52	54	int m_a6;
53	55	int m_nmi;

trunk/src/emu/bus/c64/ocean.c

r26672	r26673
86	86
87	87	UINT8 c64_ocean_cartridge_device::c64_cd_r(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2)
88	88	{
89		if (!roml)
	89	if (!roml && m_roml.bytes())
90	90	{
91	91	offs_t addr = (m_bank << 13) | (offset & 0x1fff);
92		data = m_roml[addr & m_roml_mask];
	92	data = m_roml[addr & m_roml.mask()];
93	93	}
94		else if (!romh && m_romh)
	94	else if (!romh && m_romh.bytes())
95	95	{
96	96	offs_t addr = (m_bank << 13) | (offset & 0x1fff);
97		data = m_romh[addr & m_romh_mask];
	97	data = m_romh[addr & m_romh.mask()];
98	98	}
99	99	else if (!io1)
100	100	{

trunk/src/emu/bus/c64/exp.c

r26672	r26673
31	31
32	32	device_c64_expansion_card_interface::device_c64_expansion_card_interface(const machine_config &mconfig, device_t &device)
33	33	: device_slot_card_interface(mconfig, device),
34		m_roml(NULL),
35		m_romh(NULL),
36		m_ram(NULL),
37		m_nvram(NULL),
38		m_nvram_size(0),
39		m_roml_mask(0),
40		m_romh_mask(0),
41		m_ram_mask(0),
	34	m_roml(*this, "roml"),
	35	m_romh(*this, "romh"),
	36	m_nvram(*this, "nvram"),
42	37	m_game(1),
43	38	m_exrom(1)
44	39	{
r26672	r26673
55	50	}
56	51
57	52
58		//-------------------------------------------------
59		//  c64_roml_pointer - get low ROM pointer
60		//-------------------------------------------------
61	53
62		UINT8* device_c64_expansion_card_interface::c64_roml_pointer(running_machine &machine, size_t size)
63		{
64		if (m_roml == NULL)
65		{
66		m_roml = auto_alloc_array(machine, UINT8, size);
67
68		m_roml_mask = size - 1;
69		}
70
71		return m_roml;
72		}
73
74
75		//-------------------------------------------------
76		//  c64_romh_pointer - get high ROM pointer
77		//-------------------------------------------------
78
79		UINT8* device_c64_expansion_card_interface::c64_romh_pointer(running_machine &machine, size_t size)
80		{
81		if (m_romh == NULL)
82		{
83		m_romh = auto_alloc_array(machine, UINT8, size);
84
85		m_romh_mask = size - 1;
86		}
87
88		return m_romh;
89		}
90
91
92		//-------------------------------------------------
93		//  c64_ram_pointer - get RAM pointer
94		//-------------------------------------------------
95
96		UINT8* device_c64_expansion_card_interface::c64_ram_pointer(running_machine &machine, size_t size)
97		{
98		if (m_ram == NULL)
99		{
100		m_ram = auto_alloc_array(machine, UINT8, size);
101
102		m_ram_mask = size - 1;
103		}
104
105		return m_ram;
106		}
107
108
109		//-------------------------------------------------
110		//  c64_ram_pointer - get NVRAM pointer
111		//-------------------------------------------------
112
113		UINT8* device_c64_expansion_card_interface::c64_nvram_pointer(running_machine &machine, size_t size)
114		{
115		if (m_nvram == NULL)
116		{
117		m_nvram = auto_alloc_array(machine, UINT8, size);
118
119		m_nvram_mask = size - 1;
120		m_nvram_size = size;
121		}
122
123		return m_nvram;
124		}
125
126
127
128	54	//**************************************************************************
129	55	//  LIVE DEVICE
130	56	//**************************************************************************
r26672	r26673
202	128
203	129	if (!mame_stricmp(filetype(), "80"))
204	130	{
205		fread(m_card->c64_roml_pointer(machine(), size), size);
	131	fread(m_card->m_roml, size);
206	132	m_card->m_exrom = (0);
207	133
208	134	if (size == 0x4000)
r26672	r26673
212	138	}
213	139	else if (!mame_stricmp(filetype(), "a0"))
214	140	{
215		fread(m_card->c64_romh_pointer(machine(), 0x2000), 0x2000);
	141	fread(m_card->m_romh, 0x2000);
216	142
217	143	m_card->m_exrom = 0;
218	144	m_card->m_game = 0;
219	145	}
220	146	else if (!mame_stricmp(filetype(), "e0"))
221	147	{
222		fread(m_card->c64_romh_pointer(machine(), 0x2000), 0x2000);
	148	fread(m_card->m_romh, 0x2000);
223	149
224	150	m_card->m_game = 0;
225	151	}
r26672	r26673
235	161	UINT8 *roml = NULL;
236	162	UINT8 *romh = NULL;
237	163
238		if (roml_size) roml = m_card->c64_roml_pointer(machine(), roml_size);
239		if (romh_size) romh = m_card->c64_romh_pointer(machine(), romh_size);
	164	m_card->m_roml.allocate(roml_size);
	165	m_card->m_romh.allocate(romh_size);
240	166
	167	if (roml_size) roml = m_card->m_roml;
	168	if (romh_size) romh = m_card->m_roml;
	169
241	170	cbm_crt_read_data(m_file, roml, romh);
242	171	}
243	172
r26672	r26673
252	181	if (size)
253	182	{
254	183	// Ultimax (VIC-10) cartridge
255		memcpy(m_card->c64_romh_pointer(machine(), size), get_software_region("uprom"), size);
	184	load_software_region("lorom", m_card->m_roml);
	185	load_software_region("uprom", m_card->m_romh);
256	186
257		size = get_software_region_length("lorom");
258		if (size) memcpy(m_card->c64_roml_pointer(machine(), size), get_software_region("lorom"), size);
259
260	187	m_card->m_exrom = 1;
261	188	m_card->m_game = 0;
262	189	}
263	190	else
264	191	{
265	192	// Commodore 64/128 cartridge
266		size = get_software_region_length("roml");
267		if (size) memcpy(m_card->c64_roml_pointer(machine(), size), get_software_region("roml"), size);
	193	load_software_region("roml", m_card->m_roml);
	194	load_software_region("romh", m_card->m_romh);
	195	load_software_region("nvram", m_card->m_nvram);
268	196
269		size = get_software_region_length("romh");
270		if (size) memcpy(m_card->c64_romh_pointer(machine(), size), get_software_region("romh"), size);
271
272		size = get_software_region_length("ram");
273		if (size) memset(m_card->c64_ram_pointer(machine(), size), 0, size);
274
275		size = get_software_region_length("nvram");
276		if (size) memset(m_card->c64_nvram_pointer(machine(), size), 0, size);
277
278	197	if (get_feature("exrom") != NULL) m_card->m_exrom = atol(get_feature("exrom"));
279	198	if (get_feature("game") != NULL) m_card->m_game = atol(get_feature("game"));
280	199	}

trunk/src/emu/bus/c64/exp.h

r26672	r26673
167	167	device_c64_expansion_card_interface(const machine_config &mconfig, device_t &device);
168	168	virtual ~device_c64_expansion_card_interface();
169	169
170		protected:
171		// initialization
172		virtual UINT8* c64_roml_pointer(running_machine &machine, size_t size);
173		virtual UINT8* c64_romh_pointer(running_machine &machine, size_t size);
174		virtual UINT8* c64_ram_pointer(running_machine &machine, size_t size);
175		virtual UINT8* c64_nvram_pointer(running_machine &machine, size_t size);
176
177		// runtime
178	170	virtual UINT8 c64_cd_r(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2) { return data; };
179	171	virtual void c64_cd_w(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2) { };
180	172	virtual int c64_game_r(offs_t offset, int sphi2, int ba, int rw) { return m_game; }
181	173	virtual int c64_exrom_r(offs_t offset, int sphi2, int ba, int rw) { return m_exrom; }
182	174
183		c64_expansion_slot_device *m_slot;
	175	protected:
	176	optional_shared_ptr<UINT8> m_roml;
	177	optional_shared_ptr<UINT8> m_romh;
	178	optional_shared_ptr<UINT8> m_nvram;
184	179
185		UINT8 *m_roml;
186		UINT8 *m_romh;
187		UINT8 *m_ram;
188		UINT8 *m_nvram;
189
190		size_t m_nvram_size;
191
192		size_t m_roml_mask;
193		size_t m_romh_mask;
194		size_t m_ram_mask;
195		size_t m_nvram_mask;
196
197	180	int m_game;
198	181	int m_exrom;
	182
	183	c64_expansion_slot_device *m_slot;
199	184	};
200	185
201	186

trunk/src/emu/bus/c64/ide64.c

r26672	r26673
103	103	m_flash_rom(*this, AT29C010A_TAG),
104	104	m_rtc(*this, DS1302_TAG),
105	105	m_ata(*this, ATA_TAG),
106		m_jp1(*this, "JP1")
	106	m_jp1(*this, "JP1"),
	107	m_ram(*this, "ram")
107	108	{
108	109	}
109	110
r26672	r26673
115	116	void c64_ide64_cartridge_device::device_start()
116	117	{
117	118	// allocate memory
118		c64_ram_pointer(machine(), 0x8000);
	119	m_ram.allocate(0x8000);
119	120
120	121	// state saving
121	122	save_item(NAME(m_bank));

trunk/src/emu/bus/c64/ide64.h

r26672	r26673
57	57	required_device<ds1302_device> m_rtc;
58	58	required_device<ata_interface_device> m_ata;
59	59	required_ioport m_jp1;
	60	optional_shared_ptr<UINT8> m_ram;
60	61
61	62	UINT8 m_bank;
62	63	UINT16 m_ata_data;

trunk/src/emu/bus/c64/xl80.c

r26672	r26673
178	178	device_t(mconfig, C64_XL80, "XL 80", tag, owner, clock, "c64_xl80", __FILE__),
179	179	device_c64_expansion_card_interface(mconfig, *this),
180	180	m_crtc(*this, HD46505SP_TAG),
181		m_char_rom(*this, HD46505SP_TAG)
	181	m_char_rom(*this, HD46505SP_TAG),
	182	m_ram(*this, "ram")
182	183	{
183	184	}
184	185
r26672	r26673
190	191	void c64_xl80_device::device_start()
191	192	{
192	193	// allocate memory
193		c64_ram_pointer(machine(), RAM_SIZE);
194
195		// state saving
196		save_pointer(NAME(m_ram), RAM_SIZE);
	194	m_ram.allocate(RAM_SIZE);
197	195	}
198	196
199	197

trunk/src/emu/bus/c64/xl80.h

r26672	r26673
55	55	private:
56	56	required_device<h46505_device> m_crtc;
57	57	required_memory_region m_char_rom;
	58	optional_shared_ptr<UINT8> m_ram;
58	59	};
59	60
60	61

trunk/src/emu/bus/c64/ross.c

r26672	r26673
70	70	{
71	71	offs_t addr = (m_bank << 14) | (offset & 0x3fff);
72	72
73		data = m_roml[addr & m_roml_mask];
	73	data = m_roml[addr & m_roml.mask()];
74	74	}
75	75
76	76	return data;

trunk/src/emu/bus/c64/fcc.c

r26672	r26673
244	244
245	245	READ8_MEMBER( c64_final_chesscard_device::nvram_r )
246	246	{
247		return m_nvram[offset & m_nvram_mask];
	247	return m_nvram[offset & m_nvram.mask()];
248	248	}
249	249
250	250
r26672	r26673
254	254
255	255	WRITE8_MEMBER( c64_final_chesscard_device::nvram_w )
256	256	{
257		m_nvram[offset & m_nvram_mask] = data;
	257	m_nvram[offset & m_nvram.mask()] = data;
258	258	}

trunk/src/emu/bus/c64/fcc.h

r26672	r26673
49	49
50	50	// device_nvram_interface overrides
51	51	virtual void nvram_default() { }
52		virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram_size); } }
53		virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram_size); } }
	52	virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram.bytes()); } }
	53	virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram.bytes()); } }
54	54
55	55	// device_c64_expansion_card_interface overrides
56	56	virtual UINT8 c64_cd_r(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2);

trunk/src/emu/bus/c64/16kb.c

r26672	r26673
102	102	c64_16kb_cartridge_device::c64_16kb_cartridge_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
103	103	device_t(mconfig, C64_16KB, "C64 16KB EPROM cartridge", tag, owner, clock, "c64_16kb", __FILE__),
104	104	device_c64_expansion_card_interface(mconfig, *this),
105		m_sw1(*this, "SW1")
	105	m_sw1(*this, "SW1"),
	106	m_rom_low(*this, "roml"),
	107	m_rom_high(*this, "romh")
106	108	{
107	109	}
108	110
r26672	r26673
113	115
114	116	void c64_16kb_cartridge_device::device_start()
115	117	{
116		m_roml = memregion("roml")->base();
117		m_romh = memregion("romh")->base();
118	118	}
119	119
120	120
r26672	r26673
139	139	{
140	140	if (!roml)
141	141	{
142		data = m_roml[offset & 0x1fff];
	142	data = m_rom_low->base()[offset & 0x1fff];
143	143	}
144	144	else if (!romh)
145	145	{
146		data = m_romh[offset & 0x1fff];
	146	data = m_rom_high->base()[offset & 0x1fff];
147	147	}
148	148
149	149	return data;

trunk/src/emu/bus/c64/16kb.h

r26672	r26673
49	49
50	50	private:
51	51	required_ioport m_sw1;
	52	required_memory_region m_rom_low;
	53	required_memory_region m_rom_high;
52	54	};
53	55
54	56

trunk/src/emu/bus/c64/westermann.c

r26672	r26673
63	63	{
64	64	if (!roml)
65	65	{
66		data = m_roml[offset & 0x1fff];
	66	data = m_roml[offset & m_roml.mask()];
67	67	}
68	68	else if (!romh)
69	69	{
70		if (m_romh_mask)
	70	if (m_romh.bytes())
71	71	{
72		data = m_romh[offset & 0x1fff];
	72	data = m_romh[offset & m_romh.mask()];
73	73	}
74	74	else
75	75	{
76		data = m_roml[offset & 0x3fff];
	76	data = m_roml[offset & m_roml.mask()];
77	77	}
78	78	}
79	79	else if (!io2)

trunk/src/emu/bus/c64/georam.c

r26672	r26673
31	31
32	32	c64_georam_cartridge_device::c64_georam_cartridge_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
33	33	device_t(mconfig, C64_GEORAM, "C64 GeoRAM cartridge", tag, owner, clock, "c64_georam", __FILE__),
34		device_c64_expansion_card_interface(mconfig, *this)
	34	device_c64_expansion_card_interface(mconfig, *this),
	35	m_ram(*this, "ram")
35	36	{
36	37	}
37	38
r26672	r26673
43	44	void c64_georam_cartridge_device::device_start()
44	45	{
45	46	// allocate memory
46		c64_ram_pointer(machine(), 0x80000);
	47	m_ram.allocate(0x80000);
47	48
48	49	// state saving
49	50	save_item(NAME(m_bank));

trunk/src/emu/bus/c64/georam.h

r26672	r26673
43	43	virtual void c64_cd_w(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2);
44	44
45	45	private:
	46	optional_shared_ptr<UINT8> m_ram;
	47
46	48	UINT16 m_bank;
47	49	};
48	50

trunk/src/emu/bus/c64/pagefox.c

r26672	r26673
53	53
54	54	c64_pagefox_cartridge_device::c64_pagefox_cartridge_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
55	55	device_t(mconfig, C64_PAGEFOX, "C64 Pagefox cartridge", tag, owner, clock, "c64_pagefox", __FILE__),
56		device_c64_expansion_card_interface(mconfig, *this)
	56	device_c64_expansion_card_interface(mconfig, *this),
	57	m_ram(*this, "ram")
57	58	{
58	59	}
59	60
r26672	r26673
64	65
65	66	void c64_pagefox_cartridge_device::device_start()
66	67	{
	68	// allocate memory
	69	m_ram.allocate(0x8000);
	70
67	71	// state saving
68	72	save_item(NAME(m_bank));
69	73	}

trunk/src/emu/bus/c64/std.c

r26672	r26673
51	51
52	52	UINT8 c64_standard_cartridge_device::c64_cd_r(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2)
53	53	{
54		if (!roml && m_roml_mask)
	54	if (!roml && m_roml.bytes())
55	55	{
56		data = m_roml[offset & 0x1fff];
	56	data = m_roml[offset & m_roml.mask()];
57	57	}
58	58	else if (!romh)
59	59	{
60		if (m_romh_mask)
	60	if (m_romh.bytes())
61	61	{
62		data = m_romh[offset & 0x1fff];
	62	data = m_romh[offset & m_romh.mask()];
63	63	}
64		else if (m_roml_mask == 0x3fff)
	64	else if (m_roml.mask() == 0x3fff)
65	65	{
66		data = m_roml[offset & 0x3fff];
	66	data = m_roml[offset & m_roml.mask()];
67	67	}
68	68	}
69	69

trunk/src/emu/bus/c64/pagefox.h

r26672	r26673
43	43	virtual void c64_cd_w(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2);
44	44
45	45	private:
	46	optional_shared_ptr<UINT8> m_ram;
	47
46	48	UINT8 m_bank;
47	49	};
48	50

trunk/src/emu/bus/c64/easyflash.c

r26672	r26673
89	89	m_flash_roml(*this, AM29F040_0_TAG),
90	90	m_flash_romh(*this, AM29F040_1_TAG),
91	91	m_jp1(*this, "JP1"),
	92	m_ram(*this, "ram"),
92	93	m_bank(0),
93	94	m_mode(0)
94	95	{
r26672	r26673
102	103	void c64_easyflash_cartridge_device::device_start()
103	104	{
104	105	// allocate memory
105		c64_ram_pointer(machine(), 0x100);
	106	m_ram.allocate(0x100);
106	107
107	108	// state saving
108	109	save_item(NAME(m_bank));

trunk/src/emu/bus/c64/neoram.c

r26672	r26673
44	44	void c64_neoram_cartridge_device::device_start()
45	45	{
46	46	// allocate memory
47		c64_nvram_pointer(machine(), 0x200000);
	47	m_nvram.allocate(0x200000);
48	48
49	49	// state saving
50	50	save_item(NAME(m_bank));

trunk/src/emu/bus/c64/easyflash.h

r26672	r26673
53	53	required_device<amd_29f040_device> m_flash_roml;
54	54	required_device<amd_29f040_device> m_flash_romh;
55	55	required_ioport m_jp1;
	56	optional_shared_ptr<UINT8> m_ram;
56	57
57	58	UINT8 m_bank;
58	59	UINT8 m_mode;

trunk/src/emu/bus/c64/neoram.h

r26672	r26673
41	41
42	42	// device_nvram_interface overrides
43	43	virtual void nvram_default() { }
44		virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram_size); } }
45		virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram_size); } }
	44	virtual void nvram_read(emu_file &file) { if (m_nvram != NULL) { file.read(m_nvram, m_nvram.bytes()); } }
	45	virtual void nvram_write(emu_file &file) { if (m_nvram != NULL) { file.write(m_nvram, m_nvram.bytes()); } }
46	46
47	47	// device_c64_expansion_card_interface overrides
48	48	virtual UINT8 c64_cd_r(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2);

trunk/src/emu/bus/c64/reu.c

r26672	r26673
86	86	device_t(mconfig, type, name, tag, owner, clock, shortname, source),
87	87	device_c64_expansion_card_interface(mconfig, *this),
88	88	m_dmac(*this, MOS8726R1_TAG),
	89	m_rom(*this, "rom"),
	90	m_ram(*this, "ram"),
89	91	m_variant(variant),
90	92	m_jp1(jp1),
91	93	m_ram_size(ram_size)
r26672	r26673
108	110
109	111	void c64_reu_cartridge_device::device_start()
110	112	{
111		// find memory region
112		m_roml = memregion("roml")->base();
113
114	113	// allocate memory
115		c64_ram_pointer(machine(), m_ram_size);
	114	m_ram.allocate(m_ram_size);
116	115
117	116	// setup DMA controller
118	117	m_dmac->set_unscaled_clock(m_slot->phi2());

trunk/src/emu/bus/c64/reu.h

r26672	r26673
56	56	virtual void c64_cd_w(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2);
57	57
58	58	required_device<mos8726_device> m_dmac;
	59	required_memory_region m_rom;
	60	optional_shared_ptr<UINT8> m_ram;
59	61
60	62	int m_variant;
61	63	int m_jp1;

trunk/src/emu/bus/c64/dqbb.c

r26672	r26673
53	53	void c64_dqbb_cartridge_device::device_start()
54	54	{
55	55	// allocate memory
56		c64_nvram_pointer(machine(), 0x4000);
	56	m_nvram.allocate(0x4000);
57	57
58	58	// state saving
59	59	save_item(NAME(m_cs));

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team