--- uae/src/expansion.c 2018/04/24 16:39:56 1.1.1.3 +++ uae/src/expansion.c 2018/04/24 17:16:30 1.1.1.12 @@ -1,4 +1,4 @@ - /* + /* * UAE - The Un*x Amiga Emulator * * AutoConfig (tm) Expansions (ZorroII/III) @@ -12,12 +12,12 @@ #include "sysconfig.h" #include "sysdeps.h" -#include "config.h" #include "options.h" #include "uae.h" #include "memory.h" #include "autoconf.h" #include "picasso96.h" +#include "savestate.h" #define MAX_EXPANSION_BOARDS 8 @@ -133,7 +133,7 @@ static int ecard = 0; /* Please note: ZorroIII implementation seems to work different * than described in the HRM. This claims that ZorroIII config * address is 0xff000000 while the ZorroII config space starts - * at 0x00e80000. In reality, both, Z2 and Z3 cards are + * at 0x00e80000. In reality, both, Z2 and Z3 cards are * configured in the ZorroII config space. Kickstart 3.1 doesn't * even do a single read or write access to the ZorroIII space. * The original Amiga include files tell the same as the HRM. @@ -142,7 +142,7 @@ static int ecard = 0; * to a ZorroIII card on a real Amiga. This is not implemented * yet. * -- Stefan - * + * * Surprising that 0xFF000000 isn't used. Maybe it depends on the * ROM. Anyway, the HRM says that Z3 cards may appear in Z2 config * space, so what we are doing here is correct. @@ -161,50 +161,56 @@ static uae_u16 expamem_hi; static void expamem_map_clear (void) { - fprintf (stderr, "expamem_map_clear() got called. Shouldn't happen.\n"); + write_log ("expamem_map_clear() got called. Shouldn't happen.\n"); } static void expamem_init_clear (void) { memset (expamem, 0xff, sizeof expamem); } +static void expamem_init_clear2 (void) +{ + expamem_init_clear(); + ecard = MAX_EXPANSION_BOARDS - 1; +} -static uae_u32 expamem_lget(uaecptr) REGPARAM; -static uae_u32 expamem_wget(uaecptr) REGPARAM; -static uae_u32 expamem_bget(uaecptr) REGPARAM; -static void expamem_lput(uaecptr, uae_u32) REGPARAM; -static void expamem_wput(uaecptr, uae_u32) REGPARAM; -static void expamem_bput(uaecptr, uae_u32) REGPARAM; +static uae_u32 expamem_lget (uaecptr) REGPARAM; +static uae_u32 expamem_wget (uaecptr) REGPARAM; +static uae_u32 expamem_bget (uaecptr) REGPARAM; +static void expamem_lput (uaecptr, uae_u32) REGPARAM; +static void expamem_wput (uaecptr, uae_u32) REGPARAM; +static void expamem_bput (uaecptr, uae_u32) REGPARAM; addrbank expamem_bank = { expamem_lget, expamem_wget, expamem_bget, expamem_lput, expamem_wput, expamem_bput, - default_xlate, default_check + default_xlate, default_check, NULL }; -static uae_u32 REGPARAM2 expamem_lget(uaecptr addr) +static uae_u32 REGPARAM2 expamem_lget (uaecptr addr) { - sprintf (warning_buffer, "warning: READ.L from address $%lx \n", addr); - write_log (warning_buffer); + special_mem |= S_READ; + write_log ("warning: READ.L from address $%lx \n", addr); return 0xfffffffful; } -static uae_u32 REGPARAM2 expamem_wget(uaecptr addr) +static uae_u32 REGPARAM2 expamem_wget (uaecptr addr) { - sprintf (warning_buffer, "warning: READ.W from address $%lx \n", addr); - write_log (warning_buffer); + special_mem |= S_READ; + write_log ("warning: READ.W from address $%lx \n", addr); return 0xffff; } -static uae_u32 REGPARAM2 expamem_bget(uaecptr addr) +static uae_u32 REGPARAM2 expamem_bget (uaecptr addr) { - uae_u8 value; + special_mem |= S_READ; addr &= 0xFFFF; return expamem[addr]; } static void REGPARAM2 expamem_write (uaecptr addr, uae_u32 value) { + special_mem |= S_WRITE; addr &= 0xffff; if (addr == 00 || addr == 02 || addr == 0x40 || addr == 0x42) { expamem[addr] = (value & 0xf0); @@ -215,45 +221,43 @@ static void REGPARAM2 expamem_write (uae } } -static int REGPARAM2 expamem_type(void) +static int REGPARAM2 expamem_type (void) { return ((expamem[0] | expamem[2] >> 4) & 0xc0); } -static void REGPARAM2 expamem_lput(uaecptr addr, uae_u32 value) +static void REGPARAM2 expamem_lput (uaecptr addr, uae_u32 value) { - fprintf (stderr, "warning: WRITE.L to address $%lx : value $%lx\n", addr, value); + special_mem |= S_WRITE; + write_log ("warning: WRITE.L to address $%lx : value $%lx\n", addr, value); } -static void REGPARAM2 expamem_wput(uaecptr addr, uae_u32 value) +static void REGPARAM2 expamem_wput (uaecptr addr, uae_u32 value) { - static char buffer[80]; - + special_mem |= S_WRITE; if (expamem_type() != zorroIII) - fprintf (stderr, "warning: WRITE.W to address $%lx : value $%x\n", addr, value); + write_log ("warning: WRITE.W to address $%lx : value $%x\n", addr, value); else { switch (addr & 0xff) { case 0x44: if (expamem_type() == zorroIII) { expamem_hi = value; (*card_map[ecard]) (); - sprintf (buffer, " Card %d (Zorro%s) done.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III"); - write_log (buffer); + write_log (" Card %d (Zorro%s) done.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III"); ++ecard; - if (ecard <= MAX_EXPANSION_BOARDS) + if (ecard < MAX_EXPANSION_BOARDS) (*card_init[ecard]) (); else - expamem_init_clear (); + expamem_init_clear2 (); } break; } } } -static void REGPARAM2 expamem_bput(uaecptr addr, uae_u32 value) +static void REGPARAM2 expamem_bput (uaecptr addr, uae_u32 value) { - static char buffer[80]; - + special_mem |= S_WRITE; switch (addr & 0xff) { case 0x30: case 0x32: @@ -266,13 +270,12 @@ static void REGPARAM2 expamem_bput(uaecp if (expamem_type () == zorroII) { expamem_hi = value & 0xFF; (*card_map[ecard]) (); - sprintf (buffer, " Card %d (Zorro%s) done.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III"); - write_log (buffer); + write_log (" Card %d (Zorro%s) done.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III"); ++ecard; - if (ecard <= MAX_EXPANSION_BOARDS) + if (ecard < MAX_EXPANSION_BOARDS) (*card_init[ecard]) (); else - expamem_init_clear (); + expamem_init_clear2 (); } else if (expamem_type() == zorroIII) expamem_lo = value; break; @@ -283,13 +286,12 @@ static void REGPARAM2 expamem_bput(uaecp break; case 0x4c: - sprintf (buffer, " Card %d (Zorro %s) had no success.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III"); - write_log (buffer); + write_log (" Card %d (Zorro %s) had no success.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III"); ++ecard; - if (ecard <= MAX_EXPANSION_BOARDS) + if (ecard < MAX_EXPANSION_BOARDS) (*card_init[ecard]) (); else - expamem_init_clear (); + expamem_init_clear2 (); break; } } @@ -302,19 +304,19 @@ static void REGPARAM2 expamem_bput(uaecp static uae_u32 fastmem_mask; -static uae_u32 fastmem_lget(uaecptr) REGPARAM; -static uae_u32 fastmem_wget(uaecptr) REGPARAM; -static uae_u32 fastmem_bget(uaecptr) REGPARAM; -static void fastmem_lput(uaecptr, uae_u32) REGPARAM; -static void fastmem_wput(uaecptr, uae_u32) REGPARAM; -static void fastmem_bput(uaecptr, uae_u32) REGPARAM; -static int fastmem_check(uaecptr addr, uae_u32 size) REGPARAM; -static uae_u8 *fastmem_xlate(uaecptr addr) REGPARAM; +static uae_u32 fastmem_lget (uaecptr) REGPARAM; +static uae_u32 fastmem_wget (uaecptr) REGPARAM; +static uae_u32 fastmem_bget (uaecptr) REGPARAM; +static void fastmem_lput (uaecptr, uae_u32) REGPARAM; +static void fastmem_wput (uaecptr, uae_u32) REGPARAM; +static void fastmem_bput (uaecptr, uae_u32) REGPARAM; +static int fastmem_check (uaecptr addr, uae_u32 size) REGPARAM; +static uae_u8 *fastmem_xlate (uaecptr addr) REGPARAM; static uae_u32 fastmem_start; /* Determined by the OS */ static uae_u8 *fastmemory = NULL; -uae_u32 REGPARAM2 fastmem_lget(uaecptr addr) +uae_u32 REGPARAM2 fastmem_lget (uaecptr addr) { uae_u8 *m; addr -= fastmem_start & fastmem_mask; @@ -323,7 +325,7 @@ uae_u32 REGPARAM2 fastmem_lget(uaecptr a return do_get_mem_long ((uae_u32 *)m); } -uae_u32 REGPARAM2 fastmem_wget(uaecptr addr) +uae_u32 REGPARAM2 fastmem_wget (uaecptr addr) { uae_u8 *m; addr -= fastmem_start & fastmem_mask; @@ -332,14 +334,14 @@ uae_u32 REGPARAM2 fastmem_wget(uaecptr a return do_get_mem_word ((uae_u16 *)m); } -uae_u32 REGPARAM2 fastmem_bget(uaecptr addr) +uae_u32 REGPARAM2 fastmem_bget (uaecptr addr) { addr -= fastmem_start & fastmem_mask; addr &= fastmem_mask; return fastmemory[addr]; } -void REGPARAM2 fastmem_lput(uaecptr addr, uae_u32 l) +void REGPARAM2 fastmem_lput (uaecptr addr, uae_u32 l) { uae_u8 *m; addr -= fastmem_start & fastmem_mask; @@ -348,7 +350,7 @@ void REGPARAM2 fastmem_lput(uaecptr addr do_put_mem_long ((uae_u32 *)m, l); } -void REGPARAM2 fastmem_wput(uaecptr addr, uae_u32 w) +void REGPARAM2 fastmem_wput (uaecptr addr, uae_u32 w) { uae_u8 *m; addr -= fastmem_start & fastmem_mask; @@ -357,21 +359,21 @@ void REGPARAM2 fastmem_wput(uaecptr addr do_put_mem_word ((uae_u16 *)m, w); } -void REGPARAM2 fastmem_bput(uaecptr addr, uae_u32 b) +void REGPARAM2 fastmem_bput (uaecptr addr, uae_u32 b) { addr -= fastmem_start & fastmem_mask; addr &= fastmem_mask; fastmemory[addr] = b; } -static int REGPARAM2 fastmem_check(uaecptr addr, uae_u32 size) +static int REGPARAM2 fastmem_check (uaecptr addr, uae_u32 size) { addr -= fastmem_start & fastmem_mask; addr &= fastmem_mask; - return (addr + size) < fastmem_size; + return (addr + size) <= allocated_fastmem; } -static uae_u8 REGPARAM2 *fastmem_xlate(uaecptr addr) +static uae_u8 REGPARAM2 *fastmem_xlate (uaecptr addr) { addr -= fastmem_start & fastmem_mask; addr &= fastmem_mask; @@ -381,7 +383,7 @@ static uae_u8 REGPARAM2 *fastmem_xlate(u addrbank fastmem_bank = { fastmem_lget, fastmem_wget, fastmem_bget, fastmem_lput, fastmem_wput, fastmem_bput, - fastmem_xlate, fastmem_check + fastmem_xlate, fastmem_check, NULL }; @@ -390,65 +392,71 @@ addrbank fastmem_bank = { * This is very simple, the Amiga shouldn't be doing things with it. */ -static uae_u32 filesys_lget(uaecptr) REGPARAM; -static uae_u32 filesys_wget(uaecptr) REGPARAM; -static uae_u32 filesys_bget(uaecptr) REGPARAM; -static void filesys_lput(uaecptr, uae_u32) REGPARAM; -static void filesys_wput(uaecptr, uae_u32) REGPARAM; -static void filesys_bput(uaecptr, uae_u32) REGPARAM; +static uae_u32 filesys_lget (uaecptr) REGPARAM; +static uae_u32 filesys_wget (uaecptr) REGPARAM; +static uae_u32 filesys_bget (uaecptr) REGPARAM; +static void filesys_lput (uaecptr, uae_u32) REGPARAM; +static void filesys_wput (uaecptr, uae_u32) REGPARAM; +static void filesys_bput (uaecptr, uae_u32) REGPARAM; static uae_u32 filesys_start; /* Determined by the OS */ -uae_u8 filesysory[65536]; +uae_u8 *filesysory; -uae_u32 REGPARAM2 filesys_lget(uaecptr addr) +uae_u32 REGPARAM2 filesys_lget (uaecptr addr) { uae_u8 *m; + special_mem |= S_READ; addr -= filesys_start & 65535; addr &= 65535; m = filesysory + addr; return do_get_mem_long ((uae_u32 *)m); } -uae_u32 REGPARAM2 filesys_wget(uaecptr addr) +uae_u32 REGPARAM2 filesys_wget (uaecptr addr) { uae_u8 *m; + special_mem |= S_READ; addr -= filesys_start & 65535; addr &= 65535; m = filesysory + addr; return do_get_mem_word ((uae_u16 *)m); } -uae_u32 REGPARAM2 filesys_bget(uaecptr addr) +uae_u32 REGPARAM2 filesys_bget (uaecptr addr) { + special_mem |= S_READ; addr -= filesys_start & 65535; addr &= 65535; return filesysory[addr]; } -static void REGPARAM2 filesys_lput(uaecptr addr, uae_u32 l) +static void REGPARAM2 filesys_lput (uaecptr addr, uae_u32 l) { + special_mem |= S_WRITE; write_log ("filesys_lput called\n"); } -static void REGPARAM2 filesys_wput(uaecptr addr, uae_u32 w) +static void REGPARAM2 filesys_wput (uaecptr addr, uae_u32 w) { + special_mem |= S_WRITE; write_log ("filesys_wput called\n"); } -static void REGPARAM2 filesys_bput(uaecptr addr, uae_u32 b) +static void REGPARAM2 filesys_bput (uaecptr addr, uae_u32 b) { - fprintf (stderr, "filesys_bput called. This usually means that you are using\n"); - fprintf (stderr, "Kickstart 1.2. Please give UAE the \"-a\" option next time\n"); - fprintf (stderr, "you start it. If you are _not_ using Kickstart 1.2, then\n"); - fprintf (stderr, "there's a bug somewhere.\n"); - fprintf (stderr, "Exiting...\n"); + special_mem |= S_WRITE; + write_log ("filesys_bput called. This usually means that you are using\n"); + write_log ("Kickstart 1.2. Please give UAE the \"-a\" option next time\n"); + write_log ("you start it. If you are _not_ using Kickstart 1.2, then\n"); + write_log ("there's a bug somewhere.\n"); + write_log ("Exiting...\n"); uae_quit (); } addrbank filesys_bank = { filesys_lget, filesys_wget, filesys_bget, filesys_lput, filesys_wput, filesys_bput, - default_xlate, default_check + default_xlate, default_check, NULL }; /* @@ -458,19 +466,19 @@ addrbank filesys_bank = { static uae_u32 z3fastmem_mask; -static uae_u32 z3fastmem_lget(uaecptr) REGPARAM; -static uae_u32 z3fastmem_wget(uaecptr) REGPARAM; -static uae_u32 z3fastmem_bget(uaecptr) REGPARAM; -static void z3fastmem_lput(uaecptr, uae_u32) REGPARAM; -static void z3fastmem_wput(uaecptr, uae_u32) REGPARAM; -static void z3fastmem_bput(uaecptr, uae_u32) REGPARAM; -static int z3fastmem_check(uaecptr addr, uae_u32 size) REGPARAM; -static uae_u8 *z3fastmem_xlate(uaecptr addr) REGPARAM; +static uae_u32 z3fastmem_lget (uaecptr) REGPARAM; +static uae_u32 z3fastmem_wget (uaecptr) REGPARAM; +static uae_u32 z3fastmem_bget (uaecptr) REGPARAM; +static void z3fastmem_lput (uaecptr, uae_u32) REGPARAM; +static void z3fastmem_wput (uaecptr, uae_u32) REGPARAM; +static void z3fastmem_bput (uaecptr, uae_u32) REGPARAM; +static int z3fastmem_check (uaecptr addr, uae_u32 size) REGPARAM; +static uae_u8 *z3fastmem_xlate (uaecptr addr) REGPARAM; static uae_u32 z3fastmem_start; /* Determined by the OS */ static uae_u8 *z3fastmem = NULL; -uae_u32 REGPARAM2 z3fastmem_lget(uaecptr addr) +uae_u32 REGPARAM2 z3fastmem_lget (uaecptr addr) { uae_u8 *m; addr -= z3fastmem_start & z3fastmem_mask; @@ -479,7 +487,7 @@ uae_u32 REGPARAM2 z3fastmem_lget(uaecptr return do_get_mem_long ((uae_u32 *)m); } -uae_u32 REGPARAM2 z3fastmem_wget(uaecptr addr) +uae_u32 REGPARAM2 z3fastmem_wget (uaecptr addr) { uae_u8 *m; addr -= z3fastmem_start & z3fastmem_mask; @@ -488,14 +496,14 @@ uae_u32 REGPARAM2 z3fastmem_wget(uaecptr return do_get_mem_word ((uae_u16 *)m); } -uae_u32 REGPARAM2 z3fastmem_bget(uaecptr addr) +uae_u32 REGPARAM2 z3fastmem_bget (uaecptr addr) { addr -= z3fastmem_start & z3fastmem_mask; addr &= z3fastmem_mask; return z3fastmem[addr]; } -void REGPARAM2 z3fastmem_lput(uaecptr addr, uae_u32 l) +void REGPARAM2 z3fastmem_lput (uaecptr addr, uae_u32 l) { uae_u8 *m; addr -= z3fastmem_start & z3fastmem_mask; @@ -504,7 +512,7 @@ void REGPARAM2 z3fastmem_lput(uaecptr ad do_put_mem_long ((uae_u32 *)m, l); } -void REGPARAM2 z3fastmem_wput(uaecptr addr, uae_u32 w) +void REGPARAM2 z3fastmem_wput (uaecptr addr, uae_u32 w) { uae_u8 *m; addr -= z3fastmem_start & z3fastmem_mask; @@ -513,21 +521,21 @@ void REGPARAM2 z3fastmem_wput(uaecptr ad do_put_mem_word ((uae_u16 *)m, w); } -void REGPARAM2 z3fastmem_bput(uaecptr addr, uae_u32 b) +void REGPARAM2 z3fastmem_bput (uaecptr addr, uae_u32 b) { addr -= z3fastmem_start & z3fastmem_mask; addr &= z3fastmem_mask; z3fastmem[addr] = b; } -static int REGPARAM2 z3fastmem_check(uaecptr addr, uae_u32 size) +static int REGPARAM2 z3fastmem_check (uaecptr addr, uae_u32 size) { addr -= z3fastmem_start & z3fastmem_mask; addr &= z3fastmem_mask; - return (addr + size) < z3fastmem_size; + return (addr + size) <= allocated_z3fastmem; } -static uae_u8 REGPARAM2 *z3fastmem_xlate(uaecptr addr) +static uae_u8 REGPARAM2 *z3fastmem_xlate (uaecptr addr) { addr -= z3fastmem_start & z3fastmem_mask; addr &= z3fastmem_mask; @@ -537,7 +545,7 @@ static uae_u8 REGPARAM2 *z3fastmem_xlate addrbank z3fastmem_bank = { z3fastmem_lget, z3fastmem_wget, z3fastmem_bget, z3fastmem_lput, z3fastmem_wput, z3fastmem_bput, - z3fastmem_xlate, z3fastmem_check + z3fastmem_xlate, z3fastmem_check, NULL }; /* Z3-based UAEGFX-card */ @@ -553,23 +561,21 @@ uae_u32 gfxmem_start; static void expamem_map_fastcard (void) { - char buffer[80]; fastmem_start = ((expamem_hi | (expamem_lo >> 4)) << 16); - map_banks (&fastmem_bank, fastmem_start >> 16, fastmem_size >> 16); - sprintf (buffer, "Fastcard: mapped @$%lx: %dMB fast memory\n", fastmem_start, fastmem_size >> 20); - write_log (buffer); + map_banks (&fastmem_bank, fastmem_start >> 16, allocated_fastmem >> 16, allocated_fastmem); + write_log ("Fastcard: mapped @$%lx: %dMB fast memory\n", fastmem_start, allocated_fastmem >> 20); } static void expamem_init_fastcard (void) { expamem_init_clear(); - if (fastmem_size == 0x100000) + if (allocated_fastmem == 0x100000) expamem_write (0x00, Z2_MEM_1MB + add_memory + zorroII); - else if (fastmem_size == 0x200000) + else if (allocated_fastmem == 0x200000) expamem_write (0x00, Z2_MEM_2MB + add_memory + zorroII); - else if (fastmem_size == 0x400000) + else if (allocated_fastmem == 0x400000) expamem_write (0x00, Z2_MEM_4MB + add_memory + zorroII); - else if (fastmem_size == 0x800000) + else if (allocated_fastmem == 0x800000) expamem_write (0x00, Z2_MEM_8MB + add_memory + zorroII); expamem_write (0x08, care_addr); @@ -592,7 +598,7 @@ static void expamem_init_fastcard (void) /* ********************************************************** */ -/* +/* * Filesystem device */ @@ -601,18 +607,23 @@ static void expamem_map_filesys (void) uaecptr a; filesys_start = ((expamem_hi | (expamem_lo >> 4)) << 16); - map_banks (&filesys_bank, filesys_start >> 16, 1); - write_log ("Filesystem: mapped memory.\n"); + map_banks (&filesys_bank, filesys_start >> 16, 1, 0); + write_log ("Filesystem: mapped memory @$%lx.\n", filesys_start); /* 68k code needs to know this. */ a = here (); - org (0xF0FFFC); + org (RTAREA_BASE+0xFFFC); dl (filesys_start + 0x2000); org (a); } static void expamem_init_filesys (void) { - uae_u8 diagarea[] = { 0x90, 0x00, 0x01, 0x0C, 0x01, 0x00, 0x01, 0x06 }; + /* struct DiagArea - the size has to be large enough to store several device ROMTags */ + uae_u8 diagarea[] = { 0x90, 0x00, /* da_Config, da_Flags */ + 0x02, 0x00, /* da_Size */ + 0x01, 0x00, /* da_DiagPoint */ + 0x01, 0x06 /* da_BootPoint */ + }; expamem_init_clear(); expamem_write (0x00, Z2_MEM_64KB | rom_card | zorroII); @@ -628,6 +639,7 @@ static void expamem_init_filesys (void) expamem_write (0x20, 0x00); /* ser.no. Byte 2 */ expamem_write (0x24, 0x01); /* ser.no. Byte 3 */ + /* er_InitDiagVec */ expamem_write (0x28, 0x10); /* Rom-Offset hi */ expamem_write (0x2c, 0x00); /* ROM-Offset lo */ @@ -653,32 +665,31 @@ static void expamem_init_filesys (void) static void expamem_map_z3fastmem (void) { - char buffer[80]; z3fastmem_start = ((expamem_hi | (expamem_lo >> 4)) << 16); - map_banks (&z3fastmem_bank, z3fastmem_start >> 16, z3fastmem_size >> 16); + map_banks (&z3fastmem_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16, + allocated_z3fastmem); - sprintf (buffer, "Fastmem (32bit): mapped @$%lx: %d MB Zorro III fast memory \n", - z3fastmem_start, z3fastmem_size / 0x100000); - write_log (buffer); + write_log ("Fastmem (32bit): mapped @$%lx: %d MB Zorro III fast memory \n", + z3fastmem_start, allocated_z3fastmem / 0x100000); } static void expamem_init_z3fastmem (void) { - int code = (z3fastmem_size == 0x100000 ? Z2_MEM_1MB - : z3fastmem_size == 0x200000 ? Z2_MEM_2MB - : z3fastmem_size == 0x400000 ? Z2_MEM_4MB - : z3fastmem_size == 0x800000 ? Z2_MEM_8MB - : z3fastmem_size == 0x1000000 ? Z2_MEM_16MB - : z3fastmem_size == 0x2000000 ? Z2_MEM_32MB - : z3fastmem_size == 0x4000000 ? Z2_MEM_64MB - : z3fastmem_size == 0x8000000 ? Z2_MEM_128MB - : z3fastmem_size == 0x10000000 ? Z2_MEM_256MB - : z3fastmem_size == 0x20000000 ? Z2_MEM_512MB + int code = (allocated_z3fastmem == 0x100000 ? Z2_MEM_1MB + : allocated_z3fastmem == 0x200000 ? Z2_MEM_2MB + : allocated_z3fastmem == 0x400000 ? Z2_MEM_4MB + : allocated_z3fastmem == 0x800000 ? Z2_MEM_8MB + : allocated_z3fastmem == 0x1000000 ? Z2_MEM_16MB + : allocated_z3fastmem == 0x2000000 ? Z2_MEM_32MB + : allocated_z3fastmem == 0x4000000 ? Z2_MEM_64MB + : allocated_z3fastmem == 0x8000000 ? Z2_MEM_128MB + : allocated_z3fastmem == 0x10000000 ? Z2_MEM_256MB + : allocated_z3fastmem == 0x20000000 ? Z2_MEM_512MB : Z2_MEM_1GB); expamem_init_clear(); expamem_write (0x00, add_memory | zorroIII | code); - expamem_write (0x08, no_shutup | force_z3 | (z3fastmem_size > 0x800000 ? ext_size : Z3_MEM_AUTO)); + expamem_write (0x08, no_shutup | force_z3 | (allocated_z3fastmem > 0x800000 ? ext_size : Z3_MEM_AUTO)); expamem_write (0x04, 3); @@ -694,7 +705,6 @@ static void expamem_init_z3fastmem (void expamem_write (0x2c, 0x00); /* ROM-Offset lo */ expamem_write (0x40, 0x00); /* Ctrl/Statusreg.*/ - } #ifdef PICASSO96 @@ -704,11 +714,9 @@ static void expamem_init_z3fastmem (void static void expamem_map_gfxcard (void) { - char buffer[80]; gfxmem_start = ((expamem_hi | (expamem_lo >> 4)) << 16); - map_banks (&gfxmem_bank, gfxmem_start >> 16, gfxmem_size >> 16); - sprintf (buffer, "UAEGFX-card: mapped @$%lx \n", gfxmem_start); - write_log (buffer); + map_banks (&gfxmem_bank, gfxmem_start >> 16, allocated_gfxmem >> 16, allocated_gfxmem); + write_log ("UAEGFX-card: mapped @$%lx \n", gfxmem_start); } static void expamem_init_gfxcard (void) @@ -716,7 +724,7 @@ static void expamem_init_gfxcard (void) expamem_init_clear(); expamem_write (0x00, zorroIII); - switch (gfxmem_size) { + switch (allocated_gfxmem) { case 0x00100000: expamem_write (0x08, no_shutup | force_z3 | Z3_MEM_1MB); break; @@ -748,11 +756,114 @@ static void expamem_init_gfxcard (void) } #endif -void expamem_reset() +static long fast_filepos, z3_filepos; + +static void allocate_expamem (void) { + currprefs.fastmem_size = changed_prefs.fastmem_size; + currprefs.z3fastmem_size = changed_prefs.z3fastmem_size; + currprefs.gfxmem_size = changed_prefs.gfxmem_size; + + if (allocated_fastmem != currprefs.fastmem_size) { + if (fastmemory) + mapped_free (fastmemory); + fastmemory = 0; + allocated_fastmem = currprefs.fastmem_size; + fastmem_mask = allocated_fastmem - 1; + + if (allocated_fastmem) { + fastmemory = mapped_malloc (allocated_fastmem, "fast"); + if (fastmemory == 0) { + write_log ("Out of memory for fastmem card.\n"); + allocated_fastmem = 0; + } + } + } + if (currprefs.address_space_24) { + if (z3fastmem) + mapped_free (z3fastmem); + z3fastmem = 0; + allocated_z3fastmem = 0; + if (gfxmemory) + mapped_free (gfxmemory); + gfxmemory = 0; + allocated_gfxmem = 0; + } else { + if (allocated_z3fastmem != currprefs.z3fastmem_size) { + if (z3fastmem) + mapped_free (z3fastmem); + z3fastmem = 0; + + allocated_z3fastmem = currprefs.z3fastmem_size; + z3fastmem_mask = allocated_z3fastmem - 1; + + if (allocated_z3fastmem) { + z3fastmem = mapped_malloc (allocated_z3fastmem, "z3"); + if (z3fastmem == 0) { + write_log ("Out of memory for 32 bit fast memory.\n"); + allocated_z3fastmem = 0; + } + } + } + if (allocated_gfxmem != currprefs.gfxmem_size) { + if (gfxmemory) + mapped_free (gfxmemory); + gfxmemory = 0; + + allocated_gfxmem = currprefs.gfxmem_size; + gfxmem_mask = allocated_gfxmem - 1; + + if (allocated_gfxmem) { + gfxmemory = mapped_malloc (allocated_gfxmem, "gfx"); + if (gfxmemory == 0) { + write_log ("Out of memory for graphics card memory\n"); + allocated_gfxmem = 0; + } + } + } + } + z3fastmem_bank.baseaddr = z3fastmem; + fastmem_bank.baseaddr = fastmemory; + + if (savestate_state == STATE_RESTORE) { + if (allocated_fastmem > 0) { + fseek (savestate_file, fast_filepos, SEEK_SET); + fread (fastmemory, 1, allocated_fastmem, savestate_file); + map_banks (&fastmem_bank, fastmem_start >> 16, currprefs.fastmem_size >> 16, + allocated_fastmem); + } + if (allocated_z3fastmem > 0) { + fseek (savestate_file, z3_filepos, SEEK_SET); + fread (z3fastmem, 1, allocated_z3fastmem, savestate_file); + map_banks (&z3fastmem_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16, + allocated_z3fastmem); + } + } +} + +void expamem_reset (void) +{ + int do_mount = 1; int cardno = 0; ecard = 0; + allocate_expamem (); + + /* check if Kickstart version is below 1.3 */ + if (! ersatzkickfile + && (/* Kickstart 1.0 & 1.1! */ + get_word (0xF8000C) == 0xFFFF + /* Kickstart < 1.3 */ + || get_word (0xF8000C) < 34)) + { + /* warn user */ + write_log ("Kickstart version is below 1.3! Disabling autoconfig devices.\n"); + do_mount = 0; + } + /* No need for filesystem stuff if there aren't any mounted. */ + if (nr_units (currprefs.mountinfo) == 0) + do_mount = 0; + if (fastmemory != NULL) { card_init[cardno] = expamem_init_fastcard; card_map[cardno++] = expamem_map_fastcard; @@ -767,7 +878,7 @@ void expamem_reset() card_map[cardno++] = expamem_map_gfxcard; } #endif - if (currprefs.automount_uaedev && !ersatzkickfile) { + if (do_mount && ! ersatzkickfile) { card_init[cardno] = expamem_init_filesys; card_map[cardno++] = expamem_map_filesys; } @@ -779,32 +890,82 @@ void expamem_reset() (*card_init[0]) (); } -void expansion_init(void) +void expansion_init (void) { - if (fastmem_size > 0) { - do { - fastmem_mask = fastmem_size - 1; - fastmemory = (uae_u8 *)malloc(fastmem_size); - if (!fastmemory) - fastmem_size >>= 1; - } while (!fastmemory && fastmem_size >= 1024 * 1024); - if (fastmemory == NULL) { - write_log ("Out of memory for fastmem card.\n"); - } - } - if (z3fastmem_size > 0) { - z3fastmem_mask = z3fastmem_size - 1; - z3fastmem = (uae_u8 *)malloc(z3fastmem_size); - if (z3fastmem == NULL) { - write_log ("Out of memory for Fastmem.(32bit)\n"); - } - } - if (gfxmem_size > 0) { - gfxmem_mask = gfxmem_size - 1; - gfxmemory = (uae_u8 *)malloc(gfxmem_size); - if (!gfxmemory) { - write_log ("Out of memory for UAEGFX-card.\n"); - } + z3fastmem = 0; + gfxmemory = 0; + fastmemory = 0; + allocated_z3fastmem = 0; + allocated_gfxmem = 0; + allocated_fastmem = 0; + + allocate_expamem (); + + filesysory = (uae_u8 *) mapped_malloc (0x10000, "filesys"); + if (!filesysory) { + write_log ("virtual memory exhausted (filesysory)!\n"); + exit (0); } + filesys_bank.baseaddr = (uae_u8*)filesysory; +} + +void expansion_cleanup (void) +{ + if (fastmemory) + mapped_free (fastmemory); + if (z3fastmem) + mapped_free (z3fastmem); + if (gfxmemory) + mapped_free (gfxmemory); + if (filesysory) + mapped_free (filesysory); + fastmemory = 0; + z3fastmem = 0; + gfxmemory = 0; + filesysory = 0; } +/* State save/restore code. */ + +uae_u8 *save_fram (int *len) +{ + *len = allocated_fastmem; + return fastmemory; +} + +uae_u8 *save_zram (int *len) +{ + *len = allocated_z3fastmem; + return z3fastmem; +} + +void restore_fram (int len, long filepos) +{ + fast_filepos = filepos; + changed_prefs.fastmem_size = len; +} + +void restore_zram (int len, long filepos) +{ + z3_filepos = filepos; + changed_prefs.z3fastmem_size = len; +} + +uae_u8 *save_expansion (int *len, uae_u8 *dstptr) +{ + static uae_u8 t[20]; + uae_u8 *dst = t, *dstbak = t; + if (dstptr) + dst = dstbak = dstptr; + save_u32 (fastmem_start); + save_u32 (z3fastmem_start); + *len = 8; + return dst; +} + +const uae_u8 *restore_expansion (const uae_u8 *src) +{ + fastmem_start = restore_u32 (); + z3fastmem_start = restore_u32 (); + return src; +}