public Laptop(IMotherboard motherboard, Cpu cpu, HardDriveComponent hardDrive, LaptopBattery laptopBattery)
{
this.Motherboard = motherboard;
this.Cpu = cpu;
this.HardDrive = hardDrive;
this.LaptopBattery = laptopBattery;
}
internal AbstractComputer(Cpu cpu, Ram ram, IEnumerable<HardDrive> hardDrives, VideoCard videoCard)
{
this.Cpu = cpu;
this.Ram = ram;
this.HardDrives = hardDrives;
this.VideoCard = videoCard;
}
/// <summary>
/// Initializes a new instance of the <see cref="Form1" /> class.
/// </summary>
/// <param name="args">The args.</param>
public Form1(string[] args)
{
InitializeComponent();
cpu = new Cpu();
cpu.CommandCounter = Cpu.FromShort(100);
cpu.StepCounter = 0;
activeMode = fastToolStripMenuItem;
StepMode = (StepModeEnum)Enum.Parse(typeof(StepModeEnum), activeMode.Text);
#if DEBUG
args = new string[1];
args[0] = @"C:\Dev\ASP.Net\Mini-Power-PC\Examples\Multiplikation.lvhe";
#endif
// Falls ein File als Parameter mit angegeben wurde, den Emulator damit starten
if (args.Length > 0)
{
FileTracker.ActiveFile = new FileInfo(args[0]);
initGui();
}
toolStripStatusLabel2.Text = string.Empty;
updateGui();
}
public void Rebuild(Cpu _CPU)
{
blocks.Clear();
AddBlock(0, 0, _CPU);
Stack<Block> todo = new Stack<Block>();
todo.Push(_CPU);
Block b;
while (todo.Count > 0)
{
b = todo.Pop();
if (b == null) break;
foreach (Edge e in b.Edges)
{
for (int bidx = 0; bidx < 2; bidx++)
{
if (!blocks.ContainsValue(e.Blocks[1]))
{
Vector3 pos = _CPU.transform.InverseTransformPoint(e.Blocks[bidx].transform.position);
AddBlock((int)(pos.x + 0.5f), (int)(pos.y + 0.5f), e.Blocks[bidx]);
todo.Push(e.Blocks[bidx]);
}
}
}
}
}
internal Server(
Cpu cpu,
Ram ram,
IEnumerable<HardDriver> hardDrives,
VideoCard videoCard)
: base(cpu, ram, hardDrives, videoCard)
{
}
public PersonalComputer(
Cpu cpu,
Rammstein ram,
IEnumerable<HardDrive> hardDrives,
ColourVideoCard videoCard)
: base(cpu, ram, hardDrives, videoCard)
{
}
public Server(
Cpu cpu,
Rammstein ram,
IEnumerable<HardDrive> hardDrives,
MonochromeVideoCard videoCard)
: base(cpu, ram, hardDrives, videoCard)
{
}
internal Computer(Cpu cpu, IRam ram, IEnumerable<HardDrive> hardDrives, VideoCard videoCard)
{
this.Cpu = cpu;
this.Ram = ram;
this.HardDrives = hardDrives;
this.VideoCard = videoCard;
this.motherboard = new Motherboard(this.Cpu, this.Ram, this.VideoCard);
}
public void Setup()
{
_memory = Substitute.For<IMemory>();
_input = Substitute.For<IInput>();
_output = Substitute.For<IOutput>();
_cpu = new Cpu(_memory, _input, _output);
}
public PersonalComputer(
Cpu cpu,
Ram ram,
IEnumerable<HardDriver> hardDrives,
VideoCard videoCard)
: base(cpu, ram, hardDrives, videoCard)
{
}
public Server(Cpu cpu, Ram ram, IStorageDevice hardDrives, VideoCard videoCard)
: base(cpu, ram, hardDrives, videoCard)
{
if (videoCard.IsMonochrome == false)
{
throw new ArgumentException("Cannot initialise server with colourful video card");
}
}
public static void Mount(string path, SPI.SPI_module spi, Cpu.Pin chipSelect, Cpu.Pin cardDetect)
{
if (_sdCardPath != null)
throw new NotSupportedException();
MountNative(path, (uint) spi, (uint) chipSelect, (uint) cardDetect);
_sdCardPath = path;
}
public Computer(Cpu cpu, Ram ram, VideoCard videoCard, HardDriver hdd, IEnumerable<HardDriver> hardDrives)
{
this.Cpu = cpu;
this.Ram = ram;
this.VideoCard = videoCard;
this.HardDrive = hdd;
this.HardDrives = hardDrives;
}
public Computer(Cpu cpu, Ram ram, IStorageDevice storage, VideoCard videoCard)
{
this.CPU = cpu;
this.Ram = ram;
this.StorageDevice = storage;
this.VideoCard = videoCard;
this.motherboard = new Motherboard(this.CPU, this.Ram, VideoCard);
}
public PiezoSpeaker(Cpu.Pin pin)
{
_pin = new PWM(pin);
// take the pin low, so the speaker
// doesn't make any noise until we
// ask it to
_pin.SetDutyCycle(0);
}
internal Server(
Cpu cpu,
Ram ram,
IEnumerable<HardDrive> hardDrives,
VideoCard videoCard)
: base(cpu, ram, hardDrives, videoCard)
{
this.VideoCard.IsMonochrome = true;
}
internal Laptop(
Cpu cpu,
Ram ram,
IEnumerable<HardDrive> hardDrives,
VideoCard videoCard,
ILaptopBattery battery)
: base(cpu, ram, hardDrives, videoCard)
{
this.battery = battery;
}
public PC CreatePC()
{
var ram = new Ram(8);
var videoCard = new VideoCard(false);
var cpu = new Cpu(4, 64, ram, videoCard);
var storage = new HardDrive(1000);
var pc = new PC(cpu, ram, storage, videoCard);
return pc;
}
public override Computer MakePC()
{
var ramMemory = new RAMMemory(2);
var videoCard = new ColorVideoCard();
var cpu = new Cpu(2, 32);
var hdd = new[] { new HardDriver(500, false, 0) };
var pc = new Computer("PC", cpu, ramMemory, hdd, videoCard, null);
return pc;
}
public PC CreatePC()
{
var ram = new Ram(4);
var videoCard = new VideoCard(true);
var cpu = new Cpu(2, 64, ram, videoCard);
var storage = new HardDrive(2000);
var pc = new PC(cpu, ram, storage, videoCard);
return pc;
}
public Server CreateServer()
{
var ram = new Ram(64);
var videoCard = new VideoCard(true);
var cpu = new Cpu(8, 64, ram, videoCard);
var storage = new RaidArray(2, 2000);
var server = new Server(cpu, ram, storage, videoCard);
return server;
}
private IComputer ManufacturePC()
{
Ram ram = new Ram(4);
HardDrive hardDrive = new HardDrive(2000, false, 0);
IEnumerable<HardDrive> hardDrives = new List<HardDrive>() { hardDrive };
IVideoCard videoCard = new MonochromeVideoCard();
ICpu cpu = new Cpu(2, CpuType.Bits64, new Motherboard(ram, videoCard));
IComputer pc = new PersonalComputer(cpu, ram, hardDrives, videoCard);
return pc;
}
protected Computer(
Cpu cpu,
Rammstein ram,
IEnumerable<HardDrive> hardDrives,
IVideoCard videoCard)
{
Cpu = cpu;
this.Ram = ram;
this.HardDrives = hardDrives;
this.VideoCard = videoCard;
}
public override Computer MakeLaptop()
{
var videoCard = new ColorVideoCard();
var ramMemory = new RAMMemory(4);
var cpu = new Cpu(2, 64);
var hdd = new[] { new HardDriver(500, false, 0) };
var battery = new LaptopBattery();
var laptop = new Computer("LAPTOP", cpu, ramMemory, hdd, videoCard, new LaptopBattery());
return laptop;
}
public override PersonalComputer CreatePC()
{
var ram = new Ram((int)RamType.GB2);
var videoCard = new VideoCard(false);
var motherBoard = new Motherboard(ram, videoCard);
var cpu = new Cpu(2, (int)ArchitectureType.Bits32, motherBoard);
var hardDrive = new HardDrive(500);
var pc = new PersonalComputer(motherBoard, cpu, hardDrive);
return pc;
}
public Laptop CreateLaptop()
{
var ram = new Ram(4);
var videoCard = new VideoCard(false);
var cpu = new Cpu(4, 32, ram, videoCard);
var storage = new HardDrive(1000);
var battery = new LaptopBattery();
var laptop = new Laptop(cpu, ram, storage, videoCard, battery);
return laptop;
}
private IComputer ManufactureLaptop()
{
Ram ram = new Ram(16);
HardDrive hardDrive = new HardDrive(1000, false, 0);
IEnumerable<HardDrive> hardDrives = new List<HardDrive>() { hardDrive };
IVideoCard videoCard = new ColorfulVideoCard();
LaptopBatery battery = new LaptopBatery();
ICpu cpu = new Cpu(2, CpuType.Bits64, new Motherboard(ram, videoCard));
IComputer laptop = new Laptop(cpu, ram, hardDrives, videoCard, battery);
return laptop;
}
static void Main(string[] args)
{
if(args.Length != 1)
{
Console.WriteLine("Usage: pemu binaryFile");
return;
}
var elf = ELFSharp.ELFReader.Load<uint>(args[0]);
var program = ProgramLoader.ReadProgram(elf);
var cpu = new Cpu() { Program = program };
cpu.Run();
}
public override IPlayable CreatePc()
{
IRam ram = new Ram(InitialPcRam);
VideoCardBase videoCard = new MonochromeVideoCard();
ICpu cpu = new Cpu(InitialPcCores, InitialPcCpuBits, ram, videoCard, new Cpu64BitsSquareNumberFinder());
IEnumerable<HardDrive> hardDrives = new[]
{
new HardDrive(InitialPcHardDriveSpace, InitialPcHardDriveInRaid, 0)
};
return new Pc(cpu, ram, hardDrives, videoCard);
}
private IComputer ManufactureServer()
{
Ram ram = new Ram(8);
HardDrive firstHardDrive = new HardDrive(500, true, 2);
HardDrive secondHardDrive = new HardDrive(500, true, 2);
IEnumerable<HardDrive> hardDrives = new List<HardDrive>() { firstHardDrive, secondHardDrive };
IVideoCard videoCard = new MonochromeVideoCard();
ICpu cpu = new Cpu(8, CpuType.Bits128, new Motherboard(ram, videoCard));
IComputer server = new Server(cpu, ram, hardDrives, videoCard);
return server;
}
public void Add(long value)
{
Add(value, Cpu.GetCurrentCoreId());
}
public Cpu VulCPU(Cpu cpu)
{
cpu.Wapen = itemrepo.GetCPUItemsById(cpu.ID)[0];
cpu.Potion = itemrepo.GetCPUItemsById(cpu.ID)[1];
return(cpu);
}
public bool Return(T obj)
{
return(Return(obj, Cpu.GetCurrentCoreId()));
}
/*
* 20.02
*
*/
// Value Boot Cert. Privileged Immutable
// 0 3F 3E 2C-2F, 3C-3F 2C-2F, 3F
// 1 7F 7E 6C-6F, 7C-7F 6C-6F, 7F
// 2 FF FE EC-EF, FC-FF EC-EF, FF
public override byte BusRead(object sender, ushort address)
{
int linearAddress = 0;
bool isRam = false;
// Compute linear address in RAM or flash
switch (address & 0xC000)
{
case 0x0000:
/*
* if (BootMode)
* return Flash.ReadByte(sender, address | 0xFFC000);
* else
* return Flash.ReadByte(sender, address);*/
isRam = false;
if (BootMode)
{
linearAddress = address | Flash.BootSector;
}
else
{
linearAddress = address;
}
break;
case 0x4000:
BootMode = false;
linearAddress = (address & 0x3FFF) | bank4000;
isRam = Bank4000IsRam;
break;
case 0x8000:
if (address < lowerPageAlwaysPresentLimit && memoryMapMode == 0)
{
isRam = true;
linearAddress = (address & 0x3FFF) | 0x4000;
break;
}
if (memoryMapMode == 1)
{
BootMode = false;
}
linearAddress = (address & 0x3FFF) | bank8000;
isRam = Bank8000IsRam;
break;
case 0xC000:
if (address >= upperPageAlawayPresentLimit && memoryMapMode == 0)
{
isRam = true;
linearAddress = (address & 0x3FFF);
break;
}
linearAddress = (address & 0x3FFF) | bankC000;
isRam = BankC000IsRam;
break;
}
Breakpoint bp = new Breakpoint()
{
Address = (ushort)(linearAddress & 0x3FFF),
IsRam = isRam,
Page = linearAddress >> 14,
Type = Cpu.M1 ? MemoryBreakpointType.Execution : MemoryBreakpointType.Read
};
if (Cpu.M1 && IsExecutionBreakpoint(bp))
{
Cpu.BreakExecution();
}
else if (haveReadBps && IsReadBreakpoint(bp))
{
Cpu.BreakExecution();
}
if (isRam)
{
// Check execution permissions: address must be within allowed limits, masked by RAM chip size
if (Cpu.M1 && sender is Z80Cpu)
{
if ((linearAddress & ramTypeMask) < ramLowerLimit || (linearAddress & ramTypeMask) >= ramUpperLimit)
{
Master.Reset();
}
}
return(Ram.ReadByte(sender, linearAddress & 0x3FFFF));
}
else
{
// Check execution permissions: address must be within allowed limits
if (Cpu.M1 && sender is Z80Cpu)
{
if ((linearAddress & flashTypeMask) >= flashLowerLimit && (linearAddress & flashTypeMask) < flashUpperLimit)
{
// . . . unless it's on a privileged page, in which case, execution is always allowed
if (!((((linearAddress >> 14) & 0xF) >= 0xC) && (((linearAddress >> 18) & 0x2) >= 2) && ((linearAddress >> 20) == (1 << flashType) - 1)))
{
Master.Reset();
}
}
}
// Check for censorship
int highBits = ((1 << flashType) - 1) << 20;
if ((linearAddress & 0xF00000) == highBits && !FlashWriteEnable)
{
highBits = linearAddress & 0xFFFFF;
if (highBits >= 0xF8000 && highBits < 0xFC000)
{
return(0xFF);
}
}
return(Flash.ReadByte(sender, linearAddress));
}
}
/// <summary>
/// Creates a new architecture structure with pre-set values.
/// </summary>
/// <param name="os">Determines which operating systems are supported.</param>
/// <param name="cpu">Determines which CPU-architectures are supported.</param>
public Architecture(OS os, Cpu cpu) : this()
{
OS = os;
Cpu = cpu;
}
private static void Main(string[] args)
{
var loglevel = LogLevel.Debug;
if (args.Length > 0 && args[0] == "trace")
{
loglevel = LogLevel.Trace;
}
var logConfig = new LoggingConfiguration();
var logTargetConsole = new ConsoleTarget {
Name = "console",
Header = "AutoTx Diagnostics",
Layout = @"${time} [${level}] ${message}",
};
logConfig.AddTarget(logTargetConsole);
var logRuleConsole = new LoggingRule("*", loglevel, logTargetConsole);
logConfig.LoggingRules.Add(logRuleConsole);
LogManager.Configuration = logConfig;
// set the default performance monitors:
var perfMonitors = new[] { "CPU", "PhysicalDisk" };
// if requested explicitly as a command line parameter, override them:
if (args.Length > 1)
{
perfMonitors = args[1].Split(',');
}
var commonAssembly = Assembly.GetAssembly(typeof(Cpu));
var commonVersionInfo = FileVersionInfo.GetVersionInfo(commonAssembly.Location);
Log.Info("ATxCommon library version: {0}", commonVersionInfo.ProductVersion);
Log.Debug("Free space on drive [C:]: " + Conv.BytesToString(SystemChecks.GetFreeDriveSpace("C:")));
if (perfMonitors.Contains("CPU"))
{
Log.Info("Watching CPU load using ATxCommon.Monitoring...");
var cpu = new Cpu {
Interval = 250,
Limit = 50,
Probation = 4, // 4 * 250 ms = 1 second
LogPerformanceReadings = LogLevel.Info,
Enabled = true
};
}
if (perfMonitors.Contains("PhysicalDisk"))
{
Log.Info("Watching I/O load using ATxCommon.Monitoring...");
var disk = new PhysicalDisk {
Interval = 250,
Limit = 0.25F,
Probation = 4, // 4 * 250 ms = 1 second
LogPerformanceReadings = LogLevel.Info,
Enabled = true
};
}
while (true)
{
System.Threading.Thread.Sleep(10000);
}
}
public bool FrameAdvance(IController controller, bool render, bool renderSound)
{
_controller = controller;
_lagged = true;
_frame++;
if (!IsGameGear)
{
PSG.Set_Panning(Settings.ForceStereoSeparation ? ForceStereoByte : (byte)0xFF);
}
if (Tracer.Enabled)
{
Cpu.TraceCallback = s => Tracer.Put(s);
}
else
{
Cpu.TraceCallback = null;
}
if (IsGameGear_C == false)
{
Cpu.NonMaskableInterrupt = controller.IsPressed("Pause");
}
else if (!IsGameGear && IsGameGear_C)
{
Cpu.NonMaskableInterrupt = controller.IsPressed("P1 Start");
}
if (IsGame3D && Settings.Fix3D)
{
render = ((Frame & 1) == 0) & render;
}
int scanlinesPerFrame = Vdp.DisplayType == DisplayType.NTSC ? 262 : 313;
Vdp.SpriteLimit = Settings.SpriteLimit;
for (int i = 0; i < scanlinesPerFrame; i++)
{
Vdp.ScanLine = i;
Vdp.RenderCurrentScanline(render);
Vdp.ProcessFrameInterrupt();
Vdp.ProcessLineInterrupt();
ProcessLineControls();
for (int j = 0; j < Vdp.IPeriod; j++)
{
Cpu.ExecuteOne();
PSG.generate_sound();
s_L = PSG.current_sample_L;
s_R = PSG.current_sample_R;
if (s_L != OldSl)
{
BlipL.AddDelta(SampleClock, s_L - OldSl);
OldSl = s_L;
}
if (s_R != OldSr)
{
BlipR.AddDelta(SampleClock, s_R - OldSr);
OldSr = s_R;
}
SampleClock++;
}
if (Vdp.ScanLine == scanlinesPerFrame - 1)
{
Vdp.ProcessGGScreen();
Vdp.ProcessOverscan();
}
}
if (_lagged)
{
_lagCount++;
_isLag = true;
}
else
{
_isLag = false;
}
return(true);
}
private void SyncState(Serializer ser)
{
byte[] core = null;
if (ser.IsWriter)
{
var ms = new MemoryStream();
ms.Close();
core = ms.ToArray();
}
Cpu.SyncState(ser);
ser.BeginSection(nameof(SMS));
Vdp.SyncState(ser);
PSG.SyncState(ser);
ser.Sync("RAM", ref SystemRam, false);
ser.Sync(nameof(RomBank0), ref RomBank0);
ser.Sync(nameof(RomBank1), ref RomBank1);
ser.Sync(nameof(RomBank2), ref RomBank2);
ser.Sync(nameof(RomBank3), ref RomBank3);
ser.Sync(nameof(Bios_bank), ref Bios_bank);
ser.Sync(nameof(Port01), ref Port01);
ser.Sync(nameof(Port02), ref Port02);
ser.Sync(nameof(Port05), ref Port05);
ser.Sync(nameof(Port3E), ref Port3E);
ser.Sync(nameof(Port3F), ref Port3F);
ser.Sync(nameof(Controller1SelectHigh), ref Controller1SelectHigh);
ser.Sync(nameof(Controller2SelectHigh), ref Controller2SelectHigh);
ser.Sync(nameof(LatchLightPhaser), ref LatchLightPhaser);
ser.Sync(nameof(start_pressed), ref start_pressed);
ser.Sync(nameof(cntr_rd_0), ref cntr_rd_0);
ser.Sync(nameof(cntr_rd_1), ref cntr_rd_1);
ser.Sync(nameof(cntr_rd_2), ref cntr_rd_2);
ser.Sync(nameof(stand_alone), ref stand_alone);
ser.Sync(nameof(disablePSG), ref disablePSG);
ser.Sync(nameof(sampleclock), ref sampleclock);
ser.Sync(nameof(old_s_L), ref old_s_L);
ser.Sync(nameof(old_s_R), ref old_s_R);
if (SaveRAM != null)
{
ser.Sync(nameof(SaveRAM), ref SaveRAM, false);
}
ser.Sync(nameof(SaveRamBank), ref SaveRamBank);
if (ExtRam != null)
{
ser.Sync("ExtRAM", ref ExtRam, true);
}
if (HasYM2413)
{
YM2413.SyncState(ser);
}
if (EEPROM != null)
{
EEPROM.SyncState(ser);
}
ser.Sync("Frame", ref _frame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("IsLag", ref _isLag);
ser.EndSection();
if (ser.IsReader)
{
SyncAllByteArrayDomains();
}
}
/// <summary>
/// Checks whether the execution cycle should be stopped for debugging
/// </summary>
/// <param name="options">Execution options</param>
/// <param name="executedInstructionCount">
/// The count of instructions already executed in this cycle
/// </param>
/// <param name="entryStepOutStackDepth">The initial depth of the Step-Out stack</param>
/// <returns>True, if the execution should be stopped</returns>
private bool IsDebugStop(ExecuteCycleOptions options, int executedInstructionCount, int entryStepOutStackDepth)
{
// --- No debug provider, no stop
if (DebugInfoProvider == null)
{
return(false);
}
switch (options.DebugStepMode)
{
// --- In Step-Into mode we always stop when we're about to
// --- execute the next instruction
case DebugStepMode.StepInto:
return(executedInstructionCount > 0);
// --- In Stop-At-Breakpoint mode we stop only if a predefined
// --- breakpoint is reached
case DebugStepMode.StopAtBreakpoint
when DebugInfoProvider.ShouldBreakAtAddress(Cpu.Registers.PC) && (executedInstructionCount > 0 ||
_lastBreakpoint == null ||
_lastBreakpoint != Cpu.Registers.PC):
// --- If we are paused at a breakpoint, we do not want
// --- to pause again and again, unless we step through
_lastBreakpoint = Cpu.Registers.PC;
return(true);
// --- We're in Step-Over mode
case DebugStepMode.StepOver
when DebugInfoProvider.ImminentBreakpoint != null:
{
// --- We also stop, if an imminent breakpoint is reached, and also remove
// --- this breakpoint
if (DebugInfoProvider.ImminentBreakpoint == Cpu.Registers.PC)
{
DebugInfoProvider.ImminentBreakpoint = null;
return(true);
}
break;
}
case DebugStepMode.StepOver:
{
var imminentJustCreated = false;
// --- We check for a CALL-like instruction
var length = Cpu.GetCallInstructionLength();
if (length > 0)
{
// --- Its a CALL-like instruction, create an imminent breakpoint
DebugInfoProvider.ImminentBreakpoint = (ushort)(Cpu.Registers.PC + length);
imminentJustCreated = true;
}
// --- We stop, we executed at least one instruction and if there's no imminent
// --- breakpoint or we've just created one
if (executedInstructionCount > 0 &&
(DebugInfoProvider.ImminentBreakpoint == null || imminentJustCreated))
{
return(true);
}
break;
}
// --- We're in Step-Out mode and want to complete the current subroutine call
case DebugStepMode.StepOut
when Cpu.StackDebugSupport.RetExecuted &&
executedInstructionCount > 0 &&
entryStepOutStackDepth == Cpu.StackDebugSupport.StepOutStackDepth + 1:
{
if (Cpu.Registers.PC != Cpu.StackDebugSupport.StepOutAddress)
{
Cpu.StackDebugSupport.ClearStepOutStack();
}
return(true);
}
}
// --- In any other case, we carry on
return(false);
}
public void cpu_OnPH(Cpu cpu)
{
_stackBytes[StackPtr + 1].SignalPH(cpu.Cycles);
OnPH?.Invoke(null);
}
private void WriteMemorySF2(int addr, byte value)
{
if ((addr & 0x1FFC) == 0x1FF0)
{
// Set SF2 pager.
SF2MapperLatch = (byte)(addr & 0x03);
if (SF2UpdateCDLMappings)
{
CDLMappingApplyRange(Cpu.Mappings, "ROM", 0x40, 0x80000, (SF2MapperLatch + 1) * 0x80000);
}
return;
}
if (addr >= 0x1F0000 && addr < 0x1F8000) // write RAM.
{
Ram[addr & 0x1FFF] = value;
}
else if (addr >= 0x1FE000) // hardware page.
{
if (addr < 0x1FE400)
{
VDC1.WriteVDC(addr, value);
}
else if (addr < 0x1FE800)
{
Cpu.PendingCycles--; VCE.WriteVCE(addr, value);
}
else if (addr < 0x1FEC00)
{
IOBuffer = value; PSG.WritePSG((byte)addr, value, Cpu.TotalExecutedCycles);
}
else if (addr == 0x1FEC00)
{
IOBuffer = value; Cpu.WriteTimer(value);
}
else if (addr == 0x1FEC01)
{
IOBuffer = value; Cpu.WriteTimerEnable(value);
}
else if (addr >= 0x1FF000 &&
addr < 0x1FF400)
{
IOBuffer = value; WriteInput(value);
}
else if (addr == 0x1FF402)
{
IOBuffer = value; Cpu.WriteIrqControl(value);
}
else if (addr == 0x1FF403)
{
IOBuffer = value; Cpu.WriteIrqStatus();
}
else
{
Log.Error("MEM", "unhandled hardware write [{0:X6}] : {1:X2}", addr, value);
}
}
else
{
Log.Error("MEM", "UNHANDLED WRITE: {0:X6}:{1:X2}", addr, value);
}
}
public void InterlockedAdd(long value)
{
InterlockedAdd(value, Cpu.GetCurrentCoreId());
}
public void Increment()
{
Increment(Cpu.GetCurrentCoreId());
}
public override void BusWrite(object sender, ushort address, byte value)
{
int linearAddress = 0;
bool isRam = false;
switch (address & 0xC000)
{
case 0x0000:
if (BootMode)
{
return;
}
linearAddress = address & 0x3FFF;
isRam = false;
break;
case 0x4000:
linearAddress = (address & 0x3FFF) | bank4000;
isRam = Bank4000IsRam;
break;
case 0x8000:
if (address < lowerPageAlwaysPresentLimit && memoryMapMode == 0)
{
isRam = true;
linearAddress = (address & 0x3FFF) | 0x4000;
break;
}
linearAddress = (address & 0x3FFF) | bank8000;
isRam = Bank8000IsRam;
break;
case 0xC000:
if (address >= upperPageAlawayPresentLimit && memoryMapMode == 0)
{
isRam = true;
linearAddress = (address & 0x3FFF);
break;
}
linearAddress = (address & 0x3FFF) | bankC000;
isRam = BankC000IsRam;
break;
}
Breakpoint bp = new Breakpoint()
{
Address = (ushort)(linearAddress & 0x3FFF),
IsRam = isRam,
Page = linearAddress >> 14,
Type = MemoryBreakpointType.Write
};
if (haveWriteBps && IsWriteBreakpoint(bp))
{
Cpu.BreakExecution();
}
if (isRam)
{
Ram.WriteByte(sender, linearAddress & 0x3FFFF, value);
}
else
{
if (!FlashWriteEnable)
{
return;
}
int highBits = ((1 << flashType) - 1) << 20;
if ((linearAddress & 0xF00000) == highBits)
{
highBits = linearAddress & 0xFFFFF;
if (highBits >= 0xB0000 && highBits < 0xC000 || highBits >= 0xFC000)
{
return;
}
}
Flash.WriteByte(sender, linearAddress, value);
}
}
public BLDX(Cpu cpu, AddressingModes addressingMode) : base(cpu, addressingMode)
{
}
public void Process(int data)
{
this.Ram.SaveValue(data);
Cpu.SquareNumber();
}
public void Step()
{
//if (State.Memory[0xFF50].GetBit(0)) // Bootrom disabled
//{
// //var nextInstr = Disassembler.DisassembleInstruction(InstructionLookahead.Passive(State));
// //_log[State.Registers.PC.Value] = nextInstr;
// //if (!_logHits.ContainsKey(State.Registers.PC.Value)) _logHits[State.Registers.PC.Value] = 0;
// //_logHits[State.Registers.PC.Value]++;
// _trace.WriteLine(DebugUtils.Trace(State));
// if (State.Registers.PC.Value == 0x00F0)
// {
// _trace.Flush();
// Environment.Exit(0);
// }
//}
if (State.Stopped)
{
// STOP mode is exited when a button is pressed.
// IF bit 4 is set when a button is pressed, so we can use that.
if (State.Memory[0xFF0F].GetBit(4))
{
State.Stopped = false;
}
else
{
return;
}
}
if (State.Halted)
{
_lcdController.Tick();
_timerController.Tick();
ElapsedCycles += 1;
}
else
{
var cycles = Cpu.ExecuteNextInstruction(State);
ElapsedCycles += cycles;
for (var i = 0; i < cycles; i++)
{
_lcdController.Tick();
_timerController.Tick();
}
}
// Handle interrupts
var firedInterrupts = (byte)(State.Memory[0xFF0F] & State.Memory[0xFFFF]);
if (State.InterruptMasterEnable && firedInterrupts != 0)
{
// Save PC
// TODO: push 16 bit values onto the stack in one call
var pc = State.Registers.PC.Value;
State.Stack.Push(pc.GetHigh());
State.Stack.Push(pc.GetLow());
State.InterruptMasterEnable = false;
//_logger.WriteLine($"Servicing interrupt ... {State.Memory[0xFF0F].ToBinaryString()} {State.Memory[0xFFFF].ToBinaryString()} {firedInterrupts.ToBinaryString()} {ElapsedCycles - _c}");
_c = ElapsedCycles;
if (firedInterrupts.GetBit(0)) // VBlank
{
State.Registers.PC.Value = 0x0040;
State.Memory[0xFF0F] = State.Memory[0xFF0F].SetBit(0, false);
}
else if (firedInterrupts.GetBit(1)) // LCD status
{
State.Registers.PC.Value = 0x0048;
State.Memory[0xFF0F] = State.Memory[0xFF0F].SetBit(1, false);
}
else if (firedInterrupts.GetBit(2)) // Timer
{
State.Registers.PC.Value = 0x0050;
State.Memory[0xFF0F] = State.Memory[0xFF0F].SetBit(2, false);
}
else if (firedInterrupts.GetBit(3)) // Serial link
{
State.Registers.PC.Value = 0x0058;
State.Memory[0xFF0F] = State.Memory[0xFF0F].SetBit(3, false);
}
else if (firedInterrupts.GetBit(4)) // Keypad press
{
State.Registers.PC.Value = 0x0060;
State.Memory[0xFF0F] = State.Memory[0xFF0F].SetBit(4, false);
}
}
// HALT mode is always exited regardless of the state of the IME
if (firedInterrupts != 0)
{
State.Halted = false;
}
}
public static void QueryDevices(IMessageNotifier messageNotifier)
{
MessageNotifier = messageNotifier;
// #0 get video controllers, used for cross checking
WindowsDisplayAdapters.QueryVideoControllers();
// Order important CPU Query must be first
// #1 CPU
Cpu.QueryCpus();
// #2 CUDA
if (Nvidia.IsSkipNvidia())
{
Helpers.ConsolePrint(Tag, "Skipping NVIDIA device detection, settings are set to disabled");
}
else
{
ShowMessageAndStep(International.GetText("Compute_Device_Query_Manager_CUDA_Query"));
Nvidia.QueryCudaDevices();
}
// OpenCL and AMD
if (ConfigManager.GeneralConfig.DeviceDetection.DisableDetectionAMD)
{
Helpers.ConsolePrint(Tag, "Skipping AMD device detection, settings set to disabled");
ShowMessageAndStep(International.GetText("Compute_Device_Query_Manager_AMD_Query_Skip"));
}
else
{
// #3 OpenCL
ShowMessageAndStep(International.GetText("Compute_Device_Query_Manager_OpenCL_Query"));
OpenCL.QueryOpenCLDevices();
// #4 AMD query AMD from OpenCL devices, get serial and add devices
ShowMessageAndStep(International.GetText("Compute_Device_Query_Manager_AMD_Query"));
var amd = new AmdQuery(AvaliableVideoControllers);
AmdDevices = amd.QueryAmd(_isOpenCLQuerySuccess, _openCLJsonData);
}
// #5 uncheck CPU if GPUs present, call it after we Query all devices
Group.UncheckedCpu();
// TODO update this to report undetected hardware
// #6 check NVIDIA, AMD devices count
var nvidiaCount = 0;
{
var amdCount = 0;
foreach (var vidCtrl in AvaliableVideoControllers)
{
if (vidCtrl.Name.ToLower().Contains("nvidia") && CudaUnsupported.IsSupported(vidCtrl.Name))
{
nvidiaCount += 1;
}
else if (vidCtrl.Name.ToLower().Contains("nvidia"))
{
Helpers.ConsolePrint(Tag,
"Device not supported NVIDIA/CUDA device not supported " + vidCtrl.Name);
}
amdCount += (vidCtrl.Name.ToLower().Contains("amd")) ? 1 : 0;
}
Helpers.ConsolePrint(Tag,
nvidiaCount == _cudaDevices.Count
? "Cuda NVIDIA/CUDA device count GOOD"
: "Cuda NVIDIA/CUDA device count BAD!!!");
Helpers.ConsolePrint(Tag,
amdCount == AmdDevices.Count ? "AMD GPU device count GOOD" : "AMD GPU device count BAD!!!");
}
// allerts
_currentNvidiaSmiDriver = GetNvidiaSmiDriver();
// if we have nvidia cards but no CUDA devices tell the user to upgrade driver
var isNvidiaErrorShown = false; // to prevent showing twice
var showWarning = ConfigManager.GeneralConfig.ShowDriverVersionWarning &&
WindowsDisplayAdapters.HasNvidiaVideoController();
if (showWarning && _cudaDevices.Count != nvidiaCount &&
_currentNvidiaSmiDriver.IsLesserVersionThan(NvidiaMinDetectionDriver))
{
isNvidiaErrorShown = true;
var minDriver = NvidiaMinDetectionDriver.ToString();
var recomendDrvier = NvidiaRecomendedDriver.ToString();
MessageBox.Show(string.Format(
International.GetText("Compute_Device_Query_Manager_NVIDIA_Driver_Detection"),
minDriver, recomendDrvier),
International.GetText("Compute_Device_Query_Manager_NVIDIA_RecomendedDriver_Title"),
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
// recomended driver
if (showWarning && _currentNvidiaSmiDriver.IsLesserVersionThan(NvidiaRecomendedDriver) &&
!isNvidiaErrorShown && _currentNvidiaSmiDriver.LeftPart > -1)
{
var recomendDrvier = NvidiaRecomendedDriver.ToString();
var nvdriverString = _currentNvidiaSmiDriver.LeftPart > -1
? string.Format(
International.GetText("Compute_Device_Query_Manager_NVIDIA_Driver_Recomended_PART"),
_currentNvidiaSmiDriver)
: "";
MessageBox.Show(string.Format(
International.GetText("Compute_Device_Query_Manager_NVIDIA_Driver_Recomended"),
recomendDrvier, nvdriverString, recomendDrvier),
International.GetText("Compute_Device_Query_Manager_NVIDIA_RecomendedDriver_Title"),
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
// no devices found
if (Available.Devices.Count <= 0)
{
var result = MessageBox.Show(International.GetText("Compute_Device_Query_Manager_No_Devices"),
International.GetText("Compute_Device_Query_Manager_No_Devices_Title"),
MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
if (result == DialogResult.OK)
{
Process.Start(Links.NhmNoDevHelp);
}
}
// create AMD bus ordering for Claymore
var amdDevices = Available.Devices.FindAll((a) => a.DeviceType == DeviceType.AMD);
amdDevices.Sort((a, b) => a.BusID.CompareTo(b.BusID));
for (var i = 0; i < amdDevices.Count; i++)
{
amdDevices[i].IDByBus = i;
}
//create NV bus ordering for Claymore
var nvDevices = Available.Devices.FindAll((a) => a.DeviceType == DeviceType.NVIDIA);
nvDevices.Sort((a, b) => a.BusID.CompareTo(b.BusID));
for (var i = 0; i < nvDevices.Count; i++)
{
nvDevices[i].IDByBus = i;
}
// get GPUs RAM sum
// bytes
Available.NvidiaRamSum = 0;
Available.AmdRamSum = 0;
foreach (var dev in Available.Devices)
{
if (dev.DeviceType == DeviceType.NVIDIA)
{
Available.NvidiaRamSum += dev.GpuRam;
}
else if (dev.DeviceType == DeviceType.AMD)
{
Available.AmdRamSum += dev.GpuRam;
}
}
// Make gpu ram needed not larger than 4GB per GPU
var totalGpuRam = Math.Min((Available.NvidiaRamSum + Available.AmdRamSum) * 0.6 / 1024,
(double)Available.AvailGpUs * 4 * 1024 * 1024);
double totalSysRam = SystemSpecs.FreePhysicalMemory + SystemSpecs.FreeVirtualMemory;
// check
if (ConfigManager.GeneralConfig.ShowDriverVersionWarning && totalSysRam < totalGpuRam)
{
Helpers.ConsolePrint(Tag, "virtual memory size BAD");
MessageBox.Show(International.GetText("VirtualMemorySize_BAD"),
International.GetText("Warning_with_Exclamation"),
MessageBoxButtons.OK);
}
else
{
Helpers.ConsolePrint(Tag, "virtual memory size GOOD");
}
// #x remove reference
MessageNotifier = null;
}
public T?Rent()
{
return(Rent(Cpu.GetCurrentCoreId()));
}
void CpuExecutionThread()
{
Debug.Log("CPU is waiting for hardware to become ready");
while (!mem.isReady)
{
Thread.Sleep(10);
}
while (!screen.isReady)
{
Thread.Sleep(10);
}
Debug.Log("CPU started");
Cpu.Reset();
dasm = Cpu.Disassemble(Cpu.Registers.PC);
Cpu.ExecutionInfo ei;
int cycles;
while (!stopped)
{
if (triggerReset)
{
triggerReset = false;
mem.LoadRom();
Cpu.Reset();
}
if (stepMode)
{
if (!nextStep)
{
Thread.Sleep(10);
continue;
}
else
{
nextStep = false;
cycles = Cpu.ExecuteSingle();
cyclesExecuted += cycles;
dasm = Cpu.Disassemble(Cpu.Registers.PC);
}
}
else
{
ei = Cpu.Execute(cyclesPerExec);
if (ei.cyclesExecuted == 0)
{
stopped = true; // breakpoint probably
}
if (autoAdjustCycles)
{
if (ei.cyclesSlept > 5)
{
cyclesPerExec -= (ei.cyclesSlept - 5) * 1000;
if (cyclesPerExec < 1000)
{
cyclesPerExec = 1000;
}
}
else if (ei.cyclesSlept < 1)
{
cyclesPerExec += 5000;
}
}
cyclesExecuted += ei.cyclesExecuted;
dasm = Cpu.Disassemble(Cpu.Registers.PC);
}
}
Debug.Log("CPU has stopped");
}
public Resource Subtract(JobBatch batch)
{
Cpu.Subtract(batch.Cpu * batch.Size, batch.BeginTime, batch.Duration);
Mem.Subtract(batch.Mem * batch.Size, batch.BeginTime, batch.Duration);
return(this);
}
public void InterlockedDecrement()
{
InterlockedDecrement(Cpu.GetCurrentCoreId());
}
public Resource Add(JobBatch batch)
{
Cpu.Add(batch.Cpu * batch.Size, batch.BeginTime, batch.Duration);
Mem.Add(batch.Mem * batch.Size, batch.BeginTime, batch.Duration);
return(this);
}
private void SyncState(Serializer ser)
{
byte[] core = null;
if (ser.IsWriter)
{
var ms = new MemoryStream();
ms.Close();
core = ms.ToArray();
}
Cpu.SyncState(ser);
ser.BeginSection("SMS");
Vdp.SyncState(ser);
PSG.SyncState(ser);
ser.Sync("RAM", ref SystemRam, false);
ser.Sync("RomBank0", ref RomBank0);
ser.Sync("RomBank1", ref RomBank1);
ser.Sync("RomBank2", ref RomBank2);
ser.Sync("RomBank3", ref RomBank3);
ser.Sync("Bios_bank", ref Bios_bank);
ser.Sync("Port01", ref Port01);
ser.Sync("Port02", ref Port02);
ser.Sync("Port3E", ref Port3E);
ser.Sync("Port3F", ref Port3F);
ser.Sync("Controller1SelectHigh", ref Controller1SelectHigh);
ser.Sync("ControllerSelect2High", ref Controller2SelectHigh);
ser.Sync("LatchLightPhaser", ref LatchLightPhaser);
if (SaveRAM != null)
{
ser.Sync("SaveRAM", ref SaveRAM, false);
}
ser.Sync("SaveRamBank", ref SaveRamBank);
if (ExtRam != null)
{
ser.Sync("ExtRAM", ref ExtRam, true);
}
if (HasYM2413)
{
YM2413.SyncState(ser);
}
if (EEPROM != null)
{
EEPROM.SyncState(ser);
}
ser.Sync("Frame", ref _frame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("IsLag", ref _isLag);
ser.EndSection();
if (ser.IsReader)
{
SyncAllByteArrayDomains();
}
}
internal void Process(int data)
{
Ram.SaveValue(data);
// TODO: Fix it
Cpu.SquareNumber();
}
internal override void Execute(Cpu cpu)
{
cpu.VRegisters[Vx] |= cpu.VRegisters[Vy];
}
public override bool Execute(InstructionData aData, Cpu aCpu)
{
return(false);
}
public void Decrement()
{
Decrement(Cpu.GetCurrentCoreId());
}
/// <summary>
/// The main execution cycle of the Spectrum VM
/// </summary>
/// <param name="token">Cancellation token</param>
/// <param name="options">Execution options</param>
/// <param name="completeOnCpuFrame">The cycle should complete on CPU frame completion</param>
/// <return>True, if the cycle completed; false, if it has been cancelled</return>
public bool ExecuteCycle(CancellationToken token, ExecuteCycleOptions options, bool completeOnCpuFrame = false)
{
ExecuteCycleOptions = options;
ExecutionCompletionReason = ExecutionCompletionReason.None;
LastExecutionStartTact = Cpu.Tacts;
// --- We use this variables to check whether to stop in Debug mode
var executedInstructionCount = -1;
var entryStepOutDepth = Cpu.StackDebugSupport.StepOutStackDepth;
// --- Check if we're just start running the next frame
if (HasFrameCompleted)
{
// --- This counter helps us to calculate where we are in the frame after
// --- each CPU operation cycle
LastFrameStartCpuTick = Cpu.Tacts - Overflow;
// --- Notify devices to start a new frame
OnNewFrame();
LastRenderedUlaTact = Overflow;
HasFrameCompleted = false;
}
// --- The physical frame cycle that goes on while CPU and ULA
// --- processes everything within a physical frame (0.019968 second)
while (!HasFrameCompleted)
{
// --- Check debug mode when a CPU instruction has been entirely executed
if (!Cpu.IsInOpExecution)
{
// --- The next instruction is about to be executed
executedInstructionCount++;
// --- Check for cancellation
if (token.IsCancellationRequested)
{
ExecutionCompletionReason = ExecutionCompletionReason.Cancelled;
return(false);
}
// --- Check for CPU frame completion
if (completeOnCpuFrame && Cpu.Tacts > LastExecutionStartTact + CPU_FRAME)
{
ExecutionCompletionReason = ExecutionCompletionReason.CpuFrameCompleted;
return(true);
}
// --- Check for several termination modes
switch (options.EmulationMode)
{
// --- Check for reaching the termination point
case EmulationMode.UntilExecutionPoint when options.TerminationPoint < 0x4000:
{
// --- ROM & address must match
if (options.TerminationRom == MemoryDevice.GetSelectedRomIndex() &&
options.TerminationPoint == Cpu.Registers.PC)
{
// --- We reached the termination point within ROM
ExecutionCompletionReason = ExecutionCompletionReason.TerminationPointReached;
return(true);
}
break;
}
// --- Check if we reached the termination point within RAM
case EmulationMode.UntilExecutionPoint
when options.TerminationPoint == Cpu.Registers.PC:
ExecutionCompletionReason = ExecutionCompletionReason.TerminationPointReached;
return(true);
// --- Check for a debugging stop point
case EmulationMode.Debugger
when IsDebugStop(options, executedInstructionCount, entryStepOutDepth) &&
DebugConditionSatisfied():
// --- At this point, the cycle should be stopped because of debugging reasons
// --- The screen should be refreshed
ExecutionCompletionReason = ExecutionCompletionReason.BreakpointReached;
return(true);
}
}
// --- Check for interrupt signal generation
InterruptDevice.CheckForInterrupt(CurrentFrameTact);
// --- Run a single Z80 instruction
Cpu.ExecuteCpuCycle();
_lastBreakpoint = null;
// --- Run a rendering cycle according to the current CPU tact count
var lastTact = CurrentFrameTact;
ScreenDevice.RenderScreen(LastRenderedUlaTact + 1, lastTact);
LastRenderedUlaTact = lastTact;
// --- Exit if the CPU is HALTed and the emulation mode specifies so
if (options.EmulationMode == EmulationMode.UntilHalt &&
(Cpu.StateFlags & Z80StateFlags.Halted) != 0)
{
ExecutionCompletionReason = ExecutionCompletionReason.Halted;
return(true);
}
// --- Notify each CPU-bound device that the current operation has been completed
foreach (var device in _cpuBoundDevices)
{
device.OnCpuOperationCompleted();
}
// --- Decide whether this frame has been completed
HasFrameCompleted = !Cpu.IsInOpExecution && CurrentFrameTact >= FrameTacts;
}
// --- A physical frame has just been completed. Take care about screen refresh
FrameCount++;
Overflow = CurrentFrameTact % FrameTacts;
// --- Notify devices that the current frame completed
OnFrameCompleted();
// --- We exit the cycle when the render frame has completed
ExecutionCompletionReason = ExecutionCompletionReason.RenderFrameCompleted;
return(true);
}
public void cpu_OnTXS(Cpu cpu)
{
Debug.Assert(false, "UNHANDLED TXS");
OnTXS.Invoke(null);
}
