mirror of
https://github.com/kanjitalk755/macemu.git
synced 2024-06-21 16:29:58 +00:00
Implement Direct Addressing mode similarly to Basilisk II. This is to get
SheepShaver working on OSes that don't support maipping of Low Memory globals at 0x00000000, e.g. Windows.
This commit is contained in:
gbeauche
parent
9e330d5615
commit
3ace37f4eb
|
|
@ -221,6 +221,8 @@ int64 CPUClockSpeed; // Processor clock speed (Hz)
|
|||
int64 BusClockSpeed; // Bus clock speed (Hz)
|
||||
int64 TimebaseSpeed; // Timebase clock speed (Hz)
|
||||
system_info SysInfo; // System information
|
||||
uint8 *RAMBaseHost; // Base address of Mac RAM (host address space)
|
||||
uint8 *ROMBaseHost; // Base address of Mac ROM (host address space)
|
||||
|
||||
static void *sig_stack = NULL; // Stack for signal handlers
|
||||
static void *extra_stack = NULL; // Stack for SIGSEGV inside interrupt handler
|
||||
|
|
@ -432,7 +434,8 @@ void SheepShaver::StartEmulator(void)
|
|||
PostMessage(B_QUIT_REQUESTED);
|
||||
return;
|
||||
}
|
||||
D(bug("RAM area %ld at %p\n", ram_area, RAMBase));
|
||||
RAMBaseHost = (uint8 *)RAMBase
|
||||
D(bug("RAM area %ld at %p\n", ram_area, RAMBaseHost));
|
||||
|
||||
// Create area and load Mac ROM
|
||||
try {
|
||||
|
|
@ -542,7 +545,7 @@ void SheepShaver::StartEmulator(void)
|
|||
|
||||
// Clear caches (as we loaded and patched code) and write protect ROM
|
||||
#if !EMULATED_PPC
|
||||
clear_caches((void *)ROM_BASE, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
|
||||
clear_caches(ROMBaseHost, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
|
||||
#endif
|
||||
set_area_protection(rom_area, B_READ_AREA);
|
||||
|
||||
|
|
@ -754,8 +757,8 @@ void SheepShaver::init_rom(void)
|
|||
page_size = B_PAGE_SIZE;
|
||||
|
||||
// Create area for ROM
|
||||
void *rom_addr = (void *)ROM_BASE;
|
||||
rom_area = create_area(ROM_AREA_NAME, &rom_addr, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
|
||||
ROMBaseHost = (uint8 *)ROM_BASE;
|
||||
rom_area = create_area(ROM_AREA_NAME, (void **)&ROMBaseHost, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
|
||||
if (rom_area < 0)
|
||||
throw area_error();
|
||||
D(bug("ROM area %ld at %p\n", rom_area, rom_addr));
|
||||
|
|
@ -1337,11 +1340,11 @@ void Dump68kRegs(M68kRegisters *r)
|
|||
* Make code executable
|
||||
*/
|
||||
|
||||
void MakeExecutable(int dummy, void *start, uint32 length)
|
||||
void MakeExecutable(int dummy, uint32 start, uint32 length)
|
||||
{
|
||||
if (((uint32)start >= ROM_BASE) && ((uint32)start < (ROM_BASE + ROM_SIZE)))
|
||||
if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE)))
|
||||
return;
|
||||
clear_caches(start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
|
||||
clear_caches((void *)start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -687,8 +687,8 @@ void VideoInstallAccel(void)
|
|||
// Install acceleration hooks
|
||||
if (PrefsFindBool("gfxaccel")) {
|
||||
D(bug("Video: Installing acceleration hooks\n"));
|
||||
NQDMisc(6, &bitblt_hook_info);
|
||||
NQDMisc(6, &fillrect_hook_info);
|
||||
NQDMisc(6, (uintptr)&bitblt_hook_info);
|
||||
NQDMisc(6, (uintptr)&fillrect_hook_info);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -497,7 +497,7 @@ static void do_getscrap(void **handle, uint32 type, int32 offset)
|
|||
PW(0x588f), // addq.l #4,sp
|
||||
PW(M68K_RTS)
|
||||
};
|
||||
uint32 proc_area = (uint32)proc;
|
||||
uint32 proc_area = Host2MacAddr((uint8 *)proc);
|
||||
WriteMacInt32(proc_area + 6, data.size());
|
||||
WriteMacInt32(proc_area + 12, type);
|
||||
WriteMacInt32(proc_area + 18, scrap_area);
|
||||
|
|
|
|||
|
|
@ -25,6 +25,17 @@ AC_ARG_WITH(gtk, [ --with-gtk use GTK user interface [d
|
|||
AC_ARG_WITH(mon, [ --with-mon use mon as debugger [default=yes]], [WANT_MON=$withval], [WANT_MON=yes])
|
||||
AC_ARG_WITH(dgcc, [ --with-dgcc=COMPILER use C++ COMPILER to compile synthetic opcodes], [DYNGEN_CC=$withval])
|
||||
|
||||
dnl Addressing mode
|
||||
AC_ARG_ENABLE(addressing,
|
||||
[ --enable-addressing=AM set the addressing mode to use [default=real]],
|
||||
[case "$enableval" in
|
||||
real) WANT_ADDRESSING_MODE="real";;
|
||||
direct) WANT_ADDRESSING_MODE="direct";;
|
||||
direct,0x*) WANT_ADDRESSING_MODE="direct"; NATMEM_OFFSET=`echo "$enableval" | sed -n '/direct,\(0[[xX]][[0-9A-Fa-f]]*\)/s//\1/p'`;;
|
||||
esac],
|
||||
[WANT_ADDRESSING_MODE="real"]
|
||||
)
|
||||
|
||||
dnl SDL options.
|
||||
AC_ARG_ENABLE(sdl-static, [ --enable-sdl-static use SDL static libraries for linking [default=no]], [WANT_SDL_STATIC=$enableval], [WANT_SDL_STATIC=no])
|
||||
AC_ARG_ENABLE(sdl-video, [ --enable-sdl-video use SDL for video graphics [default=no]], [WANT_SDL_VIDEO=$enableval], [WANT_SDL_VIDEO=no])
|
||||
|
|
@ -758,6 +769,87 @@ else
|
|||
WANT_VOSF=no
|
||||
fi
|
||||
|
||||
dnl Check addressing mode to use
|
||||
AC_MSG_CHECKING([for addressing mode to use])
|
||||
if [[ "$EMULATED_PPC" != "yes" ]]; then
|
||||
if [[ "$WANT_ADDRESSING_MODE" != "real" ]]; then
|
||||
AC_MSG_WARN([Running in native PowerPC mode, force use of Real Addressing.])
|
||||
WANT_ADDRESSING_MODE="real"
|
||||
fi
|
||||
fi
|
||||
if [[ "$WANT_ADDRESSING_MODE" = "direct" ]]; then
|
||||
if [[ -n "$NATMEM_OFFSET" ]]; then
|
||||
NATMEM_OFFSET_DEF="-DNATMEM_OFFSET=$NATMEM_OFFSET"
|
||||
fi
|
||||
AC_LANG_SAVE
|
||||
AC_LANG_CPLUSPLUS
|
||||
cat confdefs.h > conftest.$ac_ext
|
||||
cat >> conftest.$ac_ext << EOF
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "vm_alloc.cpp"
|
||||
|
||||
int main(void)
|
||||
{
|
||||
if (vm_init() < 0)
|
||||
return 1;
|
||||
|
||||
static const struct {
|
||||
unsigned long base;
|
||||
unsigned int size;
|
||||
} ranges[[]] = {
|
||||
{ 0x00000000, 0x0003000 },
|
||||
{ 0x10000000, 0x2000000 },
|
||||
{ 0x40800000, 0x0400000 },
|
||||
{ 0x68070000, 0x0010000 },
|
||||
{ 0x69000000, 0x0080000 },
|
||||
{ 0x68ffe000, 0x0002000 },
|
||||
{ 0x5fffe000, 0x0002000 },
|
||||
{ 0x60000000, 0x0040000 },
|
||||
};
|
||||
const int n_ranges = sizeof(ranges)/ sizeof(ranges[[0]]);
|
||||
|
||||
#ifdef NATMEM_OFFSET
|
||||
unsigned long ofs = NATMEM_OFFSET;
|
||||
#else
|
||||
for (unsigned long ofs = 0x10000000; ofs <= 0x90000000; ofs += 0x10000000)
|
||||
#endif
|
||||
for (int i = 0; i < n_ranges; i++) {
|
||||
char *m = (char *)(ranges[[i]].base + ofs);
|
||||
if (vm_acquire_fixed(m, ranges[[i]].size) != 0)
|
||||
break;
|
||||
memset(m, 0, ranges[[i]].size);
|
||||
vm_release(m, ranges[[i]].size);
|
||||
if (i == n_ranges - 1) {
|
||||
printf("0x%08x\n", ofs);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
vm_exit();
|
||||
return 1;
|
||||
}
|
||||
EOF
|
||||
doit='$CXX conftest.$ac_ext -o conftest.$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS $LIBS $NATMEM_OFFSET_DEF >& AS_MESSAGE_LOG_FD'
|
||||
if AC_TRY_EVAL(doit); then
|
||||
NATMEM_OFFSET=`./conftest.$ac_exeext`
|
||||
if [[ -z "$NATMEM_OFFSET" ]]; then
|
||||
AC_MSG_ERROR([could not determine a sensible NATMEM_OFFSET value])
|
||||
else
|
||||
WANT_ADDRESSING_MODE="direct,$NATMEM_OFFSET"
|
||||
fi
|
||||
fi
|
||||
rm -f conftest*
|
||||
AC_LANG_RESTORE
|
||||
fi
|
||||
AC_MSG_RESULT($WANT_ADDRESSING_MODE)
|
||||
|
||||
if [[ -z "$NATMEM_OFFSET" ]]; then
|
||||
NATMEM_OFFSET=0
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED(NATMEM_OFFSET, $NATMEM_OFFSET,
|
||||
[Define constant offset for Mac address translation])
|
||||
|
||||
dnl Platform specific binary postprocessor
|
||||
AC_PATH_PROG(BLESS, "true")
|
||||
if [[ "x$ac_cv_pagezero_hack" = "xyes" ]]; then
|
||||
|
|
@ -791,7 +883,7 @@ if $CXX -V -v 2>&1 | grep -q "Intel(R) C++ Compiler"; then
|
|||
fi
|
||||
AC_MSG_RESULT($HAVE_ICC)
|
||||
|
||||
# Test if the compiler can generate ELF objects
|
||||
dnl Test if the compiler can generate ELF objects
|
||||
AC_CACHE_CHECK([whether the compiler can generate ELF objects],
|
||||
ac_cv_elf_objects, [
|
||||
echo 'int i;' > conftest.$ac_ext
|
||||
|
|
@ -949,6 +1041,7 @@ echo Enable video on SEGV signals ..... : $WANT_VOSF
|
|||
echo ESD sound support ................ : $WANT_ESD
|
||||
echo GTK user interface ............... : $WANT_GTK
|
||||
echo mon debugger support ............. : $WANT_MON
|
||||
echo Addressing mode .................. : $WANT_ADDRESSING_MODE
|
||||
echo Bad memory access recovery type .. : $sigsegv_recovery
|
||||
echo
|
||||
echo "Configuration done. Now type \"make\"."
|
||||
|
|
|
|||
|
|
@ -174,7 +174,12 @@
|
|||
const char ROM_FILE_NAME[] = "ROM";
|
||||
const char ROM_FILE_NAME2[] = "Mac OS ROM";
|
||||
|
||||
#if REAL_ADDRESSING
|
||||
const uintptr RAM_BASE = 0x20000000; // Base address of RAM
|
||||
#else
|
||||
// FIXME: needs to be >= 0x04000000
|
||||
const uintptr RAM_BASE = 0x10000000; // Base address of RAM
|
||||
#endif
|
||||
const uint32 SIG_STACK_SIZE = 0x10000; // Size of signal stack
|
||||
|
||||
|
||||
|
|
@ -280,6 +285,8 @@ uint32 PVR; // Theoretical PVR
|
|||
int64 CPUClockSpeed; // Processor clock speed (Hz)
|
||||
int64 BusClockSpeed; // Bus clock speed (Hz)
|
||||
int64 TimebaseSpeed; // Timebase clock speed (Hz)
|
||||
uint8 *RAMBaseHost; // Base address of Mac RAM (host address space)
|
||||
uint8 *ROMBaseHost; // Base address of Mac ROM (host address space)
|
||||
|
||||
|
||||
// Global variables
|
||||
|
|
@ -431,7 +438,6 @@ static void usage(const char *prg_name)
|
|||
int main(int argc, char **argv)
|
||||
{
|
||||
char str[256];
|
||||
uint32 *boot_globs;
|
||||
int16 i16;
|
||||
int rom_fd;
|
||||
FILE *proc_file;
|
||||
|
|
@ -763,7 +769,7 @@ int main(int argc, char **argv)
|
|||
|
||||
#ifndef PAGEZERO_HACK
|
||||
// Create Low Memory area (0x0000..0x3000)
|
||||
if (vm_acquire_fixed((char *)0, 0x3000) < 0) {
|
||||
if (vm_acquire_fixed((char *)NATMEM_OFFSET, 0x3000) < 0) {
|
||||
sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
|
|
@ -778,29 +784,30 @@ int main(int argc, char **argv)
|
|||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
if (shmat(kernel_area, (void *)KERNEL_DATA_BASE, 0) < 0) {
|
||||
if (shmat(kernel_area, (void *)(KERNEL_DATA_BASE + NATMEM_OFFSET), 0) < 0) {
|
||||
sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
if (shmat(kernel_area, (void *)KERNEL_DATA2_BASE, 0) < 0) {
|
||||
if (shmat(kernel_area, (void *)(KERNEL_DATA2_BASE + NATMEM_OFFSET), 0) < 0) {
|
||||
sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
kernel_data = (KernelData *)KERNEL_DATA_BASE;
|
||||
kernel_data = (KernelData *)(KERNEL_DATA_BASE + NATMEM_OFFSET);
|
||||
emulator_data = &kernel_data->ed;
|
||||
KernelDataAddr = KERNEL_DATA_BASE;
|
||||
D(bug("Kernel Data at %p, Emulator Data at %p\n", kernel_data, emulator_data));
|
||||
D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE));
|
||||
D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
|
||||
|
||||
// Create area for DR Cache
|
||||
if (vm_acquire_fixed((void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
|
||||
if (vm_acquire_fixed((void *)(DR_EMULATOR_BASE + NATMEM_OFFSET), DR_EMULATOR_SIZE) < 0) {
|
||||
sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
dr_emulator_area_mapped = true;
|
||||
if (vm_acquire_fixed((void *)DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
|
||||
if (vm_acquire_fixed((void *)(DR_CACHE_BASE + NATMEM_OFFSET), DR_CACHE_SIZE) < 0) {
|
||||
sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
|
|
@ -824,20 +831,21 @@ int main(int argc, char **argv)
|
|||
}
|
||||
|
||||
// Create area for Mac ROM
|
||||
if (vm_acquire_fixed((char *)ROM_BASE, ROM_AREA_SIZE) < 0) {
|
||||
ROMBaseHost = (uint8 *)(ROM_BASE + NATMEM_OFFSET);
|
||||
if (vm_acquire_fixed(ROMBaseHost, ROM_AREA_SIZE) < 0) {
|
||||
sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
#if !EMULATED_PPC
|
||||
if (vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
|
||||
if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
|
||||
sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
#endif
|
||||
rom_area_mapped = true;
|
||||
D(bug("ROM area at %08x\n", ROM_BASE));
|
||||
D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROM_BASE));
|
||||
|
||||
// Create area for Mac RAM
|
||||
RAMSize = PrefsFindInt32("ramsize");
|
||||
|
|
@ -846,13 +854,14 @@ int main(int argc, char **argv)
|
|||
RAMSize = 8*1024*1024;
|
||||
}
|
||||
|
||||
if (vm_acquire_fixed((char *)RAM_BASE, RAMSize) < 0) {
|
||||
RAMBaseHost = (uint8 *)(RAM_BASE + NATMEM_OFFSET);
|
||||
if (vm_acquire_fixed(RAMBaseHost, RAMSize) < 0) {
|
||||
sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
}
|
||||
#if !EMULATED_PPC
|
||||
if (vm_protect((char *)RAM_BASE, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
|
||||
if (vm_protect(RAMBaseHost, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
|
||||
sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
|
||||
ErrorAlert(str);
|
||||
goto quit;
|
||||
|
|
@ -860,7 +869,7 @@ int main(int argc, char **argv)
|
|||
#endif
|
||||
RAMBase = RAM_BASE;
|
||||
ram_area_mapped = true;
|
||||
D(bug("RAM area at %08x\n", RAMBase));
|
||||
D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
|
||||
|
||||
if (RAMBase > ROM_BASE) {
|
||||
ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
|
||||
|
|
@ -938,13 +947,12 @@ int main(int argc, char **argv)
|
|||
XPRAM[0x137b] = i16 & 0xff;
|
||||
|
||||
// Create BootGlobs at top of Mac memory
|
||||
memset((void *)(RAMBase + RAMSize - 4096), 0, 4096);
|
||||
memset(RAMBaseHost + RAMSize - 4096, 0, 4096);
|
||||
BootGlobsAddr = RAMBase + RAMSize - 0x1c;
|
||||
boot_globs = (uint32 *)BootGlobsAddr;
|
||||
boot_globs[-5] = htonl(RAMBase + RAMSize); // MemTop
|
||||
boot_globs[0] = htonl(RAMBase); // First RAM bank
|
||||
boot_globs[1] = htonl(RAMSize);
|
||||
boot_globs[2] = htonl((uint32)-1); // End of bank table
|
||||
WriteMacInt32(BootGlobsAddr - 5 * 4, RAMBase + RAMSize); // MemTop
|
||||
WriteMacInt32(BootGlobsAddr + 0 * 4, RAMBase); // First RAM bank
|
||||
WriteMacInt32(BootGlobsAddr + 1 * 4, RAMSize);
|
||||
WriteMacInt32(BootGlobsAddr + 2 * 4, (uint32)-1); // End of bank table
|
||||
|
||||
// Init thunks
|
||||
if (!ThunksInit())
|
||||
|
|
@ -989,20 +997,20 @@ int main(int argc, char **argv)
|
|||
|
||||
// Clear caches (as we loaded and patched code) and write protect ROM
|
||||
#if !EMULATED_PPC
|
||||
MakeExecutable(0, (void *)ROM_BASE, ROM_AREA_SIZE);
|
||||
MakeExecutable(0, ROM_BASE, ROM_AREA_SIZE);
|
||||
#endif
|
||||
vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE);
|
||||
vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE);
|
||||
|
||||
// Initialize Kernel Data
|
||||
memset(kernel_data, 0, sizeof(KernelData));
|
||||
if (ROMType == ROMTYPE_NEWWORLD) {
|
||||
uintptr of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32));
|
||||
memset((void *)of_dev_tree, 0, 4 * sizeof(uint32));
|
||||
uintptr vector_lookup_tbl = SheepMem::Reserve(128);
|
||||
uintptr vector_mask_tbl = SheepMem::Reserve(64);
|
||||
uint32 of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32));
|
||||
Mac_memset(of_dev_tree, 0, 4 * sizeof(uint32));
|
||||
uint32 vector_lookup_tbl = SheepMem::Reserve(128);
|
||||
uint32 vector_mask_tbl = SheepMem::Reserve(64);
|
||||
memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80);
|
||||
memset((void *)vector_lookup_tbl, 0, 128);
|
||||
memset((void *)vector_mask_tbl, 0, 64);
|
||||
Mac_memset(vector_lookup_tbl, 0, 128);
|
||||
Mac_memset(vector_mask_tbl, 0, 64);
|
||||
kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE);
|
||||
kernel_data->v[0xb84 >> 2] = htonl(of_dev_tree); // OF device tree base
|
||||
kernel_data->v[0xb90 >> 2] = htonl(vector_lookup_tbl);
|
||||
|
|
@ -1040,7 +1048,7 @@ int main(int argc, char **argv)
|
|||
|
||||
// Initialize extra low memory
|
||||
D(bug("Initializing Low Memory...\n"));
|
||||
memset(NULL, 0, 0x3000);
|
||||
Mac_memset(0, 0, 0x3000);
|
||||
WriteMacInt32(XLM_SIGNATURE, FOURCC('B','a','a','h')); // Signature to detect SheepShaver
|
||||
WriteMacInt32(XLM_KERNEL_DATA, KernelDataAddr); // For trap replacement routines
|
||||
WriteMacInt32(XLM_PVR, PVR); // Theoretical PVR
|
||||
|
|
@ -1200,28 +1208,28 @@ static void Quit(void)
|
|||
|
||||
// Delete RAM area
|
||||
if (ram_area_mapped)
|
||||
vm_release((char *)RAM_BASE, RAMSize);
|
||||
vm_release(RAMBaseHost, RAMSize);
|
||||
|
||||
// Delete ROM area
|
||||
if (rom_area_mapped)
|
||||
vm_release((char *)ROM_BASE, ROM_AREA_SIZE);
|
||||
vm_release(ROMBaseHost, ROM_AREA_SIZE);
|
||||
|
||||
// Delete DR cache areas
|
||||
if (dr_emulator_area_mapped)
|
||||
vm_release((void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
|
||||
vm_release((void *)(DR_EMULATOR_BASE + NATMEM_OFFSET), DR_EMULATOR_SIZE);
|
||||
if (dr_cache_area_mapped)
|
||||
vm_release((void *)DR_CACHE_BASE, DR_CACHE_SIZE);
|
||||
vm_release((void *)(DR_CACHE_BASE + NATMEM_OFFSET), DR_CACHE_SIZE);
|
||||
|
||||
// Delete Kernel Data area
|
||||
if (kernel_area >= 0) {
|
||||
shmdt((void *)KERNEL_DATA_BASE);
|
||||
shmdt((void *)KERNEL_DATA2_BASE);
|
||||
shmdt((void *)(KERNEL_DATA_BASE + NATMEM_OFFSET));
|
||||
shmdt((void *)(KERNEL_DATA2_BASE + NATMEM_OFFSET));
|
||||
shmctl(kernel_area, IPC_RMID, NULL);
|
||||
}
|
||||
|
||||
// Delete Low Memory area
|
||||
if (lm_area_mapped)
|
||||
munmap((char *)0x0000, 0x3000);
|
||||
vm_release((void *)NATMEM_OFFSET, 0x3000);
|
||||
|
||||
// Close /dev/zero
|
||||
if (zero_fd > 0)
|
||||
|
|
@ -1377,14 +1385,14 @@ void Dump68kRegs(M68kRegisters *r)
|
|||
* Make code executable
|
||||
*/
|
||||
|
||||
void MakeExecutable(int dummy, void *start, uint32 length)
|
||||
void MakeExecutable(int dummy, uint32 start, uint32 length)
|
||||
{
|
||||
if (((uintptr)start >= ROM_BASE) && ((uintptr)start < (ROM_BASE + ROM_SIZE)))
|
||||
if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE)))
|
||||
return;
|
||||
#if EMULATED_PPC
|
||||
FlushCodeCache((uintptr)start, (uintptr)start + length);
|
||||
FlushCodeCache(start, start + length);
|
||||
#else
|
||||
flush_icache_range(start, (void *)((uintptr)start + length));
|
||||
flush_icache_range(start, (void *)(start + length));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -2203,21 +2211,22 @@ bool SheepMem::Init(void)
|
|||
page_size = getpagesize();
|
||||
|
||||
// Allocate SheepShaver globals
|
||||
if (vm_acquire_fixed((char *)base, size) < 0)
|
||||
if (vm_acquire_fixed((char *)(base + NATMEM_OFFSET), size) < 0)
|
||||
return false;
|
||||
|
||||
// Allocate page with all bits set to 0
|
||||
zero_page = base + size;
|
||||
if (vm_acquire_fixed((char *)zero_page, page_size) < 0)
|
||||
uint8 *zero_page_host = (uint8 *)zero_page + NATMEM_OFFSET;
|
||||
if (vm_acquire_fixed(zero_page_host, page_size) < 0)
|
||||
return false;
|
||||
memset((char *)zero_page, 0, page_size);
|
||||
if (vm_protect((char *)zero_page, page_size, VM_PAGE_READ) < 0)
|
||||
memset(zero_page_host, 0, page_size);
|
||||
if (vm_protect(zero_page_host, page_size, VM_PAGE_READ) < 0)
|
||||
return false;
|
||||
|
||||
#if EMULATED_PPC
|
||||
// Allocate alternate stack for PowerPC interrupt routine
|
||||
sig_stack = zero_page + page_size;
|
||||
if (vm_acquire_fixed((char *)sig_stack, SIG_STACK_SIZE) < 0)
|
||||
if (vm_acquire_fixed((char *)(sig_stack + NATMEM_OFFSET), SIG_STACK_SIZE) < 0)
|
||||
return false;
|
||||
#endif
|
||||
|
||||
|
|
@ -2229,14 +2238,14 @@ void SheepMem::Exit(void)
|
|||
{
|
||||
if (top) {
|
||||
// Delete SheepShaver globals
|
||||
vm_release((void *)base, size);
|
||||
vm_release((void *)(base + NATMEM_OFFSET), size);
|
||||
|
||||
// Delete zero page
|
||||
vm_release((void *)zero_page, page_size);
|
||||
vm_release((void *)(zero_page + NATMEM_OFFSET), page_size);
|
||||
|
||||
#if EMULATED_PPC
|
||||
// Delete alternate stack for PowerPC interrupt routine
|
||||
vm_release((void *)sig_stack, SIG_STACK_SIZE);
|
||||
vm_release((void *)(sig_stack + NATMEM_OFFSET), SIG_STACK_SIZE);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,8 +66,13 @@
|
|||
// Define for external components
|
||||
#define SHEEPSHAVER 1
|
||||
|
||||
// Mac and host address space are the same
|
||||
// Always use Real Addressing mode on native architectures
|
||||
// Otherwise, use Direct Addressing mode if NATMEM_OFFSET is set
|
||||
#if NATMEM_OFFSET == 0 || EMULATED_PPC == 0
|
||||
#define REAL_ADDRESSING 1
|
||||
#else
|
||||
#define DIRECT_ADDRESSING 1
|
||||
#endif
|
||||
|
||||
#define POWERPC_ROM 1
|
||||
|
||||
|
|
@ -413,14 +418,14 @@ extern X11_LOCK_TYPE x_display_lock;
|
|||
#endif
|
||||
|
||||
// Macro for calling MacOS routines
|
||||
#define CallMacOS(type, tvect) call_macos((uint32)tvect)
|
||||
#define CallMacOS1(type, tvect, arg1) call_macos1((uint32)tvect, (uint32)arg1)
|
||||
#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uint32)tvect, (uint32)arg1, (uint32)arg2)
|
||||
#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3)
|
||||
#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4)
|
||||
#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5)
|
||||
#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6)
|
||||
#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6, (uint32)arg7)
|
||||
#define CallMacOS(type, tvect) call_macos((uintptr)tvect)
|
||||
#define CallMacOS1(type, tvect, arg1) call_macos1((uintptr)tvect, (uintptr)arg1)
|
||||
#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uintptr)tvect, (uintptr)arg1, (uintptr)arg2)
|
||||
#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3)
|
||||
#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4)
|
||||
#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5)
|
||||
#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6)
|
||||
#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6, (uintptr)arg7)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
|
|
|||
|
|
@ -503,7 +503,7 @@ static bool open_window(int width, int height)
|
|||
the_buffer = (uint8 *)malloc((aligned_height + 2) * img->bytes_per_line);
|
||||
D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
|
||||
#endif
|
||||
screen_base = (uint32)the_buffer;
|
||||
screen_base = Host2MacAddr(the_buffer);
|
||||
|
||||
// Create GC
|
||||
the_gc = XCreateGC(x_display, the_win, 0, 0);
|
||||
|
|
@ -633,7 +633,7 @@ static bool open_dga(int width, int height)
|
|||
|
||||
// Set frame buffer base
|
||||
D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf));
|
||||
screen_base = (uint32)the_buffer;
|
||||
screen_base = Host2MacAddr(the_buffer);
|
||||
VModes[cur_mode].viRowBytes = bytes_per_row;
|
||||
return true;
|
||||
#else
|
||||
|
|
@ -1267,7 +1267,7 @@ static void suspend_emul(void)
|
|||
// Save frame buffer
|
||||
fb_save = malloc(VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
|
||||
if (fb_save)
|
||||
memcpy(fb_save, (void *)screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
|
||||
Mac2Host_memcpy(fb_save, screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
|
||||
|
||||
// Close full screen display
|
||||
#ifdef ENABLE_XF86_DGA
|
||||
|
|
@ -1329,7 +1329,7 @@ static void resume_emul(void)
|
|||
// Don't copy fb_save to the temporary frame buffer in VOSF mode
|
||||
if (!use_vosf)
|
||||
#endif
|
||||
memcpy((void *)screen_base, fb_save, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
|
||||
Host2Mac_memcpy(screen_base, fb_save, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
|
||||
free(fb_save);
|
||||
fb_save = NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@
|
|||
|
||||
|
||||
// TVector of MakeExecutable
|
||||
static uint32 *MakeExecutableTvec;
|
||||
static uint32 MakeExecutableTvec;
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -259,11 +259,11 @@ void EmulOp(M68kRegisters *r, uint32 pc, int selector)
|
|||
InstallDrivers();
|
||||
|
||||
// Patch MakeExecutable()
|
||||
MakeExecutableTvec = (uint32 *)FindLibSymbol("\023PrivateInterfaceLib", "\016MakeExecutable");
|
||||
D(bug("MakeExecutable TVECT at %p\n", MakeExecutableTvec));
|
||||
MakeExecutableTvec[0] = htonl(NativeFunction(NATIVE_MAKE_EXECUTABLE));
|
||||
MakeExecutableTvec = (uint32)FindLibSymbol("\023PrivateInterfaceLib", "\016MakeExecutable");
|
||||
D(bug("MakeExecutable TVECT at %08x\n", MakeExecutableTvec));
|
||||
WriteMacInt32(MakeExecutableTvec, NativeFunction(NATIVE_MAKE_EXECUTABLE));
|
||||
#if !EMULATED_PPC
|
||||
MakeExecutableTvec[1] = (uint32)TOC;
|
||||
WriteMacInt32(MakeExecutableTvec + 4, (uint32)TOC);
|
||||
#endif
|
||||
|
||||
// Patch DebugStr()
|
||||
|
|
@ -272,7 +272,7 @@ void EmulOp(M68kRegisters *r, uint32 pc, int selector)
|
|||
PW(0x4e74), // rtd #4
|
||||
PW(0x0004)
|
||||
};
|
||||
WriteMacInt32(0x1dfc, (uint32)proc);
|
||||
WriteMacInt32(0x1dfc, Host2MacAddr((uint8 *)proc));
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -297,7 +297,7 @@ void EmulOp(M68kRegisters *r, uint32 pc, int selector)
|
|||
WriteMacInt32(KernelDataAddr + 0x1b04, DR_CACHE_BASE);
|
||||
WriteMacInt32(KernelDataAddr + 0x1b00, DR_EMULATOR_BASE);
|
||||
memcpy((void *)DR_EMULATOR_BASE, (void *)(ROM_BASE + 0x370000), DR_EMULATOR_SIZE);
|
||||
MakeExecutable(0, (void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
|
||||
MakeExecutable(0, DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
|
|||
|
|
@ -413,13 +413,13 @@ void VideoInstallAccel(void)
|
|||
WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK));
|
||||
WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
|
||||
WriteMacInt32(base + 8, ACCL_BITBLT);
|
||||
NQDMisc(6, bitblt_hook_info.ptr());
|
||||
NQDMisc(6, bitblt_hook_info.addr());
|
||||
|
||||
SheepVar fillrect_hook_info(sizeof(accl_hook_info));
|
||||
base = fillrect_hook_info.addr();
|
||||
WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK));
|
||||
WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
|
||||
WriteMacInt32(base + 8, ACCL_FILLRECT);
|
||||
NQDMisc(6, fillrect_hook_info.ptr());
|
||||
NQDMisc(6, fillrect_hook_info.addr());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,6 +54,8 @@ struct KernelData {
|
|||
// RAM and ROM pointers (allocated and set by main_*.cpp)
|
||||
extern uint32 RAMBase; // Base address of Mac RAM
|
||||
extern uint32 RAMSize; // Size address of Mac RAM
|
||||
extern uint8 *RAMBaseHost; // Base address of Mac RAM (host address space)
|
||||
extern uint8 *ROMBaseHost; // Base address of Mac ROM (host address space)
|
||||
|
||||
// Mac memory access functions
|
||||
#if EMULATED_PPC
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ struct M68kRegisters {
|
|||
|
||||
// Functions
|
||||
extern void Dump68kRegs(M68kRegisters *r); // Dump 68k registers
|
||||
extern void MakeExecutable(int dummy, void *start, uint32 length); // Make code executable
|
||||
extern void MakeExecutable(int dummy, uint32 start, uint32 length); // Make code executable
|
||||
extern void PatchAfterStartup(void); // Patches after system startup
|
||||
extern void QuitEmulator(void); // Quit emulator (must only be called from main thread)
|
||||
extern void ErrorAlert(const char *text); // Display error alert
|
||||
|
|
|
|||
|
|
@ -99,8 +99,8 @@ public:
|
|||
static bool Init(void);
|
||||
static void Exit(void);
|
||||
static uint32 PageSize();
|
||||
static uintptr ZeroPage();
|
||||
static uintptr Reserve(uint32 size);
|
||||
static uint32 ZeroPage();
|
||||
static uint32 Reserve(uint32 size);
|
||||
static void Release(uint32 size);
|
||||
friend class SheepVar;
|
||||
};
|
||||
|
|
@ -116,12 +116,12 @@ inline uint32 SheepMem::PageSize()
|
|||
return page_size;
|
||||
}
|
||||
|
||||
inline uintptr SheepMem::ZeroPage()
|
||||
inline uint32 SheepMem::ZeroPage()
|
||||
{
|
||||
return zero_page;
|
||||
}
|
||||
|
||||
inline uintptr SheepMem::Reserve(uint32 size)
|
||||
inline uint32 SheepMem::Reserve(uint32 size)
|
||||
{
|
||||
top -= align(size);
|
||||
assert(top >= base);
|
||||
|
|
@ -135,13 +135,12 @@ inline void SheepMem::Release(uint32 size)
|
|||
|
||||
class SheepVar
|
||||
{
|
||||
uintptr m_base;
|
||||
uint32 m_size;
|
||||
uint32 m_base;
|
||||
uint32 m_size;
|
||||
public:
|
||||
SheepVar(uint32 requested_size);
|
||||
~SheepVar() { SheepMem::Release(m_size); }
|
||||
uintptr addr() const { return m_base; }
|
||||
void *ptr() const { return (void *)addr(); }
|
||||
uint32 addr() const { return m_base; }
|
||||
};
|
||||
|
||||
inline SheepVar::SheepVar(uint32 requested_size)
|
||||
|
|
@ -152,11 +151,10 @@ inline SheepVar::SheepVar(uint32 requested_size)
|
|||
|
||||
// TODO: optimize for 32-bit platforms
|
||||
|
||||
template< int size >
|
||||
template< int requested_size >
|
||||
struct SheepArray : public SheepVar
|
||||
{
|
||||
SheepArray() : SheepVar(size) { }
|
||||
uint8 *ptr() const { return (uint8 *)addr(); }
|
||||
SheepArray() : SheepVar(requested_size) { }
|
||||
};
|
||||
|
||||
struct SheepVar32 : public SheepVar
|
||||
|
|
@ -165,17 +163,14 @@ struct SheepVar32 : public SheepVar
|
|||
SheepVar32(uint32 value) : SheepVar(4) { set_value(value); }
|
||||
uint32 value() const { return ReadMacInt32(addr()); }
|
||||
void set_value(uint32 v) { WriteMacInt32(addr(), v); }
|
||||
uint32 *ptr() const { return (uint32 *)addr(); }
|
||||
};
|
||||
|
||||
struct SheepString : public SheepVar
|
||||
{
|
||||
SheepString(const char *str) : SheepVar(strlen(str) + 1)
|
||||
{ if (str) strcpy((char *)addr(), str); else WriteMacInt8(addr(), 0); }
|
||||
{ if (str) strcpy(value(), str); else WriteMacInt8(addr(), 0); }
|
||||
char *value() const
|
||||
{ return (char *)addr(); }
|
||||
char *ptr() const
|
||||
{ return (char *)addr(); }
|
||||
{ return (char *)Mac2HostAddr(addr()); }
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
extern bool VideoActivated(void);
|
||||
extern bool VideoSnapshot(int xsize, int ysize, uint8 *p);
|
||||
|
||||
extern int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uint32 commandCode, uint32 commandKind);
|
||||
extern int16 VideoDoDriverIO(uint32 spaceID, uint32 commandID, uint32 commandContents, uint32 commandCode, uint32 commandKind);
|
||||
|
||||
// System specific and internal functions/data
|
||||
struct VideoInfo {
|
||||
|
|
@ -142,7 +142,7 @@ extern bool video_can_change_cursor(void);
|
|||
extern int16 video_mode_change(VidLocals *csSave, uint32 ParamPtr);
|
||||
|
||||
extern int16 VSLDoInterruptService(uint32 arg1);
|
||||
extern void NQDMisc(uint32 arg1, void *arg2);
|
||||
extern void NQDMisc(uint32 arg1, uintptr arg2);
|
||||
|
||||
// Native QuickDraw acceleration callbacks
|
||||
extern bool NQD_sync_hook(uint32);
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1;
|
|||
#define INTERRUPTS_IN_NATIVE_MODE 1
|
||||
|
||||
// Pointer to Kernel Data
|
||||
static KernelData * const kernel_data = (KernelData *)KERNEL_DATA_BASE;
|
||||
static KernelData * kernel_data;
|
||||
|
||||
// SIGSEGV handler
|
||||
sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t);
|
||||
|
|
@ -812,7 +812,7 @@ sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_addres
|
|||
const uintptr addr = (uintptr)fault_address;
|
||||
#if HAVE_SIGSEGV_SKIP_INSTRUCTION
|
||||
// Ignore writes to ROM
|
||||
if ((addr - ROM_BASE) < ROM_SIZE)
|
||||
if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE)
|
||||
return SIGSEGV_RETURN_SKIP_INSTRUCTION;
|
||||
|
||||
// Get program counter of target CPU
|
||||
|
|
@ -872,6 +872,9 @@ sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_addres
|
|||
|
||||
void init_emul_ppc(void)
|
||||
{
|
||||
// Get pointer to KernelData in host address space
|
||||
kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE);
|
||||
|
||||
// Initialize main CPU emulator
|
||||
ppc_cpu = new sheepshaver_cpu();
|
||||
ppc_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000));
|
||||
|
|
@ -1050,7 +1053,7 @@ void sheepshaver_cpu::handle_interrupt(void)
|
|||
0x4e, 0xd0, // jmp (a0)
|
||||
M68K_RTS >> 8, M68K_RTS & 0xff // @1
|
||||
};
|
||||
Execute68k((uint32)proc, &r);
|
||||
Execute68k(Host2MacAddr((uint8 *)proc), &r);
|
||||
WriteMacInt32(XLM_68K_R25, old_r25); // Restore interrupt level
|
||||
#else
|
||||
// Only update cursor
|
||||
|
|
@ -1099,8 +1102,7 @@ void sheepshaver_cpu::execute_native_op(uint32 selector)
|
|||
VideoVBL();
|
||||
break;
|
||||
case NATIVE_VIDEO_DO_DRIVER_IO:
|
||||
gpr(3) = (int32)(int16)VideoDoDriverIO((void *)gpr(3), (void *)gpr(4),
|
||||
(void *)gpr(5), gpr(6), gpr(7));
|
||||
gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7));
|
||||
break;
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
case NATIVE_ETHER_IRQ:
|
||||
|
|
@ -1185,7 +1187,7 @@ void sheepshaver_cpu::execute_native_op(uint32 selector)
|
|||
break;
|
||||
}
|
||||
case NATIVE_MAKE_EXECUTABLE:
|
||||
MakeExecutable(0, (void *)gpr(4), gpr(5));
|
||||
MakeExecutable(0, gpr(4), gpr(5));
|
||||
break;
|
||||
case NATIVE_CHECK_LOAD_INVOC:
|
||||
check_load_invoc(gpr(3), gpr(4), gpr(5));
|
||||
|
|
|
|||
|
|
@ -189,16 +189,25 @@ typedef uintptr vm_addr_t;
|
|||
|
||||
#if REAL_ADDRESSING
|
||||
const uintptr VMBaseDiff = 0;
|
||||
#elif DIRECT_ADDRESSING && defined(NATMEM_OFFSET)
|
||||
const uintptr VMBaseDiff = NATMEM_OFFSET;
|
||||
// Wrap address to 32-bit if we are not using 33-bit addressing space
|
||||
#if defined(SHEEPSHAVER) && SIZEOF_VOID_P == 8
|
||||
#define vm_wrap_address(ADDR) (uintptr)(uint32)(ADDR)
|
||||
#endif
|
||||
#endif
|
||||
#ifndef vm_wrap_address
|
||||
#define vm_wrap_address(ADDR) (ADDR)
|
||||
#endif
|
||||
|
||||
#if REAL_ADDRESSING
|
||||
#if REAL_ADDRESSING || DIRECT_ADDRESSING
|
||||
static inline uint8 * vm_do_get_real_address(vm_addr_t addr)
|
||||
{
|
||||
return (uint8 *)VMBaseDiff + addr;
|
||||
return (uint8 *)vm_wrap_address(VMBaseDiff + addr);
|
||||
}
|
||||
static inline vm_addr_t vm_do_get_virtual_address(uint8 *addr)
|
||||
{
|
||||
return (uintptr)addr - VMBaseDiff;
|
||||
return vm_wrap_address((uintptr)addr - VMBaseDiff);
|
||||
}
|
||||
static inline uint32 vm_read_memory_1(vm_addr_t addr)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -42,15 +42,15 @@ static inline long CallUniversal(void *arg1, uint32 arg2)
|
|||
}
|
||||
typedef int16 (*gsl_ptr)(char *, uint32, uint32, uint32 *, void **, char *);
|
||||
static uint32 gsl_tvect = 0;
|
||||
static inline int16 GetSharedLibrary(char *arg1, uint32 arg2, uint32 arg3, uint32 *arg4, void **arg5, char *arg6)
|
||||
static inline int16 GetSharedLibrary(uintptr arg1, uint32 arg2, uint32 arg3, uintptr arg4, uintptr arg5, uintptr arg6)
|
||||
{
|
||||
return (int16)CallMacOS6(gsl_ptr, gsl_tvect, arg1, arg2, arg3, arg4, arg5, arg6);
|
||||
return (int16)CallMacOS6(gsl_ptr, gsl_tvect, (char *)arg1, arg2, arg3, (uint32 *)arg4, (void **)arg5, (char *)arg6);
|
||||
}
|
||||
typedef int16 (*fs_ptr)(uint32, char *, void **, uint32 *);
|
||||
static uint32 fs_tvect = 0;
|
||||
static inline int16 FindSymbol(uint32 arg1, char *arg2, void **arg3, uint32 *arg4)
|
||||
static inline int16 FindSymbol(uint32 arg1, uintptr arg2, uintptr arg3, uintptr arg4)
|
||||
{
|
||||
return (int16)CallMacOS4(fs_ptr, fs_tvect, arg1, arg2, arg3, arg4);
|
||||
return (int16)CallMacOS4(fs_ptr, fs_tvect, arg1, (char *)arg2, (void **)arg3, (uint32 **)arg4);
|
||||
}
|
||||
typedef int16 (*cc_ptr)(uint32 *);
|
||||
static uint32 cc_tvect = 0;
|
||||
|
|
@ -198,7 +198,7 @@ void *FindLibSymbol(char *lib_str, char *sym_str)
|
|||
r.a[1] = conn_id.addr();
|
||||
r.a[2] = main_addr.addr();
|
||||
r.a[3] = err.addr();
|
||||
Execute68k((uint32)proc1, &r);
|
||||
Execute68k(Host2MacAddr((uint8 *)proc1), &r);
|
||||
D(bug(" GetSharedLibrary: ret %d, connection ID %ld, main %p\n", (int16)r.d[0], conn_id.value(), main_addr.value()));
|
||||
if (r.d[0])
|
||||
return NULL;
|
||||
|
|
@ -219,7 +219,7 @@ void *FindLibSymbol(char *lib_str, char *sym_str)
|
|||
r.a[0] = sym.addr();
|
||||
r.a[1] = sym_addr.addr();
|
||||
r.a[2] = sym_class.addr();
|
||||
Execute68k((uint32)proc2, &r);
|
||||
Execute68k(Host2MacAddr((uint8 *)proc2), &r);
|
||||
D(bug(" FindSymbol1: ret %d, sym_addr %p, sym_class %ld\n", (int16)r.d[0], sym_addr.value(), sym_class.value()));
|
||||
//!! CloseConnection()?
|
||||
if (r.d[0])
|
||||
|
|
@ -234,11 +234,11 @@ void *FindLibSymbol(char *lib_str, char *sym_str)
|
|||
return 0;
|
||||
}
|
||||
int16 res;
|
||||
res = GetSharedLibrary(lib.value(), FOURCC('p','w','p','c'), 1, (uint32 *)conn_id.addr(), (void **)main_addr.addr(), (char *)err.addr());
|
||||
res = GetSharedLibrary(lib.addr(), FOURCC('p','w','p','c'), 1, conn_id.addr(), main_addr.addr(), err.addr());
|
||||
D(bug(" GetSharedLibrary: ret %d, connection ID %ld, main %p\n", res, conn_id.value(), main_addr.value()));
|
||||
if (res)
|
||||
return NULL;
|
||||
res = FindSymbol(conn_id.value(), sym.value(), (void **)sym_addr.addr(), (uint32 *)sym_class.addr());
|
||||
res = FindSymbol(conn_id.value(), sym.addr(), sym_addr.addr(), sym_class.addr());
|
||||
D(bug(" FindSymbol: ret %d, sym_addr %p, sym_class %ld\n", res, sym_addr.value(), sym_class.value()));
|
||||
//!!?? CloseConnection(&conn_id);
|
||||
if (res)
|
||||
|
|
|
|||
|
|
@ -35,17 +35,17 @@
|
|||
// Function pointers
|
||||
typedef int16 (*rcec_ptr)(const RegEntryID *, const char *, RegEntryID *);
|
||||
static uint32 rcec_tvect = 0;
|
||||
static inline int16 RegistryCStrEntryCreate(const RegEntryID *arg1, const char *arg2, RegEntryID *arg3)
|
||||
static inline int16 RegistryCStrEntryCreate(uintptr arg1, const char *arg2, uint32 arg3)
|
||||
{
|
||||
return (int16)CallMacOS3(rcec_ptr, rcec_tvect, arg1, arg2, arg3);
|
||||
return (int16)CallMacOS3(rcec_ptr, rcec_tvect, (const RegEntryID *)arg1, Host2MacAddr((uint8 *)arg2), arg3);
|
||||
}
|
||||
typedef int16 (*rpc_ptr)(const RegEntryID *, const char *, const void *, uint32);
|
||||
static uint32 rpc_tvect = 0;
|
||||
static inline int16 RegistryPropertyCreate(const RegEntryID *arg1, const char *arg2, const void *arg3, uint32 arg4)
|
||||
static inline int16 RegistryPropertyCreate(uintptr arg1, const char *arg2, uintptr arg3, uint32 arg4)
|
||||
{
|
||||
return (int16)CallMacOS4(rpc_ptr, rpc_tvect, arg1, arg2, arg3, arg4);
|
||||
return (int16)CallMacOS4(rpc_ptr, rpc_tvect, (const RegEntryID *)arg1, Host2MacAddr((uint8 *)arg2), (const void *)arg3, arg4);
|
||||
}
|
||||
#define RegistryPropertyCreateStr(e,n,s) RegistryPropertyCreate(e,n,s,strlen(s)+1)
|
||||
#define RegistryPropertyCreateStr(e,n,s) RegistryPropertyCreate(e,n,Host2MacAddr((uint8 *)s),strlen(s)+1)
|
||||
|
||||
// Video driver stub
|
||||
static const uint8 video_driver[] = {
|
||||
|
|
@ -58,16 +58,12 @@ static const uint8 ethernet_driver[] = {
|
|||
};
|
||||
|
||||
// Helper for RegEntryID
|
||||
struct SheepRegEntryID : public SheepArray<sizeof(RegEntryID)> {
|
||||
RegEntryID *ptr() const { return (RegEntryID *)addr(); }
|
||||
};
|
||||
typedef SheepArray<sizeof(RegEntryID)> SheepRegEntryID;
|
||||
|
||||
// Helper for a <uint32, uint32> pair
|
||||
struct SheepPair : public SheepArray<8> {
|
||||
SheepPair(uint32 base, uint32 size) : SheepArray<8>()
|
||||
{ WriteMacInt32(addr(), base); WriteMacInt32(addr() + 4, size); }
|
||||
uint32 *ptr() const
|
||||
{ return (uint32 *)addr(); }
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -82,17 +78,17 @@ void DoPatchNameRegistry(void)
|
|||
|
||||
// Create "device-tree"
|
||||
SheepRegEntryID device_tree;
|
||||
if (!RegistryCStrEntryCreate(NULL, "Devices:device-tree", device_tree.ptr())) {
|
||||
if (!RegistryCStrEntryCreate(0, "Devices:device-tree", device_tree.addr())) {
|
||||
u32.set_value(BusClockSpeed);
|
||||
RegistryPropertyCreate(device_tree.ptr(), "clock-frequency", u32.ptr(), 4);
|
||||
RegistryPropertyCreateStr(device_tree.ptr(), "model", "Power Macintosh");
|
||||
RegistryPropertyCreate(device_tree.addr(), "clock-frequency", u32.addr(), 4);
|
||||
RegistryPropertyCreateStr(device_tree.addr(), "model", "Power Macintosh");
|
||||
|
||||
// Create "AAPL,ROM"
|
||||
SheepRegEntryID aapl_rom;
|
||||
if (!RegistryCStrEntryCreate(device_tree.ptr(), "AAPL,ROM", aapl_rom.ptr())) {
|
||||
RegistryPropertyCreateStr(aapl_rom.ptr(), "device_type", "rom");
|
||||
if (!RegistryCStrEntryCreate(device_tree.addr(), "AAPL,ROM", aapl_rom.addr())) {
|
||||
RegistryPropertyCreateStr(aapl_rom.addr(), "device_type", "rom");
|
||||
SheepPair reg(ROM_BASE, ROM_SIZE);
|
||||
RegistryPropertyCreate(aapl_rom.ptr(), "reg", reg.ptr(), 8);
|
||||
RegistryPropertyCreate(aapl_rom.addr(), "reg", reg.addr(), 8);
|
||||
}
|
||||
|
||||
// Create "PowerPC,60x"
|
||||
|
|
@ -133,127 +129,127 @@ void DoPatchNameRegistry(void)
|
|||
str = "PowerPC,???";
|
||||
break;
|
||||
}
|
||||
if (!RegistryCStrEntryCreate(device_tree.ptr(), str, power_pc.ptr())) {
|
||||
if (!RegistryCStrEntryCreate(device_tree.addr(), str, power_pc.addr())) {
|
||||
u32.set_value(CPUClockSpeed);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "clock-frequency", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "clock-frequency", u32.addr(), 4);
|
||||
u32.set_value(BusClockSpeed);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "bus-frequency", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "bus-frequency", u32.addr(), 4);
|
||||
u32.set_value(TimebaseSpeed);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "timebase-frequency", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "timebase-frequency", u32.addr(), 4);
|
||||
u32.set_value(PVR);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "cpu-version", u32.ptr(), 4);
|
||||
RegistryPropertyCreateStr(power_pc.ptr(), "device_type", "cpu");
|
||||
RegistryPropertyCreate(power_pc.addr(), "cpu-version", u32.addr(), 4);
|
||||
RegistryPropertyCreateStr(power_pc.addr(), "device_type", "cpu");
|
||||
switch (PVR >> 16) {
|
||||
case 1: // 601
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(256);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 3: // 603
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x2000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x2000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 4: // 604
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x4000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x4000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 6: // 603e
|
||||
case 7: // 603ev
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x4000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x4000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 8: // 750, 750FX
|
||||
case 0x7000:
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(256);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(256);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 9: // 604e
|
||||
case 10: // 604ev5
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(256);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(256);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 12: // 7400, 7410, 7450, 7455, 7457
|
||||
case 0x800c:
|
||||
|
|
@ -261,72 +257,72 @@ void DoPatchNameRegistry(void)
|
|||
case 0x8001:
|
||||
case 0x8002:
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(64);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
case 0x39: // 970
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x8000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4);
|
||||
u32.set_value(128);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4);
|
||||
u32.set_value(512);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4);
|
||||
u32.set_value(0x10000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4);
|
||||
u32.set_value(256);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4);
|
||||
u32.set_value(0x1000);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
u32.set_value(32);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "reservation-granularity", u32.ptr(), 4);
|
||||
RegistryPropertyCreate(power_pc.addr(), "reservation-granularity", u32.addr(), 4);
|
||||
SheepPair reg(0, 0);
|
||||
RegistryPropertyCreate(power_pc.ptr(), "reg", reg.ptr(), 8);
|
||||
RegistryPropertyCreate(power_pc.addr(), "reg", reg.addr(), 8);
|
||||
}
|
||||
|
||||
// Create "memory"
|
||||
SheepRegEntryID memory;
|
||||
if (!RegistryCStrEntryCreate(device_tree.ptr(), "memory", memory.ptr())) {
|
||||
if (!RegistryCStrEntryCreate(device_tree.addr(), "memory", memory.addr())) {
|
||||
SheepPair reg(RAMBase, RAMSize);
|
||||
RegistryPropertyCreateStr(memory.ptr(), "device_type", "memory");
|
||||
RegistryPropertyCreate(memory.ptr(), "reg", reg.ptr(), 8);
|
||||
RegistryPropertyCreateStr(memory.addr(), "device_type", "memory");
|
||||
RegistryPropertyCreate(memory.addr(), "reg", reg.addr(), 8);
|
||||
}
|
||||
|
||||
// Create "video"
|
||||
SheepRegEntryID video;
|
||||
if (!RegistryCStrEntryCreate(device_tree.ptr(), "video", video.ptr())) {
|
||||
RegistryPropertyCreateStr(video.ptr(), "AAPL,connector", "monitor");
|
||||
RegistryPropertyCreateStr(video.ptr(), "device_type", "display");
|
||||
RegistryPropertyCreate(video.ptr(), "driver,AAPL,MacOS,PowerPC", video_driver, sizeof(video_driver));
|
||||
RegistryPropertyCreateStr(video.ptr(), "model", "SheepShaver Video");
|
||||
if (!RegistryCStrEntryCreate(device_tree.addr(), "video", video.addr())) {
|
||||
RegistryPropertyCreateStr(video.addr(), "AAPL,connector", "monitor");
|
||||
RegistryPropertyCreateStr(video.addr(), "device_type", "display");
|
||||
RegistryPropertyCreate(video.addr(), "driver,AAPL,MacOS,PowerPC", Host2MacAddr((uint8 *)video_driver), sizeof(video_driver));
|
||||
RegistryPropertyCreateStr(video.addr(), "model", "SheepShaver Video");
|
||||
}
|
||||
|
||||
// Create "ethernet"
|
||||
SheepRegEntryID ethernet;
|
||||
if (!RegistryCStrEntryCreate(device_tree.ptr(), "ethernet", ethernet.ptr())) {
|
||||
RegistryPropertyCreateStr(ethernet.ptr(), "AAPL,connector", "ethernet");
|
||||
RegistryPropertyCreateStr(ethernet.ptr(), "device_type", "network");
|
||||
RegistryPropertyCreate(ethernet.ptr(), "driver,AAPL,MacOS,PowerPC", ethernet_driver, sizeof(ethernet_driver));
|
||||
if (!RegistryCStrEntryCreate(device_tree.addr(), "ethernet", ethernet.addr())) {
|
||||
RegistryPropertyCreateStr(ethernet.addr(), "AAPL,connector", "ethernet");
|
||||
RegistryPropertyCreateStr(ethernet.addr(), "device_type", "network");
|
||||
RegistryPropertyCreate(ethernet.addr(), "driver,AAPL,MacOS,PowerPC", Host2MacAddr((uint8 *)ethernet_driver), sizeof(ethernet_driver));
|
||||
// local-mac-address
|
||||
// max-frame-size 2048
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -117,7 +117,7 @@ void CheckLoad(uint32 type, int16 id, uint16 *p, uint32 size)
|
|||
D(bug("vCheckLoad %c%c%c%c (%08x) ID %d, data %p, size %d\n", type >> 24, (type >> 16) & 0xff, (type >> 8) & 0xff, type & 0xff, type, id, p, size));
|
||||
|
||||
// Don't modify resources in ROM
|
||||
if ((uintptr)p >= ROM_BASE && (uintptr)p <= (ROM_BASE + ROM_SIZE))
|
||||
if ((uintptr)p >= (uintptr)ROMBaseHost && (uintptr)p <= (uintptr)(ROMBaseHost + ROM_SIZE))
|
||||
return;
|
||||
|
||||
if (type == FOURCC('b','o','o','t') && id == 3) {
|
||||
|
|
@ -468,7 +468,7 @@ void CheckLoad(uint32 type, int16 id, uint16 *p, uint32 size)
|
|||
|
||||
} else if (type == FOURCC('t','h','n','g')) {
|
||||
// Collect info about used audio sifters
|
||||
uint32 thing = (uintptr)p;
|
||||
uint32 thing = Host2MacAddr((uint8 *)p);
|
||||
uint32 c_type = ReadMacInt32(thing);
|
||||
uint32 sub_type = ReadMacInt32(thing + 4);
|
||||
if (c_type == FOURCC('s','d','e','v') && sub_type == FOURCC('s','i','n','g')) {
|
||||
|
|
@ -571,7 +571,7 @@ void check_load_invoc(uint32 type, int16 id, uint32 h)
|
|||
return;
|
||||
uint32 size = ReadMacInt32(p - 2 * 4) & 0xffffff;
|
||||
|
||||
CheckLoad(type, id, (uint16 *)p, size);
|
||||
CheckLoad(type, id, (uint16 *)Mac2HostAddr(p), size);
|
||||
}
|
||||
|
||||
#ifdef __BEOS__
|
||||
|
|
@ -756,87 +756,87 @@ void PatchNativeResourceManager(void)
|
|||
uint32 upp = ReadMacInt32(0x1480);
|
||||
if ((upp & 0xffc00000) == ROM_BASE)
|
||||
return;
|
||||
uint32 *tvec = (uint32 *)ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" GetResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1])));
|
||||
*(uint32 *)XLM_RES_LIB_TOC = tvec[1];
|
||||
*(uint32 *)XLM_GET_RESOURCE = tvec[0];
|
||||
uint32 tvec = ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" GetResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4)));
|
||||
WriteMacInt32(XLM_RES_LIB_TOC, ReadMacInt32(tvec + 4));
|
||||
WriteMacInt32(XLM_GET_RESOURCE, ReadMacInt32(tvec));
|
||||
#if EMULATED_PPC
|
||||
tvec[0] = htonl(NativeFunction(NATIVE_GET_RESOURCE));
|
||||
WriteMacInt32(tvec, NativeFunction(NATIVE_GET_RESOURCE));
|
||||
#else
|
||||
#ifdef __BEOS__
|
||||
uint32 *tvec2 = (uint32 *)get_resource;
|
||||
tvec[0] = tvec2[0];
|
||||
tvec[1] = tvec2[1];
|
||||
WriteMacInt32(tvec, tvec2[0]);
|
||||
WriteMacInt32(tvec + 4, tvec2[1]);
|
||||
#else
|
||||
tvec[0] = (uint32)get_resource;
|
||||
WriteMacInt32(tvec, (uint32)get_resource);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Patch native Get1Resource()
|
||||
upp = ReadMacInt32(0x0e7c);
|
||||
tvec = (uint32 *)ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" Get1Resource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1])));
|
||||
*(uint32 *)XLM_GET_1_RESOURCE = tvec[0];
|
||||
tvec = ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" Get1Resource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4)));
|
||||
WriteMacInt32(XLM_GET_1_RESOURCE, ReadMacInt32(tvec));
|
||||
#if EMULATED_PPC
|
||||
tvec[0] = htonl(NativeFunction(NATIVE_GET_1_RESOURCE));
|
||||
WriteMacInt32(tvec, NativeFunction(NATIVE_GET_1_RESOURCE));
|
||||
#else
|
||||
#ifdef __BEOS__
|
||||
tvec2 = (uint32 *)get_1_resource;
|
||||
tvec[0] = tvec2[0];
|
||||
tvec[1] = tvec2[1];
|
||||
WriteMacInt32(tvec, tvec2[0]);
|
||||
WriteMacInt32(tvec + 4, tvec2[1]);
|
||||
#else
|
||||
tvec[0] = (uint32)get_1_resource;
|
||||
WriteMacInt32(tvec, (uint32)get_1_resource);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Patch native GetIndResource()
|
||||
upp = ReadMacInt32(0x1474);
|
||||
tvec = (uint32 *)ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" GetIndResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1])));
|
||||
*(uint32 *)XLM_GET_IND_RESOURCE = tvec[0];
|
||||
tvec = ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" GetIndResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4)));
|
||||
WriteMacInt32(XLM_GET_IND_RESOURCE, ReadMacInt32(tvec));
|
||||
#if EMULATED_PPC
|
||||
tvec[0] = htonl(NativeFunction(NATIVE_GET_IND_RESOURCE));
|
||||
WriteMacInt32(tvec, NativeFunction(NATIVE_GET_IND_RESOURCE));
|
||||
#else
|
||||
#ifdef __BEOS__
|
||||
tvec2 = (uint32 *)get_ind_resource;
|
||||
tvec[0] = tvec2[0];
|
||||
tvec[1] = tvec2[1];
|
||||
WriteMacInt32(tvec, tvec2[0]);
|
||||
WriteMacInt32(tvec + 4, tvec2[1]);
|
||||
#else
|
||||
tvec[0] = (uint32)get_ind_resource;
|
||||
WriteMacInt32(tvec, (uint32)get_ind_resource);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Patch native Get1IndResource()
|
||||
upp = ReadMacInt32(0x0e38);
|
||||
tvec = (uint32 *)ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" Get1IndResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1])));
|
||||
*(uint32 *)XLM_GET_1_IND_RESOURCE = tvec[0];
|
||||
tvec = ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" Get1IndResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4)));
|
||||
WriteMacInt32(XLM_GET_1_IND_RESOURCE, ReadMacInt32(tvec));
|
||||
#if EMULATED_PPC
|
||||
tvec[0] = htonl(NativeFunction(NATIVE_GET_1_IND_RESOURCE));
|
||||
WriteMacInt32(tvec, NativeFunction(NATIVE_GET_1_IND_RESOURCE));
|
||||
#else
|
||||
#ifdef __BEOS__
|
||||
tvec2 = (uint32 *)get_1_ind_resource;
|
||||
tvec[0] = tvec2[0];
|
||||
tvec[1] = tvec2[1];
|
||||
WriteMacInt32(tvec, tvec2[0]);
|
||||
WriteMacInt32(tvec + 4, tvec2[1]);
|
||||
#else
|
||||
tvec[0] = (uint32)get_1_ind_resource;
|
||||
WriteMacInt32(tvec, (uint32)get_1_ind_resource);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Patch native RGetResource()
|
||||
upp = ReadMacInt32(0x0e30);
|
||||
tvec = (uint32 *)ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" RGetResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1])));
|
||||
*(uint32 *)XLM_R_GET_RESOURCE = tvec[0];
|
||||
tvec = ReadMacInt32(upp + 5 * 4);
|
||||
D(bug(" RGetResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4)));
|
||||
WriteMacInt32(XLM_R_GET_RESOURCE, ReadMacInt32(tvec));
|
||||
#if EMULATED_PPC
|
||||
tvec[0] = htonl(NativeFunction(NATIVE_R_GET_RESOURCE));
|
||||
WriteMacInt32(tvec, NativeFunction(NATIVE_R_GET_RESOURCE));
|
||||
#else
|
||||
#ifdef __BEOS__
|
||||
tvec2 = (uint32 *)r_get_resource;
|
||||
tvec[0] = tvec2[0];
|
||||
tvec[1] = tvec2[1];
|
||||
WriteMacInt32(tvec, tvec2[0]);
|
||||
WriteMacInt32(tvec + 4, tvec2[1]);
|
||||
#else
|
||||
tvec[0] = (uint32)r_get_resource;
|
||||
WriteMacInt32(tvec, (uint32)r_get_resource);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ static void generate_powerpc_thunks(void)
|
|||
assert(xlm_index != -1 && check_load_invoc_index != -1);
|
||||
|
||||
uint32 check_load_invoc_opcode = NativeOpcode(NATIVE_CHECK_LOAD_INVOC);
|
||||
uintptr base;
|
||||
uint32 base;
|
||||
|
||||
// GetResource()
|
||||
get_resource_func = base = SheepMem::Reserve(get_resource_template_size);
|
||||
|
|
|
|||
|
|
@ -74,15 +74,15 @@ static long save_conf_mode = APPLE_8_BIT;
|
|||
// Function pointers of imported functions
|
||||
typedef int16 (*iocic_ptr)(void *, int16);
|
||||
static uint32 iocic_tvect = 0;
|
||||
static inline int16 IOCommandIsComplete(void *arg1, int16 arg2)
|
||||
static inline int16 IOCommandIsComplete(uintptr arg1, int16 arg2)
|
||||
{
|
||||
return (int16)CallMacOS2(iocic_ptr, iocic_tvect, arg1, arg2);
|
||||
return (int16)CallMacOS2(iocic_ptr, iocic_tvect, (void *)arg1, arg2);
|
||||
}
|
||||
typedef int16 (*vslnewis_ptr)(void *, uint32, uint32 *);
|
||||
static uint32 vslnewis_tvect = 0;
|
||||
static inline int16 VSLNewInterruptService(void *arg1, uint32 arg2, uint32 *arg3)
|
||||
static inline int16 VSLNewInterruptService(uintptr arg1, uint32 arg2, uintptr arg3)
|
||||
{
|
||||
return (int16)CallMacOS3(vslnewis_ptr, vslnewis_tvect, arg1, arg2, arg3);
|
||||
return (int16)CallMacOS3(vslnewis_ptr, vslnewis_tvect, (void *)arg1, arg2, (uint32 *)arg3);
|
||||
}
|
||||
typedef int16 (*vsldisposeis_ptr)(uint32);
|
||||
static uint32 vsldisposeis_tvect = 0;
|
||||
|
|
@ -98,9 +98,9 @@ int16 VSLDoInterruptService(uint32 arg1)
|
|||
}
|
||||
typedef void (*nqdmisc_ptr)(uint32, void *);
|
||||
static uint32 nqdmisc_tvect = 0;
|
||||
void NQDMisc(uint32 arg1, void *arg2)
|
||||
void NQDMisc(uint32 arg1, uintptr arg2)
|
||||
{
|
||||
CallMacOS2(nqdmisc_ptr, nqdmisc_tvect, arg1, arg2);
|
||||
CallMacOS2(nqdmisc_ptr, nqdmisc_tvect, arg1, (void *)arg2);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -169,7 +169,7 @@ static int16 VideoOpen(uint32 pb, VidLocals *csSave)
|
|||
|
||||
// Install and activate interrupt service
|
||||
SheepVar32 theServiceID = 0;
|
||||
VSLNewInterruptService(csSave->regEntryID, FOURCC('v','b','l',' '), (uint32 *)theServiceID.addr());
|
||||
VSLNewInterruptService(Host2MacAddr((uint8 *)csSave->regEntryID), FOURCC('v','b','l',' '), theServiceID.addr());
|
||||
csSave->vslServiceID = theServiceID.value();
|
||||
D(bug(" Interrupt ServiceID %08lx\n", csSave->vslServiceID));
|
||||
csSave->interruptsEnabled = true;
|
||||
|
|
@ -184,6 +184,7 @@ static int16 VideoOpen(uint32 pb, VidLocals *csSave)
|
|||
|
||||
static int16 set_gamma(VidLocals *csSave, uint32 gamma)
|
||||
{
|
||||
#warning "FIXME: this code is not little endian aware"
|
||||
GammaTbl *clientGamma = (GammaTbl *)gamma;
|
||||
GammaTbl *gammaTable = csSave->gammaTable;
|
||||
|
||||
|
|
@ -876,9 +877,9 @@ static int16 VideoClose(uint32 pb, VidLocals *csSave)
|
|||
* Native (PCI) driver entry
|
||||
*/
|
||||
|
||||
int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uint32 commandCode, uint32 commandKind)
|
||||
int16 VideoDoDriverIO(uint32 spaceID, uint32 commandID, uint32 commandContents, uint32 commandCode, uint32 commandKind)
|
||||
{
|
||||
// D(bug("VideoDoDriverIO space %p, command %p, contents %p, code %d, kind %d\n", spaceID, commandID, commandContents, commandCode, commandKind));
|
||||
// D(bug("VideoDoDriverIO space %08x, command %08x, contents %08x, code %d, kind %d\n", spaceID, commandID, commandContents, commandCode, commandKind));
|
||||
int16 err = noErr;
|
||||
|
||||
switch (commandCode) {
|
||||
|
|
@ -926,7 +927,7 @@ int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uin
|
|||
|
||||
private_data = new VidLocals;
|
||||
private_data->gammaTable = NULL;
|
||||
memcpy(private_data->regEntryID, (uint8 *)commandContents + 2, 16); // DriverInitInfo.deviceEntry
|
||||
Mac2Host_memcpy(&private_data->regEntryID, commandContents + 2, 16); // DriverInitInfo.deviceEntry
|
||||
private_data->interruptsEnabled = false; // Disable interrupts
|
||||
break;
|
||||
|
||||
|
|
@ -939,19 +940,19 @@ int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uin
|
|||
break;
|
||||
|
||||
case kOpenCommand:
|
||||
err = VideoOpen((uint32)commandContents, private_data);
|
||||
err = VideoOpen(commandContents, private_data);
|
||||
break;
|
||||
|
||||
case kCloseCommand:
|
||||
err = VideoClose((uint32)commandContents, private_data);
|
||||
err = VideoClose(commandContents, private_data);
|
||||
break;
|
||||
|
||||
case kControlCommand:
|
||||
err = VideoControl((uint32)commandContents, private_data);
|
||||
err = VideoControl(commandContents, private_data);
|
||||
break;
|
||||
|
||||
case kStatusCommand:
|
||||
err = VideoStatus((uint32)commandContents, private_data);
|
||||
err = VideoStatus(commandContents, private_data);
|
||||
break;
|
||||
|
||||
case kReadCommand:
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user