void _z80_init(void)
{
#ifdef CPUZ80_CZ80_CORE
Cz80_Init(&neocd_cz80_struc);
Cz80_Set_Fetch(&neocd_cz80_struc,0x0000,0xFFFF,(u32)((void *)&mame_z80mem));
Cz80_Set_ReadB(&neocd_cz80_struc,&cpu_readmem8);
Cz80_Set_WriteB(&neocd_cz80_struc,&cpu_writemem8);
#if CZ80_USE_WORD_HANDLER
Cz80_Set_ReadW(&neocd_cz80_struc,&cpu_readmem16);
Cz80_Set_WriteW(&neocd_cz80_struc,&cpu_writemem16);
#endif
Cz80_Set_INPort(&neocd_cz80_struc,(CZ80_READ *)&mame_z80_readport16);
Cz80_Set_OUTPort(&neocd_cz80_struc,(CZ80_WRITE *)&mame_z80_writeport16);
Cz80_Set_IRQ_Callback(&neocd_cz80_struc,cpu_z80_irq_callback);
Cz80_Reset(&neocd_cz80_struc);
//Cz80_Exec(&neocd_cz80_struc,100000);
#endif
#ifdef CPUZ80_MAMEZ80_CORE
z80_init();
/*
z80map1 = mame_z80mem + 0x8000;
z80map2 = mame_z80mem + 0xc000;
z80map3 = mame_z80mem + 0xe000;
z80map4 = mame_z80mem + 0xf000;
z80_bank[0]=0x8000;
z80_bank[1]=0xc000;
z80_bank[2]=0xe000;
z80_bank[3]=0xf000;
*/
z80_reset(NULL);
//z80_set_irq_callback(cpu_z80_irq_callback);
#endif
}
void cpu_z80_init(void)
{
z80_init_memmap();
z80_map_fetch(0x0000, 0x7fff, memory.rom.cpu_z80.p);
z80_map_fetch(0x8000, 0xbfff, memory.rom.cpu_z80.p + 0x8000);
z80_map_fetch(0xc000, 0xdfff, memory.rom.cpu_z80.p + 0xc000);
z80_map_fetch(0xe000, 0xefff, memory.rom.cpu_z80.p + 0xe000);
z80_map_fetch(0xf000, 0xf7ff, memory.rom.cpu_z80.p + 0xf000);
z80_map_fetch(0xf800, 0xffff, memory.z80_ram);
z80_add_read(0x0000, 0x7fff, Z80_MAP_DIRECT, memory.rom.cpu_z80.p);
z80_map_read(0x8000, 0xbfff, memory.rom.cpu_z80.p + 0x8000);
z80_map_read(0xc000, 0xdfff, memory.rom.cpu_z80.p + 0xc000);
z80_map_read(0xe000, 0xefff, memory.rom.cpu_z80.p + 0xe000);
z80_map_read(0xf000, 0xf7ff, memory.rom.cpu_z80.p + 0xf000);
z80_add_read(0xf800, 0xffff, Z80_MAP_DIRECT, memory.z80_ram);
z80_bank[0]=0x8000;
z80_bank[1]=0xc000;
z80_bank[2]=0xe000;
z80_bank[3]=0xf000;
z80_add_write(0xf800, 0xffff, Z80_MAP_DIRECT, memory.z80_ram);
z80_end_memmap();
z80_set_in(z80_port_read);
z80_set_out(z80_port_write);
/* z80_set_fetch_callback(&debug);*/
cpu_z80_init_save_state();
z80_reset();
}
/* C128-specific reset sequence. */
void machine_specific_reset(void)
{
serial_traps_reset();
ciacore_reset(machine_context.cia1);
ciacore_reset(machine_context.cia2);
sid_reset();
rs232drv_reset();
rsuser_reset();
printer_reset();
vdc_reset();
/* The VIC-II must be the *last* to be reset. */
vicii_reset();
cartridge_reset();
drive_reset();
datasette_reset();
z80mem_initialize();
z80_reset();
}
void cps1_driver_reset(void)
{
m68000_reset();
z80_reset();
coin_counter_reset();
sound_data = 0x00;
cps1_sound_fade_timer = 0;
}
void cps2_driver_reset(void)
{
m68000_reset();
z80_reset();
if(!option_sound_enable) qsound_sharedram1[0xfff] = 0x77;
coin_counter_reset();
next_update_first_line = FIRST_VISIBLE_LINE;
}
void Z80_reset(void)
{
Z80Enabled = 0;
z80_writebyte = NGP_z80_writebyte;
z80_readbyte = NGP_z80_readbyte;
z80_writeport = NGP_z80_writeport;
z80_readport = NGP_z80_readport;
z80_init();
z80_reset();
}
void z80_set_reset_line(int state)
{
if (z80_suspended & SUSPEND_REASON_RESET)
{
if (state == CLEAR_LINE)
z80_suspended &= ~SUSPEND_REASON_RESET;
}
else if (state == ASSERT_LINE)
{
z80_suspended |= SUSPEND_REASON_RESET;
z80_reset();
}
}
void gen_reset_w(int state)
{
//printf("ZRESET: %d, %d\n", state, md_timestamp);
zreset = (state & 1);
zbusack = 1 ^ (zbusreq & zreset);
MDSound_SetYM2612Reset(!zreset);
if(zreset == 0)
{
z80_reset();
}
}
/* Handle reset button if poweron=0;
handle hard reset or initial poweron if poweron=1 */
void trs_reset(int poweron)
{
trs_emu_mouse = FALSE;
#ifndef ANDROID
/* Close disks opened by Z80 programs */
do_emt_resetdisk();
#endif
/* Reset devices (Model I SYSRES, Model III/4 RESET) */
trs_cassette_reset();
trs_timer_speed(0);
trs_disk_init(poweron); // also inits trs_hard and trs_stringy
/* I'm told that the hard disk controller is enabled on powerup */
/* XXX should trs_hard_init do this, then? */
trs_hard_out(TRS_HARD_CONTROL,
TRS_HARD_SOFTWARE_RESET|TRS_HARD_DEVICE_ENABLE);
if (trs_model == 5) {
/* Switch in boot ROM */
z80_out(0x9C, 1);
}
if (trs_model >= 4) {
/* Turn off various memory map and video mode bits */
z80_out(0x84, 0);
}
if (trs_model >= 3) {
grafyx_write_mode(0);
trs_interrupt_mask_write(0);
trs_nmi_mask_write(0);
}
if (trs_model == 3) {
grafyx_m3_reset();
}
if (trs_model == 1) {
hrg_onoff(0); /* Switch off HRG1B hi-res graphics. */
}
trs_kb_reset(); /* Part of keyboard stretch kludge */
trs_cancel_event();
trs_timer_interrupt(0);
if (poweron || trs_model >= 4) {
/* Reset processor */
z80_reset();
} else {
/* Signal a nonmaskable interrupt. */
trs_reset_button_interrupt(1);
trs_schedule_event(trs_reset_button_interrupt, 0, 2000);
}
}
void neogeo_driver_reset(void)
{
memset(exmem, 0, sizeof(exmem));
memset(exmem_latch, 0, sizeof(exmem_latch));
memset(exmem_bank, 0, sizeof(exmem_bank));
exmem_counter = 0;
upload_mode = UPLOAD_IMMIDIATE;
upload_type = UNKNOWN_TYPE;
upload_offset1 = 0;
upload_offset2 = 0;
upload_length = 0;
upload_pattern = 0;
upload_executing = 0;
memcpy(memory_region_cpu1, neogeo_vectors[1], 0x100); // game vector
watchdog_reset_w(0, 0, 0);
raster_line = 0;
raster_counter = RASTER_COUNTER_START;
scanline_read = 0;
display_position_interrupt_start = 1000;
display_position_interrupt_counter = 0;
display_position_interrupt_control = 0;
display_counter = 0;
vblank_interrupt_pending = 0;
display_position_interrupt_pending = 0;
sound_code = 0;
result_code = 0;
pending_command = 0;
auto_animation_frame_counter = 0;
auto_animation_speed = 0;
auto_animation_disabled = 0;
auto_animation_counter = 0;
neogeo_reset_driver_type();
m68000_reset();
z80_reset();
}
void m1snd_addz80(long clock, void *handlers)
{
char *z80cctx;
int cpunum;
z80cctx = malloc(4*1024);
cpunum = timer_add_cpu(CPU_Z80C, clock, z80_execute, z80_getcycles, z80_yield, z80_getctx, z80_setctx, z80cctx);
memory_register_cpu(cpunum, 8, M1_CPU_LE);
// printf("adding Z80 #%d\n", cpunum);
z80_init();
z80_reset(NULL);
z80_set_irq_callback(z80_irq_callback);
z80_vector = 0xff;
z80_getctx(z80cctx);
}
void gen_reset (unsigned int hard_reset)
{
if (hard_reset)
{
/* Clear RAM */
memset (work_ram, 0, sizeof (work_ram));
memset (zram, 0, sizeof (zram));
/* Reset ROM mapping */
if (config.bios_enabled == 3)
{
rom_readmap[0] = &bios_rom[0];
rom_size = 0x800;
}
else
{
rom_readmap[0] = &cart_rom[0];
rom_size = genromsize;
}
uint8 i;
for (i=1; i<8; i++) rom_readmap[i] = &cart_rom[i << 19];
}
gen_running = 1;
zreset = 0; /* Z80 is reset */
zbusreq = 0; /* Z80 has control of the Z bus */
zbusack = 1; /* Z80 is busy using the Z bus */
zbank = 0; /* Assume default bank is 000000-007FFF */
zirq = 0; /* No interrupts occuring */
resetline = -1;
/* Reset CPUs */
m68k_pulse_reset ();
z80_reset ();
_YM2612_Reset();
#ifdef NGC
/* register SOFTRESET */
SYS_SetResetCallback(set_softreset);
#endif
}
int32 qsf_command(void *handle, int32 command, int32 parameter)
{
qsf_synth_t *s = handle;
switch (command)
{
case COMMAND_RESTART:
memcpy (s->RAM, s->initRAM, 0x1000);
memcpy (s->RAM2, s->initRAM2, 0x1000);
if (s->z80) {
z80_reset(s->z80, NULL);
z80_set_irq_callback(s->z80, qsf_irq_cb);
}
qsound_sh_stop (s->qs);
s->qs = qsound_sh_start(&qsintf);
s->samples_to_next_tick = samples_per_tick;
return AO_SUCCESS;
}
return AO_FAIL;
}
int sms_z80_init(void) {
cpuz80 = (CrabZ80_t *)malloc(sizeof(CrabZ80_t));
if(cpuz80 == NULL) {
fprintf(stderr, "Out of memory while initializing Z80 in debug mode\n");
return -1;
}
/* Initialize CrabZ80 */
CrabZ80_init(cpuz80);
CrabZ80_reset(cpuz80);
CrabZ80_set_memwrite(cpuz80, sms_debug_memwrite);
CrabZ80_set_memread(cpuz80, sms_debug_memread);
CrabZ80_set_portwrite(cpuz80, sms_debug_portwrite);
CrabZ80_set_portread(cpuz80, sms_debug_portread);
z80_init();
z80_reset();
return 0;
}
void cpu_z80_init(void)
{
// init_mamez80_mem();
z80_init();
/* bank initalisation */
/*
z80map1 = memory.sm1 + 0x8000;
z80map2 = memory.sm1 + 0xc000;
z80map3 = memory.sm1 + 0xe000;
z80map4 = memory.sm1 + 0xf000;
z80_bank[0]=0x8000;
z80_bank[1]=0xc000;
z80_bank[2]=0xe000;
z80_bank[3]=0xf000;
*/
//memcpy(mame_z80mem, memory.sm1, 0xf800);
z80_reset(NULL);
//set_irq_callback(mame_z80_irq_callback);
//z80_init_save_state();
}
void gen_reset(void)
{
/* Clear RAM */
#ifndef MEM2
memset(work_ram, 0, sizeof(work_ram));
memset(zram, 0, sizeof(zram));
#else
memset(work_ram, 0, 0x10000);
memset(zram, 0, 0x2000);
#endif
gen_running = 1;
zreset = 0; /* Z80 is reset */
zbusreq = 0; /* Z80 has control of the Z bus */
zbusack = 1; /* Z80 is busy using the Z bus */
zbank = 0; /* Assume default bank is 000000-007FFF */
zirq = 0; /* No interrupts occuring */
gen_io_reset();
C68k_Reset(&Main68K);
z80_reset();
}
void gen_reset_w (unsigned int state)
{
int z80_cycles_to_run;
if (state)
{
/* stop RESET process */
if (!zbusreq && !zreset)
{
/* Z80 started */
/* z80 was OFF during the last 68k cycles */
/* we burn the appropriate number of z80 cycles */
z80_cycles_to_run = line_z80 + ((count_m68k - line_m68k)*7)/15;
count_z80 = z80_cycles_to_run;
}
}
else
{
/* start RESET process */
if (!zbusreq && zreset)
{
/* Z80 stopped */
/* z80 was ON during the last 68k cycles */
/* we execute the appropriate number of z80 cycles */
z80_cycles_to_run = line_z80 + ((count_m68k - line_m68k)*7)/15;
z80_run(z80_cycles_to_run);
}
/* Reset Z80 & YM2612 */
_YM2612_Reset();
z80_reset ();
}
zreset = state;
zbusack = 1 ^ (zbusreq & zreset);
}
int32 qsf_start(uint8 *buffer, uint32 length)
{
uint8 *file, *lib_decoded, *lib_raw_file;
uint64 file_len, lib_len, lib_raw_length;
corlett_t *lib;
z80_init();
Z80ROM = malloc(512*1024);
QSamples = malloc(8*1024*1024);
skey1 = skey2 = 0;
akey = 0;
xkey = 0;
cur_bank = 0;
memset(RAM, 0, 0x1000);
memset(RAM2, 0, 0x1000);
// Decode the current QSF
if (corlett_decode(buffer, length, &file, &file_len, &c) != AO_SUCCESS)
{
return AO_FAIL;
}
// Get the library file
if (c->lib[0] != 0)
{
uint64 tmp_length;
#if DEBUG_LOADER
printf("Loading library: %s\n", c->lib);
#endif
if (ao_get_lib(c->lib, &lib_raw_file, &tmp_length) != AO_SUCCESS)
{
return AO_FAIL;
}
lib_raw_length = tmp_length;
if (corlett_decode(lib_raw_file, lib_raw_length, &lib_decoded, &lib_len, &lib) != AO_SUCCESS)
{
free(lib_raw_file);
return AO_FAIL;
}
// Free up raw file
free(lib_raw_file);
// use the contents
qsf_walktags(lib_decoded, lib_decoded+lib_len);
// Dispose the corlett structure for the lib - we don't use it
free(lib);
}
// now patch the file into RAM OVER the libraries
qsf_walktags(file, file+file_len);
free(file);
if ((skey1 != 0) && (skey2 != 0))
{
#if DEBUG_LOADER
printf("Decoding Kabuki: skey1 %08x skey2 %08x akey %04x xkey %02x\n", skey1, skey2, akey, xkey);
#endif
uses_kabuki = 1;
cps1_decode((unsigned char *)Z80ROM, skey1, skey2, akey, xkey);
}
// set qsfby tag
strcpy(qsfby, "n/a");
if (c)
{
int i;
for (i = 0; i < MAX_UNKNOWN_TAGS; i++)
{
if (!strcasecmp(c->tag_name[i], "qsfby"))
{
strcpy(qsfby, c->tag_data[i]);
}
}
}
z80_reset(NULL);
z80_set_irq_callback(qsf_irq_cb);
qsintf.sample_rom = QSamples;
qsound_sh_start(&qsintf);
return AO_SUCCESS;
}
void Z80_SetEnable(bool set)
{
Z80Enabled = set;
if(!set)
z80_reset();
}
int main(void) {
v = no_routine;
v_hook = no_routine;
h_hook = no_routine;
pal_mutex = 0;
VDP_SET_REGISTER(MODE_SET_1, 0x16);
VDP_SET_REGISTER(NAME_TABLE_SCROLLA_BASE, SCROLL_A_ADDR(0xc000));
VDP_SET_REGISTER(NAME_TABLE_WINDOW_BASE, SCROLL_A_ADDR(0x10000));
VDP_SET_REGISTER(NAME_TABLE_SCROLLB_BASE, SCROLL_B_ADDR(0xe000));
VDP_SET_REGISTER(SPRITE_ATTRIBUTE_BASE, SPRITE_ADDR(SPRITE_BASE));
VDP_SET_REGISTER(0x06, 0x00);
VDP_SET_REGISTER(BACKGROUND_COLOR, 0x00);
VDP_SET_REGISTER(0x08, 0x01);
VDP_SET_REGISTER(0x09, 0x01);
VDP_SET_REGISTER(H_COUNTER, 1);
VDP_SET_REGISTER(MODE_SET_3, HORIZONTAL_LINE);
VDP_SET_REGISTER(MODE_SET_4, CELLW_40);
VDP_SET_REGISTER(HSCROLL_BASE, HSCROLL_ADDR( 0xfc00));
VDP_SET_REGISTER(0x0e, 0x00);
VDP_SET_INC(0x02);
VDP_SET_REGISTER(SCROLL_SIZE, SCROLL_WIDTH_64);
VDP_SET_REGISTER(WINDOW_X, 0x00);
VDP_SET_REGISTER(WINDOW_Y, 0x00);
VDP_SET_REGISTER(19, 0x00);
VDP_SET_REGISTER(20, 0x00);
VDP_SET_REGISTER(21, 0x00);
VDP_SET_REGISTER(22, 0x00);
z80_write(0,z80_prog, Z80_PROG_LEN);
z80_reset();
brightness = -8;
fade_to = -8;
updating_palette = 0;
dma_corrupt = 0;
secret_pos = 0;
lcontroller = 0;
song_pos = 0;
song_ticks = 0;
VDP_SET_REGISTER(MODE_SET_2, 0x74);
proc[0]();// init_sega();
for(;;) {
SYNC;
update_palette();
if(song_ticks == 0) {
h_hook = no_routine;
v_hook = no_routine;
fade_to = -8;
brightness = -8;
update_palette();
proc[song_pos*2]();
song_ticks = 0;
}
update_vgm_pos();
proc[(song_pos*2)+1]();
song_ticks++;
if(vgm_pos>=scenes[song_pos]) {
song_pos++;
song_ticks = 0;
}
lcontroller = controller;
controller = poll_ctrl1();
if((controller != lcontroller) && (controller != 0)) {
if(secret_msg[secret_pos] == controller)
secret_pos++;
else
secret_pos = 0;
if(secret_pos == 4) secret();
}
}
}
/* Reset Z80 emulator */
void cpu_reset(void)
{
z80_reset(0);
z80_set_irq_callback(sms_irq_callback);
}
void *qsf_start(const char *path, uint8 *buffer, uint32 length)
{
qsf_synth_t *s = malloc (sizeof (qsf_synth_t));
memset (s, 0, sizeof (qsf_synth_t));
uint8 *file = NULL, *lib_decoded = NULL, *lib_raw_file = NULL;
uint64 file_len, lib_len, lib_raw_length;
corlett_t *lib;
s->z80 = z80_init();
s->z80->userdata = s;
s->Z80ROM = malloc(512*1024);
s->QSamples = malloc(8*1024*1024);
s->skey1 = s->skey2 = 0;
s->akey = 0;
s->xkey = 0;
s->cur_bank = 0;
// Decode the current QSF
if (corlett_decode(buffer, length, &file, &file_len, &s->c) != AO_SUCCESS)
{
return AO_FAIL;
}
// Get the library file
if (s->c->lib[0] != 0)
{
uint64 tmp_length;
char libpath[PATH_MAX];
ao_getlibpath (path, s->c->lib, libpath, sizeof (libpath));
#if DEBUG_LOADER
printf("Loading library: %s\n", libpath);
#endif
if (ao_get_lib(libpath, &lib_raw_file, &tmp_length) != AO_SUCCESS)
{
free (file);
qsf_stop (s);
return NULL;
}
lib_raw_length = tmp_length;
if (corlett_decode(lib_raw_file, lib_raw_length, &lib_decoded, &lib_len, &lib) != AO_SUCCESS)
{
free(lib_raw_file);
free (file);
qsf_stop (s);
return NULL;
}
// Free up raw file
free(lib_raw_file);
// use the contents
qsf_walktags(s, lib_decoded, lib_decoded+lib_len);
// Dispose the corlett structure for the lib - we don't use it
free(lib);
if (lib_decoded) {
free (lib_decoded);
lib_decoded = NULL;
}
}
// now patch the file into RAM OVER the libraries
qsf_walktags(s, file, file+file_len);
free(file);
if ((s->skey1 != 0) && (s->skey2 != 0))
{
#if DEBUG_LOADER
printf("Decoding Kabuki: skey1 %08x skey2 %08x akey %04x xkey %02x\n", skey1, skey2, akey, xkey);
#endif
s->uses_kabuki = 1;
cps1_decode((unsigned char *)s->Z80ROM, s->skey1, s->skey2, s->akey, s->xkey);
}
// set qsfby tag
strcpy(s->qsfby, "n/a");
if (s->c)
{
int i;
for (i = 0; i < MAX_UNKNOWN_TAGS; i++)
{
if (!strcasecmp(s->c->tag_name[i], "qsfby"))
{
strcpy(s->qsfby, s->c->tag_data[i]);
}
}
}
memcpy (s->initRAM, s->RAM, 0x1000);
memcpy (s->initRAM2, s->RAM2, 0x1000);
if (s->z80) {
z80_reset(s->z80, NULL);
z80_set_irq_callback(s->z80, qsf_irq_cb);
}
qsintf.sample_rom = s->QSamples;
s->qs = qsound_sh_start(&qsintf);
s->samples_to_next_tick = samples_per_tick;
return s;
}
// RESET EMULATED MACHINE -----------------------------------------------------
void Machine_Reset(void)
{
int i;
static byte VDPInit [16] =
{
/* Values set by BIOS */
0x36, /*0xA0*/ 0x80 /* zero for Coleco */, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0x00,
0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00
/* Old (guessed ?) values */
// 0x06, 0x00, 0x0E, 0xFF, 0xFF, 0x7F, 0x00, 0x00,
// 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00
};
#ifdef DEBUG_WHOLE
Msg(MSGT_DEBUG, "Machine_Reset();");
#endif
// Unpause machine if necessary
if (g_machine_flags & MACHINE_PAUSED)
Machine_Pause();
// Set driver & machine stuff
drv_set (g_machine.driver_id);
Machine_Set_Mapper ();
if ((g_machine_flags & MACHINE_RUN) != 0 /*== MACHINE_RUN */)
Machine_Set_Mapping (); // ^^ FIXME: the test above isn't beautiful since MACHINE_RUN contains multiple flags, but I'm unsure which of them is actually needed to perform the correct test
Machine_Set_Handler_IO ();
Machine_Set_Handler_Read ();
Machine_Set_Handler_Write ();
Machine_Set_Handler_Loop ();
Machine_Set_Country ();
Machine_Set_IPeriod ();
Machine_Set_TV_Lines ();
// VDP MODEL --------------------------------------------------------------
if (DB.current_entry && DB.current_entry->emu_vdp_model != -1)
{
g_machine.VDP.model = DB.current_entry->emu_vdp_model;
}
else
{
if (g_driver->id == DRV_GG)
g_machine.VDP.model = VDP_MODEL_315_5378;
else
g_machine.VDP.model = VDP_MODEL_315_5226;
}
// 3-D GLASSES ------------------------------------------------------------
sms.Glasses_Register = ((Glasses.Mode == GLASSES_MODE_SHOW_ONLY_LEFT) ? 1 : 0);
if (Glasses.Mode == GLASSES_MODE_SHOW_ONLY_LEFT) {
sms.Glasses_Register = 1;
}
// CPU (MARAT FAIZULLIN'S CORE) -------------------------------------------
CPU_Loop_Stop = TRUE;
CPU_ForceNMI = FALSE;
#ifdef MARAT_Z80
sms.R.IPeriod = opt.Cur_IPeriod;
sms.R.Trace = FALSE;
ResetZ80 (&sms.R);
sms.R.IFF |= IFF_IM1;
sms.R.IAutoReset = FALSE;
sms.R.TrapBadOps = FALSE;
// CPU (MAME'S CORE) ------------------------------------------------------
#elif MAME_Z80
z80_reset (NULL);
z80_set_irq_callback (Get_IRQ_Vector);
z80_set_irq_line (0, ASSERT_LINE);
z80_set_irq_line (0, CLEAR_LINE);
// CPU (RICHARD MITTON'S CORE) --------------------------------------------
#elif RAZE_Z80
z80_init_memmap();
z80_add_write (0x0000, 0xFFFF, Z80_MAP_HANDLED, WrZ80);
for (i = 0; i < 4; i ++)
{
z80_add_read ((i * 0x2000), (i * 0x2000) + 0x1FFF, Z80_MAP_DIRECT, Mem_Pages [i]);
z80_map_fetch ((i * 0x2000), (i * 0x2000) + 0x1FFF, Mem_Pages [i]);
}
for (i = 4; i < 8; i ++)
{
z80_map_fetch ((i * 0x2000), (i * 0x2000) + 0x1FFF, Mem_Pages [i]);
z80_map_read ((i * 0x2000), (i * 0x2000) + 0x1FFF, Mem_Pages [i]);
}
z80_set_in (InZ80);
z80_set_out (OutZ80);
z80_end_memmap();
z80_reset();
#endif
// MEMORY -----------------------------------------------------------------
// Clear RAM
if (g_driver->id == DRV_SMS && sms.Country == COUNTRY_JAPAN)
{
// On Japanese SMS clear RAM with 0xF0 patterns
// I am not sure how reliable is that pattern but this is what I'm seeing on my JSMS
// In theory this should be applied to all drivers, all countries, etc. but the exact
// behavior of other systems and bioses should be inspected more in details before
// generalizing that.
// The game "Ali Baba" require a non-00 and non-FF memory pattern to run to a bug
// in the code which makes it execute uninitialized memory from 0xFF07 onward.
// An F0 pattern correspond to RET P which happens to fix the game.
memset (RAM, 0xF0, 0x10000);
}
else
{
memset (RAM, 0x00, 0x10000);
}
memset (VRAM, 0, 0x04000); // Clear all VRAM
memset (PRAM, 0, 0x00040); // Clear all PRAM (palette)
#ifdef DEBUG_UNINITIALIZED_RAM_ACCESSES
memset (RAM_IsUninitialized, 1, 0x2000);
#endif
// Unload BIOS if...
if ((g_driver->id != DRV_SMS || sms.Country != COUNTRY_EXPORT) && (g_machine_flags & MACHINE_ROM_LOADED))
{
#ifdef DEBUG_WHOLE
Msg(MSGT_DEBUG, "Machine_Reset(): BIOS_Unload()");
#endif
BIOS_Unload();
}
// GRAPHICS ---------------------------------------------------------------
for (i = 0; i < 16; i++)
Tms_VDP_Out (i, ((i == 1 && g_driver->id == DRV_COLECO) ? 0x00 : VDPInit [i]));
for (i = 0; i < MAX_TILES; i++)
tgfx.Tile_Dirty [i] = TILE_DIRTY_DECODE | TILE_DIRTY_REDRAW;
VDP_UpdateLineLimits();
//assert(!Screenbuffer_IsLocked());
al_set_target_bitmap(screenbuffer_1);
al_clear_to_color(COLOR_BLACK);
al_set_target_bitmap(screenbuffer_2);
al_clear_to_color(COLOR_BLACK);
//screenbuffer = screenbuffer_1;
//screenbuffer_next = screenbuffer_2;
g_machine.VDP.sprite_shift_x = 0;
g_machine.VDP.scroll_x_latched = 0;
g_machine.VDP.scroll_y_latched = 0;
memset(g_machine.VDP.scroll_x_latched_table, 0, sizeof(g_machine.VDP.scroll_x_latched_table));
tsms.VDP_Video_Change = VDP_VIDEO_CHANGE_ALL;
// GRAPHICS: SPRITE FLICKERING --------------------------------------------
if (g_configuration.sprite_flickering & SPRITE_FLICKERING_AUTO)
{
if (DB.current_entry && (DB.current_entry->flags & DB_FLAG_EMU_SPRITE_FLICKER))
g_configuration.sprite_flickering |= SPRITE_FLICKERING_ENABLED;
else
g_configuration.sprite_flickering &= ~SPRITE_FLICKERING_ENABLED;
}
// PALETTE ----------------------------------------------------------------
//if (machine & MACHINE_POWER_ON)
Palette_Emulation_Reset();
// INPUT/OUTPUT/VDP -------------------------------------------------------
sms.VDP_Status = 0x00;
sms.VDP_Address = 0x0000;
sms.VDP_Access_Mode = VDP_Access_Mode_1;
sms.VDP_Access_First = 0x00;
sms.VDP_Pal = 0x00;
sms.VDP_ReadLatch = 0x00;
sms.Lines_Left = 255;
sms.Pending_HBlank = FALSE;
sms.Pending_NMI = FALSE;
tsms.VDP_Line = 0;
// CONTROLLERS ------------------------------------------------------------
for (i = 0; i < 8; i ++)
tsms.Control [i] = 0xFFFF; /* 0x3FFF */
tsms.Control_GG = /*0x20 | 0x80*/ 0;
tsms.Control_Start_Pause = 0;
tsms.Port3F = 0;
sms.Input_Mode = 0x07;
// SOUND ------------------------------------------------------------------
sms.FM_Register = 0;
sms.FM_Magic = 0;
// if (fm_use == TRUE) fm_init (FM_ALL_INIT);
// resume_fm();
FM_Reset();
SN76489_Reset (g_machine.TV->CPU_clock, Sound.SampleRate);
if (Sound.LogVGM.Logging == VGM_LOGGING_ACCURACY_SAMPLE)
VGM_Update_Timing (&Sound.LogVGM);
Sound_ResetCycleCounter();
// FIXME: add a reset handler per driver, instead of the code below...
// GAME GEAR COMMUNICATION PORT
if (g_machine.driver_id == DRV_GG)
Comm_Reset();
// SF-7000
if (g_machine.driver_id == DRV_SF7000)
SF7000_Reset();
// DEBUGGER ---------------------------------------------------------------
#ifdef MEKA_Z80_DEBUGGER
Debugger_MachineReset();
#endif
}
void neogeo_driver_reset(void)
{
#ifdef ADHOC
if (adhoc_enable)
{
pd4990a.seconds = 0;
pd4990a.minutes = 0;
pd4990a.hours = 0;
pd4990a.days = 0;
pd4990a.month = 0;
pd4990a.year = 0;
pd4990a.weekday = 0;
}
else
#endif
{
pspTime today;
int y, m, d;
sceRtcGetCurrentClockLocalTime(&today);
pd4990a.seconds = ((today.seconds / 10) << 4) + (today.seconds % 10);
pd4990a.minutes = ((today.minutes / 10) << 4) + (today.minutes % 10);
pd4990a.hours = ((today.hour / 10) << 4) + (today.hour % 10);
pd4990a.days = ((today.day / 10) << 4) + (today.day % 10);
pd4990a.month = today.month;
pd4990a.year = (((today.year % 100) / 10) << 4) + (today.year % 10);
y = today.year;
m = today.month;
d = today.day;
if (m == 1 || m == 2) { y--; m += 12; }
pd4990a.weekday = (y + (y / 4) - (y / 100) + (y / 400) + ((13 * m + 8) / 5) + d) % 7;
}
memset(neogeo_ram, 0, 0x10000);
memcpy(memory_region_cpu1, neogeo_vectors[0], 0x80); // bios vector
main_cpu_vector_table_source = 0;
watchdog_reset_w(0, 0, 0);
raster_counter = RASTER_COUNTER_START;
scanline_read = 0;
display_position_interrupt_counter = 0;
display_position_interrupt_control = 0;
display_counter = 0;
vblank_interrupt_pending = 0;
display_position_interrupt_pending = 0;
sound_code = 0;
result_code = 0;
pending_command = 0;
auto_animation_frame_counter = 0;
auto_animation_speed = 0;
auto_animation_disabled = 0;
auto_animation_counter = 0;
neogeo_rng = 0x2345;
save_ram_unlocked = 0;
controller_select = 0;
neogeo_reset_driver_type();
if (machine_init_type == INIT_ms5pcb
|| machine_init_type == INIT_svcpcb)
{
memcpy(memory_region_user1, memory_region_user1 + 0x20000 + neogeo_hard_dipsw * 0x20000, 0x20000);
}
#if !RELEASE
if (machine_init_type == INIT_kog)
{
memory_region_cpu1[0x1ffffc/2] = neogeo_hard_dipsw;
}
#endif
m68000_reset();
z80_reset();
}
/* Set up the z80 emulation */
void z80_init(int debug)
{
z80_init_tables();
z80_reset();
if(debug) fdebug = fopen("debug.out","wt");
}
void gen_reset(int hard_reset)
{
/* System Reset */
if (hard_reset)
{
/* clear RAM */
memset (work_ram, 0x00, sizeof (work_ram));
memset (zram, 0x00, sizeof (zram));
}
else
{
/* reset YM2612 (on hard reset, this is done by sound_reset) */
fm_reset(0);
}
/* 68k & Z80 could restart anywhere in VDP frame (Bonkers, Eternal Champions, X-Men 2) */
mcycles_68k = mcycles_z80 = (uint32)((MCYCLES_PER_LINE * lines_per_frame) * ((double)rand() / (double)RAND_MAX));
//mcycles_68k = mcycles_z80 = 0;
if (system_hw == SYSTEM_PBC)
{
/* reset MS cartridge hardware */
sms_cart_reset();
/* Z80 is running */
zstate = 1;
/* 68k is halted */
m68k_pulse_halt();
}
else
{
/* reset MD cartridge hardware */
md_cart_reset(hard_reset);
/* Z80 bus is released & Z80 is reseted */
m68k_memory_map[0xa0].read8 = m68k_read_bus_8;
m68k_memory_map[0xa0].read16 = m68k_read_bus_16;
m68k_memory_map[0xa0].write8 = m68k_unused_8_w;
m68k_memory_map[0xa0].write16 = m68k_unused_16_w;
zstate = 0;
/* assume default bank is $000000-$007FFF */
zbank = 0;
/* TMSS & OS ROM support */
if (config.tmss & 1)
{
/* clear TMSS register */
memset(tmss, 0x00, sizeof(tmss));
/* VDP access is locked by default */
int i;
for (i=0xc0; i<0xe0; i+=8)
{
m68k_memory_map[i].read8 = m68k_lockup_r_8;
m68k_memory_map[i].read16 = m68k_lockup_r_16;
m68k_memory_map[i].write8 = m68k_lockup_w_8;
m68k_memory_map[i].write16 = m68k_lockup_w_16;
zbank_memory_map[i].read = zbank_lockup_r;
zbank_memory_map[i].write = zbank_lockup_w;
}
/* OS ROM is mapped at $000000-$0007FF */
if (config.tmss & 2)
{
m68k_memory_map[0].base = bios_rom;
}
}
/* reset 68k */
m68k_pulse_reset();
}
/* reset Z80 */
z80_reset();
}
// RESET EMULATED MACHINE -----------------------------------------------------
void Machine_Reset (void)
{
int i;
static byte VDPInit [16] =
{
/* Values set by BIOS */
0x36, /*0xA0*/ 0x80 /* zero for Coleco */, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0x00,
0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00
/* Old (guessed ?) values */
// 0x06, 0x00, 0x0E, 0xFF, 0xFF, 0x7F, 0x00, 0x00,
// 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00
};
#ifdef DEBUG_WHOLE
Msg (MSGT_DEBUG, "Machine_Reset();");
#endif
// Unpause machine if necessary
if (machine & MACHINE_PAUSED)
Machine_Pause ();
// Set driver & machine stuff
drv_set (cur_machine.driver_id);
Machine_Set_Mapper ();
if ((machine & MACHINE_RUN) != 0 /*== MACHINE_RUN */ && (cur_drv->id != DRV_NES))
Machine_Set_Mapping (); // ^^ FIXME: the test above isn't beautiful since MACHINE_RUN contains multiple flags, but I'm unsure which of them is actually needed to perform the correct test
Machine_Set_Handler_IO ();
Machine_Set_Handler_Read ();
Machine_Set_Handler_Write ();
Machine_Set_Handler_Loop ();
Machine_Set_Country ();
Machine_Set_IPeriod ();
Machine_Set_TV_Lines ();
// VDP MODEL --------------------------------------------------------------
if (DB_CurrentEntry && DB_CurrentEntry->emu_vdp_model != -1)
cur_machine.VDP.model = DB_CurrentEntry->emu_vdp_model;
else
{
if (cur_drv->id == DRV_GG)
cur_machine.VDP.model = VDP_MODEL_315_5378;
else
cur_machine.VDP.model = VDP_MODEL_315_5226;
}
// 3-D GLASSES ------------------------------------------------------------
sms.Glasses_Register = ((Glasses.Mode == GLASSES_MODE_SHOW_ONLY_LEFT) ? 1 : 0);
// CPU (MARAT FAIZULLIN'S CORE) -------------------------------------------
CPU_Loop_Stop = TRUE;
CPU_ForceNMI = FALSE;
#ifdef MARAT_Z80
sms.R.IPeriod = opt.Cur_IPeriod;
sms.R.Trace = FALSE;
ResetZ80 (&sms.R);
sms.R.IFF |= IFF_IM1;
sms.R.IAutoReset = FALSE;
sms.R.TrapBadOps = FALSE;
// CPU (MAME'S CORE) ------------------------------------------------------
#elif MAME_Z80
z80_reset (NULL);
z80_set_irq_callback (Get_IRQ_Vector);
z80_set_irq_line (0, ASSERT_LINE);
z80_set_irq_line (0, CLEAR_LINE);
// CPU (RICHARD MITTON'S CORE) --------------------------------------------
#elif RAZE_Z80
z80_init_memmap ();
z80_add_write (0x0000, 0xFFFF, Z80_MAP_HANDLED, WrZ80);
for (i = 0; i < 4; i ++)
{
z80_add_read ((i * 0x2000), (i * 0x2000) + 0x1FFF, Z80_MAP_DIRECT, Mem_Pages [i]);
z80_map_fetch ((i * 0x2000), (i * 0x2000) + 0x1FFF, Mem_Pages [i]);
}
for (i = 4; i < 8; i ++)
{
z80_map_fetch ((i * 0x2000), (i * 0x2000) + 0x1FFF, Mem_Pages [i]);
z80_map_read ((i * 0x2000), (i * 0x2000) + 0x1FFF, Mem_Pages [i]);
}
z80_set_in (InZ80);
z80_set_out (OutZ80);
z80_end_memmap ();
z80_reset ();
#endif
// MEMORY -----------------------------------------------------------------
memset (RAM, 0, 0x10000); // Clear all RAM
memset (VRAM, 0, 0x04000); // Clear all VRAM
PRAM = PRAM_Static;
memset (PRAM, 0, 0x00040); // Clear all PRAM (palette)
// Unload BIOS if...
if ((cur_drv->id != DRV_SMS || sms.Country != COUNTRY_EXPORT) && (machine & MACHINE_ROM_LOADED))
{
#ifdef DEBUG_WHOLE
Msg (MSGT_DEBUG, "Machine_Reset(): BIOS_Unload()");
#endif
BIOS_Unload ();
}
// GRAPHICS ---------------------------------------------------------------
for (i = 0; i < 16; i++)
Tms_VDP_Out (i, ((i == 1 && cur_drv->id == DRV_COLECO) ? 0x00 : VDPInit [i]));
for (i = 0; i < MAX_TILES; i++)
tgfx.Tile_Dirty [i] = TILE_DIRTY_DECODE | TILE_DIRTY_REDRAW;
VDP_UpdateLineLimits();
clear_bitmap (screenbuffer_1);
clear_bitmap (screenbuffer_2);
screenbuffer = screenbuffer_1;
screenbuffer_next = screenbuffer_2;
cur_machine.VDP.sprite_shift_x = 0;
cur_machine.VDP.scroll_x_latched = 0;
cur_machine.VDP.scroll_y_latched = 0;
memset(cur_machine.VDP.scroll_x_latched_table, 0, sizeof(cur_machine.VDP.scroll_x_latched_table));
tsms.VDP_Video_Change = VDP_VIDEO_CHANGE_ALL;
// GRAPHICS: SPRITE FLICKERING --------------------------------------------
if (g_Configuration.sprite_flickering & SPRITE_FLICKERING_AUTO)
{
if (DB_CurrentEntry && (DB_CurrentEntry->flags & DB_FLAG_EMU_SPRITE_FLICKER))
g_Configuration.sprite_flickering |= SPRITE_FLICKERING_ENABLED;
else
g_Configuration.sprite_flickering &= ~SPRITE_FLICKERING_ENABLED;
}
// PALETTE ----------------------------------------------------------------
//if (machine & MACHINE_POWER_ON)
Palette_Emulation_Reset();
// INPUT/OUTPUT/VDP -------------------------------------------------------
sms.VDP_Status = 0x00;
sms.VDP_Address = 0x0000;
sms.VDP_Access_Mode = VDP_Access_Mode_1;
sms.VDP_Access_First = 0x00;
sms.VDP_Pal = 0x00;
sms.VDP_ReadLatch = 0x00;
sms.Lines_Left = 255;
sms.Pending_HBlank = FALSE;
sms.Pending_NMI = FALSE;
tsms.VDP_Line = 0;
// CONTROLLERS ------------------------------------------------------------
for (i = 0; i < 8; i ++)
tsms.Control [i] = 0xFFFF; /* 0x3FFF */
tsms.Control_GG = /*0x20 | 0x80*/ 0;
tsms.Control_Start_Pause = 0;
tsms.Periph_Nat = 0;
sms.Input_Mode = 0x07;
// SOUND ------------------------------------------------------------------
sms.FM_Register = 0;
sms.FM_Magic = 0;
// if (fm_use == TRUE) fm_init (FM_ALL_INIT);
// resume_fm ();
FM_Reset ();
SN76489_Reset (cur_machine.TV->CPU_clock, audio_sample_rate);
if (Sound.LogVGM.Logging == VGM_LOGGING_ACCURACY_SAMPLE)
VGM_Update_Timing (&Sound.LogVGM);
// Reset sound cycle counter
Sound_Update_Count = 0;
Sound_CycleCounter = 0;
// FIXME: add a reset handler per driver, instead of the code below...
// GAME GEAR COMMUNICATION PORT
if (cur_machine.driver_id == DRV_GG)
{
Comm_Reset ();
}
// SF-7000
if (cur_machine.driver_id == DRV_SF7000)
{
SF7000_Reset ();
}
// NINTENDO CRAP
if (cur_machine.driver_id == DRV_NES /* && cfg.NES_Enabled */)
{
ROM = Game_ROM;
NES_Reset ();
}
// DEBUGGER ---------------------------------------------------------------
#ifdef MEKA_Z80_DEBUGGER
Debugger_MachineReset ();
#endif
}
int load_state_from_mem(void *stor)
{
int i;
/* Initialize everything */
z80_reset(0);
z80_set_irq_callback(sms_irq_callback);
system_reset();
if(snd.enabled)
sound_reset();
//davex: header is not saved in memory state
// Load VDP context
memcpy(&vdp, stor, sizeof(vdp_t)); //VDP context
stor += sizeof(vdp_t);
//Load SMS context (1/3)
memcpy(&sms, stor, sizeof(sms_t) );
stor += sizeof(sms_t);
//Load SMS context (2/3)
memcpy(&cart.fcr[0],stor, 1 );
stor += 1;
memcpy(&cart.fcr[1],stor, 1 );
stor += 1;
memcpy(&cart.fcr[2],stor, 1 );
stor += 1;
memcpy(&cart.fcr[3],stor, 1 );
stor += 1;
//Load SMS context (3/3)
memcpy(&cart.sram, stor, 0x8000);
stor += 0x8000;
// Load Z80 context
memcpy(Z80_Context, stor, sizeof(Z80_Regs) );
stor += sizeof(Z80_Regs);
memcpy(&after_EI, stor, sizeof(int) );
stor += sizeof(int);
// Load YM2413 context
FM_SetContext(stor);
stor += FM_GetContextSize();
// Load SN76489 context
SN76489_SetContext(0, stor);
/* Restore callbacks */
z80_set_irq_callback(sms_irq_callback);
for(i = 0x00; i <= 0x2F; i++)
{
cpu_readmap[i] = &cart.rom[(i & 0x1F) << 10];
cpu_writemap[i] = dummy_write;
}
for(i = 0x30; i <= 0x3F; i++)
{
cpu_readmap[i] = &sms.wram[(i & 0x07) << 10];
cpu_writemap[i] = &sms.wram[(i & 0x07) << 10];
}
sms_mapper_w(3, cart.fcr[3]);
sms_mapper_w(2, cart.fcr[2]);
sms_mapper_w(1, cart.fcr[1]);
sms_mapper_w(0, cart.fcr[0]);
/* Force full pattern cache update */
bg_list_index = 0x200;
for(i = 0; i < 0x200; i++)
{
bg_name_list[i] = i;
bg_name_dirty[i] = -1;
}
/* Restore palette */
for(i = 0; i < PALETTE_SIZE; i++)
palette_sync(i, 1);
viewport_check();
return 1;
}
void sms_z80_reset(void) {
CrabZ80_reset(cpuz80);
z80_reset();
}
void system_load_state(void *fd)
{
int i;
uint8 *buf;
char id[4];
uint16 version;
/* Initialize everything */
z80_reset(0);
z80_set_irq_callback(sms_irq_callback);
system_reset();
if(snd.enabled)
sound_reset();
/* Read header */
fread(id, 4, 1, fd);
fread(&version, 2, 1, fd);
/* Load VDP context */
fread(&vdp, sizeof(vdp_t), 1, fd);
/* Load SMS context */
fread(&sms, sizeof(sms_t), 1, fd);
cart.fcr[0] = fgetc(fd);
cart.fcr[1] = fgetc(fd);
cart.fcr[2] = fgetc(fd);
cart.fcr[3] = fgetc(fd);
fread(cart.sram, 0x8000, 1, fd);
/* Load Z80 context */
fread(Z80_Context, sizeof(Z80_Regs), 1, fd);
fread(&after_EI, sizeof(int), 1, fd);
/* Load YM2413 context */
buf = malloc(FM_GetContextSize());
fread(buf, FM_GetContextSize(), 1, fd);
FM_SetContext(buf);
free(buf);
/* Load SN76489 context */
buf = malloc(SN76489_GetContextSize());
fread(buf, SN76489_GetContextSize(), 1, fd);
SN76489_SetContext(0, buf);
free(buf);
/* Restore callbacks */
z80_set_irq_callback(sms_irq_callback);
for(i = 0x00; i <= 0x2F; i++)
{
cpu_readmap[i] = &cart.rom[(i & 0x1F) << 10];
cpu_writemap[i] = dummy_write;
}
for(i = 0x30; i <= 0x3F; i++)
{
cpu_readmap[i] = &sms.wram[(i & 0x07) << 10];
cpu_writemap[i] = &sms.wram[(i & 0x07) << 10];
}
sms_mapper_w(3, cart.fcr[3]);
sms_mapper_w(2, cart.fcr[2]);
sms_mapper_w(1, cart.fcr[1]);
sms_mapper_w(0, cart.fcr[0]);
/* Force full pattern cache update */
bg_list_index = 0x200;
for(i = 0; i < 0x200; i++)
{
bg_name_list[i] = i;
bg_name_dirty[i] = -1;
}
/* Restore palette */
for(i = 0; i < PALETTE_SIZE; i++)
palette_sync(i, 1);
viewport_check();
}
