forked from KolibriOS/kolibrios
1240 lines
30 KiB
C++
1240 lines
30 KiB
C++
// DGen/SDL v1.17+
|
|
// Megadrive C++ module
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#ifdef HAVE_MEMCPY_H
|
|
#include "memcpy.h"
|
|
#endif
|
|
#include "md.h"
|
|
#include "system.h"
|
|
#include "romload.h"
|
|
#include "rc-vars.h"
|
|
#include "debug.h"
|
|
#include "decode.h"
|
|
|
|
extern FILE *debug_log;
|
|
|
|
#ifdef WITH_STAR
|
|
extern "C" unsigned star_readbyte(unsigned a, unsigned d);
|
|
extern "C" unsigned star_readword(unsigned a, unsigned d);
|
|
extern "C" unsigned star_writebyte(unsigned a, unsigned d);
|
|
extern "C" unsigned star_writeword(unsigned a, unsigned d);
|
|
|
|
/**
|
|
* This sets up an array of memory locations.
|
|
* This method is StarScream specific.
|
|
* @return 0 on success
|
|
*/
|
|
int md::memory_map()
|
|
{
|
|
int i=0,j=0;
|
|
int rommax=romlen;
|
|
|
|
if (rommax>0xa00000) rommax=0xa00000;
|
|
if (rommax<0) rommax=0;
|
|
|
|
// FETCH: Set up 2 or 3 FETCH sections
|
|
i=0;
|
|
if (rommax>0)
|
|
{ fetch[i].lowaddr=0x000000; fetch[i].highaddr=rommax-1; fetch[i].offset=(unsigned)rom-0x000000; i++; }
|
|
fetch[i].lowaddr=0xff0000; fetch[i].highaddr=0xffffff; fetch[i].offset=(unsigned)ram- 0xff0000; i++;
|
|
// Testing
|
|
fetch[i].lowaddr=0xffff0000; fetch[i].highaddr=0xffffffff; fetch[i].offset=(unsigned)ram-0xffff0000; i++;
|
|
// Testing 2
|
|
fetch[i].lowaddr=0xff000000; fetch[i].highaddr=0xff000000+rommax-1; fetch[i].offset=(unsigned)rom-0xff000000; i++;
|
|
fetch[i].lowaddr=fetch[i].highaddr=0xffffffff; fetch[i].offset=0; i++;
|
|
|
|
if (debug_log!=NULL)
|
|
fprintf (debug_log,"StarScream memory_map has %d fetch sections\n",i);
|
|
|
|
i=0; j=0;
|
|
|
|
#if 0
|
|
// Simple version ***************
|
|
readbyte[i].lowaddr= readword[i].lowaddr=
|
|
writebyte[j].lowaddr= writeword[j].lowaddr= 0;
|
|
readbyte[i].highaddr= readword[i].highaddr=
|
|
writebyte[j].highaddr= writeword[j].highaddr= 0xffffffff;
|
|
|
|
readbyte[i].memorycall=(void *)star_readbyte;
|
|
readword[i].memorycall=(void *)star_readword;
|
|
writebyte[j].memorycall=(void *)star_writebyte;
|
|
writeword[j].memorycall=(void *)star_writeword;
|
|
|
|
readbyte[i].userdata= readword[i].userdata=
|
|
writebyte[j].userdata= writeword[j].userdata= NULL;
|
|
i++; j++;
|
|
// Simple version end ***************
|
|
|
|
#else
|
|
// Faster version ***************
|
|
// IO: Set up 3/4 read sections, and 2/3 write sections
|
|
if (rommax>0)
|
|
{
|
|
// Cartridge save RAM memory
|
|
if(save_len) {
|
|
readbyte[i].lowaddr= readword[i].lowaddr=
|
|
writebyte[j].lowaddr= writeword[j].lowaddr= save_start;
|
|
readbyte[i].highaddr= readword[i].highaddr=
|
|
writebyte[j].highaddr= writeword[j].highaddr= save_start+save_len-1;
|
|
readbyte[i].memorycall = star_readbyte;
|
|
readword[j].memorycall = star_readword;
|
|
writebyte[i].memorycall = star_writebyte;
|
|
writeword[j].memorycall = star_writeword;
|
|
readbyte[i].userdata= readword[i].userdata=
|
|
writebyte[j].userdata= writeword[j].userdata= NULL;
|
|
i++; j++;
|
|
}
|
|
// Cartridge ROM memory (read only)
|
|
readbyte[i].lowaddr= readword[i].lowaddr= 0x000000;
|
|
readbyte[i].highaddr= readword[i].highaddr= rommax-1;
|
|
readbyte[i].memorycall=readword[i].memorycall=NULL;
|
|
readbyte[i].userdata= readword[i].userdata= rom;
|
|
i++;
|
|
// misc memory (e.g. aoo and coo) through star_rw
|
|
readbyte[i].lowaddr= readword[i].lowaddr=
|
|
writebyte[j].lowaddr= writeword[j].lowaddr= rommax;
|
|
}
|
|
else
|
|
readbyte[i].lowaddr= readword[i].lowaddr=
|
|
writebyte[j].lowaddr= writeword[j].lowaddr= 0;
|
|
|
|
readbyte[i].highaddr= readword[i].highaddr=
|
|
writebyte[j].highaddr= writeword[j].highaddr= 0xfeffff;
|
|
|
|
readbyte[i].memorycall = star_readbyte;
|
|
readword[i].memorycall = star_readword;
|
|
writebyte[j].memorycall = star_writebyte;
|
|
writeword[j].memorycall = star_writeword;
|
|
|
|
readbyte[i].userdata= readword[i].userdata=
|
|
writebyte[j].userdata= writeword[j].userdata= NULL;
|
|
i++; j++;
|
|
|
|
// scratch RAM memory
|
|
readbyte[i].lowaddr = readword[i].lowaddr =
|
|
writebyte[j].lowaddr = writeword[j].lowaddr = 0xff0000;
|
|
readbyte[i].highaddr= readword[i].highaddr=
|
|
writebyte[j].highaddr= writeword[j].highaddr= 0xffffff;
|
|
readbyte[i].memorycall= readword[i].memorycall=
|
|
writebyte[j].memorycall=writeword[j].memorycall= NULL;
|
|
readbyte[i].userdata= readword[i].userdata =
|
|
writebyte[j].userdata= writeword[j].userdata = ram;
|
|
i++; j++;
|
|
// Faster version end ***************
|
|
#endif
|
|
|
|
// The end
|
|
readbyte[i].lowaddr = readword[i].lowaddr =
|
|
writebyte[j].lowaddr = writeword[j].lowaddr =
|
|
readbyte[i].highaddr = readword[i].highaddr =
|
|
writebyte[j].highaddr = writeword[j].highaddr = 0xffffffff;
|
|
|
|
readbyte[i].memorycall = 0;
|
|
readword[i].memorycall = 0;
|
|
writebyte[j].memorycall = 0;
|
|
writeword[j].memorycall = 0;
|
|
readbyte[i].userdata = 0;
|
|
readword[i].userdata = 0;
|
|
writebyte[j].userdata = 0;
|
|
writeword[j].userdata = 0;
|
|
|
|
i++; j++;
|
|
|
|
if (debug_log!=NULL)
|
|
fprintf (debug_log,"StarScream memory_map has %d read sections and %d write sections\n",i,j);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void star_irq_callback(void)
|
|
{
|
|
assert(md::md_star != NULL);
|
|
md::md_star->m68k_vdp_irq_handler();
|
|
}
|
|
#endif
|
|
|
|
#ifdef WITH_MUSA
|
|
/**
|
|
* This sets up an array of memory locations for Musashi.
|
|
*/
|
|
void md::musa_memory_map()
|
|
{
|
|
unsigned int rom0_len = romlen;
|
|
unsigned int rom1_sta = 0;
|
|
unsigned int rom1_len = 0;
|
|
|
|
m68k_register_memory(NULL, 0);
|
|
if (save_len) {
|
|
DEBUG(("[%06x-%06x] ???? (SAVE)",
|
|
save_start, (save_start + save_len - 1)));
|
|
if (save_start < romlen) {
|
|
/* Punch a hole through the ROM area. */
|
|
rom0_len = save_start;
|
|
/* Add entry for ROM leftovers, if any. */
|
|
if ((save_start + save_len) < romlen) {
|
|
rom1_sta = (save_start + save_len);
|
|
rom1_len = (romlen - rom1_sta);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef ROM_BYTESWAP
|
|
#define S 1
|
|
#else
|
|
#define S 0
|
|
#endif
|
|
|
|
const m68k_mem_t mem[3] = {
|
|
// r, w, x, swab, addr, size, mask, mem
|
|
{ 1, 0, 1, S, 0x000000, rom0_len, 0x7fffff, rom }, // M68K ROM
|
|
{ 1, 1, 1, 1, 0xe00000, 0x200000, 0x00ffff, ram }, // M68K RAM
|
|
{ 1, 0, 1, S, rom1_sta, rom1_len, 0x7fffff, &rom[rom1_sta] }
|
|
};
|
|
unsigned int i;
|
|
unsigned int j = 0;
|
|
|
|
for (i = 0; ((i < elemof(mem)) && (j < elemof(musa_memory))); ++i) {
|
|
if (mem[i].size == 0)
|
|
continue;
|
|
DEBUG(("[%06x-%06x] %c%c%c%c (%s)",
|
|
mem[i].addr,
|
|
(mem[i].addr + mem[i].size - 1),
|
|
(mem[i].r ? 'r' : '-'),
|
|
(mem[i].w ? 'w' : '-'),
|
|
(mem[i].x ? 'x' : '-'),
|
|
(mem[i].swab ? 's' : '-'),
|
|
(mem[i].w ? "RAM" : "ROM")));
|
|
musa_memory[j] = mem[i];
|
|
++j;
|
|
}
|
|
if (j)
|
|
m68k_register_memory(musa_memory, j);
|
|
else
|
|
DEBUG(("no memory region defined"));
|
|
}
|
|
|
|
int musa_irq_callback(int level)
|
|
{
|
|
(void)level;
|
|
assert(md::md_musa != NULL);
|
|
md::md_musa->m68k_vdp_irq_handler();
|
|
return M68K_INT_ACK_AUTOVECTOR;
|
|
}
|
|
#endif
|
|
|
|
#ifdef WITH_CYCLONE
|
|
extern "C" uint32_t cyclone_read_memory_8(uint32_t address);
|
|
extern "C" uint32_t cyclone_read_memory_16(uint32_t address);
|
|
extern "C" uint32_t cyclone_read_memory_32(uint32_t address);
|
|
extern "C" void cyclone_write_memory_8(uint32_t address, uint8_t value);
|
|
extern "C" void cyclone_write_memory_16(uint32_t address, uint16_t value);
|
|
extern "C" void cyclone_write_memory_32(uint32_t address, uint32_t value);
|
|
extern "C" uintptr_t cyclone_checkpc(uintptr_t pc);
|
|
|
|
int cyclone_irq_callback(int level)
|
|
{
|
|
(void)level;
|
|
assert(md::md_cyclone != NULL);
|
|
md::md_cyclone->m68k_vdp_irq_handler();
|
|
return CYCLONE_INT_ACK_AUTOVECTOR;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Resets everything (Z80, M68K, VDP, etc).
|
|
* @return 0 on success
|
|
*/
|
|
int md::reset()
|
|
{
|
|
// Clear memory.
|
|
memset(mem, 0, 0x20000);
|
|
// Reset the VDP.
|
|
vdp.reset();
|
|
// Erase CPU states.
|
|
memset(&m68k_state, 0, sizeof(m68k_state));
|
|
memset(&z80_state, 0, sizeof(z80_state));
|
|
m68k_state_restore();
|
|
z80_state_restore();
|
|
#ifdef WITH_STAR
|
|
md_set_star(1);
|
|
s68000reset();
|
|
md_set_star(0);
|
|
#endif
|
|
#ifdef WITH_MUSA
|
|
md_set_musa(1);
|
|
m68k_pulse_reset();
|
|
md_set_musa(0);
|
|
#endif
|
|
#ifdef WITH_CYCLONE
|
|
md_set_cyclone(1);
|
|
CycloneReset(&cyclonecpu);
|
|
md_set_cyclone(0);
|
|
#endif
|
|
#ifdef WITH_DEBUGGER
|
|
debug_m68k_instr_count = 0;
|
|
debug_z80_instr_count = 0;
|
|
#endif
|
|
if (debug_log) fprintf (debug_log,"reset()\n");
|
|
|
|
aoo3_toggle=aoo5_toggle=aoo3_six=aoo5_six
|
|
=aoo3_six_timeout=aoo5_six_timeout
|
|
=coo4=coo5=0;
|
|
pad[0] = MD_PAD_UNTOUCHED;
|
|
pad[1] = MD_PAD_UNTOUCHED;
|
|
memset(pad_com, 0, sizeof(pad_com));
|
|
|
|
#ifdef WITH_PICO
|
|
// Initialize Pico pen X, Y coordinates
|
|
pico_pen_coords[0] = 0x3c;
|
|
pico_pen_coords[1] = 0x1fc;
|
|
#endif
|
|
|
|
// Reset FM registers
|
|
fm_reset();
|
|
dac_init();
|
|
|
|
memset(&odo, 0, sizeof(odo));
|
|
ras = 0;
|
|
|
|
z80_st_running = 0;
|
|
m68k_st_running = 0;
|
|
z80_reset();
|
|
z80_st_busreq = 1;
|
|
z80_st_reset = 1;
|
|
z80_st_irq = 0;
|
|
return 0;
|
|
}
|
|
|
|
#ifdef WITH_MZ80
|
|
|
|
extern "C" UINT8 mz80_read(UINT32 a, struct MemoryReadByte *unused);
|
|
extern "C" void mz80_write(UINT32 a, UINT8 d, struct MemoryWriteByte *unused);
|
|
extern "C" UINT16 mz80_ioread(UINT16 a, struct z80PortRead *unused);
|
|
extern "C" void mz80_iowrite(UINT16 a, UINT8 d, struct z80PortWrite *unused);
|
|
|
|
static struct MemoryReadByte mem_read[] = {
|
|
{ 0x0000, 0xffff, mz80_read, NULL },
|
|
{ (UINT32)-1, (UINT32)-1, NULL, NULL }
|
|
};
|
|
|
|
static struct MemoryWriteByte mem_write[] = {
|
|
{ 0x0000, 0xffff, mz80_write, NULL },
|
|
{ (UINT32)-1, (UINT32)-1, NULL, NULL }
|
|
};
|
|
|
|
static struct z80PortRead io_read[] = {
|
|
{ 0x00, 0xff, mz80_ioread, NULL },
|
|
{ (UINT16)-1, (UINT16)-1, NULL, NULL }
|
|
};
|
|
|
|
static struct z80PortWrite io_write[] = {
|
|
{ 0x00, 0xff, mz80_iowrite, NULL },
|
|
{ (UINT16)-1, (UINT16)-1, NULL, NULL }
|
|
};
|
|
|
|
#endif // WITH_MZ80
|
|
|
|
#ifdef WITH_CZ80
|
|
|
|
extern "C" uint8_t cz80_memread(void *ctx, uint16_t a);
|
|
extern "C" void cz80_memwrite(void *ctx, uint16_t a, uint8_t d);
|
|
extern "C" uint16_t cz80_memread16(void *ctx, uint16_t a);
|
|
extern "C" void cz80_memwrite16(void *ctx, uint16_t a, uint16_t d);
|
|
extern "C" uint8_t cz80_ioread(void *ctx, uint16_t a);
|
|
extern "C" void cz80_iowrite(void *ctx, uint16_t a, uint8_t d);
|
|
|
|
#endif // WITH_CZ80
|
|
|
|
#ifdef WITH_DRZ80
|
|
|
|
extern uintptr_t drz80_rebaseSP(uint16_t new_sp);
|
|
extern uintptr_t drz80_rebasePC(uint16_t new_pc);
|
|
extern uint8_t drz80_read8(uint16_t a);
|
|
extern uint16_t drz80_read16(uint16_t a);
|
|
extern void drz80_write8(uint8_t d, uint16_t a);
|
|
extern void drz80_write16(uint16_t d, uint16_t a);
|
|
extern uint8_t drz80_in(uint16_t p);
|
|
extern void drz80_out(uint16_t p, uint8_t d);
|
|
|
|
void drz80_irq_callback()
|
|
{
|
|
md::md_drz80->drz80_irq_cb();
|
|
}
|
|
|
|
void md::drz80_irq_cb()
|
|
{
|
|
drz80.Z80_IRQ = 0x00; // lower irq when in accepted
|
|
}
|
|
|
|
#endif // WITH_DRZ80
|
|
|
|
/**
|
|
* Initialise the Z80.
|
|
*/
|
|
void md::z80_init()
|
|
{
|
|
#ifdef WITH_MZ80
|
|
md_set_mz80(1);
|
|
mz80init();
|
|
mz80reset();
|
|
// Erase local context with global context.
|
|
mz80GetContext(&z80);
|
|
// Configure callbacks in local context.
|
|
z80.z80Base = z80ram;
|
|
z80.z80MemRead = mem_read;
|
|
z80.z80MemWrite = mem_write;
|
|
z80.z80IoRead = io_read;
|
|
z80.z80IoWrite = io_write;
|
|
// Erase global context with the above.
|
|
mz80SetContext(&z80);
|
|
md_set_mz80(0);
|
|
#endif
|
|
#ifdef WITH_CZ80
|
|
Cz80_Set_Ctx(&cz80, this);
|
|
Cz80_Set_Fetch(&cz80, 0x0000, 0xffff, (void *)z80ram);
|
|
Cz80_Set_ReadB(&cz80, cz80_memread);
|
|
Cz80_Set_WriteB(&cz80, cz80_memwrite);
|
|
Cz80_Set_ReadW(&cz80, cz80_memread16);
|
|
Cz80_Set_WriteW(&cz80, cz80_memwrite16);
|
|
Cz80_Set_INPort(&cz80, cz80_ioread);
|
|
Cz80_Set_OUTPort(&cz80, cz80_iowrite);
|
|
Cz80_Reset(&cz80);
|
|
#endif
|
|
#ifdef WITH_DRZ80
|
|
memset(&drz80, 0, sizeof(drz80));
|
|
drz80.z80_write8 = drz80_write8;
|
|
drz80.z80_write16 = drz80_write16;
|
|
drz80.z80_in = drz80_in;
|
|
drz80.z80_out = drz80_out;
|
|
drz80.z80_read8 = drz80_read8;
|
|
drz80.z80_read16 = drz80_read16;
|
|
drz80.z80_rebasePC = drz80_rebasePC;
|
|
drz80.z80_rebaseSP = drz80_rebaseSP;
|
|
drz80.z80_irq_callback = drz80_irq_callback;
|
|
#endif
|
|
z80_st_busreq = 1;
|
|
z80_st_reset = 0;
|
|
z80_bank68k = 0xff8000;
|
|
}
|
|
|
|
/**
|
|
* Reset the Z80.
|
|
*/
|
|
void md::z80_reset()
|
|
{
|
|
z80_bank68k = 0xff8000;
|
|
#ifdef WITH_MZ80
|
|
md_set_mz80(1);
|
|
mz80reset();
|
|
md_set_mz80(0);
|
|
#endif
|
|
#ifdef WITH_CZ80
|
|
Cz80_Reset(&cz80);
|
|
#endif
|
|
#ifdef WITH_DRZ80
|
|
md_set_drz80(1);
|
|
drz80.Z80A = (1 << 2); // set ZFlag
|
|
drz80.Z80F = (1 << 2); // set ZFlag
|
|
drz80.Z80BC = 0;
|
|
drz80.Z80DE = 0;
|
|
drz80.Z80HL = 0;
|
|
drz80.Z80A2 = 0;
|
|
drz80.Z80F2 = 0;
|
|
drz80.Z80BC2 = 0x0000 << 16;
|
|
drz80.Z80DE2 = 0x0000 << 16;
|
|
drz80.Z80HL2 = 0x0000 << 16;
|
|
drz80.Z80IX = 0xFFFF << 16;
|
|
drz80.Z80IY = 0xFFFF << 16;
|
|
|
|
drz80.Z80I = 0x00;
|
|
drz80.Z80_IRQ = 0x00;
|
|
drz80.Z80IF = 0x00;
|
|
drz80.Z80IM = 0x00;
|
|
drz80.Z80R = 0x00;
|
|
|
|
drz80.Z80PC = drz80_rebasePC(0);
|
|
drz80.Z80SP = drz80_rebaseSP(0x2000);
|
|
md_set_drz80(0);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Initialise sound.
|
|
* @return True when successful.
|
|
*/
|
|
bool md::init_sound()
|
|
{
|
|
if (lock == false)
|
|
return false;
|
|
if (ok_ym2612) {
|
|
YM2612Shutdown();
|
|
ok_ym2612 = false;
|
|
}
|
|
if (ok_sn76496) {
|
|
(void)0;
|
|
ok_sn76496 = false;
|
|
}
|
|
// Initialize two additional chips when MJazz is enabled.
|
|
if (YM2612Init((dgen_mjazz ? 3 : 1),
|
|
(((pal) ? PAL_MCLK : NTSC_MCLK) / 7),
|
|
dgen_soundrate, dgen_mjazz, NULL, NULL))
|
|
return false;
|
|
ok_ym2612 = true;
|
|
if (SN76496_init(0,
|
|
(((pal) ? PAL_MCLK : NTSC_MCLK) / 15),
|
|
dgen_soundrate, 16))
|
|
return false;
|
|
ok_sn76496 = true;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Switch to PAL or NTSC.
|
|
* This method's name is a bit misleading. This switches to PAL or not
|
|
* depending on "md::pal".
|
|
*/
|
|
void md::init_pal()
|
|
{
|
|
unsigned int hc;
|
|
|
|
if (pal) {
|
|
mclk = PAL_MCLK;
|
|
lines = PAL_LINES;
|
|
vhz = PAL_HZ;
|
|
}
|
|
else {
|
|
mclk = NTSC_MCLK;
|
|
lines = NTSC_LINES;
|
|
vhz = NTSC_HZ;
|
|
}
|
|
clk0 = (mclk / 15);
|
|
clk1 = (mclk / 7);
|
|
// Initialize horizontal counter table (Gens style)
|
|
for (hc = 0; (hc < 512); ++hc) {
|
|
// H32
|
|
hc_table[hc][0] = (((hc * 170) / M68K_CYCLES_PER_LINE) - 0x18);
|
|
// H40
|
|
hc_table[hc][1] = (((hc * 205) / M68K_CYCLES_PER_LINE) - 0x1c);
|
|
}
|
|
}
|
|
|
|
bool md::lock = false;
|
|
|
|
/**
|
|
* MD constructor.
|
|
* @param pal True if we are running the MD in PAL mode.
|
|
* @param region Region to emulate ('J', 'U', or 'E').
|
|
*/
|
|
md::md(bool pal, char region):
|
|
#ifdef WITH_MUSA
|
|
md_musa_ref(0), md_musa_prev(0),
|
|
#endif
|
|
#ifdef WITH_CYCLONE
|
|
md_cyclone_ref(0), md_cyclone_prev(0),
|
|
#endif
|
|
#ifdef WITH_STAR
|
|
md_star_ref(0), md_star_prev(0),
|
|
#endif
|
|
#ifdef WITH_CZ80
|
|
md_cz80_ref(0),
|
|
#endif
|
|
#ifdef WITH_MZ80
|
|
md_mz80_ref(0), md_mz80_prev(0),
|
|
#endif
|
|
pal(pal), ok_ym2612(false), ok_sn76496(false),
|
|
vdp(*this), region(region), plugged(false)
|
|
{
|
|
// Only one MD object is allowed to exist at once.
|
|
if (lock)
|
|
return;
|
|
lock = true;
|
|
|
|
// PAL or NTSC.
|
|
init_pal();
|
|
|
|
// Start up the sound chips.
|
|
if (init_sound() == false)
|
|
goto cleanup;
|
|
|
|
romlen = no_rom_size;
|
|
rom = (uint8_t*)no_rom;
|
|
mem=ram=z80ram=saveram=NULL;
|
|
save_start=save_len=save_prot=save_active=0;
|
|
|
|
fm_reset();
|
|
|
|
#ifdef WITH_VGMDUMP
|
|
vgm_dump_file = NULL;
|
|
vgm_dump_samples_total = 0;
|
|
vgm_dump_dac_wait = 0;
|
|
vgm_dump_dac_samples = 0;
|
|
vgm_dump = false;
|
|
#endif
|
|
|
|
#ifdef WITH_PICO
|
|
pico_enabled = false;
|
|
#endif
|
|
|
|
memset(&m68k_state, 0, sizeof(m68k_state));
|
|
memset(&z80_state, 0, sizeof(z80_state));
|
|
|
|
#ifdef WITH_MUSA
|
|
ctx_musa = calloc(1, m68k_context_size());
|
|
if (ctx_musa == NULL)
|
|
goto cleanup;
|
|
md_set_musa(1);
|
|
m68k_init();
|
|
m68k_set_cpu_type(M68K_CPU_TYPE_68000);
|
|
m68k_register_memory(NULL, 0);
|
|
m68k_set_int_ack_callback(musa_irq_callback);
|
|
md_set_musa(0);
|
|
#endif
|
|
|
|
#ifdef WITH_STAR
|
|
fetch=NULL;
|
|
readbyte=readword=writebyte=writeword=NULL;
|
|
memset(&cpu,0,sizeof(cpu));
|
|
#endif
|
|
|
|
#ifdef WITH_CYCLONE
|
|
memset(&cyclonecpu, 0, sizeof(cyclonecpu));
|
|
cyclonecpu.read8 = cyclone_read_memory_8;
|
|
cyclonecpu.read16 = cyclone_read_memory_16;
|
|
cyclonecpu.read32 = cyclone_read_memory_32;
|
|
cyclonecpu.write8 = cyclone_write_memory_8;
|
|
cyclonecpu.write16 = cyclone_write_memory_16;
|
|
cyclonecpu.write32 = cyclone_write_memory_32;
|
|
cyclonecpu.checkpc = cyclone_checkpc;
|
|
cyclonecpu.fetch8 = cyclone_read_memory_8;
|
|
cyclonecpu.fetch16 = cyclone_read_memory_16;
|
|
cyclonecpu.fetch32 = cyclone_read_memory_32;
|
|
cyclonecpu.IrqCallback = cyclone_irq_callback;
|
|
md_set_cyclone(1);
|
|
CycloneInit();
|
|
md_set_cyclone(0);
|
|
#endif
|
|
|
|
#ifdef WITH_MZ80
|
|
memset(&z80,0,sizeof(z80));
|
|
#endif
|
|
#ifdef WITH_CZ80
|
|
Cz80_Init(&cz80);
|
|
#endif
|
|
#ifdef WITH_DRZ80
|
|
memset(&drz80, 0, sizeof(drz80));
|
|
#endif
|
|
memset(&cart_head, 0, sizeof(cart_head));
|
|
|
|
memset(romname, 0, sizeof(romname));
|
|
|
|
ok=0;
|
|
|
|
// Format of pad is: __SA____ UDLRBC__
|
|
|
|
rom = (uint8_t*)no_rom;
|
|
romlen = no_rom_size;
|
|
mem=ram=z80ram=NULL;
|
|
mem=(unsigned char *)malloc(0x20008);
|
|
if (mem == NULL)
|
|
goto cleanup;
|
|
memset(mem,0,0x20000);
|
|
ram= mem+0x00000;
|
|
z80ram=mem+0x10000;
|
|
// Hack for DrZ80 to avoid crashing when PC leaves z80ram.
|
|
z80ram[0x10000] = 0x00; // NOP
|
|
z80ram[0x10001] = 0x00; // NOP
|
|
z80ram[0x10002] = 0x00; // NOP
|
|
z80ram[0x10003] = 0x00; // NOP
|
|
z80ram[0x10004] = 0x00; // NOP
|
|
z80ram[0x10005] = 0xc3; // JP 0x0000
|
|
z80ram[0x10006] = 0x00;
|
|
z80ram[0x10007] = 0x00;
|
|
|
|
#ifdef WITH_MUSA
|
|
md_set_musa(1);
|
|
musa_memory_map();
|
|
md_set_musa(0);
|
|
#endif
|
|
#ifdef WITH_STAR
|
|
md_set_star(1);
|
|
if (s68000init() != 0) {
|
|
md_set_star(0);
|
|
printf ("s68000init failed!\n");
|
|
goto cleanup;
|
|
}
|
|
md_set_star(0);
|
|
|
|
// Dave: Rich said doing point star stuff is done after s68000init
|
|
// in Asgard68000, so just in case...
|
|
if (((fetch = new STARSCREAM_PROGRAMREGION [6]) == NULL) ||
|
|
((readbyte = new STARSCREAM_DATAREGION [5]) == NULL) ||
|
|
((readword = new STARSCREAM_DATAREGION [5]) == NULL) ||
|
|
((writebyte = new STARSCREAM_DATAREGION [5]) == NULL) ||
|
|
((writeword = new STARSCREAM_DATAREGION [5]) == NULL))
|
|
goto cleanup;
|
|
|
|
memory_map();
|
|
|
|
// point star stuff
|
|
cpu.s_fetch = cpu.u_fetch = fetch;
|
|
cpu.s_readbyte = cpu.u_readbyte = readbyte;
|
|
cpu.s_readword = cpu.u_readword = readword;
|
|
cpu.s_writebyte = cpu.u_writebyte = writebyte;
|
|
cpu.s_writeword = cpu.u_writeword = writeword;
|
|
|
|
cpu.inthandler = star_irq_callback;
|
|
md_set_star(1);
|
|
s68000reset();
|
|
md_set_star(0);
|
|
#endif
|
|
|
|
// M68K: 0 = none, 1 = StarScream, 2 = Musashi, 3 = Cyclone
|
|
switch (dgen_emu_m68k) {
|
|
#ifdef WITH_STAR
|
|
case 1:
|
|
cpu_emu = CPU_EMU_STAR;
|
|
break;
|
|
#endif
|
|
#ifdef WITH_MUSA
|
|
case 2:
|
|
cpu_emu = CPU_EMU_MUSA;
|
|
break;
|
|
#endif
|
|
#ifdef WITH_CYCLONE
|
|
case 3:
|
|
cpu_emu = CPU_EMU_CYCLONE;
|
|
break;
|
|
#endif
|
|
default:
|
|
cpu_emu = CPU_EMU_NONE;
|
|
break;
|
|
}
|
|
// Z80: 0 = none, 1 = CZ80, 2 = MZ80, 3 = DrZ80
|
|
switch (dgen_emu_z80) {
|
|
#ifdef WITH_MZ80
|
|
case 1:
|
|
z80_core = Z80_CORE_MZ80;
|
|
break;
|
|
#endif
|
|
#ifdef WITH_CZ80
|
|
case 2:
|
|
z80_core = Z80_CORE_CZ80;
|
|
break;
|
|
#endif
|
|
#ifdef WITH_DRZ80
|
|
case 3:
|
|
z80_core = Z80_CORE_DRZ80;
|
|
break;
|
|
#endif
|
|
default:
|
|
z80_core = Z80_CORE_NONE;
|
|
break;
|
|
}
|
|
|
|
#ifdef WITH_MUSA
|
|
md_set_musa(1);
|
|
m68k_pulse_reset();
|
|
md_set_musa(0);
|
|
#endif
|
|
|
|
#ifdef WITH_DEBUGGER
|
|
debug_init();
|
|
#endif
|
|
|
|
z80_init();
|
|
|
|
reset(); // reset megadrive
|
|
|
|
patch_elem = NULL;
|
|
|
|
ok=1;
|
|
|
|
return;
|
|
cleanup:
|
|
if (ok_ym2612)
|
|
YM2612Shutdown();
|
|
if (ok_sn76496)
|
|
(void)0;
|
|
#ifdef WITH_MUSA
|
|
free(ctx_musa);
|
|
#endif
|
|
#ifdef WITH_STAR
|
|
delete [] fetch;
|
|
delete [] readbyte;
|
|
delete [] readword;
|
|
delete [] writebyte;
|
|
delete [] writeword;
|
|
#endif
|
|
free(mem);
|
|
memset(this, 0, sizeof(*this));
|
|
lock = false;
|
|
}
|
|
|
|
md::~md()
|
|
{
|
|
#ifdef WITH_VGMDUMP
|
|
vgm_dump_stop();
|
|
#endif
|
|
|
|
assert(rom != NULL);
|
|
if (rom != no_rom)
|
|
unplug();
|
|
|
|
free(mem);
|
|
rom=mem=ram=z80ram=NULL;
|
|
|
|
#ifdef WITH_DEBUGGER
|
|
debug_leave();
|
|
#endif
|
|
#ifdef WITH_MUSA
|
|
free(ctx_musa);
|
|
#endif
|
|
#ifdef WITH_STAR
|
|
delete [] fetch;
|
|
delete [] readbyte;
|
|
delete [] readword;
|
|
delete [] writebyte;
|
|
delete [] writeword;
|
|
#endif
|
|
|
|
if (ok_ym2612)
|
|
YM2612Shutdown();
|
|
if (ok_sn76496)
|
|
(void)0;
|
|
ok=0;
|
|
memset(this, 0, sizeof(*this));
|
|
lock = false;
|
|
}
|
|
|
|
#ifdef ROM_BYTESWAP
|
|
/**
|
|
* Byteswaps memory.
|
|
* @param[in] start Byte array of cart memory.
|
|
* @param len How many bytes to byteswap.
|
|
* @return 0 on success (always 0).
|
|
*/
|
|
// Byteswaps memory
|
|
int byteswap_memory(unsigned char *start,int len)
|
|
{ int i; unsigned char tmp;
|
|
for (i=0;i<len;i+=2)
|
|
{ tmp=start[i+0]; start[i+0]=start[i+1]; start[i+1]=tmp; }
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Plug a cart into the MD.
|
|
* @param[in] cart Cart's memory as a byte array.
|
|
* @param len Length of the cart.
|
|
* @return 0 on success.
|
|
*/
|
|
int md::plug_in(unsigned char *cart,int len)
|
|
{
|
|
// Plug in the cartridge specified by the uchar *
|
|
// NB - The megadrive will free() it if unplug() is called, or it exits
|
|
// So it must be a single piece of malloced data
|
|
if (cart==NULL) return 1; if (len<=0) return 1;
|
|
#ifdef ROM_BYTESWAP
|
|
byteswap_memory(cart,len); // for starscream
|
|
#endif
|
|
romlen=len;
|
|
rom=cart;
|
|
// Get saveram start, length (remember byteswapping)
|
|
// First check magic, if there is saveram
|
|
if(rom[ROM_ADDR(0x1b0)] == 'R' && rom[ROM_ADDR(0x1b1)] == 'A')
|
|
{
|
|
save_start = rom[ROM_ADDR(0x1b4)] << 24 | rom[ROM_ADDR(0x1b5)] << 16 |
|
|
rom[ROM_ADDR(0x1b6)] << 8 | rom[ROM_ADDR(0x1b7)];
|
|
save_len = rom[ROM_ADDR(0x1b8)] << 24 | rom[ROM_ADDR(0x1b9)] << 16 |
|
|
rom[ROM_ADDR(0x1ba)] << 8 | rom[ROM_ADDR(0x1bb)];
|
|
// Make sure start is even, end is odd, for alignment
|
|
// A ROM that I came across had the start and end bytes of
|
|
// the save ram the same and wouldn't work. Fix this as seen
|
|
// fit, I know it could probably use some work. [PKH]
|
|
if(save_start != save_len) {
|
|
if(save_start & 1) --save_start;
|
|
if(!(save_len & 1)) ++save_len;
|
|
save_len -= (save_start - 1);
|
|
saveram = (unsigned char*)calloc(1, save_len);
|
|
if (saveram == NULL) {
|
|
save_len = 0;
|
|
save_start = 0;
|
|
}
|
|
// If save RAM does not overlap main ROM, set it active by default since
|
|
// a few games can't manage to properly switch it on/off.
|
|
if(save_start >= (unsigned int)romlen)
|
|
save_active = 1;
|
|
}
|
|
else {
|
|
save_start = save_len = 0;
|
|
saveram = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
save_start = save_len = 0;
|
|
saveram = NULL;
|
|
}
|
|
#ifdef WITH_MUSA
|
|
md_set_musa(1);
|
|
musa_memory_map();
|
|
md_set_musa(0);
|
|
#endif
|
|
#ifdef WITH_STAR
|
|
md_set_star(1);
|
|
memory_map(); // Update memory map to include this cartridge
|
|
md_set_star(0);
|
|
#endif
|
|
reset(); // Reset megadrive
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Region to emulate according to dgen_region_order and ROM header.
|
|
* @return Region identifier ('J', 'U' or 'E').
|
|
*/
|
|
uint8_t md::region_guess()
|
|
{
|
|
char const* order = dgen_region_order.val;
|
|
char const* avail = this->cart_head.countries;
|
|
size_t r;
|
|
size_t i;
|
|
|
|
assert(order != NULL);
|
|
assert(avail != NULL);
|
|
for (r = 0; (order[r] != '\0'); ++r)
|
|
for (i = 0; (i != sizeof(this->cart_head.countries)); ++i)
|
|
if ((isprint(order[r])) &&
|
|
(toupper(order[r]) == toupper(avail[i])))
|
|
return toupper(order[r]);
|
|
// Use default region.
|
|
return dgen_region;
|
|
}
|
|
|
|
/**
|
|
* Unplug a cart from the system.
|
|
* @return 0 on success.
|
|
*/
|
|
int md::unplug()
|
|
{
|
|
assert(rom != NULL);
|
|
assert(romlen != 0);
|
|
if (rom == no_rom) return 1;
|
|
unload_rom(rom);
|
|
rom = (uint8_t*)no_rom;
|
|
romlen = no_rom_size;
|
|
free(saveram);
|
|
saveram = NULL;
|
|
save_start = save_len = 0;
|
|
#ifdef WITH_MUSA
|
|
md_set_musa(1);
|
|
musa_memory_map();
|
|
md_set_musa(0);
|
|
#endif
|
|
#ifdef WITH_STAR
|
|
md_set_star(1);
|
|
memory_map(); // Update memory map to include no rom
|
|
md_set_star(0);
|
|
#endif
|
|
memset(romname, 0, sizeof(romname));
|
|
memset(&cart_head, 0, sizeof(cart_head));
|
|
reset();
|
|
|
|
while (patch_elem != NULL) {
|
|
struct patch_elem *next = patch_elem->next;
|
|
|
|
free(patch_elem);
|
|
patch_elem = next;
|
|
}
|
|
plugged = false;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Load a ROM.
|
|
* @param[in] name File name of cart to load.
|
|
* @return 0 on success.
|
|
*/
|
|
int md::load(const char *name)
|
|
{
|
|
uint8_t *temp;
|
|
size_t size;
|
|
const char *b_name;
|
|
|
|
if ((name == NULL) ||
|
|
((b_name = dgen_basename(name)) == NULL))
|
|
return 1;
|
|
temp = load_rom(&size, name);
|
|
if (temp == NULL)
|
|
return 1;
|
|
|
|
// Register name
|
|
romname[0] = '\0';
|
|
if ((b_name[0] != '\0')) {
|
|
unsigned int i;
|
|
|
|
snprintf(romname, sizeof(romname), "%s", b_name);
|
|
for (i = 0; (romname[i] != '\0'); ++i)
|
|
if (romname[i] == '.') {
|
|
memset(&(romname[i]), 0,
|
|
(sizeof(romname) - i));
|
|
break;
|
|
}
|
|
}
|
|
if (romname[0] == '\0')
|
|
snprintf(romname, sizeof(romname), "%s", "unknown");
|
|
|
|
// Fill the header with ROM info (god this is ugly)
|
|
memcpy((void*)cart_head.system_name, (void*)(temp + 0x100), 0x10);
|
|
memcpy((void*)cart_head.copyright, (void*)(temp + 0x110), 0x10);
|
|
memcpy((void*)cart_head.domestic_name,(void*)(temp + 0x120), 0x30);
|
|
memcpy((void*)cart_head.overseas_name,(void*)(temp + 0x150), 0x30);
|
|
memcpy((void*)cart_head.product_no, (void*)(temp + 0x180), 0x0e);
|
|
cart_head.checksum = temp[0x18e]<<8 | temp[0x18f]; // ugly, but endian-neutral
|
|
memcpy((void*)cart_head.control_data, (void*)(temp + 0x190), 0x10);
|
|
cart_head.rom_start = temp[0x1a0]<<24 | temp[0x1a1]<<16 | temp[0x1a2]<<8 | temp[0x1a3];
|
|
cart_head.rom_end = temp[0x1a4]<<24 | temp[0x1a5]<<16 | temp[0x1a6]<<8 | temp[0x1a7];
|
|
cart_head.ram_start = temp[0x1a8]<<24 | temp[0x1a9]<<16 | temp[0x1aa]<<8 | temp[0x1ab];
|
|
cart_head.ram_end = temp[0x1ac]<<24 | temp[0x1ad]<<16 | temp[0x1ae]<<8 | temp[0x1af];
|
|
cart_head.save_magic = temp[0x1b0]<<8 | temp[0x1b1];
|
|
cart_head.save_flags = temp[0x1b2]<<8 | temp[0x1b3];
|
|
cart_head.save_start = temp[0x1b4]<<24 | temp[0x1b5]<<16 | temp[0x1b6]<<8 | temp[0x1b7];
|
|
cart_head.save_end = temp[0x1b8]<<24 | temp[0x1b9]<<16 | temp[0x1ba]<<8 | temp[0x1bb];
|
|
memcpy((void*)cart_head.memo, (void*)(temp + 0x1c8), 0x28);
|
|
memcpy((void*)cart_head.countries, (void*)(temp + 0x1f0), 0x10);
|
|
|
|
#ifdef WITH_PICO
|
|
// Check if cartridge inserted is intended for Sega Pico.
|
|
// If it is, the Sega Pico I/O area will be enabled, and the
|
|
// Megadrive I/O area will be disabled.
|
|
if ((!strncmp(cart_head.system_name, "SEGA PICO", 9)) ||
|
|
(!strncmp(cart_head.system_name, "SEGATOYS PICO", 13)))
|
|
pico_enabled = true;
|
|
else
|
|
pico_enabled = false;
|
|
#endif
|
|
// Plug it into the memory map
|
|
plug_in(temp, size); // md then deallocates it when it's done
|
|
plugged = true;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Cycle through Z80 CPU implementations.
|
|
*/
|
|
void md::cycle_z80()
|
|
{
|
|
z80_state_dump();
|
|
z80_core = (enum z80_core)((z80_core + 1) % Z80_CORE_TOTAL);
|
|
z80_state_restore();
|
|
}
|
|
|
|
/**
|
|
* Cycle between M68K CPU implementations.
|
|
*/
|
|
void md::cycle_cpu()
|
|
{
|
|
m68k_state_dump();
|
|
cpu_emu = (enum cpu_emu)((cpu_emu + 1) % CPU_EMU_TOTAL);
|
|
m68k_state_restore();
|
|
}
|
|
|
|
/**
|
|
* Dump Z80 ram to a file named "dgz80ram".
|
|
* @return Always returns 0.
|
|
*/
|
|
int md::z80dump()
|
|
{
|
|
FILE *hand;
|
|
hand = dgen_fopen(NULL, "dgz80ram", DGEN_WRITE);
|
|
if (hand!=NULL)
|
|
{ fwrite(z80ram,1,0x10000,hand); fclose(hand); }
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* This takes a comma or whitespace-separated list of Game Genie and/or hex
|
|
* codes to patch the ROM with.
|
|
* @param[in] list List of codes separated by '\\t', '\\n', or ','.
|
|
* @param[out] errors Number of codes that failed to apply.
|
|
* @param[out] applied Number of codes that applied correctly.
|
|
* @param[out] reverted Number of codes that were reverted.
|
|
* @return 0 on success.
|
|
*/
|
|
int md::patch(const char *list, unsigned int *errors,
|
|
unsigned int *applied, unsigned int *reverted)
|
|
{
|
|
static const char delims[] = " \t\n,";
|
|
char *worklist, *tok;
|
|
struct patch p;
|
|
int ret = 0;
|
|
size_t wl_sz;
|
|
|
|
if (errors != NULL)
|
|
*errors = 0;
|
|
if (applied != NULL)
|
|
*applied = 0;
|
|
if (reverted != NULL)
|
|
*reverted = 0;
|
|
|
|
// Copy the given list to a working list so we can strtok it
|
|
wl_sz = strlen(list) + 1;
|
|
worklist = (char *)malloc(wl_sz);
|
|
if (worklist == NULL)
|
|
return -1;
|
|
strncpy(worklist, list, wl_sz);
|
|
|
|
for(tok = strtok(worklist, delims); tok; tok = strtok(NULL, delims))
|
|
{
|
|
struct patch_elem *elem = patch_elem;
|
|
struct patch_elem *prev = NULL;
|
|
uint8_t *dest = rom;
|
|
size_t mask = ~(size_t)0;
|
|
int rev = 0;
|
|
bool swap = true;
|
|
|
|
// If it's empty, toss it
|
|
if(*tok == '\0') continue;
|
|
// Decode it
|
|
decode(tok, &p);
|
|
// Discard it if it was bad code
|
|
if (((signed)p.addr == -1) || (p.addr >= (size_t)(romlen - 1))) {
|
|
if ((p.addr < 0xff0000) || (p.addr >= 0xffffff)) {
|
|
printf("Bad patch \"%s\"\n", tok);
|
|
if (errors != NULL)
|
|
++(*errors);
|
|
ret = -1;
|
|
continue;
|
|
}
|
|
// This is a RAM patch.
|
|
dest = ram;
|
|
mask = 0xffff;
|
|
}
|
|
if (dest == no_rom) {
|
|
printf("Cannot patch this ROM\n");
|
|
continue;
|
|
}
|
|
#ifndef ROM_BYTESWAP
|
|
if (dest == rom)
|
|
swap = false;
|
|
#endif
|
|
// Put it into dest (remember byteswapping)
|
|
while (elem != NULL) {
|
|
if (elem->addr == p.addr) {
|
|
// Revert a previous patch.
|
|
p.data = elem->data;
|
|
if (prev != NULL)
|
|
prev->next = elem->next;
|
|
else
|
|
patch_elem = NULL;
|
|
free(elem);
|
|
rev = 1;
|
|
break;
|
|
}
|
|
prev = elem;
|
|
elem = elem->next;
|
|
}
|
|
if (rev) {
|
|
printf("Reverting patch \"%s\" -> %06X\n", tok, p.addr);
|
|
if (reverted != NULL)
|
|
++(*reverted);
|
|
}
|
|
else {
|
|
printf("Patch \"%s\" -> %06X:%04X\n", tok, p.addr, p.data);
|
|
if (applied != NULL)
|
|
++(*applied);
|
|
if ((elem = (struct patch_elem *)malloc(sizeof(*elem))) != NULL) {
|
|
elem->next = patch_elem;
|
|
elem->addr = p.addr;
|
|
elem->data = ((dest[((p.addr + 0) ^ swap) & mask] << 8) |
|
|
(dest[((p.addr + 1) ^ swap) & mask]));
|
|
patch_elem = elem;
|
|
}
|
|
}
|
|
dest[((p.addr + 0) ^ swap) & mask] = (uint8_t)(p.data >> 8);
|
|
dest[((p.addr + 1) ^ swap) & mask] = (uint8_t)(p.data & 0xff);
|
|
}
|
|
// Done!
|
|
free(worklist);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Get saveram from FILE*.
|
|
* @param from File to read from.
|
|
* @return 0 on success.
|
|
*/
|
|
int md::get_save_ram(FILE *from)
|
|
{
|
|
return !fread((void*)saveram, save_len, 1, from);
|
|
}
|
|
|
|
/**
|
|
* Write a saveram to FILE*.
|
|
* @param into File to write to.
|
|
* @return 0 on success.
|
|
*/
|
|
int md::put_save_ram(FILE *into)
|
|
{
|
|
return !fwrite((void*)saveram, save_len, 1, into);
|
|
}
|
|
|
|
/**
|
|
* Calculates a ROM's checksum.
|
|
* @param rom ROM memory area.
|
|
* @param len ROM size.
|
|
* @return Checksum.
|
|
*/
|
|
static unsigned short calculate_checksum(unsigned char *rom,int len)
|
|
{
|
|
unsigned short checksum=0;
|
|
int i;
|
|
for (i=512;i<=(len-2);i+=2)
|
|
{
|
|
checksum+=(rom[ROM_ADDR(i+0)]<<8);
|
|
checksum+=rom[ROM_ADDR(i+1)];
|
|
}
|
|
return checksum;
|
|
}
|
|
|
|
/**
|
|
* Replace the in-memory ROM checksum with a calculated checksum.
|
|
*/
|
|
void md::fix_rom_checksum()
|
|
{
|
|
unsigned short cs; cs=calculate_checksum(rom,romlen);
|
|
if (romlen>=0x190) { rom[ROM_ADDR(0x18e)]=cs>>8; rom[ROM_ADDR(0x18f)]=cs&255; }
|
|
}
|
|
|
|
/**
|
|
* This is the default ROM, used when nothing is loaded.
|
|
*/
|
|
#ifdef ROM_BYTESWAP
|
|
|
|
const uint8_t md::no_rom[] = {
|
|
// Note: everything is byte swapped.
|
|
"\x72\x4e" "\xff\xff" // stop #0xffff
|
|
"\x71\x4e" // nop
|
|
"\x71\x4e" // nop
|
|
"\xf6\x60" // bra.b 0
|
|
};
|
|
|
|
#else
|
|
|
|
const uint8_t md::no_rom[] = {
|
|
"\x4e\x72" "\xff\xff" // stop #0xffff
|
|
"\x4e\x71" // nop
|
|
"\x4e\x71" // nop
|
|
"\x60\xf6" // bra.b 0
|
|
};
|
|
|
|
#endif
|
|
|
|
const size_t md::no_rom_size = sizeof(no_rom);
|