Previous

199869 Revisions

Next

r32225 Saturday 20th September, 2014 at 06:38:07 UTC by Fabio Priuli
another round of generic carts / sockets. nw.

[src/mess/drivers]	aim65.c pegasus.c pencil2.c sorcerer.c sv8000.c ti74.c uzebox.c
[src/mess/includes]	sorcerer.h
[src/mess/machine]	sorcerer.c

trunk/src/mess/machine/sorcerer.c

r32224	r32225
372	372	space.unmap_readwrite(0x8000, endmem);
373	373	break;
374	374	}
	375
	376	if (m_cart->cart_mounted())
	377	space.install_read_handler(0xc000, 0xdfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
375	378	}
376	379
377	380	MACHINE_START_MEMBER(sorcerer_state,sorcererd)

trunk/src/mess/includes/sorcerer.h

r32224	r32225
15	15	#include "bus/centronics/ctronics.h"
16	16	#include "bus/centronics/covox.h"
17	17	#include "machine/ram.h"
18		#include "imagedev/cartslot.h"
19	18	#include "imagedev/cassette.h"
20	19	#include "imagedev/snapquik.h"
21	20	#include "imagedev/flopdrv.h"
22	21	#include "formats/sorc_dsk.h"
23	22	#include "formats/sorc_cas.h"
24	23	#include "machine/micropolis.h"
	24	#include "bus/generic/slot.h"
	25	#include "bus/generic/carts.h"
25	26
26	27	#define SORCERER_USING_RS232 0
27	28
r32224	r32225
58	59	, m_wave2(*this, WAVE2_TAG)
59	60	, m_uart(*this, "uart")
60	61	, m_centronics(*this, "centronics")
	62	, m_cart(*this, "cartslot")
61	63	, m_ram(*this, RAM_TAG)
62	64	, m_iop_config(*this, "CONFIG")
63	65	, m_iop_vs(*this, "VS")
r32224	r32225
96	98	required_device<wave_device> m_wave2;
97	99	required_device<ay31015_device> m_uart;
98	100	required_device<centronics_device> m_centronics;
	101	required_device<generic_slot_device> m_cart;
99	102	required_device<ram_device> m_ram;
100	103	required_ioport m_iop_config;
101	104	required_ioport m_iop_vs;

trunk/src/mess/drivers/aim65.c

r32224	r32225
146	146
147	147	int aim65_state::load_cart(device_image_interface &image, generic_slot_device *slot, const char *slot_tag)
148	148	{
149		UINT32 size = slot->common_get_size("rom");
150
	149	UINT32 size = slot->common_get_size(slot_tag);
	150
151	151	if (size > 0x1000)
152	152	{
153	153	image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");

trunk/src/mess/drivers/sv8000.c

r32224	r32225
27	27
28	28	#include "emu.h"
29	29	#include "cpu/z80/z80.h"
30		#include "imagedev/cartslot.h"
31	30	#include "machine/i8255.h"
32	31	#include "sound/ay8910.h"
33	32	#include "video/mc6847.h"
	33	#include "bus/generic/slot.h"
	34	#include "bus/generic/carts.h"
34	35
35	36
36	37	class sv8000_state : public driver_device
r32224	r32225
40	41	: driver_device(mconfig, type, tag)
41	42	, m_maincpu(*this, "maincpu")
42	43	, m_s68047p(*this, "s68047p")
	44	, m_cart(*this, "cartslot")
43	45	, m_videoram(*this, "videoram")
44	46	, m_io_row0(*this, "ROW0")
45	47	, m_io_row1(*this, "ROW1")
r32224	r32225
69	71
70	72	required_device<cpu_device> m_maincpu;
71	73	required_device<s68047_device> m_s68047p;
	74	required_device<generic_slot_device> m_cart;
72	75	required_shared_ptr<UINT8> m_videoram;
73	76	required_ioport m_io_row0;
74	77	required_ioport m_io_row1;
r32224	r32225
91	94
92	95	static ADDRESS_MAP_START(sv8000_mem, AS_PROGRAM, 8, sv8000_state)
93	96	ADDRESS_MAP_UNMAP_HIGH
94		AM_RANGE( 0x0000, 0x0fff ) AM_ROM
	97	//AM_RANGE(0x0000, 0x0fff)      // mapped by the cartslot
95	98	AM_RANGE( 0x8000, 0x83ff ) AM_RAM // Work RAM??
96	99	AM_RANGE( 0xc000, 0xcbff ) AM_RAM AM_SHARE("videoram")
97	100	ADDRESS_MAP_END
r32224	r32225
170	173	m_intext = 0;
171	174	m_inv = 0;
172	175
	176	if (m_cart->cart_mounted())
	177	m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
	178
173	179	save_item(NAME(m_column));
174	180	save_item(NAME(m_ag));
175	181	save_item(NAME(m_gm2));
r32224	r32225
190	196
191	197	DEVICE_IMAGE_LOAD_MEMBER( sv8000_state, cart )
192	198	{
193		UINT8 *cart = memregion("maincpu")->base();
194
195		if (image.software_entry() == NULL)
	199	UINT32 size = m_cart->common_get_size("rom");
	200
	201	if (size != 0x1000)
196	202	{
197		UINT32 filesize = image.length();
198
199		if (filesize != 0x1000)
200		{
201		image.seterror(IMAGE_ERROR_UNSPECIFIED, "Incorrect or not support cartridge size");
202		return IMAGE_INIT_FAIL;
203		}
204
205		if (image.fread( cart, filesize) != filesize)
206		{
207		image.seterror(IMAGE_ERROR_UNSPECIFIED, "Error loading file");
208		return IMAGE_INIT_FAIL;
209		}
	203	image.seterror(IMAGE_ERROR_UNSPECIFIED, "Incorrect or not support cartridge size");
	204	return IMAGE_INIT_FAIL;
210	205	}
211		else
212		{
213		memcpy(cart, image.get_software_region("rom"), image.get_software_region_length("rom"));
214		}
215
	206
	207	m_cart->rom_alloc(size, 1);
	208	m_cart->common_load_rom(m_cart->get_rom_base(), size, "rom");
	209
216	210	return IMAGE_INIT_PASS;
217	211	}
218	212
r32224	r32225
261	255	READ8_MEMBER( sv8000_state::i8255_portc_r )
262	256	{
263	257	//logerror("i8255_portc_r\n");
264		return 0xFF;
	258	return 0xff;
265	259	}
266	260
267	261
r32224	r32225
274	268
275	269	READ8_MEMBER( sv8000_state::ay_port_a_r )
276	270	{
277		UINT8 data = 0xFF;
	271	UINT8 data = 0xff;
278	272
279	273	//logerror("ay_port_a_r\n");
280	274	return data;
r32224	r32225
404	398	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
405	399
406	400	/* cartridge */
407		MCFG_CARTSLOT_ADD("cart")
408		MCFG_CARTSLOT_EXTENSION_LIST("bin")
409		MCFG_CARTSLOT_MANDATORY
410		MCFG_CARTSLOT_LOAD(sv8000_state,cart)
411		MCFG_CARTSLOT_INTERFACE("sv8000_cart")
	401	MCFG_GENERIC_CARTSLOT_ADD("cartslot", GENERIC_ROM8_WIDTH, generic_plain_slot, "sv8000_cart")
	402	MCFG_GENERIC_MANDATORY
	403	MCFG_GENERIC_LOAD(sv8000_state, cart)
412	404
413	405	/* software lists */
414	406	MCFG_SOFTWARE_LIST_ADD("cart_list","sv8000")

trunk/src/mess/drivers/pegasus.c

r32224	r32225
33	33	hardware.
34	34
35	35	TO DO:
36		- Identify which rom slots the multi-rom programs should be fitted to.
37	36	- Work on the other non-working programs
38	37
39	38	****************************************************************************/
r32224	r32225
41	40	#include "emu.h"
42	41	#include "cpu/m6809/m6809.h"
43	42	#include "machine/6821pia.h"
44		#include "imagedev/cartslot.h"
45	43	#include "imagedev/cassette.h"
46	44	#include "sound/wave.h"
	45	#include "bus/generic/slot.h"
	46	#include "bus/generic/carts.h"
47	47
48	48
49	49
r32224	r32225
56	56	m_cass(*this, "cassette"),
57	57	m_pia_s(*this, "pia_s"),
58	58	m_pia_u(*this, "pia_u"),
	59	m_exp_00(*this, "exp00"),
	60	m_exp_01(*this, "exp01"),
	61	m_exp_02(*this, "exp02"),
	62	m_exp_0c(*this, "exp0c"),
	63	m_exp_0d(*this, "exp0d"),
59	64	m_p_videoram(*this, "p_videoram"){ }
60	65
61	66	required_device<cpu_device> m_maincpu;
62	67	required_device<cassette_image_device> m_cass;
63	68	required_device<pia6821_device> m_pia_s;
64	69	required_device<pia6821_device> m_pia_u;
	70	required_device<generic_slot_device> m_exp_00;
	71	required_device<generic_slot_device> m_exp_01;
	72	required_device<generic_slot_device> m_exp_02;
	73	required_device<generic_slot_device> m_exp_0c;
	74	required_device<generic_slot_device> m_exp_0d;
65	75	DECLARE_READ8_MEMBER( pegasus_keyboard_r );
66	76	DECLARE_READ8_MEMBER( pegasus_protection_r );
67	77	DECLARE_READ8_MEMBER( pegasus_pcg_r );
r32224	r32225
84	94	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
85	95	DECLARE_DRIVER_INIT(pegasus);
86	96	TIMER_DEVICE_CALLBACK_MEMBER(pegasus_firq);
87		DECLARE_DEVICE_IMAGE_LOAD_MEMBER(pegasus_cart_1);
88		DECLARE_DEVICE_IMAGE_LOAD_MEMBER(pegasus_cart_2);
89		DECLARE_DEVICE_IMAGE_LOAD_MEMBER(pegasus_cart_3);
90		DECLARE_DEVICE_IMAGE_LOAD_MEMBER(pegasus_cart_4);
91		DECLARE_DEVICE_IMAGE_LOAD_MEMBER(pegasus_cart_5);
92		void pegasus_decrypt_rom( UINT16 addr );
	97	void pegasus_decrypt_rom(UINT8 *ROM);
	98
	99	int load_cart(device_image_interface &image, generic_slot_device *slot, const char *reg_tag);
	100	DECLARE_DEVICE_IMAGE_LOAD_MEMBER(exp00_load) { return load_cart(image, m_exp_00, "0000"); }
	101	DECLARE_DEVICE_IMAGE_LOAD_MEMBER(exp01_load) { return load_cart(image, m_exp_01, "1000"); }
	102	DECLARE_DEVICE_IMAGE_LOAD_MEMBER(exp02_load) { return load_cart(image, m_exp_02, "2000"); }
	103	DECLARE_DEVICE_IMAGE_LOAD_MEMBER(exp0c_load) { return load_cart(image, m_exp_0c, "c000"); }
	104	DECLARE_DEVICE_IMAGE_LOAD_MEMBER(exp0d_load) { return load_cart(image, m_exp_0d, "d000"); }
93	105	};
94	106
95	107	TIMER_DEVICE_CALLBACK_MEMBER(pegasus_state::pegasus_firq)
r32224	r32225
171	183
172	184	static ADDRESS_MAP_START(pegasus_mem, AS_PROGRAM, 8, pegasus_state)
173	185	ADDRESS_MAP_UNMAP_HIGH
174		AM_RANGE(0x0000, 0x2fff) AM_ROM
	186	//AM_RANGE(0x0000, 0x2fff)      // mapped by the cartslots 1-3
175	187	AM_RANGE(0xb000, 0xbdff) AM_RAM
176	188	AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_SHARE("p_videoram")
177		AM_RANGE(0xc000, 0xdfff) AM_ROM AM_WRITENOP
	189	//AM_RANGE(0xc000, 0xdfff)      // mapped by the cartslots 4-5
178	190	AM_RANGE(0xe000, 0xe1ff) AM_READ(pegasus_protection_r)
179	191	AM_RANGE(0xe200, 0xe3ff) AM_READWRITE(pegasus_pcg_r,pegasus_pcg_w)
180	192	AM_RANGE(0xe400, 0xe403) AM_MIRROR(0x1fc) AM_DEVREADWRITE("pia_u", pia6821_device, read, write)
r32224	r32225
377	389
378	390	/* An encrypted single rom starts with 02, decrypted with 20. Not sure what
379	391	multipart roms will have. */
380		void pegasus_state::pegasus_decrypt_rom( UINT16 addr )
	392	void pegasus_state::pegasus_decrypt_rom(UINT8 *ROM)
381	393	{
382		UINT8 b, *ROM = memregion("maincpu")->base();
383		UINT16 i, j;
384		UINT8 buff[0x1000];
385		if (ROM[addr] == 0x02)
	394	UINT8 b;
	395	UINT16 j;
	396	dynamic_buffer temp_copy;
	397	temp_copy.resize(0x1000);
	398
	399	if (ROM[0] == 0x02)
386	400	{
387		for (i = 0; i < 0x1000; i++)
	401	for (int i = 0; i < 0x1000; i++)
388	402	{
389		b = ROM[addr|i];
390		j = BITSWAP16( i, 15, 14, 13, 12, 11, 10, 9, 8, 0, 1, 2, 3, 4, 5, 6, 7 );
391		b = BITSWAP8( b, 3, 2, 1, 0, 7, 6, 5, 4 );
392		buff[j&0xfff] = b;
	403	b = ROM[i];
	404	j = BITSWAP16(i, 15, 14, 13, 12, 11, 10, 9, 8, 0, 1, 2, 3, 4, 5, 6, 7);
	405	b = BITSWAP8(b, 3, 2, 1, 0, 7, 6, 5, 4);
	406	temp_copy[j & 0xfff] = b;
393	407	}
394		for (i = 0; i < 0x1000; i++)
395		ROM[addr|i] = buff[i];
	408	memcpy(ROM, temp_copy, 0x1000);
396	409	}
397	410	}
398	411
399		DEVICE_IMAGE_LOAD_MEMBER( pegasus_state, pegasus_cart_1 )
	412	int pegasus_state::load_cart(device_image_interface &image, generic_slot_device *slot, const char *reg_tag)
400	413	{
401		image.fread(memregion("maincpu")->base() + 0x0000, 0x1000);
402		pegasus_decrypt_rom( 0x0000 );
	414	UINT32 size = slot->common_get_size(reg_tag);
	415	bool any_socket = false;
	416
	417	if (size > 0x1000)
	418	{
	419	image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
	420	return IMAGE_INIT_FAIL;
	421	}
	422
	423	if (image.software_entry() != NULL && size == 0)
	424	{
	425	// we might be loading a cart compatible with all sockets!
	426	// so try to get region "rom"
	427	printf("universal\n");
	428	size = slot->common_get_size("rom");
	429	any_socket = true;
403	430
404		return IMAGE_INIT_PASS;
405		}
	431	if (size == 0)
	432	{
	433	astring errmsg;
	434	errmsg.printf("Attempted to load a file that does not work in this socket.\nPlease check \"Usage\" field in the software list for the correct socket(s) to use.");
	435	image.seterror(IMAGE_ERROR_UNSPECIFIED, errmsg.cstr());
	436	return IMAGE_INIT_FAIL;
	437	}
	438	}
406	439
407		DEVICE_IMAGE_LOAD_MEMBER( pegasus_state, pegasus_cart_2 )
408		{
409		image.fread(memregion("maincpu")->base() + 0x1000, 0x1000);
410		pegasus_decrypt_rom( 0x1000 );
411
	440	slot->rom_alloc(0x1000, 1);   // we alloc 0x1000 also for smaller roms!
	441	slot->common_load_rom(slot->get_rom_base(), size, any_socket ? "rom" : reg_tag);
	442
	443	// raw images have to be decrypted
	444	pegasus_decrypt_rom(slot->get_rom_base());
	445
412	446	return IMAGE_INIT_PASS;
413	447	}
414	448
415		DEVICE_IMAGE_LOAD_MEMBER( pegasus_state, pegasus_cart_3 )
416		{
417		image.fread(memregion("maincpu")->base() + 0x2000, 0x1000);
418		pegasus_decrypt_rom( 0x2000 );
419
420		return IMAGE_INIT_PASS;
421		}
422
423		DEVICE_IMAGE_LOAD_MEMBER( pegasus_state, pegasus_cart_4 )
424		{
425		image.fread(memregion("maincpu")->base() + 0xc000, 0x1000);
426		pegasus_decrypt_rom( 0xc000 );
427
428		return IMAGE_INIT_PASS;
429		}
430
431		DEVICE_IMAGE_LOAD_MEMBER( pegasus_state, pegasus_cart_5 )
432		{
433		image.fread(memregion("maincpu")->base() + 0xd000, 0x1000);
434		pegasus_decrypt_rom( 0xd000 );
435
436		return IMAGE_INIT_PASS;
437		}
438
439	449	void pegasus_state::machine_start()
440	450	{
441	451	m_p_pcgram = memregion("pcg")->base();
	452
	453	if (m_exp_00->cart_mounted())
	454	m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_00));
	455	if (m_exp_01->cart_mounted())
	456	m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_01));
	457	if (m_exp_02->cart_mounted())
	458	m_maincpu->space(AS_PROGRAM).install_read_handler(0x2000, 0x2fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_02));
	459	if (m_exp_0c->cart_mounted())
	460	m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xcfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_0c));
	461	if (m_exp_0d->cart_mounted())
	462	m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000, 0xdfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_0d));
442	463	}
443	464
444	465	void pegasus_state::machine_reset()
r32224	r32225
448	469	m_control_bits = 0;
449	470	}
450	471
451		DRIVER_INIT_MEMBER(pegasus_state,pegasus)
	472	DRIVER_INIT_MEMBER(pegasus_state, pegasus)
452	473	{
453		pegasus_decrypt_rom( 0xf000 );
	474	// decrypt monitor
	475	UINT8 *base = memregion("maincpu")->base() + 0xf000;
	476	pegasus_decrypt_rom(base);
454	477	}
455	478
456	479	static MACHINE_CONFIG_START( pegasus, pegasus_state )
r32224	r32225
488	511	MCFG_PIA_IRQA_HANDLER(DEVWRITELINE("maincpu", m6809e_device, irq_line))
489	512	MCFG_PIA_IRQB_HANDLER(DEVWRITELINE("maincpu", m6809e_device, irq_line))
490	513
491		MCFG_DEVICE_ADD( "pia_u", PIA6821, 0)
	514	MCFG_DEVICE_ADD("pia_u", PIA6821, 0)
492	515	MCFG_PIA_IRQA_HANDLER(DEVWRITELINE("maincpu", m6809e_device, irq_line))
493	516	MCFG_PIA_IRQB_HANDLER(DEVWRITELINE("maincpu", m6809e_device, irq_line))
494	517
495		MCFG_CARTSLOT_ADD("cart1")
496		MCFG_CARTSLOT_EXTENSION_LIST("bin")
497		MCFG_CARTSLOT_LOAD(pegasus_state,pegasus_cart_1)
498		MCFG_CARTSLOT_ADD("cart2")
499		MCFG_CARTSLOT_EXTENSION_LIST("bin")
500		MCFG_CARTSLOT_LOAD(pegasus_state,pegasus_cart_2)
501		MCFG_CARTSLOT_ADD("cart3")
502		MCFG_CARTSLOT_EXTENSION_LIST("bin")
503		MCFG_CARTSLOT_LOAD(pegasus_state,pegasus_cart_3)
504		MCFG_CARTSLOT_ADD("cart4")
505		MCFG_CARTSLOT_EXTENSION_LIST("bin")
506		MCFG_CARTSLOT_LOAD(pegasus_state,pegasus_cart_4)
507		MCFG_CARTSLOT_ADD("cart5")
508		MCFG_CARTSLOT_EXTENSION_LIST("bin")
509		MCFG_CARTSLOT_LOAD(pegasus_state,pegasus_cart_5)
510		MCFG_CASSETTE_ADD( "cassette" )
	518	MCFG_GENERIC_SOCKET_ADD("exp00", GENERIC_ROM8_WIDTH, generic_plain_slot, "pegasus_cart")
	519	MCFG_GENERIC_LOAD(pegasus_state, exp00_load)
	520
	521	MCFG_GENERIC_SOCKET_ADD("exp01", GENERIC_ROM8_WIDTH, generic_plain_slot, "pegasus_cart")
	522	MCFG_GENERIC_LOAD(pegasus_state, exp01_load)
	523
	524	MCFG_GENERIC_SOCKET_ADD("exp02", GENERIC_ROM8_WIDTH, generic_plain_slot, "pegasus_cart")
	525	MCFG_GENERIC_LOAD(pegasus_state, exp02_load)
	526
	527	MCFG_GENERIC_SOCKET_ADD("exp0c", GENERIC_ROM8_WIDTH, generic_plain_slot, "pegasus_cart")
	528	MCFG_GENERIC_LOAD(pegasus_state, exp0c_load)
	529
	530	MCFG_GENERIC_SOCKET_ADD("exp0d", GENERIC_ROM8_WIDTH, generic_plain_slot, "pegasus_cart")
	531	MCFG_GENERIC_LOAD(pegasus_state, exp0d_load)
	532
	533	MCFG_CASSETTE_ADD("cassette")
511	534	MCFG_CASSETTE_DEFAULT_STATE(CASSETTE_STOPPED|CASSETTE_MOTOR_ENABLED)
	535
	536	/* Software lists */
	537	MCFG_SOFTWARE_LIST_ADD("cart_list", "pegasus_cart")
512	538	MACHINE_CONFIG_END
513	539
514	540	static MACHINE_CONFIG_DERIVED( pegasusm, pegasus )

trunk/src/mess/drivers/uzebox.c

r32224	r32225
16	16	#include "emu.h"
17	17	#include "cpu/avr8/avr8.h"
18	18	#include "sound/dac.h"
19		#include "imagedev/cartslot.h"
	19	#include "bus/generic/slot.h"
	20	#include "bus/generic/carts.h"
20	21
21	22	// overclocked to 8 * NTSC burst frequency
22	23	#define MASTER_CLOCK 28618180
r32224	r32225
28	29	public:
29	30	uzebox_state(const machine_config &mconfig, device_type type, const char *tag)
30	31	: driver_device(mconfig, type, tag),
31		m_maincpu(*this, "maincpu")
32		{
33		}
	32	m_maincpu(*this, "maincpu"),
	33	m_cart(*this, "cartslot")
	34	{ }
34	35
35	36	required_device<avr8_device> m_maincpu;
	37	required_device<generic_slot_device> m_cart;
36	38
37	39	DECLARE_READ8_MEMBER(port_a_r);
38	40	DECLARE_WRITE8_MEMBER(port_a_w);
r32224	r32225
64	66	void uzebox_state::machine_start()
65	67	{
66	68	machine().first_screen()->register_screen_bitmap(m_bitmap);
	69
	70	if (m_cart->cart_mounted())
	71	m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0xffff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
67	72	}
68	73
69	74	void uzebox_state::machine_reset()
r32224	r32225
265	270	return 0;
266	271	}
267	272
268		DEVICE_IMAGE_LOAD_MEMBER(uzebox_state,uzebox_cart)
	273	DEVICE_IMAGE_LOAD_MEMBER(uzebox_state, uzebox_cart)
269	274	{
270		UINT8* rom = (UINT8*)(*memregion("maincpu"));
	275	UINT32 size = m_cart->common_get_size("rom");
	276
	277	m_cart->rom_alloc(size, 1);
271	278
272		memset(rom, 0xff, memregion("maincpu")->bytes());
273
274	279	if (image.software_entry() == NULL)
275	280	{
276		UINT32 size = image.length();
277	281	dynamic_buffer data(size);
278
279	282	image.fread(data, size);
280	283
281	284	if (!strncmp((const char*)&data[0], "UZEBOX", 6))
282		memcpy(rom, data + 0x200, size - 0x200);
	285	memcpy(m_cart->get_rom_base(), data + 0x200, size - 0x200);
283	286	else
284		memcpy(rom, data, size);
	287	memcpy(m_cart->get_rom_base(), data, size);
285	288	}
286	289	else
287		{
288		memcpy(rom, image.get_software_region("rom"), image.get_software_region_length("rom"));
289		}
	290	memcpy(m_cart->get_rom_base(), image.get_software_region("rom"), size);
290	291
291	292	return IMAGE_INIT_PASS;
292	293	}
r32224	r32225
323	324	MCFG_SOUND_ADD("dac", DAC, 0)
324	325	MCFG_SOUND_ROUTE(0, "avr8", 1.00)
325	326
326		MCFG_CARTSLOT_ADD("cart1")
327		MCFG_CARTSLOT_EXTENSION_LIST("bin,uze")
328		MCFG_CARTSLOT_MANDATORY
329		MCFG_CARTSLOT_LOAD(uzebox_state,uzebox_cart)
330		MCFG_CARTSLOT_INTERFACE("uzebox")
	327	MCFG_GENERIC_CARTSLOT_ADD("cartslot", GENERIC_ROM8_WIDTH, generic_plain_slot, "uzebox")
	328	MCFG_GENERIC_EXTENSIONS("bin,uze")
	329	MCFG_GENERIC_MANDATORY
	330	MCFG_GENERIC_LOAD(uzebox_state, uzebox_cart)
	331
331	332	MCFG_SOFTWARE_LIST_ADD("eprom_list","uzebox")
332	333	MACHINE_CONFIG_END
333	334

trunk/src/mess/drivers/pencil2.c

r32224	r32225
38	38	U22    74LS05
39	39	U23-24 SN74LS541
40	40
41		BASIC CART PEN-700 11-50332-31 Rev.0
42		SD-BASIC VERSION 2.0 FOR PENCIL II
43		(c) 1983 SOUNDIC ELECTRONICS LTD HONG KONG ALL RIGHTS RESERVED
	41
	42	SD-BASIC usage:
44	43	All commands must be in uppercase, which is the default at boot.
45	44	The 'capslock' is done by pressing Shift and Esc together, and the
46	45	cursor will change to a checkerboard pattern.
47		1 x 2732
48		2 x 2764
49		The roms were dumped by attaching a cable from the printer port to
50		a Super-80 and writing programs in Basic to transfer the bytes.
51		Therefore it is not known which rom "202" or "203" is which address range.
52	46
53	47
54	48	MEMORY MAP
r32224	r32225
61	55	but is banked out of view of a BASIC program.
62	56
63	57
64		KNOWN CARTS
65		SD-BASIC V1.0
66		SD-BASIC V2.0
67		Zaxxon
68		Smurf
69
70
71	58	ToDo:
72	59	- Cassette isn't working
73	60	- Joysticks (no info)
74		- Cart slot (only 1 cart has been dumped, so probably no point coding it)
75	61
76	62	****************************************************************************/
77	63
r32224	r32225
80	66	#include "video/tms9928a.h"
81	67	#include "sound/sn76496.h"
82	68	#include "bus/centronics/ctronics.h"
83		//#include "imagedev/cartslot.h"
84	69	#include "imagedev/cassette.h"
85	70	#include "sound/wave.h"
	71	#include "bus/generic/slot.h"
	72	#include "bus/generic/carts.h"
86	73
87	74
88	75	class pencil2_state : public driver_device
r32224	r32225
93	80	, m_maincpu(*this, "maincpu")
94	81	, m_centronics(*this, "centronics")
95	82	, m_cass(*this, "cassette")
	83	, m_cart(*this, "cartslot")
96	84	{}
97	85
98	86	DECLARE_WRITE8_MEMBER(port10_w);
r32224	r32225
105	93	DECLARE_CUSTOM_INPUT_MEMBER(printer_ready_r);
106	94	DECLARE_CUSTOM_INPUT_MEMBER(printer_ack_r);
107	95	private:
108		virtual void machine_reset();
	96	virtual void machine_start();
109	97	int m_centronics_busy;
110	98	int m_centronics_ack;
111	99	required_device<cpu_device> m_maincpu;
112	100	required_device<centronics_device> m_centronics;
113	101	required_device<cassette_image_device> m_cass;
	102	required_device<generic_slot_device> m_cart;
114	103	};
115	104
116	105	static ADDRESS_MAP_START(pencil2_mem, AS_PROGRAM, 8, pencil2_state)
117	106	ADDRESS_MAP_UNMAP_HIGH
118	107	AM_RANGE(0x0000, 0x1fff) AM_ROM
119		AM_RANGE(0x2000, 0x5FFF) AM_WRITENOP  // stop error log filling up
	108	AM_RANGE(0x2000, 0x5fff) AM_WRITENOP  // stop error log filling up
120	109	AM_RANGE(0x6000, 0x67ff) AM_MIRROR(0x1800) AM_RAM
121		AM_RANGE(0x8000, 0xffff) AM_ROM
	110	//AM_RANGE(0x8000, 0xffff)      // mapped by the cartslot
122	111	ADDRESS_MAP_END
123	112
124	113	static ADDRESS_MAP_START(pencil2_io, AS_IO, 8, pencil2_state)
r32224	r32225
283	272	INPUT_PORTS_END
284	273
285	274
286		void pencil2_state::machine_reset()
	275	void pencil2_state::machine_start()
287	276	{
	277	if (m_cart->cart_mounted())
	278	m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xffff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
288	279	}
289	280
290	281	static MACHINE_CONFIG_START( pencil2, pencil2_state )
r32224	r32225
310	301	MCFG_CASSETTE_ADD( "cassette" )
311	302
312	303	/* cartridge */
313		//  MCFG_CARTSLOT_ADD("cart")
314		//  MCFG_CARTSLOT_EXTENSION_LIST("rom")
315		//  MCFG_CARTSLOT_NOT_MANDATORY
316		//  MCFG_CARTSLOT_LOAD(pencil2_cart)
317		//  MCFG_CARTSLOT_INTERFACE("pencil2_cart")
	304	MCFG_GENERIC_CARTSLOT_ADD("cartslot", GENERIC_ROM8_WIDTH, generic_plain_slot, "pencil2_cart")
318	305
319	306	/* printer */
320	307	MCFG_CENTRONICS_ADD("centronics", centronics_printers, "printer")
r32224	r32225
322	309	MCFG_CENTRONICS_BUSY_HANDLER(WRITELINE(pencil2_state, write_centronics_busy))
323	310
324	311	MCFG_CENTRONICS_OUTPUT_LATCH_ADD("cent_data_out", "centronics")
	312
	313	/* Software lists */
	314	MCFG_SOFTWARE_LIST_ADD("cart_list", "pencil2")
325	315	MACHINE_CONFIG_END
326	316
327	317	/* ROM definition */
328	318	ROM_START( pencil2 )
329	319	ROM_REGION(0x10000, "maincpu", 0)
330	320	ROM_LOAD( "mt.u4", 0x0000, 0x2000, CRC(338d7b59) SHA1(2f89985ac06971e00210ff992bf1e30a296d10e7) )
331		ROM_LOAD( "1-or",  0xa000, 0x1000, CRC(1ddedccd) SHA1(5fc0d30b5997224b67bf286725468194359ced5a) )
332		ROM_RELOAD(        0xb000, 0x1000 )
333		ROM_LOAD( "203",   0x8000, 0x2000, CRC(f502175c) SHA1(cb2190e633e98586758008577265a7a2bc088233) )
334		ROM_LOAD( "202",   0xc000, 0x2000, CRC(5171097d) SHA1(171999bc04dc98c74c0722b2866310d193dc0f82) )
335		//  ROM_CART_LOAD("cart", 0x8000, 0x8000, ROM_OPTIONAL)
336	321	ROM_END
337	322
338	323	/* Driver */

trunk/src/mess/drivers/sorcerer.c

r32224	r32225
163	163	ADDRESS_MAP_UNMAP_HIGH
164	164	AM_RANGE(0x0000, 0x07ff) AM_RAMBANK("boot")
165	165	AM_RANGE(0x0800, 0xbfff) AM_RAM
166		AM_RANGE(0xc000, 0xefff) AM_ROM                     /* rom pac and bios */
	166	//AM_RANGE(0xc000, 0xdfff)      // mapped by the cartslot
	167	AM_RANGE(0xe000, 0xefff) AM_ROM                     /* rom pac and bios */
167	168	AM_RANGE(0xf000, 0xf7ff) AM_RAM AM_REGION("maincpu", 0xf000)        /* screen ram */
168	169	AM_RANGE(0xf800, 0xfbff) AM_ROM                     /* char rom */
169	170	AM_RANGE(0xfc00, 0xffff) AM_RAM AM_REGION("maincpu", 0xfc00)        /* programmable chars */
r32224	r32225
175	176	AM_RANGE(0x0800, 0xbbff) AM_RAM
176	177	AM_RANGE(0xbc00, 0xbcff) AM_ROM
177	178	AM_RANGE(0xbe00, 0xbe03) AM_DEVREADWRITE("fdc", micropolis_device, read, write)
178		AM_RANGE(0xc000, 0xefff) AM_ROM                     /* rom pac and bios */
	179	//AM_RANGE(0xc000, 0xdfff)      // mapped by the cartslot
	180	AM_RANGE(0xe000, 0xefff) AM_ROM                     /* rom pac and bios */
179	181	AM_RANGE(0xf000, 0xf7ff) AM_RAM AM_REGION("maincpu", 0xf000)        /* screen ram */
180	182	AM_RANGE(0xf800, 0xfbff) AM_ROM                     /* char rom */
181	183	AM_RANGE(0xfc00, 0xffff) AM_RAM AM_REGION("maincpu", 0xfc00)        /* programmable chars */
r32224	r32225
400	402	MCFG_CPU_PROGRAM_MAP(sorcerer_mem)
401	403	MCFG_CPU_IO_MAP(sorcerer_io)
402	404
403
404	405	/* video hardware */
405	406	MCFG_SCREEN_ADD("screen", RASTER)
406	407	MCFG_SCREEN_REFRESH_RATE(50)
r32224	r32225
449	450	MCFG_CASSETTE_INTERFACE("sorcerer_cass")
450	451
451	452	/* cartridge */
452		MCFG_CARTSLOT_ADD("cart")
453		MCFG_CARTSLOT_EXTENSION_LIST("rom,bin")
454		MCFG_CARTSLOT_INTERFACE("sorcerer_cart")
	453	MCFG_GENERIC_CARTSLOT_ADD("cartslot", GENERIC_ROM8_WIDTH, generic_plain_slot, "sorcerer_cart")
	454	MCFG_GENERIC_EXTENSIONS("bin,rom")
455	455
456	456	/* software lists */
457	457	MCFG_SOFTWARE_LIST_ADD("cart_list","sorcerer_cart")
r32224	r32225
477	477	MACHINE_CONFIG_END
478	478
479	479
480		DRIVER_INIT_MEMBER(sorcerer_state,sorcerer)
	480	DRIVER_INIT_MEMBER(sorcerer_state, sorcerer)
481	481	{
482	482	UINT8 *RAM = memregion("maincpu")->base();
483	483	membank("boot")->configure_entries(0, 2, &RAM[0x0000], 0xe000);
r32224	r32225
493	493	ROM_LOAD("exmo1-1.dat", 0xe000, 0x0800, CRC(ac924f67) SHA1(72fcad6dd1ed5ec0527f967604401284d0e4b6a1) ) /* monitor roms */
494	494	ROM_LOAD("exmo1-2.dat", 0xe800, 0x0800, CRC(ead1d0f6) SHA1(c68bed7344091bca135e427b4793cc7d49ca01be) )
495	495	ROM_LOAD("exchr-1.dat", 0xf800, 0x0400, CRC(4a7e1cdd) SHA1(2bf07a59c506b6e0c01ec721fb7b747b20f5dced) ) /* char rom */
496		ROM_CART_LOAD("cart",   0xc000, 0x2000, ROM_OPTIONAL)
497	496	ROM_END
498	497
499	498	ROM_START(sorcererd)
r32224	r32225
502	501	ROM_LOAD("exmo1-1.dat", 0xe000, 0x0800, CRC(ac924f67) SHA1(72fcad6dd1ed5ec0527f967604401284d0e4b6a1) ) /* monitor roms */
503	502	ROM_LOAD("exmo1-2.dat", 0xe800, 0x0800, CRC(ead1d0f6) SHA1(c68bed7344091bca135e427b4793cc7d49ca01be) )
504	503	ROM_LOAD("exchr-1.dat", 0xf800, 0x0400, CRC(4a7e1cdd) SHA1(2bf07a59c506b6e0c01ec721fb7b747b20f5dced) ) /* char rom */
505		ROM_CART_LOAD("cart",   0xc000, 0x2000, ROM_OPTIONAL)
506	504
507	505	ROM_REGION( 0x200, "proms", 0 )
508	506	ROM_LOAD_OPTIONAL("bruce.dat",  0x0000, 0x0020, CRC(fae922cb) SHA1(470a86844cfeab0d9282242e03ff1d8a1b2238d1) ) /* video prom */

trunk/src/mess/drivers/ti74.c

r32224	r32225
73	73	#include "cpu/tms7000/tms7000.h"
74	74	#include "video/hd44780.h"
75	75	#include "machine/nvram.h"
76		#include "imagedev/cartslot.h"
	76	#include "bus/generic/slot.h"
	77	#include "bus/generic/carts.h"
77	78
78	79	#include "ti74.lh"
79	80	#include "ti95.lh"
r32224	r32225
85	86	ti74_state(const machine_config &mconfig, device_type type, const char *tag)
86	87	: driver_device(mconfig, type, tag),
87	88	m_maincpu(*this, "maincpu"),
	89	m_cart(*this, "cartslot"),
88	90	m_battery_inp(*this, "BATTERY")
89	91	{ }
90	92
91	93	required_device<tms70c46_device> m_maincpu;
	94	required_device<generic_slot_device> m_cart;
92	95	required_ioport m_battery_inp;
93	96
94	97	ioport_port *m_key_matrix[8];
r32224	r32225
120	123
121	124	DEVICE_IMAGE_LOAD_MEMBER(ti74_state, ti74_cartridge)
122	125	{
123		UINT8* pos = memregion("user1")->base();
124		offs_t size;
	126	UINT32 size = m_cart->common_get_size("rom");
125	127
126		if (image.software_entry() == NULL)
127		size = image.length();
128		else
129		size = image.get_software_region_length("rom");
130
131	128	// max size is 32KB
132	129	if (size > 0x8000)
133	130	{
134	131	image.seterror(IMAGE_ERROR_UNSPECIFIED, "Invalid file size");
135	132	return IMAGE_INIT_FAIL;
136	133	}
137
138		if (image.software_entry() == NULL)
139		{
140		if (image.fread(pos, size) != size)
141		{
142		image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read file");
143		return IMAGE_INIT_FAIL;
144		}
145		}
146		else
147		memcpy(pos, image.get_software_region("rom"), size);
148
	134
	135	m_cart->rom_alloc(size, 1);
	136	m_cart->common_load_rom(m_cart->get_rom_base(), size, "rom");
	137
149	138	return IMAGE_INIT_PASS;
150	139	}
151	140
r32224	r32225
276	265	ADDRESS_MAP_UNMAP_HIGH
277	266	AM_RANGE(0x1000, 0x1001) AM_DEVREADWRITE("hd44780", hd44780_device, read, write)
278	267	AM_RANGE(0x2000, 0x3fff) AM_RAM AM_SHARE("sysram.ic3")
279		AM_RANGE(0x4000, 0xbfff) AM_ROM AM_REGION("user1", 0)
	268	//AM_RANGE(0x4000, 0xbfff)      // mapped by the cartslot
280	269	AM_RANGE(0xc000, 0xdfff) AM_ROMBANK("sysbank")
281	270	ADDRESS_MAP_END
282	271
r32224	r32225
507	496	for (int i = 0; i < 8; i++)
508	497	m_key_matrix[i] = ioport(tags[i]);
509	498
	499	if (m_cart->cart_mounted())
	500	m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
	501
510	502	membank("sysbank")->configure_entries(0, 4, memregion("system")->base(), 0x2000);
511	503	membank("sysbank")->set_entry(0);
512	504
r32224	r32225
546	538	MCFG_HD44780_PIXEL_UPDATE_CB(ti74_pixel_update)
547	539
548	540	/* cartridge */
549		MCFG_CARTSLOT_ADD("cart")
550		MCFG_CARTSLOT_EXTENSION_LIST("bin,rom,256")
551		MCFG_CARTSLOT_NOT_MANDATORY
552		MCFG_CARTSLOT_LOAD(ti74_state, ti74_cartridge)
553		MCFG_CARTSLOT_INTERFACE("ti74_cart")
	541	MCFG_GENERIC_CARTSLOT_ADD("cartslot", GENERIC_ROM8_WIDTH, generic_plain_slot, "ti74_cart")
	542	MCFG_GENERIC_EXTENSIONS("bin,rom,256")
	543	MCFG_GENERIC_LOAD(ti74_state, ti74_cartridge)
	544
554	545	MCFG_SOFTWARE_LIST_ADD("cart_list", "ti74_cart")
555	546	MACHINE_CONFIG_END
556	547
r32224	r32225
581	572	MCFG_HD44780_PIXEL_UPDATE_CB(ti95_pixel_update)
582	573
583	574	/* cartridge */
584		MCFG_CARTSLOT_ADD("cart")
585		MCFG_CARTSLOT_EXTENSION_LIST("bin,rom,256")
586		MCFG_CARTSLOT_NOT_MANDATORY
587		MCFG_CARTSLOT_LOAD(ti74_state, ti74_cartridge)
588		MCFG_CARTSLOT_INTERFACE("ti95_cart")
	575	MCFG_GENERIC_CARTSLOT_ADD("cartslot", GENERIC_ROM8_WIDTH, generic_plain_slot, "ti95_cart")
	576	MCFG_GENERIC_EXTENSIONS("bin,rom,256")
	577	MCFG_GENERIC_LOAD(ti74_state, ti74_cartridge)
	578
589	579	//MCFG_SOFTWARE_LIST_ADD("cart_list", "ti95_cart")
590	580	MACHINE_CONFIG_END
591	581
r32224	r32225
603	593
604	594	ROM_REGION( 0x8000, "system", 0 )
605	595	ROM_LOAD( "hn61256pc93.ic1", 0x0000, 0x8000, CRC(019aaa2f) SHA1(04a1e694a49d50602e45a7834846de4d9f7d587d) ) // system rom, banked
606
607		ROM_REGION( 0x8000, "user1", ROMREGION_ERASEFF ) // cartridge area
608	596	ROM_END
609	597
610	598
r32224	r32225
614	602
615	603	ROM_REGION( 0x8000, "system", 0 )
616	604	ROM_LOAD( "hn61256pc95.ic1", 0x0000, 0x8000, CRC(c46d29ae) SHA1(c653f08590dbc28241a9f5a6c2541641bdb0208b) ) // system rom, banked
617
618		ROM_REGION( 0x8000, "user1", ROMREGION_ERASEFF ) // cartridge area
619	605	ROM_END
620	606
621	607

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team