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

Saturnus: IMemoryDomains. Names match the old yahbooze names when applicable.

This commit is contained in:
nattthebear 2017-06-08 17:15:29 -04:00
parent 145f58a145
commit a42631fadc
12 changed files with 152 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/LibSaturnus.cs
View File

@ -71,6 +71,8 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
public delegate void CDSectorCallback(int disk, int lba, IntPtr dest); public delegate void CDSectorCallback(int disk, int lba, IntPtr dest);
[UnmanagedFunctionPointer(CC)] [UnmanagedFunctionPointer(CC)]
public delegate void InputCallback(); public delegate void InputCallback();
[UnmanagedFunctionPointer(CC)]
public delegate void AddMemoryDomainCallback(string name, IntPtr ptr, int size, bool writable);
[BizImport(CC)] [BizImport(CC)]
public abstract void SetFirmwareCallbacks(FirmwareSizeCallback sizecallback, FirmwareDataCallback datacallback); public abstract void SetFirmwareCallbacks(FirmwareSizeCallback sizecallback, FirmwareDataCallback datacallback);
@ -88,5 +90,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
public abstract void SetupInput(int[] portdevices, int[] multitaps); public abstract void SetupInput(int[] portdevices, int[] multitaps);
[BizImport(CC)] [BizImport(CC)]
public abstract void SetInputCallback(InputCallback callback); public abstract void SetInputCallback(InputCallback callback);
[BizImport(CC)]
public abstract void SetAddMemoryDomainCallback(AddMemoryDomainCallback callback);
} }
} }

19
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Saturnus.cs
View File

@ -80,6 +80,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
SetFirmwareCallbacks(); SetFirmwareCallbacks();
SetCdCallbacks(); SetCdCallbacks();
_core.SetAddMemoryDomainCallback(_addMemoryDomainCallback);
if (!_core.Init(_disks.Length)) if (!_core.Init(_disks.Length))
throw new InvalidOperationException("Core rejected the disks!"); throw new InvalidOperationException("Core rejected the disks!");
ClearAllCallbacks(); ClearAllCallbacks();
@ -95,6 +96,10 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
_exe.Seal(); _exe.Seal();
SetCdCallbacks(); SetCdCallbacks();
_core.SetDisk(0, false); _core.SetDisk(0, false);
(ServiceProvider as BasicServiceProvider).Register<IMemoryDomains>(new MemoryDomainList(_memoryDomains.Values.ToList())
{
MainMemory = _memoryDomains["Work Ram Low"]
});
} }
public unsafe void FrameAdvance(IController controller, bool render, bool rendersound = true) public unsafe void FrameAdvance(IController controller, bool render, bool rendersound = true)
@ -158,6 +163,17 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
public CoreComm CoreComm { get; } public CoreComm CoreComm { get; }
public ControllerDefinition ControllerDefinition { get; } public ControllerDefinition ControllerDefinition { get; }
#region IMemoryDomains
private readonly Dictionary<string, MemoryDomain> _memoryDomains = new Dictionary<string, MemoryDomain>();
private void AddMemoryDomain(string name, IntPtr ptr, int size, bool writable)
{
_memoryDomains.Add(name, new MemoryDomainIntPtrMonitor(name, MemoryDomain.Endian.Big, ptr, size, writable, 2, _exe));
}
#endregion
#region IStatable #region IStatable
public bool BinarySaveStatesPreferred => true; public bool BinarySaveStatesPreferred => true;
@ -218,6 +234,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
private LibSaturnus.CDTOCCallback _cdTocCallback; private LibSaturnus.CDTOCCallback _cdTocCallback;
private LibSaturnus.CDSectorCallback _cdSectorCallback; private LibSaturnus.CDSectorCallback _cdSectorCallback;
private LibSaturnus.InputCallback _inputCallback; private LibSaturnus.InputCallback _inputCallback;
private LibSaturnus.AddMemoryDomainCallback _addMemoryDomainCallback;
private void InitCallbacks() private void InitCallbacks()
{ {
@ -226,6 +243,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
_cdTocCallback = CDTOCCallback; _cdTocCallback = CDTOCCallback;
_cdSectorCallback = CDSectorCallback; _cdSectorCallback = CDSectorCallback;
_inputCallback = InputCallbacks.Call; _inputCallback = InputCallbacks.Call;
_addMemoryDomainCallback = AddMemoryDomain;
} }
private void SetFirmwareCallbacks() private void SetFirmwareCallbacks()
@ -245,6 +263,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.Saturn
_core.SetFirmwareCallbacks(null, null); _core.SetFirmwareCallbacks(null, null);
_core.SetCDCallbacks(null, null); _core.SetCDCallbacks(null, null);
_core.SetInputCallback(null); _core.SetInputCallback(null);
_core.SetAddMemoryDomainCallback(null);
} }
private string TranslateFirmwareName(string filename) private string TranslateFirmwareName(string filename)

7
waterbox/ss/bizhawk.cpp
View File

@ -222,6 +222,13 @@ EXPORT void SetInputCallback(void (*callback)())
InputCallback = callback; InputCallback = callback;
} }
void (*AddMemoryDomain)(const char* name, const void* ptr, int size, bool writable);
EXPORT void SetAddMemoryDomainCallback(void (*callback)(const char* name, const void* ptr, int size, bool writable))
{
AddMemoryDomain = callback;
}
// if (BackupRAM_Dirty)SaveBackupRAM(); // if (BackupRAM_Dirty)SaveBackupRAM();
// if (CART_GetClearNVDirty())SaveCartNV(); // if (CART_GetClearNVDirty())SaveCartNV();

79
waterbox/ss/cart/backup.cpp
View File

@ -25,66 +25,67 @@
namespace MDFN_IEN_SS namespace MDFN_IEN_SS
{ {
static uint8* ExtBackupRAM; static uint8 *ExtBackupRAM;
static bool ExtBackupRAM_Dirty; static bool ExtBackupRAM_Dirty;
// TODO: Check mirroring. // TODO: Check mirroring.
template<typename T, bool IsWrite> template <typename T, bool IsWrite>
static MDFN_HOT void ExtBackupRAM_RW_DB(uint32 A, uint16* DB) static MDFN_HOT void ExtBackupRAM_RW_DB(uint32 A, uint16 *DB)
{ {
uint8* const ptr = ExtBackupRAM + ((A >> 1) & 0x7FFFF); uint8 *const ptr = ExtBackupRAM + ((A >> 1) & 0x7FFFF);
if(IsWrite) if (IsWrite)
{ {
if(A & 1) if (A & 1)
{ {
ExtBackupRAM_Dirty = true; ExtBackupRAM_Dirty = true;
*ptr = *DB; *ptr = *DB;
} }
} }
else else
{ {
*DB = (*ptr << 0) | 0xFF00; *DB = (*ptr << 0) | 0xFF00;
if((A & ~1) == 0x04FFFFFE) if ((A & ~1) == 0x04FFFFFE)
*DB = 0x21; *DB = 0x21;
} }
} }
static MDFN_COLD bool GetClearNVDirty(void) static MDFN_COLD bool GetClearNVDirty(void)
{ {
bool ret = ExtBackupRAM_Dirty; bool ret = ExtBackupRAM_Dirty;
ExtBackupRAM_Dirty = false; ExtBackupRAM_Dirty = false;
return ret; return ret;
} }
static MDFN_COLD void GetNVInfo(const char** ext, void** nv_ptr, uint64* nv_size) static MDFN_COLD void GetNVInfo(const char **ext, void **nv_ptr, uint64 *nv_size)
{ {
*ext = "bcr"; *ext = "bcr";
*nv_ptr = ExtBackupRAM; *nv_ptr = ExtBackupRAM;
*nv_size = 524288; *nv_size = 524288;
} }
void CART_Backup_Init(CartInfo* c) void CART_Backup_Init(CartInfo *c)
{ {
static const uint8 init[0x10] = { 0x42, 0x61, 0x63, 0x6B, 0x55, 0x70, 0x52, 0x61, 0x6D, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x61, 0x74 }; static const uint8 init[0x10] = {0x42, 0x61, 0x63, 0x6B, 0x55, 0x70, 0x52, 0x61, 0x6D, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x61, 0x74};
ExtBackupRAM = (uint8*)alloc_plain(524288); ExtBackupRAM = (uint8 *)alloc_plain(524288);
memset(ExtBackupRAM, 0x00, 524288); memset(ExtBackupRAM, 0x00, 524288);
for(unsigned i = 0; i < 0x200; i += 0x10) for (unsigned i = 0; i < 0x200; i += 0x10)
memcpy(ExtBackupRAM + i, init, 0x10); memcpy(ExtBackupRAM + i, init, 0x10);
ExtBackupRAM_Dirty = false; ExtBackupRAM_Dirty = false;
c->CS01_SetRW8W16(0x04000000, 0x04FFFFFF, c->CS01_SetRW8W16(0x04000000, 0x04FFFFFF,
ExtBackupRAM_RW_DB<uint16, false>, ExtBackupRAM_RW_DB<uint16, false>,
ExtBackupRAM_RW_DB<uint8, true>, ExtBackupRAM_RW_DB<uint8, true>,
ExtBackupRAM_RW_DB<uint16, true>); ExtBackupRAM_RW_DB<uint16, true>);
c->GetClearNVDirty = GetClearNVDirty; c->GetClearNVDirty = GetClearNVDirty;
c->GetNVInfo = GetNVInfo; c->GetNVInfo = GetNVInfo;
AddMemoryDomain("Backup Cart", ExtBackupRAM, 524288, true);
} }
} }

40
waterbox/ss/cart/cs1ram.cpp
View File

@ -24,37 +24,37 @@
namespace MDFN_IEN_SS namespace MDFN_IEN_SS
{ {
static uint16* CS1RAM = nullptr; static uint16 *CS1RAM = nullptr;
template<typename T, bool IsWrite> template <typename T, bool IsWrite>
static MDFN_HOT void CS1RAM_RW_DB(uint32 A, uint16* DB) static MDFN_HOT void CS1RAM_RW_DB(uint32 A, uint16 *DB)
{ {
const uint32 mask = (sizeof(T) == 2) ? 0xFFFF : (0xFF << (((A & 1) ^ 1) << 3)); const uint32 mask = (sizeof(T) == 2) ? 0xFFFF : (0xFF << (((A & 1) ^ 1) << 3));
uint16* const ptr = (uint16*)((uint8*)CS1RAM + (A & 0x00FFFFFE)); uint16 *const ptr = (uint16 *)((uint8 *)CS1RAM + (A & 0x00FFFFFE));
if(IsWrite) if (IsWrite)
*ptr = (*ptr & ~mask) | (*DB & mask); *ptr = (*ptr & ~mask) | (*DB & mask);
else else
*DB = *ptr; *DB = *ptr;
} }
static MDFN_COLD void Reset(bool powering_up) static MDFN_COLD void Reset(bool powering_up)
{ {
if(powering_up) if (powering_up)
memset(CS1RAM, 0, 0x1000000); memset(CS1RAM, 0, 0x1000000);
} }
void CART_CS1RAM_Init(CartInfo* c) void CART_CS1RAM_Init(CartInfo *c)
{ {
CS1RAM = (uint16*)alloc_plain(0x1000000); CS1RAM = (uint16 *)alloc_plain(0x1000000);
SS_SetPhysMemMap (0x04000000, 0x04FFFFFF, CS1RAM, 0x1000000, true); SS_SetPhysMemMap(0x04000000, 0x04FFFFFF, CS1RAM, 0x1000000, true);
c->CS01_SetRW8W16(0x04000000, 0x04FFFFFF, c->CS01_SetRW8W16(0x04000000, 0x04FFFFFF,
CS1RAM_RW_DB<uint16, false>, CS1RAM_RW_DB<uint16, false>,
CS1RAM_RW_DB<uint8, true>, CS1RAM_RW_DB<uint8, true>,
CS1RAM_RW_DB<uint16, true>); CS1RAM_RW_DB<uint16, true>);
c->Reset = Reset; c->Reset = Reset;
AddMemoryDomain("CS1 Cart", CS1RAM, 0x1000000, true);
} }
} }

72
waterbox/ss/cart/extram.cpp
View File

@ -24,61 +24,61 @@
namespace MDFN_IEN_SS namespace MDFN_IEN_SS
{ {
static uint16* ExtRAM; //[0x200000]; static uint16 *ExtRAM; //[0x200000];
static size_t ExtRAM_Mask; static size_t ExtRAM_Mask;
static uint8 Cart_ID; static uint8 Cart_ID;
template<typename T, bool IsWrite> template <typename T, bool IsWrite>
static MDFN_HOT void ExtRAM_RW_DB(uint32 A, uint16* DB) static MDFN_HOT void ExtRAM_RW_DB(uint32 A, uint16 *DB)
{ {
const uint32 mask = (sizeof(T) == 2) ? 0xFFFF : (0xFF << (((A & 1) ^ 1) << 3)); const uint32 mask = (sizeof(T) == 2) ? 0xFFFF : (0xFF << (((A & 1) ^ 1) << 3));
uint16* const ptr = (uint16*)((uint8*)ExtRAM + (A & ExtRAM_Mask)); uint16 *const ptr = (uint16 *)((uint8 *)ExtRAM + (A & ExtRAM_Mask));
//printf("Barf %zu %d: %08x\n", sizeof(T), IsWrite, A); //printf("Barf %zu %d: %08x\n", sizeof(T), IsWrite, A);
if(IsWrite) if (IsWrite)
*ptr = (*ptr & ~mask) | (*DB & mask); *ptr = (*ptr & ~mask) | (*DB & mask);
else else
*DB = *ptr; *DB = *ptr;
} }
static MDFN_HOT void CartID_Read_DB(uint32 A, uint16* DB) static MDFN_HOT void CartID_Read_DB(uint32 A, uint16 *DB)
{ {
if((A & ~1) == 0x04FFFFFE) if ((A & ~1) == 0x04FFFFFE)
*DB = Cart_ID; *DB = Cart_ID;
} }
static MDFN_COLD void Reset(bool powering_up) static MDFN_COLD void Reset(bool powering_up)
{ {
if(powering_up) if (powering_up)
memset(ExtRAM, 0, 0x400000); // TODO: Test. memset(ExtRAM, 0, 0x400000); // TODO: Test.
} }
void CART_ExtRAM_Init(CartInfo* c, bool R4MiB) void CART_ExtRAM_Init(CartInfo *c, bool R4MiB)
{ {
ExtRAM = (uint16*)alloc_plain(0x400000); ExtRAM = (uint16 *)alloc_plain(0x400000);
if(R4MiB) if (R4MiB)
{ {
Cart_ID = 0x5C; Cart_ID = 0x5C;
ExtRAM_Mask = 0x3FFFFE; ExtRAM_Mask = 0x3FFFFE;
} }
else else
{ {
Cart_ID = 0x5A; Cart_ID = 0x5A;
ExtRAM_Mask = 0x27FFFE; ExtRAM_Mask = 0x27FFFE;
} }
SS_SetPhysMemMap(0x02400000, 0x025FFFFF, ExtRAM + (0x000000 / sizeof(uint16)), (R4MiB ? 0x200000 : 0x080000), true); SS_SetPhysMemMap(0x02400000, 0x025FFFFF, ExtRAM + (0x000000 / sizeof(uint16)), (R4MiB ? 0x200000 : 0x080000), true);
SS_SetPhysMemMap(0x02600000, 0x027FFFFF, ExtRAM + (0x200000 / sizeof(uint16)), (R4MiB ? 0x200000 : 0x080000), true); SS_SetPhysMemMap(0x02600000, 0x027FFFFF, ExtRAM + (0x200000 / sizeof(uint16)), (R4MiB ? 0x200000 : 0x080000), true);
c->CS01_SetRW8W16(0x02400000, 0x027FFFFF, c->CS01_SetRW8W16(0x02400000, 0x027FFFFF,
ExtRAM_RW_DB<uint16, false>, ExtRAM_RW_DB<uint16, false>,
ExtRAM_RW_DB<uint8, true>, ExtRAM_RW_DB<uint8, true>,
ExtRAM_RW_DB<uint16, true>); ExtRAM_RW_DB<uint16, true>);
c->CS01_SetRW8W16(/*0x04FFFFFE*/0x04F00000, 0x04FFFFFF, CartID_Read_DB); c->CS01_SetRW8W16(/*0x04FFFFFE*/ 0x04F00000, 0x04FFFFFF, CartID_Read_DB);
c->Reset = Reset; c->Reset = Reset;
AddMemoryDomain("Ram Cart", ExtRAM, 0x400000, true);
} }
} }

30
waterbox/ss/cart/rom.cpp
View File

@ -25,29 +25,29 @@
namespace MDFN_IEN_SS namespace MDFN_IEN_SS
{ {
static uint16* ROM; //[0x100000]; static uint16 *ROM; //[0x100000];
static MDFN_HOT void ROM_Read(uint32 A, uint16* DB) static MDFN_HOT void ROM_Read(uint32 A, uint16 *DB)
{ {
// TODO: Check mirroring. // TODO: Check mirroring.
//printf("ROM: %08x\n", A); //printf("ROM: %08x\n", A);
*DB = *(uint16*)((uint8*)ROM + (A & 0x1FFFFE)); *DB = *(uint16 *)((uint8 *)ROM + (A & 0x1FFFFE));
} }
void CART_ROM_Init(CartInfo* c, const char* filename) void CART_ROM_Init(CartInfo *c, const char *filename)
{ {
if (FirmwareSizeCallback(filename) != 0x200000) if (FirmwareSizeCallback(filename) != 0x200000)
abort(); abort();
ROM = (uint16*)alloc_sealed(0x200000); ROM = (uint16 *)alloc_sealed(0x200000);
FirmwareDataCallback(filename, (uint8*)ROM); FirmwareDataCallback(filename, (uint8 *)ROM);
for(unsigned i = 0; i < 0x100000; i++) for (unsigned i = 0; i < 0x100000; i++)
{ {
ROM[i] = MDFN_de16msb<true>(&ROM[i]); ROM[i] = MDFN_de16msb<true>(&ROM[i]);
} }
SS_SetPhysMemMap (0x02000000, 0x03FFFFFF, ROM, 0x200000, false); SS_SetPhysMemMap(0x02000000, 0x03FFFFFF, ROM, 0x200000, false);
c->CS01_SetRW8W16(0x02000000, 0x03FFFFFF, ROM_Read); c->CS01_SetRW8W16(0x02000000, 0x03FFFFFF, ROM_Read);
AddMemoryDomain("Rom Cart", ROM, 0x200000, false);
} }
} }

2
waterbox/ss/defs.h
View File

@ -318,3 +318,5 @@ extern bool setting_ss_region_autodetect;
extern bool InputLagged; extern bool InputLagged;
extern void (*InputCallback)(); extern void (*InputCallback)();
extern void (*AddMemoryDomain)(const char* name, const void* ptr, int size, bool writable);

1
waterbox/ss/sound.cpp
View File

@ -112,6 +112,7 @@ void SOUND_Init(void)
SS_SetPhysMemMap(0x05A00000, 0x05A7FFFF, SCSP.GetRAMPtr(), 0x80000, true); SS_SetPhysMemMap(0x05A00000, 0x05A7FFFF, SCSP.GetRAMPtr(), 0x80000, true);
// TODO: MEM4B: SS_SetPhysMemMap(0x05A00000, 0x05AFFFFF, SCSP.GetRAMPtr(), 0x40000, true); // TODO: MEM4B: SS_SetPhysMemMap(0x05A00000, 0x05AFFFFF, SCSP.GetRAMPtr(), 0x40000, true);
AddMemoryDomain("Sound Ram", SCSP.GetRAMPtr(), 0x100000, true);
} }
uint8 SOUND_PeekRAM(uint32 A) uint8 SOUND_PeekRAM(uint32 A)

6
waterbox/ss/ss.cpp
View File

@ -935,15 +935,17 @@ static bool MDFN_COLD InitCommon(const unsigned cart_type, const unsigned smpc_a
memset(BackupRAM, 0x00, sizeof(BackupRAM)); memset(BackupRAM, 0x00, sizeof(BackupRAM));
for (unsigned i = 0; i < 0x40; i++) for (unsigned i = 0; i < 0x40; i++)
BackupRAM[i] = BRAM_Init_Data[i & 0x0F]; BackupRAM[i] = BRAM_Init_Data[i & 0x0F];
AddMemoryDomain("Backup Ram", BackupRAM, sizeof(BackupRAM), true);
// Call InitFastMemMap() before functions like SOUND_Init() // Call InitFastMemMap() before functions like SOUND_Init()
InitFastMemMap(); InitFastMemMap();
BIOSROM = (uint16*)alloc_sealed(524288); BIOSROM = (uint16*)alloc_sealed(524288);
AddMemoryDomain("Boot Rom", BIOSROM, 524288, false);
SS_SetPhysMemMap(0x00000000, 0x000FFFFF, BIOSROM, 524288); SS_SetPhysMemMap(0x00000000, 0x000FFFFF, BIOSROM, 524288);
SS_SetPhysMemMap(0x00200000, 0x003FFFFF, WorkRAML, sizeof(WorkRAML), true); SS_SetPhysMemMap(0x00200000, 0x003FFFFF, WorkRAML, sizeof(WorkRAML), true);
SS_SetPhysMemMap(0x06000000, 0x07FFFFFF, WorkRAMH, sizeof(WorkRAMH), true); SS_SetPhysMemMap(0x06000000, 0x07FFFFFF, WorkRAMH, sizeof(WorkRAMH), true);
//MDFNMP_RegSearchable(0x00200000, sizeof(WorkRAML)); AddMemoryDomain("Work Ram Low", WorkRAML, sizeof(WorkRAML), true);
//MDFNMP_RegSearchable(0x06000000, sizeof(WorkRAMH)); AddMemoryDomain("Work Ram High", WorkRAMH, sizeof(WorkRAMH), true);
CART_Init(cart_type); CART_Init(cart_type);
// //

2
waterbox/ss/vdp1.cpp
View File

@ -118,6 +118,8 @@ void Init(void)
// //
// //
SS_SetPhysMemMap(0x05C00000, 0x05C7FFFF, VRAM, sizeof(VRAM), true); SS_SetPhysMemMap(0x05C00000, 0x05C7FFFF, VRAM, sizeof(VRAM), true);
AddMemoryDomain("VDP1 Ram", VRAM, sizeof(VRAM), true);
AddMemoryDomain("VDP1 Framebuffer", FB, sizeof(FB), true);
//SS_SetPhysMemMap(0x05C80000, 0x05CFFFFF, FB[FBDrawWhich], sizeof(FB[0]), true); //SS_SetPhysMemMap(0x05C80000, 0x05CFFFFF, FB[FBDrawWhich], sizeof(FB[0]), true);
vb_status = false; vb_status = false;

2
waterbox/ss/vdp2.cpp
View File

@ -789,6 +789,8 @@ void Init(const bool IsPAL)
lastts = 0; lastts = 0;
SS_SetPhysMemMap(0x05E00000, 0x05EFFFFF, VRAM, 0x80000, true); SS_SetPhysMemMap(0x05E00000, 0x05EFFFFF, VRAM, 0x80000, true);
AddMemoryDomain("VDP2 Ram", VRAM, sizeof(VRAM), true);
AddMemoryDomain("VDP2 CRam", CRAM, sizeof(CRAM), true);
VDP2REND_Init(IsPAL); VDP2REND_Init(IsPAL);
} }