--- SheepShaver/src/rom_patches.cpp	2003/12/15 15:25:38	1.22
+++ SheepShaver/src/rom_patches.cpp	2006/05/14 13:48:05	1.44
@@ -1,7 +1,7 @@
 /*
  *  rom_patches.cpp - ROM patches
  *
- *  SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig
+ *  SheepShaver (C) 1997-2005 Christian Bauer and Marc Hellwig
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -148,7 +148,7 @@ bool DecodeROM(uint8 *data, uint32 size)
 {
 	if (size == ROM_SIZE) {
 		// Plain ROM image
-		memcpy((void *)ROM_BASE, data, ROM_SIZE);
+		memcpy(ROMBaseHost, data, ROM_SIZE);
 		return true;
 	}
 	else if (strncmp((char *)data, "<CHRP-BOOT>", 11) == 0) {
@@ -186,12 +186,12 @@ bool DecodeROM(uint8 *data, uint32 size)
 		if (rom_signature == FOURCC('p','r','c','l')) {
 			D(bug("Offset of parcels data: %08x\n", image_offset));
 			D(bug("Size of parcels data: %08x\n", image_size));
-			decode_parcels(data + image_offset, (uint8 *)ROM_BASE, image_size);
+			decode_parcels(data + image_offset, ROMBaseHost, image_size);
 		}
 		else {
 			D(bug("Offset of compressed data: %08x\n", image_offset));
 			D(bug("Size of compressed data: %08x\n", image_size));
-			decode_lzss(data + image_offset, (uint8 *)ROM_BASE, image_size);
+			decode_lzss(data + image_offset, ROMBaseHost, image_size);
 		}
 		return true;
 	}
@@ -207,7 +207,7 @@ static uint32 find_rom_data(uint32 start
 {
 	uint32 ofs = start;
 	while (ofs < end) {
-		if (!memcmp((void *)(ROM_BASE + ofs), data, data_len))
+		if (!memcmp(ROMBaseHost + ofs, data, data_len))
 			return ofs;
 		ofs++;
 	}
@@ -224,10 +224,9 @@ static uint32 rsrc_ptr = 0;
 // id = 4711 means "find any ID"
 static uint32 find_rom_resource(uint32 s_type, int16 s_id = 4711, bool cont = false)
 {
-	uint32 *lp = (uint32 *)(ROM_BASE + 0x1a);
-	uint32 x = ntohl(*lp);
-	uint8 *bp = (uint8 *)(ROM_BASE + x + 5);
-	uint32 header_size = *bp;
+	uint32 lp = ROM_BASE + 0x1a;
+	uint32 x = ReadMacInt32(lp);
+	uint32 header_size = ReadMacInt8(ROM_BASE + x + 5);
 
 	if (!cont)
 		rsrc_ptr = x;
@@ -235,17 +234,17 @@ static uint32 find_rom_resource(uint32 s
 		return 0;
 
 	for (;;) {
-		lp = (uint32 *)(ROM_BASE + rsrc_ptr);
-		rsrc_ptr = ntohl(*lp);
+		lp = ROM_BASE + rsrc_ptr;
+		rsrc_ptr = ReadMacInt32(lp);
 		if (rsrc_ptr == 0)
 			break;
 
 		rsrc_ptr += header_size;
 
-		lp = (uint32 *)(ROM_BASE + rsrc_ptr + 4);
-		uint32 data = ntohl(*lp); lp++;
-		uint32 type = ntohl(*lp); lp++;
-		int16 id = ntohs(*(int16 *)lp);
+		lp = ROM_BASE + rsrc_ptr + 4;
+		uint32 data = ReadMacInt32(lp);
+		uint32 type = ReadMacInt32(lp + 4);
+		int16 id = ReadMacInt16(lp + 8);
 		if (type == s_type && (id == s_id || s_id == 4711))
 			return data;
 	}
@@ -259,13 +258,12 @@ static uint32 find_rom_resource(uint32 s
 
 static uint32 find_rom_trap(uint16 trap)
 {
-	uint32 *lp = (uint32 *)(ROM_BASE + 0x22);
-	lp = (uint32 *)(ROM_BASE + ntohl(*lp));
+	uint32 lp = ROM_BASE + ReadMacInt32(ROM_BASE + 0x22);
 
 	if (trap > 0xa800)
-		return ntohl(lp[trap & 0x3ff]);
+		return ReadMacInt32(lp + 4 * (trap & 0x3ff));
 	else
-		return ntohl(lp[(trap & 0xff) + 0x400]);
+		return ReadMacInt32(lp + 4 * ((trap & 0xff) + 0x400));
 }
 
 
@@ -274,9 +272,9 @@ static uint32 find_rom_trap(uint16 trap)
  *  there is no such instruction
  */
 
-static uint32 powerpc_branch_target(uintptr addr)
+static uint32 rom_powerpc_branch_target(uint32 addr)
 {
-	uint32 opcode = ntohl(*(uint32 *)addr);
+	uint32 opcode = ntohl(*(uint32 *)(ROMBaseHost + addr));
 	uint32 primop = opcode >> 26;
 	uint32 target = 0;
 
@@ -303,7 +301,7 @@ static uint32 powerpc_branch_target(uint
 static uint32 find_rom_powerpc_branch(uint32 start, uint32 end, uint32 target)
 {
 	for (uint32 addr = start; addr < end; addr += 4) {
-		if (powerpc_branch_target(ROM_BASE + addr) == ROM_BASE + target)
+		if (rom_powerpc_branch_target(addr) == target)
 			return addr;
 	}
 	return 0;
@@ -318,8 +316,7 @@ static bool check_rom_patch_space(uint32
 {
 	size = (size + 3) & -4;
 	for (int i = 0; i < size; i += 4) {
-		uint32 x = ntohl(*(uint32 *)(ROM_BASE + base + i));
-		printf("%08x\n", x);
+		uint32 x = ntohl(*(uint32 *)(ROMBaseHost + base + i));
 		if (x != 0x6b636b63 && x != 0)
 			return false;
 	}
@@ -690,25 +687,25 @@ static inline void memcpy_powerpc_code(v
 bool PatchROM(void)
 {
 	// Print ROM info
-	D(bug("Checksum: %08lx\n", ntohl(*(uint32 *)ROM_BASE)));
-	D(bug("Version: %04x\n", ntohs(*(uint16 *)(ROM_BASE + 8))));
-	D(bug("Sub Version: %04x\n", ntohs(*(uint16 *)(ROM_BASE + 18))));
-	D(bug("Nanokernel ID: %s\n", (char *)ROM_BASE + 0x30d064));
-	D(bug("Resource Map at %08lx\n", ntohl(*(uint32 *)(ROM_BASE + 26))));
-	D(bug("Trap Tables at %08lx\n\n", ntohl(*(uint32 *)(ROM_BASE + 34))));
+	D(bug("Checksum: %08lx\n", ntohl(*(uint32 *)ROMBaseHost)));
+	D(bug("Version: %04x\n", ntohs(*(uint16 *)(ROMBaseHost + 8))));
+	D(bug("Sub Version: %04x\n", ntohs(*(uint16 *)(ROMBaseHost + 18))));
+	D(bug("Nanokernel ID: %s\n", (char *)ROMBaseHost + 0x30d064));
+	D(bug("Resource Map at %08lx\n", ntohl(*(uint32 *)(ROMBaseHost + 26))));
+	D(bug("Trap Tables at %08lx\n\n", ntohl(*(uint32 *)(ROMBaseHost + 34))));
 
 	// Detect ROM type
-	if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot TNT", 8))
+	if (!memcmp(ROMBaseHost + 0x30d064, "Boot TNT", 8))
 		ROMType = ROMTYPE_TNT;
-	else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Alchemy", 12))
+	else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Alchemy", 12))
 		ROMType = ROMTYPE_ALCHEMY;
-	else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Zanzibar", 13))
+	else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Zanzibar", 13))
 		ROMType = ROMTYPE_ZANZIBAR;
-	else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Gazelle", 12))
+	else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Gazelle", 12))
 		ROMType = ROMTYPE_GAZELLE;
-	else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Gossamer", 13))
+	else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Gossamer", 13))
 		ROMType = ROMTYPE_GOSSAMER;
-	else if (!memcmp((void *)(ROM_BASE + 0x30d064), "NewWorld", 8))
+	else if (!memcmp(ROMBaseHost + 0x30d064, "NewWorld", 8))
 		ROMType = ROMTYPE_NEWWORLD;
 	else
 		return false;
@@ -731,19 +728,19 @@ bool PatchROM(void)
 
 #ifdef M68K_BREAK_POINT
 	// Install 68k breakpoint
-	uint16 *wp = (uint16 *)(ROM_BASE + M68K_BREAK_POINT);
+	uint16 *wp = (uint16 *)(ROMBaseHost + M68K_BREAK_POINT);
 	*wp++ = htons(M68K_EMUL_BREAK);
 	*wp = htons(M68K_EMUL_RETURN);
 #endif
 
 #ifdef POWERPC_BREAK_POINT
 	// Install PowerPC breakpoint
-	uint32 *lp = (uint32 *)(ROM_BASE + POWERPC_BREAK_POINT);
+	uint32 *lp = (uint32 *)(ROMBaseHost + POWERPC_BREAK_POINT);
 	*lp = htonl(0);
 #endif
 
 	// Copy 68k emulator to 2MB boundary
-	memcpy((void *)(ROM_BASE + ROM_SIZE), (void *)(ROM_BASE + ROM_SIZE - 0x100000), 0x100000);
+	memcpy(ROMBaseHost + ROM_SIZE, ROMBaseHost + (ROM_SIZE - 0x100000), 0x100000);
 	return true;
 }
 
@@ -758,7 +755,7 @@ static bool patch_nanokernel_boot(void)
 	uint32 base, loc;
 
 	// ROM boot structure patches
-	lp = (uint32 *)(ROM_BASE + 0x30d000);
+	lp = (uint32 *)(ROMBaseHost + 0x30d000);
 	lp[0x9c >> 2] = htonl(KernelDataAddr);			// LA_InfoRecord
 	lp[0xa0 >> 2] = htonl(KernelDataAddr);			// LA_KernelData
 	lp[0xa4 >> 2] = htonl(KernelDataAddr + 0x1000);	// LA_EmulatorData
@@ -770,16 +767,16 @@ static bool patch_nanokernel_boot(void)
 	// Skip SR/BAT/SDR init
 	loc = 0x310000;
 	if (ROMType == ROMTYPE_GAZELLE || ROMType == ROMTYPE_GOSSAMER || ROMType == ROMTYPE_NEWWORLD) {
-		lp = (uint32 *)(ROM_BASE + loc);
+		lp = (uint32 *)(ROMBaseHost + loc);
 		*lp++ = htonl(POWERPC_NOP);
 		*lp = htonl(0x38000000);
 	}
 	static const uint8 sr_init_dat[] = {0x35, 0x4a, 0xff, 0xfc, 0x7d, 0x86, 0x50, 0x2e};
 	if ((base = find_rom_data(0x3101b0, 0x3105b0, sr_init_dat, sizeof(sr_init_dat))) == 0) return false;
 	D(bug("sr_init %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + loc + 8);
+	lp = (uint32 *)(ROMBaseHost + loc + 8);
 	*lp = htonl(0x48000000 | ((base - loc - 8) & 0x3fffffc));	// b		ROM_BASE+0x3101b0
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp++ = htonl(0x80200000 + XLM_KERNEL_DATA);		// lwz	r1,(pointer to Kernel Data)
 	*lp++ = htonl(0x3da0dead);		// lis	r13,0xdead	(start of kernel memory)
 	*lp++ = htonl(0x3dc00010);		// lis	r14,0x0010	(size of page table)
@@ -789,7 +786,7 @@ static bool patch_nanokernel_boot(void)
 	static const uint8 pvr_read_dat[] = {0x7d, 0x9f, 0x42, 0xa6};
 	if ((base = find_rom_data(0x3103b0, 0x3108b0, pvr_read_dat, sizeof(pvr_read_dat))) == 0) return false;
 	D(bug("pvr_read %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp = htonl(0x81800000 + XLM_PVR);	// lwz	r12,(theoretical PVR)
 
 	// Set CPU specific data (even if ROM doesn't have support for that CPU)
@@ -798,9 +795,9 @@ static bool patch_nanokernel_boot(void)
 	uint32 ofs = ntohl(lp[7]) & 0xffff;
 	D(bug("ofs %08lx\n", ofs));
 	lp[8] = htonl((ntohl(lp[8]) & 0xffff) | 0x48000000);	// beq -> b
-	loc = (ntohl(lp[8]) & 0xffff) + (uint32)(lp+8) - ROM_BASE;
+	loc = (ntohl(lp[8]) & 0xffff) + (uintptr)(lp+8) - (uintptr)ROMBaseHost;
 	D(bug("loc %08lx\n", loc));
-	lp = (uint32 *)(ROM_BASE + ofs + 0x310000);
+	lp = (uint32 *)(ROMBaseHost + ofs + 0x310000);
 	switch (PVR >> 16) {
 		case 1:		// 601
 			lp[0] = htonl(0x1000);		// Page size
@@ -848,7 +845,8 @@ static bool patch_nanokernel_boot(void)
 			lp[7] = htonl(0x00040004);	// Inst cache assoc/Data cache assoc
 			lp[8] = htonl(0x00400002);	// TLB total size/TLB assoc
 			break;
-		case 8:		// 750
+		case 8:		// 750, 750FX
+		case 0x7000:
 			lp[0] = htonl(0x1000);		// Page size
 			lp[1] = htonl(0x8000);		// Data cache size
 			lp[2] = htonl(0x8000);		// Inst cache size
@@ -872,7 +870,11 @@ static bool patch_nanokernel_boot(void)
 			lp[8] = htonl(0x00800002);	// TLB total size/TLB assoc
 			break;
 //		case 11:	// X704?
-		case 12:	// ???
+		case 12:	// 7400, 7410, 7450, 7455, 7457
+		case 0x800c:
+		case 0x8000:
+		case 0x8001:
+		case 0x8002:
 			lp[0] = htonl(0x1000);		// Page size
 			lp[1] = htonl(0x8000);		// Data cache size
 			lp[2] = htonl(0x8000);		// Inst cache size
@@ -907,6 +909,17 @@ static bool patch_nanokernel_boot(void)
 			lp[7] = htonl(0x00080008);	// Inst cache assoc/Data cache assoc
 			lp[8] = htonl(0x00800004);	// TLB total size/TLB assoc
 			break;
+		case 0x39:	// 970
+			lp[0] = htonl(0x1000);		// Page size
+			lp[1] = htonl(0x8000);		// Data cache size
+			lp[2] = htonl(0x10000);		// Inst cache size
+			lp[3] = htonl(0x00200020);	// Coherency block size/Reservation granule size
+			lp[4] = htonl(0x00010020);	// Unified caches/Inst cache line size
+			lp[5] = htonl(0x00200020);	// Data cache line size/Data cache block size touch
+			lp[6] = htonl(0x00800080);	// Inst cache block size/Data cache block size
+			lp[7] = htonl(0x00020002);	// Inst cache assoc/Data cache assoc
+			lp[8] = htonl(0x02000004);	// TLB total size/TLB assoc
+			break;
 		default:
 			printf("WARNING: Unknown CPU type\n");
 			break;
@@ -916,7 +929,7 @@ static bool patch_nanokernel_boot(void)
 	static const uint8 sprg3_mq_dat[] = {0x7d, 0x13, 0x43, 0xa6, 0x3d, 0x00, 0x00, 0x04, 0x7d, 0x00, 0x03, 0xa6, 0x39, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x02, 0xa6};
 	if ((base = find_rom_data(loc + 0x20, loc + 0x60, sprg3_mq_dat, sizeof(sprg3_mq_dat))) == 0) return false;
 	D(bug("sprg3/mq %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	lp[0] = htonl(POWERPC_NOP);
 	lp[2] = htonl(POWERPC_NOP);
 	lp[4] = htonl(POWERPC_NOP);
@@ -925,43 +938,43 @@ static bool patch_nanokernel_boot(void)
 	static const uint8 msr_dat[] = {0x7d, 0xc0, 0x00, 0xa6};
 	if ((base = find_rom_data(loc + 0x40, loc + 0x80, msr_dat, sizeof(msr_dat))) == 0) return false;
 	D(bug("msr %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp = htonl(0x39c00000);		// li	r14,0
 
 	// Don't write to DEC
-	lp = (uint32 *)(ROM_BASE + loc + 0x70);
+	lp = (uint32 *)(ROMBaseHost + loc + 0x70);
 	*lp++ = htonl(POWERPC_NOP);
-	loc = (ntohl(lp[0]) & 0xffff) + (uint32)lp - ROM_BASE;
+	loc = (ntohl(lp[0]) & 0xffff) + (uintptr)lp - (uintptr)ROMBaseHost;
 	D(bug("loc %08lx\n", loc));
 
 	// Don't set SPRG3
 	static const uint8 sprg3_dat[] = {0x39, 0x21, 0x03, 0x60, 0x7d, 0x33, 0x43, 0xa6, 0x39, 0x01, 0x04, 0x20};
 	if ((base = find_rom_data(0x310000, 0x314000, sprg3_dat, sizeof(sprg3_dat))) == 0) return false;
 	D(bug("sprg3 %08lx\n", base + 4));
-	lp = (uint32 *)(ROM_BASE + base + 4);
+	lp = (uint32 *)(ROMBaseHost + base + 4);
 	*lp = htonl(POWERPC_NOP);
 
 	// Don't read PVR
 	static const uint8 pvr_read2_dat[] = {0x7e, 0xff, 0x42, 0xa6, 0x56, 0xf7, 0x84, 0x3e};
 	if ((base = find_rom_data(0x310000, 0x320000, pvr_read2_dat, sizeof(pvr_read2_dat))) == 0) return false;
 	D(bug("pvr_read2 %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp = htonl(0x82e00000 + XLM_PVR);		// lwz	r23,(theoretical PVR)
 	if ((base = find_rom_data(base + 4, 0x320000, pvr_read2_dat, sizeof(pvr_read2_dat))) != 0) {
 		D(bug("pvr_read2 %08lx\n", base));
-		lp = (uint32 *)(ROM_BASE + base);
+		lp = (uint32 *)(ROMBaseHost + base);
 		*lp = htonl(0x82e00000 + XLM_PVR);	// lwz	r23,(theoretical PVR)
 	}
 	static const uint8 pvr_read3_dat[] = {0x7e, 0x5f, 0x42, 0xa6, 0x56, 0x52, 0x84, 0x3e};
 	if ((base = find_rom_data(0x310000, 0x320000, pvr_read3_dat, sizeof(pvr_read3_dat))) != 0) {
 		D(bug("pvr_read3 %08lx\n", base));
-		lp = (uint32 *)(ROM_BASE + base);
+		lp = (uint32 *)(ROMBaseHost + base);
 		*lp = htonl(0x82400000 + XLM_PVR);	// lwz	r18,(theoretical PVR)
 	}
 	static const uint8 pvr_read4_dat[] = {0x7d, 0x3f, 0x42, 0xa6, 0x55, 0x29, 0x84, 0x3e};
 	if ((base = find_rom_data(0x310000, 0x320000, pvr_read4_dat, sizeof(pvr_read4_dat))) != 0) {
 		D(bug("pvr_read4 %08lx\n", base));
-		lp = (uint32 *)(ROM_BASE + base);
+		lp = (uint32 *)(ROMBaseHost + base);
 		*lp = htonl(0x81200000 + XLM_PVR);	// lzw  r9,(theoritical PVR)
 	}
 
@@ -969,7 +982,7 @@ static bool patch_nanokernel_boot(void)
 	static const uint8 sdr1_read_dat[] = {0x7d, 0x19, 0x02, 0xa6, 0x55, 0x16, 0x81, 0xde};
 	if ((base = find_rom_data(0x310000, 0x320000, sdr1_read_dat, sizeof(sdr1_read_dat))) == 0) return false;
 	D(bug("sdr1_read %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp++ = htonl(0x3d00dead);		// lis	r8,0xdead		(pointer to page table)
 	*lp++ = htonl(0x3ec0001f);		// lis	r22,0x001f	(size of page table)
 	*lp = htonl(POWERPC_NOP);
@@ -978,17 +991,17 @@ static bool patch_nanokernel_boot(void)
 	static const uint8 pgtb_clear_dat[] = {0x36, 0xd6, 0xff, 0xfc, 0x7e, 0xe8, 0xb1, 0x2e, 0x41, 0x81, 0xff, 0xf8};
 	if ((base = find_rom_data(0x310000, 0x320000, pgtb_clear_dat, sizeof(pgtb_clear_dat))) == 0) return false;
 	D(bug("pgtb_clear %08lx\n", base + 4));
-	lp = (uint32 *)(ROM_BASE + base + 4);
+	lp = (uint32 *)(ROMBaseHost + base + 4);
 	*lp = htonl(POWERPC_NOP);
 	D(bug("tblie %08lx\n", base + 12));
-	lp = (uint32 *)(ROM_BASE + base + 12);
+	lp = (uint32 *)(ROMBaseHost + base + 12);
 	*lp = htonl(POWERPC_NOP);
 
 	// Don't create RAM descriptor table
 	static const uint8 desc_create_dat[] = {0x97, 0xfd, 0x00, 0x04, 0x3b, 0xff, 0x10, 0x00, 0x4b, 0xff, 0xff, 0xdc};
 	if ((base = find_rom_data(0x310000, 0x320000, desc_create_dat, sizeof(desc_create_dat))) == 0) return false;
 	D(bug("desc_create %08lx\n", base))
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp = htonl(POWERPC_NOP);
 
 	// Don't load SRs and BATs
@@ -998,21 +1011,21 @@ static bool patch_nanokernel_boot(void)
 	if ((base = find_rom_data(0x310000, 0x320000, sr_load_caller, sizeof(sr_load_caller))) == 0) return false;
 	if ((base = find_rom_powerpc_branch(base + 12, 0x320000, loc)) == 0) return false;
 	D(bug("sr_load %08lx, called from %08lx\n", loc, base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp = htonl(POWERPC_NOP);
 
 	// Don't mess with SRs
 	static const uint8 sr_load2_dat[] = {0x83, 0xa1, 0x05, 0xe8, 0x57, 0x7c, 0x3e, 0x78, 0x7f, 0xbd, 0xe0, 0x2e};
 	if ((base = find_rom_data(0x310000, 0x320000, sr_load2_dat, sizeof(sr_load2_dat))) == 0) return false;
 	D(bug("sr_load2 %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp = htonl(POWERPC_BLR);
 
 	// Don't check performance monitor
 	static const uint8 pm_check_dat[] = {0x7e, 0x58, 0xeb, 0xa6, 0x7e, 0x53, 0x90, 0xf8, 0x7e, 0x78, 0xea, 0xa6};
 	if ((base = find_rom_data(0x310000, 0x320000, pm_check_dat, sizeof(pm_check_dat))) == 0) return false;
 	D(bug("pm_check %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	
 	static const int spr_check_list[] = {
 		952 /* mmcr0 */, 953 /* pmc1 */, 954 /* pmc2 */, 955 /* sia */,
@@ -1041,7 +1054,7 @@ static bool patch_nanokernel_boot(void)
 	if ((base = find_rom_data(0x310000, 0x320000, jump68k_caller_dat, sizeof(jump68k_caller_dat))) == 0) return false;
 	if ((base = find_rom_powerpc_branch(base + 12, 0x320000, loc)) == 0) return false;
 	D(bug("jump68k %08lx, called from %08lx\n", loc, base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp++ = htonl(0x80610634);		// lwz	r3,0x0634(r1)	(pointer to Emulator Data)
 	*lp++ = htonl(0x8081119c);		// lwz	r4,0x119c(r1)	(pointer to opcode table)
 	*lp++ = htonl(0x80011184);		// lwz	r0,0x1184(r1)	(pointer to emulator init routine)
@@ -1058,19 +1071,19 @@ static bool patch_nanokernel_boot(void)
 static bool patch_68k_emul(void)
 {
 	uint32 *lp;
-	uint32 base;
+	uint32 base, loc;
 
 	// Overwrite twi instructions
 	static const uint8 twi_dat[] = {0x0f, 0xff, 0x00, 0x00, 0x0f, 0xff, 0x00, 0x01, 0x0f, 0xff, 0x00, 0x02};
 	if ((base = find_rom_data(0x36e600, 0x36ea00, twi_dat, sizeof(twi_dat))) == 0) return false;
 	D(bug("twi %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp++ = htonl(0x48000000 + 0x36f900 - base);		// b 0x36f900 (Emulator start)
 	*lp++ = htonl(0x48000000 + 0x36fa00 - base - 4);	// b 0x36fa00 (Mixed mode)
 	*lp++ = htonl(0x48000000 + 0x36fb00 - base - 8);	// b 0x36fb00 (Reset/FC1E opcode)
 	*lp++ = htonl(0x48000000 + 0x36fc00 - base - 12);	// FE0A opcode
 	*lp++ = htonl(POWERPC_ILLEGAL);						// Interrupt
-	*lp++ = htonl(POWERPC_ILLEGAL);						// ?
+	*lp++ = htonl(0x48000000 + 0x36fd00 - base - 20);	// FE0F opcode
 	*lp++ = htonl(POWERPC_ILLEGAL);
 	*lp++ = htonl(POWERPC_ILLEGAL);
 	*lp++ = htonl(POWERPC_ILLEGAL);
@@ -1084,7 +1097,7 @@ static bool patch_68k_emul(void)
 
 #if EMULATED_PPC
 	// Install EMUL_RETURN, EXEC_RETURN, EXEC_NATIVE and EMUL_OP opcodes
-	lp = (uint32 *)(ROM_BASE + 0x380000 + (M68K_EMUL_RETURN << 3));
+	lp = (uint32 *)(ROMBaseHost + 0x380000 + (M68K_EMUL_RETURN << 3));
 	*lp++ = htonl(POWERPC_EMUL_OP);
 	*lp++ = htonl(0x4bf66e80);							// b	0x366084
 	*lp++ = htonl(POWERPC_EMUL_OP | 1);
@@ -1097,7 +1110,7 @@ static bool patch_68k_emul(void)
 	}
 #else
 	// Install EMUL_RETURN, EXEC_RETURN and EMUL_OP opcodes
-	lp = (uint32 *)(ROM_BASE + 0x380000 + (M68K_EMUL_RETURN << 3));
+	lp = (uint32 *)(ROMBaseHost + 0x380000 + (M68K_EMUL_RETURN << 3));
 	*lp++ = htonl(0x80000000 + XLM_EMUL_RETURN_PROC);	// lwz	r0,XLM_EMUL_RETURN_PROC
 	*lp++ = htonl(0x4bf705fc);							// b	0x36f800
 	*lp++ = htonl(0x80000000 + XLM_EXEC_RETURN_PROC);	// lwz	r0,XLM_EXEC_RETURN_PROC
@@ -1110,7 +1123,7 @@ static bool patch_68k_emul(void)
 	}
 
 	// Extra routines for EMUL_RETURN/EXEC_RETURN/EMUL_OP
-	lp = (uint32 *)(ROM_BASE + 0x36f800);
+	lp = (uint32 *)(ROMBaseHost + 0x36f800);
 	*lp++ = htonl(0x7c0803a6);						// mtlr	r0
 	*lp++ = htonl(0x4e800020);						// blr
 
@@ -1120,15 +1133,11 @@ static bool patch_68k_emul(void)
 #endif
 
 	// Extra routine for 68k emulator start
-	lp = (uint32 *)(ROM_BASE + 0x36f900);
+	lp = (uint32 *)(ROMBaseHost + 0x36f900);
 	*lp++ = htonl(0x7c2903a6);					// mtctr	r1
-#if EMULATED_PPC
-	*lp++ = htonl(NativeOpcode(NATIVE_DISABLE_INTERRUPT));
-#else
 	*lp++ = htonl(0x80200000 + XLM_IRQ_NEST);	// lwz		r1,XLM_IRQ_NEST
 	*lp++ = htonl(0x38210001);					// addi		r1,r1,1
 	*lp++ = htonl(0x90200000 + XLM_IRQ_NEST);	// stw		r1,XLM_IRQ_NEST
-#endif
 	*lp++ = htonl(0x80200000 + XLM_KERNEL_DATA);// lwz		r1,XLM_KERNEL_DATA
 	*lp++ = htonl(0x90c10018);					// stw		r6,0x18(r1)
 	*lp++ = htonl(0x7cc902a6);					// mfctr	r6
@@ -1154,15 +1163,11 @@ static bool patch_68k_emul(void)
 	*lp = htonl(0x4e800020);					// blr
 
 	// Extra routine for Mixed Mode
-	lp = (uint32 *)(ROM_BASE + 0x36fa00);
+	lp = (uint32 *)(ROMBaseHost + 0x36fa00);
 	*lp++ = htonl(0x7c2903a6);					// mtctr	r1
-#if EMULATED_PPC
-	*lp++ = htonl(NativeOpcode(NATIVE_DISABLE_INTERRUPT));
-#else
 	*lp++ = htonl(0x80200000 + XLM_IRQ_NEST);	// lwz		r1,XLM_IRQ_NEST
 	*lp++ = htonl(0x38210001);					// addi		r1,r1,1
 	*lp++ = htonl(0x90200000 + XLM_IRQ_NEST);	// stw		r1,XLM_IRQ_NEST
-#endif
 	*lp++ = htonl(0x80200000 + XLM_KERNEL_DATA);// lwz		r1,XLM_KERNEL_DATA
 	*lp++ = htonl(0x90c10018);					// stw		r6,0x18(r1)
 	*lp++ = htonl(0x7cc902a6);					// mfctr	r6
@@ -1188,15 +1193,11 @@ static bool patch_68k_emul(void)
 	*lp = htonl(0x4e800020);					// blr
 
 	// Extra routine for Reset/FC1E opcode
-	lp = (uint32 *)(ROM_BASE + 0x36fb00);
+	lp = (uint32 *)(ROMBaseHost + 0x36fb00);
 	*lp++ = htonl(0x7c2903a6);					// mtctr	r1
-#if EMULATED_PPC
-	*lp++ = htonl(NativeOpcode(NATIVE_DISABLE_INTERRUPT));
-#else
 	*lp++ = htonl(0x80200000 + XLM_IRQ_NEST);	// lwz		r1,XLM_IRQ_NEST
 	*lp++ = htonl(0x38210001);					// addi		r1,r1,1
 	*lp++ = htonl(0x90200000 + XLM_IRQ_NEST);	// stw		r1,XLM_IRQ_NEST
-#endif
 	*lp++ = htonl(0x80200000 + XLM_KERNEL_DATA);// lwz		r1,XLM_KERNEL_DATA
 	*lp++ = htonl(0x90c10018);					// stw		r6,0x18(r1)
 	*lp++ = htonl(0x7cc902a6);					// mfctr	r6
@@ -1222,15 +1223,11 @@ static bool patch_68k_emul(void)
 	*lp = htonl(0x4e800020);					// blr
 
 	// Extra routine for FE0A opcode (QuickDraw 3D needs this)
-	lp = (uint32 *)(ROM_BASE + 0x36fc00);
+	lp = (uint32 *)(ROMBaseHost + 0x36fc00);
 	*lp++ = htonl(0x7c2903a6);					// mtctr	r1
-#if EMULATED_PPC
-	*lp++ = htonl(NativeOpcode(NATIVE_DISABLE_INTERRUPT));
-#else
 	*lp++ = htonl(0x80200000 + XLM_IRQ_NEST);	// lwz		r1,XLM_IRQ_NEST
 	*lp++ = htonl(0x38210001);					// addi		r1,r1,1
 	*lp++ = htonl(0x90200000 + XLM_IRQ_NEST);	// stw		r1,XLM_IRQ_NEST
-#endif
 	*lp++ = htonl(0x80200000 + XLM_KERNEL_DATA);// lwz		r1,XLM_KERNEL_DATA
 	*lp++ = htonl(0x90c10018);					// stw		r6,0x18(r1)
 	*lp++ = htonl(0x7cc902a6);					// mfctr	r6
@@ -1255,9 +1252,39 @@ static bool patch_68k_emul(void)
 	*lp++ = htonl(0x50e7deb4);					// rlwimi	r7,r7,27,$00000020
 	*lp = htonl(0x4e800020);					// blr
 
+	// Extra routine for FE0F opcode (power management)
+	lp = (uint32 *)(ROMBaseHost + 0x36fd00);
+	*lp++ = htonl(0x7c2903a6);					// mtctr	r1
+	*lp++ = htonl(0x80200000 + XLM_IRQ_NEST);	// lwz		r1,XLM_IRQ_NEST
+	*lp++ = htonl(0x38210001);					// addi		r1,r1,1
+	*lp++ = htonl(0x90200000 + XLM_IRQ_NEST);	// stw		r1,XLM_IRQ_NEST
+	*lp++ = htonl(0x80200000 + XLM_KERNEL_DATA);// lwz		r1,XLM_KERNEL_DATA
+	*lp++ = htonl(0x90c10018);					// stw		r6,0x18(r1)
+	*lp++ = htonl(0x7cc902a6);					// mfctr	r6
+	*lp++ = htonl(0x90c10004);					// stw		r6,$0004(r1)
+	*lp++ = htonl(0x80c1065c);					// lwz		r6,$065c(r1)
+	*lp++ = htonl(0x90e6013c);					// stw		r7,$013c(r6)
+	*lp++ = htonl(0x91060144);					// stw		r8,$0144(r6)
+	*lp++ = htonl(0x9126014c);					// stw		r9,$014c(r6)
+	*lp++ = htonl(0x91460154);					// stw		r10,$0154(r6)
+	*lp++ = htonl(0x9166015c);					// stw		r11,$015c(r6)
+	*lp++ = htonl(0x91860164);					// stw		r12,$0164(r6)
+	*lp++ = htonl(0x91a6016c);					// stw		r13,$016c(r6)
+	*lp++ = htonl(0x7da00026);					// mfcr		r13
+	*lp++ = htonl(0x80e10660);					// lwz		r7,$0660(r1)
+	*lp++ = htonl(0x7d8802a6);					// mflr		r12
+	*lp++ = htonl(0x50e74001);					// rlwimi.	r7,r7,8,$80000000
+	*lp++ = htonl(0x81410604);					// lwz		r10,0x0604(r1)
+	*lp++ = htonl(0x7d4803a6);					// mtlr		r10
+	*lp++ = htonl(0x7d8a6378);					// mr		r10,r12
+	*lp++ = htonl(0x3d600002);					// lis		r11,0x0002
+	*lp++ = htonl(0x616bf072);					// ori		r11,r11,0xf072 (MSR)
+	*lp++ = htonl(0x50e7deb4);					// rlwimi	r7,r7,27,$00000020
+	*lp = htonl(0x4e800020);					// blr
+
 	// Patch DR emulator to jump to right address when an interrupt occurs
-	lp = (uint32 *)(ROM_BASE + 0x370000);
-	while (lp < (uint32 *)(ROM_BASE + 0x380000)) {
+	lp = (uint32 *)(ROMBaseHost + 0x370000);
+	while (lp < (uint32 *)(ROMBaseHost + 0x380000)) {
 		if (ntohl(*lp) == 0x4ca80020)		// bclr		5,8
 			goto dr_found;
 		lp++;
@@ -1266,12 +1293,21 @@ static bool patch_68k_emul(void)
 	return false;
 dr_found:
 	lp++;
-	*lp = htonl(0x48000000 + 0xf000 - (((uint32)lp - ROM_BASE) & 0xffff));		// b	DR_CACHE_BASE+0x1f000
-	lp = (uint32 *)(ROM_BASE + 0x37f000);
-	*lp++ = htonl(0x3c000000 + ((ROM_BASE + 0x46d0a4) >> 16));		// lis	r0,xxx
-	*lp++ = htonl(0x60000000 + ((ROM_BASE + 0x46d0a4) & 0xffff));	// ori	r0,r0,xxx
-	*lp++ = htonl(0x7c0903a6);										// mtctr	r0
-	*lp = htonl(POWERPC_BCTR);										// bctr
+	loc = (uintptr)lp - (uintptr)ROMBaseHost;
+	if ((base = rom_powerpc_branch_target(loc)) == 0) base = loc;
+	static const uint8 dr_ret_dat[] = {0x80, 0xbf, 0x08, 0x14, 0x53, 0x19, 0x4d, 0xac, 0x7c, 0xa8, 0x03, 0xa6};
+	if ((base = find_rom_data(base, 0x380000, dr_ret_dat, sizeof(dr_ret_dat))) == 0) return false;
+	D(bug("dr_ret %08lx\n", base));
+	if (base != loc) {
+		// OldWorld ROMs contain an absolute branch
+		D(bug(" patching absolute branch at %08x\n", loc));
+		*lp = htonl(0x48000000 + 0xf000 - (loc & 0xffff));				// b	DR_CACHE_BASE+0x1f000
+		lp = (uint32 *)(ROMBaseHost + 0x37f000);
+		*lp++ = htonl(0x3c000000 + ((ROM_BASE + base) >> 16));			// lis	r0,xxx
+		*lp++ = htonl(0x60000000 + ((ROM_BASE + base) & 0xffff));		// ori	r0,r0,xxx
+		*lp++ = htonl(0x7c0803a6);										// mtlr	r0
+		*lp = htonl(POWERPC_BLR);										// blr
+	}
 	return true;
 }
 
@@ -1289,23 +1325,23 @@ static bool patch_nanokernel(void)
 	static const uint8 virt2phys_dat[] = {0x7d, 0x1b, 0x43, 0x78, 0x3b, 0xa1, 0x03, 0x20};
 	if ((base = find_rom_data(0x313000, 0x314000, virt2phys_dat, sizeof(virt2phys_dat))) == 0) return false;
 	D(bug("virt2phys %08lx\n", base + 8));
-	lp = (uint32 *)(ROM_BASE + base + 8);	// Don't translate virtual->physical
+	lp = (uint32 *)(ROMBaseHost + base + 8);	// Don't translate virtual->physical
 	lp[0] = htonl(0x7f7fdb78);					// mr		r31,r27
 	lp[2] = htonl(POWERPC_NOP);
 
 	static const uint8 ppc_excp_tbl_dat[] = {0x39, 0x01, 0x04, 0x20, 0x7d, 0x13, 0x43, 0xa6};
 	if ((base = find_rom_data(0x313000, 0x314000, ppc_excp_tbl_dat, sizeof(ppc_excp_tbl_dat))) == 0) return false;
 	D(bug("ppc_excp_tbl %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);		// Don't activate PPC exception table
+	lp = (uint32 *)(ROMBaseHost + base);		// Don't activate PPC exception table
 	*lp++ = htonl(0x39000000 + MODE_NATIVE);	// li	r8,MODE_NATIVE
 	*lp = htonl(0x91000000 + XLM_RUN_MODE);		// stw	r8,XLM_RUN_MODE
 
 	static const uint8 save_fpu_dat[] = {0x7d, 0x00, 0x00, 0xa6, 0x61, 0x08, 0x20, 0x00, 0x7d, 0x00, 0x01, 0x24};
 	if ((base = find_rom_data(0x310000, 0x314000, save_fpu_dat, sizeof(save_fpu_dat))) == 0) return false;
 	D(bug("save_fpu %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);		// Don't modify MSR to turn on FPU
+	lp = (uint32 *)(ROMBaseHost + base);		// Don't modify MSR to turn on FPU
 	if (ntohl(lp[4]) != 0x556b04e2) return false;
-	loc = ROM_BASE + base;
+	loc = base;
 #if 1
 	// FIXME: is that really intended?
 	*lp++ = htonl(POWERPC_NOP);
@@ -1323,14 +1359,14 @@ static bool patch_nanokernel(void)
 	static const uint8 save_fpu_caller_dat[] = {0x93, 0xa6, 0x01, 0xec, 0x93, 0xc6, 0x01, 0xf4, 0x93, 0xe6, 0x01, 0xfc, 0x40};
 	if ((base = find_rom_data(0x310000, 0x314000, save_fpu_caller_dat, sizeof(save_fpu_caller_dat))) == 0) return false;
 	D(bug("save_fpu_caller %08lx\n", base + 12));
-	if (powerpc_branch_target(ROM_BASE + base + 12) != loc) return false;
-	lp = (uint32 *)(ROM_BASE + base + 12);	// Always save FPU state
+	if (rom_powerpc_branch_target(base + 12) != loc) return false;
+	lp = (uint32 *)(ROMBaseHost + base + 12);	// Always save FPU state
 	*lp = htonl(0x48000000 | (ntohl(*lp) & 0xffff));	// bl	0x00312e88
 
 	static const uint8 mdec_dat[] = {0x7f, 0xf6, 0x02, 0xa6, 0x2c, 0x08, 0x00, 0x00, 0x93, 0xe1, 0x06, 0x68, 0x7d, 0x16, 0x03, 0xa6};
 	if ((base = find_rom_data(0x310000, 0x314000, mdec_dat, sizeof(mdec_dat))) == 0) return false;
 	D(bug("mdec %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);		// Don't modify DEC
+	lp = (uint32 *)(ROMBaseHost + base);		// Don't modify DEC
 	lp[0] = htonl(0x3be00000);					// li	r31,0
 #if 1
 	lp[3] = htonl(POWERPC_NOP);
@@ -1343,13 +1379,13 @@ static bool patch_nanokernel(void)
 	static const uint8 restore_fpu_caller_dat[] = {0x81, 0x06, 0x00, 0xf4, 0x81, 0x46, 0x00, 0xfc, 0x7d, 0x09, 0x03, 0xa6, 0x40};
 	if ((base = find_rom_data(0x310000, 0x314000, restore_fpu_caller_dat, sizeof(restore_fpu_caller_dat))) == 0) return false;
 	D(bug("restore_fpu_caller %08lx\n", base + 12));
-	lp = (uint32 *)(ROM_BASE + base + 12);	// Always restore FPU state
+	lp = (uint32 *)(ROMBaseHost + base + 12);	// Always restore FPU state
 	*lp = htonl(0x48000000 | (ntohl(*lp) & 0xffff));	// bl	0x00312ddc
 
 	static const uint8 m68k_excp_tbl_dat[] = {0x81, 0x21, 0x06, 0x58, 0x39, 0x01, 0x03, 0x60, 0x7d, 0x13, 0x43, 0xa6};
 	if ((base = find_rom_data(0x310000, 0x314000, m68k_excp_tbl_dat, sizeof(m68k_excp_tbl_dat))) == 0) return false;
 	D(bug("m68k_excp %08lx\n", base + 4));
-	lp = (uint32 *)(ROM_BASE + base + 4);	// Don't activate 68k exception table
+	lp = (uint32 *)(ROMBaseHost + base + 4);	// Don't activate 68k exception table
 	*lp++ = htonl(0x39000000 + MODE_68K);		// li	r8,MODE_68K
 	*lp = htonl(0x91000000 + XLM_RUN_MODE);		// stw	r8,XLM_RUN_MODE
 
@@ -1357,15 +1393,15 @@ static bool patch_nanokernel(void)
 	static const uint8 restore_fpu_caller2_dat[] = {0x81, 0x86, 0x00, 0x8c, 0x80, 0x66, 0x00, 0x94, 0x80, 0x86, 0x00, 0x9c, 0x40};
 	if ((base = find_rom_data(0x310000, 0x314000, restore_fpu_caller2_dat, sizeof(restore_fpu_caller2_dat))) == 0) return false;
 	D(bug("restore_fpu_caller2 %08lx\n", base + 12));
-	loc = powerpc_branch_target(ROM_BASE + base + 12) - ROM_BASE;
-	lp = (uint32 *)(ROM_BASE + base + 12);	// Always restore FPU state
+	loc = rom_powerpc_branch_target(base + 12);
+	lp = (uint32 *)(ROMBaseHost + base + 12);	// Always restore FPU state
 	*lp = htonl(0x48000000 | (ntohl(*lp) & 0xffff));	// bl	0x00312dd4
 
 	static const uint8 restore_fpu_dat[] = {0x55, 0x68, 0x04, 0xa5, 0x4c, 0x82, 0x00, 0x20, 0x81, 0x06, 0x00, 0xe4};
 	if ((base = find_rom_data(0x310000, 0x314000, restore_fpu_dat, sizeof(restore_fpu_dat))) == 0) return false;
 	D(bug("restore_fpu %08lx\n", base));
 	if (base != loc) return false;
-	lp = (uint32 *)(ROM_BASE + base + 4);	// Don't modify MSR to turn on FPU
+	lp = (uint32 *)(ROMBaseHost + base + 4);	// Don't modify MSR to turn on FPU
 	*lp++ = htonl(POWERPC_NOP);
 	lp += 2;
 	*lp++ = htonl(POWERPC_NOP);
@@ -1374,29 +1410,73 @@ static bool patch_nanokernel(void)
 	*lp++ = htonl(POWERPC_NOP);
 	*lp = htonl(POWERPC_NOP);
 
+	// Disable suspend (FE0F opcode)
+	// TODO: really suspend SheepShaver?
+	static const uint8 suspend_dat[] = {0x7c, 0x88, 0x68, 0x39, 0x41, 0x9d};
+	if ((base = find_rom_data(0x315000, 0x316000, suspend_dat, sizeof(suspend_dat))) == 0) return false;
+	D(bug("suspend %08lx\n", base));
+	lp = (uint32 *)(ROMBaseHost + base + 4);
+	*lp = htonl((ntohl(*lp) & 0xffff) | 0x48000000);	// bgt -> b
+
 	// Patch trap return routine
 	static const uint8 trap_return_dat[] = {0x80, 0xc1, 0x00, 0x18, 0x80, 0x21, 0x00, 0x04, 0x4c, 0x00, 0x00, 0x64};
 	if ((base = find_rom_data(0x312000, 0x320000, trap_return_dat, sizeof(trap_return_dat))) == 0) return false;
 	D(bug("trap_return %08lx\n", base + 8));
-	lp = (uint32 *)(ROM_BASE + base + 8);	// Replace rfi
+	lp = (uint32 *)(ROMBaseHost + base + 8);	// Replace rfi
 	*lp = htonl(POWERPC_BCTR);
 
 	while (ntohl(*lp) != 0x7d5a03a6) lp--;
 	*lp++ = htonl(0x7d4903a6);					// mtctr	r10
 	*lp++ = htonl(0x7daff120);					// mtcr	r13
-	*lp = htonl(0x48000000 + ((0x318000 - ((uint32)lp - ROM_BASE)) & 0x03fffffc));	// b		ROM_BASE+0x318000
-	uint32 npc = (uint32)(lp + 1) - ROM_BASE;
+	*lp = htonl(0x48000000 + ((0x318000 - ((uintptr)lp - (uintptr)ROMBaseHost)) & 0x03fffffc));	// b		ROM_BASE+0x318000
+	uint32 npc = (uintptr)(lp + 1) - (uintptr)ROMBaseHost;
 
-	lp = (uint32 *)(ROM_BASE + 0x318000);
-#if EMULATED_PPC
-	*lp++ = htonl(NativeOpcode(NATIVE_ENABLE_INTERRUPT));
-	*lp = htonl(0x48000000 + ((npc - 0x318004) & 0x03fffffc));	// b		ROM_BASE+0x312c2c
-#else
+	lp = (uint32 *)(ROMBaseHost + 0x318000);
 	*lp++ = htonl(0x81400000 + XLM_IRQ_NEST);	// lwz	r10,XLM_IRQ_NEST
 	*lp++ = htonl(0x394affff);					// subi	r10,r10,1
 	*lp++ = htonl(0x91400000 + XLM_IRQ_NEST);	// stw	r10,XLM_IRQ_NEST
 	*lp = htonl(0x48000000 + ((npc - 0x31800c) & 0x03fffffc));	// b		ROM_BASE+0x312c2c
-#endif
+
+	// Patch FEOA opcode, selector 0x0A (virtual->physical page index)
+	static const uint8 fe0a_0a_dat[] = {0x55, 0x23, 0xa3, 0x3e, 0x4b};
+	if ((base = find_rom_data(0x314000, 0x318000, fe0a_0a_dat, sizeof(fe0a_0a_dat))) == 0) return false;
+	loc = rom_powerpc_branch_target(base - 8);
+	static const uint8 fe0a_dat[] = {0x7e, 0x04, 0x48, 0x40, 0x81, 0xe1, 0x06, 0xb0, 0x54, 0x88, 0x10, 0x3a, 0x40, 0x90};
+	if (find_rom_data(loc, 0x318000, fe0a_dat, sizeof(fe0a_dat)) != loc) return false;
+	D(bug("fe0a_0a %08lx\n", base - 8));
+	lp = (uint32 *)(ROMBaseHost + base - 8);
+	*lp++ = htonl(0x7c832378);					// mr	r3,r4
+	*lp++ = htonl(POWERPC_NOP);
+	*lp = htonl(POWERPC_NOP);
+
+	// Disable FE0A opcode, selector 0x11 (init page tables?)
+	static const uint8 fe0a_11_dat[] = {0x56, 0x07, 0x06, 0x74, 0x2c, 0x07, 0x00, 0x60, 0x40};
+	if ((base = find_rom_data(0x314000, 0x318000, fe0a_11_dat, sizeof(fe0a_11_dat))) == 0) return false;
+	loc = rom_powerpc_branch_target(base - 4);
+	if (find_rom_data(0x314000, 0x318000, fe0a_dat, sizeof(fe0a_dat)) != loc) return false;
+	D(bug("fe0a_11 %08lx\n", base - 4));
+	lp = (uint32 *)(ROMBaseHost + base - 4);
+	*lp++ = htonl(POWERPC_NOP);
+	*lp++ = htonl(POWERPC_NOP);
+	*lp++ = htonl(POWERPC_NOP);
+	*lp = htonl(ntohl(*lp) | 0x02800000);		// bf => ba
+
+	// Patch FE0A opcode to fake a page table entry so that V=P for RAM and ROM
+	static const uint8 pg_lookup_dat[] = {0x7e, 0x0f, 0x40, 0x6e, 0x81, 0xc1, 0x06, 0xa4, 0x7e, 0x00, 0x71, 0x20};
+	if ((base = find_rom_data(0x310000, 0x320000, pg_lookup_dat, sizeof(pg_lookup_dat))) == 0) return false;
+	D(bug("fe0a_pgtb_lookup %08lx\n", base - 12));
+	lp = (uint32 *)(ROMBaseHost + base - 12);
+	if (ntohl(lp[0]) != 0x81e106b0)				// lwz	r15,$06b0(r1)
+		return false;
+	lp[0] = htonl(0x54906026);					// slwi	r16,r4,12
+	lp[3] = htonl(0x62100121);					// ori	r16,r16,0x121
+
+	// Patch FE0A opcode to not write to kernel memory
+	static const uint8 krnl_write_dat[] = {0x38, 0xe0, 0x00, 0x01, 0x7e, 0x10, 0x38, 0x78, 0x92, 0x0f, 0x00, 0x00};
+	if ((base = find_rom_data(0x310000, 0x320000, krnl_write_dat, sizeof(krnl_write_dat))) == 0) return false;
+	D(bug("fe0a_krnl_write %08lx\n", base));
+	lp = (uint32 *)(ROMBaseHost + base);
+	lp[2] = htonl(POWERPC_NOP);
 
 /*
 	// Disable FE0A/FE06 opcodes
@@ -1423,14 +1503,14 @@ static bool patch_68k(void)
 	static const uint8 reset_dat[] = {0x4e, 0x70};
 	if ((base = find_rom_data(0xc8, 0x120, reset_dat, sizeof(reset_dat))) == 0) return false;
 	D(bug("reset %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp = htons(M68K_NOP);
 
 	// Fake reading PowerMac ID (via Universal)
 	static const uint8 powermac_id_dat[] = {0x45, 0xf9, 0x5f, 0xff, 0xff, 0xfc, 0x20, 0x12, 0x72, 0x00};
 	if ((base = find_rom_data(0xe000, 0x15000, powermac_id_dat, sizeof(powermac_id_dat))) == 0) return false;
 	D(bug("powermac_id %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x203c);			// move.l	#id,d0
 	*wp++ = htons(0);
 //	if (ROMType == ROMTYPE_NEWWORLD)
@@ -1445,7 +1525,7 @@ static bool patch_68k(void)
 		static const uint8 univ_info_dat[] = {0x3f, 0xff, 0x04, 0x00};
 		if ((base = find_rom_data(0x14000, 0x18000, univ_info_dat, sizeof(univ_info_dat))) == 0) return false;
 		D(bug("universal_info %08lx\n", base));
-		lp = (uint32 *)(ROM_BASE + base - 0x14);
+		lp = (uint32 *)(ROMBaseHost + base - 0x14);
 		lp[0x00 >> 2] = htonl(ADDR_MAP_PATCH_SPACE - (base - 0x14));
 		lp[0x10 >> 2] = htonl(0xcc003d11);		// Make it like the PowerMac 9500 UniversalInfo
 		lp[0x14 >> 2] = htonl(0x3fff0401);
@@ -1457,7 +1537,7 @@ static bool patch_68k(void)
 		lp[0x60 >> 2] = htonl(0x0000003d);
 	} else if (ROMType == ROMTYPE_ZANZIBAR) {
 		base = 0x12b70;
-		lp = (uint32 *)(ROM_BASE + base - 0x14);
+		lp = (uint32 *)(ROMBaseHost + base - 0x14);
 		lp[0x00 >> 2] = htonl(ADDR_MAP_PATCH_SPACE - (base - 0x14));
 		lp[0x10 >> 2] = htonl(0xcc003d11);		// Make it like the PowerMac 9500 UniversalInfo
 		lp[0x14 >> 2] = htonl(0x3fff0401);
@@ -1469,7 +1549,7 @@ static bool patch_68k(void)
 		lp[0x60 >> 2] = htonl(0x0000003d);
 	} else if (ROMType == ROMTYPE_GOSSAMER) {
 		base = 0x12d20;
-		lp = (uint32 *)(ROM_BASE + base - 0x14);
+		lp = (uint32 *)(ROMBaseHost + base - 0x14);
 		lp[0x00 >> 2] = htonl(ADDR_MAP_PATCH_SPACE - (base - 0x14));
 		lp[0x10 >> 2] = htonl(0xcc003d11);		// Make it like the PowerMac 9500 UniversalInfo
 		lp[0x14 >> 2] = htonl(0x3fff0401);
@@ -1483,7 +1563,7 @@ static bool patch_68k(void)
 
 	// Construct AddrMap for NewWorld ROM
 	if (ROMType == ROMTYPE_NEWWORLD || ROMType == ROMTYPE_ZANZIBAR || ROMType == ROMTYPE_GOSSAMER) {
-		lp = (uint32 *)(ROM_BASE + ADDR_MAP_PATCH_SPACE);
+		lp = (uint32 *)(ROMBaseHost + ADDR_MAP_PATCH_SPACE);
 		memset(lp - 10, 0, 0x128);
 		lp[-10] = htonl(0x0300001c);
 		lp[-9] = htonl(0x000108c4);
@@ -1507,19 +1587,19 @@ static bool patch_68k(void)
 	static const uint8 via_init_dat[] = {0x08, 0x00, 0x00, 0x02, 0x67, 0x00, 0x00, 0x2c, 0x24, 0x68, 0x00, 0x08};
 	if ((base = find_rom_data(0xe000, 0x15000, via_init_dat, sizeof(via_init_dat))) == 0) return false;
 	D(bug("via_init %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base + 4);
+	wp = (uint16 *)(ROMBaseHost + base + 4);
 	*wp = htons(0x6000);			// bra
 
 	static const uint8 via_init2_dat[] = {0x24, 0x68, 0x00, 0x08, 0x00, 0x12, 0x00, 0x30, 0x4e, 0x71};
 	if ((base = find_rom_data(0xa000, 0x10000, via_init2_dat, sizeof(via_init2_dat))) == 0) return false;
 	D(bug("via_init2 %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp = htons(0x4ed6);			// jmp	(a6)
 
 	static const uint8 via_init3_dat[] = {0x22, 0x68, 0x00, 0x08, 0x28, 0x3c, 0x20, 0x00, 0x01, 0x00};
 	if ((base = find_rom_data(0xa000, 0x10000, via_init3_dat, sizeof(via_init3_dat))) == 0) return false;
 	D(bug("via_init3 %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp = htons(0x4ed6);			// jmp	(a6)
 
 	// Don't RunDiags, get BootGlobs pointer directly
@@ -1527,7 +1607,7 @@ static bool patch_68k(void)
 		static const uint8 run_diags_dat[] = {0x60, 0xff, 0x00, 0x0c};
 		if ((base = find_rom_data(0x110, 0x128, run_diags_dat, sizeof(run_diags_dat))) == 0) return false;
 		D(bug("run_diags %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
+		wp = (uint16 *)(ROMBaseHost + base);
 		*wp++ = htons(0x4df9);			// lea	xxx,a6
 		*wp++ = htons((RAMBase + RAMSize - 0x1c) >> 16);
 		*wp = htons((RAMBase + RAMSize - 0x1c) & 0xffff);
@@ -1535,7 +1615,7 @@ static bool patch_68k(void)
 		static const uint8 run_diags_dat[] = {0x74, 0x00, 0x2f, 0x0e};
 		if ((base = find_rom_data(0xd0, 0xf0, run_diags_dat, sizeof(run_diags_dat))) == 0) return false;
 		D(bug("run_diags %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base - 6);
+		wp = (uint16 *)(ROMBaseHost + base - 6);
 		*wp++ = htons(0x4df9);			// lea	xxx,a6
 		*wp++ = htons((RAMBase + RAMSize - 0x1c) >> 16);
 		*wp = htons((RAMBase + RAMSize - 0x1c) & 0xffff);
@@ -1545,7 +1625,7 @@ static bool patch_68k(void)
 	static const uint8 nvram1_dat[] = {0x48, 0xe7, 0x01, 0x0e, 0x24, 0x68, 0x00, 0x08, 0x08, 0x83, 0x00, 0x1f};
 	if ((base = find_rom_data(0x7000, 0xc000, nvram1_dat, sizeof(nvram1_dat))) == 0) return false;
 	D(bug("nvram1 %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(M68K_EMUL_OP_XPRAM1);
 	*wp = htons(M68K_RTS);
 
@@ -1553,21 +1633,21 @@ static bool patch_68k(void)
 		static const uint8 nvram2_dat[] = {0x48, 0xe7, 0x1c, 0xe0, 0x4f, 0xef, 0xff, 0xb4};
 		if ((base = find_rom_data(0xa000, 0xd000, nvram2_dat, sizeof(nvram2_dat))) == 0) return false;
 		D(bug("nvram2 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
+		wp = (uint16 *)(ROMBaseHost + base);
 		*wp++ = htons(M68K_EMUL_OP_XPRAM2);
 		*wp = htons(0x4ed3);			// jmp	(a3)
 
 		static const uint8 nvram3_dat[] = {0x48, 0xe7, 0xdc, 0xe0, 0x4f, 0xef, 0xff, 0xb4};
 		if ((base = find_rom_data(0xa000, 0xd000, nvram3_dat, sizeof(nvram3_dat))) == 0) return false;
 		D(bug("nvram3 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
+		wp = (uint16 *)(ROMBaseHost + base);
 		*wp++ = htons(M68K_EMUL_OP_XPRAM3);
 		*wp = htons(0x4ed3);			// jmp	(a3)
 
 		static const uint8 nvram4_dat[] = {0x4e, 0x56, 0xff, 0xa8, 0x48, 0xe7, 0x1f, 0x38, 0x16, 0x2e, 0x00, 0x13};
 		if ((base = find_rom_data(0xa000, 0xd000, nvram4_dat, sizeof(nvram4_dat))) == 0) return false;
 		D(bug("nvram4 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base + 16);
+		wp = (uint16 *)(ROMBaseHost + base + 16);
 		*wp++ = htons(0x1a2e);			// move.b	($000f,a6),d5
 		*wp++ = htons(0x000f);
 		*wp++ = htons(M68K_EMUL_OP_NVRAM3);
@@ -1580,13 +1660,13 @@ static bool patch_68k(void)
 		static const uint8 nvram5_dat[] = {0x0c, 0x80, 0x03, 0x00, 0x00, 0x00, 0x66, 0x0a, 0x70, 0x00, 0x21, 0xf8, 0x02, 0x0c, 0x01, 0xe4};
 		if ((base = find_rom_data(0xa000, 0xd000, nvram5_dat, sizeof(nvram5_dat))) == 0) return false;
 		D(bug("nvram5 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base + 6);
+		wp = (uint16 *)(ROMBaseHost + base + 6);
 		*wp = htons(M68K_NOP);
 
 		static const uint8 nvram6_dat[] = {0x2f, 0x0a, 0x24, 0x48, 0x4f, 0xef, 0xff, 0xa0, 0x20, 0x0f};
 		if ((base = find_rom_data(0x9000, 0xb000, nvram6_dat, sizeof(nvram6_dat))) == 0) return false;
 		D(bug("nvram6 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
+		wp = (uint16 *)(ROMBaseHost + base);
 		*wp++ = htons(0x7000);			// moveq	#0,d0
 		*wp++ = htons(0x2080);			// move.l	d0,(a0)
 		*wp++ = htons(0x4228);			// clr.b	4(a0)
@@ -1597,26 +1677,26 @@ static bool patch_68k(void)
 		base = find_rom_data(0x9000, 0xb000, nvram7_dat, sizeof(nvram7_dat));
 		if (base) {
 			D(bug("nvram7 %08lx\n", base));
-			wp = (uint16 *)(ROM_BASE + base + 12);
+			wp = (uint16 *)(ROMBaseHost + base + 12);
 			*wp = htons(M68K_RTS);
 		}
 	} else {
 		static const uint8 nvram2_dat[] = {0x4e, 0xd6, 0x06, 0x41, 0x13, 0x00};
 		if ((base = find_rom_data(0x7000, 0xb000, nvram2_dat, sizeof(nvram2_dat))) == 0) return false;
 		D(bug("nvram2 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base + 2);
+		wp = (uint16 *)(ROMBaseHost + base + 2);
 		*wp++ = htons(M68K_EMUL_OP_XPRAM2);
 		*wp = htons(0x4ed3);			// jmp	(a3)
 
 		static const uint8 nvram3_dat[] = {0x4e, 0xd3, 0x06, 0x41, 0x13, 0x00};
 		if ((base = find_rom_data(0x7000, 0xb000, nvram3_dat, sizeof(nvram3_dat))) == 0) return false;
 		D(bug("nvram3 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base + 2);
+		wp = (uint16 *)(ROMBaseHost + base + 2);
 		*wp++ = htons(M68K_EMUL_OP_XPRAM3);
 		*wp = htons(0x4ed3);			// jmp	(a3)
 
 		static const uint32 nvram4_loc[] = {0x582f0, 0xa0a0, 0x7e50, 0xa1d0, 0x538d0, 0};
-		wp = (uint16 *)(ROM_BASE + nvram4_loc[ROMType]);
+		wp = (uint16 *)(ROMBaseHost + nvram4_loc[ROMType]);
 		*wp++ = htons(0x202f);			// move.l	4(sp),d0
 		*wp++ = htons(0x0004);
 		*wp++ = htons(M68K_EMUL_OP_NVRAM1);
@@ -1630,7 +1710,7 @@ static bool patch_68k(void)
 		}
 
 		static const uint32 nvram5_loc[] = {0x58460, 0xa0f0, 0x7f40, 0xa220, 0x53a20, 0};
-		wp = (uint16 *)(ROM_BASE + nvram5_loc[ROMType]);
+		wp = (uint16 *)(ROMBaseHost + nvram5_loc[ROMType]);
 		if (ROMType == ROMTYPE_ZANZIBAR || ROMType == ROMTYPE_GAZELLE) {
 			*wp++ = htons(0x202f);			// move.l	4(sp),d0
 			*wp++ = htons(0x0004);
@@ -1653,7 +1733,7 @@ static bool patch_68k(void)
 	static const uint8 mem_top_dat[] = {0x2c, 0x6c, 0xff, 0xec, 0x2a, 0x4c, 0xdb, 0xec, 0xff, 0xf4};
 	if ((base = find_rom_data(0x120, 0x180, mem_top_dat, sizeof(mem_top_dat))) == 0) return false;
 	D(bug("mem_top %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(M68K_EMUL_OP_FIX_MEMTOP);
 	*wp = htons(M68K_NOP);
 
@@ -1661,12 +1741,12 @@ static bool patch_68k(void)
 	static const uint8 scc_init_caller_dat[] = {0x21, 0xce, 0x01, 0x08, 0x22, 0x78, 0x0d, 0xd8};
 	if ((base = find_rom_data(0x180, 0x1f0, scc_init_caller_dat, sizeof(scc_init_caller_dat))) == 0) return false;
 	D(bug("scc_init_caller %08lx\n", base + 12));
-	wp = (uint16 *)(ROM_BASE + base + 12);
-	loc = ntohs(wp[1]) + ((uintptr)wp - ROM_BASE) + 2;
+	wp = (uint16 *)(ROMBaseHost + base + 12);
+	loc = ntohs(wp[1]) + ((uintptr)wp - (uintptr)ROMBaseHost) + 2;
 	static const uint8 scc_init_dat[] = {0x20, 0x78, 0x01, 0xdc, 0x22, 0x78, 0x01, 0xd8};
 	if ((base = find_rom_data(loc, loc + 0x80, scc_init_dat, sizeof(scc_init_dat))) == 0) return false;
 	D(bug("scc_init %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(M68K_EMUL_OP_RESET);
 	*wp = htons(M68K_RTS);
 
@@ -1674,18 +1754,18 @@ static bool patch_68k(void)
 	static const uint8 ext_cache_dat[] = {0x4e, 0x7b, 0x00, 0x02};
 	if ((base = find_rom_data(0x1d0, 0x230, ext_cache_dat, sizeof(ext_cache_dat))) == 0) return false;
 	D(bug("ext_cache %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base + 6);
-	wp = (uint16 *)(ROM_BASE + ntohl(*lp) + base + 6);
+	loc = ReadMacInt32(ROM_BASE + base + 6);
+	wp = (uint16 *)(ROMBaseHost + loc + base + 6);
 	*wp = htons(M68K_RTS);
-	lp = (uint32 *)(ROM_BASE + base + 12);
-	wp = (uint16 *)(ROM_BASE + ntohl(*lp) + base + 12);
+	loc = ReadMacInt32(ROM_BASE + base + 12);
+	wp = (uint16 *)(ROMBaseHost + loc + base + 12);
 	*wp = htons(M68K_RTS);
 
 	// Fake CPU speed test (SetupTimeK)
 	static const uint8 timek_dat[] = {0x0c, 0x38, 0x00, 0x04, 0x01, 0x2f, 0x6d, 0x3c};
 	if ((base = find_rom_data(0x400, 0x500, timek_dat, sizeof(timek_dat))) == 0) return false;
 	D(bug("timek %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x31fc);			// move.w	#xxx,TimeDBRA
 	*wp++ = htons(100);
 	*wp++ = htons(0x0d00);
@@ -1704,9 +1784,9 @@ static bool patch_68k(void)
 	static const uint8 jump_tab_dat[] = {0x41, 0xfa, 0x00, 0x0e, 0x21, 0xc8, 0x20, 0x10, 0x4e, 0x75};
 	if ((base = find_rom_data(0x3000, 0x6000, jump_tab_dat, sizeof(jump_tab_dat))) == 0) return false;
 	D(bug("jump_tab %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base + 16);
+	lp = (uint32 *)(ROMBaseHost + base + 16);
 	for (;;) {
-		D(bug(" %08lx\n", (uint32)lp - ROM_BASE));
+		D(bug(" %08lx\n", (uintptr)lp - (uintptr)ROMBaseHost));
 		while ((ntohl(*lp) & 0xff000000) == 0xff000000) {
 			*lp = htonl((ntohl(*lp) & (ROM_SIZE-1)) + ROM_BASE);
 			lp++;
@@ -1721,7 +1801,7 @@ static bool patch_68k(void)
 	static const uint8 sys_zone_dat[] = {0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x40, 0x00};
 	if ((base = find_rom_data(0x600, 0x900, sys_zone_dat, sizeof(sys_zone_dat))) == 0) return false;
 	D(bug("sys_zone %08lx\n", base));
-	lp = (uint32 *)(ROM_BASE + base);
+	lp = (uint32 *)(ROMBaseHost + base);
 	*lp++ = htonl(RAMBase ? RAMBase : 0x3000);
 	*lp = htonl(RAMBase ? RAMBase + 0x1800 : 0x4800);
 
@@ -1730,7 +1810,7 @@ static bool patch_68k(void)
 	static const uint8 boot_stack_dat[] = {0x08, 0x38, 0x00, 0x06, 0x24, 0x0b};
 	if ((base = find_rom_data(0x580, 0x800, boot_stack_dat, sizeof(boot_stack_dat))) == 0) return false;
 	D(bug("boot_stack %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x207c);			// move.l	#RAMBase+0x3ffffe,a0
 	*wp++ = htons((RAMBase + 0x3ffffe) >> 16);
 	*wp++ = htons((RAMBase + 0x3ffffe) & 0xffff);
@@ -1741,24 +1821,30 @@ static bool patch_68k(void)
 	static const uint8 page_size_dat[] = {0x20, 0x30, 0x81, 0xf2, 0x5f, 0xff, 0xef, 0xd8, 0x00, 0x10};
 	if ((base = find_rom_data(0xb000, 0x12000, page_size_dat, sizeof(page_size_dat))) == 0) return false;
 	D(bug("page_size %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x203c);			// move.l	#$1000,d0
 	*wp++ = htons(0);
 	*wp++ = htons(0x1000);
 	*wp++ = htons(M68K_NOP);
 	*wp = htons(M68K_NOP);
 
-	// Gestalt PowerPC page size, RAM size (InitGestalt, via 0x25c)
+	// Gestalt PowerPC page size, CPU type, RAM size (InitGestalt, via 0x25c)
 	static const uint8 page_size2_dat[] = {0x26, 0x79, 0x5f, 0xff, 0xef, 0xd8, 0x25, 0x6b, 0x00, 0x10, 0x00, 0x1e};
 	if ((base = find_rom_data(0x50000, 0x70000, page_size2_dat, sizeof(page_size2_dat))) == 0) return false;
 	D(bug("page_size2 %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x257c);			// move.l	#$1000,$1e(a2)
 	*wp++ = htons(0);
 	*wp++ = htons(0x1000);
 	*wp++ = htons(0x001e);
 	*wp++ = htons(0x157c);			// move.b	#PVR,$1d(a2)
-	*wp++ = htons(PVR >> 16);
+	uint32 cput = (PVR >> 16);
+	if (cput == 0x7000)
+		cput |= 0x20;
+	else if (cput >= 0x8000 && cput <= 0x8002)
+		cput |= 0x10;
+	cput &= 0xff;
+	*wp++ = htons(cput);
 	*wp++ = htons(0x001d);
 	*wp++ = htons(0x263c);			// move.l	#RAMSize,d3
 	*wp++ = htons(RAMSize >> 16);
@@ -1767,21 +1853,21 @@ static bool patch_68k(void)
 	*wp++ = htons(M68K_NOP);
 	*wp = htons(M68K_NOP);
 	if (ROMType == ROMTYPE_NEWWORLD)
-		wp = (uint16 *)(ROM_BASE + base + 0x4a);
+		wp = (uint16 *)(ROMBaseHost + base + 0x4a);
 	else
-		wp = (uint16 *)(ROM_BASE + base + 0x28);
+		wp = (uint16 *)(ROMBaseHost + base + 0x28);
 	*wp++ = htons(M68K_NOP);
 	*wp = htons(M68K_NOP);
 
 	// Gestalt CPU/bus clock speed (InitGestalt, via 0x25c)
 	if (ROMType == ROMTYPE_ZANZIBAR) {
-		wp = (uint16 *)(ROM_BASE + 0x5d87a);
+		wp = (uint16 *)(ROMBaseHost + 0x5d87a);
 		*wp++ = htons(0x203c);			// move.l	#Hz,d0
 		*wp++ = htons(BusClockSpeed >> 16);
 		*wp++ = htons(BusClockSpeed & 0xffff);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(M68K_NOP);
-		wp = (uint16 *)(ROM_BASE + 0x5d888);
+		wp = (uint16 *)(ROMBaseHost + 0x5d888);
 		*wp++ = htons(0x203c);			// move.l	#Hz,d0
 		*wp++ = htons(CPUClockSpeed >> 16);
 		*wp++ = htons(CPUClockSpeed & 0xffff);
@@ -1794,25 +1880,29 @@ static bool patch_68k(void)
 		static const uint8 gc_mask_dat[] = {0x83, 0xa8, 0x00, 0x24, 0x4e, 0x71};
 		if ((base = find_rom_data(0x13000, 0x20000, gc_mask_dat, sizeof(gc_mask_dat))) == 0) return false;
 		D(bug("gc_mask %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
+		wp = (uint16 *)(ROMBaseHost + base);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(M68K_NOP);
-		wp = (uint16 *)(ROM_BASE + base + 0x40);
+		wp = (uint16 *)(ROMBaseHost + base + 0x40);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(M68K_NOP);
-		wp = (uint16 *)(ROM_BASE + base + 0x78);
+		wp = (uint16 *)(ROMBaseHost + base + 0x78);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(M68K_NOP);
-		wp = (uint16 *)(ROM_BASE + base + 0x96);
+		wp = (uint16 *)(ROMBaseHost + base + 0x96);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(M68K_NOP);
 
 		static const uint8 gc_mask2_dat[] = {0x02, 0xa8, 0x00, 0x00, 0x00, 0x80, 0x00, 0x24};
 		if ((base = find_rom_data(0x13000, 0x20000, gc_mask2_dat, sizeof(gc_mask2_dat))) == 0) return false;
 		D(bug("gc_mask2 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
-		if (ROMType == ROMTYPE_GOSSAMER)
+		wp = (uint16 *)(ROMBaseHost + base);
+		if (ROMType == ROMTYPE_GOSSAMER) {
+			*wp++ = htons(M68K_NOP);
+			*wp++ = htons(M68K_NOP);
 			*wp++ = htons(M68K_NOP);
+			*wp++ = htons(M68K_NOP);
+		}
 		for (int i=0; i<5; i++) {
 			*wp++ = htons(M68K_NOP);
 			*wp++ = htons(M68K_NOP);
@@ -1835,7 +1925,7 @@ static bool patch_68k(void)
 	static const uint8 cuda_init_dat[] = {0x08, 0xa9, 0x00, 0x04, 0x16, 0x00, 0x4e, 0x71, 0x13, 0x7c, 0x00, 0x84, 0x1c, 0x00, 0x4e, 0x71};
 	if ((base = find_rom_data(0xa000, 0x12000, cuda_init_dat, sizeof(cuda_init_dat))) == 0) return false;
 	D(bug("cuda_init %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(M68K_NOP);
 	*wp++ = htons(M68K_NOP);
 	*wp++ = htons(M68K_NOP);
@@ -1848,14 +1938,14 @@ static bool patch_68k(void)
 	static const uint8 cpu_speed_dat[] = {0x20, 0x30, 0x81, 0xf2, 0x5f, 0xff, 0xef, 0xd8, 0x00, 0x04, 0x4c, 0x7c};
 	if ((base = find_rom_data(0x6000, 0xa000, cpu_speed_dat, sizeof(cpu_speed_dat))) == 0) return false;
 	D(bug("cpu_speed %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x203c);			// move.l	#(MHz<<16)|MHz,d0
 	*wp++ = htons(CPUClockSpeed / 1000000);
 	*wp++ = htons(CPUClockSpeed / 1000000);
 	*wp = htons(M68K_RTS);
 	if ((base = find_rom_data(base, 0xa000, cpu_speed_dat, sizeof(cpu_speed_dat))) != 0) {
 		D(bug("cpu_speed2 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);
+		wp = (uint16 *)(ROMBaseHost + base);
 		*wp++ = htons(0x203c);			// move.l	#(MHz<<16)|MHz,d0
 		*wp++ = htons(CPUClockSpeed / 1000000);
 		*wp++ = htons(CPUClockSpeed / 1000000);
@@ -1866,7 +1956,7 @@ static bool patch_68k(void)
 	static const uint8 time_via_dat[] = {0x40, 0xe7, 0x00, 0x7c, 0x07, 0x00, 0x28, 0x78, 0x01, 0xd4, 0x43, 0xec, 0x10, 0x00};
 	if ((base = find_rom_data(0x30000, 0x40000, time_via_dat, sizeof(time_via_dat))) == 0) return false;
 	D(bug("time_via %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x4cdf);			// movem.l	(sp)+,d0-d5/a0-a4
 	*wp++ = htons(0x1f3f);
 	*wp = htons(M68K_RTS);
@@ -1876,12 +1966,12 @@ static bool patch_68k(void)
 	static const uint8 open_firmware_dat[] = {0x2f, 0x79, 0xff, 0x80, 0x00, 0x00, 0x00, 0xfc};
 	if ((base = find_rom_data(0x48000, 0x58000, open_firmware_dat, sizeof(open_firmware_dat))) == 0) return false;
 	D(bug("open_firmware %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x2f7c);			// move.l		#deadbeef,0xfc(a7)
 	*wp++ = htons(0xdead);
 	*wp++ = htons(0xbeef);
 	*wp = htons(0x00fc);
-	wp = (uint16 *)(ROM_BASE + base + 0x1a);
+	wp = (uint16 *)(ROMBaseHost + base + 0x1a);
 	*wp++ = htons(M68K_NOP);		// (FE03 opcode, tries to jump to 0xdeadbeef)
 	*wp = htons(M68K_NOP);
 
@@ -1889,7 +1979,7 @@ static bool patch_68k(void)
 	static const uint8 ext_cache2_dat[] = {0x4f, 0xef, 0xff, 0xec, 0x20, 0x4f, 0x10, 0xbc, 0x00, 0x01, 0x11, 0x7c, 0x00, 0x1b};
 	if ((base = find_rom_data(0x13000, 0x20000, ext_cache2_dat, sizeof(ext_cache2_dat))) == 0) return false;
 	D(bug("ext_cache2 %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp = htons(M68K_RTS);
 
 	// Don't install Time Manager task for 60Hz interrupt (Enable60HzInts, via 0x2b8)
@@ -1897,7 +1987,7 @@ static bool patch_68k(void)
 		static const uint8 tm_task_dat[] = {0x30, 0x3c, 0x4e, 0x2b, 0xa9, 0xc9};
 		if ((base = find_rom_data(0x2a0, 0x320, tm_task_dat, sizeof(tm_task_dat))) == 0) return false;
 		D(bug("tm_task %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base + 28);
+		wp = (uint16 *)(ROMBaseHost + base + 28);
 		*wp++ = htons(M68K_NOP);
 		*wp++ = htons(M68K_NOP);
 		*wp++ = htons(M68K_NOP);
@@ -1908,7 +1998,7 @@ static bool patch_68k(void)
 		static const uint8 tm_task_dat[] = {0x20, 0x3c, 0x73, 0x79, 0x73, 0x61};
 		if ((base = find_rom_data(0x280, 0x300, tm_task_dat, sizeof(tm_task_dat))) == 0) return false;
 		D(bug("tm_task %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base - 6);
+		wp = (uint16 *)(ROMBaseHost + base - 6);
 		*wp++ = htons(M68K_NOP);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(M68K_NOP);
@@ -1925,7 +2015,7 @@ static bool patch_68k(void)
 			if ((base = find_rom_data(dsl_offset, dsl_offset + 0x6000, dsl_pvr_dat, sizeof(dsl_pvr_dat))) == 0) return false;
 		}
 		D(bug("dsl_pvr %08lx\n", base));
-		lp = (uint32 *)(ROM_BASE + base + 12);
+		lp = (uint32 *)(ROMBaseHost + base + 12);
 		*lp = htonl(0x3c800000 | (PVR >> 16));	// lis	r4,PVR
 
 		// Don't read bus clock from 0x5fffef88 in DriverServicesLib (via 0x316)
@@ -1933,30 +2023,30 @@ static bool patch_68k(void)
 			static const uint8 dsl_bus_dat[] = {0x81, 0x07, 0x00, 0x00, 0x39, 0x20, 0x42, 0x40, 0x81, 0x62, 0xff, 0x20};
 			if ((base = find_rom_data(dsl_offset, dsl_offset + 0x6000, dsl_bus_dat, sizeof(dsl_bus_dat))) == 0) return false;
 			D(bug("dsl_bus %08lx\n", base));
-			lp = (uint32 *)(ROM_BASE + base);
+			lp = (uint32 *)(ROMBaseHost + base);
 			*lp = htonl(0x81000000 + XLM_BUS_CLOCK);	// lwz	r8,(bus clock speed)
 		} else {
 			static const uint8 dsl_bus_dat[] = {0x80, 0x83, 0xef, 0xe8, 0x80, 0x62, 0x00, 0x10, 0x7c, 0x04, 0x03, 0x96};
 			if ((base = find_rom_data(dsl_offset, dsl_offset + 0x6000, dsl_bus_dat, sizeof(dsl_bus_dat))) == 0) return false;
 			D(bug("dsl_bus %08lx\n", base));
-			lp = (uint32 *)(ROM_BASE + base);
+			lp = (uint32 *)(ROMBaseHost + base);
 			*lp = htonl(0x80800000 + XLM_BUS_CLOCK);	// lwz	r4,(bus clock speed)
 		}
 	}
 
 	// Don't open InterruptTreeTNT in MotherBoardHAL init in DriverServicesLib init
 	if (ROMType == ROMTYPE_ZANZIBAR) {
-		lp = (uint32 *)(ROM_BASE + find_rom_resource(FOURCC('n','l','i','b'), -16408) + 0x16c);
+		lp = (uint32 *)(ROMBaseHost + find_rom_resource(FOURCC('n','l','i','b'), -16408) + 0x16c);
 		*lp = htonl(0x38600000);		// li	r3,0
 	}
 
-	// FIXME: Fake reading from [HpChk]+4 (the callchain reports some function from DriverServicesLib)
+	// Don't read from MacPgm in WipeOutMACPGMINFOProcPtrs (StdCLib)
 	if (1) {
 		uint32 hpchk_offset = find_rom_resource(FOURCC('n','l','i','b'), 10);
 		static const uint8 hpchk_dat[] = {0x80, 0x80, 0x03, 0x16, 0x94, 0x21, 0xff, 0xb0, 0x83, 0xc4, 0x00, 0x04};
 		if ((base = find_rom_data(hpchk_offset, hpchk_offset + 0x3000, hpchk_dat, sizeof(hpchk_dat))) == 0) return false;
-		D(bug("hpchk %08lx\n", base));
-		lp = (uint32 *)(ROM_BASE + base);
+		D(bug("macpgm %08lx\n", base));
+		lp = (uint32 *)(ROMBaseHost + base);
 		*lp = htonl(0x80800000 + XLM_ZERO_PAGE);		// lwz	r4,(zero page)
 	}
 
@@ -1964,7 +2054,7 @@ static bool patch_68k(void)
 	static const uint8 name_reg_dat[] = {0x70, 0xff, 0xab, 0xeb};
 	if ((base = find_rom_data(0x300, 0x380, name_reg_dat, sizeof(name_reg_dat))) == 0) return false;
 	D(bug("name_reg %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp = htons(M68K_EMUL_OP_NAME_REGISTRY);
 
 #if DISABLE_SCSI
@@ -1976,7 +2066,7 @@ static bool patch_68k(void)
 		if ((base = find_rom_data(0x1c000, 0x28000, scsi_mgr_b_dat, sizeof(scsi_mgr_b_dat))) == 0) return false;
 	}
 	D(bug("scsi_mgr %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x21fc);			// move.l	#xxx,0x624	(SCSIAtomic)
 	*wp++ = htons((ROM_BASE + base + 18) >> 16);
 	*wp++ = htons((ROM_BASE + base + 18) & 0xffff);
@@ -1990,7 +2080,7 @@ static bool patch_68k(void)
 	*wp++ = htons(M68K_RTS);
 	*wp++ = htons(M68K_EMUL_OP_SCSI_DISPATCH);
 	*wp = htons(0x4ed0);			// jmp		(a0)
-	wp = (uint16 *)(ROM_BASE + base + 0x20);
+	wp = (uint16 *)(ROMBaseHost + base + 0x20);
 	*wp++ = htons(0x7000);			// moveq	#0,d0
 	*wp = htons(M68K_RTS);
 #endif
@@ -2002,14 +2092,14 @@ static bool patch_68k(void)
 		static const uint8 scsi_var_dat[] = {0x70, 0x01, 0xa0, 0x89, 0x4a, 0x6e, 0xfe, 0xac, 0x4f, 0xef, 0x00, 0x10, 0x66, 0x00};
 		if ((base = find_rom_data(0x1f500, 0x1f600, scsi_var_dat, sizeof(scsi_var_dat))) != 0) {
 			D(bug("scsi_var %08lx\n", base));
-			wp = (uint16 *)(ROM_BASE + base + 12);
+			wp = (uint16 *)(ROMBaseHost + base + 12);
 			*wp = htons(0x6000);	// bra
 		}
 
 		static const uint8 scsi_var2_dat[] = {0x4e, 0x56, 0xfc, 0x58, 0x48, 0xe7, 0x1f, 0x38};
 		if ((base = find_rom_data(0x1f700, 0x1f800, scsi_var2_dat, sizeof(scsi_var2_dat))) != 0) {
 			D(bug("scsi_var2 %08lx\n", base));
-			wp = (uint16 *)(ROM_BASE + base);
+			wp = (uint16 *)(ROMBaseHost + base);
 			*wp++ = htons(0x7000);	// moveq #0,d0
 			*wp = htons(M68K_RTS);
 		}
@@ -2018,14 +2108,14 @@ static bool patch_68k(void)
 		static const uint8 scsi_var_dat[] = {0x70, 0x01, 0xa0, 0x89, 0x4a, 0x6e, 0xfe, 0xac, 0x4f, 0xef, 0x00, 0x10, 0x66, 0x00};
 		if ((base = find_rom_data(0x1d700, 0x1d800, scsi_var_dat, sizeof(scsi_var_dat))) != 0) {
 			D(bug("scsi_var %08lx\n", base));
-			wp = (uint16 *)(ROM_BASE + base + 12);
+			wp = (uint16 *)(ROMBaseHost + base + 12);
 			*wp = htons(0x6000);	// bra
 		}
 
 		static const uint8 scsi_var2_dat[] = {0x4e, 0x56, 0xfc, 0x5a, 0x48, 0xe7, 0x1f, 0x38};
 		if ((base = find_rom_data(0x1d900, 0x1da00, scsi_var2_dat, sizeof(scsi_var2_dat))) != 0) {
 			D(bug("scsi_var2 %08lx\n", base));
-			wp = (uint16 *)(ROM_BASE + base);
+			wp = (uint16 *)(ROMBaseHost + base);
 			*wp++ = htons(0x7000);	// moveq #0,d0
 			*wp = htons(M68K_RTS);
 		}
@@ -2036,25 +2126,25 @@ static bool patch_68k(void)
 	static const uint8 adb_init_dat[] = {0x08, 0x2b, 0x00, 0x05, 0x01, 0x5d, 0x66, 0xf8};
 	if ((base = find_rom_data(0x31000, 0x3d000, adb_init_dat, sizeof(adb_init_dat))) == 0) return false;
 	D(bug("adb_init %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base + 6);
+	wp = (uint16 *)(ROMBaseHost + base + 6);
 	*wp = htons(M68K_NOP);
 
 	// Modify check in InitResources() so that addresses >0x80000000 work
 	static const uint8 init_res_dat[] = {0x4a, 0xb8, 0x0a, 0x50, 0x6e, 0x20};
 	if ((base = find_rom_data(0x78000, 0x8c000, init_res_dat, sizeof(init_res_dat))) == 0) return false;
 	D(bug("init_res %08lx\n", base));
-	bp = (uint8 *)(ROM_BASE + base + 4);
+	bp = (uint8 *)(ROMBaseHost + base + 4);
 	*bp = 0x66;
 
 	// Modify vCheckLoad() so that we can patch resources (68k Resource Manager)
 	static const uint8 check_load_dat[] = {0x20, 0x78, 0x07, 0xf0, 0x4e, 0xd0};
 	if ((base = find_rom_data(0x78000, 0x8c000, check_load_dat, sizeof(check_load_dat))) == 0) return false;
 	D(bug("check_load %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(M68K_JMP);
 	*wp++ = htons((ROM_BASE + CHECK_LOAD_PATCH_SPACE) >> 16);
 	*wp = htons((ROM_BASE + CHECK_LOAD_PATCH_SPACE) & 0xffff);
-	wp = (uint16 *)(ROM_BASE + CHECK_LOAD_PATCH_SPACE);
+	wp = (uint16 *)(ROMBaseHost + CHECK_LOAD_PATCH_SPACE);
 	*wp++ = htons(0x2f03);			// move.l	d3,-(a7)
 	*wp++ = htons(0x2078);			// move.l	$07f0,a0
 	*wp++ = htons(0x07f0);
@@ -2070,17 +2160,17 @@ static bool patch_68k(void)
 		sony_offset = find_rom_resource(FOURCC('n','d','r','v'), -20196);		// NewWorld 1.6 has "PCFloppy" ndrv
 		if (sony_offset == 0)
 			return false;
-		lp = (uint32 *)(ROM_BASE + rsrc_ptr + 8);
+		lp = (uint32 *)(ROMBaseHost + rsrc_ptr + 8);
 		*lp = htonl(FOURCC('D','R','V','R'));
-		wp = (uint16 *)(ROM_BASE + rsrc_ptr + 12);
+		wp = (uint16 *)(ROMBaseHost + rsrc_ptr + 12);
 		*wp = htons(4);
 	}
 	D(bug("sony_offset %08lx\n", sony_offset));
-	memcpy((void *)(ROM_BASE + sony_offset), sony_driver, sizeof(sony_driver));
+	memcpy((void *)(ROMBaseHost + sony_offset), sony_driver, sizeof(sony_driver));
 
 	// Install .Disk and .AppleCD drivers
-	memcpy((void *)(ROM_BASE + sony_offset + 0x100), disk_driver, sizeof(disk_driver));
-	memcpy((void *)(ROM_BASE + sony_offset + 0x200), cdrom_driver, sizeof(cdrom_driver));
+	memcpy((void *)(ROMBaseHost + sony_offset + 0x100), disk_driver, sizeof(disk_driver));
+	memcpy((void *)(ROMBaseHost + sony_offset + 0x200), cdrom_driver, sizeof(cdrom_driver));
 
 	// Install serial drivers
 	gen_ain_driver( ROM_BASE + sony_offset + 0x300);
@@ -2090,64 +2180,64 @@ static bool patch_68k(void)
 
 	// Copy icons to ROM
 	SonyDiskIconAddr = ROM_BASE + sony_offset + 0x800;
-	memcpy((void *)(ROM_BASE + sony_offset + 0x800), SonyDiskIcon, sizeof(SonyDiskIcon));
+	memcpy(ROMBaseHost + sony_offset + 0x800, SonyDiskIcon, sizeof(SonyDiskIcon));
 	SonyDriveIconAddr = ROM_BASE + sony_offset + 0xa00;
-	memcpy((void *)(ROM_BASE + sony_offset + 0xa00), SonyDriveIcon, sizeof(SonyDriveIcon));
+	memcpy(ROMBaseHost + sony_offset + 0xa00, SonyDriveIcon, sizeof(SonyDriveIcon));
 	DiskIconAddr = ROM_BASE + sony_offset + 0xc00;
-	memcpy((void *)(ROM_BASE + sony_offset + 0xc00), DiskIcon, sizeof(DiskIcon));
+	memcpy(ROMBaseHost + sony_offset + 0xc00, DiskIcon, sizeof(DiskIcon));
 	CDROMIconAddr = ROM_BASE + sony_offset + 0xe00;
-	memcpy((void *)(ROM_BASE + sony_offset + 0xe00), CDROMIcon, sizeof(CDROMIcon));
+	memcpy(ROMBaseHost + sony_offset + 0xe00, CDROMIcon, sizeof(CDROMIcon));
 
 	// Patch driver install routine
 	static const uint8 drvr_install_dat[] = {0xa7, 0x1e, 0x21, 0xc8, 0x01, 0x1c, 0x4e, 0x75};
 	if ((base = find_rom_data(0xb00, 0xd00, drvr_install_dat, sizeof(drvr_install_dat))) == 0) return false;
 	D(bug("drvr_install %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base + 8);
+	wp = (uint16 *)(ROMBaseHost + base + 8);
 	*wp++ = htons(M68K_EMUL_OP_INSTALL_DRIVERS);
 	*wp = htons(M68K_RTS);
 
 	// Don't install serial drivers from ROM
 	if (ROMType == ROMTYPE_ZANZIBAR || ROMType == ROMTYPE_NEWWORLD || ROMType == ROMTYPE_GOSSAMER) {
-		wp = (uint16 *)(ROM_BASE + find_rom_resource(FOURCC('S','E','R','D'), 0));
+		wp = (uint16 *)(ROMBaseHost + find_rom_resource(FOURCC('S','E','R','D'), 0));
 		*wp = htons(M68K_RTS);
 	} else {
-		wp = (uint16 *)(ROM_BASE + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0xc4);
+		wp = (uint16 *)(ROMBaseHost + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0xc4);
 		*wp++ = htons(M68K_NOP);
 		*wp++ = htons(M68K_NOP);
 		*wp++ = htons(M68K_NOP);
 		*wp++ = htons(M68K_NOP);
 		*wp = htons(0x7000);			// moveq	#0,d0
-		wp = (uint16 *)(ROM_BASE + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0x8ee);
+		wp = (uint16 *)(ROMBaseHost + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0x8ee);
 		*wp = htons(M68K_NOP);
 	}
 	uint32 nsrd_offset = find_rom_resource(FOURCC('n','s','r','d'), 1);
 	if (nsrd_offset) {
-		lp = (uint32 *)(ROM_BASE + rsrc_ptr + 8);
+		lp = (uint32 *)(ROMBaseHost + rsrc_ptr + 8);
 		*lp = htonl(FOURCC('x','s','r','d'));
 	}
 
 	// Replace ADBOp()
-	memcpy((void *)(ROM_BASE + find_rom_trap(0xa07c)), adbop_patch, sizeof(adbop_patch));
+	memcpy(ROMBaseHost + find_rom_trap(0xa07c), adbop_patch, sizeof(adbop_patch));
 
 	// Replace Time Manager
-	wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa058));
+	wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa058));
 	*wp++ = htons(M68K_EMUL_OP_INSTIME);
 	*wp = htons(M68K_RTS);
-	wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa059));
+	wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa059));
 	*wp++ = htons(0x40e7);		// move	sr,-(sp)
 	*wp++ = htons(0x007c);		// ori	#$0700,sr
 	*wp++ = htons(0x0700);
 	*wp++ = htons(M68K_EMUL_OP_RMVTIME);
 	*wp++ = htons(0x46df);		// move	(sp)+,sr
 	*wp = htons(M68K_RTS);
-	wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa05a));
+	wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa05a));
 	*wp++ = htons(0x40e7);		// move	sr,-(sp)
 	*wp++ = htons(0x007c);		// ori	#$0700,sr
 	*wp++ = htons(0x0700);
 	*wp++ = htons(M68K_EMUL_OP_PRIMETIME);
 	*wp++ = htons(0x46df);		// move	(sp)+,sr
 	*wp = htons(M68K_RTS);
-	wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa093));
+	wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa093));
 	*wp++ = htons(M68K_EMUL_OP_MICROSECONDS);
 	*wp = htons(M68K_RTS);
 
@@ -2155,7 +2245,7 @@ static bool patch_68k(void)
 	static const uint8 egret_dat[] = {0x2f, 0x30, 0x81, 0xe2, 0x20, 0x10, 0x00, 0x18};
 	if ((base = find_rom_data(0xa000, 0x10000, egret_dat, sizeof(egret_dat))) == 0) return false;
 	D(bug("egret %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	*wp++ = htons(0x7000);
 	*wp = htons(M68K_RTS);
 
@@ -2163,7 +2253,7 @@ static bool patch_68k(void)
 	static const uint8 shutdown_dat[] = {0x40, 0xe7, 0x00, 0x7c, 0x07, 0x00, 0x48, 0xe7, 0x3f, 0x00, 0x2c, 0x00, 0x2e, 0x01};
 	if ((base = find_rom_data(0x30000, 0x40000, shutdown_dat, sizeof(shutdown_dat))) == 0) return false;
 	D(bug("shutdown %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);
+	wp = (uint16 *)(ROMBaseHost + base);
 	if (ROMType == ROMTYPE_ZANZIBAR)
 		*wp = htons(M68K_RTS);
 	else if (ntohs(wp[-4]) == 0x61ff)
@@ -2172,7 +2262,7 @@ static bool patch_68k(void)
 		wp[-2] = htons(0x6000);	// bra
 
 	// Patch PowerOff()
-	wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa05b));	// PowerOff()
+	wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa05b));	// PowerOff()
 	*wp = htons(M68K_EMUL_RETURN);
 
 	// Patch VIA interrupt handler
@@ -2180,7 +2270,7 @@ static bool patch_68k(void)
 	if ((base = find_rom_data(0x13000, 0x1c000, via_int_dat, sizeof(via_int_dat))) == 0) return false;
 	D(bug("via_int %08lx\n", base));
 	uint32 level1_int = ROM_BASE + base;
-	wp = (uint16 *)level1_int;			// Level 1 handler
+	wp = (uint16 *)(ROMBaseHost + base);	// Level 1 handler
 	*wp++ = htons(0x7002);			// moveq	#2,d0 (60Hz interrupt)
 	*wp++ = htons(M68K_NOP);
 	*wp++ = htons(M68K_NOP);
@@ -2190,7 +2280,7 @@ static bool patch_68k(void)
 	static const uint8 via_int2_dat[] = {0x13, 0x7c, 0x00, 0x02, 0x1a, 0x00, 0x4e, 0x71, 0x52, 0xb8, 0x01, 0x6a};
 	if ((base = find_rom_data(0x10000, 0x18000, via_int2_dat, sizeof(via_int2_dat))) == 0) return false;
 	D(bug("via_int2 %08lx\n", base));
-	wp = (uint16 *)(ROM_BASE + base);	// 60Hz handler
+	wp = (uint16 *)(ROMBaseHost + base);	// 60Hz handler
 	*wp++ = htons(M68K_EMUL_OP_IRQ);
 	*wp++ = htons(0x4a80);			// tst.l	d0
 	*wp++ = htons(0x6700);			// beq		xxx
@@ -2200,7 +2290,7 @@ static bool patch_68k(void)
 		static const uint8 via_int3_dat[] = {0x48, 0xe7, 0xf0, 0xf0, 0x76, 0x01, 0x60, 0x26};
 		if ((base = find_rom_data(0x15000, 0x19000, via_int3_dat, sizeof(via_int3_dat))) == 0) return false;
 		D(bug("via_int3 %08lx\n", base));
-		wp = (uint16 *)(ROM_BASE + base);	// CHRP level 1 handler
+		wp = (uint16 *)(ROMBaseHost + base);	// CHRP level 1 handler
 		*wp++ = htons(M68K_JMP);
 		*wp++ = htons((level1_int - 12) >> 16);
 		*wp = htons((level1_int - 12) & 0xffff);
@@ -2208,39 +2298,39 @@ static bool patch_68k(void)
 
 	// Patch PutScrap() for clipboard exchange with host OS
 	uint32 put_scrap = find_rom_trap(0xa9fe);	// PutScrap()
-	wp = (uint16 *)(ROM_BASE + PUT_SCRAP_PATCH_SPACE);
+	wp = (uint16 *)(ROMBaseHost + PUT_SCRAP_PATCH_SPACE);
 	*wp++ = htons(M68K_EMUL_OP_PUT_SCRAP);
 	*wp++ = htons(M68K_JMP);
 	*wp++ = htons((ROM_BASE + put_scrap) >> 16);
 	*wp++ = htons((ROM_BASE + put_scrap) & 0xffff);
-	lp = (uint32 *)(ROM_BASE + 0x22);
-	lp = (uint32 *)(ROM_BASE + ntohl(*lp));
-	lp[0xa9fe & 0x3ff] = htonl(PUT_SCRAP_PATCH_SPACE);
+	base = ROM_BASE + ReadMacInt32(ROM_BASE + 0x22);
+	WriteMacInt32(base + 4 * (0xa9fe & 0x3ff), PUT_SCRAP_PATCH_SPACE);
 
 	// Patch GetScrap() for clipboard exchange with host OS
 	uint32 get_scrap = find_rom_trap(0xa9fd);	// GetScrap()
-	wp = (uint16 *)(ROM_BASE + GET_SCRAP_PATCH_SPACE);
+	wp = (uint16 *)(ROMBaseHost + GET_SCRAP_PATCH_SPACE);
 	*wp++ = htons(M68K_EMUL_OP_GET_SCRAP);
 	*wp++ = htons(M68K_JMP);
 	*wp++ = htons((ROM_BASE + get_scrap) >> 16);
 	*wp++ = htons((ROM_BASE + get_scrap) & 0xffff);
-	lp = (uint32 *)(ROM_BASE + 0x22);
-	lp = (uint32 *)(ROM_BASE + ntohl(*lp));
-	lp[0xa9fd & 0x3ff] = htonl(GET_SCRAP_PATCH_SPACE);
+	base = ROM_BASE + ReadMacInt32(ROM_BASE + 0x22);
+	WriteMacInt32(base + 4 * (0xa9fd & 0x3ff), GET_SCRAP_PATCH_SPACE);
 
-#if __BEOS__
 	// Patch SynchIdleTime()
 	if (PrefsFindBool("idlewait")) {
-		wp = (uint16 *)(ROM_BASE + find_rom_trap(0xabf7) + 4);	// SynchIdleTime()
-		D(bug("SynchIdleTime at %08lx\n", wp));
-		if (ntohs(*wp) == 0x2078) {
+		base = find_rom_trap(0xabf7) + 4;						// SynchIdleTime()
+		wp = (uint16 *)(ROMBaseHost + base);
+		D(bug("SynchIdleTime at %08lx\n", base));
+		if (ntohs(*wp) == 0x2078) {								// movea.l	ExpandMem,a0
 			*wp++ = htons(M68K_EMUL_OP_IDLE_TIME);
 			*wp = htons(M68K_NOP);
-		} else {
+		}
+		else if (ntohs(*wp) == 0x70fe)							// moveq	#-2,d0
+			*wp++ = htons(M68K_EMUL_OP_IDLE_TIME_2);
+		else {
 			D(bug("SynchIdleTime patch not installed\n"));
 		}
 	}
-#endif
 
 	// Construct list of all sifters used by sound components in ROM
 	D(bug("Searching for sound components with type sdev in ROM\n"));
@@ -2264,7 +2354,7 @@ static bool patch_68k(void)
 		if ((thing = find_rom_resource(sifter_list[i].type, sifter_list[i].id)) != 0) {
 			D(bug(" patching type %08x, id %d\n", sifter_list[i].type, sifter_list[i].id));
 			// Install 68k glue code
-			uint16 *wp = (uint16 *)(ROM_BASE + thing);
+			uint16 *wp = (uint16 *)(ROMBaseHost + thing);
 			*wp++ = htons(0x4e56); *wp++ = htons(0x0000);	// link a6,#0
 			*wp++ = htons(0x48e7); *wp++ = htons(0x8018);	// movem.l d0/a3-a4,-(a7)
 			*wp++ = htons(0x266e); *wp++ = htons(0x000c);	// movea.l $c(a6),a3
@@ -2291,6 +2381,15 @@ void InstallDrivers(void)
 	SheepArray<SIZEOF_IOParam> pb_var;
 	const uintptr pb = pb_var.addr();
 
+#if DISABLE_SCSI
+	// Setup fake SCSI Globals
+	r.d[0] = 0x1000;
+	Execute68kTrap(0xa71e, &r);		// NewPtrSysClear()
+	uint32 scsi_globals = r.a[0];
+	D(bug("Fake SCSI globals at %08lx\n", scsi_globals));
+	WriteMacInt32(0xc0c, scsi_globals);	// Set SCSIGlobals
+#endif
+
 	// Install floppy driver
 	if (ROMType == ROMTYPE_NEWWORLD || ROMType == ROMTYPE_GOSSAMER) {
 
@@ -2305,11 +2404,6 @@ void InstallDrivers(void)
 		WriteMacInt16(dce + dCtlFlags, SonyDriverFlags);
 	}
 
-#if DISABLE_SCSI && 0
-	// Fake SCSIGlobals
-	WriteMacInt32(0xc0c, SheepMem::ZeroPage());
-#endif
-
 	// Open .Sony driver
 	SheepString sony_str("\005.Sony");
 	WriteMacInt8(pb + ioPermssn, 0);