{
int roms[8];
- roms[0] = 16;
- roms[1] = 31;
- roms[2] = 15;
- roms[3] = 14;
- roms[4] = 12;
- roms[5] = 11;
- roms[6] = -1;
+ roms[0] = 46;
+ roms[1] = 16;
+ roms[2] = 31;
+ roms[3] = 15;
+ roms[4] = 14;
+ roms[5] = 12;
+ roms[6] = 11;
+ roms[7] = -1;
p->bogomem_size = 0;
p->chipmem_size = 0x400000;
p->z3fastmem_size = 8 * 1024 * 1024;
debugger_active = 1;
set_special (SPCFLAG_BRK);
debugging = 1;
+ mmu_triggered = 0;
}
int firsthist = 0;
static struct breakpoint_node bpnodes[BREAKPOINT_TOTAL];
static addrbank **debug_mem_banks;
+static addrbank *debug_mem_area;
#define MEMWATCH_TOTAL 4
struct memwatch_node {
uaecptr addr;
static int debug_mem_off (uaecptr addr)
{
- return (munge24 (addr) >> 16) & 0xff;
+ return munge24 (addr) >> 16;
}
static void memwatch_func (uaecptr addr, int rw, int size, uae_u32 val)
}
}
+static int mmu_hit (uaecptr addr, int size, int rw, uae_u32 *v);
+
+static uae_u32 REGPARAM mmu_lget (uaecptr addr)
+{
+ int off = debug_mem_off (addr);
+ uae_u32 v = 0;
+ if (!mmu_hit(addr, 4, 0, &v))
+ v = debug_mem_banks[off]->lget(addr);
+ return v;
+}
+static uae_u32 REGPARAM mmu_wget (uaecptr addr)
+{
+ int off = debug_mem_off (addr);
+ uae_u32 v = 0;
+ if (!mmu_hit(addr, 2, 0, &v))
+ v = debug_mem_banks[off]->wget(addr);
+ return v;
+}
+static uae_u32 REGPARAM mmu_bget (uaecptr addr)
+{
+ int off = debug_mem_off (addr);
+ uae_u32 v = 0;
+ if (!mmu_hit(addr, 1, 0, &v))
+ v = debug_mem_banks[off]->bget(addr);
+ return v;
+}
+static void REGPARAM2 mmu_lput (uaecptr addr, uae_u32 v)
+{
+ int off = debug_mem_off (addr);
+ if (!mmu_hit(addr, 4, 1, &v))
+ debug_mem_banks[off]->lput(addr, v);
+}
+static void REGPARAM2 mmu_wput (uaecptr addr, uae_u32 v)
+{
+ int off = debug_mem_off (addr);
+ if (!mmu_hit(addr, 2, 1, &v))
+ debug_mem_banks[off]->wput(addr, v);
+}
+static void REGPARAM2 mmu_bput (uaecptr addr, uae_u32 v)
+{
+ int off = debug_mem_off (addr);
+ if (!mmu_hit(addr, 1, 1, &v))
+ debug_mem_banks[off]->bput(addr, v);
+}
+
static uae_u32 REGPARAM debug_lget (uaecptr addr)
{
int off = debug_mem_off (addr);
memwatch_func (addr, 1, 1, v);
debug_mem_banks[off]->bput(addr, v);
}
+
static int REGPARAM2 debug_check (uaecptr addr, uae_u32 size)
{
return debug_mem_banks[munge24 (addr) >> 16]->check (addr, size);
int i, as;
addrbank *a1, *a2;
- if (!memwatch_enabled)
+ if (!memwatch_enabled && !mmu_enabled)
return;
as = currprefs.address_space_24 ? 256 : 65536;
for (i = 0; i < as; i++) {
a1 = debug_mem_banks[i];
a2 = mem_banks[i];
memcpy (a2, a1, sizeof (addrbank));
- xfree (a1);
}
xfree (debug_mem_banks);
debug_mem_banks = 0;
+ xfree (debug_mem_area);
+ debug_mem_area = 0;
memwatch_enabled = 0;
+ mmu_enabled = 0;
xfree (illgdebug);
illgdebug = 0;
}
-static int initialize_memwatch (void)
+static void initialize_memwatch (int mode)
{
int i, as;
addrbank *a1, *a2;
+ deinitialize_memwatch();
as = currprefs.address_space_24 ? 256 : 65536;
debug_mem_banks = xmalloc (sizeof (addrbank*) * as);
+ debug_mem_area = xmalloc (sizeof (addrbank) * as);
for (i = 0; i < as; i++) {
- a1 = debug_mem_banks[i] = xmalloc (sizeof (addrbank));
+ a1 = debug_mem_banks[i] = debug_mem_area + i;
a2 = mem_banks[i];
memcpy (a1, a2, sizeof (addrbank));
}
for (i = 0; i < as; i++) {
a2 = mem_banks[i];
- a2->bget = debug_bget;
- a2->wget = debug_wget;
- a2->lget = debug_lget;
- a2->bput = debug_bput;
- a2->wput = debug_wput;
- a2->lput = debug_lput;
+ a2->bget = mode ? mmu_bget : debug_bget;
+ a2->wget = mode ? mmu_wget : debug_wget;
+ a2->lget = mode ? mmu_lget : debug_lget;
+ a2->bput = mode ? mmu_bput : debug_bput;
+ a2->wput = mode ? mmu_wput : debug_wput;
+ a2->lput = mode ? mmu_lput : debug_lput;
a2->check = debug_check;
a2->xlateaddr = debug_xlate;
}
- memwatch_enabled = 1;
- return 1;
+ if (mode)
+ mmu_enabled = 1;
+ else
+ memwatch_enabled = 1;
}
static void memwatch_dump (int num)
char nc;
if (!memwatch_enabled) {
- if (!initialize_memwatch ()) {
- console_out ("Memwatch breakpoints require 24-bit address space\n");
- return;
- }
+ initialize_memwatch (0);
console_out ("Memwatch breakpoints enabled\n");
}
}
*/
-struct snooperdata {
+static int mmu_logging;
+
+#define MMU_PAGE_SHIFT 16
+
+struct mmudata {
uae_u32 flags;
uae_u32 addr;
uae_u32 len;
+ uae_u32 remap;
uae_u32 p_addr;
};
-static struct snooperdata *snoop;
-static uae_u32 snooper_callback;
-
-#define SNOOPER_READ (1 << 0)
-#define SNOOPER_WRITE (1 << 1)
+static struct mmudata *mmubanks;
+static uae_u32 mmu_callback, mmu_regs;
+static uae_u32 mmu_fault_bank_addr, mmu_fault_addr;
+static int mmu_fault_size, mmu_fault_rw;
+static int mmu_slots;
+static struct regstruct mmur;
-void snooper_trigger(uaecptr trapaddr)
+struct mmunode {
+ struct mmudata *mmubank;
+ struct mmunode *next;
+};
+static struct mmunode **mmunl;
+
+#define MMU_READ_U (1 << 0)
+#define MMU_WRITE_U (1 << 1)
+#define MMU_READ_S (1 << 2)
+#define MMU_WRITE_S (1 << 3)
+#define MMU_MAP_READ_U (1 << 4)
+#define MMU_MAP_WRITE_U (1 << 5)
+#define MMU_MAP_READ_S (1 << 6)
+#define MMU_MAP_WRITE_S (1 << 7)
+
+void mmu_do_hit(void)
{
- uae_u32 currpc = m68k_getpc ();
- int sv = regs.s, i;
- struct snooperdata *sd = snoop;
-
- while (sd->flags != 0xffffffff) {
- if (trapaddr >= sd->addr && trapaddr < sd->addr + sd->len)
- break;
- }
- if (sd->flags == 0xffffffff)
- return;
+ int i;
+ uae_u32 pc;
- MakeSR();
+ mmu_triggered = 0;
+ pc = m68k_getpc();
+ regs.intmask = 7;
if (!regs.s) {
regs.usp = m68k_areg(regs, 7);
if (currprefs.cpu_level >= 2)
m68k_areg(regs, 7) = regs.isp;
regs.s = 1;
}
+ MakeSR();
+ m68k_setpc(mmu_callback);
+ set_special(SPCFLAG_END_COMPILE);
+ fill_prefetch_slow ();
- m68k_areg(regs, 7) -= 4;
- put_word (m68k_areg(regs, 7), 0);
- for (i = 0 ; i < 8; i++) {
- m68k_areg(regs, 7) -= 4;
- put_long (m68k_areg(regs, 7), m68k_dreg(regs, i));
- }
- for (i = 0 ; i < 8; i++) {
- m68k_areg(regs, 7) -= 4;
- put_long (m68k_areg(regs, 7), m68k_areg(regs, i));
+ if (currprefs.cpu_level > 0) {
+ for (i = 0 ; i < 9; i++) {
+ m68k_areg(regs, 7) -= 4;
+ put_long (m68k_areg(regs, 7), 0);
+ }
+ m68k_areg(regs, 7) -= 4;
+ put_long (m68k_areg(regs, 7), mmu_fault_addr);
+ m68k_areg(regs, 7) -= 2;
+ put_word (m68k_areg(regs, 7), 0); /* WB1S */
+ m68k_areg(regs, 7) -= 2;
+ put_word (m68k_areg(regs, 7), 0); /* WB2S */
+ m68k_areg(regs, 7) -= 2;
+ put_word (m68k_areg(regs, 7), 0); /* WB3S */
+ m68k_areg(regs, 7) -= 2;
+ put_word (m68k_areg(regs, 7),
+ (mmu_fault_rw ? 0 : 0x100) | (mmu_fault_size << 5)); /* SSW */
+ m68k_areg(regs, 7) -= 4;
+ put_long (m68k_areg(regs, 7), mmu_fault_bank_addr);
+ m68k_areg(regs, 7) -= 2;
+ put_word (m68k_areg(regs, 7), 0x7002);
}
-
m68k_areg(regs, 7) -= 4;
- put_long (m68k_areg(regs, 7), sd->p_addr);
- m68k_areg(regs, 7) -= 2;
- put_word (m68k_areg(regs, 7), 0);
- m68k_areg(regs, 7) -= 2;
- put_word (m68k_areg(regs, 7), 0);
+ put_long (m68k_areg(regs, 7), pc);
m68k_areg(regs, 7) -= 2;
- put_word (m68k_areg(regs, 7), 0);
- m68k_areg(regs, 7) -= 2;
- put_word (m68k_areg(regs, 7), 0x0140 | (sv ? 6 : 2)); /* SSW */
- m68k_areg(regs, 7) -= 4;
- put_long (m68k_areg(regs, 7), trapaddr);
- m68k_areg(regs, 7) -= 2;
- put_word (m68k_areg(regs, 7), 0x7008);
+ put_word (m68k_areg(regs, 7), mmur.sr);
+}
- m68k_areg(regs, 7) -= 4;
- put_long (m68k_areg(regs, 7), currpc);
- m68k_areg(regs, 7) -= 2;
- put_word (m68k_areg(regs, 7), regs.sr);
- m68k_setpc(snooper_callback);
+static void mmu_do_hit_pre (struct mmudata *md, uaecptr addr, int size, int rw, uae_u32 v)
+{
+ uae_u32 p, pc;
+ int i;
- set_special(SPCFLAG_END_COMPILE);
- fill_prefetch_slow ();
+ mmur = regs;
+ pc = m68k_getpc();
+ if (mmu_logging)
+ write_log ("MMU: hit %08.8X SZ=%d RW=%d V=%08.8X PC=%08.8X\n", addr, size, rw, v, pc);
+
+ p = mmu_regs;
+ for (i = 0; i < 16; i++) {
+ put_long (p, regs.regs[i]);
+ p += 4;
+ }
+ put_long (p, pc); p += 4;
+ put_long (p, regs.usp); p += 4;
+ put_long (p, regs.isp); p += 4;
+ put_long (p, regs.msp); p += 4;
+ put_word (p, regs.sr); p += 2;
+ put_word (p, (size << 1) | (rw ? 1 : 0)); /* size and rw */ p += 2;
+ put_long (p, addr); /* fault address */ p += 4;
+ put_long (p, md->p_addr); /* bank address */ p += 4;
+ mmu_fault_addr = addr;
+ mmu_fault_bank_addr = md->p_addr;
+ mmu_fault_size = size;
+ mmu_fault_rw = rw;
+ mmu_triggered = 1;
}
-int snooper(uaecptr p)
+static int mmu_hit (uaecptr addr, int size, int rw, uae_u32 *v)
{
- uaecptr p2;
- int size;
- struct snooperdata *snptr;
+ int s, trig;
+ uae_u32 flags;
+ struct mmudata *md;
+ struct mmunode *mn;
+
+ if (mmu_triggered)
+ return 1;
+
+ mn = mmunl[addr >> MMU_PAGE_SHIFT];
+ if (mn == NULL)
+ return 0;
- if (!p) {
- xfree (snoop);
- snoop = 0;
+ s = regs.s;
+ while (mn) {
+ md = mn->mmubank;
+ if (addr >= md->addr && addr < md->addr + md->len) {
+ flags = md->flags;
+ if (flags & (MMU_MAP_READ_U | MMU_MAP_WRITE_U | MMU_MAP_READ_S | MMU_MAP_WRITE_S)) {
+ trig = 0;
+ if (!s && (flags & MMU_MAP_READ_U) && !rw)
+ trig = 1;
+ if (!s && (flags & MMU_MAP_WRITE_U) && rw)
+ trig = 1;
+ if (s && (flags & MMU_MAP_READ_S) && !rw)
+ trig = 1;
+ if (s && (flags & MMU_MAP_WRITE_S) && rw)
+ trig = 1;
+ if (trig) {
+ uaecptr maddr = md->remap + (addr - md->addr);
+ if (maddr == addr) /* infinite mmu hit loop? no thanks.. */
+ return 1;
+ if (mmu_logging)
+ write_log ("MMU: remap %08.8X -> %08.8X SZ=%d RW=%d\n", addr, maddr, size, rw);
+ if (rw) {
+ switch (size)
+ {
+ case 4:
+ put_long(maddr, *v);
+ break;
+ case 2:
+ put_word(maddr, *v);
+ break;
+ case 1:
+ put_byte(maddr, *v);
+ break;
+ }
+ } else {
+ switch (size)
+ {
+ case 4:
+ *v = get_long(maddr);
+ break;
+ case 2:
+ *v = get_word(maddr);
+ break;
+ case 1:
+ *v = get_byte(maddr);
+ break;
+ }
+ }
+ return 1;
+ }
+ }
+ if (flags & (MMU_READ_U | MMU_WRITE_U | MMU_READ_S | MMU_WRITE_S)) {
+ trig = 0;
+ if (!s && (flags & MMU_READ_U) && !rw)
+ trig = 1;
+ if (!s && (flags & MMU_WRITE_U) && rw)
+ trig = 1;
+ if (s && (flags & MMU_READ_S) && !rw)
+ trig = 1;
+ if (s && (flags & MMU_WRITE_S) && rw)
+ trig = 1;
+ if (trig) {
+ mmu_do_hit_pre (md, addr, size, rw, *v);
+ return 1;
+ }
+ }
+ }
+ mn = mn->next;
+ }
+ return 0;
+}
+
+static void mmu_free_node(struct mmunode *mn)
+{
+ if (!mn)
+ return;
+ mmu_free_node(mn->next);
+ xfree(mn);
+}
+
+static void mmu_free(void)
+{
+ struct mmunode *mn;
+ int i;
+
+ for (i = 0; i < mmu_slots; i++) {
+ mn = mmunl[i];
+ mmu_free_node(mn);
+ }
+ xfree(mmunl);
+ mmunl = NULL;
+ xfree (mmubanks);
+ mmubanks = NULL;
+}
+
+static int getmmubank(struct mmudata *snptr, uaecptr p)
+{
+ snptr->flags = get_long (p);
+ if (snptr->flags == 0xffffffff)
+ return 1;
+ snptr->addr = get_long (p + 4);
+ snptr->len = get_long (p + 8);
+ snptr->remap = get_long (p + 12);
+ snptr->p_addr = p;
+ return 0;
+}
+
+int mmu_init(int mode, uaecptr parm, uaecptr parm2)
+{
+ uaecptr p, p2;
+ int size;
+ struct mmudata *snptr;
+ struct mmunode *mn;
+ static int wasjit;
+
+ if (currprefs.cachesize) {
+ wasjit = currprefs.cachesize;
+ changed_prefs.cachesize = 0;
+ write_log ("MMU: JIT disabled\n");
+ }
+
+ if (mode == 0) {
+ if (mmu_enabled) {
+ mmu_free();
+ deinitialize_memwatch();
+ write_log ("MMU: disabled\n");
+ changed_prefs.cachesize = wasjit;
+ }
+ mmu_logging = 0;
return 1;
}
- if (!initialize_memwatch())
+
+ p = parm;
+ if (get_long (p) != 1) {
+ write_log ("MMU: version mismatch %d <> %d\n", get_long (p), 1);
return 0;
- snooper_callback = get_long (p);
+ }
+ p += 4;
+ mmu_logging = get_long (p) & 1;
+ p += 4;
+ mmu_callback = get_long (p);
+ p += 4;
+ mmu_regs = get_long (p);
p += 4;
+ if (mode == 2) {
+ int off;
+ uaecptr addr = get_long (parm2 + 4);
+ if (!mmu_enabled)
+ return 0;
+ off = addr >> MMU_PAGE_SHIFT;
+ mn = mmunl[off];
+ while (mn) {
+ if (mn->mmubank->p_addr == parm2) {
+ getmmubank(mn->mmubank, parm2);
+ if (mmu_logging)
+ write_log ("MMU: bank update %08.8X: %08.8X - %08.8X %08.8X\n",
+ mn->mmubank->flags, mn->mmubank->addr, mn->mmubank->len + mn->mmubank->addr,
+ mn->mmubank->remap);
+ }
+ mn = mn->next;
+ }
+ return 1;
+ }
+
+ mmu_slots = 1 << ((currprefs.address_space_24 ? 24 : 32) - MMU_PAGE_SHIFT);
+ mmunl = xcalloc (sizeof (struct mmunode*) * mmu_slots, 1);
size = 1;
- p2 = p;
+ p2 = get_long (p);
while (get_long (p2) != 0xffffffff) {
- p2 += 12;
+ p2 += 16;
size++;
}
- snoop = xmalloc (sizeof (struct snooperdata) * size);
- snptr = snoop;
+ p = get_long (p);
+ snptr = mmubanks = xmalloc (sizeof (struct mmudata) * size);
for (;;) {
- snptr->flags = get_long (p);
- if (snptr->flags == 0xffffffff)
+ int off;
+ if (getmmubank(snptr, p))
break;
- snptr->addr = get_long (p + 4);
- snptr->len = get_long (p + 8);
- snptr->p_addr = p;
- p += 12;
+ p += 16;
+ off = snptr->addr >> MMU_PAGE_SHIFT;
+ if (mmunl[off] == NULL) {
+ mn = mmunl[off] = xcalloc (sizeof (struct mmunode), 1);
+ } else {
+ mn = mmunl[off];
+ while (mn->next)
+ mn = mn->next;
+ mn = mn->next = xcalloc (sizeof (struct mmunode), 1);
+ }
+ mn->mmubank = snptr;
+ snptr++;
}
+
+ initialize_memwatch(1);
+ write_log ("MMU: enabled, %d banks, CB=%08.8X, %d*%d\n",
+ size - 1, mmu_callback, mmu_slots, 1 << MMU_PAGE_SHIFT);
+ set_special (SPCFLAG_BRK);
return 1;
}
#include "crc32.h"
#include "inputdevice.h"
+static int longwritemode = 0;
+
/* support HD floppies */
#define FLOPPY_DRIVE_HD
/* writable track length with normal 2us bitcell/300RPM motor (PAL) */
#define FLOPPY_WRITE_LEN (currprefs.ntscmode ? (12798 / 2) : (12668 / 2)) /* 12667 PAL, 12797 NTSC */
+#define FLOPPY_WRITE_MAXLEN 0x3800
/* This works out to 350 */
#define FLOPPY_GAP_LEN (FLOPPY_WRITE_LEN - 11 * 544)
/* (cycles/bitcell) << 8, normal = ((2us/280ns)<<8) = ~1830 */
#define MAX_DISK_WORDS_PER_LINE 50 /* depends on floppy_speed */
static uae_u32 dma_tab[MAX_DISK_WORDS_PER_LINE + 1];
#endif
-static int dskdmaen, dsklength, dsklen;
+static int dskdmaen, dsklength, dsklength2, dsklen;
static uae_u16 dskbytr_val;
static uae_u32 dskpt;
static int dma_enable, bitoffset, syncoffset;
drv->drive_id = DRIVE_ID_35DD;
#endif
break;
+ case DRV_35_DD_ESCOM:
case DRV_35_DD:
default:
drv->drive_id = DRIVE_ID_35DD;
len = (tracklen + 7) / 8;
if (len > ti->len) {
write_log ("disk raw write: image file's track %d is too small (%d < %d)!\n", ti->track, ti->len, len);
- return 0;
+ len = ti->len;
}
diskfile_update (diskfile, ti, tracklen, TRACK_RAW);
for (i = 0; i < ti->len / 2; i++) {
static void drive_write_data (drive * drv)
{
- int ret;
+ int ret = -1;
static int warned;
if (drive_writeprotected (drv)) {
drv->buffered_side = 2;
return;
}
- if (drv->writediskfile)
- drive_write_ext2 (drv->bigmfmbuf, drv->writediskfile, &drv->writetrackdata[drv->cyl * 2 + side], drv->tracklen);
-
+ if (drv->writediskfile) {
+ drive_write_ext2 (drv->bigmfmbuf, drv->writediskfile, &drv->writetrackdata[drv->cyl * 2 + side],
+ longwritemode ? dsklength2 * 8 : drv->tracklen);
+ }
switch (drv->filetype) {
case ADF_NORMAL:
if (drive_write_adf_amigados (drv)) {
case ADF_EXT1:
break;
case ADF_EXT2:
- ret = drive_write_adf_amigados (drv);
+ if (!longwritemode)
+ ret = drive_write_adf_amigados (drv);
if (ret) {
write_log("not an amigados track %d (error %d), writing as raw track\n", drv->cyl * 2 + side, ret);
- drive_write_ext2 (drv->bigmfmbuf, drv->diskfile, &drv->trackdata[drv->cyl * 2 + side], drv->tracklen);
+ drive_write_ext2 (drv->bigmfmbuf, drv->diskfile, &drv->trackdata[drv->cyl * 2 + side],
+ longwritemode ? dsklength2 * 8 : drv->tracklen);
}
return;
case ADF_IPF:
st &= ~0x20;
#endif
} else {
- if (drv->dskready && !drv->indexhack)
+ if (drv->dskready && !drv->indexhack && currprefs.dfxtype[dr] != DRV_35_DD_ESCOM)
st &= ~0x20;
}
} else {
/* report drive ID */
- if (drv->idbit)
+ if (drv->idbit && currprefs.dfxtype[dr] != DRV_35_DD_ESCOM)
st &= ~0x20;
#if 0
if (dr == 0 && currprefs.dfxtype[dr] == DRV_35_DD &&
static void disk_dmafinished (void)
{
INTREQ (0x8002);
+ longwritemode = 0;
dskdmaen = 0;
if (disk_debug_logging > 0) {
int dr, mfmpos = -1;
trackid *ti = drv->trackdata + tr;
if (dskdmaen == 3) {
- drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 8 * 2;
+ drv->tracklen = longwritemode ? FLOPPY_WRITE_MAXLEN : FLOPPY_WRITE_LEN * drv->ddhd * 8 * 2;
drv->trackspeed = get_floppy_speed ();
drv->skipoffset = -1;
updatemfmpos (drv);
}
}
dsklen = v;
- dsklength = dsklen & 0x3fff;
+ dsklength2 = dsklength = dsklen & 0x3fff;
if (dsklength == 1)
dsklength = 0;
void DSKDAT (uae_u16 v)
{
static int count = 0;
+#if 0
+ if (dsklen == 0x8000) {
+ if (v == 1)
+ longwritemode = 1;
+ return;
+ }
+#endif
if (count < 5) {
count++;
write_log ("%04.4X written to DSKDAT. Not good. PC=%08.8X", v, m68k_getpc());
return u;
}
+/* flags and comments supported? */
static int fsdb_cando (Unit *unit)
{
if (currprefs.filesys_custom_uaefsdb && (unit->volflags & MYVOLUMEINFO_STREAMS))
PUT_PCK_RES2 (packet, dos_errno ());
return;
}
-
- fsu.fsu_blocks >>= 1;
- fsu.fsu_bavail >>= 1;
put_long (info, 0); /* errors */
put_long (info + 4, unit->unit); /* unit number */
put_long (info + 8, unit->ui.readonly ? 80 : 82); /* state */
}
a->amigaos_mode = mask;
- if (fsdb_cando (unit))
+ if (!fsdb_cando (unit))
a->amigaos_mode = fsdb_mode_supported (a);
err = fsdb_set_file_attrs (a);
if (err != 0) {
#include <windows.h>
int get_fs_usage (const char *path, const char *disk, struct fs_usage *fsp)
{
- char buf2[1024];
- DWORD SectorsPerCluster;
- DWORD BytesPerSector;
- DWORD NumberOfFreeClusters;
- DWORD TotalNumberOfClusters;
+ char buf2[MAX_DPATH];
+ ULARGE_INTEGER FreeBytesAvailable, TotalNumberOfBytes, TotalNumberOfFreeBytes;
- GetFullPathName (path, sizeof buf2, buf2, NULL);
-
- buf2[3] = 0;
-
- if (!GetDiskFreeSpace (buf2, &SectorsPerCluster, &BytesPerSector,
- &NumberOfFreeClusters, &TotalNumberOfClusters))
- {
- /* lasterror = GetLastError ();*/
+ if (!GetFullPathName (path, sizeof buf2, buf2, NULL)) {
+ write_log("GetFullPathName() failed err=%d\n", GetLastError());
return -1;
}
- /* HACK ALERT! WinNT returns 0 in TotalNumberOfClusters for an audio-CD, which calls the GURU! */
- if( ( TotalNumberOfClusters == 0 ) &&
- ( GetDriveType( buf2 ) == DRIVE_CDROM ) )
- {
- TotalNumberOfClusters = 327680;
+ if (!memcmp (buf2, "\\\\", 2)) {
+ char *p;
+ strcat(buf2, "\\");
+ p = strchr(buf2 + 2, '\\');
+ if (!p)
+ return -1;
+ p = strchr(p + 1, '\\');
+ if (!p)
+ return -1;
+ p[1] = 0;
+ } else {
+ buf2[3] = 0;
}
- BytesPerSector *= SectorsPerCluster;
- fsp->fsu_blocks = adjust_blocks (TotalNumberOfClusters, BytesPerSector, 512);
- fsp->fsu_bavail = adjust_blocks (NumberOfFreeClusters, BytesPerSector, 512);
+ if (!GetDiskFreeSpaceEx (buf2, &FreeBytesAvailable, &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
+ {
+ write_log("GetDiskFreeSpaceEx() failed err=%d\n", GetLastError());
+ return -1;
+ }
+ fsp->fsu_blocks = (1 << 31) - 1;
+ fsp->fsu_bavail = (1 << 31) - 1;
+ if (TotalNumberOfBytes.QuadPart / 1024 < (1 << 31))
+ fsp->fsu_blocks = TotalNumberOfBytes.QuadPart / 1024;
+ if (FreeBytesAvailable.QuadPart / 1024 < (1 << 31))
+ fsp->fsu_bavail = FreeBytesAvailable.QuadPart / 1024;
return 0;
}
case Areg:
switch (size) {
case sz_word:
- write_log ("Foo\n");
printf ("\tm68k_areg(regs, %s) = (uae_s32)(uae_s16)(%s);\n", reg, from);
break;
case sz_long:
printf ("\telse if ((format & 0xF000) == 0x1000) { ; }\n");
printf ("\telse if ((format & 0xF000) == 0x2000) { m68k_areg(regs, 7) += 4; break; }\n");
printf ("\telse if ((format & 0xF000) == 0x8000) { m68k_areg(regs, 7) += 50; break; }\n");
+ printf ("\telse if ((format & 0xF000) == 0x7000) { m68k_areg(regs, 7) += 60; break; }\n");
printf ("\telse if ((format & 0xF000) == 0x9000) { m68k_areg(regs, 7) += 12; break; }\n");
printf ("\telse if ((format & 0xF000) == 0xa000) { m68k_areg(regs, 7) += 24; break; }\n");
printf ("\telse if ((format & 0xF000) == 0xb000) { m68k_areg(regs, 7) += 84; break; }\n");
extern const char *debuginfo(int);
extern void record_copper (uaecptr addr, int hpos, int vpos);
extern void record_copper_reset(void);
-extern int snooper(uaecptr);
+extern int mmu_init(int,uaecptr,uaecptr);
+extern void mmu_do_hit(void);
extern void dump_aga_custom (void);
#else
* (c) 1995 Bernd Schmidt
*/
-typedef enum { DRV_35_DD, DRV_35_HD, DRV_525_SD } drive_type;
+typedef enum { DRV_35_DD, DRV_35_HD, DRV_525_SD, DRV_35_DD_ESCOM } drive_type;
extern void DISK_init (void);
extern void DISK_free (void);
/* Space usage statistics for a filesystem. Blocks are 512-byte. */
struct fs_usage
{
- long fsu_blocks; /* Total blocks. */
- long fsu_bfree; /* Free blocks available to superuser. */
- long fsu_bavail; /* Free blocks available to non-superuser. */
- long fsu_files; /* Total file nodes. */
- long fsu_ffree; /* Free file nodes. */
+ unsigned long fsu_blocks; /* Total blocks. */
+ unsigned long fsu_bfree; /* Free blocks available to superuser. */
+ unsigned long fsu_bavail; /* Free blocks available to non-superuser. */
+ unsigned long fsu_files; /* Total file nodes. */
+ unsigned long fsu_ffree; /* Free file nodes. */
};
#ifndef __P
uae_u8 panic;
uae_u32 panic_pc, panic_addr;
-} regs, lastint_regs;
+} regs, lastint_regs, mmu_backup_regs;
typedef struct {
uae_u16* location;
extern unsigned long irqcycles[15];
extern int irqdelay[15];
+extern int mmu_enabled, mmu_triggered;
STATIC_INLINE void set_special (uae_u32 x)
{
{ "Kickstart v3.1 (A4000)(Cloanto)", 3, 1, 40, 68, "A4000\0", 0x43b6dd22, 524288, 31, 2, 1, ROMTYPE_KICK },
{ "Kickstart v3.1 (A4000)", 3, 1, 40, 68, "A4000\0", 0xd6bae334, 524288, 16, 2, 0, ROMTYPE_KICK },
{ "Kickstart v3.1 (A4000T)", 3, 1, 40, 70, "A4000T\0", 0x75932c3a, 524288, 17, 2, 0, ROMTYPE_KICK },
+ { "Kickstart v3.X (A4000)(Cloanto)", 3, 10, 45, 57, "A4000\0", 0x08b69382, 524288, 46, 2, 0, ROMTYPE_KICK },
{ "CD32 Kickstart v3.1", 3, 1, 40, 60, "CD32\0", 0x1e62d4a5, 524288, 18, 1, 0, ROMTYPE_KICKCD32 },
{ "CD32 Extended", 3, 1, 40, 60, "CD32\0", 0x87746be2, 524288, 19, 1, 0, ROMTYPE_EXTCD32 },
{
void *a = malloc (n);
if (a == NULL) {
- write_log ("xmalloc(%d): virtual memory exhausted\n", n);
abort ();
}
return a;
{
void *a = calloc (n, size);
if (a == NULL) {
- write_log ("xcalloc(%d): virtual memory exhausted\n", n * size);
abort ();
}
return a;
static int last_instructionaccess_for_exception_3;
unsigned long irqcycles[15];
int irqdelay[15];
+int mmu_enabled, mmu_triggered;
int areg_byteinc[] = { 1,1,1,1,1,1,1,2 };
int imm8_table[] = { 8,1,2,3,4,5,6,7 };
init_m68k ();
}
-struct regstruct regs, lastint_regs;
+struct regstruct regs, lastint_regs, mmu_backup_regs;
static struct regstruct regs_backup[16];
static int backup_pointer = 0;
static long int m68kpc_offset;
}
}
+/* "MMU" 68k */
+static void m68k_run_mmu (void)
+{
+ for (;;) {
+ int cycles;
+ uae_u32 opcode = get_iword (0);
+ mmu_backup_regs = regs;
+ cycles = (*cpufunctbl[opcode])(opcode);
+ cycles &= cycles_mask;
+ cycles |= cycles_val;
+ if (mmu_triggered)
+ mmu_do_hit();
+ do_cycles (cycles);
+ if (regs.spcflags) {
+ if (do_specialties (cycles))
+ return;
+ }
+ }
+}
+
#endif
#ifdef X86_ASSEMBLY
currprefs.cpu_level == 0 && currprefs.cpu_compatible ? m68k_run_1 :
currprefs.cpu_compatible ? m68k_run_2p : m68k_run_2);
#else
- m68k_run1 (currprefs.cpu_cycle_exact && currprefs.cpu_level == 0 ? m68k_run_1_ce :
+ if (mmu_enabled && !currprefs.cachesize) {
+ m68k_run1 (m68k_run_mmu);
+ } else {
+ m68k_run1 (currprefs.cpu_cycle_exact && currprefs.cpu_level == 0 ? m68k_run_1_ce :
currprefs.cpu_compatible > 0 && currprefs.cpu_level == 0 ? m68k_run_1 :
currprefs.cpu_level >= 2 && currprefs.cachesize ? m68k_run_2a :
currprefs.cpu_compatible ? m68k_run_2p : m68k_run_2);
+ }
#endif
}
in_m68k_go--;
DWORD dwDDSColor;
DWORD flags = DDPF_RGB;
+ ZeroMemory( &ddpfOverlayFormat, sizeof(ddpfOverlayFormat) );
+ ddpfOverlayFormat.dwSize = sizeof(ddpfOverlayFormat);
+ ZeroMemory( &ddsd, sizeof(ddsd) );
+
if( bOverlayAvailable )
{
write_log( "CreateOverlaySurface being called with %d-bits!\n", bits );
if( bits == 16 )
{
// Set the overlay format to 16 bit RGB 5:6:5
- ZeroMemory( &ddpfOverlayFormat, sizeof(ddpfOverlayFormat) );
- ddpfOverlayFormat.dwSize = sizeof(ddpfOverlayFormat);
ddpfOverlayFormat.dwFlags = flags;
ddpfOverlayFormat.dwRGBBitCount = 16;
ddpfOverlayFormat.dwRBitMask = 0xF800;
else if( bits == 32 )
{
// Set the overlay format to 32 bit ARGB 8:8:8:8
- ZeroMemory( &ddpfOverlayFormat, sizeof(ddpfOverlayFormat) );
- ddpfOverlayFormat.dwSize = sizeof(ddpfOverlayFormat);
ddpfOverlayFormat.dwFlags = flags;
ddpfOverlayFormat.dwRGBBitCount = 32;
ddpfOverlayFormat.dwRBitMask = 0x00FF0000;
else if( bits == 8 )
{
// Set the overlay format to 8 bit palette
- ZeroMemory( &ddpfOverlayFormat, sizeof(ddpfOverlayFormat) );
- ddpfOverlayFormat.dwSize = sizeof(ddpfOverlayFormat);
ddpfOverlayFormat.dwFlags = flags | DDPF_PALETTEINDEXED8;
ddpfOverlayFormat.dwRGBBitCount = 8;
ddpfOverlayFormat.dwRBitMask = 0x00000000;
}
// Setup the overlay surface's attributes in the surface descriptor
- ZeroMemory( &ddsd, sizeof(ddsd) );
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
dr.left = (dr.left + drivercaps.dwAlignBoundaryDest / 2) & ~(drivercaps.dwAlignBoundaryDest - 1);
if ((drivercaps.dwCaps & DDCAPS_ALIGNSIZEDEST) && drivercaps.dwAlignSizeDest)
dr.right = dr.left + (dr.right - dr.left) & ~(drivercaps.dwAlignSizeDest - 1);
- result = IDirectDrawSurface7_UpdateOverlay( DirectDrawState.overlay.surface, &sr, DirectDrawState.primary.surface, &dr, overlayflags, &overlayfx);
+ result = IDirectDrawSurface7_UpdateOverlay(DirectDrawState.overlay.surface, &sr, DirectDrawState.primary.surface, &dr, overlayflags, &overlayfx);
}
if (FAILED(result)) {
p = make_uaefsdbpath (dir, NULL);
ret = DeleteFile(p);
- write_log("delete FSDB stream '%s' = %d\n", p, ret);
+ //write_log("delete FSDB stream '%s' = %d\n", p, ret);
xfree (p);
return ret;
}
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
- InheritedPropertySheets="UpgradeFromVC71.vsprops"
+ InheritedPropertySheets="..\..\..\..\..\msvs2005\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
- InheritedPropertySheets="UpgradeFromVC71.vsprops"
+ InheritedPropertySheets="..\..\..\..\..\msvs2005\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
- InheritedPropertySheets="UpgradeFromVC71.vsprops"
+ InheritedPropertySheets="..\..\..\..\..\msvs2005\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
RelativePath="..\..\readcpu.c"
>
</File>
- <File
- RelativePath="..\writelog.c"
- >
- </File>
</Filter>
</Files>
<Globals>
Version="8,00"
Name="gencpu"
ProjectGUID="{DEF7ACF7-050E-4069-BB99-5B5D93F60521}"
- SignManifests="true"
>
<Platforms>
<Platform
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
- InheritedPropertySheets="UpgradeFromVC71.vsprops"
+ InheritedPropertySheets="..\..\..\..\..\msvs2005\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
- InheritedPropertySheets="UpgradeFromVC71.vsprops"
+ InheritedPropertySheets="..\..\..\..\..\msvs2005\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
- InheritedPropertySheets="UpgradeFromVC71.vsprops"
+ InheritedPropertySheets="..\..\..\..\..\msvs2005\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
RelativePath="..\..\readcpu.c"
>
</File>
- <File
- RelativePath="..\writelog.c"
- >
- </File>
</Filter>
</Files>
<Globals>
sprintf (tmp, "%.1fG", ((double)(uae_u32)(size / (1024 * 1024))) / 1024.0);
else
sprintf (tmp, "%.1fM", ((double)(uae_u32)(size / (1024))) / 1024.0);
- sprintf (name, "%s (%s)", uae_drives[index].device_name, tmp);
+ sprintf (name, "[%s] %s", tmp, uae_drives[index].device_name);
return name;
}
if (flags & 2)
{
HANDLE h = INVALID_HANDLE_VALUE, hdst = INVALID_HANDLE_VALUE;
void *cache = NULL;
- DWORD ret, high, low, got, gotdst;
+ DWORD ret, got, gotdst, get;
uae_u64 size, sizecnt, written;
+ LARGE_INTEGER li;
char path[MAX_DPATH], tmp[MAX_DPATH], tmp2[MAX_DPATH];
DWORD retcode = 0;
HWND hwnd, hwndprogress, hwndprogresstxt;
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_NO_BUFFERING, NULL);
if (hdst == INVALID_HANDLE_VALUE)
goto err;
- low = (DWORD)size;
- high = size >> 32;
- ret = SetFilePointer(hdst, low, &high, FILE_BEGIN);
+ li.QuadPart = size;
+ ret = SetFilePointer(hdst, li.LowPart, &li.HighPart, FILE_BEGIN);
if (ret == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
goto err;
if (!SetEndOfFile(hdst))
goto err;
- high = 0;
- SetFilePointer(hdst, 0, &high, FILE_BEGIN);
- SetFilePointer(h, 0, &high, FILE_BEGIN);
+ li.QuadPart = 0;
+ SetFilePointer(hdst, 0, &li.HighPart, FILE_BEGIN);
+ li.QuadPart = 0;
+ SetFilePointer(h, 0, &li.HighPart, FILE_BEGIN);
progressdialogreturn = -1;
progressdialogactive = 1;
hwnd = CreateDialog (hUIDLL ? hUIDLL : hInst, MAKEINTRESOURCE (IDD_PROGRESSBAR), hDlg, ProgressDialogProc);
cnt = 0;
}
got = gotdst = 0;
- ReadFile(h, cache, COPY_CACHE_SIZE, &got, NULL);
+ li.QuadPart = sizecnt;
+ if (SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+ DWORD err = GetLastError();
+ if (err != NO_ERROR) {
+ progressdialogreturn = 3;
+ break;
+ }
+ }
+ get = COPY_CACHE_SIZE;
+ if (sizecnt + get > size)
+ get = size - sizecnt;
+ if (!ReadFile(h, cache, get, &got, NULL)) {
+ progressdialogreturn = 4;
+ break;
+ }
+ if (get != got) {
+ progressdialogreturn = 5;
+ break;
+ }
if (got > 0) {
if (written + got > size)
got = size - written;
- WriteFile(hdst, cache, got, &gotdst, NULL);
+ if (!WriteFile(hdst, cache, got, &gotdst, NULL)) {
+ progressdialogreturn = 5;
+ break;
+ }
written += gotdst;
if (written == size)
break;
err:
WIN32GUI_LoadUIString (IDS_HDCLONE_FAIL, tmp, MAX_DPATH);
- sprintf (tmp2, tmp, GetLastError());
+ sprintf (tmp2, tmp, progressdialogreturn, GetLastError());
gui_message (tmp2);
ok:
}
}
}
+ setoverlay(1);
}
static int set_panning_called = 0;
#define IDS_SOUND_FILTER_ON 253
#define IDS_SOUND_FILTER_ON_A500 253
#define IDS_DRIVESOUND_PC_FLOPPY 254
+#define IDS_FLOPPYTYPE35DDESCOM 255
#define IDS_NUMSG_NEEDEXT2 300
#define IDS_NUMSG_NOROMKEY 301
#define IDS_NUMSG_KSROMCRCERROR 302
#define IDC_QUICKSTART_COMPATIBILITY 1676
#define IDC_PATHS_AVIOUTPUTS 1676
#define IDC_QUICKSTART_CONFIG 1677
-#define IDC_RESETREGISTRY2 1677
#define IDC_RESETDISKHISTORY 1677
#define IDC_DF0Q 1678
#define IDC_DF0QQ 1678
CONTROL "Autoscale",IDC_FILTERAUTORES,"Button",BS_AUTOCHECKBOX | BS_LEFT | WS_GROUP | WS_TABSTOP,26,168,63,10
END
-IDD_HARDDRIVE DIALOGEX 0, 0, 300, 66
+IDD_HARDDRIVE DIALOGEX 0, 0, 380, 66
STYLE DS_SETFONT | DS_MODALFRAME | DS_SETFOREGROUND | DS_3DLOOK | DS_CENTER | DS_CENTERMOUSE | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "Harddrive Settings"
FONT 8, "MS Sans Serif", 0, 0, 0x0
BEGIN
LTEXT "Hard drive:",-1,7,11,35,10
- COMBOBOX IDC_HARDDRIVE,49,9,246,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP
- CONTROL "Read/write",IDC_RW,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,185,33,50,10
- DEFPUSHBUTTON "Add hard drive",IDOK,116,30,57,14
- PUSHBUTTON "Cancel",IDCANCEL,241,30,54,14
- DEFPUSHBUTTON "Create hard disk image file",IDC_HARDDRIVE_IMAGE,9,30,95,14
+ COMBOBOX IDC_HARDDRIVE,49,9,325,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP
+ CONTROL "Read/write",IDC_RW,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,245,33,50,10
+ DEFPUSHBUTTON "Add hard drive",IDOK,176,30,57,14
+ PUSHBUTTON "Cancel",IDCANCEL,321,30,54,14
+ DEFPUSHBUTTON "Create hard disk image file",IDC_HARDDRIVE_IMAGE,49,30,95,14
EDITTEXT IDC_PATH_NAME,89,49,169,15,ES_AUTOHSCROLL | NOT WS_VISIBLE
END
IDS_SOUND_FILTER_ON_AGA "Always on (A500)"
IDS_SOUND_FILTER_ON_A500 "Always on (A1200)"
IDS_DRIVESOUND_PC_FLOPPY "PC floppy drive %c"
+ IDS_FLOPPYTYPE35DDESCOM "3.5"" ESCOM"
END
STRINGTABLE
IDS_NUMSG_KICKREPNO "The floppy disk (image file) in DF0: is not compatible with the system ROM replacement functionality."
IDS_NUMSG_NOROM "Could not load Kickstart ROM, trying system ROM replacement."
IDS_HDCLONE_OK "Hard drive image file created succesfully."
- IDS_HDCLONE_FAIL "Hard drive image file creation failed, error code %d."
+ IDS_HDCLONE_FAIL "Hard drive image file creation failed.\nError code %d:%d."
END
STRINGTABLE
"\nPress F12 to show the Settings Dialog (GUI), Alt-F4 to quit."
"\nEnd+F1 changes floppy 0, End+F2 changes floppy 1, etc."
"\n");
- write_log ("EXE: '%s'\nDATA: '%s'\n", start_path_exe, start_path_data);
+ write_log ("EXE: '%s', DATA: '%s'\n", start_path_exe, start_path_data);
}
void logging_cleanup( void )
}
extern void test (void);
-extern int screenshotmode;
+extern int screenshotmode, b0rken_ati_overlay;
static int PASCAL WinMain2 (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
int nCmdShow)
if (!strcmp (arg, "-disableharddrivesafetycheck")) harddrive_dangerous = 0x1234dead;
if (!strcmp (arg, "-noaspifiltering")) aspi_allow_all = 1;
#endif
+ if (!strcmp (arg, "-disableowr")) b0rken_ati_overlay = -1;
+ if (!strcmp (arg, "-enableowr")) b0rken_ati_overlay = 1;
if (!strcmp (arg, "-nordtsc")) no_rdtsc = 1;
if (!strcmp (arg, "-forcerdtsc")) no_rdtsc = -1;
if (!strcmp (arg, "-norawinput")) no_rawinput = 1;
extern int mouseactive, focus;
extern int ignore_messages_all;
#define WINUAEBETA 1
-#define WINUAEBETASTR " Beta 3"
+#define WINUAEBETASTR " Beta 4"
extern char start_path_exe[MAX_DPATH];
extern char start_path_data[MAX_DPATH];
int display_change_requested, normal_display_change_starting;
int window_led_drives, window_led_drives_end;
extern int console_logging;
+int b0rken_ati_overlay;
#define SM_WINDOW 0
#define SM_WINDOW_OVERLAY 1
memcpy (&md->guid, guid, sizeof (GUID));
}
write_log ("'%s' '%s' %s\n", desc, name, outGUID(guid));
+ if ((strstr(desc, "X1900") || strstr(desc, "X1800") || strstr(desc, "X1600")) && !b0rken_ati_overlay) {
+ b0rken_ati_overlay = 1;
+ write_log ("** Radeon X1x00 series display card detected, enabling overlay workaround.\n");
+ write_log ("** (blank display with Catalyst 6.1 and newer). Use -disableowr to disable workaround.\n");
+ }
return 1;
}
int w = DirectDraw_CurrentWidth ();
int h = DirectDraw_CurrentHeight ();
int b = DirectDraw_GetSurfaceBitCount ();
- write_log ("W=%d H=%d B=%d\n", w, h, b);
+ write_log ("Desktop: W=%d H=%d B=%d\n", w, h, b);
DirectDraw_EnumDisplayModes (DDEDM_REFRESHRATES , modesCallback);
//dhack();
sortmodes ();
return index;
}
+void setoverlay(int quick)
+{
+ static RECT sr, dr;
+ RECT statusr;
+ POINT p = {0,0};
+ int maxwidth, maxheight, w, h;
+ HMONITOR hm;
+ MONITORINFO mi;
+
+ if (quick) {
+ if (!(currentmode->flags & DM_OVERLAY) || b0rken_ati_overlay <= 0)
+ return;
+ goto end;
+ }
+
+ hm = MonitorFromWindow (hMainWnd, MONITOR_DEFAULTTONEAREST);
+ mi.cbSize = sizeof (mi);
+ if (!GetMonitorInfo (hm, &mi))
+ return;
+
+ GetClientRect (hMainWnd, &dr);
+ // adjust the dest-rect to avoid the status-bar
+ if (hStatusWnd) {
+ if (GetWindowRect (hStatusWnd, &statusr))
+ dr.bottom = dr.bottom - ( statusr.bottom - statusr.top );
+ }
+
+ ClientToScreen(hMainWnd, &p);
+ if (!currprefs.win32_borderless) {
+ p.x += 2;
+ p.y += 2;
+ }
+ dr.left = p.x;
+ dr.top = p.y;
+ dr.right += p.x + 1;
+ dr.bottom += p.y + 1;
+ /* overlay's coordinates are relative to monitor's top/left-corner */
+ dr.left -= mi.rcMonitor.left;
+ dr.top -= mi.rcMonitor.top;
+ dr.right -= mi.rcMonitor.left;
+ dr.bottom -= mi.rcMonitor.top;
+
+ w = currentmode->current_width;
+ h = currentmode->current_height;
+
+ sr.left = 0;
+ sr.top = 0;
+ sr.right = w;
+ sr.bottom = h;
+
+ // Adjust our dst-rect to match the dimensions of our src-rect
+ if (dr.right - dr.left > sr.right - sr.left)
+ dr.right = dr.left + sr.right - sr.left;
+ if (dr.bottom - dr.top > sr.bottom - sr.top)
+ dr.bottom = dr.top + sr.bottom - sr.top;
+
+ maxwidth = mi.rcMonitor.right - mi.rcMonitor.left;
+ if (dr.right > maxwidth) {
+ sr.right = w - (dr.right - maxwidth);
+ dr.right = maxwidth;
+ }
+ maxheight = mi.rcMonitor.bottom - mi.rcMonitor.top;
+ if (dr.bottom > maxheight) {
+ sr.bottom = h - (dr.bottom - maxheight);
+ dr.bottom = maxheight;
+ }
+ if (dr.left < 0) {
+ sr.left = -dr.left;
+ dr.left = 0;
+ }
+ if (dr.top < 0) {
+ sr.top = -dr.top;
+ dr.top = 0;
+ }
+end:
+ DirectDraw_UpdateOverlay(sr, dr);
+}
+
// This function is only called for full-screen Amiga screen-modes, and simply flips
// the front and back buffers. Additionally, because the emulation is not always drawing
// complete frames, we also need to update the back-buffer with the new contents we just
#ifdef GFXFILTER
} else if (currentmode->flags & DM_SWSCALE) {
S2X_render ();
- if( currentmode->flags & DM_DX_FULLSCREEN )
+ if(currentmode->flags & DM_DX_FULLSCREEN )
DX_Flip ();
else if (DirectDraw_GetLockableType() != overlay_surface)
DX_Blit( 0, 0, 0, 0, WIN32GFX_GetWidth(), WIN32GFX_GetHeight(), BLIT_SRC );
#endif
} else if ((currentmode->flags & DM_DDRAW) && DirectDraw_GetLockableType() == secondary_surface ) {
if (currentmode->flags & DM_DX_FULLSCREEN) {
- if( turbo_emulation || DX_Flip() == 0 )
+ if(turbo_emulation || DX_Flip() == 0)
DX_Blit (0, a, 0, a, currentmode->current_width, b - a + 1, BLIT_SRC);
} else if(DirectDraw_GetLockableType() != overlay_surface)
DX_Blit (0, a, 0, a, currentmode->current_width, b - a + 1, BLIT_SRC);
}
+ setoverlay(1);
}
static uae_u8 *ddraw_dolock (void)
void gfx_unlock_picasso (void)
{
DirectDraw_SurfaceUnlock();
- if( p96_double_buffer_needs_flushing )
- {
+ if (p96_double_buffer_needs_flushing) {
/* Here, our flush_block() will deal with a offscreen-plain (back-buffer) to visible-surface (front-buffer) */
- if( DirectDraw_GetLockableType() == secondary_surface )
- {
+ if (DirectDraw_GetLockableType() == secondary_surface) {
BOOL relock = FALSE;
- if( DirectDraw_IsLocked() )
- {
+ if (DirectDraw_IsLocked()) {
relock = TRUE;
unlockscr();
}
- DX_Blit( 0, p96_double_buffer_first,
+ DX_Blit (0, p96_double_buffer_first,
0, p96_double_buffer_first,
currentmode->current_width, p96_double_buffer_last - p96_double_buffer_first + 1,
- BLIT_SRC );
- if( relock )
- {
+ BLIT_SRC);
+ if (relock) {
lockscr();
}
}
c |= currprefs.gfx_display != changed_prefs.gfx_display ? (1|4|8) : 0;
c |= currprefs.win32_alwaysontop != changed_prefs.win32_alwaysontop ? 1 : 0;
c |= currprefs.win32_borderless != changed_prefs.win32_borderless ? 1 : 0;
- c |= currprefs.win32_no_overlay != changed_prefs.win32_no_overlay ? 1 : 0;
+ c |= currprefs.win32_no_overlay != changed_prefs.win32_no_overlay ? 2 : 0;
if (display_change_requested || c)
{
currprefs.win32_borderless = changed_prefs.win32_borderless;
currprefs.win32_no_overlay = changed_prefs.win32_no_overlay;
- if (c & 8) {
- inputdevice_unacquire ();
+ inputdevice_unacquire ();
+ if (c & 2) {
close_windows ();
graphics_init ();
}
pause_sound ();
resume_sound ();
}
- if (c & 8) {
- inputdevice_acquire ();
- }
+ inputdevice_acquire ();
return 1;
}
return 1;
}
-static void setoverlay(void)
-{
- RECT sr, dr, statusr;
- POINT p = {0,0};
- int maxwidth, maxheight, w, h;
- HMONITOR hm;
- MONITORINFO mi;
-
- hm = MonitorFromWindow (hMainWnd, MONITOR_DEFAULTTONEAREST);
- mi.cbSize = sizeof (mi);
- if (!GetMonitorInfo (hm, &mi))
- return;
-
- GetClientRect (hMainWnd, &dr);
- // adjust the dest-rect to avoid the status-bar
- if (hStatusWnd) {
- if (GetWindowRect (hStatusWnd, &statusr))
- dr.bottom = dr.bottom - ( statusr.bottom - statusr.top );
- }
-
- ClientToScreen(hMainWnd, &p);
- if (!currprefs.win32_borderless) {
- p.x += 2;
- p.y += 2;
- }
- dr.left = p.x;
- dr.top = p.y;
- dr.right += p.x + 1;
- dr.bottom += p.y + 1;
- /* overlay's coordinates are relative to monitor's top/left-corner */
- dr.left -= mi.rcMonitor.left;
- dr.top -= mi.rcMonitor.top;
- dr.right -= mi.rcMonitor.left;
- dr.bottom -= mi.rcMonitor.top;
-
- w = currentmode->current_width;
- h = currentmode->current_height;
-
- sr.left = 0;
- sr.top = 0;
- sr.right = w;
- sr.bottom = h;
-
- // Adjust our dst-rect to match the dimensions of our src-rect
- if (dr.right - dr.left > sr.right - sr.left)
- dr.right = dr.left + sr.right - sr.left;
- if (dr.bottom - dr.top > sr.bottom - sr.top)
- dr.bottom = dr.top + sr.bottom - sr.top;
-
- maxwidth = mi.rcMonitor.right - mi.rcMonitor.left;
- if (dr.right > maxwidth) {
- sr.right = w - (dr.right - maxwidth);
- dr.right = maxwidth;
- }
- maxheight = mi.rcMonitor.bottom - mi.rcMonitor.top;
- if (dr.bottom > maxheight) {
- sr.bottom = h - (dr.bottom - maxheight);
- dr.bottom = maxheight;
- }
- if (dr.left < 0) {
- sr.left = -dr.left;
- dr.left = 0;
- }
- if (dr.top < 0) {
- sr.top = -dr.top;
- dr.top = 0;
- }
- DirectDraw_UpdateOverlay(sr, dr);
-}
-
static void updatemodes (void)
{
if (screen_is_picasso) {
init_colors ();
if (currentmode->flags & DM_OVERLAY)
- setoverlay ();
+ setoverlay (0);
#if defined (GFXFILTER)
if (currentmode->flags & DM_SWSCALE) {
void WIN32GFX_WindowMove ( void )
{
if (currentmode->flags & DM_OVERLAY)
- setoverlay();
+ setoverlay(0);
}
void updatedisplayarea (void)
extern void close_windows (void);
extern void updatewinfsmode (struct uae_prefs *p);
extern int is3dmode (void);
+extern void setoverlay(int);
#endif
{
case WM_INITDIALOG:
{
- char ft35dd[100];
- char ft35hd[100];
- char ft525sd[100];
- char ftdis[100];
- WIN32GUI_LoadUIString(IDS_FLOPPYTYPE35DD, ft35dd, sizeof (ft35dd));
- WIN32GUI_LoadUIString(IDS_FLOPPYTYPE35HD, ft35hd, sizeof (ft35hd));
- WIN32GUI_LoadUIString(IDS_FLOPPYTYPE525SD, ft525sd, sizeof (ft525sd));
- WIN32GUI_LoadUIString(IDS_FLOPPYTYPEDISABLED, ftdis, sizeof (ftdis));
+ char ft35dd[20], ft35hd[20], ft525sd[20], ftdis[20], ft35ddescom[20];
+ WIN32GUI_LoadUIString(IDS_FLOPPYTYPE35DD, ft35dd, sizeof ft35dd);
+ WIN32GUI_LoadUIString(IDS_FLOPPYTYPE35HD, ft35hd, sizeof ft35hd);
+ WIN32GUI_LoadUIString(IDS_FLOPPYTYPE525SD, ft525sd, sizeof ft525sd);
+ WIN32GUI_LoadUIString(IDS_FLOPPYTYPE35DDESCOM, ft35ddescom, sizeof ft35ddescom);
+ WIN32GUI_LoadUIString(IDS_FLOPPYTYPEDISABLED, ftdis, sizeof ftdis);
pages[FLOPPY_ID] = hDlg;
if (workprefs.floppy_speed > 0 && workprefs.floppy_speed < 10)
workprefs.floppy_speed = 100;
SendDlgItemMessage (hDlg, IDC_FLOPPYTYPE, CB_ADDSTRING, 0, (LPARAM)ft35dd);
SendDlgItemMessage (hDlg, IDC_FLOPPYTYPE, CB_ADDSTRING, 0, (LPARAM)ft35hd);
SendDlgItemMessage (hDlg, IDC_FLOPPYTYPE, CB_ADDSTRING, 0, (LPARAM)ft525sd);
+ SendDlgItemMessage (hDlg, IDC_FLOPPYTYPE, CB_ADDSTRING, 0, (LPARAM)ft35ddescom);
SendDlgItemMessage (hDlg, IDC_FLOPPYTYPE, CB_SETCURSEL, 0, 0);
for (i = 0; i < 4; i++) {
int f_type = floppybuttons[i][3];
SendDlgItemMessage (hDlg, f_type, CB_ADDSTRING, 0, (LPARAM)ft35dd);
SendDlgItemMessage (hDlg, f_type, CB_ADDSTRING, 0, (LPARAM)ft35hd);
SendDlgItemMessage (hDlg, f_type, CB_ADDSTRING, 0, (LPARAM)ft525sd);
+ SendDlgItemMessage (hDlg, f_type, CB_ADDSTRING, 0, (LPARAM)ft35ddescom);
}
}
case WM_USER:
endofline:
/* now, we have a match */
if (table68k[opc].mnemo != i_ILLG)
- write_log ("Double match: %x: %s\n", opc, opcstr);
+ printf ("Double match: %x: %s\n", opc, opcstr);
if (find == -1) {
for (find = 0;; find++) {
if (strcmp(mnemonic, lookuptab[find].name) == 0) {
case 82: return cfgfile_uaelib_modify (ARG1, ARG2, ARG3, ARG4, ARG5);
case 83: currprefs.mmkeyboard = ARG1 ? 1 : 0; return currprefs.mmkeyboard;
#ifdef DEBUGGER
- case 84: return snooper (ARG0);
+ case 84: return mmu_init (ARG1, ARG2, ARG3);
#endif
}
return 0;
projects / francis / winuae.git / commitdiff