From: Toni Wilen <twilen@winuae.net>
Date: Sat, 12 Feb 2005 13:35:09 +0000 (+0200)
Subject: imported winuaesrc1000b11.zip
X-Git-Tag: 2100~320
X-Git-Url: https://git.unchartedbackwaters.co.uk/w/?a=commitdiff_plain;h=8115e475caf1d4b7e0ef40dc788ae1bab96b8d65;p=francis%2Fwinuae.git

imported winuaesrc1000b11.zip
---

diff --git a/arcadia.c b/arcadia.c
index 5fbec9ba..eab2eb13 100755
--- a/arcadia.c
+++ b/arcadia.c
@@ -47,11 +47,11 @@ static struct arcadiarom roms[] = {
     { "ar_dart.zip", "scpa211", "dart_", 1, 4, 0, 7, 6, 3, 1, 2, 5, 0x98f564 },
     { "ar_fast.zip", "scpav3_0.1", "fastv28.", 0, 7, 6, 5, 4, 3, 2, 1, 0, 0x9902bc },
     { "ar_ldrb.zip", "scpa211", "lbg240", 0, 7, 6, 5, 4, 3, 2, 1, 0, 0x98f564 },
-    { "ar_ldrba.zip", "ar_ldrb.zip/scpa211", "ldrb_", 1, 2, 3, 4, 1, 0, 7, 5, 6, 0x98f564 },
+    { "ar_ldrba.zip", "scpa211", "ldrb_", 1, 2, 3, 4, 1, 0, 7, 5, 6, 0x98f564 },
     { "ar_ninj.zip", "scpa211", "ninj_", 1, 1, 6, 5, 7, 4, 2, 0, 3, 0x98f564 },
     { "ar_rdwr.zip", "scpa211", "rdwr_", 1, 3, 1, 6, 4, 0, 5, 2, 7, 0x98f564 },
     { "ar_sdwr.zip", "scpa211", "sdwr_", 1, 6, 3, 4, 5, 2, 1, 0, 7, 0x98f564 },
-    { "ar_spot.zip", "spotv3.0", "spotv2.", 0, 7, 6, 5, 4, 3, 2, 1, 0, 0x9902bc },
+    { "ar_spot.zip", "scpav3_0.1", "spotv2.", 0, 7, 6, 5, 4, 3, 2, 1, 0, 0x9902bc },
     { "ar_sprg.zip", "scpa211", "sprg_", 1, 4, 7, 3, 0, 6, 5, 2, 1, 0x98f564 },
     { "ar_xeon.zip", "scpa211", "xeon_", 1, 3, 1, 2, 4, 0, 5, 6, 7, 0x98f564 },
     { NULL, NULL, NULL }
@@ -130,34 +130,40 @@ static struct arcadiarom *is_arcadia (char *xpath)
 
 static int load_roms (char *xpath, struct arcadiarom *rom)
 {
-    char path[MAX_DPATH], path2[MAX_DPATH];
+    char path[MAX_DPATH], path2[MAX_DPATH], path3[MAX_DPATH], *p;
     int i;
     
-    i = 0;
-    strcpy (path2, xpath);
-    if (strchr (rom->bios, '/')) {
-	char *p = path2 + strlen (path2) - 1;
-	while (p > path2) {
-	    if (p[0] == '\\' || p[0] == '/') {
-		*p = 0;
-		break;
-	    }
-	    p--;
-	}
-	if (p == path2)
+    strcpy (path3, xpath);
+    p = path3 + strlen (path3) - 1;
+    while (p > path3) {
+	if (p[0] == '\\' || p[0] == '/') {
 	    *p = 0;
+	    break;
+        }
+        p--;
     }
-    sprintf (path, "%s/%s", path2, rom->bios);
+    if (p == path3)
+	*p = 0;
+    strcpy (path2, xpath);
+    if (strchr (rom->bios, '/'))
+	strcpy (path2, path3);
+
+    sprintf (path, "%s/ar_bios.zip/%s", path3, rom->bios);
     if (!load_rom8 (path, arbmemory + bios_offset, 0)) {
-	write_log ("Arcadia: bios load failed ('%s')\n", path);
-	return 0;
+        write_log ("Arcadia: bios load failed ('%s')\n", path);
+	sprintf (path, "%s/%s", path2, rom->bios);
+        if (!load_rom8 (path, arbmemory + bios_offset, 0)) {
+	    write_log ("Arcadia: bios load failed ('%s')\n", path);
+	    return 0;
+	}
     }
     write_log ("Arcadia: bios '%s' loaded\n", path);
+    i = 0;
     for (;;) {
-	sprintf (path, "%s/%s%d", xpath, rom->rom, i + 1);
+        sprintf (path, "%s/%s%d", xpath, rom->rom, i + 1);
 	if (!load_rom8 (path, arbmemory + 2 * 65536 * i, rom->bin)) {
 	    if (i == 0)
-		write_log ("Arcadia: game rom load failed ('%s')\n", path);
+	        write_log ("Arcadia: game rom load failed ('%s')\n", path);
 	    break;
 	}
 	i++;
diff --git a/audio.c b/audio.c
index 3c1be73c..532e07ae 100755
--- a/audio.c
+++ b/audio.c
@@ -906,7 +906,7 @@ void audio_hsync (int dmaaction)
 		    write_log ("%d:>5: LEN=%d PT=%08.8X\n", nr, cdp->wlen, cdp->pt);
 #endif
 	    }
-	    cdp->dat2 = chipmem_wget (cdp->pt);
+	    cdp->dat2 = chipmem_agnus_wget (cdp->pt);
 	    if (cdp->request_word >= 2)
 		handle2 = 1;
 	    if (chan_ena) {
diff --git a/blitter.c b/blitter.c
index 1e512c0e..d9aa4357 100755
--- a/blitter.c
+++ b/blitter.c
@@ -227,7 +227,7 @@ static void blitter_dofast(void)
 		uae_u32 bltadat, blitahold;
 		uae_u16 bltbdat;
 		if (bltadatptr) {
-		    blt_info.bltadat = bltadat = chipmem_wget (bltadatptr);
+		    blt_info.bltadat = bltadat = chipmem_agnus_wget (bltadatptr);
 		    bltadatptr += 2;
 		} else
 		    bltadat = blt_info.bltadat;
@@ -236,17 +236,17 @@ static void blitter_dofast(void)
 		preva = bltadat;
 
 		if (bltbdatptr) {
-		    blt_info.bltbdat = bltbdat = chipmem_wget (bltbdatptr);
+		    blt_info.bltbdat = bltbdat = chipmem_agnus_wget (bltbdatptr);
 		    bltbdatptr += 2;
 		    blitbhold = (((uae_u32)prevb << 16) | bltbdat) >> blt_info.blitbshift;
 		    prevb = bltbdat;
 		}
 
 		if (bltcdatptr) {
-		    blt_info.bltcdat = chipmem_wget (bltcdatptr);
+		    blt_info.bltcdat = chipmem_agnus_wget (bltcdatptr);
 		    bltcdatptr += 2;
 		}
-		if (dodst) chipmem_wput (dstp, blt_info.bltddat);
+		if (dodst) chipmem_agnus_wput (dstp, blt_info.bltddat);
 		blt_info.bltddat = blit_func (blitahold, blitbhold, blt_info.bltcdat, mt) & 0xFFFF;
 		if (blitfill) {
 		    uae_u16 d = blt_info.bltddat;
@@ -269,7 +269,7 @@ static void blitter_dofast(void)
 	    if (bltcdatptr) bltcdatptr += blt_info.bltcmod;
 	    if (bltddatptr) bltddatptr += blt_info.bltdmod;
 	}
-	if (dodst) chipmem_wput (dstp, blt_info.bltddat);
+	if (dodst) chipmem_agnus_wput (dstp, blt_info.bltddat);
 	blt_info.bltbhold = blitbhold;
     }
     blit_masktable[0] = 0xFFFF;
@@ -320,7 +320,7 @@ static void blitter_dofast_desc(void)
 		uae_u32 bltadat, blitahold;
 		uae_u16 bltbdat;
 		if (bltadatptr) {
-		    bltadat = blt_info.bltadat = chipmem_wget (bltadatptr);
+		    bltadat = blt_info.bltadat = chipmem_agnus_wget (bltadatptr);
 		    bltadatptr -= 2;
 		} else
 		    bltadat = blt_info.bltadat;
@@ -329,17 +329,17 @@ static void blitter_dofast_desc(void)
 		preva = bltadat;
 
 		if (bltbdatptr) {
-		    blt_info.bltbdat = bltbdat = chipmem_wget (bltbdatptr);
+		    blt_info.bltbdat = bltbdat = chipmem_agnus_wget (bltbdatptr);
 		    bltbdatptr -= 2;
 		    blitbhold = (((uae_u32)bltbdat << 16) | prevb) >> blt_info.blitdownbshift;
 		    prevb = bltbdat;
 		}
 
 		if (bltcdatptr) {
-		    blt_info.bltcdat = blt_info.bltbdat = chipmem_wget (bltcdatptr);
+		    blt_info.bltcdat = blt_info.bltbdat = chipmem_agnus_wget (bltcdatptr);
 		    bltcdatptr -= 2;
 		}
-		if (dodst) chipmem_wput (dstp, blt_info.bltddat);
+		if (dodst) chipmem_agnus_wput (dstp, blt_info.bltddat);
 		blt_info.bltddat = blit_func (blitahold, blitbhold, blt_info.bltcdat, mt) & 0xFFFF;
 		if (blitfill) {
 		    uae_u16 d = blt_info.bltddat;
@@ -362,7 +362,7 @@ static void blitter_dofast_desc(void)
 	    if (bltcdatptr) bltcdatptr -= blt_info.bltcmod;
 	    if (bltddatptr) bltddatptr -= blt_info.bltdmod;
 	}
-	if (dodst) chipmem_wput (dstp, blt_info.bltddat);
+	if (dodst) chipmem_agnus_wput (dstp, blt_info.bltddat);
 	blt_info.bltbhold = blitbhold;
     }
     blit_masktable[0] = 0xFFFF;
@@ -604,7 +604,7 @@ STATIC_INLINE int blitter_doddma (void)
 	wd = 1;
     }
     if (wd) {
-	chipmem_wput (bltdpt, d);
+	chipmem_agnus_wput (bltdpt, d);
 	bltdpt += blit_add;
 	blitter_hcounter2++;
 	if (blitter_hcounter2 == blt_info.hblitsize) {
@@ -626,11 +626,11 @@ STATIC_INLINE void blitter_dodma (int ch)
     switch (ch)
     {
 	case 1:
-        blt_info.bltadat = chipmem_wget (bltapt);
+        blt_info.bltadat = chipmem_agnus_wget (bltapt);
 	bltapt += blit_add;
 	break;
 	case 2:
-	blt_info.bltbdat = chipmem_wget (bltbpt);
+	blt_info.bltbdat = chipmem_agnus_wget (bltbpt);
 	bltbpt += blit_add;
 	if (blitdesc)
 	    blt_info.bltbhold = (((uae_u32)blt_info.bltbdat << 16) | prevb) >> blt_info.blitdownbshift;
@@ -639,7 +639,7 @@ STATIC_INLINE void blitter_dodma (int ch)
 	prevb = blt_info.bltbdat;
 	break;
 	case 3:
-	blt_info.bltcdat = chipmem_wget (bltcpt);
+	blt_info.bltcdat = chipmem_agnus_wget (bltcpt);
 	bltcpt += blit_add;
 	break;
     }
@@ -924,7 +924,6 @@ void do_blitter (int hpos)
 	blitter_dump ();
     }
 #endif
-
     blit_slowdown = 0;
 
     unset_special (SPCFLAG_BLTNASTY);
diff --git a/catweasel.c b/catweasel.c
index ac67d333..fab5915f 100755
--- a/catweasel.c
+++ b/catweasel.c
@@ -11,11 +11,15 @@
 #include "catweasel.h"
 #include "uae.h"
 
+#include <catweasl_usr.h>
+
 struct catweasel_contr cwc;
 
 static int cwhsync;
 static int handshake;
 
+static HANDLE handle = INVALID_HANDLE_VALUE;
+
 void catweasel_hsync (void)
 {
     if (cwhsync <= 0)
@@ -89,21 +93,45 @@ void catweasel_do_bput (uaecptr addr, uae_u32 b)
 
 int catweasel_init (void)
 {
-    if (!currprefs.catweasel_io)
-	return 0;
-    if (!ioport_init ())
-	return 0;
-    cwc.type = currprefs.catweasel_io >= 0x400 ? CATWEASEL_TYPE_MK3 : CATWEASEL_TYPE_MK1;
-    cwc.iobase = currprefs.catweasel_io;
+    char name[32];
+    int i, len;
+    uae_u8 buffer[1000];
+    uae_u32 model, base;
+
+    return 0;
+
+    for (i = 0; i < 4; i++) {
+        sprintf (name, "\\\\.\\CAT%d_F0", i);
+	handle = CreateFile (name, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, 0,
+	    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+	if (handle != INVALID_HANDLE_VALUE)
+	    break;
+	write_log("%s: %d\n", name, GetLastError());
+    }
+    if (handle == INVALID_HANDLE_VALUE)
+	goto fail;
+    if (!DeviceIoControl (handle, CW_LOCK_EXCLUSIVE, 0, 0, buffer, sizeof (buffer), &len, 0)) {
+	write_log ("CW_LOCK_EXCLUSIVE failed %d\n", GetLastError());
+	goto fail;
+    }
+    model = *((uae_u32*)(buffer + 4));
+    base = *((uae_u32*)(buffer + 0));
+    write_log ("Catweasel MK%d @%p detected and enabled\n", model, base);
+    cwc.type = model == 0 ? 1 : model == 3 ? 4 : 2;
+    cwc.iobase = base;
     catweasel_init_controller (&cwc);
     return 1;
+fail:
+    catweasel_free ();
+    return 0;
+
 }
 
 void catweasel_free (void)
 {
-    if (!currprefs.catweasel_io)
-	return;
-    ioport_free ();
+    if (handle != INVALID_HANDLE_VALUE)
+	CloseHandle (handle);
+    handle = INVALID_HANDLE_VALUE;
     cwc.type = 0;
 }
 
@@ -775,4 +803,6 @@ int catweasel_read(catweasel_drive *d, int side, int clock, int rawmode)
     return 1;
 }
 
-#endif
\ No newline at end of file
+#endif
+
+
diff --git a/catweasel_old.c b/catweasel_old.c
new file mode 100755
index 00000000..9d345e50
--- /dev/null
+++ b/catweasel_old.c
@@ -0,0 +1,804 @@
+
+#include "sysconfig.h"
+#include "sysdeps.h"
+
+#ifdef CATWEASEL
+
+#include "config.h"
+#include "options.h"
+#include "memory.h"
+#include "ioport.h"
+#include "catweasel.h"
+#include "uae.h"
+
+#include <catweasl_usr.h>
+
+struct catweasel_contr cwc;
+
+static int cwhsync;
+static int handshake;
+
+static HANDLE h = INVALID_HANDLE_VALUE;
+
+void catweasel_hsync (void)
+{
+    if (cwhsync <= 0)
+	return;
+    cwhsync--;
+    if (cwhsync == 0) {
+        if (handshake)
+	    ioport_write (currprefs.catweasel_io + 0xd0, 0);
+	handshake = 0;
+    }
+}
+
+int catweasel_read_joystick (uae_u8 *dir, uae_u8 *buttons)
+{
+    if (cwc.type != CATWEASEL_TYPE_MK3)
+	return 0;
+    *dir = ioport_read (currprefs.catweasel_io + 0xc0);
+    *buttons = ioport_read (currprefs.catweasel_io + 0xc8);
+    return 1;
+}
+
+int catweasel_read_keyboard (uae_u8 *keycode)
+{
+    uae_u8 v;
+    if (cwc.type != CATWEASEL_TYPE_MK3)
+	return 0;
+    v = ioport_read (currprefs.catweasel_io + 0xd4);
+    if (!(v & 0x80))
+	return 0;
+    if (handshake)
+	return 0;
+    *keycode = ioport_read (currprefs.catweasel_io + 0xd0);
+    ioport_write (currprefs.catweasel_io + 0xd0, 0);
+    handshake = 1;
+    cwhsync = 10;
+    return 1;
+}
+
+uae_u32 catweasel_do_bget (uaecptr addr)
+{
+    if (cwc.type == CATWEASEL_TYPE_MK3) {
+	if ((currprefs.catweasel_io & 3) == 0 && addr >= 0xc0 && addr <= 0xfc)
+	    return ioport_read (currprefs.catweasel_io + addr);
+    } else {
+	if (addr >= currprefs.catweasel_io && addr <= currprefs.catweasel_io + 8) {
+	    return ioport_read (addr & 0x3ff);
+	} else if(addr >= 0x10000 + currprefs.catweasel_io && addr <= 0x10000 + currprefs.catweasel_io) {
+	    return ioport_read (addr & 0x3ff);
+	} else if ((addr & 0x3ff) < 0x200 || (addr & 0x3ff) >= 0x400) {
+	    write_log("catweasel_bget @%08.8X!\n",addr);
+	}
+    }
+    return 0;
+}
+
+void catweasel_do_bput (uaecptr addr, uae_u32 b)
+{
+    if (cwc.type == CATWEASEL_TYPE_MK3) {
+	if ((currprefs.catweasel_io & 3) == 0 && addr >= 0xc0 && addr <= 0xfc)
+	    ioport_write (currprefs.catweasel_io + addr, b);
+    } else {
+	if (addr >= currprefs.catweasel_io && addr <= currprefs.catweasel_io + 8) {
+	    ioport_write (addr & 0x3ff, b);
+	} else if(addr >= 0x10000 + currprefs.catweasel_io && addr <= 0x10000 + currprefs.catweasel_io) {
+	    ioport_write (addr & 0x3ff, b);
+	} else if ((addr & 0x3ff) < 0x200 || (addr & 0x3ff) >= 0x400) {
+	    write_log("catweasel_bput @%08.8X=%02.2X!\n",addr,b);
+	}
+    }
+}
+
+int catweasel_init (void)
+{
+    char name[32];
+    int i, len;
+    uae_u8 buffer[1000];
+    uae_u32 model, base;
+
+    for (i = 0; i < 4; i++) {
+        sprintf (name, "\\\\.\\CAT%d", i);
+	handle = CreateFile (devname, GENERIC_READ, FILE_SHARE_WRITE|FILE_SHARE_READ, 0,
+	    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+	if (handle != INVALID_HANDLE_VALUE)
+	    break;
+    }
+    if (handle == INVALID_HANDLE_VALUE)
+	goto fail;
+    if (!DeviceIoControl (handle, CW_LOCK_EXCLUSIVE, 0L, 0, buffer, sizeof (buffer), &len, 0) {
+	write_log ("CW_LOCK_EXCLUSIVE failed %d\n", GetLastError());
+	goto fail;
+    model = *((uae_u32*)(buffer + 4));
+    base = *((uae_u32*)(buffer + 0));
+    write_log ("Catweasel MK%d @%p detected and enabled\n", model, base);
+    cwc.type = model == 0 ? 1 : model == 3 ? 4 : 2;
+    cwc.iobase = base;
+    catweasel_init_controller (&cwc);
+    return 1;
+fail:
+    catweasel_free ();
+    return 0;
+
+}
+
+void catweasel_free (void)
+{
+    if (handle != INVALID_HANDLE_VALUE)
+	CloseHandle (handle);
+    handle = INVALID_HANDLE_VALUE;
+    cwc.type = 0;
+}
+
+#define outb(v,port) ioport_write(port,v)
+#define inb(port) ioport_read(port)
+
+#define LONGEST_TRACK 16000
+
+static uae_u8 mfmbuf[LONGEST_TRACK * 4];
+static uae_u8 tmpmfmbuffer[LONGEST_TRACK * 2];
+
+static int bitshiftcompare(uae_u8 *src,int bit,int len,uae_u8 *comp)
+{
+	uae_u8 b;
+	int ones,zeros,len2;
+
+	ones=zeros=0;
+	len2=len;
+	while(len--) {
+		b = (comp[0] << bit) | (comp[1] >> (8 - bit));
+		if(b != *src) return 1;
+		if(b==0x00) zeros++;
+		if(b==0xff) ones++;
+		src++;
+		comp++;
+	}
+	if(ones==len2||zeros==len2) return 1;
+	return 0;
+}
+
+static uae_u8 *mergepieces(uae_u8 *start,int len,int bits,uae_u8 *sync)
+{
+	uae_u8 *dst=tmpmfmbuffer;
+	uae_u8 b;
+	int size;
+	int shift;
+	
+	size=len-(sync-start);
+	memcpy(dst,sync,size);
+	dst+=size;
+	b=start[len];
+	b&=~(255>>bits);
+	b|=start[0]>>bits;
+	*dst++=b;
+	shift=8-bits;
+	while(start<=sync+2000) {
+		*dst++=(start[0]<<shift)|(start[1]>>(8-shift));
+		start++;
+	}
+	return tmpmfmbuffer;
+}	
+		
+#define SCANOFFSET 1 /* scanning range in bytes, -SCANOFFSET to SCANOFFSET */
+#define SCANOFFSET2 20
+#define SCANLENGHT 200 /* scanning length in bytes */
+
+static uae_u8* scantrack(uae_u8 *sync1,uae_u8 *sync2,int *trackbytes,int *trackbits)
+{
+	int i,bits,bytes,matched;
+	uae_u8 *sync2bak=sync2;
+	
+	sync1+=SCANOFFSET2;
+	sync2+=SCANOFFSET2;
+	while(sync1 < sync2bak - 2*SCANOFFSET - SCANOFFSET2 - SCANLENGHT) {
+		matched=0x7fff;
+		for(i=0;i<2*SCANOFFSET*8;i++) {
+			bits=i&7;
+			bytes=-SCANOFFSET+(i>>3);
+			if(!bitshiftcompare(sync1,bits,SCANLENGHT,sync2+bytes)) {
+				if(matched==0x7fff) {
+					matched=i;
+				} else {
+					break;
+				}
+			}
+		}
+		if(matched!=0x7fff && i>=2*SCANOFFSET*8) {
+			bits=matched&7;
+			bytes=-SCANOFFSET+(matched>>3);
+			*trackbytes=sync2+bytes-sync1;
+			*trackbits=bits;
+			return mergepieces(sync1,*trackbytes,*trackbits,sync2bak);
+		}
+		sync1++;
+		sync2++;
+	}
+	return 0;
+}	
+
+static unsigned char threshtab[128];
+
+static void codec_makethresh(int trycnt, const unsigned char *origt, unsigned char *t, int numthresh)
+{
+    static unsigned char tab[10] = { 0, 0, 0, 0, -1, -2, 1, 2, -1, 1 };
+
+    if (trycnt >= sizeof (tab))
+	trycnt = sizeof (tab) - 1;
+    while(numthresh--)
+	t[numthresh] = origt[numthresh] + tab[trycnt];
+}
+
+static void codec_init_threshtab(int trycnt, const unsigned char *origt)
+{
+    static unsigned char old_thresholds[2] = { 0, 0 };
+    unsigned char t[2];
+    int a, i;
+
+    codec_makethresh(trycnt, origt, t, 2);
+
+    if(*(unsigned short*)t == *(unsigned short*)old_thresholds)
+	return;
+
+    for(i=0,a=2; i<128; i++) {
+	if(i == t[0] || i == t[1])
+	    a++;
+	threshtab[i] = a;
+    }
+
+    *(unsigned short*)&old_thresholds = *(unsigned short*)t;
+}
+
+static __inline__ void CWSetCReg(catweasel_contr *c, unsigned char clear, unsigned char set)
+{
+    c->control_register = (c->control_register & ~clear) | set;
+    outb(c->control_register, c->io_sr);
+}
+
+static void CWTriggerStep(catweasel_contr *c)
+{
+    CWSetCReg(c, c->crm_step, 0);
+    CWSetCReg(c, 0, c->crm_step);
+}
+
+void catweasel_init_controller(catweasel_contr *c)
+{
+    int i, j;
+
+    if(!c->iobase)
+	return;
+
+    switch(c->type) {
+    case CATWEASEL_TYPE_MK1:
+	c->crm_sel0 = 1 << 5;
+	c->crm_sel1 = 1 << 4;
+	c->crm_mot0 = 1 << 3;
+	c->crm_mot1 = 1 << 7;
+	c->crm_dir  = 1 << 1;
+	c->crm_step = 1 << 0;
+	c->srm_trk0 = 1 << 4;
+	c->srm_dchg = 1 << 5;
+	c->srm_writ = 1 << 1;
+	c->io_sr    = c->iobase + 2;
+	c->io_mem   = c->iobase;
+	break;
+    case CATWEASEL_TYPE_MK3:
+	c->crm_sel0 = 1 << 2;
+	c->crm_sel1 = 1 << 3;
+	c->crm_mot0 = 1 << 1;
+	c->crm_mot1 = 1 << 5;
+	c->crm_dir  = 1 << 4;
+	c->crm_step = 1 << 7;
+	c->srm_trk0 = 1 << 2;
+	c->srm_dchg = 1 << 5;
+	c->srm_writ = 1 << 6;
+	c->srm_dskready = 1 << 4;
+	c->io_sr    = c->iobase + 0xe8;
+	c->io_mem   = c->iobase + 0xe0;
+	break;
+    default:
+	return;	
+    }
+
+    c->control_register = 255;
+
+    /* select all drives, step inside */
+    CWSetCReg(c, c->crm_dir | c->crm_sel0 | c->crm_sel1, 0);
+    for(i=0;i<2;i++) {
+	c->drives[i].number = i;
+	c->drives[i].contr = c;
+	c->drives[i].diskindrive = 0;
+	
+	/* select only the respective drive, step to track 0 */
+	if(i == 0) {
+	    CWSetCReg(c, c->crm_sel0, c->crm_dir | c->crm_sel1);
+	} else {
+	    CWSetCReg(c, c->crm_sel1, c->crm_dir | c->crm_sel0);
+	}
+
+	for(j = 0; j < 86 && (inb(c->io_sr) & c->srm_trk0); j++) {
+	    CWTriggerStep(c);
+	    sleep_millis(6);
+	}
+	
+	if(j < 86) {
+	    c->drives[i].type = 1;
+	    c->drives[i].track = 0;
+	} else {
+	    c->drives[i].type = 0;
+	}
+    }
+    c->drives[0].sel = c->crm_sel0;
+    c->drives[0].mot = c->crm_mot0;
+    c->drives[1].sel = c->crm_sel1;
+    c->drives[1].mot = c->crm_mot1;
+    CWSetCReg(c, 0, c->crm_sel0 | c->crm_sel1); /* deselect all drives */
+}
+
+void catweasel_free_controller(catweasel_contr *c)
+{
+    if(!c->iobase)
+	return;
+
+    /* all motors off, deselect all drives */
+    CWSetCReg(c, 0, c->crm_mot0 | c->crm_mot1 | c->crm_sel0 | c->crm_sel1);
+}
+
+void catweasel_set_motor(catweasel_drive *d, int on)
+{
+    CWSetCReg(d->contr, d->sel, 0);
+    if (on)
+	CWSetCReg(d->contr, d->mot, 0);
+    else
+	CWSetCReg(d->contr, 0, d->mot);
+    CWSetCReg(d->contr, 0, d->sel);
+}
+
+int catweasel_step(catweasel_drive *d, int dir)
+{
+    catweasel_contr *c = d->contr;
+    CWSetCReg(c, d->sel, 0);
+    if (dir > 0)
+	CWSetCReg(c, c->crm_dir, 0);
+    else
+	CWSetCReg(c, 0, c->crm_dir);
+    CWTriggerStep (c);
+    CWSetCReg(c, 0, d->sel);
+    d->track += dir > 0 ? 1 : -1;
+    return 1;
+}
+
+int catweasel_disk_changed(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = (inb(d->contr->io_sr) & d->contr->srm_dchg) ? 0 : 1;
+    CWSetCReg(d->contr, 0, d->sel);
+    return ret;
+}
+
+int catweasel_diskready(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = (inb(d->contr->io_sr) & d->contr->srm_dskready) ? 0 : 1;
+    CWSetCReg(d->contr, 0, d->sel);
+    return ret;
+}
+
+int catweasel_track0(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = (inb(d->contr->io_sr) & d->contr->srm_trk0) ? 0 : 1;
+    CWSetCReg(d->contr, 0, d->sel);
+    if (ret)
+	d->track = 0;
+    return ret;
+}
+
+int catweasel_write_protected(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = !(inb(d->contr->io_sr) & 8);
+    CWSetCReg(d->contr, 0, d->sel);
+    return ret;
+}
+
+uae_u8 catweasel_read_byte(catweasel_drive *d)
+{
+    return inb(d->contr->io_mem);
+}
+
+static const unsigned char amiga_thresholds[] = { 0x22, 0x30 }; // 27, 38 for 5.25"
+
+#define FLOPPY_WRITE_LEN 6250
+
+#define MFMMASK 0x55555555
+static uae_u32 getmfmlong (uae_u16 * mbuf)
+{
+	return (uae_u32)(((*mbuf << 16) | *(mbuf + 1)) & MFMMASK);
+}
+
+static int drive_write_adf_amigados (uae_u16 *mbuf, uae_u16 *mend, uae_u8 *writebuffer, int track)
+{
+	int i, secwritten = 0;
+	uae_u32 odd, even, chksum, id, dlong;
+	uae_u8 *secdata;
+	uae_u8 secbuf[544];
+	char sectable[22];
+	int num_sectors = 11;
+	int ec = 0;
+
+	memset (sectable, 0, sizeof (sectable));
+	mend -= (4 + 16 + 8 + 512);
+	while (secwritten < num_sectors) {
+		int trackoffs;
+
+		do {
+			while (*mbuf++ != 0x4489) {
+			    if (mbuf >= mend) {
+				ec = 1;
+				goto err;
+			    }
+			}
+		} while (*mbuf++ != 0x4489);
+
+		odd = getmfmlong (mbuf);
+		even = getmfmlong (mbuf + 2);
+		mbuf += 4;
+		id = (odd << 1) | even;
+
+		trackoffs = (id & 0xff00) >> 8;
+		if (trackoffs > 10) {
+		    ec = 2;
+		    goto err;
+		}
+		chksum = odd ^ even;
+		for (i = 0; i < 4; i++) {
+			odd = getmfmlong (mbuf);
+			even = getmfmlong (mbuf + 8);
+			mbuf += 2;
+
+			dlong = (odd << 1) | even;
+			if (dlong) {
+			    ec = 6;
+			    goto err;
+			}
+			chksum ^= odd ^ even;
+		} /* could check here if the label is nonstandard */
+		mbuf += 8;
+		odd = getmfmlong (mbuf);
+		even = getmfmlong (mbuf + 2);
+		mbuf += 4;
+		if (((odd << 1) | even) != chksum) {
+		    ec = 3;
+		    goto err;
+		}
+		odd = (id & 0x00ff0000) >> 16;
+		if (odd != track) {
+		    ec = 7;
+		    goto err;
+		}
+		odd = getmfmlong (mbuf);
+		even = getmfmlong (mbuf + 2);
+		mbuf += 4;
+		chksum = (odd << 1) | even;
+		secdata = secbuf + 32;
+		for (i = 0; i < 128; i++) {
+			odd = getmfmlong (mbuf);
+			even = getmfmlong (mbuf + 256);
+			mbuf += 2;
+			dlong = (odd << 1) | even;
+			*secdata++ = dlong >> 24;
+			*secdata++ = dlong >> 16;
+			*secdata++ = dlong >> 8;
+			*secdata++ = dlong;
+			chksum ^= odd ^ even;
+		}
+		mbuf += 256;
+		if (chksum) {
+		    ec = 4;
+		    goto err;
+		}
+		sectable[trackoffs] = 1;
+		secwritten++;
+		memcpy (writebuffer + trackoffs * 512, secbuf + 32, 512);
+	}
+	if (secwritten == 0 || secwritten < 0) {
+	    ec = 5;
+	    goto err;
+	}
+	return 0;
+err:
+	write_log ("mfm decode error %d. secwritten=%d\n", ec, secwritten);
+	for (i = 0; i < num_sectors; i++)
+	    write_log ("%d:%d ", i, sectable[i]);
+	write_log ("\n");
+	return ec;
+}
+
+static void mfmcode (uae_u16 * mfm, int words)
+{
+    uae_u32 lastword = 0;
+
+    while (words--) {
+	uae_u32 v = *mfm;
+	uae_u32 lv = (lastword << 16) | v;
+	uae_u32 nlv = 0x55555555 & ~lv;
+	uae_u32 mfmbits = (nlv << 1) & (nlv >> 1);
+
+	*mfm++ = v | mfmbits;
+	lastword = v;
+    }
+}
+
+#define FLOPPY_GAP_LEN 360
+
+static int amigados_mfmcode (uae_u8 *src, uae_u16 *dst, int num_secs, int track)
+{
+	int sec;
+	memset (dst, 0xaa, FLOPPY_GAP_LEN * 2);
+
+	for (sec = 0; sec < num_secs; sec++) {
+	    uae_u8 secbuf[544];
+	    int i;
+	    uae_u16 *mfmbuf = dst + 544 * sec + FLOPPY_GAP_LEN;
+	    uae_u32 deven, dodd;
+	    uae_u32 hck = 0, dck = 0;
+
+	    secbuf[0] = secbuf[1] = 0x00;
+	    secbuf[2] = secbuf[3] = 0xa1;
+	    secbuf[4] = 0xff;
+	    secbuf[5] = track;
+	    secbuf[6] = sec;
+	    secbuf[7] = num_secs - sec;
+
+	    for (i = 8; i < 24; i++)
+		secbuf[i] = 0;
+
+	    mfmbuf[0] = mfmbuf[1] = 0xaaaa;
+	    mfmbuf[2] = mfmbuf[3] = 0x4489;
+
+	    memcpy (secbuf + 32, src + sec * 512, 512);
+	    deven = ((secbuf[4] << 24) | (secbuf[5] << 16)
+		     | (secbuf[6] << 8) | (secbuf[7]));
+	    dodd = deven >> 1;
+	    deven &= 0x55555555;
+	    dodd &= 0x55555555;
+
+	    mfmbuf[4] = dodd >> 16;
+	    mfmbuf[5] = dodd;
+	    mfmbuf[6] = deven >> 16;
+	    mfmbuf[7] = deven;
+
+	    for (i = 8; i < 48; i++)
+		mfmbuf[i] = 0xaaaa;
+	    for (i = 0; i < 512; i += 4) {
+		deven = ((secbuf[i + 32] << 24) | (secbuf[i + 33] << 16)
+			 | (secbuf[i + 34] << 8) | (secbuf[i + 35]));
+		dodd = deven >> 1;
+		deven &= 0x55555555;
+		dodd &= 0x55555555;
+		mfmbuf[(i >> 1) + 32] = dodd >> 16;
+		mfmbuf[(i >> 1) + 33] = dodd;
+		mfmbuf[(i >> 1) + 256 + 32] = deven >> 16;
+		mfmbuf[(i >> 1) + 256 + 33] = deven;
+	    }
+
+	    for (i = 4; i < 24; i += 2)
+		hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
+
+	    deven = dodd = hck;
+	    dodd >>= 1;
+	    mfmbuf[24] = dodd >> 16;
+	    mfmbuf[25] = dodd;
+	    mfmbuf[26] = deven >> 16;
+	    mfmbuf[27] = deven;
+
+	    for (i = 32; i < 544; i += 2)
+		dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
+
+	    deven = dodd = dck;
+	    dodd >>= 1;
+	    mfmbuf[28] = dodd >> 16;
+	    mfmbuf[29] = dodd;
+	    mfmbuf[30] = deven >> 16;
+	    mfmbuf[31] = deven;
+	    mfmcode (mfmbuf + 4, 544 - 4);
+
+	}
+    return (num_secs * 544 + FLOPPY_GAP_LEN) * 2 * 8;
+}
+
+static uae_u16 amigamfmbuffer[LONGEST_TRACK];
+static uae_u8 amigabuffer[512*22];
+
+/* search and align to 0x4489 WORDSYNC markers */
+static int isamigatrack(uae_u8 *mfmdata, uae_u8 *mfmdatae, uae_u16 *mfmdst, int track)
+{
+	uae_u16 *dst = amigamfmbuffer;
+	int len;
+	int shift, syncshift, sync,ret;
+	uae_u32 l;
+	uae_u16 w;
+
+	sync = syncshift = shift = 0;
+	len = (mfmdatae - mfmdata) * 8;
+	if (len > LONGEST_TRACK * 8)
+	    len = LONGEST_TRACK * 8;
+	while (len--) {
+		l = (mfmdata[0] << 16) | (mfmdata[1] << 8) | (mfmdata[2] << 0);
+		w = l >> (8 - shift);
+		if (w == 0x4489) {
+			sync = 1;
+			syncshift = 0;
+		}
+		if (sync) {
+			if (syncshift == 0) *dst++ = w;
+			syncshift ++;
+			if (syncshift == 16) syncshift = 0;
+		}
+		shift++;
+		if (shift == 8) {
+			mfmdata++;
+			shift = 0;
+		}
+	}
+	if (sync) {
+		ret=drive_write_adf_amigados (amigamfmbuffer, dst, amigabuffer, track);
+		if(!ret)
+		    return amigados_mfmcode (amigabuffer, mfmdst, 11, track);
+		write_log ("decode error %d\n", ret);
+	} else {
+	    write_log ("decode error: no sync found\n");
+	}
+	return 0;
+}
+
+
+
+int catweasel_fillmfm (catweasel_drive *d, uae_u16 *mfm, int side, int clock, int rawmode)
+{
+    int i, j, oldsync, syncs[10], synccnt, endcnt;
+    uae_u32 tt1 = 0, tt2 = 0;
+    uae_u8 *p1;
+    int bytes = 0, bits = 0;
+    static int lasttrack, trycnt;
+
+    if (cwc.type == 0)
+	return 0;
+    if (d->contr->control_register & d->mot)
+	return 0;
+    if (!catweasel_read (d, side, 1, rawmode))
+	return 0;
+    if(d->contr->type == CATWEASEL_TYPE_MK1) {
+	inb(d->contr->iobase + 1);
+	inb(d->contr->io_mem); /* ignore first byte */
+    } else {
+	outb(0, d->contr->iobase + 0xe4);
+    }
+    catweasel_read_byte (d);
+    if (lasttrack == d->track)
+	trycnt++;
+    else
+	trycnt = 0;
+    lasttrack = d->track;
+    codec_init_threshtab(trycnt, amiga_thresholds);
+    i = 0; j = 0;
+    synccnt = 0;
+    oldsync = -1;
+    endcnt = 0;
+    while (j < LONGEST_TRACK * 4) {
+	uae_u8 b = catweasel_read_byte (d);
+	if (b >= 250) {
+	    if (b == 255 - endcnt) {
+		endcnt++;
+		if (endcnt == 5)
+		    break;
+	    } else
+		endcnt = 0;
+	}
+	if (rawmode) {
+	    if (b & 0x80) {
+		if (oldsync < j) {
+		    syncs[synccnt++] = j;
+		    oldsync = j + 300;
+		}
+	    }
+	    if (synccnt >= 3 && j > oldsync)
+		break;
+	}
+	b = threshtab[b & 0x7f];
+	tt1 = (tt1 << b) + 1;
+	tt2 += b;
+
+	if (tt2 >= 16) {
+	    tt2 -= 16;
+	    mfmbuf[j++] = tt1 >> (tt2 + 8);
+	    mfmbuf[j++] = tt1 >> tt2;
+	}
+	i++;
+    }
+    write_log ("cyl=%d, side=%d, length %d, syncs %d\n", d->track, side, j, synccnt);
+    if (rawmode) {
+	if (synccnt >= 3) {
+	    p1 = scantrack (mfmbuf + syncs[1], mfmbuf + syncs[2], &bytes, &bits);
+	    if (p1) {
+		j = 0;
+		for (i = 0; i < bytes + 2; i+=2) {
+		    mfm[j++] = (p1[i] << 8) | p1[i + 1];
+		}
+	        return bytes * 8 + bits;
+	    }
+	}
+    } else {
+	return isamigatrack (mfmbuf, mfmbuf + j, mfm, d->track * 2 + side);
+    }
+    return 0;
+}
+	
+int catweasel_read(catweasel_drive *d, int side, int clock, int rawmode)
+{
+    int iobase = d->contr->iobase;
+
+    CWSetCReg(d->contr, d->sel, 0);
+    if(d->contr->type == CATWEASEL_TYPE_MK1) {
+	CWSetCReg(d->contr, 1<<2, (!side)<<2); /* set disk side */
+
+	inb(iobase+1); /* ra reset */
+	outb(clock*128, iobase+3);
+
+	inb(iobase+1);
+	inb(iobase+0);
+//	inb(iobase+0);
+//	outb(0, iobase+3); /* don't store index pulse */
+
+	inb(iobase+1);
+
+	inb(iobase+7); /* start reading */
+	sleep_millis(rawmode ? 550 : 225);
+	outb(0, iobase+1); /* stop reading, don't reset RAM pointer */
+
+	outb(128, iobase+0); /* add data end mark */
+	outb(128, iobase+0);
+
+	inb(iobase+1); /* Reset RAM pointer */
+    } else {
+	CWSetCReg(d->contr, 1<<6, (!side)<<6); /* set disk side */
+
+	outb(0, iobase + 0xe4); /* Reset memory pointer */
+	switch(clock) {
+	case 0: /* 28MHz */
+	    outb(128, iobase + 0xec);
+	    break;
+	case 1: /* 14MHz */
+	    outb(0, iobase + 0xec);
+	    break;
+	}
+	inb(iobase + 0xe0);
+	inb(iobase + 0xe0);
+	outb(0, iobase + 0xec); /* no IRQs, no MFM predecode */
+	inb(iobase + 0xe0);
+	outb(0, iobase + 0xec); /* don't store index pulse */
+
+	outb(0, iobase + 0xe4); /* Reset memory pointer */
+	inb(iobase + 0xf0); /* start reading */
+	sleep_millis(rawmode ? 550 : 225);
+	inb(iobase + 0xe4); /* stop reading, don't reset RAM pointer */
+
+	outb(255, iobase + 0xe0); /* add data end mark */
+	outb(254, iobase + 0xe0); /* add data end mark */
+	outb(253, iobase + 0xe0); /* add data end mark */
+	outb(252, iobase + 0xe0); /* add data end mark */
+	outb(251, iobase + 0xe0); /* add data end mark */
+	outb(0, iobase + 0xe4); /* Reset memory pointer */
+    }
+    CWSetCReg(d->contr, 0, d->sel);
+    return 1;
+}
+
+#endif
+
+
diff --git a/catweasel_old2.c b/catweasel_old2.c
new file mode 100755
index 00000000..ac67d333
--- /dev/null
+++ b/catweasel_old2.c
@@ -0,0 +1,778 @@
+
+#include "sysconfig.h"
+#include "sysdeps.h"
+
+#ifdef CATWEASEL
+
+#include "config.h"
+#include "options.h"
+#include "memory.h"
+#include "ioport.h"
+#include "catweasel.h"
+#include "uae.h"
+
+struct catweasel_contr cwc;
+
+static int cwhsync;
+static int handshake;
+
+void catweasel_hsync (void)
+{
+    if (cwhsync <= 0)
+	return;
+    cwhsync--;
+    if (cwhsync == 0) {
+        if (handshake)
+	    ioport_write (currprefs.catweasel_io + 0xd0, 0);
+	handshake = 0;
+    }
+}
+
+int catweasel_read_joystick (uae_u8 *dir, uae_u8 *buttons)
+{
+    if (cwc.type != CATWEASEL_TYPE_MK3)
+	return 0;
+    *dir = ioport_read (currprefs.catweasel_io + 0xc0);
+    *buttons = ioport_read (currprefs.catweasel_io + 0xc8);
+    return 1;
+}
+
+int catweasel_read_keyboard (uae_u8 *keycode)
+{
+    uae_u8 v;
+    if (cwc.type != CATWEASEL_TYPE_MK3)
+	return 0;
+    v = ioport_read (currprefs.catweasel_io + 0xd4);
+    if (!(v & 0x80))
+	return 0;
+    if (handshake)
+	return 0;
+    *keycode = ioport_read (currprefs.catweasel_io + 0xd0);
+    ioport_write (currprefs.catweasel_io + 0xd0, 0);
+    handshake = 1;
+    cwhsync = 10;
+    return 1;
+}
+
+uae_u32 catweasel_do_bget (uaecptr addr)
+{
+    if (cwc.type == CATWEASEL_TYPE_MK3) {
+	if ((currprefs.catweasel_io & 3) == 0 && addr >= 0xc0 && addr <= 0xfc)
+	    return ioport_read (currprefs.catweasel_io + addr);
+    } else {
+	if (addr >= currprefs.catweasel_io && addr <= currprefs.catweasel_io + 8) {
+	    return ioport_read (addr & 0x3ff);
+	} else if(addr >= 0x10000 + currprefs.catweasel_io && addr <= 0x10000 + currprefs.catweasel_io) {
+	    return ioport_read (addr & 0x3ff);
+	} else if ((addr & 0x3ff) < 0x200 || (addr & 0x3ff) >= 0x400) {
+	    write_log("catweasel_bget @%08.8X!\n",addr);
+	}
+    }
+    return 0;
+}
+
+void catweasel_do_bput (uaecptr addr, uae_u32 b)
+{
+    if (cwc.type == CATWEASEL_TYPE_MK3) {
+	if ((currprefs.catweasel_io & 3) == 0 && addr >= 0xc0 && addr <= 0xfc)
+	    ioport_write (currprefs.catweasel_io + addr, b);
+    } else {
+	if (addr >= currprefs.catweasel_io && addr <= currprefs.catweasel_io + 8) {
+	    ioport_write (addr & 0x3ff, b);
+	} else if(addr >= 0x10000 + currprefs.catweasel_io && addr <= 0x10000 + currprefs.catweasel_io) {
+	    ioport_write (addr & 0x3ff, b);
+	} else if ((addr & 0x3ff) < 0x200 || (addr & 0x3ff) >= 0x400) {
+	    write_log("catweasel_bput @%08.8X=%02.2X!\n",addr,b);
+	}
+    }
+}
+
+int catweasel_init (void)
+{
+    if (!currprefs.catweasel_io)
+	return 0;
+    if (!ioport_init ())
+	return 0;
+    cwc.type = currprefs.catweasel_io >= 0x400 ? CATWEASEL_TYPE_MK3 : CATWEASEL_TYPE_MK1;
+    cwc.iobase = currprefs.catweasel_io;
+    catweasel_init_controller (&cwc);
+    return 1;
+}
+
+void catweasel_free (void)
+{
+    if (!currprefs.catweasel_io)
+	return;
+    ioport_free ();
+    cwc.type = 0;
+}
+
+#define outb(v,port) ioport_write(port,v)
+#define inb(port) ioport_read(port)
+
+#define LONGEST_TRACK 16000
+
+static uae_u8 mfmbuf[LONGEST_TRACK * 4];
+static uae_u8 tmpmfmbuffer[LONGEST_TRACK * 2];
+
+static int bitshiftcompare(uae_u8 *src,int bit,int len,uae_u8 *comp)
+{
+	uae_u8 b;
+	int ones,zeros,len2;
+
+	ones=zeros=0;
+	len2=len;
+	while(len--) {
+		b = (comp[0] << bit) | (comp[1] >> (8 - bit));
+		if(b != *src) return 1;
+		if(b==0x00) zeros++;
+		if(b==0xff) ones++;
+		src++;
+		comp++;
+	}
+	if(ones==len2||zeros==len2) return 1;
+	return 0;
+}
+
+static uae_u8 *mergepieces(uae_u8 *start,int len,int bits,uae_u8 *sync)
+{
+	uae_u8 *dst=tmpmfmbuffer;
+	uae_u8 b;
+	int size;
+	int shift;
+	
+	size=len-(sync-start);
+	memcpy(dst,sync,size);
+	dst+=size;
+	b=start[len];
+	b&=~(255>>bits);
+	b|=start[0]>>bits;
+	*dst++=b;
+	shift=8-bits;
+	while(start<=sync+2000) {
+		*dst++=(start[0]<<shift)|(start[1]>>(8-shift));
+		start++;
+	}
+	return tmpmfmbuffer;
+}	
+		
+#define SCANOFFSET 1 /* scanning range in bytes, -SCANOFFSET to SCANOFFSET */
+#define SCANOFFSET2 20
+#define SCANLENGHT 200 /* scanning length in bytes */
+
+static uae_u8* scantrack(uae_u8 *sync1,uae_u8 *sync2,int *trackbytes,int *trackbits)
+{
+	int i,bits,bytes,matched;
+	uae_u8 *sync2bak=sync2;
+	
+	sync1+=SCANOFFSET2;
+	sync2+=SCANOFFSET2;
+	while(sync1 < sync2bak - 2*SCANOFFSET - SCANOFFSET2 - SCANLENGHT) {
+		matched=0x7fff;
+		for(i=0;i<2*SCANOFFSET*8;i++) {
+			bits=i&7;
+			bytes=-SCANOFFSET+(i>>3);
+			if(!bitshiftcompare(sync1,bits,SCANLENGHT,sync2+bytes)) {
+				if(matched==0x7fff) {
+					matched=i;
+				} else {
+					break;
+				}
+			}
+		}
+		if(matched!=0x7fff && i>=2*SCANOFFSET*8) {
+			bits=matched&7;
+			bytes=-SCANOFFSET+(matched>>3);
+			*trackbytes=sync2+bytes-sync1;
+			*trackbits=bits;
+			return mergepieces(sync1,*trackbytes,*trackbits,sync2bak);
+		}
+		sync1++;
+		sync2++;
+	}
+	return 0;
+}	
+
+static unsigned char threshtab[128];
+
+static void codec_makethresh(int trycnt, const unsigned char *origt, unsigned char *t, int numthresh)
+{
+    static unsigned char tab[10] = { 0, 0, 0, 0, -1, -2, 1, 2, -1, 1 };
+
+    if (trycnt >= sizeof (tab))
+	trycnt = sizeof (tab) - 1;
+    while(numthresh--)
+	t[numthresh] = origt[numthresh] + tab[trycnt];
+}
+
+static void codec_init_threshtab(int trycnt, const unsigned char *origt)
+{
+    static unsigned char old_thresholds[2] = { 0, 0 };
+    unsigned char t[2];
+    int a, i;
+
+    codec_makethresh(trycnt, origt, t, 2);
+
+    if(*(unsigned short*)t == *(unsigned short*)old_thresholds)
+	return;
+
+    for(i=0,a=2; i<128; i++) {
+	if(i == t[0] || i == t[1])
+	    a++;
+	threshtab[i] = a;
+    }
+
+    *(unsigned short*)&old_thresholds = *(unsigned short*)t;
+}
+
+static __inline__ void CWSetCReg(catweasel_contr *c, unsigned char clear, unsigned char set)
+{
+    c->control_register = (c->control_register & ~clear) | set;
+    outb(c->control_register, c->io_sr);
+}
+
+static void CWTriggerStep(catweasel_contr *c)
+{
+    CWSetCReg(c, c->crm_step, 0);
+    CWSetCReg(c, 0, c->crm_step);
+}
+
+void catweasel_init_controller(catweasel_contr *c)
+{
+    int i, j;
+
+    if(!c->iobase)
+	return;
+
+    switch(c->type) {
+    case CATWEASEL_TYPE_MK1:
+	c->crm_sel0 = 1 << 5;
+	c->crm_sel1 = 1 << 4;
+	c->crm_mot0 = 1 << 3;
+	c->crm_mot1 = 1 << 7;
+	c->crm_dir  = 1 << 1;
+	c->crm_step = 1 << 0;
+	c->srm_trk0 = 1 << 4;
+	c->srm_dchg = 1 << 5;
+	c->srm_writ = 1 << 1;
+	c->io_sr    = c->iobase + 2;
+	c->io_mem   = c->iobase;
+	break;
+    case CATWEASEL_TYPE_MK3:
+	c->crm_sel0 = 1 << 2;
+	c->crm_sel1 = 1 << 3;
+	c->crm_mot0 = 1 << 1;
+	c->crm_mot1 = 1 << 5;
+	c->crm_dir  = 1 << 4;
+	c->crm_step = 1 << 7;
+	c->srm_trk0 = 1 << 2;
+	c->srm_dchg = 1 << 5;
+	c->srm_writ = 1 << 6;
+	c->srm_dskready = 1 << 4;
+	c->io_sr    = c->iobase + 0xe8;
+	c->io_mem   = c->iobase + 0xe0;
+	break;
+    default:
+	return;	
+    }
+
+    c->control_register = 255;
+
+    /* select all drives, step inside */
+    CWSetCReg(c, c->crm_dir | c->crm_sel0 | c->crm_sel1, 0);
+    for(i=0;i<2;i++) {
+	c->drives[i].number = i;
+	c->drives[i].contr = c;
+	c->drives[i].diskindrive = 0;
+	
+	/* select only the respective drive, step to track 0 */
+	if(i == 0) {
+	    CWSetCReg(c, c->crm_sel0, c->crm_dir | c->crm_sel1);
+	} else {
+	    CWSetCReg(c, c->crm_sel1, c->crm_dir | c->crm_sel0);
+	}
+
+	for(j = 0; j < 86 && (inb(c->io_sr) & c->srm_trk0); j++) {
+	    CWTriggerStep(c);
+	    sleep_millis(6);
+	}
+	
+	if(j < 86) {
+	    c->drives[i].type = 1;
+	    c->drives[i].track = 0;
+	} else {
+	    c->drives[i].type = 0;
+	}
+    }
+    c->drives[0].sel = c->crm_sel0;
+    c->drives[0].mot = c->crm_mot0;
+    c->drives[1].sel = c->crm_sel1;
+    c->drives[1].mot = c->crm_mot1;
+    CWSetCReg(c, 0, c->crm_sel0 | c->crm_sel1); /* deselect all drives */
+}
+
+void catweasel_free_controller(catweasel_contr *c)
+{
+    if(!c->iobase)
+	return;
+
+    /* all motors off, deselect all drives */
+    CWSetCReg(c, 0, c->crm_mot0 | c->crm_mot1 | c->crm_sel0 | c->crm_sel1);
+}
+
+void catweasel_set_motor(catweasel_drive *d, int on)
+{
+    CWSetCReg(d->contr, d->sel, 0);
+    if (on)
+	CWSetCReg(d->contr, d->mot, 0);
+    else
+	CWSetCReg(d->contr, 0, d->mot);
+    CWSetCReg(d->contr, 0, d->sel);
+}
+
+int catweasel_step(catweasel_drive *d, int dir)
+{
+    catweasel_contr *c = d->contr;
+    CWSetCReg(c, d->sel, 0);
+    if (dir > 0)
+	CWSetCReg(c, c->crm_dir, 0);
+    else
+	CWSetCReg(c, 0, c->crm_dir);
+    CWTriggerStep (c);
+    CWSetCReg(c, 0, d->sel);
+    d->track += dir > 0 ? 1 : -1;
+    return 1;
+}
+
+int catweasel_disk_changed(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = (inb(d->contr->io_sr) & d->contr->srm_dchg) ? 0 : 1;
+    CWSetCReg(d->contr, 0, d->sel);
+    return ret;
+}
+
+int catweasel_diskready(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = (inb(d->contr->io_sr) & d->contr->srm_dskready) ? 0 : 1;
+    CWSetCReg(d->contr, 0, d->sel);
+    return ret;
+}
+
+int catweasel_track0(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = (inb(d->contr->io_sr) & d->contr->srm_trk0) ? 0 : 1;
+    CWSetCReg(d->contr, 0, d->sel);
+    if (ret)
+	d->track = 0;
+    return ret;
+}
+
+int catweasel_write_protected(catweasel_drive *d)
+{
+    int ret;
+    CWSetCReg(d->contr, d->sel, 0);
+    ret = !(inb(d->contr->io_sr) & 8);
+    CWSetCReg(d->contr, 0, d->sel);
+    return ret;
+}
+
+uae_u8 catweasel_read_byte(catweasel_drive *d)
+{
+    return inb(d->contr->io_mem);
+}
+
+static const unsigned char amiga_thresholds[] = { 0x22, 0x30 }; // 27, 38 for 5.25"
+
+#define FLOPPY_WRITE_LEN 6250
+
+#define MFMMASK 0x55555555
+static uae_u32 getmfmlong (uae_u16 * mbuf)
+{
+	return (uae_u32)(((*mbuf << 16) | *(mbuf + 1)) & MFMMASK);
+}
+
+static int drive_write_adf_amigados (uae_u16 *mbuf, uae_u16 *mend, uae_u8 *writebuffer, int track)
+{
+	int i, secwritten = 0;
+	uae_u32 odd, even, chksum, id, dlong;
+	uae_u8 *secdata;
+	uae_u8 secbuf[544];
+	char sectable[22];
+	int num_sectors = 11;
+	int ec = 0;
+
+	memset (sectable, 0, sizeof (sectable));
+	mend -= (4 + 16 + 8 + 512);
+	while (secwritten < num_sectors) {
+		int trackoffs;
+
+		do {
+			while (*mbuf++ != 0x4489) {
+			    if (mbuf >= mend) {
+				ec = 1;
+				goto err;
+			    }
+			}
+		} while (*mbuf++ != 0x4489);
+
+		odd = getmfmlong (mbuf);
+		even = getmfmlong (mbuf + 2);
+		mbuf += 4;
+		id = (odd << 1) | even;
+
+		trackoffs = (id & 0xff00) >> 8;
+		if (trackoffs > 10) {
+		    ec = 2;
+		    goto err;
+		}
+		chksum = odd ^ even;
+		for (i = 0; i < 4; i++) {
+			odd = getmfmlong (mbuf);
+			even = getmfmlong (mbuf + 8);
+			mbuf += 2;
+
+			dlong = (odd << 1) | even;
+			if (dlong) {
+			    ec = 6;
+			    goto err;
+			}
+			chksum ^= odd ^ even;
+		} /* could check here if the label is nonstandard */
+		mbuf += 8;
+		odd = getmfmlong (mbuf);
+		even = getmfmlong (mbuf + 2);
+		mbuf += 4;
+		if (((odd << 1) | even) != chksum) {
+		    ec = 3;
+		    goto err;
+		}
+		odd = (id & 0x00ff0000) >> 16;
+		if (odd != track) {
+		    ec = 7;
+		    goto err;
+		}
+		odd = getmfmlong (mbuf);
+		even = getmfmlong (mbuf + 2);
+		mbuf += 4;
+		chksum = (odd << 1) | even;
+		secdata = secbuf + 32;
+		for (i = 0; i < 128; i++) {
+			odd = getmfmlong (mbuf);
+			even = getmfmlong (mbuf + 256);
+			mbuf += 2;
+			dlong = (odd << 1) | even;
+			*secdata++ = dlong >> 24;
+			*secdata++ = dlong >> 16;
+			*secdata++ = dlong >> 8;
+			*secdata++ = dlong;
+			chksum ^= odd ^ even;
+		}
+		mbuf += 256;
+		if (chksum) {
+		    ec = 4;
+		    goto err;
+		}
+		sectable[trackoffs] = 1;
+		secwritten++;
+		memcpy (writebuffer + trackoffs * 512, secbuf + 32, 512);
+	}
+	if (secwritten == 0 || secwritten < 0) {
+	    ec = 5;
+	    goto err;
+	}
+	return 0;
+err:
+	write_log ("mfm decode error %d. secwritten=%d\n", ec, secwritten);
+	for (i = 0; i < num_sectors; i++)
+	    write_log ("%d:%d ", i, sectable[i]);
+	write_log ("\n");
+	return ec;
+}
+
+static void mfmcode (uae_u16 * mfm, int words)
+{
+    uae_u32 lastword = 0;
+
+    while (words--) {
+	uae_u32 v = *mfm;
+	uae_u32 lv = (lastword << 16) | v;
+	uae_u32 nlv = 0x55555555 & ~lv;
+	uae_u32 mfmbits = (nlv << 1) & (nlv >> 1);
+
+	*mfm++ = v | mfmbits;
+	lastword = v;
+    }
+}
+
+#define FLOPPY_GAP_LEN 360
+
+static int amigados_mfmcode (uae_u8 *src, uae_u16 *dst, int num_secs, int track)
+{
+	int sec;
+	memset (dst, 0xaa, FLOPPY_GAP_LEN * 2);
+
+	for (sec = 0; sec < num_secs; sec++) {
+	    uae_u8 secbuf[544];
+	    int i;
+	    uae_u16 *mfmbuf = dst + 544 * sec + FLOPPY_GAP_LEN;
+	    uae_u32 deven, dodd;
+	    uae_u32 hck = 0, dck = 0;
+
+	    secbuf[0] = secbuf[1] = 0x00;
+	    secbuf[2] = secbuf[3] = 0xa1;
+	    secbuf[4] = 0xff;
+	    secbuf[5] = track;
+	    secbuf[6] = sec;
+	    secbuf[7] = num_secs - sec;
+
+	    for (i = 8; i < 24; i++)
+		secbuf[i] = 0;
+
+	    mfmbuf[0] = mfmbuf[1] = 0xaaaa;
+	    mfmbuf[2] = mfmbuf[3] = 0x4489;
+
+	    memcpy (secbuf + 32, src + sec * 512, 512);
+	    deven = ((secbuf[4] << 24) | (secbuf[5] << 16)
+		     | (secbuf[6] << 8) | (secbuf[7]));
+	    dodd = deven >> 1;
+	    deven &= 0x55555555;
+	    dodd &= 0x55555555;
+
+	    mfmbuf[4] = dodd >> 16;
+	    mfmbuf[5] = dodd;
+	    mfmbuf[6] = deven >> 16;
+	    mfmbuf[7] = deven;
+
+	    for (i = 8; i < 48; i++)
+		mfmbuf[i] = 0xaaaa;
+	    for (i = 0; i < 512; i += 4) {
+		deven = ((secbuf[i + 32] << 24) | (secbuf[i + 33] << 16)
+			 | (secbuf[i + 34] << 8) | (secbuf[i + 35]));
+		dodd = deven >> 1;
+		deven &= 0x55555555;
+		dodd &= 0x55555555;
+		mfmbuf[(i >> 1) + 32] = dodd >> 16;
+		mfmbuf[(i >> 1) + 33] = dodd;
+		mfmbuf[(i >> 1) + 256 + 32] = deven >> 16;
+		mfmbuf[(i >> 1) + 256 + 33] = deven;
+	    }
+
+	    for (i = 4; i < 24; i += 2)
+		hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
+
+	    deven = dodd = hck;
+	    dodd >>= 1;
+	    mfmbuf[24] = dodd >> 16;
+	    mfmbuf[25] = dodd;
+	    mfmbuf[26] = deven >> 16;
+	    mfmbuf[27] = deven;
+
+	    for (i = 32; i < 544; i += 2)
+		dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
+
+	    deven = dodd = dck;
+	    dodd >>= 1;
+	    mfmbuf[28] = dodd >> 16;
+	    mfmbuf[29] = dodd;
+	    mfmbuf[30] = deven >> 16;
+	    mfmbuf[31] = deven;
+	    mfmcode (mfmbuf + 4, 544 - 4);
+
+	}
+    return (num_secs * 544 + FLOPPY_GAP_LEN) * 2 * 8;
+}
+
+static uae_u16 amigamfmbuffer[LONGEST_TRACK];
+static uae_u8 amigabuffer[512*22];
+
+/* search and align to 0x4489 WORDSYNC markers */
+static int isamigatrack(uae_u8 *mfmdata, uae_u8 *mfmdatae, uae_u16 *mfmdst, int track)
+{
+	uae_u16 *dst = amigamfmbuffer;
+	int len;
+	int shift, syncshift, sync,ret;
+	uae_u32 l;
+	uae_u16 w;
+
+	sync = syncshift = shift = 0;
+	len = (mfmdatae - mfmdata) * 8;
+	if (len > LONGEST_TRACK * 8)
+	    len = LONGEST_TRACK * 8;
+	while (len--) {
+		l = (mfmdata[0] << 16) | (mfmdata[1] << 8) | (mfmdata[2] << 0);
+		w = l >> (8 - shift);
+		if (w == 0x4489) {
+			sync = 1;
+			syncshift = 0;
+		}
+		if (sync) {
+			if (syncshift == 0) *dst++ = w;
+			syncshift ++;
+			if (syncshift == 16) syncshift = 0;
+		}
+		shift++;
+		if (shift == 8) {
+			mfmdata++;
+			shift = 0;
+		}
+	}
+	if (sync) {
+		ret=drive_write_adf_amigados (amigamfmbuffer, dst, amigabuffer, track);
+		if(!ret)
+		    return amigados_mfmcode (amigabuffer, mfmdst, 11, track);
+		write_log ("decode error %d\n", ret);
+	} else {
+	    write_log ("decode error: no sync found\n");
+	}
+	return 0;
+}
+
+
+
+int catweasel_fillmfm (catweasel_drive *d, uae_u16 *mfm, int side, int clock, int rawmode)
+{
+    int i, j, oldsync, syncs[10], synccnt, endcnt;
+    uae_u32 tt1 = 0, tt2 = 0;
+    uae_u8 *p1;
+    int bytes = 0, bits = 0;
+    static int lasttrack, trycnt;
+
+    if (cwc.type == 0)
+	return 0;
+    if (d->contr->control_register & d->mot)
+	return 0;
+    if (!catweasel_read (d, side, 1, rawmode))
+	return 0;
+    if(d->contr->type == CATWEASEL_TYPE_MK1) {
+	inb(d->contr->iobase + 1);
+	inb(d->contr->io_mem); /* ignore first byte */
+    } else {
+	outb(0, d->contr->iobase + 0xe4);
+    }
+    catweasel_read_byte (d);
+    if (lasttrack == d->track)
+	trycnt++;
+    else
+	trycnt = 0;
+    lasttrack = d->track;
+    codec_init_threshtab(trycnt, amiga_thresholds);
+    i = 0; j = 0;
+    synccnt = 0;
+    oldsync = -1;
+    endcnt = 0;
+    while (j < LONGEST_TRACK * 4) {
+	uae_u8 b = catweasel_read_byte (d);
+	if (b >= 250) {
+	    if (b == 255 - endcnt) {
+		endcnt++;
+		if (endcnt == 5)
+		    break;
+	    } else
+		endcnt = 0;
+	}
+	if (rawmode) {
+	    if (b & 0x80) {
+		if (oldsync < j) {
+		    syncs[synccnt++] = j;
+		    oldsync = j + 300;
+		}
+	    }
+	    if (synccnt >= 3 && j > oldsync)
+		break;
+	}
+	b = threshtab[b & 0x7f];
+	tt1 = (tt1 << b) + 1;
+	tt2 += b;
+
+	if (tt2 >= 16) {
+	    tt2 -= 16;
+	    mfmbuf[j++] = tt1 >> (tt2 + 8);
+	    mfmbuf[j++] = tt1 >> tt2;
+	}
+	i++;
+    }
+    write_log ("cyl=%d, side=%d, length %d, syncs %d\n", d->track, side, j, synccnt);
+    if (rawmode) {
+	if (synccnt >= 3) {
+	    p1 = scantrack (mfmbuf + syncs[1], mfmbuf + syncs[2], &bytes, &bits);
+	    if (p1) {
+		j = 0;
+		for (i = 0; i < bytes + 2; i+=2) {
+		    mfm[j++] = (p1[i] << 8) | p1[i + 1];
+		}
+	        return bytes * 8 + bits;
+	    }
+	}
+    } else {
+	return isamigatrack (mfmbuf, mfmbuf + j, mfm, d->track * 2 + side);
+    }
+    return 0;
+}
+	
+int catweasel_read(catweasel_drive *d, int side, int clock, int rawmode)
+{
+    int iobase = d->contr->iobase;
+
+    CWSetCReg(d->contr, d->sel, 0);
+    if(d->contr->type == CATWEASEL_TYPE_MK1) {
+	CWSetCReg(d->contr, 1<<2, (!side)<<2); /* set disk side */
+
+	inb(iobase+1); /* ra reset */
+	outb(clock*128, iobase+3);
+
+	inb(iobase+1);
+	inb(iobase+0);
+//	inb(iobase+0);
+//	outb(0, iobase+3); /* don't store index pulse */
+
+	inb(iobase+1);
+
+	inb(iobase+7); /* start reading */
+	sleep_millis(rawmode ? 550 : 225);
+	outb(0, iobase+1); /* stop reading, don't reset RAM pointer */
+
+	outb(128, iobase+0); /* add data end mark */
+	outb(128, iobase+0);
+
+	inb(iobase+1); /* Reset RAM pointer */
+    } else {
+	CWSetCReg(d->contr, 1<<6, (!side)<<6); /* set disk side */
+
+	outb(0, iobase + 0xe4); /* Reset memory pointer */
+	switch(clock) {
+	case 0: /* 28MHz */
+	    outb(128, iobase + 0xec);
+	    break;
+	case 1: /* 14MHz */
+	    outb(0, iobase + 0xec);
+	    break;
+	}
+	inb(iobase + 0xe0);
+	inb(iobase + 0xe0);
+	outb(0, iobase + 0xec); /* no IRQs, no MFM predecode */
+	inb(iobase + 0xe0);
+	outb(0, iobase + 0xec); /* don't store index pulse */
+
+	outb(0, iobase + 0xe4); /* Reset memory pointer */
+	inb(iobase + 0xf0); /* start reading */
+	sleep_millis(rawmode ? 550 : 225);
+	inb(iobase + 0xe4); /* stop reading, don't reset RAM pointer */
+
+	outb(255, iobase + 0xe0); /* add data end mark */
+	outb(254, iobase + 0xe0); /* add data end mark */
+	outb(253, iobase + 0xe0); /* add data end mark */
+	outb(252, iobase + 0xe0); /* add data end mark */
+	outb(251, iobase + 0xe0); /* add data end mark */
+	outb(0, iobase + 0xe4); /* Reset memory pointer */
+    }
+    CWSetCReg(d->contr, 0, d->sel);
+    return 1;
+}
+
+#endif
\ No newline at end of file
diff --git a/cfgfile.c b/cfgfile.c
index 6e70ef3e..a7c13c83 100755
--- a/cfgfile.c
+++ b/cfgfile.c
@@ -2643,6 +2643,7 @@ int build_in_prefs (struct uae_prefs *p, int model, int config, int compa, int r
 	case 7:
 	v = bip_a500 (p, 3, compa, romcheck);
 	p->nr_floppies = 0;
+	p->chipset_mask = CSMASK_ECS_AGNUS;
 	p->dfxtype[0] = -1;
 	p->dfxtype[1] = -1;
 	break;
diff --git a/custom.c b/custom.c
index 12772c50..05b6302f 100755
--- a/custom.c
+++ b/custom.c
@@ -837,7 +837,7 @@ STATIC_INLINE void fetch (int nr, int fm)
     p = bplpt[nr] + bpl_off[nr];
     switch (fm) {
     case 0:
-	fetched[nr] = last_custom_value = chipmem_wget (p);
+	fetched[nr] = last_custom_value = chipmem_agnus_wget (p);
 	bplpt[nr] += 2;
 	break;
 #ifdef AGA
@@ -2381,6 +2381,10 @@ STATIC_INLINE uae_u16 DMACONR (void)
     decide_blitter (current_hpos ());
     v = dmacon | (bltstate == BLT_done ? 0 : 0x4000)
 	    | (blt_info.blitzero ? 0x2000 : 0);
+#if 0
+    if (!dmaen (DMA_BLITTER))
+	v &= ~0x4000;
+#endif
     return v;
 }
 STATIC_INLINE uae_u16 INTENAR (void)
@@ -3389,7 +3393,7 @@ static void predict_copper (void)
     if (state == COP_read2) {
 	w1 = cop_state.i1;
 	if (w1 & 1) {
-	    w2 = chipmem_wget (ip);
+	    w2 = chipmem_agnus_wget (ip);
 	    if (w2 & 1)
 		goto done;
 	    state = COP_wait;
@@ -3407,9 +3411,9 @@ static void predict_copper (void)
 
     while (c_hpos + 1 < maxhpos) {
 	if (state == COP_read1) {
-	    w1 = chipmem_wget (ip);
+	    w1 = chipmem_agnus_wget (ip);
 	    if (w1 & 1) {
-		w2 = chipmem_wget (ip + 2);
+		w2 = chipmem_agnus_wget (ip + 2);
 		if (w2 & 1)
 		    break;
 		state = COP_wait;
@@ -3635,7 +3639,7 @@ static void update_copper (int until_hpos)
 	case COP_read1:
 	    if (copper_cant_read (old_hpos))
 		continue;
-	    cop_state.i1 = chipmem_wget (cop_state.ip);
+	    cop_state.i1 = chipmem_agnus_wget (cop_state.ip);
 #ifdef CPUEMU_6
 	    cycle_line[old_hpos] |= CYCLE_COPPER;
 #endif
@@ -3649,7 +3653,7 @@ static void update_copper (int until_hpos)
 	case COP_read2:
 	    if (copper_cant_read (old_hpos))
 		continue;
-	    cop_state.i2 = chipmem_wget (cop_state.ip);
+	    cop_state.i2 = chipmem_agnus_wget (cop_state.ip);
 #ifdef CPUEMU_6
 	    cycle_line[old_hpos] |= CYCLE_COPPER;
 #endif
@@ -3771,18 +3775,18 @@ static void update_copper (int until_hpos)
 	    if ((vp1 > vcmp || (vp1 == vcmp && hp1 >= hcmp))
 		&& ((cop_state.saved_i2 & 0x8000) != 0 || ! (DMACONR() & 0x4000)))
 		cop_state.ignore_next = 1;
-	    if (chipmem_wget (cop_state.ip) & 1) { /* FIXME: HACK!!! */
+	    if (chipmem_agnus_wget (cop_state.ip) & 1) { /* FIXME: HACK!!! */
 		/* copper never skips if following instruction is WAIT or another SKIP... */
 		cop_state.ignore_next = 0;
 	    }
 
 	    cop_state.state = COP_read1;
 
-	    if (cop_state.ignore_next && (chipmem_wget (cop_state.ip) & 1) == 0) {
+	    if (cop_state.ignore_next && (chipmem_agnus_wget (cop_state.ip) & 1) == 0) {
 		/* another undocumented copper feature:
 		   copper stops if skipped instruction is MOVE to dangerous register...
 		*/
-		test_copper_dangerous (chipmem_wget(cop_state.ip));
+		test_copper_dangerous (chipmem_agnus_wget(cop_state.ip));
 	    }
 
 	    record_copper (cop_state.ip - 4, old_hpos, vpos);
@@ -3885,7 +3889,7 @@ STATIC_INLINE uae_u16 sprite_fetch (struct sprite *s, int dma, int hpos, int cyc
 {
     uae_u16 data = last_custom_value;
     if (dma) {
-        data = last_custom_value = chipmem_wget (s->pt);
+        data = last_custom_value = chipmem_agnus_wget (s->pt);
 #ifdef CPUEMU_6
 	cycle_line[hpos] |= CYCLE_SPRITE;
 #endif
diff --git a/enforcer.c b/enforcer.c
index 4dd8db46..461e6b47 100755
--- a/enforcer.c
+++ b/enforcer.c
@@ -27,7 +27,7 @@
 extern uae_u32 natmem_offset;
 
 int flashscreen = 0;
-static int enforcer_installed = 0;
+static int enforcer_installed = 0,enforcermode = 0;
 static int enforcer_hit = 0; /* set to 1 if displaying the hit */
 
 #define ENFORCER_BUF_SIZE 4096
@@ -182,16 +182,19 @@ static void enforcer_display_hit(const char *addressmode, uae_u32 pc, uaecptr ad
 	static int bestpc_idxs[INSTRUCTIONLINES/2];
 	char *enforcer_buf_ptr = enforcer_buf;
 	uaecptr bestpc,pospc,nextpc,temppc;
-
+   
 	if (enforcer_hit) return; /* our function itself generated a hit ;), avoid endless loop */
 	enforcer_hit = 1;
 
 	if (!(sysbase = get_long(4))) return;
 	if (!(this_task = get_long(sysbase + 276))) return;
-
+    
 	task_name = get_long(this_task + 10); /* ln_Name */
 	native_task_name = amiga2native(task_name,100);
-
+	/*if (strcmp(native_task_name,"c:MCP")!=0)
+	{
+		Exception (0x2d,0);
+	}*/
 	strcpy(enforcer_buf_ptr,"Enforcer Hit! Bad program\n");
 	enforcer_buf_ptr += strlen(enforcer_buf_ptr);
 
@@ -368,8 +371,13 @@ uae_u32 REGPARAM2 chipmem_lget2 (uaecptr addr)
     m = (uae_u32 *)(chipmemory + addr);
 	
 	if (ISILLEGAL(addr))
+		{
 		enforcer_display_hit("LONG READ from",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
-
+        if (enforcermode==1)
+			{
+			set_special (SPCFLAG_TRAP);
+			}	
+		}
     return do_get_mem_long (m);
 }
 
@@ -382,8 +390,13 @@ uae_u32 REGPARAM2 chipmem_wget2(uaecptr addr)
     m = (uae_u16 *)(chipmemory + addr);
 
 	if (ISILLEGAL(addr))
+	{	
 		enforcer_display_hit("WORD READ from",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
-
+        if (enforcermode==1)
+			{
+			set_special (SPCFLAG_TRAP);
+			}		
+	}
     return do_get_mem_word (m);
 }
 
@@ -393,8 +406,14 @@ uae_u32 REGPARAM2 chipmem_bget2 (uaecptr addr)
     addr &= chipmem_mask;
 
 	if (ISILLEGAL(addr))
+	{
 		enforcer_display_hit("BYTE READ from",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
-
+		if (enforcermode==1)
+		{
+		set_special (SPCFLAG_TRAP);				
+		}
+	}
+	
     return chipmemory[addr];
 }
 
@@ -407,8 +426,13 @@ void REGPARAM2 chipmem_lput2 (uaecptr addr, uae_u32 l)
     m = (uae_u32 *)(chipmemory + addr);
 
 	if (ISILLEGAL(addr))
+	{
 		enforcer_display_hit("LONG WRITE to",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
-
+		if (enforcermode==1)
+		{
+		if ( addr!=0x100 ) set_special (SPCFLAG_TRAP);
+  		}
+	}
     do_put_mem_long (m, l);
 }
 
@@ -421,8 +445,13 @@ void REGPARAM2 chipmem_wput2 (uaecptr addr, uae_u32 w)
     m = (uae_u16 *)(chipmemory + addr);
 
 	if (ISILLEGAL(addr))
+	{
 		enforcer_display_hit("WORD WRITE to",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
-   
+	if (enforcermode==1)
+	{
+		set_special (SPCFLAG_TRAP);
+	}
+	}
     do_put_mem_word (m, w);
 }
 
@@ -433,8 +462,14 @@ void REGPARAM2 chipmem_bput2 (uaecptr addr, uae_u32 b)
     addr &= chipmem_mask;
 
 	if (ISILLEGAL(addr))
+	{
 		enforcer_display_hit("BYTE WRITE to",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
-    chipmemory[addr] = b;
+		chipmemory[addr] = b;
+			if (enforcermode==1)
+			{
+			set_special (SPCFLAG_TRAP);	
+			}
+	}
 }
 
 int REGPARAM2 chipmem_check2 (uaecptr addr, uae_u32 size)
@@ -455,6 +490,11 @@ uae_u32 REGPARAM2 dummy_lget2 (uaecptr addr)
 {
     special_mem |= S_READ;
 	enforcer_display_hit("LONG READ from",(uae_u32)(regs.pc_p - NATMEM_OFFSET), addr);
+	if (enforcermode==1)
+	{
+		set_special (SPCFLAG_TRAP);
+		return 0;
+	}
 	return 0xbadedeef;
 }
 
@@ -479,6 +519,11 @@ uae_u32 REGPARAM2 dummy_wget2 (uaecptr addr)
 	}
 #endif
 	enforcer_display_hit("WORD READ from",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
+	if (enforcermode==1)
+	{
+			set_special (SPCFLAG_TRAP);
+			return 0;
+	}
 	return 0xbadf;
 }
 
@@ -486,6 +531,11 @@ uae_u32 REGPARAM2 dummy_bget2 (uaecptr addr)
 {
     special_mem |= S_READ;
 	enforcer_display_hit("BYTE READ from",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
+	if (enforcermode==1)
+	{
+		set_special (SPCFLAG_TRAP);
+		return 0;
+	}
 	return 0xbadedeef;
 }
 
@@ -493,18 +543,33 @@ void REGPARAM2 dummy_lput2 (uaecptr addr, uae_u32 l)
 {
     special_mem |= S_WRITE;
 	enforcer_display_hit("LONG WRITE to",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
+    if (enforcermode==1)
+	{
+	    set_special (SPCFLAG_TRAP);
+		return;
+	}
 }
 
 void REGPARAM2 dummy_wput2 (uaecptr addr, uae_u32 w)
 {
     special_mem |= S_WRITE;
 	enforcer_display_hit("WORD WRITE to",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
+    if (enforcermode==1)
+	{
+		set_special (SPCFLAG_TRAP);
+		return;
+	}
 }
 
 void REGPARAM2 dummy_bput2 (uaecptr addr, uae_u32 b)
 {
     special_mem |= S_WRITE;
 	enforcer_display_hit("BYTE WRITE to",(uae_u32)(regs.pc_p - NATMEM_OFFSET),addr);
+	if (enforcermode==1)
+	{
+		set_special (SPCFLAG_TRAP);
+		return;
+	}
 }
 
 int REGPARAM2 dummy_check2 (uaecptr addr, uae_u32 size)
@@ -520,10 +585,10 @@ int REGPARAM2 dummy_check2 (uaecptr addr, uae_u32 size)
  exceptions so enforcer can use it. Returns 1 if enforcer
  is enabled
 *************************************************************/
-int enforcer_enable(void)
+int enforcer_enable(int enfmode)
 {
 	extern addrbank chipmem_bank,dummy_bank;
-
+    enforcermode=enfmode;
 	if (!enforcer_installed)
 	{
 		saved_dummy_lget = dummy_bank.lget;
diff --git a/expansion.c b/expansion.c
index 8deb712e..1966b747 100755
--- a/expansion.c
+++ b/expansion.c
@@ -312,7 +312,7 @@ static void REGPARAM2 expamem_bput (uaecptr addr, uae_u32 value)
 	break;
 
      case 0x4c:
-	write_log ("   Card %d (Zorro %s) had no success.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III");
+	write_log ("   Card %d (Zorro%s) had no success.\n", ecard + 1, expamem_type() == 0xc0 ? "II" : "III");
 	++ecard;
 	if (ecard < MAX_EXPANSION_BOARDS)
 	    (*card_init[ecard]) ();
@@ -1162,6 +1162,8 @@ void expamem_reset (void)
 
 #ifdef ARCADIA
     if (arcadia_rom) {
+	arcadiaboot = mapped_malloc (0x10000, "arcadia");
+	arcadia_bank.baseaddr = arcadiaboot;    
 	card_init[cardno] = expamem_init_arcadia;
 	card_map[cardno++] = expamem_map_arcadia;
     }
@@ -1170,12 +1172,12 @@ void expamem_reset (void)
 	card_init[cardno] = expamem_init_fastcard;
 	card_map[cardno++] = expamem_map_fastcard;
     }
-    if (z3fastmem != NULL) {
+    if (z3fastmem != NULL && kickstart_version >= 36) {
 	card_init[cardno] = expamem_init_z3fastmem;
 	card_map[cardno++] = expamem_map_z3fastmem;
     }
 #ifdef PICASSO96
-    if (gfxmemory != NULL) {
+    if (gfxmemory != NULL && kickstart_version >= 36) {
 	card_init[cardno] = expamem_init_gfxcard;
 	card_map[cardno++] = expamem_map_gfxcard;
     }
@@ -1224,10 +1226,6 @@ void expansion_init (void)
 	exit (0);
     }
     filesys_bank.baseaddr = (uae_u8*)filesysory;
-#ifdef ARCADIA
-    arcadiaboot = mapped_malloc (0x10000, "arcadia");
-    arcadia_bank.baseaddr = arcadiaboot;    
-#endif
 }
 
 void expansion_cleanup (void)
diff --git a/filesys.c b/filesys.c
index 7ac480bb..25f96dbf 100755
--- a/filesys.c
+++ b/filesys.c
@@ -200,7 +200,8 @@ char *get_filesys_unit (struct uaedev_mount_info *mountinfo, int nr,
     *blocksize = uip->hf.blocksize;
     *size = uip->hf.size;
     *bootpri = uip->bootpri;
-    *flags = uip->automounted ? FILESYS_FLAG_DONOTSAVE : 0;
+    if (flags)
+	*flags = uip->automounted ? FILESYS_FLAG_DONOTSAVE : 0;
     if (filesysdir)
 	*filesysdir = uip->filesysdir ? my_strdup (uip->filesysdir) : 0;
     return 0;
@@ -1744,7 +1745,7 @@ action_lock (Unit *unit, dpacket packet)
     uae_u32 err;
 
     if (mode != SHARED_LOCK && mode != EXCLUSIVE_LOCK) {
-	TRACE(("Bad mode.\n"));
+	TRACE(("Bad mode %d (should be %d or %d).\n", mode, SHARED_LOCK, EXCLUSIVE_LOCK));
 	mode = SHARED_LOCK;
     }
 
@@ -2763,9 +2764,10 @@ action_parent (Unit *unit, dpacket packet)
     if (!lock) {
 	PUT_PCK_RES1 (packet, 0);
 	PUT_PCK_RES2 (packet, 0);
-	return;
+    } else {
+	action_parent_common (unit, packet, get_long (lock + 4));
     }
-    action_parent_common (unit, packet, get_long (lock + 4));
+    TRACE(("=%x %d\n", GET_PCK_RES1 (packet), GET_PCK_RES2 (packet)));
 }
 
 static void
@@ -3210,10 +3212,18 @@ static uae_u32 exter_int_helper (void)
 	    unit->cmds_complete = unit->cmds_acked;
 	    while (comm_pipe_has_data (unit->ui.back_pipe)) {
 		uaecptr locks, lockend;
+		int cnt = 0;
 		locks = read_comm_pipe_int_blocking (unit->ui.back_pipe);
 		lockend = locks;
-		while (get_long (lockend) != 0)
+		while (get_long (lockend) != 0) {
+		    if (get_long (lockend) == lockend) {
+			write_log ("filesystem lock queue corrupted!\n");
+			break;
+		    }
 		    lockend = get_long (lockend);
+		    cnt++;
+		}
+		TRACE(("%d %x %x %x\n", cnt, locks, lockend, m68k_areg (regs, 3)));
 		put_long (lockend, get_long (m68k_areg (regs, 3)));
 		put_long (m68k_areg (regs, 3), locks);
 	    }
diff --git a/genblitter.c b/genblitter.c
index 0cb3204c..c019395d 100755
--- a/genblitter.c
+++ b/genblitter.c
@@ -97,15 +97,15 @@ static void generate_func(void)
 	printf("uaecptr dstp = 0;\n");
 	printf("for (j = 0; j < b->vblitsize; j++) {\n");
 	printf("\tfor (i = 0; i < b->hblitsize; i++) {\n\t\tuae_u32 bltadat, srca;\n\n");
-	if (c_is_on) printf("\t\tif (ptc) { srcc = chipmem_wget (ptc); ptc += 2; }\n");
-	if (b_is_on) printf("\t\tif (ptb) {\n\t\t\tuae_u32 bltbdat = blt_info.bltbdat = chipmem_wget (ptb); ptb += 2;\n");
+	if (c_is_on) printf("\t\tif (ptc) { srcc = chipmem_agnus_wget (ptc); ptc += 2; }\n");
+	if (b_is_on) printf("\t\tif (ptb) {\n\t\t\tuae_u32 bltbdat = blt_info.bltbdat = chipmem_agnus_wget (ptb); ptb += 2;\n");
 	if (b_is_on) printf("\t\t\tsrcb = (((uae_u32)prevb << 16) | bltbdat) >> b->blitbshift;\n");
 	if (b_is_on) printf("\t\t\tprevb = bltbdat;\n\t\t}\n");
-	if (a_is_on) printf("\t\tif (pta) { bltadat = blt_info.bltadat = chipmem_wget (pta); pta += 2; } else { bltadat = blt_info.bltadat; }\n");
+	if (a_is_on) printf("\t\tif (pta) { bltadat = blt_info.bltadat = chipmem_agnus_wget (pta); pta += 2; } else { bltadat = blt_info.bltadat; }\n");
 	if (a_is_on) printf("\t\tbltadat &= blit_masktable[i];\n");
 	if (a_is_on) printf("\t\tsrca = (((uae_u32)preva << 16) | bltadat) >> b->blitashift;\n");
 	if (a_is_on) printf("\t\tpreva = bltadat;\n");
-	printf("\t\tif (dstp) chipmem_wput (dstp, dstd);\n");
+	printf("\t\tif (dstp) chipmem_agnus_wput (dstp, dstd);\n");
 	printf("\t\tdstd = (%s) & 0xFFFF;\n", blitops[blttbl[i]].s);
 	printf("\t\ttotald |= dstd;\n");
 	printf("\t\tif (ptd) { dstp = ptd; ptd += 2; }\n");
@@ -117,7 +117,7 @@ static void generate_func(void)
 	printf("}\n");
 	if (b_is_on) printf("b->bltbhold = srcb;\n");
 	printf("b->bltcdat = srcc;\n");
-	printf("\t\tif (dstp) chipmem_wput (dstp, dstd);\n");
+	printf("\t\tif (dstp) chipmem_agnus_wput (dstp, dstd);\n");
 #if 0
 	printf("}\n");
 #endif
@@ -174,15 +174,15 @@ static void generate_func(void)
 	printf("uaecptr dstp = 0;\n");
 	printf("for (j = 0; j < b->vblitsize; j++) {\n");
 	printf("\tfor (i = 0; i < b->hblitsize; i++) {\n\t\tuae_u32 bltadat, srca;\n");
-	if (c_is_on) printf("\t\tif (ptc) { srcc = chipmem_wget (ptc); ptc -= 2; }\n");
-	if (b_is_on) printf("\t\tif (ptb) {\n\t\t\tuae_u32 bltbdat = blt_info.bltbdat = chipmem_wget (ptb); ptb -= 2;\n");
+	if (c_is_on) printf("\t\tif (ptc) { srcc = chipmem_agnus_wget (ptc); ptc -= 2; }\n");
+	if (b_is_on) printf("\t\tif (ptb) {\n\t\t\tuae_u32 bltbdat = blt_info.bltbdat = chipmem_agnus_wget (ptb); ptb -= 2;\n");
 	if (b_is_on) printf("\t\t\tsrcb = ((bltbdat << 16) | prevb) >> b->blitdownbshift;\n");
 	if (b_is_on) printf("\t\t\tprevb = bltbdat;\n\t\t}\n");
-	if (a_is_on) printf("\t\tif (pta) { bltadat = blt_info.bltadat = chipmem_wget (pta); pta -= 2; } else { bltadat = blt_info.bltadat; }\n");
+	if (a_is_on) printf("\t\tif (pta) { bltadat = blt_info.bltadat = chipmem_agnus_wget (pta); pta -= 2; } else { bltadat = blt_info.bltadat; }\n");
 	if (a_is_on) printf("\t\tbltadat &= blit_masktable[i];\n");
 	if (a_is_on) printf("\t\tsrca = (((uae_u32)bltadat << 16) | preva) >> b->blitdownashift;\n");
 	if (a_is_on) printf("\t\tpreva = bltadat;\n");
-	printf("\t\tif (dstp) chipmem_wput (dstp, dstd);\n");
+	printf("\t\tif (dstp) chipmem_agnus_wput (dstp, dstd);\n");
 	printf("\t\tdstd = (%s) & 0xFFFF;\n", blitops[blttbl[i]].s);
 	printf("\t\ttotald |= dstd;\n");
 	printf("\t\tif (ptd) { dstp = ptd; ptd -= 2; }\n");
@@ -194,7 +194,7 @@ static void generate_func(void)
 	printf("}\n");
 	if (b_is_on) printf("b->bltbhold = srcb;\n");
 	printf("b->bltcdat = srcc;\n");
-	printf("\t\tif (dstp) chipmem_wput (dstp, dstd);\n");
+	printf("\t\tif (dstp) chipmem_agnus_wput (dstp, dstd);\n");
 #if 0
 	printf("}\n");
 #endif
diff --git a/include/catweasel.h b/include/catweasel.h
index 848221ef..29c5de0c 100755
--- a/include/catweasel.h
+++ b/include/catweasel.h
@@ -44,6 +44,7 @@ typedef struct catweasel_contr {
 #define CATWEASEL_TYPE_NONE  -1
 #define CATWEASEL_TYPE_MK1    1
 #define CATWEASEL_TYPE_MK3    3
+#define CATWEASEL_TYPE_MK4    4
 
 /* Initialize a Catweasel controller; c->iobase and c->msdelay must have
    been initialized -- msdelay might be used */
diff --git a/include/custom.h b/include/custom.h
index 20816f1c..3f4f526a 100755
--- a/include/custom.h
+++ b/include/custom.h
@@ -62,6 +62,7 @@ STATIC_INLINE int dmaen (unsigned int dmamask)
 #define SPCFLAG_BLTNASTY 512
 #define SPCFLAG_EXEC 1024
 #define SPCFLAG_ACTION_REPLAY 2048
+#define SPCFLAG_TRAP 4096 /* enforcer-hack */
 #define SPCFLAG_MODE_CHANGE 8192
 #define SPCFLAG_END_COMPILE 16384
 
diff --git a/include/memory.h b/include/memory.h
index 0c1cb86a..f0ceb0f1 100755
--- a/include/memory.h
+++ b/include/memory.h
@@ -81,6 +81,7 @@ extern uae_u8 *filesysory;
 extern uae_u8 *rtarea;
 
 extern addrbank chipmem_bank;
+extern addrbank chipmem_agnus_bank;
 extern addrbank chipmem_bank_ce2;
 extern addrbank kickmem_bank;
 extern addrbank custom_bank;
@@ -200,6 +201,13 @@ extern void chipmem_lput (uaecptr, uae_u32) REGPARAM;
 extern void chipmem_wput (uaecptr, uae_u32) REGPARAM;
 extern void chipmem_bput (uaecptr, uae_u32) REGPARAM;
 
+extern uae_u32 chipmem_agnus_lget (uaecptr) REGPARAM;
+extern uae_u32 chipmem_agnus_wget (uaecptr) REGPARAM;
+extern uae_u32 chipmem_agnus_bget (uaecptr) REGPARAM;
+extern void chipmem_agnus_lput (uaecptr, uae_u32) REGPARAM;
+extern void chipmem_agnus_wput (uaecptr, uae_u32) REGPARAM;
+extern void chipmem_agnus_bput (uaecptr, uae_u32) REGPARAM;
+
 extern uae_u32 chipmem_mask, kickmem_mask;
 extern uae_u8 *kickmemory;
 extern int kickmem_size;
diff --git a/include/options.h b/include/options.h
index 96143c53..50c7e8fc 100755
--- a/include/options.h
+++ b/include/options.h
@@ -219,6 +219,7 @@ struct uae_prefs {
     int win32_midiindev;
     int win32_aspi;
     int win32_soundcard;
+    int win32_norecyclebin;
 
     int curses_reverse_video;
 
diff --git a/inputdevice.c b/inputdevice.c
index a828129d..867c8d76 100755
--- a/inputdevice.c
+++ b/inputdevice.c
@@ -82,7 +82,7 @@ struct inputevent {
 #define AM_AF 32 /* supports autofire */
 #define AM_INFO 64 /* information data for gui */
 #define AM_DUMMY 128 /* placeholder */
-#define AM_K (AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF) /* keyboard */
+#define AM_K (AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF) /* generic button/switch */
 
 /* event flags */
 #define ID_FLAG_AUTOFIRE 1
diff --git a/inputevents.def b/inputevents.def
index 21e13c68..678a90ea 100755
--- a/inputevents.def
+++ b/inputevents.def
@@ -22,25 +22,25 @@ DEFEVENT(JOY1_VERT,"Joy1 Vertical",AM_JOY_AXIS,0,1,DIR_UP|DIR_DOWN)
 DEFEVENT(JOY1_HORIZ_POT,"Joy1 Horizontal (Analog)",AM_JOY_AXIS,64,1,0)
 DEFEVENT(JOY1_VERT_POT,"Joy1 Vertical (Analog)",AM_JOY_AXIS,64,1,1)
 
-DEFEVENT(JOY1_LEFT,"Joy1 Left",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_LEFT)
-DEFEVENT(JOY1_RIGHT,"Joy1 Right",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_RIGHT)
-DEFEVENT(JOY1_UP,"Joy1 Up",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_UP)
-DEFEVENT(JOY1_DOWN,"Joy1 Down",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_DOWN)
-DEFEVENT(JOY1_LEFT_UP,"Joy1 Left+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_LEFT|DIR_UP)
-DEFEVENT(JOY1_LEFT_DOWN,"Joy1 Left+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_LEFT|DIR_DOWN)
-DEFEVENT(JOY1_RIGHT_UP,"Joy1 Right+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_RIGHT|DIR_UP)
-DEFEVENT(JOY1_RIGHT_DOWN,"Joy1 Right+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,1,DIR_RIGHT|DIR_DOWN)
-
-DEFEVENT(JOY1_FIRE_BUTTON,"Joy1 Fire/Mouse1 Left Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_1)
-DEFEVENT(JOY1_2ND_BUTTON,"Joy1 2nd Button/Mouse1 Right Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_2)
-DEFEVENT(JOY1_3RD_BUTTON,"Joy1 3rd Button/Mouse1 Middle Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_3)
-DEFEVENT(JOY1_CD32_PLAY,"Joy1 CD32 Play",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_PLAY)
-DEFEVENT(JOY1_CD32_RWD,"Joy1 CD32 RWD",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_RWD)
-DEFEVENT(JOY1_CD32_FFW,"Joy1 CD32 FFW",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_FFW)
-DEFEVENT(JOY1_CD32_GREEN,"Joy1 CD32 Green",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_GREEN)
-DEFEVENT(JOY1_CD32_YELLOW,"Joy1 CD32 Yellow",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_YELLOW)
-DEFEVENT(JOY1_CD32_RED,"Joy1 CD32 Red",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_RED)
-DEFEVENT(JOY1_CD32_BLUE,"Joy1 CD32 Blue",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,1,JOYBUTTON_CD32_BLUE)
+DEFEVENT(JOY1_LEFT,"Joy1 Left",AM_K,16,1,DIR_LEFT)
+DEFEVENT(JOY1_RIGHT,"Joy1 Right",AM_K,16,1,DIR_RIGHT)
+DEFEVENT(JOY1_UP,"Joy1 Up",AM_K,16,1,DIR_UP)
+DEFEVENT(JOY1_DOWN,"Joy1 Down",AM_K,16,1,DIR_DOWN)
+DEFEVENT(JOY1_LEFT_UP,"Joy1 Left+Up",AM_K,16,1,DIR_LEFT|DIR_UP)
+DEFEVENT(JOY1_LEFT_DOWN,"Joy1 Left+Down",AM_K,16,1,DIR_LEFT|DIR_DOWN)
+DEFEVENT(JOY1_RIGHT_UP,"Joy1 Right+Up",AM_K,16,1,DIR_RIGHT|DIR_UP)
+DEFEVENT(JOY1_RIGHT_DOWN,"Joy1 Right+Down",AM_K,16,1,DIR_RIGHT|DIR_DOWN)
+
+DEFEVENT(JOY1_FIRE_BUTTON,"Joy1 Fire/Mouse1 Left Button",AM_K,4,1,JOYBUTTON_1)
+DEFEVENT(JOY1_2ND_BUTTON,"Joy1 2nd Button/Mouse1 Right Button",AM_K,4,1,JOYBUTTON_2)
+DEFEVENT(JOY1_3RD_BUTTON,"Joy1 3rd Button/Mouse1 Middle Button",AM_K,4,1,JOYBUTTON_3)
+DEFEVENT(JOY1_CD32_PLAY,"Joy1 CD32 Play",AM_K,4,1,JOYBUTTON_CD32_PLAY)
+DEFEVENT(JOY1_CD32_RWD,"Joy1 CD32 RWD",AM_K,4,1,JOYBUTTON_CD32_RWD)
+DEFEVENT(JOY1_CD32_FFW,"Joy1 CD32 FFW",AM_K,4,1,JOYBUTTON_CD32_FFW)
+DEFEVENT(JOY1_CD32_GREEN,"Joy1 CD32 Green",AM_K,4,1,JOYBUTTON_CD32_GREEN)
+DEFEVENT(JOY1_CD32_YELLOW,"Joy1 CD32 Yellow",AM_K,4,1,JOYBUTTON_CD32_YELLOW)
+DEFEVENT(JOY1_CD32_RED,"Joy1 CD32 Red",AM_K,4,1,JOYBUTTON_CD32_RED)
+DEFEVENT(JOY1_CD32_BLUE,"Joy1 CD32 Blue",AM_K,4,1,JOYBUTTON_CD32_BLUE)
 
 /* joystick/mouse port 2 */
 
@@ -63,25 +63,25 @@ DEFEVENT(JOY2_VERT,"Joy2 Vertical",AM_JOY_AXIS,0,2,DIR_UP|DIR_DOWN)
 DEFEVENT(JOY2_HORIZ_POT,"Joy2 Horizontal (Analog)",AM_JOY_AXIS,64,2,0)
 DEFEVENT(JOY2_VERT_POT,"Joy2 Vertical (Analog)",AM_JOY_AXIS,64,2,1)
 
-DEFEVENT(JOY2_LEFT,"Joy2 Left",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_LEFT)
-DEFEVENT(JOY2_RIGHT,"Joy2 Right",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_RIGHT)
-DEFEVENT(JOY2_UP,"Joy2 Up",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_UP)
-DEFEVENT(JOY2_DOWN,"Joy2 Down",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_DOWN)
-DEFEVENT(JOY2_LEFT_UP,"Joy2 Left+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_LEFT|DIR_UP)
-DEFEVENT(JOY2_LEFT_DOWN,"Joy2 Left+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_LEFT|DIR_DOWN)
-DEFEVENT(JOY2_RIGHT_UP,"Joy2 Right+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_RIGHT|DIR_UP)
-DEFEVENT(JOY2_RIGHT_DOWN,"Joy2 Right+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,2,DIR_RIGHT|DIR_DOWN)
-
-DEFEVENT(JOY2_FIRE_BUTTON,"Joy2 Fire/Mouse1 Left Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_1)
-DEFEVENT(JOY2_2ND_BUTTON,"Joy2 2nd Button/Mouse1 Right Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_2)
-DEFEVENT(JOY2_3RD_BUTTON,"Joy2 3rd Button/Mouse1 Middle Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_3)
-DEFEVENT(JOY2_CD32_PLAY,"Joy2 CD32 Play",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_PLAY)
-DEFEVENT(JOY2_CD32_RWD,"Joy2 CD32 RWD",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_RWD)
-DEFEVENT(JOY2_CD32_FFW,"Joy2 CD32 FFW",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_FFW)
-DEFEVENT(JOY2_CD32_GREEN,"Joy2 CD32 Green",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_GREEN)
-DEFEVENT(JOY2_CD32_YELLOW,"Joy2 CD32 Yellow",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_YELLOW)
-DEFEVENT(JOY2_CD32_RED,"Joy2 CD32 Red",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_RED)
-DEFEVENT(JOY2_CD32_BLUE,"Joy2 CD32 Blue",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,2,JOYBUTTON_CD32_BLUE)
+DEFEVENT(JOY2_LEFT,"Joy2 Left",AM_K,16,2,DIR_LEFT)
+DEFEVENT(JOY2_RIGHT,"Joy2 Right",AM_K,16,2,DIR_RIGHT)
+DEFEVENT(JOY2_UP,"Joy2 Up",AM_K,16,2,DIR_UP)
+DEFEVENT(JOY2_DOWN,"Joy2 Down",AM_K,16,2,DIR_DOWN)
+DEFEVENT(JOY2_LEFT_UP,"Joy2 Left+Up",AM_K,16,2,DIR_LEFT|DIR_UP)
+DEFEVENT(JOY2_LEFT_DOWN,"Joy2 Left+Down",AM_K,16,2,DIR_LEFT|DIR_DOWN)
+DEFEVENT(JOY2_RIGHT_UP,"Joy2 Right+Up",AM_K,16,2,DIR_RIGHT|DIR_UP)
+DEFEVENT(JOY2_RIGHT_DOWN,"Joy2 Right+Down",AM_K,16,2,DIR_RIGHT|DIR_DOWN)
+
+DEFEVENT(JOY2_FIRE_BUTTON,"Joy2 Fire/Mouse1 Left Button",AM_K,4,2,JOYBUTTON_1)
+DEFEVENT(JOY2_2ND_BUTTON,"Joy2 2nd Button/Mouse1 Right Button",AM_K,4,2,JOYBUTTON_2)
+DEFEVENT(JOY2_3RD_BUTTON,"Joy2 3rd Button/Mouse1 Middle Button",AM_K,4,2,JOYBUTTON_3)
+DEFEVENT(JOY2_CD32_PLAY,"Joy2 CD32 Play",AM_K,4,2,JOYBUTTON_CD32_PLAY)
+DEFEVENT(JOY2_CD32_RWD,"Joy2 CD32 RWD",AM_K,4,2,JOYBUTTON_CD32_RWD)
+DEFEVENT(JOY2_CD32_FFW,"Joy2 CD32 FFW",AM_K,4,2,JOYBUTTON_CD32_FFW)
+DEFEVENT(JOY2_CD32_GREEN,"Joy2 CD32 Green",AM_K,4,2,JOYBUTTON_CD32_GREEN)
+DEFEVENT(JOY2_CD32_YELLOW,"Joy2 CD32 Yellow",AM_K,4,2,JOYBUTTON_CD32_YELLOW)
+DEFEVENT(JOY2_CD32_RED,"Joy2 CD32 Red",AM_K,4,2,JOYBUTTON_CD32_RED)
+DEFEVENT(JOY2_CD32_BLUE,"Joy2 CD32 Blue",AM_K,4,2,JOYBUTTON_CD32_BLUE)
 
 /* parallel port joystick adapter */
 
@@ -89,29 +89,29 @@ DEFEVENT(PAR_JOY1_START, "Parallel port joystick adapter", AM_INFO, 0,3,0)
 
 DEFEVENT(PAR_JOY1_HORIZ,"Parallel Joy1 Horizontal",AM_JOY_AXIS,0,3,DIR_LEFT|DIR_RIGHT)
 DEFEVENT(PAR_JOY1_VERT,"Parallel Joy1 Vertical",AM_JOY_AXIS,0,3,DIR_UP|DIR_DOWN)
-DEFEVENT(PAR_JOY1_LEFT,"Parallel Joy1 Left",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_LEFT)
-DEFEVENT(PAR_JOY1_RIGHT,"Parallel Joy1 Right",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_RIGHT)
-DEFEVENT(PAR_JOY1_UP,"Parallel Joy1 Up",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_UP)
-DEFEVENT(PAR_JOY1_DOWN,"Parallel Joy1 Down",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_DOWN)
-DEFEVENT(PAR_JOY1_LEFT_UP,"Parallel Joy1 Left+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_LEFT|DIR_UP)
-DEFEVENT(PAR_JOY1_LEFT_DOWN,"Parallel Joy1 Left+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_LEFT|DIR_DOWN)
-DEFEVENT(PAR_JOY1_RIGHT_UP,"Parallel Joy1 Right+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_RIGHT|DIR_UP)
-DEFEVENT(PAR_JOY1_RIGHT_DOWN,"Parallel Joy1 Right+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,3,DIR_RIGHT|DIR_DOWN)
-DEFEVENT(PAR_JOY1_FIRE_BUTTON,"Parallel Joy1 Fire Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,3,JOYBUTTON_1)
+DEFEVENT(PAR_JOY1_LEFT,"Parallel Joy1 Left",AM_K,16,3,DIR_LEFT)
+DEFEVENT(PAR_JOY1_RIGHT,"Parallel Joy1 Right",AM_K,16,3,DIR_RIGHT)
+DEFEVENT(PAR_JOY1_UP,"Parallel Joy1 Up",AM_K,16,3,DIR_UP)
+DEFEVENT(PAR_JOY1_DOWN,"Parallel Joy1 Down",AM_K,16,3,DIR_DOWN)
+DEFEVENT(PAR_JOY1_LEFT_UP,"Parallel Joy1 Left+Up",AM_K,16,3,DIR_LEFT|DIR_UP)
+DEFEVENT(PAR_JOY1_LEFT_DOWN,"Parallel Joy1 Left+Down",AM_K,16,3,DIR_LEFT|DIR_DOWN)
+DEFEVENT(PAR_JOY1_RIGHT_UP,"Parallel Joy1 Right+Up",AM_K,16,3,DIR_RIGHT|DIR_UP)
+DEFEVENT(PAR_JOY1_RIGHT_DOWN,"Parallel Joy1 Right+Down",AM_K,16,3,DIR_RIGHT|DIR_DOWN)
+DEFEVENT(PAR_JOY1_FIRE_BUTTON,"Parallel Joy1 Fire Button",AM_K,4,3,JOYBUTTON_1)
 
 DEFEVENT(PAR_JOY2_START, "", AM_DUMMY, 0,4,0)
 
 DEFEVENT(PAR_JOY2_HORIZ,"Parallel Joy2 Horizontal",AM_JOY_AXIS,0,4,DIR_LEFT|DIR_RIGHT)
 DEFEVENT(PAR_JOY2_VERT,"Parallel Joy2 Vertical",AM_JOY_AXIS,0,4,DIR_UP|DIR_DOWN)
-DEFEVENT(PAR_JOY2_LEFT,"Parallel Joy2 Left",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_LEFT)
-DEFEVENT(PAR_JOY2_RIGHT,"Parallel Joy2 Right",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_RIGHT)
-DEFEVENT(PAR_JOY2_UP,"Parallel Joy2 Up",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_UP)
-DEFEVENT(PAR_JOY2_DOWN,"Parallel Joy2 Down",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_DOWN)
-DEFEVENT(PAR_JOY2_LEFT_UP,"Parallel Joy2 Left+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_LEFT|DIR_UP)
-DEFEVENT(PAR_JOY2_LEFT_DOWN,"Parallel Joy2 Left+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_LEFT|DIR_DOWN)
-DEFEVENT(PAR_JOY2_RIGHT_UP,"Parallel Joy2 Right+Up",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_RIGHT|DIR_UP)
-DEFEVENT(PAR_JOY2_RIGHT_DOWN,"Parallel Joy2 Right+Down",AM_KEY|AM_JOY_BUT|AM_AF,16,4,DIR_RIGHT|DIR_DOWN)
-DEFEVENT(PAR_JOY2_FIRE_BUTTON,"Parallel Joy2 Fire Button",AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF,4,4,JOYBUTTON_1)
+DEFEVENT(PAR_JOY2_LEFT,"Parallel Joy2 Left",AM_K,16,4,DIR_LEFT)
+DEFEVENT(PAR_JOY2_RIGHT,"Parallel Joy2 Right",AM_K,16,4,DIR_RIGHT)
+DEFEVENT(PAR_JOY2_UP,"Parallel Joy2 Up",AM_K,16,4,DIR_UP)
+DEFEVENT(PAR_JOY2_DOWN,"Parallel Joy2 Down",AM_K,16,4,DIR_DOWN)
+DEFEVENT(PAR_JOY2_LEFT_UP,"Parallel Joy2 Left+Up",AM_K,16,4,DIR_LEFT|DIR_UP)
+DEFEVENT(PAR_JOY2_LEFT_DOWN,"Parallel Joy2 Left+Down",AM_K,16,4,DIR_LEFT|DIR_DOWN)
+DEFEVENT(PAR_JOY2_RIGHT_UP,"Parallel Joy2 Right+Up",AM_K,16,4,DIR_RIGHT|DIR_UP)
+DEFEVENT(PAR_JOY2_RIGHT_DOWN,"Parallel Joy2 Right+Down",AM_K,16,4,DIR_RIGHT|DIR_DOWN)
+DEFEVENT(PAR_JOY2_FIRE_BUTTON,"Parallel Joy2 Fire Button",AM_K,4,4,JOYBUTTON_1)
 
 DEFEVENT(PAR_JOY_END, "", AM_DUMMY, 0,0,0)
 
@@ -277,7 +277,7 @@ DEFEVENT(SPC_STATESAVEDIALOG,"Save state",AM_K,0,0,AKS_STATESAVEDIALOG)
 DEFEVENT(SPC_STATERESTOREDIALOG,"Restore state",AM_K,0,0,AKS_STATERESTOREDIALOG)
 DEFEVENT(SPC_TOGGLEFULLSCREEN,"Toggle windowed/fullscreen",AM_K,0,0,AKS_TOGGLEFULLSCREEN)
 DEFEVENT(SPC_DECREASE_REFRESHRATE,"Decrease emulation speed",AM_K,0,0,AKS_DECREASEREFRESHRATE)
-DEFEVENT(SPC_INCREASE_REFRESHRARE,"Increase emulation speed",AM_K,0,0,AKS_INCREASEREFRESHRATE)
+DEFEVENT(SPC_INCREASE_REFRESHRATE,"Increase emulation speed",AM_K,0,0,AKS_INCREASEREFRESHRATE)
 
 DEFEVENT(SPC_ARCADIA_DIAGNOSTICS,"Arcadia diagnostics dip switch",AM_K,0,0,AKS_ARCADIADIAGNOSTICS)
 DEFEVENT(SPC_ARCADIA_PLAYER1,"Arcadia player 1",AM_K,0,0,AKS_ARCADIAPLY1)
diff --git a/memory.c b/memory.c
index 65e5c111..8c86a4f9 100755
--- a/memory.c
+++ b/memory.c
@@ -93,7 +93,7 @@ static struct romdata roms[] = {
     { "Kickstart v1.0 (A1000)(NTSC)", 0, 0, 0x299790ff, 262144, 1, 0, 0, ROMTYPE_KICK },
     { "Kickstart v1.1 (A1000)(NTSC)", 31, 34, 0xd060572a, 262144, 2, 0, 0, ROMTYPE_KICK },
     { "Kickstart v1.1 (A1000)(PAL)", 31, 34, 0xec86dae2, 262144, 3, 0, 0, ROMTYPE_KICK },
-    { "Kickstart v1.2 (A1000)", 33, 166, 0x0ed783d0, 262144, 4, 0, 0, ROMTYPE_KICK },
+    { "Kickstart v1.2 (A1000)", 33, 166, 0x9ed783d0, 262144, 4, 0, 0, ROMTYPE_KICK },
     { "Kickstart v1.2 (A500,A1000,A2000)", 33, 180, 0xa6ce1636, 262144, 5, 0, 0, ROMTYPE_KICK },
     { "Kickstart v1.3 (A500,A1000,A2000)", 34, 5, 0xc4f0f55f, 262144, 6, 60, 0, ROMTYPE_KICK },
     { "Kickstart v1.3 (A3000)", 34, 5, 0xe0f37258, 262144, 32, 0, 0, ROMTYPE_KICK },
@@ -194,14 +194,13 @@ uae_u8 *load_keyfile (struct uae_prefs *p, char *path, int *size)
 	    strcat (tmp, "rom.key");
 	    f = zfile_fopen (tmp, "rb");
 	    if (!f) {
-		f = zfile_fopen ("roms\\rom.key", "rb");
+		f = zfile_fopen ("roms/rom.key", "rb");
 		if (!f) {
 		    strcpy (tmp, start_path);
 		    strcat (tmp, "rom.key");
 		    f = zfile_fopen(tmp, "rb");
 		    if (!f) {
-			strcpy (tmp, start_path);
-			strcat (tmp, "..\\shared\\rom\\rom.key");
+			sprintf (tmp, "%s../shared/rom/rom.key", start_path);
 			f = zfile_fopen(tmp, "rb");
 		    }
 		}
@@ -302,10 +301,12 @@ struct romdata *getromdatabydata (uae_u8 *rom, int size)
     memcpy (rom, tmp, 4);
     i = 0;
     while (roms[i].name) {
-	if (crc32a == roms[i].crc32 || crc32b == roms[i].crc32)
-	    return &roms[i];
-	if (crc32c == roms[i].crc32 && roms[i].type == ROMTYPE_AR)
-	    return &roms[i];
+	if (roms[i].crc32) {
+	    if (crc32a == roms[i].crc32 || crc32b == roms[i].crc32)
+		return &roms[i];
+	    if (crc32c == roms[i].crc32 && roms[i].type == ROMTYPE_AR)
+		return &roms[i];
+	}
 	i++;
     }
     xfree (tmpbuf);
@@ -382,7 +383,8 @@ __inline__ void byteput (uaecptr addr, uae_u32 b)
 }
 #endif
 
-uae_u32 chipmem_mask, kickmem_mask, extendedkickmem_mask, bogomem_mask, a3000mem_mask;
+uae_u32 chipmem_mask, chipmem_full_mask;
+uae_u32 kickmem_mask, extendedkickmem_mask, bogomem_mask, a3000mem_mask;
 
 static int illegal_count;
 /* A dummy bank that only contains zeros */
@@ -690,7 +692,6 @@ void REGPARAM2 chipmem_lput (uaecptr addr, uae_u32 l)
     do_put_mem_long (m, l);
 }
 
-
 void REGPARAM2 chipmem_wput (uaecptr addr, uae_u32 w)
 {
     uae_u16 *m;
@@ -708,6 +709,66 @@ void REGPARAM2 chipmem_bput (uaecptr addr, uae_u32 b)
     chipmemory[addr] = b;
 }
 
+uae_u32 REGPARAM2 chipmem_agnus_lget (uaecptr addr)
+{
+    uae_u32 *m;
+
+    addr -= chipmem_start & chipmem_full_mask;
+    addr &= chipmem_full_mask;
+    m = (uae_u32 *)(chipmemory + addr);
+    return do_get_mem_long (m);
+}
+
+uae_u32 REGPARAM2 chipmem_agnus_wget (uaecptr addr)
+{
+    uae_u16 *m;
+
+    addr -= chipmem_start & chipmem_full_mask;
+    addr &= chipmem_full_mask;
+    m = (uae_u16 *)(chipmemory + addr);
+    return do_get_mem_word (m);
+}
+
+uae_u32 REGPARAM2 chipmem_agnus_bget (uaecptr addr)
+{
+    addr -= chipmem_start & chipmem_full_mask;
+    addr &= chipmem_full_mask;
+    return chipmemory[addr];
+}
+
+void REGPARAM2 chipmem_agnus_lput (uaecptr addr, uae_u32 l)
+{
+    uae_u32 *m;
+
+    addr -= chipmem_start & chipmem_full_mask;
+    addr &= chipmem_full_mask;
+    if (addr >= allocated_chipmem)
+	return;
+    m = (uae_u32 *)(chipmemory + addr);
+    do_put_mem_long (m, l);
+}
+
+void REGPARAM2 chipmem_agnus_wput (uaecptr addr, uae_u32 w)
+{
+    uae_u16 *m;
+
+    addr -= chipmem_start & chipmem_full_mask;
+    addr &= chipmem_full_mask;
+    if (addr >= allocated_chipmem)
+	return;
+    m = (uae_u16 *)(chipmemory + addr);
+    do_put_mem_word (m, w);
+}
+
+void REGPARAM2 chipmem_agnus_bput (uaecptr addr, uae_u32 b)
+{
+    addr -= chipmem_start & chipmem_full_mask;
+    addr &= chipmem_full_mask;
+    if (addr >= allocated_chipmem)
+	return;
+    chipmemory[addr] = b;
+}
+
 int REGPARAM2 chipmem_check (uaecptr addr, uae_u32 size)
 {
     addr -= chipmem_start & chipmem_mask;
@@ -1216,6 +1277,12 @@ addrbank chipmem_bank = {
     chipmem_xlate, chipmem_check, NULL
 };
 
+addrbank chipmem_agnus_bank = {
+    chipmem_agnus_lget, chipmem_agnus_wget, chipmem_agnus_bget,
+    chipmem_agnus_lput, chipmem_agnus_wput, chipmem_agnus_bput,
+    chipmem_xlate, chipmem_check, NULL
+};
+
 #ifdef AGA
 addrbank chipmem_bank_ce2 = {
     chipmem_lget_ce2, chipmem_wget_ce2, chipmem_bget_ce2,
@@ -1438,21 +1505,27 @@ static int patch_residents (uae_u8 *kickmemory)
 static int load_kickstart (void)
 {
     struct zfile *f = zfile_fopen (currprefs.romfile, "rb");
-    char tmprom[MAX_DPATH];
+    char tmprom[MAX_DPATH], tmprom2[MAX_DPATH];
     int patched = 0;
 
     strcpy (tmprom, currprefs.romfile);
     if (f == NULL) {
-	strcpy (currprefs.romfile, "roms/kick.rom");
-	f = zfile_fopen (currprefs.romfile, "rb");
+	sprintf (tmprom2, "%s%s", start_path, currprefs.romfile);
+	f = zfile_fopen (tmprom2, "rb");
 	if (f == NULL) {
-	    strcpy( currprefs.romfile, "kick.rom" );
-	    f = zfile_fopen( currprefs.romfile, "rb" );
+	    sprintf (currprefs.romfile, "%sroms/kick.rom", start_path);
+	    f = zfile_fopen (currprefs.romfile, "rb");
 	    if (f == NULL) {
-		strcpy( currprefs.romfile, "..\\shared\\rom\\kick.rom" );
-		f = zfile_fopen( currprefs.romfile, "rb" );
+		sprintf (currprefs.romfile, "%skick.rom", start_path);
+		f = zfile_fopen (currprefs.romfile, "rb");
+		if (f == NULL) {
+		    sprintf (currprefs.romfile, "%s../shared/rom/kick.rom", start_path);
+		    f = zfile_fopen (currprefs.romfile, "rb");
+		}
 	    }
-        }
+	} else {
+	    strcpy (currprefs.romfile, tmprom2);
+	}
     }
     if( f == NULL ) { /* still no luck */
 #if defined(AMIGA)||defined(__POS__)
@@ -1659,19 +1732,26 @@ void clearexec (void)
 static void allocate_memory (void)
 {
     if (allocated_chipmem != currprefs.chipmem_size) {
+	int memsize;
 	if (chipmemory)
 	    mapped_free (chipmemory);
 	chipmemory = 0;
 
-	allocated_chipmem = currprefs.chipmem_size;
-	chipmem_mask = allocated_chipmem - 1;
-
-	chipmemory = mapped_malloc (allocated_chipmem, "chip");
+	memsize = allocated_chipmem = currprefs.chipmem_size;
+	chipmem_full_mask = chipmem_mask = allocated_chipmem - 1;
+	if ((currprefs.chipset_mask & CSMASK_ECS_AGNUS) && allocated_chipmem < 0x100000) {
+	    chipmem_full_mask = 0x100000 - 1;
+	    memsize *= 2;
+	}
+	chipmemory = mapped_malloc (memsize, "chip");
 	if (chipmemory == 0) {
 	    write_log ("Fatal error: out of memory for chipmem.\n");
 	    allocated_chipmem = 0;
-	} else
-	clearexec ();
+	} else {
+	    clearexec ();
+	    if (memsize != allocated_chipmem)
+		memset (chipmemory + allocated_chipmem, 0xff, memsize - allocated_chipmem);
+	}
     }
 
     if (allocated_bogomem != currprefs.bogomem_size) {
@@ -1770,8 +1850,10 @@ void memory_reset (void)
         load_extendedkickstart ();
 	kickmem_mask = 524288 - 1;
 	if (!load_kickstart ()) {
-	    if (strlen (currprefs.romfile) > 0)
+	    if (strlen (currprefs.romfile) > 0) {
+		write_log ("%s\n", currprefs.romfile);
 		notify_user (NUMSG_NOROM);
+	    }
 #ifdef AUTOCONFIG
             init_ersatz_rom (kickmemory);
 	    ersatzkickfile = 1;
diff --git a/newcpu.c b/newcpu.c
index 0a1637d9..b4b3745d 100755
--- a/newcpu.c
+++ b/newcpu.c
@@ -1698,9 +1698,13 @@ static int do_specialties (int cycles)
 	    do_copper ();
     }
 
-    if (regs.spcflags & SPCFLAG_DOTRACE) {
+    if (regs.spcflags & SPCFLAG_DOTRACE)
 	Exception (9,last_trace_ad);
+    if (regs.spcflags & SPCFLAG_TRAP) {
+	unset_special (SPCFLAG_TRAP);
+	Exception (32 + 15, 0);
     }
+
     while (regs.spcflags & SPCFLAG_STOP) {
  	do_cycles (4 * CYCLE_UNIT);
 	if (regs.spcflags & SPCFLAG_COPPER)
diff --git a/od-win32/fsdb_win32.c b/od-win32/fsdb_win32.c
index 6abb1433..5d1056ad 100755
--- a/od-win32/fsdb_win32.c
+++ b/od-win32/fsdb_win32.c
@@ -437,7 +437,8 @@ static int recycle (const char *name)
     memset (&fos, 0, sizeof (fos));
     fos.wFunc = FO_DELETE;
     fos.pFrom = p;
-    fos.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NORECURSION | FOF_SILENT;
+    fos.fFlags = (currprefs.win32_norecyclebin ? 0 : FOF_ALLOWUNDO) |
+	FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NORECURSION | FOF_SILENT;
     v = SHFileOperation (&fos);
     xfree (p);
     return v ? -1 : 0;
@@ -469,14 +470,12 @@ int my_rmdir (const char *name)
     }
 
     return recycle (name);
-    //return RemoveDirectory (name) == 0 ? -1 : 0;
 }
 
 /* "move to Recycle Bin" (if enabled) -version of DeleteFile() */
 int my_unlink (const char *name)
 {
     return recycle (name);
-    //return DeleteFile (name) == 0 ? -1 : 0;
 }
 
 int my_rename (const char *oldname, const char *newname)
diff --git a/od-win32/mman.c b/od-win32/mman.c
index a05eb40c..ad67e76e 100755
--- a/od-win32/mman.c
+++ b/od-win32/mman.c
@@ -25,6 +25,8 @@ void init_shm( void )
 #else
     LPBYTE address = (LPBYTE)0x10000000; // Letting the system decide doesn't seem to work on some systems
 #endif
+    int size = 0x19000000;
+    int add = 0x1000000;
 
     canbang = 0;
     gfxoffs = 0;
@@ -37,27 +39,34 @@ void init_shm( void )
 	shmids[i].addr = NULL;
 	shmids[i].name[0] = 0;
     }
-    while( address < (LPBYTE)0xa0000000 )
+    while (address < (LPBYTE)0xa0000000)
     {
-        blah = VirtualAlloc( address, 0x19000000, MEM_RESERVE, PAGE_EXECUTE_READWRITE );
-        if( blah == NULL )
+        blah = VirtualAlloc( address, size, MEM_RESERVE, PAGE_EXECUTE_READWRITE );
+        if (blah == NULL)
         {
-	    address += 0x01000000;
+	    address += add;
 	}
         else
         {
-	    natmem_offset = (uae_u32)blah + 0x1000000;
+	    natmem_offset = (uae_u32)blah;
+    	    write_log ("NATMEM: Our special area: 0x%x-0x%x\n", natmem_offset, natmem_offset + size);
+	    VirtualFree (blah, 0, MEM_RELEASE);
+	    while (address < (LPBYTE)0xa0000000) {
+		address += add * 8;
+		blah = VirtualAlloc (address, size, MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+		if (blah == NULL) {
+		    address -= add * 8;
+		    break;
+		}
+	        VirtualFree (blah, 0, MEM_RELEASE);
+	    }
+	    natmem_offset = (uae_u8*)natmem_offset + ((uae_u8*)address - (uae_u8*)natmem_offset) / 2;
+    	    write_log ("NATMEM: after adjustment; 0x%x-0x%x\n", natmem_offset, natmem_offset + size);
+	    canbang = 1;
 	    break;
 	}
     }
-    if( natmem_offset )
-    {
-    	write_log( "NATMEM: Our special area is 0x%x\n", natmem_offset );
-	VirtualFree( blah, 0, MEM_RELEASE );
-	canbang = 1;
-    }
-    else
-    {
+    if (!natmem_offset) {
 	write_log( "NATMEM: No special area could be allocated!\n" );
     }
 }
@@ -199,6 +208,12 @@ void *shmat(int shmid, LPVOID shmaddr, int shmflg)
 	    shmids[shmid].attached=result;
 	    return result;
 	}
+	if(!strcmp(shmids[shmid].name,"arcadia"))
+	{
+	    result=natmem_offset+0x10000;
+	    shmids[shmid].attached=result;
+	    return result;
+	}
 }
 #endif
     
@@ -210,10 +225,11 @@ void *shmat(int shmid, LPVOID shmaddr, int shmflg)
 	    {
 		result=(void*)VirtualFree(shmaddr,0,MEM_RELEASE);
 	    }
-	    result =VirtualAlloc(shmaddr,size,MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
+	    result = VirtualAlloc(shmaddr,size,MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
 	    if( result == NULL )
 	    {
 		result = (void *)-1;
+		write_log ("VirtualAlloc %x %x failed %d\n", shmaddr, size, GetLastError ());
 	    }
 	    else
 	    {
diff --git a/od-win32/picasso96_win.c b/od-win32/picasso96_win.c
index 4c001958..9ea9ba1a 100755
--- a/od-win32/picasso96_win.c
+++ b/od-win32/picasso96_win.c
@@ -1583,7 +1583,7 @@ static void FillBoardInfo (uaecptr amigamemptr, struct LibResolution *res, struc
     put_byte (amigamemptr + PSSO_ModeInfo_first_union, 98);
     put_byte (amigamemptr + PSSO_ModeInfo_second_union, 14);
     
-    put_long (amigamemptr + PSSO_ModeInfo_PixelClock, dm->res.width * dm->res.height * (currprefs.gfx_refreshrate ? currprefs.gfx_refreshrate : default_freq));
+    put_long (amigamemptr + PSSO_ModeInfo_PixelClock, dm->res.width * dm->res.height * (currprefs.gfx_refreshrate ? abs (currprefs.gfx_refreshrate) : default_freq));
 }
 
 static int AssignModeID( int i, int count )
@@ -2235,8 +2235,8 @@ STATIC_INLINE int BlitRectHelper( void )
     * If we have a destination RenderInfo, then we've been called from picasso_BlitRectNoMaskComplete()
     * and we need to put the results on the screen from the frame-buffer.
     */
-    //if (dstri == NULL) 
-    if (dstri->Memory == ri->Memory)
+    //if (dstri->Memory == ri->Memory)
+    if (dstri == NULL || dstri->Memory == ri->Memory)
     {
         if( mask != 0xFF && Bpp > 1 ) 
         {
@@ -2862,7 +2862,7 @@ void init_hz_p96 (void)
     if (isfullscreen ())
 	rate = DirectDraw_CurrentRefreshRate ();
     else
-	rate = currprefs.gfx_refreshrate;
+	rate = abs (currprefs.gfx_refreshrate);
     if (rate <= 0)
         rate = 60;
     p96syncrate /= rate;
diff --git a/od-win32/resources/winuae.rc b/od-win32/resources/winuae.rc
index 3bdb1820..c6c0c771 100755
--- a/od-win32/resources/winuae.rc
+++ b/od-win32/resources/winuae.rc
@@ -1258,7 +1258,7 @@ BEGIN
     IDS_SELECTFILESYSROOT   "Please select your file-system root directory..."
     IDS_DEFAULTMIDIOUT      "Default MIDI-Out Device"
     IDS_CONTRIBUTORS1       "Bernd Schmidt - The Grand-Master\nSam Jordan - Custom-chip, floppy-DMA, etc.\nMathias Ortmann - Original WinUAE Main Guy, BSD Socket support\nBrian King - Picasso96 Support, Integrated GUI for WinUAE, previous WinUAE Main Guy\nToni Wilen - Core updates, WinUAE Main Guy\nGustavo Goedert/Peter Remmers/Michael Sontheimer/Tomi Hakala/Tim Gunn/Nemo Pohle - DOS Port Stuff\nSamuel Devulder/Olaf Barthel/Sam Jordan - Amiga Ports\nKrister Bergman - XFree86 and OS/2 Port\nA. Blanchard/Ernesto Corvi - MacOS Port\nChristian Bauer - BeOS Port\nIan Stephenson - NextStep Port\nPeter Teichmann - Acorn/RiscOS Port\nStefan Reinauer - ZorroII/III AutoConfig, Serial Support\nChristian Schmitt/Chris Hames - Serial Support\nHerman ten Brugge - 68020/68881 Emulation Code\nTauno Taipaleenmaki - Various UAE-Control/UAE-Library Support\nBrett Eden/Tim Gunn/Paolo Besser/Nemo Pohle - Various Docs and Web-Sites\nGeorg Veichtlbauer - Help File coordinator, German GUI\nFulvio Leonardi - Italian translator for WinUAE\n"
-    IDS_CONTRIBUTORS2       "Bill Panagouleas - Hardware support\nSpecial thanks to Alexander Kneer and Tobias Abt (The Picasso96 Team)\nSteven Weiser  - Postscript printing emulation idea and testing."
+    IDS_CONTRIBUTORS2       "Bill Panagouleas - Hardware support\nSpecial thanks to Alexander Kneer and Tobias Abt (The Picasso96 Team)\nSteven Weiser  - Postscript printing emulation idea and testing.\nPéter Tóth /Balázs Rátkai/Iván Herczeg/András Arató - Hungarian translation"
     IDS_INVALIDPRTPORT      "The printer you have in this configuration is not valid on this machine.\n"
     IDS_RESTOREUSS          "Restore a UAE Snap-Shot File"
     IDS_USS                 "UAE Snap-Shot Files"
@@ -1277,7 +1277,7 @@ BEGIN
     IDS_PATH                "Path"
     IDS_RW                  "R/W"
     IDS_SECTORS             "Sectors"
-    IDS_SURFACES            "Surfaces"
+    IDS_SURFACES            "Bill Panagouleas - Hardware support\nSpecial thanks to Alexander Kneer and Tobias Abt (The Picasso96 Team)\nSteven Weiser  - Postscript printing emulation idea and testing.\nHungarian translation - Péter Tóth , Balázs Rátkai , Iván Herczeg , András Arató"
     IDS_RESERVED            "Reserved"
     IDS_BLOCKSIZE           "Block Size"
     IDS_NAME                "Name"
diff --git a/od-win32/win32.c b/od-win32/win32.c
index 5341f564..c6784bb1 100755
--- a/od-win32/win32.c
+++ b/od-win32/win32.c
@@ -1958,7 +1958,7 @@ static void WIN32_HandleRegistryStuff( void )
                               KEY_ALL_ACCESS, NULL, &hWinUAEKeyLocal, &disposition ) == ERROR_SUCCESS ) )
         {
             /* Set our (default) sub-key to BE the "WinUAE" command for launching a configuration */
-            sprintf( path, "%sWinUAE.exe -f \"%%1\"", start_path );
+            sprintf( path, "%sWinUAE.exe -log -f \"%%1\"", start_path );
             RegSetValueEx( hWinUAEKeyLocal, "", 0, REG_SZ, (CONST BYTE *)path, strlen( path ) + 1 );
         }
 	RegCloseKey( hWinUAEKeyLocal );
@@ -2222,6 +2222,7 @@ __asm{
 	    posn[1] = 0;
 	sprintf (help_file, "%sWinUAE.chm", start_path );
 	sprintf( VersionStr, "WinUAE %d.%d.%d%s", UAEMAJOR, UAEMINOR, UAESUBREV, WINUAEBETA ? WINUAEBETASTR : "" );
+	SetCurrentDirectory (start_path);
 
 	logging_init ();
 
diff --git a/od-win32/win32.h b/od-win32/win32.h
index a004f9ae..fd977607 100755
--- a/od-win32/win32.h
+++ b/od-win32/win32.h
@@ -22,7 +22,7 @@ extern int manual_palette_refresh_needed;
 extern int mouseactive, focus;
 extern int ignore_messages_all;
 #define WINUAEBETA 1
-#define WINUAEBETASTR " Beta 1"
+#define WINUAEBETASTR " Beta 2"
 
 extern void my_kbd_handler (int, int, int);
 extern void clearallkeys(void);
diff --git a/od-win32/win32gui.c b/od-win32/win32gui.c
index 8bdd57d7..06b63cb6 100755
--- a/od-win32/win32gui.c
+++ b/od-win32/win32gui.c
@@ -497,7 +497,7 @@ end:
     free (p);
 }
 
-int scan_roms (char *pathp)
+static int scan_roms_2 (char *pathp)
 {
     HKEY fkey = NULL;
     char buf[MAX_PATH], path[MAX_PATH];
@@ -530,7 +530,7 @@ int scan_roms (char *pathp)
 	    char tmppath[MAX_PATH];
 	    strcpy (tmppath, path);
 	    strcat (tmppath, find_data.cFileName);
-	    if (scan_rom (tmppath, fkey, keybuf, keysize))
+	    if (find_data.nFileSizeLow < 10000000 && scan_rom (tmppath, fkey, keybuf, keysize))
 		ret = 1;
 	    if (FindNextFile (handle, &find_data) == 0) {
 		FindClose (handle);
@@ -548,6 +548,20 @@ end:
     if (fkey)
 	RegCloseKey (fkey);
     free_keyfile (keybuf);
+    return ret;
+}
+
+int scan_roms (char *pathp)
+{
+    char path[MAX_DPATH];
+
+    int ret = scan_roms_2 (pathp);
+    sprintf (path, "%s..\\shared\\rom\\", start_path);
+    if (!ret && pathp == NULL) {
+	ret = scan_roms_2 (path);
+	if (ret)
+	    set_path ("KickstartPath", path);
+    }
     read_rom_list (0);
     show_rom_list ();
     return ret;
@@ -4313,7 +4327,7 @@ static BOOL MiscDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 		    break;
 		}
 	    }
-	} else {
+	} else if (currentpage == MISC2_ID) {
 	    misc_getpri (hDlg, IDC_ACTIVE_PRIORITY, &workprefs.win32_active_priority);
 	    misc_getpri (hDlg, IDC_INACTIVE_PRIORITY, &workprefs.win32_inactive_priority);
 	    misc_getpri (hDlg, IDC_MINIMIZED_PRIORITY, &workprefs.win32_iconified_priority);
@@ -6128,15 +6142,18 @@ static void swapperhili (HWND hDlg, int entry)
 static void addswapperfile (HWND hDlg, int entry)
 {
     char path[MAX_DPATH];
+    int lastentry = entry;
+
     if (MultiDiskSelection (hDlg, -1, 0, &changed_prefs, path)) {
         char dpath[MAX_DPATH];
         loopmulti (path, NULL);
         while (loopmulti(path, dpath) && entry < MAX_SPARE_DRIVES) {
             strcpy (workprefs.dfxlist[entry], dpath);
+	    lastentry = entry;
             entry++;
         }
         InitializeListView (hDlg);
-        swapperhili (hDlg, entry);
+        swapperhili (hDlg, lastentry);
     }
 }
 
@@ -6270,10 +6287,14 @@ static BOOL CALLBACK SwapperDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM
 	    break;
 	
 	    case IDC_DISKLISTINSERT:
-		if (entry >= 0 && getfloppybox (hDlg, IDC_DISKTEXT, tmp, sizeof (tmp))) {
-		    strcpy (workprefs.dfxlist[entry], tmp);
-		    InitializeListView (hDlg);
-		    swapperhili (hDlg, entry);
+		if (entry >= 0) {
+		    if (getfloppybox (hDlg, IDC_DISKTEXT, tmp, sizeof (tmp))) {
+			strcpy (workprefs.dfxlist[entry], tmp);
+			InitializeListView (hDlg);
+			swapperhili (hDlg, entry);
+		    } else {
+			addswapperfile (hDlg, entry);
+		    }
 		}
 		break;