Previous

199869 Revisions

Next

r21046 Wednesday 13th February, 2013 at 20:50:54 UTC by Wilbert Pol
(MESS) msx.c: Reduce tagmap lookups (nw)

[src/mess/drivers]	msx.c
[src/mess/includes]	msx.h
[src/mess/machine]	msx.c msx_slot.c

trunk/src/mess/machine/msx_slot.c

r21045	r21046
31	31	static void msx_cpu_setbank (running_machine &machine, int page, UINT8 *mem)
32	32	{
33	33	msx_state *state = machine.driver_data<msx_state>();
34		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	34	address_space &space = state->m_maincpu->space(AS_PROGRAM);
35	35	switch (page)
36	36	{
37	37	case 1:
38		state->membank ("bank1")->set_base (mem);
	38	state->m_bank1->set_base (mem);
39	39	break;
40	40	case 2:
41		state->membank ("bank2")->set_base (mem);
	41	state->m_bank2->set_base (mem);
42	42	break;
43	43	case 3:
44		state->membank ("bank3")->set_base (mem);
	44	state->m_bank3->set_base (mem);
45	45	break;
46	46	case 4:
47		state->membank ("bank4")->set_base (mem);
48		state->membank ("bank5")->set_base (mem + 0x1ff8);
	47	state->m_bank4->set_base (mem);
	48	state->m_bank5->set_base (mem + 0x1ff8);
49	49	space.install_read_bank(0x7ff8, 0x7fff, "bank5");
50	50	break;
51	51	case 5:
52		state->membank ("bank6")->set_base (mem);
53		state->membank ("bank7")->set_base (mem + 0x1800);
	52	state->m_bank6->set_base (mem);
	53	state->m_bank7->set_base (mem + 0x1800);
54	54	space.install_read_bank(0x9800, 0x9fff, "bank7");
55	55	break;
56	56	case 6:
57		state->membank ("bank8")->set_base (mem);
58		state->membank ("bank9")->set_base (mem + 0x1800);
	57	state->m_bank8->set_base (mem);
	58	state->m_bank9->set_base (mem + 0x1800);
59	59	space.install_read_bank(0xb800, 0xbfff, "bank9");
60	60	break;
61	61	case 7:
62		state->membank ("bank10")->set_base (mem);
	62	state->m_bank10->set_base (mem);
63	63	break;
64	64	case 8:
65		state->membank ("bank11")->set_base (mem);
	65	state->m_bank11->set_base (mem);
66	66	state->m_top_page = mem;
67	67	break;
68	68	}
r21045	r21046
349	349
350	350	static READ8_HANDLER (konami_scc_bank5)
351	351	{
	352	msx_state *drvstate = space.machine().driver_data<msx_state>();
352	353	if (offset & 0x80)
353	354	{
354	355	if ((offset & 0xff) >= 0xe0)
355	356	{
356		return k051649_test_r (space.machine().device("k051649"), space, offset & 0xff);
	357	return k051649_test_r(drvstate->m_k051649, space, offset & 0xff);
357	358	}
358	359	return 0xff;
359	360	}
360	361	else
361	362	{
362		return k051649_waveform_r (space.machine().device("k051649"), space, offset & 0x7f);
	363	return k051649_waveform_r(drvstate->m_k051649, space, offset & 0x7f);
363	364	}
364	365	}
365	366
r21045	r21046
379	380	msx_cpu_setbank (machine, 5, state->m_mem + state->m_banks[2] * 0x2000);
380	381	msx_cpu_setbank (machine, 6, state->m_mem + state->m_banks[3] * 0x2000);
381	382	if (state->m_cart.scc.active ) {
382		machine.device("maincpu")->memory().space(AS_PROGRAM).install_legacy_read_handler(0x9800, 0x9fff, FUNC(konami_scc_bank5));
	383	msx_state *drvstate = machine.driver_data<msx_state>();
	384	drvstate->m_maincpu->space(AS_PROGRAM).install_legacy_read_handler(0x9800, 0x9fff, FUNC(konami_scc_bank5));
383	385	} else {
384		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x9800, 0x9fff,"bank7");
	386	msx_state *drvstate = machine.driver_data<msx_state>();
	387	drvstate->m_maincpu->space(AS_PROGRAM).install_read_bank(0x9800, 0x9fff,"bank7");
385	388	}
386	389	break;
387	390	case 3:
r21045	r21046
393	396	MSX_SLOT_WRITE(konami_scc)
394	397	{
395	398	msx_state *drvstate = machine.driver_data<msx_state>();
396		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	399	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
397	400	if (addr >= 0x5000 && addr < 0x5800)
398	401	{
399	402	state->m_banks[0] = val & state->m_bank_mask;
r21045	r21046
424	427	}
425	428	else if (state->m_cart.scc.active && addr >= 0x9800 && addr < 0xa000)
426	429	{
427		device_t *k051649 = space.machine().device("k051649");
428	430	int offset = addr & 0xff;
429	431
430	432	if (offset < 0x80)
431	433	{
432		k051649_waveform_w (k051649, space, offset, val);
	434	k051649_waveform_w (drvstate->m_k051649, space, offset, val);
433	435	}
434	436	else if (offset < 0xa0)
435	437	{
436	438	offset &= 0xf;
437	439	if (offset < 0xa)
438	440	{
439		k051649_frequency_w (k051649, space, offset, val);
	441	k051649_frequency_w (drvstate->m_k051649, space, offset, val);
440	442	}
441	443	else if (offset < 0xf)
442	444	{
443		k051649_volume_w (k051649, space, offset - 0xa, val);
	445	k051649_volume_w (drvstate->m_k051649, space, offset - 0xa, val);
444	446	}
445	447	else
446	448	{
447		k051649_keyonoff_w (k051649, space, 0, val);
	449	k051649_keyonoff_w (drvstate->m_k051649, space, 0, val);
448	450	}
449	451	}
450	452	else if (offset >= 0xe0)
451	453	{
452		k051649_test_w (k051649, space, offset, val);
	454	k051649_test_w (drvstate->m_k051649, space, offset, val);
453	455	}
454	456	}
455	457	else if (addr >= 0xb000 && addr < 0xb800)
r21045	r21046
1228	1230
1229	1231	MSX_SLOT_RESET(diskrom)
1230	1232	{
1231		device_t *fdc = machine.device("wd179x");
1232		wd17xx_reset(fdc);
	1233	msx_state *drvstate = machine.driver_data<msx_state>();
	1234	wd17xx_reset(drvstate->m_wd179x);
1233	1235	}
1234	1236
1235	1237	static READ8_HANDLER (msx_diskrom_page1_r)
1236	1238	{
1237	1239	msx_state *state = space.machine().driver_data<msx_state>();
1238		device_t *fdc = space.machine().device("wd179x");
1239	1240	switch (offset)
1240	1241	{
1241		case 0: return wd17xx_status_r (fdc, space, 0);
1242		case 1: return wd17xx_track_r (fdc, space, 0);
1243		case 2: return wd17xx_sector_r (fdc, space, 0);
1244		case 3: return wd17xx_data_r (fdc, space, 0);
	1242	case 0: return wd17xx_status_r (state->m_wd179x, space, 0);
	1243	case 1: return wd17xx_track_r (state->m_wd179x, space, 0);
	1244	case 2: return wd17xx_sector_r (state->m_wd179x, space, 0);
	1245	case 3: return wd17xx_data_r (state->m_wd179x, space, 0);
1245	1246	case 7: return state->m_dsk_stat;
1246	1247	default:
1247	1248	return state->m_state[1]->m_mem[offset + 0x3ff8];
r21045	r21046
1251	1252	static READ8_HANDLER (msx_diskrom_page2_r)
1252	1253	{
1253	1254	msx_state *state = space.machine().driver_data<msx_state>();
1254		device_t *fdc = space.machine().device("wd179x");
1255	1255	if (offset >= 0x7f8)
1256	1256	{
1257	1257	switch (offset)
1258	1258	{
1259	1259	case 0x7f8:
1260		return wd17xx_status_r (fdc, space, 0);
	1260	return wd17xx_status_r (state->m_wd179x, space, 0);
1261	1261	case 0x7f9:
1262		return wd17xx_track_r (fdc, space, 0);
	1262	return wd17xx_track_r (state->m_wd179x, space, 0);
1263	1263	case 0x7fa:
1264		return wd17xx_sector_r (fdc, space, 0);
	1264	return wd17xx_sector_r (state->m_wd179x, space, 0);
1265	1265	case 0x7fb:
1266		return wd17xx_data_r (fdc, space, 0);
	1266	return wd17xx_data_r (state->m_wd179x, space, 0);
1267	1267	case 0x7ff:
1268	1268	return state->m_dsk_stat;
1269	1269	default:
r21045	r21046
1279	1279	MSX_SLOT_MAP(diskrom)
1280	1280	{
1281	1281	msx_state *drvstate = machine.driver_data<msx_state>();
1282		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	1282	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
1283	1283	switch (page)
1284	1284	{
1285	1285	case 0:
r21045	r21046
1305	1305
1306	1306	MSX_SLOT_WRITE(diskrom)
1307	1307	{
1308		device_t *fdc = machine.device("wd179x");
1309		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	1308	msx_state *drvstate = machine.driver_data<msx_state>();
	1309	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
1310	1310	if (addr >= 0xa000 && addr < 0xc000)
1311	1311	{
1312	1312	addr -= 0x4000;
r21045	r21046
1314	1314	switch (addr)
1315	1315	{
1316	1316	case 0x7ff8:
1317		wd17xx_command_w (fdc, space, 0, val);
	1317	wd17xx_command_w (drvstate->m_wd179x, space, 0, val);
1318	1318	break;
1319	1319	case 0x7ff9:
1320		wd17xx_track_w (fdc, space, 0, val);
	1320	wd17xx_track_w (drvstate->m_wd179x, space, 0, val);
1321	1321	break;
1322	1322	case 0x7ffa:
1323		wd17xx_sector_w (fdc, space, 0, val);
	1323	wd17xx_sector_w (drvstate->m_wd179x, space, 0, val);
1324	1324	break;
1325	1325	case 0x7ffb:
1326		wd17xx_data_w (fdc, space, 0, val);
	1326	wd17xx_data_w (drvstate->m_wd179x, space, 0, val);
1327	1327	break;
1328	1328	case 0x7ffc:
1329		wd17xx_set_side (fdc,val & 1);
	1329	wd17xx_set_side (drvstate->m_wd179x,val & 1);
1330	1330	state->m_mem[0x3ffc] = val | 0xfe;
1331	1331	break;
1332	1332	case 0x7ffd:
1333		wd17xx_set_drive (fdc,val & 1);
	1333	wd17xx_set_drive (drvstate->m_wd179x,val & 1);
1334	1334	if ((state->m_mem[0x3ffd] ^ val) & 0x40)
1335	1335	{
1336	1336	set_led_status (machine, 0, !(val & 0x40));
r21045	r21046
1357	1357
1358	1358	MSX_SLOT_RESET(diskrom2)
1359	1359	{
1360		device_t *fdc = machine.device("wd179x");
1361		wd17xx_reset (fdc);
	1360	msx_state *drvstate = machine.driver_data<msx_state>();
	1361	wd17xx_reset (drvstate->m_wd179x);
1362	1362	}
1363	1363
1364	1364	static READ8_HANDLER (msx_diskrom2_page1_r)
1365	1365	{
1366	1366	msx_state *state = space.machine().driver_data<msx_state>();
1367		device_t *fdc = space.machine().device("wd179x");
1368	1367	switch (offset)
1369	1368	{
1370		case 0: return wd17xx_status_r(fdc, space, 0);
1371		case 1: return wd17xx_track_r(fdc, space, 0);
1372		case 2: return wd17xx_sector_r(fdc, space, 0);
1373		case 3: return wd17xx_data_r(fdc, space, 0);
	1369	case 0: return wd17xx_status_r(state->m_wd179x, space, 0);
	1370	case 1: return wd17xx_track_r(state->m_wd179x, space, 0);
	1371	case 2: return wd17xx_sector_r(state->m_wd179x, space, 0);
	1372	case 3: return wd17xx_data_r(state->m_wd179x, space, 0);
1374	1373	case 4: return state->m_dsk_stat;
1375	1374	default:
1376	1375	return state->m_state[1]->m_mem[offset + 0x3ff8];
r21045	r21046
1380	1379	static  READ8_HANDLER (msx_diskrom2_page2_r)
1381	1380	{
1382	1381	msx_state *state = space.machine().driver_data<msx_state>();
1383		device_t *fdc = space.machine().device("wd179x");
1384	1382	if (offset >= 0x7b8)
1385	1383	{
1386	1384	switch (offset)
1387	1385	{
1388	1386	case 0x7b8:
1389		return wd17xx_status_r (fdc, space, 0);
	1387	return wd17xx_status_r (state->m_wd179x, space, 0);
1390	1388	case 0x7b9:
1391		return wd17xx_track_r (fdc, space, 0);
	1389	return wd17xx_track_r (state->m_wd179x, space, 0);
1392	1390	case 0x7ba:
1393		return wd17xx_sector_r (fdc, space, 0);
	1391	return wd17xx_sector_r (state->m_wd179x, space, 0);
1394	1392	case 0x7bb:
1395		return wd17xx_data_r (fdc, space, 0);
	1393	return wd17xx_data_r (state->m_wd179x, space, 0);
1396	1394	case 0x7bc:
1397	1395	return state->m_dsk_stat;
1398	1396	default:
r21045	r21046
1408	1406	MSX_SLOT_MAP(diskrom2)
1409	1407	{
1410	1408	msx_state *drvstate = machine.driver_data<msx_state>();
1411		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	1409	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
1412	1410	switch (page)
1413	1411	{
1414	1412	case 0:
r21045	r21046
1433	1431
1434	1432	MSX_SLOT_WRITE(diskrom2)
1435	1433	{
1436		device_t *fdc = machine.device("wd179x");
1437		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	1434	msx_state *drvstate = machine.driver_data<msx_state>();
	1435	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
1438	1436	if (addr >= 0xa000 && addr < 0xc000)
1439	1437	{
1440	1438	addr -= 0x4000;
r21045	r21046
1442	1440	switch (addr)
1443	1441	{
1444	1442	case 0x7fb8:
1445		wd17xx_command_w (fdc, space, 0, val);
	1443	wd17xx_command_w (drvstate->m_wd179x, space, 0, val);
1446	1444	break;
1447	1445	case 0x7fb9:
1448		wd17xx_track_w (fdc, space, 0, val);
	1446	wd17xx_track_w (drvstate->m_wd179x, space, 0, val);
1449	1447	break;
1450	1448	case 0x7fba:
1451		wd17xx_sector_w (fdc, space, 0, val);
	1449	wd17xx_sector_w (drvstate->m_wd179x, space, 0, val);
1452	1450	break;
1453	1451	case 0x7fbb:
1454		wd17xx_data_w (fdc, space, 0, val);
	1452	wd17xx_data_w (drvstate->m_wd179x, space, 0, val);
1455	1453	break;
1456	1454	case 0x7fbc:
1457		wd17xx_set_side (fdc,val & 1);
	1455	wd17xx_set_side (drvstate->m_wd179x,val & 1);
1458	1456	state->m_mem[0x3fbc] = val | 0xfe;
1459		wd17xx_set_drive (fdc,val & 1);
	1457	wd17xx_set_drive (drvstate->m_wd179x,val & 1);
1460	1458	if ((state->m_mem[0x3fbc] ^ val) & 0x40)
1461	1459	{
1462	1460	set_led_status (machine, 0, !(val & 0x40));
r21045	r21046
1512	1510	{
1513	1511	if (addr >= 0x4000 && addr < 0x8000 && !(addr & 0x0010))
1514	1512	{
1515		machine.device<dac_device>("dac")->write_unsigned8(val);
	1513	msx_state *drvstate = machine.driver_data<msx_state>();
	1514	drvstate->m_dac->write_unsigned8(val);
1516	1515	}
1517	1516	}
1518	1517
r21045	r21046
1569	1568	msx_state *drvstate = machine.driver_data<msx_state>();
1570	1569	if (addr >= 0x5000 && addr < 0x6000)
1571	1570	{
1572		machine.device<dac_device>("dac")->write_unsigned8(val);
	1571	drvstate->m_dac->write_unsigned8(val);
1573	1572	}
1574	1573	else if (addr >= 0x6000 && addr < 0x8000)
1575	1574	{
r21045	r21046
1685	1684	MSX_SLOT_WRITE(fmpac)
1686	1685	{
1687	1686	msx_state *drvstate = machine.driver_data<msx_state>();
1688		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	1687	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
1689	1688	int i, data;
1690	1689
1691	1690	if (addr >= 0x4000 && addr < 0x6000 && state->m_cart.fmpac.sram_support)
r21045	r21046
1705	1704	case 0x7ff4:
1706	1705	if (state->m_cart.fmpac.opll_active)
1707	1706	{
1708		ym2413_w (space.machine().device("ay8910"), space, 0, val);
	1707	ym2413_w (drvstate->m_ym, space, 0, val);
1709	1708	}
1710	1709	break;
1711	1710	case 0x7ff5:
1712	1711	if (state->m_cart.fmpac.opll_active)
1713	1712	{
1714		ym2413_w (space.machine().device("ay8910"), space, 1, val);
	1713	ym2413_w (drvstate->m_ym, space, 1, val);
1715	1714	}
1716	1715	break;
1717	1716	case 0x7ff6:
r21045	r21046
2198	2197
2199	2198	if (reg < 0x80)
2200	2199	{
2201		return k051649_waveform_r (space.machine().device("k051649"), space, reg);
	2200	return k051649_waveform_r (state->m_k051649, space, reg);
2202	2201	}
2203	2202	else if (reg < 0xa0)
2204	2203	{
r21045	r21046
2207	2206	else if (reg < 0xc0)
2208	2207	{
2209	2208	/* read wave 5 */
2210		return k051649_waveform_r (space.machine().device("k051649"), space, 0x80 + (reg & 0x1f));
	2209	return k051649_waveform_r (state->m_k051649, space, 0x80 + (reg & 0x1f));
2211	2210	}
2212	2211	else if (reg < 0xe0)
2213	2212	{
2214		return k051649_test_r (space.machine().device("k051649"), space, reg);
	2213	return k051649_test_r (state->m_k051649, space, reg);
2215	2214	}
2216	2215
2217	2216	return 0xff;
r21045	r21046
2232	2231
2233	2232	if (reg < 0xa0)
2234	2233	{
2235		return k052539_waveform_r (space.machine().device("k051649"), space, reg);
	2234	return k052539_waveform_r (state->m_k051649, space, reg);
2236	2235	}
2237	2236	else if (reg >= 0xc0 && reg < 0xe0)
2238	2237	{
2239		return k051649_test_r (space.machine().device("k051649"), space, reg);
	2238	return k051649_test_r (state->m_k051649, space, reg);
2240	2239	}
2241	2240
2242	2241	return 0xff;
r21045	r21046
2244	2243
2245	2244	MSX_SLOT_MAP(soundcartridge)
2246	2245	{
2247		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	2246	msx_state *drvstate = machine.driver_data<msx_state>();
	2247	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
2248	2248	switch (page)
2249	2249	{
2250	2250	case 0:
r21045	r21046
2279	2279	MSX_SLOT_WRITE(soundcartridge)
2280	2280	{
2281	2281	msx_state *drvstate = machine.driver_data<msx_state>();
2282		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
	2282	address_space &space = drvstate->m_maincpu->space(AS_PROGRAM);
2283	2283	int i;
2284	2284
2285	2285	if (addr < 0x4000)
r21045	r21046
2341	2341	}
2342	2342	else if (addr >= 0x9800 && state->m_cart.sccp.scc_active)
2343	2343	{
2344		device_t *k051649 = space.machine().device("k051649");
2345	2344	int offset = addr & 0xff;
2346	2345
2347	2346	if (offset < 0x80)
2348	2347	{
2349		k051649_waveform_w (k051649, space, offset, val);
	2348	k051649_waveform_w (drvstate->m_k051649, space, offset, val);
2350	2349	}
2351	2350	else if (offset < 0xa0)
2352	2351	{
r21045	r21046
2354	2353
2355	2354	if (offset < 0xa)
2356	2355	{
2357		k051649_frequency_w (k051649, space, offset, val);
	2356	k051649_frequency_w (drvstate->m_k051649, space, offset, val);
2358	2357	}
2359	2358	else if (offset < 0x0f)
2360	2359	{
2361		k051649_volume_w (k051649, space, offset - 0xa, val);
	2360	k051649_volume_w (drvstate->m_k051649, space, offset - 0xa, val);
2362	2361	}
2363	2362	else if (offset == 0x0f)
2364	2363	{
2365		k051649_keyonoff_w (k051649, space, 0, val);
	2364	k051649_keyonoff_w (drvstate->m_k051649, space, 0, val);
2366	2365	}
2367	2366	}
2368	2367	else if (offset < 0xe0)
2369	2368	{
2370		k051649_test_w (k051649, space, offset, val);
	2369	k051649_test_w (drvstate->m_k051649, space, offset, val);
2371	2370	}
2372	2371	}
2373	2372	}
r21045	r21046
2391	2390	}
2392	2391	else if (addr >= 0xb800 && state->m_cart.sccp.sccp_active)
2393	2392	{
2394		device_t *k051649 = space.machine().device("k051649");
2395	2393	int offset = addr & 0xff;
2396	2394
2397	2395	if (offset < 0xa0)
2398	2396	{
2399		k052539_waveform_w (k051649, space, offset, val);
	2397	k052539_waveform_w (drvstate->m_k051649, space, offset, val);
2400	2398	}
2401	2399	else if (offset < 0xc0)
2402	2400	{
r21045	r21046
2404	2402
2405	2403	if (offset < 0x0a)
2406	2404	{
2407		k051649_frequency_w (k051649, space, offset, val);
	2405	k051649_frequency_w (drvstate->m_k051649, space, offset, val);
2408	2406	}
2409	2407	else if (offset < 0x0f)
2410	2408	{
2411		k051649_volume_w (k051649, space, offset - 0x0a, val);
	2409	k051649_volume_w (drvstate->m_k051649, space, offset - 0x0a, val);
2412	2410	}
2413	2411	else if (offset == 0x0f)
2414	2412	{
2415		k051649_keyonoff_w (k051649, space, 0, val);
	2413	k051649_keyonoff_w (drvstate->m_k051649, space, 0, val);
2416	2414	}
2417	2415	}
2418	2416	else if (offset < 0xe0)
2419	2417	{
2420		k051649_test_w (k051649, space, offset, val);
	2418	k051649_test_w (drvstate->m_k051649, space, offset, val);
2421	2419	}
2422	2420	}
2423	2421	}

trunk/src/mess/machine/msx.c

r21045	r21046
145	145	UINT8 *rom_region = image.get_software_region("rom");
146	146	size = size_aligned = image.get_software_region_length("rom");
147	147
148		mem = auto_alloc_array(image.device().machine(), UINT8, size_aligned);
	148	mem = auto_alloc_array(machine(), UINT8, size_aligned);
149	149	memcpy(mem, rom_region, size_aligned);
150	150	}
151	151	else
r21045	r21046
164	164	while (size_aligned < size)
165	165	size_aligned *= 2;
166	166
167		mem = auto_alloc_array(image.device().machine(),UINT8,size_aligned);
	167	mem = auto_alloc_array(machine(),UINT8,size_aligned);
168	168	if (!mem)
169	169	{
170	170	logerror ("cart #%d: error: failed to allocate memory for cartridge\n", id);
r21045	r21046
216	216	int old_size_aligned = size_aligned;
217	217
218	218	size_aligned = 0x10000;
219		mem = auto_alloc_array(image.device().machine(),UINT8, 0x10000);
	219	mem = auto_alloc_array(machine(),UINT8, 0x10000);
220	220	if (!mem)
221	221	{
222		auto_free(image.device().machine(),old_mem);
	222	auto_free(machine(),old_mem);
223	223	logerror ("cart #%d: error: cannot allocate memory\n", id);
224	224	return IMAGE_INIT_FAIL;
225	225	}
r21045	r21046
236	236
237	237	/* Copy old contents to newly claimed memory */
238	238	memcpy(mem,old_mem,old_size_aligned);
239		auto_free(image.device().machine(),old_mem);
	239	auto_free(machine(),old_mem);
240	240	}
241	241
242	242	/* mapper type 0 (ROM) might need moving around a bit */
r21045	r21046
303	303	type = SLOT_ROM;
304	304
305	305	/* allocate and set slot_state for this cartridge */
306		st = auto_alloc(image.device().machine(),slot_state);
	306	st = auto_alloc(machine(),slot_state);
307	307	if (!st)
308	308	{
309	309	logerror ("cart #%d: error: cannot allocate memory for cartridge state\n", id);
r21045	r21046
312	312	memset (st, 0, sizeof (slot_state));
313	313
314	314	st->m_type = type;
315		sramfile = auto_alloc_array(image.device().machine(), char, strlen (image.filename () + 1));
	315	sramfile = auto_alloc_array(machine(), char, strlen (image.filename () + 1));
316	316
317	317	if (sramfile)
318	318	{
r21045	r21046
326	326	st->m_sramfile = sramfile;
327	327	}
328	328
329		if (msx_slot_list[type].init (image.device().machine(), st, 0, mem, size_aligned))
	329	if (msx_slot_list[type].init (machine(), st, 0, mem, size_aligned))
330	330	return IMAGE_INIT_FAIL;
331	331
332	332	if (msx_slot_list[type].loadsram)
333		msx_slot_list[type].loadsram (image.device().machine(), st);
	333	msx_slot_list[type].loadsram (machine(), st);
334	334
335	335	m_cart_state[id] = st;
336		msx_memory_set_carts (image.device().machine());
	336	msx_memory_set_carts();
337	337
338	338	return IMAGE_INIT_PASS;
339	339	}
r21045	r21046
360	360
361	361	void msx_vdp_interrupt(device_t *, v99x8_device &device, int i)
362	362	{
363		device.machine().device("maincpu")->execute().set_input_line(0, (i ? HOLD_LINE : CLEAR_LINE));
	363	msx_state *state = device.machine().driver_data<msx_state>();
	364
	365	state->m_maincpu->set_input_line(0, (i ? HOLD_LINE : CLEAR_LINE));
364	366	}
365	367
366	368	void msx_state::msx_ch_reset_core ()
r21045	r21046
519	521
520	522	DRIVER_INIT_MEMBER(msx_state,msx)
521	523	{
522		machine().device("maincpu")->execute().set_input_line_vector(0, 0xff);
	524	m_maincpu->set_input_line_vector(0, 0xff);
523	525
524		msx_memory_init (machine());
	526	msx_memory_init();
525	527
526		z80_set_cycle_tables( machine().device("maincpu"), cc_op, cc_cb, cc_ed, cc_xy, cc_xycb, cc_ex );
	528	z80_set_cycle_tables( m_maincpu, cc_op, cc_cb, cc_ed, cc_xy, cc_xycb, cc_ex );
527	529	}
528	530
529	531	TIMER_DEVICE_CALLBACK_MEMBER(msx_state::msx2_interrupt)
530	532	{
531		m_v9938->set_resolution(machine().root_device().ioport("DSW")->read() & 0x03);
	533	m_v9938->set_resolution(m_io_dsw->read() & 0x03);
532	534	m_v9938->interrupt();
533	535	}
534	536
r21045	r21046
536	538	{
537	539	int i;
538	540
539		for (i=0; i<2; i++)
540		{
541		m_mouse[i] = ioport(i ? "MOUSE1" : "MOUSE0")->read();
542		m_mouse_stat[i] = -1;
543		}
	541	m_mouse[0] = m_io_mouse0->read();
	542	m_mouse_stat[0] = -1;
	543	m_mouse[1] = m_io_mouse1->read();
	544	m_mouse_stat[1] = -1;
544	545	}
545	546
546	547	/*
r21045	r21046
554	555
555	556	data = (m_cass->input() > 0.0038 ? 0x80 : 0);
556	557
557		if ( (m_psg_b ^ ioport("DSW")->read() ) & 0x40)
	558	if ( (m_psg_b ^ m_io_dsw->read() ) & 0x40)
558	559	{
559	560	/* game port 2 */
560		UINT8 inp = ioport("JOY1")->read();
	561	UINT8 inp = m_io_joy1->read();
561	562	if ( !(inp & 0x80) )
562	563	{
563	564	/* joystick */
r21045	r21046
576	577	else
577	578	{
578	579	/* game port 1 */
579		UINT8 inp = ioport("JOY0")->read();
	580	UINT8 inp = m_io_joy0->read();
580	581	if ( !(inp & 0x80) )
581	582	{
582	583	/* joystick */
r21045	r21046
625	626
626	627	WRITE8_MEMBER(msx_state::msx_printer_strobe_w)
627	628	{
628		machine().device<centronics_device>("centronics")->strobe_w(BIT(data, 1));
	629	m_centronics->strobe_w(BIT(data, 1));
629	630	}
630	631
631	632	WRITE8_MEMBER(msx_state::msx_printer_data_w)
632	633	{
633		if (machine().root_device().ioport("DSW")->read() & 0x80)
	634	if (m_io_dsw->read() & 0x80)
634	635	/* SIMPL emulation */
635		machine().device<dac_device>("dac")->write_signed8(data);
	636	m_dac->write_signed8(data);
636	637	else
637		machine().device<centronics_device>("centronics")->write(machine().driver_data()->generic_space(), 0, data);
	638	m_centronics->write(space, 0, data);
638	639	}
639	640
640	641	READ8_MEMBER(msx_state::msx_printer_status_r)
641	642	{
642	643	UINT8 result = 0xfd;
643	644
644		if (machine().root_device().ioport("DSW")->read() & 0x80)
	645	if (m_io_dsw->read() & 0x80)
645	646	return 0xff;
646	647
647		result |= machine().device<centronics_device>("centronics")->busy_r() << 1;
	648	result |= m_centronics->busy_r() << 1;
648	649
649	650	return result;
650	651	}
r21045	r21046
789	790	{
790	791	UINT8 result = 0xff;
791	792	int row, data;
792		static const char *const keynames[] = { "KEY0", "KEY1", "KEY2", "KEY3", "KEY4", "KEY5" };
	793	ioport_port *keynames[] = { m_io_key0, m_io_key1, m_io_key2, m_io_key3, m_io_key4, m_io_key5 };
793	794
794	795	row = keylatch;
795	796	if (row <= 10)
796	797	{
797		data = ioport(keynames[row / 2])->read();
	798	data = keynames[row / 2]->read();
798	799
799	800	if (BIT(row, 0))
800	801	data >>= 8;
r21045	r21046
809	810	*
810	811	***********************************************************************/
811	812
812		static void msx_memory_init (running_machine &machine)
	813	void msx_state::msx_memory_init()
813	814	{
814		msx_state *state = machine.driver_data<msx_state>();
815	815	int prim, sec, page, extent, option;
816	816	int size = 0;
817	817	const msx_slot_layout *layout= (msx_slot_layout*)NULL;
r21045	r21046
820	820	slot_state *st;
821	821	UINT8 *mem = NULL;
822	822
823		state->m_empty = auto_alloc_array(machine, UINT8, 0x4000);
824		memset (state->m_empty, 0xff, 0x4000);
	823	m_empty = auto_alloc_array(machine(), UINT8, 0x4000);
	824	memset (m_empty, 0xff, 0x4000);
825	825
826	826	for (prim=0; prim<4; prim++) {
827	827	for (sec=0; sec<4; sec++) {
828	828	for (page=0; page<4; page++) {
829		state->m_all_state[prim][sec][page]= (slot_state*)NULL;
	829	m_all_state[prim][sec][page]= (slot_state*)NULL;
830	830	}
831	831	}
832	832	}
833	833
834	834	for (driver = msx_driver_list; driver->name[0]; driver++) {
835		if (!strcmp (driver->name, machine.system().name)) {
	835	if (!strcmp (driver->name, machine().system().name)) {
836	836	layout = driver->layout;
837	837	}
838	838	}
r21045	r21046
843	843	return;
844	844	}
845	845
846		state->layout = layout;
	846	m_layout = layout;
847	847
848	848	for (; layout->entry != MSX_LAYOUT_LAST; layout++) {
849	849	switch (layout->entry) {
r21045	r21046
854	854	extent = layout->page_extent;
855	855
856	856	if (layout->slot_secondary) {
857		state->m_slot_expanded[layout->slot_primary]= TRUE;
	857	m_slot_expanded[layout->slot_primary]= TRUE;
858	858	}
859	859
860	860	slot = &msx_slot_list[layout->type];
r21045	r21046
874	874
875	875	st = (slot_state*)NULL;
876	876	if (layout->type == SLOT_CARTRIDGE1) {
877		st = state->m_cart_state[0];
	877	st = m_cart_state[0];
878	878	if (!st) {
879	879	slot = &msx_slot_list[SLOT_SOUNDCARTRIDGE];
880	880	size = 0x20000;
881	881	}
882	882	}
883	883	if (layout->type == SLOT_CARTRIDGE2) {
884		st = state->m_cart_state[1];
	884	st = m_cart_state[1];
885	885	if (!st) {
886	886	/* Check whether the optional FM-PAC rom is present */
887	887	option = 0x10000;
888	888	size = 0x10000;
889		mem = machine.root_device().memregion("maincpu")->base() + option;
890		if (machine.root_device().memregion("maincpu")->bytes() >= size + option && mem[0] == 'A' && mem[1] == 'B') {
	889	mem = m_region_maincpu->base() + option;
	890	if (m_region_maincpu->bytes() >= size + option && mem[0] == 'A' && mem[1] == 'B') {
891	891	slot = &msx_slot_list[SLOT_FMPAC];
892	892	}
893	893	else {
r21045	r21046
900	900	switch (slot->mem_type) {
901	901	case MSX_MEM_HANDLER:
902	902	case MSX_MEM_ROM:
903		mem = machine.root_device().memregion("maincpu")->base() + option;
	903	mem = m_region_maincpu->base() + option;
904	904	break;
905	905	case MSX_MEM_RAM:
906	906	mem = NULL;
907	907	break;
908	908	}
909		st = auto_alloc_clear (machine, slot_state);
	909	st = auto_alloc_clear (machine(), slot_state);
910	910	memset (st, 0, sizeof (slot_state));
911	911
912		if (slot->init (machine, st, layout->slot_page, mem, size)) {
	912	if (slot->init (machine(), st, layout->slot_page, mem, size)) {
913	913	continue;
914	914	}
915	915	}
r21045	r21046
920	920	"page + extent > 3\n");
921	921	break;
922	922	}
923		state->m_all_state[prim][sec][page] = st;
	923	m_all_state[prim][sec][page] = st;
924	924	page++;
925	925	}
926	926	break;
927	927	case MSX_LAYOUT_KANJI_ENTRY:
928		state->m_kanji_mem = machine.root_device().memregion("maincpu")->base() + layout->option;
	928	m_kanji_mem = m_region_maincpu->base() + layout->option;
929	929	break;
930	930	case MSX_LAYOUT_RAMIO_SET_BITS_ENTRY:
931		state->m_ramio_set_bits = (UINT8)layout->option;
	931	m_ramio_set_bits = (UINT8)layout->option;
932	932	break;
933	933	}
934	934	}
r21045	r21046
957	957	}
958	958	}
959	959
960		static void msx_memory_set_carts (running_machine &machine)
	960	void msx_state::msx_memory_set_carts()
961	961	{
962		msx_state *state = machine.driver_data<msx_state>();
963	962	const msx_slot_layout *layout;
964	963	int page;
965	964
966		if (!state->layout)
	965	if (!layout)
967	966	return;
968	967
969		for (layout = state->layout; layout->entry != MSX_LAYOUT_LAST; layout++)
	968	for (layout = m_layout; layout->entry != MSX_LAYOUT_LAST; layout++)
970	969	{
971	970	if (layout->entry == MSX_LAYOUT_SLOT_ENTRY)
972	971	{
r21045	r21046
974	973	{
975	974	case SLOT_CARTRIDGE1:
976	975	for (page=0; page<4; page++)
977		state->m_all_state[layout->slot_primary][layout->slot_secondary][page]
978		= state->m_cart_state[0];
	976	m_all_state[layout->slot_primary][layout->slot_secondary][page]
	977	= m_cart_state[0];
979	978	break;
980	979	case SLOT_CARTRIDGE2:
981	980	for (page=0; page<4; page++)
982		state->m_all_state[layout->slot_primary][layout->slot_secondary][page]
983		= state->m_cart_state[1];
	981	m_all_state[layout->slot_primary][layout->slot_secondary][page]
	982	= m_cart_state[1];
984	983	break;
985	984	}
986	985	}

trunk/src/mess/includes/msx.h

r21045	r21046
38	38	{
39	39	public:
40	40	msx_state(const machine_config &mconfig, device_type type, const char *tag)
41		: driver_device(mconfig, type, tag),
42		m_v9938(*this, "v9938"),
43		m_cass(*this, CASSETTE_TAG),
44		m_ym(*this, "ym2413"),
45		m_dac(*this, "dac"),
46		m_rtc(*this, TC8521_TAG)
	41	: driver_device(mconfig, type, tag)
	42	, m_maincpu(*this, "maincpu")
	43	, m_v9938(*this, "v9938")
	44	, m_cass(*this, CASSETTE_TAG)
	45	, m_ay8910(*this, "ay8910")
	46	, m_ym(*this, "ym2413")
	47	, m_k051649(*this, "k051649")
	48	, m_dac(*this, "dac")
	49	, m_centronics(*this, "centronics")
	50	, m_rtc(*this, TC8521_TAG)
	51	, m_wd179x(*this, "wd179x")
	52	, m_bank1(*this, "bank1")
	53	, m_bank2(*this, "bank2")
	54	, m_bank3(*this, "bank3")
	55	, m_bank4(*this, "bank4")
	56	, m_bank5(*this, "bank5")
	57	, m_bank6(*this, "bank6")
	58	, m_bank7(*this, "bank7")
	59	, m_bank8(*this, "bank8")
	60	, m_bank9(*this, "bank9")
	61	, m_bank10(*this, "bank10")
	62	, m_bank11(*this, "bank11")
	63	, m_region_maincpu(*this, "maincpu")
	64	, m_io_joy0(*this, "JOY0")
	65	, m_io_joy1(*this, "JOY1")
	66	, m_io_dsw(*this, "DSW")
	67	, m_io_mouse0(*this, "MOUSE0")
	68	, m_io_mouse1(*this, "MOUSE1")
	69	, m_io_key0(*this, "KEY0")
	70	, m_io_key1(*this, "KEY1")
	71	, m_io_key2(*this, "KEY2")
	72	, m_io_key3(*this, "KEY3")
	73	, m_io_key4(*this, "KEY4")
	74	, m_io_key5(*this, "KEY5")
47	75	{ }
48	76
49	77	DECLARE_WRITE8_MEMBER(msx_page0_w);
r21045	r21046
89	117	UINT8 *m_kanji_mem;
90	118	int m_kanji_latch;
91	119	/* memory */
92		const msx_slot_layout *layout;
	120	const msx_slot_layout *m_layout;
93	121	slot_state *m_cart_state[MSX_MAX_CARTS];
94	122	slot_state *m_state[4];
95	123	const msx_slot *m_slot[4];
r21045	r21046
110	138	void msx_ch_reset_core ();
111	139	void msx_memory_reset ();
112	140
	141	required_device<cpu_device> m_maincpu;
113	142	optional_device<v9938_device> m_v9938;
114	143	required_device<cassette_image_device> m_cass;
	144	required_device<device_t> m_ay8910;
115	145	required_device<ym2413_device> m_ym;
	146	optional_device<device_t> m_k051649;
116	147	required_device<dac_device> m_dac;
	148	required_device<centronics_device> m_centronics;
117	149	optional_device<rp5c01_device> m_rtc;
	150	optional_device<device_t> m_wd179x;
118	151	DECLARE_READ8_MEMBER(msx_psg_port_a_r);
119	152	DECLARE_READ8_MEMBER(msx_psg_port_b_r);
120	153	DECLARE_WRITE8_MEMBER(msx_psg_port_a_w);
r21045	r21046
130	163	DECLARE_WRITE8_MEMBER(msx_printer_strobe_w);
131	164	DECLARE_WRITE8_MEMBER(msx_printer_data_w);
132	165	DECLARE_READ8_MEMBER(msx_printer_status_r);
	166	void msx_memory_init();
	167	void msx_memory_set_carts();
133	168
134	169	DECLARE_DEVICE_IMAGE_LOAD_MEMBER( msx_cart );
135	170	DECLARE_DEVICE_IMAGE_UNLOAD_MEMBER( msx_cart );
	171
	172	required_memory_bank m_bank1;
	173	required_memory_bank m_bank2;
	174	required_memory_bank m_bank3;
	175	required_memory_bank m_bank4;
	176	required_memory_bank m_bank5;
	177	required_memory_bank m_bank6;
	178	required_memory_bank m_bank7;
	179	required_memory_bank m_bank8;
	180	required_memory_bank m_bank9;
	181	required_memory_bank m_bank10;
	182	required_memory_bank m_bank11;
	183	protected:
	184	required_memory_region m_region_maincpu;
	185	required_ioport m_io_joy0;
	186	required_ioport m_io_joy1;
	187	required_ioport m_io_dsw;
	188	required_ioport m_io_mouse0;
	189	required_ioport m_io_mouse1;
	190	required_ioport m_io_key0;
	191	required_ioport m_io_key1;
	192	required_ioport m_io_key2;
	193	required_ioport m_io_key3;
	194	required_ioport m_io_key4;
	195	required_ioport m_io_key5;
136	196	};
137	197
138	198

trunk/src/mess/drivers/msx.c

r21045	r21046
343	343
344	344	WRITE8_MEMBER(msx_state::msx_ay8910_w)
345	345	{
346		device_t *device = machine().device("ay8910");
347	346	if ( offset & 1 )
348		ay8910_data_w( device, space, offset, data );
	347	ay8910_data_w( m_ay8910, space, offset, data );
349	348	else
350		ay8910_address_w( device, space, offset, data );
	349	ay8910_address_w( m_ay8910, space, offset, data );
351	350	}
352	351
353	352

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team