cfgfile_write (f, "a3000mem_size=%d\n", p->mbresmem_low_size / 0x100000);
cfgfile_write (f, "mbresmem_size=%d\n", p->mbresmem_high_size / 0x100000);
cfgfile_write (f, "z3mem_size=%d\n", p->z3fastmem_size / 0x100000);
+ cfgfile_write (f, "z3mem2_size=%d\n", p->z3fastmem2_size / 0x100000);
cfgfile_write (f, "z3mem_start=0x%x\n", p->z3fastmem_start);
cfgfile_write (f, "bogomem_size=%d\n", p->bogomem_size / 0x40000);
cfgfile_write (f, "gfxcard_size=%d\n", p->gfxmem_size / 0x100000);
|| cfgfile_intval (option, value, "a3000mem_size", &p->mbresmem_low_size, 0x100000)
|| cfgfile_intval (option, value, "mbresmem_size", &p->mbresmem_high_size, 0x100000)
|| cfgfile_intval (option, value, "z3mem_size", &p->z3fastmem_size, 0x100000)
+ || cfgfile_intval (option, value, "z3mem2_size", &p->z3fastmem2_size, 0x100000)
|| cfgfile_intval (option, value, "z3mem_start", &p->z3fastmem_start, 1)
|| cfgfile_intval (option, value, "bogomem_size", &p->bogomem_size, 0x40000)
|| cfgfile_intval (option, value, "gfxcard_size", &p->gfxmem_size, 0x100000)
p->mbresmem_low_size = 0x00000000;
p->mbresmem_high_size = 0x00000000;
p->z3fastmem_size = 0x00000000;
+ p->z3fastmem2_size = 0x00000000;
p->z3fastmem_start = 0x10000000;
p->chipmem_size = 0x00080000;
p->bogomem_size = 0x00080000;
p->mbresmem_low_size = 0x00000000;
p->mbresmem_high_size = 0x00000000;
p->z3fastmem_size = 0x00000000;
+ p->z3fastmem2_size = 0x00000000;
p->gfxmem_size = 0x00000000;
p->cs_rtc = 0;
static void (*card_init[MAX_EXPANSION_BOARDS]) (void);
static void (*card_map[MAX_EXPANSION_BOARDS]) (void);
-static int ecard;
-static int cardno;
+static int ecard, cardno, z3num;
static uae_u16 uae_id;
switch (addr & 0xff) {
case 0x44:
if (expamem_type() == zorroIII) {
+ uae_u32 p1, p2;
// +Bernd Roesch & Toni Wilen
+ p1 = get_word (regs.regs[11] + 0x20);
if (expamem[0] & add_memory) {
// Z3 RAM expansion
- value = z3fastmem_start >> 16;
+ if (z3num == 0)
+ p2 = z3fastmem_start >> 16;
+ else
+ p2 = z3fastmem2_start >> 16;
+ z3num++;
} else {
// Z3 P96 RAM
- value = p96ram_start >> 16;
+ p2 = p96ram_start >> 16;
}
- put_word (regs.regs[11] + 0x20, value);
- put_word (regs.regs[11] + 0x28, value);
+ put_word (regs.regs[11] + 0x20, p2);
+ put_word (regs.regs[11] + 0x28, p2);
// -Bernd Roesch
- expamem_hi = value;
+ expamem_hi = p2;
(*card_map[ecard]) ();
- write_log (" Card %d (Zorro%s) done.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III");
- ++ecard;
+ ecard++;
+ if (p1 != p2)
+ write_log (" Card %d remapped %04x0000 -> %04x0000\n", ecard, p1, p2);
+ write_log (" Card %d (Zorro%s) done.\n", ecard, expamem_type () == 0xc0 ? "II" : "III");
if (ecard < cardno)
(*card_init[ecard]) ();
else
if (expamem_type () == zorroII) {
expamem_hi = value;
(*card_map[ecard]) ();
- write_log (" Card %d (Zorro%s) done.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III");
+ write_log (" Card %d (Zorro%s) done.\n", ecard + 1, expamem_type () == 0xc0 ? "II" : "III");
++ecard;
if (ecard < cardno)
(*card_init[ecard]) ();
break;
case 0x4c:
- write_log (" Card %d (Zorro%s) had no success.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III");
+ write_log (" Card %d (Zorro%s) had no success.\n", ecard + 1, expamem_type () == 0xc0 ? "II" : "III");
++ecard;
if (ecard < cardno)
(*card_init[ecard]) ();
* Z3fastmem Memory
*/
-static uae_u32 z3fastmem_mask;
-
-static uae_u32 REGPARAM3 z3fastmem_lget (uaecptr) REGPARAM;
-static uae_u32 REGPARAM3 z3fastmem_wget (uaecptr) REGPARAM;
-static uae_u32 REGPARAM3 z3fastmem_bget (uaecptr) REGPARAM;
-static void REGPARAM3 z3fastmem_lput (uaecptr, uae_u32) REGPARAM;
-static void REGPARAM3 z3fastmem_wput (uaecptr, uae_u32) REGPARAM;
-static void REGPARAM3 z3fastmem_bput (uaecptr, uae_u32) REGPARAM;
-static int REGPARAM3 z3fastmem_check (uaecptr addr, uae_u32 size) REGPARAM;
-static uae_u8 *REGPARAM3 z3fastmem_xlate (uaecptr addr) REGPARAM;
-
-uaecptr z3fastmem_start; /* Determined by the OS */
-static uae_u8 *z3fastmem;
+static uae_u32 z3fastmem_mask, z3fastmem2_mask;
+uaecptr z3fastmem_start, z3fastmem2_start;
+static uae_u8 *z3fastmem, *z3fastmem2;
static uae_u32 REGPARAM2 z3fastmem_lget (uaecptr addr)
{
m = z3fastmem + addr;
return do_get_mem_long ((uae_u32 *)m);
}
-
static uae_u32 REGPARAM2 z3fastmem_wget (uaecptr addr)
{
uae_u8 *m;
addr &= z3fastmem_mask;
return z3fastmem[addr];
}
-
static void REGPARAM2 z3fastmem_lput (uaecptr addr, uae_u32 l)
{
uae_u8 *m;
m = z3fastmem + addr;
do_put_mem_long ((uae_u32 *)m, l);
}
-
static void REGPARAM2 z3fastmem_wput (uaecptr addr, uae_u32 w)
{
uae_u8 *m;
m = z3fastmem + addr;
do_put_mem_word ((uae_u16 *)m, w);
}
-
static 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)
{
addr -= z3fastmem_start & z3fastmem_mask;
addr &= z3fastmem_mask;
return (addr + size) <= allocated_z3fastmem;
}
-
static uae_u8 *REGPARAM2 z3fastmem_xlate (uaecptr addr)
{
addr -= z3fastmem_start & z3fastmem_mask;
return z3fastmem + addr;
}
+static uae_u32 REGPARAM2 z3fastmem2_lget (uaecptr addr)
+{
+ uae_u8 *m;
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ m = z3fastmem2 + addr;
+ return do_get_mem_long ((uae_u32 *)m);
+}
+static uae_u32 REGPARAM2 z3fastmem2_wget (uaecptr addr)
+{
+ uae_u8 *m;
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ m = z3fastmem2 + addr;
+ return do_get_mem_word ((uae_u16 *)m);
+}
+static uae_u32 REGPARAM2 z3fastmem2_bget (uaecptr addr)
+{
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ return z3fastmem2[addr];
+}
+static void REGPARAM2 z3fastmem2_lput (uaecptr addr, uae_u32 l)
+{
+ uae_u8 *m;
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ m = z3fastmem2 + addr;
+ do_put_mem_long ((uae_u32 *)m, l);
+}
+static void REGPARAM2 z3fastmem2_wput (uaecptr addr, uae_u32 w)
+{
+ uae_u8 *m;
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ m = z3fastmem2 + addr;
+ do_put_mem_word ((uae_u16 *)m, w);
+}
+static void REGPARAM2 z3fastmem2_bput (uaecptr addr, uae_u32 b)
+{
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ z3fastmem2[addr] = b;
+}
+static int REGPARAM2 z3fastmem2_check (uaecptr addr, uae_u32 size)
+{
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ return (addr + size) <= allocated_z3fastmem2;
+}
+static uae_u8 *REGPARAM2 z3fastmem2_xlate (uaecptr addr)
+{
+ addr -= z3fastmem2_start & z3fastmem2_mask;
+ addr &= z3fastmem2_mask;
+ return z3fastmem2 + addr;
+}
addrbank z3fastmem_bank = {
z3fastmem_lget, z3fastmem_wget, z3fastmem_bget,
z3fastmem_lput, z3fastmem_wput, z3fastmem_bput,
z3fastmem_xlate, z3fastmem_check, NULL, "ZorroIII Fast RAM",
z3fastmem_lget, z3fastmem_wget, ABFLAG_RAM
};
+addrbank z3fastmem2_bank = {
+ z3fastmem2_lget, z3fastmem2_wget, z3fastmem2_bget,
+ z3fastmem2_lput, z3fastmem2_wput, z3fastmem2_bput,
+ z3fastmem2_xlate, z3fastmem2_check, NULL, "ZorroIII Fast RAM #2",
+ z3fastmem2_lget, z3fastmem2_wget, ABFLAG_RAM
+};
/* Z3-based UAEGFX-card */
uae_u32 gfxmem_mask; /* for memory.c */
* Zorro III expansion memory
*/
-static void expamem_map_z3fastmem (void)
+static void expamem_map_z3fastmem_2 (addrbank *bank, int *startp, uae_u32 size, uae_u32 allocated)
{
int z3fs = ((expamem_hi | (expamem_lo >> 4)) << 16);
-
- if (z3fastmem_start != z3fs) {
- write_log ("WARNING: Z3FAST mapping changed from $%lx to $%lx\n", z3fastmem_start, z3fs);
- map_banks (&dummy_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16,
- allocated_z3fastmem);
- z3fastmem_start = z3fs;
- map_banks (&z3fastmem_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16,
- allocated_z3fastmem);
+ int start = *startp;
+
+ if (start != z3fs) {
+ write_log ("WARNING: Z3FAST mapping changed from $%08x to $%08x\n", start, z3fs);
+ map_banks (&dummy_bank, start >> 16, size >> 16,
+ allocated);
+ *startp = z3fs;
+ map_banks (bank, start >> 16, size >> 16,
+ allocated);
}
- write_log ("Fastmem (32bit): mapped @$%lx: %d MB Zorro III fast memory \n",
- z3fastmem_start, allocated_z3fastmem / 0x100000);
+ write_log ("Fastmem (32bit): mapped @$%08x: %d MB Zorro III fast memory \n",
+ start, allocated / 0x100000);
}
-static void expamem_init_z3fastmem (void)
+static void expamem_map_z3fastmem (void)
{
- 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
+ expamem_map_z3fastmem_2 (&z3fastmem_bank, &z3fastmem_start, currprefs.z3fastmem_size, allocated_z3fastmem);
+}
+static void expamem_map_z3fastmem2 (void)
+{
+ expamem_map_z3fastmem_2 (&z3fastmem2_bank, &z3fastmem2_start, currprefs.z3fastmem2_size, allocated_z3fastmem2);
+}
+
+static void expamem_init_z3fastmem_2 (addrbank *bank, uae_u32 start, uae_u32 size, uae_u32 allocated)
+{
+ int code = (allocated == 0x100000 ? Z2_MEM_1MB
+ : allocated == 0x200000 ? Z2_MEM_2MB
+ : allocated == 0x400000 ? Z2_MEM_4MB
+ : allocated == 0x800000 ? Z2_MEM_8MB
+ : allocated == 0x1000000 ? Z2_MEM_16MB
+ : allocated == 0x2000000 ? Z2_MEM_32MB
+ : allocated == 0x4000000 ? Z2_MEM_64MB
+ : allocated == 0x8000000 ? Z2_MEM_128MB
+ : allocated == 0x10000000 ? Z2_MEM_256MB
+ : allocated == 0x20000000 ? Z2_MEM_512MB
: Z2_MEM_1GB);
expamem_init_clear ();
expamem_write (0x00, add_memory | zorroIII | code);
- expamem_write (0x08, care_addr | no_shutup | force_z3 | (allocated_z3fastmem > 0x800000 ? ext_size : Z3_MEM_AUTO));
+ expamem_write (0x08, care_addr | no_shutup | force_z3 | (allocated > 0x800000 ? ext_size : Z3_MEM_AUTO));
expamem_write (0x04, 3);
expamem_write (0x40, 0x00); /* Ctrl/Statusreg.*/
- map_banks (&z3fastmem_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16,
- allocated_z3fastmem);
+ map_banks (bank, start >> 16, size >> 16, allocated);
}
+static void expamem_init_z3fastmem (void)
+{
+ expamem_init_z3fastmem_2 (&z3fastmem_bank, z3fastmem_start, currprefs.z3fastmem_size, allocated_z3fastmem);
+}
+static void expamem_init_z3fastmem2 (void)
+{
+ expamem_init_z3fastmem_2 (&z3fastmem2_bank, z3fastmem2_start, currprefs.z3fastmem2_size, allocated_z3fastmem2);
+}
#ifdef PICASSO96
/*
#ifdef SAVESTATE
-static size_t fast_filepos, z3_filepos, p96_filepos;
+static size_t fast_filepos, z3_filepos, z3_filepos2, p96_filepos;
#endif
void free_fastmemory (void)
{
currprefs.fastmem_size = changed_prefs.fastmem_size;
currprefs.z3fastmem_size = changed_prefs.z3fastmem_size;
+ currprefs.z3fastmem2_size = changed_prefs.z3fastmem2_size;
currprefs.gfxmem_size = changed_prefs.gfxmem_size;
if (allocated_fastmem != currprefs.fastmem_size) {
}
memory_hardreset ();
}
+ if (allocated_z3fastmem2 != currprefs.z3fastmem2_size) {
+ if (z3fastmem2)
+ mapped_free (z3fastmem2);
+ z3fastmem2 = 0;
+
+ allocated_z3fastmem2 = currprefs.z3fastmem2_size;
+ z3fastmem2_mask = allocated_z3fastmem2 - 1;
+
+ if (allocated_z3fastmem2) {
+ z3fastmem2 = mapped_malloc (allocated_z3fastmem2, "z3_2");
+ if (z3fastmem2 == 0) {
+ write_log ("Out of memory for 32 bit fast memory #2.\n");
+ allocated_z3fastmem2 = 0;
+ }
+ }
+ memory_hardreset ();
+ }
#ifdef PICASSO96
if (allocated_gfxmem != currprefs.gfxmem_size) {
if (gfxmemory)
#endif
z3fastmem_bank.baseaddr = z3fastmem;
+ z3fastmem2_bank.baseaddr = z3fastmem2;
fastmem_bank.baseaddr = fastmemory;
gfxmem_bankx.baseaddr = gfxmemory;
map_banks (&z3fastmem_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16,
allocated_z3fastmem);
}
+ if (allocated_z3fastmem2 > 0) {
+ restore_ram (z3_filepos2, z3fastmem2);
+ map_banks (&z3fastmem2_bank, z3fastmem2_start >> 16, currprefs.z3fastmem2_size >> 16,
+ allocated_z3fastmem2);
+ }
#ifdef PICASSO96
if (allocated_gfxmem > 0 && gfxmem_start > 0) {
restore_ram (p96_filepos, gfxmemory);
void p96memstart(void)
{
/* make sure there is always empty space between Z3 and P96 RAM */
- p96ram_start = currprefs.z3fastmem_start + ((currprefs.z3fastmem_size + 0xffffff) & ~0xffffff);
- if (p96ram_start == currprefs.z3fastmem_start + currprefs.z3fastmem_size &&
- (currprefs.z3fastmem_size < 512 * 1024 * 1024 || currprefs.gfxmem_size < 128 * 1024 * 1024))
+ p96ram_start = currprefs.z3fastmem_start + ((currprefs.z3fastmem_size + currprefs.z3fastmem2_size + 0xffffff) & ~0xffffff);
+ if (p96ram_start == currprefs.z3fastmem_start + currprefs.z3fastmem_size + currprefs.z3fastmem2_size &&
+ (currprefs.z3fastmem_size + currprefs.z3fastmem2_size < 512 * 1024 * 1024 || currprefs.gfxmem_size < 128 * 1024 * 1024))
p96ram_start += 0x1000000;
}
card_init[cardno] = expamem_init_fastcard;
card_map[cardno++] = expamem_map_fastcard;
}
+
+ z3fastmem_start = currprefs.z3fastmem_start;
+ z3fastmem2_start = currprefs.z3fastmem_start + currprefs.z3fastmem_size;
if (z3fastmem != NULL) {
+ z3num = 0;
card_init[cardno] = expamem_init_z3fastmem;
card_map[cardno++] = expamem_map_z3fastmem;
+ map_banks (&z3fastmem_bank, z3fastmem_start >> 16, currprefs.z3fastmem_size >> 16, allocated_z3fastmem);
+ if (z3fastmem2 != NULL) {
+ card_init[cardno] = expamem_init_z3fastmem2;
+ card_map[cardno++] = expamem_map_z3fastmem2;
+ map_banks (&z3fastmem2_bank, z3fastmem2_start >> 16, currprefs.z3fastmem2_size >> 16, allocated_z3fastmem2);
+ }
}
#ifdef CDTV
if (currprefs.cs_cdtvcd) {
card_map[cardno++] = expamem_map_clear;
}
- z3fastmem_start = currprefs.z3fastmem_start;
-
if (cardno == 0)
expamem_init_clear_zero ();
else
allocated_z3fastmem = 0;
z3fastmem_mask = z3fastmem_start = 0;
z3fastmem = 0;
+ allocated_z3fastmem2 = 0;
+ z3fastmem2_mask = z3fastmem2_start = 0;
+ z3fastmem2 = 0;
allocate_expamem ();
if (z3fastmem)
mapped_free (z3fastmem);
z3fastmem = 0;
+ if (z3fastmem2)
+ mapped_free (z3fastmem2);
+ z3fastmem2 = 0;
#ifdef PICASSO96
if (gfxmemory)
memset (fastmemory, 0, allocated_fastmem);
if (z3fastmem)
memset (z3fastmem, 0, allocated_z3fastmem > 0x800000 ? 0x800000 : allocated_z3fastmem);
+ if (z3fastmem2)
+ memset (z3fastmem2, 0, allocated_z3fastmem2 > 0x800000 ? 0x800000 : allocated_z3fastmem2);
if (gfxmemory)
memset (gfxmemory, 0, allocated_gfxmem);
}
return fastmemory;
}
-uae_u8 *save_zram (int *len)
+uae_u8 *save_zram (int *len, int num)
{
- *len = allocated_z3fastmem;
- return z3fastmem;
+ *len = num ? allocated_z3fastmem2 : allocated_z3fastmem;
+ return num ? z3fastmem2 : z3fastmem;
}
uae_u8 *save_pram (int *len)
changed_prefs.fastmem_size = len;
}
-void restore_zram (int len, size_t filepos)
+void restore_zram (int len, size_t filepos, int num)
{
- z3_filepos = filepos;
- changed_prefs.z3fastmem_size = len;
+ if (num) {
+ z3_filepos2 = filepos;
+ changed_prefs.z3fastmem2_size = len;
+ } else {
+ z3_filepos = filepos;
+ changed_prefs.z3fastmem_size = len;
+ }
}
void restore_pram (int len, size_t filepos)
extern uae_u32 allocated_fastmem;
extern uae_u32 allocated_bogomem;
extern uae_u32 allocated_gfxmem;
-extern uae_u32 allocated_z3fastmem, max_z3fastmem;
+extern uae_u32 allocated_z3fastmem, allocated_z3fastmem2, max_z3fastmem;
extern uae_u32 allocated_a3000mem;
extern uae_u32 allocated_cardmem;
#define bogomem_start 0x00C00000
#define cardmem_start 0x00E00000
#define kickmem_start 0x00F80000
-extern uaecptr z3fastmem_start;
+extern uaecptr z3fastmem_start, z3fastmem2_start;
extern uaecptr p96ram_start;
extern uaecptr fastmem_start;
extern uaecptr a3000lmem_start, a3000hmem_start;
int picasso96_nocustom;
int picasso96_modeflags;
- uae_u32 z3fastmem_size;
+ uae_u32 z3fastmem_size, z3fastmem2_size;
uae_u32 z3fastmem_start;
uae_u32 fastmem_size;
uae_u32 chipmem_size;
extern void restore_cram (int, size_t);
extern void restore_bram (int, size_t);
extern void restore_fram (int, size_t);
-extern void restore_zram (int, size_t);
+extern void restore_zram (int, size_t, int);
extern void restore_bootrom (int, size_t);
extern void restore_pram (int, size_t);
extern void restore_a3000lram (int, size_t);
extern uae_u8 *save_cram (int *);
extern uae_u8 *save_bram (int *);
extern uae_u8 *save_fram (int *);
-extern uae_u8 *save_zram (int *);
+extern uae_u8 *save_zram (int *, int);
extern uae_u8 *save_bootrom (int *);
extern uae_u8 *save_pram (int *);
extern uae_u8 *save_a3000lram (int *);
built_in_chipset_prefs (p);
fixup_cpu (p);
- if ((p->chipmem_size & (p->chipmem_size - 1)) != 0
+ if (((p->chipmem_size & (p->chipmem_size - 1)) != 0 && p->chipmem_size != 0x180000)
|| p->chipmem_size < 0x20000
|| p->chipmem_size > 0x800000)
{
p->z3fastmem_size = 0;
err = 1;
}
+ if ((p->z3fastmem2_size & (p->z3fastmem2_size - 1)) != 0
+ || (p->z3fastmem2_size != 0 && (p->z3fastmem2_size < 0x100000 || p->z3fastmem2_size > max_z3fastmem)))
+ {
+ write_log ("Unsupported Zorro III fastmem size %x (%x)!\n", p->z3fastmem2_size, max_z3fastmem);
+ if (p->z3fastmem2_size > max_z3fastmem)
+ p->z3fastmem2_size = max_z3fastmem;
+ else
+ p->z3fastmem2_size = 0;
+ err = 1;
+ }
p->z3fastmem_start &= ~0xffff;
if (p->z3fastmem_start < 0x1000000)
p->z3fastmem_start = 0x1000000;
uae_u32 allocated_fastmem;
uae_u32 allocated_bogomem;
uae_u32 allocated_gfxmem;
-uae_u32 allocated_z3fastmem;
+uae_u32 allocated_z3fastmem, allocated_z3fastmem2;
uae_u32 allocated_a3000lmem;
uae_u32 allocated_a3000hmem;
uae_u32 allocated_cardmem;
return 1;
}
-static void addkey (int *pkeyid, uae_u8 *key, int size, const char *name)
+static void addkey (uae_u8 *key, int size, const char *name)
{
- int keyid = *pkeyid;
int i;
- if (key == NULL || size == 0 || keyid >= ROM_KEY_NUM) {
+ if (key == NULL || size == 0) {
xfree (key);
return;
}
- for (i = 0; i < keyid; i++) {
+ for (i = 0; i < ROM_KEY_NUM; i++) {
if (keyring[i].key && keyring[i].size == size && !memcmp (keyring[i].key, key, size)) {
xfree (key);
return;
}
}
- keyring[keyid].key = key;
- keyring[keyid++].size = size;
+ for (i = 0; i < ROM_KEY_NUM; i++) {
+ if (keyring[i].key == NULL)
+ break;
+ }
+ if (i == ROM_KEY_NUM) {
+ xfree (key);
+ return;
+ }
+ keyring[i].key = key;
+ keyring[i].size = size;
write_log ("ROM KEY '%s' %d bytes loaded\n", name, size);
- *pkeyid = keyid;
+}
+
+static void addkeyfile (const char *path)
+{
+ struct zfile *f;
+ int keysize;
+ uae_u8 *keybuf;
+
+ f = zfile_fopen (path, "rb");
+ if (!f)
+ return;
+ zfile_fseek (f, 0, SEEK_END);
+ keysize = zfile_ftell (f);
+ if (keysize > 0) {
+ zfile_fseek (f, 0, SEEK_SET);
+ keybuf = xmalloc (keysize);
+ zfile_fread (keybuf, 1, keysize, f);
+ addkey (keybuf, keysize, path);
+ }
+ zfile_fclose (f);
+}
+
+static void addkeydir (const char *path)
+{
+ char tmp[MAX_DPATH];
+
+ strcpy (tmp, path);
+ if (zfile_exists (tmp)) {
+ int i;
+ for (i = strlen (tmp) - 1; i > 0; i--) {
+ if (tmp[i] == '\\' || tmp[i] == '/')
+ break;
+ }
+ tmp[i] = 0;
+ }
+ strcat (tmp, "/");
+ strcat (tmp, "rom.key");
+ addkeyfile (tmp);
}
int get_keyring (void)
int load_keyring (struct uae_prefs *p, char *path)
{
- struct zfile *f;
uae_u8 *keybuf;
int keysize;
char tmp[MAX_PATH], *d;
int keyids[] = { 0, 48, -1 };
- int keyid;
int cnt, i;
free_keyring ();
- keyid = 0;
keybuf = target_load_keyfile (p, path, &keysize, tmp);
- addkey (&keyid, keybuf, keysize, tmp);
- for (i = 0; keyids[i] >= 0 && keyid < ROM_KEY_NUM; i++) {
+ addkey (keybuf, keysize, tmp);
+ for (i = 0; keyids[i] >= 0; i++) {
struct romdata *rd = getromdatabyid (keyids[i]);
char *s;
if (rd) {
s = romlist_get (rd);
- if (s) {
- f = zfile_fopen (s, "rb");
- if (f) {
- zfile_fseek (f, 0, SEEK_END);
- keysize = zfile_ftell (f);
- if (keysize > 0) {
- zfile_fseek (f, 0, SEEK_SET);
- keybuf = (uae_u8*)xmalloc (keysize);
- zfile_fread (keybuf, 1, keysize, f);
- addkey(&keyid, keybuf, keysize, s);
- }
- zfile_fclose (f);
- }
- }
+ if (s)
+ addkeyfile (s);
}
}
}
break;
case 7:
- return keyid;
+ return cnt;
}
cnt++;
if (!tmp[0])
continue;
- f = zfile_fopen(tmp, "rb");
- if (!f)
- continue;
- zfile_fseek (f, 0, SEEK_END);
- keysize = zfile_ftell (f);
- if (keysize > 0) {
- zfile_fseek (f, 0, SEEK_SET);
- keybuf = (uae_u8*)xmalloc (keysize);
- zfile_fread (keybuf, 1, keysize, f);
- addkey (&keyid, keybuf, keysize, tmp);
- }
- zfile_fclose (f);
+ addkeyfile (tmp);
}
}
void free_keyring (void)
return 0;
zfile_fread (buf, rd->size, 1, zf);
zfile_fclose (zf);
+ addkeydir (rl->path);
return 1;
}
}
oldpos = zfile_ftell (f);
i = zfile_fread (buffer, 1, 11, f);
- if (!memcmp(buffer, "KICK", 4)) {
+ if (!memcmp (buffer, "KICK", 4)) {
zfile_fseek (f, 512, SEEK_SET);
kickdisk = 1;
#if 0
struct zfile *f;
int size, off;
- if (strlen(currprefs.romextfile) == 0)
+ if (strlen (currprefs.romextfile) == 0)
return 0;
- if (is_arcadia_rom(currprefs.romextfile) == ARCADIA_BIOS) {
+ if (is_arcadia_rom (currprefs.romextfile) == ARCADIA_BIOS) {
extendedkickmem_type = EXTENDED_ROM_ARCADIA;
return 0;
}
zfile_fseek (f, off, SEEK_SET);
switch (extendedkickmem_type) {
case EXTENDED_ROM_CDTV:
- extendedkickmemory = (uae_u8 *) mapped_malloc (extendedkickmem_size, "rom_f0");
- extendedkickmem_bank.baseaddr = (uae_u8 *) extendedkickmemory;
+ extendedkickmemory = mapped_malloc (extendedkickmem_size, "rom_f0");
+ extendedkickmem_bank.baseaddr = extendedkickmemory;
break;
case EXTENDED_ROM_CD32:
- extendedkickmemory = (uae_u8 *) mapped_malloc (extendedkickmem_size, "rom_e0");
- extendedkickmem_bank.baseaddr = (uae_u8 *) extendedkickmemory;
+ extendedkickmemory = mapped_malloc (extendedkickmem_size, "rom_e0");
+ extendedkickmem_bank.baseaddr = extendedkickmemory;
break;
}
read_kickstart (f, extendedkickmemory, extendedkickmem_size, 0, 0, 1);
strcpy (currprefs.romfile, tmprom2);
}
}
+ addkeydir (currprefs.romfile);
if( f == NULL ) { /* still no luck */
#if defined(AMIGA)||defined(__POS__)
#define USE_UAE_ERSATZ "USE_UAE_ERSATZ"
chipmem_full_mask = chipmem_mask = allocated_chipmem - 1;
if (memsize < 0x100000)
memsize = 0x100000;
+ if (memsize > 0x100000 && memsize < 0x200000)
+ memsize = 0x200000;
chipmemory = mapped_malloc (memsize, "chip");
if (chipmemory == 0) {
write_log ("Fatal error: out of memory for chipmem.\n");
currprefs.chipset_mask = changed_prefs.chipset_mask;
chipmem_full_mask = allocated_chipmem - 1;
- if ((currprefs.chipset_mask & CSMASK_ECS_AGNUS) && allocated_chipmem < 0x100000)
- chipmem_full_mask = 0x100000 - 1;
+ if (currprefs.chipset_mask & CSMASK_ECS_AGNUS) {
+ if (allocated_chipmem < 0x100000)
+ chipmem_full_mask = 0x100000 - 1;
+ if (allocated_chipmem > 0x100000 && allocated_chipmem < 0x200000)
+ chipmem_full_mask = chipmem_mask = 0x200000 - 1;
+ }
if (allocated_bogomem != currprefs.bogomem_size) {
if (bogomemory)
void map_overlay (int chip)
{
- int i = allocated_chipmem > 0x200000 ? (allocated_chipmem >> 16) : 32;
+ int size;
addrbank *cb;
+ size = allocated_chipmem >= 0x180000 ? (allocated_chipmem >> 16) : 32;
cb = &chipmem_bank;
#ifdef AGA
if (currprefs.cpu_cycle_exact && currprefs.cpu_model >= 68020)
cb = &chipmem_bank_ce2;
#endif
if (chip) {
- map_banks (cb, 0, i, allocated_chipmem);
+ map_banks (&dummy_bank, 0, 32, 0);
+ if (currprefs.cpu_model < 68020 || currprefs.address_space_24)
+ map_banks (cb, 0, size, allocated_chipmem);
+ else
+ map_banks (cb, 0, allocated_chipmem >> 16, 0);
} else {
addrbank *rb = NULL;
+ if (size < 32)
+ size = 32;
cb = &get_mem_bank (0xf00000);
if (!rb && cb && (cb->flags & ABFLAG_ROM) && get_word (0xf00000) == 0x1114)
rb = cb;
rb = cb;
if (!rb)
rb = &kickmem_bank;
- map_banks (rb, 0, i, 0x80000);
+ map_banks (rb, 0, size, 0x80000);
}
if (savestate_state != STATE_RESTORE && savestate_state != STATE_REWIND && valid_address (regs.pc, 4))
m68k_setpc (®s, m68k_getpc (®s));
size += currprefs.mbresmem_low_size;
size += currprefs.mbresmem_high_size;
size += currprefs.z3fastmem_size;
+ size += currprefs.z3fastmem2_size;
buf = p = (uae_u8*)xmalloc (size);
if (!buf)
return;
p += currprefs.mbresmem_high_size;
mc (p, z3fastmem_start, currprefs.z3fastmem_size);
p += currprefs.z3fastmem_size;
+ mc (p, z3fastmem_start + currprefs.z3fastmem_size, currprefs.z3fastmem2_size);
+ p += currprefs.z3fastmem2_size;
got = 0;
canceled = 0;
releaser (dxdata.flipping[0], IDirectDrawSurface7_Release);
releaser (dxdata.primary, IDirectDrawSurface7_Release);
releaser (dxdata.secondary, IDirectDrawSurface7_Release);
- releaser (dxdata.cursorsurface, IDirectDrawSurface7_Release);
+ releaser (dxdata.cursorsurface1, IDirectDrawSurface7_Release);
+ releaser (dxdata.cursorsurface2, IDirectDrawSurface7_Release);
dxdata.backbuffers = 0;
}
if (FAILED (ddrval)) {
write_log ("IDirectDraw7_CreateSurface (%dx%d,%s): %s\n", width, height, alloctexts[forcemode], DXError (ddrval));
} else {
- write_log ("Created %dx%d surface in %s (%d)\n", width, height, alloctexts[forcemode], forcemode);
+ write_log ("Created %dx%dx%d (%p) surface in %s (%d)\n", width, height, desc.ddpfPixelFormat.dwRGBBitCount, surf,
+ alloctexts[forcemode], forcemode);
}
return surf;
}
static void createcursorsurface (void)
{
- releaser (dxdata.cursorsurface, IDirectDrawSurface7_Release);
- dxdata.cursorsurface = allocsurface_2 (dxdata.cursorwidth, dxdata.cursorheight * 2, TRUE);
- if (dxdata.cursorsurface)
- clearsurf (dxdata.cursorsurface);
+ releaser (dxdata.cursorsurface1, IDirectDrawSurface7_Release);
+ releaser (dxdata.cursorsurface2, IDirectDrawSurface7_Release);
+ dxdata.cursorsurface1 = allocsurface_2 (dxdata.cursorwidth, dxdata.cursorheight, TRUE);
+ dxdata.cursorsurface2 = allocsurface_2 (dxdata.cursorwidth, dxdata.cursorheight, FALSE);
+ if (dxdata.cursorsurface1)
+ clearsurf (dxdata.cursorsurface1);
+ if (dxdata.cursorsurface2)
+ clearsurf (dxdata.cursorsurface2);
}
HRESULT DirectDraw_CreateMainSurface (int width, int height)
unlocksurface (surf);
}
createcursorsurface ();
-
} else {
ddrval = DD_FALSE;
}
+ write_log ("DDRAW: primary surface %p, secondary %p (%dx%dx%d)\n",
+ dxdata.primary, surf, width, height, dxdata.native.ddpfPixelFormat.dwRGBBitCount);
return ddrval;
}
static void DirectDraw_Blt (LPDIRECTDRAWSURFACE7 dst, RECT *dstrect, LPDIRECTDRAWSURFACE7 src, RECT *srcrect)
{
HRESULT ddrval;
- DDBLTFX fx = { 0 };
-
- fx.dwSize = sizeof (fx);
- fx.dwROP = SRCCOPY;
if (dst == NULL)
dst = getlocksurface ();
src = getlocksurface ();
if (dst == src)
return;
- while (FAILED(ddrval = IDirectDrawSurface7_Blt (dst, dstrect, src, srcrect, DDBLT_ROP | DDBLT_WAIT, &fx))) {
+ while (FAILED(ddrval = IDirectDrawSurface7_Blt (dst, dstrect, src, srcrect, DDBLT_WAIT, NULL))) {
if (ddrval == DDERR_SURFACELOST) {
ddrval = restoresurfacex (dst, src);
if (FAILED (ddrval))
int maxwidth, maxheight;
uae_u32 colorkey;
- LPDIRECTDRAWSURFACE7 cursorsurface;
+ LPDIRECTDRAWSURFACE7 cursorsurface1;
+ LPDIRECTDRAWSURFACE7 cursorsurface2;
int cursorwidth, cursorheight;
};
extern struct ddstuff dxdata;
static uae_u32 lowmem (void)
{
uae_u32 change = 0;
- if (currprefs.z3fastmem_size >= 8 * 1024 * 1024 && currprefs.gfxmem_size < 64 * 1024 * 1024) {
- change = currprefs.z3fastmem_size - currprefs.z3fastmem_size / 2;
- currprefs.z3fastmem_size >>= 1;
- changed_prefs.z3fastmem_size = currprefs.z3fastmem_size;
- } else if (currprefs.gfxmem_size >= 8 * 1024 * 1024) {
+ if (currprefs.z3fastmem_size + currprefs.z3fastmem2_size >= 8 * 1024 * 1024) {
+ if (currprefs.z3fastmem2_size) {
+ if (currprefs.z3fastmem2_size <= 128 * 1024 * 1024) {
+ change = currprefs.z3fastmem2_size;
+ currprefs.z3fastmem2_size = 0;
+ } else {
+ change = currprefs.z3fastmem2_size / 2;
+ currprefs.z3fastmem2_size >>= 1;
+ changed_prefs.z3fastmem2_size = currprefs.z3fastmem2_size;
+ }
+ } else {
+ change = currprefs.z3fastmem_size - currprefs.z3fastmem_size / 4;
+ currprefs.z3fastmem2_size = changed_prefs.z3fastmem2_size = currprefs.z3fastmem_size / 4;
+ currprefs.z3fastmem_size >>= 1;
+ changed_prefs.z3fastmem_size = currprefs.z3fastmem_size;
+ }
+ } else if (currprefs.gfxmem_size >= 1 * 1024 * 1024) {
change = currprefs.gfxmem_size - currprefs.gfxmem_size / 2;
currprefs.gfxmem_size >>= 1;
changed_prefs.gfxmem_size = currprefs.gfxmem_size;
rtgbarrier = si.dwPageSize;
if (currprefs.cpu_model >= 68020)
size = 0x10000000;
- if (currprefs.z3fastmem_size) {
- z3size = currprefs.z3fastmem_size + (currprefs.z3fastmem_start - 0x10000000);
+ if (currprefs.z3fastmem_size || currprefs.z3fastmem2_size) {
+ z3size = currprefs.z3fastmem_size + currprefs.z3fastmem2_size + (currprefs.z3fastmem_start - 0x10000000);
if (currprefs.gfxmem_size)
rtgbarrier = 16 * 1024 * 1024;
} else {
break;
}
write_log ("NATMEM: %dM area failed to allocate, err=%d (Z3=%dM,RTG=%dM)\n",
- natmemsize >> 20, GetLastError (), currprefs.z3fastmem_size >> 20, currprefs.gfxmem_size >> 20);
+ natmemsize >> 20, GetLastError (), (currprefs.z3fastmem_size + currprefs.z3fastmem2_size) >> 20, currprefs.gfxmem_size >> 20);
if (!lowmem ()) {
write_log ("NATMEM: No special area could be allocated (2)!\n");
return 0;
}
if(!strcmp(shmids[shmid].name,"z3")) {
shmaddr=natmem_offset + currprefs.z3fastmem_start;
+ if (!currprefs.z3fastmem2_size)
+ size += BARRIER;
+ got = TRUE;
+ }
+ if(!strcmp(shmids[shmid].name,"z3_2")) {
+ shmaddr=natmem_offset + currprefs.z3fastmem_start + currprefs.z3fastmem_size;
size += BARRIER;
got = TRUE;
}
result = virtualallocwithlock (shmaddr, size, MEM_COMMIT, protect);
if (result == NULL) {
result = (void*)-1;
- write_log ("VirtualAlloc %08.8X - %08.8X %x (%dk) failed %d\n",
+ write_log ("VirtualAlloc %08X - %08X %x (%dk) failed %d\n",
(uae_u8*)shmaddr - natmem_offset, (uae_u8*)shmaddr - natmem_offset + size,
- size, size >> 10, GetLastError());
+ size, size >> 10, GetLastError ());
} else {
shmids[shmid].attached = result;
- write_log ("VirtualAlloc %08.8X - %08.8X %x (%dk) ok%s\n",
+ write_log ("VirtualAlloc %08X - %08X %x (%dk) ok%s\n",
(uae_u8*)shmaddr - natmem_offset, (uae_u8*)shmaddr - natmem_offset + size,
size, size >> 10, p96special ? " P96" : "");
}
fx1 = remcursor_x;
fy1 = remcursor_y;
- fx2 = fx1 + remcursor_h;
- fy2 = fy1 + remcursor_w;
+ fx2 = fx1 + remcursor_w;
+ fy2 = fy1 + remcursor_h;
remcursor_x = x;
remcursor_y = y;
static uae_u32 setspriteimage (uaecptr bi);
static void recursor (void)
{
- restoresurface (dxdata.cursorsurface);
- clearsurface (dxdata.cursorsurface);
+ restoresurface (dxdata.cursorsurface1);
+ restoresurface (dxdata.cursorsurface2);
+ clearsurface (dxdata.cursorsurface1);
+ clearsurface (dxdata.cursorsurface2);
reloadcursor = 1;
cursorok = FALSE;
setspriteimage (cursorbi);
cursor_r1.bottom += ydiff;
cursor_r2.left = 0;
- cursor_r2.top = cursorheight;
+ cursor_r2.top = 0;
cursor_r2.right = cursorwidth + xdiff + xdiff2;
- cursor_r2.bottom = cursorheight + cursorheight + ydiff + ydiff2;
+ cursor_r2.bottom = cursorheight + ydiff + ydiff2;
- ddrval = IDirectDrawSurface7_Blt (dxdata.cursorsurface, &cursor_r2, dstsurf, &cursor_r1, DDBLT_WAIT, NULL);
+ ddrval = IDirectDrawSurface7_Blt (dxdata.cursorsurface2, &cursor_r2, dstsurf, &cursor_r1, DDBLT_WAIT, NULL);
if (FAILED (ddrval)) {
if (ddrval != DDERR_SURFACELOST)
write_log ("Cursor surface blit1 failed: %s\n", DXError (ddrval));
cursor_r2.right = cursor_r2.left + cursorwidth + xdiff + xdiff2;
cursor_r2.bottom = cursor_r2.top + cursorheight + ydiff + ydiff2;
- ddrval = IDirectDrawSurface7_Blt (dstsurf, &cursor_r1, dxdata.cursorsurface, &cursor_r2, DDBLT_WAIT | DDBLT_KEYSRC, NULL);
+ ddrval = IDirectDrawSurface7_Blt (dstsurf, &cursor_r1, dxdata.cursorsurface1, &cursor_r2, DDBLT_WAIT | DDBLT_KEYSRC, NULL);
if (FAILED (ddrval)) {
if (ddrval != DDERR_SURFACELOST)
write_log ("Cursor surface blit2 failed: %s\n", DXError (ddrval));
}
cursor_r2.left = 0;
- cursor_r2.top = cursorheight;
+ cursor_r2.top = 0;
cursor_r2.right = cursorwidth + xdiff + xdiff2;
- cursor_r2.bottom = cursorheight + cursorheight + ydiff + ydiff2;
+ cursor_r2.bottom = cursorheight + ydiff + ydiff2;
mouseput = 1;
}
return;
mouseput = 0;
- ddrval = IDirectDrawSurface7_Blt (dstsurf, &cursor_r1, dxdata.cursorsurface, &cursor_r2, DDBLT_WAIT, NULL);
+ ddrval = IDirectDrawSurface7_Blt (dstsurf, &cursor_r1, dxdata.cursorsurface2, &cursor_r2, DDBLT_WAIT, NULL);
if (FAILED(ddrval)) {
if (ddrval != DDERR_SURFACELOST)
write_log ("Cursor surface clearblit failed: %s\n", DXError (ddrval));
int w, h;
cursordeactivate = 0;
- if (!hwsprite || !dxdata.cursorsurface)
+ if (!hwsprite || !dxdata.cursorsurface1)
return 0;
oldcursor_x = -10000;
w = (uae_u32)get_byte (bi + PSSO_BoardInfo_MouseWidth);
if (!reloadcursor && w == cursorwidth && h == cursorheight) {
int different = 0;
desc.dwSize = sizeof (desc);
- ddrval = DD_OK;
- while (FAILED (ddrval = IDirectDrawSurface7_Lock (dxdata.cursorsurface, NULL, &desc, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL))) {
+ while (FAILED ((ddrval = IDirectDrawSurface7_Lock (dxdata.cursorsurface1, NULL, &desc, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL)))) {
if (ddrval == DDERR_SURFACELOST) {
- ddrval = IDirectDrawSurface7_Restore (dxdata.cursorsurface);
+ ddrval = IDirectDrawSurface7_Restore (dxdata.cursorsurface1);
if (FAILED (ddrval))
break;
}
if (memcmp (p1, p2, w * bpp))
different = 1;
}
- IDirectDrawSurface_Unlock (dxdata.cursorsurface, NULL);
+ IDirectDrawSurface_Unlock (dxdata.cursorsurface1, NULL);
if (!different) {
P96TRACE_SPR (("sprite was same as previously\n"));
ret = 1;
cursorheight = h;
desc.dwSize = sizeof (desc);
- while (FAILED(ddrval = IDirectDrawSurface7_Lock (dxdata.cursorsurface, NULL, &desc, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL))) {
+ while (FAILED((ddrval = IDirectDrawSurface7_Lock (dxdata.cursorsurface1, NULL, &desc, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL)))) {
if (ddrval == DDERR_SURFACELOST) {
- ddrval = IDirectDrawSurface7_Restore (dxdata.cursorsurface);
+ ddrval = IDirectDrawSurface7_Restore (dxdata.cursorsurface1);
if (FAILED(ddrval)) {
write_log ("sprite surface failed to restore: %s\n", DXError (ddrval));
goto end;
uae_u8 *p2 = dptr + pitch * y;
memcpy (p2, p1, w * bpp);
}
- IDirectDrawSurface_Unlock (dxdata.cursorsurface, NULL);
+ IDirectDrawSurface_Unlock (dxdata.cursorsurface1, NULL);
ret = 1;
reloadcursor = 0;
cursorok = TRUE;
while (missmodes[misscnt * 2] == 0)
misscnt++;
if (missmodes[misscnt * 2] >= 0) {
- if (DisplayModes[i].res.width > missmodes[misscnt * 2 + 0] || DisplayModes[i].res.height > missmodes[misscnt * 2 + 1]) {
- int depth;
- int w = DisplayModes[i].res.width;
- int h = DisplayModes[i].res.height;
- for (depth = 8; depth <= 32; depth++) {
- struct PicassoResolution *pr = &newmodes[cnt];
- if (!p96depth (depth))
- continue;
- memcpy (pr, &DisplayModes[i], sizeof (struct PicassoResolution));
- pr->res.width = missmodes[misscnt * 2 + 0];
- pr->res.height = missmodes[misscnt * 2 + 1];
- sprintf (pr->name, "%dx%dx%d FAKE", pr->res.width, pr->res.height, depth);
- size += PSSO_ModeInfo_sizeof;
- }
+ int w = DisplayModes[i].res.width;
+ int h = DisplayModes[i].res.height;
+ if (w > missmodes[misscnt * 2 + 0] || h > missmodes[misscnt * 2 + 1]) {
+ struct PicassoResolution *pr = &newmodes[cnt];
+ memcpy (pr, &DisplayModes[i], sizeof (struct PicassoResolution));
+ pr->res.width = missmodes[misscnt * 2 + 0];
+ pr->res.height = missmodes[misscnt * 2 + 1];
+ sprintf (pr->name, "%dx%d FAKE", pr->res.width, pr->res.height);
+ size += PSSO_ModeInfo_sizeof * depths;
+ cnt++;
misscnt++;
continue;
}
struct LibResolution res = { 0 };
j = i;
addmode (AmigaBoardInfo, &amem, &res, newmodes[i].res.width, newmodes[i].res.height, NULL, -1, &unkcnt);
+ write_log ("%08X %4dx%4d %s\n", res.DisplayID, res.Width, res.Height, res.Name);
while (newmodes[i].depth >= 0
&& newmodes[i].res.width == newmodes[j].res.width
&& newmodes[i].res.height == newmodes[j].res.height)
case RPIPCGM_VOLUME: return "RPIPCGM_VOLUME";
case RPIPCGM_DEVICECONTENT: return "RPIPCGM_DEVICECONTENT";
case RPIPCGM_DEVICESEEK: return "RPIPCGM_DEVICESEEK";
-
+ case RPIPCGM_ESCAPED: return "RPIPCGM_ESCAPED";
case RPIPCHM_CLOSE: return "RPIPCHM_CLOSE";
case RPIPCHM_SCREENMODE: return "RPIPCHM_SCREENMODE";
case RPIPCHM_SCREENCAPTURE: return "RPIPCHM_SCREENCAPTURE";
TranslateMessage (&msg);
DispatchMessage (&msg);
}
- sleep_millis (50);
+ sleep_millis (20);
inputdevicefunc_keyboard.read ();
inputdevicefunc_mouse.read ();
inputdevicefunc_joystick.read ();
#define GETBDM(x) (((x) - ((x / 10000) * 10000)) / 100)
#define GETBDD(x) ((x) % 100)
-#define WINUAEBETA 16
+#define WINUAEBETA 17
#define WINUAEPUBLICBETA 1
-#define WINUAEDATE MAKEBD(2008, 5, 4)
+#define WINUAEDATE MAKEBD(2008, 5, 10)
#define WINUAEEXTRA ""
#define WINUAEREV ""
void centerdstrect (RECT *dr)
{
if(!(currentmode->flags & (DM_DX_FULLSCREEN | DM_W_FULLSCREEN)))
- OffsetRect(dr, amigawin_rect.left, amigawin_rect.top);
+ OffsetRect (dr, amigawin_rect.left, amigawin_rect.top);
if (currentmode->flags & DM_W_FULLSCREEN) {
if (currentmode->fullfill && (currentmode->current_width > currentmode->native_width || currentmode->current_height > currentmode->native_height))
return;
picasso96_state.Height != wc->current_height)
return 1;
if (picasso96_state.Width == wc->current_width &&
- picasso96_state.Height == wc->current_height &&
- picasso96_state.BytesPerPixel * 8 == wc->current_depth)
- return 0;
+ picasso96_state.Height == wc->current_height) {
+ if (picasso96_state.BytesPerPixel * 8 == wc->current_depth)
+ return 0;
+ if (!currprefs.win32_rtgmatchdepth && wc->current_depth >= 16)
+ return 0;
+ }
return 1;
} else {
if (currentmode->current_width != wc->current_width ||
getbestmode (0);
}
- if (rp_isactive ()) {
+ if (rp_isactive () && !dxfs && !fsw) {
HWND parent = rp_getparent ();
hAmigaWnd = CreateWindowEx (dxfs ? WS_EX_ACCEPTFILES | WS_EX_TOPMOST : WS_EX_ACCEPTFILES | WS_EX_TOOLWINDOW | (currprefs.win32_alwaysontop ? WS_EX_TOPMOST : 0),
"AmigaPowah", "WinUAE",
#define MIN_SLOW_MEM 0
#define MAX_SLOW_MEM 4
#define MIN_Z3_MEM 0
-#define MAX_Z3_MEM ((max_z3fastmem >> 20) < 512 ? 9 : ((max_z3fastmem >> 20) < 1024 ? 10 : ((max_z3fastmem >> 20) < 2048) ? 11 : 12))
+#define MAX_Z3_MEM ((max_z3fastmem >> 20) < 512 ? 12 : ((max_z3fastmem >> 20) < 1024 ? 13 : ((max_z3fastmem >> 20) < 2048) ? 14 : 16))
#define MIN_P96_MEM 0
#define MAX_P96_MEM ((max_z3fastmem >> 20) < 512 ? 8 : ((max_z3fastmem >> 20) < 1024 ? 9 : ((max_z3fastmem >> 20) < 2048) ? 10 : 11))
#define MIN_MB_MEM 0
/* 14*/ "1.5MB",
/* 15*/ "1.8MB",
/* 16*/ "2 GB",
+/* 17*/ "384 MB",
+/* 18*/ "768 MB",
+/* 19*/ "1.5 GB",
};
static unsigned long memsizes[] = {
/* 0 */ 0,
-/* 1 */ 0x00040000, /* 256-K */
-/* 2 */ 0x00080000, /* 512-K */
-/* 3 */ 0x00100000, /* 1-meg */
-/* 4 */ 0x00200000, /* 2-meg */
-/* 5 */ 0x00400000, /* 4-meg */
-/* 6 */ 0x00800000, /* 8-meg */
-/* 7 */ 0x01000000, /* 16-meg */
-/* 8 */ 0x02000000, /* 32-meg */
-/* 9 */ 0x04000000, /* 64-meg */
-/* 10*/ 0x08000000, //128 Meg
-/* 11*/ 0x10000000, //256 Meg
-/* 12*/ 0x20000000, //512 Meg The correct size is set in mman.c
+/* 1 */ 0x00040000, /* 256K */
+/* 2 */ 0x00080000, /* 512K */
+/* 3 */ 0x00100000, /* 1M */
+/* 4 */ 0x00200000, /* 2M */
+/* 5 */ 0x00400000, /* 4M */
+/* 6 */ 0x00800000, /* 8M */
+/* 7 */ 0x01000000, /* 16M */
+/* 8 */ 0x02000000, /* 32M */
+/* 9 */ 0x04000000, /* 64M */
+/* 10*/ 0x08000000, //128M
+/* 11*/ 0x10000000, //256M
+/* 12*/ 0x20000000, //512M
/* 13*/ 0x40000000, //1GB
/* 14*/ 0x00180000, //1.5MB
/* 15*/ 0x001C0000, //1.8MB
/* 16*/ 0x80000000, //2GB
+/* 17*/ 0x18000000, //384M
+/* 18*/ 0x30000000, //768M
+/* 19*/ 0x60000000, //1.5GB
};
-static int msi_chip[] = { 1, 2, 3, 4, 5, 6 };
+static int msi_chip[] = { 1, 2, 3, 14, 4, 5, 6 };
static int msi_bogo[] = { 0, 2, 3, 14, 15 };
static int msi_fast[] = { 0, 3, 4, 5, 6 };
-static int msi_z3fast[] = { 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16 };
+static int msi_z3fast[] = { 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 12, 18, 13, 19, 16 };
static int msi_gfx[] = { 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
static int CalculateHardfileSize (HWND hDlg)
static void values_to_memorydlg (HWND hDlg)
{
uae_u32 mem_size = 0;
+ uae_u32 v;
switch (workprefs.chipmem_size) {
case 0x00040000: mem_size = 0; break;
case 0x00080000: mem_size = 1; break;
case 0x00100000: mem_size = 2; break;
- case 0x00200000: mem_size = 3; break;
- case 0x00400000: mem_size = 4; break;
- case 0x00800000: mem_size = 5; break;
+ case 0x00180000: mem_size = 3; break;
+ case 0x00200000: mem_size = 4; break;
+ case 0x00400000: mem_size = 5; break;
+ case 0x00800000: mem_size = 6; break;
}
SendDlgItemMessage (hDlg, IDC_CHIPMEM, TBM_SETPOS, TRUE, mem_size);
SetDlgItemText (hDlg, IDC_CHIPRAM, memsize_names[msi_chip[mem_size]]);
SetDlgItemText (hDlg, IDC_SLOWRAM, memsize_names[msi_bogo[mem_size]]);
mem_size = 0;
- switch (workprefs.z3fastmem_size) {
- case 0x00000000: mem_size = 0; break; /* 0-megs */
- case 0x00100000: mem_size = 1; break; /* 1-megs */
- case 0x00200000: mem_size = 2; break; /* 2-megs */
- case 0x00400000: mem_size = 3; break; /* 4-megs */
- case 0x00800000: mem_size = 4; break; /* 8-megs */
- case 0x01000000: mem_size = 5; break; /* 16-megs */
- case 0x02000000: mem_size = 6; break; /* 32-megs */
- case 0x04000000: mem_size = 7; break; /* 64-megs */
- case 0x08000000: mem_size = 8; break; /* 128-megs */
- case 0x10000000: mem_size = 9; break; /* 256-megs */
- case 0x20000000: mem_size = 10; break; /* 512-megs */
- case 0x40000000: mem_size = 11; break; /* 1 GB */
- case 0x80000000: mem_size = 12; break; /* 2 GB */
-
- }
+ v = workprefs.z3fastmem_size + workprefs.z3fastmem2_size;
+ if (v < 0x00100000)
+ mem_size = 0;
+ else if (v < 0x00200000)
+ mem_size = 1;
+ else if (v < 0x00400000)
+ mem_size = 2;
+ else if (v < 0x00800000)
+ mem_size = 3;
+ else if (v < 0x01000000)
+ mem_size = 4;
+ else if (v < 0x02000000)
+ mem_size = 5;
+ else if (v < 0x04000000)
+ mem_size = 6;
+ else if (v < 0x08000000)
+ mem_size = 7;
+ else if (v < 0x10000000)
+ mem_size = 8;
+ else if (v < 0x18000000)
+ mem_size = 9;
+ else if (v < 0x20000000)
+ mem_size = 10;
+ else if (v < 0x30000000)
+ mem_size = 11;
+ else if (v < 0x40000000)
+ mem_size = 12;
+ else if (v < 0x60000000)
+ mem_size = 13;
+ else if (v < 0x80000000)
+ mem_size = 14;
+ else
+ mem_size = 15;
SendDlgItemMessage (hDlg, IDC_Z3FASTMEM, TBM_SETPOS, TRUE, mem_size);
SetDlgItemText (hDlg, IDC_Z3FASTRAM, memsize_names[msi_z3fast[mem_size]]);
if (workprefs.chipmem_size > 0x200000)
workprefs.fastmem_size = 0;
}
+static void updatez3 (uae_u32 *size1p, uae_u32 *size2p)
+{
+ int i;
+ uae_u32 s1, s2;
+
+ s1 = *size1p;
+ *size1p = 0;
+ *size2p = 0;
+ s2 = 0;
+ for (i = 32; i >= 0; i--) {
+ if (s1 & (1 << i))
+ break;
+ }
+ if (i < 20)
+ return;
+ if (s1 == (1 << i)) {
+ *size1p = s1;
+ return;
+ }
+ s2 = s1 & ((1 << i) - 1);
+ s1 = 1 << i;
+ i--;
+ while (i >= 0) {
+ if (s2 & (1 << i)) {
+ s2 = 1 << i;
+ break;
+ }
+ i--;
+ }
+ if (i < 19)
+ s2 = 0;
+ *size1p = s1;
+ *size2p = s2;
+}
static INT_PTR CALLBACK MemoryDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
workprefs.bogomem_size = memsizes[msi_bogo[SendMessage (GetDlgItem (hDlg, IDC_SLOWMEM), TBM_GETPOS, 0, 0)]];
workprefs.fastmem_size = memsizes[msi_fast[SendMessage (GetDlgItem (hDlg, IDC_FASTMEM), TBM_GETPOS, 0, 0)]];
workprefs.z3fastmem_size = memsizes[msi_z3fast[SendMessage (GetDlgItem (hDlg, IDC_Z3FASTMEM), TBM_GETPOS, 0, 0)]];
+ updatez3 (&workprefs.z3fastmem_size, &workprefs.z3fastmem2_size);
workprefs.gfxmem_size = memsizes[msi_gfx[SendMessage (GetDlgItem (hDlg, IDC_P96MEM), TBM_GETPOS, 0, 0)]];
workprefs.mbresmem_low_size = memsizes[msi_gfx[SendMessage (GetDlgItem (hDlg, IDC_MBMEM1), TBM_GETPOS, 0, 0)]];
workprefs.mbresmem_high_size = memsizes[msi_gfx[SendMessage (GetDlgItem (hDlg, IDC_MBMEM2), TBM_GETPOS, 0, 0)]];
+Beta 17:
+
+- hardware mouse cursor trails fixed when cursor height > width
+- fullscreen to fullscreen picasso96 mode switching work properly
+ when "Match host and RTG color depth if possible" is off
+ (instant switch without resetting display mode)
+- Picasso96 "fake" (320x200 etc..) display resolutions fixed
+ (resolutions disappeared few betas ago)
+- added 1.5M chip ram option (A500Plus + 0.5M trap door expansion)
+ NOTE: do not use with JIT, JIT does not like non-power-of-2 RAM
+- added 384M/768M/1.5G Z3 RAM options (enables second Z3 RAM board,
+ 384M = 256M+128M, 768M = 512M+256M...) Why? Because on most PCs
+ 1G is not possible (without having 64-bit OS) but 768M is usually
+ possible and lots of RAM is fun and pointless :)
+- Z3 RAM is now always mapped (more compatible with some reset proof
+ programs)
+
Beta 16:
- winuaebootlog.txt and winuaelog.txt (if enabled) is written to crash
more Windows-like (input is read as long as program has focus)
- "Match host and RTG color depth if possible" set and 24-bit fullscreen
Picasso96 mode selected -> use 32-bit native mode
-- Picasso96 hardware mouse cursor fixed in 8/16-bit modes
+- fixed corrupted Picasso96 hardware mouse cursor in 8/16-bit modes
Beta 15:
char name[5];
size_t len, totallen;
size_t filepos, filesize;
+ int z3num;
chunk = 0;
f = zfile_fopen (filename, "rb");
changed_prefs.chipmem_size = 0;
changed_prefs.fastmem_size = 0;
changed_prefs.z3fastmem_size = 0;
+ changed_prefs.z3fastmem2_size = 0;
changed_prefs.mbresmem_low_size = 0;
changed_prefs.mbresmem_high_size = 0;
+ z3num = 0;
savestate_state = STATE_RESTORE;
for (;;) {
name[0] = 0;
restore_fram (totallen, filepos);
continue;
} else if (!strcmp (name, "ZRAM")) {
- restore_zram (totallen, filepos);
+ restore_zram (totallen, filepos, z3num++);
continue;
} else if (!strcmp (name, "BORO")) {
restore_bootrom (totallen, filepos);
#ifdef AUTOCONFIG
dst = save_fram (&len);
save_chunk (f, dst, len, "FRAM", comp);
- dst = save_zram (&len);
+ dst = save_zram (&len, 0);
+ save_chunk (f, dst, len, "ZRAM", comp);
+ dst = save_zram (&len, 1);
save_chunk (f, dst, len, "ZRAM", comp);
dst = save_bootrom (&len);
save_chunk (f, dst, len, "BORO", comp);
memcpy (save_fram (&dummy), p, currprefs.fastmem_size > len ? len : currprefs.fastmem_size);
p += len;
len = restore_u32_func (&p);
- memcpy (save_zram (&dummy), p, currprefs.z3fastmem_size > len ? len : currprefs.z3fastmem_size);
+ memcpy (save_zram (&dummy, 0), p, currprefs.z3fastmem_size > len ? len : currprefs.z3fastmem_size);
p += len;
#endif
#ifdef ACTION_REPLAY
memcpy (p, dst, len);
tlen += len + 4;
p += len;
- dst = save_zram (&len);
+ dst = save_zram (&len, 0);
if (bufcheck (&p, len))
goto retry;
save_u32_func (&p, len);
projects / francis / winuae.git / commitdiff