public Clock.ClockOp CreateFromStateFile(C64Interfaces.IFile stateFile)
{
switch (stateFile.ReadByte())
{
case (byte)Ops.Stall:
return(new Clock.StallOp());
case (byte)Ops.DecodeOpcode:
return(new DecodeOpcodeOp(_cpu));
case (byte)Ops.DecodeAddressing:
return(new DecodeAddressOp(_cpu, stateFile));
case (byte)Ops.ExecuteOpcode:
return(new ExecuteOpcodeOp(_cpu, stateFile));
case (byte)Ops.WriteResult:
return(new WriteResultOp(_cpu));
case (byte)Ops.Interrupt:
return(new InterruptOp(_cpu, stateFile));
case (byte)Ops.Reset:
return(new ResetOp(_cpu, stateFile));
}
return(null);
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
_portA.WriteDeviceState(stateFile);
_portB.WriteDeviceState(stateFile);
stateFile.Write(_latchPortA);
stateFile.Write(_latchedValueA);
stateFile.Write(_ca1);
stateFile.Write(_ca2);
stateFile.Write(_latchPortB);
stateFile.Write(_latchedValueB);
stateFile.Write(_cb1);
stateFile.Write(_pulseCA2);
stateFile.Write(_cb2);
stateFile.Write(_pulseCB2);
stateFile.Write(_t1Counter);
stateFile.Write(_t1Latch);
stateFile.Write(_t1Count);
stateFile.Write(_t1OutPB);
stateFile.Write(_t1FreeRun);
stateFile.Write(_t2Counter);
stateFile.Write(_t2Latch);
stateFile.Write(_t2Count);
stateFile.Write(_t2InPB);
stateFile.Write(_functionControlRegister);
stateFile.Write(_auxiliaryControlRegister);
stateFile.Write(_interruptFlagRegister);
stateFile.Write(_interruptEnabledRegister);
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_portA.ReadDeviceState(stateFile);
_portB.ReadDeviceState(stateFile);
_latchPortA = stateFile.ReadBool();
_latchedValueA = stateFile.ReadByte();
_ca1 = stateFile.ReadBool();
_ca2 = stateFile.ReadBool();
_latchPortB = stateFile.ReadBool();
_latchedValueB = stateFile.ReadByte();
_cb1 = stateFile.ReadBool();
_pulseCA2 = stateFile.ReadBool();
_cb2 = stateFile.ReadBool();
_pulseCB2 = stateFile.ReadBool();
_t1Counter = stateFile.ReadWord();
_t1Latch = stateFile.ReadWord();
_t1Count = stateFile.ReadBool();
_t1OutPB = stateFile.ReadBool();
_t1FreeRun = stateFile.ReadBool();
_t2Counter = stateFile.ReadWord();
_t2Latch = stateFile.ReadByte();
_t2Count = stateFile.ReadBool();
_t2InPB = stateFile.ReadBool();
_functionControlRegister = stateFile.ReadByte();
_auxiliaryControlRegister = stateFile.ReadByte();
_interruptFlagRegister = stateFile.ReadByte();
_interruptEnabledRegister = stateFile.ReadByte();
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
_portA.WriteDeviceState(stateFile);
_portB.WriteDeviceState(stateFile);
stateFile.Write(_pcState);
stateFile.Write(_todPause);
stateFile.Write(_todLatch);
stateFile.Write(_todClkCnt);
stateFile.Write(_todLimits);
for (int i = 0; i < _tod.GetLength(0); i++)
{
for (int j = 0; j < _tod.GetLength(1); j++)
{
stateFile.Write(_tod[i, j]);
}
}
stateFile.Write(_interruptRegisters);
stateFile.Write(_serialRegister);
stateFile.Write(_flag);
stateFile.Write(_cntState);
stateFile.Write(_cntEdge);
_timerA.WriteDeviceState(stateFile);
_timerB.WriteDeviceState(stateFile);
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_portA.ReadDeviceState(stateFile);
_portB.ReadDeviceState(stateFile);
_pcState = stateFile.ReadBool();
_todPause = stateFile.ReadBool();
_todLatch = stateFile.ReadBool();
_todClkCnt = stateFile.ReadByte();
stateFile.ReadBytes(_todLimits);
for (int i = 0; i < _tod.GetLength(0); i++)
{
for (int j = 0; j < _tod.GetLength(1); j++)
{
_tod[i, j] = stateFile.ReadByte();
}
}
stateFile.ReadBytes(_interruptRegisters);
_serialRegister = stateFile.ReadByte();
_flag = stateFile.ReadBool();
_cntState = stateFile.ReadBool();
_cntEdge = stateFile.ReadBool();
_timerA.ReadDeviceState(stateFile);
_timerB.ReadDeviceState(stateFile);
}
public virtual void WriteToStateFile(C64Interfaces.IFile stateFile)
{
stateFile.Write((byte)0);
_op.WriteToStateFile(stateFile);
stateFile.Write(_comboNext);
}
public override void WriteToStateFile(C64Interfaces.IFile stateFile)
{
stateFile.Write((byte)TargetFactory.TargetTypes.ImmediateTarget);
stateFile.Write(_address);
stateFile.Write(_part);
}
public virtual void WriteToStateFile(C64Interfaces.IFile stateFile)
{
stateFile.Write((byte)TargetFactory.TargetTypes.ReadableTarget);
stateFile.Write(_address);
stateFile.Write(_part);
}
public override void WriteToStateFile(C64Interfaces.IFile stateFile)
{
stateFile.Write((byte)1);
_op.WriteToStateFile(stateFile);
stateFile.Write(_comboNext);
stateFile.Write(_length);
stateFile.Write(_cycle);
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
byte trackCount = stateFile.ReadByte();
for (int i = 0; i < _tracks.Length; i++)
{
ushort sectoirCount = stateFile.ReadWord();
stateFile.ReadBytes(_tracks[i]);
}
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
stateFile.Write((byte)_tracks.Length);
for (int i = 0; i < _tracks.Length; i++)
{
stateFile.Write((ushort)_tracks[i].Length);
stateFile.Write(_tracks[i]);
}
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_headTrackPos = stateFile.ReadByte();
_headSectorPos = stateFile.ReadWord();
_lastHeadDirection = stateFile.ReadByte();
_spinning = stateFile.ReadBool();
_density = stateFile.ReadByte();
_cycleCount = stateFile.ReadByte();
_lastData = stateFile.ReadByte();
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
stateFile.Write(_headTrackPos);
stateFile.Write(_headSectorPos);
stateFile.Write(_lastHeadDirection);
stateFile.Write(_spinning);
stateFile.Write(_density);
stateFile.Write(_cycleCount);
stateFile.Write(_lastData);
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
_ram.WriteDeviceState(stateFile);
_driveCpu.WriteDeviceState(stateFile);
_driveVias[0].WriteDeviceState(stateFile);
_driveVias[1].WriteDeviceState(stateFile);
_drive.WriteDeviceState(stateFile);
_sAtnaConn.WriteDeviceState(stateFile);
_sClockConn.WriteDeviceState(stateFile);
_sDataConn.WriteDeviceState(stateFile);
_driveClock.WriteDeviceState(stateFile);
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_ram.ReadDeviceState(stateFile);
_driveCpu.ReadDeviceState(stateFile);
_driveVias[0].ReadDeviceState(stateFile);
_driveVias[1].ReadDeviceState(stateFile);
_drive.ReadDeviceState(stateFile);
_sAtnaConn.ReadDeviceState(stateFile);
_sClockConn.ReadDeviceState(stateFile);
_sDataConn.ReadDeviceState(stateFile);
_driveClock.ReadDeviceState(stateFile);
}
public void SaveState(C64Interfaces.IFile stateFile)
{
lock (_systemClock)
{
if (_currentStateFile != null)
{
throw new System.InvalidOperationException();
}
_currentStateFile = stateFile;
_pendingStateOperation = PendingStateOperations.Save;
}
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
stateFile.Write(_controlReg);
stateFile.Write(_active);
stateFile.Write(_mode);
stateFile.Write(_oneTime);
stateFile.Write(_output);
stateFile.Write(_pulsing);
stateFile.Write(_pulsed);
stateFile.Write(_current);
stateFile.Write(_latch);
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_controlReg = stateFile.ReadByte();
_active = stateFile.ReadBool();
_mode = stateFile.ReadByte();
_oneTime = stateFile.ReadBool();
_output = stateFile.ReadBool();
_pulsing = stateFile.ReadBool();
_pulsed = stateFile.ReadBool();
_current = stateFile.ReadWord();
_latch = stateFile.ReadWord();
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_systemRam.ReadDeviceState(stateFile);
_systemCpu.ReadDeviceState(stateFile);
_systemVic.ReadDeviceState(stateFile);
_systemCias[0].ReadDeviceState(stateFile);
_systemCias[1].ReadDeviceState(stateFile);
_serial.ReadDeviceState(stateFile);
_sDataConn.ReadDeviceState(stateFile);
_sClockConn.ReadDeviceState(stateFile);
CpuPort_OnMemoryMapChanged(stateFile.ReadByte());
_systemClock.ReadDeviceState(stateFile);
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
_systemRam.WriteDeviceState(stateFile);
_systemCpu.WriteDeviceState(stateFile);
_systemVic.WriteDeviceState(stateFile);
_systemCias[0].WriteDeviceState(stateFile);
_systemCias[1].WriteDeviceState(stateFile);
_serial.WriteDeviceState(stateFile);
_sDataConn.WriteDeviceState(stateFile);
_sClockConn.WriteDeviceState(stateFile);
stateFile.Write(_currentMap);
_systemClock.WriteDeviceState(stateFile);
}
protected void WritePhaseToDeviceState(C64Interfaces.IFile stateFile, byte phase)
{
byte opCount = 0;
for (ClockEntry op = _currentOps[phase]; op != null; op = op.Next)
{
opCount++;
}
stateFile.Write(opCount);
for (ClockEntry op = _currentOps[phase]; op != null; op = op.Next)
{
op.WriteToStateFile(stateFile);
}
}
public virtual void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_state.A.Value = stateFile.ReadByte();
_state.X.Value = stateFile.ReadByte();
_state.Y.Value = stateFile.ReadByte();
_state.PC.Value = stateFile.ReadWord();
_state.S.Value = stateFile.ReadWord();
_state.P.Value = stateFile.ReadByte();
_opcode = stateFile.ReadByte();
_result = stateFile.ReadByte();
_target = TargetFactory.ReadTargetFromStateFile(this, stateFile);
_irq.ReadDeviceState(stateFile);
_nmi.ReadDeviceState(stateFile);
}
public virtual void WriteDeviceState(C64Interfaces.IFile stateFile)
{
stateFile.Write(_state.A.Value);
stateFile.Write(_state.X.Value);
stateFile.Write(_state.Y.Value);
stateFile.Write(_state.PC.Value);
stateFile.Write(_state.S.Value);
stateFile.Write(_state.P.Value);
stateFile.Write(_opcode);
stateFile.Write(_result);
_target.WriteToStateFile(stateFile);
_irq.WriteDeviceState(stateFile);
_nmi.WriteDeviceState(stateFile);
}
public CBM1541(C64Interfaces.IFile kernel, IO.SerialPort serial)
{
_driveCpu = new CPU.MOS6502(_memory, 0);
_driveClock.OpFactory = _driveCpu.OpFactory;
_driveVias = new VIA[2]
{
new VIA((ushort)Map.Via1RegistersAddress, (ushort)Map.Via1RegistersSize, _driveCpu.IRQ),
new VIA((ushort)Map.Via2RegistersAddress, (ushort)Map.Via2RegistersSize, _driveCpu.IRQ)
};
_drive = new DiskDrive.Drive(_driveVias[1]);
_drive.OnDataReady += new DiskDrive.Drive.DateReadyDelegate(drive_OnDataReady);
_ram = new Memory.RAM((ushort)Map.RamAddress, (ushort)Map.RamSize);
_rom = new Memory.ROM((ushort)Map.RomAddress, (ushort)Map.RomSize, kernel);
_rom.Patch(IDLE_TRAP_ADDRES, IDLE_TRAP_OPCODE);
for (int i = 0; i < PATCH_MAP.Length; i++)
{
_rom.Patch(PATCH_MAP[i], NOP_OPCODE);
}
_memory.Map(_ram, true);
_memory.Map(_driveVias[0], true);
_memory.Map(_driveVias[1], true);
_memory.Map(_rom, Memory.MemoryMapEntry.AccessType.Read, true);
_serial = serial;
_sAtnaConn = new IO.SerialPort.BusLineConnection(_serial.DataLine);
_sDataConn = new IO.SerialPort.BusLineConnection(_serial.DataLine);
_sClockConn = new IO.SerialPort.BusLineConnection(_serial.ClockLine);
_serial.OnAtnLineChanged += new IO.SerialPort.LineChangedDelegate(serial_OnAtnLineChanged);
_serial.ClockLine.OnLineChanged += new IO.SerialPort.LineChangedDelegate(ClockLine_OnLineChanged);
_serial.DataLine.OnLineChanged += new IO.SerialPort.LineChangedDelegate(DataLine_OnLineChanged);
_driveVias[0].PortB.OnPortOut += new IO.IOPort.PortOutDelegate(PortB_OnPortOut);
_driveCpu.Restart(_driveClock, 0);
_driveClock.QueueOpsStart(_driveVias[0].CreateOps(), 1);
_driveClock.QueueOpsStart(_driveVias[1].CreateOps(), 2);
_driveClock.QueueOpsStart(_drive.CreateOps(), 3);
}
protected void ReadPhaseFromDeviceState(C64Interfaces.IFile stateFile, byte phase)
{
ClockEntry previousOp = null;
byte opCount = stateFile.ReadByte();
for (byte i = 0; i < opCount; i++)
{
ClockEntry op = stateFile.ReadByte() == 0 ? new ClockEntry(stateFile, _opFactory) : new ClockEntryRep(stateFile, _opFactory);
if (previousOp == null)
{
_currentOps[phase] = op;
}
else
{
previousOp.Next = op;
}
previousOp = op;
}
}
private void _checkPendingStateOperations_OnTimeSlice()
{
lock (_systemClock)
{
if (_currentStateFile != null)
{
switch (_pendingStateOperation)
{
case PendingStateOperations.Load:
ReadDeviceState(_currentStateFile);
if (OnLoadState != null)
{
OnLoadState(_currentStateFile);
}
_currentStateFile.Close();
_currentStateFile = null;
break;
case PendingStateOperations.Save:
WriteDeviceState(_currentStateFile);
if (OnSaveState != null)
{
OnSaveState(_currentStateFile);
}
_currentStateFile.Close();
_currentStateFile = null;
break;
}
}
}
}
public static AddressedTarget ReadTargetFromStateFile(MOS6502 cpu, C64Interfaces.IFile stateFile)
{
switch (stateFile.ReadByte())
{
case (byte)TargetTypes.ReadableTarget:
return(new ReadableTarget(cpu, stateFile));
case (byte)TargetTypes.WritableTarget:
return(new WritableTarget(cpu, stateFile));
case (byte)TargetTypes.IndirectTarget:
return(new IndirectTarget(cpu, stateFile));
case (byte)TargetTypes.AccumulatorTarget:
return(new AccAddressing.Target(cpu));
case (byte)TargetTypes.ImmediateTarget:
return(new ImmAddressing.Target(cpu, stateFile));
}
return(null);
}
public GCRImage(C64Interfaces.IFile diskImage)
{
ushort id = 0;
byte[] sector = new byte[RAW_SECT_LEN];
int offset = 0;
_tracks = new byte[TRACK_COUNT][];
for (byte i = 0; i < TRACK_COUNT; i++)
{
byte track = (byte)(i >> 1);
_tracks[i] = new byte[SPT[track] * GCR_SECTOR_LEN];
if ((i & 1) == 0)
{
if ((ulong)offset < diskImage.Size)
{
ushort start = 0;
for (byte j = 0; j < SPT[track]; j++)
{
diskImage.Read(sector, offset, RAW_SECT_LEN);
ConvertSectorToGCR(sector, _tracks[i], ref start, j, (byte)(track + 1), id);
offset += RAW_SECT_LEN;
}
}
}
else
{
ushort start = 0;
for (byte j = 0; j < SPT[track]; j++)
{
ConvertSectorToGCR(sector, _tracks[i], ref start, j, (byte)(track + 1), id);
}
}
}
}
public void WriteDeviceState(C64Interfaces.IFile stateFile)
{
stateFile.Write(_state);
}
public void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_state = stateFile.ReadByte();
}
private void _checkPendingStateOperations_OnTimeSlice()
{
lock (_systemClock)
{
if (_currentStateFile != null)
{
switch (_pendingStateOperation)
{
case PendingStateOperations.Load:
ReadDeviceState(_currentStateFile);
if (OnLoadState != null)
OnLoadState(_currentStateFile);
_currentStateFile.Close();
_currentStateFile = null;
break;
case PendingStateOperations.Save:
WriteDeviceState(_currentStateFile);
if (OnSaveState != null)
OnSaveState(_currentStateFile);
_currentStateFile.Close();
_currentStateFile = null;
break;
}
}
}
}
public void SaveState(C64Interfaces.IFile stateFile)
{
lock (_systemClock)
{
if (_currentStateFile != null)
throw new System.InvalidOperationException();
_currentStateFile = stateFile;
_pendingStateOperation = PendingStateOperations.Save;
}
}
