203 lines
7.3 KiB
C#
203 lines
7.3 KiB
C#
using BizHawk.Emulation.Cores.Computers.Commodore64.Media;
|
|
|
|
namespace BizHawk.Emulation.Cores.Computers.Commodore64.Serial
|
|
{
|
|
public sealed partial class Drive1541
|
|
{
|
|
private const long LEHMER_RNG_PRIME = 48271;
|
|
|
|
private int _diskDensityCounter; // density .. 16
|
|
private int _diskSupplementaryCounter; // 0 .. 16
|
|
private bool _diskFluxReversalDetected;
|
|
private int _diskBitsLeft;
|
|
private int _diskByteOffset;
|
|
private int _diskBits;
|
|
private int _diskCycle;
|
|
private int _diskDensity;
|
|
private bool _previousCa1;
|
|
private int _countsBeforeRandomTransition;
|
|
private int _rngCurrent;
|
|
private int _clocks;
|
|
private int _cpuClocks;
|
|
private int _diskWriteBitsRemaining;
|
|
private bool _diskWriteEnabled;
|
|
private int _diskWriteLatch;
|
|
private int _diskOutputBits;
|
|
private bool _diskWriteProtected;
|
|
|
|
// Lehmer RNG
|
|
private void AdvanceRng()
|
|
{
|
|
if (_rngCurrent == 0)
|
|
{
|
|
_rngCurrent = 1;
|
|
}
|
|
|
|
_rngCurrent = unchecked((int) ((_rngCurrent * LEHMER_RNG_PRIME) & int.MaxValue));
|
|
}
|
|
|
|
private void ExecuteFlux()
|
|
{
|
|
// This actually executes the main 16mhz clock
|
|
while (_clocks > 0)
|
|
{
|
|
_clocks--;
|
|
|
|
// rotate disk
|
|
if (_motorEnabled)
|
|
{
|
|
if (_disk == null)
|
|
{
|
|
_diskBitsLeft = 1;
|
|
_diskBits = 0;
|
|
}
|
|
else
|
|
{
|
|
if (_diskBitsLeft <= 0)
|
|
{
|
|
if (_diskWriteEnabled)
|
|
_trackImageData[_diskByteOffset] = _diskOutputBits;
|
|
|
|
_diskByteOffset++;
|
|
|
|
if (_diskByteOffset == Disk.FluxEntriesPerTrack)
|
|
_diskByteOffset = 0;
|
|
|
|
if (!_diskWriteEnabled)
|
|
_diskBits = _trackImageData[_diskByteOffset];
|
|
|
|
_diskOutputBits = 0;
|
|
_diskBitsLeft = Disk.FluxBitsPerEntry;
|
|
}
|
|
}
|
|
_diskOutputBits >>= 1;
|
|
|
|
if (_diskWriteEnabled && !_diskWriteProtected)
|
|
_countsBeforeRandomTransition = 0;
|
|
|
|
if ((_diskBits & 1) != 0)
|
|
{
|
|
_countsBeforeRandomTransition = 0;
|
|
_diskFluxReversalDetected = true;
|
|
_diskOutputBits |= int.MinValue; // set bit 31
|
|
}
|
|
else
|
|
{
|
|
_diskOutputBits &= int.MaxValue; // clear bit 31
|
|
}
|
|
|
|
_diskBits >>= 1;
|
|
_diskBitsLeft--;
|
|
}
|
|
|
|
// random flux transition readings for unformatted data
|
|
if (_countsBeforeRandomTransition > 0)
|
|
{
|
|
_countsBeforeRandomTransition--;
|
|
if (_countsBeforeRandomTransition == 0)
|
|
{
|
|
_diskFluxReversalDetected = true;
|
|
AdvanceRng();
|
|
// This constant is what VICE uses. TODO: Determine accuracy.
|
|
_countsBeforeRandomTransition = (_rngCurrent % 367) + 33;
|
|
}
|
|
}
|
|
|
|
// flux transition circuitry
|
|
if (_diskFluxReversalDetected)
|
|
{
|
|
if (!_diskWriteEnabled)
|
|
{
|
|
_diskDensityCounter = _diskDensity;
|
|
_diskSupplementaryCounter = 0;
|
|
}
|
|
_diskFluxReversalDetected = false;
|
|
if (_countsBeforeRandomTransition == 0)
|
|
{
|
|
AdvanceRng();
|
|
// This constant is what VICE uses. TODO: Determine accuracy.
|
|
_countsBeforeRandomTransition = (_rngCurrent & 0x1F) + 289;
|
|
}
|
|
}
|
|
|
|
// counter circuitry
|
|
if (_diskDensityCounter >= 16)
|
|
{
|
|
_diskDensityCounter = _diskDensity;
|
|
_diskSupplementaryCounter++;
|
|
|
|
if ((_diskSupplementaryCounter & 0x3) == 0x2)
|
|
{
|
|
if (!_diskWriteEnabled)
|
|
_diskWriteBitsRemaining = 0;
|
|
_diskWriteEnabled = !Via1.Cb2;
|
|
|
|
_diskWriteBitsRemaining--;
|
|
if (_diskWriteEnabled)
|
|
{
|
|
_countsBeforeRandomTransition = 0;
|
|
_byteReady = false;
|
|
if (_diskWriteBitsRemaining <= 0)
|
|
{
|
|
_diskWriteLatch = Via1.EffectivePrA;
|
|
_diskWriteBitsRemaining = 8;
|
|
_byteReady = Via1.Ca2;
|
|
}
|
|
if ((_diskWriteLatch & 0x80) != 0)
|
|
{
|
|
_diskOutputBits |= int.MinValue; // set bit 31
|
|
}
|
|
_diskWriteLatch <<= 1;
|
|
}
|
|
else
|
|
{
|
|
_bitsRemainingInLatchedByte--;
|
|
_byteReady = false;
|
|
_bitHistory = (_bitHistory << 1) | ((_diskSupplementaryCounter & 0xC) == 0x0 ? 1 : 0);
|
|
_sync = false;
|
|
if (!_diskWriteEnabled && (_bitHistory & 0x3FF) == 0x3FF)
|
|
{
|
|
_sync = true;
|
|
_bitsRemainingInLatchedByte = 8;
|
|
_byteReady = false;
|
|
}
|
|
|
|
if (_bitsRemainingInLatchedByte <= 0)
|
|
{
|
|
_bitsRemainingInLatchedByte = 8;
|
|
|
|
// SOE (SO/Byte Ready enabled)
|
|
_byteReady = Via1.Ca2;
|
|
}
|
|
}
|
|
}
|
|
|
|
// negative transition activates SO pin on CPU
|
|
_previousCa1 = Via1.Ca1;
|
|
Via1.Ca1 = !_byteReady;
|
|
if (_previousCa1 && !Via1.Ca1)
|
|
{
|
|
// cycle 6 is roughly 400ns
|
|
_overflowFlagDelaySr |= _diskCycle > 6 ? 4 : 2;
|
|
}
|
|
}
|
|
|
|
if (_diskSupplementaryCounter >= 16)
|
|
{
|
|
_diskSupplementaryCounter = 0;
|
|
}
|
|
|
|
_cpuClocks--;
|
|
if (_cpuClocks <= 0)
|
|
{
|
|
ExecuteSystem();
|
|
_cpuClocks = 16;
|
|
}
|
|
|
|
_diskDensityCounter++;
|
|
_diskCycle = (_diskCycle + 1) & 0xF;
|
|
}
|
|
}
|
|
}
|
|
}
|