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
}
int cps1_driver_init(void)
{
m68000_init();
z80_init();
z80_bank = -1;
if (machine_driver_type == MACHINE_qsound)
{
EEPROM_init(&qsound_eeprom_interface);
cps1_nvram_read_write(0);
}
else if (machine_driver_type == MACHINE_wofhfh)
{
EEPROM_init(&qsound_eeprom_interface);
cps1_nvram_read_write(0);
}
else if (machine_driver_type == MACHINE_pang3)
{
EEPROM_init(&pang3_eeprom_interface);
cps1_nvram_read_write(0);
}
return 1;
}
void neogeo_driver_init(void)
{
memcpy(neogeo_game_vectors, memory_region_cpu1, 0x80);
neogeo_vectors[0] = memory_region_user1;
neogeo_vectors[1] = neogeo_game_vectors;
m68k_second_bank = 0xffffffff;
z80_bank[0] = 0xffffffff;
z80_bank[1] = 0xffffffff;
z80_bank[2] = 0xffffffff;
z80_bank[3] = 0xffffffff;
if (memory_length_cpu1 > 0x100000)
neogeo_set_cpu1_second_bank(0x100000);
else
neogeo_set_cpu1_second_bank(0x000000);
neogeo_set_cpu2_bank(0, 0x8000);
neogeo_set_cpu2_bank(1, 0xc000);
neogeo_set_cpu2_bank(2, 0xe000);
neogeo_set_cpu2_bank(3, 0xf000);
m68000_init();
z80_init();
}
void gen_init (void)
{
int i;
/* initialize CPUs */
m68k_set_cpu_type (M68K_CPU_TYPE_68000);
m68k_init();
z80_init(0,0,0,z80_irq_callback);
/* default 68000 mapping */
for (i=16; i<24; i++)
{
m68k_readmap_8[i] = ILLEGAL;
m68k_readmap_16[i] = ILLEGAL;
m68k_writemap_8[i] = ILLEGAL;
m68k_writemap_16[i] = ILLEGAL;
}
/* Z80, I/O, CONTROL */
m68k_readmap_8[20] = SYSTEM_IO;
m68k_readmap_16[20] = SYSTEM_IO;
m68k_writemap_8[20] = SYSTEM_IO;
m68k_writemap_16[20] = SYSTEM_IO;
/* SEGA PICO */
if (system_hw == SYSTEM_PICO)
{
m68k_readmap_8[16] = PICO_HW;
m68k_readmap_16[16] = PICO_HW;
m68k_writemap_8[16] = PICO_HW;
m68k_writemap_16[16] = PICO_HW;
/* Notaz: there is no IO CONTROL area (Z80/YM2612/IO) */
m68k_readmap_8[20] = UNUSED;
m68k_readmap_16[20] = UNUSED;
m68k_writemap_8[20] = UNUSED;
m68k_writemap_16[20] = UNUSED;
}
/* VDP */
for (i=24; i<28; i++)
{
m68k_readmap_8[i] = VDP;
m68k_readmap_16[i] = VDP;
m68k_writemap_8[i] = VDP;
m68k_writemap_16[i] = VDP;
}
/* WRAM */
for (i=28; i<32; i++)
{
m68k_readmap_8[i] = WRAM;
m68k_readmap_16[i] = WRAM;
m68k_writemap_8[i] = WRAM;
m68k_writemap_16[i] = WRAM;
}
}
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 neogeo_driver_init(void)
{
if (neogeo_boot_bios)
memcpy(neogeo_game_vectors, memory_region_user1, 0x100);
memcpy(memory_region_cpu1, memory_region_user1, 0x100);
neogeo_vectors[0] = memory_region_user1;
neogeo_vectors[1] = neogeo_game_vectors;
memset(memory_region_hctrl, 0, sizeof(memory_region_hctrl));
z80_cdda_offset = 0;
m68000_init();
z80_init();
}
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);
}
static void system_init(bool overseas, bool PAL, bool overseas_reported, bool PAL_reported)
{
gen_running = 1;
z80_init();
z80_readbyte = MD_Z80_ReadByte;
z80_writebyte = MD_Z80_WriteByte;
z80_readport = MD_Z80_ReadPort;
z80_writeport = MD_Z80_WritePort;
gen_init();
MDIO_Init(overseas, PAL, overseas_reported, PAL_reported);
MainVDP.SetSettings(PAL, PAL_reported, MDFN_GetSettingB("md.correct_aspect"));
#ifdef WANT_DEBUGGER
MDDBG_Init();
#endif
}
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 cps2_driver_init(void)
{
if (memory_length_user1)
{
m68000_init();
m68000_set_encrypted_range(0, memory_length_user1 - 1, memory_region_user1);
}
else
{
m68000_init();
}
z80_init();
z80_bank = -1;
EEPROM_init();
cps2_nvram_read_write(0);
//SFA3 patch
if (!strcmp(driver->name, "sfa3"))
EEPROM_write_data(0x75, 0x04);
}
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();
}
int
main( int argc, char **argv )
{
FILE *f;
progname = argv[0];
if( argc < 2 ) {
fprintf( stderr, "Usage: %s <testsfile>\n", progname );
return 1;
}
testsfile = argv[1];
if( init_dummies() ) return 1;
/* Initialise the tables used by the Z80 core */
z80_init();
f = fopen( testsfile, "r" );
if( !f ) {
fprintf( stderr, "%s: couldn't open tests file `%s': %s\n", progname,
testsfile, strerror( errno ) );
return 1;
}
while( run_test( f ) ) {
/* Do nothing */
}
if( fclose( f ) ) {
fprintf( stderr, "%s: couldn't close `%s': %s\n", progname, testsfile,
strerror( errno ) );
return 1;
}
return 0;
}
void gen_init(void)
{
int i;
/* initialize 68k */
m68k_set_cpu_type(M68K_CPU_TYPE_68000);
m68k_init();
/* initialize Z80 */
z80_init(0,z80_irq_callback);
/* initialize 68k memory map */
/* $000000-$7FFFFF is affected to cartridge area (see md_cart.c) */
for (i=0x80; i<0x100; i++)
{
/* $800000-$FFFFFF is affected to WRAM (see VDP DMA) */
m68k_memory_map[i].base = work_ram;
m68k_memory_map[i].read8 = NULL;
m68k_memory_map[i].read16 = NULL;
m68k_memory_map[i].write8 = NULL;
m68k_memory_map[i].write16 = NULL;
zbank_memory_map[i].read = NULL;
zbank_memory_map[i].write = NULL;
}
/* initialize 68k memory handlers */
for (i=0x80; i<0xe0; i++)
{
/* $800000-$DFFFFF : illegal area by default */
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;
}
/* $A10000-$A1FFFF : I/O & Control registers */
m68k_memory_map[0xa1].read8 = ctrl_io_read_byte;
m68k_memory_map[0xa1].read16 = ctrl_io_read_word;
m68k_memory_map[0xa1].write8 = ctrl_io_write_byte;
m68k_memory_map[0xa1].write16 = ctrl_io_write_word;
zbank_memory_map[0xa1].read = zbank_read_ctrl_io;
zbank_memory_map[0xa1].write = zbank_write_ctrl_io;
/* $C0xxxx, $C8xxxx, $D0xxxx, $D8xxxx : VDP ports */
for (i=0xc0; i<0xe0; i+=8)
{
m68k_memory_map[i].read8 = vdp_read_byte;
m68k_memory_map[i].read16 = vdp_read_word;
m68k_memory_map[i].write8 = vdp_write_byte;
m68k_memory_map[i].write16 = vdp_write_word;
zbank_memory_map[i].read = zbank_read_vdp;
zbank_memory_map[i].write = zbank_write_vdp;
}
/* MS COMPATIBILITY mode */
if (system_hw == SYSTEM_PBC)
{
/* initialize Z80 read handler */
/* NB: memory map & write handler are defined by cartridge hardware */
z80_readmem = z80_sms_memory_r;
/* initialize Z80 ports handlers */
z80_writeport = z80_sms_port_w;
z80_readport = z80_sms_port_r;
/* initialize MS cartridge hardware */
sms_cart_init();
}
else
{
/* PICO hardware */
if (system_hw == SYSTEM_PICO)
{
/* additional registers mapped to $800000-$80FFFF */
m68k_memory_map[0x80].read8 = pico_read_byte;
m68k_memory_map[0x80].read16 = pico_read_word;
m68k_memory_map[0x80].write8 = m68k_unused_8_w;
m68k_memory_map[0x80].write16 = m68k_unused_16_w;
/* there is no I/O area (Notaz) */
m68k_memory_map[0xa1].read8 = m68k_read_bus_8;
m68k_memory_map[0xa1].read16 = m68k_read_bus_16;
m68k_memory_map[0xa1].write8 = m68k_unused_8_w;
m68k_memory_map[0xa1].write16 = m68k_unused_16_w;
/* page registers */
pico_current = 0x00;
pico_page[0] = 0x00;
pico_page[1] = 0x01;
pico_page[2] = 0x03;
pico_page[3] = 0x07;
pico_page[4] = 0x0F;
pico_page[5] = 0x1F;
pico_page[6] = 0x3F;
}
/* initialize Z80 memory map */
/* $0000-$3FFF is mapped to Z80 RAM (8K mirrored) */
/* $4000-$FFFF is mapped to hardware but Z80.PC should never point there */
for (i=0; i<64; i++)
{
z80_readmap[i] = &zram[(i & 7) << 10];
}
/* initialize Z80 memory handlers */
z80_writemem = z80_md_memory_w;
z80_readmem = z80_md_memory_r;
/* initialize Z80 port handlers */
z80_writeport = z80_unused_port_w;
z80_readport = z80_unused_port_r;
/* initialize MD cartridge hardware */
md_cart_init();
}
}
/*-------------------------------------------------------------------------
Do all one time initializations.
---------------------------------------------------------------------------*/
void neogeo_initialize ( void )
{
neogeo_audio_track = NULL;
/* Create and register the watchdog timer */
timer_create ( &neogeo_watchdog_timer, neogeo_watchdog_callback );
timer_register ( &neogeo_watchdog_timer );
/* Create and register the drawline timer. */
timer_create ( &neogeo_drawline_timer, neogeo_drawline_callback );
timer_register ( &neogeo_drawline_timer );
/* Create and register the screen timer. */
timer_create ( &neogeo_screen_timer, neogeo_screen_callback );
timer_register ( &neogeo_screen_timer );
/* Create and register the VBL timer */
timer_create ( &neogeo_VBL_timer, neogeo_VBL_callback );
timer_register ( &neogeo_VBL_timer );
/* Create and register the HBL timer */
timer_create ( &neogeo_HIRQ_timer, neogeo_HIRQ_callback );
timer_register ( &neogeo_HIRQ_timer );
/* Create and register the CDROM IRQ1 Timer */
timer_create ( &neogeo_cdrom_irq1_timer, neogeo_cdrom_irq1_callback );
timer_register ( &neogeo_cdrom_irq1_timer );
/* Create and register the CDROM IRQ2 Timer */
timer_create ( &neogeo_cdrom_irq2_timer, neogeo_cdrom_irq2_callback );
timer_register ( &neogeo_cdrom_irq2_timer );
/* Create and register the timer for audio commands */
timer_create ( &neogeo_audio_command_timer, neogeo_audio_command_timer_callback );
timer_register ( &neogeo_audio_command_timer );
/* Create and register the YM2610 timers */
timer_create ( &neogeo_ym2610_timer_a, neogeo_ym2610_timer_callback );
timer_set_data ( &neogeo_ym2610_timer_a, 0 );
timer_register ( &neogeo_ym2610_timer_a );
timer_create ( &neogeo_ym2610_timer_b, neogeo_ym2610_timer_callback );
timer_set_data ( &neogeo_ym2610_timer_b, 1 );
timer_register ( &neogeo_ym2610_timer_b );
/* Initialize the memory lookup table */
memory_init_lookup();
/* Initialize the 68000 emulation core */
m68k_set_cpu_type ( M68K_CPU_TYPE_68000 );
m68k_init();
/* Inizialize the z80 core */
z80_init ( 0, Z80_CLOCK, NULL, neogeo_z80_irq_callback );
/* Initialize the YM2610 */
YM2610Init ( 8000000, neogeo_audio_frequency, neogeo_PCM_RAM, 0x100000, YM2610TimerHandler, YM2610IrqHandler );
/* Patch protection check 1 (Disc recognition) */
m68k_debug_write_memory_16 ( 0xC0D280, 0x4E71 );
/* Patch protection check 2 ("Now loading" screen) */
m68k_debug_write_memory_16 ( 0xC0EB82, 0x4E71 );
/* CD-Loading "speed hack" ^.^ */
m68k_debug_write_memory_32 ( 0xC0E764, 0x4E722000 );
m68k_debug_write_memory_16 ( 0xC0E768, 0x4E71 );
/* Reset all internal register and variables to a known state */
neogeo_cold_reset();
/* Test if the underlying OS has accurate sleep() */
neogeo_test_delay_accurate();
}
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 *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;
}
void gen_init(void)
{
int i;
/* initialize CPUs */
m68k_set_cpu_type(M68K_CPU_TYPE_68000);
m68k_init();
z80_init(0,z80_irq_callback);
/* initialize 68k mapped memory */
/* $000000-$7fffff is affected to cartridge area (see cart_hw.c) */
/* $800000-$ffffff is affected to WRAM (see VDP DMA) */
for (i=0x80; i<0x100; i++)
{
m68k_memory_map[i].base = work_ram;
m68k_memory_map[i].read8 = NULL;
m68k_memory_map[i].read16 = NULL;
m68k_memory_map[i].write8 = NULL;
m68k_memory_map[i].write16 = NULL;
zbank_memory_map[i].read = NULL;
zbank_memory_map[i].write = NULL;
}
/* initialize 68k memory handlers */
for (i=0x80; i<0xe0; i++)
{
/* illegal area */
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;
}
/* Z80 bus (bank access) */
zbank_memory_map[0xa0].read = zbank_lockup_r;
zbank_memory_map[0xa0].write = zbank_lockup_w;
/* I/O & Control registers */
m68k_memory_map[0xa1].read8 = ctrl_io_read_byte;
m68k_memory_map[0xa1].read16 = ctrl_io_read_word;
m68k_memory_map[0xa1].write8 = ctrl_io_write_byte;
m68k_memory_map[0xa1].write16 = ctrl_io_write_word;
zbank_memory_map[0xa1].read = zbank_read_ctrl_io;
zbank_memory_map[0xa1].write = zbank_write_ctrl_io;
/* VDP (initially locked on models with TMSS) */
if (!(config.tmss & 1))
{
for (i=0xc0; i<0xe0; i+=8)
{
m68k_memory_map[i].read8 = vdp_read_byte;
m68k_memory_map[i].read16 = vdp_read_word;
m68k_memory_map[i].write8 = vdp_write_byte;
m68k_memory_map[i].write16 = vdp_write_word;
zbank_memory_map[i].read = zbank_read_vdp;
zbank_memory_map[i].write = zbank_write_vdp;
}
}
/* SEGA PICO */
if (system_hw == SYSTEM_PICO)
{
m68k_memory_map[0x80].read8 = pico_read_byte;
m68k_memory_map[0x80].read16 = pico_read_word;
m68k_memory_map[0x80].write8 = m68k_unused_8_w;
m68k_memory_map[0x80].write16 = m68k_unused_16_w;
/* there is no I/O area (Notaz) */
m68k_memory_map[0xa1].read8 = m68k_read_bus_8;
m68k_memory_map[0xa1].read16 = m68k_read_bus_16;
m68k_memory_map[0xa1].write8 = m68k_unused_8_w;
m68k_memory_map[0xa1].write16 = m68k_unused_16_w;
/* page registers */
pico_current = 0x00;
pico_page[0] = 0x00;
pico_page[1] = 0x01;
pico_page[2] = 0x03;
pico_page[3] = 0x07;
pico_page[4] = 0x0F;
pico_page[5] = 0x1F;
pico_page[6] = 0x3F;
}
}
void init() {
z80_init(&z80);
mem_init(&mem);
}
void gameboy_init()
{
/* init global values */
// global_init();
/* init z80 */
z80_init();
/* init cycles syncronizer */
cycles_init();
/* init input */
input_init();
/* init timer */
timer_init();
/* init serial */
serial_init();
/* init sound (this will start audio thread) */
sound_init();
/* reset GPU counters */
gpu_reset();
/* reset to default values */
mmu_write_no_cyc(0xFF05, 0x00);
mmu_write_no_cyc(0xFF06, 0x00);
mmu_write_no_cyc(0xFF07, 0x00);
mmu_write_no_cyc(0xFF10, 0x80);
mmu_write_no_cyc(0xFF11, 0xBF);
mmu_write_no_cyc(0xFF12, 0xF3);
mmu_write_no_cyc(0xFF14, 0xBF);
mmu_write_no_cyc(0xFF16, 0x3F);
mmu_write_no_cyc(0xFF17, 0x00);
mmu_write_no_cyc(0xFF19, 0xBF);
mmu_write_no_cyc(0xFF1A, 0x7F);
mmu_write_no_cyc(0xFF1B, 0xFF);
mmu_write_no_cyc(0xFF1C, 0x9F);
mmu_write_no_cyc(0xFF1E, 0xBF);
mmu_write_no_cyc(0xFF20, 0xFF);
mmu_write_no_cyc(0xFF21, 0x00);
mmu_write_no_cyc(0xFF22, 0x00);
mmu_write_no_cyc(0xFF23, 0xBF);
mmu_write_no_cyc(0xFF24, 0x77);
mmu_write_no_cyc(0xFF25, 0xF3);
mmu_write_no_cyc(0xFF26, 0xF1);
mmu_write_no_cyc(0xFF40, 0x91);
mmu_write_no_cyc(0xFF41, 0x80);
mmu_write_no_cyc(0xFF42, 0x00);
mmu_write_no_cyc(0xFF43, 0x00);
mmu_write_no_cyc(0xFF44, 0x00);
mmu_write_no_cyc(0xFF45, 0x00);
mmu_write_no_cyc(0xFF47, 0xFC);
mmu_write_no_cyc(0xFF48, 0xFF);
mmu_write_no_cyc(0xFF49, 0xFF);
mmu_write_no_cyc(0xFF4A, 0x00);
mmu_write_no_cyc(0xFF4B, 0x00);
mmu_write_no_cyc(0xFF98, 0xDC);
mmu_write_no_cyc(0xFFFF, 0x00);
mmu_write_no_cyc(0xC000, 0x08);
mmu_write_no_cyc(0xFFFE, 0x69);
if (global_cgb)
state.a = 0x11;
else
state.a = 0x00;
state.b = 0x00;
state.c = 0x13;
state.d = 0x00;
state.e = 0xd8;
state.h = 0x01;
state.l = 0x4d;
state.pc = 0x0100;
state.sp = 0xFFFE;
*state.f = 0xB0;
/* init semaphore for pauses */
sem_init(&gameboy_sem, 0, 0);
/* mark as inited */
gameboy_inited = 1;
return;
}
