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.11 by gbeauche, 2004-02-24T11:12:52Z vs.
Revision 1.19 by gbeauche, 2008-01-01T09:47:38Z

#	Line 1 | Line 1
1		/*
2		*  main_beos.cpp - Emulation core, BeOS implementation
3		*
4	<	*  SheepShaver (C) 1997-2004 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
#	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		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::top;                          // Top of SheepShaver data (stack like storage)
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 296 | 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 313 | 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 360 | Line 361 | void SheepShaver::MessageReceived(BMessa
361		void SheepShaver::StartEmulator(void)
362		{
363		char str[256];
363	–	int16 i16;
364
365		// Open sheep driver and remap low memory
366		sheep_fd = open("/dev/sheep", 0);
#	Line 403 | 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 424 | 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 458 | 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;
467	<	XPRAM[0x1379] = i16 & 0xff;
468	<	i16 = PrefsFindInt32("bootdriver");
469	<	XPRAM[0x137a] = i16 >> 8;
470	<	XPRAM[0x137b] = i16 & 0xff;
471	<
472	<	// Create BootGlobs at top of Mac memory
473	<	memset((void *)(RAMBase + RAMSize - 4096), 0, 4096);
474	<	BootGlobsAddr = RAMBase + RAMSize - 0x1c;
475	<	uint32 *boot_globs = (uint32 *)BootGlobsAddr;
476	<	boot_globs[-5] = htonl(RAMBase + RAMSize);              // MemTop
477	<	boot_globs[0] = htonl(RAMBase);                                 // First RAM bank
478	<	boot_globs[1] = htonl(RAMSize);
479	<	boot_globs[2] = htonl((uint32)-1);                              // End of bank table
480	<
481	<	// Init thunks
482	<	if (!InitThunks()) {
483	<	PostMessage(B_QUIT_REQUESTED);
484	<	return;
485	<	}
486	<
487	<	// Init drivers
488	<	SonyInit();
489	<	DiskInit();
490	<	CDROMInit();
491	<	SCSIInit();
492	<
493	<	// Init external file system
494	<	ExtFSInit();
495	<
496	<	// Init audio
497	<	AudioInit();
498	<
499	<	// Init network
500	<	EtherInit();
501	<
502	<	// Init serial ports
503	<	SerialInit();
504	<
505	<	// Init Time Manager
506	<	TimerInit();
507	<
508	<	// Init clipboard
509	<	ClipInit();
510	<
511	<	// Init video
512	<	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()) {
519	<	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
530	–	// Initialize Kernel Data
531	–	memset(kernel_data, 0, sizeof(KernelData));
532	–	if (ROMType == ROMTYPE_NEWWORLD) {
533	–	static uint32 of_dev_tree[4] = {0, 0, 0, 0};
534	–	static uint8 vector_lookup_tbl[128];
535	–	static uint8 vector_mask_tbl[64];
536	–	memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80);
537	–	memset(vector_lookup_tbl, 0, 128);
538	–	memset(vector_mask_tbl, 0, 64);
539	–	kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE);
540	–	kernel_data->v[0xb84 >> 2] = htonl((uint32)of_dev_tree);        // OF device tree base
541	–	kernel_data->v[0xb90 >> 2] = htonl((uint32)vector_lookup_tbl);
542	–	kernel_data->v[0xb94 >> 2] = htonl((uint32)vector_mask_tbl);
543	–	kernel_data->v[0xb98 >> 2] = htonl(ROM_BASE);                           // OpenPIC base
544	–	kernel_data->v[0xbb0 >> 2] = htonl(0);                                          // ADB base
545	–	kernel_data->v[0xc20 >> 2] = htonl(RAMSize);
546	–	kernel_data->v[0xc24 >> 2] = htonl(RAMSize);
547	–	kernel_data->v[0xc30 >> 2] = htonl(RAMSize);
548	–	kernel_data->v[0xc34 >> 2] = htonl(RAMSize);
549	–	kernel_data->v[0xc38 >> 2] = htonl(0x00010020);
550	–	kernel_data->v[0xc3c >> 2] = htonl(0x00200001);
551	–	kernel_data->v[0xc40 >> 2] = htonl(0x00010000);
552	–	kernel_data->v[0xc50 >> 2] = htonl(RAMBase);
553	–	kernel_data->v[0xc54 >> 2] = htonl(RAMSize);
554	–	kernel_data->v[0xf60 >> 2] = htonl(PVR);
555	–	kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed);
556	–	kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed);
557	–	kernel_data->v[0xf6c >> 2] = htonl(CPUClockSpeed);
558	–	} else {
559	–	kernel_data->v[0xc80 >> 2] = htonl(RAMSize);
560	–	kernel_data->v[0xc84 >> 2] = htonl(RAMSize);
561	–	kernel_data->v[0xc90 >> 2] = htonl(RAMSize);
562	–	kernel_data->v[0xc94 >> 2] = htonl(RAMSize);
563	–	kernel_data->v[0xc98 >> 2] = htonl(0x00010020);
564	–	kernel_data->v[0xc9c >> 2] = htonl(0x00200001);
565	–	kernel_data->v[0xca0 >> 2] = htonl(0x00010000);
566	–	kernel_data->v[0xcb0 >> 2] = htonl(RAMBase);
567	–	kernel_data->v[0xcb4 >> 2] = htonl(RAMSize);
568	–	kernel_data->v[0xf80 >> 2] = htonl(PVR);
569	–	kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed);
570	–	kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed);
571	–	kernel_data->v[0xf8c >> 2] = htonl(CPUClockSpeed);
572	–	}
573	–
486		// Initialize extra low memory
487	<	D(bug("Initializing Low Memory...\n"));
576	<	memset(NULL, 0, 0x3000);
577	<	WriteMacInt32(XLM_SIGNATURE, 'Baah');                                                   // Signature to detect SheepShaver
578	<	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
581	<	WriteMacInt32(XLM_BUS_CLOCK, BusClockSpeed);                                    // For DriverServicesLib patch
582	<	WriteMacInt16(XLM_EXEC_RETURN_OPCODE, M68K_EXEC_RETURN);                // For Execute68k() (RTS from the executed 68k code will jump here and end 68k mode)
583	<	WriteMacInt32(XLM_ZERO_PAGE, SheepMem::ZeroPage());                             // Pointer to read-only page with all bits set to 0
584	<	#if !EMULATED_PPC
585	<	WriteMacInt32(XLM_TOC, (uint32)TOC);                                                    // TOC pointer of emulator
586	<	WriteMacInt32(XLM_ETHER_INIT, *(uint32 *)InitStreamModule);             // DLPI ethernet driver functions
587	<	WriteMacInt32(XLM_ETHER_TERM, *(uint32 *)TerminateStreamModule);
588	<	WriteMacInt32(XLM_ETHER_OPEN, *(uint32 *)ether_open);
589	<	WriteMacInt32(XLM_ETHER_CLOSE, *(uint32 *)ether_close);
590	<	WriteMacInt32(XLM_ETHER_WPUT, *(uint32 *)ether_wput);
591	<	WriteMacInt32(XLM_ETHER_RSRV, *(uint32 *)ether_rsrv);
592	<	WriteMacInt32(XLM_VIDEO_DOIO, *(uint32 *)VideoDoDriverIO);
593	<	#endif
594	<	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 647 | Line 542 | void SheepShaver::Quit(void)
542		if (emul_thread > 0)
543		wait_for_thread(emul_thread, &l);
544
545	<	// Save NVRAM
546	<	XPRAMExit();
652	<
653	<	// Exit clipboard
654	<	ClipExit();
655	<
656	<	// Exit Time Manager
657	<	TimerExit();
658	<
659	<	// Exit serial
660	<	SerialExit();
661	<
662	<	// Exit network
663	<	EtherExit();
664	<
665	<	// Exit audio
666	<	AudioExit();
667	<
668	<	// Exit video
669	<	VideoExit();
670	<
671	<	// Exit external file system
672	<	ExtFSExit();
673	<
674	<	// Exit drivers
675	<	SCSIExit();
676	<	CDROMExit();
677	<	DiskExit();
678	<	SonyExit();
679	<
680	<	// Delete thunks
681	<	ThunksExit();
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 731 | Line 600 | void SheepShaver::init_rom(void)
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 1314 | 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);
1322	<	}
1323	<
1324	<
1325	<	/*
1326	<	*  Patch things after system startup (gets called by disk driver accRun routine)
1327	<	*/
1328	<
1329	<	void PatchAfterStartup(void)
1330	<	{
1331	<	ExecuteNative(NATIVE_VIDEO_INSTALL_ACCEL);
1332	<	InstallExtFS();
1190	>	clear_caches((void *)start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
1191		}
1192
1193
#	Line 1390 | 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 2083 | 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;
#	Line 2093 | Line 1952 | bool SheepMem::Init(void)
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