ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/waterbox/ngp/mem.cpp

690 lines
16 KiB
C++
Raw Blame History

//---------------------------------------------------------------------------
// NEOPOP : Emulator as in Dreamland
//
// Copyright (c) 2001-2002 by neopop_uk
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// This program 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; either version 2 of the License, or
// (at your option) any later version. See also the license.txt file for
// additional informations.
//---------------------------------------------------------------------------
#include "neopop.h"
#include "Z80_interface.h"
#include "bios.h"
#include "gfx.h"
#include "mem.h"
#include "interrupt.h"
#include "sound.h"
#include "flash.h"
#include "rtc.h"
//=============================================================================
namespace MDFN_IEN_NGP
{
extern uint8 settings_language;
extern bool lagged;
extern void (*inputcallback)();
//Hack way of returning good Flash status.
bool FlashStatusEnable = FALSE;
static uint32 FlashStatus;
uint8 CPUExRAM[16384];
bool debug_abort_memory = FALSE;
bool debug_mask_memory_error_messages = FALSE;
bool memory_unlock_flash_write = FALSE;
bool memory_flash_error = FALSE;
bool memory_flash_command = FALSE;
uint8 SC0BUF; // Serial channel 0 buffer.
uint8 COMMStatus;
// In very very very rare conditions(like on embedded platforms with no virtual memory and very limited RAM and
// malloc happens to return a pointer aligned to a 64KiB boundary), a FastReadMap entry may be NULL even if
// it points to valid data when it's added to the address of the read, but
// if this happens, it will only make the emulator slightly slower.
static uint8 *FastReadMap[256], *FastReadMapReal[256];
void SetFRM(void) // Call this function after rom is loaded
{
for (unsigned int x = 0; x < 256; x++)
FastReadMapReal[x] = NULL;
for (unsigned int x = 0x20; x <= 0x3f; x++)
{
if (ngpc_rom.length > (x * 65536 + 65535 - 0x20000))
FastReadMapReal[x] = &ngpc_rom.data[x * 65536 - 0x200000] - x * 65536;
}
for (unsigned int x = 0x80; x <= 0x9f; x++)
{
if (ngpc_rom.length > (x * 65536 + 65535 - 0x80000))
FastReadMapReal[x] = &ngpc_rom.data[x * 65536 - 0x800000] - x * 65536;
}
}
void RecacheFRM(void)
{
for (int x = 0; x < 256; x++)
FastReadMap[x] = FlashStatusEnable ? NULL : FastReadMapReal[x];
}
static void *translate_address_read(uint32 address)
{
address &= 0xFFFFFF;
//Get Flash status?
if (FlashStatusEnable)
{
if ((address >= ROM_START && address <= ROM_END) || (address >= HIROM_START && address <= HIROM_END))
{
FlashStatusEnable = FALSE;
RecacheFRM();
if (address == 0x220000 || address == 0x230000)
{
FlashStatus = 0xFFFFFFFF;
return &FlashStatus;
}
}
}
//ROM (LOW)
if (address >= ROM_START && address <= ROM_END)
{
if (address < ROM_START + ngpc_rom.length)
return ngpc_rom.data + (address - ROM_START);
else
return NULL;
}
//ROM (HIGH)
if (address >= HIROM_START && address <= HIROM_END)
{
if (address < HIROM_START + (ngpc_rom.length - 0x200000))
return ngpc_rom.data + 0x200000 + (address - HIROM_START);
else
return NULL;
}
// ===================================
//BIOS Access?
if ((address & 0xFF0000) == 0xFF0000)
{
return ngpc_bios + (address & 0xFFFF); // BIOS ROM
}
return NULL;
}
//=============================================================================
static void *translate_address_write(uint32 address)
{
address &= 0xFFFFFF;
if (memory_unlock_flash_write)
{
//ROM (LOW)
if (address >= ROM_START && address <= ROM_END)
{
if (address < ROM_START + ngpc_rom.length)
return ngpc_rom.data + (address - ROM_START);
else
return NULL;
}
//ROM (HIGH)
if (address >= HIROM_START && address <= HIROM_END)
{
if (address < HIROM_START + (ngpc_rom.length - 0x200000))
return ngpc_rom.data + 0x200000 + (address - HIROM_START);
else
return NULL;
}
}
else
{
//ROM (LOW)
if (address >= ROM_START && address <= ROM_END)
{
//Ignore Flash commands
if (address == 0x202AAA || address == 0x205555)
{
// system_debug_message("%06X: Enable Flash command from %06X", pc, address);
memory_flash_command = TRUE;
return NULL;
}
//Set Flash status reading?
if (address == 0x220000 || address == 0x230000)
{
// system_debug_message("%06X: Flash status read from %06X", pc, address);
FlashStatusEnable = TRUE;
RecacheFRM();
return NULL;
}
if (memory_flash_command)
{
//Write the 256byte block around the flash data
flash_write(address & 0xFFFF00, 256);
//Need to issue a new command before writing will work again.
memory_flash_command = FALSE;
// system_debug_message("%06X: Direct Flash write to %06X", pc, address & 0xFFFF00);
// system_debug_stop();
//Write to the rom itself.
if (address < ROM_START + ngpc_rom.length)
return ngpc_rom.data + (address - ROM_START);
}
}
}
// ===================================
return NULL;
}
/* WARNING: 32-bit loads and stores apparently DON'T have to be 4-byte-aligned(so we must +2 instead of |2). */
/* Treat all 32-bit operations as two 16-bit operations */
uint8 loadB(uint32 address)
{
address &= 0xFFFFFF;
if (FastReadMap[address >> 16])
return (FastReadMap[address >> 16][address]);
if (address == 0x6f82)
{
lagged = false;
if (inputcallback)
inputcallback();
}
uint8 *ptr = (uint8 *)translate_address_read(address);
if (ptr)
return *ptr;
if (address >= 0x8000 && address <= 0xbfff)
return (NGPGfx->read8(address));
if (address >= 0x4000 && address <= 0x7fff)
{
return (*(uint8 *)(CPUExRAM + address - 0x4000));
}
if (address >= 0x70 && address <= 0x7F)
{
return (int_read8(address));
}
if (address >= 0x90 && address <= 0x97)
{
return (rtc_read8(address));
}
if (address >= 0x20 && address <= 0x29)
{
return (timer_read8(address));
}
if (address == 0x50)
return (SC0BUF);
if (address == 0xBC)
return Z80_ReadComm();
//printf("UNK B R: %08x\n", address);
return (0);
}
uint16 loadW(uint32 address)
{
address &= 0xFFFFFF;
if (address & 1)
{
uint16 ret;
ret = loadB(address);
ret |= loadB(address + 1) << 8;
return (ret);
}
if (FastReadMap[address >> 16])
return (MDFN_de16lsb<true>(&FastReadMap[address >> 16][address]));
if (address == 0x6f82)
{
lagged = false;
if (inputcallback)
inputcallback();
}
uint16 *ptr = (uint16 *)translate_address_read(address);
if (ptr)
return MDFN_de16lsb<true>(ptr);
if (address >= 0x8000 && address <= 0xbfff)
return (NGPGfx->read16(address));
if (address >= 0x4000 && address <= 0x7fff)
{
return (MDFN_de16lsb<true>(CPUExRAM + address - 0x4000));
}
if (address == 0x50)
return (SC0BUF);
if (address >= 0x70 && address <= 0x7F)
{
uint16 ret;
ret = int_read8(address);
ret |= int_read8(address + 1) << 8;
return (ret);
}
if (address >= 0x90 && address <= 0x97)
{
uint16 ret;
ret = rtc_read8(address);
ret |= rtc_read8(address + 1) << 8;
return (ret);
}
if (address >= 0x20 && address <= 0x29)
{
uint16 ret;
ret = timer_read8(address);
ret |= timer_read8(address + 1) << 8;
return (ret);
}
if (address == 0xBC)
return Z80_ReadComm();
//printf("UNK W R: %08x\n", address);
return (0);
}
uint32 loadL(uint32 address)
{
uint32 ret;
ret = loadW(address);
ret |= loadW(address + 2) << 16;
return (ret);
}
//=============================================================================
void storeB(uint32 address, uint8 data)
{
address &= 0xFFFFFF;
if (address >= 0x8000 && address <= 0xbfff)
{
NGPGfx->write8(address, data);
return;
}
if (address >= 0x4000 && address <= 0x7fff)
{
*(uint8 *)(CPUExRAM + address - 0x4000) = data;
return;
}
if (address >= 0x70 && address <= 0x7F)
{
int_write8(address, data);
return;
}
if (address >= 0x20 && address <= 0x29)
{
timer_write8(address, data);
return;
}
if (address == 0x50)
{
SC0BUF = data;
return;
}
if (address == 0x6f) // Watchdog timer
{
return;
}
if (address == 0xb2) // Comm?
{
COMMStatus = data & 1;
return;
}
if (address == 0xb9)
{
if (data == 0x55)
Z80_SetEnable(1);
else if (data == 0xAA)
Z80_SetEnable(0);
return;
}
if (address == 0xb8)
{
if (data == 0x55)
MDFNNGPCSOUND_SetEnable(1);
else if (data == 0xAA)
MDFNNGPCSOUND_SetEnable(0);
return;
}
if (address == 0xBA)
{
Z80_nmi();
return;
}
if (address == 0xBC)
{
Z80_WriteComm(data);
return;
}
if (address >= 0xa0 && address <= 0xA3)
{
if (!Z80_IsEnabled())
{
if (address == 0xA1)
Write_SoundChipLeft(data);
else if (address == 0xA0)
Write_SoundChipRight(data);
}
//DAC Write
if (address == 0xA2)
{
dac_write_left(data);
}
else if (address == 0xA3)
{
dac_write_right(data);
}
return;
}
//printf("%08x %02x\n", address, data);
uint8 *ptr = (uint8 *)translate_address_write(address);
//Write
if (ptr)
{
*ptr = data;
}
//else
// printf("ACK: %08x %02x\n", address, data);
}
void storeW(uint32 address, uint16 data)
{
address &= 0xFFFFFF;
if (address & 1)
{
storeB(address + 0, data & 0xFF);
storeB(address + 1, data >> 8);
return;
}
if (address >= 0x8000 && address <= 0xbfff)
{
NGPGfx->write16(address, data);
return;
}
if (address >= 0x4000 && address <= 0x7fff)
{
MDFN_en16lsb<true>(CPUExRAM + address - 0x4000, data);
return;
}
if (address >= 0x70 && address <= 0x7F)
{
int_write8(address, data & 0xFF);
int_write8(address + 1, data >> 8);
return;
}
if (address >= 0x20 && address <= 0x29)
{
timer_write8(address, data & 0xFF);
timer_write8(address + 1, data >> 8);
}
if (address == 0x50)
{
SC0BUF = data & 0xFF;
return;
}
if (address == 0x6e) // Watchdog timer(technically 0x6f)
{
return;
}
if (address == 0xb2) // Comm?
{
COMMStatus = data & 1;
return;
}
if (address == 0xb8)
{
if ((data & 0xFF00) == 0x5500)
Z80_SetEnable(1);
else if ((data & 0xFF00) == 0xAA00)
Z80_SetEnable(0);
if ((data & 0xFF) == 0x55)
MDFNNGPCSOUND_SetEnable(1);
else if ((data & 0xFF) == 0xAA)
MDFNNGPCSOUND_SetEnable(0);
return;
}
if (address == 0xBA)
{
Z80_nmi();
return;
}
if (address == 0xBC)
{
Z80_WriteComm(data);
return;
}
if (address >= 0xa0 && address <= 0xA3)
{
storeB(address, data & 0xFF);
storeB(address + 1, data >> 8);
return;
}
uint16 *ptr = (uint16 *)translate_address_write(address);
//Write
if (ptr)
{
MDFN_en16lsb<true>(ptr, data);
}
//else
// printf("ACK16: %08x %04x\n", address, data);
}
void storeL(uint32 address, uint32 data)
{
storeW(address, data & 0xFFFF);
storeW(address + 2, data >> 16);
}
//=============================================================================
static const uint8 systemMemory[] =
{
// 0x00 // 0x08
0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x08, 0xFF, 0xFF,
// 0x10 // 0x18
0x34, 0x3C, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x3F, 0xFF, 0x2D, 0x01, 0xFF, 0xFF, 0x03, 0xB2,
// 0x20 // 0x28
0x80, 0x00, 0x01, 0x90, 0x03, 0xB0, 0x90, 0x62, 0x05, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x4C, 0x4C,
// 0x30 // 0x38
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x20, 0xFF, 0x80, 0x7F,
// 0x40 // 0x48
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x50 // 0x58
0x00, 0x20, 0x69, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
// 0x60 // 0x68
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x17, 0x03, 0x03, 0x02, 0x00, 0x00, 0x4E,
// 0x70 // 0x78
0x02, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x80 // 0x88
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x90 // 0x98
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0xA0 // 0xA8
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0xB0 // 0xB8
0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0xC0 // 0xC8
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0xD0 // 0xD8
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0xE0 // 0xE8
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0xF0 // 0xF8
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
//=============================================================================
void reset_memory(void)
{
unsigned int i;
FlashStatusEnable = FALSE;
RecacheFRM();
memory_flash_command = FALSE;
//=============================================================================
//000000 -> 000100 CPU Internal RAM (Timers/DMA/Z80)
//=====================================================
for (i = 0; i < sizeof(systemMemory); i++)
storeB(i, systemMemory[i]);
//=============================================================================
//006C00 -> 006FFF BIOS Workspace
//==================================
storeL(0x6C00, MDFN_de32lsb(rom_header->startPC)); //Start
storeW(0x6C04, MDFN_de16lsb(rom_header->catalog));
storeW(0x6E82, MDFN_de16lsb(rom_header->catalog));
storeB(0x6C06, rom_header->subCatalog);
storeB(0x6E84, rom_header->subCatalog);
for (i = 0; i < 12; i++)
storeB(0x6c08 + i, ngpc_rom.data[0x24 + i]);
storeB(0x6C58, 0x01);
//32MBit cart?
if (ngpc_rom.length > 0x200000)
storeB(0x6C59, 0x01);
else
storeB(0x6C59, 0x00);
storeB(0x6C55, 1); //Commercial game
storeB(0x6F80, 0xFF); //Lots of battery power!
storeB(0x6F81, 0x03);
storeB(0x6F84, 0x40); // "Power On" startup
storeB(0x6F85, 0x00); // No shutdown request
storeB(0x6F86, 0x00); // No user answer (?)
//Language: 0 = Japanese, 1 = English
storeB(0x6F87, settings_language);
//Color Mode Selection: 0x00 = B&W, 0x10 = Colour
storeB(0x6F91, rom_header->mode);
storeB(0x6F95, rom_header->mode);
//Interrupt table
for (i = 0; i < 0x12; i++)
storeL(0x6FB8 + i * 4, 0x00FF23DF);
//=============================================================================
//008000 -> 00BFFF Video RAM
//=============================
storeB(0x8000, 0xC0); // Both interrupts allowed
//Hardware window
storeB(0x8002, 0x00);
storeB(0x8003, 0x00);
storeB(0x8004, 0xFF);
storeB(0x8005, 0xFF);
storeB(0x8006, 0xc6); // Frame Rate Register
storeB(0x8012, 0x00); // NEG / OOWC setting.
storeB(0x8118, 0x80); // BGC on!
storeB(0x83E0, 0xFF); // Default background colour
storeB(0x83E1, 0x0F);
storeB(0x83F0, 0xFF); // Default window colour
storeB(0x83F1, 0x0F);
storeB(0x8400, 0xFF); // LED on
storeB(0x8402, 0x80); // Flash cycle = 1.3s
storeB(0x87E2, loadB(0x6F95) ? 0x00 : 0x80);
//
// Metal Slug - 2nd Mission oddly relies on a specific character RAM pattern.
//
{
static const uint8 char_data[64] = {
255, 63, 255, 255, 0, 252, 255, 255, 255, 63, 3, 0, 255, 255, 255, 255,
240, 243, 252, 243, 255, 3, 255, 195, 255, 243, 243, 243, 240, 243, 240, 195,
207, 15, 207, 15, 207, 15, 207, 207, 207, 255, 207, 255, 207, 255, 207, 63,
255, 192, 252, 195, 240, 207, 192, 255, 192, 255, 240, 207, 252, 195, 255, 192};
for (i = 0; i < 64; i++)
{
storeB(0xA1C0 + i, char_data[i]);
}
}
}
}
//=============================================================================
Reference in New Issue View Git Blame Copy Permalink