[ViewVC] Diff of: cebix/SheepShaver/src/Unix/main

Comparing SheepShaver/src/Unix/main_unix.cpp (file contents):
Revision 1.51 by gbeauche, 2004-07-19T19:42:21Z vs.
Revision 1.52 by gbeauche, 2004-11-13T14:09:15Z

#	Line 174 \| Line 174
174		const char ROM_FILE_NAME[] = "ROM";
175		const char ROM_FILE_NAME2[] = "Mac OS ROM";
176
177	+	#if REAL_ADDRESSING
178		const uintptr RAM_BASE = 0x20000000; // Base address of RAM
179	+	#else
180	+	// FIXME: needs to be >= 0x04000000
181	+	const uintptr RAM_BASE = 0x10000000; // Base address of RAM
182	+	#endif
183		const uint32 SIG_STACK_SIZE = 0x10000; // Size of signal stack
184
185
#	Line 280 \| Line 285 \| uint32 PVR; // Theoretical PVR
285		int64 CPUClockSpeed; // Processor clock speed (Hz)
286		int64 BusClockSpeed; // Bus clock speed (Hz)
287		int64 TimebaseSpeed; // Timebase clock speed (Hz)
288	+	uint8 *RAMBaseHost; // Base address of Mac RAM (host address space)
289	+	uint8 *ROMBaseHost; // Base address of Mac ROM (host address space)
290
291
292		// Global variables
#	Line 431 \| Line 438 \| *static void usage(const char prg_name)**
438		int main(int argc, char **argv)
439		{
440		char str[256];
434	–	uint32 *boot_globs;
441		int16 i16;
442		int rom_fd;
443		FILE *proc_file;
#	Line 763 \| Line 769 \| int main(int argc, char argv)**
769
770		#ifndef PAGEZERO_HACK
771		// Create Low Memory area (0x0000..0x3000)
772	<	if (vm_acquire_fixed((char *)0, 0x3000) < 0) {
772	>	if (vm_acquire_fixed((char *)NATMEM_OFFSET, 0x3000) < 0) {
773		sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
774		ErrorAlert(str);
775		goto quit;
#	Line 778 \| Line 784 \| int main(int argc, char argv)**
784		ErrorAlert(str);
785		goto quit;
786		}
787	<	if (shmat(kernel_area, (void *)KERNEL_DATA_BASE, 0) < 0) {
787	>	if (shmat(kernel_area, (void *)(KERNEL_DATA_BASE + NATMEM_OFFSET), 0) < 0) {
788		sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno));
789		ErrorAlert(str);
790		goto quit;
791		}
792	<	if (shmat(kernel_area, (void *)KERNEL_DATA2_BASE, 0) < 0) {
792	>	if (shmat(kernel_area, (void *)(KERNEL_DATA2_BASE + NATMEM_OFFSET), 0) < 0) {
793		sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno));
794		ErrorAlert(str);
795		goto quit;
796		}
797	<	kernel_data = (KernelData *)KERNEL_DATA_BASE;
797	>	kernel_data = (KernelData *)(KERNEL_DATA_BASE + NATMEM_OFFSET);
798		emulator_data = &kernel_data->ed;
799		KernelDataAddr = KERNEL_DATA_BASE;
800	<	D(bug("Kernel Data at %p, Emulator Data at %p\n", kernel_data, emulator_data));
800	>	D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE));
801	>	D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
802
803		// Create area for DR Cache
804	<	if (vm_acquire_fixed((void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
804	>	if (vm_acquire_fixed((void *)(DR_EMULATOR_BASE + NATMEM_OFFSET), DR_EMULATOR_SIZE) < 0) {
805		sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
806		ErrorAlert(str);
807		goto quit;
808		}
809		dr_emulator_area_mapped = true;
810	<	if (vm_acquire_fixed((void *)DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
810	>	if (vm_acquire_fixed((void *)(DR_CACHE_BASE + NATMEM_OFFSET), DR_CACHE_SIZE) < 0) {
811		sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
812		ErrorAlert(str);
813		goto quit;
#	Line 824 \| Line 831 \| int main(int argc, char argv)**
831		}
832
833		// Create area for Mac ROM
834	<	if (vm_acquire_fixed((char *)ROM_BASE, ROM_AREA_SIZE) < 0) {
834	>	ROMBaseHost = (uint8 *)(ROM_BASE + NATMEM_OFFSET);
835	>	if (vm_acquire_fixed(ROMBaseHost, ROM_AREA_SIZE) < 0) {
836		sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
837		ErrorAlert(str);
838		goto quit;
839		}
840		#if !EMULATED_PPC
841	<	if (vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ \| VM_PAGE_WRITE \| VM_PAGE_EXECUTE) < 0) {
841	>	if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ \| VM_PAGE_WRITE \| VM_PAGE_EXECUTE) < 0) {
842		sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
843		ErrorAlert(str);
844		goto quit;
845		}
846		#endif
847		rom_area_mapped = true;
848	<	D(bug("ROM area at %08x\n", ROM_BASE));
848	>	D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROM_BASE));
849
850		// Create area for Mac RAM
851		RAMSize = PrefsFindInt32("ramsize");
#	Line 846 \| Line 854 \| int main(int argc, char argv)**
854		RAMSize = 810241024;
855		}
856
857	<	if (vm_acquire_fixed((char *)RAM_BASE, RAMSize) < 0) {
857	>	RAMBaseHost = (uint8 *)(RAM_BASE + NATMEM_OFFSET);
858	>	if (vm_acquire_fixed(RAMBaseHost, RAMSize) < 0) {
859		sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
860		ErrorAlert(str);
861		goto quit;
862		}
863		#if !EMULATED_PPC
864	<	if (vm_protect((char *)RAM_BASE, RAMSize, VM_PAGE_READ \| VM_PAGE_WRITE \| VM_PAGE_EXECUTE) < 0) {
864	>	if (vm_protect(RAMBaseHost, RAMSize, VM_PAGE_READ \| VM_PAGE_WRITE \| VM_PAGE_EXECUTE) < 0) {
865		sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
866		ErrorAlert(str);
867		goto quit;
#	Line 860 \| Line 869 \| int main(int argc, char argv)**
869		#endif
870		RAMBase = RAM_BASE;
871		ram_area_mapped = true;
872	<	D(bug("RAM area at %08x\n", RAMBase));
872	>	D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
873
874		if (RAMBase > ROM_BASE) {
875		ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
#	Line 938 \| Line 947 \| int main(int argc, char argv)**
947		XPRAM[0x137b] = i16 & 0xff;
948
949		// Create BootGlobs at top of Mac memory
950	<	memset((void *)(RAMBase + RAMSize - 4096), 0, 4096);
950	>	memset(RAMBaseHost + RAMSize - 4096, 0, 4096);
951		BootGlobsAddr = RAMBase + RAMSize - 0x1c;
952	<	boot_globs = (uint32 *)BootGlobsAddr;
953	<	boot_globs[-5] = htonl(RAMBase + RAMSize); // MemTop
954	<	boot_globs[0] = htonl(RAMBase); // First RAM bank
955	<	boot_globs[1] = htonl(RAMSize);
947	<	boot_globs[2] = htonl((uint32)-1); // End of bank table
952	>	WriteMacInt32(BootGlobsAddr - 5 * 4, RAMBase + RAMSize); // MemTop
953	>	WriteMacInt32(BootGlobsAddr + 0 * 4, RAMBase); // First RAM bank
954	>	WriteMacInt32(BootGlobsAddr + 1 * 4, RAMSize);
955	>	WriteMacInt32(BootGlobsAddr + 2 * 4, (uint32)-1); // End of bank table
956
957		// Init thunks
958		if (!ThunksInit())
#	Line 989 \| Line 997 \| int main(int argc, char argv)**
997
998		// Clear caches (as we loaded and patched code) and write protect ROM
999		#if !EMULATED_PPC
1000	<	MakeExecutable(0, (void *)ROM_BASE, ROM_AREA_SIZE);
1000	>	MakeExecutable(0, ROM_BASE, ROM_AREA_SIZE);
1001		#endif
1002	<	vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ \| VM_PAGE_EXECUTE);
1002	>	vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ \| VM_PAGE_EXECUTE);
1003
1004		// Initialize Kernel Data
1005		memset(kernel_data, 0, sizeof(KernelData));
1006		if (ROMType == ROMTYPE_NEWWORLD) {
1007	<	uintptr of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32));
1008	<	memset((void )of_dev_tree, 0, 4 sizeof(uint32));
1009	<	uintptr vector_lookup_tbl = SheepMem::Reserve(128);
1010	<	uintptr vector_mask_tbl = SheepMem::Reserve(64);
1007	>	uint32 of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32));
1008	>	Mac_memset(of_dev_tree, 0, 4 * sizeof(uint32));
1009	>	uint32 vector_lookup_tbl = SheepMem::Reserve(128);
1010	>	uint32 vector_mask_tbl = SheepMem::Reserve(64);
1011		memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80);
1012	<	memset((void *)vector_lookup_tbl, 0, 128);
1013	<	memset((void *)vector_mask_tbl, 0, 64);
1012	>	Mac_memset(vector_lookup_tbl, 0, 128);
1013	>	Mac_memset(vector_mask_tbl, 0, 64);
1014		kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE);
1015		kernel_data->v[0xb84 >> 2] = htonl(of_dev_tree); // OF device tree base
1016		kernel_data->v[0xb90 >> 2] = htonl(vector_lookup_tbl);
#	Line 1040 \| Line 1048 \| int main(int argc, char argv)**
1048
1049		// Initialize extra low memory
1050		D(bug("Initializing Low Memory...\n"));
1051	<	memset(NULL, 0, 0x3000);
1051	>	Mac_memset(0, 0, 0x3000);
1052		WriteMacInt32(XLM_SIGNATURE, FOURCC('B','a','a','h')); // Signature to detect SheepShaver
1053		WriteMacInt32(XLM_KERNEL_DATA, KernelDataAddr); // For trap replacement routines
1054		WriteMacInt32(XLM_PVR, PVR); // Theoretical PVR
#	Line 1200 \| Line 1208 \| static void Quit(void)
1208
1209		// Delete RAM area
1210		if (ram_area_mapped)
1211	<	vm_release((char *)RAM_BASE, RAMSize);
1211	>	vm_release(RAMBaseHost, RAMSize);
1212
1213		// Delete ROM area
1214		if (rom_area_mapped)
1215	<	vm_release((char *)ROM_BASE, ROM_AREA_SIZE);
1215	>	vm_release(ROMBaseHost, ROM_AREA_SIZE);
1216
1217		// Delete DR cache areas
1218		if (dr_emulator_area_mapped)
1219	<	vm_release((void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
1219	>	vm_release((void *)(DR_EMULATOR_BASE + NATMEM_OFFSET), DR_EMULATOR_SIZE);
1220		if (dr_cache_area_mapped)
1221	<	vm_release((void *)DR_CACHE_BASE, DR_CACHE_SIZE);
1221	>	vm_release((void *)(DR_CACHE_BASE + NATMEM_OFFSET), DR_CACHE_SIZE);
1222
1223		// Delete Kernel Data area
1224		if (kernel_area >= 0) {
1225	<	shmdt((void *)KERNEL_DATA_BASE);
1226	<	shmdt((void *)KERNEL_DATA2_BASE);
1225	>	shmdt((void *)(KERNEL_DATA_BASE + NATMEM_OFFSET));
1226	>	shmdt((void *)(KERNEL_DATA2_BASE + NATMEM_OFFSET));
1227		shmctl(kernel_area, IPC_RMID, NULL);
1228		}
1229
1230		// Delete Low Memory area
1231		if (lm_area_mapped)
1232	<	munmap((char *)0x0000, 0x3000);
1232	>	vm_release((void *)NATMEM_OFFSET, 0x3000);
1233
1234		// Close /dev/zero
1235		if (zero_fd > 0)
#	Line 1377 \| Line 1385 \| *void Dump68kRegs(M68kRegisters r)**
1385		* Make code executable
1386		*/
1387
1388	<	void MakeExecutable(int dummy, void *start, uint32 length)
1388	>	void MakeExecutable(int dummy, uint32 start, uint32 length)
1389		{
1390	<	if (((uintptr)start >= ROM_BASE) && ((uintptr)start < (ROM_BASE + ROM_SIZE)))
1390	>	if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE)))
1391		return;
1392		#if EMULATED_PPC
1393	<	FlushCodeCache((uintptr)start, (uintptr)start + length);
1393	>	FlushCodeCache(start, start + length);
1394		#else
1395	<	flush_icache_range(start, (void *)((uintptr)start + length));
1395	>	flush_icache_range(start, (void *)(start + length));
1396		#endif
1397		}
1398
#	Line 2203 \| Line 2211 \| bool SheepMem::Init(void)
2211		page_size = getpagesize();
2212
2213		// Allocate SheepShaver globals
2214	<	if (vm_acquire_fixed((char *)base, size) < 0)
2214	>	if (vm_acquire_fixed((char *)(base + NATMEM_OFFSET), size) < 0)
2215		return false;
2216
2217		// Allocate page with all bits set to 0
2218		zero_page = base + size;
2219	<	if (vm_acquire_fixed((char *)zero_page, page_size) < 0)
2219	>	uint8 zero_page_host = (uint8 )zero_page + NATMEM_OFFSET;
2220	>	if (vm_acquire_fixed(zero_page_host, page_size) < 0)
2221		return false;
2222	<	memset((char *)zero_page, 0, page_size);
2223	<	if (vm_protect((char *)zero_page, page_size, VM_PAGE_READ) < 0)
2222	>	memset(zero_page_host, 0, page_size);
2223	>	if (vm_protect(zero_page_host, page_size, VM_PAGE_READ) < 0)
2224		return false;
2225
2226		#if EMULATED_PPC
2227		// Allocate alternate stack for PowerPC interrupt routine
2228		sig_stack = zero_page + page_size;
2229	<	if (vm_acquire_fixed((char *)sig_stack, SIG_STACK_SIZE) < 0)
2229	>	if (vm_acquire_fixed((char *)(sig_stack + NATMEM_OFFSET), SIG_STACK_SIZE) < 0)
2230		return false;
2231		#endif
2232
#	Line 2229 \| Line 2238 \| void SheepMem::Exit(void)
2238		{
2239		if (top) {
2240		// Delete SheepShaver globals
2241	<	vm_release((void *)base, size);
2241	>	vm_release((void *)(base + NATMEM_OFFSET), size);
2242
2243		// Delete zero page
2244	<	vm_release((void *)zero_page, page_size);
2244	>	vm_release((void *)(zero_page + NATMEM_OFFSET), page_size);
2245
2246		#if EMULATED_PPC
2247		// Delete alternate stack for PowerPC interrupt routine
2248	<	vm_release((void *)sig_stack, SIG_STACK_SIZE);
2248	>	vm_release((void *)(sig_stack + NATMEM_OFFSET), SIG_STACK_SIZE);
2249		#endif
2250		}
2251		}

Diff Legend

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

Comparing SheepShaver/src/Unix/main_unix.cpp (file contents): Revision 1.51 by gbeauche, 2004-07-19T19:42:21Z vs. Revision 1.52 by gbeauche, 2004-11-13T14:09:15Z

Diff Legend

Comparing SheepShaver/src/Unix/main_unix.cpp (file contents):
Revision 1.51 by gbeauche, 2004-07-19T19:42:21Z vs.
Revision 1.52 by gbeauche, 2004-11-13T14:09:15Z