src/Windows/main_windows.cpp

/*
 *  main_windows.cpp - Startup code for Windows
 *
 *  Basilisk II (C) 1997-2005 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>

#include <SDL.h>
#include <SDL_mutex.h>
#include <SDL_thread.h>

#include <string>
using std::string;

#include "cpu_emulation.h"
#include "sys.h"
#include "rom_patches.h"
#include "xpram.h"
#include "timer.h"
#include "video.h"
#include "cdrom.h"
#include "emul_op.h"
#include "prefs.h"
#include "prefs_editor.h"
#include "macos_util.h"
#include "user_strings.h"
#include "version.h"
#include "main.h"
#include "vm_alloc.h"
#include "sigsegv.h"
#include "util_windows.h"
#include "kernel_windows.h"

#if USE_JIT
extern void flush_icache_range(uint32 start, uint32 size); // from compemu_support.cpp
#endif

#ifdef ENABLE_MON
# include "mon.h"
#endif

#define DEBUG 0
#include "debug.h"


// Constants
const char ROM_FILE_NAME[] = "ROM";
const int SCRATCH_MEM_SIZE = 0x10000;   // Size of scratch memory area


// CPU and FPU type, addressing mode
int CPUType;
bool CPUIs68060;
int FPUType;
bool TwentyFourBitAddressing;
bool ThirtyThreeBitAddressing = false;


// Global variables
static uint8 last_xpram[XPRAM_SIZE];                            // Buffer for monitoring XPRAM changes

static bool xpram_thread_active = false;                        // Flag: XPRAM watchdog installed
static volatile bool xpram_thread_cancel = false;       // Flag: Cancel XPRAM thread
static SDL_Thread *xpram_thread = NULL;                         // XPRAM watchdog

static bool tick_thread_active = false;                         // Flag: 60Hz thread installed
static volatile bool tick_thread_cancel = false;        // Flag: Cancel 60Hz thread
static SDL_Thread *tick_thread;                                         // 60Hz thread

static SDL_mutex *intflag_lock = NULL;                          // Mutex to protect InterruptFlags
#define LOCK_INTFLAGS SDL_LockMutex(intflag_lock)
#define UNLOCK_INTFLAGS SDL_UnlockMutex(intflag_lock)

DWORD win_os;                                                                           // Windows OS id
DWORD win_os_major;                                                                     // Windows OS version major

#if USE_SCRATCHMEM_SUBTERFUGE
uint8 *ScratchMem = NULL;                       // Scratch memory for Mac ROM writes
#endif

#if REAL_ADDRESSING
static bool lm_area_mapped = false;     // Flag: Low Memory area mmap()ped
#endif


// Prototypes
static int xpram_func(void *arg);
static int tick_func(void *arg);
static void one_tick(...);


/*
 *  Ersatz functions
 */

extern "C" {

#ifndef HAVE_STRDUP
char *strdup(const char *s)
{
        char *n = (char *)malloc(strlen(s) + 1);
        strcpy(n, s);
        return n;
}
#endif

}


/*
 *  Map memory that can be accessed from the Mac side
 */

void *vm_acquire_mac(size_t size)
{
        void *m = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_33BIT);
        if (m == NULL) {
                ThirtyThreeBitAddressing = false;
                m = vm_acquire(size);
        }
        return m;
}


/*
 *  SIGSEGV handler
 */

static sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction)
{
#if ENABLE_VOSF
        // Handle screen fault
        extern bool Screen_fault_handler(sigsegv_address_t, sigsegv_address_t);
        if (Screen_fault_handler(fault_address, fault_instruction))
                return SIGSEGV_RETURN_SUCCESS;
#endif

#ifdef HAVE_SIGSEGV_SKIP_INSTRUCTION
        // Ignore writes to ROM
        if (((uintptr)fault_address - (uintptr)ROMBaseHost) < ROMSize)
                return SIGSEGV_RETURN_SKIP_INSTRUCTION;

        // Ignore all other faults, if requested
        if (PrefsFindBool("ignoresegv"))
                return SIGSEGV_RETURN_SKIP_INSTRUCTION;
#endif

        return SIGSEGV_RETURN_FAILURE;
}

/*
 *  Dump state when everything went wrong after a SEGV
 */

static void sigsegv_dump_state(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction)
{
        fprintf(stderr, "Caught SIGSEGV at address %p", fault_address);
        if (fault_instruction != SIGSEGV_INVALID_PC)
                fprintf(stderr, " [IP=%p]", fault_instruction);
        fprintf(stderr, "\n");
        uaecptr nextpc;
        extern void m68k_dumpstate(uaecptr *nextpc);
        m68k_dumpstate(&nextpc);
#if USE_JIT && JIT_DEBUG
        extern void compiler_dumpstate(void);
        compiler_dumpstate();
#endif
        VideoQuitFullScreen();
#ifdef ENABLE_MON
        char *arg[4] = {"mon", "-m", "-r", NULL};
        mon(3, arg);
        QuitEmulator();
#endif
}


/*
 *  Main program
 */

static void usage(const char *prg_name)
{
        printf(
                "Usage: %s [OPTION...]\n"
                "\nUnix options:\n"
                "  --config FILE\n    read/write configuration from/to FILE\n"
                "  --display STRING\n    X display to use\n"
                "  --break ADDRESS\n    set ROM breakpoint\n"
                "  --rominfo\n    dump ROM information\n", prg_name
        );
        LoadPrefs(); // read the prefs file so PrefsPrintUsage() will print the correct default values
        PrefsPrintUsage();
        exit(0);
}

int main(int argc, char **argv)
{
        char str[256];
        bool cd_boot = false;

        // Initialize variables
        RAMBaseHost = NULL;
        ROMBaseHost = NULL;
        srand(time(NULL));
        tzset();

        // Print some info
        printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
        printf(" %s\n", GetString(STR_ABOUT_TEXT2));

        // Parse command line arguments
        for (int i=1; i<argc; i++) {
                if (strcmp(argv[i], "--help") == 0) {
                        usage(argv[0]);
                } else if (strcmp(argv[i], "--break") == 0) {
                        argv[i++] = NULL;
                        if (i < argc) {
                                ROMBreakpoint = strtol(argv[i], NULL, 0);
                                argv[i] = NULL;
                        }
                } else if (strcmp(argv[i], "--config") == 0) {
                        argv[i++] = NULL;
                        if (i < argc) {
                                extern string UserPrefsPath; // from prefs_unix.cpp
                                UserPrefsPath = argv[i];
                                argv[i] = NULL;
                        }
                } else if (strcmp(argv[i], "--rominfo") == 0) {
                        argv[i] = NULL;
                        PrintROMInfo = true;
                } else if (strcmp(argv[i], "--cdboot") == 0) {
                        argv[i] = NULL;
                        cd_boot = true;
                }
        }

        // Remove processed arguments
        for (int i=1; i<argc; i++) {
                int k;
                for (k=i; k<argc; k++)
                        if (argv[k] != NULL)
                                break;
                if (k > i) {
                        k -= i;
                        for (int j=i+k; j<argc; j++)
                                argv[j-k] = argv[j];
                        argc -= k;
                }
        }

        // Read preferences
        PrefsInit(argc, argv);

        // Boot MacOS from CD-ROM?
        if (cd_boot)
                PrefsReplaceInt32("bootdriver", CDROMRefNum);

        // Any command line arguments left?
        for (int i=1; i<argc; i++) {
                if (argv[i][0] == '-') {
                        fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
                        usage(argv[0]);
                }
        }

        // Check we are using a Windows NT kernel >= 4.0
        OSVERSIONINFO osvi;
        ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        if (!GetVersionEx(&osvi)) {
                ErrorAlert("Could not determine OS type");
                QuitEmulator();
        }
        win_os = osvi.dwPlatformId;
        win_os_major = osvi.dwMajorVersion;
        if (win_os != VER_PLATFORM_WIN32_NT || win_os_major < 4) {
                ErrorAlert(STR_NO_WIN32_NT_4);
                QuitEmulator();
        }

        // Check that drivers are installed
        if (!check_drivers())
                QuitEmulator();

        // Load win32 libraries
        KernelInit();

        // FIXME: default to DIB driver
        if (getenv("SDL_VIDEODRIVER") == NULL)
            putenv("SDL_VIDEODRIVER=windib");

        // Initialize SDL system
        int sdl_flags = 0;
#ifdef USE_SDL_VIDEO
        sdl_flags |= SDL_INIT_VIDEO;
#endif
#ifdef USE_SDL_AUDIO
        sdl_flags |= SDL_INIT_AUDIO;
#endif
        assert(sdl_flags != 0);
        if (SDL_Init(sdl_flags) == -1) {
                char str[256];
                sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
                ErrorAlert(str);
                QuitEmulator();
        }
        atexit(SDL_Quit);

        // Init system routines
        SysInit();

        // Show preferences editor
        if (!PrefsFindBool("nogui"))
                if (!PrefsEditor())
                        QuitEmulator();

        // Install the handler for SIGSEGV
        if (!sigsegv_install_handler(sigsegv_handler)) {
                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
                ErrorAlert(str);
                QuitEmulator();
        }
        
        // Register dump state function when we got mad after a segfault
        sigsegv_set_dump_state(sigsegv_dump_state);

        // Read RAM size
        RAMSize = PrefsFindInt32("ramsize") & 0xfff00000;       // Round down to 1MB boundary
        if (RAMSize < 1024*1024) {
                WarningAlert(GetString(STR_SMALL_RAM_WARN));
                RAMSize = 1024*1024;
        }
        
        // Initialize VM system
        vm_init();

        // Create areas for Mac RAM and ROM
#ifdef USE_33BIT_ADDRESSING
        // Speculatively enables 33-bit addressing
        ThirtyThreeBitAddressing = true;
#endif
        RAMBaseHost = (uint8 *)vm_acquire_mac(RAMSize);
        ROMBaseHost = (uint8 *)vm_acquire_mac(0x100000);
        if (RAMBaseHost == VM_MAP_FAILED || ROMBaseHost == VM_MAP_FAILED) {
                ErrorAlert(STR_NO_MEM_ERR);
                QuitEmulator();
        }

#if USE_SCRATCHMEM_SUBTERFUGE
        // Allocate scratch memory
        ScratchMem = (uint8 *)vm_acquire(SCRATCH_MEM_SIZE);
        if (ScratchMem == VM_MAP_FAILED) {
                ErrorAlert(STR_NO_MEM_ERR);
                QuitEmulator();
        }
        ScratchMem += SCRATCH_MEM_SIZE/2;       // ScratchMem points to middle of block
#endif

#if DIRECT_ADDRESSING
        // RAMBaseMac shall always be zero
        MEMBaseDiff = (uintptr)RAMBaseHost;
        RAMBaseMac = 0;
        ROMBaseMac = Host2MacAddr(ROMBaseHost);
#endif
        D(bug("Mac RAM starts at %p (%08x)\n", RAMBaseHost, RAMBaseMac));
        D(bug("Mac ROM starts at %p (%08x)\n", ROMBaseHost, ROMBaseMac));
        
        // Get rom file path from preferences
        const char *rom_path = PrefsFindString("rom");

        // Load Mac ROM
        HANDLE rom_fh = CreateFile(rom_path ? rom_path : ROM_FILE_NAME,
                                                           GENERIC_READ,
                                                           0, NULL,
                                                           OPEN_EXISTING,
                                                           FILE_ATTRIBUTE_NORMAL,
                                                           NULL);
        if (rom_fh == INVALID_HANDLE_VALUE) {
                ErrorAlert(STR_NO_ROM_FILE_ERR);
                QuitEmulator();
        }
        printf(GetString(STR_READING_ROM_FILE));
        ROMSize = GetFileSize(rom_fh, NULL);
        if (ROMSize != 64*1024 && ROMSize != 128*1024 && ROMSize != 256*1024 && ROMSize != 512*1024 && ROMSize != 1024*1024) {
                ErrorAlert(STR_ROM_SIZE_ERR);
                CloseHandle(rom_fh);
                QuitEmulator();
        }
        DWORD bytes_read;
        if (ReadFile(rom_fh, ROMBaseHost, ROMSize, &bytes_read, NULL) == 0 || bytes_read != ROMSize) {
                ErrorAlert(STR_ROM_FILE_READ_ERR);
                CloseHandle(rom_fh);
                QuitEmulator();
        }

        // Initialize native timers
        timer_init();

        // Initialize everything
        if (!InitAll())
                QuitEmulator();
        D(bug("Initialization complete\n"));

        // SDL threads available, start 60Hz thread
        tick_thread_active = ((tick_thread = SDL_CreateThread(tick_func, NULL)) != NULL);
        if (!tick_thread_active) {
                sprintf(str, GetString(STR_TICK_THREAD_ERR), strerror(errno));
                ErrorAlert(str);
                QuitEmulator();
        }
        D(bug("60Hz thread started\n"));

        // Start XPRAM watchdog thread
        memcpy(last_xpram, XPRAM, XPRAM_SIZE);
        xpram_thread_active = ((xpram_thread = SDL_CreateThread(xpram_func, NULL)) != NULL);
        D(bug("XPRAM thread started\n"));

        // Start 68k and jump to ROM boot routine
        D(bug("Starting emulation...\n"));
        Start680x0();

        QuitEmulator();
        return 0;
}


/*
 *  Quit emulator
 */

void QuitEmulator(void)
{
        D(bug("QuitEmulator\n"));

        // Exit 680x0 emulation
        Exit680x0();

        // Stop 60Hz thread
        if (tick_thread_active) {
                tick_thread_cancel = true;
                SDL_WaitThread(tick_thread, NULL);
        }

        // Stop XPRAM watchdog thread
        if (xpram_thread_active) {
                xpram_thread_cancel = true;
                SDL_WaitThread(xpram_thread, NULL);
        }

        // Deinitialize everything
        ExitAll();

        // Free ROM/RAM areas
        if (RAMBaseHost != VM_MAP_FAILED) {
                vm_release(RAMBaseHost, RAMSize);
                RAMBaseHost = NULL;
        }
        if (ROMBaseHost != VM_MAP_FAILED) {
                vm_release(ROMBaseHost, 0x100000);
                ROMBaseHost = NULL;
        }

#if USE_SCRATCHMEM_SUBTERFUGE
        // Delete scratch memory area
        if (ScratchMem != (uint8 *)VM_MAP_FAILED) {
                vm_release((void *)(ScratchMem - SCRATCH_MEM_SIZE/2), SCRATCH_MEM_SIZE);
                ScratchMem = NULL;
        }
#endif

        // Exit VM wrappers
        vm_exit();

        // Exit system routines
        SysExit();

        // Exit preferences
        PrefsExit();

        // Release win32 libraries
        KernelExit();

        exit(0);
}


/*
 *  Code was patched, flush caches if neccessary (i.e. when using a real 680x0
 *  or a dynamically recompiling emulator)
 */

void FlushCodeCache(void *start, uint32 size)
{
#if USE_JIT
    if (UseJIT)
                flush_icache_range((uintptr)start, size);
#endif
}


/*
 *  Mutexes
 */

struct B2_mutex {
        B2_mutex() { m = SDL_CreateMutex(); }
        ~B2_mutex() { if (m) SDL_DestroyMutex(m); }
        SDL_mutex *m;
};

B2_mutex *B2_create_mutex(void)
{
        return new B2_mutex;
}

void B2_lock_mutex(B2_mutex *mutex)
{
        if (mutex)
                SDL_LockMutex(mutex->m);
}

void B2_unlock_mutex(B2_mutex *mutex)
{
        if (mutex)
                SDL_UnlockMutex(mutex->m);
}

void B2_delete_mutex(B2_mutex *mutex)
{
        delete mutex;
}


/*
 *  Interrupt flags (must be handled atomically!)
 */

uint32 InterruptFlags = 0;

void SetInterruptFlag(uint32 flag)
{
        LOCK_INTFLAGS;
        InterruptFlags |= flag;
        UNLOCK_INTFLAGS;
}

void ClearInterruptFlag(uint32 flag)
{
        LOCK_INTFLAGS;
        InterruptFlags &= ~flag;
        UNLOCK_INTFLAGS;
}


/*
 *  XPRAM watchdog thread (saves XPRAM every minute)
 */

static void xpram_watchdog(void)
{
        if (memcmp(last_xpram, XPRAM, XPRAM_SIZE)) {
                memcpy(last_xpram, XPRAM, XPRAM_SIZE);
                SaveXPRAM();
        }
}

static int xpram_func(void *arg)
{
        while (!xpram_thread_cancel) {
                for (int i=0; i<60 && !xpram_thread_cancel; i++)
                        Delay_usec(999999);             // Only wait 1 second so we quit promptly when xpram_thread_cancel becomes true
                xpram_watchdog();
        }
        return 0;
}


/*
 *  60Hz thread (really 60.15Hz)
 */

static void one_second(void)
{
        // Pseudo Mac 1Hz interrupt, update local time
        WriteMacInt32(0x20c, TimerDateTime());

        SetInterruptFlag(INTFLAG_1HZ);
        TriggerInterrupt();
}

static void one_tick(...)
{
        static int tick_counter = 0;
        if (++tick_counter > 60) {
                tick_counter = 0;
                one_second();
        }

        // Trigger 60Hz interrupt
        if (ROMVersion != ROM_VERSION_CLASSIC || HasMacStarted()) {
                SetInterruptFlag(INTFLAG_60HZ);
                TriggerInterrupt();
        }
}

static int tick_func(void *arg)
{
        uint64 start = GetTicks_usec();
        int64 ticks = 0;
        uint64 next = GetTicks_usec();
        while (!tick_thread_cancel) {
                one_tick();
                next += 16625;
                int64 delay = next - GetTicks_usec();
                if (delay > 0)
                        Delay_usec(delay);
                else if (delay < -16625)
                        next = GetTicks_usec();
                ticks++;
        }
        uint64 end = GetTicks_usec();
        D(bug("%Ld ticks in %Ld usec = %f ticks/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
        return 0;
}


/*
 *  Get the main window handle
 */

#ifdef USE_SDL_VIDEO
#include <SDL_syswm.h>
static HWND GetMainWindowHandle(void)
{
        SDL_SysWMinfo wmInfo;
        wmInfo.version.major = SDL_MAJOR_VERSION;
        wmInfo.version.minor = SDL_MINOR_VERSION;
        wmInfo.version.patch = SDL_PATCHLEVEL;
        return SDL_GetWMInfo(&wmInfo) ? wmInfo.window : NULL;
}
#endif


/*
 *  Display alert
 */

static void display_alert(int title_id, const char *text, int flags)
{
        HWND hMainWnd = GetMainWindowHandle();
        MessageBox(hMainWnd, text, GetString(title_id), MB_OK | flags);
}


/*
 *  Display error alert
 */

void ErrorAlert(const char *text)
{
        if (PrefsFindBool("nogui"))
                return;

        VideoQuitFullScreen();
        display_alert(STR_ERROR_ALERT_TITLE, text, MB_ICONSTOP);
}


/*
 *  Display warning alert
 */

void WarningAlert(const char *text)
{
        if (PrefsFindBool("nogui"))
                return;

        display_alert(STR_WARNING_ALERT_TITLE, text, MB_ICONINFORMATION);
}


/*
 *  Display choice alert
 */

bool ChoiceAlert(const char *text, const char *pos, const char *neg)
{
        printf(GetString(STR_SHELL_WARNING_PREFIX), text);
        return false;   //!!
}
Revision:	1.7
Committed:	2005-11-22T06:26:35Z (18 years, 6 months ago) by gbeauche
Branch:	MAIN
CVS Tags:	nigel-build-17
Changes since 1.6:	+4 -0 lines
Log Message:	Windows HACK: default to the DIB driver as it looks smoother to me and doesn't require locking the surfaces, which probably the cause of apparent slowness when using the DirectX backend. This needs to be investigated more
#	Content
1	/*
2	* main_windows.cpp - Startup code for Windows
3	*
4	* Basilisk II (C) 1997-2005 Christian Bauer
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
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "sysdeps.h"
22
23	#include <stdio.h>
24	#include <stdlib.h>
25	#include <signal.h>
26	#include <errno.h>
27
28	#include <SDL.h>
29	#include <SDL_mutex.h>
30	#include <SDL_thread.h>
31
32	#include <string>
33	using std::string;
34
35	#include "cpu_emulation.h"
36	#include "sys.h"
37	#include "rom_patches.h"
38	#include "xpram.h"
39	#include "timer.h"
40	#include "video.h"
41	#include "cdrom.h"
42	#include "emul_op.h"
43	#include "prefs.h"
44	#include "prefs_editor.h"
45	#include "macos_util.h"
46	#include "user_strings.h"
47	#include "version.h"
48	#include "main.h"
49	#include "vm_alloc.h"
50	#include "sigsegv.h"
51	#include "util_windows.h"
52	#include "kernel_windows.h"
53
54	#if USE_JIT
55	extern void flush_icache_range(uint32 start, uint32 size); // from compemu_support.cpp
56	#endif
57
58	#ifdef ENABLE_MON
59	# include "mon.h"
60	#endif
61
62	#define DEBUG 0
63	#include "debug.h"
64
65
66	// Constants
67	const char ROM_FILE_NAME[] = "ROM";
68	const int SCRATCH_MEM_SIZE = 0x10000; // Size of scratch memory area
69
70
71	// CPU and FPU type, addressing mode
72	int CPUType;
73	bool CPUIs68060;
74	int FPUType;
75	bool TwentyFourBitAddressing;
76	bool ThirtyThreeBitAddressing = false;
77
78
79	// Global variables
80	static uint8 last_xpram[XPRAM_SIZE]; // Buffer for monitoring XPRAM changes
81
82	static bool xpram_thread_active = false; // Flag: XPRAM watchdog installed
83	static volatile bool xpram_thread_cancel = false; // Flag: Cancel XPRAM thread
84	static SDL_Thread *xpram_thread = NULL; // XPRAM watchdog
85
86	static bool tick_thread_active = false; // Flag: 60Hz thread installed
87	static volatile bool tick_thread_cancel = false; // Flag: Cancel 60Hz thread
88	static SDL_Thread *tick_thread; // 60Hz thread
89
90	static SDL_mutex *intflag_lock = NULL; // Mutex to protect InterruptFlags
91	#define LOCK_INTFLAGS SDL_LockMutex(intflag_lock)
92	#define UNLOCK_INTFLAGS SDL_UnlockMutex(intflag_lock)
93
94	DWORD win_os; // Windows OS id
95	DWORD win_os_major; // Windows OS version major
96
97	#if USE_SCRATCHMEM_SUBTERFUGE
98	uint8 *ScratchMem = NULL; // Scratch memory for Mac ROM writes
99	#endif
100
101	#if REAL_ADDRESSING
102	static bool lm_area_mapped = false; // Flag: Low Memory area mmap()ped
103	#endif
104
105
106	// Prototypes
107	static int xpram_func(void *arg);
108	static int tick_func(void *arg);
109	static void one_tick(...);
110
111
112	/*
113	* Ersatz functions
114	*/
115
116	extern "C" {
117
118	#ifndef HAVE_STRDUP
119	char strdup(const char s)
120	{
121	char n = (char )malloc(strlen(s) + 1);
122	strcpy(n, s);
123	return n;
124	}
125	#endif
126
127	}
128
129
130	/*
131	* Map memory that can be accessed from the Mac side
132	*/
133
134	void *vm_acquire_mac(size_t size)
135	{
136	void *m = vm_acquire(size, VM_MAP_DEFAULT \| VM_MAP_33BIT);
137	if (m == NULL) {
138	ThirtyThreeBitAddressing = false;
139	m = vm_acquire(size);
140	}
141	return m;
142	}
143
144
145	/*
146	* SIGSEGV handler
147	*/
148
149	static sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction)
150	{
151	#if ENABLE_VOSF
152	// Handle screen fault
153	extern bool Screen_fault_handler(sigsegv_address_t, sigsegv_address_t);
154	if (Screen_fault_handler(fault_address, fault_instruction))
155	return SIGSEGV_RETURN_SUCCESS;
156	#endif
157
158	#ifdef HAVE_SIGSEGV_SKIP_INSTRUCTION
159	// Ignore writes to ROM
160	if (((uintptr)fault_address - (uintptr)ROMBaseHost) < ROMSize)
161	return SIGSEGV_RETURN_SKIP_INSTRUCTION;
162
163	// Ignore all other faults, if requested
164	if (PrefsFindBool("ignoresegv"))
165	return SIGSEGV_RETURN_SKIP_INSTRUCTION;
166	#endif
167
168	return SIGSEGV_RETURN_FAILURE;
169	}
170
171	/*
172	* Dump state when everything went wrong after a SEGV
173	*/
174
175	static void sigsegv_dump_state(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction)
176	{
177	fprintf(stderr, "Caught SIGSEGV at address %p", fault_address);
178	if (fault_instruction != SIGSEGV_INVALID_PC)
179	fprintf(stderr, " [IP=%p]", fault_instruction);
180	fprintf(stderr, "\n");
181	uaecptr nextpc;
182	extern void m68k_dumpstate(uaecptr *nextpc);
183	m68k_dumpstate(&nextpc);
184	#if USE_JIT && JIT_DEBUG
185	extern void compiler_dumpstate(void);
186	compiler_dumpstate();
187	#endif
188	VideoQuitFullScreen();
189	#ifdef ENABLE_MON
190	char *arg[4] = {"mon", "-m", "-r", NULL};
191	mon(3, arg);
192	QuitEmulator();
193	#endif
194	}
195
196
197	/*
198	* Main program
199	*/
200
201	static void usage(const char *prg_name)
202	{
203	printf(
204	"Usage: %s [OPTION...]\n"
205	"\nUnix options:\n"
206	" --config FILE\n read/write configuration from/to FILE\n"
207	" --display STRING\n X display to use\n"
208	" --break ADDRESS\n set ROM breakpoint\n"
209	" --rominfo\n dump ROM information\n", prg_name
210	);
211	LoadPrefs(); // read the prefs file so PrefsPrintUsage() will print the correct default values
212	PrefsPrintUsage();
213	exit(0);
214	}
215
216	int main(int argc, char **argv)
217	{
218	char str[256];
219	bool cd_boot = false;
220
221	// Initialize variables
222	RAMBaseHost = NULL;
223	ROMBaseHost = NULL;
224	srand(time(NULL));
225	tzset();
226
227	// Print some info
228	printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
229	printf(" %s\n", GetString(STR_ABOUT_TEXT2));
230
231	// Parse command line arguments
232	for (int i=1; i<argc; i++) {
233	if (strcmp(argv[i], "--help") == 0) {
234	usage(argv[0]);
235	} else if (strcmp(argv[i], "--break") == 0) {
236	argv[i++] = NULL;
237	if (i < argc) {
238	ROMBreakpoint = strtol(argv[i], NULL, 0);
239	argv[i] = NULL;
240	}
241	} else if (strcmp(argv[i], "--config") == 0) {
242	argv[i++] = NULL;
243	if (i < argc) {
244	extern string UserPrefsPath; // from prefs_unix.cpp
245	UserPrefsPath = argv[i];
246	argv[i] = NULL;
247	}
248	} else if (strcmp(argv[i], "--rominfo") == 0) {
249	argv[i] = NULL;
250	PrintROMInfo = true;
251	} else if (strcmp(argv[i], "--cdboot") == 0) {
252	argv[i] = NULL;
253	cd_boot = true;
254	}
255	}
256
257	// Remove processed arguments
258	for (int i=1; i<argc; i++) {
259	int k;
260	for (k=i; k<argc; k++)
261	if (argv[k] != NULL)
262	break;
263	if (k > i) {
264	k -= i;
265	for (int j=i+k; j<argc; j++)
266	argv[j-k] = argv[j];
267	argc -= k;
268	}
269	}
270
271	// Read preferences
272	PrefsInit(argc, argv);
273
274	// Boot MacOS from CD-ROM?
275	if (cd_boot)
276	PrefsReplaceInt32("bootdriver", CDROMRefNum);
277
278	// Any command line arguments left?
279	for (int i=1; i<argc; i++) {
280	if (argv[i][0] == '-') {
281	fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
282	usage(argv[0]);
283	}
284	}
285
286	// Check we are using a Windows NT kernel >= 4.0
287	OSVERSIONINFO osvi;
288	ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
289	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
290	if (!GetVersionEx(&osvi)) {
291	ErrorAlert("Could not determine OS type");
292	QuitEmulator();
293	}
294	win_os = osvi.dwPlatformId;
295	win_os_major = osvi.dwMajorVersion;
296	if (win_os != VER_PLATFORM_WIN32_NT \|\| win_os_major < 4) {
297	ErrorAlert(STR_NO_WIN32_NT_4);
298	QuitEmulator();
299	}
300
301	// Check that drivers are installed
302	if (!check_drivers())
303	QuitEmulator();
304
305	// Load win32 libraries
306	KernelInit();
307
308	// FIXME: default to DIB driver
309	if (getenv("SDL_VIDEODRIVER") == NULL)
310	putenv("SDL_VIDEODRIVER=windib");
311
312	// Initialize SDL system
313	int sdl_flags = 0;
314	#ifdef USE_SDL_VIDEO
315	sdl_flags \|= SDL_INIT_VIDEO;
316	#endif
317	#ifdef USE_SDL_AUDIO
318	sdl_flags \|= SDL_INIT_AUDIO;
319	#endif
320	assert(sdl_flags != 0);
321	if (SDL_Init(sdl_flags) == -1) {
322	char str[256];
323	sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
324	ErrorAlert(str);
325	QuitEmulator();
326	}
327	atexit(SDL_Quit);
328
329	// Init system routines
330	SysInit();
331
332	// Show preferences editor
333	if (!PrefsFindBool("nogui"))
334	if (!PrefsEditor())
335	QuitEmulator();
336
337	// Install the handler for SIGSEGV
338	if (!sigsegv_install_handler(sigsegv_handler)) {
339	sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
340	ErrorAlert(str);
341	QuitEmulator();
342	}
343
344	// Register dump state function when we got mad after a segfault
345	sigsegv_set_dump_state(sigsegv_dump_state);
346
347	// Read RAM size
348	RAMSize = PrefsFindInt32("ramsize") & 0xfff00000; // Round down to 1MB boundary
349	if (RAMSize < 1024*1024) {
350	WarningAlert(GetString(STR_SMALL_RAM_WARN));
351	RAMSize = 1024*1024;
352	}
353
354	// Initialize VM system
355	vm_init();
356
357	// Create areas for Mac RAM and ROM
358	#ifdef USE_33BIT_ADDRESSING
359	// Speculatively enables 33-bit addressing
360	ThirtyThreeBitAddressing = true;
361	#endif
362	RAMBaseHost = (uint8 *)vm_acquire_mac(RAMSize);
363	ROMBaseHost = (uint8 *)vm_acquire_mac(0x100000);
364	if (RAMBaseHost == VM_MAP_FAILED \|\| ROMBaseHost == VM_MAP_FAILED) {
365	ErrorAlert(STR_NO_MEM_ERR);
366	QuitEmulator();
367	}
368
369	#if USE_SCRATCHMEM_SUBTERFUGE
370	// Allocate scratch memory
371	ScratchMem = (uint8 *)vm_acquire(SCRATCH_MEM_SIZE);
372	if (ScratchMem == VM_MAP_FAILED) {
373	ErrorAlert(STR_NO_MEM_ERR);
374	QuitEmulator();
375	}
376	ScratchMem += SCRATCH_MEM_SIZE/2; // ScratchMem points to middle of block
377	#endif
378
379	#if DIRECT_ADDRESSING
380	// RAMBaseMac shall always be zero
381	MEMBaseDiff = (uintptr)RAMBaseHost;
382	RAMBaseMac = 0;
383	ROMBaseMac = Host2MacAddr(ROMBaseHost);
384	#endif
385	D(bug("Mac RAM starts at %p (%08x)\n", RAMBaseHost, RAMBaseMac));
386	D(bug("Mac ROM starts at %p (%08x)\n", ROMBaseHost, ROMBaseMac));
387
388	// Get rom file path from preferences
389	const char *rom_path = PrefsFindString("rom");
390
391	// Load Mac ROM
392	HANDLE rom_fh = CreateFile(rom_path ? rom_path : ROM_FILE_NAME,
393	GENERIC_READ,
394	0, NULL,
395	OPEN_EXISTING,
396	FILE_ATTRIBUTE_NORMAL,
397	NULL);
398	if (rom_fh == INVALID_HANDLE_VALUE) {
399	ErrorAlert(STR_NO_ROM_FILE_ERR);
400	QuitEmulator();
401	}
402	printf(GetString(STR_READING_ROM_FILE));
403	ROMSize = GetFileSize(rom_fh, NULL);
404	if (ROMSize != 641024 && ROMSize != 1281024 && ROMSize != 2561024 && ROMSize != 5121024 && ROMSize != 1024*1024) {
405	ErrorAlert(STR_ROM_SIZE_ERR);
406	CloseHandle(rom_fh);
407	QuitEmulator();
408	}
409	DWORD bytes_read;
410	if (ReadFile(rom_fh, ROMBaseHost, ROMSize, &bytes_read, NULL) == 0 \|\| bytes_read != ROMSize) {
411	ErrorAlert(STR_ROM_FILE_READ_ERR);
412	CloseHandle(rom_fh);
413	QuitEmulator();
414	}
415
416	// Initialize native timers
417	timer_init();
418
419	// Initialize everything
420	if (!InitAll())
421	QuitEmulator();
422	D(bug("Initialization complete\n"));
423
424	// SDL threads available, start 60Hz thread
425	tick_thread_active = ((tick_thread = SDL_CreateThread(tick_func, NULL)) != NULL);
426	if (!tick_thread_active) {
427	sprintf(str, GetString(STR_TICK_THREAD_ERR), strerror(errno));
428	ErrorAlert(str);
429	QuitEmulator();
430	}
431	D(bug("60Hz thread started\n"));
432
433	// Start XPRAM watchdog thread
434	memcpy(last_xpram, XPRAM, XPRAM_SIZE);
435	xpram_thread_active = ((xpram_thread = SDL_CreateThread(xpram_func, NULL)) != NULL);
436	D(bug("XPRAM thread started\n"));
437
438	// Start 68k and jump to ROM boot routine
439	D(bug("Starting emulation...\n"));
440	Start680x0();
441
442	QuitEmulator();
443	return 0;
444	}
445
446
447	/*
448	* Quit emulator
449	*/
450
451	void QuitEmulator(void)
452	{
453	D(bug("QuitEmulator\n"));
454
455	// Exit 680x0 emulation
456	Exit680x0();
457
458	// Stop 60Hz thread
459	if (tick_thread_active) {
460	tick_thread_cancel = true;
461	SDL_WaitThread(tick_thread, NULL);
462	}
463
464	// Stop XPRAM watchdog thread
465	if (xpram_thread_active) {
466	xpram_thread_cancel = true;
467	SDL_WaitThread(xpram_thread, NULL);
468	}
469
470	// Deinitialize everything
471	ExitAll();
472
473	// Free ROM/RAM areas
474	if (RAMBaseHost != VM_MAP_FAILED) {
475	vm_release(RAMBaseHost, RAMSize);
476	RAMBaseHost = NULL;
477	}
478	if (ROMBaseHost != VM_MAP_FAILED) {
479	vm_release(ROMBaseHost, 0x100000);
480	ROMBaseHost = NULL;
481	}
482
483	#if USE_SCRATCHMEM_SUBTERFUGE
484	// Delete scratch memory area
485	if (ScratchMem != (uint8 *)VM_MAP_FAILED) {
486	vm_release((void *)(ScratchMem - SCRATCH_MEM_SIZE/2), SCRATCH_MEM_SIZE);
487	ScratchMem = NULL;
488	}
489	#endif
490
491	// Exit VM wrappers
492	vm_exit();
493
494	// Exit system routines
495	SysExit();
496
497	// Exit preferences
498	PrefsExit();
499
500	// Release win32 libraries
501	KernelExit();
502
503	exit(0);
504	}
505
506
507	/*
508	* Code was patched, flush caches if neccessary (i.e. when using a real 680x0
509	* or a dynamically recompiling emulator)
510	*/
511
512	void FlushCodeCache(void *start, uint32 size)
513	{
514	#if USE_JIT
515	if (UseJIT)
516	flush_icache_range((uintptr)start, size);
517	#endif
518	}
519
520
521	/*
522	* Mutexes
523	*/
524
525	struct B2_mutex {
526	B2_mutex() { m = SDL_CreateMutex(); }
527	~B2_mutex() { if (m) SDL_DestroyMutex(m); }
528	SDL_mutex *m;
529	};
530
531	B2_mutex *B2_create_mutex(void)
532	{
533	return new B2_mutex;
534	}
535
536	void B2_lock_mutex(B2_mutex *mutex)
537	{
538	if (mutex)
539	SDL_LockMutex(mutex->m);
540	}
541
542	void B2_unlock_mutex(B2_mutex *mutex)
543	{
544	if (mutex)
545	SDL_UnlockMutex(mutex->m);
546	}
547
548	void B2_delete_mutex(B2_mutex *mutex)
549	{
550	delete mutex;
551	}
552
553
554	/*
555	* Interrupt flags (must be handled atomically!)
556	*/
557
558	uint32 InterruptFlags = 0;
559
560	void SetInterruptFlag(uint32 flag)
561	{
562	LOCK_INTFLAGS;
563	InterruptFlags \|= flag;
564	UNLOCK_INTFLAGS;
565	}
566
567	void ClearInterruptFlag(uint32 flag)
568	{
569	LOCK_INTFLAGS;
570	InterruptFlags &= ~flag;
571	UNLOCK_INTFLAGS;
572	}
573
574
575	/*
576	* XPRAM watchdog thread (saves XPRAM every minute)
577	*/
578
579	static void xpram_watchdog(void)
580	{
581	if (memcmp(last_xpram, XPRAM, XPRAM_SIZE)) {
582	memcpy(last_xpram, XPRAM, XPRAM_SIZE);
583	SaveXPRAM();
584	}
585	}
586
587	static int xpram_func(void *arg)
588	{
589	while (!xpram_thread_cancel) {
590	for (int i=0; i<60 && !xpram_thread_cancel; i++)
591	Delay_usec(999999); // Only wait 1 second so we quit promptly when xpram_thread_cancel becomes true
592	xpram_watchdog();
593	}
594	return 0;
595	}
596
597
598	/*
599	* 60Hz thread (really 60.15Hz)
600	*/
601
602	static void one_second(void)
603	{
604	// Pseudo Mac 1Hz interrupt, update local time
605	WriteMacInt32(0x20c, TimerDateTime());
606
607	SetInterruptFlag(INTFLAG_1HZ);
608	TriggerInterrupt();
609	}
610
611	static void one_tick(...)
612	{
613	static int tick_counter = 0;
614	if (++tick_counter > 60) {
615	tick_counter = 0;
616	one_second();
617	}
618
619	// Trigger 60Hz interrupt
620	if (ROMVersion != ROM_VERSION_CLASSIC \|\| HasMacStarted()) {
621	SetInterruptFlag(INTFLAG_60HZ);
622	TriggerInterrupt();
623	}
624	}
625
626	static int tick_func(void *arg)
627	{
628	uint64 start = GetTicks_usec();
629	int64 ticks = 0;
630	uint64 next = GetTicks_usec();
631	while (!tick_thread_cancel) {
632	one_tick();
633	next += 16625;
634	int64 delay = next - GetTicks_usec();
635	if (delay > 0)
636	Delay_usec(delay);
637	else if (delay < -16625)
638	next = GetTicks_usec();
639	ticks++;
640	}
641	uint64 end = GetTicks_usec();
642	D(bug("%Ld ticks in %Ld usec = %f ticks/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
643	return 0;
644	}
645
646
647	/*
648	* Get the main window handle
649	*/
650
651	#ifdef USE_SDL_VIDEO
652	#include <SDL_syswm.h>
653	static HWND GetMainWindowHandle(void)
654	{
655	SDL_SysWMinfo wmInfo;
656	wmInfo.version.major = SDL_MAJOR_VERSION;
657	wmInfo.version.minor = SDL_MINOR_VERSION;
658	wmInfo.version.patch = SDL_PATCHLEVEL;
659	return SDL_GetWMInfo(&wmInfo) ? wmInfo.window : NULL;
660	}
661	#endif
662
663
664	/*
665	* Display alert
666	*/
667
668	static void display_alert(int title_id, const char *text, int flags)
669	{
670	HWND hMainWnd = GetMainWindowHandle();
671	MessageBox(hMainWnd, text, GetString(title_id), MB_OK \| flags);
672	}
673
674
675	/*
676	* Display error alert
677	*/
678
679	void ErrorAlert(const char *text)
680	{
681	if (PrefsFindBool("nogui"))
682	return;
683
684	VideoQuitFullScreen();
685	display_alert(STR_ERROR_ALERT_TITLE, text, MB_ICONSTOP);
686	}
687
688
689	/*
690	* Display warning alert
691	*/
692
693	void WarningAlert(const char *text)
694	{
695	if (PrefsFindBool("nogui"))
696	return;
697
698	display_alert(STR_WARNING_ALERT_TITLE, text, MB_ICONINFORMATION);
699	}
700
701
702	/*
703	* Display choice alert
704	*/
705
706	bool ChoiceAlert(const char text, const char pos, const char *neg)
707	{
708	printf(GetString(STR_SHELL_WARNING_PREFIX), text);
709	return false; //!!
710	}