654 lines
15 KiB
C#
654 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace BizHawk.Emulation.Computers.Commodore64
|
|
{
|
|
public class CiaRegs
|
|
{
|
|
public bool ALARM; // alarm enabled
|
|
public int ALARM10; // alarm 10ths of a second
|
|
public int ALARMHR; // alarm hours
|
|
public int ALARMMIN; // alarm minutes
|
|
public bool ALARMPM; // alarm AM/PM
|
|
public int ALARMSEC; // alarm seconds
|
|
public bool CNT; // external counter bit input
|
|
public bool EIALARM; // enable alarm interrupt (internal)
|
|
public bool EIFLG; // enable flag pin interrupt (internal)
|
|
public bool EISP; // enable shift register interrupt (internal)
|
|
public bool[] EIT = new bool[2]; // enable timer interrupt (internal)
|
|
public bool FLG; // external flag bit input
|
|
public bool IALARM; // alarm interrupt triggered
|
|
public bool IFLG; // interrupt triggered on FLAG pin
|
|
public int[] INMODE = new int[2]; // timer input mode
|
|
public bool IRQ; // interrupt triggered
|
|
public bool ISP; // shift register interrupt
|
|
public bool[] IT = new bool[2]; // timer interrupt
|
|
public bool[] LOAD = new bool[2]; // force load timer
|
|
public bool[] OUTMODE = new bool[2]; // timer output mode
|
|
public bool[] PBON = new bool[2]; // port bit modify on
|
|
public bool[] RUNMODE = new bool[2]; // running mode
|
|
public int SDR; // serial shift register
|
|
public int SDRCOUNT; // serial shift register bit count
|
|
public bool SPMODE; // shift register mode
|
|
public bool[] START = new bool[2]; // timer enabled
|
|
public int[] T = new int[2]; // timer counter
|
|
public bool[] TICK = new bool[2]; // execute timer tick
|
|
public int[] TLATCH = new int[2]; // timer latch (internal)
|
|
public int TOD10; // time of day 10ths of a second
|
|
public bool TODIN; // time of day/alarm set
|
|
public int TODHR; // time of day hour
|
|
public int TODMIN; // time of day minute
|
|
public bool TODPM; // time of day AM/PM
|
|
public bool TODREADLATCH; // read latch (internal)
|
|
public int TODREADLATCH10; // tod read latch (internal)
|
|
public int TODREADLATCHSEC; // tod read latch (internal)
|
|
public int TODREADLATCHMIN; // tod read latch (internal)
|
|
public int TODREADLATCHHR; // tod read latch (internal)
|
|
public int TODSEC; // time of day seconds
|
|
|
|
public DataPortBus[] ports;
|
|
|
|
private DataPortConnector[] connectors;
|
|
|
|
public CiaRegs()
|
|
{
|
|
ports = new DataPortBus[2];
|
|
ports[0] = new DataPortBus();
|
|
ports[1] = new DataPortBus();
|
|
connectors = new DataPortConnector[2];
|
|
connectors[0] = ports[0].Connect();
|
|
connectors[1] = ports[1].Connect();
|
|
HardReset();
|
|
}
|
|
|
|
public byte this[int addr]
|
|
{
|
|
get
|
|
{
|
|
// value of open bits
|
|
int result = 0x00;
|
|
|
|
addr &= 0x0F;
|
|
switch (addr)
|
|
{
|
|
case 0x00:
|
|
result = connectors[0].Data;
|
|
break;
|
|
case 0x01:
|
|
result = connectors[1].Data;
|
|
break;
|
|
case 0x02:
|
|
result = connectors[0].Direction;
|
|
break;
|
|
case 0x03:
|
|
result = connectors[1].Direction;
|
|
break;
|
|
case 0x04:
|
|
result = (T[0] & 0xFF);
|
|
break;
|
|
case 0x05:
|
|
result = ((T[0] >> 8) & 0xFF);
|
|
break;
|
|
case 0x06:
|
|
result = (T[1] & 0xFF);
|
|
break;
|
|
case 0x07:
|
|
result = ((T[1] >> 8) & 0xFF);
|
|
break;
|
|
case 0x08:
|
|
result |= (TOD10 & 0x0F);
|
|
break;
|
|
case 0x09:
|
|
result &= 0x80;
|
|
result |= (TODSEC & 0x7F);
|
|
break;
|
|
case 0x0A:
|
|
result &= 0x80;
|
|
result |= (TODMIN & 0x7F);
|
|
break;
|
|
case 0x0B:
|
|
result &= 0x40;
|
|
result |= ((TODHR & 0x3F) | (TODPM ? 0x80 : 0x00));
|
|
break;
|
|
case 0x0C:
|
|
result = SDR;
|
|
break;
|
|
case 0x0D:
|
|
result &= 0x9F;
|
|
result |= (IT[0] ? 0x01 : 0x00);
|
|
result |= (IT[1] ? 0x02 : 0x00);
|
|
result |= (IALARM ? 0x04 : 0x00);
|
|
result |= (ISP ? 0x08 : 0x00);
|
|
result |= (IFLG ? 0x10 : 0x00);
|
|
result |= (IRQ ? 0x80 : 0x00);
|
|
break;
|
|
case 0x0E:
|
|
result = (START[0] ? 0x01 : 0x00);
|
|
result = (PBON[0] ? 0x02 : 0x00);
|
|
result = (OUTMODE[0] ? 0x04 : 0x00);
|
|
result = (RUNMODE[0] ? 0x08 : 0x00);
|
|
result = (LOAD[0] ? 0x10 : 0x00);
|
|
result = ((INMODE[0] & 0x01) << 5);
|
|
result = (SPMODE ? 0x40 : 0x00);
|
|
result = (TODIN ? 0x80 : 0x00);
|
|
break;
|
|
case 0x0F:
|
|
result = (START[1] ? 0x01 : 0x00);
|
|
result = (PBON[1] ? 0x02 : 0x00);
|
|
result = (OUTMODE[1] ? 0x04 : 0x00);
|
|
result = (RUNMODE[1] ? 0x08 : 0x00);
|
|
result = (LOAD[1] ? 0x10 : 0x00);
|
|
result = ((INMODE[1] & 0x03) << 5);
|
|
result = (ALARM ? 0x80 : 0x00);
|
|
break;
|
|
}
|
|
|
|
return (byte)(result & 0xFF);
|
|
}
|
|
|
|
set
|
|
{
|
|
byte val = value;
|
|
addr &= 0x0F;
|
|
switch (addr)
|
|
{
|
|
case 0x00:
|
|
connectors[0].Data = val;
|
|
break;
|
|
case 0x01:
|
|
connectors[1].Data = val;
|
|
break;
|
|
case 0x02:
|
|
connectors[0].Direction = val;
|
|
break;
|
|
case 0x03:
|
|
connectors[1].Direction = val;
|
|
break;
|
|
case 0x04:
|
|
T[0] &= 0xFF00;
|
|
T[0] |= val;
|
|
break;
|
|
case 0x05:
|
|
T[0] &= 0x00FF;
|
|
T[0] |= ((int)val << 8);
|
|
break;
|
|
case 0x06:
|
|
T[1] &= 0xFF00;
|
|
T[1] |= val;
|
|
break;
|
|
case 0x07:
|
|
T[1] &= 0x00FF;
|
|
T[1] |= ((int)val << 8);
|
|
break;
|
|
case 0x08:
|
|
TOD10 = val & 0x0F;
|
|
break;
|
|
case 0x09:
|
|
TODSEC = val & 0x7F;
|
|
break;
|
|
case 0x0A:
|
|
TODMIN = val & 0x7F;
|
|
break;
|
|
case 0x0B:
|
|
val &= 0x9F;
|
|
TODHR = val;
|
|
TODPM = ((val & 0x80) != 0x00);
|
|
break;
|
|
case 0x0C:
|
|
SDR = val;
|
|
break;
|
|
case 0x0D:
|
|
IT[0] = ((val & 0x01) != 0x00);
|
|
IT[1] = ((val & 0x02) != 0x00);
|
|
IALARM = ((val & 0x04) != 0x00);
|
|
ISP = ((val & 0x08) != 0x00);
|
|
IFLG = ((val & 0x10) != 0x00);
|
|
IRQ = ((val & 0x80) != 0x00);
|
|
break;
|
|
case 0x0E:
|
|
START[0] = ((val & 0x01) != 0x00);
|
|
PBON[0] = ((val & 0x02) != 0x00);
|
|
OUTMODE[0] = ((val & 0x04) != 0x00);
|
|
RUNMODE[0] = ((val & 0x08) != 0x00);
|
|
LOAD[0] = ((val & 0x10) != 0x00);
|
|
INMODE[0] = ((val & 0x20) >> 5);
|
|
SPMODE = ((val & 0x40) != 0x00);
|
|
TODIN = ((val & 0x80) != 0x00);
|
|
break;
|
|
case 0x0F:
|
|
START[1] = ((val & 0x01) != 0x00);
|
|
PBON[1] = ((val & 0x02) != 0x00);
|
|
OUTMODE[1] = ((val & 0x04) != 0x00);
|
|
RUNMODE[1] = ((val & 0x08) != 0x00);
|
|
LOAD[1] = ((val & 0x10) != 0x00);
|
|
INMODE[1] = ((val & 0x60) >> 5);
|
|
ALARM = ((val & 0x80) != 0x00);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void HardReset()
|
|
{
|
|
// power on state
|
|
for (int i = 0; i < 0x10; i++)
|
|
this[i] = 0x00;
|
|
|
|
TLATCH[0] = 0xFFFF;
|
|
TLATCH[1] = 0xFFFF;
|
|
T[0] = TLATCH[0];
|
|
T[1] = TLATCH[1];
|
|
|
|
this[0x0B] = 0x01;
|
|
|
|
connectors[0].Data = 0xFF;
|
|
connectors[1].Data = 0xFF;
|
|
connectors[0].Direction = 0xFF;
|
|
connectors[1].Direction = 0xFF;
|
|
}
|
|
}
|
|
|
|
public class Cia
|
|
{
|
|
public int intMask;
|
|
public bool lastCNT;
|
|
public byte[] outputBitMask;
|
|
private CiaRegs regs = new CiaRegs();
|
|
public int todCounter;
|
|
public int todFrequency;
|
|
public bool[] underflow;
|
|
|
|
public Func<bool> ReadSerial;
|
|
public Action<bool> WriteSerial;
|
|
|
|
public Cia(Region newRegion)
|
|
{
|
|
ReadSerial = ReadSerialDummy;
|
|
WriteSerial = WriteSerialDummy;
|
|
switch (newRegion)
|
|
{
|
|
case Region.NTSC:
|
|
todFrequency = 14318181 / 14 / 10;
|
|
break;
|
|
case Region.PAL:
|
|
todFrequency = 14318181 / 18 / 10;
|
|
break;
|
|
}
|
|
HardReset();
|
|
}
|
|
|
|
private void AdvanceTOD()
|
|
{
|
|
bool overflow;
|
|
int tenths = regs.TOD10;
|
|
int seconds = regs.TODSEC;
|
|
int minutes = regs.TODMIN;
|
|
int hours = regs.TODHR;
|
|
bool ampm = regs.TODPM;
|
|
todCounter = todFrequency;
|
|
|
|
tenths = BCDAdd(tenths, 1, out overflow);
|
|
if (tenths >= 10)
|
|
{
|
|
tenths = 0;
|
|
seconds = BCDAdd(seconds, 1, out overflow);
|
|
if (overflow)
|
|
{
|
|
seconds = 0;
|
|
minutes = BCDAdd(minutes, 1, out overflow);
|
|
if (overflow)
|
|
{
|
|
minutes = 0;
|
|
hours = BCDAdd(hours, 1, out overflow);
|
|
if (hours > 12)
|
|
{
|
|
hours = 1;
|
|
ampm = !ampm;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
regs.TOD10 = tenths;
|
|
regs.TODSEC = seconds;
|
|
regs.TODMIN = minutes;
|
|
regs.TODHR = hours;
|
|
regs.TODPM = ampm;
|
|
}
|
|
|
|
public void AttachWriteHook(int index, Action act)
|
|
{
|
|
regs.ports[index].AttachWriteHook(act);
|
|
}
|
|
|
|
private int BCDAdd(int i, int j, out bool overflow)
|
|
{
|
|
int lo;
|
|
int hi;
|
|
int result;
|
|
|
|
lo = (i & 0x0F) + (j & 0x0F);
|
|
hi = (i & 0x70) + (j & 0x70);
|
|
if (lo > 0x09)
|
|
{
|
|
hi += 0x10;
|
|
lo += 0x06;
|
|
}
|
|
if (hi > 0x50)
|
|
{
|
|
hi += 0xA0;
|
|
}
|
|
overflow = hi >= 0x60;
|
|
result = (hi & 0x70) + (lo & 0x0F);
|
|
return result;
|
|
}
|
|
|
|
public DataPortConnector ConnectPort(int index)
|
|
{
|
|
return regs.ports[index].Connect();
|
|
}
|
|
|
|
public DataPortConnector ConnectSerialPort(int index)
|
|
{
|
|
DataPortConnector result = regs.ports[index].Connect();
|
|
regs.ports[index].AttachInputConverter(result, new DataPortSerialInputConverter());
|
|
regs.ports[index].AttachOutputConverter(result, new DataPortSerialOutputConverter());
|
|
return result;
|
|
}
|
|
|
|
public void HardReset()
|
|
{
|
|
outputBitMask = new byte[] { 0x40, 0x80 };
|
|
regs.HardReset();
|
|
underflow = new bool[2];
|
|
todCounter = todFrequency;
|
|
}
|
|
|
|
public bool IRQ
|
|
{
|
|
get
|
|
{
|
|
return regs.IRQ;
|
|
}
|
|
}
|
|
|
|
public byte Peek(int addr)
|
|
{
|
|
addr &= 0xF;
|
|
return regs[addr];
|
|
}
|
|
|
|
public void PerformCycle()
|
|
{
|
|
// process time of day counter
|
|
todCounter--;
|
|
if (todCounter <= 0)
|
|
AdvanceTOD();
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
if (regs.START[i])
|
|
{
|
|
TimerTick(i);
|
|
if (regs.PBON[i])
|
|
{
|
|
// output the clock data to port B
|
|
|
|
if (regs.OUTMODE[i])
|
|
{
|
|
// clear bit if set
|
|
regs[0x01] &= (byte)~outputBitMask[i];
|
|
}
|
|
if (underflow[i])
|
|
{
|
|
if (regs.OUTMODE[i])
|
|
{
|
|
// toggle bit
|
|
regs[0x01] ^= outputBitMask[i];
|
|
}
|
|
else
|
|
{
|
|
// set for a cycle
|
|
regs[0x01] |= outputBitMask[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
lastCNT = regs.CNT;
|
|
regs.CNT = false;
|
|
UpdateInterrupt();
|
|
}
|
|
|
|
public void Poke(int addr, byte val)
|
|
{
|
|
addr &= 0xF;
|
|
regs[addr] = val;
|
|
}
|
|
|
|
public byte Read(ushort addr)
|
|
{
|
|
byte result;
|
|
addr &= 0xF;
|
|
|
|
switch (addr)
|
|
{
|
|
case 0x08:
|
|
regs.TODREADLATCH = false;
|
|
return (byte)regs.TODREADLATCH10;
|
|
case 0x09:
|
|
if (!regs.TODREADLATCH)
|
|
return regs[addr];
|
|
else
|
|
return (byte)regs.TODREADLATCHSEC;
|
|
case 0x0A:
|
|
if (!regs.TODREADLATCH)
|
|
return regs[addr];
|
|
else
|
|
return (byte)regs.TODREADLATCHMIN;
|
|
case 0x0B:
|
|
regs.TODREADLATCH = true;
|
|
regs.TODREADLATCH10 = regs.TOD10;
|
|
regs.TODREADLATCHSEC = regs.TODSEC;
|
|
regs.TODREADLATCHMIN = regs.TODMIN;
|
|
regs.TODREADLATCHHR = regs.TODHR;
|
|
return (byte)regs.TODREADLATCHHR;
|
|
case 0x0D:
|
|
// reading this reg clears it
|
|
result = regs[0x0D];
|
|
regs[0x0D] = 0x00;
|
|
UpdateInterrupt();
|
|
return result;
|
|
default:
|
|
return regs[addr];
|
|
}
|
|
}
|
|
|
|
private bool ReadSerialDummy()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public void TimerDec(int index)
|
|
{
|
|
int timer = regs.T[index];
|
|
timer--;
|
|
if (timer < 0)
|
|
{
|
|
underflow[index] = true;
|
|
if (regs.RUNMODE[index])
|
|
{
|
|
// one shot timer
|
|
regs.START[index] = false;
|
|
}
|
|
timer = regs.TLATCH[index];
|
|
}
|
|
else
|
|
{
|
|
underflow[index] = false;
|
|
}
|
|
|
|
regs.IT[index] |= underflow[index];
|
|
regs.T[index] = timer;
|
|
}
|
|
|
|
public void TimerTick(int index)
|
|
{
|
|
switch (regs.INMODE[index])
|
|
{
|
|
case 0:
|
|
regs.TICK[index] = true;
|
|
break;
|
|
case 1:
|
|
regs.TICK[index] |= (regs.CNT && !lastCNT);
|
|
break;
|
|
case 2:
|
|
regs.TICK[index] |= underflow[0];
|
|
break;
|
|
case 3:
|
|
regs.TICK[index] |= (regs.CNT && !lastCNT) || underflow[0];
|
|
break;
|
|
}
|
|
if (regs.TICK[index])
|
|
{
|
|
TimerDec(index);
|
|
regs.TICK[index] = false;
|
|
}
|
|
}
|
|
|
|
public void UpdateInterrupt()
|
|
{
|
|
bool irq = false;
|
|
irq |= (regs.EIT[0] & regs.IT[0]);
|
|
irq |= (regs.EIT[1] & regs.IT[1]);
|
|
irq |= (regs.EIFLG & regs.IFLG);
|
|
irq |= (regs.EISP & regs.ISP);
|
|
irq |= (regs.EIALARM & regs.IALARM);
|
|
regs.IRQ = irq;
|
|
}
|
|
|
|
public void Write(ushort addr, byte val)
|
|
{
|
|
addr &= 0xF;
|
|
switch (addr)
|
|
{
|
|
case 0x04:
|
|
regs.TLATCH[0] &= 0xFF00;
|
|
regs.TLATCH[0] |= val;
|
|
if (regs.LOAD[0])
|
|
regs.T[0] = regs.TLATCH[0];
|
|
break;
|
|
case 0x05:
|
|
regs.TLATCH[0] &= 0xFF;
|
|
regs.TLATCH[0] |= (int)val << 8;
|
|
if (regs.LOAD[0] || !regs.START[0])
|
|
regs.T[0] = regs.TLATCH[0];
|
|
break;
|
|
case 0x06:
|
|
regs.TLATCH[1] &= 0xFF00;
|
|
regs.TLATCH[1] |= val;
|
|
if (regs.LOAD[1])
|
|
regs.T[1] = regs.TLATCH[1];
|
|
break;
|
|
case 0x07:
|
|
regs.TLATCH[1] &= 0xFF;
|
|
regs.TLATCH[1] |= (int)val << 8;
|
|
if (regs.LOAD[1] || !regs.START[1])
|
|
regs.T[1] = regs.TLATCH[1];
|
|
break;
|
|
case 0x08:
|
|
if (regs.ALARM)
|
|
regs.ALARM10 = val & 0x0F;
|
|
else
|
|
regs[addr] = val;
|
|
break;
|
|
case 0x09:
|
|
if (regs.ALARM)
|
|
regs.ALARMSEC = val & 0x7F;
|
|
else
|
|
regs[addr] = val;
|
|
break;
|
|
case 0x0A:
|
|
if (regs.ALARM)
|
|
regs.ALARMMIN = val & 0x7F;
|
|
else
|
|
regs[addr] = val;
|
|
break;
|
|
case 0x0B:
|
|
if (regs.ALARM)
|
|
{
|
|
regs.ALARMHR = val & 0x1F;
|
|
regs.ALARMPM = ((val & 0x80) != 0x00);
|
|
}
|
|
else
|
|
{
|
|
regs[addr] = val;
|
|
}
|
|
break;
|
|
case 0x0D:
|
|
intMask &= ~val;
|
|
if ((val & 0x80) != 0x00)
|
|
intMask ^= val;
|
|
regs.EIT[0] = ((intMask & 0x01) != 0x00);
|
|
regs.EIT[1] = ((intMask & 0x02) != 0x00);
|
|
regs.EIALARM = ((intMask & 0x04) != 0x00);
|
|
regs.EISP = ((intMask & 0x08) != 0x00);
|
|
regs.EIFLG = ((intMask & 0x10) != 0x00);
|
|
UpdateInterrupt();
|
|
break;
|
|
default:
|
|
regs[addr] = val;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
public void WriteCNT(bool val)
|
|
{
|
|
if (!lastCNT && val)
|
|
{
|
|
if (!regs.SPMODE)
|
|
{
|
|
// read bit into shift register
|
|
bool inputBit = ReadSerial();
|
|
regs.SDR = ((regs.SDR << 1) | (inputBit ? 0x01 : 0x00)) & 0xFF;
|
|
|
|
regs.SDRCOUNT = (regs.SDRCOUNT - 1) & 0x7;
|
|
if (regs.SDRCOUNT == 0)
|
|
{
|
|
regs.ISP = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// write bit out from shift register
|
|
bool outputBit = ((regs.SDR & 0x01) != 0);
|
|
regs.SDR >>= 1;
|
|
WriteSerial(outputBit);
|
|
|
|
regs.SDRCOUNT = (regs.SDRCOUNT - 1) & 0x7;
|
|
if (regs.SDRCOUNT == 0)
|
|
{
|
|
regs.ISP = true;
|
|
}
|
|
}
|
|
}
|
|
regs.CNT = val;
|
|
}
|
|
|
|
public void WriteFLG(bool val)
|
|
{
|
|
regs.FLG = val;
|
|
regs.IFLG |= val;
|
|
}
|
|
|
|
private void WriteSerialDummy(bool val)
|
|
{
|
|
// do nothing
|
|
}
|
|
}
|
|
}
|