893 lines
23 KiB
C
893 lines
23 KiB
C
|
/*
|
||
|
* libtilemcore - Graphing calculator emulation library
|
||
|
*
|
||
|
* Copyright (C) 2009-2012 Benjamin Moody
|
||
|
*
|
||
|
* This library is free software; you can redistribute it and/or
|
||
|
* modify it under the terms of the GNU Lesser General Public License
|
||
|
* as published by the Free Software Foundation; either version 2.1 of
|
||
|
* the License, or (at your option) any later version.
|
||
|
*
|
||
|
* This library 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
|
||
|
* Lesser General Public License for more details.
|
||
|
*
|
||
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
* License along with this library; if not, see
|
||
|
* <http://www.gnu.org/licenses/>.
|
||
|
*/
|
||
|
|
||
|
#ifdef HAVE_CONFIG_H
|
||
|
# include <config.h>
|
||
|
#endif
|
||
|
|
||
|
#include <stdio.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <string.h>
|
||
|
#include "tilem.h"
|
||
|
#include "z80.h"
|
||
|
|
||
|
static void set_hw_reg(TilemCalc* calc, const char* name, dword value)
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
for (i = 0; i < calc->hw.nhwregs; i++) {
|
||
|
if (!strcmp(name, calc->hw.hwregnames[i])) {
|
||
|
calc->hwregs[i] = value;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
tilem_warning(calc, "Unknown hwreg %s", name);
|
||
|
}
|
||
|
|
||
|
static const char* get_timer_name(TilemCalc* calc, int id)
|
||
|
{
|
||
|
if (id == TILEM_TIMER_LCD_DELAY)
|
||
|
return "lcddelay";
|
||
|
else if (id == TILEM_TIMER_FLASH_DELAY)
|
||
|
return "flashdelay";
|
||
|
else if (id == TILEM_TIMER_LINK_ASSIST)
|
||
|
return "linkassist";
|
||
|
else if (id == TILEM_TIMER_USER1)
|
||
|
return "user1";
|
||
|
else if (id == TILEM_TIMER_USER2)
|
||
|
return "user2";
|
||
|
else if (id == TILEM_TIMER_USER3)
|
||
|
return "user3";
|
||
|
else if (id <= TILEM_NUM_SYS_TIMERS)
|
||
|
abort();
|
||
|
|
||
|
id -= TILEM_NUM_SYS_TIMERS + 1;
|
||
|
if (id < calc->hw.nhwtimers)
|
||
|
return calc->hw.hwtimernames[id];
|
||
|
else
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
static void set_ptimer(TilemCalc* calc, const char* name, dword value,
|
||
|
dword period, int rt)
|
||
|
{
|
||
|
int i;
|
||
|
const char* tname;
|
||
|
|
||
|
for (i = 1; i <= calc->z80.ntimers; i++) {
|
||
|
tname = get_timer_name(calc, i);
|
||
|
if (tname && !strcmp(name, tname)) {
|
||
|
tilem_z80_set_timer(calc, i, value, period, rt);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
tilem_warning(calc, "Unknown timer %s", name);
|
||
|
}
|
||
|
|
||
|
static int load_old_sav_file(TilemCalc* calc, FILE* savfile)
|
||
|
{
|
||
|
byte b[76];
|
||
|
dword regs[19];
|
||
|
int i, le, be, c;
|
||
|
unsigned int pageA, pageB;
|
||
|
|
||
|
/* Read memory mapping */
|
||
|
|
||
|
if (fread(calc->mempagemap, 1, 4, savfile) < 4)
|
||
|
return 1;
|
||
|
|
||
|
/* Read CPU registers */
|
||
|
|
||
|
if (fread(b, 1, 76, savfile) < 76)
|
||
|
return 1;
|
||
|
|
||
|
be = le = 0;
|
||
|
|
||
|
/* determine if file is in big-endian or little-endian
|
||
|
format */
|
||
|
|
||
|
for (i = 0; i < 19; i++) {
|
||
|
if (b[i * 4] || b[i * 4 + 1])
|
||
|
le++;
|
||
|
if (b[i * 4 + 2] || b[i * 4 + 3])
|
||
|
be++;
|
||
|
}
|
||
|
|
||
|
if (le > be) {
|
||
|
for (i = 0; i < 19; i++) {
|
||
|
regs[i] = b[i * 4] + (b[i * 4 + 1] << 8);
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
for (i = 0; i < 19; i++) {
|
||
|
regs[i] = b[i * 4 + 3] + (b[i * 4 + 2] << 8);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
calc->z80.r.af.d = regs[0];
|
||
|
calc->z80.r.bc.d = regs[1];
|
||
|
calc->z80.r.de.d = regs[2];
|
||
|
calc->z80.r.hl.d = regs[3];
|
||
|
calc->z80.r.ix.d = regs[4];
|
||
|
calc->z80.r.iy.d = regs[5];
|
||
|
calc->z80.r.pc.d = regs[6];
|
||
|
calc->z80.r.sp.d = regs[7];
|
||
|
calc->z80.r.af2.d = regs[8];
|
||
|
calc->z80.r.bc2.d = regs[9];
|
||
|
calc->z80.r.de2.d = regs[10];
|
||
|
calc->z80.r.hl2.d = regs[11];
|
||
|
calc->z80.r.iff1 = regs[12] ? 1 : 0;
|
||
|
calc->z80.r.iff2 = regs[13] ? 1 : 0;
|
||
|
calc->z80.r.im = regs[15];
|
||
|
calc->z80.r.ir.b.h = regs[16];
|
||
|
calc->z80.r.ir.b.l = regs[17];
|
||
|
calc->z80.r.r7 = regs[18] & 0x80;
|
||
|
|
||
|
if (calc->hw.model_id == '2' || calc->hw.model_id == '3') {
|
||
|
if (fread(b, 1, 5, savfile) < 5)
|
||
|
return 1;
|
||
|
|
||
|
if (calc->hw.model_id == '3')
|
||
|
set_hw_reg(calc, "rom_bank", calc->mempagemap[1] & 0x08);
|
||
|
calc->hw.z80_out(calc, 0x02, b[4]);
|
||
|
}
|
||
|
|
||
|
/* Read RAM contents: old save files for TI-82/83/85 store RAM
|
||
|
pages in logical rather than physical order */
|
||
|
|
||
|
if (calc->hw.model_id == '2' || calc->hw.model_id == '3'
|
||
|
|| calc->hw.model_id == '5') {
|
||
|
if (fread(calc->mem + calc->hw.romsize + 0x4000, 1,
|
||
|
0x4000, savfile) < 0x4000)
|
||
|
return 1;
|
||
|
if (fread(calc->mem + calc->hw.romsize, 1,
|
||
|
0x4000, savfile) < 0x4000)
|
||
|
return 1;
|
||
|
}
|
||
|
else {
|
||
|
if (fread(calc->mem + calc->hw.romsize, 1,
|
||
|
calc->hw.ramsize, savfile) < calc->hw.ramsize)
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
/* Read LCD contents */
|
||
|
|
||
|
if (calc->hw.flags & TILEM_CALC_HAS_T6A04) {
|
||
|
calc->lcd.rowstride = 12; /* old save files only
|
||
|
support the visible
|
||
|
portion of the screen */
|
||
|
if (fread(calc->lcdmem, 1, 768, savfile) < 768)
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
/* Read additional HW state */
|
||
|
|
||
|
switch (calc->hw.model_id) {
|
||
|
case '1':
|
||
|
break;
|
||
|
|
||
|
case '2':
|
||
|
case '3':
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.mode = c;
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.x = c;
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.y = c;
|
||
|
break;
|
||
|
|
||
|
case '5':
|
||
|
pageA = calc->mempagemap[1];
|
||
|
if (pageA >= 0x08)
|
||
|
pageA += 0x38;
|
||
|
calc->hw.z80_out(calc, 0x05, pageA);
|
||
|
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->hw.z80_out(calc, 0x06, c);
|
||
|
break;
|
||
|
|
||
|
case '6':
|
||
|
pageA = calc->mempagemap[1];
|
||
|
pageB = calc->mempagemap[2];
|
||
|
if (pageA >= 0x10)
|
||
|
pageA += 0x30;
|
||
|
if (pageB >= 0x10)
|
||
|
pageB += 0x30;
|
||
|
|
||
|
calc->hw.z80_out(calc, 0x05, pageA);
|
||
|
calc->hw.z80_out(calc, 0x06, pageB);
|
||
|
break;
|
||
|
|
||
|
default: /* TI-73/83+ series */
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.mode = c;
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.x = c;
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.y = c;
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->lcd.inc = c;
|
||
|
|
||
|
if ((c = fgetc(savfile)) == EOF)
|
||
|
c = 0;
|
||
|
if (c) {
|
||
|
pageA = calc->mempagemap[2];
|
||
|
pageB = calc->mempagemap[3];
|
||
|
calc->hw.z80_out(calc, 0x04, 0x77);
|
||
|
}
|
||
|
else {
|
||
|
pageA = calc->mempagemap[1];
|
||
|
pageB = calc->mempagemap[2];
|
||
|
calc->hw.z80_out(calc, 0x04, 0x76);
|
||
|
}
|
||
|
|
||
|
if (pageA >= (calc->hw.romsize >> 14))
|
||
|
pageA = ((pageA & 0x1f) | calc->hw.rampagemask);
|
||
|
if (pageB >= (calc->hw.romsize >> 14))
|
||
|
pageB = ((pageB & 0x1f) | calc->hw.rampagemask);
|
||
|
|
||
|
calc->hw.z80_out(calc, 0x06, pageA);
|
||
|
calc->hw.z80_out(calc, 0x07, pageB);
|
||
|
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->flash.state = c;
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->flash.unlock = c;
|
||
|
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->hw.z80_out(calc, 0x20, c);
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
set_hw_reg(calc, "port21", c);
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
set_hw_reg(calc, "port22", c);
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
set_hw_reg(calc, "port23", c);
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->hw.z80_out(calc, 0x27, c);
|
||
|
if ((c = fgetc(savfile)) != EOF)
|
||
|
calc->hw.z80_out(calc, 0x28, c);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
calc->poweronhalt = calc->lcd.active = 1;
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static int read_sav_line(FILE* savfile, char **buf)
|
||
|
{
|
||
|
int c, n, na;
|
||
|
|
||
|
tilem_free(*buf);
|
||
|
|
||
|
na = 100;
|
||
|
*buf = tilem_malloc_atomic(na);
|
||
|
n = 0;
|
||
|
|
||
|
while ((c = fgetc(savfile)) != EOF) {
|
||
|
if (c == '\r' || c == '\n')
|
||
|
break;
|
||
|
|
||
|
n++;
|
||
|
if (n >= na) {
|
||
|
na = n * 2;
|
||
|
*buf = tilem_realloc(*buf, na);
|
||
|
}
|
||
|
|
||
|
if (c == '#')
|
||
|
c = 0;
|
||
|
(*buf)[n - 1] = c;
|
||
|
}
|
||
|
|
||
|
if (n == 0 && c == EOF) {
|
||
|
tilem_free(*buf);
|
||
|
*buf = NULL;
|
||
|
return 0;
|
||
|
}
|
||
|
else {
|
||
|
(*buf)[n] = 0;
|
||
|
return 1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static int parse_sav_definition(char* line, char** value)
|
||
|
{
|
||
|
char *p;
|
||
|
|
||
|
p = strchr(line, '=');
|
||
|
if (!p)
|
||
|
return 0;
|
||
|
|
||
|
while (p != line && p[-1] == ' ')
|
||
|
p--;
|
||
|
*p = 0;
|
||
|
p++;
|
||
|
while (*p == ' ' || *p == '=')
|
||
|
p++;
|
||
|
*value = p;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
static int load_new_sav_file(TilemCalc* calc, FILE* savfile)
|
||
|
{
|
||
|
char *buf = NULL;
|
||
|
char *p, *q;
|
||
|
dword value, length;
|
||
|
byte *data;
|
||
|
int ok = 0;
|
||
|
byte digit;
|
||
|
int firstdigit;
|
||
|
dword period;
|
||
|
int rt;
|
||
|
|
||
|
while (read_sav_line(savfile, &buf)) {
|
||
|
if (!parse_sav_definition(buf, &p))
|
||
|
continue;
|
||
|
|
||
|
if (*p == '{') {
|
||
|
p++;
|
||
|
if (!strcmp(buf, "RAM")) {
|
||
|
length = calc->hw.ramsize;
|
||
|
data = calc->ram;
|
||
|
}
|
||
|
else if (!strcmp(buf, "LCD")) {
|
||
|
length = calc->hw.lcdmemsize;
|
||
|
data = calc->lcdmem;
|
||
|
}
|
||
|
else {
|
||
|
length = 0;
|
||
|
data = NULL;
|
||
|
}
|
||
|
|
||
|
value = 0;
|
||
|
firstdigit = 1;
|
||
|
|
||
|
while (*p != '}') {
|
||
|
if (*p == 0 || *p == '#') {
|
||
|
if (!read_sav_line(savfile, &buf))
|
||
|
return 1;
|
||
|
p = buf;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if (*p >= '0' && *p <= '9') {
|
||
|
digit = *p - '0';
|
||
|
p++;
|
||
|
}
|
||
|
else if (*p >= 'A' && *p <= 'F') {
|
||
|
digit = *p + 10 - 'A';
|
||
|
p++;
|
||
|
}
|
||
|
else if (*p >= 'a' && *p <= 'f') {
|
||
|
digit = *p + 10 - 'a';
|
||
|
p++;
|
||
|
}
|
||
|
else {
|
||
|
p++;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if (firstdigit) {
|
||
|
value = digit << 4;
|
||
|
firstdigit = 0;
|
||
|
}
|
||
|
else {
|
||
|
value |= digit;
|
||
|
if (length != 0) {
|
||
|
*data = value;
|
||
|
data++;
|
||
|
length--;
|
||
|
}
|
||
|
firstdigit = 1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if (!strcmp(buf, "MODEL")) {
|
||
|
q = p;
|
||
|
while (*q >= ' ')
|
||
|
q++;
|
||
|
*q = 0;
|
||
|
if (strcmp(p, calc->hw.name)) {
|
||
|
tilem_free(buf);
|
||
|
return 1;
|
||
|
}
|
||
|
ok = 1;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
value = strtol(p, &q, 16);
|
||
|
|
||
|
/* Persistent timers */
|
||
|
if (!strncmp(buf, "timer:", 6)) {
|
||
|
while (*q == ' ')
|
||
|
q++;
|
||
|
if (*q != ',')
|
||
|
continue;
|
||
|
q++;
|
||
|
while (*q == ' ')
|
||
|
q++;
|
||
|
period = strtol(q, &q, 16);
|
||
|
|
||
|
while (*q == ' ')
|
||
|
q++;
|
||
|
if (*q != ',')
|
||
|
continue;
|
||
|
q++;
|
||
|
while (*q == ' ')
|
||
|
q++;
|
||
|
rt = strtol(q, &q, 16);
|
||
|
|
||
|
set_ptimer(calc, buf + 6, value, period, rt);
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
/* Z80 */
|
||
|
if (!strcmp(buf, "af")) calc->z80.r.af.d = value;
|
||
|
else if (!strcmp(buf, "bc")) calc->z80.r.bc.d = value;
|
||
|
else if (!strcmp(buf, "de")) calc->z80.r.de.d = value;
|
||
|
else if (!strcmp(buf, "hl")) calc->z80.r.hl.d = value;
|
||
|
else if (!strcmp(buf, "af'")) calc->z80.r.af2.d = value;
|
||
|
else if (!strcmp(buf, "bc'")) calc->z80.r.bc2.d = value;
|
||
|
else if (!strcmp(buf, "de'")) calc->z80.r.de2.d = value;
|
||
|
else if (!strcmp(buf, "hl'")) calc->z80.r.hl2.d = value;
|
||
|
else if (!strcmp(buf, "ix")) calc->z80.r.ix.d = value;
|
||
|
else if (!strcmp(buf, "iy")) calc->z80.r.iy.d = value;
|
||
|
else if (!strcmp(buf, "pc")) calc->z80.r.pc.d = value;
|
||
|
else if (!strcmp(buf, "sp")) calc->z80.r.sp.d = value;
|
||
|
else if (!strcmp(buf, "ir")) {
|
||
|
calc->z80.r.ir.d = value;
|
||
|
calc->z80.r.r7 = value & 0x80;
|
||
|
}
|
||
|
else if (!strcmp(buf, "wz")) calc->z80.r.wz.d = value;
|
||
|
else if (!strcmp(buf, "wz'")) calc->z80.r.wz2.d = value;
|
||
|
else if (!strcmp(buf, "iff1")) calc->z80.r.iff1 = value;
|
||
|
else if (!strcmp(buf, "iff2")) calc->z80.r.iff2 = value;
|
||
|
else if (!strcmp(buf, "im")) calc->z80.r.im = value;
|
||
|
else if (!strcmp(buf, "interrupts"))
|
||
|
calc->z80.interrupts = value;
|
||
|
else if (!strcmp(buf, "clockspeed"))
|
||
|
calc->z80.clockspeed = value;
|
||
|
else if (!strcmp(buf, "halted")) calc->z80.halted = value;
|
||
|
|
||
|
/* LCD */
|
||
|
else if (!strcmp(buf, "lcd.active"))
|
||
|
calc->lcd.active = value;
|
||
|
else if (!strcmp(buf, "lcd.addr"))
|
||
|
calc->lcd.addr = value;
|
||
|
else if (!strcmp(buf, "lcd.rowshift"))
|
||
|
calc->lcd.rowshift = value;
|
||
|
else if (!strcmp(buf, "lcd.contrast"))
|
||
|
calc->lcd.contrast = value;
|
||
|
else if (!strcmp(buf, "lcd.inc"))
|
||
|
calc->lcd.inc = value;
|
||
|
else if (!strcmp(buf, "lcd.mode"))
|
||
|
calc->lcd.mode = value;
|
||
|
else if (!strcmp(buf, "lcd.x"))
|
||
|
calc->lcd.x = value;
|
||
|
else if (!strcmp(buf, "lcd.y"))
|
||
|
calc->lcd.y = value;
|
||
|
else if (!strcmp(buf, "lcd.nextbyte"))
|
||
|
calc->lcd.nextbyte = value;
|
||
|
else if (!strcmp(buf, "lcd.rowstride"))
|
||
|
calc->lcd.rowstride = value;
|
||
|
else if (!strcmp(buf, "lcd.busy"))
|
||
|
calc->lcd.busy = value;
|
||
|
|
||
|
/* Link port */
|
||
|
else if (!strcmp(buf, "linkport.lines"))
|
||
|
calc->linkport.lines = value;
|
||
|
else if (!strcmp(buf, "linkport.mode"))
|
||
|
calc->linkport.mode = value;
|
||
|
else if (!strcmp(buf, "linkport.assistflags"))
|
||
|
calc->linkport.assistflags = value;
|
||
|
else if (!strcmp(buf, "linkport.assistin"))
|
||
|
calc->linkport.assistin = value;
|
||
|
else if (!strcmp(buf, "linkport.assistinbits"))
|
||
|
calc->linkport.assistinbits = value;
|
||
|
else if (!strcmp(buf, "linkport.assistout"))
|
||
|
calc->linkport.assistout = value;
|
||
|
else if (!strcmp(buf, "linkport.assistoutbits"))
|
||
|
calc->linkport.assistoutbits = value;
|
||
|
else if (!strcmp(buf, "linkport.assistlastbyte"))
|
||
|
calc->linkport.assistlastbyte = value;
|
||
|
|
||
|
/* Keypad */
|
||
|
else if (!strcmp(buf, "keypad.group"))
|
||
|
calc->keypad.group = value;
|
||
|
else if (!strcmp(buf, "keypad.onkeyint"))
|
||
|
calc->keypad.onkeyint = value;
|
||
|
|
||
|
/* MD5 assist */
|
||
|
else if (!strcmp(buf, "md5assist.a"))
|
||
|
calc->md5assist.regs[0] = value;
|
||
|
else if (!strcmp(buf, "md5assist.b"))
|
||
|
calc->md5assist.regs[1] = value;
|
||
|
else if (!strcmp(buf, "md5assist.c"))
|
||
|
calc->md5assist.regs[2] = value;
|
||
|
else if (!strcmp(buf, "md5assist.d"))
|
||
|
calc->md5assist.regs[3] = value;
|
||
|
else if (!strcmp(buf, "md5assist.x"))
|
||
|
calc->md5assist.regs[4] = value;
|
||
|
else if (!strcmp(buf, "md5assist.t"))
|
||
|
calc->md5assist.regs[5] = value;
|
||
|
else if (!strcmp(buf, "md5assist.shift"))
|
||
|
calc->md5assist.shift = value;
|
||
|
else if (!strcmp(buf, "md5assist.mode"))
|
||
|
calc->md5assist.mode = value;
|
||
|
|
||
|
/* Programmable timers */
|
||
|
else if (!strcmp(buf, "usertimer0.frequency"))
|
||
|
calc->usertimers[0].frequency = value;
|
||
|
else if (!strcmp(buf, "usertimer0.loopvalue"))
|
||
|
calc->usertimers[0].loopvalue = value;
|
||
|
else if (!strcmp(buf, "usertimer0.status"))
|
||
|
calc->usertimers[0].status = value;
|
||
|
else if (!strcmp(buf, "usertimer1.frequency"))
|
||
|
calc->usertimers[1].frequency = value;
|
||
|
else if (!strcmp(buf, "usertimer1.loopvalue"))
|
||
|
calc->usertimers[1].loopvalue = value;
|
||
|
else if (!strcmp(buf, "usertimer1.status"))
|
||
|
calc->usertimers[1].status = value;
|
||
|
else if (!strcmp(buf, "usertimer2.frequency"))
|
||
|
calc->usertimers[2].frequency = value;
|
||
|
else if (!strcmp(buf, "usertimer2.loopvalue"))
|
||
|
calc->usertimers[2].loopvalue = value;
|
||
|
else if (!strcmp(buf, "usertimer2.status"))
|
||
|
calc->usertimers[2].status = value;
|
||
|
|
||
|
/* Main power */
|
||
|
else if (!strcmp(buf, "poweronhalt"))
|
||
|
calc->poweronhalt = value;
|
||
|
|
||
|
/* Battery */
|
||
|
else if (!strcmp(buf, "battery"))
|
||
|
calc->battery = value;
|
||
|
|
||
|
/* Memory */
|
||
|
else if (!strcmp(buf, "mempagemap0"))
|
||
|
calc->mempagemap[0] = value;
|
||
|
else if (!strcmp(buf, "mempagemap1"))
|
||
|
calc->mempagemap[1] = value;
|
||
|
else if (!strcmp(buf, "mempagemap2"))
|
||
|
calc->mempagemap[2] = value;
|
||
|
else if (!strcmp(buf, "mempagemap3"))
|
||
|
calc->mempagemap[3] = value;
|
||
|
else if (!strcmp(buf, "flash.unlock"))
|
||
|
calc->flash.unlock = value;
|
||
|
else if (!strcmp(buf, "flash.state"))
|
||
|
calc->flash.state = value;
|
||
|
else if (!strcmp(buf, "flash.busy"))
|
||
|
calc->flash.busy = value;
|
||
|
else if (!strcmp(buf, "flash.progaddr"))
|
||
|
calc->flash.progaddr = value;
|
||
|
else if (!strcmp(buf, "flash.progbyte"))
|
||
|
calc->flash.progbyte = value;
|
||
|
else if (!strcmp(buf, "flash.toggles"))
|
||
|
calc->flash.toggles = value;
|
||
|
else if (!strcmp(buf, "flash.overridegroup"))
|
||
|
calc->flash.overridegroup = value;
|
||
|
|
||
|
else
|
||
|
set_hw_reg(calc, buf, value);
|
||
|
}
|
||
|
|
||
|
tilem_free(buf);
|
||
|
|
||
|
return !ok;
|
||
|
}
|
||
|
|
||
|
int tilem_calc_load_state(TilemCalc* calc, FILE* romfile, FILE* savfile)
|
||
|
{
|
||
|
int b;
|
||
|
int savtype = 0;
|
||
|
|
||
|
if (romfile) {
|
||
|
if (fread(calc->mem, 1, calc->hw.romsize, romfile)
|
||
|
!= calc->hw.romsize)
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
tilem_calc_reset(calc);
|
||
|
|
||
|
if (savfile) {
|
||
|
/* first byte of old save files is always zero */
|
||
|
b = fgetc(savfile);
|
||
|
fseek(savfile, 0L, SEEK_SET);
|
||
|
|
||
|
if (b == 0) {
|
||
|
if (load_old_sav_file(calc, savfile)) {
|
||
|
tilem_calc_reset(calc);
|
||
|
return 1;
|
||
|
}
|
||
|
else
|
||
|
savtype = 1;
|
||
|
}
|
||
|
else {
|
||
|
if (load_new_sav_file(calc, savfile)) {
|
||
|
tilem_calc_reset(calc);
|
||
|
return 1;
|
||
|
}
|
||
|
else
|
||
|
savtype = 2;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (calc->hw.stateloaded)
|
||
|
(*calc->hw.stateloaded)(calc, savtype);
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
char tilem_get_sav_type(FILE* savfile)
|
||
|
{
|
||
|
int b;
|
||
|
char *buf = NULL, *p, *q;
|
||
|
const TilemHardware **models;
|
||
|
int nmodels, i;
|
||
|
char id = 0;
|
||
|
|
||
|
tilem_get_supported_hardware(&models, &nmodels);
|
||
|
|
||
|
/* first byte of old save files is always zero */
|
||
|
b = fgetc(savfile);
|
||
|
fseek(savfile, 0L, SEEK_SET);
|
||
|
if (b == 0)
|
||
|
return 0; /* old files give no way to detect model */
|
||
|
|
||
|
while (read_sav_line(savfile, &buf)) {
|
||
|
if (parse_sav_definition(buf, &p)
|
||
|
&& !strcmp(buf, "MODEL")) {
|
||
|
q = p;
|
||
|
while (*q >= ' ')
|
||
|
q++;
|
||
|
*q = 0;
|
||
|
|
||
|
for (i = 0; i < nmodels; i++)
|
||
|
if (!strcmp(p, models[i]->name))
|
||
|
id = models[i]->model_id;
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fseek(savfile, 0L, SEEK_SET);
|
||
|
tilem_free(buf);
|
||
|
return id;
|
||
|
}
|
||
|
|
||
|
int tilem_calc_save_state(TilemCalc* calc, FILE* romfile, FILE* savfile)
|
||
|
{
|
||
|
dword i;
|
||
|
dword t;
|
||
|
int j;
|
||
|
const char* tname;
|
||
|
unsigned int rowstride;
|
||
|
|
||
|
if (romfile) {
|
||
|
if (fwrite(calc->mem, 1, calc->hw.romsize, romfile)
|
||
|
!= calc->hw.romsize)
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
if (savfile) {
|
||
|
fprintf(savfile, "# Tilem II State File\n# Version: %s\n",
|
||
|
PACKAGE_VERSION);
|
||
|
fprintf(savfile, "MODEL = %s\n", calc->hw.name);
|
||
|
|
||
|
fprintf(savfile, "\n## CPU ##\n");
|
||
|
fprintf(savfile, "af = %04X\n", calc->z80.r.af.w.l);
|
||
|
fprintf(savfile, "bc = %04X\n", calc->z80.r.bc.w.l);
|
||
|
fprintf(savfile, "de = %04X\n", calc->z80.r.de.w.l);
|
||
|
fprintf(savfile, "hl = %04X\n", calc->z80.r.hl.w.l);
|
||
|
fprintf(savfile, "af' = %04X\n", calc->z80.r.af2.w.l);
|
||
|
fprintf(savfile, "bc' = %04X\n", calc->z80.r.bc2.w.l);
|
||
|
fprintf(savfile, "de' = %04X\n", calc->z80.r.de2.w.l);
|
||
|
fprintf(savfile, "hl' = %04X\n", calc->z80.r.hl2.w.l);
|
||
|
fprintf(savfile, "ix = %04X\n", calc->z80.r.ix.w.l);
|
||
|
fprintf(savfile, "iy = %04X\n", calc->z80.r.iy.w.l);
|
||
|
fprintf(savfile, "pc = %04X\n", calc->z80.r.pc.w.l);
|
||
|
fprintf(savfile, "sp = %04X\n", calc->z80.r.sp.w.l);
|
||
|
fprintf(savfile, "ir = %04X\n",
|
||
|
((calc->z80.r.ir.w.l & ~0x80) | calc->z80.r.r7));
|
||
|
fprintf(savfile, "wz = %04X\n", calc->z80.r.wz.w.l);
|
||
|
fprintf(savfile, "wz' = %04X\n", calc->z80.r.wz2.w.l);
|
||
|
fprintf(savfile, "iff1 = %X\n", calc->z80.r.iff1);
|
||
|
fprintf(savfile, "iff2 = %X\n", calc->z80.r.iff2);
|
||
|
fprintf(savfile, "im = %X\n", calc->z80.r.im);
|
||
|
fprintf(savfile, "interrupts = %08X\n", calc->z80.interrupts);
|
||
|
fprintf(savfile, "clockspeed = %X\n", calc->z80.clockspeed);
|
||
|
fprintf(savfile, "halted = %X\n", calc->z80.halted);
|
||
|
|
||
|
fprintf(savfile, "\n## LCD Driver ##\n");
|
||
|
fprintf(savfile, "lcd.active = %X\n",
|
||
|
calc->lcd.active);
|
||
|
fprintf(savfile, "lcd.contrast = %X\n",
|
||
|
calc->lcd.contrast);
|
||
|
fprintf(savfile, "lcd.rowstride = %X\n",
|
||
|
calc->lcd.rowstride);
|
||
|
if (calc->hw.flags & TILEM_CALC_HAS_T6A04) {
|
||
|
fprintf(savfile, "lcd.rowshift = %X\n",
|
||
|
calc->lcd.rowshift);
|
||
|
fprintf(savfile, "lcd.inc = %X\n",
|
||
|
calc->lcd.inc);
|
||
|
fprintf(savfile, "lcd.mode = %X\n",
|
||
|
calc->lcd.mode);
|
||
|
fprintf(savfile, "lcd.x = %02X\n",
|
||
|
calc->lcd.x);
|
||
|
fprintf(savfile, "lcd.y = %02X\n",
|
||
|
calc->lcd.y);
|
||
|
fprintf(savfile, "lcd.nextbyte = %02X\n",
|
||
|
calc->lcd.nextbyte);
|
||
|
fprintf(savfile, "lcd.busy = %X\n",
|
||
|
calc->lcd.busy);
|
||
|
}
|
||
|
fprintf(savfile, "lcd.addr = %X\n", calc->lcd.addr);
|
||
|
|
||
|
if (calc->hw.flags & TILEM_CALC_HAS_LINK) {
|
||
|
fprintf(savfile, "\n## Link Port ##\n");
|
||
|
fprintf(savfile, "linkport.lines = %X\n",
|
||
|
calc->linkport.lines);
|
||
|
fprintf(savfile, "linkport.mode = %08X\n",
|
||
|
calc->linkport.mode);
|
||
|
}
|
||
|
if (calc->hw.flags & TILEM_CALC_HAS_LINK_ASSIST) {
|
||
|
fprintf(savfile, "linkport.assistflags = %08X\n",
|
||
|
calc->linkport.assistflags);
|
||
|
fprintf(savfile, "linkport.assistin = %02X\n",
|
||
|
calc->linkport.assistin);
|
||
|
fprintf(savfile, "linkport.assistinbits = %X\n",
|
||
|
calc->linkport.assistinbits);
|
||
|
fprintf(savfile, "linkport.assistout = %02X\n",
|
||
|
calc->linkport.assistout);
|
||
|
fprintf(savfile, "linkport.assistoutbits = %X\n",
|
||
|
calc->linkport.assistoutbits);
|
||
|
fprintf(savfile, "linkport.assistlastbyte = %02X\n",
|
||
|
calc->linkport.assistlastbyte);
|
||
|
}
|
||
|
|
||
|
fprintf(savfile, "\n## Keypad ##\n");
|
||
|
fprintf(savfile, "keypad.group = %X\n", calc->keypad.group);
|
||
|
fprintf(savfile, "keypad.onkeyint = %X\n",
|
||
|
calc->keypad.onkeyint);
|
||
|
|
||
|
fprintf(savfile, "\n## Memory mapping ##\n");
|
||
|
fprintf(savfile, "mempagemap0 = %X\n", calc->mempagemap[0]);
|
||
|
fprintf(savfile, "mempagemap1 = %X\n", calc->mempagemap[1]);
|
||
|
fprintf(savfile, "mempagemap2 = %X\n", calc->mempagemap[2]);
|
||
|
fprintf(savfile, "mempagemap3 = %X\n", calc->mempagemap[3]);
|
||
|
|
||
|
fprintf(savfile, "\n## Power ##\n");
|
||
|
fprintf(savfile, "poweronhalt = %X\n", calc->poweronhalt);
|
||
|
fprintf(savfile, "battery = %X\n", calc->battery);
|
||
|
|
||
|
if (calc->hw.flags & TILEM_CALC_HAS_FLASH) {
|
||
|
fprintf(savfile, "\n## Flash ##\n");
|
||
|
fprintf(savfile, "flash.unlock = %X\n",
|
||
|
calc->flash.unlock);
|
||
|
fprintf(savfile, "flash.state = %X\n",
|
||
|
calc->flash.state);
|
||
|
fprintf(savfile, "flash.busy = %X\n",
|
||
|
calc->flash.busy);
|
||
|
fprintf(savfile, "flash.progaddr = %X\n",
|
||
|
calc->flash.progaddr);
|
||
|
fprintf(savfile, "flash.progbyte = %X\n",
|
||
|
calc->flash.progbyte);
|
||
|
fprintf(savfile, "flash.toggles = %X\n",
|
||
|
calc->flash.toggles);
|
||
|
fprintf(savfile, "flash.overridegroup = %X\n",
|
||
|
calc->flash.overridegroup);
|
||
|
}
|
||
|
|
||
|
if (calc->hw.flags & TILEM_CALC_HAS_MD5_ASSIST) {
|
||
|
fprintf(savfile, "\n## MD5 assist ##\n");
|
||
|
fprintf(savfile, "md5assist.a = %X\n",
|
||
|
calc->md5assist.regs[0]);
|
||
|
fprintf(savfile, "md5assist.b = %X\n",
|
||
|
calc->md5assist.regs[1]);
|
||
|
fprintf(savfile, "md5assist.c = %X\n",
|
||
|
calc->md5assist.regs[2]);
|
||
|
fprintf(savfile, "md5assist.d = %X\n",
|
||
|
calc->md5assist.regs[3]);
|
||
|
fprintf(savfile, "md5assist.x = %X\n",
|
||
|
calc->md5assist.regs[4]);
|
||
|
fprintf(savfile, "md5assist.t = %X\n",
|
||
|
calc->md5assist.regs[5]);
|
||
|
fprintf(savfile, "md5assist.shift = %X\n",
|
||
|
calc->md5assist.shift);
|
||
|
fprintf(savfile, "md5assist.mode = %X\n",
|
||
|
calc->md5assist.mode);
|
||
|
}
|
||
|
|
||
|
for (j = 0; j < calc->hw.nusertimers; j++) {
|
||
|
fprintf(savfile,
|
||
|
"\n## Programmable timer %d ##\n", j);
|
||
|
fprintf(savfile, "usertimer%d.frequency = %X\n",
|
||
|
j, calc->usertimers[j].frequency);
|
||
|
fprintf(savfile, "usertimer%d.loopvalue = %X\n",
|
||
|
j, calc->usertimers[j].loopvalue);
|
||
|
fprintf(savfile, "usertimer%d.status = %X\n",
|
||
|
j, calc->usertimers[j].status);
|
||
|
}
|
||
|
|
||
|
fprintf(savfile, "\n## Model-specific ##\n");
|
||
|
for (j = 0; j < calc->hw.nhwregs; j++) {
|
||
|
fprintf(savfile, "%s = %X\n", calc->hw.hwregnames[j],
|
||
|
calc->hwregs[j]);
|
||
|
}
|
||
|
|
||
|
fprintf(savfile, "\n## Timers ##\n");
|
||
|
for (j = calc->z80.timer_cpu; j;
|
||
|
j = calc->z80.timers[j].next) {
|
||
|
tname = get_timer_name(calc, j);
|
||
|
if (tname) {
|
||
|
t = tilem_z80_get_timer_clocks(calc, j);
|
||
|
fprintf(savfile, "timer:%s = %X, %X, 0\n",
|
||
|
tname, t, calc->z80.timers[j].period);
|
||
|
}
|
||
|
}
|
||
|
for (j = calc->z80.timer_rt; j;
|
||
|
j = calc->z80.timers[j].next) {
|
||
|
tname = get_timer_name(calc, j);
|
||
|
if (tname) {
|
||
|
t = tilem_z80_get_timer_microseconds(calc, j);
|
||
|
fprintf(savfile, "timer:%s = %X, %X, 1\n",
|
||
|
tname, t, calc->z80.timers[j].period);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fprintf(savfile, "\n## RAM contents ##\n");
|
||
|
fprintf(savfile, "RAM = {\n");
|
||
|
for (i = 0; i < calc->hw.ramsize; i++) {
|
||
|
if (i % 256 == 0) {
|
||
|
fprintf(savfile, "# %02X:%04X\n",
|
||
|
(i >> 14), (i & 0x3fff));
|
||
|
}
|
||
|
|
||
|
fprintf(savfile, "%02X",
|
||
|
calc->mem[i + calc->hw.romsize]);
|
||
|
if (i % 32 == 31)
|
||
|
fprintf(savfile, "\n");
|
||
|
}
|
||
|
fprintf(savfile, "}\n## End of RAM contents ##\n");
|
||
|
|
||
|
if (calc->hw.lcdmemsize) {
|
||
|
fprintf(savfile, "\n## LCD contents ##\n");
|
||
|
fprintf(savfile, "LCD = {\n");
|
||
|
rowstride = calc->lcd.rowstride;
|
||
|
if (rowstride == 0)
|
||
|
rowstride = 32;
|
||
|
|
||
|
for (i = 0; i < calc->hw.lcdmemsize; i++) {
|
||
|
fprintf(savfile, "%02X", calc->lcdmem[i]);
|
||
|
if (i % rowstride == (rowstride - 1))
|
||
|
fprintf(savfile, "\n");
|
||
|
}
|
||
|
fprintf(savfile, "}\n## End of LCD contents ##\n");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|