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);
}
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();
}
}
}
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);
}
}
public void Reset()
{
registers.Reset();
IRQ.Set(false);
SoftwareIRQ.Set(false);
cpu.InnerTimer.Reset();
}
public void PressAndRelease()
{
IRQ.Set();
IRQ.Unset();
OnStateChange(true);
OnStateChange(false);
}
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()
{
base.Reset();
innerTimer.Reset();
IRQ.Set(false);
}
private void Update()
{
if (BitHelper.IsBitSet(control, (byte)ControlBits.InterruptEnable) && BitHelper.IsBitSet(status, (byte)StatusBits.InterruptFlag))
{
IRQ.Set();
}
}
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 UpdateInterrupts()
{
var stopped = eventStopped.Value && interruptEnableStopped.Value;
var rxPointerUpdated = eventRxPointerUpdated.Value && interruptEnableRxPointerUpdated.Value;
var txPointerUpdated = eventTxPointerUpdated.Value && interruptEnableTxPointerUpdated.Value;
IRQ.Set(stopped || rxPointerUpdated || txPointerUpdated);
}
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 status = readyEnabled.Value && readyPending.Value;
status &= enabled;
this.Log(LogLevel.Noisy, "Setting IRQ to {0}", status);
IRQ.Set(status);
}
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 void SignalInterrupt()
{
if (!interruptsEnabled)
{
return;
}
IRQ.Set(true);
IRQ.Set(false);
}
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 override void Reset()
{
base.Reset();
registers.Reset();
IRQ.Set(false);
autoReloadValue = initialLimit;
Limit = initialLimit;
updateInterruptFlag = false;
}
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();
}
}
private void Update()
{
var level = IRQLevel;
if (IRQEnable != 0)
{
IRQ.Set((level & Masks[Priority]) != 0);
FIQ.Set(((Level | SoftLevel) & FIQSelect) != 0);
}
}
private void UpdateInterrupts()
{
// None of these should be set if Module Enabled field is cleared.
IRQ.Set(moduleEnabled.Value && timers.Any((timer) => timer.Interrupt));
for (int channel = 0; channel < ChannelCount; channel++)
{
// For output it doesn't matter whether interrupts are enabled (hence RawInterrupt).
GetTimerOutput(channel).Set(moduleEnabled.Value && timers[channel].RawInterrupt);
}
}
public void Reset()
{
registers.Reset();
activeInterrupts.Clear();
foreach (var irqSource in irqSources)
{
irqSource?.Clear();
}
IRQ.Set(false);
}
public void MoveTo(int x, int y)
{
points[0].X = (ushort)(y);
points[0].Y = (ushort)(x);
if (points[0].Type == PointType.Down)
{
this.DebugLog("Moving the pointer to {0}x{1}", x, y);
EnqueueNewPoint();
IRQ.Set();
}
}
private void MoveToInner(int x, int y)
{
points[0].X = (ushort)(MaxY - y);
points[0].Y = (ushort)(MaxX - x);
//WARNING! X and Y ARE reversed! Intentionaly!
if (points[0].Type == PointType.Down)
{
this.DebugLog("Moving the pointer to {0}x{1}", x, y);
EnqueueNewPoint();
IRQ.Set();
}
}
private void UpdateIRQ()
{
if (InterruptRequestRegister != 0)
{
this.NoisyLog("IRQ is on, val = {0:X},enable={1:X}", InterruptRequestRegister, EnableRequestRegister);
IRQ.Set();
}
else
{
IRQ.Unset();
}
}
private void UpdateInterrupts()
{
if (i2cIntIrqStatus.Value && i2cIntIrqEnabled.Value)
{
i2cIntIrqPending.Value = true;
}
if (txRxDoneIrqStatus && txRxDoneIrqEnabled.Value)
{
txRxDoneIrqPending.Value = true;
}
// this.Log(LogLevel.Noisy, " Setting status: {0}, enabled: {1}, pending: {2}", txRxDoneIrqStatus, txRxDoneIrqEnabled.Value, txRxDoneIrqPending.Value);
IRQ.Set(i2cIntIrqPending.Value || txRxDoneIrqPending.Value);
}
private void UpdateInterrupts()
{
if (this.illegalOpcodeStatus)
{
this.illegalOpcodePending.Value = true;
}
if (this.finishedStatus)
{
this.finishedPending.Value = true;
}
IRQ.Set((this.illegalOpcodePending.Value && this.illegalOpcodeEnabled.Value) ||
(this.finishedPending.Value && this.finishedEnabled.Value));
}
private void UpdateInterrupts()
{
if (this.irqKeyPressedStatus && this.irqKeyPressedEnabled.Value)
{
this.irqKeyPressedPending.Value = true;
}
if (this.irqInjectStatus && this.irqInjectEnabled.Value)
{
this.irqInjectPending.Value = true;
}
IRQ.Set((this.irqKeyPressedPending.Value && this.irqKeyPressedEnabled.Value) ||
(this.irqInjectPending.Value && this.irqInjectEnabled.Value));
}
private void UpdateInterrupts()
{
if ((Interlocked.Read(ref this.tickValue) >= (long)this.msleepTarget) && this.irqEnabled.Value)
{
this.irqPending.Value = true;
}
this.Log(LogLevel.Noisy, "Setting IRQ: {0} because tickValue {1} >= msleepTarget {2} ({3}) and irqEnabled = {4}",
irqPending.Value && this.irqEnabled.Value,
this.tickValue,
this.msleepTarget,
this.tickValue >= (long)this.msleepTarget, this.irqEnabled.Value);
IRQ.Set(this.irqPending.Value && this.irqEnabled.Value);
}
private void UpdateInterrupts()
{
var flag = false;
ipTxWatermarkEmpty.Value = txQueue.EmptyLevel >= txWatermark.Value;
ipRxWatermarkAvailable.Value = rxQueue.FillLevel >= rxWatermark.Value;
flag |= ipCommandDone.Value && ipCommandDoneEnabled.Value;
flag |= ipTxWatermarkEmpty.Value && ipTxWatermarkEmptyEnabled.Value;
flag |= ipRxWatermarkAvailable.Value && ipRxWatermarkAvailableEnabled.Value;
this.Log(LogLevel.Debug, "Setting IRQ flag to {0}", flag);
IRQ.Set(flag);
}
private void ReceiveFrameInner(EthernetFrame frame)
{
lock (sync)
{
this.Log(LogLevel.Noisy, "Received packet len {0}", frame.Bytes.Length);
if ((registers.Control & (1u << 2)) == 0)
{
this.Log(LogLevel.Debug, "Receiver not enabled, dropping frame.");
return;
}
if (!registers.IgnoreFCS && !EthernetFrame.CheckCRC(frame.Bytes))
{
this.Log(LogLevel.Info, "Invalid CRC, packet discarded");
return;
}
bool interrupt = false;
rxBufferDescriptor rxBD = new rxBufferDescriptor(machine.SystemBus);
rxBD.Fetch(registers.RxQueueBaseAddr);
if (!rxBD.Ownership)//if we could write data to this BD
{
interrupt = false;
rxBD.Ownership = true;
rxBD.StartOfFrame = true;
rxBD.EndOfFrame = true;
rxBD.Length = (ushort)frame.Bytes.Length;
machine.SystemBus.WriteBytes(frame.Bytes, rxBD.BufferAddress);
rxBD.WriteBack();
if (rxBD.Wrap)
{
registers.RxQueueBaseAddr = rxBufferBase;
}
else
{
registers.RxQueueBaseAddr += 8;
}
registers.RxStatus |= 1u << 1;
if ((registers.InterruptMask & (1u << 1)) == 0)
{
registers.InterruptStatus |= 1u << 1;
interrupt = true;
}
if (interrupt)
{
IRQ.Set();
}
}
}
}
private void RefreshInterrupt()
{
if (transmitQueueEmptyInterruptEnabled.Value)
{
IRQ.Set();
}
else if (receiveInterruptEnabled.Value)
{
IRQ.Set(receiveQueue.Count > 0);
}
else
{
IRQ.Unset();
}
}
