/* * Copyright (C) 1996-1998 Szeredi Miklos * Email: mszeredi@inf.bme.hu * * 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. See the file COPYING. * * 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., 675 Mass Ave, Cambridge, MA 02139, USA. * */ #include "zxmisc.h" #include "helpers.h" #include "spperif.h" #include "z80.h" #include "snapshot.h" #include "compr.h" #include "interf.h" #include "spconf.h" #include "interf.h" #include #include #include #define COMPRESS_SAVE 1 static char quick_snap_file[]= ROCKBOX_DIR "/zxboxq.z80"; typedef struct { int isfile; int fd; unsigned len; byte *at; } SNFILE; #define sngetc(snfp) ((snfp)->isfile ? getc((snfp)->fd) : snmgetc(snfp)) static int snmgetc(SNFILE *snfp) { if(!snfp->len) return EOF; snfp->len--; return *snfp->at++; } static int snread(void *ptr, int size, SNFILE *snfp) { int i; byte *dest; if(snfp->isfile) return (int) rb->read( snfp->fd,ptr, (size_t) size); dest = (byte *) ptr; for(i = 0; snfp->len && size; i++, snfp->len--, size--) *dest++ = *snfp->at++; return i; } /* These structures are taken from 'spconv' by Henk de Groot */ struct sna_s { byte i; byte lbk; byte hbk; byte ebk; byte dbk; byte cbk; byte bbk; byte fbk; byte abk; byte l; byte h; byte e; byte d; byte c; byte b; byte iyl; byte iyh; byte ixl; byte ixh; byte iff2; byte r; byte f; byte a; byte spl; byte sph; byte im; byte border; }; #define sna_size 27 /* sizeof(struct sna_s)=27 */ struct z80_1_s { byte a; /*00*/ byte f; /*01*/ byte c; /*02*/ byte b; /*03*/ byte l; /*04*/ byte h; /*05*/ byte pcl; /*06*/ byte pch; /*07*/ byte spl; /*08*/ byte sph; /*09*/ byte i; /*0A*/ byte r; /*0B*/ byte data; /*0C*/ byte e; /*0D*/ byte d; /*0E*/ byte cbk; /*0F*/ byte bbk; /*10*/ byte ebk; /*11*/ byte dbk; /*12*/ byte lbk; /*13*/ byte hbk; /*14*/ byte abk; /*15*/ byte fbk; /*16*/ byte iyl; /*17*/ byte iyh; /*18*/ byte ixl; /*19*/ byte ixh; /*1A*/ byte iff1; /*1B*/ byte iff2; /*1C*/ byte im; /*1D*/ }; #define z80_145_size 0x1e /* length of z80 V1.45 header */ struct z80_2_s { /* Extended 2.01 and 3.0 header, flagged with PC=0 */ byte h2_len_l; /*1E*/ byte h2_len_h; /*1F*/ byte n_pcl; /*20*/ byte n_pch; /*21*/ byte hardware; /*22*/ byte samram; /*23*/ byte if1_paged; /*24*/ byte r_ldir_emu; /*25*/ byte last_out; /*26*/ byte sound_reg[16]; /*27*/ /* Continues with extended 3.0 header, but this part is not used anyway */ }; #define z80_201_ext_size 23 /* length of extended z80 V2.01 header */ #define z80_300_ext_size 54 /* length of extended z80 V3.0 header */ struct z80_page_s { byte blklen_l; /*00*/ byte blklen_h; /*01*/ byte page_num; /*02*/ }; #define z80_pg_size 3 /* sizeof(struct z80_page_s)=3 */ static int savfd; static int memptr; int compr_read_byte(void) { if(memptr < 0x10000) return z80_proc.mem[memptr++]; else return -1; } void compr_put_byte(int i) { putc(i, savfd); } #define STORE_NORMAL_REGS(head) \ head.f = RF; /* F reg */ \ head.a = RA; /* A reg */ \ head.b = RB; /* B reg */ \ head.c = RC; /* C reg */ \ head.d = RD; /* D reg */ \ head.e = RE; /* E reg */ \ head.h = RH; /* H reg */ \ head.l = RL; /* L reg */ \ head.fbk = FBK; /* F' reg */ \ head.abk = ABK; /* A' reg */ \ head.bbk = BBK; /* B' reg */ \ head.cbk = CBK; /* C' reg */ \ head.dbk = DBK; /* D' reg */ \ head.ebk = EBK; /* E' reg */ \ head.hbk = HBK; /* H' reg */ \ head.lbk = LBK; /* L' reg */ \ head.iyh = YH; /* IY reg */ \ head.iyl = YL; \ head.ixh = XH; /* IX reg */ \ head.ixl = XL #define LOAD_NORMAL_REGS(head) \ RF = head.f; /* F reg */ \ RA = head.a; /* A reg */ \ RB = head.b; /* B reg */ \ RC = head.c; /* C reg */ \ RD = head.d; /* D reg */ \ RE = head.e; /* E reg */ \ RH = head.h; /* H reg */ \ RL = head.l; /* L reg */ \ FBK = head.fbk; /* F' reg */ \ ABK = head.abk; /* A' reg */ \ BBK = head.bbk; /* B' reg */ \ CBK = head.cbk; /* C' reg */ \ DBK = head.dbk; /* D' reg */ \ EBK = head.ebk; /* E' reg */ \ HBK = head.hbk; /* H' reg */ \ LBK = head.lbk; /* L' reg */ \ YH = head.iyh; /* IY reg */ \ YL = head.iyl; \ XH = head.ixh; /* IX reg */ \ XL = head.ixl static void snsh_z80_save(int fd) { struct z80_1_s z80; int to_comp = COMPRESS_SAVE; STORE_NORMAL_REGS(z80); z80.i = RI; /* I reg */ z80.r = RR; /* R reg */ z80.sph = SPH; /* SP reg */ z80.spl = SPL; z80.pch = PCH; /* PC reg */ z80.pcl = PCL; z80.iff1 = z80_proc.iff1; /* iff1 */ z80.iff2 = z80_proc.iff2; /* iff2 */ z80.im = (z80_proc.it_mode & 0x03) | 0x60; /* Bit 0-1: Interrupt mode (0, 1 or 2) Bit 2 : 1=Issue 2 emulation Bit 3 : 1=Double interrupt frequency Bit 4-5: 1=High video synchronisation 3=Low video synchronisation 0,2=Normal Bit 6-7: 0=Cursor/Protek/AGF joystick 1=Kempston joystick 2=Sinclair 1 joystick 3=Sinclair 2 joystick */ z80.data = ((RR >> 7) & 0x01) | ((z80_proc.ula_outport & 0x07) << 1) | (to_comp ? 0x20 : 0); /* Bit 0 : Bit 7 of the R-register Bit 1-3: Border colour Bit 4 : 1=Basic SamRom switched in Bit 5 : 1=Block of data is compressed Bit 6-7: No meaning */ rb->write(fd,&z80,z80_145_size); if(!to_comp) rb->write(fd,z80_proc.mem + 0x4000,0xC000); else { memptr = 0x4000; savfd = fd; compr(); } } static void snsh_sna_save(int fd) { struct sna_s sna; byte saves1, saves2; STORE_NORMAL_REGS(sna); sna.i = RI; /* I reg */ sna.r = RR; /* R reg */ sna.border = z80_proc.ula_outport & 0x07; SP -= 2; sna.sph = SPH; /* SP reg */ sna.spl = SPL; saves1 = z80_proc.mem[SP]; saves2 = z80_proc.mem[(dbyte)(SP+1)]; if(SP >= 0x4000) { z80_proc.mem[SP] = PCL; if(SP < 0xFFFF) z80_proc.mem[SP+1] = PCH; } sna.iff2 = z80_proc.iff2 ? 0xff : 0x00; /* iff2 */ sna.im = z80_proc.it_mode & 0x03; rb->write(fd,&sna, sna_size); rb->write(fd,z80_proc.mem + 0x4000, 0xC000); if(SP > 0x4000) { z80_proc.mem[SP] = saves1; if(SP < 0xFFFF) z80_proc.mem[SP+1] = saves2; } SP += 2; } #define GET_DATA(c) { \ if(!datalen) break; \ c = sngetc(fp); \ if(c == EOF) break; \ if(datalen > 0) datalen--; \ } static void read_compressed_data(SNFILE *fp, byte *start, unsigned size, long datalen) { int j; int times, last_ed, ch; byte *p, *end; p = start; end = start+size; last_ed = 0; while(p < end) { GET_DATA(ch); if(ch != 0xED) { last_ed = 0; *p++ = ch; } else { if(last_ed) { last_ed = 0; p--; GET_DATA(times); if(times == 0) break; GET_DATA(ch); if(p + times > end) { put_msg("Warning: Repeat parameter too large in snapshot"); times = (int) ((long) end - (long) p); } for(j = 0; j < times; j++) *p++ = ch; } else { last_ed = 1; *p++ = 0xED; } } } if(datalen < 0) { if(sngetc(fp) != 0 || sngetc(fp) != 0xED || sngetc(fp) != 0xED || sngetc(fp) != 0) put_msg("Warning: Illegal ending of snapshot"); } if(datalen > 0) { while(datalen) { if(sngetc(fp) == EOF) break; datalen--; } put_msg("Warning: Page too long in snapshot"); } if(p < end) put_msg("Warning: Page too short in snapshot"); } static int read_header(void *p, int size, SNFILE *fp) { int res; res = snread(p, size, fp); if(res != size) { put_msg("Error, End Of File in snapshot header"); return 0; } return 1; } static int read_z80_page(SNFILE *fp) { struct z80_page_s page; unsigned datalen; unsigned pos = 0; int validpage; int res; res = snread(&page, z80_pg_size, fp); if(res == 0) return 0; if(res != z80_pg_size) { put_msg("Error, End Of File in page header"); return 0; } datalen = (page.blklen_h << 8) | page.blklen_l; validpage = 1; switch(page.page_num) { case 4: pos = 0x8000; break; case 5: pos = 0xC000; break; case 8: pos = 0x4000; break; default: validpage = 0; while(datalen) { if(sngetc(fp) == EOF) { put_msg("Warning: Page too short in snapshot"); break; } datalen--; } } if(validpage) read_compressed_data(fp, z80_proc.mem+pos, 0x4000, (long) datalen); return 1; } static void snsh_z80_load(SNFILE *fp) { struct z80_1_s z80; if(!read_header(&z80, z80_145_size, fp)) return; if(z80.pch == 0 && z80.pcl == 0) { struct z80_2_s z80_2; int ext_size, rem; if(!read_header(&z80_2, 2, fp)) return; ext_size = z80_2.h2_len_l | (z80_2.h2_len_h << 8); if(ext_size < z80_201_ext_size) { put_msg("Error in Z80 header"); return; } if(!read_header(&z80_2.n_pcl, z80_201_ext_size, fp)) return; rem = ext_size - z80_201_ext_size; for(; rem; rem--) sngetc(fp); if(z80_2.hardware >= 3 && (ext_size == z80_201_ext_size || z80_2.hardware >= 4)) { put_msg("Can't load non 48k snapshot"); return; } if(z80_2.if1_paged) { put_msg("Can't load snapshot: IF1 roma paged in"); return; } PCH = z80_2.n_pch; PCL = z80_2.n_pcl; while(read_z80_page(fp)); } else { if(z80.data == 0xFF) z80.data = 1; if(z80.data & 0x20) read_compressed_data(fp, z80_proc.mem + 0x4000, 0xC000, -1); else { if(snread(z80_proc.mem + 0x4000, 0xC000, fp) != 0xC000) put_msg("Warning: Snapshot file too short (z80)"); else if(sngetc(fp) != EOF) put_msg("Warning: Snapshot file too long"); } PCH = z80.pch; PCL = z80.pcl; } LOAD_NORMAL_REGS(z80); RI = z80.i; /* I reg */ RR = (z80.r & 0x7F) | ((z80.data & 0x01) << 7); /* R reg */ SPH = z80.sph; /* SP reg */ SPL = z80.spl; z80_proc.ula_outport = (z80_proc.ula_outport & ~(0x07)) | ((z80.data >> 1) & 0x07); /* Bit 0 : Bit 7 of the R-register Bit 1-3: Border colour Bit 4 : 1=Basic SamRom switched in Bit 5 : 1=Block of data is compressed Bit 6-7: No meaning */ z80_proc.iff1 = z80.iff1 ? 1 : 0; z80_proc.iff2 = z80.iff2 ? 1 : 0; z80_proc.it_mode = z80.im & 0x03; /* Bit 0-1: Interrupt mode (0, 1 or 2) Bit 2 : 1=Issue 2 emulation Bit 3 : 1=Double interrupt frequency Bit 4-5: 1=High video synchronisation 3=Low video synchronisation 0,2=Normal Bit 6-7: 0=Cursor/Protek/AGF joystick 1=Kempston joystick 2=Sinclair 1 joystick 3=Sinclair 2 joystick */ z80_proc.haltstate = 0; sp_init_screen_mark(); } static void snsh_sna_load(SNFILE *fp) { struct sna_s sna; if(!read_header(&sna, sna_size, fp)) return; if(snread(z80_proc.mem+0x4000, 0xC000, fp) != 0xC000) put_msg("Warning: Snapshot file too short (sna)"); else if(sngetc(fp) != EOF) put_msg("Warning: Snapshot file too long"); LOAD_NORMAL_REGS(sna); RI = sna.i; /* I reg */ RR = sna.r; /* R reg */ z80_proc.ula_outport = (z80_proc.ula_outport & ~(0x07)) | (sna.border & 0x07); SPH = sna.sph; /* SP reg */ SPL = sna.spl; PCL = z80_proc.mem[SP]; if(SP >= 0x4000) z80_proc.mem[SP] = 0; SP++; PCH = z80_proc.mem[SP]; if(SP >= 0x4000) z80_proc.mem[SP] = 0; SP++; z80_proc.iff1 = z80_proc.iff2 = sna.iff2 ? 1 : 0; z80_proc.it_mode = sna.im & 0x03; z80_proc.haltstate = 0; sp_init_screen_mark(); } static void save_snapshot_file_type(char *name, int type) { int snsh; snsh = rb->open(name, O_WRONLY); if(snsh < 0) { snsh = rb->creat(name); if(snsh < 0) { put_msg("Could not create snapshot file"); return; } } if(type == SN_SNA) snsh_sna_save(snsh); else if(type == SN_Z80) snsh_z80_save(snsh); rb->close(snsh); } void save_snapshot_file(char *name) { int type; rb->strlcpy(filenamebuf, name, MAXFILENAME-10 + 1); type = SN_Z80; if(check_ext(filenamebuf, "z80")) type = SN_Z80; else if(check_ext(filenamebuf, "sna")) type = SN_SNA; else { add_extension(filenamebuf, "z80"); type = SN_Z80; } save_snapshot_file_type(filenamebuf, type); char msgbuf [MAXFILENAME]; rb->snprintf(msgbuf,MAXFILENAME, "Saved snapshot to file %s", filenamebuf); put_msg(msgbuf); } void save_quick_snapshot(void) { save_snapshot_file_type(quick_snap_file, SN_Z80); } void save_snapshot(void) { char name[MAXFILENAME]; name[0]='/'; name[1]='\0'; put_msg("Enter name of snapshot file to save:"); if (!rb->kbd_input((char*)&name, sizeof name)) save_snapshot_file(&name[0]); } void load_snapshot_file_type(char *name, int type) { int filetype = FT_SNAPSHOT; int snsh; SNFILE snfil; rb->strlcpy(filenamebuf, name, MAXFILENAME-10 + 1); spcf_find_file_type(filenamebuf, &filetype, &type); if(type < 0) type = SN_Z80; snsh = rb->open(filenamebuf, O_RDONLY); if(snsh < 0) { #ifndef USE_GRAY rb->splashf(HZ, "Could not open snapshot file `%s'",filenamebuf); #endif return; } snfil.isfile = 1; snfil.fd = snsh; if(type == SN_SNA) snsh_sna_load(&snfil); else if(type == SN_Z80) snsh_z80_load(&snfil); rb->close(snsh); } void snsh_z80_load_intern(byte *p, unsigned len) { SNFILE snfil; snfil.isfile = 0; snfil.at = p; snfil.len = len; snsh_z80_load(&snfil); } void load_quick_snapshot(void) { int qsnap; qsnap = rb->open(quick_snap_file,O_RDONLY); if(qsnap < 0) { put_msg("No quick snapshot saved yet"); return; } else rb->close ( qsnap ); load_snapshot_file_type(quick_snap_file, SN_Z80); } void load_snapshot(void) { char *name; put_msg("Enter name of snapshot file to load:"); name = spif_get_filename(); if(name == NULL) return; load_snapshot_file_type(name, -1); }