1 |
|
/* |
2 |
|
* main_beos.cpp - Emulation core, BeOS implementation |
3 |
|
* |
4 |
< |
* SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig |
4 |
> |
* SheepShaver (C) 1997-2008 Christian Bauer and Marc Hellwig |
5 |
|
* |
6 |
|
* This program is free software; you can redistribute it and/or modify |
7 |
|
* it under the terms of the GNU General Public License as published by |
74 |
|
#include "xpram.h" |
75 |
|
#include "timer.h" |
76 |
|
#include "adb.h" |
77 |
– |
#include "sony.h" |
78 |
– |
#include "disk.h" |
79 |
– |
#include "cdrom.h" |
80 |
– |
#include "scsi.h" |
77 |
|
#include "video.h" |
82 |
– |
#include "audio.h" |
83 |
– |
#include "ether.h" |
84 |
– |
#include "serial.h" |
85 |
– |
#include "clip.h" |
86 |
– |
#include "extfs.h" |
78 |
|
#include "sys.h" |
79 |
|
#include "macos_util.h" |
80 |
|
#include "rom_patches.h" |
81 |
|
#include "user_strings.h" |
91 |
– |
#include "thunks.h" |
82 |
|
|
83 |
|
#include "sheep_driver.h" |
84 |
|
|
107 |
|
const char RAM_AREA_NAME[] = "Macintosh RAM"; |
108 |
|
const char ROM_AREA_NAME[] = "Macintosh ROM"; |
109 |
|
const char DR_CACHE_AREA_NAME[] = "Macintosh DR Cache"; |
110 |
+ |
const char DR_EMULATOR_AREA_NAME[] = "Macintosh DR Emulator"; |
111 |
|
const char SHEEP_AREA_NAME[] = "SheepShaver Virtual Stack"; |
112 |
|
|
113 |
+ |
const uintptr ROM_BASE = 0x40800000; // Base address of ROM |
114 |
+ |
|
115 |
|
const uint32 SIG_STACK_SIZE = 8192; // Size of signal stack |
116 |
|
|
117 |
|
const uint32 MSG_START = 'strt'; // Emulator start message |
135 |
|
// Initialize other variables |
136 |
|
sheep_fd = -1; |
137 |
|
emulator_data = NULL; |
138 |
< |
kernel_area = kernel_area2 = rom_area = ram_area = dr_cache_area = -1; |
138 |
> |
kernel_area = kernel_area2 = rom_area = ram_area = dr_cache_area = dr_emulator_area = -1; |
139 |
|
emul_thread = nvram_thread = tick_thread = -1; |
140 |
|
ReadyForSignals = false; |
141 |
|
AllowQuitting = true; |
183 |
|
area_id rom_area; // ROM area ID |
184 |
|
area_id ram_area; // RAM area ID |
185 |
|
area_id dr_cache_area; // DR Cache area ID |
186 |
+ |
area_id dr_emulator_area; // DR Emulator area ID |
187 |
|
|
188 |
|
struct sigaction sigusr1_action; // Interrupt signal (of emulator thread) |
189 |
|
struct sigaction sigsegv_action; // Data access exception signal (of emulator thread) |
204 |
|
#endif |
205 |
|
uint32 RAMBase; // Base address of Mac RAM |
206 |
|
uint32 RAMSize; // Size of Mac RAM |
207 |
+ |
uint32 ROMBase; // Base address of Mac ROM |
208 |
|
uint32 KernelDataAddr; // Address of Kernel Data |
209 |
|
uint32 BootGlobsAddr; // Address of BootGlobs structure at top of Mac RAM |
210 |
|
uint32 DRCacheAddr; // Address of DR Cache |
211 |
+ |
uint32 DREmulatorAddr; // Address of DR Emulator |
212 |
|
uint32 PVR; // Theoretical PVR |
213 |
|
int64 CPUClockSpeed; // Processor clock speed (Hz) |
214 |
|
int64 BusClockSpeed; // Bus clock speed (Hz) |
215 |
+ |
int64 TimebaseSpeed; // Timebase clock speed (Hz) |
216 |
|
system_info SysInfo; // System information |
217 |
+ |
uint8 *RAMBaseHost; // Base address of Mac RAM (host address space) |
218 |
+ |
uint8 *ROMBaseHost; // Base address of Mac ROM (host address space) |
219 |
|
|
220 |
|
static void *sig_stack = NULL; // Stack for signal handlers |
221 |
|
static void *extra_stack = NULL; // Stack for SIGSEGV inside interrupt handler |
222 |
+ |
uint32 SheepMem::page_size; // Size of a native page |
223 |
|
uintptr SheepMem::zero_page = 0; // Address of ro page filled in with zeros |
224 |
|
uintptr SheepMem::base; // Address of SheepShaver data |
225 |
< |
uintptr SheepMem::top; // Top of SheepShaver data (stack like storage) |
225 |
> |
uintptr SheepMem::proc; // Bottom address of SheepShave procedures |
226 |
> |
uintptr SheepMem::data; // Top of SheepShaver data (stack like storage) |
227 |
|
static area_id SheepMemArea; // SheepShaver data area ID |
228 |
|
|
229 |
|
|
296 |
|
} |
297 |
|
CPUClockSpeed = SysInfo.cpu_clock_speed; |
298 |
|
BusClockSpeed = SysInfo.bus_clock_speed; |
299 |
+ |
TimebaseSpeed = BusClockSpeed / 4; |
300 |
|
|
301 |
|
// Delete old areas |
302 |
|
area_id old_kernel_area = find_area(KERNEL_AREA_NAME); |
314 |
|
area_id old_dr_cache_area = find_area(DR_CACHE_AREA_NAME); |
315 |
|
if (old_dr_cache_area > 0) |
316 |
|
delete_area(old_dr_cache_area); |
317 |
+ |
area_id old_dr_emulator_area = find_area(DR_EMULATOR_AREA_NAME); |
318 |
+ |
if (old_dr_emulator_area > 0) |
319 |
+ |
delete_area(old_dr_emulator_area); |
320 |
|
|
321 |
|
// Read preferences |
322 |
|
int argc = 0; |
323 |
|
char **argv = NULL; |
324 |
< |
PrefsInit(argc, argv); |
324 |
> |
PrefsInit(NULL, argc, argv); |
325 |
|
|
326 |
|
// Init system routines |
327 |
|
SysInit(); |
364 |
|
void SheepShaver::StartEmulator(void) |
365 |
|
{ |
366 |
|
char str[256]; |
362 |
– |
int16 i16; |
367 |
|
|
368 |
|
// Open sheep driver and remap low memory |
369 |
|
sheep_fd = open("/dev/sheep", 0); |
406 |
|
|
407 |
|
// Create area for SheepShaver data |
408 |
|
if (!SheepMem::Init()) { |
409 |
< |
sprintf(str, GetString(STR_NO_SHEEP_MEM_AREA_ERR)); |
409 |
> |
sprintf(str, GetString(STR_NO_SHEEP_MEM_AREA_ERR), strerror(SheepMemArea), SheepMemArea); |
410 |
|
ErrorAlert(str); |
411 |
|
PostMessage(B_QUIT_REQUESTED); |
412 |
|
return; |
427 |
|
PostMessage(B_QUIT_REQUESTED); |
428 |
|
return; |
429 |
|
} |
430 |
< |
D(bug("RAM area %ld at %p\n", ram_area, RAMBase)); |
430 |
> |
RAMBaseHost = (uint8 *)RAMBase |
431 |
> |
D(bug("RAM area %ld at %p\n", ram_area, RAMBaseHost)); |
432 |
|
|
433 |
|
// Create area and load Mac ROM |
434 |
|
try { |
462 |
|
} |
463 |
|
D(bug("DR Cache area %ld at %p\n", dr_cache_area, DRCacheAddr)); |
464 |
|
|
465 |
< |
// Load NVRAM |
466 |
< |
XPRAMInit(); |
467 |
< |
|
468 |
< |
// Set boot volume |
469 |
< |
i16 = PrefsFindInt32("bootdrive"); |
470 |
< |
XPRAM[0x1378] = i16 >> 8; |
466 |
< |
XPRAM[0x1379] = i16 & 0xff; |
467 |
< |
i16 = PrefsFindInt32("bootdriver"); |
468 |
< |
XPRAM[0x137a] = i16 >> 8; |
469 |
< |
XPRAM[0x137b] = i16 & 0xff; |
470 |
< |
|
471 |
< |
// Create BootGlobs at top of Mac memory |
472 |
< |
memset((void *)(RAMBase + RAMSize - 4096), 0, 4096); |
473 |
< |
BootGlobsAddr = RAMBase + RAMSize - 0x1c; |
474 |
< |
uint32 *boot_globs = (uint32 *)BootGlobsAddr; |
475 |
< |
boot_globs[-5] = htonl(RAMBase + RAMSize); // MemTop |
476 |
< |
boot_globs[0] = htonl(RAMBase); // First RAM bank |
477 |
< |
boot_globs[1] = htonl(RAMSize); |
478 |
< |
boot_globs[2] = htonl((uint32)-1); // End of bank table |
479 |
< |
|
480 |
< |
// Init thunks |
481 |
< |
if (!InitThunks()) { |
482 |
< |
PostMessage(B_QUIT_REQUESTED); |
483 |
< |
return; |
484 |
< |
} |
485 |
< |
|
486 |
< |
// Init drivers |
487 |
< |
SonyInit(); |
488 |
< |
DiskInit(); |
489 |
< |
CDROMInit(); |
490 |
< |
SCSIInit(); |
491 |
< |
|
492 |
< |
// Init external file system |
493 |
< |
ExtFSInit(); |
494 |
< |
|
495 |
< |
// Init audio |
496 |
< |
AudioInit(); |
497 |
< |
|
498 |
< |
// Init network |
499 |
< |
EtherInit(); |
500 |
< |
|
501 |
< |
// Init serial ports |
502 |
< |
SerialInit(); |
503 |
< |
|
504 |
< |
// Init Time Manager |
505 |
< |
TimerInit(); |
506 |
< |
|
507 |
< |
// Init clipboard |
508 |
< |
ClipInit(); |
509 |
< |
|
510 |
< |
// Init video |
511 |
< |
if (!VideoInit()) { |
465 |
> |
// Create area for DR Emulator |
466 |
> |
DREmulatorAddr = DR_EMULATOR_BASE; |
467 |
> |
dr_emulator_area = create_area(DR_EMULATOR_AREA_NAME, (void **)&DREmulatorAddr, B_EXACT_ADDRESS, DR_EMULATOR_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); |
468 |
> |
if (dr_emulator_area < 0) { |
469 |
> |
sprintf(str, GetString(STR_NO_KERNEL_DATA_ERR), strerror(dr_emulator_area), dr_emulator_area); |
470 |
> |
ErrorAlert(str); |
471 |
|
PostMessage(B_QUIT_REQUESTED); |
472 |
|
return; |
473 |
|
} |
474 |
+ |
D(bug("DR Emulator area %ld at %p\n", dr_emulator_area, DREmulatorAddr)); |
475 |
|
|
476 |
< |
// Install ROM patches |
477 |
< |
if (!PatchROM()) { |
518 |
< |
ErrorAlert(GetString(STR_UNSUPPORTED_ROM_TYPE_ERR)); |
476 |
> |
// Initialize everything |
477 |
> |
if (!InitAll(NULL)) { |
478 |
|
PostMessage(B_QUIT_REQUESTED); |
479 |
|
return; |
480 |
|
} |
481 |
+ |
D(bug("Initialization complete\n")); |
482 |
|
|
483 |
|
// Clear caches (as we loaded and patched code) and write protect ROM |
484 |
|
#if !EMULATED_PPC |
485 |
< |
clear_caches((void *)ROM_BASE, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); |
485 |
> |
clear_caches(ROMBaseHost, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); |
486 |
|
#endif |
487 |
|
set_area_protection(rom_area, B_READ_AREA); |
488 |
|
|
529 |
– |
// Initialize Kernel Data |
530 |
– |
memset(kernel_data, 0, sizeof(KernelData)); |
531 |
– |
if (ROMType == ROMTYPE_NEWWORLD) { |
532 |
– |
static uint32 of_dev_tree[4] = {0, 0, 0, 0}; |
533 |
– |
static uint8 vector_lookup_tbl[128]; |
534 |
– |
static uint8 vector_mask_tbl[64]; |
535 |
– |
memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80); |
536 |
– |
memset(vector_lookup_tbl, 0, 128); |
537 |
– |
memset(vector_mask_tbl, 0, 64); |
538 |
– |
kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE); |
539 |
– |
kernel_data->v[0xb84 >> 2] = htonl((uint32)of_dev_tree); // OF device tree base |
540 |
– |
kernel_data->v[0xb90 >> 2] = htonl((uint32)vector_lookup_tbl); |
541 |
– |
kernel_data->v[0xb94 >> 2] = htonl((uint32)vector_mask_tbl); |
542 |
– |
kernel_data->v[0xb98 >> 2] = htonl(ROM_BASE); // OpenPIC base |
543 |
– |
kernel_data->v[0xbb0 >> 2] = htonl(0); // ADB base |
544 |
– |
kernel_data->v[0xc20 >> 2] = htonl(RAMSize); |
545 |
– |
kernel_data->v[0xc24 >> 2] = htonl(RAMSize); |
546 |
– |
kernel_data->v[0xc30 >> 2] = htonl(RAMSize); |
547 |
– |
kernel_data->v[0xc34 >> 2] = htonl(RAMSize); |
548 |
– |
kernel_data->v[0xc38 >> 2] = htonl(0x00010020); |
549 |
– |
kernel_data->v[0xc3c >> 2] = htonl(0x00200001); |
550 |
– |
kernel_data->v[0xc40 >> 2] = htonl(0x00010000); |
551 |
– |
kernel_data->v[0xc50 >> 2] = htonl(RAMBase); |
552 |
– |
kernel_data->v[0xc54 >> 2] = htonl(RAMSize); |
553 |
– |
kernel_data->v[0xf60 >> 2] = htonl(PVR); |
554 |
– |
kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed); |
555 |
– |
kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed); |
556 |
– |
kernel_data->v[0xf6c >> 2] = htonl(CPUClockSpeed); |
557 |
– |
} else { |
558 |
– |
kernel_data->v[0xc80 >> 2] = htonl(RAMSize); |
559 |
– |
kernel_data->v[0xc84 >> 2] = htonl(RAMSize); |
560 |
– |
kernel_data->v[0xc90 >> 2] = htonl(RAMSize); |
561 |
– |
kernel_data->v[0xc94 >> 2] = htonl(RAMSize); |
562 |
– |
kernel_data->v[0xc98 >> 2] = htonl(0x00010020); |
563 |
– |
kernel_data->v[0xc9c >> 2] = htonl(0x00200001); |
564 |
– |
kernel_data->v[0xca0 >> 2] = htonl(0x00010000); |
565 |
– |
kernel_data->v[0xcb0 >> 2] = htonl(RAMBase); |
566 |
– |
kernel_data->v[0xcb4 >> 2] = htonl(RAMSize); |
567 |
– |
kernel_data->v[0xf80 >> 2] = htonl(PVR); |
568 |
– |
kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed); |
569 |
– |
kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed); |
570 |
– |
kernel_data->v[0xf8c >> 2] = htonl(CPUClockSpeed); |
571 |
– |
} |
572 |
– |
|
489 |
|
// Initialize extra low memory |
490 |
< |
D(bug("Initializing Low Memory...\n")); |
575 |
< |
memset(NULL, 0, 0x3000); |
576 |
< |
WriteMacInt32(XLM_SIGNATURE, 'Baah'); // Signature to detect SheepShaver |
577 |
< |
WriteMacInt32(XLM_KERNEL_DATA, (uint32)kernel_data); // For trap replacement routines |
490 |
> |
D(bug("Initializing extra Low Memory...\n")); |
491 |
|
WriteMacInt32(XLM_SHEEP_OBJ, (uint32)this); // Pointer to SheepShaver object |
492 |
< |
WriteMacInt32(XLM_PVR, PVR); // Theoretical PVR |
580 |
< |
WriteMacInt32(XLM_BUS_CLOCK, BusClockSpeed); // For DriverServicesLib patch |
581 |
< |
WriteMacInt16(XLM_EXEC_RETURN_OPCODE, M68K_EXEC_RETURN); // For Execute68k() (RTS from the executed 68k code will jump here and end 68k mode) |
582 |
< |
WriteMacInt32(XLM_ZERO_PAGE, SheepMem::ZeroPage()); // Pointer to read-only page with all bits set to 0 |
583 |
< |
#if !EMULATED_PPC |
584 |
< |
WriteMacInt32(XLM_TOC, (uint32)TOC); // TOC pointer of emulator |
585 |
< |
WriteMacInt32(XLM_ETHER_INIT, *(uint32 *)InitStreamModule); // DLPI ethernet driver functions |
586 |
< |
WriteMacInt32(XLM_ETHER_TERM, *(uint32 *)TerminateStreamModule); |
587 |
< |
WriteMacInt32(XLM_ETHER_OPEN, *(uint32 *)ether_open); |
588 |
< |
WriteMacInt32(XLM_ETHER_CLOSE, *(uint32 *)ether_close); |
589 |
< |
WriteMacInt32(XLM_ETHER_WPUT, *(uint32 *)ether_wput); |
590 |
< |
WriteMacInt32(XLM_ETHER_RSRV, *(uint32 *)ether_rsrv); |
591 |
< |
WriteMacInt32(XLM_VIDEO_DOIO, *(uint32 *)VideoDoDriverIO); |
592 |
< |
#endif |
593 |
< |
D(bug("Low Memory initialized\n")); |
492 |
> |
D(bug("Extra Low Memory initialized\n")); |
493 |
|
|
494 |
|
// Disallow quitting with Alt-Q from now on |
495 |
|
AllowQuitting = false; |
545 |
|
if (emul_thread > 0) |
546 |
|
wait_for_thread(emul_thread, &l); |
547 |
|
|
548 |
< |
// Save NVRAM |
549 |
< |
XPRAMExit(); |
651 |
< |
|
652 |
< |
// Exit clipboard |
653 |
< |
ClipExit(); |
654 |
< |
|
655 |
< |
// Exit Time Manager |
656 |
< |
TimerExit(); |
657 |
< |
|
658 |
< |
// Exit serial |
659 |
< |
SerialExit(); |
660 |
< |
|
661 |
< |
// Exit network |
662 |
< |
EtherExit(); |
663 |
< |
|
664 |
< |
// Exit audio |
665 |
< |
AudioExit(); |
666 |
< |
|
667 |
< |
// Exit video |
668 |
< |
VideoExit(); |
669 |
< |
|
670 |
< |
// Exit external file system |
671 |
< |
ExtFSExit(); |
672 |
< |
|
673 |
< |
// Exit drivers |
674 |
< |
SCSIExit(); |
675 |
< |
CDROMExit(); |
676 |
< |
DiskExit(); |
677 |
< |
SonyExit(); |
548 |
> |
// Deinitialize everything |
549 |
> |
ExitAll(); |
550 |
|
|
551 |
|
// Delete SheepShaver globals |
552 |
|
SheepMem::Exit(); |
553 |
|
|
554 |
+ |
// Delete DR Emulator area |
555 |
+ |
if (dr_emulator_area >= 0) |
556 |
+ |
delete_area(dr_emulator_area); |
557 |
+ |
|
558 |
|
// Delete DR Cache area |
559 |
|
if (dr_cache_area >= 0) |
560 |
|
delete_area(dr_cache_area); |
599 |
|
|
600 |
|
void SheepShaver::init_rom(void) |
601 |
|
{ |
602 |
+ |
// Size of a native page |
603 |
+ |
page_size = B_PAGE_SIZE; |
604 |
+ |
|
605 |
|
// Create area for ROM |
606 |
< |
void *rom_addr = (void *)ROM_BASE; |
607 |
< |
rom_area = create_area(ROM_AREA_NAME, &rom_addr, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); |
606 |
> |
ROMBase = ROM_BASE; |
607 |
> |
rom_area = create_area(ROM_AREA_NAME, (void **)&ROMBase, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); |
608 |
|
if (rom_area < 0) |
609 |
|
throw area_error(); |
610 |
+ |
ROMBaseHost = (uint8 *)ROMBase; |
611 |
|
D(bug("ROM area %ld at %p\n", rom_area, rom_addr)); |
612 |
|
|
613 |
|
// Load ROM |
628 |
|
const char *rom_path = PrefsFindString("rom"); |
629 |
|
|
630 |
|
// Try to open ROM file |
631 |
< |
BFile file(rom_path ? rom_path : ROM_FILE_NAME, B_READ_ONLY); |
631 |
> |
BFile file(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, B_READ_ONLY); |
632 |
|
if (file.InitCheck() != B_NO_ERROR) { |
633 |
|
|
634 |
|
// Failed, then ask memory_mess driver for ROM |
635 |
|
uint8 *rom = new uint8[ROM_SIZE]; // Reading directly into the area doesn't work |
636 |
|
ssize_t actual = read(sheep_fd, (void *)rom, ROM_SIZE); |
637 |
|
if (actual == ROM_SIZE) { |
638 |
< |
memcpy((void *)ROM_BASE, rom, ROM_SIZE); |
638 |
> |
memcpy(ROMBaseHost, rom, ROM_SIZE); |
639 |
|
delete[] rom; |
640 |
|
return; |
641 |
|
} else |
706 |
|
|
707 |
|
// Jump to ROM boot routine |
708 |
|
D(bug("Jumping to ROM\n")); |
709 |
< |
obj->jump_to_rom(ROM_BASE + 0x310000); |
709 |
> |
obj->jump_to_rom(ROMBase + 0x310000); |
710 |
|
D(bug("Returned from ROM\n")); |
711 |
|
|
712 |
|
// We're no longer ready to receive signals |
1187 |
|
* Make code executable |
1188 |
|
*/ |
1189 |
|
|
1190 |
< |
void MakeExecutable(int dummy, void *start, uint32 length) |
1190 |
> |
void MakeExecutable(int dummy, uint32 start, uint32 length) |
1191 |
|
{ |
1192 |
< |
if (((uint32)start >= ROM_BASE) && ((uint32)start < (ROM_BASE + ROM_SIZE))) |
1192 |
> |
if ((start >= ROMBase) && (start < (ROMBase + ROM_SIZE))) |
1193 |
|
return; |
1194 |
< |
clear_caches(start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); |
1315 |
< |
} |
1316 |
< |
|
1317 |
< |
|
1318 |
< |
/* |
1319 |
< |
* Patch things after system startup (gets called by disk driver accRun routine) |
1320 |
< |
*/ |
1321 |
< |
|
1322 |
< |
void PatchAfterStartup(void) |
1323 |
< |
{ |
1324 |
< |
ExecuteNative(NATIVE_VIDEO_INSTALL_ACCEL); |
1325 |
< |
InstallExtFS(); |
1194 |
> |
clear_caches((void *)start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); |
1195 |
|
} |
1196 |
|
|
1197 |
|
|
1252 |
|
|
1253 |
|
void TriggerInterrupt(void) |
1254 |
|
{ |
1255 |
+ |
idle_resume(); |
1256 |
|
#if 0 |
1257 |
|
WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1); |
1258 |
|
#else |
1404 |
|
// Execute nanokernel interrupt routine (this will activate the 68k emulator) |
1405 |
|
atomic_add((int32 *)XLM_IRQ_NEST, 1); |
1406 |
|
if (ROMType == ROMTYPE_NEWWORLD) |
1407 |
< |
ppc_interrupt(ROM_BASE + 0x312b1c); |
1407 |
> |
ppc_interrupt(ROMBase + 0x312b1c); |
1408 |
|
else |
1409 |
< |
ppc_interrupt(ROM_BASE + 0x312a3c); |
1409 |
> |
ppc_interrupt(ROMBase + 0x312a3c); |
1410 |
|
} |
1411 |
|
break; |
1412 |
|
#endif |
1510 |
|
uint32 imm = opcode & 0xffff; |
1511 |
|
|
1512 |
|
// Fault in Mac ROM or RAM? |
1513 |
< |
bool mac_fault = (r->pc >= ROM_BASE) && (r->pc < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize)); |
1513 |
> |
bool mac_fault = (r->pc >= ROMBase) && (r->pc < (ROMBase + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize)); |
1514 |
|
if (mac_fault) { |
1515 |
|
|
1516 |
|
// "VM settings" during MacOS 8 installation |
1517 |
< |
if (r->pc == ROM_BASE + 0x488160 && segv_r[20] == 0xf8000000) { |
1517 |
> |
if (r->pc == ROMBase + 0x488160 && segv_r[20] == 0xf8000000) { |
1518 |
|
r->pc += 4; |
1519 |
|
segv_r[8] = 0; |
1520 |
|
goto rti; |
1521 |
|
|
1522 |
|
// MacOS 8.5 installation |
1523 |
< |
} else if (r->pc == ROM_BASE + 0x488140 && segv_r[16] == 0xf8000000) { |
1523 |
> |
} else if (r->pc == ROMBase + 0x488140 && segv_r[16] == 0xf8000000) { |
1524 |
|
r->pc += 4; |
1525 |
|
segv_r[8] = 0; |
1526 |
|
goto rti; |
1527 |
|
|
1528 |
|
// MacOS 8 serial drivers on startup |
1529 |
< |
} else if (r->pc == ROM_BASE + 0x48e080 && (segv_r[8] == 0xf3012002 || segv_r[8] == 0xf3012000)) { |
1529 |
> |
} else if (r->pc == ROMBase + 0x48e080 && (segv_r[8] == 0xf3012002 || segv_r[8] == 0xf3012000)) { |
1530 |
|
r->pc += 4; |
1531 |
|
segv_r[8] = 0; |
1532 |
|
goto rti; |
1533 |
|
|
1534 |
|
// MacOS 8.1 serial drivers on startup |
1535 |
< |
} else if (r->pc == ROM_BASE + 0x48c5e0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) { |
1535 |
> |
} else if (r->pc == ROMBase + 0x48c5e0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) { |
1536 |
|
r->pc += 4; |
1537 |
|
goto rti; |
1538 |
< |
} else if (r->pc == ROM_BASE + 0x4a10a0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) { |
1538 |
> |
} else if (r->pc == ROMBase + 0x4a10a0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) { |
1539 |
|
r->pc += 4; |
1540 |
|
goto rti; |
1541 |
|
} |
1646 |
|
} |
1647 |
|
|
1648 |
|
// Ignore ROM writes |
1649 |
< |
if (transfer_type == TYPE_STORE && addr >= ROM_BASE && addr < ROM_BASE + ROM_SIZE) { |
1649 |
> |
if (transfer_type == TYPE_STORE && addr >= ROMBase && addr < ROMBase + ROM_SIZE) { |
1650 |
|
D(bug("WARNING: %s write access to ROM at %p, pc %p\n", transfer_size == SIZE_BYTE ? "Byte" : transfer_size == SIZE_HALFWORD ? "Halfword" : "Word", addr, r->pc)); |
1651 |
|
if (addr_mode == MODE_U || addr_mode == MODE_UX) |
1652 |
|
segv_r[ra] = addr; |
1781 |
|
uint32 imm = opcode & 0xffff; |
1782 |
|
|
1783 |
|
// Fault in Mac ROM or RAM? |
1784 |
< |
bool mac_fault = (r->pc >= ROM_BASE) && (r->pc < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize)); |
1784 |
> |
bool mac_fault = (r->pc >= ROMBase) && (r->pc < (ROMBase + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize)); |
1785 |
|
if (mac_fault) { |
1786 |
|
|
1787 |
|
switch (primop) { |
1946 |
|
delete_area(old_sheep_area); |
1947 |
|
|
1948 |
|
// Create area for SheepShaver data |
1949 |
< |
base = 0x60000000; |
1949 |
> |
proc = base = 0x60000000; |
1950 |
|
SheepMemArea = create_area(SHEEP_AREA_NAME, (void **)&base, B_BASE_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); |
1951 |
|
if (SheepMemArea < 0) |
1952 |
|
return false; |
1956 |
|
zero_page = const_zero_page; |
1957 |
|
|
1958 |
|
D(bug("SheepShaver area %ld at %p\n", SheepMemArea, base)); |
1959 |
< |
top = base + size; |
1959 |
> |
data = base + size; |
1960 |
|
return true; |
1961 |
|
} |
1962 |
|
|