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(); } }