Previous

15994 Revisions

Next

r9405 Sunday 17th October, 2010 at 18:52:25 UTC by R. Belmont
[MAC] CLeanups, greatly improved V8-type support (LC2, Classic II both stick on Egret now), improved LC III support, and improved ASC FIFO mode (SoundTrecker plays recognizable MODs now & several games sounded OK).

[src/emu/sound]	asc.c asc.h
[src/mess/audio]	mac.c
[src/mess/drivers]	mac.c
[src/mess/includes]	mac.h
[src/mess/machine]	mac.c
[src/mess/video]	mac.c

src/emu/sound/asc.c

r9404	r9405
4	4
5	5	Apple Sound Chip (ASC) 344S0063
6	6	Enhanced Apple Sound Chip (EASC) 343S1063
7
	7
8	8	Emulation by R. Belmont
9	9
10	10	Registers:
r9404	r9405
18	18	0x807: CLOCK RATE (0 = Mac 22257 Hz, 1 = undefined, 2 = 22050 Hz, 3 = 44100 Hz)
19	19	0x80a: PLAY REC A
20	20	0x80f: TEST (bits 6-7 = digital test, bits 4-5 = analog test)
21		0x810: WAVETABLE 0 PHASE (big-endian 8.16 fixed-point, only 24 bits valid)
22		0x814: WAVETABLE 0 INCREMENT (big-endian 8.16 fixed-point, only 24 bits valid)
	21	0x810: WAVETABLE 0 PHASE (big-endian 9.15 fixed-point, only 24 bits valid)
	22	0x814: WAVETABLE 0 INCREMENT (big-endian 9.15 fixed-point, only 24 bits valid)
23	23	0x818: WAVETABLE 1 PHASE
24	24	0x81C: WAVETABLE 1 INCREMENT
25	25	0x820: WAVETABLE 2 PHASE
r9404	r9405
141	141	memset(m_fifo_b, 0, sizeof(m_fifo_b));
142	142	memset(m_phase, 0, sizeof(m_phase));
143	143	memset(m_incr, 0, sizeof(m_incr));
144		memset(m_fifo_a_wrhalf, 0, sizeof(m_fifo_a_wrhalf));
145		memset(m_fifo_b_wrhalf, 0, sizeof(m_fifo_b_wrhalf));
146	144
147	145	m_fifo_a_rdptr = m_fifo_b_rdptr = 0;
148	146	m_fifo_a_wrptr = m_fifo_b_wrptr = 0;
	147	m_fifo_cap_a = m_fifo_cap_b = 0;
149	148	}
150	149
151	150	//-------------------------------------------------
r9404	r9405
161	160	void asc_device::stream_generate(stream_sample_t **inputs, stream_sample_t **outputs, int samples)
162	161	{
163	162	stream_sample_t *outL, *outR;
164		int i, ch, halt = 0;
	163	int i, ch;
165	164	static UINT32 wtoffs[2] = { 0, 0x200 };
166	165
167	166	outL = outputs[0];
r9404	r9405
177	176	break;
178	177
179	178	case 1:   // FIFO mode
180		if ((m_fifo_a_rdptr == 0) && (!m_fifo_a_wrhalf[0]))
181		{
182		halt = 1;
183		}
184		else if ((m_fifo_a_rdptr == 0x200) && (!m_fifo_a_wrhalf[1]))
185		{
186		halt = 1;
187		}
188
189	179	for (i = 0; i < samples; i++)
190	180	{
191	181	INT8 smpll, smplr;
192	182
193		if (m_fifo_a_rdptr < 0x200)
	183	smpll = (INT8)m_fifo_a[m_fifo_a_rdptr]^0x80;
	184	smplr = (INT8)m_fifo_b[m_fifo_b_rdptr]^0x80;
	185
	186	// don't advance the sample pointer if there are no more samples
	187	if (m_fifo_cap_a)
194	188	{
195		m_fifo_a_wrhalf[0] = 0;
196		m_fifo_b_wrhalf[0] = 0;
	189	m_fifo_a_rdptr++;
	190	m_fifo_a_rdptr &= 0x3ff;
	191	m_fifo_cap_a--;
197	192	}
198		else
	193
	194	if (m_fifo_cap_b)
199	195	{
200		m_fifo_a_wrhalf[1] = 0;
201		m_fifo_b_wrhalf[1] = 0;
	196	m_fifo_b_rdptr++;
	197	m_fifo_b_rdptr &= 0x3ff;
	198	m_fifo_cap_b--;
202	199	}
203	200
204		smpll = (INT8)m_fifo_a[m_fifo_a_rdptr++]^0x80;
205		smplr = (INT8)m_fifo_b[m_fifo_b_rdptr++]^0x80;
206
207		if ((m_fifo_a_rdptr == 0x200) || (m_fifo_a_rdptr == 0x400))
	201	switch (m_chip_type)
208	202	{
209		m_regs[R_FIFOSTAT-0x800] |= 1;   // fifo A half-empty
210		if (m_irq_cb)
211		{
212		m_irq_cb(this, 1);
213		}
214		}
	203	case ASC_TYPE_SONORA:
	204	if (m_fifo_cap_a <= 0x200)
	205	{
	206	m_regs[R_FIFOSTAT-0x800] |= 0x4;   // fifo less than half full
	207	m_regs[R_FIFOSTAT-0x800] |= 0x8;   // just pass the damn test
	208	if (m_irq_cb)
	209	{
	210	m_irq_cb(this, 1);
	211	}
	212	}
	213	break;
215	214
216		if ((m_fifo_b_rdptr == 0x200) || (m_fifo_b_rdptr == 0x400))
217		{
218		m_regs[R_FIFOSTAT-0x800] |= 4;   // fifo B half-empty
219		if (m_irq_cb)
220		{
221		m_irq_cb(this, 1);
222		}
	215	default:
	216	if (m_fifo_cap_a <= 0x200)
	217	{
	218	m_regs[R_FIFOSTAT-0x800] |= 1;   // fifo A half-empty
	219	if (m_irq_cb)
	220	{
	221	m_irq_cb(this, 1);
	222	}
	223	}
	224
	225	// don't update for non-(E)ASC
	226	if (m_fifo_cap_b <= 0x200)
	227	{
	228	m_regs[R_FIFOSTAT-0x800] |= 4;   // fifo B half-empty
	229	if (m_irq_cb)
	230	{
	231	m_irq_cb(this, 1);
	232	}
	233	}
	234	break;
223	235	}
224	236
225		m_fifo_a_rdptr &= 0x3ff;
226		m_fifo_b_rdptr &= 0x3ff;
227
228	237	outL[i] = smpll * 64;
229	238	outR[i] = smplr * 64;
230	239	}
231
232		if (halt)
233		{
234		//              m_regs[R_MODE-0x800] = 0;
235		}
236	240	break;
237	241
238	242	case 2: // wavetable mode
r9404	r9405
242	246	INT8 smpl;
243	247
244	248	mixL = mixR = 0;
245
	249
246	250	// update channel pointers
247	251	for (ch = 0; ch < 4; ch++)
248	252	{
r9404	r9405
250	254
251	255	if (ch < 2)
252	256	{
253		smpl = (INT8)m_fifo_a[((m_phase[ch]>>16)&0x1ff) + wtoffs[ch&1]];
	257	smpl = (INT8)m_fifo_a[((m_phase[ch]>>15)&0x1ff) + wtoffs[ch&1]];
254	258	}
255	259	else
256	260	{
257		smpl = (INT8)m_fifo_b[((m_phase[ch]>>16)&0x1ff) + wtoffs[ch&1]];
	261	smpl = (INT8)m_fifo_b[((m_phase[ch]>>15)&0x1ff) + wtoffs[ch&1]];
258	262	}
259	263
260	264	smpl ^= 0x80;
r9404	r9405
277	281	{
278	282	UINT8 rv;
279	283
280		//  printf("ASC: read at %x\n", offset);
	284	//   printf("ASC: read at %x\n", offset);
281	285
282	286	// not sure what actually happens when the CPU reads the FIFO...
283	287	if (offset < 0x400)
r9404	r9405
409	413
410	414	void asc_device::write(UINT16 offset, UINT8 data)
411	415	{
412		//  printf("ASC: write %02x to %x\n", data, offset);
	416	//   printf("ASC: write %02x to %x\n", data, offset);
413	417
414	418	if (offset < 0x400)
415	419	{
416	420	if (m_regs[R_MODE-0x800] == 1)
417	421	{
418		if (m_fifo_a_wrptr < 0x400)
419		{
420		m_fifo_a_wrhalf[0] = 1;
421		}
422		else
423		{
424		m_fifo_a_wrhalf[1] = 1;
425		}
426
427	422	m_fifo_a[m_fifo_a_wrptr++] = data;
	423	m_fifo_cap_a++;
428	424
429		if ((m_fifo_a_wrptr == 0x200) || (m_fifo_a_wrptr == 0x400))
	425	if (m_fifo_cap_a == 0x800)
430	426	{
431		m_regs[R_FIFOSTAT-0x800] |= 2;   // fifo A half-full
432		if (m_irq_cb)
433		{
434		m_irq_cb(this, 1);
435		}
	427	m_regs[R_FIFOSTAT-0x800] |= 2;   // fifo A full
436	428	}
437	429
438	430	m_fifo_a_wrptr &= 0x3ff;
r9404	r9405
446	438	{
447	439	if (m_regs[R_MODE-0x800] == 1)
448	440	{
449		if (m_fifo_b_wrptr < 0x400)
450		{
451		m_fifo_b_wrhalf[0] = 1;
452		}
453		else
454		{
455		m_fifo_b_wrhalf[1] = 1;
456		}
457
458	441	m_fifo_b[m_fifo_b_wrptr++] = data;
	442	m_fifo_cap_b++;
459	443
460		if ((m_fifo_a_wrptr == 0x200) || (m_fifo_a_wrptr == 0x400))
	444	if (m_fifo_cap_b == 0x800)
461	445	{
462		m_regs[R_FIFOSTAT-0x800] |= 8;   // fifo B half-full
463		if (m_irq_cb)
464		{
465		m_irq_cb(this, 1);
466		}
	446	m_regs[R_FIFOSTAT-0x800] |= 8;   // fifo B full
467	447	}
468	448
469	449	m_fifo_b_wrptr &= 0x3ff;
470		}
	450	}
471	451	else
472	452	{
473	453	m_fifo_b[offset-0x400] = data;
r9404	r9405
475	455	}
476	456	else
477	457	{
478		//      printf("ASC: %02x to %x (was %x)\n", data, offset, m_regs[offset-0x800]);
	458	//      printf("ASC: %02x to %x (was %x)\n", data, offset, m_regs[offset-0x800]);
479	459
480	460	stream_update(m_stream);
481	461	switch (offset)
r9404	r9405
483	463	case R_MODE:
484	464	data &= 3;   // only bits 0 and 1 can be written
485	465
486		memset(m_fifo_a_wrhalf, 0, sizeof(m_fifo_a_wrhalf));
487		memset(m_fifo_b_wrhalf, 0, sizeof(m_fifo_b_wrhalf));
	466	if (data != m_regs[R_MODE-0x800])
	467	{
	468	m_fifo_a_rdptr = m_fifo_b_rdptr = 0;
	469	m_fifo_a_wrptr = m_fifo_b_wrptr = 0;
	470	m_fifo_cap_a = m_fifo_cap_b = 0;
	471	}
	472	break;
488	473
489		m_fifo_a_rdptr = m_fifo_b_rdptr = 0;
490		m_fifo_a_wrptr = m_fifo_b_wrptr = 0;
	474	case R_FIFOMODE:
	475	if (data & 0x80)
	476	{
	477	m_fifo_a_rdptr = m_fifo_b_rdptr = 0;
	478	m_fifo_a_wrptr = m_fifo_b_wrptr = 0;
	479	m_fifo_cap_a = m_fifo_cap_b = 0;
	480	}
491	481	break;
492	482
493	483	case R_WTCONTROL:
494		//              printf("One-shot wavetable %02x\n", data);
	484	//            printf("One-shot wavetable %02x\n", data);
495	485	break;
496	486
497		case 0x811:
	487	case 0x811:
498	488	m_phase[0] &= 0x00ffff;
499	489	m_phase[0] |= data<<16;
500	490	break;
r9404	r9405
509	499	m_phase[0] |= data;
510	500	break;
511	501
512		case 0x815:
	502	case 0x815:
513	503	m_incr[0] &= 0x00ffff;
514	504	m_incr[0] |= data<<16;
515	505	break;
r9404	r9405
524	514	m_incr[0] |= data;
525	515	break;
526	516
527		case 0x819:
	517	case 0x819:
528	518	m_phase[1] &= 0x00ffff;
529	519	m_phase[1] |= data<<16;
530	520	break;
r9404	r9405
539	529	m_phase[1] |= data;
540	530	break;
541	531
542		case 0x81d:
	532	case 0x81d:
543	533	m_incr[1] &= 0x00ffff;
544	534	m_incr[1] |= data<<16;
545	535	break;
r9404	r9405
554	544	m_incr[1] |= data;
555	545	break;
556	546
557		case 0x821:
	547	case 0x821:
558	548	m_phase[2] &= 0x00ffff;
559	549	m_phase[2] |= data<<16;
560	550	break;
r9404	r9405
569	559	m_phase[2] |= data;
570	560	break;
571	561
572		case 0x825:
	562	case 0x825:
573	563	m_incr[2] &= 0x00ffff;
574	564	m_incr[2] |= data<<16;
575	565	break;
r9404	r9405
584	574	m_incr[2] |= data;
585	575	break;
586	576
587		case 0x829:
	577	case 0x829:
588	578	m_phase[3] &= 0x00ffff;
589	579	m_phase[3] |= data<<16;
590	580	break;
r9404	r9405
599	589	m_phase[3] |= data;
600	590	break;
601	591
602		case 0x82d:
	592	case 0x82d:
603	593	m_incr[3] &= 0x00ffff;
604	594	m_incr[3] |= data<<16;
605	595	break;

src/emu/sound/asc.h

r9404	r9405
138	138	UINT8   m_fifo_a[0x400];
139	139	UINT8   m_fifo_b[0x400];
140	140
141		UINT8   m_regs[0x100];
	141	UINT8   m_regs[0x800];
142	142
143	143	UINT32   m_phase[4], m_incr[4];
144	144
145	145	int   m_fifo_a_rdptr, m_fifo_b_rdptr;
146	146	int   m_fifo_a_wrptr, m_fifo_b_wrptr;
147		int   m_fifo_a_wrhalf[2], m_fifo_b_wrhalf[2];
	147	int    m_fifo_cap_a, m_fifo_cap_b;
148	148	};
149	149
150	150

src/mess/audio/mac.c

r9404	r9405
70	70	mac_sound *token = get_token(device);
71	71	mac_state *mac = device->machine->driver_data<mac_state>();
72	72
73		if ((mac->mac_model == MODEL_MAC_PORTABLE) || (mac->mac_model == MODEL_MAC_PB100))
	73	if ((mac->model == MODEL_MAC_PORTABLE) || (mac->model == MODEL_MAC_PB100))
74	74	{
75	75	memset(buffer, 0, samples * sizeof(*buffer));
76	76	return;

src/mess/machine/mac.c

r9404	r9405
78	78	#include "devices/messram.h"
79	79	#include "debugger.h"
80	80
81		#define ADB_IS_BITBANG   ((mac->mac_model == MODEL_MAC_SE || mac->mac_model == MODEL_MAC_CLASSIC) || (mac->mac_model >= MODEL_MAC_II && mac->mac_model <= MODEL_MAC_IICI) || (mac->mac_model == MODEL_MAC_SE30))
82		#define ADB_IS_EGRET   (mac->mac_model >= MODEL_MAC_LC && mac->mac_model <= MODEL_MAC_COLOR_CLASSIC) || ((mac->mac_model >= MODEL_MAC_IISI) && (mac->mac_model <= MODEL_MAC_IIVI))
83		#define ADB_IS_PM   (mac->mac_model >= MODEL_MAC_PORTABLE && mac->mac_model <= MODEL_MAC_PB100)
	81	#define ADB_IS_BITBANG   ((mac->model == MODEL_MAC_SE || mac->model == MODEL_MAC_CLASSIC) || (mac->model >= MODEL_MAC_II && mac->model <= MODEL_MAC_IICI) || (mac->model == MODEL_MAC_SE30))
	82	#define ADB_IS_EGRET   (mac->model >= MODEL_MAC_LC && mac->model <= MODEL_MAC_COLOR_CLASSIC) || ((mac->model >= MODEL_MAC_IISI) && (mac->model <= MODEL_MAC_IIVI))
	83	#define ADB_IS_PM   (mac->model >= MODEL_MAC_PORTABLE && mac->model <= MODEL_MAC_PB100)
84	84
85		#define AUDIO_IS_CLASSIC (mac->mac_model < MODEL_MAC_II) && (mac->mac_model != MODEL_MAC_PORTABLE) && (mac->mac_model != MODEL_MAC_PB100)
86		#define MAC_HAS_VIA2   (mac->mac_model >= MODEL_MAC_II)
	85	#define AUDIO_IS_CLASSIC (mac->model < MODEL_MAC_II) && (mac->model != MODEL_MAC_PORTABLE) && (mac->model != MODEL_MAC_PB100)
	86	#define MAC_HAS_VIA2   (mac->model >= MODEL_MAC_II)
87	87
88		#define ASC_INTS_RBV   ((mac->mac_model >= MODEL_MAC_IICI) && (mac->mac_model <= MODEL_MAC_IIVI)) || ((mac->mac_model >= MODEL_MAC_LC) && (mac->mac_model <= MODEL_MAC_COLOR_CLASSIC))
	88	#define ASC_INTS_RBV   ((mac->model >= MODEL_MAC_IICI) && (mac->model <= MODEL_MAC_IIVI)) || ((mac->model >= MODEL_MAC_LC) && (mac->model <= MODEL_MAC_COLOR_CLASSIC))
89	89
90	90	#ifdef MAME_DEBUG
91	91	#define LOG_VIA         0
r9404	r9405
176	176	// returns non-zero if this Mac has ADB
177	177	static int has_adb(mac_state *mac)
178	178	{
179		return mac->mac_model >= MODEL_MAC_SE;
	179	return mac->model >= MODEL_MAC_SE;
180	180	}
181	181
182	182	// handle disk enable lines
r9404	r9405
184	184	{
185	185	mac_state *mac = device->machine->driver_data<mac_state>();
186	186
187		if (mac->mac_model != MODEL_MAC_SE)
	187	if (mac->model != MODEL_MAC_SE)
188	188	{
189	189	sony_set_enable_lines(device,enable_mask);
190	190	}
r9404	r9405
192	192	{
193	193	if (enable_mask)
194	194	{
195		sony_set_enable_lines(device,mac->mac_drive_select ? 1 : 2);
	195	sony_set_enable_lines(device,mac->drive_select ? 1 : 2);
196	196	}
197	197	else
198	198	{
r9404	r9405
243	243
244	244	int take_interrupt = -1;
245	245
246		if (mac->mac_model < MODEL_MAC_II)
	246	if (mac->model < MODEL_MAC_II)
247	247	{
248	248	if ((scc_interrupt) || (scsi_interrupt))
249	249	{
r9404	r9405
254	254	take_interrupt = 1;
255	255	}
256	256	}
257		else if (mac->mac_model < MODEL_MAC_POWERMAC_6100)
	257	else if (mac->model < MODEL_MAC_POWERMAC_6100)
258	258	{
259	259	if (scc_interrupt)
260	260	{
r9404	r9405
315	315	{
316	316	mac->rbv_regs[3] |= 0x90;   // any VIA 2 interrupt | sound interrupt
317	317
318		// (need to figure out what gets triggered here)
	318	if (mac->rbv_ier & 0x10)   // ASC on RBV is CB1, bit 4 of IER/IFR
	319	{
	320	mac->rbv_ifr |= 0x90;
	321	mac_set_via2_interrupt(device->machine, 1);
	322	}
	323
319	324	}
320		else if (mac->mac_model >= MODEL_MAC_II)
	325	else if (mac->model >= MODEL_MAC_II)
321	326	{
322	327	via6522_device *via2 = device->machine->device<via6522_device>("via6522_1");
323	328
r9404	r9405
356	361	/* Not Yet Implemented */
357	362	}
358	363
	364	void mac_v8_resize(running_machine *machine, mac_state *mac)
	365	{
	366	offs_t memory_size;
	367	UINT8 *memory_data;
	368	int is_rom;
	369
	370	is_rom = (mac->overlay) ? 1 : 0;
	371
	372	// get what memory we're going to map
	373	if (is_rom)
	374	{
	375	/* ROM mirror */
	376	memory_size = memory_region_length(machine, "bootrom");
	377	memory_data = memory_region(machine, "bootrom");
	378	is_rom = TRUE;
	379	}
	380	else
	381	{
	382	/* RAM */
	383	memory_size = messram_get_size(machine->device("messram"));
	384	memory_data = messram_get_ptr(machine->device("messram"));
	385	is_rom = FALSE;
	386	}
	387
	388	//   printf("mac_v8_resize: memory_size = %x, ctrl bits %02x (overlay %d = %s)\n", memory_size, mac->rbv_regs[1] & 0xe0, mac->overlay, is_rom ? "ROM" : "RAM");
	389
	390	if (is_rom)
	391	{
	392	mac_install_memory(machine, 0x00000000, memory_size-1, memory_size, memory_data, is_rom, "bank1");
	393	}
	394	else
	395	{
	396	address_space* space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
	397	UINT32 onboard_amt, simm_amt, simm_size;
	398	UINT32 simm_sizes[4] = { 0, 2*1024*1024, 4*1024*1024, 8*1024*1024 };
	399
	400	// force unmap of entire RAM region
	401	memory_unmap_write(space, 0, 0x9fffff, 0x9fffff, 0);
	402
	403	// LC has 2 MB built-in, all other V8-style machines have 4 MB
	404	// we reserve the first 2 or 4 MB of mess_ram for the onboard,
	405	// RAM above that mark is the SIMM
	406	onboard_amt = ((mac->model == MODEL_MAC_LC) || (mac->model == MODEL_MAC_CLASSIC_II)) ? 2*1024*1024 : 4*1024*1024;
	407	simm_amt = (mac->rbv_regs[1]>>6) & 3;   // size of SIMM RAM window
	408	simm_size = memory_size - onboard_amt;   // actual amount of RAM available for SIMMs
	409
	410	// installing SIMM RAM?
	411	if (simm_amt != 0)
	412	{
	413	//         printf("mac_v8_resize: SIMM region size is %x, SIMM size is %x, onboard size is %x\n", simm_sizes[simm_amt], simm_size, onboard_amt);
	414
	415	if ((simm_amt > 0) && (simm_size > 0))
	416	{
	417	mac_install_memory(machine, 0x000000, simm_sizes[simm_amt]-1, simm_sizes[simm_amt], memory_data + onboard_amt, is_rom, "bank1");
	418	}
	419
	420	// onboard RAM sits immediately above the SIMM, if any
	421	if (simm_sizes[simm_amt] + onboard_amt <= 0x800000)
	422	{
	423	mac_install_memory(machine, simm_sizes[simm_amt], simm_sizes[simm_amt] + onboard_amt - 1, onboard_amt, memory_data, is_rom, "bank2");
	424	}
	425
	426	// a mirror of the first 2 MB of on board RAM always lives at 0x800000
	427	mac_install_memory(machine, 0x800000, 0x9fffff, 0x200000, memory_data, is_rom, "bank3");
	428	}
	429	else
	430	{
	431	//         printf("mac_v8_resize: SIMM off, mobo RAM at 0 and top\n");
	432
	433	mac_install_memory(machine, 0x000000, onboard_amt-1, onboard_amt, memory_data, is_rom, "bank1");
	434	mac_install_memory(machine, 0x800000, 0x9fffff, 0x200000, memory_data, is_rom, "bank3");
	435	}
	436	}
	437	}
	438
359	439	static void set_memory_overlay(running_machine *machine, int overlay)
360	440	{
361	441	offs_t memory_size;
r9404	r9405
366	446	/* normalize overlay */
367	447	overlay = overlay ? TRUE : FALSE;
368	448
369		if (overlay != mac->mac_overlay)
	449	if (overlay != mac->overlay)
370	450	{
371	451	/* set up either main RAM area or ROM mirror at 0x000000-0x3fffff */
372	452	if (overlay)
r9404	r9405
375	455	memory_size = memory_region_length(machine, "bootrom");
376	456	memory_data = memory_region(machine, "bootrom");
377	457	is_rom = TRUE;
378
379		/* HACK! - copy in the initial reset/stack */
380		memcpy(messram_get_ptr(machine->device("messram")), memory_data, 8);
381	458	}
382	459	else
383	460	{
r9404	r9405
388	465	}
389	466
390	467	/* install the memory */
391		if (((mac->mac_model >= MODEL_MAC_LC) && (mac->mac_model <= MODEL_MAC_COLOR_CLASSIC) && (mac->mac_model != MODEL_MAC_LC_III)) || (mac->mac_model == MODEL_MAC_CLASSIC_II))
	468	if (((mac->model >= MODEL_MAC_LC) && (mac->model <= MODEL_MAC_COLOR_CLASSIC) && (mac->model != MODEL_MAC_LC_III)) || (mac->model == MODEL_MAC_CLASSIC_II))
392	469	{
393		//         printf("V8 style machine: memory_size = %x (%s)\n", memory_size, is_rom ? "ROM" : "RAM");
394
395		if (is_rom)
396		{
397		mac_install_memory(machine, 0x00000000, memory_size-1, memory_size, memory_data, is_rom, "bank1");
398		}
399		else
400		{
401		//            address_space* space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
402		UINT32 v8_internal_mirror_base;
403
404		v8_internal_mirror_base = 0xffffffff;   // default to "none"
405
406		// force unmap of entire RAM region
407		//            memory_unmap_write(space, 0, 0x9fffff, 0x9fffff, 0);
408
409		// install the total RAM size at 0
410		mac_install_memory(machine, 0x000000, memory_size-1, memory_size, memory_data, is_rom, "bank1");
411
412		// LC has 2 MB built-in, all other V8-style machines have 4 MB
413		if (mac->mac_model == MODEL_MAC_LC)
414		{
415		switch (memory_size / 0x100000)
416		{
417		case 2:   // 2 MB: RAM at 0 and mirrored at 800000
418		v8_internal_mirror_base = 0x000000;
419		break;
420
421		case 4:   // 4 MB: 2 MB SIMM at 0, internal RAM at 200000, mirrored at 800000
422		v8_internal_mirror_base = 0x200000;
423		break;
424
425		case 6: // 6 MB: 4 MB SIMM at 0, internal RAM at 400000, mirrored at 800000
426		v8_internal_mirror_base = 0x400000;
427		break;
428
429		case 10: // 10 MB: 8 MB SIMM at 0, internal RAM at 800000, no mirror
430		break;
431		}
432		}
433		else
434		{
435		switch (memory_size / 0x100000)
436		{
437		case 2:   // 2 MB: RAM at 0 and mirrored at 800000
438		case 4:   // 4 MB: RAM at 0 and mirrored at 800000
439		v8_internal_mirror_base = 0x000000;
440		break;
441
442		case 6: // 6 MB: 2 MB SIMM at 0, internal RAM at 200000, mirrored at 800000
443		v8_internal_mirror_base = 0x200000;
444		break;
445
446		case 8: // 8 MB: 4 MB SIMM at 0, internal RAM at 400000, mirrored at 800000
447		v8_internal_mirror_base = 0x400000;
448		break;
449
450		case 10: // 10 MB: 8 MB SIMM at 0, internal RAM at 800000, no mirror
451		break;
452		}
453		}
454
455		if (v8_internal_mirror_base != 0xffffffff)
456		{
457		//               printf("V8 style machine: setting internal RAM mirror from offset %x\n", v8_internal_mirror_base);
458		mac_install_memory(machine, 0x800000, 0x9fffff, 0x200000, &memory_data[v8_internal_mirror_base], is_rom, "bank2");
459		}
460		}
	470	mac->overlay = overlay;
	471	mac_v8_resize(machine, mac);
461	472	}
462		else if (mac->mac_model == MODEL_MAC_POWERMAC_6100)
	473	else if (mac->model == MODEL_MAC_POWERMAC_6100)
463	474	{
464	475	mac_install_memory(machine, 0x00000000, memory_size-1, memory_size, memory_data, is_rom, "bank1");
465	476	}
466		else if ((mac->mac_model == MODEL_MAC_IICI) || (mac->mac_model == MODEL_MAC_IISI))
	477	else if ((mac->model == MODEL_MAC_IICI) || (mac->model == MODEL_MAC_IISI))
467	478	{
468	479	// ROM is OK to flood to 3fffffff
469	480	if (is_rom)
r9404	r9405
475	486	mac_install_memory(machine, 0x00000000, 0x03ffffff, memory_size, memory_data, is_rom, "bank1");
476	487	}
477	488	}
478		else if ((mac->mac_model == MODEL_MAC_PORTABLE) || (mac->mac_model == MODEL_MAC_PB100))
	489	else if ((mac->model == MODEL_MAC_PORTABLE) || (mac->model == MODEL_MAC_PB100))
479	490	{
480	491	mac_install_memory(machine, 0x000000, 0x8fffff, memory_size, memory_data, is_rom, "bank1");
481	492	}
482		else if ((mac->mac_model == MODEL_MAC_CLASSIC_II) || ((mac->mac_model >= MODEL_MAC_II) && (mac->mac_model <= MODEL_MAC_SE30)))
	493	else if ((mac->model >= MODEL_MAC_II) && (mac->model <= MODEL_MAC_SE30))
483	494	{
484	495	mac_install_memory(machine, 0x00000000, 0x3fffffff, memory_size, memory_data, is_rom, "bank1");
485	496	}
486		else if (mac->mac_model == MODEL_MAC_LC_III)   // up to 36 MB
	497	else if (mac->model == MODEL_MAC_LC_III)   // up to 36 MB
487	498	{
488		mac_install_memory(machine, 0x00000000, 0x023fffff, memory_size, memory_data, is_rom, "bank1");
	499	mac_install_memory(machine, 0x00000000, memory_size-1, memory_size, memory_data, is_rom, "bank1");
489	500	}
490	501	else
491	502	{
492	503	mac_install_memory(machine, 0x00000000, 0x003fffff, memory_size, memory_data, is_rom, "bank1");
493	504	}
494	505
495		mac->mac_overlay = overlay;
	506	mac->overlay = overlay;
496	507
497	508	if (LOG_GENERAL)
498	509	logerror("set_memory_overlay: overlay=%i\n", overlay);
r9404	r9405
1037	1048	{
1038	1049	mac_state *mac = machine->driver_data<mac_state>();
1039	1050
1040		if ((mac->mac_scsiirq_enable) && ((mac->mac_model == MODEL_MAC_SE) || (mac->mac_model == MODEL_MAC_CLASSIC)))
	1051	if ((mac->scsiirq_enable) && ((mac->model == MODEL_MAC_SE) || (mac->model == MODEL_MAC_CLASSIC)))
1041	1052	{
1042	1053	scsi_interrupt = state;
1043	1054	mac_field_interrupts(machine);
r9404	r9405
1400	1411	mac->rtc_ram[0x12] = 0x01;
1401	1412	mac->rtc_ram[0x13] = 0x4c;
1402	1413
1403		if (mac->mac_model >= MODEL_MAC_II)
	1414	if (mac->model >= MODEL_MAC_II)
1404	1415	{
1405	1416	mac->rtc_ram[0xc] = 0x4e;   // XPRAM valid is different for these
1406	1417	mac->rtc_ram[0xd] = 0x75;
r9404	r9405
2580	2591
2581	2592	//  printf("VIA1 IN_A (PC %x)\n", cpu_get_pc(device->machine->device("maincpu")));
2582	2593
2583		switch (mac->mac_model)
	2594	switch (mac->model)
2584	2595	{
2585	2596	case MODEL_MAC_PORTABLE:
2586	2597	case MODEL_MAC_PB100:
r9404	r9405
2599	2610	case MODEL_MAC_SE30:
2600	2611	return 0x81 | PA6;
2601	2612
2602		case MODEL_MAC_LC:
	2613	case MODEL_MAC_LC:      // apollo board is 0x38, box 0x11 (17), vid hw 0x21
2603	2614	case MODEL_MAC_LC_II:
2604	2615	return 0x81 | PA6 | PA4 | PA2;
2605	2616
r9404	r9405
2615	2626	case MODEL_MAC_IICX:
2616	2627	return 0x81 | PA6;
2617	2628
	2629	case MODEL_MAC_PB170:      // since the decoders are different, these are allowed to "collide"
	2630	case MODEL_MAC_CLASSIC_II:
	2631	return 0x81 | PA4 | PA1;
	2632
	2633	case MODEL_MAC_QUADRA_700:
	2634	return 0x81 | PA6;
	2635
	2636	case MODEL_MAC_QUADRA_900:
	2637	return 0x81 | PA6 | PA4;
	2638
2618	2639	default:
2619	2640	return 0x80;
2620	2641
r9404	r9405
2629	2650	mac_state *mac = device->machine->driver_data<mac_state>();
2630	2651
2631	2652	// portable/PB100 is pretty different
2632		if (mac->mac_model >= MODEL_MAC_PORTABLE && mac->mac_model <= MODEL_MAC_PB100)
	2653	if (mac->model >= MODEL_MAC_PORTABLE && mac->model <= MODEL_MAC_PB100)
2633	2654	{
2634	2655	//      printf("Read VIA B: PM_ACK %x\n", mac->pm_ack);
2635	2656	val = 0x80 | 0x04 | mac->pm_ack;   // SCC wait/request (bit 2 must be set at 900c1a or startup tests always fail)
r9404	r9405
2680	2701
2681	2702	//  printf("VIA1 OUT A: %02x (PC %x)\n", data, cpu_get_pc(device->machine->device("maincpu")));
2682	2703
2683		if (mac->mac_model >= MODEL_MAC_PORTABLE && mac->mac_model <= MODEL_MAC_PB100)
	2704	if (mac->model >= MODEL_MAC_PORTABLE && mac->model <= MODEL_MAC_PB100)
2684	2705	{
2685	2706	#if LOG_ADB
2686	2707	//      printf("%02x to PM\n", data);
r9404	r9405
2692	2713	set_scc_waitrequest((data & 0x80) >> 7);
2693	2714	mac_set_screen_buffer((data & 0x40) >> 6);
2694	2715	sony_set_sel_line(fdc,(data & 0x20) >> 5);
2695		if (mac->mac_model == MODEL_MAC_SE)   // on SE this selects which floppy drive (0 = upper, 1 = lower)
	2716	if (mac->model == MODEL_MAC_SE)   // on SE this selects which floppy drive (0 = upper, 1 = lower)
2696	2717	{
2697		mac->mac_drive_select = ((data & 0x10) >> 4);
	2718	mac->drive_select = ((data & 0x10) >> 4);
2698	2719	}
2699	2720
2700		if (mac->mac_model < MODEL_MAC_SE)   // SE no longer has dual buffers
	2721	if (mac->model < MODEL_MAC_SE)   // SE no longer has dual buffers
2701	2722	{
2702	2723	mac_set_sound_buffer(sound, (data & 0x08) >> 3);
2703	2724	}
2704	2725
2705		if (mac->mac_model < MODEL_MAC_II)
	2726	if (mac->model < MODEL_MAC_II)
2706	2727	{
2707	2728	mac_set_volume(sound, data & 0x07);
2708	2729	}
r9404	r9405
2710	2731	/* Early Mac models had VIA A4 control overlaying.  In the Mac SE (and
2711	2732	* possibly later models), overlay was set on reset, but cleared on the
2712	2733	* first access to the ROM. */
2713		if (mac->mac_model < MODEL_MAC_SE)
	2734	if (mac->model < MODEL_MAC_SE)
	2735	{
2714	2736	set_memory_overlay(device->machine, (data & 0x10) >> 4);
	2737	}
2715	2738	}
2716	2739
2717	2740	static WRITE8_DEVICE_HANDLER(mac_via_out_b)
r9404	r9405
2722	2745
2723	2746	//  printf("VIA1 OUT B: %02x (PC %x)\n", data, cpu_get_pc(device->machine->device("maincpu")));
2724	2747
2725		if (mac->mac_model >= MODEL_MAC_PORTABLE && mac->mac_model <= MODEL_MAC_PB100)
	2748	if (mac->model >= MODEL_MAC_PORTABLE && mac->model <= MODEL_MAC_PB100)
2726	2749	{
2727	2750	running_device *fdc = device->machine->device("fdc");
2728	2751
2729	2752	sony_set_sel_line(fdc,(data & 0x20) >> 5);
2730		mac->mac_drive_select = ((data & 0x10) >> 4);
	2753	mac->drive_select = ((data & 0x10) >> 4);
2731	2754
2732	2755	if ((data & 1) && !(mac->pm_req & 1))
2733	2756	{
r9404	r9405
2792	2815	}
2793	2816
2794	2817	// SE and Classic have SCSI enable/disable here
2795		if ((mac->mac_model == MODEL_MAC_SE) || (mac->mac_model == MODEL_MAC_CLASSIC))
	2818	if ((mac->model == MODEL_MAC_SE) || (mac->model == MODEL_MAC_CLASSIC))
2796	2819	{
2797		mac->mac_scsiirq_enable = (data & 0x40) ? 0 : 1;
2798		//      printf("VIAB & 0x40 = %02x, IRQ enable %d\n", data & 0x40, mac->mac_scsiirq_enable);
	2820	mac->scsiirq_enable = (data & 0x40) ? 0 : 1;
	2821	//      printf("VIAB & 0x40 = %02x, IRQ enable %d\n", data & 0x40, mac->scsiirq_enable);
2799	2822	}
2800	2823
2801		if (mac->mac_model == MODEL_MAC_SE30)
	2824	if (mac->model == MODEL_MAC_SE30)
2802	2825	{
2803	2826	// 0x40 = 0 means enable vblank on SE/30
2804	2827	mac->mac_se30_vbl_enable = (data & 0x40) ? 0 : 1;
r9404	r9405
2917	2940
2918	2941	//  logerror("VIA2 IN B (PC %x)\n", cpu_get_pc(device->machine->device("maincpu")));
2919	2942
2920		if ((mac->mac_model == MODEL_MAC_LC) || (mac->mac_model == MODEL_MAC_LC_II))
	2943	if ((mac->model == MODEL_MAC_LC) || (mac->model == MODEL_MAC_LC_II) || (mac->model == MODEL_MAC_CLASSIC_II))
2921	2944	{
2922	2945	return 0x4f;
2923	2946	}
2924	2947
2925		if (mac->mac_model == MODEL_MAC_SE30)
	2948	if (mac->model == MODEL_MAC_SE30)
2926	2949	{
2927	2950	return 0x87;   // bits 3 and 6 are tied low on SE/30
2928	2951	}
r9404	r9405
2990	3013	timer_adjust_oneshot(mac->mac6015_timer, attotime_never, 0);
2991	3014
2992	3015	// start 60.15 Hz timer for IIci/IIsi (and eventually others)
2993		if ((mac->mac_model == MODEL_MAC_IICI) || (mac->mac_model == MODEL_MAC_IISI))
	3016	if ((mac->model == MODEL_MAC_IICI) || (mac->model == MODEL_MAC_IISI))
2994	3017	{
2995	3018	timer_adjust_periodic(mac->mac6015_timer, ATTOTIME_IN_HZ(60.15), 0, ATTOTIME_IN_HZ(60.15));
2996	3019	}
r9404	r9405
3007	3030	rtc_init(mac);
3008	3031
3009	3032	/* setup the memory overlay */
3010		if (mac->mac_model < MODEL_MAC_POWERMAC_6100)   // no overlay for PowerPC
	3033	if (mac->model < MODEL_MAC_POWERMAC_6100)   // no overlay for PowerPC
3011	3034	{
	3035	mac->overlay = -1;   // insure no match
3012	3036	set_memory_overlay(machine, 1);
3013	3037	}
3014	3038
r9404	r9405
3032	3056	adb_reset(mac);
3033	3057	}
3034	3058
3035		if ((mac->mac_model == MODEL_MAC_SE) || (mac->mac_model == MODEL_MAC_CLASSIC))
	3059	if ((mac->model == MODEL_MAC_SE) || (mac->model == MODEL_MAC_CLASSIC))
3036	3060	{
3037	3061	mac_set_sound_buffer(machine->device("custom"), 1);
3038	3062
r9404	r9405
3046	3070	machine->device<cpu_device>("maincpu")->debug()->set_dasm_override(mac_dasm_override);
3047	3071	}
3048	3072
3049		mac->mac_drive_select = 0;
3050		mac->mac_scsiirq_enable = 0;
	3073	mac->drive_select = 0;
	3074	mac->scsiirq_enable = 0;
3051	3075	mac->mac_via2_vbl = 0;
3052	3076	mac->mac_se30_vbl_enable = 0;
3053	3077	mac->mac_nubus_irq_state = 0xff;
r9404	r9405
3076	3100	int overlay;
3077	3101	mac_state *mac = machine->driver_data<mac_state>();
3078	3102
3079		overlay = mac->mac_overlay;
3080		mac->mac_overlay = -1;
	3103	overlay = mac->overlay;
	3104	mac->overlay = -1;
3081	3105	set_memory_overlay(machine, overlay);
3082	3106	}
3083	3107
r9404	r9405
3086	3110	{
3087	3111	mac_state *mac = machine->driver_data<mac_state>();
3088	3112
3089		if (mac->mac_overlay != -1)
	3113	if (mac->overlay != -1)
3090	3114	{
3091		if ((mac->mac_model == MODEL_MAC_PORTABLE) || (mac->mac_model == MODEL_MAC_PB100))
	3115	if ((mac->model == MODEL_MAC_PORTABLE) || (mac->model == MODEL_MAC_PB100))
3092	3116	{
3093	3117	if ((address >= 0x900000) && (address <= 0x9fffff))
3094	3118	{
3095	3119	set_memory_overlay(machine, 0);      // kill the overlay
3096		mac->mac_overlay = -1;
3097	3120	}
3098	3121	}
3099		else if ((mac->mac_model == MODEL_MAC_SE) || (mac->mac_model == MODEL_MAC_CLASSIC))
	3122	else if ((mac->model == MODEL_MAC_SE) || (mac->model == MODEL_MAC_CLASSIC))
3100	3123	{
3101	3124	if ((address >= 0x400000) && (address <= 0x4fffff))
3102	3125	{
3103	3126	set_memory_overlay(machine, 0);      // kill the overlay
3104		mac->mac_overlay = -1;
3105	3127	}
3106	3128	}
3107		else if ((mac->mac_model == MODEL_MAC_LC) || (mac->mac_model == MODEL_MAC_LC_II))
	3129	else if ((mac->model == MODEL_MAC_LC) || (mac->model == MODEL_MAC_LC_II) || (mac->model == MODEL_MAC_CLASSIC_II))
3108	3130	{
3109	3131	if ((address >= 0xa00000) && (address <= 0xafffff))
3110	3132	{
3111	3133	set_memory_overlay(machine, 0);      // kill the overlay
3112		mac->mac_overlay = -1;
3113	3134	}
3114	3135	}
3115	3136	else
r9404	r9405
3117	3138	if ((address >= 0x40000000) && (address <= 0x4fffffff))
3118	3139	{
3119	3140	set_memory_overlay(machine, 0);      // kill the overlay
3120		mac->mac_overlay = -1;
3121	3141	}
3122	3142	}
3123	3143	}
r9404	r9405
3125	3145	return address;
3126	3146	}
3127	3147
3128		static void mac_driver_init(running_machine *machine, mac_model_t model)
	3148	static void mac_driver_init(running_machine *machine, model_t model)
3129	3149	{
3130	3150	mac_state *mac = machine->driver_data<mac_state>();
3131	3151
3132		mac->mac_overlay = -1;
	3152	mac->overlay = 1;
3133	3153	scsi_interrupt = 0;
3134		mac->mac_model = model;
	3154	mac->model = model;
3135	3155
3136		if ((mac->mac_model == MODEL_MAC_PORTABLE) || (mac->mac_model == MODEL_MAC_PB100))
	3156	if ((mac->model == MODEL_MAC_PORTABLE) || (mac->model == MODEL_MAC_PB100))
3137	3157	{
3138	3158	}
3139	3159	else if (model < MODEL_MAC_II)
r9404	r9405
3145	3165	mac_install_memory(machine, 0x400000, (model >= MODEL_MAC_PLUS) ? 0x43ffff : 0x5fffff,
3146	3166	memory_region_length(machine, "bootrom"), memory_region(machine, "bootrom"), TRUE, "bank3");
3147	3167	}
3148		else if ((model == MODEL_MAC_LC) || (model == MODEL_MAC_LC_II) || (model == MODEL_MAC_LC_III))
3149		{
3150		mac_install_memory(machine, 0x000000, messram_get_size(machine->device("messram"))-1, messram_get_size(machine->device("messram")), messram_get_ptr(machine->device("messram")), FALSE, "bank2");
3151		}
3152		else if ((mac->mac_model == MODEL_MAC_CLASSIC_II) || ((mac->mac_model >= MODEL_MAC_II) && (mac->mac_model <= MODEL_MAC_SE30)))
3153		{
3154		mac_install_memory(machine, 0x00000000, 0x3fffffff, messram_get_size(machine->device("messram")), messram_get_ptr(machine->device("messram")), FALSE, "bank2");
3155		}
3156	3168
	3169	mac->overlay = -1;
3157	3170	set_memory_overlay(machine, 1);
3158		mac->mac_overlay = 1;
3159	3171
3160	3172	memset(messram_get_ptr(machine->device("messram")), 0, messram_get_size(machine->device("messram")));
3161	3173
3162	3174	if ((model == MODEL_MAC_SE) || (model == MODEL_MAC_CLASSIC) || (model == MODEL_MAC_CLASSIC_II) || (model == MODEL_MAC_LC) ||
3163		(model == MODEL_MAC_LC_II) || (model == MODEL_MAC_LC_III) || ((mac->mac_model >= MODEL_MAC_II) && (mac->mac_model <= MODEL_MAC_SE30)) ||
	3175	(model == MODEL_MAC_LC_II) || (model == MODEL_MAC_LC_III) || ((mac->model >= MODEL_MAC_II) && (mac->model <= MODEL_MAC_SE30)) ||
3164	3176	(model == MODEL_MAC_PORTABLE) || (model == MODEL_MAC_PB100))
3165	3177	{
3166	3178	cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM)->set_direct_update_handler(direct_update_delegate_create_static(overlay_opbaseoverride, *machine));
r9404	r9405
3172	3184	mac->inquiry_timeout = timer_alloc(machine, inquiry_timeout_func, NULL);
3173	3185
3174	3186	/* save state stuff */
3175		state_save_register_global(machine, mac->mac_overlay);
	3187	state_save_register_global(machine, mac->overlay);
3176	3188	state_save_register_postload(machine, mac_state_load, NULL);
3177	3189	}
3178	3190
r9404	r9405
3195	3207	MAC_DRIVER_INIT(macii, MODEL_MAC_II)
3196	3208	MAC_DRIVER_INIT(macse30, MODEL_MAC_SE30)
3197	3209	MAC_DRIVER_INIT(macclassic2, MODEL_MAC_CLASSIC_II)
	3210	MAC_DRIVER_INIT(maclrcclassic, MODEL_MAC_COLOR_CLASSIC)
3198	3211	MAC_DRIVER_INIT(macpm6100, MODEL_MAC_POWERMAC_6100)
3199	3212	MAC_DRIVER_INIT(macprtb, MODEL_MAC_PORTABLE)
3200	3213	MAC_DRIVER_INIT(macpb100, MODEL_MAC_PB100)
r9404	r9405
3289	3302	}
3290	3303
3291	3304	/* signal VBlank on CA1 input on the VIA */
3292		if (mac->mac_model < MODEL_MAC_II)
	3305	if (mac->model < MODEL_MAC_II)
3293	3306	{
3294	3307	ca1_data ^= 1;
3295	3308	via_0->write_ca1(ca1_data);
r9404	r9405
3307	3320	}
3308	3321
3309	3322	// handle SE/30 vblank IRQ
3310		if (mac->mac_model == MODEL_MAC_SE30)
	3323	if (mac->model == MODEL_MAC_SE30)
3311	3324	{
3312	3325	if (mac->mac_se30_vbl_enable)
3313	3326	{
r9404	r9405
3335	3348	mac_vblank_irq(machine);
3336	3349
3337	3350	/* check for mouse changes at 10 irqs per frame */
3338		if (mac->mac_model <= MODEL_MAC_PLUS)
	3351	if (mac->model <= MODEL_MAC_PLUS)
3339	3352	{
3340	3353	if (!(scanline % 10))
3341	3354	mouse_callback(machine);

src/mess/video/mac.c

r9404	r9405
316	316
317	317	VIDEO_START( macrbv )
318	318	{
	319	}
	320
	321	VIDEO_RESET(macrbv)
	322	{
319	323	mac_state *mac = machine->driver_data<mac_state>();
	324	rectangle visarea;
	325	int htotal, vtotal;
	326	double framerate;
320	327
321	328	memset(mac->rbv_regs, 0, sizeof(mac->rbv_regs));
322	329
r9404	r9405
327	334	mac->rbv_regs[2] = 0xff;
328	335
329	336	mac->rbv_type = RBV_TYPE_RBV;
	337
	338	visarea.min_x = 0;
	339	visarea.min_y = 0;
	340
	341	if (mac->model == MODEL_MAC_CLASSIC_II)
	342	{
	343	mac->rbv_montype = 32;
	344	visarea.max_x = MAC_H_VIS-1;
	345	visarea.max_y = MAC_V_VIS-1;
	346	htotal = MAC_H_TOTAL;
	347	vtotal = MAC_V_TOTAL;
	348	framerate = 60.15;
	349	}
	350	else
	351	{
	352	mac->rbv_montype = input_port_read(machine, "MONTYPE");
	353	switch (mac->rbv_montype)
	354	{
	355	case 1:   // 15" portrait display
	356	visarea.max_x = 640-1;
	357	visarea.max_y = 870-1;
	358	htotal = 832;
	359	vtotal = 918;
	360	framerate = 75.0;
	361	break;
	362
	363	case 2: // 12" RGB
	364	visarea.max_x = 512-1;
	365	visarea.max_y = 384-1;
	366	htotal = 640;
	367	vtotal = 407;
	368	framerate = 60.15;
	369	break;
	370
	371	case 6: // 13" RGB
	372	default:
	373	visarea.max_x = 640-1;
	374	visarea.max_y = 480-1;
	375	htotal = 800;
	376	vtotal = 525;
	377	framerate = 59.94;
	378	break;
	379	}
	380	}
	381
	382	//   printf("RBV reset: monitor is %dx%d @ %f Hz\n", visarea.max_x+1, visarea.max_y+1, framerate);
	383	machine->primary_screen->configure(htotal, vtotal, visarea, HZ_TO_ATTOSECONDS(framerate));
330	384	}
331	385
332	386	VIDEO_START( macsonora )
r9404	r9405
343	397	mac->rbv_regs[4] = 0x6;
344	398	mac->rbv_regs[5] = 0x3;
345	399
	400	mac->sonora_vctl[0] = 0x9f;
	401	mac->sonora_vctl[1] = 0;
	402	mac->sonora_vctl[2] = 0;
	403
346	404	mac->rbv_type = RBV_TYPE_SONORA;
347	405	}
348	406
	407	VIDEO_START( macv8 )
	408	{
	409	mac_state *mac = machine->driver_data<mac_state>();
	410
	411	memset(mac->rbv_regs, 0, sizeof(mac->rbv_regs));
	412
	413	mac->rbv_count = 0;
	414	mac->rbv_clutoffs = 0;
	415	mac->rbv_immed10wr = 0;
	416
	417	mac->rbv_regs[0] = 0x4f;
	418	mac->rbv_regs[1] = 0x06;
	419	mac->rbv_regs[2] = 0xff;
	420
	421	mac->rbv_type = RBV_TYPE_V8;
	422	}
	423
349	424	VIDEO_UPDATE( macrbv )
350	425	{
351	426	UINT32 *scanline;
352		int x, y;
	427	int x, y, hres, vres;
353	428	mac_state *mac = screen->machine->driver_data<mac_state>();
354	429
	430	switch (mac->rbv_montype)
	431	{
	432	case 32: // classic II built-in display
	433	hres = MAC_H_VIS;
	434	vres = MAC_V_VIS;
	435	break;
	436
	437	case 1:   // 15" portrait display
	438	hres = 640;
	439	vres = 870;
	440	break;
	441
	442	case 2: // 12" RGB
	443	hres = 512;
	444	vres = 384;
	445	break;
	446
	447	case 6: // 13" RGB
	448	default:
	449	hres = 640;
	450	vres = 480;
	451	break;
	452	}
	453
355	454	switch (mac->rbv_regs[0x10] & 7)
356	455	{
357	456	case 0:   // 1bpp
r9404	r9405
359	458	UINT8 *vram8 = (UINT8 *)messram_get_ptr(screen->machine->device("messram"));
360	459	UINT8 pixels;
361	460
362		for (y = 0; y < 480; y++)
	461	for (y = 0; y < vres; y++)
363	462	{
364	463	scanline = BITMAP_ADDR32(bitmap, y, 0);
365		for (x = 0; x < 640; x+=8)
	464	for (x = 0; x < hres; x+=8)
366	465	{
367		pixels = vram8[(y * 80) + ((x/8)^3)];
	466	pixels = vram8[(y * (hres/8)) + ((x/8)^3)];
368	467
369	468	*scanline++ = mac->rbv_palette[0xfe|(pixels>>7)];
370	469	*scanline++ = mac->rbv_palette[0xfe|((pixels>>6)&1)];
r9404	r9405
384	483	UINT8 *vram8 = (UINT8 *)messram_get_ptr(screen->machine->device("messram"));
385	484	UINT8 pixels;
386	485
387		for (y = 0; y < 480; y++)
	486	for (y = 0; y < vres; y++)
388	487	{
389	488	scanline = BITMAP_ADDR32(bitmap, y, 0);
390		for (x = 0; x < 640/4; x++)
	489	for (x = 0; x < hres/4; x++)
391	490	{
392		pixels = vram8[(y * 160) + (BYTE4_XOR_BE(x))];
	491	pixels = vram8[(y * (hres/4)) + (BYTE4_XOR_BE(x))];
393	492
394	493	*scanline++ = mac->rbv_palette[0xfc|((pixels>>6)&3)];
395	494	*scanline++ = mac->rbv_palette[0xfc|((pixels>>4)&3)];
r9404	r9405
405	504	UINT8 *vram8 = (UINT8 *)messram_get_ptr(screen->machine->device("messram"));
406	505	UINT8 pixels;
407	506
408		for (y = 0; y < 480; y++)
	507	for (y = 0; y < vres; y++)
409	508	{
410	509	scanline = BITMAP_ADDR32(bitmap, y, 0);
411	510
412		for (x = 0; x < 640/2; x++)
	511	for (x = 0; x < hres/2; x++)
413	512	{
414		pixels = vram8[(y * 320) + (BYTE4_XOR_BE(x))];
	513	pixels = vram8[(y * (hres/2)) + (BYTE4_XOR_BE(x))];
415	514
416	515	*scanline++ = mac->rbv_palette[0xf0|(pixels>>4)];
417	516	*scanline++ = mac->rbv_palette[0xf0|(pixels&0xf)];
r9404	r9405
425	524	UINT8 *vram8 = (UINT8 *)messram_get_ptr(screen->machine->device("messram"));
426	525	UINT8 pixels;
427	526
428		for (y = 0; y < 480; y++)
	527	for (y = 0; y < vres; y++)
429	528	{
430	529	scanline = BITMAP_ADDR32(bitmap, y, 0);
431	530
432		for (x = 0; x < 640; x++)
	531	for (x = 0; x < hres; x++)
433	532	{
434		pixels = vram8[(y * 640) + (BYTE4_XOR_BE(x))];
	533	pixels = vram8[(y * hres) + (BYTE4_XOR_BE(x))];
435	534	*scanline++ = mac->rbv_palette[pixels];
436	535	}
437	536	}
r9404	r9405
446	545	UINT32 *scanline;
447	546	int x, y;
448	547	mac_state *mac = screen->machine->driver_data<mac_state>();
	548	UINT8 mode = 0;
449	549
450		switch (mac->rbv_regs[0x10] & 7)
	550	switch (mac->rbv_type)
451	551	{
	552	case RBV_TYPE_RBV:
	553	case RBV_TYPE_V8:
	554	mode = mac->rbv_regs[0x10] & 7;
	555	break;
	556
	557	case RBV_TYPE_SONORA:
	558	mode = mac->sonora_vctl[1] & 7;
	559
	560	// forced blank?
	561	if (mac->sonora_vctl[0] & 0x80)
	562	{
	563	return 0;
	564	}
	565	break;
	566	}
	567
	568	switch (mode)
	569	{
452	570	case 0:   // 1bpp
453	571	{
454	572	UINT8 *vram8 = (UINT8 *)mac->rbv_vram;

src/mess/includes/mac.h

r9404	r9405
93	93	MODEL_MAC_PB190cs,
94	94
95	95	MODEL_MAC_POWERMAC_6100   // original PowerMac
96		} mac_model_t;
	96	} model_t;
97	97
98	98	// video parameters for classic Macs
99	99	#define MAC_H_VIS   (512)
r9404	r9405
103	103
104	104	/*----------- defined in machine/mac.c -----------*/
105	105
106		extern mac_model_t mac_model;
107	106	extern const via6522_interface mac_via6522_intf;
108	107	extern const via6522_interface mac_via6522_2_intf;
109	108	extern const via6522_interface mac_via6522_adb_intf;
r9404	r9405
117	116	DRIVER_INIT(macplus);
118	117	DRIVER_INIT(macse);
119	118	DRIVER_INIT(macclassic);
	119	DRIVER_INIT(maclrcclassic);
120	120	DRIVER_INIT(maclc);
121	121	DRIVER_INIT(macii);
122	122	DRIVER_INIT(maciifdhd);
r9404	r9405
171	171	PALETTE_INIT( mac );
172	172
173	173	VIDEO_START( macrbv );
	174	VIDEO_START( macv8 );
174	175	VIDEO_START( macsonora );
175	176	VIDEO_UPDATE( macrbv );
176	177	VIDEO_UPDATE( macrbvvram );
	178	VIDEO_RESET(macrbv);
177	179
178	180	void mac_set_screen_buffer( int buffer );
179	181
r9404	r9405
203	205	mac_state(running_machine &machine, const driver_device_config_base &config)
204	206	: driver_device(machine, config) { }
205	207
206		mac_model_t mac_model;
	208	model_t model;
207	209
208		UINT32 mac_overlay;
209		int mac_drive_select;
210		int mac_scsiirq_enable;
	210	UINT32 overlay;
	211	int drive_select;
	212	int scsiirq_enable;
211	213
212	214	UINT32 mac_via2_vbl;
213	215	UINT32 mac_se30_vbl_enable;
r9404	r9405
277	279	emu_timer *mac6015_timer;
278	280
279	281	// RBV and friends (V8, etc)
280		UINT8 rbv_regs[256], rbv_ier, rbv_ifr, rbv_type;
	282	UINT8 rbv_regs[256], rbv_ier, rbv_ifr, rbv_type, rbv_montype;
281	283	UINT32 rbv_colors[3], rbv_count, rbv_clutoffs, rbv_immed10wr;
282	284	UINT32 rbv_palette[256];
283	285	UINT32 *rbv_vram;
	286	UINT8 sonora_vctl[4];
284	287	};
285	288
	289	// defined in machine/mac.c
	290	void mac_v8_resize(running_machine *machine, mac_state *mac);
	291
286	292	#endif /* MAC_H_ */
287	293
288	294

src/mess/drivers/mac.c

r9404	r9405
66	66	space->machine->device<asc_device>("asc")->write(offset, data);
67	67	}
68	68
69		static READ32_HANDLER(mac_swim_r)
70		{
71		return 0x17171717;
72		}
73
74	69	// do this here - VIDEO_UPDATE is called each scanline when stepping in the
75	70	// debugger, which means you can't escape the VIA2 IRQ handler
	71	//
	72	// RBV/MDU interrupts:
	73	//
	74	// CA1: any slot interrupt = 0x02
	75	// CA2: SCSI interrupt = 0x01
	76	// CB1: ASC interrupt = 0x10
	77
76	78	INTERRUPT_GEN( mac_rbv_vbl )
77	79	{
78	80	mac_state *mac = device->machine->driver_data<mac_state>();
79	81
80	82	mac->rbv_regs[2] &= ~0x40;   // set vblank signal
81	83
82		if ((mac->rbv_regs[0x12] & 0x40) && (mac->rbv_ier & 0x2))
	84	if ((mac->rbv_regs[0x12] & 0x40) && (mac->rbv_ier & 0x2))
83	85	{
84	86	mac->rbv_ifr |= 0x82;
85	87	mac_set_via2_interrupt(device->machine, 1);
86	88	}
87	89	}
88	90
	91	static READ32_HANDLER( rbv_ramdac_r )
	92	{
	93	return 0;
	94	}
	95
89	96	static WRITE32_HANDLER( rbv_ramdac_w )
90	97	{
91	98	mac_state *mac = space->machine->driver_data<mac_state>();
r9404	r9405
101	108
102	109	if (mac->rbv_count == 3)
103	110	{
104		palette_set_color(space->machine, mac->rbv_clutoffs, MAKE_RGB(mac->rbv_colors[0], mac->rbv_colors[1], mac->rbv_colors[2]));
105		mac->rbv_palette[mac->rbv_clutoffs] = MAKE_RGB(mac->rbv_colors[0], mac->rbv_colors[1], mac->rbv_colors[2]);
106		mac->rbv_clutoffs++;
107		mac->rbv_count = 0;
	111	// for portrait display, force monochrome by using the blue channel
	112	if (mac->model != MODEL_MAC_CLASSIC_II)
	113	{
	114	if (input_port_read(space->machine, "MONTYPE") == 1)
	115	{
	116	palette_set_color(space->machine, mac->rbv_clutoffs, MAKE_RGB(mac->rbv_colors[2], mac->rbv_colors[2], mac->rbv_colors[2]));
	117	mac->rbv_palette[mac->rbv_clutoffs] = MAKE_RGB(mac->rbv_colors[2], mac->rbv_colors[2], mac->rbv_colors[2]);
	118	mac->rbv_clutoffs++;
	119	mac->rbv_count = 0;
	120	}
	121	else
	122	{
	123	palette_set_color(space->machine, mac->rbv_clutoffs, MAKE_RGB(mac->rbv_colors[0], mac->rbv_colors[1], mac->rbv_colors[2]));
	124	mac->rbv_palette[mac->rbv_clutoffs] = MAKE_RGB(mac->rbv_colors[0], mac->rbv_colors[1], mac->rbv_colors[2]);
	125	mac->rbv_clutoffs++;
	126	mac->rbv_count = 0;
	127	}
	128	}
108	129	}
109	130	}
110	131	}
111	132
	133	static READ8_HANDLER( mac_sonora_vctl_r )
	134	{
	135	mac_state *mac = space->machine->driver_data<mac_state>();
	136
	137	if (offset == 2)
	138	{
	139	return (6 << 4);   // 640x480 RGB monitor
	140	}
	141
	142	return mac->sonora_vctl[offset];
	143	}
	144
	145	static WRITE8_HANDLER( mac_sonora_vctl_w )
	146	{
	147	mac_state *mac = space->machine->driver_data<mac_state>();
	148
	149	mac->sonora_vctl[offset] = data;
	150	}
	151
112	152	static READ8_HANDLER ( mac_rbv_r )
113	153	{
114	154	int data = 0;
r9404	r9405
131	171	if (!mac->rbv_immed10wr)
132	172	{
133	173	data &= ~0x38;
134		data |= (6<<3);   // 13" RGB monitor at 640x480
	174	data |= (input_port_read(space->machine, "MONTYPE")<<3);
135	175	}
136	176	else
137	177	{
r9404	r9405
179	219	//      if (offset == 0x10) printf("rbv_w: %02x to offset %x (PC=%x)\n", data, offset, cpu_get_pc(space->cpu));
180	220	switch (offset)
181	221	{
	222	case 0x00:
	223	if (mac->model == MODEL_MAC_LC)
	224	{
	225	running_device *cpu = space->machine->device("maincpu");
	226
	227	m68k_set_hmmu_enable(cpu, (data & 0x8) ? M68K_HMMU_DISABLE : M68K_HMMU_ENABLE_LC);
	228	}
	229	break;
	230
	231	case 0x01:
	232	if (((data & 0xc0) != (mac->rbv_regs[1] & 0xc0)) && (mac->rbv_type == RBV_TYPE_V8))
	233	{
	234	mac->rbv_regs[1] = data;
	235	mac_v8_resize(space->machine, mac);
	236	}
	237	break;
	238
182	239	case 0x02:
183	240	if ((data & 0x40) && (mac->rbv_type == RBV_TYPE_SONORA))
184	241	{
r9404	r9405
265	322	}
266	323	}
267	324
268		// LC/LC II "V8" video and friends
269
270		static UINT8 v8_regs[256];
271		static UINT32 v8_colors[3], v8_count, v8_clutoffs;
272		static UINT32 v8_palette[256];
273
274		static READ16_HANDLER ( mac_v8_r )
275		{
276		int data, viaoffs;
277		via6522_device *via_1 = space->machine->device<via6522_device>("via6522_1");
278
279		//  printf("v8_r: %x, mask %x (PC %x)\n", offset*2, mem_mask, cpu_get_pc(space->cpu));
280
281		viaoffs = (offset >> 8) & 0x0f;
282
283		switch (offset)
284		{
285		case 0:
286		data = via_1->read(*space, viaoffs);
287		return (data<<8) | v8_regs[0];
288
289		default:
290		data = via_1->read(*space, viaoffs);
291		return (data<<8)|data;
292		}
293
294		}
295
296		static WRITE16_HANDLER ( mac_v8_w )
297		{
298		via6522_device *via_1 = space->machine->device<via6522_device>("via6522_1");
299		int viaoffs;
300
301		//  printf("v8_w: %x to offset %x, mask %x (PC %x)\n", data, offset*2, mem_mask, cpu_get_pc(space->cpu));
302
303		viaoffs = (offset >> 8) & 0x0f;
304
305		switch (offset)
306		{
307		case 0:
308		if (ACCESSING_BITS_8_15)
309		{
310		via_1->write(*space, viaoffs, (data >> 8) & 0xff);
311		}
312		else
313		{
314		v8_regs[0] = data&0xe7;
315		}
316		break;
317
318		default:
319		if (ACCESSING_BITS_8_15)
320		{
321		via_1->write(*space, viaoffs, (data >> 8) & 0xff);
322		}
323		break;
324		}
325		}
326
327		static WRITE32_HANDLER( mac_v8_ramdac_w )
328		{
329		if (mem_mask == 0xff000000)
330		{
331		v8_clutoffs = data>>24;
332		v8_count = 0;
333		}
334		else if (mem_mask == 0x00ff0000)
335		{
336		v8_colors[v8_count++] = data>>16;
337
338		if (v8_count == 3)
339		{
340		v8_count = 0;
341		palette_set_color(space->machine, v8_clutoffs, MAKE_RGB(v8_colors[0], v8_colors[1], v8_colors[2]));
342		v8_palette[v8_clutoffs] = MAKE_RGB(v8_colors[0], v8_colors[1], v8_colors[2]);
343		v8_clutoffs++;
344		}
345		}
346		}
347
348		static VIDEO_START( maclc )
349		{
350		memset(v8_regs, 0, sizeof(v8_regs));
351
352		v8_regs[1] = 0x6;   // set init value
353		}
354
355		static VIDEO_UPDATE( maclc )
356		{
357		return 0;
358		}
359
360	325	static READ32_HANDLER(mac_lc3_id)
361	326	{
362	327	//  printf("Sonora ID register read, PC=%x\n", cpu_get_pc(space->cpu));
r9404	r9405
415	380	static ADDRESS_MAP_START(maclc_map, ADDRESS_SPACE_PROGRAM, 32)
416	381	AM_RANGE(0x00a00000, 0x00a7ffff) AM_ROM AM_REGION("bootrom", 0)   // ROM (in 32-bit mode)
417	382
	383	AM_RANGE(0xf00000, 0xf01fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff)
	384	AM_RANGE(0xf04000, 0xf05fff) AM_READWRITE16(mac_scc_r, mac_scc_2_w, 0xffffffff)
	385	AM_RANGE(0xf06000, 0xf06003) AM_WRITE(macii_scsi_drq_w) AM_MIRROR(0x00f00000)
	386	AM_RANGE(0xf10000, 0xf11fff) AM_READWRITE16(macplus_scsi_r, macii_scsi_w, 0xffffffff) AM_MIRROR(0x00f00000)
	387	AM_RANGE(0xf12060, 0xf12063) AM_READ(macii_scsi_drq_r) AM_MIRROR(0x00f00000)
	388	AM_RANGE(0xf14000, 0xf15fff) AM_READ8(mac_asc_r, 0xffffffff) AM_WRITE8(mac_asc_w, 0xffffffff)
	389	AM_RANGE(0xf16000, 0xf17fff) AM_READWRITE16(mac_iwm_r, mac_iwm_w, 0xffffffff) AM_MIRROR(0x00f00000)
	390	AM_RANGE(0xf24000, 0xf24003) AM_READWRITE(rbv_ramdac_r, rbv_ramdac_w)
	391	AM_RANGE(0xf26000, 0xf27fff) AM_READWRITE8(mac_rbv_r, mac_rbv_w, 0xffffffff)   // VIA2 (V8)
	392
418	393	AM_RANGE(0x50f00000, 0x50f01fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff)
419	394	AM_RANGE(0x50f04000, 0x50f05fff) AM_READWRITE16(mac_scc_r, mac_scc_2_w, 0xffffffff)
420		// 50f06000-7fff = SCSI handshake
421
422		// 50f10000-1fff = SCSI
423		// 50f12000-3fff = SCSI DMA
	395	AM_RANGE(0x50f06000, 0x50f06003) AM_WRITE(macii_scsi_drq_w) AM_MIRROR(0x00f00000)
	396	AM_RANGE(0x50f10000, 0x50f11fff) AM_READWRITE16(macplus_scsi_r, macii_scsi_w, 0xffffffff) AM_MIRROR(0x00f00000)
	397	AM_RANGE(0x50f12060, 0x50f12063) AM_READ(macii_scsi_drq_r) AM_MIRROR(0x00f00000)
424	398	AM_RANGE(0x50f14000, 0x50f15fff) AM_READ8(mac_asc_r, 0xffffffff) AM_WRITE8(mac_asc_w, 0xffffffff)
425		AM_RANGE(0x50f16000, 0x50f17fff) AM_READ(mac_swim_r) AM_WRITENOP
426		// 50f18000-9fff = PWMs
427
428		// 50f24000-5fff = VDAC (palette)
429		AM_RANGE(0x50f24000, 0x50f24003) AM_WRITE(mac_v8_ramdac_w)
430		AM_RANGE(0x50f26000, 0x50f27fff) AM_READWRITE16(mac_v8_r, mac_v8_w, 0xffffffff)   // VIA2 (V8)
431
432		AM_RANGE(0x50f40000, 0x50fbffff) AM_RAM   // V8 VRAM
	399	AM_RANGE(0x50f16000, 0x50f17fff) AM_READWRITE16(mac_iwm_r, mac_iwm_w, 0xffffffff) AM_MIRROR(0x00f00000)
	400	AM_RANGE(0x50f24000, 0x50f24003) AM_READWRITE(rbv_ramdac_r,rbv_ramdac_w)
	401	AM_RANGE(0x50f26000, 0x50f27fff) AM_READWRITE8(mac_rbv_r, mac_rbv_w, 0xffffffff)   // VIA2 (V8)
	402	AM_RANGE(0x50f40000, 0x50fbffff) AM_RAM AM_BASE_MEMBER(mac_state, rbv_vram)
433	403	ADDRESS_MAP_END
434	404
435	405	static ADDRESS_MAP_START(maclc3_map, ADDRESS_SPACE_PROGRAM, 32)
r9404	r9405
438	408	AM_RANGE(0x50000000, 0x50001fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff) AM_MIRROR(0x00f00000)
439	409	AM_RANGE(0x50004000, 0x50005fff) AM_READWRITE16(mac_scc_r, mac_scc_2_w, 0xffffffff) AM_MIRROR(0x00f00000)
440	410	AM_RANGE(0x50014000, 0x50015fff) AM_READ8(mac_asc_r, 0xffffffff) AM_WRITE8(mac_asc_w, 0xffffffff) AM_MIRROR(0x00f00000)
441		AM_RANGE(0x50016000, 0x50017fff) AM_READ(mac_swim_r) AM_WRITENOP AM_MIRROR(0x00f00000)
	411	AM_RANGE(0x50016000, 0x50017fff) AM_READWRITE16(mac_iwm_r, mac_iwm_w, 0xffffffff) AM_MIRROR(0x00f00000)
442	412	AM_RANGE(0x50024000, 0x50024007) AM_WRITE( rbv_ramdac_w ) AM_MIRROR(0x00f00000)
443	413	AM_RANGE(0x50026000, 0x50027fff) AM_READWRITE16(mac_rbv_r, mac_rbv_w, 0xffffffff) AM_MIRROR(0x00f00000)
	414	AM_RANGE(0x50028000, 0x50028003) AM_READWRITE8(mac_sonora_vctl_r, mac_sonora_vctl_w, 0xffffffff) AM_MIRROR(0x00f00000)
444	415
445	416	AM_RANGE(0x5ffffffc, 0x5fffffff) AM_READ(mac_lc3_id)
446	417
r9404	r9405
503	474	AM_RANGE(0xfeffe000, 0xfeffffff) AM_ROM AM_REGION("se30vrom", 0x0)
504	475	ADDRESS_MAP_END
505	476
506		static ADDRESS_MAP_START(macclas2_map, ADDRESS_SPACE_PROGRAM, 32)
507		AM_RANGE(0x40000000, 0x4007ffff) AM_ROM AM_REGION("bootrom", 0) AM_MIRROR(0x0ff80000)
508
509		AM_RANGE(0x50000000, 0x50001fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff) AM_MIRROR(0x00f00000)
510		AM_RANGE(0x50002000, 0x50003fff) AM_READWRITE16(mac_via2_r, mac_via2_w, 0xffffffff) AM_MIRROR(0x00f00000)
511		AM_RANGE(0x50004000, 0x50005fff) AM_READWRITE16(mac_scc_r, mac_scc_2_w, 0xffffffff) AM_MIRROR(0x00f00000)
512		AM_RANGE(0x50010000, 0x50011fff) AM_READWRITE16(macplus_scsi_r, macii_scsi_w, 0xffffffff) AM_MIRROR(0x00f00000)
513		AM_RANGE(0x50006000, 0x50006003) AM_WRITE(macii_scsi_drq_w) AM_MIRROR(0x00f00000)
514		AM_RANGE(0x50012060, 0x50012063) AM_READ(macii_scsi_drq_r) AM_MIRROR(0x00f00000)
515		AM_RANGE(0x50014000, 0x50015fff) AM_READ8(mac_asc_r, 0xffffffff) AM_WRITE8(mac_asc_w, 0xffffffff) AM_MIRROR(0x00f00000)
516		AM_RANGE(0x50016000, 0x50017fff) AM_READ(mac_swim_r) AM_WRITENOP AM_MIRROR(0x00f00000)
517		AM_RANGE(0x50040000, 0x50041fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff) AM_MIRROR(0x00f00000)   // mirror
518		ADDRESS_MAP_END
519
520	477	static ADDRESS_MAP_START(pwrmac_map, ADDRESS_SPACE_PROGRAM, 64)
521		AM_RANGE(0x40000000, 0x4003ffff) AM_ROM AM_REGION("bootrom", 0) AM_MIRROR(0x0ffc0000)
	478	AM_RANGE(0x40000000, 0x403fffff) AM_ROM AM_REGION("bootrom", 0) AM_MIRROR(0x0fc00000)
522	479
523	480	AM_RANGE(0x50000000, 0x50001fff) AM_READWRITE16(mac_via_r, mac_via_w, U64(0xffffffffffffffff)) AM_MIRROR(0x00f00000)
524	481	AM_RANGE(0x50002000, 0x50003fff) AM_READWRITE16(mac_via2_r, mac_via2_w, U64(0xffffffffffffffff)) AM_MIRROR(0x00f00000)
r9404	r9405
774	731	/* internal ram */
775	732	MDRV_RAM_ADD("messram")
776	733	MDRV_RAM_DEFAULT_SIZE("2M")
777		MDRV_RAM_EXTRA_OPTIONS("8M,12M,16M,20M")
	734	MDRV_RAM_EXTRA_OPTIONS("8M,32M,64M,96M,128M")
778	735	MACHINE_CONFIG_END
779	736
780	737	static MACHINE_CONFIG_DERIVED( maclc, macii )
r9404	r9405
784	741
785	742	MDRV_PALETTE_LENGTH(256)
786	743
787		MDRV_VIDEO_START(maclc)
788		MDRV_VIDEO_UPDATE(maclc)
	744	MDRV_VIDEO_START(macv8)
	745	MDRV_VIDEO_UPDATE(macrbvvram)
789	746
790	747	MDRV_RAM_MODIFY("messram")
791	748	MDRV_RAM_DEFAULT_SIZE("2M")
r9404	r9405
831	788
832	789	MDRV_RAM_MODIFY("messram")
833	790	MDRV_RAM_DEFAULT_SIZE("2M")
834		MDRV_RAM_EXTRA_OPTIONS("8M,16M,32M,48M,64M,96M,128M")
	791	MDRV_RAM_EXTRA_OPTIONS("8M,32M,64M,96M,128M")
835	792	MACHINE_CONFIG_END
836	793
837	794	static MACHINE_CONFIG_START( macse30, mac_state )
r9404	r9405
891	848	static MACHINE_CONFIG_DERIVED( macclas2, maclc )
892	849
893	850	MDRV_CPU_REPLACE("maincpu", M68030, 7833600*2)
894		MDRV_CPU_PROGRAM_MAP(macclas2_map)
	851	MDRV_CPU_PROGRAM_MAP(maclc_map)
895	852
896		MDRV_VIDEO_START(maclc)
897		MDRV_VIDEO_UPDATE(maclc)
	853	MDRV_VIDEO_START(macv8)
	854	MDRV_VIDEO_UPDATE(macrbv)
898	855
899	856	MDRV_ASC_REPLACE("asc", C15M, ASC_TYPE_EAGLE, mac_asc_irq)
900	857	MDRV_SOUND_ROUTE(0, "lspeaker", 1.0)
901	858	MDRV_SOUND_ROUTE(1, "rspeaker", 1.0)
	859
	860	MDRV_RAM_MODIFY("messram")
	861	MDRV_RAM_DEFAULT_SIZE("10M")
	862	MDRV_RAM_EXTRA_OPTIONS("2M,4M,6M,8M,10M")
902	863	MACHINE_CONFIG_END
903	864
904	865	static MACHINE_CONFIG_DERIVED( maciici, macii )
r9404	r9405
910	871	MDRV_PALETTE_LENGTH(256)
911	872
912	873	MDRV_VIDEO_START(macrbv)
	874	MDRV_VIDEO_RESET(macrbv)
913	875	MDRV_VIDEO_UPDATE(macrbv)
914	876
915	877	MDRV_SCREEN_MODIFY("screen")
	878	MDRV_DEFAULT_LAYOUT(layout_lcd)
	879	MDRV_SCREEN_SIZE(640, 870)
916	880	MDRV_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
917	881
918	882	/* internal ram */
919	883	MDRV_RAM_MODIFY("messram")
920	884	MDRV_RAM_DEFAULT_SIZE("2M")
921		MDRV_RAM_EXTRA_OPTIONS("4M,8M,16M,32M,48M,64M,128M")
	885	MDRV_RAM_EXTRA_OPTIONS("4M,8M,16M,32M,48M,64M")
922	886	MACHINE_CONFIG_END
923	887
924	888	static MACHINE_CONFIG_DERIVED( maciisi, macii )
r9404	r9405
929	893	MDRV_PALETTE_LENGTH(256)
930	894
931	895	MDRV_VIDEO_START(macrbv)
	896	MDRV_VIDEO_RESET(macrbv)
932	897	MDRV_VIDEO_UPDATE(macrbv)
933	898
	899	MDRV_SCREEN_MODIFY("screen")
	900	MDRV_DEFAULT_LAYOUT(layout_lcd)
	901	MDRV_SCREEN_SIZE(640, 870)
	902	MDRV_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
	903
934	904	/* internal ram */
935	905	MDRV_RAM_MODIFY("messram")
936	906	MDRV_RAM_DEFAULT_SIZE("2M")
r9404	r9405
957	927	MDRV_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
958	928	MDRV_PALETTE_LENGTH(256)
959	929
960		MDRV_VIDEO_START(maclc)
961		MDRV_VIDEO_UPDATE(maclc)
	930	MDRV_VIDEO_START(macsonora)
	931	MDRV_VIDEO_UPDATE(macrbv)
962	932
963	933	/* sound hardware */
964	934	MDRV_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
r9404	r9405
1236	1206	PORT_BIT(0xE000, IP_ACTIVE_HIGH, IPT_UNUSED)
1237	1207	INPUT_PORTS_END
1238	1208
	1209	INPUT_PORTS_START( maciici )
	1210	PORT_INCLUDE(macadb)
1239	1211
	1212	PORT_START("MONTYPE")
	1213	PORT_CONFNAME(0x0f, 0x06, "Connected monitor")
	1214	PORT_CONFSETTING( 0x01, "15\" Portrait Display (640x870)")
	1215	PORT_CONFSETTING( 0x02, "12\" RGB (512x384)")
	1216	PORT_CONFSETTING( 0x06, "13\" RGB (640x480)")
	1217	INPUT_PORTS_END
	1218
1240	1219	/***************************************************************************
1241	1220
1242	1221	Game driver(s)
r9404	r9405
1352	1331
1353	1332	ROM_START( maclc2 )
1354	1333	ROM_REGION32_BE(0x80000, "bootrom", 0)
1355		ROM_LOAD( "35c28f5f.rom", 0x000000, 0x080000, CRC(a92145b3) SHA1(d5786182b62a8ffeeb9fd3f80b5511dba70318a0) )
	1334	ROM_LOAD32_BYTE( "341-0476_ue2-hh.bin", 0x000000, 0x020000, CRC(0c3b0ce4) SHA1(e4e8c883d7f2e002a3f7b7aefaa3840991e57025) )
	1335	ROM_LOAD32_BYTE( "341-0475_ud2-mh.bin", 0x000001, 0x020000, CRC(7b013595) SHA1(0b82d8fac570270db9774f6254017d28611ae756) )
	1336	ROM_LOAD32_BYTE( "341-0474_uc2-ml.bin", 0x000002, 0x020000, CRC(2ff2f52b) SHA1(876850df61d0233c1dd3c00d48d8d6690186b164) )
	1337	ROM_LOAD32_BYTE( "341-0473_ub2-ll.bin", 0x000003, 0x020000, CRC(8843c37c) SHA1(bb5104110507ca543d106f11c6061245fd90c1a7) )
1356	1338	ROM_END
1357	1339
1358	1340	ROM_START( maclc3 )
r9404	r9405
1388	1370	COMP( 1989, macprtb,  0,        0,      macprtb,  macadb,   macprtb,  "Apple Computer", "Macintosh Portable", GAME_NOT_WORKING )
1389	1371	COMP( 1989, macse30,  mac2fdhd, 0,   macse30,  macadb,   macse30,     "Apple Computer", "Macintosh SE/30",  0 )
1390	1372	COMP( 1989, maciicx,  mac2fdhd, 0,   maciix,   macadb,   maciicx,     "Apple Computer", "Macintosh IIcx",  0 )
1391		COMP( 1989, maciici,  0,   0,   maciici,  macadb,   maciici,         "Apple Computer", "Macintosh IIci", 0 )
	1373	COMP( 1989, maciici,  0,   0,   maciici,  maciici,  maciici,         "Apple Computer", "Macintosh IIci", 0 )
1392	1374	COMP( 1990, macclasc, 0,   0,   macse,    macadb,   macclassic,         "Apple Computer", "Macintosh Classic",  GAME_NOT_WORKING )
1393		COMP( 1990, maclc,    0,   0,   maclc,    macadb,   maclc,             "Apple Computer", "Macintosh LC",  GAME_NOT_WORKING )
1394		COMP( 1990, maciisi,  0,   0,   maciisi,  macadb,   maciisi,         "Apple Computer", "Macintosh IIsi",  GAME_NOT_WORKING )
	1375	COMP( 1990, maclc,    0,   0,   maclc,    maciici,  maclc,             "Apple Computer", "Macintosh LC",  GAME_NOT_WORKING )
	1376	COMP( 1990, maciisi,  0,   0,   maciisi,  maciici,  maciisi,         "Apple Computer", "Macintosh IIsi",  GAME_NOT_WORKING )
1395	1377	COMP( 1991, macpb100, 0,        0,      macprtb,  macadb,   macprtb,  "Apple Computer", "Macintosh PowerBook 100", GAME_NOT_WORKING )
1396	1378	COMP( 1991, macclas2, 0,   0,   macclas2, macadb,   macclassic2,      "Apple Computer", "Macintosh Classic II",  GAME_NOT_WORKING )
1397		COMP( 1991, maclc2,   0,   0,   maclc2,   macadb,   maclc2,             "Apple Computer", "Macintosh LC II",  GAME_NOT_WORKING )
1398		COMP( 1993, maclc3,   0,   0,   maclc3,   macadb,   maclc3,             "Apple Computer", "Macintosh LC III",  GAME_NOT_WORKING )
	1379	COMP( 1991, maclc2,   0,   0,   maclc2,   maciici,  maclc2,             "Apple Computer", "Macintosh LC II",  GAME_NOT_WORKING )
	1380	COMP( 1993, maclc3,   0,   0,   maclc3,   maciici,  maclc3,             "Apple Computer", "Macintosh LC III",  GAME_NOT_WORKING )
1399	1381	COMP( 1994, pmac6100, 0,   0,   pwrmac,   macadb,   macpm6100,         "Apple Computer", "Power Macintosh 6100",  GAME_NOT_WORKING | GAME_NO_SOUND )
1400	1382

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team