Copied DS81 files as a baselineHEADmaster

1 files changed, 1171 insertions, 0 deletions

diff --git a/source/zx81.c b/source/zx81.c
new file mode 100644
index 0000000..7aa5380
--- /dev/null
+++ b/source/zx81.c
@@ -0,0 +1,1171 @@
+/*
+    ds81 - Nintendo DS ZX81 emulator
+
+    Copyright (C) 2006  Ian Cowburn <ianc@noddybox.co.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    -------------------------------------------------------------------------
+
+    Provides the emulation for the ZX81
+
+*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <nds.h>
+
+#include "zx81.h"
+#include "gui.h"
+
+#include "stream.h"
+
+#include "config.h"
+
+#include "zx81_bin.h"
+
+#include "ds81_debug.h"
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+/* ---------------------------------------- STATICS
+*/
+#define ROMLEN		0x2000
+#define ROM_SAVE	0x2fc
+#define ROM_LOAD	0x347
+
+#define ED_SAVE		0xf0
+#define ED_LOAD		0xf1
+#define ED_WAITKEY	0xf2
+#define ED_ENDWAITKEY	0xf3
+#define ED_PAUSE	0xf4
+
+#define SLOW_TSTATES	16000
+#define FAST_TSTATES	64000
+
+#define E_LINE		16404
+#define LASTK1		16421
+#define LASTK2		16422
+#define MARGIN		16424
+#define FRAMES		16436
+#define CDFLAG		16443
+
+static Z80Val		FRAME_TSTATES=FAST_TSTATES;
+
+/* The ZX81 screen and memory
+*/
+static void		(*DrawScreen)(Z80 *z80);
+
+static int		waitkey=FALSE;
+static int		started=FALSE;
+
+static int		hires=FALSE;
+static int		hires_dfile;
+static int		last_I;
+
+static unsigned		prev_lk1;
+static unsigned		prev_lk2;
+
+#define	SCR_W		256
+#define	SCR_H		192
+#define	TXT_W		32
+#define	TXT_H		24
+
+static Z80Byte		mem[0x10000];
+
+static Z80Byte		scr_mirror[7000];
+
+static Z80Word		RAMBOT=0;
+static Z80Word		RAMTOP=0;
+
+#define DFILE		0x400c
+
+#define WORD(a)		(mem[a] | (Z80Word)mem[a+1]<<8)
+
+/* Tape
+*/
+static int		enable_filesystem;
+static int		allow_save;
+static const Z80Byte	*tape_image;
+static int		tape_len;
+
+static char		last_dir[FILENAME_MAX] = "/";
+
+/* GFX vars
+*/
+static uint16		*txt_screen;
+static uint16		*bmp_screen;
+
+/* The keyboard
+*/
+static Z80Byte		matrix[8];
+
+static struct
+{
+    int row;
+    int bit;
+} key_matrix[]=
+    {
+    	{3,0x01}, {3,0x02}, {3,0x04}, {3,0x08}, {3,0x10}, 	/* 1 - 5 */
+    	{4,0x10}, {4,0x08}, {4,0x04}, {4,0x02}, {4,0x01}, 	/* 6 - 0 */
+    	{2,0x01}, {2,0x02}, {2,0x04}, {2,0x08}, {2,0x10}, 	/* Q - T */
+    	{5,0x10}, {5,0x08}, {5,0x04}, {5,0x02}, {5,0x01}, 	/* Y - P */
+    	{1,0x01}, {1,0x02}, {1,0x04}, {1,0x08}, {1,0x10}, 	/* A - G */
+    	{6,0x10}, {6,0x08}, {6,0x04}, {6,0x02}, {6,0x01}, 	/* H - NL */
+    	{0,0x01}, {0,0x02}, {0,0x04}, {0,0x08}, {0,0x10}, 	/* CAPS - V */
+    	{7,0x10}, {7,0x08}, {7,0x04}, {7,0x02}, {7,0x01} 	/* B - SPACE */
+    };
+
+
+/* ---------------------------------------- PRIVATE FUNCTIONS
+*/
+#define PEEKW(addr)		(mem[addr] | (Z80Word)mem[addr+1]<<8)
+
+#define POKEW(addr,val)         do					\
+                                {					\
+                                    Z80Word wa=addr;			\
+                                    Z80Word wv=val;			\
+                                    mem[wa]=wv;				\
+                                    mem[wa+1]=wv>>8;			\
+                                } while(0)
+
+static void RomPatch(void)
+{
+    static const Z80Byte save[]=
+    {
+    	0xed, ED_SAVE,		/* (SAVE)		*/
+	0xc3, 0x07, 0x02,	/* JP $0207		*/
+	0xff			/* End of patch		*/
+    };
+
+    static const Z80Byte load[]=
+    {
+    	0xed, ED_LOAD,		/* (LOAD)		*/
+	0xc3, 0x07, 0x02,	/* JP $0207		*/
+	0xff			/* End of patch		*/
+    };
+
+    static const Z80Byte fast_hack[]=
+    {
+	0xed, ED_WAITKEY,	/* (START KEY WAIT)	*/
+	0xcb,0x46,		/* L: bit 0,(hl)	*/
+	0x28,0xfc,		/* jr z,L		*/
+	0xed, ED_ENDWAITKEY,	/* (END KEY WAIT)	*/
+    	0x00,			/* nop			*/
+	0xff			/* End of patch		*/
+    };
+
+    static const Z80Byte kbd_hack[]=
+    {
+	0x2a,0x25,0x40,		/* ld hl,(LASTK)	*/
+	0xc9,			/* ret			*/
+	0xff			/* End of patch		*/
+    };
+
+    static const Z80Byte pause_hack[]=
+    {
+	0xed, ED_PAUSE,		/* (PAUSE)		*/
+    	0x00,			/* nop			*/
+	0xff			/* End of patch		*/
+    };
+
+    int f;
+
+    for(f=0;save[f]!=0xff;f++)
+    {
+	mem[ROM_SAVE+f]=save[f];
+    }
+
+    for(f=0;load[f]!=0xff;f++)
+    {
+	mem[ROM_LOAD+f]=load[f];
+    }
+
+    for(f=0;fast_hack[f]!=0xff;f++)
+    {
+	mem[0x4ca+f]=fast_hack[f];
+    }
+
+    for(f=0;kbd_hack[f]!=0xff;f++)
+    {
+	mem[0x2bb+f]=kbd_hack[f];
+    }
+
+    for(f=0;pause_hack[f]!=0xff;f++)
+    {
+	mem[0xf3a+f]=pause_hack[f];
+    }
+
+    /* Trust me, we have a ZX81... Honestly.
+    */
+    mem[0x21c]=0x00;
+    mem[0x21d]=0x00;
+
+    /* Remove HALTs as we don't do interrupts
+    */
+    mem[0x0079]=0;
+    mem[0x02ec]=0;
+}
+
+static Z80Byte FromASCII(char c)
+{
+    static const char *charset =
+      /* 0123456789 */
+    	" _________"
+	"_\"#$:?()><"
+	"=+-*/:,.01"
+	"23456789ab"
+	"cdefghijkl"
+	"mnopqrstuv"
+	"wxyz";
+
+    int f;
+
+    c = tolower(c);
+
+    for(f = 0; charset[f]; f++)
+    {
+    	if (charset[f] == c)
+	{
+	    return f;
+	}
+    }
+
+    return 0;
+}
+
+
+/* Open a tape file the passed address
+*/
+static FILE *OpenTapeFile(Z80Word addr, int *cancelled, const char *mode)
+{
+    static const char zx_chars[] = "\"#$:?()><=+-*/;,."
+				   "0123456789"
+				   "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    FILE *fp;
+    char full_fn[FILENAME_MAX] = DEFAULT_SNAPDIR;
+    char fn[FILENAME_MAX];
+    int f;
+    int done;
+
+    fp = NULL;
+    f = 0;
+    done = FALSE;
+    *cancelled = FALSE;
+
+    while(f<(FILENAME_MAX-3) && !done)
+    {
+    	int ch;
+
+	ch = mem[addr++];
+
+	if (ch&0x80)
+	{
+	    done = TRUE;
+	    ch &= 0x7f;
+	}
+
+	if (ch>=11 && ch<=63)
+	{
+	    fn[f++] = zx_chars[ch-11];
+	}
+    }
+
+    if (fn[0] == '*')
+    {
+    	if (GUI_FileSelect(last_dir,fn,".P"))
+	{
+	    fp = fopen(fn, mode);
+	}
+	else
+	{
+	    *cancelled = TRUE;
+	}
+
+	SK_DisplayKeyboard();
+    }
+    else
+    {
+	fn[f++] = '.';
+	fn[f++] = 'P';
+	fn[f] = 0;
+
+	strcat(full_fn,fn);
+
+	if (!(fp = fopen(full_fn, mode)))
+	{
+	    fp = fopen(fn, mode);
+	}
+    }
+
+    return fp;
+}
+
+
+static void LoadInternalTape(Z80 *z80)
+{
+    memcpy(mem+0x4009,tape_image,tape_len);
+}
+
+
+static void LoadExternalTape(FILE *tape, Z80 *z80)
+{
+    int c;
+    Z80Byte *a;
+
+    a=mem+0x4009;
+
+    while((c=getc(tape))!=EOF)
+    {
+    	*a++=c;
+    }
+}
+
+
+static void SaveExternalTape(FILE *tape, Z80 *z80)
+{
+    int f;
+    int end;
+
+    f = 0x4009;
+    end = WORD(E_LINE);
+
+    while(f <= end)
+    {
+    	fputc(mem[f++], tape);
+    }
+}
+
+
+static void ClearBitmap(void)
+{
+    uint16 *s;
+    uint16 p;
+    int f;
+
+    s = bmp_screen;
+    p = 0x8000|RGB15(31,31,31);
+
+    for(f=0;f<SCREEN_WIDTH*SCREEN_HEIGHT;f++)
+    {
+    	*s++=p;
+    }
+}
+
+
+static void ClearText(void)
+{
+    uint16 *s;
+    int f;
+
+    s = txt_screen;
+
+    for(f=0;f<TXT_W*TXT_H;f++)
+    {
+    	*s++=0;
+    }
+}
+
+
+static void DrawScreen_HIRES_Dirty(Z80 *z80)
+{
+    uint16 *bmp;
+    Z80Byte *scr;
+    Z80Byte *mirror;
+    int x,y;
+    int table;
+    int c;
+    int v;
+    int b;
+
+    scr = mem + hires_dfile;
+    mirror = scr_mirror;
+    bmp = bmp_screen;
+    table = z80->I << 8;
+
+    /* scr is increment in both loops so that it can skip the end-of-line
+       character
+    */
+    for(y=0; y<192; y++)
+    {
+    	for(x=0; x<32; x++)
+	{
+	    c = *scr;
+
+	    if (c != *mirror)
+	    {
+	    	*mirror++ = c;
+
+		v = mem[table + (c&0x3f)*8];
+
+		if (c & 0x80)
+		{
+		    v ^= 0xff;
+		}
+
+		for(b=0;b<8;b++)
+		{
+		    if (v & 0x80)
+		    {
+			*bmp++ = 0x8000;
+		    }
+		    else
+		    {
+			*bmp++ = 0xffff;
+		    }
+
+		    v=v<<1;
+		}
+	    }
+	    else
+	    {
+	    	mirror++;
+		bmp+=8;
+	    }
+
+	    scr++;
+	}
+
+	scr++;
+    }
+}
+
+
+static void DrawScreen_HIRES_Full(Z80 *z80)
+{
+    uint16 *bmp;
+    Z80Byte *scr;
+    Z80Byte *mirror;
+    int x,y;
+    int table;
+
+    scr = mem + hires_dfile;
+    mirror = scr_mirror;
+    bmp = bmp_screen;
+    table = z80->I << 8;
+
+    /* scr is increment in both loops so that it can skip the end-of-line
+       character
+    */
+    for(y=0; y<192; y++)
+    {
+    	for(x=0; x<32; x++)
+	{
+	    int c;
+	    int v;
+	    int b;
+
+	    c = *mirror++ = *scr;
+
+	    v = mem[table + (c&0x3f)*8];
+
+	    if (c & 0x80)
+	    {
+	    	v ^= 0xff;
+	    }
+
+	    for(b=0;b<8;b++)
+	    {
+	    	if (v & 0x80)
+		{
+		    *bmp++ = 0x8000;
+		}
+		else
+		{
+		    *bmp++ = 0xffff;
+		}
+
+		v=v<<1;
+	    }
+
+	    scr++;
+	}
+
+	scr++;
+    }
+
+    DrawScreen = DrawScreen_HIRES_Dirty;
+}
+
+
+static void DrawScreen_TEXT(Z80 *z80)
+{
+    Z80Byte *scr=mem+WORD(DFILE);
+    int x,y;
+
+    x=0;
+    y=0;
+
+    while(y<TXT_H)
+    {
+	scr++;
+	x=0;
+
+	while((*scr!=118)&&(x<TXT_W))
+	{
+	    Z80Byte ch = *scr++;
+
+	    if (ch&0x80)
+	    {
+	    	txt_screen[x+y*32]=(ch&0x3f)|0x40;
+	    }
+	    else
+	    {
+	    	txt_screen[x+y*32]=(ch&0x3f);
+	    }
+
+	    x++;
+	}
+
+	while (x<TXT_W)
+	{
+	    txt_screen[x+y*32]=0;
+	    x++;
+	}
+
+	y++;
+    }
+}
+
+
+static void DrawSnow(Z80 *z80)
+{
+    uint16 *s;
+    int f;
+
+    s = txt_screen;
+
+    for(f=0;f<TXT_W*TXT_H;f++)
+    {
+    	*s++=8;
+    }
+}
+
+
+static void FindHiresDFILE(void)
+{
+    /* Somewhat based on the code from xz81, an X-based ZX81 emulator,
+       (C) 1994 Ian Collier.  Search the ZX81's RAM until we find what looks
+       like a hi-res display file.
+
+       Bizarrely the original code used 'f' for a loop counter too...  Another
+       poor soul forever damaged by the ZX81's keyword entry system...
+    */
+    int f;
+
+    for(f=0x8000-(33*192); f>0x4000 ; f--)
+    {
+	int v;
+
+	v = mem[f+32];
+
+	if (v&0x40)
+	{
+	    int ok = TRUE;
+	    int n;
+
+	    for(n=0;n<192 && ok;n++)
+	    {
+	    	if (mem[f+33*n]&0x40)
+		{
+		    ok = FALSE;
+		}
+
+		if (mem[f+32+33*n] != v)
+		{
+		    ok = FALSE;
+		}
+	    }
+
+	    if (ok)
+	    {
+	    	hires_dfile = f;
+		return;
+	    }
+	}
+    }
+
+    /* All else fails, put the hires dfile at 0x4000 -- at least it should be
+       obvious that the hires won't work for whatever is being run.
+    */
+    hires_dfile = 0x4000;
+}
+
+
+/* Perform ZX81 housekeeping functions like updating FRAMES and updating LASTK
+*/
+static void ZX81HouseKeeping(Z80 *z80)
+{
+    unsigned row;
+    unsigned lastk1;
+    unsigned lastk2;
+
+    /* British ZX81
+    */
+    mem[MARGIN]=55;
+
+    /* Update FRAMES
+    */
+    if (FRAME_TSTATES==SLOW_TSTATES)
+    {
+    	Z80Word frame=PEEKW(FRAMES)&0x7fff;
+
+	if (frame)
+	{
+	    frame--;
+	}
+
+	POKEW(FRAMES,frame|0x8000);
+    }
+
+    if (!started)
+    {
+    	prev_lk1=0;
+    	prev_lk2=0;
+	return;
+    }
+
+    /* Update LASTK
+    */
+    lastk1=0;
+    lastk2=0;
+
+    for(row=0;row<8;row++)
+    {
+    	unsigned b;
+
+	b=(~matrix[row]&0x1f)<<1;
+
+	if (row==0)
+	{
+	    unsigned shift;
+
+	    shift=b&2;
+	    b&=~2;
+	    b|=(shift>>1);
+	}
+
+	if (b)
+	{
+	    if (b>1)
+	    {
+		lastk1|=(1<<row);
+	    }
+
+	    lastk2|=b;
+	}
+    }
+
+    if (lastk1 && (lastk1!=prev_lk1 || lastk2!=prev_lk2))
+    {
+    	mem[CDFLAG]|=1;
+    }
+    else
+    {
+    	mem[CDFLAG]&=~1;
+    }
+
+    mem[LASTK1]=lastk1^0xff;
+    mem[LASTK2]=lastk2^0xff;
+
+    prev_lk1=lastk1;
+    prev_lk2=lastk2;
+}
+
+
+static int CheckTimers(Z80 *z80, Z80Val val)
+{
+    if (val>=FRAME_TSTATES)
+    {
+    	/* Check for hi-res modes
+	*/
+	if (z80->I && z80->I != last_I)
+	{
+	    last_I = z80->I;
+
+	    if (z80->I == 0x1e)
+	    {
+	    	hires = FALSE;
+		DrawScreen = DrawScreen_TEXT;
+		ClearBitmap();
+	    }
+	    else
+	    {
+	    	hires = TRUE;
+		DrawScreen = DrawScreen_HIRES_Full;
+		ClearBitmap();
+		ClearText();
+		FindHiresDFILE();
+	    }
+	}
+
+	Z80ResetCycles(z80,val-FRAME_TSTATES);
+
+	/* Kludge warning - We assume that a hires display will not be in
+	   FAST mode! 
+	*/
+	if (started && ((mem[CDFLAG] & 0x80) || waitkey || hires))
+	{
+	    DrawScreen(z80);
+	    FRAME_TSTATES=SLOW_TSTATES;
+	}
+	else
+	{
+	    DrawSnow(z80);
+	    FRAME_TSTATES=FAST_TSTATES;
+	}
+
+	/* Update FRAMES (if in SLOW) and scan the keyboard.  This only happens
+	   once we've got to a decent point in the boot cycle (detected with
+	   a valid stack pointer).
+	*/
+	if (z80->SP<0x8000)
+	{
+	    ZX81HouseKeeping(z80);
+	}
+
+	swiWaitForVBlank();
+
+	return FALSE;
+    }
+    else
+    {
+	return TRUE;
+    }
+}
+
+
+static int EDCallback(Z80 *z80, Z80Val data)
+{
+    Z80Word pause;
+
+    switch((Z80Byte)data)
+    {
+    	case ED_SAVE:
+	    if (allow_save && z80->DE.w<0x8000)
+	    {
+		FILE *fp;
+		int cancel;
+
+		if ((fp=OpenTapeFile(z80->HL.w, &cancel, "wb")))
+		{
+		    SaveExternalTape(fp,z80);
+		    fclose(fp);
+		}
+	    }
+	    break;
+
+    	case ED_LOAD:
+	    /* Try and load the external file if a name given.  Otherwise, we
+	       try the internal one.  Some of this is slightly dodgy -- it was
+	       never intended for the emulator to be doing any GUI related
+	       nonsense (like the alerts) but simply emulating.
+	    */
+	    if (enable_filesystem && z80->DE.w<0x8000)
+	    {
+		FILE *fp;
+		int cancel;
+
+		if ((fp=OpenTapeFile(z80->DE.w, &cancel, "rb")))
+		{
+		    LoadExternalTape(fp,z80);
+		    fclose(fp);
+		}
+		else
+		{
+		    if (!cancel)
+		    {
+			GUI_Alert(FALSE,"Couldn't open tape");
+			SK_DisplayKeyboard();
+		    }
+		}
+	    }
+	    else
+	    {
+		if (tape_image)
+		{
+		    LoadInternalTape(z80);
+		}
+		else
+		{
+		    GUI_Alert(FALSE,"No tape image selected");
+		    SK_DisplayKeyboard();
+		}
+	    }
+
+	    mem[CDFLAG]=0xc0;
+	    break;
+
+	case ED_WAITKEY:
+	    waitkey=TRUE;
+	    started=TRUE;
+	    break;
+
+	case ED_ENDWAITKEY:
+	    waitkey=FALSE;
+	    break;
+
+	case ED_PAUSE:
+	    waitkey=TRUE;
+
+	    pause=z80->BC.w;
+
+	    while(pause-- && !(mem[CDFLAG]&1))
+	    {
+		SoftKeyEvent ev;
+
+		while (SK_GetEvent(&ev))
+		{
+		    ZX81HandleKey(ev.key,ev.pressed);
+		}
+
+	    	CheckTimers(z80,FRAME_TSTATES);
+	    }
+
+	    waitkey=FALSE;
+	    break;
+
+	default:
+	    break;
+    }
+
+    return TRUE;
+}
+
+
+/* ---------------------------------------- EXPORTED INTERFACES
+*/
+void ZX81Init(uint16 *text_vram, uint16* bitmap_vram, Z80 *z80)
+{
+    Z80Word f;
+
+    txt_screen = text_vram;
+    bmp_screen = bitmap_vram;
+
+    hires = FALSE;
+    hires_dfile = 0;
+    last_I = 0x1e;
+    DrawScreen = DrawScreen_TEXT;
+
+    ClearBitmap();
+
+    /* Load the ROM
+    */
+    memcpy(mem,zx81_bin,ROMLEN);
+
+    /* Patch the ROM
+    */
+    RomPatch();
+    Z80LodgeCallback(z80,eZ80_EDHook,EDCallback);
+    Z80LodgeCallback(z80,eZ80_Instruction,CheckTimers);
+
+    /* Mirror the ROM
+    */
+    memcpy(mem+ROMLEN,mem,ROMLEN);
+
+    /* Memory size (16K)
+    */
+    RAMBOT=0x4000;
+    RAMTOP=RAMBOT+0x4000;
+
+    for(f = RAMBOT; f <= RAMTOP; f++)
+    {
+    	mem[f] = 0;
+    }
+
+    for(f = 0; f < 8; f++)
+    {
+    	matrix[f] = 0x1f;
+    }
+
+    /* Fill the upper 32K with RET opcodes -- hopefully by simply returning
+       RET for ULA reads we save a lot of ROM patching shenanigans.
+       
+       Note that this check used to be in ZX81ReadMem, but obviously this 
+       should cut down on a *lot* of pointless expression evaluation!
+    */
+    for(f = 0x8000; f <= RAMTOP; f++)
+    {
+    	mem[f] = 0xc9;
+    }
+
+}
+
+
+void ZX81HandleKey(SoftKey key, int is_pressed)
+{
+    if (key<SK_CONFIG)
+    {
+	if (is_pressed)
+	{
+	    matrix[key_matrix[key].row]&=~key_matrix[key].bit;
+	}
+	else
+	{
+	    matrix[key_matrix[key].row]|=key_matrix[key].bit;
+	}
+    }
+    else
+    {
+    	/* TODO: Joysticks?  Were there any common ones for the 81? */
+    }
+}
+
+
+Z80Byte ZX81ReadMem(Z80 *z80, Z80Word addr)
+{
+    return mem[addr];
+}
+
+
+void ZX81WriteMem(Z80 *z80, Z80Word addr, Z80Byte val)
+{
+    if (addr>=RAMBOT && addr<=RAMTOP)
+    {
+	mem[addr]=val;
+    }
+}
+
+
+Z80Byte ZX81ReadPort(Z80 *z80, Z80Word port)
+{
+    Z80Byte b=0;
+
+    switch(port&0xff)
+    {
+    	case 0xfe:	/* ULA */
+	    /* Key matrix
+	    */
+	    switch(port&0xff00)
+	    {
+	    	case 0xfe00:
+		    b=matrix[0];
+		    break;
+	    	case 0xfd00:
+		    b=matrix[1];
+		    break;
+	    	case 0xfb00:
+		    b=matrix[2];
+		    break;
+	    	case 0xf700:
+		    b=matrix[3];
+		    break;
+	    	case 0xef00:
+		    b=matrix[4];
+		    break;
+	    	case 0xdf00:
+		    b=matrix[5];
+		    break;
+	    	case 0xbf00:
+		    b=matrix[6];
+		    break;
+	    	case 0x7f00:
+		    b=matrix[7];
+		    break;
+	    }
+
+	    /* Some code expects some of the top bits set...  Of course, whether
+	       or not this may be worse as other code doesn't expect the bits,
+	       we shall find out!
+	    */
+	    b |= 0x60;
+
+	    break;
+
+	default:
+	    b = 0xff;	/* Idle bus */
+	    break;
+    }
+
+    return b;
+}
+
+
+void ZX81WritePort(Z80 *z80, Z80Word port, Z80Byte val)
+{
+    switch(port&0xff)
+    {
+    	case 0xfd:
+	    break;
+
+	case 0xfe:
+	    break;
+    }
+}
+
+
+void ZX81Reset(Z80 *z80)
+{
+    int f;
+
+    for(f=0;f<8;f++)
+    	matrix[f]=0x1f;
+
+    Z80Reset(z80);
+    Z80ResetCycles(z80,0);
+
+    started=FALSE;
+
+    hires = FALSE;
+    hires_dfile = 0;
+    last_I = 0x1e;
+    DrawScreen = DrawScreen_TEXT;
+
+    ClearBitmap();
+}
+
+
+void ZX81EnableFileSystem(int enable)
+{
+    enable_filesystem=enable;
+}
+
+
+void ZX81SetTape(const Z80Byte *image, int len)
+{
+    tape_image=image;
+    tape_len=len;
+}
+
+
+void ZX81SuspendDisplay(void)
+{
+    ClearBitmap();
+    ClearText();
+}
+
+
+void ZX81ResumeDisplay(void)
+{
+    ClearText();
+
+    /* Reset last_I to force hi/lo res detection
+    */
+    last_I = 0;
+}
+
+
+void ZX81DisplayString(const char *p)
+{
+    uint16 *s;
+    uint16 inv=0;
+    int f;
+
+    ClearText();
+
+    s = txt_screen;
+    f = 0;
+
+    while(*p)
+    {
+	switch(*p)
+	{
+	    case '\n':
+		s+=32;
+		f=0;
+		break;
+
+	    case '%':
+	    	inv^=0x40;
+		break;
+
+	    default:
+		s[f++]=FromASCII(*p)|inv;
+		break;
+	}
+
+	p++;
+    }
+}
+
+
+void ZX81Reconfigure(void)
+{
+    if (DS81_Config[DS81_STATIC_RAM_AT_0x2000])
+    {
+    	RAMBOT = 0x2000;
+    }
+    else
+    {
+    	RAMBOT = 0x4000;
+	memcpy(mem+ROMLEN,mem,ROMLEN);
+    }
+
+    allow_save = enable_filesystem && DS81_Config[DS81_ALLOW_TAPE_SAVE];
+}
+
+
+void ZX81SaveSnapshot(FILE *fp)
+{
+    int f;
+
+    for(f=0; f<sizeof mem; f++)
+    {
+	PUT_Byte(fp, mem[f]);
+    }
+
+    for(f=0; f<sizeof matrix; f++)
+    {
+	PUT_Byte(fp, matrix[f]);
+    }
+
+    PUT_Long(fp, waitkey);
+    PUT_Long(fp, started);
+
+    PUT_ULong(fp, RAMBOT);
+    PUT_ULong(fp, RAMTOP);
+
+    PUT_ULong(fp, prev_lk1);
+    PUT_ULong(fp, prev_lk2);
+}
+
+
+void ZX81LoadSnapshot(FILE *fp)
+{
+    int f;
+
+    for(f=0; f<sizeof mem; f++)
+    {
+	mem[f] = GET_Byte(fp);
+    }
+
+    for(f=0; f<sizeof matrix; f++)
+    {
+	matrix[f] = GET_Byte(fp);
+    }
+
+    waitkey = GET_Long(fp);
+    started = GET_Long(fp);
+
+    RAMBOT = GET_ULong(fp);
+    RAMTOP = GET_ULong(fp);
+
+    prev_lk1 = GET_ULong(fp);
+    prev_lk2 = GET_ULong(fp);
+
+    /* Reset last_I to force hi/lo res detection
+    */
+    last_I = 0;
+}
+
+
+/* END OF FILE */