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