m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
grafX2/src/c64load.c
Thomas Bernard d7451d6d6e
c64load: emulate C64 KERNAL GETIN better 
no key is pressed
2020-01-02 00:00:26 +01:00

319 lines
9.2 KiB
C
Raw Blame History

/* vim:expandtab:ts=2 sw=2:
*/
/* Grafx2 - The Ultimate 256-color bitmap paint program
Copyright 2018-2019 Thomas Bernard
Copyright 2011 Pawel Góralski
Copyright 2009 Petter Lindquist
Copyright 2008 Yves Rizoud
Copyright 2008 Franck Charlet
Copyright 2007-2011 Adrien Destugues
Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
Grafx2 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; version 2
of the License.
Grafx2 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 Grafx2; if not, see <http://www.gnu.org/licenses/>
*/
///@file c64load.c
/// Load C64 .PRG files
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "struct.h"
#include "io.h"
#include "c64load.h"
#include "gfx2mem.h"
#include "gfx2log.h"
#define CPU_6502_STATIC
#define CPU_6502_DEPENDENCIES_H "6502types.h"
#define CPU_6502_USE_LOCAL_HEADER
#include "6502.h"
#define MAX_IO_ACCESS_MSG_COUNT 10
/**
* Check if it is a machine langage program with a BASIC
* startup line (eg. 10 SYS2061)
* @return 0 or the machine language code start address
*/
word C64_isBinaryProgram(FILE * f)
{
word prg_load_addr;
word addr, next, linenum;
word len;
char * line;
unsigned long start = 0;
int i;
if (f == NULL)
return 0;
if (fseek(f, 0, SEEK_SET) < 0)
return 0;
if (!Read_word_le(f, &prg_load_addr))
return 0;
if (prg_load_addr != 0x0801)
return 0;
addr = prg_load_addr;
while (start == 0)
{
if (!Read_word_le(f, &next))
return 0;
if (next == 0)
break;
if (!Read_word_le(f, &linenum))
return 0;
GFX2_Log(GFX2_DEBUG, "$%04x %hu\n", next, linenum);
len = next - addr - 4;
line = malloc(len);
if (!Read_bytes(f, line, len))
{
free(line);
return 0;
}
GFX2_LogHexDump(GFX2_DEBUG, "", (byte *)line, 0, len);
if ((byte)line[0] == 0x9e) // SYS BASIC token
{
GFX2_Log(GFX2_DEBUG, "SYS%s\n", line + 1);
i = 1;
while (line[i] == ' ')
i++;
start = strtoul(line + i, NULL, 10);
}
free(line);
}
return start;
}
static byte C64_mem_read(void *context, word address)
{
struct c64state * c64 = (struct c64state *)context;
if ((c64->ram[1] & 2) && address >= 0xe000)
{
GFX2_Log(GFX2_WARNING, "** ROM ** read($%04x)\n", address);
// $FFE4 GETIN
// make it return 0 (an Z=1) like if no key is pressed
if (address == 0xffe4)
{
c64->keyjoyread++;
return 0xA9; // LDA #$xx
}
if (address == 0xffe5)
return 0x00; // 2nd byte of LDA #$00
return 0x60; // RTS
}
if ((c64->ram[1] & 4) &&
(((address >= 0xd000) && (address < 0xd800)) || ((address >= 0xdc00) && (address < 0xe000))))
{
if ((address & 0xff00) == 0xd000)
{
if (c64->ioaccess[address - 0xd000] < MAX_IO_ACCESS_MSG_COUNT)
{
GFX2_Log(GFX2_DEBUG, "** IO ** read($%04x) $%02x\n",
address, c64->ram[address]);
if (++c64->ioaccess[address - 0xd000] == MAX_IO_ACCESS_MSG_COUNT)
GFX2_Log(GFX2_DEBUG, " stopping debug log on $%04x\n", address);
}
}
else
{
GFX2_Log(GFX2_DEBUG, "** IO ** read($%04x) $%02x\n",
address, c64->ram[address]);
}
if ((address & 0xfffe) == 0xdc00)
c64->keyjoyread++;
}
return c64->ram[address];
}
static void C64_mem_write(void *context, word address, byte value)
{
struct c64state * c64 = (struct c64state *)context;
if ((address >= 0xd000 && address < 0xd800) ||
(address >= 0xdc00 && address < 0xe000))
{
if ((address & 0xff00) == 0xd000)
{
if (c64->ioaccess[address - 0xd000] < MAX_IO_ACCESS_MSG_COUNT)
{
GFX2_Log(GFX2_DEBUG, "** IO ** write($%04x, $%02x)\n", address, value);
if (++c64->ioaccess[address - 0xd000] == MAX_IO_ACCESS_MSG_COUNT)
GFX2_Log(GFX2_DEBUG, " stopping debug log on $%04x\n", address);
}
}
else
{
GFX2_Log(GFX2_DEBUG, "** IO ** write($%04x, $%02x)\n", address, value);
}
switch (address)
{
case 0xd011:
c64->irqrasterline = (c64->irqrasterline & 0x00ff) | (value >> 7);
break;
case 0xd012:
c64->irqrasterline = (c64->irqrasterline & 0xff00) | value;
break;
case 0xd018:
if (c64->ram[0xd011] & 0x10) // Screen is on
c64->fliscreens[(c64->ram[0xd011] - 50) & 7] = value >> 4;
break;
case 0xd019:
// acknowledge rasterirq
m6502_irq(c64->cpu, FALSE);
break;
case 0xd021: // background color
{
word line = ((word)(c64->ram[0xd011] & 0x80) << 1) | c64->ram[0xd012];
if (line >= 50 && line < 250)
c64->backgrounds[line - 50] = value & 0x0f;
}
break;
}
}
else if (address >= 0xfffa)
GFX2_Log(GFX2_DEBUG, "write($%04x, $%02x)\n", address, value);
else if (address == 0x314 || address == 0x315)
GFX2_Log(GFX2_DEBUG, "write($%04x, $%02x)\n", address, value);
c64->ram[address] = value;
}
int C64_LoadPrg(struct c64state * c64, FILE * file, word start)
{
M6502 cpu;
zusize cycles = 0;
zusize next_rasterline = 63;
int i, count = 0;
byte screen_min = 255;
int prg_size;
if (c64->ram == NULL)
{
c64->ram = GFX2_malloc(65536);
if (c64->ram == NULL)
return 0;
}
memset(c64->ram, 0, 65536);
prg_size = fread(c64->ram + 0x801, 1, 38911, file);
GFX2_Log(GFX2_DEBUG, "C64_LoadPrg(%d, $%04x)\n", prg_size, start);
if (prg_size < 0)
return 0;
c64->ram[0x00] = 0x2F;
c64->ram[0x01] = 0x37;
c64->ram[0x2B] = 0x01;
c64->ram[0x2C] = 0x08;
c64->ram[0x2D] = (0x7ff + prg_size) & 0xff;
c64->ram[0x2E] = (0x7ff + prg_size) >> 8;
c64->ram[0x2F] = c64->ram[0x2D];
c64->ram[0x30] = c64->ram[0x2E];
c64->ram[0x31] = c64->ram[0x2D];
c64->ram[0x32] = c64->ram[0x2E];
c64->ram[0xd011] = 0x1B;
c64->ram[0xd016] = 0xC8;
c64->ram[0xd018] = 0x15;
c64->ram[0xd020] = 0xFE;
c64->ram[0xd021] = 0xF6;
c64->ram[0xd022] = 0xF1;
c64->ram[0xd023] = 0xF2;
c64->ram[0xd024] = 0xF3;
c64->ram[0xd025] = 0xF4;
c64->ram[0xd026] = 0xF0;
c64->ram[0xd027] = 0xF1;
c64->ram[0xd028] = 0xF2;
c64->ram[0xd029] = 0xF3;
c64->ram[0xd02a] = 0xF4;
c64->ram[0xd02b] = 0xF5;
c64->ram[0xd02c] = 0xF6;
c64->ram[0xd02d] = 0xF7;
c64->ram[0xd02e] = 0xFC;
c64->ram[0xdd00] = 0x97;
c64->cpu = &cpu;
memset(&cpu, 0, sizeof(cpu));
cpu.context = (void*)c64;
cpu.read = C64_mem_read;
cpu.write = C64_mem_write;
m6502_power(&cpu, TRUE);
cpu.state.pc = start;
while (cycles < 10000000 && c64->keyjoyread < 10)
{
word lastpc = cpu.state.pc;
//cycles += m6502_run(&cpu, next_rasterline > cycles ? next_rasterline - cycles : 1);
cycles += m6502_run(&cpu, 1);
if (cycles >= next_rasterline)
{
word line = ((word)(c64->ram[0xd011] & 0x80) << 1) | c64->ram[0xd012];
if (++line >= 312)
line = 0;
c64->ram[0xd012] = line & 0xff;
c64->ram[0xd011] = (c64->ram[0xd011] & 0x7f) | ((line >> 1) & 0x80);
if (c64->ram[0xd01a] & 1)
{
if (line == c64->irqrasterline)
{
GFX2_Log(GFX2_DEBUG, "pc=$%04x Raster IRQ line %hu\n", cpu.state.pc, line);
c64->ram[0xd019] |= 0x81;
m6502_irq(&cpu, TRUE);
}
}
next_rasterline += 63;
}
if (lastpc == cpu.state.pc/* && !(c64->ram[0xd01a] & 1)*/)
{
GFX2_Log(GFX2_DEBUG, "infinite loop detected\n");
if ((c64->ram[0xd011] & 0x10) == 0 // Screen off
&& (c64->ram[0x315] != 0))
{
// fake system interrupt
cpu.state.pc = ((word)c64->ram[0x315] << 8) + c64->ram[0x314];
}
else
break;
}
}
GFX2_Log(GFX2_DEBUG, "%u cycles pc=$%04x\n", cycles, cpu.state.pc);
c64->vicmode = (c64->ram[0xd011] & 0x60) | (c64->ram[0xd016] & 0x10);
GFX2_Log(GFX2_DEBUG, "$%02x %s%s%s\n",
c64->vicmode,
(c64->ram[0xd011] & 0x20) ? "BITMAP" : "TEXT",
(c64->ram[0xd011] & 0x40) ? " EXTBKG" : "",
(c64->ram[0xd016] & 0x10) ? " MULTICOLOR" : "");
GFX2_Log(GFX2_DEBUG, "fliscreens [%x %x %x %x %x %x %x %x]\n",
c64->fliscreens[0], c64->fliscreens[1], c64->fliscreens[2], c64->fliscreens[3],
c64->fliscreens[4], c64->fliscreens[5], c64->fliscreens[6], c64->fliscreens[7]);
for (i = 0; i < 8; i++)
{
if (c64->fliscreens[i] != 0)
count++;
if (c64->fliscreens[i] < screen_min)
screen_min = c64->fliscreens[i];
}
if (count > 1)
{
GFX2_Log(GFX2_INFO, "FLI MODE DETECTED\n");
c64->vicmode |= C64_VICMODE_FLI;
}
c64->bitmap = c64->screen = ((c64->ram[0xdd00] & 3) ^ 3) << 14;
c64->bitmap += (c64->ram[0xd018] & 0x0f) << 10;
c64->bitmap &= ((c64->ram[0xd011] & 0x20) ? 0xe000 : 0xf800);
if (c64->vicmode & C64_VICMODE_FLI)
c64->screen += screen_min << 10;
else
c64->screen += (c64->ram[0xd018] & 0xf0) << 6;
GFX2_Log(GFX2_DEBUG, "$D018=$%02x bitmap at $%04x, screen at $%04x\n",
c64->ram[0xd018], c64->bitmap, c64->screen);
return 1;
}
Reference in New Issue View Git Blame Copy Permalink