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 override void Reset() { base.Reset(); dataFifo.Clear(); Array.Clear(channelValues, 0, NUMBER_OF_CHANNELS); IRQ.Unset(); readDataValue = 0; }
public override void Reset() { base.Reset(); IRQ.Unset(); internalClock.Reset(); subSecondAlarmCounter = 0; subSecondsCounter = 0; }
public void Reset() { registers.Reset(); foreach (var timer in innerTimers) { timer.Reset(); } IRQ.Unset(); }
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(); }
public override void Reset() { base.Reset(); IRQ.Unset(); for (var channel = 0; channel < ChannelCount; channel++) { timers[channel].Reset(); GetTimerOutput(channel).Unset(); } }
public override void Reset() { lock (locker) { base.Reset(); irqManager.Reset(); registers.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); } }
public override void Reset() { base.Reset(); foreach (var timer in innerTimers) { timer.Reset(); } IRQ.Unset(); }
public override void Reset() { base.Reset(); RegistersCollection.Reset(); for (var i = 0; i < previousState.Length; i++) { previousState[i] = false; } IRQ.Unset(); }
public override void Reset() { base.Reset(); decoderLeft?.Reset(); decoderRight?.Reset(); sampleThread?.Dispose(); sampleThread = null; inputFileLeft = null; inputFileRight = null; numberOfChannels = 1; IRQ.Unset(); }
override public void Reset() { base.Reset(); registers.Reset(); IRQ.Unset(); readyToReset = false; interruptEnabled = false; for (var i = 0; i < NumberOfRegisters; i++) { requestRegisterEnabled[i] = false; } }
private void UpdateIRQ() { if (InterruptRequestRegister != 0) { this.NoisyLog("IRQ is on, val = {0:X},enable={1:X}", InterruptRequestRegister, EnableRequestRegister); IRQ.Set(); } else { IRQ.Unset(); } }
public override void Reset() { base.Reset(); IRQ.Unset(); decoder?.Reset(); encoder?.FlushBuffer(); sampleRatio = 256; sampleWidth = 8; numberOfChannels = 2; masterFrequency = 4_000_000; samplesPerDoubleWord = 4; }
public override void Reset() { base.Reset(); for (int i = 0; i < NumberOfInternalTimers; i++) { alternativeLoadCount[i] = 0; operationMode[i] = OperationMode.Timer; runningMode[i] = RunningMode.Free; interruptMask[i] = false; interruptStatus[i] = false; timers[i].Reset(); } registers.Reset(); IRQ.Unset(); }
public void Toggle() { if (Pressed) { IRQ.Unset(); Pressed = false; OnStateChange(false); } else { IRQ.Set(); Pressed = true; OnStateChange(true); } }
private void RefreshInterrupt() { if (transmitQueueEmptyInterruptEnabled.Value) { IRQ.Set(); } else if (receiveInterruptEnabled.Value) { IRQ.Set(receiveQueue.Count > 0); } else { IRQ.Unset(); } }
public void WriteChar(byte value) { lock (buffer) { buffer.Enqueue(value); registers.Status &= ~(uint)(0x3fu << 26); registers.Status |= (uint)(((buffer.Count) & 0x3f) << 26) | 0x01u; //data ready and data count if ((registers.Control & 1u << 2) != 0) { IRQ.Set(); IRQ.Unset(); } } }
public uint ReadDoubleWord(long offset) { lock (localLock) { switch ((Register)offset) { case Register.InterruptVectorRegister: if (CurrentIRQ.HasValue) { nestedInterruptStack.Push(Tuple.Create(CurrentIRQ.Value, (int)GetPriority(CurrentIRQ.Value))); BitHelper.SetBit(ref interruptPendingRegister, (byte)CurrentIRQ.Value, true); } uint result; var irq = CalculateCurrentInterrupt(); if (irq.HasValue) { BitHelper.SetBit(ref interruptPendingRegister, (byte)irq.Value, false); // clears the interrupt CurrentIRQ = irq.Value; result = sourceVectorRegisters[irq.Value]; } else { CurrentIRQ = -1; // hack - there is no irq, but spourius irq handler is called result = spouriousInterruptVectorRegister; } IRQ.Unset(); // de-asserts nIRQ to processor return(result); case Register.InterruptStatusRegister: if (CurrentIRQ.HasValue && CurrentIRQ > -1) { return((uint)CurrentIRQ.Value); } else { this.Log(LogLevel.Warning, "Spourious !!! level is: {0}", level[1]); // When there is no interrupt or we have a spourious one return 0 return(0u); } default: this.LogUnhandledRead(offset); return(0u); } } }
public void Reset() { IRQ.Unset(); currentReturnValue = null; lastWriteRegister = 0; for (ushort i = 0; i < touchedPoints.Length; ++i) { touchedPoints[i] = new TouchedPoint { Type = PointType.Reserved, X = 0, Y = 0, Id = i }; } }
public override void Reset() { base.Reset(); IRQ.Unset(); decoderLeft?.Reset(); decoderRight?.Reset(); sampleThread?.Dispose(); sampleThread = null; inputFileLeft = ""; inputFileRight = ""; multiplierL = 1.0; multiplierR = 1.0; numberOfChannels = 2; sampleRatio = 64; clockFrequency = 32000000 / 31; SetSampleFrequency(); }
public override void Reset() { lock (locker) { base.Reset(); IRQ.Unset(); registers.Reset(); for (var i = 0; i < NumberOfPins; ++i) { data[i] = false; directionOutNotIn[i] = false; interruptEnabled[i] = false; interruptRequest[i] = false; edgeSelect[i] = false; interruptConfig[i] = InterruptConfig.Low; } } }
public override void Reset() { lock (internalLock) { base.Reset(); for (int i = 0; i < NumberOfGPIOS; i++) { previousState[i] = false; activeInterrupts[i] = false; PortDataDirection[i] = PinDirection.Input; InterruptEnable[i] = false; InterruptMask[i] = false; interruptType[i] = InterruptTrigger.ActiveLow; } IRQ.Unset(); registers.Reset(); } }
public int GetPendingInterrupt() { lock (sync) { var result = FindPendingInterrupt(); if (result != -1) { interrupts[result] |= IRQState.Active; interrupts[result] &= ~IRQState.Pending; this.NoisyLog("Acknowledged IRQ {0}.", result); activeIrqs.Push(result); IRQ.Unset(); return(result); } this.Log(LogLevel.Warning, "Trying to acknowledge an interrupt, but there is nothing to acknowledge!"); // We should probably handle spurious vector here return(0); } }
private void HandleEndOfInterrupt(int?timerId = null) { lock (internalLock) { if (timerId.HasValue) { interruptStatus[timerId.Value] = false; if (interruptStatus.All(x => !x)) { IRQ.Unset(); } } else { for (int i = 0; i < interruptStatus.Length; i++) { interruptStatus[i] = false; } IRQ.Unset(); } } }
public override void Reset() { lock (locker) { base.Reset(); IRQ.Unset(); registers.Reset(); for (var i = 0; i < numberOfPins; ++i) { interruptRequest[i] = false; interruptEnabled[i] = false; directOutputValue[i] = false; maskedOutputValue[i] = false; directOutputEnabled[i] = false; maskedOutputEnabled[i] = false; interruptEnableRising[i] = false; interruptEnableFalling[i] = false; interruptEnableHigh[i] = false; interruptEnableLow[i] = false; } } }
private void EnqueueNewPoint() { var data = PrepareTouchData(); if (currentRetValue == null) { this.Log(LogLevel.Noisy, "Setting currentRetValue"); currentRetValue = data; readItAlready = false; } else { this.Log(LogLevel.Noisy, "Enqueueing packet"); readQueue.Enqueue(data); if (IRQ.IsSet) { this.Log(LogLevel.Noisy, "Forcing IRQ"); IRQ.Unset(); IRQ.Set(); } } }