public override void Reset()
{
portRegisters.Reset();
gpioRegisters.Reset();
interruptManager.Reset();
IRQ.Unset();
}
public void PressAndRelease()
{
IRQ.Set();
IRQ.Unset();
OnStateChange(true);
OnStateChange(false);
}
public void Write(byte[] data)
{
this.DebugLog("Writing {0}.", data.Select(x => x.ToString()).Stringify());
IRQ.Unset();
if (data.Length > 0)
{
switch ((Command)data[0])
{
case Command.VersionInfoLow:
case Command.VersionInfo:
//just set command. Here to prevent default case.
break;
case Command.Reset:
Reset();
break;
case Command.ScanComplete:
IRQ.Unset();
break;
default:
this.Log(LogLevel.Warning, "Unknown write data: {0}.", data.Select(x => x.ToString("X")).Stringify());
break;
}
lastCommand = (Command)data[0];
}
PressAgainIfNeeded();
}
private void Update()
{
if (BitHelper.IsBitSet(control, (byte)ControlBits.InterruptEnable) && BitHelper.IsBitSet(status, (byte)StatusBits.InterruptFlag))
{
IRQ.Set();
}
}
private void HandleLimitReached(int timerId)
{
lock (internalLock)
{
interruptStatus[timerId] = true;
if (!interruptMask[timerId])
{
IRQ.Set();
}
if (operationMode[timerId] == OperationMode.Timer)
{
if (runningMode[timerId] == RunningMode.Free)
{
// i'm not sure if it is correct as the documentation is quite confusing
timers[timerId].Limit = uint.MaxValue;
timers[timerId].ResetValue();
}
}
else
{
var currentLimit = (uint)timers[timerId].Limit;
timers[timerId].Limit = alternativeLoadCount[timerId];
timers[timerId].ResetValue();
alternativeLoadCount[timerId] = currentLimit;
Connections[timerId].Toggle();
}
}
}
public override void Reset()
{
IRQ.Unset();
base.Reset();
lastValue = 0;
lastCompare = 0;
}
public void Reset()
{
registers.Reset();
IRQ.Set(false);
SoftwareIRQ.Set(false);
cpu.InnerTimer.Reset();
}
private void Update()
{
var bestFiqPriority = 3u;
var bestIrqPriority = 8u;
bestFiq = -1;
bestIrq = -1;
for (var i = 0; i < interrupts.Length; i++)
{
if (IsCandidate(i))
{
var type = GetInterruptType(i);
if (type == InterruptType.FIQ)
{
if (priorities[i].Value < bestFiqPriority)
{
bestFiqPriority = priorities[i].Value;
bestFiq = i;
}
}
else
{
if (priorities[i].Value < bestIrqPriority)
{
bestIrqPriority = priorities[i].Value;
bestIrq = i;
}
}
}
}
IRQ.Set(bestIrq != -1);
FIQ.Set(bestFiq != -1);
}
private void DefineRegisters()
{
Registers.ServicesCR.Define(this)
.WithFlag(0, out controlRequest)
.WithTag("CONTROL_BUSY", 1, 1)
.WithTag("CONTROL_ABORT", 2, 1)
.WithTag("CONTROL_NOTIFY", 3, 1)
.WithReservedBits(4, 12)
.WithValueField(16, 7, out command)
.WithValueField(23, 9, out commandOffset)
.WithWriteCallback((_, __) =>
{
if (!controlRequest.Value)
{
return;
}
HandleRequest((Commands)command.Value, commandOffset.Value);
IRQ.Blink();
})
;
Registers.ServicesSR.Define(this)
.WithTag("STATUS_REQUEST", 0, 1)
.WithTag("STATUS_BUSY", 1, 1)
.WithTag("STATUS_ABORT", 2, 1)
.WithTag("STATUS_NOTIFY", 3, 1)
.WithReservedBits(4, 12)
.WithEnumField <DoubleWordRegister, RequestResult>(16, 16, FieldMode.Read, valueProviderCallback: (_) => status)
;
}
public override void Reset()
{
base.Reset();
innerTimer.Reset();
IRQ.Set(false);
}
private void Update()
{
var interruptId = InterruptLevel.NoInterruptsPending;
if (((interruptEnable & InterruptEnableLevel.ReceiverLineStatus) != 0) && ((lineStatus & LineStatus.InterruptAny) != 0))
{
interruptId = InterruptLevel.ReceiverLineStatusIrq;
}
else if (((interruptEnable & InterruptEnableLevel.ReceiverData) != 0) && ((lineStatus & LineStatus.DataReady) != 0) && (((fifoControl & FifoControl.Enable) == 0) || true /* HACK */ || recvFifo.Count > interruptTriggerLevel))
{
interruptId = InterruptLevel.ReceiverDataIrq;
}
else if (((interruptEnable & InterruptEnableLevel.TransmitterHoldingReg) != 0) && (transmitNotPending != 0))
{
interruptId = InterruptLevel.TransmitterHoldingRegEmpty;
}
else if (((interruptEnable & InterruptEnableLevel.ModemStatus) != 0) && ((modemStatus & ModemStatus.AnyDelta) != 0))
{
interruptId = InterruptLevel.ModemStatusIrq;
}
interruptIdentification = interruptId | (interruptIdentification & (InterruptLevel)0xF0);
if (interruptId != InterruptLevel.NoInterruptsPending)
{
this.NoisyLog("IRQ true");
IRQ.Set(true);
}
else
{
this.NoisyLog("IRQ false");
IRQ.Set(false);
}
}
/// <summary>
/// Initialize serialport
/// </summary>
public static unsafe void Init()
{
comports = new Comport[4];
comports[0] = new Comport();
comports[0].Name = "COM1";
comports[1] = new Comport();
comports[1].Name = "COM2";
comports[2] = new Comport();
comports[2].Name = "COM3";
comports[3] = new Comport();
comports[3].Name = "COM4";
readBda();
initDevice(0);
initDevice(1);
initDevice(2);
initDevice(3);
IRQ.SetHandler(3, Handler24);
IRQ.SetHandler(4, Handler13);
IOApicManager.CreateISARedirection(3, 3);
IOApicManager.CreateISARedirection(4, 4);
}
protected override void Repaint()
{
lock (internalLock)
{
if (Width == 0 || Height == 0)
{
return;
}
for (var i = 0; i < 2; i++)
{
if (layer[i].LayerEnableFlag.Value && layer[i].ColorFrameBufferAddressRegister.Value != 0)
{
machine.SystemBus.ReadBytes(layer[i].ColorFrameBufferAddressRegister.Value, layer[i].LayerBuffer.Length, layer[i].LayerBuffer, 0);
localLayerBuffer[i] = layer[i].LayerBuffer;
}
else
{
localLayerBuffer[i] = layer[i].LayerBackgroundBuffer;
}
}
blender.Blend(localLayerBuffer[0], localLayerBuffer[1], ref buffer, backgroundColor, (byte)layer[0].ConstantAlphaConfigurationRegister.Value, (byte)layer[1].ConstantAlphaConfigurationRegister.Value);
if (lineInterruptEnableFlag.Value)
{
IRQ.Set();
}
}
}
public void Reset()
{
IRQ.Unset();
memoryBuffer = new MemoryRegion[NumberOfPackets];
for (var i = 0; i < memoryBuffer.Length; ++i)
{
memoryBuffer[i] = new MemoryRegion();
}
rxFifo.Clear();
txFifo.Clear();
sentFifo.Clear();
currentBank = Bank.Bank0;
transmitControl = 0x0000;
receiveControl = 0x0000;
configuration = 0xA0B1;
generalPurposeRegister = 0x0000;
control = 0x1210;
packetNumber = 0x00;
allocationResult = 0x0;
pointer = 0x0000;
interruptMask = 0x0;
interruptStatus = TxEmptyInterrupt;
earlyReceive = 0x001f;
Update();
}
public uint ReadDoubleWord(long offset)
{
lock (sync)
{
switch ((Offset)offset)
{
case Offset.NetControl:
return(registers.Control);
case Offset.NetConfig:
return(registers.Config);
case Offset.NetStatus:
return(registers.Status);
case Offset.DMAConfig:
return(registers.DMAConfig);
case Offset.TxStatus:
return(registers.TxStatus);
case Offset.RxQueueBaseAddr:
return(registers.RxQueueBaseAddr);
case Offset.TxQueueBaseAddr:
return(registers.TxQueueBaseAddr);
case Offset.RxStatus:
return(registers.RxStatus);
case Offset.InterruptStatus:
var retval = registers.InterruptStatus;
registers.InterruptStatus = 0;
IRQ.Unset();
return(retval);
case Offset.InterruptMask:
return(registers.InterruptMask);
case Offset.PhyMaintenance:
return(registers.PhyMaintenance);
case Offset.SpecificAddress1Bottom:
//return registers.SpecificAddress1Bottom;
return(BitConverter.ToUInt32(MAC.Bytes, 0));
case Offset.SpecificAddress1Top:
//return registers.SpecificAddress1Top;
return((uint)BitConverter.ToUInt16(MAC.Bytes, 4));
case Offset.ModuleId:
return(registers.ModuleId);
default:
//this.LogUnhandledRead(offset);
return(0);
}
}
}
public void Press(MouseButton button = MouseButton.Left)
{
pressed = true;
points[0].Type = PointType.Down;
this.DebugLog("Button pressed, sending press signal at {0}x{1}.", points[0].X, points[0].Y);
EnqueueNewPoint();
IRQ.Set();
}
private void RefreshIrq()
{
var anyEventPending = (writerEventEnabled.Value && writerEventPending.Value) ||
(readerEventEnabled.Value && readerEventPending.Value);
this.Log(LogLevel.Noisy, "Setting IRQ to: {0}", anyEventPending);
IRQ.Set(anyEventPending);
}
private void UpdateInterrupts()
{
var stopped = eventStopped.Value && interruptEnableStopped.Value;
var rxPointerUpdated = eventRxPointerUpdated.Value && interruptEnableRxPointerUpdated.Value;
var txPointerUpdated = eventTxPointerUpdated.Value && interruptEnableTxPointerUpdated.Value;
IRQ.Set(stopped || rxPointerUpdated || txPointerUpdated);
}
public override void Reset()
{
base.Reset();
registers.Reset();
IRQ.Set(false);
autoReloadValue = initialLimit;
Limit = initialLimit;
updateInterruptFlag = false;
}
public override void Reset()
{
base.Reset();
IRQ.Unset();
internalClock.Reset();
subSecondAlarmCounter = 0;
subSecondsCounter = 0;
}
public void SignalInterrupt()
{
if (!interruptsEnabled)
{
return;
}
IRQ.Set(true);
IRQ.Set(false);
}
private void UpdateInterrupts()
{
var status = readyEnabled.Value && readyPending.Value;
status &= enabled;
this.Log(LogLevel.Noisy, "Setting IRQ to {0}", status);
IRQ.Set(status);
}
public void Release(MouseButton button = MouseButton.Left)
{
this.Log(LogLevel.Noisy, "Sending release signal");
points[0].Type = PointType.Up;
pressed = false;
EnqueueNewPoint();
IRQ.Set();
this.DebugLog("Button released at {0}x{1}.", points[0].X, points[0].Y);
}
public void Reset()
{
registers.Reset();
foreach (var timer in innerTimers)
{
timer.Reset();
}
IRQ.Unset();
}
private void UpdateInterrupts()
{
if (this.irqStatus && this.irqEnabled.Value)
{
this.irqPending.Value = true;
}
this.Log(LogLevel.Noisy, "Setting IRQ: {0}", irqPending.Value);
IRQ.Set(irqPending.Value && irqEnabled.Value);
}
public override void Reset()
{
base.Reset();
dataFifo.Clear();
Array.Clear(channelValues, 0, NUMBER_OF_CHANNELS);
IRQ.Unset();
readDataValue = 0;
}
public void Reset()
{
preProgramMode = false;
registers.Reset();
hvTimer.Reset();
switchState = SwitchState.Off;
Array.Clear(pageLatch, 0, pageLatch.Length);
IRQ.Unset();
}
private void RefreshInterrupts()
{
var irqState = false;
for (int i = 0; i < NumberOfGPIOS; i++)
{
if (!InterruptEnable[i])
{
continue;
}
var isEdge = State[i] != previousState[i];
switch (interruptType[i])
{
case InterruptTrigger.ActiveHigh:
irqState |= (State[i] && !InterruptMask[i]);
break;
case InterruptTrigger.ActiveLow:
irqState |= (!State[i] && !InterruptMask[i]);
break;
case InterruptTrigger.RisingEdge:
if (isEdge && State[i])
{
irqState |= !InterruptMask[i];
activeInterrupts[i] = true;
}
break;
case InterruptTrigger.FallingEdge:
if (isEdge && !State[i])
{
irqState |= !InterruptMask[i];
activeInterrupts[i] = true;
}
break;
case InterruptTrigger.BothEdges:
if (isEdge)
{
irqState |= !InterruptMask[i];
activeInterrupts[i] = true;
}
break;
}
}
Array.Copy(State, previousState, State.Length);
if (irqState)
{
IRQ.Set();
}
else if (!activeInterrupts.Any(x => x))
{
IRQ.Unset();
}
}
public override void Reset()
{
prescaler = 0;
innerTimer.Reset();
reloadValue = initialLimit;
innerTimer.Compare = initialLimit;
interruptEnabled.Value = false;
base.Reset();
IRQ.Unset();
}
private uint AcknowledgeInterrupts()
{
lock (sync)
{
var best = FindBestInterrupt();
acknowledgedInterrupts.Push(best);
IRQ.Unset(); // since we've selected the best interrupt
return((uint)best * 4);
}
}
