Previous

15994 Revisions

Next

r15537 Thursday 5th July, 2012 at 13:20:31 UTC by Antoine Mine
[THOMSON] Performance improvements and bug-fixes: more efficient bank switching, fixed video update (Mach 3, Sparce Racer, HCL), fixed game PIA port B, fixed side-effect in debugger, fixed MO6 cassette. [Fabrice Bellet]

[src/mess/drivers]	thomson.c
[src/mess/machine]	thomson.c
[src/mess/tools/castool]	main.c
[src/mess/video]	thomson.c

src/mess/tools/castool/main.c

r15536	r15537
39	39	#include "formats/rk_cas.h"
40	40	#include "formats/sord_cas.h"
41	41	#include "formats/svi_cas.h"
	42	#include "formats/thom_cas.h"
42	43	#include "formats/trs_cas.h"
43	44	#include "formats/tvc_cas.h"
44	45	#include "formats/tzx_cas.h"
r15536	r15537
86	87	{"rkp", rkp_cassette_formats               ,"Partner"},
87	88	{"sordm5", sordm5_cassette_formats         ,"Sord M5"},
88	89	{"svi", svi_cassette_formats               ,"SVI"},
	90	{"to7", to7_cassette_formats               ,"Thomson TO"},
	91	{"mo5", mo5_cassette_formats               ,"Thomson MO"},
89	92	{"trs80l2", trs80l2_cassette_formats       ,"TRS-80 Level 2"},
90	93	{"tvc64", tvc64_cassette_formats           ,"Videoton TVC 64"},
91	94	{"tzx", tzx_cassette_formats               ,"ZX Spectrum"},

src/mess/machine/thomson.c

r15536	r15537
37	37	/* It must be set accordingly in formats/thom_cas.c */
38	38	#define K7_SPEED_HACK 0
39	39
40		/* bank logging */
	40	/* bank logging and optimisations */
41	41	static int old_cart_bank;
	42	static int old_cart_bank_was_read_only;
42	43	static int old_ram_bank;
43	44	static int old_floppy_bank;
44	45
r15536	r15537
451	452	if ( thom_cart_nb_banks )
452	453	{
453	454	bank = thom_cart_bank % thom_cart_nb_banks;
454		space->install_legacy_read_handler(0x0000, 0x0003, FUNC(to7_cartridge_r) );
	455	if ( bank != old_cart_bank && old_cart_bank < 0 )
	456	{
	457	space->install_legacy_read_handler(0x0000, 0x0003, FUNC(to7_cartridge_r) );
	458	}
455	459	}
456
457		if ( bank != old_cart_bank )
	460	if ( bank != old_cart_bank )
	461	{
	462	machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
	463	old_cart_bank = bank;
458	464	LOG_BANK(( "to7_update_cart_bank: CART is cartridge bank %i\n", bank ));
459
460		machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
461		old_cart_bank = bank;
	465	}
462	466	}
463	467
464	468
r15536	r15537
487	491	{
488	492	UINT8* pos = space->machine().root_device().memregion( "maincpu" )->base() + 0x10000;
489	493	UINT8 data = pos[offset + (thom_cart_bank % thom_cart_nb_banks) * 0x4000];
490		thom_cart_bank = offset & 3;
491		to7_update_cart_bank(space->machine());
	494	if ( !space->debugger_access() )
	495	{
	496	thom_cart_bank = offset & 3;
	497	to7_update_cart_bank(space->machine());
	498	}
492	499	return data;
493	500	}
494	501
r15536	r15537
932	939
933	940	READ8_HANDLER ( to7_modem_mea8000_r )
934	941	{
	942	if ( space->debugger_access() )
	943	{
	944	return 0;
	945	}
	946
935	947	if ( space->machine().root_device().ioport("mconfig")->read() & 1 )
936	948	{
937	949	device_t* device = space->machine().device("mea8000" );
r15536	r15537
1281	1293
1282	1294	case 1: /* get input data */
1283	1295	{
1284		UINT8 data = chardev_in( to7_midi_chardev );
1285		to7_midi_status &= ~(ACIA_6850_irq | ACIA_6850_RDRF);
1286		if ( to7_midi_overrun )
1287		to7_midi_status |= ACIA_6850_OVRN;
1288		else
1289		to7_midi_status &= ~ACIA_6850_OVRN;
1290		to7_midi_overrun = 0;
1291		LOG_MIDI(( "$%04x %f to7_midi_r: read data $%02X\n",
1292		cpu_get_previouspc(space->machine().device("maincpu")), space->machine().time().as_double(), data ));
1293		to7_midi_update_irq( space->machine );
1294		return data;
	1296	UINT8 data = chardev_in( to7_midi_chardev );
	1297	if ( !space->debugger_access() )
	1298	{
	1299	to7_midi_status &= ~(ACIA_6850_irq | ACIA_6850_RDRF);
	1300	if ( to7_midi_overrun )
	1301	to7_midi_status |= ACIA_6850_OVRN;
	1302	else
	1303	to7_midi_status &= ~ACIA_6850_OVRN;
	1304	to7_midi_overrun = 0;
	1305	LOG_MIDI(( "$%04x %f to7_midi_r: read data $%02X\n",
	1306	cpu_get_previouspc(space->machine().device("maincpu")), space->machine().time().as_double(), data ));
	1307	to7_midi_update_irq( space->machine() );
	1308	}
	1309	return data;
1295	1310	}
1296	1311
1297	1312
r15536	r15537
1342	1357	(to7_midi_intr & 3) ? 1 : 0));
1343	1358	}
1344	1359	}
1345		to7_midi_update_irq( space->machine );
	1360	to7_midi_update_irq( space->machine() );
1346	1361	break;
1347	1362
1348	1363
r15536	r15537
1389	1404	static void to7_midi_init( running_machine &machine )
1390	1405	{
1391	1406	LOG (( "to7_midi_init\n" ));
1392		to7_midi_chardev = chardev_open( machine, "/dev/snd/midiC1D0", "/dev/snd/midiC1D1", &to7_midi_interface );
	1407	to7_midi_chardev = chardev_open( &machine, "/dev/snd/midiC0D0", "/dev/snd/midiC0D1", &to7_midi_interface );
1393	1408	state_save_register_global( machine, to7_midi_status );
1394	1409	state_save_register_global( machine, to7_midi_overrun );
1395	1410	state_save_register_global( machine, to7_midi_intr );
r15536	r15537
1577	1592	return;
1578	1593	}
1579	1594
1580		if ( bank != old_ram_bank )
	1595	if ( bank != old_ram_bank )
	1596	{
	1597	if ( machine.device<ram_device>(RAM_TAG)->size() == 128*1024 || bank < 2 )
	1598	{
	1599	machine.root_device().membank( THOM_RAM_BANK )->set_entry( bank );
	1600	}
	1601	else
	1602	{
	1603	/* RAM size is 48 KB only and unavailable bank
	1604	* requested */
	1605	space->nop_readwrite(0xa000, 0xdfff);
	1606	}
	1607	old_ram_bank = bank;
1581	1608	LOG_BANK(( "to770_update_ram_bank: RAM bank change %i\n", bank ));
1582
1583		if ( machine.device<ram_device>(RAM_TAG)->size() == 128*1024 || bank < 2 )
1584		{
1585		machine.root_device().membank( THOM_RAM_BANK )->set_entry( bank );
1586		space->install_write_bank(0xa000, 0xdfff, THOM_RAM_BANK);
1587	1609	}
1588		else
1589		{
1590		space->unmap_write(0xa000, 0xdfff);
1591		}
1592
1593		old_ram_bank = bank;
1594	1610	}
1595	1611
1596	1612
r15536	r15537
1979	1995	address_space* space = machine.device("maincpu")->memory().space(AS_PROGRAM);
1980	1996	int rom_is_ram = mo5_reg_cart & 4;
1981	1997	int bank = 0;
	1998	int bank_is_read_only = 0;
1982	1999
1983		space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
1984	2000
1985	2001	if ( rom_is_ram && thom_cart_nb_banks == 4 )
1986	2002	{
1987	2003	/* 64 KB ROM from "JANE" cartridge */
1988		space->nop_write( 0xb000, 0xefff);
1989	2004	bank = mo5_reg_cart & 3;
1990		if ( bank != old_cart_bank )
	2005	if ( bank != old_cart_bank )
	2006	{
	2007	if ( old_cart_bank < 0 || old_cart_bank > 3 )
	2008	{
	2009	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	2010	space->nop_write( 0xb000, 0xefff);
	2011	}
1991	2012	LOG_BANK(( "mo5_update_cart_bank: CART is cartridge bank %i (A7CB style)\n", bank ));
	2013	}
1992	2014	}
1993	2015	else if ( rom_is_ram )
1994	2016	{
1995	2017	/* 64 KB RAM from network extension */
1996		int write_enable = mo5_reg_cart & 8;
1997	2018	bank = 4 + ( mo5_reg_cart & 3 );
1998		if (write_enable) {
1999		space->install_write_bank( 0xb000, 0xefff, THOM_CART_BANK);
2000		} else {
2001		space->nop_write( 0xb000, 0xefff);
2002		}
2003		if ( bank != old_cart_bank )
2004		LOG_BANK(( "mo5_update_cart_bank: CART is nanonetwork RAM bank %i (write-enable=%i)\n", mo5_reg_cart & 3, write_enable ? 1 : 0 ));
	2019	bank_is_read_only = (( mo5_reg_cart & 8 ) == 0);
	2020
	2021	if ( bank != old_cart_bank || bank_is_read_only != old_cart_bank_was_read_only)
	2022	{
	2023	if ( bank_is_read_only )
	2024	{
	2025	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	2026	space->nop_write( 0xb000, 0xefff );
	2027	}
	2028	else
	2029	{
	2030	space->install_readwrite_bank( 0xb000, 0xefff, THOM_CART_BANK);
	2031	}
	2032	LOG_BANK(( "mo5_update_cart_bank: CART is nanonetwork RAM bank %i (%s)\n",
	2033	mo5_reg_cart & 3,
	2034	bank_is_read_only ? "read-only":"read-write"));
	2035	old_cart_bank_was_read_only = bank_is_read_only;
	2036	}
2005	2037	}
2006	2038	else
2007	2039	{
2008	2040	/* regular cartridge bank switch */
2009		space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(mo5_cartridge_w) );
2010	2041	if ( thom_cart_nb_banks )
2011	2042	{
2012	2043	bank = thom_cart_bank % thom_cart_nb_banks;
2013		space->install_legacy_read_handler( 0xbffc, 0xbfff, FUNC(mo5_cartridge_r) );
2014		}
2015		if ( bank != old_cart_bank )
2016		LOG_BANK(( "mo5_update_cart_bank: CART is internal / cartridge bank %i\n", thom_cart_bank ));
	2044	if ( bank != old_cart_bank )
	2045	{
	2046	if ( old_cart_bank < 0 )
	2047	{
	2048	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	2049	space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(mo5_cartridge_w) );
	2050	space->install_legacy_read_handler( 0xbffc, 0xbfff, FUNC(mo5_cartridge_r) );
	2051	}
	2052	LOG_BANK(( "mo5_update_cart_bank: CART is cartridge bank %i\n", bank ));
	2053	}
	2054	} else
	2055	/* internal ROM */
	2056	if ( old_cart_bank != 0 )
	2057	{
	2058	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	2059	space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(mo5_cartridge_w) );
	2060	LOG_BANK(( "mo5_update_cart_bank: CART is internal\n"));
	2061	}
2017	2062	}
2018		machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
2019		old_cart_bank = bank;
	2063	if ( bank != old_cart_bank )
	2064	{
	2065	machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
	2066	old_cart_bank = bank;
	2067	}
2020	2068	}
2021	2069
2022	2070
r15536	r15537
2045	2093	{
2046	2094	UINT8* pos = space->machine().root_device().memregion( "maincpu" )->base() + 0x10000;
2047	2095	UINT8 data = pos[offset + 0xbffc + (thom_cart_bank % thom_cart_nb_banks) * 0x4000];
2048		thom_cart_bank = offset & 3;
2049		mo5_update_cart_bank(space->machine());
	2096	if ( !space->debugger_access() )
	2097	{
	2098	thom_cart_bank = offset & 3;
	2099	mo5_update_cart_bank(space->machine());
	2100	}
2050	2101	return data;
2051	2102	}
2052	2103
r15536	r15537
2264	2315	case 0: /* palette data */
2265	2316	{
2266	2317	UINT8 c =  to9_palette_data[ to9_palette_idx ];
2267		to9_palette_idx = ( to9_palette_idx + 1 ) & 31;
	2318	if ( !space->debugger_access() )
	2319	{
	2320	to9_palette_idx = ( to9_palette_idx + 1 ) & 31;
	2321	}
2268	2322	return c;
2269	2323	}
2270	2324
r15536	r15537
2344	2398	int bank = 0;
2345	2399	int slot = ( mc6846_get_output_port(machine.device("mc6846")) >> 4 ) & 3; /* bits 4-5: ROM bank */
2346	2400
2347		/* reset cartridge read handler */
2348		space->install_read_bank( 0x0000, 0x0003, THOM_CART_BANK );
2349
2350	2401	switch ( slot )
2351	2402	{
2352	2403	case 0:
2353	2404	/* BASIC (64 KB) */
2354	2405	bank = 4 + to9_soft_bank;
2355	2406	if ( bank != old_cart_bank )
	2407	{
	2408	if ( old_cart_bank < 4)
	2409	{
	2410	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	2411	}
2356	2412	LOG_BANK(( "to9_update_cart_bank: CART is BASIC bank %i\n", to9_soft_bank ));
	2413	}
2357	2414	break;
2358	2415	case 1:
2359	2416	/* software 1 (32 KB) */
2360	2417	bank = 8 + (to9_soft_bank & 1);
2361		if ( bank != old_cart_bank )
	2418	if ( bank != old_cart_bank )
	2419	{
	2420	if ( old_cart_bank < 4)
	2421	{
	2422	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	2423	}
2362	2424	LOG_BANK(( "to9_update_cart_bank: CART is software 1 bank %i\n", to9_soft_bank ));
	2425	}
2363	2426	break;
2364	2427	case 2:
2365	2428	/* software 2 (32 KB) */
2366	2429	bank = 10 + (to9_soft_bank & 1);
2367		if ( bank != old_cart_bank )
	2430	if ( bank != old_cart_bank )
	2431	{
	2432	if ( old_cart_bank < 4)
	2433	{
	2434	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	2435	}
2368	2436	LOG_BANK(( "to9_update_cart_bank: CART is software 2 bank %i\n", to9_soft_bank ));
	2437	}
2369	2438	break;
2370	2439	case 3:
2371	2440	/* external cartridge */
2372	2441	if ( thom_cart_nb_banks )
2373	2442	{
2374	2443	bank = thom_cart_bank % thom_cart_nb_banks;
2375		space->install_legacy_read_handler( 0x0000, 0x0003, FUNC(to7_cartridge_r) );
2376		}
2377		if ( bank != old_cart_bank )
2378		LOG_BANK(( "to9_update_cart_bank: CART is cartridge bank %i\n",  thom_cart_bank ));
	2444	if ( bank != old_cart_bank )
	2445	{
	2446	if ( old_cart_bank < 0 || old_cart_bank > 3 )
	2447	{
	2448	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	2449	space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to9_cartridge_w) );
	2450	space->install_legacy_read_handler( 0x0000, 0x0003, FUNC(to9_cartridge_r) );
	2451	}
	2452	LOG_BANK(( "to9_update_cart_bank: CART is cartridge bank %i\n",  thom_cart_bank ));
	2453	}
	2454	} else
	2455	if ( old_cart_bank != 0 )
	2456	{
	2457	space->nop_read( 0x0000, 0x3fff);
	2458	LOG_BANK(( "to9_update_cart_bank: CART is unmapped\n"));
	2459	}
2379	2460	break;
2380	2461	}
2381
2382		machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
2383		old_cart_bank = bank;
	2462	if ( bank != old_cart_bank )
	2463	{
	2464	machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
	2465	old_cart_bank = bank;
	2466	}
2384	2467	}
2385	2468
2386	2469
r15536	r15537
2414	2497	{
2415	2498	UINT8* pos = space->machine().root_device().memregion( "maincpu" )->base() + 0x10000;
2416	2499	UINT8 data = pos[offset + (thom_cart_bank % thom_cart_nb_banks) * 0x4000];
2417		thom_cart_bank = offset & 3;
2418		to9_update_cart_bank(space->machine());
	2500	if ( !space->debugger_access() )
	2501	{
	2502	thom_cart_bank = offset & 3;
	2503	to9_update_cart_bank(space->machine());
	2504	}
2419	2505	return data;
2420	2506	}
2421	2507
r15536	r15537
2451	2537	return;
2452	2538	}
2453	2539
2454		if ( old_ram_bank != bank )
	2540	if ( old_ram_bank != bank )
	2541	{
	2542	if ( machine.device<ram_device>(RAM_TAG)->size() == 192*1024 || bank < 6 )
	2543	{
	2544	machine.root_device().membank( THOM_RAM_BANK )->set_entry( bank );
	2545	}
	2546	else
	2547	{
	2548	space->nop_readwrite( 0xa000, 0xdfff);
	2549	}
	2550	old_ram_bank = bank;
2455	2551	LOG_BANK(( "to9_update_ram_bank: bank %i selected (pia=$%02X disk=%i)\n", bank, portb & 0xf8, disk ));
2456
2457		if ( machine.device<ram_device>(RAM_TAG)->size() == 192*1024 || bank < 6 )
2458		{
2459		machine.root_device().membank( THOM_RAM_BANK )->set_entry( bank );
2460		space->install_write_bank( 0xa000, 0xdfff, THOM_RAM_BANK);
2461	2552	}
2462		else
2463		{
2464		space->nop_write( 0xa000, 0xdfff);
2465		}
2466
2467		old_ram_bank = bank;
2468	2553	}
2469	2554
2470	2555
r15536	r15537
2592	2677	return to9_kbd_status;
2593	2678
2594	2679	case 1: /* get input data */
2595		to9_kbd_status &= ~(ACIA_6850_irq | ACIA_6850_PE);
2596		if ( to9_kbd_overrun )
2597		to9_kbd_status |= ACIA_6850_OVRN;
2598		else
2599		to9_kbd_status &= ~(ACIA_6850_OVRN | ACIA_6850_RDRF);
2600		to9_kbd_overrun = 0;
2601		LOG_KBD(( "$%04x %f to9_kbd_r: read data $%02X\n", cpu_get_previouspc(space->machine().device("maincpu")), space->machine().time().as_double(), to9_kbd_in ));
2602		to9_kbd_update_irq(space->machine());
	2680	if ( !space->debugger_access() )
	2681	{
	2682	to9_kbd_status &= ~(ACIA_6850_irq | ACIA_6850_PE);
	2683	if ( to9_kbd_overrun )
	2684	to9_kbd_status |= ACIA_6850_OVRN;
	2685	else
	2686	to9_kbd_status &= ~(ACIA_6850_OVRN | ACIA_6850_RDRF);
	2687	to9_kbd_overrun = 0;
	2688	LOG_KBD(( "$%04x %f to9_kbd_r: read data $%02X\n", cpu_get_previouspc(space->machine().device("maincpu")), space->machine().time().as_double(), to9_kbd_in ));
	2689	to9_kbd_update_irq(space->machine());
	2690	}
2603	2691	return to9_kbd_in;
2604	2692
2605	2693	default:
r15536	r15537
3464	3552	int bank = (to8_reg_sys1 & 0x80) ? to7_floppy_bank : (to8_bios_bank + TO7_NB_FLOP_BANK);
3465	3553
3466	3554	if ( bank != old_floppy_bank )
	3555	{
3467	3556	LOG_BANK(( "to8_update_floppy_bank: floppy ROM is %s bank %i\n",
3468		(to8_reg_sys1 & 0x80) ? "external" : "internal",
3469		bank % TO7_NB_FLOP_BANK ));
3470		machine.root_device().membank( THOM_FLOP_BANK )->set_entry( bank );
3471		old_floppy_bank = bank;
	3557	(to8_reg_sys1 & 0x80) ? "external" : "internal",
	3558	bank % TO7_NB_FLOP_BANK ));
	3559	machine.root_device().membank( THOM_FLOP_BANK )->set_entry( bank );
	3560	old_floppy_bank = bank;
	3561	}
3472	3562	}
3473	3563
3474	3564
r15536	r15537
3489	3579	if ( to8_reg_sys1 & 0x10 )
3490	3580	{
3491	3581	bank = to8_reg_ram & 31;
3492		if ( bank != to8_data_vpage )
3493		LOG_BANK(( "to8_update_ram_bank: select bank %i (new style)\n", bank ));
3494	3582	}
3495	3583	else
3496	3584	{
r15536	r15537
3510	3598	logerror( "to8_update_ram_bank: unknown RAM bank=$%02X\n", portb & 0xf8 );
3511	3599	return;
3512	3600	}
3513		if ( bank != to8_data_vpage )
3514		LOG_BANK(( "to8_update_ram_bank: select bank %i (old style)\n", bank  ));
3515	3601	}
3516	3602
3517	3603	/*  due to addressing distortion, the 16 KB banked memory space is
r15536	r15537
3521	3607	this is important if we map a bank that is also reachable by another,
3522	3608	undistorted space, such as cartridge, page 0 (video), or page 1
3523	3609	*/
3524		to8_data_vpage = bank;
3525		if ( machine.device<ram_device>(RAM_TAG)->size() == 512*1024 || to8_data_vpage < 16 )
3526		{
3527		machine.root_device().membank( TO8_DATA_LO )->set_entry( to8_data_vpage );
3528		machine.root_device().membank( TO8_DATA_HI )->set_entry( to8_data_vpage );
3529
3530		if (to8_data_vpage <= 4) {
3531		space->install_legacy_write_handler( 0xa000, 0xbfff, FUNC(to8_data_lo_w));
3532		space->install_legacy_write_handler( 0xc000, 0xdfff, FUNC(to8_data_hi_w));
3533		} else {
3534		space->install_write_bank( 0xa000, 0xbfff, TO8_DATA_LO);
3535		space->install_write_bank( 0xc000, 0xdfff, TO8_DATA_HI);
	3610	if ( bank != old_ram_bank)
	3611	{
	3612	if (machine.device<ram_device>(RAM_TAG)->size() == 512*1024 || to8_data_vpage < 16)
	3613	{
	3614	machine.root_device().membank( TO8_DATA_LO )->set_entry( bank );
	3615	machine.root_device().membank( TO8_DATA_HI )->set_entry( bank );
	3616	} else
	3617	{
	3618	/* RAM size is 256 KB only and unavailable
	3619	* bank requested */
	3620	space->nop_readwrite( 0xa000, 0xbfff);
	3621	space->nop_readwrite( 0xc000, 0xdfff);
3536	3622	}
	3623	to8_data_vpage = bank;
	3624	old_ram_bank = bank;
	3625	LOG_BANK(( "to8_update_ram_bank: select bank %i (%s style)\n", bank, (to8_reg_sys1 & 0x10) ? "new" : "old"));
3537	3626	}
3538		else
3539		{
3540		space->nop_write( 0xa000, 0xbfff);
3541		space->nop_write( 0xc000, 0xdfff);
3542		}
3543	3627	}
3544	3628
3545	3629
r15536	r15537
3555	3639	{
3556	3640	address_space* space = machine.device("maincpu")->memory().space(AS_PROGRAM);
3557	3641	int bank = 0;
	3642	int bank_is_read_only = 0;
3558	3643
3559		/* reset bank switch */
3560		space->install_read_bank( 0x0000, 0x0003, THOM_CART_BANK );
3561
3562	3644	if ( to8_reg_cart & 0x20 )
3563	3645	{
3564	3646	/* RAM space */
3565	3647	to8_cart_vpage = to8_reg_cart & 31;
3566	3648	bank = 8 + to8_cart_vpage;
3567		if ((to8_cart_vpage < 8 || machine.device<ram_device>(RAM_TAG)->size() == 512*1024) && (to8_reg_cart & 0x40)) {
3568		if (to8_cart_vpage <= 4) {
3569		space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to8_vcart_w));
3570		} else {
3571		space->install_write_bank( 0x0000, 0x3fff,THOM_CART_BANK);
3572		}
3573		} else {
3574		space->nop_write( 0x0000, 0x3fff);
	3649	bank_is_read_only = (( to8_reg_cart & 0x40 ) == 0);
	3650	if ( bank != old_cart_bank )
	3651	{
	3652	/* mapping to VRAM */
	3653	if (machine.device<ram_device>(RAM_TAG)->size() == 512*1024 || to8_cart_vpage < 16)
	3654	{
	3655	if (to8_cart_vpage < 4)
	3656	{
	3657	if (old_cart_bank < 8 || old_cart_bank > 11)
	3658	{
	3659	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	3660	if ( bank_is_read_only )
	3661	{
	3662	space->nop_write( 0x0000, 0x3fff);
	3663	}
	3664	else
	3665	{
	3666	space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to8_vcart_w));
	3667	}
	3668	}
	3669	}
	3670	else
	3671	{
	3672	if (old_cart_bank < 12)
	3673	{
	3674	if ( bank_is_read_only )
	3675	{
	3676	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	3677	space->nop_write( 0x0000, 0x3fff);
	3678	}
	3679	else
	3680	{
	3681	space->install_readwrite_bank( 0x0000, 0x3fff,THOM_CART_BANK);
	3682	}
	3683	}
	3684	}
	3685	}
	3686	else
	3687	{
	3688	/* RAM size is 256 KB only and unavailable
	3689	* bank requested */
	3690	space->nop_readwrite( 0x0000, 0x3fff);
	3691	}
	3692	LOG_BANK(( "to8_update_cart_bank: CART is RAM bank %i (%s)\n",
	3693	to8_cart_vpage,
	3694	bank_is_read_only ? "read-only":"read-write"));
3575	3695	}
3576		if ( bank != old_cart_bank )
3577		LOG_BANK(( "to8_update_cart_bank: CART is RAM bank %i (write-enable=%i)\n", to8_cart_vpage, (to8_reg_cart & 0x40) ? 1 : 0 ));
	3696	else
	3697	{
	3698	if ( bank_is_read_only != old_cart_bank_was_read_only )
	3699	{
	3700	if ( bank_is_read_only )
	3701	{
	3702	space->nop_write( 0x0000, 0x3fff);
	3703	}
	3704	else
	3705	{
	3706	if (to8_cart_vpage < 4)
	3707	{
	3708	space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to8_vcart_w));
	3709	}
	3710	else
	3711	{
	3712	space->install_readwrite_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	3713	}
	3714	}
	3715	LOG_BANK(( "to8_update_cart_bank: update CART bank %i write status to %s\n",
	3716	to8_cart_vpage,
	3717	bank_is_read_only ? "read-only":"read-write"));
	3718	}
	3719	}
	3720	old_cart_bank_was_read_only = bank_is_read_only;
3578	3721	}
3579	3722	else
3580	3723	{
3581		space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to8_cartridge_w) );
3582	3724	if ( to8_soft_select )
3583	3725	{
3584	3726	/* internal software ROM space */
3585	3727	bank = 4 + to8_soft_bank;
3586		if ( bank != old_cart_bank )
3587		LOG_BANK(( "to8_update_cart_bank: CART is internal bank %i\n",
3588		to8_soft_bank ));
	3728	if ( bank != old_cart_bank )
	3729	{
	3730	if ( old_cart_bank < 4 || old_cart_bank > 7 )
	3731	{
	3732	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	3733	space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to8_cartridge_w) );
	3734	}
	3735	LOG_BANK(( "to8_update_cart_bank: CART is internal bank %i\n", to8_soft_bank ));
	3736	}
3589	3737	}
3590	3738	else
3591	3739	{
r15536	r15537
3593	3741	if ( thom_cart_nb_banks )
3594	3742	{
3595	3743	bank = thom_cart_bank % thom_cart_nb_banks;
3596		space->install_legacy_read_handler( 0x0000, 0x0003, FUNC(to8_cartridge_r) );
3597
3598		}
3599
3600		if ( bank != old_cart_bank )
3601		LOG_BANK(( "to8_update_cart_bank: CART is external cartridge bank %i\n", thom_cart_bank ));
3602		}
3603		}
3604
3605		if ( machine.device<ram_device>(RAM_TAG)->size() == 512*1024 || bank < 16 )
3606		{
	3744	if ( bank != old_cart_bank )
	3745	{
	3746	if ( old_cart_bank < 0 || old_cart_bank > 3 )
	3747	{
	3748	space->install_read_bank( 0x0000, 0x3fff, THOM_CART_BANK );
	3749	space->install_legacy_write_handler( 0x0000, 0x3fff, FUNC(to8_cartridge_w) );
	3750	space->install_legacy_read_handler( 0x0000, 0x0003, FUNC(to8_cartridge_r) );
	3751	}
	3752	LOG_BANK(( "to8_update_cart_bank: CART is external cartridge bank %i\n", bank ));
	3753	}
	3754	}
	3755	else
	3756	{
	3757	if ( old_cart_bank != 0 )
	3758	{
	3759	space->nop_read( 0x0000, 0x3fff);
	3760	LOG_BANK(( "to8_update_cart_bank: CART is unmapped\n"));
	3761	}
	3762	}
	3763	}
	3764	}
	3765	if ( bank != old_cart_bank )
	3766	{
3607	3767	machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
	3768	old_cart_bank = bank;
3608	3769	}
3609
3610		old_cart_bank = bank;
3611	3770	}
3612	3771
3613	3772
r15536	r15537
3640	3799	{
3641	3800	UINT8* pos = space->machine().root_device().memregion( "maincpu" )->base() + 0x10000;
3642	3801	UINT8 data = pos[offset + (thom_cart_bank % thom_cart_nb_banks) * 0x4000];
3643		thom_cart_bank = offset & 3;
3644		to8_update_cart_bank(space->machine());
	3802	if ( !space->debugger_access() )
	3803	{
	3804	thom_cart_bank = offset & 3;
	3805	to8_update_cart_bank(space->machine());
	3806	}
3645	3807	return data;
3646	3808	}
3647	3809
r15536	r15537
3671	3833
3672	3834	READ8_HANDLER ( to8_floppy_r )
3673	3835	{
	3836	if ( space->debugger_access() )
	3837	return 0;
	3838
3674	3839	if ( (to8_reg_sys1 & 0x80) && THOM_FLOPPY_EXT )
3675	3840	/* external controller */
3676	3841	return to7_floppy_r( space, offset );
r15536	r15537
3728	3893	case 1: /* ram register / lightpen register 2 */
3729	3894	if ( to7_lightpen )
3730	3895	{
3731		thom_firq_2( space->machine(), 0 );
3732		to8_lightpen_intr = 0;
	3896	if ( !space->debugger_access() )
	3897	{
	3898	thom_firq_2( space->machine(), 0 );
	3899	to8_lightpen_intr = 0;
	3900	}
3733	3901	res = count & 0xff;
3734	3902	}
3735	3903	else
r15536	r15537
3811	3979	/* 0xe7dc from external floppy drive aliases the video gate-array */
3812	3980	if ( ( offset == 3 ) && ( to8_reg_ram & 0x80 ) && ( to8_reg_sys1 & 0x80 ) )
3813	3981	{
	3982	if ( space->debugger_access() )
	3983	return 0;
	3984
3814	3985	if ( THOM_FLOPPY_EXT )
3815	3986	return to7_floppy_r( space, 0xc );
3816	3987	else
r15536	r15537
3823	3994	case 0: /* palette data */
3824	3995	{
3825	3996	UINT8 c =  to9_palette_data[ to9_palette_idx ];
3826		to9_palette_idx = ( to9_palette_idx + 1 ) & 31;
	3997	if ( !space->debugger_access() )
	3998	{
	3999	to9_palette_idx = ( to9_palette_idx + 1 ) & 31;
	4000	}
3827	4001	return c;
3828	4002	}
3829	4003
r15536	r15537
4043	4217	/* memory */
4044	4218	old_ram_bank = -1;
4045	4219	old_cart_bank = -1;
	4220	old_cart_bank_was_read_only = 0;
4046	4221	old_floppy_bank = -1;
4047	4222	to8_cart_vpage = 0;
4048	4223	to8_data_vpage = 0;
r15536	r15537
4301	4476	if ( to8_reg_sys1 & 0x10 )
4302	4477	{
4303	4478	bank = to8_reg_ram & 7; /* 128 KB RAM only = 8 pages */
4304		if ( bank != to8_data_vpage )
4305		LOG_BANK(( "mo6_update_ram_bank: select bank %i (new style)\n", bank ));
4306	4479	}
4307		to8_data_vpage = bank;
4308		machine.root_device().membank( TO8_DATA_LO )->set_entry( to8_data_vpage );
4309		machine.root_device().membank( TO8_DATA_HI )->set_entry( to8_data_vpage );
	4480	if ( bank != to8_data_vpage ) {
	4481	machine.root_device().membank( TO8_DATA_LO )->set_entry( bank );
	4482	machine.root_device().membank( TO8_DATA_HI )->set_entry( bank );
	4483	to8_data_vpage = bank;
	4484	old_ram_bank = bank;
	4485	LOG_BANK(( "mo6_update_ram_bank: select bank %i (new style)\n", bank ));
	4486	}
4310	4487	}
4311	4488
4312	4489
r15536	r15537
4324	4501	address_space* space = machine.device("maincpu")->memory().space(AS_PROGRAM);
4325	4502	int b = (sys_pia->a_output() >> 5) & 1;
4326	4503	int bank = 0;
	4504	int bank_is_read_only = 0;
4327	4505
4328		space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK );
	4506	// space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK );
4329	4507
4330	4508	if ( ( ( to8_reg_sys1 & 0x40 ) && ( to8_reg_cart & 0x20 ) ) || ( ! ( to8_reg_sys1 & 0x40 ) && ( mo5_reg_cart & 4 ) ) )
4331	4509	{
r15536	r15537
4335	4513	/* use a7e6 */
4336	4514	to8_cart_vpage = to8_reg_cart & 7; /* 128 KB RAM only = 8 pages */
4337	4515	bank = 8 + to8_cart_vpage;
4338		if (to8_reg_cart & 0x40)  {
4339		if (to8_cart_vpage <= 4) {
4340		space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(to8_vcart_w));
4341		} else {
4342		space->install_write_bank( 0xb000, 0xefff,THOM_CART_BANK);
4343		}
4344		} else {
4345		space->nop_write( 0xb000, 0xefff);
	4516	bank_is_read_only = (( to8_reg_cart & 0x40 ) == 0);
	4517	if ( bank != old_cart_bank )
	4518	{
	4519	if (to8_cart_vpage < 4)
	4520	{
	4521	if (old_cart_bank < 8 || old_cart_bank > 11)
	4522	{
	4523	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK );
	4524	if ( bank_is_read_only )
	4525	{
	4526	space->nop_write( 0xb000, 0xefff);
	4527	}
	4528	else
	4529	{
	4530	space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(to8_vcart_w));
	4531	}
	4532	}
	4533	}
	4534	else
	4535	{
	4536
	4537	if (old_cart_bank < 12)
	4538	{
	4539	if ( bank_is_read_only )
	4540	{
	4541	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK );
	4542	space->nop_write( 0xb000, 0xefff);
	4543	}
	4544	else
	4545	{
	4546	space->install_readwrite_bank( 0xb000, 0xefff,THOM_CART_BANK);
	4547	}
	4548	}
	4549	}
	4550	LOG_BANK(( "mo6_update_cart_bank: CART is RAM bank %i (%s)\n",
	4551	to8_cart_vpage,
	4552	bank_is_read_only ? "read-only":"read-write"));
4346	4553	}
4347		if ( bank != old_cart_bank )
4348		LOG_BANK(( "mo6_update_cart_bank: CART is RAM bank %i (write-enable=%i)\n", to8_cart_vpage, (to8_reg_cart & 0x40) ? 1 : 0 ));
	4554	else if ( bank_is_read_only != old_cart_bank_was_read_only )
	4555	{
	4556	if ( bank_is_read_only )
	4557	{
	4558	space->nop_write( 0xb000, 0xefff);
	4559	}
	4560	else
	4561	{
	4562	if (to8_cart_vpage < 4)
	4563	{
	4564	space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(to8_vcart_w));
	4565	}
	4566	else
	4567	{
	4568	space->install_readwrite_bank( 0xb000, 0xefff, THOM_CART_BANK );
	4569	}
	4570	}
	4571	LOG_BANK(( "mo6_update_cart_bank: update CART bank %i write status to %s\n",
	4572	to8_cart_vpage,
	4573	bank_is_read_only ? "read-only":"read-write"));
	4574	}
	4575	old_cart_bank_was_read_only = bank_is_read_only;
4349	4576	}
4350	4577	else if ( thom_cart_nb_banks == 4 )
4351	4578	{
4352	4579	/* "JANE"-style cartridge bank switching */
4353		space->nop_write( 0xb000, 0xefff);
4354	4580	bank = mo5_reg_cart & 3;
4355	4581	if ( bank != old_cart_bank )
	4582	{
	4583	if ( old_cart_bank < 0 || old_cart_bank > 3 )
	4584	{
	4585	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK );
	4586	space->nop_write( 0xb000, 0xefff);
	4587	}
4356	4588	LOG_BANK(( "mo6_update_cart_bank: CART is external cartridge bank %i (A7CB style)\n", bank ));
	4589	}
4357	4590	}
4358	4591	else
4359	4592	{
4360	4593	/* RAM from MO5 network extension */
4361		int write_enable = mo5_reg_cart & 8;
	4594	int bank_is_read_only = (( mo5_reg_cart & 8 ) == 0);
4362	4595	to8_cart_vpage = (mo5_reg_cart & 3) | 4;
4363	4596	bank = 8 + to8_cart_vpage;
4364		if (write_enable) {
4365		space->install_write_bank( 0xb000, 0xefff, THOM_CART_BANK);
4366		} else {
4367		space->nop_write( 0xb000, 0xefff);
	4597	if ( bank != old_cart_bank )
	4598	{
	4599	if ( old_cart_bank < 12 )
	4600	{
	4601	if ( bank_is_read_only )
	4602	{
	4603	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	4604	space->nop_write( 0xb000, 0xefff);
	4605	} else
	4606	{
	4607	space->install_readwrite_bank( 0xb000, 0xefff, THOM_CART_BANK);
	4608	}
	4609	}
	4610	LOG_BANK(( "mo6_update_cart_bank: CART is RAM bank %i (MO5 compat.) (%s)\n",
	4611	to8_cart_vpage,
	4612	bank_is_read_only ? "read-only":"read-write"));
4368	4613	}
4369		if ( bank != old_cart_bank )
4370		LOG_BANK(( "mo6_update_cart_bank: CART is RAM bank %i (write-enable=%i) (MO5 compat.)\n", to8_cart_vpage, write_enable ? 1 : 0 ));
	4614	else if ( bank_is_read_only != old_cart_bank_was_read_only )
	4615	{
	4616	if ( bank_is_read_only )
	4617	{
	4618	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	4619	space->nop_write( 0xb000, 0xefff);
	4620	}
	4621	else
	4622	{
	4623	space->install_readwrite_bank( 0xb000, 0xefff, THOM_CART_BANK);
	4624	}
	4625	LOG_BANK(( "mo5_update_cart_bank: update CART bank %i write status to %s\n",
	4626	to8_cart_vpage,
	4627	bank_is_read_only ? "read-only":"read-write"));
	4628	}
	4629	old_cart_bank_was_read_only = bank_is_read_only;
4371	4630	}
4372	4631	}
4373	4632	else
4374	4633	{
4375	4634	/* ROM space */
4376		space->nop_write( 0xb000, 0xefff);
4377	4635	if ( to8_reg_sys2 & 0x20 )
4378	4636	{
4379	4637	/* internal ROM */
4380	4638	if ( to8_reg_sys2 & 0x10)
	4639	{
4381	4640	bank = b + 6; /* BASIC 128 */
	4641	}
4382	4642	else
	4643	{
4383	4644	bank = b + 4;                      /* BASIC 1 */
4384		if ( bank != old_cart_bank )
	4645	}
	4646	if ( bank != old_cart_bank )
	4647	{
	4648	if ( old_cart_bank < 4 || old_cart_bank > 7 )
	4649	{
	4650	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK);
	4651	space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(mo6_cartridge_w) );
	4652	}
4385	4653	LOG_BANK(( "mo6_update_cart_bank: CART is internal ROM bank %i\n", b ));
	4654	}
4386	4655	}
4387	4656	else
4388	4657	{
4389	4658	/* cartridge */
4390		space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(mo6_cartridge_w) );
4391	4659	if ( thom_cart_nb_banks )
4392	4660	{
4393	4661	bank = thom_cart_bank % thom_cart_nb_banks;
4394		space->install_legacy_read_handler( 0xbffc, 0xbfff, FUNC(mo6_cartridge_r) );
4395		}
4396		if ( bank != old_cart_bank )
4397		LOG_BANK(( "mo6_update_cart_bank: CART is external cartridge bank %i\n", bank ));
	4662	if ( bank != old_cart_bank )
	4663	{
	4664	if ( old_cart_bank < 0 || old_cart_bank > 3 )
	4665	{
	4666	space->install_read_bank( 0xb000, 0xefff, THOM_CART_BANK );
	4667	space->install_legacy_write_handler( 0xb000, 0xefff, FUNC(mo6_cartridge_w) );
	4668	space->install_legacy_read_handler( 0xbffc, 0xbfff, FUNC(mo6_cartridge_r) );
	4669	}
	4670	LOG_BANK(( "mo6_update_cart_bank: CART is external cartridge bank %i\n", bank ));
	4671	}
	4672	}
	4673	else
	4674	{
	4675	if ( old_cart_bank != 0 )
	4676	{
	4677	space->nop_read( 0xb000, 0xefff );
	4678	LOG_BANK(( "mo6_update_cart_bank: CART is unmapped\n"));
	4679	}
	4680	}
4398	4681	}
4399	4682	}
4400
4401		old_cart_bank = bank;
4402		machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
4403		machine.root_device().membank( TO8_BIOS_BANK )->set_entry( b );
	4683	if ( bank != old_cart_bank )
	4684	{
	4685	machine.root_device().membank( THOM_CART_BANK )->set_entry( bank );
	4686	machine.root_device().membank( TO8_BIOS_BANK )->set_entry( b );
	4687	old_cart_bank = bank;
	4688	}
4404	4689	}
4405	4690
4406	4691
r15536	r15537
4429	4714	{
4430	4715	UINT8* pos = space->machine().root_device().memregion( "maincpu" )->base() + 0x10000;
4431	4716	UINT8 data = pos[offset + 0xbffc + (thom_cart_bank % thom_cart_nb_banks) * 0x4000];
4432		thom_cart_bank = offset & 3;
4433		mo6_update_cart_bank(space->machine());
	4717	if ( !space->debugger_access() )
	4718	{
	4719	thom_cart_bank = offset & 3;
	4720	mo6_update_cart_bank(space->machine());
	4721	}
4434	4722	return data;
4435	4723	}
4436	4724
r15536	r15537
4664	4952	case 1: /* ram register / lightpen register 2 */
4665	4953	if ( to7_lightpen )
4666	4954	{
4667		thom_firq_2( space->machine(), 0 );
4668		to8_lightpen_intr = 0;
	4955	if ( !space->debugger_access() )
	4956	{
	4957	thom_firq_2( space->machine(), 0 );
	4958	to8_lightpen_intr = 0;
	4959	}
4669	4960	res =  count & 0xff;
4670	4961	}
4671	4962	else
r15536	r15537
4743	5034	{
4744	5035	/* 0xa7dc from external floppy drive aliases the video gate-array */
4745	5036	if ( ( offset == 3 ) && ( to8_reg_ram & 0x80 ) )
4746		return to7_floppy_r( space, 0xc );
	5037	{
	5038	if ( !space->debugger_access() )
	5039	return to7_floppy_r( space, 0xc );
	5040	}
4747	5041
4748	5042	switch ( offset )
4749	5043	{
r15536	r15537
4919	5213
4920	5214	READ8_HANDLER ( mo5nr_net_r )
4921	5215	{
	5216	if ( space->debugger_access() )
	5217	return 0;
	5218
4922	5219	if ( to7_controller_type )
4923	5220	return to7_floppy_r ( space, offset );
4924	5221

src/mess/video/thomson.c

r15536	r15537
389	389	LOG (( "thom_set_video_mode: %i at line %i, col %i\n", mode, thom_video_elapsed( machine ) / 64, thom_video_elapsed( machine ) % 64 ));
390	390	thom_vmode = mode;
391	391	thom_gplinfo_changed( machine );
	392	thom_vstate_dirty = 1;
392	393	thom_hires_better |= thom_mode_is_hires( mode );
393	394	}
394	395	}
r15536	r15537
403	404	LOG (( "thom_set_video_page: %i at line %i col %i\n", page, thom_video_elapsed( machine ) / 64, thom_video_elapsed( machine ) % 64  ));
404	405	thom_vpage = page;
405	406	thom_gplinfo_changed( machine );
	407	thom_vstate_dirty = 1;
406	408	}
407	409	}
408	410
r15536	r15537
806	808	unsigned page = thom_vmodepage[x] & 0xff;
807	809	assert( mode < THOM_VMODE_NB );
808	810	assert( page < 4 );
809		do
810		{
811		xx++;
812		} while ( xx < 40 && thom_vmodepage[xx] == -1 );
	811	if ( thom_vmodepage_changed )
	812	{
	813	do
	814	{
	815	xx++;
	816	}
	817	while ( xx < 40 && thom_vmodepage[xx] == -1 );
	818	}
	819	else
	820	{
	821	xx = 40;
	822	}
813	823	thom_scandraw_funcs[ mode ][ thom_hires ]
814	824	( machine,
815	825	thom_vram + y * 40 + page * 0x4000,
r15536	r15537
1123	1133	memset( thom_border_l, 0xff, sizeof( thom_border_l ) );
1124	1134	memset( thom_border_r, 0xff, sizeof( thom_border_r ) );
1125	1135	memset( thom_vbody, 0, sizeof( thom_vbody ) );
1126		memset( thom_vmodepage, 0, sizeof( thom_vmodepage ) );
	1136	memset( thom_vmodepage, 0xffff, sizeof( thom_vmodepage ) );
1127	1137	memset( thom_vmem_dirty, 0, sizeof( thom_vmem_dirty ) );
1128	1138	thom_border_l[ 0 ] = 0;
1129	1139	thom_border_r[ 0 ] = 0;
	1140	thom_vmodepage[ 0 ] = 0;
	1141	thom_vmodepage_changed = 0;
1130	1142	thom_vmode = 0;
1131	1143	thom_vpage = 0;
1132	1144	thom_border_index = 0;

src/mess/drivers/thomson.c

r15536	r15537
147	147	/* joysticks, SX 90-018 specific */
148	148	PAD ( 0x04, 1, "Action B", BUTTON2, BUTTON2, LALT )
149	149	PAD ( 0x08, 2, "Action B", BUTTON2, BUTTON2, RALT )
150		PORT_BIT  ( 0x30, IP_ACTIVE_LOW, IPT_UNUSED )
151		PORT_BIT  ( 0x03, IP_ACTIVE_LOW, IPT_UNUSED ) /* ? */
	150	PORT_BIT  ( 0x30, IP_ACTIVE_HIGH, IPT_UNUSED )
	151	PORT_BIT  ( 0x03, IP_ACTIVE_HIGH, IPT_UNUSED ) /* ? */
152	152
153	153	/* mouse, SX 90-018 specific */
154	154	PORT_START ( "mouse_x" )
r15536	r15537
2082	2082	MCFG_CPU_MODIFY( "maincpu" )
2083	2083	MCFG_CPU_PROGRAM_MAP ( mo6)
2084	2084
	2085	MCFG_CASSETTE_MODIFY( CASSETTE_TAG, mo5_cassette_interface )
	2086
2085	2087	MCFG_DEVICE_REMOVE( "mc6846" )
2086	2088
2087	2089	MCFG_PIA6821_MODIFY( THOM_PIA_SYS, mo6_pia6821_sys )

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team