framecounter--;
if (framecounter <= 0) {
if (cdrom_playing || cdrom_toc_counter > 0)
- gui_cd_led (1);
+ gui_cd_led (0, 1);
cdrom_run_read ();
framecounter = 1000000 / (74 * 75 * cdrom_speed);
set_status(CDSTATUS_FRAME);
do_stch();
}
if (cd_playing)
- gui_cd_led (1);
+ gui_cd_led (0, 1);
if (cd_media && (tp_cr & 1)) {
tp_air |= 1 << 1;
INT2();
cfgfile_dwrite (f, "ciaatod=%s\n", ciaatodmode[p->cs_ciaatod]);
cfgfile_dwrite (f, "rtc=%s\n", rtctype[p->cs_rtc]);
//cfgfile_dwrite (f, "chipset_rtc_adjust=%d\n", p->cs_rtc_adjust);
- cfgfile_dwrite (f, "ksmirror=%s\n", ksmirrortype[p->cs_ksmirror]);
+ cfgfile_dwrite (f, "ksmirror_e0=%s\n", p->cs_ksmirror_e0 ? "true" : "false");
+ cfgfile_dwrite (f, "ksmirror_a8=%s\n", p->cs_ksmirror_a8 ? "true" : "false");
cfgfile_dwrite (f, "cd32cd=%s\n", p->cs_cd32cd ? "true" : "false");
cfgfile_dwrite (f, "cd32c2p=%s\n", p->cs_cd32c2p ? "true" : "false");
cfgfile_dwrite (f, "cd32nvram=%s\n", p->cs_cd32nvram ? "true" : "false");
cfgfile_dwrite (f, "scsi_a3000=%s\n", p->cs_mbdmac == 1 ? "true" : "false");
cfgfile_dwrite (f, "scsi_a4000t=%s\n", p->cs_mbdmac == 2 ? "true" : "false");
cfgfile_dwrite (f, "bogomem_fast=%s\n", p->cs_slowmemisfast ? "true" : "false");
+ cfgfile_dwrite (f, "resetwarning=%s\n", p->cs_resetwarning ? "true" : "false");
cfgfile_write (f, "fastmem_size=%d\n", p->fastmem_size / 0x100000);
cfgfile_write (f, "a3000mem_size=%d\n", p->mbresmem_low_size / 0x100000);
|| cfgfile_yesno (option, value, "scsi_cdtv", &p->cs_cdtvscsi)
|| cfgfile_yesno (option, value, "scsi_a4091", &p->cs_a4091)
|| cfgfile_yesno (option, value, "scsi_a2091", &p->cs_a2091)
+ || cfgfile_yesno (option, value, "cia_overlay", &p->cs_ciaoverlay)
|| cfgfile_yesno (option, value, "bogomem_fast", &p->cs_slowmemisfast)
+ || cfgfile_yesno (option, value, "ksmirror_e0", &p->cs_ksmirror_e0)
+ || cfgfile_yesno (option, value, "ksmirror_a8", &p->cs_ksmirror_a8)
+ || cfgfile_yesno (option, value, "resetwarning", &p->cs_resetwarning)
|| cfgfile_yesno (option, value, "kickshifter", &p->kickshifter)
|| cfgfile_yesno (option, value, "ntsc", &p->ntscmode)
if (cfgfile_strval (option, value, "comp_trustbyte", &p->comptrustbyte, compmode, 0)
|| cfgfile_strval (option, value, "chipset_compatible", &p->cs_compatible, cscompa, 0)
|| cfgfile_strval (option, value, "rtc", &p->cs_rtc, rtctype, 0)
- || cfgfile_strval (option, value, "ksmirror", &p->cs_ksmirror, ksmirrortype, 0)
+ || cfgfile_strval (option, value, "ksmirror", &p->cs_ksmirror_e0, ksmirrortype, 0)
|| cfgfile_strval (option, value, "ciaatod", &p->cs_ciaatod, ciaatodmode, 0)
|| cfgfile_strval (option, value, "ide", &p->cs_ide, idemode, 0)
|| cfgfile_strval (option, value, "scsi", &p->scsi, scsimode, 0)
p->cs_cd32c2p = p->cs_cd32cd = p->cs_cd32nvram = 0;
p->cs_cdtvcd = p->cs_cdtvram = p->cs_cdtvcard = 0;
p->cs_pcmcia = 0;
- p->cs_ksmirror = 1;
+ p->cs_ksmirror_e0 = 1;
+ p->cs_ksmirror_a8 = 0;
+ p->cs_ciaoverlay = 1;
p->cs_ciaatod = 0;
p->cs_df0idhw = 1;
p->cs_slowmemisfast = 0;
+ p->cs_resetwarning = 1;
p->gfx_filter = 0;
p->gfx_filter_horiz_zoom_mult = 1000;
p->z3fastmem_size = 0x00000000;
p->gfxmem_size = 0x00000000;
- p->cs_rtc = 1;
+ p->cs_rtc = 0;
p->cs_a1000ram = 0;
p->cs_fatgaryrev = -1;
p->cs_ramseyrev = -1;
p->cs_cdtvcd = p->cs_cdtvram = p->cs_cdtvcard = 0;
p->cs_ide = 0;
p->cs_pcmcia = 0;
- p->cs_ksmirror = 1;
+ p->cs_ksmirror_e0 = 1;
+ p->cs_ksmirror_a8 = 0;
+ p->cs_ciaoverlay = 1;
p->cs_ciaatod = 0;
p->cs_df0idhw = 1;
+ p->cs_resetwarning = 0;
strcpy (p->romfile, "");
strcpy (p->romextfile, "");
roms[1] = 31;
roms[2] = 15;
roms[3] = -1;
+ p->cs_rtc = 0;
if (config == 1) {
p->fastmem_size = 0x400000;
p->cs_rtc = 2;
roms[3] = -1;
p->bogomem_size = 0;
p->chipmem_size = 0x100000;
+ if (config > 0)
+ p->cs_rtc = 1;
if (config == 1)
p->chipmem_size = 0x200000;
if (config == 2)
roms[1] = -1;
p->bogomem_size = 0;
p->chipmem_size = 0x100000;
+ if (config > 0)
+ p->cs_rtc = 1;
if (config == 1)
p->chipmem_size = 0x200000;
if (config == 2)
built_in_chipset_prefs (p);
p->cs_ide = -1;
p->cs_ciaatod = p->ntscmode ? 2 : 1;
- strcat(p->flashfile, "battclock.nvr");
+ //strcat(p->flashfile, "battclock.nvr");
return configure_rom (p, roms, romcheck);
}
p->cs_mbdmac = 0;
p->cs_a2091 = 0;
p->cs_pcmcia = 0;
- p->cs_ksmirror = 1;
+ p->cs_ksmirror_e0 = 1;
+ p->cs_ciaoverlay = 1;
p->cs_ciaatod = 0;
p->cs_df0idhw = 1;
+ p->cs_resetwarning = 1;
switch (p->cs_compatible)
{
p->cs_rtc = 1;
p->cs_cdtvcd = p->cs_cdtvram = 1;
p->cs_df0idhw = 1;
- p->cs_ksmirror = 0;
+ p->cs_ksmirror_e0 = 0;
break;
case CP_CD32: // CD32
p->cs_cd32c2p = p->cs_cd32cd = p->cs_cd32nvram = 1;
- p->cs_ksmirror = 0;
+ p->cs_ksmirror_e0 = 0;
+ p->cs_ksmirror_a8 = 1;
+ p->cs_ciaoverlay = 0;
+ p->cs_resetwarning = 0;
break;
case CP_A500: // A500
p->cs_df0idhw = 0;
+ p->cs_resetwarning = 0;
break;
case CP_A500P: // A500+
+ p->cs_resetwarning = 0;
break;
case CP_A600: // A600
p->cs_ide = 1;
p->cs_pcmcia = 1;
+ p->cs_ksmirror_a8 = 1;
+ p->cs_ciaoverlay = 0;
+ p->cs_resetwarning = 0;
break;
case CP_A1000: // A1000
p->cs_a1000ram = 1;
p->cs_ciaatod = p->ntscmode ? 2 : 1;
- p->cs_ksmirror = 0;
+ p->cs_ksmirror_e0 = 0;
p->cs_rtc = 0;
p->chipset_mask |= CSMASK_BLTBUSY_BUG;
break;
case CP_A1200: // A1200
p->cs_ide = 1;
p->cs_pcmcia = 1;
- p->cs_ksmirror = 2;
+ p->cs_ksmirror_a8 = 1;
+ p->cs_ciaoverlay = 0;
break;
case CP_A2000: // A2000
p->cs_rtc = 1;
p->cs_ciaatod = p->ntscmode ? 2 : 1;
break;
- break;
case CP_A3000: // A3000
p->cs_rtc = 2;
p->cs_fatgaryrev = 0;
p->cs_ramseyrev = 0x0f;
p->cs_ide = 2;
p->cs_mbdmac = 0;
+ p->cs_ksmirror_a8 = 1;
+ p->cs_ciaoverlay = 0;
break;
case CP_A4000T: // A4000T
p->cs_rtc = 2;
p->cs_ramseyrev = 0x0f;
p->cs_ide = 2;
p->cs_mbdmac = 2;
+ p->cs_ksmirror_a8 = 1;
+ p->cs_ciaoverlay = 0;
break;
}
return 1;
#include "debug.h"
#include "arcadia.h"
#include "audio.h"
+#include "keyboard.h"
+#include "uae.h"
#include "amax.h"
//#define CIAA_DEBUG_R
}
}
+static int resetwarning_phase, resetwarning_timer;
+
+static void setcode (uae_u8 keycode)
+{
+ ciaasdr = ~((keycode << 1) | (keycode >> 7));
+}
+
+static void sendrw (void)
+{
+ setcode (AK_RESETWARNING);
+ ciaaicr |= 8;
+ ciaasdr_unread = 1;
+ RethinkICRA ();
+ write_log ("KB: sent reset warning code (phase=%d)\n", resetwarning_phase);
+}
+
+int resetwarning_do (int canreset)
+{
+ if (resetwarning_phase) {
+ /* just force reset if second reset happens during resetwarning */
+ if (canreset) {
+ resetwarning_phase = 0;
+ resetwarning_timer = 0;
+ }
+ return 0;
+ }
+ resetwarning_phase = 1;
+ resetwarning_timer = maxvpos * 5;
+ write_log ("KB: reset warning triggered\n");
+ sendrw ();
+ return 1;
+}
+
+static void resetwarning_check (void)
+{
+ if (resetwarning_timer > 0) {
+ resetwarning_timer--;
+ if (resetwarning_timer <= 0) {
+ write_log ("KB: reset warning forced reset. Phase=%d\n", resetwarning_phase);
+ resetwarning_phase = -1;
+ uae_reset (0);
+ }
+ }
+ if (resetwarning_phase == 1) {
+ if (kback && !(ciaacra & 0x40) && ciaasdr_unread == 2) {
+ write_log ("KB: reset warning second phase..\n");
+ resetwarning_phase = 2;
+ resetwarning_timer = maxvpos * 5;
+ sendrw ();
+ }
+ } else if (resetwarning_phase == 2) {
+ if (ciaacra & 0x40) {
+ resetwarning_phase = 3;
+ write_log ("KB: reset warning SP = output\n");
+ resetwarning_timer = 10 * maxvpos * vblank_hz; /* wait max 10s */
+ }
+ } else if (resetwarning_phase == 3) {
+ if (!(ciaacra & 0x40)) {
+ write_log ("KB: reset warning end by software. reset.\n");
+ resetwarning_phase = -1;
+ uae_reset (0);
+ }
+ }
+}
+
void CIA_hsync_handler (void)
{
if (ciabtodon) {
ciab_checkalarm (1);
}
- if (keys_available() && kback && (ciaacra & 0x40) == 0 && (hsync_counter & 15) == 0) {
+ if (resetwarning_phase) {
+ resetwarning_check ();
+ while (keys_available ())
+ get_next_key ();
+ } else if ((keys_available() || kbstate < 2) && kback && (ciaacra & 0x40) == 0 && (hsync_counter & 15) == 0) {
/*
* This hack lets one possible ciaaicr cycle go by without any key
* being read, for every cycle in which a key is pulled out of the
} else if (ciaasdr_unread == 0) {
switch (kbstate) {
case 0:
- ciaasdr = (uae_s8)~0xFB; /* aaarghh... stupid compiler */
+ setcode (AK_INIT_POWERUP);
kbstate++;
break;
case 1:
+ setcode (AK_TERM_POWERUP);
kbstate++;
- ciaasdr = (uae_s8)~0xFD;
break;
case 2:
ciaasdr = ~get_next_key();
oldovl = v & 1;
if (!oldovl || ersatzkickfile) {
map_overlay (1);
- } else if (!(currprefs.chipset_mask & CSMASK_AGA)) {
- /* pin disconnected in AGA chipset, CD audio mute on/off on CD32 */
+ } else if (currprefs.cs_ciaoverlay) {
+ /* Gayle does this internally, CIA pin disconnected, CD audio mute on/off on CD32 */
map_overlay (0);
}
}
serbits = 0;
oldovl = -1;
oldled = -1;
+ resetwarning_phase = resetwarning_timer = 0;
if (!savestate_state) {
ciaatlatch = ciabtlatch = 0;
addrbank clock_bank = {
clock_lget, clock_wget, clock_bget,
clock_lput, clock_wput, clock_bput,
- default_xlate, default_check, NULL, "Battery backed up clock",
+ default_xlate, default_check, NULL, "Battery backed up clock (none)",
dummy_lgeti, dummy_wgeti, ABFLAG_IO
};
" W <address> <value> Write into Amiga memory\n"
" w <num> <address> <length> <R/W/I/F> [<value>] (read/write/opcode/freeze)\n"
" Add/remove memory watchpoints\n"
- " wd [<0-1>] Enable illegal access logger. 1 = break when detected.\n"
+ " wd [<0-1>] Enable illegal access logger. 1 = enable break.\n"
" S <file> <addr> <n> Save a block of Amiga memory\n"
" s \"<string>\"/<values> [<addr>] [<length>]\n"
" Search for string/bytes\n"
" Also enables level 1 disk logging\n"
" did <log level> Enable disk logging\n"
" dj [<level bitmask>] Enable joystick/mouse input debugging\n"
- " smc [<0-1>] Enable self-modifying code detector. 1 = break when detected.\n"
+ " smc [<0-1>] Enable self-modifying code detector. 1 = enable break.\n"
" dm Dump current address space map\n"
+ " ?<value> Hex/Bin/Dec converter\n"
#ifdef _WIN32
" x Close debugger.\n"
" xx Switch between console and GUI debugger.\n"
console_out (help);
}
+static int debug_linecounter;
+#define MAX_LINECOUNTER 1000
+static int debug_out (const char *format,...)
+{
+ va_list parms;
+ char buffer[4000];
+
+ va_start (parms, format);
+ _vsnprintf (buffer, 4000 - 1, format, parms);
+ va_end (parms);
+
+ console_out (buffer);
+ if (debug_linecounter < MAX_LINECOUNTER)
+ debug_linecounter++;
+ if (debug_linecounter >= MAX_LINECOUNTER)
+ return 0;
+ return 1;
+}
static void ignore_ws (char **c)
{
}
static uae_u32 readint (char **c);
-static uae_u32 readhex (char **c)
+static uae_u32 readbin (char **c);
+static uae_u32 readhex (char **c);
+
+static int readregx (char **c, uae_u32 *valp)
+{
+ int i;
+ uae_u32 addr;
+ char *p = *c;
+ char tmp[10];
+ int extra = 0;
+
+ addr = 0;
+ i = 0;
+ while (p[i]) {
+ tmp[i] = toupper(p[i]);
+ if (i >= sizeof (tmp) - 1)
+ break;
+ i++;
+ }
+ tmp[i] = 0;
+ if (toupper (tmp[0]) == 'R') {
+ memmove (tmp, tmp + 1, sizeof (tmp) - 1);
+ extra = 1;
+ }
+ if (!strcmp(tmp, "USP")) {
+ addr = regs.usp;
+ (*c) += 3;
+ } else if (!strcmp(tmp, "VBR")) {
+ addr = regs.vbr;
+ (*c) += 3;
+ } else if (!strcmp(tmp, "MSP")) {
+ addr = regs.msp;
+ (*c) += 3;
+ } else if (!strcmp(tmp, "ISP")) {
+ addr = regs.isp;
+ (*c) += 3;
+ } else if (!strcmp(tmp, "PC")) {
+ addr = regs.pc;
+ (*c) += 2;
+ } else if (tmp[0] == 'A' || tmp[0] == 'D') {
+ int reg = 0;
+ if (tmp[0] == 'A')
+ reg += 8;
+ reg += tmp[1] - '0';
+ if (reg < 0 || reg > 15)
+ return 0;
+ addr = regs.regs[reg];
+ (*c) += 2;
+ } else {
+ return 0;
+ }
+ *valp = addr;
+ (*c) += extra;
+ return 1;
+}
+
+static uae_u32 readbinx (char **c)
{
uae_u32 val = 0;
- char nc;
ignore_ws (c);
- if (**c == '!' || **c == '_') {
+ for (;;) {
+ char nc = **c;
+ if (nc != '1' && nc != '0')
+ break;
(*c)++;
- return readint (c);
+ val <<= 1;
+ if (nc == '1')
+ val |= 1;
}
+ return val;
+}
+
+static uae_u32 readhexx (char **c)
+{
+ uae_u32 val = 0;
+ char nc;
+
+ ignore_ws (c);
while (isxdigit(nc = **c)) {
(*c)++;
val *= 16;
return val;
}
-static uae_u32 readint (char **c)
+static uae_u32 readintx (char **c)
{
uae_u32 val = 0;
char nc;
int negative = 0;
ignore_ws (c);
- if (**c == '$') {
- (*c)++;
- return readhex (c);
- }
- if (**c == '0' && toupper((*c)[1]) == 'X') {
- (*c)+= 2;
- return readhex (c);
- }
if (**c == '-')
negative = 1, (*c)++;
while (isdigit(nc = **c)) {
return val * (negative ? -1 : 1);
}
+
+static int checkvaltype (char **c, uae_u32 *val)
+{
+ char nc;
+
+ ignore_ws (c);
+ nc = toupper(**c);
+ if (nc == '!') {
+ (*c)++;
+ *val = readintx (c);
+ return 1;
+ }
+ if (nc == '$') {
+ (*c)++;
+ *val = readhexx (c);
+ return 1;
+ }
+ if (nc == '0' && toupper((*c)[1]) == 'X') {
+ (*c)+= 2;
+ *val = readhexx (c);
+ return 1;
+ }
+ if (nc == '%') {
+ (*c)++;
+ *val = readbinx (c);
+ return 1;
+ }
+ if (nc >= 'A' && nc <= 'Z' && nc != 'A' && nc != 'D') {
+ if (readregx (c, val))
+ return 1;
+ }
+ return 0;
+}
+
+static uae_u32 readint (char **c)
+{
+ uae_u32 val;
+ if (checkvaltype (c, &val))
+ return val;
+ return readintx (c);
+}
+static uae_u32 readhex (char **c)
+{
+ uae_u32 val;
+ if (checkvaltype (c, &val))
+ return val;
+ return readhexx (c);
+}
+static uae_u32 readbin (char **c)
+{
+ uae_u32 val;
+ if (checkvaltype (c, &val))
+ return val;
+ return readbinx (c);
+}
+
static char next_char(char **c)
{
ignore_ws (c);
return strlen (out);
}
+static void converter (char **c)
+{
+ uae_u32 v = readint (c);
+ char s[100];
+ char *p = s;
+ int i;
+
+ for (i = 0; i < 32; i++)
+ s[i] = (v & (1 << (31 - i))) ? '1' : '0';
+ s[i] = 0;
+ console_out ("0x%08X = %%%s = %u = %d\n", v, s, v, (uae_s32)v);
+}
+
static uae_u32 lastaddr (void)
{
if (currprefs.z3fastmem_size)
char line[MAX_LINEWIDTH + 1];
for (;lines--;) {
addr = dumpmem2 (addr, line, sizeof(line));
- console_out ("%s", line);
- console_out ("\n");
- }
- *nxmem = addr;
-}
-
-static void dumpmemreg (char **inptr)
-{
- int i;
- char *p = *inptr;
- uaecptr nxmem, addr;
- char tmp[10];
-
- addr = 0;
- i = 0;
- while (p[i]) {
- tmp[i] = toupper(p[i]);
- if (i >= sizeof (tmp) - 1)
+ debug_out ("%s", line);
+ if (!debug_out ("\n"))
break;
- i++;
}
- tmp[i] = 0;
- if (!strcmp(tmp, "USP"))
- addr = regs.usp;
- if (!strcmp(tmp, "VBR"))
- addr = regs.vbr;
- if (!strcmp(tmp, "MSP"))
- addr = regs.msp;
- if (!strcmp(tmp, "ISP"))
- addr = regs.isp;
- if (!strcmp(tmp, "PC"))
- addr = regs.pc;
- if (toupper(p[0]) == 'A' || toupper(p[0]) == 'D') {
- int reg = 0;
- if (toupper(p[0]) == 'A')
- reg += 8;
- reg += p[1] - '0';
- if (reg < 0 || reg > 15)
- return;
- addr = regs.regs[reg];
- }
- addr -= 16;
- dumpmem (addr, &nxmem, 20);
+ *nxmem = addr;
}
static void dump_custom_regs (int aga)
*p1++ = get_byte (i);
addr = end - 1;
}
- console_out("Deep trainer first pass complete.\n");
+ console_out ("Deep trainer first pass complete.\n");
return;
}
inconly = deconly = 0;
ignore_ws (c);
if (!more_params(c)) {
first = 1;
- console_out("search reset\n");
+ console_out ("search reset\n");
xfree (vlist);
listsize = memsize;
vlist = (uae_u8*)xcalloc (listsize >> 3, 1);
memset (illgdebug + 0xe00000, 1, 512 * 1024); /* CD32 ext ROM */
}
#endif
- if (currprefs.cs_ksmirror)
+ if (currprefs.cs_ksmirror_e0)
memset (illgdebug + 0xe00000, 1, 512 * 1024);
+ if (currprefs.cs_ksmirror_a8)
+ memset (illgdebug + 0xa80000, 1, 2 * 512 * 1024);
#ifdef FILESYS
if (uae_boot_rom) /* filesys "rom" */
memset (illgdebug + rtarea_base, 1, 0x10000);
initialize_memwatch (0);
if (v)
smc_mode = 1;
- console_out("SMCD enabled. Break=%d\n", smc_mode);
+ console_out ("SMCD enabled. Break=%d\n", smc_mode);
}
#define SMC_MAXHITS 8
}
if (hitcnt < 100) {
smc_table[hitaddr].cnt++;
- console_out("SMC at %08.8X - %08.8X (%d) from %08.8X\n",
+ console_out ("SMC at %08.8X - %08.8X (%d) from %08.8X\n",
hitaddr, hitaddr + hitcnt, hitcnt, hitpc);
if (smc_mode)
activate_debugger ();
if (smc_table[hitaddr].cnt >= SMC_MAXHITS)
- console_out("* hit count >= %d, future hits ignored\n", SMC_MAXHITS);
+ console_out ("* hit count >= %d, future hits ignored\n", SMC_MAXHITS);
}
}
memwatch_dump (num);
}
-static void writeintoreg (char **c)
-{
- char cc, cc2;
-
- ignore_ws(c);
- cc = toupper(*c[0]);
- cc2 = toupper(*c[1]);
- if ((cc == 'D' || cc == 'A') && cc2 >= '0' && cc2 <= '7') {
-
-
- }
-}
-
static void writeintomem (char **c)
{
uae_u32 addr = 0;
if (log)
write_log (txt);
else
- console_out(txt);
+ console_out (txt);
if (tmp[0]) {
if (log)
write_log (tmp);
else
- console_out(tmp);
+ console_out (tmp);
}
j = i;
a1 = a2;
(*inptr)++;
ignore_ws(inptr);
disk_debug_logging = readint(inptr);
- console_out("disk logging level %d\n", disk_debug_logging);
+ console_out ("disk logging level %d\n", disk_debug_logging);
return;
}
disk_debug_mode = 0;
if (disk_debug_logging == 0)
disk_debug_logging = 1;
end:
- console_out("disk breakpoint mode %c%c%c track %d\n",
+ console_out ("disk breakpoint mode %c%c%c track %d\n",
disk_debug_mode & DISK_DEBUG_DMA_READ ? 'R' : '-',
disk_debug_mode & DISK_DEBUG_DMA_WRITE ? 'W' : '-',
disk_debug_mode & DISK_DEBUG_PIO ? 'P' : '-',
{
uae_u32 ea, sea, dea;
uaecptr addr, end;
+ int hits = 0;
addr = 0;
end = lastaddr();
if (more_params(inptr))
end = readhex (inptr);
}
- console_out("Searching from %08.8X to %08.8X\n", addr, end);
+ console_out ("Searching from %08X to %08X\n", addr, end);
while((addr = nextaddr(addr, &end)) != 0xffffffff) {
if ((addr & 1) == 0 && addr + 6 <= end) {
sea = 0xffffffff;
dea = 0xffffffff;
m68k_disasm_ea (NULL, addr, NULL, 1, &sea, &dea);
- if (ea == sea || ea == dea)
+ if (ea == sea || ea == dea) {
m68k_disasm (stdout, addr, NULL, 1);
+ hits++;
+ if (hits > 100) {
+ write_log ("Too many hits. End addr = %08X\n", addr);
+ break;
+ }
+ }
}
}
}
} else if (!strcmp (parm, "CCR")) {
regs.sr = (regs.sr & ~31) | (v & 31);
MakeFromSR (®s);
+ } else if (!strcmp(parm, "USP")) {
+ regs.usp = v;
+ } else if (!strcmp(parm, "ISP")) {
+ regs.isp = v;
} else if (!strcmp (parm, "PC")) {
m68k_setpc (®s, v);
- fill_prefetch_slow(®s);
+ fill_prefetch_slow (®s);
} else {
for (i = 0; m2cregs[i].regname; i++) {
if (!strcmp (parm, m2cregs[i].regname))
update_debug_info();
console_out (">");
console_flush ();
+ debug_linecounter = 0;
v = console_get (input, MAX_LINEWIDTH);
if (v < 0)
return;
if (v == 0)
continue;
+
inptr = input;
cmd = next_char (&inptr);
- switch (cmd) {
+ switch (cmd)
+ {
case 'c': dumpcia (); dumpdisk (); dumpcustom (); break;
case 'i':
addr = 0xffffffff;
uae_u32 maddr;
int lines;
if (more_params(&inptr)) {
- if (toupper(inptr[0]) == 'R') {
- inptr++;
- dumpmemreg(&inptr);
- break;
- } else {
- maddr = readhex(&inptr);
- }
+ maddr = readhex(&inptr);
} else {
maddr = nxmem;
}
break;
case 'h':
case '?':
- debug_help ();
+ if (more_params (&inptr))
+ converter (&inptr);
+ else
+ debug_help ();
break;
}
}
static void addhistory(void)
{
uae_u32 pc = m68k_getpc (®s);
- if (!notinrom())
- return;
+// if (!notinrom())
+// return;
history[lasthist] = regs;
history[lasthist].pc = m68k_getpc (®s);
if (++lasthist == MAX_HIST)
if (currprefs.gfx_afullscreen && currprefs.gfx_avsync)
flush_screen (0, 0); /* vsync mode */
}
- gui_hd_led (0);
- gui_cd_led (0);
+ gui_hd_led (-1, 0);
+ gui_cd_led (-1, 0);
#ifdef AVIOUTPUT
frame_drawn ();
#endif
uae_u32 uniq;
TRACE(("ACTION_EXAMINE_NEXT(0x%lx,0x%lx)\n", lock, info));
- gui_hd_led (1);
+ gui_hd_led (unit->unit, 1);
DUMPLOCK(unit, lock);
if (lock != 0)
return;
}
TRACE(("ACTION_READ(%s,0x%lx,%ld)\n",k->aino->nname,addr,size));
- gui_hd_led (1);
+ gui_hd_led (unit->unit, 1);
#ifdef RELY_ON_LOADSEG_DETECTION
/* HACK HACK HACK HACK
* Try to detect a LoadSeg() */
return;
}
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
TRACE(("ACTION_WRITE(%s,0x%lx,%ld)\n",k->aino->nname,addr,size));
if (unit->ui.readonly) {
if (mode < 0) whence = SEEK_SET;
TRACE(("ACTION_SEEK(%s,%d,%d)\n", k->aino->nname, pos, mode));
- gui_hd_led (1);
+ gui_hd_led (unit->unit, 1);
old = fs_lseek (unit, k->fd, 0, SEEK_CUR);
{
PUT_PCK_RES1 (packet, DOS_TRUE);
}
notify_check (unit, a);
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
}
static void action_set_comment (Unit * unit, dpacket packet)
a->comment = commented;
fsdb_set_file_attrs (a);
notify_check (unit, a);
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
}
static void
notify_check (unit, aino);
updatedirtime (aino, 0);
PUT_PCK_RES1 (packet, make_lock (unit, aino->uniq, -2) >> 2);
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
}
static void
return;
}
- gui_hd_led (1);
+ gui_hd_led (unit->unit, 1);
k->notifyactive = 1;
/* If any open files have file pointers beyond this size, truncate only
* so far that these pointers do not become invalid. */
delete_aino (unit, a);
}
PUT_PCK_RES1 (packet, DOS_TRUE);
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
}
static void
notify_check (unit, a);
PUT_PCK_RES1 (packet, DOS_TRUE);
}
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
}
static void
if (a2->elock > 0 || a2->shlock > 0 || wehavekeys > 0)
de_recycle_aino (unit, a2);
PUT_PCK_RES1 (packet, DOS_TRUE);
- gui_hd_led (2);
+ gui_hd_led (unit->unit, 2);
}
static void
ide_fail ();
return;
}
- gui_hd_led (1);
+ gui_hd_led (ide->num, 1);
nsec = ide_nsector == 0 ? 256 : ide_nsector;
get_lbachs (ide, &lba, &cyl, &head, &sec);
if (IDE_LOG > 0)
ide_fail ();
return;
}
- gui_hd_led (2);
+ gui_hd_led (ide->num, 2);
nsec = ide_nsector == 0 ? 256 : ide_nsector;
get_lbachs (ide, &lba, &cyl, &head, &sec);
if (lba * 512 >= ide->hdhfd.size) {
int len = end - start;
if (len > 0) {
hdf_write (&pcmcia_sram->hfd, pcmcia_common + start, start, len);
- write_log ("write %d %d\n", start, len);
pcmcia_write_min = -1;
}
}
static uae_u64 cmd_readx (struct hardfiledata *hfd, uae_u8 *dataptr, uae_u64 offset, uae_u64 len)
{
- gui_hd_led (1);
+ gui_hd_led (hfd->unitnum, 1);
hf_log3 ("cmd_read: %p %04.4x-%08.8x (%d) %08.8x (%d)\n",
dataptr, (uae_u32)(offset >> 32), (uae_u32)offset, (uae_u32)(offset / hfd->blocksize), (uae_u32)len, (uae_u32)(len / hfd->blocksize));
return hdf_read (hfd, dataptr, offset, len);
}
static uae_u64 cmd_writex (struct hardfiledata *hfd, uae_u8 *dataptr, uae_u64 offset, uae_u64 len)
{
- gui_hd_led (2);
+ gui_hd_led (hfd->unitnum, 2);
hf_log3 ("cmd_write: %p %04.4x-%08.8x (%d) %08.8x (%d)\n",
dataptr, (uae_u32)(offset >> 32), (uae_u32)offset, (uae_u32)(offset / hfd->blocksize), (uae_u32)len, (uae_u32)(len / hfd->blocksize));
return hdf_write (hfd, dataptr, offset, len);
extern void dumpcia (void);
extern void rethink_cias (void);
+extern int resetwarning_do (int);
extern int parallel_direct_write_data (uae_u8, uae_u8);
extern int parallel_direct_read_data (uae_u8*);
int warned;
uae_u8 *virtual_rdb;
uae_u64 virtual_size;
+ int unitnum;
int drive_empty;
char *emptyname;
extern void gui_changesettings (void);
extern void gui_lock (void);
extern void gui_unlock (void);
-extern void gui_hd_led (int);
-extern void gui_cd_led (int);
+extern void gui_hd_led (int, int);
+extern void gui_cd_led (int, int);
extern unsigned int gui_ledstate;
extern void gui_display(int shortcut);
#endif
uae_u32 pcr;
- uae_u32 kick_mask;
uae_u32 address_space_mask;
uae_u8 panic;
int cs_rtc;
int cs_rtc_adjust;
int cs_rtc_adjust_mode;
- int cs_ksmirror;
+ int cs_ksmirror_e0;
+ int cs_ksmirror_a8;
+ int cs_ciaoverlay;
int cs_cd32cd;
int cs_cd32c2p;
int cs_cd32nvram;
int cs_a2091, cs_a4091;
int cs_df0idhw;
int cs_slowmemisfast;
+ int cs_resetwarning;
char df[4][MAX_DPATH];
char dfxlist[MAX_SPARE_DRIVES][MAX_DPATH];
if (code < 0x80) {
uae_u8 key = code | (state ? 0x00 : 0x80);
keybuf[key & 0x7f] = (key & 0x80) ? 0 : 1;
- if (((keybuf[AK_CTRL] || keybuf[AK_RCTRL]) && keybuf[AK_LAMI] && keybuf[AK_RAMI]) || key == AK_RESETWARNING) {
+ if (key == AK_RESETWARNING) {
+ resetwarning_do (0);
+ return;
+ } else if ((keybuf[AK_CTRL] || keybuf[AK_RCTRL]) && keybuf[AK_LAMI] && keybuf[AK_RAMI]) {
int r = keybuf[AK_LALT] | keybuf[AK_RALT];
+ if (!r && currprefs.cs_resetwarning && resetwarning_do (1))
+ return;
memset (keybuf, 0, sizeof (keybuf));
uae_reset (r);
}
static int switchdevice (struct uae_input_device *id, int num, int button)
{
- int i;
+ int i, j;
int ismouse = 0;
int newport = 0;
int flags = 0;
char *name = NULL;
+ int otherbuttonpressed = 0;
if (num >= 4)
return 0;
name = idev[IDTYPE_JOYSTICK].get_uniquename (i);
newport = num == 0 ? 1 : 0;
flags = idev[IDTYPE_JOYSTICK].get_flags (i);
+ for (j = 0; j < MAX_INPUT_DEVICES; j++) {
+ if (j != i) {
+ struct uae_input_device2 *id2 = &joysticks2[j];
+ if (id2->buttonmask)
+ otherbuttonpressed = 1;
+ }
+ }
}
if (id == &mice[i]) {
ismouse = 1;
}
if (!name)
return 0;
+ if (num == 0 && otherbuttonpressed)
+ newport = newport ? 0 : 1;
if (!currprefs.input_selected_setting) {
if (num == 0 || num == 1) {
int om = jsem_ismouse (num, &currprefs);
if ((p->gfxmem_size & (p->gfxmem_size - 1)) != 0
|| (p->gfxmem_size != 0 && (p->gfxmem_size < 0x100000 || p->gfxmem_size > max_z3fastmem / 2)))
{
- write_log ("Unsupported graphics card memory size %x!\n", p->gfxmem_size);
+ write_log ("Unsupported graphics card memory size %x (%x)!\n", p->gfxmem_size, max_z3fastmem / 2);
if (p->gfxmem_size > max_z3fastmem / 2)
p->gfxmem_size = max_z3fastmem / 2;
else
if ((p->z3fastmem_size & (p->z3fastmem_size - 1)) != 0
|| (p->z3fastmem_size != 0 && (p->z3fastmem_size < 0x100000 || p->z3fastmem_size > max_z3fastmem)))
{
+ write_log ("Unsupported Zorro III fastmem size %x (%x)!\n", p->z3fastmem_size, max_z3fastmem);
if (p->z3fastmem_size > max_z3fastmem)
p->z3fastmem_size = max_z3fastmem;
else
p->z3fastmem_size = 0;
- write_log ("Unsupported Zorro III fastmem size!\n");
err = 1;
}
p->z3fastmem_start &= ~0xffff;
return get_keyring();
}
+static int decode_rekick_rom_do (uae_u8 *mem, int size, int real_size)
+{
+ uae_u32 d1 = 0xdeadfeed, d0;
+ int i;
+
+ for (i = 0; i < size / 8; i++) {
+ d0 = ((mem[i * 8 + 0] << 24) | (mem[i * 8 + 1] << 16) | (mem[i * 8 + 2] << 8) | mem[i * 8 + 3]);
+ d1 = d1 ^ d0;
+ mem[i * 8 + 0] = d1 >> 24;
+ mem[i * 8 + 1] = d1 >> 16;
+ mem[i * 8 + 2] = d1 >> 8;
+ mem[i * 8 + 3] = d1;
+ d1 = ((mem[i * 8 + 4] << 24) | (mem[i * 8 + 5] << 16) | (mem[i * 8 + 6] << 8) | mem[i * 8 + 7]);
+ d0 = d0 ^ d1;
+ mem[i * 8 + 4] = d0 >> 24;
+ mem[i * 8 + 5] = d0 >> 16;
+ mem[i * 8 + 6] = d0 >> 8;
+ mem[i * 8 + 7] = d0;
+ }
+ return 1;
+}
+
static void addkey(int *pkeyid, uae_u8 *key, int size, const char *name)
{
int keyid = *pkeyid;
memset(keyring, 0, sizeof (struct rom_key) * ROM_KEY_NUM);
}
-static int decode_cloanto_rom (uae_u8 *mem, int size, int real_size)
+static int decode_rom (uae_u8 *mem, int size, int mode, int real_size)
{
- if (!decode_cloanto_rom_do (mem, size, real_size)) {
- #ifndef SINGLEFILE
- notify_user (NUMSG_NOROMKEY);
- #endif
- return 0;
+ if (mode == 1) {
+ if (!decode_cloanto_rom_do (mem, size, real_size)) {
+ #ifndef SINGLEFILE
+ notify_user (NUMSG_NOROMKEY);
+ #endif
+ return 0;
+ }
+ return 1;
+ } else if (mode == 2) {
+ decode_rekick_rom_do (mem, size, real_size);
+ return 1;
}
- return 1;
+ return 0;
}
struct romdata *getromdatabyname (char *name)
uae_u8 *tmpbuf = (uae_u8*)xmalloc (size);
int tmpsize = size - 11;
memcpy (tmpbuf, rom + 11, tmpsize);
- decode_cloanto_rom (tmpbuf, tmpsize, tmpsize);
+ decode_rom (tmpbuf, tmpsize, 1, tmpsize);
rom = tmpbuf;
size = tmpsize;
}
+#if 0
+ if (size > 0x6c + 524288 && !memcmp (rom, "AMIG", 4)) {
+ uae_u8 *tmpbuf = (uae_u8*)xmalloc (size);
+ int tmpsize = size - 0x6c;
+ memcpy (tmpbuf, rom + 0x6c, tmpsize);
+ decode_rom (tmpbuf, tmpsize, 2, tmpsize);
+ rom = tmpbuf;
+ size = tmpsize;
+ }
+#endif
get_sha1 (rom, size, sha1);
ret = checkromdata(sha1, size, -1);
if (!ret) {
}
uae_u32 chipmem_mask, chipmem_full_mask;
-uae_u32 kickmem_mask, extendedkickmem_mask, bogomem_mask;
+uae_u32 kickmem_mask, extendedkickmem_mask, extendedkickmem2_mask, bogomem_mask;
uae_u32 a3000lmem_mask, a3000hmem_mask, cardmem_mask;
static int illegal_count;
/* CD32/CDTV extended kick memory */
-uae_u8 *extendedkickmemory;
-static int extendedkickmem_size;
-static uae_u32 extendedkickmem_start;
+uae_u8 *extendedkickmemory, *extendedkickmemory2;
+static int extendedkickmem_size, extendedkickmem2_size;
+static uae_u32 extendedkickmem_start, extendedkickmem2_start;
static int extendedkickmem_type;
#define EXTENDED_ROM_CD32 1
static void REGPARAM3 extendedkickmem_bput (uaecptr, uae_u32) REGPARAM;
static int REGPARAM3 extendedkickmem_check (uaecptr addr, uae_u32 size) REGPARAM;
static uae_u8 *REGPARAM3 extendedkickmem_xlate (uaecptr addr) REGPARAM;
-
static uae_u32 REGPARAM2 extendedkickmem_lget (uaecptr addr)
{
uae_u32 *m;
m = (uae_u32 *)(extendedkickmemory + addr);
return do_get_mem_long (m);
}
-
static uae_u32 REGPARAM2 extendedkickmem_wget (uaecptr addr)
{
uae_u16 *m;
m = (uae_u16 *)(extendedkickmemory + addr);
return do_get_mem_word (m);
}
-
static uae_u32 REGPARAM2 extendedkickmem_bget (uaecptr addr)
{
addr -= extendedkickmem_start & extendedkickmem_mask;
addr &= extendedkickmem_mask;
return extendedkickmemory[addr];
}
-
static void REGPARAM2 extendedkickmem_lput (uaecptr addr, uae_u32 b)
{
#ifdef JIT
if (currprefs.illegal_mem)
write_log ("Illegal extendedkickmem lput at %08lx\n", addr);
}
-
static void REGPARAM2 extendedkickmem_wput (uaecptr addr, uae_u32 b)
{
#ifdef JIT
if (currprefs.illegal_mem)
write_log ("Illegal extendedkickmem wput at %08lx\n", addr);
}
-
static void REGPARAM2 extendedkickmem_bput (uaecptr addr, uae_u32 b)
{
#ifdef JIT
if (currprefs.illegal_mem)
write_log ("Illegal extendedkickmem lput at %08lx\n", addr);
}
-
static int REGPARAM2 extendedkickmem_check (uaecptr addr, uae_u32 size)
{
addr -= extendedkickmem_start & extendedkickmem_mask;
addr &= extendedkickmem_mask;
return (addr + size) <= extendedkickmem_size;
}
-
static uae_u8 *REGPARAM2 extendedkickmem_xlate (uaecptr addr)
{
addr -= extendedkickmem_start & extendedkickmem_mask;
return extendedkickmemory + addr;
}
+static uae_u32 REGPARAM3 extendedkickmem2_lget (uaecptr) REGPARAM;
+static uae_u32 REGPARAM3 extendedkickmem2_wget (uaecptr) REGPARAM;
+static uae_u32 REGPARAM3 extendedkickmem2_bget (uaecptr) REGPARAM;
+static void REGPARAM3 extendedkickmem2_lput (uaecptr, uae_u32) REGPARAM;
+static void REGPARAM3 extendedkickmem2_wput (uaecptr, uae_u32) REGPARAM;
+static void REGPARAM3 extendedkickmem2_bput (uaecptr, uae_u32) REGPARAM;
+static int REGPARAM3 extendedkickmem2_check (uaecptr addr, uae_u32 size) REGPARAM;
+static uae_u8 *REGPARAM3 extendedkickmem2_xlate (uaecptr addr) REGPARAM;
+static uae_u32 REGPARAM2 extendedkickmem2_lget (uaecptr addr)
+{
+ uae_u32 *m;
+ addr -= extendedkickmem2_start & extendedkickmem2_mask;
+ addr &= extendedkickmem2_mask;
+ m = (uae_u32 *)(extendedkickmemory2 + addr);
+ return do_get_mem_long (m);
+}
+static uae_u32 REGPARAM2 extendedkickmem2_wget (uaecptr addr)
+{
+ uae_u16 *m;
+ addr -= extendedkickmem2_start & extendedkickmem2_mask;
+ addr &= extendedkickmem2_mask;
+ m = (uae_u16 *)(extendedkickmemory2 + addr);
+ return do_get_mem_word (m);
+}
+static uae_u32 REGPARAM2 extendedkickmem2_bget (uaecptr addr)
+{
+ addr -= extendedkickmem2_start & extendedkickmem2_mask;
+ addr &= extendedkickmem2_mask;
+ return extendedkickmemory2[addr];
+}
+static void REGPARAM2 extendedkickmem2_lput (uaecptr addr, uae_u32 b)
+{
+#ifdef JIT
+ special_mem |= S_WRITE;
+#endif
+ if (currprefs.illegal_mem)
+ write_log ("Illegal extendedkickmem2 lput at %08lx\n", addr);
+}
+static void REGPARAM2 extendedkickmem2_wput (uaecptr addr, uae_u32 b)
+{
+#ifdef JIT
+ special_mem |= S_WRITE;
+#endif
+ if (currprefs.illegal_mem)
+ write_log ("Illegal extendedkickmem2 wput at %08lx\n", addr);
+}
+static void REGPARAM2 extendedkickmem2_bput (uaecptr addr, uae_u32 b)
+{
+#ifdef JIT
+ special_mem |= S_WRITE;
+#endif
+ if (currprefs.illegal_mem)
+ write_log ("Illegal extendedkickmem2 lput at %08lx\n", addr);
+}
+static int REGPARAM2 extendedkickmem2_check (uaecptr addr, uae_u32 size)
+{
+ addr -= extendedkickmem2_start & extendedkickmem2_mask;
+ addr &= extendedkickmem2_mask;
+ return (addr + size) <= extendedkickmem2_size;
+}
+static uae_u8 *REGPARAM2 extendedkickmem2_xlate (uaecptr addr)
+{
+ addr -= extendedkickmem2_start & extendedkickmem2_mask;
+ addr &= extendedkickmem2_mask;
+ return extendedkickmemory2 + addr;
+}
+
+
/* Default memory access functions */
int REGPARAM2 default_check (uaecptr a, uae_u32 b)
extendedkickmem_xlate, extendedkickmem_check, NULL, "Extended Kickstart ROM",
extendedkickmem_lget, extendedkickmem_wget, ABFLAG_ROM
};
+addrbank extendedkickmem2_bank = {
+ extendedkickmem2_lget, extendedkickmem2_wget, extendedkickmem2_bget,
+ extendedkickmem2_lput, extendedkickmem2_wput, extendedkickmem2_bput,
+ extendedkickmem2_xlate, extendedkickmem2_check, NULL, "Extended 2nd Kickstart ROM",
+ extendedkickmem2_lget, extendedkickmem2_wget, ABFLAG_ROM
+};
static uae_u32 allocated_custmem1, allocated_custmem2;
if (!memcmp(buffer, "KICK", 4)) {
zfile_fseek (f, 512, SEEK_SET);
kickdisk = 1;
+#if 0
+ } else if (size >= 524288 && !memcmp (buffer, "AMIG", 4)) {
+ /* ReKick */
+ zfile_fseek (f, oldpos + 0x6c, SEEK_SET);
+ cr = 2;
+#endif
} else if (strncmp ((char *)buffer, "AMIROMTYPE1", 11) != 0) {
zfile_fseek (f, oldpos, SEEK_SET);
} else {
memcpy (mem + size / 2, mem, size / 2);
if (cr) {
- if (!decode_cloanto_rom (mem, size, i))
+ if (!decode_rom (mem, size, cr, i))
return 0;
}
if (currprefs.cs_a1000ram) {
}
zfile_fseek (f, kspos, SEEK_SET);
}
+ if (filesize >= 524288 * 4) {
+ kspos = 524288 * 3;
+ extpos = 0;
+ zfile_fseek (f, kspos, SEEK_SET);
+ }
size = read_kickstart (f, kickmemory, maxsize, 1, &cloanto_rom, 0);
if (size == 0)
goto err;
kickmem_size = size;
if (filesize >= 524288 * 2 && !extendedkickmem_type) {
extendedkickmem_size = 0x80000;
- extendedkickmem_type = EXTENDED_ROM_KS;
- extendedkickmemory = (uae_u8 *) mapped_malloc (extendedkickmem_size, "rom_e0");
- extendedkickmem_bank.baseaddr = (uae_u8 *) extendedkickmemory;
+ if (currprefs.cs_cdtvcd || currprefs.cs_cdtvram) {
+ extendedkickmem_type = EXTENDED_ROM_CDTV;
+ extendedkickmemory = mapped_malloc (extendedkickmem_size, "rom_f0");
+ } else {
+ extendedkickmem_type = EXTENDED_ROM_KS;
+ extendedkickmemory = mapped_malloc (extendedkickmem_size, "rom_e0");
+ }
+ extendedkickmem_bank.baseaddr = extendedkickmemory;
zfile_fseek (f, extpos, SEEK_SET);
read_kickstart (f, extendedkickmemory, 0x80000, 0, 0, 1);
extendedkickmem_mask = extendedkickmem_size - 1;
}
+ if (filesize > 524288 * 2) {
+ extendedkickmem2_size = 524288 * 2;
+ extendedkickmemory2 = mapped_malloc (extendedkickmem2_size, "rom_a8");
+ extendedkickmem2_bank.baseaddr = extendedkickmemory2;
+ zfile_fseek (f, extpos + 524288, SEEK_SET);
+ read_kickstart (f, extendedkickmemory2, 524288, 0, 0, 1);
+ zfile_fseek (f, extpos + 524288 * 2, SEEK_SET);
+ read_kickstart (f, extendedkickmemory2 + 524288, 524288, 0, 0, 1);
+ extendedkickmem2_mask = extendedkickmem2_size - 1;
+ }
}
#if defined(AMIGA)
if (currprefs.cpu_cycle_exact && currprefs.cpu_model >= 68020)
cb = &chipmem_bank_ce2;
#endif
- if (chip)
+ if (chip) {
map_banks (cb, 0, i, allocated_chipmem);
- else
- map_banks (&kickmem_bank, 0, i, 0x80000);
+ } else {
+ addrbank *rb = NULL;
+ cb = &get_mem_bank (0xf00000);
+ if (!rb && cb && (cb->flags & ABFLAG_ROM) && get_word (0xf00000) == 0x1114)
+ rb = cb;
+ cb = &get_mem_bank (0xe00000);
+ if (!rb && cb && (cb->flags & ABFLAG_ROM) && get_word (0xe00000) == 0x1114)
+ rb = cb;
+ if (!rb)
+ rb = &kickmem_bank;
+ map_banks (rb, 0, i, 0x80000);
+ }
if (savestate_state != STATE_RESTORE && savestate_state != STATE_REWIND && valid_address (regs.pc, 4))
m68k_setpc (®s, m68k_getpc (®s));
}
void memory_reset (void)
{
int bnk, bnk_end;
+ int gayle;
be_cnt = 0;
currprefs.chipmem_size = changed_prefs.chipmem_size;
currprefs.bogomem_size = changed_prefs.bogomem_size;
currprefs.mbresmem_low_size = changed_prefs.mbresmem_low_size;
currprefs.mbresmem_high_size = changed_prefs.mbresmem_high_size;
- currprefs.cs_ksmirror = changed_prefs.cs_ksmirror;
+ currprefs.cs_ksmirror_e0 = changed_prefs.cs_ksmirror_e0;
+ currprefs.cs_ksmirror_a8 = changed_prefs.cs_ksmirror_a8;
+ currprefs.cs_ciaoverlay = changed_prefs.cs_ciaoverlay;
currprefs.cs_cdtvram = changed_prefs.cs_cdtvram;
currprefs.cs_cdtvcard = changed_prefs.cs_cdtvcard;
currprefs.cs_a1000ram = changed_prefs.cs_a1000ram;
currprefs.cs_fatgaryrev = changed_prefs.cs_fatgaryrev;
currprefs.cs_ramseyrev = changed_prefs.cs_ramseyrev;
+ gayle = (currprefs.chipset_mask & CSMASK_AGA) || currprefs.cs_pcmcia || currprefs.cs_ide > 0;
+
need_hardreset = 0;
/* Use changed_prefs, as m68k_reset is called later. */
if (last_address_space_24 != changed_prefs.address_space_24)
mapped_free (extendedkickmemory);
extendedkickmemory = 0;
extendedkickmem_size = 0;
+ extendedkickmemory2 = 0;
+ extendedkickmem2_size = 0;
extendedkickmem_type = 0;
load_extendedkickstart ();
kickmem_mask = 524288 - 1;
if (cloanto_rom)
currprefs.maprom = changed_prefs.maprom = 0;
+ gayle = currprefs.cs_ksmirror_a8 || currprefs.cs_pcmcia || currprefs.cs_ide > 0;
map_banks (&custom_bank, 0xC0, 0xE0 - 0xC0, 0);
map_banks (&cia_bank, 0xA0, 32, 0);
bnk = allocated_chipmem >> 16;
if (bnk < 0x20 + (currprefs.fastmem_size >> 16))
bnk = 0x20 + (currprefs.fastmem_size >> 16);
- bnk_end = (((currprefs.chipset_mask & CSMASK_AGA) || currprefs.cs_pcmcia || currprefs.cs_ide > 0) ? 0xBF : 0xA0);
+ bnk_end = gayle ? 0xBF : 0xA0;
map_banks (&dummy_bank, bnk, bnk_end - bnk, 0);
- if (currprefs.chipset_mask & CSMASK_AGA)
+ if (gayle)
map_banks (&dummy_bank, 0xc0, 0xd8 - 0xc0, 0);
if (bogomemory != 0) {
}
if (currprefs.cs_rtc || currprefs.cs_cdtvram)
map_banks (&clock_bank, 0xDC, 1, 0);
+ else if (currprefs.cs_ksmirror_a8 || currprefs.cs_ide > 0 || currprefs.cs_pcmcia)
+ map_banks (&clock_bank, 0xDC, 1, 0); /* none clock */
if (currprefs.cs_fatgaryrev >= 0 || currprefs.cs_ramseyrev >= 0)
map_banks (&mbres_bank, 0xDE, 1, 0);
if (currprefs.cs_cd32c2p || currprefs.cs_cd32cd || currprefs.cs_cd32nvram)
#endif
}
- if ((cloanto_rom || currprefs.cs_ksmirror) && !currprefs.maprom && !extendedkickmem_type)
+ if ((cloanto_rom || currprefs.cs_ksmirror_e0) && !currprefs.maprom && !extendedkickmem_type)
map_banks (&kickmem_bank, 0xE0, 8, 0);
- if (currprefs.cs_ksmirror == 2) { /* unexpanded A1200 also maps ROM here.. */
- struct romdata *rd = getromdatabypath(currprefs.cartfile);
- if (!rd || rd->id != 63) {
- map_banks (&kickmem_bank, 0xA8, 8, 0);
- map_banks (&kickmem_bank, 0xB0, 8, 0);
+ if (currprefs.cs_ksmirror_a8) {
+ if (extendedkickmem2_size) {
+ map_banks (&extendedkickmem2_bank, 0xa8, 16, 0);
+ } else {
+ struct romdata *rd = getromdatabypath(currprefs.cartfile);
+ if (!rd || rd->id != 63) {
+ if (extendedkickmem_type == EXTENDED_ROM_CD32 || extendedkickmem_type == EXTENDED_ROM_KS)
+ map_banks (&extendedkickmem_bank, 0xb0, 8, 0);
+ else
+ map_banks (&kickmem_bank, 0xb0, 8, 0);
+ map_banks (&kickmem_bank, 0xa8, 8, 0);
+ }
}
}
kickmemory = 0;
extendedkickmemory = 0;
extendedkickmem_size = 0;
+ extendedkickmemory2 = 0;
+ extendedkickmem2_size = 0;
extendedkickmem_type = 0;
chipmemory = 0;
allocated_a3000lmem = allocated_a3000hmem = 0;
put_word (m68k_areg (regs, 7) + 8, regs->sr);
put_long (m68k_areg (regs, 7) + 10, last_addr_for_exception_3);
write_log ("Exception %d (%x) at %x -> %x!\n", nr, oldpc, currpc, get_long (regs->vbr + 4*nr));
+ activate_debugger();
goto kludge_me_do;
}
m68k_areg (regs, 7) -= 4;
void m68k_reset (int hardreset)
{
- regs.kick_mask = 0x00F80000;
regs.spcflags = 0;
#ifdef SAVESTATE
if (savestate_state == STATE_RESTORE || savestate_state == STATE_REWIND) {
return;
}
#endif
- m68k_areg (®s, 7) = get_long (0x00f80000);
- m68k_setpc (®s, get_long (0x00f80004));
+ m68k_areg (®s, 7) = get_long (0);
+ m68k_setpc (®s, get_long (4));
regs.s = 1;
regs.m = 0;
regs.stopped = 0;
f_out (f, "USP %08.8X ISP %08.8X ", regs.usp, regs.isp);
for (i = 0; m2cregs[i].regno>= 0; i++) {
if (!movec_illg (m2cregs[i].regno)) {
+ if (!strcmp (m2cregs[i].regname, "USP") || !strcmp (m2cregs[i].regname, "ISP"))
+ continue;
if (j > 0 && (j % 4) == 0)
f_out (f, "\n");
f_out (f, "%-4s %08.8X ", m2cregs[i].regname, val_move2c (m2cregs[i].regno));
int type = si[unitnum].type;
if (type == INQ_ROMD)
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
else if (type == INQ_DASD)
- gui_hd_led (1);
+ gui_hd_led (unitnum, 1);
}
static uae_sem_t scgp_sem;
cmd[3] = (uae_u8)(sector >> 16);
cmd[4] = (uae_u8)(sector >> 8);
cmd[5] = (uae_u8)(sector >> 0);
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
memset (&swb, 0, sizeof (swb));
memcpy (swb.spt.Cdb, cmd, len);
swb.spt.Length = sizeof (SCSI_PASS_THROUGH);
if (sectorsize != 2336 && sectorsize != 2352 && sectorsize != 2048)
return 0;
while (cnt-- > 0) {
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
seterrormode (unitnum);
rri.DiskOffset.QuadPart = sector * 2048;
rri.SectorCount = 1;
if (!open_createfile(unitnum, 0))
return 0;
while (cnt-- > 0) {
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
seterrormode (unitnum);
if (SetFilePointer (ciw32[unitnum].h, sector * ciw32[unitnum].blocksize, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
reseterrormode (unitnum);
}
cnt = 3;
while (cnt-- > 0) {
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
seterrormode (unitnum);
if (write) {
if (!WriteFile (ciw32[unitnum].h, p, blocksize, &dtotal, 0)) {
}
}
reseterrormode (unitnum);
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
break;
}
*ptr = p;
if (!open_createfile(unitnum, 0))
return 0;
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
while (cnt-- > 0) {
seterrormode (unitnum);
if (!DeviceIoControl(ciw32[unitnum].h, IOCTL_CDROM_READ_TOC, NULL, 0, toc, sizeof(CDROM_TOC), &len, NULL)) {
p[10] = toc->TrackData[i].Address[3];
p += 11;
}
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
return ciw32[unitnum].tempbuffer;
}
scsi_log_before (swb->spt.Cdb, swb->spt.CdbLength,
swb->spt.DataIn == SCSI_IOCTL_DATA_OUT ? swb->spt.DataBuffer : 0,swb->spt.DataTransferLength);
}
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
swb->spt.ScsiStatus = 0;
if (di->bus >= 0) {
swb->spt.PathId = di->path;
swb->spt.SenseInfoLength = 0; /* 0 and 1 = success, not error.. */
if (swb->spt.SenseInfoLength > 0)
return 0;
- gui_cd_led (1);
+ gui_cd_led (unitnum, 1);
return status;
}
static void putnumbers(int x, int y, int num, int inv)
{
- putnumber(x, y, num < 0 ? num : num / 10, inv);
+ putnumber(x, y, num < 0 ? num : ((num / 10) > 0 ? num / 10 : -1), inv);
putnumber(x + numbers_width, y, num < 0 ? num : num % 10, inv);
}
natmem_offset = NULL;
canbang = 0;
- size = currprefs.z3fastmem_size + (currprefs.z3fastmem_start - 0x10000000);
- size += currprefs.gfxmem_size;
- size += 16 * 1024 * 1024;
+ size = 0x1000000;
+ if (currprefs.cpu_model >= 68020)
+ size = 0x10000000;
+ if (currprefs.z3fastmem_size || currprefs.gfxmem_size) {
+ size = currprefs.z3fastmem_size + (currprefs.z3fastmem_start - 0x10000000);
+ size += currprefs.gfxmem_size;
+ size += 16 * 1024 * 1024;
+ }
while (size > size64) {
int change = lowmem ();
#define IDC_CS_CIAA_TOD3 1713
#define IDC_CS_COMPATIBLE 1714
#define IDC_CS_RAMSEYREV 1715
-#define IDC_CS_KSMIRROR 1716
+#define IDC_CS_KSMIRROR_E0 1716
#define IDC_STRINGBOXEDIT 1716
#define IDC_CS_CD32CD 1717
#define IDC_STRINGBOX_TEXT 1717
#define IDC_CS_SLOWISFAST 1740
#define IDC_DBG_HELP 1740
#define IDC_DBG_INPUT 1741
+#define IDC_CS_KSMIRROR_A8 1741
#define IDC_DBG_DREG 1742
+#define IDC_CS_CIAOVERLAY 1742
#define IDC_DBG_AREG 1743
+#define IDC_CS_KSMIRROR_E1 1743
+#define IDC_CS_RESETWARNING 1743
#define IDC_DBG_CCR 1744
#define IDC_DBG_AMEM 1745
#define IDC_DBG_SP_VBR 1746
#define IDC_CS_CIAA_TOD3 1713
#define IDC_CS_COMPATIBLE 1714
#define IDC_CS_RAMSEYREV 1715
-#define IDC_CS_KSMIRROR 1716
+#define IDC_CS_KSMIRROR_E0 1716
#define IDC_STRINGBOXEDIT 1716
#define IDC_CS_CD32CD 1717
#define IDC_STRINGBOX_TEXT 1717
#define IDC_CS_SLOWISFAST 1740
#define IDC_DBG_HELP 1740
#define IDC_DBG_INPUT 1741
+#define IDC_CS_KSMIRROR_A8 1741
#define IDC_DBG_DREG 1742
+#define IDC_CS_CIAOVERLAY 1742
#define IDC_DBG_AREG 1743
+#define IDC_CS_RESETWARNING 1743
#define IDC_DBG_CCR 1744
#define IDC_DBG_AMEM 1745
#define IDC_DBG_SP_VBR 1746
CONTROL "Magic Mouse",IDC_MOUSETRICK,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,161,79,119,10
CONTROL "uaenet.device",IDC_SANA2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,161,92,94,10
END
+
IDD_HARDFILE DIALOGEX 0, 0, 299, 249
STYLE DS_LOCALEDIT | DS_SETFONT | DS_MODALFRAME | DS_SETFOREGROUND | DS_3DLOOK | DS_CENTER | DS_CENTERMOUSE | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "Hardfile Settings"
CONTROL "Vertical Sync",IDC_CS_CIAA_TOD1,"Button",BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP,19,68,63,10
CONTROL "Power Supply 50Hz",IDC_CS_CIAA_TOD2,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,90,68,85,10
CONTROL "Power Supply 60Hz",IDC_CS_CIAA_TOD3,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,186,68,88,10
- CONTROL "Boot ROM Mirror",IDC_CS_KSMIRROR,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,95,80,10
+ CONTROL "ROM Mirror (A8)",IDC_CS_KSMIRROR_A8,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,146,80,10
CONTROL "A1000 Boot RAM/ROM",IDC_CS_A1000RAM,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,95,88,10
CONTROL "CD32 CD",IDC_CS_CD32CD,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,108,76,10
CONTROL "CD32 C2P",IDC_CS_CD32C2P,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,108,87,10
CONTROL "CDTV SRAM Expansion",IDC_CS_CDTVRAMEXP,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,120,90,10
CONTROL "A600/A1200 IDE",IDC_CS_IDE1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,133,79,10
CONTROL "A4000/A4000T IDE",IDC_CS_IDE2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,133,88,10
- CONTROL "Ramsey revision:",IDC_CS_RAMSEY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,210,71,10
- EDITTEXT IDC_CS_RAMSEYREV,91,208,45,13,ES_AUTOHSCROLL
- CONTROL "Fat Gary revision:",IDC_CS_FATGARY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,223,71,10
- EDITTEXT IDC_CS_FATGARYREV,91,222,45,13,ES_AUTOHSCROLL
- CONTROL "A3000 SCSI",IDC_CS_DMAC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,174,76,10
+ CONTROL "Ramsey revision:",IDC_CS_RAMSEY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,216,71,10
+ EDITTEXT IDC_CS_RAMSEYREV,91,214,45,13,ES_AUTOHSCROLL
+ CONTROL "Fat Gary revision:",IDC_CS_FATGARY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,229,71,10
+ EDITTEXT IDC_CS_FATGARYREV,91,228,45,13,ES_AUTOHSCROLL
+ CONTROL "A3000 SCSI",IDC_CS_DMAC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,188,76,10
CONTROL "Compatible Settings",IDC_CS_COMPATIBLE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,8,234,10
CONTROL "DF0: ID Hardware",IDC_CS_DF0IDHW,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,95,92,10
- CONTROL "Agnus/Alice revision:",IDC_CS_AGNUS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,147,210,81,10
- EDITTEXT IDC_CS_AGNUSREV,232,208,45,13,ES_AUTOHSCROLL
- CONTROL "Denise/Lisa revision:",IDC_CS_DENISE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,147,223,81,10
- EDITTEXT IDC_CS_DENISEREV,232,222,45,13,ES_AUTOHSCROLL
- CONTROL "A590/A2091 SCSI",IDC_CS_A2091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,174,76,10
- CONTROL "A4000T SCSI",IDC_CS_DMAC2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,174,88,10
- LTEXT "A4091/A4000T SCSI not yet implemented.",IDC_STATIC,22,160,224,8,SS_CENTERIMAGE
+ CONTROL "Agnus/Alice revision:",IDC_CS_AGNUS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,147,216,81,10
+ EDITTEXT IDC_CS_AGNUSREV,232,214,45,13,ES_AUTOHSCROLL
+ CONTROL "Denise/Lisa revision:",IDC_CS_DENISE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,147,229,81,10
+ EDITTEXT IDC_CS_DENISEREV,232,228,45,13,ES_AUTOHSCROLL
+ CONTROL "A590/A2091 SCSI",IDC_CS_A2091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,188,76,10
+ CONTROL "A4000T SCSI",IDC_CS_DMAC2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,188,88,10
+ LTEXT "A4091/A4000T SCSI not yet implemented.",IDC_STATIC,22,174,224,8,SS_CENTERIMAGE
CONTROL "PCMCIA",IDC_CS_PCMCIA,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,133,92,10
- CONTROL "A4091 SCSI",IDC_CS_A4091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,186,76,10
- CONTROL "CDTV SCSI",IDC_CS_CDTVSCSI,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,186,76,10
- CONTROL "Include host SCSI devices",IDC_CS_SCSIMODE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,186,101,10
+ CONTROL "A4091 SCSI",IDC_CS_A4091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,200,76,10
+ CONTROL "CDTV SCSI",IDC_CS_CDTVSCSI,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,94,200,76,10
+ CONTROL "Include host SCSI devices",IDC_CS_SCSIMODE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,200,101,10
CONTROL "C00000 is Fast RAM",IDC_CS_SLOWISFAST,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,146,92,10
+ CONTROL "ROM Mirror (E0)",IDC_CS_KSMIRROR_E0,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,146,80,10
+ CONTROL "CIA ROM Overlay",IDC_CS_CIAOVERLAY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,95,80,10
+ CONTROL "KB Reset Warning",IDC_CS_RESETWARNING,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,159,80,10
END
IDD_AVIOUTPUT DIALOGEX 0, 0, 288, 203
#include "picasso96_win.h"
#include "win32.h"
#include "win32gfx.h"
+#include "filesys.h"
static int initialized;
static RPGUESTINFO guestinfo;
static int default_width, default_height;
static int hwndset;
static int minimized;
+static DWORD hd_mask, cd_mask;
static char *ua (const WCHAR *s)
v |= 1 << i;
}
RPSendMessagex(RPIPCGM_DEVICES, RP_DEVICE_FLOPPY, v, NULL, 0, &guestinfo, NULL);
+ cd_mask = 0;
+ for (i = 0; i < currprefs.mountitems; i++) {
+ struct uaedev_config_info *uci = &currprefs.mountconfig[i];
+ if (uci->controller == HD_CONTROLLER_UAE) {
+ hd_mask |= 1 << i;
+ } else if (uci->controller <= HD_CONTROLLER_IDE3 ) {
+ hd_mask |= 1 << (uci->controller - HD_CONTROLLER_IDE0);
+ } else if (uci->controller <= HD_CONTROLLER_SCSI6) {
+ hd_mask |= 1 << (uci->controller - HD_CONTROLLER_SCSI0);
+ }
+ }
+ RPSendMessagex(RPIPCGM_DEVICES, RP_DEVICE_HD, hd_mask, NULL, 0, &guestinfo, NULL);
+}
+
+void rp_hd_change (int num, int removed)
+{
+ if (removed)
+ hd_mask &= ~(1 << num);
+ else
+ hd_mask |= 1 << num;
+ RPSendMessagex(RPIPCGM_DEVICES, RP_DEVICE_HD, hd_mask, NULL, 0, &guestinfo, NULL);
+}
+
+void rp_cd_change (int num, int removed)
+{
+ if (removed)
+ cd_mask &= ~(1 << num);
+ else
+ cd_mask |= 1 << num;
+ RPSendMessagex(RPIPCGM_DEVICES, RP_DEVICE_CD, cd_mask, NULL, 0, &guestinfo, NULL);
}
void rp_update_leds (int led, int onoff)
}
}
+void rp_hd_activity (int num, int onoff)
+{
+ if (!initialized)
+ return;
+ if (num < 0)
+ return;
+ if (onoff)
+ RPSendMessage(RPIPCGM_DEVICEACTIVITY, MAKEWORD (RP_DEVICE_HD, num), 200, NULL, 0, &guestinfo, NULL);
+}
+
+void rp_cd_activity (int num, int onoff)
+{
+ if (!initialized)
+ return;
+ if (num < 0)
+ return;
+ if ((cd_mask & (1 << num)) != ((onoff ? 1 : 0) << num)) {
+ cd_mask ^= 1 << num;
+ RPSendMessagex(RPIPCGM_DEVICES, RP_DEVICE_CD, cd_mask, NULL, 0, &guestinfo, NULL);
+ }
+ if (onoff) {
+ RPSendMessage(RPIPCGM_DEVICEACTIVITY, MAKEWORD (RP_DEVICE_CD, num), 200, NULL, 0, &guestinfo, NULL);
+ }
+}
+
+
void rp_update_status (struct uae_prefs *p)
{
if (!initialized)
extern void rp_fixup_options (struct uae_prefs*);
extern void rp_update_status (struct uae_prefs*);
extern void rp_update_leds (int, int);
+extern void rp_hd_activity (int, int);
+extern void rp_hd_change (int, int);
+extern void rp_cd_activity (int, int);
+extern void rp_cd_change (int, int);
extern void rp_activate (int, LPARAM);
extern void rp_minimize (int);
extern void rp_mousecapture (int);
NOTIFYICONDATA nid;
BOOL v;
+#ifdef RETROPLATFORM
+ if (rp_isactive())
+ return;
+#endif
//write_log ("notif: systray(%x,%d)\n", hwnd, remove);
if (!remove) {
TaskbarRestart = RegisterWindowMessage(TEXT("TaskbarCreated"));
#define GETBDM(x) (((x) - ((x / 10000) * 10000)) / 100)
#define GETBDD(x) ((x) % 100)
-#define WINUAEBETA 5
+#define WINUAEBETA 6
#define WINUAEPUBLICBETA 1
-#define WINUAEDATE MAKEBD(2008, 1, 9)
+#define WINUAEDATE MAKEBD(2008, 1, 16)
#define WINUAEEXTRA ""
#define WINUAEREV ""
break;
}
CheckDlgButton (hDlg, IDC_CS_COMPATIBLE, workprefs.cs_compatible);
- CheckDlgButton (hDlg, IDC_CS_KSMIRROR, workprefs.cs_ksmirror);
+ CheckDlgButton (hDlg, IDC_CS_RESETWARNING, workprefs.cs_resetwarning);
+ CheckDlgButton (hDlg, IDC_CS_KSMIRROR_E0, workprefs.cs_ksmirror_e0);
+ CheckDlgButton (hDlg, IDC_CS_KSMIRROR_A8, workprefs.cs_ksmirror_a8);
+ CheckDlgButton (hDlg, IDC_CS_CIAOVERLAY, workprefs.cs_ciaoverlay);
CheckDlgButton (hDlg, IDC_CS_DF0IDHW, workprefs.cs_df0idhw);
CheckDlgButton (hDlg, IDC_CS_CD32CD, workprefs.cs_cd32cd);
CheckDlgButton (hDlg, IDC_CS_CD32C2P, workprefs.cs_cd32c2p);
int v;
workprefs.cs_compatible = IsDlgButtonChecked (hDlg, IDC_CS_COMPATIBLE);
- workprefs.cs_ksmirror = IsDlgButtonChecked (hDlg, IDC_CS_KSMIRROR);
+ workprefs.cs_resetwarning = IsDlgButtonChecked (hDlg, IDC_CS_RESETWARNING);
+ workprefs.cs_ksmirror_e0 = IsDlgButtonChecked (hDlg, IDC_CS_KSMIRROR_E0);
+ workprefs.cs_ksmirror_a8 = IsDlgButtonChecked (hDlg, IDC_CS_KSMIRROR_A8);
+ workprefs.cs_ciaoverlay = IsDlgButtonChecked (hDlg, IDC_CS_CIAOVERLAY);
workprefs.cs_df0idhw = IsDlgButtonChecked (hDlg, IDC_CS_DF0IDHW);
workprefs.cs_cd32cd = IsDlgButtonChecked (hDlg, IDC_CS_CD32CD);
workprefs.cs_cd32c2p = IsDlgButtonChecked (hDlg, IDC_CS_CD32C2P);
ew (hDlg, IDC_CS_CDTVCD, e);
ew (hDlg, IDC_CS_CDTVRAM, e);
ew (hDlg, IDC_CS_CDTVRAMEXP, e);
- ew (hDlg, IDC_CS_KSMIRROR, e);
+ ew (hDlg, IDC_CS_RESETWARNING, e);
+ ew (hDlg, IDC_CS_KSMIRROR_E0, e);
+ ew (hDlg, IDC_CS_KSMIRROR_A8, e);
+ ew (hDlg, IDC_CS_CIAOVERLAY, e);
ew (hDlg, IDC_CS_A1000RAM, e);
ew (hDlg, IDC_CS_DF0IDHW, e);
ew (hDlg, IDC_CS_CIAA_TOD1, e);
{
}
-void gui_hd_led (int led)
+void gui_hd_led (int unitnum, int led)
{
static int resetcounter;
if (resetcounter > 0)
return;
}
+#ifdef RETROPLATFORM
+ rp_hd_activity (unitnum, led);
+#endif
gui_data.hd = led;
resetcounter = 6;
if (old != gui_data.hd)
gui_led (5, gui_data.hd);
}
-void gui_cd_led (int led)
+void gui_cd_led (int unitnum, int led)
{
static int resetcounter;
if (resetcounter > 0)
return;
}
+#ifdef RETROPLATFORM
+ rp_cd_activity (unitnum, led);
+#endif
gui_data.cd = led;
resetcounter = 6;
if (old != gui_data.cd)
RelativePath="..\hq2x32.obj"
>
</File>
+ <File
+ RelativePath="..\resources\resource"
+ >
+ </File>
<File
RelativePath="..\resources\resource.h"
>
1.4.6 will be the last Windows 98/ME compatible version. 1.5.0
will require Windows 2000 or newer.
+Beta 6:
+
+- binary support added to debugger, '%10101'
+- hex/dec/bin converter added to debugger, '?<value>'
+ result is 0x<hex>, %<bin>, <unsigned dec> and <signed dec>
+- all debugger commands which take numeric parameters also accept
+ register names: A0-A7 = RA0-RA7, D0-D7 = RD0-RD7, PC, USP, VBR,..
+- debugger number prefixes: hex = 0x or $, bin = %, dec = !. Most
+ command parameters default to hex (addresses) or decimal.
+- do not reserve lots of jit direct ram if non-jit compatible cpu
+- logitech lcd dfx/cpu/fps counter leading zeros removed
+ (I have G15 again, updated revision this time)
+- some incorrect Quickstart RTC configurations fixed
+- keyboard reset warning feature emulated and added to advanced
+ chipset panel. Reset warning information:
+ http://cataclysm.cx/random/amiga/reference/Hardware_Manual_guide/node0178.html
+ Reset warning sequence is only triggered if Amiga-Amiga-CTRL key
+ sequence pressed and reset warning setting enabled. Or Input panel
+ event "Keycode 0x78 (Reset Warning)" is received.
+ Amiga-Amiga-CTRL-ALT still does instant hardreset. Second
+ Amiga-Amiga-CTRL during reset warning sequence will also cause
+ instant reset.
+ Pre-emptive "bug report": if Amiga-Amiga-CTRL now causes gurus,
+ reset delays or something weird (and does not if reset warning is
+ disabled or GUI Reset-button clicked) you have buggy/badly configured
+ reset handler utility installed. This is Somebody Else's Problem.
+- joystick autoswitch update: firebutton press on non-connected
+ (to emulated Amiga port) joystick AND another joystick already in
+ joystick port (port 1) WITH firebutton pressed = insert new joystick
+ to mouse port
+
+ Following can be ignored if you aren't testing custom ROM images
+ before burning EPROM(s)
+
+- kickstart chipram overlay maps 0xe00000 rom instead of 0xf80000,
+ same with 0xf00000 rom if it begins with 0x1114 (emulates my 1M CDTV
+ EPROM hack..)
+- 2M ROM image support. Gayle ROM mapping:
+ * first 512K bank: E00000-E7FFFF (overlay bank)
+ * second 512K bank: A80000-AFFFFF
+ * third 512K bank: B00000-B7FFFF
+ * fourth 512K bank: F80000-FFFFFF
+ At least A600 and A1200 have 2MB ROM support but note that A1200
+ Blizzard accel's MAPROM feature must be disabled
+- cia overlay advanced chipset setting added (Pre-Gayle models use
+ CIA overlay io pin, newer models have overlay logic inside Gayle)
+- ROM Mirror advanced chipset setting separated to E0 and A8 ROM
+ banks. (A8-B8 = Gayle feature)
+
Beta 5:
- fixed wrong input device GUID format in config files
break;
}
bufp[bufsize - 1] = 0;
+ if (!memcmp (bufp, "write ",6))
+ bufsize--;
ts = writets();
if (bufp[0] == '*')
count++;
projects / francis / winuae.git / commitdiff