--- hatari/src/uae-cpu/memory.c 2019/04/01 07:09:16 1.1.1.1 +++ hatari/src/uae-cpu/memory.c 2019/04/09 08:48:50 1.1.1.14 @@ -1,39 +1,55 @@ /* - * UAE - The Un*x Amiga Emulator + * UAE - The Un*x Amiga Emulator - CPU core * * Memory management * * (c) 1995 Bernd Schmidt + * + * Adaptation to Hatari by Thomas Huth + * + * This file is distributed under the GNU Public License, version 2 or at + * your option any later version. Read the file gpl.txt for details. */ +const char Memory_fileid[] = "Hatari memory.c : " __DATE__ " " __TIME__; -/*#include "sysconfig.h"*/ +#include "config.h" #include "sysdeps.h" #include "hatari-glue.h" #include "maccess.h" #include "memory.h" -#include "../includes/tos.h" -/* -#include "config.h" -#include "options.h" -#include "uae.h" -*/ -#ifdef USE_MAPPED_MEMORY -#include -#endif - -#include "../includes/intercept.h" - -extern unsigned char STRam[16*1024*1024]; /* See hatari.c */ - - -/* Set by each memory handler that does not simply access real memory. */ -int special_mem; - -uae_u32 allocated_STmem; -uae_u32 allocated_TTmem; - -uae_u32 STmem_mask, ROMmem_mask, IOmem_mask, TTmem_mask; +#include "main.h" +#include "tos.h" +#include "ide.h" +#include "ioMem.h" +#include "reset.h" +#include "stMemory.h" +#include "m68000.h" + +#include "newcpu.h" + + +/* Set illegal_mem to 1 for debug output: */ +#define illegal_mem 1 + + +static uae_u32 STmem_size, TTmem_size = 0; +static uae_u32 TTmem_mask; + +#define STmem_start 0x00000000 +#define ROMmem_start 0x00E00000 +#define IdeMem_start 0x00F00000 +#define IOmem_start 0x00FF0000 +#define TTmem_start 0x01000000 + +#define IdeMem_size 65536 +#define IOmem_size 65536 +#define ROMmem_size (0x00FF0000 - 0x00E00000) /* So we cover both possible ROM regions + cartridge */ + +#define STmem_mask 0x00ffffff +#define ROMmem_mask 0x00ffffff +#define IdeMem_mask (IdeMem_size - 1) +#define IOmem_mask (IOmem_size - 1) #ifdef SAVE_MEMORY_BANKS @@ -70,288 +86,464 @@ __inline__ void byteput (uaecptr addr, u #endif +/* Some prototypes: */ +extern void SDL_Quit(void); +static int STmem_check (uaecptr addr, uae_u32 size) REGPARAM; +static uae_u8 *STmem_xlate (uaecptr addr) REGPARAM; + + /* A dummy bank that only contains zeros */ -static uae_u32 dummy_lget (uaecptr) REGPARAM; -static uae_u32 dummy_wget (uaecptr) REGPARAM; -static uae_u32 dummy_bget (uaecptr) REGPARAM; -static void dummy_lput (uaecptr, uae_u32) REGPARAM; -static void dummy_wput (uaecptr, uae_u32) REGPARAM; -static void dummy_bput (uaecptr, uae_u32) REGPARAM; -static int dummy_check (uaecptr addr, uae_u32 size) REGPARAM; +static uae_u32 dummy_lget(uaecptr addr) +{ + if (illegal_mem) + write_log ("Illegal lget at %08lx\n", (long)addr); + + return 0; +} + +static uae_u32 dummy_wget(uaecptr addr) +{ + if (illegal_mem) + write_log ("Illegal wget at %08lx\n", (long)addr); + + return 0; +} + +static uae_u32 dummy_bget(uaecptr addr) +{ + if (illegal_mem) + write_log ("Illegal bget at %08lx\n", (long)addr); + + return 0; +} + +static void dummy_lput(uaecptr addr, uae_u32 l) +{ + if (illegal_mem) + write_log ("Illegal lput at %08lx\n", (long)addr); +} + +static void dummy_wput(uaecptr addr, uae_u32 w) +{ + if (illegal_mem) + write_log ("Illegal wput at %08lx\n", (long)addr); +} + +static void dummy_bput(uaecptr addr, uae_u32 b) +{ + if (illegal_mem) + write_log ("Illegal bput at %08lx\n", (long)addr); +} + +static int dummy_check(uaecptr addr, uae_u32 size) +{ + if (illegal_mem) + write_log ("Illegal check at %08lx\n", (long)addr); + + return 0; +} + +static uae_u8 *dummy_xlate(uaecptr addr) +{ + write_log("Your Atari program just did something terribly stupid:" + " dummy_xlate($%x)\n", addr); + /*Reset_Warm();*/ + return STmem_xlate(addr); /* So we don't crash. */ +} + + +/* **** This memory bank only generates bus errors **** */ -uae_u32 REGPARAM2 dummy_lget (uaecptr addr) +static uae_u32 BusErrMem_lget(uaecptr addr) { - special_mem |= S_READ; if (illegal_mem) - write_log ("Illegal lget at %08lx\n", addr); + write_log ("Bus error lget at %08lx\n", (long)addr); + M68000_BusError(addr, 1); return 0; } -uae_u32 REGPARAM2 dummy_wget (uaecptr addr) +static uae_u32 BusErrMem_wget(uaecptr addr) { - special_mem |= S_READ; if (illegal_mem) - write_log ("Illegal wget at %08lx\n", addr); + write_log ("Bus error wget at %08lx\n", (long)addr); + M68000_BusError(addr, 1); return 0; } -uae_u32 REGPARAM2 dummy_bget (uaecptr addr) +static uae_u32 BusErrMem_bget(uaecptr addr) { - special_mem |= S_READ; if (illegal_mem) - write_log ("Illegal bget at %08lx\n", addr); + write_log ("Bus error bget at %08lx\n", (long)addr); + M68000_BusError(addr, 1); return 0; } -void REGPARAM2 dummy_lput (uaecptr addr, uae_u32 l) +static void BusErrMem_lput(uaecptr addr, uae_u32 l) { - special_mem |= S_WRITE; if (illegal_mem) - write_log ("Illegal lput at %08lx\n", addr); + write_log ("Bus error lput at %08lx\n", (long)addr); + + M68000_BusError(addr, 0); } -void REGPARAM2 dummy_wput (uaecptr addr, uae_u32 w) + +static void BusErrMem_wput(uaecptr addr, uae_u32 w) { - special_mem |= S_WRITE; if (illegal_mem) - write_log ("Illegal wput at %08lx\n", addr); + write_log ("Bus error wput at %08lx\n", (long)addr); + + M68000_BusError(addr, 0); } -void REGPARAM2 dummy_bput (uaecptr addr, uae_u32 b) + +static void BusErrMem_bput(uaecptr addr, uae_u32 b) { - special_mem |= S_WRITE; if (illegal_mem) - write_log ("Illegal bput at %08lx\n", addr); + write_log ("Bus error bput at %08lx\n", (long)addr); + + M68000_BusError(addr, 0); } -int REGPARAM2 dummy_check (uaecptr addr, uae_u32 size) +static int BusErrMem_check(uaecptr addr, uae_u32 size) { if (illegal_mem) - write_log ("Illegal check at %08lx\n", addr); + write_log ("Bus error check at %08lx\n", (long)addr); return 0; } +static uae_u8 *BusErrMem_xlate (uaecptr addr) +{ + write_log("Your Atari program just did something terribly stupid:" + " BusErrMem_xlate($%x)\n", addr); + + /*M68000_BusError(addr);*/ + return STmem_xlate(addr); /* So we don't crash. */ +} -/* ST RAM memory */ -uae_u8 *STmemory; +/* **** ST RAM memory **** */ -static int STmem_check (uaecptr addr, uae_u32 size) REGPARAM; -static uae_u8 *STmem_xlate (uaecptr addr) REGPARAM; +/*static uae_u8 *STmemory;*/ +#define STmemory STRam -uae_u32 REGPARAM2 STmem_lget (uaecptr addr) +static uae_u32 STmem_lget(uaecptr addr) { - uae_u32 *m; + addr -= STmem_start & STmem_mask; + addr &= STmem_mask; + return do_get_mem_long(STmemory + addr); +} +static uae_u32 STmem_wget(uaecptr addr) +{ addr -= STmem_start & STmem_mask; addr &= STmem_mask; - m = (uae_u32 *)(STmemory + addr); - return do_get_mem_long (m); + return do_get_mem_word(STmemory + addr); } -uae_u32 REGPARAM2 STmem_wget (uaecptr addr) +static uae_u32 STmem_bget(uaecptr addr) { - uae_u16 *m; + addr -= STmem_start & STmem_mask; + addr &= STmem_mask; + return STmemory[addr]; +} +static void STmem_lput(uaecptr addr, uae_u32 l) +{ addr -= STmem_start & STmem_mask; addr &= STmem_mask; - m = (uae_u16 *)(STmemory + addr); - return do_get_mem_word (m); + do_put_mem_long(STmemory + addr, l); } -uae_u32 REGPARAM2 STmem_bget (uaecptr addr) +static void STmem_wput(uaecptr addr, uae_u32 w) { addr -= STmem_start & STmem_mask; addr &= STmem_mask; - return STmemory[addr]; + do_put_mem_word(STmemory + addr, w); } -void REGPARAM2 STmem_lput (uaecptr addr, uae_u32 l) +static void STmem_bput(uaecptr addr, uae_u32 b) { - uae_u32 *m; + addr -= STmem_start & STmem_mask; + addr &= STmem_mask; + STmemory[addr] = b; +} +static int STmem_check(uaecptr addr, uae_u32 size) +{ addr -= STmem_start & STmem_mask; addr &= STmem_mask; - m = (uae_u32 *)(STmemory + addr); - do_put_mem_long (m, l); + return (addr + size) <= STmem_size; } -void REGPARAM2 STmem_wput (uaecptr addr, uae_u32 w) +static uae_u8 *STmem_xlate(uaecptr addr) { - uae_u16 *m; + addr -= STmem_start & STmem_mask; + addr &= STmem_mask; + return STmemory + addr; +} + + +/* + * **** ST RAM system memory **** + * We need a separate mem bank for this region since the first 0x800 bytes on + * the ST can only be accessed in supervisor mode. Note that the very first + * 8 bytes of the ST memory are also a mirror of the TOS ROM, so they are write + * protected! + */ +static uae_u32 SysMem_lget(uaecptr addr) +{ + if(addr < 0x800 && !regs.s) + { + M68000_BusError(addr, 1); + return 0; + } addr -= STmem_start & STmem_mask; addr &= STmem_mask; - m = (uae_u16 *)(STmemory + addr); - do_put_mem_word (m, w); + + return do_get_mem_long(STmemory + addr); } -void REGPARAM2 STmem_bput (uaecptr addr, uae_u32 b) +static uae_u32 SysMem_wget(uaecptr addr) { + if(addr < 0x800 && !regs.s) + { + M68000_BusError(addr, 1); + return 0; + } + addr -= STmem_start & STmem_mask; addr &= STmem_mask; - STmemory[addr] = b; + + return do_get_mem_word(STmemory + addr); } -int REGPARAM2 STmem_check (uaecptr addr, uae_u32 size) +static uae_u32 SysMem_bget(uaecptr addr) { + if(addr < 0x800 && !regs.s) + { + M68000_BusError(addr, 1); + return 0; + } + addr -= STmem_start & STmem_mask; addr &= STmem_mask; - return (addr + size) <= allocated_STmem; + return STmemory[addr]; } -uae_u8 REGPARAM2 *STmem_xlate (uaecptr addr) +static void SysMem_lput(uaecptr addr, uae_u32 l) { + if(addr < 0x8 || (addr < 0x800 && !regs.s)) + { + M68000_BusError(addr, 0); + return; + } + addr -= STmem_start & STmem_mask; addr &= STmem_mask; - return STmemory + addr; + + do_put_mem_long(STmemory + addr, l); } +static void SysMem_wput(uaecptr addr, uae_u32 w) +{ + if(addr < 0x8 || (addr < 0x800 && !regs.s)) + { + M68000_BusError(addr, 0); + return; + } -/* TT fast memory */ + addr -= STmem_start & STmem_mask; + addr &= STmem_mask; -static uae_u8 *TTmemory; + do_put_mem_word(STmemory + addr, w); +} -static uae_u32 TTmem_lget (uaecptr) REGPARAM; -static uae_u32 TTmem_wget (uaecptr) REGPARAM; -static uae_u32 TTmem_bget (uaecptr) REGPARAM; -static void TTmem_lput (uaecptr, uae_u32) REGPARAM; -static void TTmem_wput (uaecptr, uae_u32) REGPARAM; -static void TTmem_bput (uaecptr, uae_u32) REGPARAM; -static int TTmem_check (uaecptr addr, uae_u32 size) REGPARAM; -static uae_u8 *TTmem_xlate (uaecptr addr) REGPARAM; +static void SysMem_bput(uaecptr addr, uae_u32 b) +{ + if(addr < 0x8 || (addr < 0x800 && !regs.s)) + { + M68000_BusError(addr, 0); + return; + } -uae_u32 REGPARAM2 TTmem_lget (uaecptr addr) + addr -= STmem_start & STmem_mask; + addr &= STmem_mask; + STmemory[addr] = b; +} + + +/* + * **** Void memory **** + * Between the ST-RAM end and the 4 MB barrier, there is a void memory space: + * Reading always returns the same value and writing does nothing at all. + */ + +static uae_u32 VoidMem_lget(uaecptr addr) +{ + return 0; +} + +static uae_u32 VoidMem_wget(uaecptr addr) +{ + return 0; +} + +static uae_u32 VoidMem_bget(uaecptr addr) +{ + return 0; +} + +static void VoidMem_lput(uaecptr addr, uae_u32 l) +{ +} + +static void VoidMem_wput(uaecptr addr, uae_u32 w) +{ +} + +static void VoidMem_bput (uaecptr addr, uae_u32 b) +{ +} + +static int VoidMem_check(uaecptr addr, uae_u32 size) +{ + if (illegal_mem) + write_log ("Void memory check at %08lx\n", (long)addr); + + return 0; +} + +static uae_u8 *VoidMem_xlate (uaecptr addr) +{ + write_log("Your Atari program just did something terribly stupid:" + " VoidMem_xlate($%x)\n", addr); + + return STmem_xlate(addr); /* So we don't crash. */ +} + + +/* **** TT fast memory (not yet supported) **** */ + +static uae_u8 *TTmemory; + +static uae_u32 TTmem_lget(uaecptr addr) { - uae_u32 *m; addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; - m = (uae_u32 *)(TTmemory + addr); - return do_get_mem_long (m); + return do_get_mem_long(TTmemory + addr); } -uae_u32 REGPARAM2 TTmem_wget (uaecptr addr) +static uae_u32 TTmem_wget(uaecptr addr) { - uae_u16 *m; addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; - m = (uae_u16 *)(TTmemory + addr); - return do_get_mem_word (m); + return do_get_mem_word(TTmemory + addr); } -uae_u32 REGPARAM2 TTmem_bget (uaecptr addr) +static uae_u32 TTmem_bget(uaecptr addr) { addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; return TTmemory[addr]; } -void REGPARAM2 TTmem_lput (uaecptr addr, uae_u32 l) +static void TTmem_lput(uaecptr addr, uae_u32 l) { - uae_u32 *m; addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; - m = (uae_u32 *)(TTmemory + addr); - do_put_mem_long (m, l); + do_put_mem_long(TTmemory + addr, l); } -void REGPARAM2 TTmem_wput (uaecptr addr, uae_u32 w) +static void TTmem_wput(uaecptr addr, uae_u32 w) { - uae_u16 *m; addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; - m = (uae_u16 *)(TTmemory + addr); - do_put_mem_word (m, w); + do_put_mem_word(TTmemory + addr, w); } -void REGPARAM2 TTmem_bput (uaecptr addr, uae_u32 b) +static void TTmem_bput(uaecptr addr, uae_u32 b) { addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; TTmemory[addr] = b; } -int REGPARAM2 TTmem_check (uaecptr addr, uae_u32 size) +static int TTmem_check(uaecptr addr, uae_u32 size) { addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; - return (addr + size) <= allocated_TTmem; + return (addr + size) <= TTmem_size; } -uae_u8 REGPARAM2 *TTmem_xlate(uaecptr addr) +static uae_u8 *TTmem_xlate(uaecptr addr) { addr -= TTmem_start & TTmem_mask; addr &= TTmem_mask; return TTmemory + addr; } -/* ROM memory */ -uae_u8 *ROMmemory; +/* **** ROM memory **** */ -static uae_u32 ROMmem_lget (uaecptr) REGPARAM; -static uae_u32 ROMmem_wget (uaecptr) REGPARAM; -static uae_u32 ROMmem_bget (uaecptr) REGPARAM; -static void ROMmem_lput (uaecptr, uae_u32) REGPARAM; -static void ROMmem_wput (uaecptr, uae_u32) REGPARAM; -static void ROMmem_bput (uaecptr, uae_u32) REGPARAM; -static int ROMmem_check (uaecptr addr, uae_u32 size) REGPARAM; -static uae_u8 *ROMmem_xlate (uaecptr addr) REGPARAM; +uae_u8 *ROMmemory; -uae_u32 REGPARAM2 ROMmem_lget (uaecptr addr) +static uae_u32 ROMmem_lget(uaecptr addr) { - uae_u32 *m; addr -= ROMmem_start & ROMmem_mask; addr &= ROMmem_mask; - m = (uae_u32 *)(ROMmemory + addr); - return do_get_mem_long (m); + return do_get_mem_long(ROMmemory + addr); } -uae_u32 REGPARAM2 ROMmem_wget (uaecptr addr) +static uae_u32 ROMmem_wget(uaecptr addr) { - uae_u16 *m; addr -= ROMmem_start & ROMmem_mask; addr &= ROMmem_mask; - m = (uae_u16 *)(ROMmemory + addr); - return do_get_mem_word (m); + return do_get_mem_word(ROMmemory + addr); } -uae_u32 REGPARAM2 ROMmem_bget (uaecptr addr) +static uae_u32 ROMmem_bget(uaecptr addr) { addr -= ROMmem_start & ROMmem_mask; addr &= ROMmem_mask; return ROMmemory[addr]; } -void REGPARAM2 ROMmem_lput (uaecptr addr, uae_u32 b) +static void ROMmem_lput(uaecptr addr, uae_u32 b) { if (illegal_mem) - write_log ("Illegal ROMmem lput at %08lx\n", addr); + write_log ("Illegal ROMmem lput at %08lx\n", (long)addr); + + M68000_BusError(addr, 0); } -void REGPARAM2 ROMmem_wput (uaecptr addr, uae_u32 b) +static void ROMmem_wput(uaecptr addr, uae_u32 b) { if (illegal_mem) - write_log ("Illegal ROMmem wput at %08lx\n", addr); + write_log ("Illegal ROMmem wput at %08lx\n", (long)addr); + + M68000_BusError(addr, 0); } -void REGPARAM2 ROMmem_bput (uaecptr addr, uae_u32 b) +static void ROMmem_bput(uaecptr addr, uae_u32 b) { if (illegal_mem) - write_log ("Illegal ROMmem lput at %08lx\n", addr); + write_log ("Illegal ROMmem bput at %08lx\n", (long)addr); + + M68000_BusError(addr, 0); } -int REGPARAM2 ROMmem_check (uaecptr addr, uae_u32 size) +static int ROMmem_check(uaecptr addr, uae_u32 size) { addr -= ROMmem_start & ROMmem_mask; addr &= ROMmem_mask; return (addr + size) <= ROMmem_size; } -uae_u8 REGPARAM2 *ROMmem_xlate (uaecptr addr) +static uae_u8 *ROMmem_xlate(uaecptr addr) { addr -= ROMmem_start & ROMmem_mask; addr &= ROMmem_mask; @@ -359,80 +551,113 @@ uae_u8 REGPARAM2 *ROMmem_xlate (uaecptr } -/* Hardware IO memory */ -/* see also intercept.c */ +/* IDE controller IO memory */ +/* see also ide.c */ -uae_u8 *IOmemory; - -static int IOmem_check (uaecptr addr, uae_u32 size) REGPARAM; -static uae_u8 *IOmem_xlate (uaecptr addr) REGPARAM; +static uae_u8 *IdeMemory; -int REGPARAM2 IOmem_check (uaecptr addr, uae_u32 size) +static int IdeMem_check(uaecptr addr, uae_u32 size) { - addr -= IOmem_start & IOmem_mask; - addr &= IOmem_mask; - return (addr + size) <= IOmem_size; + addr -= IdeMem_start; + addr &= IdeMem_mask; + return (addr + size) <= IdeMem_size; } -uae_u8 REGPARAM2 *IOmem_xlate (uaecptr addr) +static uae_u8 *IdeMem_xlate(uaecptr addr) { - addr -= IOmem_start & IOmem_mask; - addr &= IOmem_mask; - return IOmemory + addr; + addr -= IdeMem_start; + addr &= IdeMem_mask; + return IdeMemory + addr; } +/* Hardware IO memory */ +/* see also ioMem.c */ -/* Default memory access functions */ +uae_u8 *IOmemory; -int REGPARAM2 default_check (uaecptr a, uae_u32 b) +static int IOmem_check(uaecptr addr, uae_u32 size) { - return 0; + addr -= IOmem_start; + addr &= IOmem_mask; + return (addr + size) <= IOmem_size; } -uae_u8 REGPARAM2 *default_xlate (uaecptr a) +static uae_u8 *IOmem_xlate(uaecptr addr) { - write_log ("Your Atari program just did something terribly stupid\n"); - Reset_Warm(); - return ROMmem_xlate (get_long (0xFC0000)); /* So we don't crash. */ + addr -= IOmem_start; + addr &= IOmem_mask; + return IOmemory + addr; } -/* Address banks */ -addrbank dummy_bank = { +/* **** Address banks **** */ + +static addrbank dummy_bank = +{ dummy_lget, dummy_wget, dummy_bget, dummy_lput, dummy_wput, dummy_bput, - default_xlate, dummy_check + dummy_xlate, dummy_check +}; + +static addrbank BusErrMem_bank = +{ + BusErrMem_lget, BusErrMem_wget, BusErrMem_bget, + BusErrMem_lput, BusErrMem_wput, BusErrMem_bput, + BusErrMem_xlate, BusErrMem_check }; -addrbank STmem_bank = { +static addrbank STmem_bank = +{ STmem_lget, STmem_wget, STmem_bget, STmem_lput, STmem_wput, STmem_bput, STmem_xlate, STmem_check }; -addrbank TTmem_bank = { +static addrbank SysMem_bank = +{ + SysMem_lget, SysMem_wget, SysMem_bget, + SysMem_lput, SysMem_wput, SysMem_bput, + STmem_xlate, STmem_check +}; + +static addrbank VoidMem_bank = +{ + VoidMem_lget, VoidMem_wget, VoidMem_bget, + VoidMem_lput, VoidMem_wput, VoidMem_bput, + VoidMem_xlate, VoidMem_check +}; + +static addrbank TTmem_bank = +{ TTmem_lget, TTmem_wget, TTmem_bget, TTmem_lput, TTmem_wput, TTmem_bput, TTmem_xlate, TTmem_check }; -addrbank ROMmem_bank = { +static addrbank ROMmem_bank = +{ ROMmem_lget, ROMmem_wget, ROMmem_bget, ROMmem_lput, ROMmem_wput, ROMmem_bput, ROMmem_xlate, ROMmem_check }; -addrbank IOmem_bank = { - Intercept_ReadLong, Intercept_ReadWord, Intercept_ReadByte, - Intercept_WriteLong, Intercept_WriteWord, Intercept_WriteByte, +static addrbank IdeMem_bank = +{ + Ide_Mem_lget, Ide_Mem_wget, Ide_Mem_bget, + Ide_Mem_lput, Ide_Mem_wput, Ide_Mem_bput, + IdeMem_xlate, IdeMem_check +}; + +static addrbank IOmem_bank = +{ + IoMem_lget, IoMem_wget, IoMem_bget, + IoMem_lput, IoMem_wput, IoMem_bput, IOmem_xlate, IOmem_check }; -char *address_space, *good_address_map; -int good_address_fd; static void init_mem_banks (void) { @@ -441,108 +666,132 @@ static void init_mem_banks (void) put_mem_bank (i<<16, &dummy_bank); } -#define MAKE_USER_PROGRAMS_BEHAVE 1 -void memory_init (void) -{ - char buffer[4096]; - char *nam; - int i, fd; - /*int custom_start;*/ - - allocated_STmem = STmem_size; - allocated_TTmem = TTmem_size; - -#ifdef USE_MAPPED_MEMORY -#error So nicht - fd = open ("/dev/zero", O_RDWR); - good_address_map = mmap (NULL, 1 << 24, PROT_READ, MAP_PRIVATE, fd, 0); - /* Don't believe USER_PROGRAMS_BEHAVE. Otherwise, we'd segfault as soon - * as a decrunch routine tries to do color register hacks. */ - address_space = mmap (NULL, 1 << 24, PROT_READ | (USER_PROGRAMS_BEHAVE || MAKE_USER_PROGRAMS_BEHAVE? PROT_WRITE : 0), MAP_PRIVATE, fd, 0); - if ((int)address_space < 0 || (int)good_address_map < 0) { - write_log ("Your system does not have enough virtual memory - increase swap.\n"); - abort (); - } -#ifdef MAKE_USER_PROGRAMS_BEHAVE - memset (address_space + 0xDFF180, 0xFF, 32*2); -#else - /* Likewise. This is mostly for mouse button checks. */ - if (USER_PROGRAMS_BEHAVE) - memset (address_space + 0xA00000, 0xFF, 0xF00000 - 0xA00000); -#endif - STmemory = mmap (address_space, 0x200000, PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0); - ROMmemory = mmap (address_space + TOSAddress, ROMmem_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, fd, 0); - - close(fd); - good_address_fd = open (nam = tmpnam (NULL), O_CREAT|O_RDWR, 0600); - memset (buffer, 1, sizeof(buffer)); - write (good_address_fd, buffer, sizeof buffer); - unlink (nam); - - for (i = 0; i < allocated_STmem; i += 4096) - mmap (good_address_map + i, 4096, PROT_READ, MAP_FIXED | MAP_PRIVATE, - good_address_fd, 0); - for (i = 0; i < ROMmem_size; i += 4096) - mmap (good_address_map + i + 0x1000000 - ROMmem_size, 4096, PROT_READ, - MAP_FIXED | MAP_PRIVATE, good_address_fd, 0); -#else - ROMmemory = STRam+TOSAddress; /*(uae_u8 *)malloc (ROMmem_size)*/; - STmemory = STRam; /*(uae_u8 *)malloc (allocated_STmem);*/ /* - while (! STmemory && allocated_STmem > 512*1024) { - allocated_STmem >>= 1; - STmemory = (uae_u8 *)malloc (allocated_STmem); + * Initialize the memory banks + */ +void memory_init(uae_u32 nNewSTMemSize, uae_u32 nNewTTMemSize, uae_u32 nNewRomMemStart) +{ + STmem_size = (nNewSTMemSize + 65535) & 0xFFFF0000; + TTmem_size = (nNewTTMemSize + 65535) & 0xFFFF0000; + + /*write_log("memory_init: STmem_size=$%x, TTmem_size=$%x, ROM-Start=$%x,\n", + STmem_size, TTmem_size, nNewRomMemStart);*/ + +#if ENABLE_SMALL_MEM + + /* Allocate memory for ROM areas and IO memory space (0xE00000 - 0xFFFFFF) */ + ROMmemory = malloc(2*1024*1024); + if (!ROMmemory) { + fprintf(stderr, "Out of memory (ROM/IO mem)!\n"); + SDL_Quit(); + exit(1); + } + IdeMemory = ROMmemory + 0x100000; + IOmemory = ROMmemory + 0x1f0000; + + /* Allocate memory for normal ST RAM */ + STmemory = malloc(STmem_size); + while (!STmemory && STmem_size > 512*1024) { + STmem_size >>= 1; + STmemory = (uae_u8 *)malloc (STmem_size); if (STmemory) - fprintf (stderr, "Reducing STmem size to %dkb\n", allocated_STmem >> 10); + write_log ("Reducing STmem size to %dkb\n", STmem_size >> 10); } - if (! STmemory) { + if (!STmemory) { write_log ("virtual memory exhausted (STmemory)!\n"); - abort (); + SDL_Quit(); + exit(1); } -*/ -#endif - do_put_mem_long ((uae_u32 *)(STmemory), do_get_mem_long((uae_u32 *)ROMmemory)); - do_put_mem_long ((uae_u32 *)(STmemory + 4), do_get_mem_long((uae_u32 *)(ROMmemory+4))); - init_mem_banks (); +#else - /* Map the STmem into all of the lower 16MB */ - map_banks (&STmem_bank, 0x00, 256); -/* - custom_start = 0xC0; - map_banks (&custom_bank, custom_start, 0xE0-custom_start); - map_banks (&cia_bank, 0xA0, 32); - map_banks (&clock_bank, 0xDC, 1); -*/ - /* @@@ Does anyone have a clue what should be in the 0x200000 - 0xA00000 - * range on an Amiga without expansion memory? */ -/* - custom_start = allocated_STmem >> 16; - if (custom_start < 0x20) - custom_start = 0x20; - map_banks (&dummy_bank, custom_start, 0xA0 - custom_start); -*/ - /*map_banks (&TTram_bank, 0xDE, 1);*/ + /* STmemory points to the 16 MiB STRam array, we just have to set up + * the remaining pointers here: */ + ROMmemory = STRam + ROMmem_start; + IdeMemory = STRam + IdeMem_start; + IOmemory = STRam + IOmem_start; + +#endif + + init_mem_banks(); - if (allocated_TTmem > 0) - TTmemory = (uae_u8 *)malloc (allocated_TTmem); + /* Map the ST system RAM: */ + map_banks(&SysMem_bank, 0x00, 1); + /* Between STRamEnd and 4MB barrier, there is void space: */ + map_banks(&VoidMem_bank, 0x08, 0x38); + /* Space between 4MB barrier and TOS ROM causes a bus error: */ + map_banks(&BusErrMem_bank, 0x400000 >> 16, 0xA0); + /* Now map main ST RAM, overwriting the void and bus error regions if necessary: */ + map_banks(&STmem_bank, 0x01, (STmem_size >> 16) - 1); + + /* TT memory isn't really supported yet */ + if (TTmem_size > 0) + TTmemory = (uae_u8 *)malloc (TTmem_size); if (TTmemory != 0) - map_banks (&TTmem_bank, TTmem_start >> 16, allocated_TTmem >> 16); + map_banks (&TTmem_bank, TTmem_start >> 16, TTmem_size >> 16); else - allocated_TTmem = 0; + TTmem_size = 0; + TTmem_mask = TTmem_size - 1; + + /* ROM memory: */ + /* Depending on which ROM version we are using, the other ROM region is illegal! */ + if(nNewRomMemStart == 0xFC0000) + { + map_banks(&ROMmem_bank, 0xFC0000 >> 16, 0x3); + map_banks(&BusErrMem_bank, 0xE00000 >> 16, 0x10); + } + else if(nNewRomMemStart == 0xE00000) + { + map_banks(&ROMmem_bank, 0xE00000 >> 16, 0x10); + map_banks(&BusErrMem_bank, 0xFC0000 >> 16, 0x3); + } + else + { + write_log("Illegal ROM memory start!\n"); + } - map_banks(&ROMmem_bank, ROMmem_start >> 16, ROMmem_size/65536); -/* map_banks(&ROMmem_bank, 0xFFFC, 4);*/ + /* Cartridge memory: */ + map_banks(&ROMmem_bank, 0xFA0000 >> 16, 0x2); - map_banks(&IOmem_bank, IOmem_start>>16, 1); + /* IO memory: */ + map_banks(&IOmem_bank, IOmem_start>>16, 0x1); - STmem_mask = 0x00ffffff /*allocated_STmem- 1*/; - ROMmem_mask = 0x00ffffff /*ROMmem_size - 1*/; - TTmem_mask = allocated_TTmem - 1; - IOmem_mask = IOmem_size - 1; + /* IDE controller memory region: */ + map_banks(&IdeMem_bank, IdeMem_start >> 16, 0x1); /* IDE controller on the Falcon */ + + /* Illegal memory regions cause a bus error on the ST: */ + map_banks(&BusErrMem_bank, 0xF10000 >> 16, 0x9); } + +/* + * Uninitialize the memory banks. + */ +void memory_uninit (void) +{ + /* Here, we free allocated memory from memory_init */ + if (TTmem_size > 0) { + free(TTmemory); + TTmemory = NULL; + } + +#if ENABLE_SMALL_MEM + + if (STmemory) { + free(STmemory); + STmemory = NULL; + } + + if (ROMmemory) { + free(ROMmemory); + ROMmemory = NULL; + } + +#endif /* ENABLE_SMALL_MEM */ +} + + void map_banks (addrbank *bank, int start, int size) { int bnr; @@ -554,7 +803,7 @@ void map_banks (addrbank *bank, int star return; } /* Some ROMs apparently require a 24 bit address space... */ - if (address_space_24) + if (currprefs.address_space_24) endhioffs = 0x10000; for (hioffs = 0; hioffs < endhioffs; hioffs += 0x100) for (bnr = start; bnr < start+size; bnr++)