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

GBHawk: timer improvements

This commit is contained in:
alyosha-tas 2020-08-17 11:23:48 -04:00
parent 68701e05de
commit 475b1ac211
2 changed files with 75 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/GBHawk.IEmulator.cs
View File

@ -330,6 +330,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public void SetIntRegs(byte r)
{
if (((REG_FF0F & 4) == 4) && ((r & 4) == 0)) { timer.IRQ_block = true; }
REG_FF0F = r;
}

87
src/BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/Timer.cs
View File

@ -5,6 +5,21 @@ using BizHawk.Common.NumberExtensions;
namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
{
// Timer Emulation
// NOTES:
//
// For GB, it looks like divider reg should start at 0 on reset. however in this case, in order to pass Gambatte timer tests,
// reads from timer when timer is about to rollover need to return the next value
// for GBC, a starting value of 0xFFFF passes all tests. GBA is not explicotlu tested but for now is set to 0xFFFF as well.
//
// Some additional glitches happen on GBC, but they are non-deterministic and not emulated here
//
// TODO: On GBA models, there is a race condition when enabling with a change in bit check
// that would result in a state change that is not consistent in all models, see tac_set_disabled.gbc
//
// TODO: On GBA only, there is a glitch where if the current timer control is 7 and the written value is 7 and
// there is a coincident timer increment, there will be an additional increment along with this write.
// not sure it effects all models or of exact details, see test tac_set_timer_disabled.gbc
public class Timer
{
public GBHawk Core { get; set; }
@ -15,6 +30,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public byte timer_old;
public byte timer_control;
public byte pending_reload;
public bool IRQ_block; // if the timer IRQ happens on the same cycle as a previous one was cleared, the IRQ is blocked
public bool old_state;
public bool state;
public bool reload_block;
@ -66,14 +82,54 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
// TAC (Timer Control)
case 0xFF07:
bool was_off = (timer_control & 4) == 0;
//Console.WriteLine(timer_control + " " + value + " " + timer + " " + divider_reg);
timer_control = (byte)((timer_control & 0xf8) | (value & 0x7)); // only bottom 3 bits function
/*
if (was_off && ((timer_control & 4) > 0) && Core.is_GBC)
{
bool temp_check = false;
// NOTE: On GBA models, there is a race condition when enabling with a change in bit check
// that would result in a state change that is not consistent in all models, see tac_set_disabled.gbc
switch (timer_control & 3)
{
case 0:
temp_check = (divider_reg & 0x1FF) == 0x1FF;
break;
case 1:
temp_check = (divider_reg & 0x7) == 0x7;
break;
case 2:
temp_check = (divider_reg & 0x1F) == 0x1F;
break;
case 3:
temp_check = (divider_reg & 0x7F) == 0x7F;
break;
}
// NOTE: On GBA only, there is a glitch where if the current timer control is 7 and the written value is 7 and
// there is a coincident timer increment, there will be an additional increment along with this write.
// not sure it effects all models or of exact details, see test tac_set_timer_disabled.gbc
if (temp_check)
{
timer_old = timer;
timer++;
Console.WriteLine("glitch");
// if overflow happens, set the interrupt flag and reload the timer (if applicable)
if (timer < timer_old)
{
if (timer_control.Bit(2))
{
pending_reload = 4;
reload_block = false;
}
else
{
//TODO: Check if timer still gets reloaded if TAC diabled causes overflow
if (Core.REG_FFFF.Bit(2)) { Core.cpu.FlagI = true; }
Core.REG_FF0F |= 0x04;
}
}
}
}
*/
break;
}
}
@ -104,7 +160,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
// this procedure allows several glitchy timer ticks, since it only measures falling edge of the state
// so things like turning the timer off and resetting the divider will tick the timer
// NOTE: Some additional glitches happen on GBC, but they are non-deterministic and not emulated here
if (old_state && !state)
{
timer_old = timer;
@ -120,10 +175,9 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
}
else
{
//TODO: Check if timer still gets reloaded if TAC diabled causes overflow
if (Core.REG_FFFF.Bit(2)) { Core.cpu.FlagI = true; }
Core.REG_FF0F |= 0x04;
}
pending_reload = 3;
reload_block = false;
}
}
}
@ -140,20 +194,26 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
next_free_cycle = 4 + Core.cpu.TotalExecutedCycles;
// set interrupts
if (Core.REG_FFFF.Bit(2)) { Core.cpu.FlagI = true; }
Core.REG_FF0F |= 0x04;
if (!IRQ_block)
{
if (Core.REG_FFFF.Bit(2)) { Core.cpu.FlagI = true; }
Core.REG_FF0F |= 0x04;
}
}
}
IRQ_block = false;
}
public void Reset()
{
divider_reg = 0;
divider_reg = (ushort)(Core.is_GBC ? 0xFFFF : 0);
timer_reload = 0;
timer = 0;
timer_old = 0;
timer_control = 0xF8;
pending_reload = 0;
IRQ_block = false;
old_state = false;
state = false;
reload_block = false;
@ -168,6 +228,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
ser.Sync(nameof(timer_old), ref timer_old);
ser.Sync(nameof(timer_control), ref timer_control);
ser.Sync(nameof(pending_reload), ref pending_reload);
ser.Sync(nameof(IRQ_block), ref IRQ_block);
ser.Sync(nameof(old_state), ref old_state);
ser.Sync(nameof(state), ref state);
ser.Sync(nameof(reload_block), ref reload_block);