Previous

15994 Revisions

Next

r15041 Friday 27th April, 2012 at 02:10:23 UTC by R. Belmont
Apple II: Misc cleanup/modernization (nw)

[src/mess/includes]	apple2.h apple2gs.h
[src/mess/machine]	a2swyft.c apple2.c apple2gs.c

src/mess/machine/apple2gs.c

r15040	r15041
476	476
477	477
478	478
479		static UINT8 adb_read_datareg(apple2gs_state *state)
	479	UINT8 apple2gs_state::adb_read_datareg()
480	480	{
481	481	UINT8 result;
482	482
483		switch(state->m_adb_state)
	483	switch(m_adb_state)
484	484	{
485	485	case ADBSTATE_INRESPONSE:
486		result = state->m_adb_response_bytes[state->m_adb_response_pos++];
487		if (state->m_adb_response_pos >= state->m_adb_response_length)
	486	result = m_adb_response_bytes[m_adb_response_pos++];
	487	if (m_adb_response_pos >= m_adb_response_length)
488	488	{
489		state->m_adb_state = ADBSTATE_IDLE;
490		state->m_adb_latent_result = result;
491		state->m_adb_kmstatus &= ~0x20;
	489	m_adb_state = ADBSTATE_IDLE;
	490	m_adb_latent_result = result;
	491	m_adb_kmstatus &= ~0x20;
492	492	}
493	493	break;
494	494
r15040	r15041
624	624
625	625	// real rom 3 h/w reads 0x90 when idle, 0x98 when key pressed
626	626	// current MESS reads back 0xb0 when idle
627		static UINT8 adb_read_kmstatus(apple2gs_state *state)
	627	UINT8 apple2gs_state::adb_read_kmstatus()
628	628	{
629		return state->m_adb_kmstatus;
	629	return m_adb_kmstatus;
630	630	}
631	631
632	632
r15040	r15041
910	910	return result;
911	911	}
912	912
913		static READ8_HANDLER( apple2gs_c0xx_r )
	913	READ8_MEMBER( apple2gs_state::apple2gs_c0xx_r )
914	914	{
915		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
916	915	UINT8 result;
917	916	scc8530_t *scc;
918	917
919		if(space->debugger_access())
	918	if(space.debugger_access())
920	919	{
921	920	return 0;
922	921	}
r15040	r15041
926	925	switch(offset)
927	926	{
928	927	case 0x19:   /* C019 - RDVBLBAR */
929		result = (space->machine().primary_screen->vpos() >= (192+BORDER_TOP)) ? 0x80 : 0x00;
	928	result = (space.machine().primary_screen->vpos() >= (192+BORDER_TOP)) ? 0x80 : 0x00;
930	929	break;
931	930
932	931	case 0x22:   /* C022 - TBCOLOR */
933		result = (state->m_fgcolor << 4) | state->m_bgcolor;
	932	result = (m_fgcolor << 4) | m_bgcolor;
934	933	break;
935	934
936	935	case 0x23:   /* C023 - VGCINT */
937		result = state->m_vgcint;
	936	result = m_vgcint;
938	937	break;
939	938
940	939	case 0x24:   /* C024 - MOUSEDATA */
941		result = adb_read_mousedata(space->machine());
	940	result = adb_read_mousedata(space.machine());
942	941	break;
943	942
944	943	case 0x25:   /* C025 - KEYMODREG */
945		result = AY3600_keymod_r(space->machine());
	944	result = AY3600_keymod_r(space.machine());
946	945	break;
947	946
948	947	case 0x26:   /* C026 - DATAREG */
949		result = adb_read_datareg(state);
	948	result = adb_read_datareg();
950	949	break;
951	950
952	951	case 0x27:   /* C027 - KMSTATUS */
953		result = adb_read_kmstatus(state);
	952	result = adb_read_kmstatus();
954	953	break;
955	954
956	955	case 0x29:   /* C029 - NEWVIDEO */
957		result = state->m_newvideo;
	956	result = m_newvideo;
958	957	break;
959	958
960	959	case 0x2B:   /* C02B - LANGSEL */
961		result = state->m_langsel;
	960	result = m_langsel;
962	961	break;
963	962
964	963	case 0x2D:   /* C02D - SLTROMSEL */
965		result = state->m_sltromsel;
	964	result = m_sltromsel;
966	965	break;
967	966
968	967	case 0x2E:   /* C02E - VERTCNT */
969		result = apple2gs_get_vpos(space->machine()) >> 1;
	968	result = apple2gs_get_vpos(space.machine()) >> 1;
970	969	break;
971	970
972	971	case 0x2F:   /* C02F - HORIZCNT */
973		result = space->machine().primary_screen->hpos() / 11;
	972	result = space.machine().primary_screen->hpos() / 11;
974	973	if (result > 0)
975	974	{
976	975	result += 0x40;
977	976	}
978	977
979		if (apple2gs_get_vpos(space->machine()) & 1)
	978	if (apple2gs_get_vpos(space.machine()) & 1)
980	979	{
981	980	result |= 0x80;
982	981	}
983	982	break;
984	983
985	984	case 0x31:   /* C031 - DISKREG */
986		result = state->m_fdc_diskreg;
	985	result = m_fdc_diskreg;
987	986	break;
988	987
989	988	case 0x33:   /* C033 - CLOCKDATA */
990		result = state->m_clock_data;
	989	result = m_clock_data;
991	990	break;
992	991
993	992	case 0x34:   /* C034 - CLOCKCTL */
994		result = state->m_clock_control;
	993	result = m_clock_control;
995	994	break;
996	995
997	996	case 0x35:   /* C035 - SHADOW */
998		result = state->m_shadow;
	997	result = m_shadow;
999	998	break;
1000	999
1001	1000	case 0x36:   /* C036 - CYAREG */
1002		result = state->m_cyareg;
	1001	result = m_cyareg;
1003	1002	break;
1004	1003
1005	1004	case 0x38:   /* C038 - SCCBREG */
1006	1005	case 0x39:   /* C039 - SCCAREG */
1007	1006	case 0x3A:   /* C03A - SCCBDATA */
1008	1007	case 0x3B:   /* C03B - SCCADATA */
1009		scc = space->machine().device<scc8530_t>("scc");
1010		result = scc->reg_r(*space, offset & 0x03);
	1008	scc = space.machine().device<scc8530_t>("scc");
	1009	result = scc->reg_r(space, offset & 0x03);
1011	1010	break;
1012	1011
1013	1012	case 0x3C:   /* C03C - SOUNDCTL */
1014	1013	case 0x3D:   /* C03D - SOUNDDATA */
1015	1014	case 0x3E:   /* C03E - SOUNDADRL */
1016	1015	case 0x3F:   /* C03F - SOUNDADRH */
1017		result = gssnd_r(space, offset & 0x03);
	1016	result = gssnd_r(&space, offset & 0x03);
1018	1017	break;
1019	1018
1020	1019	case 0x41:   /* C041 - INTEN */
1021		result = state->m_inten;
	1020	result = m_inten;
1022	1021	break;
1023	1022
1024	1023	case 0x46:   /* C046 - INTFLAG */
1025		result = state->m_intflag;
	1024	result = m_intflag;
1026	1025	break;
1027	1026
1028	1027	case 0x68:   /* C068 - STATEREG */
1029		result = ((state->m_flags & VAR_ALTZP)   ? 0x80 : 0x00)
1030		|   ((state->m_flags & VAR_PAGE2)   ? 0x40 : 0x00)
1031		|   ((state->m_flags & VAR_RAMRD)   ? 0x20 : 0x00)
1032		|   ((state->m_flags & VAR_RAMWRT)   ? 0x10 : 0x00)
1033		|   ((state->m_flags & VAR_LCRAM)   ? 0x00 : 0x08)
1034		|   ((state->m_flags & VAR_LCRAM2)   ? 0x04 : 0x00)
1035		|   ((state->m_flags & VAR_INTCXROM)? 0x01 : 0x00);
	1028	result = ((m_flags & VAR_ALTZP)   ? 0x80 : 0x00)
	1029	|   ((m_flags & VAR_PAGE2)   ? 0x40 : 0x00)
	1030	|   ((m_flags & VAR_RAMRD)   ? 0x20 : 0x00)
	1031	|   ((m_flags & VAR_RAMWRT)   ? 0x10 : 0x00)
	1032	|   ((m_flags & VAR_LCRAM)   ? 0x00 : 0x08)
	1033	|   ((m_flags & VAR_LCRAM2)   ? 0x04 : 0x00)
	1034	|   ((m_flags & VAR_INTCXROM)? 0x01 : 0x00);
1036	1035	break;
1037	1036
1038	1037	case 0x71: case 0x72: case 0x73:
1039	1038	case 0x74: case 0x75: case 0x76: case 0x77:
1040	1039	case 0x78: case 0x79: case 0x7a: case 0x7b:
1041	1040	case 0x7c: case 0x7d: case 0x7e: case 0x7f:
1042		offset |= (space->machine().root_device().memregion("maincpu")->bytes() - 1) & ~0x3FFF;
1043		result = space->machine().root_device().memregion("maincpu")->base()[offset];
	1041	offset |= (space.machine().root_device().memregion("maincpu")->bytes() - 1) & ~0x3FFF;
	1042	result = space.machine().root_device().memregion("maincpu")->base()[offset];
1044	1043	break;
1045	1044
1046	1045	case 0x21:   /* C021 - MONOCOLOR */
r15040	r15041
1051	1050	// slot 6 registers should go to applefdc if slot 6 not "Your Card"
1052	1051	case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7:
1053	1052	case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef:
1054		if ((state->m_sltromsel & (1 << 6)) == 0)
	1053	if ((m_sltromsel & (1 << 6)) == 0)
1055	1054	{
1056		result = applefdc_r(state->m_fdc, offset);
	1055	result = applefdc_r(m_fdc, offset);
1057	1056	}
1058	1057	else
1059	1058	{
1060		result = apple2_c0xx_r(space, offset);
	1059	result = apple2_c0xx_r(space, offset, 0);
1061	1060	}
1062	1061	break;
1063	1062
1064	1063	default:
1065	1064	if (offset < 0x80)
1066	1065	{
1067		result = apple2_c0xx_r(space, offset);
	1066	result = apple2_c0xx_r(space, offset, 0);
1068	1067	}
1069	1068	else
1070	1069	{
1071		result = apple2_c080_r(space, offset);
	1070	result = apple2_c080_r(space, offset, 0);
1072	1071	}
1073	1072	break;
1074	1073	}
r15040	r15041
1080	1079
1081	1080
1082	1081
1083		static WRITE8_HANDLER( apple2gs_c0xx_w )
	1082	WRITE8_MEMBER( apple2gs_state::apple2gs_c0xx_w )
1084	1083	{
1085		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1086	1084	scc8530_t *scc;
1087	1085
1088	1086	offset &= 0xFF;
r15040	r15041
1093	1091	switch(offset)
1094	1092	{
1095	1093	case 0x22:   /* C022 - TBCOLOR */
1096		state->m_fgcolor = (data >> 4) & 0x0F;
1097		state->m_bgcolor = (data >> 0) & 0x0F;
	1094	m_fgcolor = (data >> 4) & 0x0F;
	1095	m_bgcolor = (data >> 0) & 0x0F;
1098	1096	break;
1099	1097
1100	1098	case 0x23:   /* C023 - VGCINT */
1101		state->m_vgcint &= ~0x0F;
1102		state->m_vgcint |= data & 0x0F;
	1099	m_vgcint &= ~0x0F;
	1100	m_vgcint |= data & 0x0F;
1103	1101	break;
1104	1102
1105	1103	case 0x24:   /* C024 - MOUSEDATA */
r15040	r15041
1112	1110	break;
1113	1111
1114	1112	case 0x26:   /* C026 - DATAREG */
1115		adb_write_datareg(space->machine(), data);
	1113	adb_write_datareg(space.machine(), data);
1116	1114	break;
1117	1115
1118	1116	case 0x27:   /* C027 - KMSTATUS */
1119		adb_write_kmstatus(state, data);
	1117	adb_write_kmstatus(this, data);
1120	1118	break;
1121	1119
1122	1120	case 0x29:   /* C029 - NEWVIDEO */
1123		state->m_newvideo = data;
	1121	m_newvideo = data;
1124	1122	break;
1125	1123
1126	1124	case 0x2B:   /* C02B - LANGSEL */
1127		state->m_langsel = data;
	1125	m_langsel = data;
1128	1126	break;
1129	1127
1130	1128	case 0x2D:   /* C02D - SLTROMSEL */
1131		state->m_sltromsel = data;
1132		apple2_update_memory(space->machine());
	1129	m_sltromsel = data;
	1130	apple2_update_memory(space.machine());
1133	1131	break;
1134	1132
1135	1133	case 0x31:   /* C031 - DISKREG */
1136		apple2_iwm_setdiskreg(space->machine(), data);
	1134	apple2_iwm_setdiskreg(space.machine(), data);
1137	1135	break;
1138	1136
1139	1137	case 0x32:   /* C032 - SCANINT */
1140		apple2gs_set_scanint(space->machine(), data);
	1138	apple2gs_set_scanint(space.machine(), data);
1141	1139	break;
1142	1140
1143	1141	case 0x33:   /* C033 - CLOCKDATA */
1144		state->m_clock_data = data;
	1142	m_clock_data = data;
1145	1143	break;
1146	1144
1147	1145	case 0x34:   /* C034 - CLOCKCTL */
1148		state->m_clock_control = data & 0x7F;
1149		state->m_bordercolor = data & 0x0F;
	1146	m_clock_control = data & 0x7F;
	1147	m_bordercolor = data & 0x0F;
1150	1148	if (data & 0x80)
1151		process_clock(space->machine());
	1149	process_clock(space.machine());
1152	1150	break;
1153	1151
1154	1152	case 0x35:   /* C035 - SHADOW */
1155		if (state->m_shadow != data)
	1153	if (m_shadow != data)
1156	1154	{
1157		state->m_shadow = data;
1158		apple2_update_memory(space->machine());
	1155	m_shadow = data;
	1156	apple2_update_memory(space.machine());
1159	1157	}
1160	1158	break;
1161	1159
1162	1160	case 0x36:   /* C036 - CYAREG */
1163		state->m_cyareg = data & ~0x20;
1164		space->machine().device("maincpu")->set_unscaled_clock((data & 0x80) ? APPLE2GS_14M/5 : APPLE2GS_7M/7);
	1161	m_cyareg = data & ~0x20;
	1162	space.machine().device("maincpu")->set_unscaled_clock((data & 0x80) ? APPLE2GS_14M/5 : APPLE2GS_7M/7);
1165	1163	break;
1166	1164
1167	1165	case 0x38:   /* C038 - SCCBREG */
1168	1166	case 0x39:   /* C039 - SCCAREG */
1169	1167	case 0x3A:   /* C03A - SCCBDATA */
1170	1168	case 0x3B:   /* C03B - SCCADATA */
1171		scc = space->machine().device<scc8530_t>("scc");
1172		scc->reg_w(*space, offset & 0x03, data);
	1169	scc = space.machine().device<scc8530_t>("scc");
	1170	scc->reg_w(space, offset & 0x03, data);
1173	1171	break;
1174	1172
1175	1173	case 0x3C:   /* C03C - SOUNDCTL */
1176	1174	case 0x3D:   /* C03D - SOUNDDATA */
1177	1175	case 0x3E:   /* C03E - SOUNDADRL */
1178	1176	case 0x3F:   /* C03F - SOUNDADRH */
1179		gssnd_w(space, offset & 0x03, data);
	1177	gssnd_w(&space, offset & 0x03, data);
1180	1178	break;
1181	1179
1182	1180	case 0x41:   /* C041 - INTEN */
1183		state->m_inten = data & 0x1F;
1184		if ((state->m_inten & 0x10) == 0x00)
1185		apple2gs_remove_irq(space->machine(), IRQ_INTEN_QSECOND);
1186		if ((state->m_inten & 0x08) == 0x00)
1187		apple2gs_remove_irq(space->machine(), IRQ_INTEN_VBL);
	1181	m_inten = data & 0x1F;
	1182	if ((m_inten & 0x10) == 0x00)
	1183	apple2gs_remove_irq(space.machine(), IRQ_INTEN_QSECOND);
	1184	if ((m_inten & 0x08) == 0x00)
	1185	apple2gs_remove_irq(space.machine(), IRQ_INTEN_VBL);
1188	1186	break;
1189	1187
1190	1188	case 0x47:   /* C047 - CLRVBLINT */
1191		state->m_intflag &= ~0x18;
1192		apple2gs_remove_irq(space->machine(), IRQ_INTEN_QSECOND);
1193		apple2gs_remove_irq(space->machine(), IRQ_INTEN_VBL);
	1189	m_intflag &= ~0x18;
	1190	apple2gs_remove_irq(space.machine(), IRQ_INTEN_QSECOND);
	1191	apple2gs_remove_irq(space.machine(), IRQ_INTEN_VBL);
1194	1192	break;
1195	1193
1196	1194	case 0x68:   /* C068 - STATEREG */
1197		apple2_setvar(space->machine(),
	1195	apple2_setvar(space.machine(),
1198	1196	((data & 0x80) ? VAR_ALTZP : 0) |
1199	1197	((data & 0x40) ? VAR_PAGE2 : 0) |
1200	1198	((data & 0x20) ? VAR_RAMRD : 0) |
r15040	r15041
1208	1206	// slot 6 registers should go to applefdc if slot 6 not "Your Card"
1209	1207	case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7:
1210	1208	case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef:
1211		if ((state->m_sltromsel & (1 << 6)) == 0)
	1209	if ((m_sltromsel & (1 << 6)) == 0)
1212	1210	{
1213		applefdc_w(state->m_fdc, offset, data);
	1211	applefdc_w(m_fdc, offset, data);
1214	1212	}
1215	1213	else
1216	1214	{
1217		apple2_c0xx_w(space, offset, data);
	1215	apple2_c0xx_w(space, offset, data, 0);
1218	1216	}
1219	1217	break;
1220	1218
1221	1219	default:
1222	1220	if (offset < 0x80)
1223	1221	{
1224		apple2_c0xx_w(space, offset, data);
	1222	apple2_c0xx_w(space, offset, data, 0);
1225	1223	}
1226	1224	else
1227	1225	{
1228		apple2_c080_w(space, offset, data);
	1226	apple2_c080_w(space, offset, data, 0);
1229	1227	}
1230	1228	break;
1231	1229	}
r15040	r15041
1237	1235	* Memory management
1238	1236	* ----------------------------------------------------------------------- */
1239	1237
1240		static WRITE8_HANDLER( apple2gs_main0400_w )
	1238	WRITE8_MEMBER( apple2gs_state::apple2gs_main0400_w )
1241	1239	{
1242		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1243	1240	offset += 0x000400;
1244		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1241	m_rambase[offset] = data;
1245	1242
1246		if (!(state->m_shadow & 0x01))
	1243	if (!(m_shadow & 0x01))
1247	1244	{
1248		state->m_slowmem[offset] = data;
	1245	m_slowmem[offset] = data;
1249	1246	}
1250	1247	}
1251	1248
1252		static WRITE8_HANDLER( apple2gs_aux0400_w )
	1249	WRITE8_MEMBER( apple2gs_state::apple2gs_aux0400_w )
1253	1250	{
1254		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1255	1251	offset += 0x010400;
1256		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1252	m_rambase[offset] = data;
1257	1253
1258		if (!(state->m_shadow & 0x01))
	1254	if (!(m_shadow & 0x01))
1259	1255	{
1260		state->m_slowmem[offset] = data;
	1256	m_slowmem[offset] = data;
1261	1257	}
1262	1258	}
1263	1259
1264		static WRITE8_HANDLER( apple2gs_main2000_w )
	1260	WRITE8_MEMBER( apple2gs_state::apple2gs_main2000_w )
1265	1261	{
1266		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1267	1262	offset += 0x002000;
1268		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1263	m_rambase[offset] = data;
1269	1264
1270		if (!(state->m_shadow & 0x02))
	1265	if (!(m_shadow & 0x02))
1271	1266	{
1272		state->m_slowmem[offset] = data;
	1267	m_slowmem[offset] = data;
1273	1268	}
1274	1269	}
1275	1270
1276		static WRITE8_HANDLER( apple2gs_aux2000_w )
	1271	WRITE8_MEMBER( apple2gs_state::apple2gs_aux2000_w )
1277	1272	{
1278		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1279	1273	offset += 0x012000;
1280		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1274	m_rambase[offset] = data;
1281	1275
1282		if (!(state->m_shadow & 0x12) || !(state->m_shadow & 0x08))
	1276	if (!(m_shadow & 0x12) || !(m_shadow & 0x08))
1283	1277	{
1284		state->m_slowmem[offset] = data;
	1278	m_slowmem[offset] = data;
1285	1279	}
1286	1280	}
1287	1281
1288		static WRITE8_HANDLER( apple2gs_main4000_w )
	1282	WRITE8_MEMBER( apple2gs_state::apple2gs_main4000_w )
1289	1283	{
1290		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1291	1284	offset += 0x004000;
1292		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1285	m_rambase[offset] = data;
1293	1286
1294	1287	if ((offset >= 0x004000) && (offset <= 0x005FFF))
1295	1288	{
1296		if (!(state->m_shadow & 0x04))
1297		state->m_slowmem[offset] = data;
	1289	if (!(m_shadow & 0x04))
	1290	m_slowmem[offset] = data;
1298	1291	}
1299	1292	}
1300	1293
1301		static WRITE8_HANDLER( apple2gs_aux4000_w )
	1294	WRITE8_MEMBER( apple2gs_state::apple2gs_aux4000_w )
1302	1295	{
1303		apple2gs_state *state = space->machine().driver_data<apple2gs_state>();
1304	1296	offset += 0x014000;
1305		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1297	m_rambase[offset] = data;
1306	1298
1307	1299	if ((offset >= 0x014000) && (offset <= 0x015FFF))
1308	1300	{
1309		if (!(state->m_shadow & 0x14) || !(state->m_shadow & 0x08))
1310		state->m_slowmem[offset] = data;
	1301	if (!(m_shadow & 0x14) || !(m_shadow & 0x08))
	1302	m_slowmem[offset] = data;
1311	1303	}
1312	1304	else if ((offset >= 0x016000) && (offset <= 0x019FFF))
1313	1305	{
1314		if (!(state->m_shadow & 0x08))
	1306	if (!(m_shadow & 0x08))
1315	1307	{
1316		state->m_slowmem[offset] = data;
	1308	m_slowmem[offset] = data;
1317	1309
1318	1310	if (offset >= 0x19e00)
1319	1311	{
1320	1312	int color = (offset - 0x19e00) >> 1;
1321	1313
1322		palette_set_color_rgb(space->machine(), color + 16,
1323		((state->m_slowmem[0x19E00 + (color * 2) + 1] >> 0) & 0x0F) * 17,
1324		((state->m_slowmem[0x19E00 + (color * 2) + 0] >> 4) & 0x0F) * 17,
1325		((state->m_slowmem[0x19E00 + (color * 2) + 0] >> 0) & 0x0F) * 17);
	1314	palette_set_color_rgb(space.machine(), color + 16,
	1315	((m_slowmem[0x19E00 + (color * 2) + 1] >> 0) & 0x0F) * 17,
	1316	((m_slowmem[0x19E00 + (color * 2) + 0] >> 4) & 0x0F) * 17,
	1317	((m_slowmem[0x19E00 + (color * 2) + 0] >> 0) & 0x0F) * 17);
1326	1318	}
1327	1319	}
1328	1320	}
r15040	r15041
1332	1324
1333	1325	static void apple2gs_mem_000000(running_machine &machine,offs_t begin, offs_t end, apple2_meminfo *meminfo)
1334	1326	{
1335		apple2_state *state = machine.driver_data<apple2_state>();
	1327	apple2gs_state *state = machine.driver_data<apple2gs_state>();
1336	1328	meminfo->read_mem         = (state->m_flags & VAR_ALTZP)   ? 0x010000 : 0x000000;
1337	1329	meminfo->write_mem         = (state->m_flags & VAR_ALTZP)   ? 0x010000 : 0x000000;
1338	1330	}
1339	1331
1340	1332	static void apple2gs_mem_000200(running_machine &machine,offs_t begin, offs_t end, apple2_meminfo *meminfo)
1341	1333	{
1342		apple2_state *state = machine.driver_data<apple2_state>();
	1334	apple2gs_state *state = machine.driver_data<apple2gs_state>();
1343	1335	meminfo->read_mem         = (state->m_flags & VAR_RAMRD)   ? 0x010200 : 0x000200;
1344	1336	meminfo->write_mem         = (state->m_flags & VAR_RAMWRT)   ? 0x010200 : 0x000200;
1345	1337	}
1346	1338
1347	1339	static void apple2gs_mem_000400(running_machine &machine,offs_t begin, offs_t end, apple2_meminfo *meminfo)
1348	1340	{
1349		apple2_state *state = machine.driver_data<apple2_state>();
	1341	apple2gs_state *state = machine.driver_data<apple2gs_state>();
	1342	static write8_delegate write_delegates[] =
	1343	{
	1344	write8_delegate(FUNC(apple2gs_state::apple2gs_aux0400_w), state),
	1345	write8_delegate(FUNC(apple2gs_state::apple2gs_main0400_w), state)
	1346	};
	1347
1350	1348	if (state->m_flags & VAR_80STORE)
1351	1349	{
1352	1350	meminfo->read_mem      = (state->m_flags & VAR_PAGE2)   ? 0x010400 : 0x000400;
1353	1351	meminfo->write_mem      = (state->m_flags & VAR_PAGE2)   ? 0x010400 : 0x000400;
1354		meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? apple2gs_aux0400_w : apple2gs_main0400_w;
	1352	meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? &write_delegates[0] : &write_delegates[1];
1355	1353	}
1356	1354	else
1357	1355	{
1358	1356	meminfo->read_mem      = (state->m_flags & VAR_RAMRD)   ? 0x010400 : 0x000400;
1359	1357	meminfo->write_mem      = (state->m_flags & VAR_RAMWRT)   ? 0x010400 : 0x000400;
1360		meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? apple2gs_aux0400_w : apple2gs_main0400_w;
	1358	meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? &write_delegates[0] : &write_delegates[1];
1361	1359	}
1362	1360	}
1363	1361
1364	1362	static void apple2gs_mem_000800(running_machine &machine,offs_t begin, offs_t end, apple2_meminfo *meminfo)
1365	1363	{
1366		apple2_state *state = machine.driver_data<apple2_state>();
	1364	apple2gs_state *state = machine.driver_data<apple2gs_state>();
1367	1365	meminfo->read_mem         = (state->m_flags & VAR_RAMRD)   ? 0x010800 : 0x000800;
1368	1366	meminfo->write_mem         = (state->m_flags & VAR_RAMWRT)   ? 0x010800 : 0x000800;
1369	1367	}
1370	1368
1371	1369	static void apple2gs_mem_002000(running_machine &machine,offs_t begin, offs_t end, apple2_meminfo *meminfo)
1372	1370	{
1373		apple2_state *state = machine.driver_data<apple2_state>();
	1371	apple2gs_state *state = machine.driver_data<apple2gs_state>();
	1372	static write8_delegate write_delegates[] =
	1373	{
	1374	write8_delegate(FUNC(apple2gs_state::apple2gs_aux2000_w), state),
	1375	write8_delegate(FUNC(apple2gs_state::apple2gs_main2000_w), state)
	1376	};
1374	1377	if ((state->m_flags & (VAR_80STORE|VAR_HIRES)) == (VAR_80STORE|VAR_HIRES))
1375	1378	{
1376	1379	meminfo->read_mem      = (state->m_flags & VAR_PAGE2)   ? 0x012000 : 0x002000;
1377	1380	meminfo->write_mem      = (state->m_flags & VAR_PAGE2)   ? 0x012000 : 0x002000;
1378		meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? apple2gs_aux2000_w : apple2gs_main2000_w;
	1381	meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? &write_delegates[0] : &write_delegates[1];
1379	1382	}
1380	1383	else
1381	1384	{
1382	1385	meminfo->read_mem      = (state->m_flags & VAR_RAMRD)   ? 0x012000 : 0x002000;
1383	1386	meminfo->write_mem      = (state->m_flags & VAR_RAMWRT)   ? 0x012000 : 0x002000;
1384		meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? apple2gs_aux2000_w : apple2gs_main2000_w;
	1387	meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? &write_delegates[0] : &write_delegates[1];
1385	1388	}
1386	1389	}
1387	1390
1388	1391	static void apple2gs_mem_004000(running_machine &machine,offs_t begin, offs_t end, apple2_meminfo *meminfo)
1389	1392	{
1390		apple2_state *state = machine.driver_data<apple2_state>();
	1393	apple2gs_state *state = machine.driver_data<apple2gs_state>();
	1394	static write8_delegate write_delegates[] =
	1395	{
	1396	write8_delegate(FUNC(apple2gs_state::apple2gs_aux4000_w), state),
	1397	write8_delegate(FUNC(apple2gs_state::apple2gs_main4000_w), state)
	1398	};
1391	1399	meminfo->read_mem         = (state->m_flags & VAR_RAMRD)   ? 0x014000 : 0x004000;
1392		meminfo->write_handler      = (state->m_flags & VAR_RAMWRT)   ? apple2gs_aux4000_w : apple2gs_main4000_w;
	1400	meminfo->write_handler      = (state->m_flags & VAR_RAMWRT)   ? &write_delegates[0] : &write_delegates[1];
1393	1401	}
1394	1402
1395	1403	static void apple2gs_mem_xxD000(running_machine &machine,apple2_meminfo *meminfo, UINT32 lcmem)
1396	1404	{
1397		apple2_state *state = machine.driver_data<apple2_state>();
	1405	apple2gs_state *state = machine.driver_data<apple2gs_state>();
1398	1406	if (state->m_flags & VAR_LCRAM)
1399	1407	{
1400	1408	if (state->m_flags & VAR_LCRAM2)
r15040	r15041
1422	1430
1423	1431	static void apple2gs_mem_xxE000(running_machine &machine,apple2_meminfo *meminfo, UINT32 lcmem)
1424	1432	{
1425		apple2_state *state = machine.driver_data<apple2_state>();
	1433	apple2gs_state *state = machine.driver_data<apple2gs_state>();
1426	1434	if (state->m_flags & VAR_LCRAM)
1427	1435	meminfo->read_mem      = lcmem | 0x00E000;
1428	1436	else
r15040	r15041
1562	1570	}
1563	1571	else if ((address & 0x000F00) == 0x000000)   // accessing C0xx?
1564	1572	{
1565		result = apple2gs_c0xx_r(machine.device("maincpu")->memory().space(AS_PROGRAM), address);
	1573	result = state->apple2gs_c0xx_r(*machine.device("maincpu")->memory().space(AS_PROGRAM), address, 0);
1566	1574	}
1567	1575	else
1568	1576	{
r15040	r15041
1654	1662	}
1655	1663	else if ((address & 0x000F00) == 0x000000)
1656	1664	{
1657		apple2gs_c0xx_w(machine.device("maincpu")->memory().space(AS_PROGRAM), address, data);
	1665	state->apple2gs_c0xx_w(*machine.device("maincpu")->memory().space(AS_PROGRAM), address, data, 0);
1658	1666	}
1659	1667	else
1660	1668	{
r15040	r15041
1866	1874
1867	1875
1868	1876	/* install aux memory writes (for shadowing) */
1869		space->install_legacy_write_handler(0x010400, 0x0107FF, FUNC(apple2gs_aux0400_w));
1870		space->install_legacy_write_handler(0x012000, 0x013FFF, FUNC(apple2gs_aux2000_w));
1871		space->install_legacy_write_handler(0x014000, 0x019FFF, FUNC(apple2gs_aux4000_w));
	1877	space->install_write_handler(0x010400, 0x0107FF, write8_delegate(FUNC(apple2gs_state::apple2gs_aux0400_w), state));
	1878	space->install_write_handler(0x012000, 0x013FFF, write8_delegate(FUNC(apple2gs_state::apple2gs_aux2000_w), state));
	1879	space->install_write_handler(0x014000, 0x019FFF, write8_delegate(FUNC(apple2gs_state::apple2gs_aux4000_w), state));
1872	1880
1873	1881	/* setup the Apple II memory system */
1874	1882	memset(&cfg, 0, sizeof(cfg));

src/mess/machine/a2swyft.c

r15040	r15041
66	66
67	67	astring tempstring;
68	68	m_rom = device().machine().root_device().memregion(this->subtag(tempstring, SWYFT_ROM_REGION))->base();
	69
	70	save_item(NAME(m_rombank));
69	71	}
70	72
71	73	void a2bus_swyft_device::device_reset()

src/mess/machine/apple2.c

r15040	r15041
35	35	#define PROFILER_C08X   PROFILER_USER2
36	36	#define PROFILER_A2INT   PROFILER_USER2
37	37
38		/* softswitch */
39
40		/* before the softswitch is changed, these are applied */
41
42
43		/* local */
44
45
46		static WRITE8_HANDLER ( apple2_mainram0400_w );
47		static WRITE8_HANDLER ( apple2_mainram2000_w );
48		static WRITE8_HANDLER ( apple2_auxram0400_w );
49		static WRITE8_HANDLER ( apple2_auxram2000_w );
50
51		static READ8_HANDLER ( apple2_c1xx_r );
52		static WRITE8_HANDLER ( apple2_c1xx_w );
53		static READ8_HANDLER ( apple2_c3xx_r );
54		static WRITE8_HANDLER ( apple2_c3xx_w );
55		static READ8_HANDLER ( apple2_c4xx_r );
56		static WRITE8_HANDLER ( apple2_c4xx_w );
57
58		static READ8_HANDLER ( apple2_c800_r );
59		static WRITE8_HANDLER ( apple2_c800_w );
60		static READ8_HANDLER ( apple2_ce00_r );
61		static WRITE8_HANDLER ( apple2_ce00_w );
62
63		static READ8_HANDLER ( apple2_inh_d000_r );
64		static WRITE8_HANDLER ( apple2_inh_d000_w );
65		static READ8_HANDLER ( apple2_inh_e000_r );
66		static WRITE8_HANDLER ( apple2_inh_e000_w );
67
68	38	/* -----------------------------------------------------------------------
69	39	* New Apple II memory manager
70	40	* ----------------------------------------------------------------------- */
71	41
72
73
74		static READ8_HANDLER(read_floatingbus)
	42	READ8_MEMBER(apple2_state::read_floatingbus)
75	43	{
76		return apple2_getfloatingbusvalue(space->machine());
	44	return apple2_getfloatingbusvalue(space.machine());
77	45	}
78	46
79	47
r15040	r15041
96	64	char rbank[10], wbank[10];
97	65	int full_update = 0;
98	66	apple2_meminfo meminfo;
99		read8_space_func rh; const char *rh_name = NULL;
100		write8_space_func wh; const char *wh_name = NULL;
	67	read8_delegate *rh;
	68	write8_delegate *wh;
101	69	offs_t begin, end_r, end_w;
102	70	UINT8 *rbase, *wbase, *rom;
103	71	UINT32 rom_length, offset;
104	72	bank_disposition_t bank_disposition;
105	73	int wh_nop = 0;
	74	static read8_delegate read_delegates[] =
	75	{
	76	read8_delegate(FUNC(apple2_state::read_floatingbus), state),
	77	read8_delegate(FUNC(apple2_state::apple2_c1xx_r), state),
	78	read8_delegate(FUNC(apple2_state::apple2_c3xx_r), state),
	79	read8_delegate(FUNC(apple2_state::apple2_c4xx_r), state)
	80	};
	81	static write8_delegate write_delegates[] =
	82	{
	83	write8_delegate(FUNC(apple2_state::apple2_c1xx_w), state),
	84	write8_delegate(FUNC(apple2_state::apple2_c3xx_w), state),
	85	write8_delegate(FUNC(apple2_state::apple2_c4xx_w), state)
	86	};
106	87
107	88	/* need to build list of current info? */
108	89	if (!state->m_current_meminfo)
r15040	r15041
146	127	{
147	128	/* handler */
148	129	rh = meminfo.read_handler;
149		rh_name = meminfo.read_handler_name;
150	130	}
151	131	else if (meminfo.read_mem == APPLE2_MEM_FLOATING)
152	132	{
153	133	/* floating RAM */
154		rh = read_floatingbus;
155		rh_name = "read_floatingbus";
	134	rh = &read_delegates[0];
156	135	}
157	136	else if ((meminfo.read_mem & 0xC0000000) == APPLE2_MEM_AUX)
158	137	{
r15040	r15041
166	145	// slots 1-2
167	146	if ((meminfo.write_mem & APPLE2_MEM_MASK) == 0)
168	147	{
169		rh = apple2_c1xx_r;
170		rh_name = "apple2_c1xx_r";
	148	rh = &read_delegates[1];
171	149	}
172	150	else if ((meminfo.write_mem & APPLE2_MEM_MASK) == 0x200)
173	151	{   // slot 3
174		rh = apple2_c3xx_r;
175		rh_name = "apple2_c3xx_r";
	152	rh = &read_delegates[2];
176	153	}
177	154	else if ((meminfo.write_mem & APPLE2_MEM_MASK) == 0x300)
178	155	{   // slots 4-7
179		rh = apple2_c4xx_r;
180		rh_name = "apple2_c4xx_r";
	156	rh = &read_delegates[3];
181	157	}
182	158	else
183	159	{
r15040	r15041
203	179	/* install the actual handlers */
204	180	if (begin <= end_r) {
205	181	if (rh) {
206		space->install_legacy_read_handler(begin, end_r, rh, rh_name);
	182	space->install_read_handler(begin, end_r, *rh);
207	183	} else {
208	184	space->install_read_bank(begin, end_r, rbank);
209	185	}
r15040	r15041
246	222	{
247	223	/* handler */
248	224	wh = meminfo.write_handler;
249		wh_name = meminfo.write_handler_name;
250	225	}
251	226	else if ((meminfo.write_mem & 0xC0000000) == APPLE2_MEM_AUX)
252	227	{
r15040	r15041
262	237	// slots 1-2
263	238	if ((meminfo.write_mem & APPLE2_MEM_MASK) == 0)
264	239	{
265		wh = apple2_c1xx_w;
266		wh_name = "apple2_c1xx_w";
	240	wh = &write_delegates[0];
267	241	}
268	242	else if ((meminfo.write_mem & APPLE2_MEM_MASK) == 0x200)
269	243	{   // slot 3
270		wh = apple2_c3xx_w;
271		wh_name = "apple2_c3xx_w";
	244	wh = &write_delegates[1];
272	245	}
273	246	else if ((meminfo.write_mem & APPLE2_MEM_MASK) == 0x300)
274	247	{   // slots 4-7
275		wh = apple2_c4xx_w;
276		wh_name = "apple2_c4xx_w";
	248	wh = &write_delegates[2];
277	249	}
278	250	}
279	251	else if ((meminfo.write_mem & 0xC0000000) == APPLE2_MEM_ROM)
r15040	r15041
295	267	/* install the actual handlers */
296	268	if (begin <= end_w) {
297	269	if (wh) {
298		space->install_legacy_write_handler(begin, end_w, wh ,wh_name);
	270	space->install_write_handler(begin, end_w, *wh);
299	271	} else {
300	272	if (wh_nop) {
301	273	space->nop_write(begin, end_w);
r15040	r15041
336	308	* Apple II memory map
337	309	* ----------------------------------------------------------------------- */
338	310
339		READ8_HANDLER(apple2_c0xx_r)
	311	READ8_MEMBER(apple2_state::apple2_c0xx_r)
340	312	{
341		apple2_state *state = space->machine().driver_data<apple2_state>();
342		if(!space->debugger_access())
	313	if(!space.debugger_access())
343	314	{
344		static const read8_delegate handlers[] =
	315	static read8_delegate handlers[] =
345	316	{
346		read8_delegate(FUNC(apple2_state::apple2_c00x_r), state),
347		read8_delegate(FUNC(apple2_state::apple2_c01x_r), state),
348		read8_delegate(FUNC(apple2_state::apple2_c02x_r), state),
349		read8_delegate(FUNC(apple2_state::apple2_c03x_r), state),
350		read8_delegate(FUNC(apple2_state::apple2_c03x_r), state),   // not called here, handled elsewhere
351		read8_delegate(FUNC(apple2_state::apple2_c05x_r), state),
352		read8_delegate(FUNC(apple2_state::apple2_c06x_r), state),
353		read8_delegate(FUNC(apple2_state::apple2_c07x_r), state)
	317	read8_delegate(FUNC(apple2_state::apple2_c00x_r), this),
	318	read8_delegate(FUNC(apple2_state::apple2_c01x_r), this),
	319	read8_delegate(FUNC(apple2_state::apple2_c02x_r), this),
	320	read8_delegate(FUNC(apple2_state::apple2_c03x_r), this),
	321	read8_delegate(FUNC(apple2_state::apple2_c03x_r), this),   // not called here, handled elsewhere
	322	read8_delegate(FUNC(apple2_state::apple2_c05x_r), this),
	323	read8_delegate(FUNC(apple2_state::apple2_c06x_r), this),
	324	read8_delegate(FUNC(apple2_state::apple2_c07x_r), this)
354	325	};
355	326
356	327	offset &= 0x7F;
r15040	r15041
358	329	/* normal handler */
359	330	if (offset / 0x10 != 4)
360	331	{
361		return handlers[offset / 0x10](*space, offset % 0x10, 0);
	332	return handlers[offset / 0x10](space, offset % 0x10, 0);
362	333	}
363	334	}
364	335
r15040	r15041
367	338
368	339
369	340
370		WRITE8_HANDLER(apple2_c0xx_w)
	341	WRITE8_MEMBER(apple2_state::apple2_c0xx_w)
371	342	{
372		apple2_state *state = space->machine().driver_data<apple2_state>();
373		static const write8_delegate handlers[] =
	343	static write8_delegate handlers[] =
374	344	{
375		write8_delegate(FUNC(apple2_state::apple2_c00x_w), state),
376		write8_delegate(FUNC(apple2_state::apple2_c01x_w), state),
377		write8_delegate(FUNC(apple2_state::apple2_c02x_w), state),
378		write8_delegate(FUNC(apple2_state::apple2_c03x_w), state),
379		write8_delegate(FUNC(apple2_state::apple2_c03x_w), state),      // unused
380		write8_delegate(FUNC(apple2_state::apple2_c05x_w), state),
381		write8_delegate(FUNC(apple2_state::apple2_c05x_w), state),      // unused
382		write8_delegate(FUNC(apple2_state::apple2_c07x_w), state)
	345	write8_delegate(FUNC(apple2_state::apple2_c00x_w), this),
	346	write8_delegate(FUNC(apple2_state::apple2_c01x_w), this),
	347	write8_delegate(FUNC(apple2_state::apple2_c02x_w), this),
	348	write8_delegate(FUNC(apple2_state::apple2_c03x_w), this),
	349	write8_delegate(FUNC(apple2_state::apple2_c03x_w), this),      // unused
	350	write8_delegate(FUNC(apple2_state::apple2_c05x_w), this),
	351	write8_delegate(FUNC(apple2_state::apple2_c05x_w), this),      // unused
	352	write8_delegate(FUNC(apple2_state::apple2_c07x_w), this)
383	353	};
384	354
385	355	offset &= 0x7F;
r15040	r15041
387	357	/* normal handler */
388	358	if (((offset / 0x10) != 4) && (offset / 0x10) != 6)
389	359	{
390		handlers[offset / 0x10](*space, offset % 0x10, data, 0);
	360	handlers[offset / 0x10](space, offset % 0x10, data, 0);
391	361	}
392	362	}
393	363
394		READ8_HANDLER(apple2_c080_r)
	364	READ8_MEMBER(apple2_state::apple2_c080_r)
395	365	{
396		if(!space->debugger_access())
	366	if(!space.debugger_access())
397	367	{
398		apple2_state *state = space->machine().driver_data<apple2_state>();
399	368	device_a2bus_card_interface *slotdevice;
400	369
401	370	offset &= 0x7F;
402	371
403	372	/* now identify the device */
404		slotdevice = state->m_a2bus->get_a2bus_card(offset / 0x10);
	373	slotdevice = m_a2bus->get_a2bus_card(offset / 0x10);
405	374
406	375	/* and if we can, read from the slot */
407	376	if (slotdevice != NULL)
408	377	{
409		return slotdevice->read_c0nx(*space, offset % 0x10);
	378	return slotdevice->read_c0nx(space, offset % 0x10);
410	379	}
411	380	}
412	381
r15040	r15041
414	383	}
415	384
416	385
417		WRITE8_HANDLER(apple2_c080_w)
	386	WRITE8_MEMBER(apple2_state::apple2_c080_w)
418	387	{
419		apple2_state *state = space->machine().driver_data<apple2_state>();
420	388	device_a2bus_card_interface *slotdevice;
421	389
422	390	offset &= 0x7F;
423	391
424	392	/* now identify the device */
425		slotdevice = state->m_a2bus->get_a2bus_card(offset / 0x10);
	393	slotdevice = m_a2bus->get_a2bus_card(offset / 0x10);
426	394
427	395	/* and if we can, write to the slot */
428	396	if (slotdevice != NULL)
429	397	{
430		slotdevice->write_c0nx(*space, offset % 0x10, data);
	398	slotdevice->write_c0nx(space, offset % 0x10, data);
431	399	}
432	400	}
433	401
r15040	r15041
460	428	return apple2_getfloatingbusvalue(space.machine());
461	429	}
462	430
463		static READ8_HANDLER( apple2_c1xx_r )
	431	READ8_MEMBER(apple2_state::apple2_c1xx_r )
464	432	{
465		apple2_state *state = space->machine().driver_data<apple2_state>();
466	433	int slotnum;
467	434	device_a2bus_card_interface *slotdevice;
468	435
469	436	slotnum = ((offset>>8) & 0xf) + 1;
470		slotdevice = state->m_a2bus->get_a2bus_card(slotnum);
	437	slotdevice = m_a2bus->get_a2bus_card(slotnum);
471	438
472	439	if (slotdevice != NULL)
473	440	{
474	441	if (slotdevice->take_c800())
475	442	{
476	443	//          printf("c1xx_r: taking cnxx_slot to %d\n", slotnum);
477		state->m_a2_cnxx_slot = slotnum;
478		apple2_update_memory(space->machine());
	444	m_a2_cnxx_slot = slotnum;
	445	apple2_update_memory(space.machine());
479	446	}
480	447
481		return slotdevice->read_cnxx(*space, offset&0xff);
	448	return slotdevice->read_cnxx(space, offset&0xff);
482	449	}
483	450	else
484	451	{
485		return apple2_slotram_r(*space, slotnum, offset);
	452	return apple2_slotram_r(space, slotnum, offset);
486	453	}
487	454
488	455	// else fall through to floating bus
489		return apple2_getfloatingbusvalue(space->machine());
	456	return apple2_getfloatingbusvalue(space.machine());
490	457	}
491	458
492		static WRITE8_HANDLER ( apple2_c1xx_w )
	459	WRITE8_MEMBER(apple2_state::apple2_c1xx_w )
493	460	{
494	461	int slotnum;
495		apple2_state *state = space->machine().driver_data<apple2_state>();
496	462	device_a2bus_card_interface *slotdevice;
497	463	UINT8 *rom, *slot_ram;
498	464	UINT32 rom_length, slot_length;
499	465
500	466	// find slot_ram if any
501		rom = space->machine().root_device().memregion("maincpu")->base();
502		rom_length = space->machine().root_device().memregion("maincpu")->bytes() & ~0xFFF;
503		slot_length = state->memregion("maincpu")->bytes() - rom_length;
	467	rom = space.machine().root_device().memregion("maincpu")->base();
	468	rom_length = space.machine().root_device().memregion("maincpu")->bytes() & ~0xFFF;
	469	slot_length = memregion("maincpu")->bytes() - rom_length;
504	470	slot_ram = (slot_length > 0) ? &rom[rom_length] : NULL;
505	471
506	472	slotnum = ((offset>>8) & 0xf) + 1;
507	473
508		slotdevice = state->m_a2bus->get_a2bus_card(slotnum);
	474	slotdevice = m_a2bus->get_a2bus_card(slotnum);
509	475
510	476	if (slotdevice != NULL)
511	477	{
512		slotdevice->write_cnxx(*space, offset&0xff, data);
	478	slotdevice->write_cnxx(space, offset&0xff, data);
513	479	}
514	480	else
515	481	{
r15040	r15041
518	484	}
519	485	}
520	486
521		static READ8_HANDLER( apple2_c3xx_r )
	487	READ8_MEMBER(apple2_state::apple2_c3xx_r )
522	488	{
523		apple2_state *state = space->machine().driver_data<apple2_state>();
524	489	int slotnum;
525	490	device_a2bus_card_interface *slotdevice;
526	491
527	492	slotnum = 3;
528		slotdevice = state->m_a2bus->get_a2bus_card(slotnum);
	493	slotdevice = m_a2bus->get_a2bus_card(slotnum);
529	494
530	495	// is a card installed in this slot?
531	496	if (slotdevice != NULL)
r15040	r15041
533	498	if (slotdevice->take_c800())
534	499	{
535	500	//          printf("c3xx_r: taking cnxx_slot to %d\n", slotnum);
536		state->m_a2_cnxx_slot = slotnum;
537		apple2_update_memory(space->machine());
	501	m_a2_cnxx_slot = slotnum;
	502	apple2_update_memory(space.machine());
538	503	}
539		return slotdevice->read_cnxx(*space, offset&0xff);
	504	return slotdevice->read_cnxx(space, offset&0xff);
540	505	}
541	506	else
542	507	{
543		return apple2_slotram_r(*space, slotnum, offset);
	508	return apple2_slotram_r(space, slotnum, offset);
544	509	}
545	510
546	511	// else fall through to floating bus
547		return apple2_getfloatingbusvalue(space->machine());
	512	return apple2_getfloatingbusvalue(space.machine());
548	513	}
549	514
550		static WRITE8_HANDLER ( apple2_c3xx_w )
	515	WRITE8_MEMBER(apple2_state::apple2_c3xx_w )
551	516	{
552		apple2_state *state = space->machine().driver_data<apple2_state>();
553	517	int slotnum;
554	518	device_a2bus_card_interface *slotdevice;
555	519	UINT8 *rom, *slot_ram;
556	520	UINT32 rom_length, slot_length;
557	521
558	522	// find slot_ram if any
559		rom = space->machine().root_device().memregion("maincpu")->base();
560		rom_length = space->machine().root_device().memregion("maincpu")->bytes() & ~0xFFF;
561		slot_length = state->memregion("maincpu")->bytes() - rom_length;
	523	rom = space.machine().root_device().memregion("maincpu")->base();
	524	rom_length = space.machine().root_device().memregion("maincpu")->bytes() & ~0xFFF;
	525	slot_length = memregion("maincpu")->bytes() - rom_length;
562	526	slot_ram = (slot_length > 0) ? &rom[rom_length] : NULL;
563	527
564	528	slotnum = 3;
565		slotdevice = state->m_a2bus->get_a2bus_card(slotnum);
	529	slotdevice = m_a2bus->get_a2bus_card(slotnum);
566	530
567	531	if (slotdevice != NULL)
568	532	{
569	533	if (slotdevice->take_c800())
570	534	{
571	535	//          printf("c3xx_w: taking cnxx_slot to %d\n", slotnum);
572		state->m_a2_cnxx_slot = slotnum;
573		apple2_update_memory(space->machine());
	536	m_a2_cnxx_slot = slotnum;
	537	apple2_update_memory(space.machine());
574	538	}
575		slotdevice->write_cnxx(*space, offset&0xff, data);
	539	slotdevice->write_cnxx(space, offset&0xff, data);
576	540	}
577	541	else
578	542	{
r15040	r15041
581	545	}
582	546	}
583	547
584		static READ8_HANDLER( apple2_c4xx_r )
	548	READ8_MEMBER(apple2_state::apple2_c4xx_r )
585	549	{
586		apple2_state *state = space->machine().driver_data<apple2_state>();
587	550	int slotnum;
588	551	device_a2bus_card_interface *slotdevice;
589	552
590	553	slotnum = ((offset>>8) & 0xf) + 4;
591		slotdevice = state->m_a2bus->get_a2bus_card(slotnum);
	554	slotdevice = m_a2bus->get_a2bus_card(slotnum);
592	555
593	556	// is a card installed in this slot?
594	557	if (slotdevice != NULL)
r15040	r15041
596	559	if (slotdevice->take_c800())
597	560	{
598	561	//          printf("c4xx_r: taking cnxx_slot to %d\n", slotnum);
599		state->m_a2_cnxx_slot = slotnum;
600		apple2_update_memory(space->machine());
	562	m_a2_cnxx_slot = slotnum;
	563	apple2_update_memory(space.machine());
601	564	}
602		return slotdevice->read_cnxx(*space, offset&0xff);
	565	return slotdevice->read_cnxx(space, offset&0xff);
603	566	}
604	567	else
605	568	{
606		return apple2_slotram_r(*space, slotnum, offset);
	569	return apple2_slotram_r(space, slotnum, offset);
607	570	}
608	571
609	572	// else fall through to floating bus
610		return apple2_getfloatingbusvalue(space->machine());
	573	return apple2_getfloatingbusvalue(space.machine());
611	574	}
612	575
613		static WRITE8_HANDLER ( apple2_c4xx_w )
	576	WRITE8_MEMBER ( apple2_state::apple2_c4xx_w )
614	577	{
615		apple2_state *state = space->machine().driver_data<apple2_state>();
616	578	int slotnum;
617	579	device_a2bus_card_interface *slotdevice;
618	580	UINT8 *rom, *slot_ram;
619	581	UINT32 rom_length, slot_length;
620	582
621	583	// find slot_ram if any
622		rom = space->machine().root_device().memregion("maincpu")->base();
623		rom_length = space->machine().root_device().memregion("maincpu")->bytes() & ~0xFFF;
624		slot_length = state->memregion("maincpu")->bytes() - rom_length;
	584	rom = space.machine().root_device().memregion("maincpu")->base();
	585	rom_length = space.machine().root_device().memregion("maincpu")->bytes() & ~0xFFF;
	586	slot_length = memregion("maincpu")->bytes() - rom_length;
625	587	slot_ram = (slot_length > 0) ? &rom[rom_length] : NULL;
626	588
627	589	slotnum = ((offset>>8) & 0xf) + 4;
628		slotdevice = state->m_a2bus->get_a2bus_card(slotnum);
	590	slotdevice = m_a2bus->get_a2bus_card(slotnum);
629	591
630	592	if (slotdevice != NULL)
631	593	{
632	594	if (slotdevice->take_c800())
633	595	{
634	596	//          printf("c4xx_w: taking cnxx_slot to %d\n", slotnum);
635		state->m_a2_cnxx_slot = slotnum;
636		apple2_update_memory(space->machine());
	597	m_a2_cnxx_slot = slotnum;
	598	apple2_update_memory(space.machine());
637	599	}
638		slotdevice->write_cnxx(*space, offset&0xff, data);
	600	slotdevice->write_cnxx(space, offset&0xff, data);
639	601	}
640	602	else
641	603	{
r15040	r15041
644	606	}
645	607	}
646	608
647		static READ8_HANDLER(apple2_cfff_r)
	609	READ8_MEMBER(apple2_state::apple2_cfff_r)
648	610	{
649	611	// debugger guard
650		if (!space->debugger_access())
	612	if (!space.debugger_access())
651	613	{
652		apple2_state *state = space->machine().driver_data<apple2_state>();
653	614	//      printf("cfff_r: taking cnxx_slot to -1\n");
654		state->m_a2_cnxx_slot = -1;
655		apple2_update_memory(space->machine());
	615	m_a2_cnxx_slot = -1;
	616	apple2_update_memory(space.machine());
656	617	}
657	618
658		return apple2_getfloatingbusvalue(space->machine());
	619	return apple2_getfloatingbusvalue(space.machine());
659	620	}
660	621
661		static WRITE8_HANDLER(apple2_cfff_w)
	622	WRITE8_MEMBER(apple2_state::apple2_cfff_w)
662	623	{
663		if (!space->debugger_access())
	624	if (!space.debugger_access())
664	625	{
665		apple2_state *state = space->machine().driver_data<apple2_state>();
666	626	//      printf("cfff_w: taking cnxx_slot to -1\n");
667		state->m_a2_cnxx_slot = -1;
668		apple2_update_memory(space->machine());
	627	m_a2_cnxx_slot = -1;
	628	apple2_update_memory(space.machine());
669	629	}
670	630	}
671	631
672		static READ8_HANDLER ( apple2_c800_r )
	632	READ8_MEMBER(apple2_state::apple2_c800_r )
673	633	{
674		apple2_state *state = space->machine().driver_data<apple2_state>();
675	634	device_a2bus_card_interface *slotdevice;
676	635
677		slotdevice = state->m_a2bus->get_a2bus_card(state->m_a2_cnxx_slot);
	636	slotdevice = m_a2bus->get_a2bus_card(m_a2_cnxx_slot);
678	637
679	638	if (slotdevice != NULL)
680	639	{
681		return slotdevice->read_c800(*space, offset&0xfff);
	640	return slotdevice->read_c800(space, offset&0xfff);
682	641	}
683	642
684		return apple2_getfloatingbusvalue(space->machine());
	643	return apple2_getfloatingbusvalue(space.machine());
685	644	}
686	645
687		static WRITE8_HANDLER ( apple2_c800_w )
	646	WRITE8_MEMBER(apple2_state::apple2_c800_w )
688	647	{
689		apple2_state *state = space->machine().driver_data<apple2_state>();
690	648	device_a2bus_card_interface *slotdevice;
691	649
692		slotdevice = state->m_a2bus->get_a2bus_card(state->m_a2_cnxx_slot);
	650	slotdevice = m_a2bus->get_a2bus_card(m_a2_cnxx_slot);
693	651
694	652	if (slotdevice != NULL)
695	653	{
696		slotdevice->write_c800(*space, offset&0xfff, data);
	654	slotdevice->write_c800(space, offset&0xfff, data);
697	655	}
698	656	}
699	657
700		static READ8_HANDLER ( apple2_ce00_r )
	658	READ8_MEMBER(apple2_state::apple2_ce00_r )
701	659	{
702		apple2_state *state = space->machine().driver_data<apple2_state>();
703	660	device_a2bus_card_interface *slotdevice;
704	661
705		slotdevice = state->m_a2bus->get_a2bus_card(state->m_a2_cnxx_slot);
	662	slotdevice = m_a2bus->get_a2bus_card(m_a2_cnxx_slot);
706	663
707	664	if (slotdevice != NULL)
708	665	{
709		return slotdevice->read_c800(*space, (offset&0xfff) + 0x600);
	666	return slotdevice->read_c800(space, (offset&0xfff) + 0x600);
710	667	}
711	668
712		return apple2_getfloatingbusvalue(space->machine());
	669	return apple2_getfloatingbusvalue(space.machine());
713	670	}
714	671
715		static WRITE8_HANDLER ( apple2_ce00_w )
	672	WRITE8_MEMBER(apple2_state::apple2_ce00_w )
716	673	{
717		apple2_state *state = space->machine().driver_data<apple2_state>();
718	674	device_a2bus_card_interface *slotdevice;
719	675
720		slotdevice = state->m_a2bus->get_a2bus_card(state->m_a2_cnxx_slot);
	676	slotdevice = m_a2bus->get_a2bus_card(m_a2_cnxx_slot);
721	677
722	678	if (slotdevice != NULL)
723	679	{
724		slotdevice->write_c800(*space, (offset&0xfff)+0x600, data);
	680	slotdevice->write_c800(space, (offset&0xfff)+0x600, data);
725	681	}
726	682	}
727	683
728		static READ8_HANDLER ( apple2_inh_d000_r )
	684	READ8_MEMBER(apple2_state::apple2_inh_d000_r )
729	685	{
730		apple2_state *state = space->machine().driver_data<apple2_state>();
731	686	device_a2bus_card_interface *slotdevice;
732	687
733		slotdevice = state->m_a2bus->get_a2bus_card(state->m_inh_slot);
	688	slotdevice = m_a2bus->get_a2bus_card(m_inh_slot);
734	689
735	690	if (slotdevice != NULL)
736	691	{
737		return slotdevice->read_inh_rom(*space, offset & 0xfff);
	692	return slotdevice->read_inh_rom(space, offset & 0xfff);
738	693	}
739	694
740		return apple2_getfloatingbusvalue(space->machine());
	695	return apple2_getfloatingbusvalue(space.machine());
741	696	}
742	697
743		static WRITE8_HANDLER ( apple2_inh_d000_w )
	698	WRITE8_MEMBER(apple2_state::apple2_inh_d000_w )
744	699	{
745		apple2_state *state = space->machine().driver_data<apple2_state>();
746	700	device_a2bus_card_interface *slotdevice;
747	701
748		slotdevice = state->m_a2bus->get_a2bus_card(state->m_inh_slot);
	702	slotdevice = m_a2bus->get_a2bus_card(m_inh_slot);
749	703
750	704	if (slotdevice != NULL)
751	705	{
752		return slotdevice->write_inh_rom(*space, offset & 0xfff, data);
	706	return slotdevice->write_inh_rom(space, offset & 0xfff, data);
753	707	}
754	708	}
755	709
756		static READ8_HANDLER ( apple2_inh_e000_r )
	710	READ8_MEMBER(apple2_state::apple2_inh_e000_r )
757	711	{
758		apple2_state *state = space->machine().driver_data<apple2_state>();
759	712	device_a2bus_card_interface *slotdevice;
760	713
761		slotdevice = state->m_a2bus->get_a2bus_card(state->m_inh_slot);
	714	slotdevice = m_a2bus->get_a2bus_card(m_inh_slot);
762	715
763	716	if (slotdevice != NULL)
764	717	{
765		return slotdevice->read_inh_rom(*space, (offset & 0x1fff) + 0x1000);
	718	return slotdevice->read_inh_rom(space, (offset & 0x1fff) + 0x1000);
766	719	}
767	720
768		return apple2_getfloatingbusvalue(space->machine());
	721	return apple2_getfloatingbusvalue(space.machine());
769	722	}
770	723
771		static WRITE8_HANDLER ( apple2_inh_e000_w )
	724	WRITE8_MEMBER(apple2_state::apple2_inh_e000_w )
772	725	{
773		apple2_state *state = space->machine().driver_data<apple2_state>();
774	726	device_a2bus_card_interface *slotdevice;
775	727
776		slotdevice = state->m_a2bus->get_a2bus_card(state->m_inh_slot);
	728	slotdevice = m_a2bus->get_a2bus_card(m_inh_slot);
777	729
778	730	if (slotdevice != NULL)
779	731	{
780		slotdevice->write_inh_rom(*space, (offset & 0x1fff) + 0x1000, data);
	732	slotdevice->write_inh_rom(space, (offset & 0x1fff) + 0x1000, data);
781	733	}
782	734	}
783	735
r15040	r15041
798	750	static void apple2_mem_0400(running_machine &machine, offs_t begin, offs_t end, apple2_meminfo *meminfo)
799	751	{
800	752	apple2_state *state = machine.driver_data<apple2_state>();
	753	static write8_delegate write_delegates[] =
	754	{
	755	write8_delegate(FUNC(apple2_state::apple2_auxram0400_w), state),
	756	write8_delegate(FUNC(apple2_state::apple2_mainram0400_w), state)
	757	};
801	758	if (state->m_flags & VAR_80STORE)
802	759	{
803	760	meminfo->read_mem      = (state->m_flags & VAR_PAGE2)   ? 0x010400 : 0x000400;
804	761	meminfo->write_mem      = (state->m_flags & VAR_PAGE2)   ? 0x010400 : 0x000400;
805		meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? apple2_auxram0400_w : apple2_mainram0400_w;
	762	meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? &write_delegates[0] : &write_delegates[1];
806	763	}
807	764	else
808	765	{
809	766	meminfo->read_mem      = (state->m_flags & VAR_RAMRD)   ? 0x010400 : 0x000400;
810	767	meminfo->write_mem      = (state->m_flags & VAR_RAMWRT)   ? 0x010400 : 0x000400;
811		meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? apple2_auxram0400_w : apple2_mainram0400_w;
	768	meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? &write_delegates[0] : &write_delegates[1];
812	769	}
813	770	}
814	771
r15040	r15041
822	779	static void apple2_mem_2000(running_machine &machine, offs_t begin, offs_t end, apple2_meminfo *meminfo)
823	780	{
824	781	apple2_state *state = machine.driver_data<apple2_state>();
	782	static write8_delegate write_delegates[] =
	783	{
	784	write8_delegate(FUNC(apple2_state::apple2_auxram2000_w), state),
	785	write8_delegate(FUNC(apple2_state::apple2_mainram2000_w), state)
	786	};
825	787	if ((state->m_flags & (VAR_80STORE|VAR_HIRES)) == (VAR_80STORE|VAR_HIRES))
826	788	{
827	789	meminfo->read_mem      = (state->m_flags & VAR_PAGE2)   ? 0x012000 : 0x002000;
828	790	meminfo->write_mem      = (state->m_flags & VAR_PAGE2)   ? 0x012000 : 0x002000;
829		meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? apple2_auxram2000_w : apple2_mainram2000_w;
	791	meminfo->write_handler   = (state->m_flags & VAR_PAGE2)   ? &write_delegates[0] : &write_delegates[1];
830	792	}
831	793	else
832	794	{
833	795	meminfo->read_mem      = (state->m_flags & VAR_RAMRD)   ? 0x012000 : 0x002000;
834	796	meminfo->write_mem      = (state->m_flags & VAR_RAMWRT)   ? 0x012000 : 0x002000;
835		meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? apple2_auxram2000_w : apple2_mainram2000_w;
	797	meminfo->write_handler   = (state->m_flags & VAR_RAMWRT)   ? &write_delegates[0] : &write_delegates[1];
836	798	}
837	799	}
838	800
r15040	r15041
845	807
846	808	static void apple2_mem_C000(running_machine &machine, offs_t begin, offs_t end, apple2_meminfo *meminfo)
847	809	{
848		meminfo->read_handler = apple2_c0xx_r;
849		meminfo->write_handler = apple2_c0xx_w;
	810	apple2_state *state = machine.driver_data<apple2_state>();
	811	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_c0xx_r), state);
	812	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_c0xx_w), state);
	813
	814	meminfo->read_handler = &rd;
	815	meminfo->write_handler = &wd;
850	816	}
851	817
852	818	static void apple2_mem_C080(running_machine &machine, offs_t begin, offs_t end, apple2_meminfo *meminfo)
853	819	{
854		meminfo->read_handler = apple2_c080_r;
855		meminfo->write_handler = apple2_c080_w;
	820	apple2_state *state = machine.driver_data<apple2_state>();
	821	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_c080_r), state);
	822	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_c080_w), state);
	823
	824	meminfo->read_handler = &rd;
	825	meminfo->write_handler = &wd;
856	826	}
857	827
858	828	static void apple2_mem_CFFF(running_machine &machine, offs_t begin, offs_t end, apple2_meminfo *meminfo)
859	829	{
860		meminfo->read_handler = apple2_cfff_r;
861		meminfo->write_handler = apple2_cfff_w;
	830	apple2_state *state = machine.driver_data<apple2_state>();
	831	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_cfff_r), state);
	832	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_cfff_w), state);
	833
	834	meminfo->read_handler = &rd;
	835	meminfo->write_handler = &wd;
862	836	}
863	837
864	838	static void apple2_mem_Cx00(running_machine &machine, offs_t begin, offs_t end, apple2_meminfo *meminfo)
r15040	r15041
901	875	}
902	876	else
903	877	{
904		meminfo->read_handler = apple2_c800_r;
905		meminfo->write_handler = apple2_c800_w;
	878	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_c800_r), state);
	879	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_c800_w), state);
	880
	881	meminfo->read_handler = &rd;
	882	meminfo->write_handler = &wd;
906	883	}
907	884	}
908	885
r15040	r15041
923	900	}
924	901	else
925	902	{
926		meminfo->read_handler = apple2_ce00_r;
927		meminfo->write_handler = apple2_ce00_w;
	903	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_ce00_r), state);
	904	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_ce00_w), state);
	905
	906	meminfo->read_handler = &rd;
	907	meminfo->write_handler = &wd;
928	908	}
929	909	}
930	910	}
r15040	r15041
962	942	}
963	943	else
964	944	{
965		meminfo->read_handler = apple2_inh_d000_r;
966		meminfo->write_handler = apple2_inh_d000_w;
	945	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_inh_d000_r), state);
	946	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_inh_d000_w), state);
	947
	948	meminfo->read_handler = &rd;
	949	meminfo->write_handler = &wd;
967	950	}
968	951	}
969	952
r15040	r15041
994	977	}
995	978	else
996	979	{
997		meminfo->read_handler = apple2_inh_e000_r;
998		meminfo->write_handler = apple2_inh_e000_w;
	980	static read8_delegate rd = read8_delegate(FUNC(apple2_state::apple2_inh_e000_r), state);
	981	static write8_delegate wd = write8_delegate(FUNC(apple2_state::apple2_inh_e000_w), state);
	982
	983	meminfo->read_handler = &rd;
	984	meminfo->write_handler = &wd;
999	985	}
1000	986	}
1001	987
r15040	r15041
1207	1193	apple2_state *state = machine.driver_data<apple2_state>();
1208	1194	int need_intcxrom;
1209	1195
	1196	state->m_rambase = state->m_ram->pointer();
	1197
1210	1198	need_intcxrom = !strcmp(machine.system().name, "apple2c")
1211	1199	|| !strcmp(machine.system().name, "apple2c0")
1212	1200	|| !strcmp(machine.system().name, "apple2c3")
r15040	r15041
1253	1241	apple2_auxram2000_w
1254	1242	***************************************************************************/
1255	1243
1256		static WRITE8_HANDLER ( apple2_mainram0400_w )
	1244	WRITE8_MEMBER ( apple2_state::apple2_mainram0400_w )
1257	1245	{
1258	1246	offset += 0x400;
1259		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1247	m_rambase[offset] = data;
1260	1248	}
1261	1249
1262		static WRITE8_HANDLER ( apple2_mainram2000_w )
	1250	WRITE8_MEMBER ( apple2_state::apple2_mainram2000_w )
1263	1251	{
1264	1252	offset += 0x2000;
1265		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1253	m_rambase[offset] = data;
1266	1254	}
1267	1255
1268		static WRITE8_HANDLER ( apple2_auxram0400_w )
	1256	WRITE8_MEMBER ( apple2_state::apple2_auxram0400_w )
1269	1257	{
1270	1258	offset += 0x10400;
1271		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1259	m_rambase[offset] = data;
1272	1260	}
1273	1261
1274		static WRITE8_HANDLER ( apple2_auxram2000_w )
	1262	WRITE8_MEMBER ( apple2_state::apple2_auxram2000_w )
1275	1263	{
1276	1264	offset += 0x12000;
1277		space->machine().device<ram_device>(RAM_TAG)->pointer()[offset] = data;
	1265	m_rambase[offset] = data;
1278	1266	}
1279	1267
1280	1268

src/mess/includes/apple2gs.h

r15040	r15041
117	117	UINT8 m_echo_bank;
118	118
119	119	DECLARE_DIRECT_UPDATE_MEMBER(apple2gs_opbase);
	120
	121	READ8_MEMBER( apple2gs_c0xx_r );
	122	WRITE8_MEMBER( apple2gs_c0xx_w );
	123	WRITE8_MEMBER( apple2gs_main0400_w );
	124	WRITE8_MEMBER( apple2gs_aux0400_w );
	125	WRITE8_MEMBER( apple2gs_main2000_w );
	126	WRITE8_MEMBER( apple2gs_aux2000_w );
	127	WRITE8_MEMBER( apple2gs_main4000_w );
	128	WRITE8_MEMBER( apple2gs_aux4000_w );
	129
	130	UINT8 adb_read_datareg();
	131	UINT8 adb_read_kmstatus();
120	132	};
121	133
122	134

src/mess/includes/apple2.h

r15040	r15041
80	80	struct _apple2_meminfo
81	81	{
82	82	UINT32 read_mem;
83		read8_space_func read_handler;
84		const char *read_handler_name;
	83	read8_delegate *read_handler;
85	84	UINT32 write_mem;
86		write8_space_func write_handler;
87		const char *write_handler_name;
	85	write8_delegate *write_handler;
88	86	};
89	87
90	88	typedef struct _apple2_memmap_entry apple2_memmap_entry;
r15040	r15041
153	151	bool m_monochrome_dhr;
154	152	int m_inh_slot;
155	153
	154	UINT8 *m_rambase;
	155
	156	READ8_MEMBER(apple2_c0xx_r);
	157	WRITE8_MEMBER(apple2_c0xx_w);
	158	READ8_MEMBER(apple2_c080_r);
	159	WRITE8_MEMBER(apple2_c080_w);
	160
156	161	READ8_MEMBER ( apple2_c00x_r );
157	162	READ8_MEMBER ( apple2_c01x_r );
158	163	READ8_MEMBER ( apple2_c02x_r );
r15040	r15041
166	171	WRITE8_MEMBER ( apple2_c03x_w );
167	172	WRITE8_MEMBER ( apple2_c05x_w );
168	173	WRITE8_MEMBER ( apple2_c07x_w );
	174
	175	WRITE8_MEMBER ( apple2_mainram0400_w );
	176	WRITE8_MEMBER ( apple2_mainram2000_w );
	177	WRITE8_MEMBER ( apple2_auxram0400_w );
	178	WRITE8_MEMBER ( apple2_auxram2000_w );
	179
	180	READ8_MEMBER ( apple2_c1xx_r );
	181	WRITE8_MEMBER ( apple2_c1xx_w );
	182	READ8_MEMBER ( apple2_c3xx_r );
	183	WRITE8_MEMBER ( apple2_c3xx_w );
	184	READ8_MEMBER ( apple2_c4xx_r );
	185	WRITE8_MEMBER ( apple2_c4xx_w );
	186
	187	READ8_MEMBER ( apple2_c800_r );
	188	WRITE8_MEMBER ( apple2_c800_w );
	189	READ8_MEMBER ( apple2_ce00_r );
	190	WRITE8_MEMBER ( apple2_ce00_w );
	191
	192	READ8_MEMBER ( apple2_inh_d000_r );
	193	WRITE8_MEMBER ( apple2_inh_d000_w );
	194	READ8_MEMBER ( apple2_inh_e000_r );
	195	WRITE8_MEMBER ( apple2_inh_e000_w );
	196
	197	READ8_MEMBER(read_floatingbus);
	198
	199	READ8_MEMBER(apple2_cfff_r);
	200	WRITE8_MEMBER(apple2_cfff_w);
	201
169	202	};
170	203
171	204

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team