cdtv_scsi_int ();
return;
}
- if (!currprefs.cs_a2091 && currprefs.cs_mbdmac != 1)
+ if (!currprefs.a2091 && currprefs.cs_mbdmac != 1)
return;
INT2();
#if A2091_DEBUG > 2 || A3000_DEBUG > 2
static uae_u8 *REGPARAM2 dmac_xlate (uaecptr addr)
{
- addr &= rom_mask;
+ addr &= 0xffff;
addr += rombank * rom_size;
+ if (addr >= 0x8000)
+ addr = 0x8000;
return rom + addr;
}
void a2091_init (void)
{
- int roms[5];
+ int roms[6];
+ int slotsize;
struct romlist *rl;
- struct romdata *rd;
init_scsi ();
configured = 0;
ew (0x20, 0x00); /* ser.no. Byte 2 */
ew (0x24, 0x00); /* ser.no. Byte 3 */
-#if 1
roms[0] = 55; // 7.0
roms[1] = 54; // 6.6
roms[2] = 53; // 6.0
- roms[3] = -1; //roms[3] = 56; // guru
- roms[4] = -1;
-#else
- roms[0] = 56; // guru
- roms[1] = 55; // 7.0
- roms[2] = 54; // 6.6
- roms[3] = 53; // 6.0
- roms[4] = -1;
-#endif
+ roms[3] = 56; // guru
+ roms[4] = 87;
+ roms[5] = -1;
rombankswitcher = 0;
rombank = 0;
- struct zfile *z = read_rom_name (currprefs.a2091romfile);
- if (!z) {
- rl = getromlistbyids (roms);
- if (rl) {
- rd = rl->rd;
- z = read_rom (&rd);
+ slotsize = 65536;
+ rom = xmalloc (uae_u8, slotsize);
+ rom_size = 16384;
+ rom_mask = rom_size - 1;
+ if (_tcscmp (currprefs.a2091romfile, _T(":NOROM"))) {
+ struct zfile *z = read_rom_name (currprefs.a2091romfile);
+ if (!z) {
+ rl = getromlistbyids (roms);
+ if (rl) {
+ z = read_rom (&rl->rd);
+ }
}
- }
- if (z) {
- int slotsize = 65536;
- write_log (_T("A590/A2091 BOOT ROM '%s'\n"), zfile_getname (z));
- rom_size = rd->size;
- rom = xmalloc (uae_u8, slotsize);
- zfile_fread (rom, rom_size, 1, z);
- zfile_fclose (z);
- if (rl->rd->id == 56) {
- rombankswitcher = 1;
- for (int i = rom_size - 1; i >= 0; i--) {
- rom[i * 2 + 0] = rom[i];
- rom[i * 2 + 1] = 0xff;
+ if (z) {
+ write_log (_T("A590/A2091 BOOT ROM '%s'\n"), zfile_getname (z));
+ rom_size = zfile_size (z);
+ zfile_fread (rom, rom_size, 1, z);
+ zfile_fclose (z);
+ if (rom_size == 32768) {
+ rombankswitcher = 1;
+ for (int i = rom_size - 1; i >= 0; i--) {
+ rom[i * 2 + 0] = rom[i];
+ rom[i * 2 + 1] = 0xff;
+ }
+ } else {
+ for (int i = 1; i < slotsize / rom_size; i++)
+ memcpy (rom + i * rom_size, rom, rom_size);
}
+ rom_mask = rom_size - 1;
} else {
- for (int i = 1; i < slotsize / rom_size; i++)
- memcpy (rom + i * rom_size, rom, rom_size);
+ romwarning (roms);
}
- rom_mask = rom_size - 1;
- } else {
- romwarning (roms);
}
map_banks (&dmaca2091_bank, 0xe80000 >> 16, 0x10000 >> 16, 0x10000);
}
{
uae_u8 *dstbak, *dst;
- if (!currprefs.cs_a2091 && !currprefs.cs_mbdmac)
+ if (!currprefs.a2091 && !currprefs.cs_mbdmac)
return NULL;
if (dstptr)
dstbak = dst = dstptr;
STATIC_INLINE void chipmem_agnus_wput2 (uaecptr addr, uae_u32 w)
{
- last_custom_value1 = w;
+ //last_custom_value1 = w; blitter writes are not stored
if (!(log_blitter & 4)) {
chipmem_wput_indirect (addr, w);
debug_wputpeekdma_chipram (addr, w, 0x000);
if (bltcon0 & 0x200) {
if (!dmaen (DMA_BLITTER))
return;
- last_custom_value1 = blt_info.bltddat;
+ //last_custom_value1 = blt_info.bltddat; blitter writes are not stored
chipmem_wput_indirect (bltdpt, blt_info.bltddat);
debug_wputpeekdma_chipram (bltdpt, blt_info.bltddat, 0x000);
}
return;
}
record_dma_blit (0x00, d, bltdpt, hpos);
- last_custom_value1 = d;
+ //last_custom_value1 = d; blitter writes are not stored
chipmem_agnus_wput2 (bltdpt, d);
alloc_cycle_blitter (hpos, &bltdpt, 4);
bltdpt += blit_add;
play_subchannel_callback cdda_subfunc;
play_status_callback cdda_statusfunc;
int cdda_delay, cdda_delay_frames;
+ bool thread_active;
TCHAR imgname[MAX_DPATH];
uae_sem_t sub_sem;
struct cdunit *cdu = (struct cdunit*)v;
int oldtrack = -1;
+ cdu->thread_active = true;
+
while (cdu->cdda_play == 0)
Sleep (10);
oldplay = -1;
memset (cda->buffers[bufnum], 0, num_sectors * 2352);
- for (cnt = 0; cnt < num_sectors; cnt++) {
+ for (cnt = 0; cnt < num_sectors && cdu->cdda_play > 0; cnt++) {
uae_u8 *dst = cda->buffers[bufnum] + cnt * 2352;
uae_u8 subbuf[SUB_CHANNEL_SIZE];
sector = cdda_pos;
bufon[bufnum] = 1;
cda->setvolume (currprefs.sound_volume_cd >= 0 ? currprefs.sound_volume_cd : currprefs.sound_volume, cdu->cdda_volume[0], cdu->cdda_volume[1]);
if (!cda->play (bufnum)) {
- setstate (cdu, AUDIO_STATUS_PLAY_ERROR);
+ if (cdu->cdda_play > 0)
+ setstate (cdu, AUDIO_STATUS_PLAY_ERROR);
goto end;
}
if (dofinish) {
- setstate (cdu, AUDIO_STATUS_PLAY_COMPLETE);
+ if (cdu->cdda_play >= 0)
+ setstate (cdu, AUDIO_STATUS_PLAY_COMPLETE);
cdu->cdda_play = -1;
cdda_pos = cdu->cdda_end + 1;
}
cdu->cdda_play = 0;
write_log (_T("IMAGE CDDA: thread killed\n"));
+ cdu->thread_active = false;
return NULL;
}
{
if (cdu->cdda_play != 0) {
cdu->cdda_play = -1;
- while (cdu->cdda_play) {
+ while (cdu->cdda_play && cdu->thread_active) {
Sleep (10);
}
+ cdu->cdda_play = 0;
}
cdu->cdda_paused = 0;
cdu->cdda_play_state = 0;
struct cdunit *cdu = unitisopen (unitnum);
if (!cdu)
return 0;
+ if (cdu->cdda_play) {
+ cdu->cdda_play = -1;
+ while (cdu->thread_active)
+ Sleep (10);
+ cdu->cdda_play = 0;
+ }
cdu->cd_last_pos = startlsn;
cdu->cdda_start = startlsn;
cdu->cdda_end = endlsn;
setstate (cdu, AUDIO_STATUS_PLAY_ERROR);
return 0;
}
- if (!cdu->cdda_play)
+ if (!cdu->thread_active) {
uae_start_thread (_T("cdimage_cdda_play"), cdda_play_func, cdu, NULL);
+ while (!cdu->thread_active)
+ Sleep (10);
+ }
cdu->cdda_play++;
return 1;
}
cd_finished = 1;
cd_paused = 0;
//cd_error = 1;
+ write_log (_T("audio finished\n"));
activate_stch = 1;
}
cfgfile_dwrite (f, _T("ramsey"), _T("%d"), p->cs_ramseyrev);
cfgfile_dwrite_bool (f, _T("pcmcia"), p->cs_pcmcia);
cfgfile_dwrite_bool (f, _T("scsi_cdtv"), p->cs_cdtvscsi);
- cfgfile_dwrite_bool (f, _T("scsi_a2091"), p->cs_a2091);
- cfgfile_dwrite_bool (f, _T("scsi_a4091"), p->cs_a4091);
+ cfgfile_dwrite_bool (f, _T("scsi_a2091"), p->a2091);
+ cfgfile_dwrite_bool (f, _T("scsi_a4091"), p->a4091);
cfgfile_dwrite_bool (f, _T("scsi_a3000"), p->cs_mbdmac == 1);
cfgfile_dwrite_bool (f, _T("scsi_a4000t"), p->cs_mbdmac == 2);
cfgfile_dwrite_bool (f, _T("bogomem_fast"), p->cs_slowmemisfast);
TCHAR id[MAX_DPATH];
if (!cfgfile_string (option, value, name, id, sizeof id / sizeof (TCHAR)))
return 0;
- if (zfile_exists (location))
- return 1;
TCHAR *p = _tcschr (id, ',');
if (p) {
TCHAR *endptr, tmp;
uae_u32 crc32 = _tcstol (id, &endptr, 16) << 16;
id[4] = tmp;
crc32 |= _tcstol (id + 4, &endptr, 16);
- struct romdata *rd = getromdatabycrc (crc32);
+ struct romdata *rd = getromdatabycrc (crc32, true);
if (rd) {
+ struct romdata *rd2 = getromdatabyid (rd->id);
+ if (rd->group == 0 && rd2 == rd) {
+ if (zfile_exists (location))
+ return 1;
+ }
+ if (rd->group && rd2)
+ rd = rd2;
struct romlist *rl = getromlistbyromdata (rd);
if (rl) {
write_log (_T("%s: %s -> %s\n"), name, location, rl->path);
|| cfgfile_yesno (option, value, _T("a1000ram"), &p->cs_a1000ram)
|| cfgfile_yesno (option, value, _T("pcmcia"), &p->cs_pcmcia)
|| cfgfile_yesno (option, value, _T("scsi_cdtv"), &p->cs_cdtvscsi)
- || cfgfile_yesno (option, value, _T("scsi_a4091"), &p->cs_a4091)
- || cfgfile_yesno (option, value, _T("scsi_a2091"), &p->cs_a2091)
+ || cfgfile_yesno (option, value, _T("scsi_a4091"), &p->a4091)
+ || cfgfile_yesno (option, value, _T("scsi_a2091"), &p->a2091)
|| cfgfile_yesno (option, value, _T("cia_overlay"), &p->cs_ciaoverlay)
|| cfgfile_yesno (option, value, _T("bogomem_fast"), &p->cs_slowmemisfast)
|| cfgfile_yesno (option, value, _T("ksmirror_e0"), &p->cs_ksmirror_e0)
p->cs_agnusrev = -1;
p->cs_deniserev = -1;
p->cs_mbdmac = 0;
- p->cs_a2091 = 0;
- p->cs_a4091 = 0;
+ p->a2091 = 0;
+ p->a4091 = 0;
p->cs_cd32c2p = p->cs_cd32cd = p->cs_cd32nvram = false;
p->cs_cdtvcd = p->cs_cdtvram = false;
p->cs_cdtvcard = 0;
p->cs_agnusrev = -1;
p->cs_deniserev = -1;
p->cs_mbdmac = 0;
- p->cs_a2091 = false;
- p->cs_a4091 = false;
+ p->a2091 = false;
+ p->a4091 = false;
p->cs_cd32c2p = p->cs_cd32cd = p->cs_cd32nvram = false;
p->cs_cdtvcd = p->cs_cdtvram = p->cs_cdtvcard = false;
p->cs_ide = 0;
p->cs_a1000ram = 0;
p->cs_cd32c2p = p->cs_cd32cd = p->cs_cd32nvram = 0;
p->cs_cdtvcd = p->cs_cdtvram = p->cs_cdtvscsi = 0;
- p->cs_a2091 = p->cs_a4091 = 0;
p->cs_fatgaryrev = -1;
p->cs_ide = 0;
p->cs_ramseyrev = -1;
uae_u16 mmu030_state[3];
uae_u32 mmu030_data_buffer;
uae_u32 mmu030_disp_store[2];
+uae_u32 mmu030_fmovem_store[2];
struct mmu030_access mmu030_ad[MAX_MMU030_ACCESS];
/* for debugging messages */
/* Compare actual address with address base using mask */
if ((comp.addr_base&comp.addr_mask)==(addr&comp.addr_mask)) {
- return TT_NO_READ; /* TODO: check this! */
+ return TT_OK_MATCH;
}
}
}
mmu030_state[2] = get_word_mmu030 (a7 + 0x34);
mmu030_disp_store[0] = get_long_mmu030 (a7 + 0x1c);
mmu030_disp_store[1] = get_long_mmu030 (a7 + 0x1c + 4);
-
+ if (mmu030_state[1] & MMU030_STATEFLAG1_FMOVEM) {
+ mmu030_fmovem_store[0] = get_long_mmu030 (a7 + 0x5c - (7 + 1) * 4);
+ mmu030_fmovem_store[1] = get_long_mmu030 (a7 + 0x5c - (8 + 1) * 4);
+ }
// Rerun "mmu030_opcode" using restored state.
mmu030_retry = true;
}
#endif
-uae_u16 last_custom_value1;
-
static unsigned int n_consecutive_skipped = 0;
static unsigned int total_skipped = 0;
static bool genlockvtoggle;
static bool graphicsbuffer_retry;
-
#define LOF_TOGGLES_NEEDED 3
//#define NLACE_CNT_NEEDED 50
static int lof_togglecnt_lace, lof_togglecnt_nlace; //, nlace_cnt;
uae_u16 intena, intreq;
uae_u16 dmacon;
uae_u16 adkcon; /* used by audio code */
+uae_u16 last_custom_value1;
static uae_u32 cop1lc, cop2lc, copcon;
static unsigned int diwstrt, diwstop, diwhigh;
static int diwhigh_written;
static unsigned int ddfstrt, ddfstop, ddfstrt_old_hpos;
-static int ddf_change, badmode, diw_change;
+static int line_cyclebased, badmode, diw_change;
static int bplcon1_fetch;
/* The display and data fetch windows */
if (isocs7planes ()) {
toscr_nr_planes_agnus = 6;
}
- ddf_change = vpos;
+ line_cyclebased = vpos;
}
static void BPLCON0_Denise (int hpos, uae_u16 v, bool);
static void bpldmainitdelay (int hpos)
{
- ddf_change = vpos;
+ line_cyclebased = vpos;
if (hpos + BPLCON_AGNUS_DELAY < 0x14) {
BPLCON0_Denise (hpos, bplcon0, false);
setup_fmodes (hpos);
bitplane_line_crossing = hpos;
warned--;
#if 0
- ddf_change = vpos;
+ line_cyclebased = vpos;
corrupt_offset = (vpos ^ (timeframes << 12)) & 0xff00;
for (int i = 0; i < bplcon0_planes_limit; i++) {
uae_u16 v;
#ifdef SPEEDUP
/* Unrolled version of the for loop below. */
- if (plf_state < plf_wait_stop && ddf_change != vpos && ddf_change + 1 != vpos
+ if (plf_state < plf_wait_stop && line_cyclebased != vpos && line_cyclebased + 1 != vpos
&& dma
&& (fetch_cycle & fetchstart_mask) == (fm_maxplane & fetchstart_mask)
&& !badmode
// A1000 Agnus won't start bitplane DMA if vertical diw is zero.
if (vpos > 0 || (vpos == 0 && !currprefs.cs_dipagnus)) {
diwstate = DIW_waiting_stop;
- ddf_change = vpos;
+ line_cyclebased = vpos;
}
}
// last line of field can never have bitplane dma active
if (vpos == plflastline || cant_this_last_line ()) {
diwstate = DIW_waiting_start;
- ddf_change = vpos;
+ line_cyclebased = vpos;
}
if (hpos <= last_decide_line_hpos)
decide_fetch_safe (hpos);
setclr (&dmacon, v);
- dmacon &= 0x1FFF;
+ dmacon &= 0x07FF;
changed = dmacon ^ oldcon;
#if 0
audio_state_machine ();
if (changed & (DMA_MASTER | DMA_BITPLANE)) {
- ddf_change = vpos;
+ line_cyclebased = vpos;
#if 0
if (dmaen (DMA_BITPLANE)) {
if (vpos == 0xba)
}
#endif
}
- events_schedule();
}
static int irq_nmi;
dbplpth[num] = (v << 16) & 0xffff0000;
dbplpth_on[num] = hpos;
dbplpth_on2++;
- ddf_change = vpos;
+ line_cyclebased = vpos;
return;
}
dbplptl[num] = v & 0x0000fffe;
dbplptl_on[num] = 255;
dbplptl_on2 = 1;
- ddf_change = vpos;
+ line_cyclebased = vpos;
return;
}
bplpt[num] = (bplpt[num] & 0xffff0000) | (v & 0x0000fffe);
if (bplcon0 == v)
return;
- ddf_change = vpos;
+ line_cyclebased = vpos;
decide_diw (hpos);
decide_line (hpos);
decide_fetch_safe (hpos);
v &= 0xff;
if (bplcon1 == v)
return;
- ddf_change = vpos;
+ line_cyclebased = vpos;
decide_line (hpos);
decide_fetch_safe (hpos);
bplcon1_written = true;
v &= 0xfc;
if (ddfstrt == v && hpos + 2 != ddfstrt)
return;
- ddf_change = vpos;
+ line_cyclebased = vpos;
decide_line (hpos);
ddfstrt_old_hpos = hpos;
ddfstrt = v;
v &= 0xfc;
if (ddfstop == v && hpos + 2 != ddfstop)
return;
- ddf_change = vpos;
+ line_cyclebased = vpos;
decide_line (hpos);
decide_fetch_safe (hpos);
ddfstop = v;
v &= 0xC00F;
if (fmode == v)
return;
- ddf_change = vpos;
+ line_cyclebased = vpos;
fmode = v;
sprite_width = GET_SPRITEWIDTH (fmode);
bpldmainitdelay (hpos);
uae_lua_run_handler ("on_uae_vsync");
#endif
- if ((bplcon0 & 2) && currprefs.genlock) {
- genlockvtoggle = !genlockvtoggle;
- //lof_store = genlockvtoggle ? 1 : 0;
- }
if (bplcon0 & 4) {
lof_store = lof_store ? 0 : 1;
}
+ if ((bplcon0 & 2) && currprefs.genlock) {
+ genlockvtoggle = lof_store ? 1 : 0;
+ }
+
if (lof_prev_lastline != lof_lastline) {
if (lof_togglecnt_lace < LOF_TOGGLES_NEEDED)
lof_togglecnt_lace++;
}
#endif
- // genlock active = TOD pulses only every other line/field
+ // genlock active:
+ // vertical: interlaced = toggles every other field, non-interlaced = both fields (normal)
+ // horizontal: PAL = every line, NTSC = every other line
genlockhtoggle = !genlockhtoggle;
- bool ciahsyncs = !(bplcon0 & 2) || ((bplcon0 & 2) && currprefs.genlock && genlockhtoggle);
+ bool ciahsyncs = !(bplcon0 & 2) || ((bplcon0 & 2) && currprefs.genlock && (!currprefs.ntscmode || genlockhtoggle));
bool ciavsyncs = !(bplcon0 & 2) || ((bplcon0 & 2) && currprefs.genlock && genlockvtoggle);
CIA_hsync_posthandler (ciahsyncs);
inputdevice_hsync ();
- last_custom_value1 = 0xffff; // refresh slots should set this to 0xffff
-
if (!nocustom ()) {
if (!currprefs.blitter_cycle_exact && bltstate != BLT_done && dmaen (DMA_BITPLANE) && diwstate == DIW_waiting_stop) {
blitter_slowdown (thisline_decision.plfleft, thisline_decision.plfright - (16 << fetchmode),
return custom_lget (addr);
}
-STATIC_INLINE uae_u32 REGPARAM2 custom_wget_1 (int hpos, uaecptr addr, int noput)
+STATIC_INLINE uae_u32 REGPARAM2 custom_wget_1 (int hpos, uaecptr addr, int noput, bool isbyte)
{
uae_u16 v;
int missing;
* all ones)
*/
v = last_custom_value1;
+ line_cyclebased = vpos;
if (!noput) {
int r;
- uae_u16 old = last_custom_value1;
- uae_u16 l = currprefs.cpu_compatible && currprefs.cpu_model == 68000 ? regs.irc : ((currprefs.chipset_mask & CSMASK_AGA) ? old : 0xffff);
+ uae_u16 l;
+
+ // last chip bus value (read or write) is written to register
+ if (currprefs.cpu_compatible && currprefs.cpu_model == 68000) {
+ if (isbyte)
+ l = (regs.chipset_latch_rw << 8) | (regs.chipset_latch_rw & 0xff);
+ else
+ l = regs.chipset_latch_rw;
+ } else {
+ l = regs.chipset_latch_rw;
+ }
decide_line (hpos);
decide_fetch_safe (hpos);
debug_wputpeek (0xdff000 + addr, l);
r = custom_wput_1 (hpos, addr, l, 1);
- if (r) { // register don't exist
- if (currprefs.chipset_mask & CSMASK_ECS_AGNUS) {
- v = l;
- } else {
- if ((addr & 0x1fe) == 0) {
- if (is_cycle_ce ())
- v = last_custom_value1;
- else
- v = l;
- }
- }
+
+ // cpu gets back
+ // - if last cycle was DMA cycle: DMA cycle data
+ // - if last cycle was not DMA cycle: FFFF or some ANDed old data.
+ //
+ if (is_bitplane_dma (hpos) || (cycle_line[hpos] & CYCLE_MASK) < CYCLE_CPU) {
+ v = last_custom_value1;
} else {
- if ((currprefs.chipset_mask & CSMASK_ECS_AGNUS) && !(currprefs.chipset_mask & CSMASK_AGA))
- v = 0xffff;
- else
- v = l;
+ v = 0xffff;
}
#if CUSTOM_DEBUG > 0
write_log (_T("%08X read = %04X. Value written=%04X PC=%08x\n"), 0xdff000 | addr, v, l, M68K_GETPC);
return v;
}
}
- last_custom_value1 = v;
return v;
}
-STATIC_INLINE uae_u32 custom_wget2 (uaecptr addr)
+STATIC_INLINE uae_u32 custom_wget2 (uaecptr addr, bool byte)
{
uae_u32 v;
int hpos = current_hpos ();
sync_copper_with_cpu (hpos, 1);
- v = custom_wget_1 (hpos, addr, 0);
+ v = custom_wget_1 (hpos, addr, 0, byte);
#ifdef ACTION_REPLAY
#ifdef ACTION_REPLAY_COMMON
addr &= 0x1ff;
if (addr & 1) {
/* think about move.w $dff005,d0.. (68020+ only) */
addr &= ~1;
- v = custom_wget2 (addr) << 8;
- v |= custom_wget2 (addr + 2) >> 8;
+ v = custom_wget2 (addr, false) << 8;
+ v |= custom_wget2 (addr + 2, false) >> 8;
return v;
}
- return custom_wget2 (addr);
+ return custom_wget2 (addr, false);
}
static uae_u32 REGPARAM2 custom_bget (uaecptr addr)
#ifdef JIT
special_mem |= S_READ;
#endif
- v = custom_wget2 (addr & ~1);
+ v = custom_wget2 (addr & ~1, true);
v >>= (addr & 1 ? 0 : 8);
return v;
}
}
static int REGPARAM2 custom_wput_1 (int hpos, uaecptr addr, uae_u32 value, int noget)
{
- if (!noget)
- last_custom_value1 = value;
addr &= 0x1FE;
value &= 0xffff;
#ifdef ACTION_REPLAY
#if CUSTOM_DEBUG > 0
write_log (_T("%04X written %08x\n"), addr, M68K_GETPC);
#endif
- custom_wget_1 (hpos, addr, 1);
+ custom_wget_1 (hpos, addr, 1, false);
}
return 1;
}
currprefs.cs_a1000ram = changed_prefs.cs_a1000ram = RBB;
currprefs.cs_slowmemisfast = changed_prefs.cs_slowmemisfast = RBB;
- currprefs.cs_a2091 = changed_prefs.cs_a2091 = RBB;
- currprefs.cs_a4091 = changed_prefs.cs_a4091 = RBB;
+ currprefs.a2091 = changed_prefs.a2091 = RBB;
+ currprefs.a4091 = changed_prefs.a4091 = RBB;
currprefs.cs_cdtvscsi = changed_prefs.cs_cdtvscsi = RBB;
currprefs.cs_pcmcia = changed_prefs.cs_pcmcia = RBB;
SB (currprefs.cs_a1000ram ? 1 : 0);
SB (currprefs.cs_slowmemisfast ? 1 : 0);
- SB (currprefs.cs_a2091 ? 1 : 0);
- SB (currprefs.cs_a4091 ? 1 : 0);
+ SB (currprefs.a2091 ? 1 : 0);
+ SB (currprefs.a4091 ? 1 : 0);
SB (currprefs.cs_cdtvscsi ? 1 : 0);
SB (currprefs.cs_pcmcia ? 1 : 0);
STATIC_INLINE void decide_fetch_ce (int hpos)
{
- if ((ddf_change == vpos || ddf_change + 1 == vpos || blitter_dangerous_bpl) && vpos < current_maxvpos ())
+ if ((line_cyclebased == vpos || line_cyclebased + 1 == vpos || blitter_dangerous_bpl) && vpos < current_maxvpos ())
decide_fetch (hpos);
}
}
}
+#define SETIFCHIP \
+ if (addr < 0xd80000) \
+ last_custom_value1 = v;
+
uae_u32 wait_cpu_cycle_read (uaecptr addr, int mode)
{
uae_u32 v = 0;
x_do_cycles_post (CYCLE_UNIT, v);
regs.chipset_latch_rw = regs.chipset_latch_read = v;
+ SETIFCHIP
return v;
}
x_do_cycles_post (CYCLE_UNIT / 2, v);
regs.chipset_latch_rw = regs.chipset_latch_read = v;
+ SETIFCHIP
return v;
}
x_do_cycles_post (CYCLE_UNIT, v);
regs.chipset_latch_rw = regs.chipset_latch_write = v;
+ SETIFCHIP
}
void wait_cpu_cycle_write_ce020 (uaecptr addr, int mode, uae_u32 v)
x_do_cycles_post (CYCLE_UNIT / 2, v);
regs.chipset_latch_rw = regs.chipset_latch_write = v;
+ SETIFCHIP
}
void do_cycles_ce (unsigned long cycles)
ham_src_pixel = MAX_PIXELS_PER_LINE + res_shift_from_window (playfield_start - native_ddf_left);
unpainted = res_shift_from_window (unpainted);
- if (sprite_first_x < sprite_last_x) {
- if (sprite_first_x < 0)
- sprite_first_x = 0;
- if (sprite_last_x >= MAX_PIXELS_PER_LINE - 1)
- sprite_last_x = MAX_PIXELS_PER_LINE - 2;
- if (sprite_first_x < sprite_last_x)
- memset (spritepixels + sprite_first_x, 0, sizeof (struct spritepixelsbuf) * (sprite_last_x - sprite_first_x + 1));
+ int first_x = sprite_first_x;
+ int last_x = sprite_last_x;
+ if (first_x < last_x) {
+ if (dp_for_drawing->bordersprite_seen) {
+ if (first_x > visible_left_border)
+ first_x = visible_left_border;
+ if (last_x < visible_right_border)
+ last_x = visible_right_border;
+ }
+ if (first_x < 0)
+ first_x = 0;
+ if (last_x > MAX_PIXELS_PER_LINE - 2)
+ last_x = MAX_PIXELS_PER_LINE - 2;
+ if (first_x < last_x)
+ memset (spritepixels + first_x, 0, sizeof (struct spritepixelsbuf) * (last_x - first_x + 1));
}
+
sprite_last_x = 0;
sprite_first_x = MAX_PIXELS_PER_LINE - 1;
if (dip_for_drawing->nr_sprites) {
int i;
#ifdef AGA
- if (colors_for_drawing.bordersprite)
+ if (colors_for_drawing.bordersprite && dp_for_drawing->bordersprite_seen)
clear_bitplane_border_aga ();
#endif
}
#ifdef AGA
- if (dip_for_drawing->nr_sprites && colors_for_drawing.bordersprite)
+ if (dip_for_drawing->nr_sprites && colors_for_drawing.bordersprite && dp_for_drawing->bordersprite_seen)
do_color_changes (pfield_do_linetoscr_bordersprite_aga, pfield_do_linetoscr, lineno);
else
#endif
static void expamem_init_fastcard (void)
{
- uae_u16 mid = (currprefs.cs_a2091 || currprefs.uae_hide) ? commodore : uae_id;
- uae_u8 pid = (currprefs.cs_a2091 || currprefs.uae_hide) ? commodore_a2091_ram : (currprefs.maprom ? 1 : 81);
- uae_u8 type = add_memory | zorroII | (currprefs.cs_a2091 ? chainedconfig : 0);
+ uae_u16 mid = (currprefs.a2091 || currprefs.uae_hide) ? commodore : uae_id;
+ uae_u8 pid = (currprefs.a2091 || currprefs.uae_hide) ? commodore_a2091_ram : (currprefs.maprom ? 1 : 81);
+ uae_u8 type = add_memory | zorroII | (currprefs.a2091 ? chainedconfig : 0);
expamem_init_clear ();
if (fastmem_bank.allocated == 0x100000)
z3chipmem_bank.start = currprefs.z3fastmem_start;
if (currprefs.mbresmem_high_size == 128 * 1024 * 1024)
z3chipmem_bank.start += 16 * 1024 * 1024;
- z3fastmem_bank.start = z3chipmem_bank.start;
+ if (currprefs.jit_direct_compatible_memory)
+ z3fastmem_bank.start = z3chipmem_bank.start;
+ else
+ z3fastmem_bank.start = 0x40000000;
if (currprefs.z3chipmem_size)
- z3fastmem_bank.start += currprefs.z3chipmem_size + 16 * 1024 * 1024;
+ z3fastmem_bank.start += currprefs.z3chipmem_size;
z3fastmem2_bank.start = z3fastmem_bank.start + currprefs.z3fastmem_size;
if (fastmem_bank.allocated != currprefs.fastmem_size) {
gfxboard_init_registers ();
#endif
}
-#if 0
-void p96memstart (void)
-{
- /* make sure there is always empty space between Z3 and P96 RAM */
- p96ram_start = currprefs.z3fastmem_bank.start + ((currprefs.z3fastmem_size + currprefs.z3fastmem2_size + currprefs.z3chipmem_size + 0xffffff) & ~0xffffff);
- if (p96ram_start == currprefs.z3fastmem_bank.start + currprefs.z3fastmem_size + currprefs.z3fastmem2_size + currprefs.z3chipmem_size &&
- (currprefs.z3fastmem_size + currprefs.z3fastmem2_size + currprefs.z3chipmem_size < 512 * 1024 * 1024 || currprefs.rtgmem_size < 128 * 1024 * 1024))
- p96ram_start += 0x1000000;
-}
-#endif
+
void expamem_reset (void)
{
int do_mount = 1;
}
// immediately after Z2Fast so that they can be emulated as A590/A2091 with fast ram.
#ifdef A2091
- if (currprefs.cs_a2091) {
+ if (currprefs.a2091) {
card_name[cardno] = _T("A2091");
card_init[cardno] = expamem_init_a2091;
card_map[cardno++] = NULL;
}
#endif
-
#ifdef CDTV
if (currprefs.cs_cdtvcd) {
card_name[cardno] = _T("CDTV DMAC");
if (z3chipmem_bank.baseaddr != NULL)
map_banks (&z3chipmem_bank, z3chipmem_bank.start >> 16, currprefs.z3chipmem_size >> 16, z3chipmem_bank.allocated);
#ifdef NCR
- if (currprefs.cs_a4091) {
+ if (currprefs.a4091) {
card_name[cardno] = _T("A4091");
card_init[cardno] = expamem_init_a4091;
card_map[cardno++] = NULL;
a4000t_add_scsi_unit (uci->controller - HD_CONTROLLER_SCSI0, uci);
allocuci (&currprefs, nr, -1);
#endif
- } else if (currprefs.cs_a2091) {
+ } else if (currprefs.a2091) {
#ifdef A2091
a2091_add_scsi_unit (uci->controller - HD_CONTROLLER_SCSI0, uci);
allocuci (&currprefs, nr, -1);
#endif
- } else if (currprefs.cs_a4091) {
+ } else if (currprefs.a4091) {
#ifdef NCR
a4091_add_scsi_unit (uci->controller - HD_CONTROLLER_SCSI0, uci);
allocuci (&currprefs, nr, -1);
#define FFLAG_N 0x0100
#define FFLAG_NAN 0x0400
-#define MAKE_FPSR(r) (regs).fp_result=(r)
+#define MAKE_FPSR(r) (regs).fp_result.fp=(r)
+
+static void fpclear (fpdata *fpd)
+{
+ fpd->fp = 0;
+#ifdef USE_SOFT_LONG_DOUBLE
+ fpd->fpe = 0;
+ fpd->fpm = 0;
+#endif
+}
+static void fpset (fpdata *fpd, fptype f)
+{
+ fpd->fp = f;
+#ifdef USE_SOFT_LONG_DOUBLE
+ fpd->fpe = 0;
+ fpd->fpm = 0;
+#endif
+}
static __inline__ void native_set_fpucw (uae_u32 m68k_cw)
{
{
int v = 0;
- if (currprefs.fpu_revision >= 0)
- return currprefs.fpu_revision;
switch (currprefs.fpu_model)
{
case 68881:
regs.fpsr = 0;
regs.fpiar = 0;
regs.fpsr_highbyte = 0;
- regs.fp_result = 0;
+ fpclear (®s.fp_result);
for (int i = 0; i < 8; i++)
- regs.fp[i] = 0;
+ fpclear (®s.fp[i]);
}
#define fp_round_to_minus_infinity(x) fp_floor(x)
{
uae_u32 answer = regs.fpsr & 0x00ffffff;
#ifdef HAVE_ISNAN
- if (isnan (regs.fp_result))
+ if (isnan (regs.fp_result.fp))
answer |= 0x01000000;
else
#endif
{
- if (regs.fp_result == 0)
+ if (regs.fp_result.fp == 0)
answer |= 0x04000000;
- else if (regs.fp_result < 0)
+ else if (regs.fp_result.fp < 0)
answer |= 0x08000000;
#ifdef HAVE_ISINF
if (isinf (regs.fp_result))
regs.fpsr = x;
if (x & 0x01000000) {
- regs.fp_result = *fp_nan;
+ fpset (®s.fp_result, *fp_nan);
}
else if (x & 0x04000000)
- regs.fp_result = 0;
+ fpset (®s.fp_result, 0);
else if (x & 0x08000000)
- regs.fp_result = -1;
+ fpset (®s.fp_result, -1);
else
- regs.fp_result = 1;
+ fpset (®s.fp_result, 1);
}
/* single : S 8*E 23*F */
/* E = MAX & F # 0 -> NotANumber */
/* E = biased by 127 (single) ,1023 (double) ,16383 (extended) */
-STATIC_INLINE fptype to_pack (uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
+static fptype to_pack (uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
{
fptype d;
char *cp;
*cp++ = ((wrd1 >> 20) & 0xf) + '0';
*cp++ = ((wrd1 >> 16) & 0xf) + '0';
*cp = 0;
+#if USE_LONG_DOUBLE
+ sscanf (str, "%Le", &d);
+#else
sscanf (str, "%le", &d);
+#endif
return d;
}
-STATIC_INLINE void from_pack (fptype src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3)
+// TODO: k-Factor is ignored.
+static void from_pack (fptype src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3, int kfactor)
{
int i;
int t;
char *cp;
char str[100];
+#if USE_LONG_DOUBLE
+ sprintf (str, "%.16Le", src);
+#else
sprintf (str, "%.16e", src);
+#endif
cp = str;
*wrd1 = *wrd2 = *wrd3 = 0;
if (*cp == '-') {
}
}
-STATIC_INLINE int get_fp_value (uae_u32 opcode, uae_u16 extra, fptype *src, uaecptr oldpc)
+STATIC_INLINE int get_fp_value (uae_u32 opcode, uae_u16 extra, fpdata *src, uaecptr oldpc)
{
int size, mode, reg;
uae_u32 ad = 0;
switch (size)
{
case 6:
- *src = (fptype) (uae_s8) m68k_dreg (regs, reg);
+ src->fp = (fptype) (uae_s8) m68k_dreg (regs, reg);
break;
case 4:
- *src = (fptype) (uae_s16) m68k_dreg (regs, reg);
+ src->fp = (fptype) (uae_s16) m68k_dreg (regs, reg);
break;
case 0:
- *src = (fptype) (uae_s32) m68k_dreg (regs, reg);
+ src->fp = (fptype) (uae_s32) m68k_dreg (regs, reg);
break;
case 1:
- *src = to_single (m68k_dreg (regs, reg));
+ src->fp = to_single (m68k_dreg (regs, reg));
break;
default:
return 0;
ad = m68k_areg (regs, reg);
break;
case 5:
- ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) x_next_iword ();
+ ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 6:
ad = x_cp_get_disp_ea_020 (m68k_areg (regs, reg), 0);
switch (reg)
{
case 0:
- ad = (uae_s32) (uae_s16) x_next_iword ();
+ ad = (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 1:
- ad = x_next_ilong ();
+ ad = x_cp_next_ilong ();
break;
case 2:
ad = m68k_getpc ();
- ad += (uae_s32) (uae_s16) x_next_iword ();
+ ad += (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 3:
ad = x_cp_get_disp_ea_020 (m68k_getpc (), 0);
{
case 0:
case 1:
- exts[0] = x_next_ilong ();
+ exts[0] = x_cp_next_ilong ();
break;
case 2:
case 3:
- exts[0] = x_next_ilong ();
- exts[1] = x_next_ilong ();
- exts[2] = x_next_ilong ();
+ exts[0] = x_cp_next_ilong ();
+ exts[1] = x_cp_next_ilong ();
+ exts[2] = x_cp_next_ilong ();
break;
case 4:
- exts[0] = x_next_iword ();
+ exts[0] = x_cp_next_iword ();
break;
case 5:
- exts[0] = x_next_ilong ();
- exts[1] = x_next_ilong ();
+ exts[0] = x_cp_next_ilong ();
+ exts[1] = x_cp_next_ilong ();
break;
case 6:
- exts[0] = x_next_iword ();
+ exts[0] = x_cp_next_iword ();
break;
}
break;
switch (size)
{
case 0:
- *src = (fptype) (uae_s32) (doext ? exts[0] : x_cp_get_long (ad));
+ src->fp = (fptype) (uae_s32) (doext ? exts[0] : x_cp_get_long (ad));
break;
case 1:
- *src = to_single ((doext ? exts[0] : x_cp_get_long (ad)));
+ src->fp = to_single ((doext ? exts[0] : x_cp_get_long (ad)));
break;
case 2:
{
wrd2 = (doext ? exts[1] : x_cp_get_long (ad));
ad += 4;
wrd3 = (doext ? exts[2] : x_cp_get_long (ad));
- *src = to_exten (wrd1, wrd2, wrd3);
+ to_exten (src, wrd1, wrd2, wrd3);
}
break;
case 3:
wrd2 = (doext ? exts[1] : x_cp_get_long (ad));
ad += 4;
wrd3 = (doext ? exts[2] : x_cp_get_long (ad));
- *src = to_pack (wrd1, wrd2, wrd3);
+ src->fp = to_pack (wrd1, wrd2, wrd3);
}
break;
case 4:
- *src = (fptype) (uae_s16) (doext ? exts[0] : x_cp_get_word (ad));
+ src->fp = (fptype) (uae_s16) (doext ? exts[0] : x_cp_get_word (ad));
break;
case 5:
{
wrd1 = (doext ? exts[0] : x_cp_get_long (ad));
ad += 4;
wrd2 = (doext ? exts[1] : x_cp_get_long (ad));
- *src = to_double (wrd1, wrd2);
+ src->fp = to_double (wrd1, wrd2);
}
break;
case 6:
- *src = (fptype) (uae_s8) (doext ? exts[0] : x_cp_get_byte (ad));
+ src->fp = (fptype) (uae_s8) (doext ? exts[0] : x_cp_get_byte (ad));
break;
default:
return 0;
return 1;
}
-STATIC_INLINE int put_fp_value (fptype value, uae_u32 opcode, uae_u16 extra, uaecptr oldpc)
+STATIC_INLINE int put_fp_value (fpdata *value, uae_u32 opcode, uae_u16 extra, uaecptr oldpc)
{
int size, mode, reg;
uae_u32 ad = 0;
#if DEBUG_FPP
if (!isinrom ())
write_log (_T("PUTFP: %f %04X %04X\n"), value, opcode, extra);
+#endif
+#ifdef USE_SOFT_LONG_DOUBLE
+ value->fpx = false;
#endif
if (!(extra & 0x4000)) {
if (fault_if_no_fpu (opcode, extra, 0, oldpc))
return 1;
- regs.fp[(extra >> 10) & 7] = value;
+ regs.fp[(extra >> 10) & 7] = *value;
return 1;
}
reg = opcode & 7;
switch (size)
{
case 6:
- m68k_dreg (regs, reg) = (uae_u32)(((toint (value, -128.0, 127.0) & 0xff)
+ m68k_dreg (regs, reg) = (uae_u32)(((toint (value->fp, -128.0, 127.0) & 0xff)
| (m68k_dreg (regs, reg) & ~0xff)));
break;
case 4:
- m68k_dreg (regs, reg) = (uae_u32)(((toint (value, -32768.0, 32767.0) & 0xffff)
+ m68k_dreg (regs, reg) = (uae_u32)(((toint (value->fp, -32768.0, 32767.0) & 0xffff)
| (m68k_dreg (regs, reg) & ~0xffff)));
break;
case 0:
- m68k_dreg (regs, reg) = (uae_u32)toint (value, -2147483648.0, 2147483647.0);
+ m68k_dreg (regs, reg) = (uae_u32)toint (value->fp, -2147483648.0, 2147483647.0);
break;
case 1:
- m68k_dreg (regs, reg) = from_single (value);
+ m68k_dreg (regs, reg) = from_single (value->fp);
break;
default:
return 0;
ad = m68k_areg (regs, reg);
break;
case 5:
- ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) x_next_iword ();
+ ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 6:
ad = x_cp_get_disp_ea_020 (m68k_areg (regs, reg), 0);
switch (reg)
{
case 0:
- ad = (uae_s32) (uae_s16) x_next_iword ();
+ ad = (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 1:
- ad = x_next_ilong ();
+ ad = x_cp_next_ilong ();
break;
case 2:
ad = m68k_getpc ();
- ad += (uae_s32) (uae_s16) x_next_iword ();
+ ad += (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 3:
ad = x_cp_get_disp_ea_020 (m68k_getpc (), 0);
switch (size)
{
case 0:
- x_cp_put_long (ad, (uae_u32)toint (value, -2147483648.0, 2147483647.0));
+ x_cp_put_long (ad, (uae_u32)toint (value->fp, -2147483648.0, 2147483647.0));
break;
case 1:
- x_cp_put_long (ad, from_single (value));
+ x_cp_put_long (ad, from_single (value->fp));
break;
case 2:
{
x_cp_put_long (ad, wrd3);
}
break;
- case 3:
+ case 3: // Packed-Decimal Real with Static k-Factor
+ case 7: // Packed-Decimal Real with Dynamic k-Factor (P{Dn}) (reg to memory only)
{
uae_u32 wrd1, wrd2, wrd3;
if (fault_if_4060 (opcode, extra, ad, oldpc, FPU_EXP_UNIMP_DATATYPE))
return -1;
- from_pack (value, &wrd1, &wrd2, &wrd3);
+ from_pack (value->fp, &wrd1, &wrd2, &wrd3, size == 7 ? m68k_dreg (regs, (extra >> 4) & 7) : extra & 127);
x_cp_put_long (ad, wrd1);
ad += 4;
x_cp_put_long (ad, wrd2);
}
break;
case 4:
- x_cp_put_word (ad, (uae_s16) toint (value, -32768.0, 32767.0));
+ x_cp_put_word (ad, (uae_s16) toint (value->fp, -32768.0, 32767.0));
break;
case 5:
{
uae_u32 wrd1, wrd2;
- from_double (value, &wrd1, &wrd2);
+ from_double (value->fp, &wrd1, &wrd2);
x_cp_put_long (ad, wrd1);
ad += 4;
x_cp_put_long (ad, wrd2);
}
break;
case 6:
- x_cp_put_byte (ad, (uae_s8)toint (value, -128.0, 127.0));
+ x_cp_put_byte (ad, (uae_s8)toint (value->fp, -128.0, 127.0));
break;
default:
return 0;
*ad = m68k_areg (regs, reg);
break;
case 5:
- *ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) x_next_iword ();
+ *ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 6:
*ad = x_cp_get_disp_ea_020 (m68k_areg (regs, reg), 0);
switch (reg)
{
case 0:
- *ad = (uae_s32) (uae_s16) x_next_iword ();
+ *ad = (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 1:
- *ad = x_next_ilong ();
+ *ad = x_cp_next_ilong ();
break;
case 2:
*ad = m68k_getpc ();
- *ad += (uae_s32) (uae_s16) x_next_iword ();
+ *ad += (uae_s32) (uae_s16) x_cp_next_iword ();
break;
case 3:
*ad = x_cp_get_disp_ea_020 (m68k_getpc (), 0);
STATIC_INLINE int fpp_cond (int condition)
{
- int N = (regs.fp_result < 0.0);
- int Z = (regs.fp_result == 0.0);
+ int N = (regs.fp_result.fp < 0.0);
+ int Z = (regs.fp_result.fp == 0.0);
int NotANumber = 0;
#ifdef HAVE_ISNAN
- NotANumber = isnan (regs.fp_result);
+ NotANumber = isnan (regs.fp_result.fp);
#endif
if (NotANumber)
if (fault_if_no_6888x (opcode, extra, pc - 4))
return;
- disp = (uae_s32) (uae_s16) x_next_iword ();
+ disp = (uae_s32) (uae_s16) x_cp_next_iword ();
if (fault_if_no_fpu_u (opcode, extra, pc + disp, pc - 4))
return;
regs.fpiar = pc - 4;
cc = fpp_cond (extra & 0x3f);
if (cc == -1) {
fpu_op_illg (opcode, oldpc);
- }
- if (cc)
+ } else if (cc) {
Exception (7);
+ }
}
void fpuop_bcc (uae_u32 opcode, uaecptr oldpc, uae_u32 extra)
uae_u32 frame_id = regs.fpu_state == 0 ? 0x00000000 : 0x00006000;
if (incr < 0) {
ad -= 4;
- x_cp_put_long (ad, 0x00000000);
+ x_put_long (ad, 0x00000000);
ad -= 4;
- x_cp_put_long (ad, 0x00000000);
+ x_put_long (ad, 0x00000000);
ad -= 4;
- x_cp_put_long (ad, frame_id);
+ x_put_long (ad, frame_id);
} else {
- x_cp_put_long (ad, frame_id);
+ x_put_long (ad, frame_id);
ad += 4;
- x_cp_put_long (ad, 0x00000000);
+ x_put_long (ad, 0x00000000);
ad += 4;
- x_cp_put_long (ad, 0x00000000);
+ x_put_long (ad, 0x00000000);
ad += 4;
}
} else if (currprefs.fpu_model == 68040) {
uae_u32 frame_id = regs.fpu_state == 0 ? 0 : fpu_version << 24;
if (incr < 0) {
ad -= 4;
- x_cp_put_long (ad, frame_id);
+ x_put_long (ad, frame_id);
} else {
- x_cp_put_long (ad, frame_id);
+ x_put_long (ad, frame_id);
ad += 4;
}
} else { /* 68881/68882 */
if (incr < 0) {
for (i = 0; i < (frame_size / 4) - 1; i++) {
ad -= 4;
- x_cp_put_long (ad, i == 0 ? 0x70000000 : 0x00000000);
+ x_put_long (ad, i == 0 ? 0x70000000 : 0x00000000);
}
ad -= 4;
- x_cp_put_long (ad, frame_id);
+ x_put_long (ad, frame_id);
} else {
- x_cp_put_long (ad, frame_id);
+ x_put_long (ad, frame_id);
ad += 4;
for (i = 0; i < (frame_size / 4) - 1; i++) {
- x_cp_put_long (ad, i == (frame_size / 4) - 2 ? 0x70000000 : 0x00000000);
+ x_put_long (ad, i == (frame_size / 4) - 2 ? 0x70000000 : 0x00000000);
ad += 4;
}
}
uae_u32 pad = ad;
if (incr < 0) {
ad -= 4;
- d = x_cp_get_long (ad);
+ d = x_get_long (ad);
} else {
- d = x_cp_get_long (ad);
+ d = x_get_long (ad);
ad += 4;
}
static void fround (int reg)
{
- regs.fp[reg] = (float)regs.fp[reg];
+ regs.fp[reg].fp = (float)regs.fp[reg].fp;
}
static uaecptr fmovem2mem (uaecptr ad, uae_u32 list, int incr)
// 68030 MMU state saving is annoying!
if (currprefs.mmu_model == 68030) {
int idx = 0;
+ uae_u32 wrd[3];
+ mmu030_state[1] |= MMU030_STATEFLAG1_MOVEM1;
if (incr < 0) {
for (reg = 7; reg >= 0; reg--) {
- uae_u32 wrd1, wrd2, wrd3;
if (list & 0x80) {
- from_exten (regs.fp[reg], &wrd1, &wrd2, &wrd3);
- ad -= 4;
- if (mmu030_state[0] == idx * 3 + 0) {
- x_put_long (ad, wrd3);
- mmu030_state[0]++;
- }
- ad -= 4;
- if (mmu030_state[0] == idx * 3 + 1) {
- x_put_long (ad, wrd2);
- mmu030_state[0]++;
- }
- ad -= 4;
- if (mmu030_state[0] == idx * 3 + 2) {
- x_put_long (ad, wrd1);
- mmu030_state[0]++;
+ from_exten (®s.fp[reg], &wrd[2], &wrd[1], &wrd[0]);
+ for (int i = 0; i < 3; i++) {
+ ad -= 4;
+ if (mmu030_state[0] == idx * 3 + i) {
+ if (mmu030_state[1] & MMU030_STATEFLAG1_MOVEM2) {
+ mmu030_state[1] &= ~MMU030_STATEFLAG1_MOVEM2;
+ } else {
+ mmu030_data_buffer = wrd[i];
+ x_put_long (ad, wrd[i]);
+ }
+ mmu030_state[0]++;
+ }
}
idx++;
}
}
} else {
for (reg = 0; reg <= 7; reg++) {
- uae_u32 wrd1, wrd2, wrd3;
if (list & 0x80) {
- from_exten (regs.fp[reg], &wrd1, &wrd2, &wrd3);
- if (mmu030_state[0] == idx * 3 + 0) {
- x_put_long (ad, wrd1);
- mmu030_state[0]++;
- }
- ad += 4;
- if (mmu030_state[0] == idx * 3 + 1) {
- x_put_long (ad, wrd2);
- mmu030_state[0]++;
- }
- ad += 4;
- if (mmu030_state[0] == idx * 3 + 2) {
- x_put_long (ad, wrd3);
- mmu030_state[0]++;
+ from_exten (®s.fp[reg], &wrd[0], &wrd[1], &wrd[2]);
+ for (int i = 0; i < 3; i++) {
+ if (mmu030_state[0] == idx * 3 + i) {
+ if (mmu030_state[1] & MMU030_STATEFLAG1_MOVEM2) {
+ mmu030_state[1] &= ~MMU030_STATEFLAG1_MOVEM2;
+ } else {
+ mmu030_data_buffer = wrd[i];
+ x_put_long (ad, wrd[i]);
+ }
+ mmu030_state[0]++;
+ }
+ ad += 4;
}
- ad += 4;
idx++;
}
list <<= 1;
for (reg = 7; reg >= 0; reg--) {
uae_u32 wrd1, wrd2, wrd3;
if (list & 0x80) {
- from_exten (regs.fp[reg], &wrd1, &wrd2, &wrd3);
+ from_exten (®s.fp[reg], &wrd1, &wrd2, &wrd3);
ad -= 4;
- x_cp_put_long (ad, wrd3);
+ x_put_long (ad, wrd3);
ad -= 4;
- x_cp_put_long (ad, wrd2);
+ x_put_long (ad, wrd2);
ad -= 4;
- x_cp_put_long (ad, wrd1);
+ x_put_long (ad, wrd1);
}
list <<= 1;
}
for (reg = 0; reg <= 7; reg++) {
uae_u32 wrd1, wrd2, wrd3;
if (list & 0x80) {
- from_exten (regs.fp[reg], &wrd1, &wrd2, &wrd3);
- x_cp_put_long (ad, wrd1);
+ from_exten (®s.fp[reg], &wrd1, &wrd2, &wrd3);
+ x_put_long (ad, wrd1);
ad += 4;
- x_cp_put_long (ad, wrd2);
+ x_put_long (ad, wrd2);
ad += 4;
- x_cp_put_long (ad, wrd3);
+ x_put_long (ad, wrd3);
ad += 4;
}
list <<= 1;
{
int reg;
if (currprefs.mmu_model == 68030) {
- static uae_u32 wrd1, wrd2, wrd3;
+ uae_u32 wrd[3];
int idx = 0;
+ mmu030_state[1] |= MMU030_STATEFLAG1_MOVEM1 | MMU030_STATEFLAG1_FMOVEM;
+ if (mmu030_state[1] & MMU030_STATEFLAG1_MOVEM2)
+ ad = mmu030_ad[mmu030_idx].val;
+ else
+ mmu030_ad[mmu030_idx].val = ad;
if (incr < 0) {
for (reg = 7; reg >= 0; reg--) {
if (list & 0x80) {
- ad -= 4;
- if (mmu030_state[0] == idx * 3 + 0) {
- wrd3 = x_get_long (ad);
- mmu030_state[0]++;
- }
- ad -= 4;
- if (mmu030_state[0] == idx * 3 + 1) {
- wrd2 = x_get_long (ad);
- mmu030_state[0]++;
- }
- ad -= 4;
- if (mmu030_state[0] == idx * 3 + 2) {
- wrd1 = x_get_long (ad);
- mmu030_state[0]++;
- regs.fp[reg] = to_exten(wrd1, wrd2, wrd3);
+ for (int i = 0; i < 3; i++) {
+ ad -= 4;
+ if (mmu030_state[0] == idx * 3 + i) {
+ if (mmu030_state[1] & MMU030_STATEFLAG1_MOVEM2) {
+ mmu030_state[1] &= ~MMU030_STATEFLAG1_MOVEM2;
+ wrd[i] = mmu030_data_buffer;
+ } else {
+ wrd[i] = x_get_long (ad);
+ }
+ // save first two entries if 2nd or 3rd get_long() faults.
+ if (i == 0 || i == 1)
+ mmu030_fmovem_store[i] = wrd[i];
+ mmu030_state[0]++;
+ if (i == 2)
+ to_exten (®s.fp[reg], wrd[2], mmu030_fmovem_store[1], mmu030_fmovem_store[0]);
+ }
}
idx++;
}
} else {
for (reg = 0; reg <= 7; reg++) {
if (list & 0x80) {
- if (mmu030_state[0] == idx * 3 + 0) {
- wrd1 = x_get_long (ad);
- mmu030_state[0]++;
- }
- ad += 4;
- if (mmu030_state[0] == idx * 3 + 1) {
- wrd2 = x_get_long (ad);
- mmu030_state[0]++;
- }
- ad += 4;
- if (mmu030_state[0] == idx * 3 + 2) {
- wrd3 = x_get_long (ad);
- mmu030_state[0]++;
- regs.fp[reg] = to_exten(wrd1, wrd2, wrd3);
+ for (int i = 0; i < 3; i++) {
+ if (mmu030_state[0] == idx * 3 + i) {
+ if (mmu030_state[1] & MMU030_STATEFLAG1_MOVEM2) {
+ mmu030_state[1] &= ~MMU030_STATEFLAG1_MOVEM2;
+ wrd[i] = mmu030_data_buffer;
+ } else {
+ wrd[i] = x_get_long (ad);
+ }
+ if (i == 0 || i == 1)
+ mmu030_fmovem_store[i] = wrd[i];
+ mmu030_state[0]++;
+ if (i == 2)
+ to_exten (®s.fp[reg], mmu030_fmovem_store[0], mmu030_fmovem_store[1], wrd[2]);
+ }
+ ad += 4;
}
- ad += 4;
idx++;
}
list <<= 1;
uae_u32 wrd1, wrd2, wrd3;
if (list & 0x80) {
ad -= 4;
- wrd3 = x_cp_get_long (ad);
+ wrd3 = x_get_long (ad);
ad -= 4;
- wrd2 = x_cp_get_long (ad);
+ wrd2 = x_get_long (ad);
ad -= 4;
- wrd1 = x_cp_get_long (ad);
- regs.fp[reg] = to_exten(wrd1, wrd2, wrd3);
+ wrd1 = x_get_long (ad);
+ to_exten (®s.fp[reg], wrd1, wrd2, wrd3);
}
list <<= 1;
}
for (reg = 0; reg <= 7; reg++) {
uae_u32 wrd1, wrd2, wrd3;
if (list & 0x80) {
- wrd1 = x_cp_get_long (ad);
+ wrd1 = x_get_long (ad);
ad += 4;
- wrd2 = x_cp_get_long (ad);
+ wrd2 = x_get_long (ad);
ad += 4;
- wrd3 = x_cp_get_long (ad);
+ wrd3 = x_get_long (ad);
ad += 4;
- regs.fp[reg] = to_exten(wrd1, wrd2, wrd3);
+ to_exten (®s.fp[reg], wrd1, wrd2, wrd3);
}
list <<= 1;
}
{
int reg, v;
fptype src;
+ fpdata srcd;
uaecptr pc = m68k_getpc () - 4;
uaecptr ad = 0;
switch ((extra >> 13) & 0x7)
{
case 3:
- if (put_fp_value (regs.fp[(extra >> 7) & 7], opcode, extra, pc) == 0)
+ if (put_fp_value (®s.fp[(extra >> 7) & 7], opcode, extra, pc) == 0)
fpu_noinst (opcode, pc);
return;
return;
if ((extra & 0x2000) == 0) {
if (extra & 0x1000) {
- regs.fpcr = x_next_ilong ();
+ regs.fpcr = x_cp_next_ilong ();
native_set_fpucw (regs.fpcr);
}
if (extra & 0x0800)
- set_fpsr (x_next_ilong ());
+ set_fpsr (x_cp_next_ilong ());
if (extra & 0x0400)
- regs.fpiar = x_next_ilong ();
+ regs.fpiar = x_cp_next_ilong ();
}
} else if (extra & 0x2000) {
/* FMOVEM FPP->memory */
case 2: /* Extremely common */
regs.fpiar = pc;
reg = (extra >> 7) & 7;
+#ifdef USE_SOFT_LONG_DOUBLE
+ regs.fp[reg].fpx = false;
+#endif
if ((extra & 0xfc00) == 0x5c00) {
if (fault_if_no_fpu (opcode, extra, 0, pc))
return;
switch (extra & 0x7f)
{
case 0x00:
- regs.fp[reg] = *fp_pi;
+ regs.fp[reg].fp = *fp_pi;
break;
case 0x0b:
- regs.fp[reg] = *fp_l10_2;
+ regs.fp[reg].fp = *fp_l10_2;
break;
case 0x0c:
- regs.fp[reg] = *fp_exp_1;
+ regs.fp[reg].fp = *fp_exp_1;
break;
case 0x0d:
- regs.fp[reg] = *fp_l2_e;
+ regs.fp[reg].fp = *fp_l2_e;
break;
case 0x0e:
- regs.fp[reg] = *fp_l10_e;
+ regs.fp[reg].fp = *fp_l10_e;
break;
case 0x0f:
- regs.fp[reg] = 0.0;
+ regs.fp[reg].fp = 0.0;
break;
case 0x30:
- regs.fp[reg] = *fp_ln_2;
+ regs.fp[reg].fp = *fp_ln_2;
break;
case 0x31:
- regs.fp[reg] = *fp_ln_10;
+ regs.fp[reg].fp = *fp_ln_10;
break;
case 0x32:
- regs.fp[reg] = (fptype)fp_1e0;
+ regs.fp[reg].fp = (fptype)fp_1e0;
break;
case 0x33:
- regs.fp[reg] = (fptype)fp_1e1;
+ regs.fp[reg].fp = (fptype)fp_1e1;
break;
case 0x34:
- regs.fp[reg] = (fptype)fp_1e2;
+ regs.fp[reg].fp = (fptype)fp_1e2;
break;
case 0x35:
- regs.fp[reg] = (fptype)fp_1e4;
+ regs.fp[reg].fp = (fptype)fp_1e4;
break;
case 0x36:
- regs.fp[reg] = (fptype)fp_1e8;
+ regs.fp[reg].fp = (fptype)fp_1e8;
break;
case 0x37:
- regs.fp[reg] = *fp_1e16;
+ regs.fp[reg].fp = *fp_1e16;
break;
case 0x38:
- regs.fp[reg] = *fp_1e32;
+ regs.fp[reg].fp = *fp_1e32;
break;
case 0x39:
- regs.fp[reg] = *fp_1e64;
+ regs.fp[reg].fp = *fp_1e64;
break;
case 0x3a:
- regs.fp[reg] = *fp_1e128;
+ regs.fp[reg].fp = *fp_1e128;
break;
case 0x3b:
- regs.fp[reg] = *fp_1e256;
+ regs.fp[reg].fp = *fp_1e256;
break;
case 0x3c:
- regs.fp[reg] = *fp_1e512;
+ regs.fp[reg].fp = *fp_1e512;
break;
case 0x3d:
- regs.fp[reg] = *fp_1e1024;
+ regs.fp[reg].fp = *fp_1e1024;
break;
case 0x3e:
- regs.fp[reg] = *fp_1e2048;
+ regs.fp[reg].fp = *fp_1e2048;
break;
case 0x3f:
- regs.fp[reg] = *fp_1e4096;
+ regs.fp[reg].fp = *fp_1e4096;
break;
default:
fpu_noinst (opcode, pc);
return;
}
- MAKE_FPSR (regs.fp[reg]);
+ MAKE_FPSR (regs.fp[reg].fp);
return;
}
if (fault_if_unimplemented_6888x (opcode, extra, pc))
return;
- v = get_fp_value (opcode, extra, &src, pc);
+ v = get_fp_value (opcode, extra, &srcd, pc);
if (v <= 0) {
if (v == 0)
fpu_noinst (opcode, pc);
return;
}
+ src = srcd.fp;
// get_fp_value() checked this, but only if EA was nonzero (non-register)
if (fault_if_unimplemented_680x0 (opcode, extra, 0, pc))
case 0x00: /* FMOVE */
case 0x40: /* Explicit rounding. This is just a quick fix. */
case 0x44: /* Same for all other cases that have three choices */
- regs.fp[reg] = src; /* Brian King was here. */
+ regs.fp[reg].fp = src; /* Brian King was here. */
/*<ea> to register needs FPSR updated. See Motorola 68K Manual. */
if ((extra & 0x44) == 0x40)
fround (reg);
frndint
fstp LDPTR tmp_fp
}
- regs.fp[reg] = tmp_fp;
+ regs.fp[reg].fp = tmp_fp;
}
#else /* no X86_MSVC */
switch ((regs.fpcr >> 4) & 3) {
case 0: /* to nearest */
- regs.fp[reg] = floor (src + 0.5);
+ regs.fp[reg].fp = floor (src + 0.5);
break;
case 1: /* to zero */
if (src >= 0.0)
- regs.fp[reg] = floor (src);
+ regs.fp[reg].fp = floor (src);
else
- regs.fp[reg] = ceil (src);
+ regs.fp[reg].fp = ceil (src);
break;
case 2: /* down */
- regs.fp[reg] = floor (src);
+ regs.fp[reg].fp = floor (src);
break;
case 3: /* up */
- regs.fp[reg] = ceil (src);
+ regs.fp[reg].fp = ceil (src);
break;
default: /* never reached */
- regs.fp[reg] = src;
+ regs.fp[reg].fp = src;
}
#endif /* X86_MSVC */
break;
case 0x02: /* FSINH */
- regs.fp[reg] = sinh (src);
+ regs.fp[reg].fp = sinh (src);
break;
case 0x03: /* FINTRZ */
- regs.fp[reg] = fp_round_to_zero (src);
+ regs.fp[reg].fp = fp_round_to_zero (src);
break;
case 0x04: /* FSQRT */
case 0x41: /* FSSQRT */
case 0x45: /* FDSQRT */
- regs.fp[reg] = sqrt (src);
+ regs.fp[reg].fp = sqrt (src);
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x06: /* FLOGNP1 */
- regs.fp[reg] = log (src + 1.0);
+ regs.fp[reg].fp = log (src + 1.0);
break;
case 0x08: /* FETOXM1 */
- regs.fp[reg] = exp (src) - 1.0;
+ regs.fp[reg].fp = exp (src) - 1.0;
break;
case 0x09: /* FTANH */
- regs.fp[reg] = tanh (src);
+ regs.fp[reg].fp = tanh (src);
break;
case 0x0a: /* FATAN */
- regs.fp[reg] = atan (src);
+ regs.fp[reg].fp = atan (src);
break;
case 0x0c: /* FASIN */
- regs.fp[reg] = asin (src);
+ regs.fp[reg].fp = asin (src);
break;
case 0x0d: /* FATANH */
#if 1 /* The BeBox doesn't have atanh, and it isn't in the HPUX libm either */
- regs.fp[reg] = 0.5 * log ((1 + src) / (1 - src));
+ regs.fp[reg].fp = 0.5 * log ((1 + src) / (1 - src));
#else
- regs.fp[reg] = atanh (src);
+ regs.fp[reg].fp = atanh (src);
#endif
break;
case 0x0e: /* FSIN */
- regs.fp[reg] = sin (src);
+ regs.fp[reg].fp = sin (src);
break;
case 0x0f: /* FTAN */
- regs.fp[reg] = tan (src);
+ regs.fp[reg].fp = tan (src);
break;
case 0x10: /* FETOX */
- regs.fp[reg] = exp (src);
+ regs.fp[reg].fp = exp (src);
break;
case 0x11: /* FTWOTOX */
- regs.fp[reg] = pow (2.0, src);
+ regs.fp[reg].fp = pow (2.0, src);
break;
case 0x12: /* FTENTOX */
- regs.fp[reg] = pow (10.0, src);
+ regs.fp[reg].fp = pow (10.0, src);
break;
case 0x14: /* FLOGN */
- regs.fp[reg] = log (src);
+ regs.fp[reg].fp = log (src);
break;
case 0x15: /* FLOG10 */
- regs.fp[reg] = log10 (src);
+ regs.fp[reg].fp = log10 (src);
break;
case 0x16: /* FLOG2 */
- regs.fp[reg] = *fp_l2_e * log (src);
+ regs.fp[reg].fp = *fp_l2_e * log (src);
break;
case 0x18: /* FABS */
case 0x58: /* FSABS */
case 0x5c: /* FDABS */
- regs.fp[reg] = src < 0 ? -src : src;
+ regs.fp[reg].fp = src < 0 ? -src : src;
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x19: /* FCOSH */
- regs.fp[reg] = cosh (src);
+ regs.fp[reg].fp = cosh (src);
break;
case 0x1a: /* FNEG */
case 0x5a: /* FSNEG */
case 0x5e: /* FDNEG */
- regs.fp[reg] = -src;
+ regs.fp[reg].fp = -src;
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x1c: /* FACOS */
- regs.fp[reg] = acos (src);
+ regs.fp[reg].fp = acos (src);
break;
case 0x1d: /* FCOS */
- regs.fp[reg] = cos (src);
+ regs.fp[reg].fp = cos (src);
break;
case 0x1e: /* FGETEXP */
{
if (src == 0) {
- regs.fp[reg] = 0;
+ regs.fp[reg].fp = 0;
} else {
int expon;
frexp (src, &expon);
- regs.fp[reg] = (double) (expon - 1);
+ regs.fp[reg].fp = (double) (expon - 1);
}
}
break;
case 0x1f: /* FGETMAN */
{
if (src == 0) {
- regs.fp[reg] = 0;
+ regs.fp[reg].fp = 0;
} else {
int expon;
- regs.fp[reg] = frexp (src, &expon) * 2.0;
+ regs.fp[reg].fp = frexp (src, &expon) * 2.0;
}
}
break;
case 0x20: /* FDIV */
case 0x60: /* FSDIV */
case 0x64: /* FDADD */
- regs.fp[reg] /= src;
+ regs.fp[reg].fp /= src;
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x21: /* FMOD */
{
- fptype quot = fp_round_to_zero(regs.fp[reg] / src);
- regs.fp[reg] = regs.fp[reg] - quot * src;
+ fptype quot = fp_round_to_zero(regs.fp[reg].fp / src);
+ regs.fp[reg].fp = regs.fp[reg].fp - quot * src;
}
break;
case 0x22: /* FADD */
case 0x62: /* FSADD */
case 0x66: /* FDADD */
- regs.fp[reg] += src;
+ regs.fp[reg].fp += src;
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x23: /* FMUL */
case 0x63: /* FSMUL */
case 0x67: /* FDMUL */
- regs.fp[reg] *= src;
+ regs.fp[reg].fp *= src;
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x24: /* FSGLDIV */
- regs.fp[reg] /= src;
+ regs.fp[reg].fp /= src;
break;
case 0x25: /* FREM */
{
- fptype quot = fp_round_to_nearest(regs.fp[reg] / src);
- regs.fp[reg] = regs.fp[reg] - quot * src;
+ fptype quot = fp_round_to_nearest(regs.fp[reg].fp / src);
+ regs.fp[reg].fp = regs.fp[reg].fp - quot * src;
}
break;
case 0x26: /* FSCALE */
#ifdef ldexp
regs.fp[reg] = ldexp (regs.fp[reg], (int) src);
#else
- regs.fp[reg] *= exp (*fp_ln_2 * (int) src);
+ regs.fp[reg].fp *= exp (*fp_ln_2 * (int) src);
#endif
}
break;
case 0x27: /* FSGLMUL */
- regs.fp[reg] *= src;
+ regs.fp[reg].fp *= src;
break;
case 0x28: /* FSUB */
case 0x68: /* FSSUB */
case 0x6c: /* FDSUB */
- regs.fp[reg] -= src;
+ regs.fp[reg].fp -= src;
if ((extra & 0x44) == 0x40)
fround (reg);
break;
case 0x35:
case 0x36:
case 0x37:
- regs.fp[extra & 7] = cos (src);
- regs.fp[reg] = sin (src);
+ regs.fp[extra & 7].fp = cos (src);
+ regs.fp[reg].fp = sin (src);
break;
case 0x38: /* FCMP */
{
- fptype tmp = regs.fp[reg] - src;
+ fptype tmp = regs.fp[reg].fp - src;
regs.fpsr = 0;
MAKE_FPSR (tmp);
}
fpu_noinst (opcode, pc);
return;
}
- MAKE_FPSR (regs.fp[reg]);
+ MAKE_FPSR (regs.fp[reg].fp);
return;
default:
break;
void fpuop_arithmetic (uae_u32 opcode, uae_u16 extra)
{
+ if (opcode == 0xf210 && extra == 0x7c00) {
+// activate_debugger();
+// return;
+ write_log (_T("*"));
+ }
+
regs.fpsr_highbyte = 0;
regs.fpu_state = 1;
regs.fp_exception = false;
}
}
-
void fpu_reset (void)
{
regs.fpcr = regs.fpsr = regs.fpiar = 0;
- regs.fp_result = 1;
+ fpset (®s.fp_result, 1);
+ native_set_fpucw (regs.fpcr);
fpux_restore (NULL);
}
uae_u32 w1 = restore_u32 ();
uae_u32 w2 = restore_u32 ();
uae_u32 w3 = restore_u16 ();
- regs.fp[i] = to_exten (w1, w2, w3);
+ to_exten (®s.fp[i], w1, w2, w3);
}
regs.fpcr = restore_u32 ();
native_set_fpucw (regs.fpcr);
save_u32 (0x80000000 | (regs.fpu_state == 0 ? 1 : 0));
for (i = 0; i < 8; i++) {
uae_u32 w1, w2, w3;
- from_exten (regs.fp[i], &w1, &w2, &w3);
+ from_exten (®s.fp[i], &w1, &w2, &w3);
save_u32 (w1);
save_u32 (w2);
save_u16 (w3);
/* A4000T NCR */
#define NCR_OFFSET 0x40
-#define NCR_LONG_OFFSET 0x80
+#define NCR_ALT_OFFSET 0x80
#define NCR_MASK 0x3f
/* Gayle definitions from Linux drivers and preliminary Gayle datasheet */
if (currprefs.cs_mbdmac == 2 && (addr & 0xffff) == 0x3000)
return 0xffffffff; // NCR DIP BANK
if (isa4000t (&addr)) {
- if (addr >= NCR_LONG_OFFSET) {
+ if (addr >= NCR_ALT_OFFSET) {
addr &= NCR_MASK;
v = (ncr_io_bget (addr + 3) << 0) | (ncr_io_bget (addr + 2) << 8) |
(ncr_io_bget (addr + 1) << 16) | (ncr_io_bget (addr + 0) << 24);
special_mem |= S_WRITE;
#endif
if (isa4000t (&addr)) {
- if (addr >= NCR_LONG_OFFSET) {
+ if (addr >= NCR_ALT_OFFSET) {
addr &= NCR_MASK;
ncr_io_bput (addr + 3, value >> 0);
ncr_io_bput (addr + 2, value >> 8);
}
static uae_u8 ramsey_config;
-static int gary_coldboot, gary_toenb, gary_timeout;
+static int gary_coldboot;
+static int gary_timeout;
static int garyidoffset;
+int gary_toenb;
static void mbres_write (uaecptr addr, uae_u32 val, int size)
{
printf ("\t%s |= regs.irc;\n", name);
insn_n_cycles += 4;
} else {
- printf ("\t%s = %s (%d);\n", name, prefetch_long, r + 2);
- count_read++;
+ printf ("\t%s = %s (%d) << 16;\n", name, prefetch_word, r + 2);
count_read++;
+ printf ("\t%s |= %s (%d);\n", name, prefetch_word, r + 4);
insn_n_cycles += 8;
}
} else {
case sz_long: insn_n_cycles += 8; printf ("\tuae_s32 %s = %s (%sa);\n", name, srcl, name); count_read += 2; break;
default: term ();
}
- } else if (using_ce) {
+ } else if (using_ce || using_prefetch) {
switch (size) {
case sz_byte: printf ("\tuae_s8 %s = %s (%sa);\n", name, srcb, name); count_read++; break;
case sz_word: printf ("\tuae_s16 %s = %s (%sa);\n", name, srcw, name); count_read++; break;
default:
term ();
}
+ } else if (using_prefetch) {
+ switch (size) {
+ case sz_byte:
+ insn_n_cycles += 4;
+ printf ("\t%s (%sa, %s);\n", dstb, to, from);
+ count_write++;
+ break;
+ case sz_word:
+ insn_n_cycles += 4;
+ if (cpu_level < 2 && (mode == PC16 || mode == PC8r))
+ term ();
+ printf ("\t%s (%sa, %s);\n", dstw, to, from);
+ count_write++;
+ break;
+ case sz_long:
+ insn_n_cycles += 8;
+ if (cpu_level < 2 && (mode == PC16 || mode == PC8r))
+ term ();
+ if (store_dir)
+ printf ("\t%s (%sa + 2, %s); %s (%sa, %s >> 16);\n", dstw, to, from, dstw, to, from);
+ else
+ printf ("\t%s (%sa, %s >> 16); %s (%sa + 2, %s);\n", dstw, to, from, dstw, to, from);
+ count_write += 2;
+ break;
+ default:
+ term ();
+ }
} else {
switch (size) {
case sz_byte:
dstb = "put_byte_ce000";
do_cycles = "do_cycles_ce000";
} else if (using_prefetch) {
+ // 68000 prefetch
prefetch_word = "get_word_prefetch";
prefetch_long = "get_long_prefetch";
- srcwi = "get_wordi";
- srcl = "get_long";
- dstl = "put_long";
- srcw = "get_word";
- dstw = "put_word";
- srcb = "get_byte";
- dstb = "put_byte";
+ srcwi = "get_wordi_prefetch";
+ srcl = "get_long_prefetch";
+ dstl = "put_long_prefetch";
+ srcw = "get_word_prefetch";
+ dstw = "put_word_prefetch";
+ srcb = "get_byte_prefetch";
+ dstb = "put_byte_prefetch";
} else {
// generic
prefetch_long = "get_ilong";
case i_BTST:
genamodedual (curi,
curi->smode, "srcreg", curi->size, "src", 1, 0,
- curi->dmode, "dstreg", curi->size, "dst", 1, GF_IR2IRC);
+ curi->dmode, "dstreg", curi->size, "dst", 1, 0);
//genamode (curi, curi->smode, "srcreg", curi->size, "src", 1, 0, 0);
//genamode (curi, curi->dmode, "dstreg", curi->size, "dst", 1, 0, GF_IR2IRC);
fill_prefetch_next ();
//during instruction's read access CPU data lines appear as zero to outside world,
// (normally previously fetched data appears in data lines if reading write-only register)
// this allows stupid things like bset #2,$dff096 to work "correctly"
+ // NOTE: above can't be right.
genamodedual (curi,
curi->smode, "srcreg", curi->size, "src", 1, 0,
- curi->dmode, "dstreg", curi->size, "dst", 1, GF_IR2IRC | GF_RMW);
+ curi->dmode, "dstreg", curi->size, "dst", 1, GF_RMW);
//genamode (curi, curi->smode, "srcreg", curi->size, "src", 1, 0, 0);
//genamode (curi, curi->dmode, "dstreg", curi->size, "dst", 1, 0, GF_IR2IRC | GF_RMW);
fill_prefetch_next ();
break;
case i_MVMEL:
// confirmed
- if (using_ce)
+ if (using_ce || using_prefetch)
genmovemel_ce (opcode);
else
genmovemel (opcode);
break;
case i_MVMLE:
// confirmed
- if (using_ce)
+ if (using_ce || using_prefetch)
genmovemle_ce (opcode);
else
genmovemle (opcode);
m68k_pc_offset = 0;
fill_prefetch_1 (0);
printf ("\tm68k_areg (regs, 7) -= 4;\n");
- if (using_ce) {
- printf ("\tx_put_word (m68k_areg (regs, 7), oldpc >> 16);\n");
- printf ("\tx_put_word (m68k_areg (regs, 7) + 2, oldpc);\n");
+ if (using_ce || using_prefetch) {
+ printf ("\t%s (m68k_areg (regs, 7), oldpc >> 16);\n", dstw);
+ printf ("\t%s (m68k_areg (regs, 7) + 2, oldpc);\n", dstw);
} else {
printf ("\t%s (m68k_areg (regs, 7), oldpc);\n", dstl);
}
}
need_endlabel = 0;
endlabelno++;
- sprintf (endlabelstr, "endlabel%d", endlabelno);
+ sprintf (endlabelstr, "l_%d", endlabelno);
count_read = count_write = count_ncycles = count_cycles = 0;
count_cycles_ce020 = 0;
count_read_ea = count_write_ea = count_cycles_ea = 0;
fprintf (stblfile, "#ifndef CPUEMU_68000_ONLY\n");
fprintf (stblfile, "const struct cputbl CPUFUNC(op_smalltbl_%d%s)[] = {\n", postfix, extra);
}
+ endlabelno = id * 10000;
generate_func (extra);
if (generate_stbl) {
if ((id > 0 && id < 10) || (id >= 20))
goto outofbounds;
scsi_len = (uae_u32)cmd_writex (hfd, scsi_data, offset, len);
break;
-#if 0
- case 0x2f: /* VERIFY */
+ case 0x2f: /* VERIFY (10) */
{
int bytchk = cmdbuf[1] & 2;
if (nodisk (hfd))
goto nodisk;
- offset = rl (cmdbuf + 2);
- offset *= hfd->ci.blocksize;
- len = rl (cmdbuf + 7 - 2) & 0xffff;
- len *= hfd->ci.blocksize;
- if (checkbounds (hfd, offset, len)) {
- uae_u8 *vb = xmalloc (hfd->ci.blocksize);
- while (len > 0) {
- int len = cmd_readx (hfd, vb, offset, hfd->ci.blocksize);
- if (bytchk) {
- if (memcmp (vb, scsi_data, hfd->ci.blocksize))
+ if (bytchk) {
+ offset = rl (cmdbuf + 2);
+ offset *= hfd->ci.blocksize;
+ len = rl (cmdbuf + 7 - 2) & 0xffff;
+ len *= hfd->ci.blocksize;
+ uae_u8 *vb = xmalloc (uae_u8, hfd->ci.blocksize);
+ if (checkbounds (hfd, offset, len)) {
+ while (len > 0) {
+ int readlen = cmd_readx (hfd, vb, offset, hfd->ci.blocksize);
+ if (readlen != hfd->ci.blocksize || memcmp (vb, scsi_data, hfd->ci.blocksize)) {
+ xfree (vb);
goto miscompare;
+ }
scsi_data += hfd->ci.blocksize;
+ offset += hfd->ci.blocksize;
+ len -= hfd->ci.blocksize;
}
- offset += hfd->ci.blocksize;
}
xfree (vb);
}
+ scsi_len = 0;
}
break;
-#endif
case 0x35: /* SYNCRONIZE CACHE (10) */
if (nodisk (hfd))
goto nodisk;
-STATIC_INLINE uae_u32 get_word_prefetch (int o)
-{
- uae_u32 v = regs.irc;
- regs.irc = get_wordi (m68k_getpc () + o);
- return v;
-}
-STATIC_INLINE uae_u32 get_long_prefetch (int o)
-{
- uae_u32 v = get_word_prefetch (o) << 16;
- v |= get_word_prefetch (o + 2);
- return v;
-}
-
#ifdef CPUEMU_20
extern uae_u32 get_word_020_prefetch (int);
#endif
+#ifdef CPUEMU_11
+
+STATIC_INLINE uae_u32 get_word_prefetch (int o)
+{
+ uae_u32 v = regs.irc;
+ regs.irc = regs.db = get_wordi (m68k_getpc () + o);
+ return v;
+}
+STATIC_INLINE uae_u32 get_byte_prefetch (uaecptr addr)
+{
+ uae_u32 v = get_byte (addr);
+ regs.db = (v << 8) | v;
+ return v;
+}
+STATIC_INLINE uae_u32 get_word_prefetch (uaecptr addr)
+{
+ uae_u32 v = get_word (addr);
+ regs.db = v;
+ return v;
+}
+STATIC_INLINE void put_byte_prefetch (uaecptr addr, uae_u32 v)
+{
+ regs.db = (v << 8) | v;
+ put_byte (addr, v);
+}
+STATIC_INLINE void put_word_prefetch (uaecptr addr, uae_u32 v)
+{
+ regs.db = v;
+ put_word (addr, v);
+}
+#endif
+
#ifdef CPUEMU_13
STATIC_INLINE void do_cycles_ce000 (int clocks)
STATIC_INLINE uae_u32 mem_access_delay_word_read (uaecptr addr)
{
+ uae_u32 v;
switch (ce_banktype[addr >> 16])
{
case CE_MEMBANK_CHIP16:
case CE_MEMBANK_CHIP32:
- return wait_cpu_cycle_read (addr, 1);
+ v = wait_cpu_cycle_read (addr, 1);
+ break;
case CE_MEMBANK_FAST16:
case CE_MEMBANK_FAST32:
- uae_u32 v = get_word (addr);
+ v = get_word (addr);
x_do_cycles_post (4 * cpucycleunit, v);
- return v;
+ break;
+ default:
+ v = get_word (addr);
+ break;
}
- return get_word (addr);
+ regs.db = v;
+ return v;
}
STATIC_INLINE uae_u32 mem_access_delay_wordi_read (uaecptr addr)
{
+ uae_u32 v;
switch (ce_banktype[addr >> 16])
{
case CE_MEMBANK_CHIP16:
case CE_MEMBANK_CHIP32:
- return wait_cpu_cycle_read (addr, 1);
+ v = wait_cpu_cycle_read (addr, 1);
+ break;
case CE_MEMBANK_FAST16:
case CE_MEMBANK_FAST32:
- uae_u32 v = get_wordi (addr);
+ v = get_wordi (addr);
x_do_cycles_post (4 * cpucycleunit, v);
- return v;
+ break;
+ default:
+ v = get_wordi (addr);
+ break;
}
- return get_wordi (addr);
+ regs.db = v;
+ return v;
}
STATIC_INLINE uae_u32 mem_access_delay_byte_read (uaecptr addr)
{
+ uae_u32 v;
switch (ce_banktype[addr >> 16])
{
case CE_MEMBANK_CHIP16:
case CE_MEMBANK_CHIP32:
- return wait_cpu_cycle_read (addr, 0);
+ v = wait_cpu_cycle_read (addr, 0);
+ break;
case CE_MEMBANK_FAST16:
case CE_MEMBANK_FAST32:
- uae_u32 v = get_byte (addr);
+ v = get_byte (addr);
x_do_cycles_post (4 * cpucycleunit, v);
- return v;
+ break;
+ default:
+ v = get_byte (addr);
+ break;
}
- return get_byte (addr);
+ regs.db = (v << 8) | v;
+ return v;
}
STATIC_INLINE void mem_access_delay_byte_write (uaecptr addr, uae_u32 v)
{
+ regs.db = (v << 8) | v;
switch (ce_banktype[addr >> 16])
{
case CE_MEMBANK_CHIP16:
case CE_MEMBANK_CHIP32:
wait_cpu_cycle_write (addr, 0, v);
- return;
+ break;
case CE_MEMBANK_FAST16:
case CE_MEMBANK_FAST32:
put_byte (addr, v);
}
STATIC_INLINE void mem_access_delay_word_write (uaecptr addr, uae_u32 v)
{
+ regs.db = v;
switch (ce_banktype[addr >> 16])
{
case CE_MEMBANK_CHIP16:
STATIC_INLINE uae_u32 get_word_ce000_prefetch (int o)
{
uae_u32 v = regs.irc;
- regs.irc = x_get_iword (o);
+ regs.irc = regs.db = x_get_iword (o);
return v;
}
extern uae_u16 mmu030_state[3];
extern uae_u32 mmu030_data_buffer;
extern uae_u32 mmu030_disp_store[2];
+extern uae_u32 mmu030_fmovem_store[2];
+#define MMU030_STATEFLAG1_FMOVEM 0x2000
#define MMU030_STATEFLAG1_MOVEM1 0x4000
#define MMU030_STATEFLAG1_MOVEM2 0x8000
#define MMU030_STATEFLAG1_DISP0 0x0001
extern void rethink_gayle (void);
extern void gayle_map_pcmcia (void);
+extern int gary_toenb; // non-existing memory access = bus error.
+
#define PCMCIA_COMMON_START 0x600000
#define PCMCIA_COMMON_SIZE 0x400000
extern int inputdevice_get_widget_num (int devnum);
extern int inputdevice_get_widget_type (int devnum, int num, TCHAR *name);
-extern int input_get_default_mouse (struct uae_input_device *uid, int num, int port, int af, bool gp, bool wheel);
-extern int input_get_default_lightpen (struct uae_input_device *uid, int num, int port, int af, bool gp);
-extern int input_get_default_joystick (struct uae_input_device *uid, int num, int port, int af, int mode, bool gp);
-extern int input_get_default_joystick_analog (struct uae_input_device *uid, int num, int port, int af, bool gp);
+extern int input_get_default_mouse (struct uae_input_device *uid, int num, int port, int af, bool gp, bool wheel, bool joymouseswap);
+extern int input_get_default_lightpen (struct uae_input_device *uid, int num, int port, int af, bool gp, bool joymouseswap);
+extern int input_get_default_joystick (struct uae_input_device *uid, int num, int port, int af, int mode, bool gp, bool joymouseswap);
+extern int input_get_default_joystick_analog (struct uae_input_device *uid, int num, int port, int af, bool gp, bool joymouseswap);
extern int input_get_default_keyboard (int num);
#define DEFEVENT(A, B, C, D, E, F) INPUTEVENT_ ## A,
};
extern struct mmufixup mmufixup[2];
+typedef struct
+{
+ fptype fp;
+#ifdef USE_SOFT_LONG_DOUBLE
+ bool fpx;
+ uae_u32 fpm;
+ uae_u64 fpe;
+#endif
+} fpdata;
+
struct regstruct
{
uae_u32 regs[16];
uae_u8 *pc_oldp;
uae_u32 instruction_pc;
- uae_u16 irc, ir;
+ uae_u16 irc, ir, db;
uae_u32 spcflags;
uae_u32 last_prefetch;
uae_u32 chipset_latch_rw;
uae_u32 vbr, sfc, dfc;
#ifdef FPUEMU
- fptype fp[8];
- fptype fp_result;
+ fpdata fp[8];
+ fpdata fp_result;
uae_u32 fpcr, fpsr, fpiar;
uae_u32 fpsr_highbyte;
uae_u32 fpu_state;
}
extern uae_u32 (*x_prefetch)(int);
-extern uae_u32 (*x_prefetch_long)(int);
extern uae_u32 (*x_get_byte)(uaecptr addr);
extern uae_u32 (*x_get_word)(uaecptr addr);
extern uae_u32 (*x_get_long)(uaecptr addr);
int cs_deniserev;
int cs_mbdmac;
bool cs_cdtvscsi;
- bool cs_a2091, cs_a4091;
bool cs_df0idhw;
bool cs_slowmemisfast;
bool cs_resetwarning;
TCHAR romextident[256];
TCHAR a2091romfile[MAX_DPATH];
TCHAR a2091romident[256];
+ bool a2091;
TCHAR a4091romfile[MAX_DPATH];
TCHAR a4091romident[256];
+ bool a4091;
TCHAR flashfile[MAX_DPATH];
TCHAR rtcfile[MAX_DPATH];
TCHAR cartfile[MAX_DPATH];
#define ROMTYPE_BYTESWAP 0x100000
#define ROMTYPE_CD32 0x200000
#define ROMTYPE_SCRAMBLED 0x400000
+#define ROMTYPE_NONE 0x800000
#define ROMTYPE_ALL_KICK (ROMTYPE_KICK | ROMTYPE_KICKCD32 | ROMTYPE_CD32)
#define ROMTYPE_ALL_EXT (ROMTYPE_EXTCD32 | ROMTYPE_EXTCDTV)
extern struct romdata *getromdatabypath (const TCHAR *path);
extern struct romdata *getromdatabycrc (uae_u32 crc32);
+extern struct romdata *getromdatabycrc (uae_u32 crc32, bool);
extern struct romdata *getromdatabydata (uae_u8 *rom, int size);
extern struct romdata *getromdatabyid (int id);
extern struct romdata *getromdatabyidgroup (int id, int group, int subitem);
static uae_s16 mouse_x[MAX_JPORTS], mouse_y[MAX_JPORTS];
static uae_s16 mouse_delta[MAX_JPORTS][MOUSE_AXIS_TOTAL];
static uae_s16 mouse_deltanoreset[MAX_JPORTS][MOUSE_AXIS_TOTAL];
+static uae_s16 lightpen_delta[2];
+static uae_s16 lightpen_deltanoreset[2];
static int joybutton[MAX_JPORTS];
static int joydir[MAX_JPORTS];
static int joydirpot[MAX_JPORTS][2];
static int cd32_shifter[NORMAL_JPORTS];
static int cd32_pad_enabled[NORMAL_JPORTS];
static int parport_joystick_enabled;
-static int oldmx[MAX_JPORTS], oldmy[MAX_JPORTS];
static int oleft[MAX_JPORTS], oright[MAX_JPORTS], otop[MAX_JPORTS], obot[MAX_JPORTS];
static int horizclear[MAX_JPORTS], vertclear[MAX_JPORTS];
+static int relativecount[MAX_JPORTS][2];
uae_u16 potgo_value;
static int pot_cap[NORMAL_JPORTS][2];
}
}
+
+ if (lightpen_delta[0]) {
+ lightpen_x += lightpen_delta[0];
+ if (!lightpen_deltanoreset[0])
+ lightpen_delta[0] = 0;
+ }
+ if (lightpen_delta[1]) {
+ lightpen_y += lightpen_delta[1];
+ if (!lightpen_deltanoreset[1])
+ lightpen_delta[1] = 0;
+ }
+
+
}
static int input_vpos, input_frame;
{
case 5: /* lightpen/gun */
{
+ int unit = ie->data & 0x7f;
if (!lightpen_active) {
lightpen_x = gfxvidinfo.outbuffer->outwidth / 2;
lightpen_y = gfxvidinfo.outbuffer->outheight / 2;
lightpen_enabled = true;
if (ie->type == 0) {
int delta = 0;
- if (max == 0)
+ if (max == 0) {
delta = state * currprefs.input_mouse_speed / 100;
- else if (state > 0)
- delta = currprefs.input_joymouse_speed;
- else if (state < 0)
- delta = -currprefs.input_joymouse_speed;
+ } else {
+ int deadzone = currprefs.input_joymouse_deadzone * max / 100;
+ if (state <= deadzone && state >= -deadzone) {
+ state = 0;
+ lightpen_deltanoreset[unit] = 0;
+ } else if (state < 0) {
+ state += deadzone;
+ lightpen_deltanoreset[unit] = 1;
+ } else {
+ state -= deadzone;
+ lightpen_deltanoreset[unit] = 1;
+ }
+ max -= deadzone;
+ delta = state * currprefs.input_joymouse_multiplier / (10 * max);
+ }
if (ie->data)
lightpen_y += delta;
else
lightpen_x += delta;
+ if (max)
+ lightpen_delta[unit] = delta;
+ else
+ lightpen_delta[unit] += delta;
} else {
int delta = currprefs.input_joymouse_speed;
if (ie->data & DIR_LEFT)
state -= deadzone;
}
state = state * max / (max - deadzone);
+ } else {
+ max = 100;
+ relativecount[joy][unit] += state;
+ state = relativecount[joy][unit];
+ if (state < -max)
+ state = -max;
+ if (state > max)
+ state = max;
+ relativecount[joy][unit] = state;
}
+
if (ie->data & IE_INVERT)
state = -state;
/* "normal" joystick axis */
int deadzone = currprefs.input_joystick_deadzone * max / 100;
int neg, pos;
- if (state < deadzone && state > -deadzone)
- state = 0;
- neg = state < 0 ? 1 : 0;
- pos = state > 0 ? 1 : 0;
+ if (max == 0) {
+ int cnt;
+ int mmax = 50, mextra = 10;
+ int unit = (ie->data & (4 | 8)) ? 1 : 0;
+ // relative events
+ relativecount[joy][unit] += state;
+ cnt = relativecount[joy][unit];
+ neg = cnt < -mmax;
+ pos = cnt > mmax;
+ if (cnt < -(mmax + mextra))
+ cnt = -(mmax + mextra);
+ if (cnt > (mmax + mextra))
+ cnt = (mmax + mextra);
+ relativecount[joy][unit] = cnt;
+ } else {
+ if (state < deadzone && state > -deadzone)
+ state = 0;
+ neg = state < 0 ? 1 : 0;
+ pos = state > 0 ? 1 : 0;
+ }
if (ie->data & DIR_LEFT) {
left = oleft[joy] = neg;
if (horizclear[joy] && left) {
for (i = 0; i < MAX_JPORTS; i++) {
joymodes[i] = prefs->jports[i].mode;
- joyinputs[i]= NULL;
+ joyinputs[i] = NULL;
// remove all mappings from this port, except if custom
if (prefs->jports[i].id != JPORT_CUSTOM) {
if (gameports)
case JSEM_MODE_MOUSE:
case JSEM_MODE_WHEELMOUSE:
default:
- input_get_default_mouse (mice, joy, i, af, !gameports, mode != JSEM_MODE_MOUSE);
+ input_get_default_mouse (mice, joy, i, af, !gameports, mode != JSEM_MODE_MOUSE, false);
joymodes[i] = JSEM_MODE_WHEELMOUSE;
break;
case JSEM_MODE_LIGHTPEN:
- input_get_default_lightpen (mice, joy, i, af, !gameports);
+ input_get_default_lightpen (mice, joy, i, af, !gameports, false);
joymodes[i] = JSEM_MODE_LIGHTPEN;
break;
+ case JSEM_MODE_JOYSTICK:
+ case JSEM_MODE_GAMEPAD:
+ case JSEM_MODE_JOYSTICK_CD32:
+ input_get_default_joystick (mice, joy, i, af, mode, !gameports, true);
+ joymodes[i] = mode;
+ break;
+ case JSEM_MODE_JOYSTICK_ANALOG:
+ input_get_default_joystick_analog (mice, joy, i, af, !gameports, true);
+ joymodes[i] = JSEM_MODE_JOYSTICK_ANALOG;
+ break;
}
_tcsncpy (prefs->jports[i].name, idev[IDTYPE_MOUSE].get_friendlyname (joy), MAX_JPORTNAME - 1);
_tcsncpy (prefs->jports[i].configname, idev[IDTYPE_MOUSE].get_uniquename (joy), MAX_JPORTNAME - 1);
default:
{
bool iscd32 = mode == JSEM_MODE_JOYSTICK_CD32 || (mode == JSEM_MODE_DEFAULT && prefs->cs_cd32cd);
- input_get_default_joystick (joysticks, joy, i, af, mode, !gameports);
+ input_get_default_joystick (joysticks, joy, i, af, mode, !gameports, false);
if (iscd32)
joymodes[i] = JSEM_MODE_JOYSTICK_CD32;
else if (mode == JSEM_MODE_GAMEPAD)
break;
}
case JSEM_MODE_JOYSTICK_ANALOG:
- input_get_default_joystick_analog (joysticks, joy, i, af, !gameports);
+ input_get_default_joystick_analog (joysticks, joy, i, af, !gameports, false);
joymodes[i] = JSEM_MODE_JOYSTICK_ANALOG;
break;
case JSEM_MODE_MOUSE:
case JSEM_MODE_WHEELMOUSE:
- input_get_default_mouse (joysticks, joy, i, af, !gameports, mode == JSEM_MODE_WHEELMOUSE);
+ input_get_default_mouse (joysticks, joy, i, af, !gameports, mode == JSEM_MODE_WHEELMOUSE, true);
joymodes[i] = JSEM_MODE_WHEELMOUSE;
break;
case JSEM_MODE_LIGHTPEN:
- input_get_default_lightpen (joysticks, joy, i, af, !gameports);
+ input_get_default_lightpen (joysticks, joy, i, af, !gameports, true);
joymodes[i] = JSEM_MODE_LIGHTPEN;
break;
case JSEM_MODE_MOUSE_CDTV:
joymodes[i] = JSEM_MODE_MOUSE_CDTV;
- input_get_default_joystick (joysticks, joy, i, af, mode, !gameports);
+ input_get_default_joystick (joysticks, joy, i, af, mode, !gameports, false);
break;
}
if (joy >= 0) {
if (gameports)
cleardev (joysticks, joy);
- input_get_default_joystick (joysticks, joy, i, af, 0, !gameports);
+ input_get_default_joystick (joysticks, joy, i, af, 0, !gameports, false);
_tcsncpy (prefs->jports[i].name, idev[IDTYPE_JOYSTICK].get_friendlyname (joy), MAX_JPORTNAME - 1);
_tcsncpy (prefs->jports[i].configname, idev[IDTYPE_JOYSTICK].get_uniquename (joy), MAX_JPORTNAME - 1);
used[joy] = 1;
oright[i] = 0;
otop[i] = 0;
obot[i] = 0;
- oldmx[i] = -1;
- oldmy[i] = -1;
joybutton[i] = 0;
joydir[i] = 0;
mouse_deltanoreset[i][0] = 0;
mouse_deltanoreset[i][2] = 0;
mouse_delta[i][2] = 0;
}
+ lightpen_delta[0] = lightpen_delta[1] = 0;
+ lightpen_deltanoreset[0] = lightpen_deltanoreset[0] = 0;
memset (keybuf, 0, sizeof keybuf);
for (int i = 0; i < INPUT_QUEUE_SIZE; i++)
input_queue[i].linecnt = input_queue[i].nextlinecnt = -1;
for (int i = 0; i < MAX_JPORTS; i++) {
horizclear[i] = 1;
vertclear[i] = 1;
+ relativecount[i][0] = relativecount[i][1] = 0;
}
}
for (i=0;i<VREGS;i++) {
if (i<16) { /* First 16 registers map to 68k registers */
- live.state[i].mem=((uae_u32*)®s)+i;
+ live.state[i].mem=®s.regs[i];
live.state[i].needflush=NF_TOMEM;
set_status(i,INMEM);
}
for (i=0;i<VFREGS;i++) {
if (i<8) { /* First 8 registers map to 68k FPU registers */
- live.fate[i].mem=(uae_u32*)(((fptype*)regs.fp)+i);
+ live.fate[i].mem=(uae_u32*)(®s.fp[i].fp);
live.fate[i].needflush=NF_TOMEM;
live.fate[i].status=INMEM;
}
}
}
-static uae_u32 dummy_get (uaecptr addr, int size)
+static void dummy_put (uaecptr addr, int size)
+{
+ if (gary_toenb && currprefs.mmu_model)
+ exception2 (addr, true, size, regs.s ? 4 : 0);
+}
+
+static uae_u32 dummy_get (uaecptr addr, int size, bool inst)
{
uae_u32 v = NONEXISTINGDATA;
+ if (gary_toenb && currprefs.mmu_model) {
+ exception2 (addr, false, size, (regs.s ? 4 : 0) | (inst ? 0 : 1));
+ return v;
+ }
+
if (currprefs.cpu_model >= 68040)
return v;
if (!currprefs.cpu_compatible)
addr &= 0x00ffffff;
if (addr >= 0x10000000)
return v;
- /* fixme: emulate correct hardware behavior */
- if (munge24 (m68k_getpc () & 0xFFF80000) == 0xF80000)
- return v;
- if (size == 4) {
- v = (regs.irc << 16) | regs.irc;
- } else if (size == 2) {
- v = regs.irc & 0xffff;
- } else {
- v = regs.irc;
- v = (addr & 1) ? (v & 0xff) : ((v >> 8) & 0xff);
+ if (currprefs.cpu_model == 68000) {
+ if (size == 4) {
+ v = (regs.db << 16) | regs.db;
+ } else if (size == 2) {
+ v = regs.db & 0xffff;
+ } else {
+ v = regs.db;
+ v = (addr & 1) ? (v & 0xff) : ((v >> 8) & 0xff);
+ }
}
#if 0
if (addr >= 0x10000000)
#endif
if (currprefs.illegal_mem)
dummylog (0, addr, 4, 0, 0);
- return dummy_get (addr, 4);
+ return dummy_get (addr, 4, false);
}
uae_u32 REGPARAM2 dummy_lgeti (uaecptr addr)
{
#endif
if (currprefs.illegal_mem)
dummylog (0, addr, 4, 0, 1);
- return dummy_get (addr, 4);
+ return dummy_get (addr, 4, true);
}
static uae_u32 REGPARAM2 dummy_wget (uaecptr addr)
#endif
if (currprefs.illegal_mem)
dummylog (0, addr, 2, 0, 0);
- return dummy_get (addr, 2);
+ return dummy_get (addr, 2, false);
}
uae_u32 REGPARAM2 dummy_wgeti (uaecptr addr)
{
#endif
if (currprefs.illegal_mem)
dummylog (0, addr, 2, 0, 1);
- return dummy_get (addr, 2);
+ return dummy_get (addr, 2, true);
}
static uae_u32 REGPARAM2 dummy_bget (uaecptr addr)
#endif
if (currprefs.illegal_mem)
dummylog (0, addr, 1, 0, 0);
- return dummy_get (addr, 1);
+ return dummy_get (addr, 1, false);
}
static void REGPARAM2 dummy_lput (uaecptr addr, uae_u32 l)
#endif
if (currprefs.illegal_mem)
dummylog (1, addr, 4, l, 0);
+ dummy_put (addr, 4);
}
static void REGPARAM2 dummy_wput (uaecptr addr, uae_u32 w)
{
#endif
if (currprefs.illegal_mem)
dummylog (1, addr, 2, w, 0);
+ dummy_put (addr, 2);
}
static void REGPARAM2 dummy_bput (uaecptr addr, uae_u32 b)
{
#endif
if (currprefs.illegal_mem)
dummylog (1, addr, 1, b, 0);
+ dummy_put (addr, 1);
}
static int REGPARAM2 dummy_check (uaecptr addr, uae_u32 size)
#ifdef NCR
-#define NCR_LOG 1
-#define NCR_DEBUG 1
+#define NCR_DEBUG 0
#include "options.h"
#include "uae.h"
#include "qemuvga\queue.h"
#include "qemuvga\scsi\scsi.h"
-#define NCRNAME _T("NCR53C710")
-#define NCR_REGS 0x40
-
#define ROM_VECTOR 0x0200
#define ROM_OFFSET 0x0000
#define ROM_SIZE 32768
#define BOARD_SIZE 16777216
#define A4091_IO_OFFSET 0x00800000
-#define A4091_IO_SWAP 0x00840000
+#define A4091_IO_ALT 0x00840000
#define A4091_IO_END 0x00880000
#define A4091_IO_MASK 0xff
static uae_u8 *rom;
static int board_mask;
static int configured;
-static uae_u8 acmemory[100];
+static uae_u8 acmemory[128];
static DeviceState devobject;
static SCSIDevice *scsid[8];
void scsi_req_continue(SCSIRequest *req)
{
struct scsi_data *sd = (struct scsi_data*)req->dev->handle;
- if (sd->data_len) {
+ if (sd->data_len < 0) {
+ lsi_command_complete (req, sd->status, 0);
+ } else if (sd->data_len) {
lsi_transfer_data (req, sd->data_len);
} else {
if (sd->direction > 0)
write_log (_T("scsi_req_cancel\n"));
}
-
static uae_u8 read_rombyte (uaecptr addr)
{
uae_u8 v = rom[addr];
return 0;
}
-
static uaecptr beswap (uaecptr addr)
{
return (addr & ~3) | (3 - (addr & 3));
special_mem |= S_READ;
#endif
addr &= board_mask;
- if (addr >= A4091_IO_SWAP) {
- v = (ncr_bget2 (addr + 3) << 24) | (ncr_bget2 (addr + 2) << 16) |
- (ncr_bget2 (addr + 1) << 8) | (ncr_bget2 (addr + 0));
+ if (addr >= A4091_IO_ALT) {
+ v = (ncr_bget2 (addr + 3) << 0) | (ncr_bget2 (addr + 2) << 8) |
+ (ncr_bget2 (addr + 1) << 16) | (ncr_bget2 (addr + 0) << 24);
} else {
- v = (ncr_bget2 (addr + 0) << 24) | (ncr_bget2 (addr + 1) << 16) |
- (ncr_bget2 (addr + 2) << 8) | (ncr_bget2 (addr + 3));
+ v = (ncr_bget2 (addr + 3) << 0) | (ncr_bget2 (addr + 2) << 8) |
+ (ncr_bget2 (addr + 1) << 16) | (ncr_bget2 (addr + 0) << 24);
}
#if NCR_DEBUG > 0
if (addr < ROM_VECTOR)
if (addr < ROM_VECTOR)
write_log (_T("ncr_lput %08X=%08X PC=%08X\n"), addr, l, M68K_GETPC);
#endif
- if (addr >= A4091_IO_SWAP) {
+ if (addr >= A4091_IO_ALT) {
ncr_bput2 (addr + 3, l >> 0);
ncr_bput2 (addr + 2, l >> 8);
ncr_bput2 (addr + 1, l >> 16);
ncr_bput2 (addr + 0, l >> 24);
} else {
- ncr_bput2 (addr + 0, l >> 24);
- ncr_bput2 (addr + 1, l >> 16);
- ncr_bput2 (addr + 2, l >> 8);
ncr_bput2 (addr + 3, l >> 0);
+ ncr_bput2 (addr + 2, l >> 8);
+ ncr_bput2 (addr + 1, l >> 16);
+ ncr_bput2 (addr + 0, l >> 24);
}
}
+static uae_u32 expamem_hi, expamem_lo;
+
static void REGPARAM2 ncr_wput (uaecptr addr, uae_u32 w)
{
#ifdef JIT
if (addr < ROM_VECTOR)
write_log (_T("ncr_wput %04X=%04X PC=%08X\n"), addr, w & 65535, M68K_GETPC);
#endif
- if (addr == 0x44 && !configured) {
- uae_u32 value = gfxmem_bank.start + ((currprefs.rtgmem_size + 0xffffff) & ~0xffffff);
- if (value < 0x10000000)
- value = 0x10000000;
- value >>= 16;
- chipmem_wput (regs.regs[11] + 0x20, value);
- chipmem_wput (regs.regs[11] + 0x28, value);
- map_banks (&ncr_bank, value, BOARD_SIZE >> 16, 0);
- board_mask = 0x00ffffff;
- write_log (_T("A4091 Z3 autoconfigured at %04X0000\n"), value);
- configured = 1;
- expamem_next();
+ if (!configured) {
+ uae_u32 value;
+ switch (addr)
+ {
+ case 0x44:
+ // yes, this could be much better..
+ if (currprefs.jit_direct_compatible_memory) {
+ value = gfxmem_bank.start + ((currprefs.rtgmem_size + 0xffffff) & ~0xffffff);
+ if (value < 0x10000000) {
+ value = 0x10000000;
+ if (value < z3fastmem_bank.start + currprefs.z3fastmem_size)
+ value = z3fastmem_bank.start + currprefs.z3fastmem_size;
+ if (value < z3fastmem2_bank.start + currprefs.z3fastmem2_size)
+ value = z3fastmem2_bank.start + currprefs.z3fastmem2_size;
+ }
+ value >>= 16;
+ chipmem_wput (regs.regs[11] + 0x20, value);
+ chipmem_wput (regs.regs[11] + 0x28, value);
+ } else {
+ expamem_hi = w & 0xff00;
+ value = expamem_hi | (expamem_lo >> 4);
+ }
+ map_banks (&ncr_bank, value, BOARD_SIZE >> 16, 0);
+ board_mask = 0x00ffffff;
+ write_log (_T("A4091 Z3 autoconfigured at %04X0000\n"), value);
+ configured = 1;
+ expamem_next();
+ break;
+ }
return;
}
ncr_bput2 (addr, w >> 8);
#endif
b &= 0xff;
addr &= board_mask;
- if (addr == 0x4c && !configured) {
- write_log (_T("A4091 AUTOCONFIG SHUT-UP!\n"));
- configured = 1;
- expamem_next ();
+ if (!configured) {
+ switch (addr)
+ {
+ case 0x4c:
+ write_log (_T("A4091 AUTOCONFIG SHUT-UP!\n"));
+ configured = 1;
+ expamem_next ();
+ break;
+ case 0x48:
+ expamem_lo = b & 0xff;
+ break;
+ }
return;
}
- if (!configured)
- return;
ncr_bput2 (addr, b);
}
int i;
configured = 0;
- memset (acmemory, 0xff, 100);
- ew (0x00, 0x80 | 0x10 | 0x00);
- ew (0x08, 0x80 | 0x20 | 0x10);
-
- /* A4091 hardware id */
- ew (0x04, 0x54);
- /* commodore's manufacturer id */
- ew (0x10, 0x02);
- ew (0x14, 0x02);
- /* rom vector */
- ew (0x28, ROM_VECTOR >> 8);
- ew (0x2c, ROM_VECTOR);
-
- ew (0x18, 0x00); /* ser.no. Byte 0 */
- ew (0x1c, 0x00); /* ser.no. Byte 1 */
- ew (0x20, 0x00); /* ser.no. Byte 2 */
- ew (0x24, 0x00); /* ser.no. Byte 3 */
roms[0] = 58;
roms[1] = 57;
roms[2] = -1;
+ memset (acmemory, 0xff, sizeof acmemory);
+
struct zfile *z = read_rom_name (currprefs.a4091romfile);
if (!z) {
struct romlist *rl = getromlistbyids(roms);
zfile_fread (&b, 1, 1, z);
rom[i * 4 + 0] = b;
rom[i * 4 + 2] = b << 4;
+ if (i < 0x20) {
+ acmemory[i * 4 + 0] = b;
+ } else if (i >= 0x40 && i < 0x60) {
+ acmemory[(i - 0x40) * 4 + 2] = b;
+ }
}
zfile_fclose(z);
} else {
static void (*x2_do_cycles_post)(unsigned long, uae_u32);
uae_u32 (*x_prefetch)(int);
-uae_u32 (*x_prefetch_long)(int);
uae_u32 (*x_next_iword)(void);
uae_u32 (*x_next_ilong)(void);
uae_u32 (*x_get_ilong)(int);
cputrace.cyclecounter || cputrace.cyclecounter_pre || cputrace.cyclecounter_post)
return false;
x_prefetch = x2_prefetch;
- x_prefetch_long = x2_prefetch_long;
x_get_ilong = x2_get_ilong;
x_get_iword = x2_get_iword;
x_get_ibyte = x2_get_ibyte;
}
return v;
}
-static uae_u32 cputracefunc_x_prefetch_long (int o)
-{
- uae_u32 pc = m68k_getpc ();
- set_trace (pc + o, 2, 4);
- uae_u32 v = x2_prefetch_long (o);
- add_trace (pc + o, v, 2, 4);
- return v;
-}
-static uae_u32 cputracefunc2_x_prefetch_long (int o)
-{
- uae_u32 v;
- if (get_trace (m68k_getpc () + o, 2, 4, &v)) {
- v = x2_prefetch_long (o);
- check_trace2 ();
- }
- return v;
-}
static uae_u32 cputracefunc_x_next_iword (void)
{
if (currprefs.mmu_model) {
if (currprefs.cpu_model == 68060) {
x_prefetch = get_iword_mmu060;
- x_prefetch_long = get_ilong_mmu060;
x_get_ilong = get_ilong_mmu060;
x_get_iword = get_iword_mmu060;
x_get_ibyte = get_ibyte_mmu060;
x_get_byte = get_byte_mmu060;
} else if (currprefs.cpu_model == 68040) {
x_prefetch = get_iword_mmu040;
- x_prefetch_long = get_ilong_mmu040;
x_get_ilong = get_ilong_mmu040;
x_get_iword = get_iword_mmu040;
x_get_ibyte = get_ibyte_mmu040;
x_get_byte = get_byte_mmu040;
} else {
x_prefetch = get_iword_mmu030;
- x_prefetch_long = get_ilong_mmu030;
x_get_ilong = get_ilong_mmu030;
x_get_iword = get_iword_mmu030;
x_get_ibyte = get_ibyte_mmu030;
// 68000/010
if (currprefs.cpu_cycle_exact) {
x_prefetch = get_word_ce000_prefetch;
- x_prefetch_long = NULL;
x_get_ilong = NULL;
x_get_iword = get_wordi_ce000;
x_get_ibyte = NULL;
x_do_cycles_post = do_cycles_ce_post;
} else if (currprefs.cpu_compatible) {
x_prefetch = get_word_prefetch;
- x_prefetch_long = get_long_prefetch;
x_get_ilong = NULL;
x_get_iword = get_iword;
x_get_ibyte = get_ibyte;
x_do_cycles_post = do_cycles_post;
} else {
x_prefetch = NULL;
- x_prefetch_long = NULL;
x_get_ilong = get_ilong;
x_get_iword = get_iword;
x_get_ibyte = get_ibyte;
if (currprefs.cpu_compatible) {
if (currprefs.cpu_model == 68020 && !currprefs.cachesize) {
x_prefetch = get_word_prefetch;
- x_prefetch_long = get_long_prefetch;
x_get_ilong = get_long_020_prefetch;
x_get_iword = get_word_020_prefetch;
x_get_ibyte = NULL;
} else {
// JIT or 68030+ does not have real prefetch only emulation
x_prefetch = NULL;
- x_prefetch_long = NULL;
x_get_ilong = get_ilong;
x_get_iword = get_iword;
x_get_ibyte = get_ibyte;
}
} else {
x_prefetch = NULL;
- x_prefetch_long = NULL;
x_get_ilong = get_ilong;
x_get_iword = get_iword;
x_get_ibyte = get_ibyte;
// 68020+ cycle exact
} else if (currprefs.cpu_model == 68020) {
x_prefetch = get_word_ce020_prefetch;
- x_prefetch_long = NULL;
x_get_ilong = get_long_ce020_prefetch;
x_get_iword = get_word_ce020_prefetch;
x_get_ibyte = NULL;
x_do_cycles_post = do_cycles_ce020_post;
} else {
x_prefetch = get_word_ce030_prefetch;
- x_prefetch_long = NULL;
x_get_ilong = get_long_ce030_prefetch;
x_get_iword = get_word_ce030_prefetch;
x_get_ibyte = NULL;
x_do_cycles_post = do_cycles_ce020_post;
}
x2_prefetch = x_prefetch;
- x2_prefetch_long = x_prefetch_long;
x2_get_ilong = x_get_ilong;
x2_get_iword = x_get_iword;
x2_get_ibyte = x_get_ibyte;
if (cpu_tracer > 0) {
x_prefetch = cputracefunc_x_prefetch;
- x_prefetch_long = cputracefunc_x_prefetch_long;
x_get_ilong = cputracefunc_x_get_ilong;
x_get_iword = cputracefunc_x_get_iword;
x_get_ibyte = cputracefunc_x_get_ibyte;
} else if (cpu_tracer < 0) {
if (!check_trace ()) {
x_prefetch = cputracefunc2_x_prefetch;
- x_prefetch_long = cputracefunc2_x_prefetch_long;
x_get_ilong = cputracefunc2_x_get_ilong;
x_get_iword = cputracefunc2_x_get_iword;
x_get_ibyte = cputracefunc2_x_get_ibyte;
x_put_long (m68k_areg (regs, 7), mmu030_ad[i].val);
}
while (i < 9) {
+ uae_u32 v = 0;
m68k_areg (regs, 7) -= 4;
- x_put_long (m68k_areg (regs, 7), 0);
+ // mmu030_idx is always small enough instruction is FMOVEM.
+ if (mmu030_state[1] & MMU030_STATEFLAG1_FMOVEM) {
+ if (i == 7)
+ v = mmu030_fmovem_store[0];
+ else if (i == 8)
+ v = mmu030_fmovem_store[1];
+ }
+ x_put_long (m68k_areg (regs, 7), v);
i++;
}
// version & internal information (We store index here)
newpc = x_get_long (regs.vbr + 4 * nr);
if (regs.m && nr >= 24 && nr < 32) { /* M + Interrupt */
+ Exception_build_stack_frame (oldpc, currpc, regs.mmu_ssw, nr, 0x0);
+ MakeSR ();
+ regs.m = 0;
+ regs.msp = m68k_areg (regs, 7);
+ m68k_areg (regs, 7) = regs.isp;
Exception_build_stack_frame (oldpc, currpc, regs.mmu_ssw, nr, 0x1);
} else if (nr ==5 || nr == 6 || nr == 7 || nr == 9 || nr == 56) {
Exception_build_stack_frame (oldpc, currpc, regs.mmu_ssw, nr, 0x2);
x_put_word (m68k_areg (regs, 7), regs.sr);
regs.sr |= (1 << 13);
regs.msp = m68k_areg (regs, 7);
+ regs.m = 0;
m68k_areg (regs, 7) = regs.isp;
m68k_areg (regs, 7) -= 2;
x_put_word (m68k_areg (regs, 7), 0x1000 + nr * 4);
/* Same thing, but don't use prefetch to get opcode. */
static void m68k_run_2 (void)
{
- static int done;
+// static int done;
struct regstruct *r = ®s;
for (;;) {
used[opcode] = 1;
}
#endif
- if (done)
- write_log (_T("%08x %04X %d "), r->instruction_pc, opcode, cpu_cycles);
+// if (done)
+// write_log (_T("%08x %04X %d "), r->instruction_pc, opcode, cpu_cycles);
do_cycles (cpu_cycles);
cpu_cycles = (*cpufunctbl[opcode])(opcode);
if (currprefs.fpu_model) {
uae_u32 fpsr;
for (i = 0; i < 8; i++){
- console_out_f (_T("FP%d: %g "), i, regs.fp[i]);
+ console_out_f (_T("FP%d: %g "), i, regs.fp[i].fp);
if ((i & 3) == 3)
console_out_f (_T("\n"));
}
(fpsr & 0x1000000) != 0);
}
#endif
+ if (currprefs.mmu_model == 68030) {
+ console_out_f (_T("SRP: %llX CRP: %llX\n"), srp_030, crp_030);
+ console_out_f (_T("TT0: %08X TT1: %08X TC: %08X\n"), tt0_030, tt1_030, tc_030);
+ }
if (currprefs.cpu_compatible && currprefs.cpu_model == 68000) {
struct instr *dp;
struct mnemolookup *lookup1, *lookup2;
errno = 0;
value = _tcstod(txt, &stopstr);
if (_tcslen(stopstr) == 0 && errno == 0)
- regs.fp[index] = _tcstod(txt, &stopstr);
+ regs.fp[index].fp = _tcstod(txt, &stopstr);
}
else {
int bytes, i, offset = -1;
regs.fpsr = x;
if (x & 0x01000000) {
- regs.fp_result = *fp_nan;
+ regs.fp_result.fp = *fp_nan;
}
else if (x & 0x04000000)
- regs.fp_result = 0;
+ regs.fp_result.fp = 0;
else if (x & 0x08000000)
- regs.fp_result = -1;
+ regs.fp_result.fp = -1;
else
- regs.fp_result = 1;
+ regs.fp_result.fp = 1;
}
static void ToggleFPSRFlag(HWND hwnd, int x, int y)
{
int i;
+ if (did == NULL)
+ return;
did->buttons_real = did->buttons;
for (i = 0; i < did->axles; i++) {
if (did->axissort[i] == -97)
for (i = 0; i < 1; i++) {
if (num_mouse >= MAX_INPUT_DEVICES)
return;
+ cleardid (did);
num_mouse++;
name = (i == 0) ? _T("Windows mouse") : _T("Mousehack mouse");
did->connection = DIDC_WIN;
uid[i].flags[slot][sub] |= ID_FLAG_INVERTTOGGLE;
}
-int input_get_default_mouse (struct uae_input_device *uid, int i, int port, int af, bool gp, bool wheel)
+int input_get_default_mouse (struct uae_input_device *uid, int i, int port, int af, bool gp, bool wheel, bool joymouseswap)
{
- struct didata *did;
+ struct didata *did = NULL;
- if (i >= num_mouse)
- return 0;
- did = &di_mouse[i];
+ if (!joymouseswap) {
+ if (i >= num_mouse)
+ return 0;
+ did = &di_mouse[i];
+ } else {
+ if (i >= num_joystick)
+ return 0;
+ did = &di_joystick[i];
+ }
setid (uid, i, ID_AXIS_OFFSET + 0, 0, port, port ? INPUTEVENT_MOUSE2_HORIZ : INPUTEVENT_MOUSE1_HORIZ, gp);
setid (uid, i, ID_AXIS_OFFSET + 1, 0, port, port ? INPUTEVENT_MOUSE2_VERT : INPUTEVENT_MOUSE1_VERT, gp);
if (wheel)
return 0;
}
-int input_get_default_lightpen (struct uae_input_device *uid, int i, int port, int af, bool gp)
+int input_get_default_lightpen (struct uae_input_device *uid, int i, int port, int af, bool gp, bool joymouseswap)
{
- struct didata *did;
+ struct didata *did = NULL;
- if (i >= num_mouse)
- return 0;
- did = &di_mouse[i];
+ if (!joymouseswap) {
+ if (i >= num_mouse)
+ return 0;
+ did = &di_mouse[i];
+ } else {
+ if (i >= num_joystick)
+ return 0;
+ did = &di_joystick[i];
+ }
setid (uid, i, ID_AXIS_OFFSET + 0, 0, port, INPUTEVENT_LIGHTPEN_HORIZ, gp);
setid (uid, i, ID_AXIS_OFFSET + 1, 0, port, INPUTEVENT_LIGHTPEN_VERT, gp);
setid (uid, i, ID_BUTTON_OFFSET + 0, 0, port, port ? INPUTEVENT_JOY2_3RD_BUTTON : INPUTEVENT_JOY1_3RD_BUTTON, gp);
return 0;
}
-int input_get_default_joystick (struct uae_input_device *uid, int i, int port, int af, int mode, bool gp)
+int input_get_default_joystick (struct uae_input_device *uid, int i, int port, int af, int mode, bool gp, bool joymouseswap)
{
int j;
- struct didata *did;
+ struct didata *did = NULL;
int h, v;
- if (i >= num_joystick)
- return 0;
- did = &di_joystick[i];
+ if (joymouseswap) {
+ if (i >= num_mouse)
+ return 0;
+ did = &di_mouse[i];
+ } else {
+ if (i >= num_joystick)
+ return 0;
+ did = &di_joystick[i];
+ }
if (mode == JSEM_MODE_MOUSE_CDTV) {
h = INPUTEVENT_MOUSE_CDTV_HORIZ;
v = INPUTEVENT_MOUSE_CDTV_VERT;
j++;
}
}
+
if (mode == JSEM_MODE_JOYSTICK_CD32) {
setid (uid, i, ID_BUTTON_OFFSET + 0, 0, port, port ? INPUTEVENT_JOY2_CD32_RED : INPUTEVENT_JOY1_CD32_RED, af, gp);
if (isrealbutton (did, 1)) {
return 0;
}
-int input_get_default_joystick_analog (struct uae_input_device *uid, int i, int port, int af, bool gp)
+int input_get_default_joystick_analog (struct uae_input_device *uid, int i, int port, int af, bool gp, bool joymouseswap)
{
int j;
struct didata *did;
- if (i >= num_joystick)
- return 0;
- did = &di_joystick[i];
+ if (joymouseswap) {
+ if (i >= num_mouse)
+ return 0;
+ did = &di_mouse[i];
+ } else {
+ if (i >= num_joystick)
+ return 0;
+ did = &di_joystick[i];
+ }
setid (uid, i, ID_AXIS_OFFSET + 0, 0, port, port ? INPUTEVENT_JOY2_HORIZ_POT : INPUTEVENT_JOY1_HORIZ_POT, gp);
setid (uid, i, ID_AXIS_OFFSET + 1, 0, port, port ? INPUTEVENT_JOY2_VERT_POT : INPUTEVENT_JOY1_VERT_POT, gp);
setid (uid, i, ID_BUTTON_OFFSET + 0, 0, port, port ? INPUTEVENT_JOY2_LEFT : INPUTEVENT_JOY1_LEFT, af, gp);
setid (uid, i, ID_BUTTON_OFFSET + 2, 0, port, port ? INPUTEVENT_JOY2_UP : INPUTEVENT_JOY1_UP, gp);
if (isrealbutton (did, 3))
setid (uid, i, ID_BUTTON_OFFSET + 3, 0, port, port ? INPUTEVENT_JOY2_DOWN : INPUTEVENT_JOY1_DOWN, gp);
+
for (j = 2; j < MAX_MAPPINGS - 1; j++) {
int type = did->axistype[j];
if (type == AXISTYPE_POV_X) {
j++;
}
}
+
if (i == 0)
return 1;
return 0;
int do_rdbdump;
static struct uae_driveinfo uae_drives[MAX_FILESYSTEM_UNITS];
-#if 0
+#if 1
static void fixdrive (struct hardfiledata *hfd)
{
uae_u8 data[512];
- struct zfile *zf = zfile_fopen (_T("d:\\amiga\\hdf\\a500supradrive.hdf"), _T("rb"));
- for (int i = 0; i < 0x30000 / 512; i++) {
- zfile_fread (data, 1, 512, zf);
- hdf_write (hfd, data, i * 512, 512);
+ int i = 0;
+ struct zfile *zf = zfile_fopen (_T("d:\\amiga\\hdf\\test_16MB_hdf.bin"), _T("rb"));
+ while (zfile_fread (data, 1, 512, zf)) {
+ hdf_write (hfd, data, i, 512);
+ i += 512;
}
zfile_fclose (zf);
}
hfd->handle_valid = HDF_HANDLE_WIN32;
hfd->emptyname = my_strdup (name);
- //fixdrive (hfd);
+
+ fixdrive (hfd);
+
} else {
hfd->flags = HFD_FLAGS_REALDRIVE;
hfd->drive_empty = -1;
#define HAVE_to_single
STATIC_INLINE double to_single (uae_u32 longvalue)
{
- double floatfake;
+ double floatfake;
- __asm {
- fld dword ptr longvalue;
- fstp qword ptr floatfake;
+ __asm {
+ fld dword ptr longvalue;
+ fstp qword ptr floatfake;
}
- return(floatfake);
+ return floatfake;
}
#endif
#define HAVE_from_single
STATIC_INLINE uae_u32 from_single (double floatfake)
{
- uae_u32 longvalue;
+ uae_u32 longvalue;
- __asm {
- fld qword ptr floatfake;
- fstp dword ptr longvalue;
- }
- return(longvalue);
+ __asm {
+ fld qword ptr floatfake;
+ fstp dword ptr longvalue;
+ }
+ return longvalue;
}
#endif
#ifndef HAVE_to_exten
#define HAVE_to_exten
-STATIC_INLINE double to_exten(uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
+STATIC_INLINE void to_exten(fpdata *fpd, uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
{
- uae_u32 longarray[] = {wrd3,wrd2,((wrd1>>16)&0xffff)}; // little endian
- double extenfake;
-
- __asm {
- fld tbyte ptr longarray;
- fstp qword ptr extenfake;
- }
- return(extenfake);
+ uae_u32 longarray[] = { wrd3, wrd2, ((wrd1 >> 16) & 0xffff) }; // little endian
+ double extenfake;
+
+ __asm {
+ fld tbyte ptr longarray;
+ fstp qword ptr extenfake;
+ }
+ fpd->fp = extenfake;
+#ifdef USE_SOFT_LONG_DOUBLE
+ fpd->fpe = ((uae_u64)wrd2 << 32) | wrd3;
+ fpd->fpm = wrd1;
+ fpd->fpx = true;
+#endif
}
#endif
#ifndef HAVE_from_exten
#define HAVE_from_exten
-STATIC_INLINE void from_exten(double src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3)
+STATIC_INLINE void from_exten(fpdata *fpd, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3)
{
- uae_u32 longarray[3], *srcarray = (uae_u32 *)&src;
-
- __asm {
- fld qword ptr src;
- fstp tbyte ptr longarray;
- }
- *wrd1 = (longarray[2] & 0xffff) <<16;
- *wrd2 = longarray[1];
- *wrd3 = longarray[0]; // little endian
- if (!srcarray[0] && (srcarray[1]==0x7ff00000 || srcarray[1]==0xfff00000))
- *wrd2 = 0; // The MSB of the mantissa was set wrongly for infinity, causing a NaN
+#ifdef USE_SOFT_LONG_DOUBLE
+ if (fpd->fpx) {
+ *wrd1 = fpd->fpm;
+ *wrd2 = fpd->fpe >> 32;
+ *wrd3 = (uae_u32)fpd->fpe;
+ } else
+#endif
+ {
+ fptype src = fpd->fp;
+ uae_u32 longarray[3], *srcarray = (uae_u32 *)&src;
+ __asm {
+ fld qword ptr src;
+ fstp tbyte ptr longarray;
+ }
+ *wrd1 = (longarray[2] & 0xffff) <<16;
+ *wrd2 = longarray[1];
+ *wrd3 = longarray[0]; // little endian
+ if (!srcarray[0] && (srcarray[1] == 0x7ff00000 || srcarray[1] == 0xfff00000))
+ *wrd2 = 0; // The MSB of the mantissa was set wrongly for infinity, causing a NaN
+ }
}
#endif
#endif /* X86_MSVC_ASSEMBLY */
static int doinit_shm (void)
{
uae_u32 size, totalsize, z3size, natmemsize;
- uae_u32 startbarrier, rtgbarrier, z3chipbarrier, rtgextra;
+ uae_u32 startbarrier;
int rounds = 0;
ULONG z3rtgmem_size;
z3size = 0;
size = 0x1000000;
- rtgextra = 0;
- z3chipbarrier = 0;
startbarrier = changed_prefs.mbresmem_high_size == 128 * 1024 * 1024 ? 16 * 1024 * 1024 : 0;
- rtgbarrier = si.dwPageSize;
z3rtgmem_size = gfxboard_is_z3 (changed_prefs.rtgmem_type) ? changed_prefs.rtgmem_size : 0;
if (changed_prefs.cpu_model >= 68020)
size = 0x10000000;
- if (changed_prefs.z3fastmem_size || changed_prefs.z3fastmem2_size || changed_prefs.z3chipmem_size) {
+ if (changed_prefs.z3fastmem_size || changed_prefs.z3fastmem2_size || changed_prefs.z3chipmem_size)
z3size = changed_prefs.z3fastmem_size + changed_prefs.z3fastmem2_size + changed_prefs.z3chipmem_size + (changed_prefs.z3fastmem_start - 0x10000000);
- if (z3rtgmem_size) {
- rtgbarrier = 16 * 1024 * 1024 - ((changed_prefs.z3fastmem_size + changed_prefs.z3fastmem2_size) & 0x00ffffff);
- }
- if (changed_prefs.z3chipmem_size && (changed_prefs.z3fastmem_size || changed_prefs.z3fastmem2_size))
- z3chipbarrier = 16 * 1024 * 1024;
- } else {
- rtgbarrier = 0;
- }
totalsize = size + z3size + z3rtgmem_size;
while (totalsize > size64) {
int change = lowmem ();
}
natmemsize = size + z3size;
- if (z3rtgmem_size) {
- rtgextra = si.dwPageSize;
- } else {
- rtgbarrier = 0;
- rtgextra = 0;
- }
- if (startbarrier + natmemsize + z3chipbarrier + rtgbarrier + z3rtgmem_size + rtgextra + 16 * si.dwPageSize <= natmem_size)
+ if (startbarrier + natmemsize + z3rtgmem_size + 16 * si.dwPageSize <= natmem_size)
break;
write_log (_T("NATMEM: %dM area failed to allocate, err=%d (Z3=%dM,RTG=%dM)\n"),
natmemsize >> 20, GetLastError (), (changed_prefs.z3fastmem_size + changed_prefs.z3fastmem2_size + changed_prefs.z3chipmem_size) >> 20, z3rtgmem_size >> 20);
p96mem_offset = NULL;
p96mem_size = z3rtgmem_size;
if (changed_prefs.rtgmem_size && gfxboard_is_z3 (changed_prefs.rtgmem_type)) {
- p96mem_offset = natmem_offset + natmemsize + startbarrier + rtgbarrier + z3chipbarrier;
+ p96mem_offset = natmem_offset + natmemsize + startbarrier;
} else if (changed_prefs.rtgmem_size && !gfxboard_is_z3 (changed_prefs.rtgmem_type)) {
p96mem_offset = natmem_offset + getz2rtgaddr ();
}
CONTROL "A600/A1200 IDE",IDC_CS_IDE1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,143,104,11
CONTROL "ROM Mirror (E0)",IDC_CS_KSMIRROR_E0,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,157,104,11
CONTROL "KB Reset Warning",IDC_CS_RESETWARNING,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,171,104,11
- CONTROL "A590/A2091 SCSI",IDC_CS_A2091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,216,104,11
- CONTROL "A4091 SCSI",IDC_CS_A4091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,229,104,11
CONTROL "A1000 Boot RAM/ROM",IDC_CS_A1000RAM,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,102,121,11
CONTROL "CD32 C2P",IDC_CS_CD32C2P,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,116,121,11
CONTROL "CDTV SRAM",IDC_CS_CDTVRAM,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,129,121,11
CONTROL "A4000/A4000T IDE",IDC_CS_IDE2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,143,121,11
CONTROL "ROM Mirror (A8)",IDC_CS_KSMIRROR_A8,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,157,121,11
CONTROL "No-EHB Denise",IDC_CS_NOEHB,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,171,121,11
- CONTROL "A3000 SCSI",IDC_CS_DMAC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,216,121,11
- CONTROL "CDTV SCSI",IDC_CS_CDTVSCSI,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,127,229,121,11
+ CONTROL "A3000 WD33C93 SCSI",IDC_CS_DMAC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,34,216,121,11
+ CONTROL "CDTV WD33C93 SCSI",IDC_CS_CDTVSCSI,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,34,229,121,11
CONTROL "DF0: ID Hardware",IDC_CS_DF0IDHW,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,102,125,11
CONTROL "CD32 NVRAM",IDC_CS_CD32NVRAM,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,116,125,11
CONTROL "CDTV SRAM Expansion",IDC_CS_CDTVRAMEXP,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,129,125,11
CONTROL "PCMCIA",IDC_CS_PCMCIA,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,143,125,11
CONTROL "C00000 is Fast RAM",IDC_CS_SLOWISFAST,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,157,125,11
CONTROL "A1000 Agnus (8361/8367)",IDC_CS_DIPAGNUS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,171,125,11
- CONTROL "A4000T SCSI",IDC_CS_DMAC2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,216,125,11
- CONTROL "Include host SCSI devices",IDC_CS_SCSIMODE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,264,229,125,11
+ CONTROL "A4000T NCR53C710 SCSI",IDC_CS_DMAC2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,171,216,125,11
GROUPBOX "Chipset Revision",IDC_STATIC,1,249,393,46
CONTROL "Ramsey revision:",IDC_CS_RAMSEY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,34,261,97,11
CONTROL "Fat Gary revision:",IDC_CS_FATGARY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,34,275,97,11
EDITTEXT IDC_CS_AGNUSREV,311,260,45,13,ES_AUTOHSCROLL
EDITTEXT IDC_CS_DENISEREV,311,275,45,13,ES_AUTOHSCROLL
CONTROL "CIA TOD bug",IDC_CS_CIATODBUG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,14,184,104,11
- GROUPBOX "SCSI Hardware",IDC_STATIC,0,201,393,45
+ GROUPBOX "Internal SCSI Hardware",IDC_STATIC,0,201,393,45
END
IDD_AVIOUTPUT DIALOGEX 0, 0, 396, 260
CTEXT "Enter address",IDC_DBG_ADDRINPUTTXT,20,1,100,10,SS_CENTERIMAGE | WS_TABSTOP
END
-IDD_EXPANSION DIALOGEX 0, 0, 396, 278
+IDD_EXPANSION DIALOGEX 0, 0, 396, 289
STYLE DS_LOCALEDIT | DS_SETFONT | DS_3DLOOK | DS_CONTROL | WS_CHILD
FONT 8, "MS Sans Serif", 0, 0, 0x1
BEGIN
COMBOBOX IDC_RTG_BUFFERCNT,153,162,84,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP
CTEXT "Aspect ratio:",IDC_STATIC,282,149,83,10,SS_CENTERIMAGE
COMBOBOX IDC_RTG_SCALE_ASPECTRATIO,282,162,84,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP
- GROUPBOX "Miscellaneous Expansions",IDC_STATIC,1,197,172,80
+ GROUPBOX "Miscellaneous Expansions",IDC_STATIC,1,197,172,87
CONTROL "Catweasel Z2 emulation [] Catweasel MK2 Zorro II card emulation. Physical Windows compatible Catweasel card and drivers required.",IDC_CATWEASEL,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,216,147,11
CONTROL "uaescsi.device",IDC_SCSIDEVICE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,229,147,11
- GROUPBOX "Network",IDC_STATIC,181,197,213,80
+ GROUPBOX "Network",IDC_STATIC,181,197,213,86
CONTROL "bsdsocket.library [] bsdsocket network library emulation.",IDC_SOCKETS,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,202,216,187,11
CONTROL "uaenet.device [] Sana 2 compatible network device emulation.",IDC_SANA2,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,202,242,187,11
COMBOBOX IDC_NETDEVICE,202,257,178,65,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
CONTROL "Always center",IDC_RTG_CENTER,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,25,93,212,10
+ CONTROL "A590/A2091 WD33C93 SCSI",IDC_CS_A2091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,242,147,11
+ CONTROL "A4091 NCR53C710 SCSI",IDC_CS_A4091,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,255,151,11
+ CONTROL "Include host SCSI devices",IDC_CS_SCSIMODE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,268,147,11
END
IDD_INPUTMAP DIALOGEX 0, 0, 421, 341
#define __i386__
#define WINDOWS
#define ZLIB_WINAPI
+//#define USE_SOFT_LONG_DOUBLE
#define PACKAGE_STRING "WinUAE"
#ifndef UAE_MINI
#define LANG_DLL 1
#if WINUAEPUBLICBETA
-#define WINUAEBETA _T("7")
+#define WINUAEBETA _T("8")
#else
#define WINUAEBETA _T("")
#endif
-#define WINUAEDATE MAKEBD(2014, 2, 9)
+#define WINUAEDATE MAKEBD(2014, 2, 16)
#define WINUAEEXTRA _T("")
//#define WINUAEEXTRA _T("AmiKit Preview")
//#define WINUAEEXTRA _T("Amiga Forever Edition")
CheckDlgButton (hDlg, IDC_CS_DENISE, workprefs.cs_deniserev >= 0);
CheckDlgButton (hDlg, IDC_CS_DMAC, workprefs.cs_mbdmac == 1);
CheckDlgButton (hDlg, IDC_CS_DMAC2, workprefs.cs_mbdmac == 2);
- CheckDlgButton (hDlg, IDC_CS_A2091, workprefs.cs_a2091);
- CheckDlgButton (hDlg, IDC_CS_A4091, workprefs.cs_a4091);
CheckDlgButton (hDlg, IDC_CS_CDTVSCSI, workprefs.cs_cdtvscsi);
- CheckDlgButton (hDlg, IDC_CS_SCSIMODE, workprefs.scsi == 2);
CheckDlgButton (hDlg, IDC_CS_PCMCIA, workprefs.cs_pcmcia);
CheckDlgButton (hDlg, IDC_CS_SLOWISFAST, workprefs.cs_slowmemisfast);
CheckDlgButton (hDlg, IDC_CS_CIATODBUG, workprefs.cs_ciatodbug);
workprefs.cs_mbdmac = ischecked (hDlg, IDC_CS_DMAC) ? 1 : 0;
if (workprefs.cs_mbdmac == 0)
workprefs.cs_mbdmac = ischecked (hDlg, IDC_CS_DMAC2) ? 2 : 0;
- workprefs.cs_a2091 = ischecked (hDlg, IDC_CS_A2091) ? 1 : 0;
- workprefs.cs_a4091 = ischecked (hDlg, IDC_CS_A4091) ? 1 : 0;
-#if 0
- if (msg == WM_COMMAND && LOWORD(wParam) == IDC_CS_SCSIMODE)
- workprefs.scsi = ischecked (hDlg, IDC_CS_SCSIMODE) ? 2 : 0;
-#endif
workprefs.cs_cdtvscsi = ischecked (hDlg, IDC_CS_CDTVSCSI) ? 1 : 0;
workprefs.cs_pcmcia = ischecked (hDlg, IDC_CS_PCMCIA) ? 1 : 0;
workprefs.cs_slowmemisfast = ischecked (hDlg, IDC_CS_SLOWISFAST) ? 1 : 0;
ew (hDlg, IDC_CS_IDE2, e);
ew (hDlg, IDC_CS_DMAC, e);
ew (hDlg, IDC_CS_DMAC2, e);
- ew (hDlg, IDC_CS_A2091, e);
- ew (hDlg, IDC_CS_A4091, e);
- ShowWindow (GetDlgItem(hDlg, IDC_CS_SCSIMODE), SW_HIDE);
- ew (hDlg, IDC_CS_SCSIMODE, FALSE);
ew (hDlg, IDC_CS_CDTVSCSI, e);
ew (hDlg, IDC_CS_PCMCIA, e);
ew (hDlg, IDC_CS_SLOWISFAST, e);
CheckDlgButton (hDlg, IDC_RTG_HWSPRITE, FALSE);
}
ew (hDlg, IDC_RTG_HWSPRITE, rtg3 && workprefs.gfx_api);
+ ShowWindow (GetDlgItem(hDlg, IDC_CS_SCSIMODE), SW_HIDE);
+ ew (hDlg, IDC_CS_A2091, en);
+ ew (hDlg, IDC_CS_A4091, en);
+ ew (hDlg, IDC_CS_SCSIMODE, FALSE);
}
static void values_to_expansiondlg (HWND hDlg)
CheckDlgButton (hDlg, IDC_SCSIDEVICE, workprefs.scsi == 1);
CheckDlgButton (hDlg, IDC_SANA2, workprefs.sana2);
CheckDlgButton (hDlg, IDC_A2065, workprefs.a2065name[0] ? 1 : 0);
+ CheckDlgButton (hDlg, IDC_CS_A2091, workprefs.a2091);
+ CheckDlgButton (hDlg, IDC_CS_A4091, workprefs.a4091);
+ CheckDlgButton (hDlg, IDC_CS_SCSIMODE, workprefs.scsi == 2);
SendDlgItemMessage (hDlg, IDC_RTG_BUFFERCNT, CB_SETCURSEL, workprefs.gfx_apmode[1].gfx_backbuffers == 0 ? 0 : workprefs.gfx_apmode[1].gfx_backbuffers - 1, 0);
cw = catweasel_detect ();
ew (hDlg, IDC_CATWEASEL, cw);
case IDC_CATWEASEL:
workprefs.catweasel = ischecked (hDlg, IDC_CATWEASEL) ? -1 : 0;
break;
+ case IDC_CS_A2091:
+ workprefs.a2091 = ischecked (hDlg, IDC_CS_A2091) ? 1 : 0;
+ break;
+ case IDC_CS_A4091:
+ workprefs.a4091 = ischecked (hDlg, IDC_CS_A4091) ? 1 : 0;
+ break;
}
if (HIWORD (wParam) == CBN_SELENDOK || HIWORD (wParam) == CBN_KILLFOCUS || HIWORD (wParam) == CBN_EDITCHANGE) {
uae_u32 mask = workprefs.picasso96_modeflags;
addromfiles (fkey, hDlg, IDC_CARTFILE, workprefs.cartfile,
ROMTYPE_AR | ROMTYPE_SUPERIV | ROMTYPE_NORDIC | ROMTYPE_XPOWER | ROMTYPE_ARCADIAGAME | ROMTYPE_HRTMON | ROMTYPE_CD32CART);
addromfiles (fkey, hDlg, IDC_A2091ROMFILE, workprefs.a2091romfile,
- ROMTYPE_A2091BOOT);
+ ROMTYPE_A2091BOOT | ROMTYPE_NONE);
addromfiles (fkey, hDlg, IDC_A4091ROMFILE, workprefs.a4091romfile,
ROMTYPE_A4091BOOT);
regclosetree (fkey);
ew (hDlg, IDC_CARTCHOOSER), FALSE);
ew (hDlg, IDC_FLASHCHOOSER), FALSE);
#endif
- ew (hDlg, IDC_A4091ROMCHOOSER, workprefs.cs_a4091);
- ew (hDlg, IDC_A4091ROMFILE, workprefs.cs_a4091);
- ew (hDlg, IDC_A2091ROMCHOOSER, workprefs.cs_a2091);
- ew (hDlg, IDC_A2091ROMFILE, workprefs.cs_a2091);
+ ew (hDlg, IDC_A4091ROMCHOOSER, workprefs.a4091);
+ ew (hDlg, IDC_A4091ROMFILE, workprefs.a4091);
+ ew (hDlg, IDC_A2091ROMCHOOSER, workprefs.a2091);
+ ew (hDlg, IDC_A2091ROMFILE, workprefs.a2091);
if (!regexiststree (NULL , _T("DetectedROMs")))
scan_roms (NULL, rp_isactive () ? 0 : 1);
}
recursive++;
inithdcontroller (hDlg);
if (current_tapedlg.ci.controller < HD_CONTROLLER_IDE0)
- current_tapedlg.ci.controller = (workprefs.cs_a2091 || workprefs.cs_cdtvscsi || workprefs.cs_mbdmac == 1) ? HD_CONTROLLER_SCSI0 : HD_CONTROLLER_IDE0;
+ current_tapedlg.ci.controller = (workprefs.a2091 || workprefs.a4091 || workprefs.cs_cdtvscsi || workprefs.cs_mbdmac >= 1) ? HD_CONTROLLER_SCSI0 : HD_CONTROLLER_IDE0;
SendDlgItemMessage (hDlg, IDC_HDF_CONTROLLER, CB_SETCURSEL, current_tapedlg.ci.controller, 0);
SetDlgItemText (hDlg, IDC_PATH_NAME, current_tapedlg.ci.rootdir);
readonly = my_existsfile (current_tapedlg.ci.rootdir);
recursive++;
inithdcontroller (hDlg);
if (current_cddlg.ci.controller < HD_CONTROLLER_IDE0)
- current_cddlg.ci.controller = (workprefs.cs_a2091 || workprefs.cs_cdtvscsi || workprefs.cs_mbdmac == 1) ? HD_CONTROLLER_SCSI0 : HD_CONTROLLER_IDE0;
+ current_cddlg.ci.controller = (workprefs.a2091 || workprefs.a4091 || workprefs.cs_cdtvscsi || workprefs.cs_mbdmac >= 1) ? HD_CONTROLLER_SCSI0 : HD_CONTROLLER_IDE0;
SendDlgItemMessage (hDlg, IDC_HDF_CONTROLLER, CB_SETCURSEL, current_cddlg.ci.controller, 0);
InitializeListView (hDlg);
recursive--;
rl2 = rl + romlist_cnt - 1;
rl2->path = my_strdup (path);
rl2->rd = rd;
+ struct romdata *rd2 = getromdatabyid (rd->id);
+ if (rd2 != rd && rd2) // replace "X" with parent name
+ rd->name = rd2->name;
}
return NULL;
}
-#define NEXT_ROM_ID 87
+#define NEXT_ROM_ID 88
static struct romheader romheaders[] = {
{ _T("Freezer Cartridges"), 1 },
static struct romdata roms[] = {
{ _T(" AROS KS ROM (built-in)"), 0, 0, 0, 0, _T("AROS\0"), 524288 * 2, 66, 0, 0, ROMTYPE_KICK, 0, 0, NULL,
0xffffffff, 0, 0, 0, 0, 0, _T("AROS") },
+ { _T(" ROM Disabled"), 0, 0, 0, 0, _T("NOROM\0"), 0, 87, 0, 0, ROMTYPE_NONE, 0, 0, NULL,
+ 0xffffffff, 0, 0, 0, 0, 0, _T("NOROM") },
{ _T("Cloanto Amiga Forever ROM key"), 0, 0, 0, 0, 0, 2069, 0, 0, 1, ROMTYPE_KEY, 0, 0, NULL,
0x869ae1b1, 0x801bbab3,0x2e3d3738,0x6dd1636d,0x4f1d6fa7,0xe21d5874 },
return 0;
}
-struct romdata *getromdatabycrc (uae_u32 crc32)
+struct romdata *getromdatabycrc (uae_u32 crc32, bool allowgroup)
{
int i = 0;
while (roms[i].name) {
return &roms[i];
i++;
}
+ if (allowgroup) {
+ i = 0;
+ while (roms[i].name) {
+ if (roms[i].group && crc32 == roms[i].crc32 && !notcrc32(crc32))
+ return &roms[i];
+ i++;
+ }
+ }
return 0;
}
+struct romdata *getromdatabycrc (uae_u32 crc32)
+{
+ return getromdatabycrc (crc32, false);
+}
static int cmpsha1 (const uae_u8 *s1, const struct romdata *rd)
{
#include "blkdev.h"
#include "zfile.h"
-static int outcmd[] = { 0x0a, 0x2a, 0x2f, 0xaa, 0x15, 0x55, -1 };
+static int outcmd[] = { 0x0a, 0x2a, 0xaa, 0x15, 0x55, -1 };
static int incmd[] = { 0x01, 0x03, 0x05, 0x08, 0x12, 0x1a, 0x5a, 0x25, 0x28, 0x34, 0x37, 0x42, 0x43, 0xa8, 0x51, 0x52, 0xbd, -1 };
static int nonecmd[] = { 0x00, 0x0b, 0x11, 0x16, 0x17, 0x19, 0x1b, 0x1e, 0x2b, 0x35, -1 };
static int scsicmdsizes[] = { 6, 10, 10, 12, 16, 12, 10, 10 };
data_len = sd->data_len;
cmd_len = scsicmdsizes[sd->cmd[0] >> 5];
+ sd->cmd_len = cmd_len;
switch (sd->cmd[0])
{
case 0x0a:
case 0xaa:
data_len = ((sd->cmd[6] << 24) | (sd->cmd[7] << 16) | (sd->cmd[8] << 8) | (sd->cmd[9] << 0)) * (uae_s64)sd->blocksize;
break;
+ case 0x2f: // VERIFY
+ if (sd->cmd[1] & 2) {
+ sd->data_len = ((sd->cmd[7] << 8) | (sd->cmd[8] << 0)) * (uae_s64)sd->blocksize;
+ sd->direction = 1;
+ } else {
+ sd->data_len = 0;
+ sd->direction = 0;
+ }
+ return;
}
- sd->cmd_len = cmd_len;
sd->data_len = data_len;
sd->direction = scsi_data_dir (sd);
}
projects / francis / winuae.git / commitdiff