ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/SheepShaver/src/BeOS/main_beos.cpp

Comparing SheepShaver/src/BeOS/main_beos.cpp (file contents):
Revision 1.5 by gbeauche, 2003-12-04T17:26:36Z vs.
Revision 1.18 by gbeauche, 2005-06-30T10:17:58Z

#	Line 1 | Line 1
1		/*
2		*  main_beos.cpp - Emulation core, BeOS implementation
3		*
4	<	*  SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig
4	>	*  SheepShaver (C) 1997-2005 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
#	Line 74 | Line 74
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
#	Line 117 | Line 107 | const char KERNEL_AREA2_NAME[] = "Macint
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 uint32 SIG_STACK_SIZE = 8192;                     // Size of signal stack
#	Line 142 | Line 133 | public:
133		// Initialize other variables
134		sheep_fd = -1;
135		emulator_data = NULL;
136	<	kernel_area = kernel_area2 = rom_area = ram_area = dr_cache_area = -1;
136	>	kernel_area = kernel_area2 = rom_area = ram_area = dr_cache_area = dr_emulator_area = -1;
137		emul_thread = nvram_thread = tick_thread = -1;
138		ReadyForSignals = false;
139		AllowQuitting = true;
#	Line 190 | Line 181 | private:
181		area_id rom_area;               // ROM area ID
182		area_id ram_area;               // RAM area ID
183		area_id dr_cache_area;  // DR Cache area ID
184	+	area_id dr_emulator_area;       // DR Emulator area ID
185
186		struct sigaction sigusr1_action;        // Interrupt signal (of emulator thread)
187		struct sigaction sigsegv_action;        // Data access exception signal (of emulator thread)
#	Line 213 | Line 205 | uint32 RAMSize;                        // Size of Mac RAM
205		uint32 KernelDataAddr;  // Address of Kernel Data
206		uint32 BootGlobsAddr;   // Address of BootGlobs structure at top of Mac RAM
207		uint32 DRCacheAddr;             // Address of DR Cache
208	+	uint32 DREmulatorAddr;  // Address of DR Emulator
209		uint32 PVR;                             // Theoretical PVR
210		int64 CPUClockSpeed;    // Processor clock speed (Hz)
211		int64 BusClockSpeed;    // Bus clock speed (Hz)
212	+	int64 TimebaseSpeed;    // Timebase clock speed (Hz)
213		system_info SysInfo;    // System information
214	+	uint8 *RAMBaseHost;             // Base address of Mac RAM (host address space)
215	+	uint8 *ROMBaseHost;             // Base address of Mac ROM (host address space)
216
217		static void *sig_stack = NULL;          // Stack for signal handlers
218		static void *extra_stack = NULL;        // Stack for SIGSEGV inside interrupt handler
219	<	static uintptr SheepMem::base;          // Address of SheepShaver data
220	<	static uintptr SheepMem::top;           // Top of SheepShaver data (stack like storage)
219	>	uint32  SheepMem::page_size;            // Size of a native page
220	>	uintptr SheepMem::zero_page = 0;        // Address of ro page filled in with zeros
221	>	uintptr SheepMem::base;                         // Address of SheepShaver data
222	>	uintptr SheepMem::proc;                         // Bottom address of SheepShave procedures
223	>	uintptr SheepMem::data;                         // Top of SheepShaver data (stack like storage)
224		static area_id SheepMemArea;            // SheepShaver data area ID
225
226
#	Line 294 | Line 293 | void SheepShaver::ReadyToRun(void)
293		}
294		CPUClockSpeed = SysInfo.cpu_clock_speed;
295		BusClockSpeed = SysInfo.bus_clock_speed;
296	+	TimebaseSpeed = BusClockSpeed / 4;
297
298		// Delete old areas
299		area_id old_kernel_area = find_area(KERNEL_AREA_NAME);
#	Line 311 | Line 311 | void SheepShaver::ReadyToRun(void)
311		area_id old_dr_cache_area = find_area(DR_CACHE_AREA_NAME);
312		if (old_dr_cache_area > 0)
313		delete_area(old_dr_cache_area);
314	+	area_id old_dr_emulator_area = find_area(DR_EMULATOR_AREA_NAME);
315	+	if (old_dr_emulator_area > 0)
316	+	delete_area(old_dr_emulator_area);
317
318		// Read preferences
319		int argc = 0;
#	Line 358 | Line 361 | void SheepShaver::MessageReceived(BMessa
361		void SheepShaver::StartEmulator(void)
362		{
363		char str[256];
361	–	int16 i16;
364
365		// Open sheep driver and remap low memory
366		sheep_fd = open("/dev/sheep", 0);
#	Line 401 | Line 403 | void SheepShaver::StartEmulator(void)
403
404		// Create area for SheepShaver data
405		if (!SheepMem::Init()) {
406	<	sprintf(str, GetString(STR_NO_SHEEP_MEM_AREA_ERR));
406	>	sprintf(str, GetString(STR_NO_SHEEP_MEM_AREA_ERR), strerror(SheepMemArea), SheepMemArea);
407		ErrorAlert(str);
408		PostMessage(B_QUIT_REQUESTED);
409		return;
#	Line 422 | Line 424 | void SheepShaver::StartEmulator(void)
424		PostMessage(B_QUIT_REQUESTED);
425		return;
426		}
427	<	D(bug("RAM area %ld at %p\n", ram_area, RAMBase));
427	>	RAMBaseHost = (uint8 *)RAMBase
428	>	D(bug("RAM area %ld at %p\n", ram_area, RAMBaseHost));
429
430		// Create area and load Mac ROM
431		try {
#	Line 456 | Line 459 | void SheepShaver::StartEmulator(void)
459		}
460		D(bug("DR Cache area %ld at %p\n", dr_cache_area, DRCacheAddr));
461
462	<	// Load NVRAM
463	<	XPRAMInit();
464	<
465	<	// Set boot volume
466	<	i16 = PrefsFindInt32("bootdrive");
467	<	XPRAM[0x1378] = i16 >> 8;
465	<	XPRAM[0x1379] = i16 & 0xff;
466	<	i16 = PrefsFindInt32("bootdriver");
467	<	XPRAM[0x137a] = i16 >> 8;
468	<	XPRAM[0x137b] = i16 & 0xff;
469	<
470	<	// Create BootGlobs at top of Mac memory
471	<	memset((void *)(RAMBase + RAMSize - 4096), 0, 4096);
472	<	BootGlobsAddr = RAMBase + RAMSize - 0x1c;
473	<	uint32 *boot_globs = (uint32 *)BootGlobsAddr;
474	<	boot_globs[-5] = htonl(RAMBase + RAMSize);              // MemTop
475	<	boot_globs[0] = htonl(RAMBase);                                 // First RAM bank
476	<	boot_globs[1] = htonl(RAMSize);
477	<	boot_globs[2] = htonl((uint32)-1);                              // End of bank table
478	<
479	<	// Init thunks
480	<	if (!InitThunks()) {
481	<	PostMessage(B_QUIT_REQUESTED);
482	<	return;
483	<	}
484	<
485	<	// Init drivers
486	<	SonyInit();
487	<	DiskInit();
488	<	CDROMInit();
489	<	SCSIInit();
490	<
491	<	// Init external file system
492	<	ExtFSInit();
493	<
494	<	// Init audio
495	<	AudioInit();
496	<
497	<	// Init network
498	<	EtherInit();
499	<
500	<	// Init serial ports
501	<	SerialInit();
502	<
503	<	// Init Time Manager
504	<	TimerInit();
505	<
506	<	// Init clipboard
507	<	ClipInit();
508	<
509	<	// Init video
510	<	if (!VideoInit()) {
462	>	// Create area for DR Emulator
463	>	DREmulatorAddr = DR_EMULATOR_BASE;
464	>	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);
465	>	if (dr_emulator_area < 0) {
466	>	sprintf(str, GetString(STR_NO_KERNEL_DATA_ERR), strerror(dr_emulator_area), dr_emulator_area);
467	>	ErrorAlert(str);
468		PostMessage(B_QUIT_REQUESTED);
469		return;
470		}
471	+	D(bug("DR Emulator area %ld at %p\n", dr_emulator_area, DREmulatorAddr));
472
473	<	// Install ROM patches
474	<	if (!PatchROM()) {
517	<	ErrorAlert(GetString(STR_UNSUPPORTED_ROM_TYPE_ERR));
473	>	// Initialize everything
474	>	if (!InitAll()) {
475		PostMessage(B_QUIT_REQUESTED);
476		return;
477		}
478	+	D(bug("Initialization complete\n"));
479
480		// Clear caches (as we loaded and patched code) and write protect ROM
481		#if !EMULATED_PPC
482	<	clear_caches((void *)ROM_BASE, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
482	>	clear_caches(ROMBaseHost, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
483		#endif
484		set_area_protection(rom_area, B_READ_AREA);
485
528	–	// Initialize Kernel Data
529	–	memset(kernel_data, 0, sizeof(KernelData));
530	–	if (ROMType == ROMTYPE_NEWWORLD) {
531	–	static uint32 of_dev_tree[4] = {0, 0, 0, 0};
532	–	static uint8 vector_lookup_tbl[128];
533	–	static uint8 vector_mask_tbl[64];
534	–	memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80);
535	–	memset(vector_lookup_tbl, 0, 128);
536	–	memset(vector_mask_tbl, 0, 64);
537	–	kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE);
538	–	kernel_data->v[0xb84 >> 2] = htonl((uint32)of_dev_tree);        // OF device tree base
539	–	kernel_data->v[0xb90 >> 2] = htonl((uint32)vector_lookup_tbl);
540	–	kernel_data->v[0xb94 >> 2] = htonl((uint32)vector_mask_tbl);
541	–	kernel_data->v[0xb98 >> 2] = htonl(ROM_BASE);                           // OpenPIC base
542	–	kernel_data->v[0xbb0 >> 2] = htonl(0);                                          // ADB base
543	–	kernel_data->v[0xc20 >> 2] = htonl(RAMSize);
544	–	kernel_data->v[0xc24 >> 2] = htonl(RAMSize);
545	–	kernel_data->v[0xc30 >> 2] = htonl(RAMSize);
546	–	kernel_data->v[0xc34 >> 2] = htonl(RAMSize);
547	–	kernel_data->v[0xc38 >> 2] = htonl(0x00010020);
548	–	kernel_data->v[0xc3c >> 2] = htonl(0x00200001);
549	–	kernel_data->v[0xc40 >> 2] = htonl(0x00010000);
550	–	kernel_data->v[0xc50 >> 2] = htonl(RAMBase);
551	–	kernel_data->v[0xc54 >> 2] = htonl(RAMSize);
552	–	kernel_data->v[0xf60 >> 2] = htonl(PVR);
553	–	kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed);
554	–	kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed);
555	–	kernel_data->v[0xf6c >> 2] = htonl(CPUClockSpeed);
556	–	} else {
557	–	kernel_data->v[0xc80 >> 2] = htonl(RAMSize);
558	–	kernel_data->v[0xc84 >> 2] = htonl(RAMSize);
559	–	kernel_data->v[0xc90 >> 2] = htonl(RAMSize);
560	–	kernel_data->v[0xc94 >> 2] = htonl(RAMSize);
561	–	kernel_data->v[0xc98 >> 2] = htonl(0x00010020);
562	–	kernel_data->v[0xc9c >> 2] = htonl(0x00200001);
563	–	kernel_data->v[0xca0 >> 2] = htonl(0x00010000);
564	–	kernel_data->v[0xcb0 >> 2] = htonl(RAMBase);
565	–	kernel_data->v[0xcb4 >> 2] = htonl(RAMSize);
566	–	kernel_data->v[0xf80 >> 2] = htonl(PVR);
567	–	kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed);
568	–	kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed);
569	–	kernel_data->v[0xf8c >> 2] = htonl(CPUClockSpeed);
570	–	}
571	–
486		// Initialize extra low memory
487	<	D(bug("Initializing Low Memory...\n"));
574	<	memset(NULL, 0, 0x3000);
575	<	WriteMacInt32(XLM_SIGNATURE, 'Baah');                                                   // Signature to detect SheepShaver
576	<	WriteMacInt32(XLM_KERNEL_DATA, (uint32)kernel_data);                    // For trap replacement routines
487	>	D(bug("Initializing extra Low Memory...\n"));
488		WriteMacInt32(XLM_SHEEP_OBJ, (uint32)this);                                             // Pointer to SheepShaver object
489	<	WriteMacInt32(XLM_PVR, PVR);                                                                    // Theoretical PVR
579	<	WriteMacInt32(XLM_BUS_CLOCK, BusClockSpeed);                                    // For DriverServicesLib patch
580	<	WriteMacInt16(XLM_EXEC_RETURN_OPCODE, M68K_EXEC_RETURN);                // For Execute68k() (RTS from the executed 68k code will jump here and end 68k mode)
581	<	#if !EMULATED_PPC
582	<	WriteMacInt32(XLM_TOC, (uint32)TOC);                                                    // TOC pointer of emulator
583	<	WriteMacInt32(XLM_ETHER_INIT, *(uint32 *)InitStreamModule);             // DLPI ethernet driver functions
584	<	WriteMacInt32(XLM_ETHER_TERM, *(uint32 *)TerminateStreamModule);
585	<	WriteMacInt32(XLM_ETHER_OPEN, *(uint32 *)ether_open);
586	<	WriteMacInt32(XLM_ETHER_CLOSE, *(uint32 *)ether_close);
587	<	WriteMacInt32(XLM_ETHER_WPUT, *(uint32 *)ether_wput);
588	<	WriteMacInt32(XLM_ETHER_RSRV, *(uint32 *)ether_rsrv);
589	<	WriteMacInt32(XLM_VIDEO_DOIO, *(uint32 *)VideoDoDriverIO);
590	<	#endif
591	<	D(bug("Low Memory initialized\n"));
489	>	D(bug("Extra Low Memory initialized\n"));
490
491		// Disallow quitting with Alt-Q from now on
492		AllowQuitting = false;
#	Line 644 | Line 542 | void SheepShaver::Quit(void)
542		if (emul_thread > 0)
543		wait_for_thread(emul_thread, &l);
544
545	<	// Save NVRAM
546	<	XPRAMExit();
649	<
650	<	// Exit clipboard
651	<	ClipExit();
652	<
653	<	// Exit Time Manager
654	<	TimerExit();
655	<
656	<	// Exit serial
657	<	SerialExit();
658	<
659	<	// Exit network
660	<	EtherExit();
661	<
662	<	// Exit audio
663	<	AudioExit();
664	<
665	<	// Exit video
666	<	VideoExit();
667	<
668	<	// Exit external file system
669	<	ExtFSExit();
670	<
671	<	// Exit drivers
672	<	SCSIExit();
673	<	CDROMExit();
674	<	DiskExit();
675	<	SonyExit();
545	>	// Deinitialize everything
546	>	ExitAll();
547
548		// Delete SheepShaver globals
549		SheepMem::Exit();
550
551	+	// Delete DR Emulator area
552	+	if (dr_emulator_area >= 0)
553	+	delete_area(dr_emulator_area);
554	+
555		// Delete DR Cache area
556		if (dr_cache_area >= 0)
557		delete_area(dr_cache_area);
#	Line 721 | Line 596 | void SheepShaver::Quit(void)
596
597		void SheepShaver::init_rom(void)
598		{
599	+	// Size of a native page
600	+	page_size = B_PAGE_SIZE;
601	+
602		// Create area for ROM
603	<	void *rom_addr = (void *)ROM_BASE;
604	<	rom_area = create_area(ROM_AREA_NAME, &rom_addr, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
603	>	ROMBaseHost = (uint8 *)ROM_BASE;
604	>	rom_area = create_area(ROM_AREA_NAME, (void **)&ROMBaseHost, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
605		if (rom_area < 0)
606		throw area_error();
607		D(bug("ROM area %ld at %p\n", rom_area, rom_addr));
#	Line 1265 | Line 1143 | void Execute68kTrap(uint16 trap, M68kReg
1143
1144
1145		/*
1268	–	*  Execute PPC code from EMUL_OP routine (real mode switch)
1269	–	*/
1270	–
1271	–	void ExecutePPC(void (*func)())
1272	–	{
1273	–	SheepRoutineDescriptor desc(0, (uint32)func);
1274	–	M68kRegisters r;
1275	–	Execute68k((uint32)&desc, &r);
1276	–	}
1277	–
1278	–
1279	–	/*
1146		*  Quit emulator (must only be called from main thread)
1147		*/
1148
#	Line 1317 | Line 1183 | void Dump68kRegs(M68kRegisters *r)
1183		*  Make code executable
1184		*/
1185
1186	<	void MakeExecutable(int dummy, void *start, uint32 length)
1186	>	void MakeExecutable(int dummy, uint32 start, uint32 length)
1187		{
1188	<	if (((uint32)start >= ROM_BASE) && ((uint32)start < (ROM_BASE + ROM_SIZE)))
1188	>	if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE)))
1189		return;
1190	<	clear_caches(start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
1325	<	}
1326	<
1327	<
1328	<	/*
1329	<	*  Patch things after system startup (gets called by disk driver accRun routine)
1330	<	*/
1331	<
1332	<	void PatchAfterStartup(void)
1333	<	{
1334	<	ExecutePPC(VideoInstallAccel);
1335	<	InstallExtFS();
1190	>	clear_caches((void *)start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
1191		}
1192
1193
#	Line 1393 | Line 1248 | status_t SheepShaver::tick_func(void *ar
1248
1249		void TriggerInterrupt(void)
1250		{
1251	+	idle_resume();
1252		#if 0
1253		WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1);
1254		#else
#	Line 1579 | Line 1435 | void SheepShaver::sigusr1_handler(vregs
1435		if (InterruptFlags & INTFLAG_VIA) {
1436		ClearInterruptFlag(INTFLAG_VIA);
1437		ADBInterrupt();
1438	<	ExecutePPC(VideoVBL);
1438	>	ExecuteNative(NATIVE_VIDEO_VBL);
1439		}
1440		}
1441		#endif
#	Line 2086 | Line 1942 | bool SheepMem::Init(void)
1942		delete_area(old_sheep_area);
1943
1944		// Create area for SheepShaver data
1945	<	base = 0x60000000;
1945	>	proc = base = 0x60000000;
1946		SheepMemArea = create_area(SHEEP_AREA_NAME, (void **)&base, B_BASE_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
1947		if (SheepMemArea < 0)
1948		return false;
1949
1950	+	// Create read-only area with all bits set to 0
1951	+	static const uint8 const_zero_page[4096] = {0,};
1952	+	zero_page = const_zero_page;
1953	+
1954		D(bug("SheepShaver area %ld at %p\n", SheepMemArea, base));
1955	<	top = base + size;
1955	>	data = base + size;
1956		return true;
1957		}
1958

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines