mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
Merge branch 'main' of github.com:betrusted-io/xous-core into main
This commit is contained in:
commit
535a090501
12 changed files with 6099 additions and 666 deletions
287
emulation/peripherals/BetrustedSpinor.cs
Normal file
287
emulation/peripherals/BetrustedSpinor.cs
Normal file
|
|
@ -0,0 +1,287 @@
|
|||
//
|
||||
// Copyright (c) 2010-2019 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Antmicro.Renode.Core;
|
||||
using Antmicro.Renode.Core.Structure;
|
||||
using Antmicro.Renode.Core.Structure.Registers;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Peripherals.Bus;
|
||||
using Antmicro.Renode.Utilities;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
[AllowedTranslations(AllowedTranslation.ByteToDoubleWord | AllowedTranslation.WordToDoubleWord)]
|
||||
public class BetrustedSpinor : NullRegistrationPointPeripheralContainer<ISPIPeripheral>, IDoubleWordPeripheral, IKnownSize
|
||||
{
|
||||
public BetrustedSpinor(Machine machine) : base(machine)
|
||||
{
|
||||
// bbHelper = new BitBangHelper(8, loggingParent: this, outputMsbFirst: true);
|
||||
txQueue = new Queue<byte>(256);
|
||||
rxQueue = new Queue<byte>(256);
|
||||
IRQ = new GPIO();
|
||||
|
||||
var registers = new Dictionary<long, DoubleWordRegister>
|
||||
{
|
||||
{(long)Registers.Config, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 5, name: "dummy")
|
||||
},
|
||||
{(long)Registers.DelayConfig, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 5, name: "d")
|
||||
.WithFlag(5, name: "load")
|
||||
},
|
||||
{(long)Registers.DelayStatus, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 5, name: "q")
|
||||
},
|
||||
{(long)Registers.Command, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 32, FieldMode.Write, writeCallback: (_, data) => {
|
||||
var wakeup = BitHelper.IsBitSet(data, 0);
|
||||
var exec_cmd = BitHelper.IsBitSet(data, 1);
|
||||
cmdCode = (byte)BitHelper.GetValue(data, 2, 8);
|
||||
hasArg = BitHelper.IsBitSet(data, 10);
|
||||
dummyCycles = (uint)BitHelper.GetValue(data, 11, 5);
|
||||
dataWords = (uint)BitHelper.GetValue(data, 16, 8);
|
||||
lockReads = BitHelper.IsBitSet(data, 24);
|
||||
|
||||
if (exec_cmd) {
|
||||
// Ensure the device is in OPI mode. This may change due to a system reset.
|
||||
SwitchSpiToOpi();
|
||||
|
||||
this.Log(LogLevel.Noisy, "Executing command! cmdCode: {0:X2} hasArg? {1} ({6:X8}) dummyCycles: {2} dataWords: {3} txFifo.Count: {4} rxFifo.Count: {5}",
|
||||
cmdCode, hasArg, dummyCycles, dataWords, txQueue.Count, rxQueue.Count, cmdArg.Value);
|
||||
if (RegisteredPeripheral == null) {
|
||||
this.Log(LogLevel.Error, "Unable to get SPI chip device!");
|
||||
return;
|
||||
}
|
||||
|
||||
// In OPI mode, send the command, followed by the inverse of the command
|
||||
RegisteredPeripheral.Transmit(cmdCode);
|
||||
RegisteredPeripheral.Transmit((byte)~cmdCode);
|
||||
|
||||
if (dummyCycles == 0) {
|
||||
if (hasArg) {
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 24));
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 16));
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 8));
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 0));
|
||||
}
|
||||
// Is Write
|
||||
for (var i = 0; i < dataWords; i++) {
|
||||
RegisteredPeripheral.Transmit((txQueue.Count > 0) ? txQueue.Dequeue() : (byte)0xff);
|
||||
RegisteredPeripheral.Transmit((txQueue.Count > 0) ? txQueue.Dequeue() : (byte)0xff);
|
||||
}
|
||||
} else {
|
||||
// Is Read
|
||||
|
||||
// Transmit the dummy data
|
||||
for (var i = 0; i < dummyCycles; i++) {
|
||||
if (hasArg && (i == 0)) {
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 24));
|
||||
} else if (hasArg && (i == 1)) {
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 16));
|
||||
} else if (hasArg && (i == 2)) {
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 8));
|
||||
} else if (hasArg && (i == 3)) {
|
||||
RegisteredPeripheral.Transmit((byte)(cmdArg.Value >> 0));
|
||||
} else {
|
||||
RegisteredPeripheral.Transmit(0xff);
|
||||
}
|
||||
}
|
||||
|
||||
// Receive data back, two transmissions per word since it's in
|
||||
// units of 16 bits.
|
||||
for (var i = 0; i < dataWords; i++) {
|
||||
rxQueue.Enqueue((byte)(RegisteredPeripheral.Transmit(0xff)));
|
||||
rxQueue.Enqueue((byte)(RegisteredPeripheral.Transmit(0xff) >> 8));
|
||||
}
|
||||
}
|
||||
|
||||
RegisteredPeripheral.FinishTransmission();
|
||||
}
|
||||
})
|
||||
},
|
||||
{(long)Registers.CmdArg, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 32, out cmdArg, FieldMode.Read | FieldMode.Write, name: "cmd_arg")
|
||||
},
|
||||
{(long)Registers.CmdRbkData, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 32, FieldMode.Read, valueProviderCallback: (_) => HandleRxFifoRead(), name: "cmd_rbk_data")
|
||||
},
|
||||
{(long)Registers.Status, new DoubleWordRegister(this)
|
||||
.WithFlag(0, name: "wip")
|
||||
},
|
||||
{(long)Registers.WData, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 16, FieldMode.Write, writeCallback: (_, data) => HandleTxFifoWrite(data), name: "wdata")
|
||||
},
|
||||
{(long)Registers.EvStatus, new DoubleWordRegister(this)
|
||||
.WithFlag(0, name: "ecc_error")
|
||||
},
|
||||
{(long)Registers.EvPending, new DoubleWordRegister(this)
|
||||
.WithFlag(0, name: "ecc_error")
|
||||
},
|
||||
{(long)Registers.EvEnable, new DoubleWordRegister(this)
|
||||
.WithFlag(0, name: "ecc_error")
|
||||
},
|
||||
{(long)Registers.EccAddress, new DoubleWordRegister(this)
|
||||
.WithValueField(0, 32, name: "ecc_address")
|
||||
},
|
||||
{(long)Registers.EccStatus, new DoubleWordRegister(this)
|
||||
.WithFlag(0, name: "ecc_error")
|
||||
.WithFlag(1, name: "ecc_overflow")
|
||||
},
|
||||
};
|
||||
|
||||
registersCollection = new DoubleWordRegisterCollection(this, registers);
|
||||
Reset();
|
||||
}
|
||||
|
||||
public override void Reset()
|
||||
{
|
||||
registersCollection.Reset();
|
||||
if (RegisteredPeripheral != null) {
|
||||
spiIsInOpiMode = false;
|
||||
RegisteredPeripheral.Reset();
|
||||
}
|
||||
}
|
||||
|
||||
private void HandleTxFifoWrite(uint value)
|
||||
{
|
||||
txQueue.Enqueue((byte)(value));
|
||||
txQueue.Enqueue((byte)(value >> 8));
|
||||
}
|
||||
|
||||
private uint HandleRxFifoRead()
|
||||
{
|
||||
uint ret = 0;
|
||||
if (rxQueue.Count > 0)
|
||||
{
|
||||
ret |= (uint)rxQueue.Dequeue() << 0;
|
||||
}
|
||||
if (rxQueue.Count > 0)
|
||||
{
|
||||
ret |= (uint)rxQueue.Dequeue() << 8;
|
||||
}
|
||||
if (rxQueue.Count > 0)
|
||||
{
|
||||
ret |= (uint)rxQueue.Dequeue() << 16;
|
||||
}
|
||||
if (rxQueue.Count > 0)
|
||||
{
|
||||
ret |= (uint)rxQueue.Dequeue() << 24;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long offset)
|
||||
{
|
||||
return registersCollection.Read(offset);
|
||||
}
|
||||
|
||||
[ConnectionRegionAttribute("xip")]
|
||||
public uint XipReadDoubleWord(long offset)
|
||||
{
|
||||
return (RegisteredPeripheral as IDoubleWordPeripheral)?.ReadDoubleWord(offset) ?? 0;
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long offset, uint value)
|
||||
{
|
||||
registersCollection.Write(offset, value);
|
||||
}
|
||||
|
||||
[ConnectionRegionAttribute("xip")]
|
||||
public void XipWriteDoubleWord(long offset, uint value)
|
||||
{
|
||||
(RegisteredPeripheral as IDoubleWordPeripheral)?.WriteDoubleWord(offset, value);
|
||||
}
|
||||
|
||||
public override void Register(ISPIPeripheral peripheral, NullRegistrationPoint registrationPoint)
|
||||
{
|
||||
peripheral.Reset();
|
||||
base.Register(peripheral, registrationPoint);
|
||||
SwitchSpiToOpi();
|
||||
}
|
||||
|
||||
private void SwitchSpiToOpi()
|
||||
{
|
||||
if (spiIsInOpiMode) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Wake up from deep sleep
|
||||
byte[] wakeup = new byte[] { 0xab };
|
||||
|
||||
// WREN
|
||||
byte[] wren = new byte[] { 0x06 };
|
||||
|
||||
// Set to 8 dummy cycles to run at 84 MHz
|
||||
byte[] dummy_cycles_84 = new byte[6];
|
||||
dummy_cycles_84[0] = 0x72;
|
||||
dummy_cycles_84[1] = 0x00;
|
||||
dummy_cycles_84[2] = 0x00;
|
||||
dummy_cycles_84[3] = 0x03;
|
||||
dummy_cycles_84[4] = 0x00;
|
||||
dummy_cycles_84[5] = 0x05;
|
||||
|
||||
// Switch to DOPI
|
||||
byte[] switch_to_ddr_opi = new byte[6];
|
||||
switch_to_ddr_opi[0] = 0x72;
|
||||
switch_to_ddr_opi[1] = 0x00;
|
||||
switch_to_ddr_opi[2] = 0x00;
|
||||
switch_to_ddr_opi[3] = 0x00;
|
||||
switch_to_ddr_opi[4] = 0x00;
|
||||
switch_to_ddr_opi[5] = 0x02;
|
||||
|
||||
|
||||
TransmitTransaction(wakeup);
|
||||
TransmitTransaction(wren);
|
||||
TransmitTransaction(dummy_cycles_84);
|
||||
TransmitTransaction(wren);
|
||||
TransmitTransaction(switch_to_ddr_opi);
|
||||
|
||||
spiIsInOpiMode = true;
|
||||
}
|
||||
|
||||
private void TransmitTransaction(byte[] sequence) {
|
||||
foreach (var b in sequence) {
|
||||
RegisteredPeripheral.Transmit(b);
|
||||
}
|
||||
RegisteredPeripheral.FinishTransmission();
|
||||
}
|
||||
|
||||
public long Size { get { return 4096; } }
|
||||
public GPIO IRQ { get; private set; }
|
||||
|
||||
private readonly Queue<byte> rxQueue;
|
||||
private readonly Queue<byte> txQueue;
|
||||
|
||||
private readonly DoubleWordRegisterCollection registersCollection;
|
||||
private uint dataWords;
|
||||
private uint dummyCycles;
|
||||
private byte cmdCode;
|
||||
bool spiIsInOpiMode = false;
|
||||
private readonly IValueRegisterField cmdArg;
|
||||
private bool hasArg;
|
||||
private bool lockReads;
|
||||
|
||||
private enum Registers
|
||||
{
|
||||
Config = 0x00,
|
||||
DelayConfig = 0x04,
|
||||
DelayStatus = 0x08,
|
||||
Command = 0x0c,
|
||||
CmdArg = 0x10,
|
||||
CmdRbkData = 0x14,
|
||||
Status = 0x18,
|
||||
WData = 0x1c,
|
||||
EvStatus = 0x20,
|
||||
EvPending = 0x24,
|
||||
EvEnable = 0x28,
|
||||
EccAddress = 0x2c,
|
||||
EccStatus = 0x30,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,519 +0,0 @@
|
|||
//
|
||||
// Copyright (c) 2010-2021 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
using System.Collections.Generic;
|
||||
using Antmicro.Renode.Core;
|
||||
using Antmicro.Renode.Core.Structure;
|
||||
using Antmicro.Renode.Exceptions;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Time;
|
||||
using Antmicro.Renode.Utilities;
|
||||
using Antmicro.Renode.Peripherals.Bus;
|
||||
using Antmicro.Renode.Core.Structure.Registers;
|
||||
using System.Collections.Concurrent;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
public interface IComPeripheral : IPeripheral, IInterestingType
|
||||
{
|
||||
ushort Transmit(ushort data);
|
||||
bool HasData();
|
||||
void FinishTransmission();
|
||||
}
|
||||
public interface IComController : IPeripheral, IInterestingType, IGPIOReceiver
|
||||
{
|
||||
ushort Transmit(ushort data);
|
||||
void FinishTransmission();
|
||||
}
|
||||
public static class ComConnectorExtensions
|
||||
{
|
||||
public static void CreateComConnector(this Emulation emulation, string name)
|
||||
{
|
||||
emulation.ExternalsManager.AddExternal(new BetrustedComConnector(), name);
|
||||
}
|
||||
}
|
||||
|
||||
// This class is responsible for synchronizing communication between the EC and SoC.
|
||||
// Note that the "Controller" is the SoC side and the "Peripheral" is the EC side.
|
||||
public class BetrustedComConnector : IExternal, IComController, IConnectable<IComPeripheral>, IConnectable<NullRegistrationPointPeripheralContainer<IComController>>, IGPIOReceiver
|
||||
{
|
||||
public BetrustedComConnector()
|
||||
{
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
}
|
||||
|
||||
public void AttachTo(NullRegistrationPointPeripheralContainer<IComController> controller)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (controller == this.controller)
|
||||
{
|
||||
throw new RecoverableException("Cannot attach to the provided peripheral as it is already registered in this connector.");
|
||||
}
|
||||
else if (this.controller != null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Overwriting controller connection.");
|
||||
}
|
||||
|
||||
this.controller?.Unregister(this);
|
||||
this.controller = controller;
|
||||
this.controller.Register(this, NullRegistrationPoint.Instance);
|
||||
foreach (var gpio in controller.GetGPIOs())
|
||||
{
|
||||
if (gpio.Item1 == "HOLD")
|
||||
{
|
||||
this.holdGpio = gpio.Item2;
|
||||
}
|
||||
if (gpio.Item1 == "INTERRUPT")
|
||||
{
|
||||
this.interruptGpio = gpio.Item2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void AttachTo(IComPeripheral peripheral)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (peripheral == this.peripheral)
|
||||
{
|
||||
throw new RecoverableException("Cannot attach to the provided peripheral as it is already registered in this connector.");
|
||||
}
|
||||
else if (this.peripheral != null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Overwriting peripheral connection.");
|
||||
}
|
||||
this.peripheral = peripheral;
|
||||
foreach (var gpio in peripheral.GetGPIOs())
|
||||
{
|
||||
if (gpio.Item1 == "Hold")
|
||||
{
|
||||
gpio.Item2.Connect(this, 0);
|
||||
}
|
||||
else if (gpio.Item1 == "Interrupt")
|
||||
{
|
||||
gpio.Item2.Connect(this, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void DetachFrom(NullRegistrationPointPeripheralContainer<IComController> controller)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (controller == this.controller)
|
||||
{
|
||||
this.controller.Unregister(this);
|
||||
this.controller = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new RecoverableException("Cannot detach from the provided controller as it is not registered in this connector.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void DetachFrom(IComPeripheral peripheral)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (peripheral == this.peripheral)
|
||||
{
|
||||
foreach (var gpio in peripheral.GetGPIOs())
|
||||
{
|
||||
if (gpio.Item1 == "Hold")
|
||||
{
|
||||
gpio.Item2.Disconnect();
|
||||
}
|
||||
else if (gpio.Item1 == "Interrupt")
|
||||
{
|
||||
gpio.Item2.Disconnect();
|
||||
}
|
||||
}
|
||||
peripheral = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new RecoverableException("Cannot detach from the provided peripheral as it is not registered in this connector.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void OnGPIO(int number, bool value)
|
||||
{
|
||||
if (number == 0)
|
||||
{
|
||||
// "Hold" pin
|
||||
if (holdGpio != null)
|
||||
{
|
||||
// controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, new TimeStamp(default(TimeInterval), EmulationManager.ExternalWorld));
|
||||
controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, false);
|
||||
}
|
||||
}
|
||||
else if (number == 1)
|
||||
{
|
||||
// "Interrupt" pin
|
||||
if (interruptGpio != null)
|
||||
{
|
||||
// controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, new TimeStamp(default(TimeInterval), EmulationManager.ExternalWorld));
|
||||
controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public ushort Transmit(ushort data)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (peripheral == null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Controller sent data (0x{0:X}), but peripheral is not connected.", data);
|
||||
return 0xDDDD;
|
||||
}
|
||||
// We don't use a separate time domain here because the peripheral's output is buffered and we
|
||||
// want it to operate at the same speed as the host. If we used a separate time domain then there would
|
||||
// be gaps in the buffer, whereas the real hardware will have no gaps.
|
||||
ushort result = peripheral.Transmit(data);
|
||||
|
||||
// Update the hold GPIO in this same domain. It may get updated slightly in the future
|
||||
// by the `OnGPIO` call above, but update it in this cycle to avoid latency issues.
|
||||
if (holdGpio != null)
|
||||
{
|
||||
holdGpio.Set(!peripheral.HasData());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
public void FinishTransmission()
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
peripheral.GetMachine().HandleTimeDomainEvent<object>(_ => peripheral.FinishTransmission(), null, TimeDomainsManager.Instance.VirtualTimeStamp);
|
||||
}
|
||||
}
|
||||
|
||||
private NullRegistrationPointPeripheralContainer<IComController> controller;
|
||||
private IComPeripheral peripheral;
|
||||
private IGPIO holdGpio;
|
||||
private IGPIO interruptGpio;
|
||||
private readonly object locker = new object();
|
||||
}
|
||||
|
||||
public class BetrustedEcRam : IDoubleWordPeripheral, IKnownSize
|
||||
{
|
||||
public BetrustedEcRam(Machine machine, BetrustedEcCom spi, long size)
|
||||
{
|
||||
this.machine = machine;
|
||||
this.spi = spi;
|
||||
this.size = size;
|
||||
// Hardware defaults to 1280 entries
|
||||
readFifo = new ConcurrentQueue<uint>();
|
||||
writeFifo = new ConcurrentQueue<uint>();
|
||||
}
|
||||
|
||||
private Machine machine;
|
||||
private BetrustedEcCom spi;
|
||||
private long size;
|
||||
private ConcurrentQueue<uint> readFifo;
|
||||
private ConcurrentQueue<uint> writeFifo;
|
||||
public long Size { get { return size; } }
|
||||
|
||||
public bool WriteNextWord(uint value)
|
||||
{
|
||||
readFifo.Enqueue(value);
|
||||
return true;
|
||||
}
|
||||
|
||||
public bool ReadFifoHasData()
|
||||
{
|
||||
return !readFifo.IsEmpty;
|
||||
}
|
||||
|
||||
public int ReadFifoCount()
|
||||
{
|
||||
return readFifo.Count;
|
||||
}
|
||||
|
||||
public bool GetNextWord(out uint value)
|
||||
{
|
||||
bool have_data = writeFifo.TryDequeue(out value);
|
||||
return have_data;
|
||||
}
|
||||
|
||||
public int WriteFifoCount()
|
||||
{
|
||||
return writeFifo.Count;
|
||||
}
|
||||
|
||||
public bool WriteFifoHasData()
|
||||
{
|
||||
return !writeFifo.IsEmpty;
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long address, uint value)
|
||||
{
|
||||
if (address == 0)
|
||||
{
|
||||
// machine.Log(LogLevel.Error, "EC queueing word: {0:X4}", value);
|
||||
writeFifo.Enqueue(value);
|
||||
spi.Hold.Set(false);
|
||||
return;
|
||||
}
|
||||
machine.Log(LogLevel.Error, "Write to unsupported address: {}", address);
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long address)
|
||||
{
|
||||
uint ret = 0;
|
||||
if ((address == 0) && readFifo.TryDequeue(out ret))
|
||||
{
|
||||
// machine.Log(LogLevel.Error, "EC received word: {0:X4}", ret);
|
||||
}
|
||||
else
|
||||
{
|
||||
// machine.Log(LogLevel.Error, "Read double word, but have no data");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
readFifo = new ConcurrentQueue<uint>();
|
||||
writeFifo = new ConcurrentQueue<uint>();
|
||||
}
|
||||
}
|
||||
|
||||
public class BetrustedEcCom : IComPeripheral, IDoubleWordPeripheral, IKnownSize, IProvidesRegisterCollection<DoubleWordRegisterCollection>, IGPIOSender
|
||||
{
|
||||
|
||||
public BetrustedEcCom(Machine machine, uint memAddr, uint memSize)
|
||||
{
|
||||
Hold = new GPIO();
|
||||
Interrupt = new GPIO();
|
||||
EcRam = new BetrustedEcRam(machine, this, memSize);
|
||||
machine.SystemBus.Register(EcRam, new BusRangeRegistration(memAddr, memSize));
|
||||
|
||||
RegistersCollection = new DoubleWordRegisterCollection(this);
|
||||
Registers.ComControl.Define32(this)
|
||||
.WithFlag(0, FieldMode.Write, name: "CLRERR")
|
||||
.WithFlag(1, FieldMode.Write, writeCallback: (_, val) => Interrupt.Set(val), name: "HOST_INT")
|
||||
.WithFlag(2, FieldMode.Write, writeCallback: (_, val) =>
|
||||
{
|
||||
if (!val)
|
||||
return;
|
||||
machine.Log(LogLevel.Debug, "Resetting FIFO due to RESET bit being set");
|
||||
Reset();
|
||||
}, name: "RESET")
|
||||
;
|
||||
|
||||
Registers.ComStatus.Define32(this)
|
||||
.WithFlag(0, FieldMode.Read, valueProviderCallback: (_) => false, name: "TIP")
|
||||
.WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => EcRam.ReadFifoHasData(), name: "RX_AVAIL")
|
||||
.WithFlag(2, FieldMode.Read, valueProviderCallback: (_) => EcRam.ReadFifoCount() >= 1280, name: "RX_OVER")
|
||||
.WithFlag(3, FieldMode.Read, valueProviderCallback: (_) => EcRam.ReadFifoCount() == 0, name: "RX_UNDER")
|
||||
.WithValueField(4, 12, FieldMode.Read, valueProviderCallback: (_) => (uint)EcRam.ReadFifoCount(), name: "RX_LEVEL")
|
||||
.WithFlag(16, FieldMode.Read, valueProviderCallback: (_) => EcRam.WriteFifoHasData(), name: "TX_AVAIL")
|
||||
.WithFlag(17, FieldMode.Read, valueProviderCallback: (_) => EcRam.WriteFifoCount() == 0, name: "TX_EMPTY")
|
||||
.WithValueField(18, 12, FieldMode.Read, valueProviderCallback: (_) => (uint)EcRam.WriteFifoCount(), name: "TX_LEVEL")
|
||||
.WithFlag(30, FieldMode.Read, valueProviderCallback: (_) => EcRam.WriteFifoCount() >= 1280, name: "TX_OVER")
|
||||
.WithFlag(31, FieldMode.Read, valueProviderCallback: (_) => false, name: "TX_UNDER")
|
||||
;
|
||||
Reset();
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long address, uint value)
|
||||
{
|
||||
RegistersCollection.Write(address, value);
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long offset)
|
||||
{
|
||||
return RegistersCollection.Read(offset);
|
||||
}
|
||||
|
||||
public ushort Transmit(ushort value)
|
||||
{
|
||||
uint TxValue;
|
||||
if (!EcRam.GetNextWord(out TxValue))
|
||||
{
|
||||
TxValue = 0xDDDD;
|
||||
}
|
||||
this.Log(LogLevel.Noisy, "EC received:{0:X4} sent:{1:X4}", value, TxValue);
|
||||
Hold.Set(!EcRam.WriteFifoHasData());
|
||||
EcRam.WriteNextWord((ushort)value);
|
||||
// this.Log(LogLevel.Info, "EcRam.ReadFifo now contains {0} items, EcRam.WriteFifo contains {1} items", EcRam.ReadFifoCount(), EcRam.WriteFifoCount());
|
||||
return (ushort)(TxValue & 0xffff);
|
||||
}
|
||||
|
||||
public void FinishTransmission()
|
||||
{
|
||||
// this.Log(LogLevel.Info, "EC finished transmission");
|
||||
}
|
||||
|
||||
public bool HasData()
|
||||
{
|
||||
return EcRam.WriteFifoHasData();
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
EcRam.Reset();
|
||||
Hold.Set(true);
|
||||
}
|
||||
|
||||
public long Size { get { return 0x100; } }
|
||||
private uint TxValue;
|
||||
private BetrustedEcRam EcRam;
|
||||
public GPIO Hold { get; }
|
||||
public GPIO Interrupt { get; }
|
||||
public DoubleWordRegisterCollection RegistersCollection { get; private set; }
|
||||
|
||||
private enum Registers
|
||||
{
|
||||
ComControl = 0x00,
|
||||
|
||||
ComStatus = 0x04,
|
||||
}
|
||||
}
|
||||
|
||||
public class BetrustedSocCom : NullRegistrationPointPeripheralContainer<IComController>, IDoubleWordPeripheral, IProvidesRegisterCollection<DoubleWordRegisterCollection>, IKnownSize
|
||||
{
|
||||
public BetrustedSocCom(Machine machine) : base(machine)
|
||||
{
|
||||
IRQ = new GPIO();
|
||||
HOLD = new GPIO();
|
||||
RegistersCollection = new DoubleWordRegisterCollection(this);
|
||||
|
||||
Registers.ComTx.Define32(this)
|
||||
.WithValueField(0, 16, FieldMode.Write, writeCallback: (_, val) =>
|
||||
{
|
||||
// Skip transaction if HOLD is set
|
||||
// if (AutoHold.Value && (HOLD && HOLD.IsSet)
|
||||
// {
|
||||
// return;
|
||||
// }
|
||||
Rx.Value = (uint)RegisteredPeripheral.Transmit((ushort)val);
|
||||
RegisteredPeripheral.FinishTransmission();
|
||||
machine.Log(LogLevel.Noisy, "SoC sent {0:X4} received {1:X4}", val, Rx.Value);
|
||||
if (IntEna.Value)
|
||||
{
|
||||
SpiIntStatus.Value = true;
|
||||
UpdateInterrupts();
|
||||
SpiIntStatus.Value = false;
|
||||
}
|
||||
}, name: "TX")
|
||||
;
|
||||
|
||||
Registers.ComRx.Define32(this)
|
||||
.WithValueField(0, 16, out Rx, FieldMode.Read, name: "RX")
|
||||
;
|
||||
|
||||
Registers.ComControl.Define32(this)
|
||||
.WithFlag(0, out IntEna, FieldMode.Read | FieldMode.Write, name: "IntEna")
|
||||
.WithFlag(1, out AutoHold, FieldMode.Read | FieldMode.Write, name: "AutoHold")
|
||||
;
|
||||
Registers.ComStatus.Define32(this)
|
||||
.WithFlag(0, out Tip, FieldMode.Read, name: "Tip")
|
||||
.WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => HOLD.IsSet, name: "Hold")
|
||||
;
|
||||
|
||||
Registers.ComEvStatus.Define32(this)
|
||||
.WithFlag(0, out SpiIntStatus, FieldMode.Read, name: "SpiInt")
|
||||
.WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => HOLD.IsSet, name: "SpiHold")
|
||||
;
|
||||
|
||||
Registers.ComEvPending.Define32(this)
|
||||
.WithFlag(0, out SpiIntPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "SpiInt", changeCallback: (_, __) => UpdateInterrupts())
|
||||
.WithFlag(1, out SpiHoldPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "SpiHold", changeCallback: (_, __) => UpdateInterrupts())
|
||||
;
|
||||
|
||||
Registers.ComEvEnable.Define32(this)
|
||||
.WithFlag(0, out SpiIntEnable, name: "SpiInt", changeCallback: (_, __) => UpdateInterrupts())
|
||||
.WithFlag(1, out SpiHoldEnable, name: "SpiHold", changeCallback: (_, __) => UpdateInterrupts())
|
||||
;
|
||||
|
||||
Reset();
|
||||
}
|
||||
|
||||
private void UpdateInterrupts()
|
||||
{
|
||||
// if (RegisteredPeripheral.Interrupt())
|
||||
// {
|
||||
// SpiIntPending.Value = true;
|
||||
// }
|
||||
if (HOLD.IsSet)
|
||||
{
|
||||
SpiHoldPending.Value = true;
|
||||
}
|
||||
IRQ.Set((SpiIntPending.Value && SpiIntEnable.Value)
|
||||
|| (SpiHoldPending.Value && SpiHoldEnable.Value));
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long address, uint value)
|
||||
{
|
||||
RegistersCollection.Write(address, value);
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long offset)
|
||||
{
|
||||
return RegistersCollection.Read(offset);
|
||||
}
|
||||
|
||||
public override void Reset()
|
||||
{
|
||||
// IntEna.Value = false;
|
||||
// AutoHold.Value = false;
|
||||
// Tip.Value = false;
|
||||
// Rx.Value = 0;
|
||||
|
||||
SpiIntStatus.Value = false;
|
||||
SpiIntPending.Value = false;
|
||||
SpiHoldPending.Value = false;
|
||||
SpiIntEnable.Value = false;
|
||||
SpiHoldEnable.Value = false;
|
||||
|
||||
Tip.Value = false;
|
||||
}
|
||||
|
||||
|
||||
public long Size { get { return 0x100; } }
|
||||
|
||||
public GPIO IRQ { get; private set; }
|
||||
public GPIO HOLD { get; private set; }
|
||||
|
||||
private IFlagRegisterField IntEna;
|
||||
private IFlagRegisterField AutoHold;
|
||||
private IFlagRegisterField Tip;
|
||||
private IValueRegisterField Rx;
|
||||
|
||||
// Interrupts
|
||||
private IFlagRegisterField SpiIntStatus;
|
||||
private IFlagRegisterField SpiIntPending;
|
||||
private IFlagRegisterField SpiHoldPending;
|
||||
private IFlagRegisterField SpiIntEnable;
|
||||
private IFlagRegisterField SpiHoldEnable;
|
||||
|
||||
public DoubleWordRegisterCollection RegistersCollection { get; private set; }
|
||||
|
||||
private enum Registers
|
||||
{
|
||||
ComTx = 0x00,
|
||||
|
||||
ComRx = 0x04,
|
||||
ComControl = 0x08,
|
||||
ComStatus = 0x0c,
|
||||
ComEvStatus = 0x10,
|
||||
ComEvPending = 0x14,
|
||||
ComEvEnable = 0x18,
|
||||
}
|
||||
}
|
||||
}
|
||||
210
emulation/peripherals/ComConnector.cs
Normal file
210
emulation/peripherals/ComConnector.cs
Normal file
|
|
@ -0,0 +1,210 @@
|
|||
//
|
||||
// Copyright (c) 2010-2021 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
using System.Collections.Generic;
|
||||
using Antmicro.Renode.Core;
|
||||
using Antmicro.Renode.Core.Structure;
|
||||
using Antmicro.Renode.Exceptions;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Time;
|
||||
using Antmicro.Renode.Utilities;
|
||||
using Antmicro.Renode.Peripherals.Bus;
|
||||
using Antmicro.Renode.Core.Structure.Registers;
|
||||
using System.Collections.Concurrent;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
public interface IComPeripheral : IPeripheral, IInterestingType
|
||||
{
|
||||
ushort Transmit(ushort data);
|
||||
bool HasData();
|
||||
void FinishTransmission();
|
||||
}
|
||||
public interface IComController : IPeripheral, IInterestingType, IGPIOReceiver
|
||||
{
|
||||
ushort Transmit(ushort data);
|
||||
void FinishTransmission();
|
||||
}
|
||||
public static class ComConnectorExtensions
|
||||
{
|
||||
public static void CreateComConnector(this Emulation emulation, string name)
|
||||
{
|
||||
emulation.ExternalsManager.AddExternal(new BetrustedComConnector(), name);
|
||||
}
|
||||
}
|
||||
|
||||
// This class is responsible for synchronizing communication between the EC and SoC.
|
||||
// Note that the "Controller" is the SoC side and the "Peripheral" is the EC side.
|
||||
public class BetrustedComConnector : IExternal, IComController, IConnectable<IComPeripheral>, IConnectable<NullRegistrationPointPeripheralContainer<IComController>>, IGPIOReceiver
|
||||
{
|
||||
public BetrustedComConnector()
|
||||
{
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
}
|
||||
|
||||
public void AttachTo(NullRegistrationPointPeripheralContainer<IComController> controller)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (controller == this.controller)
|
||||
{
|
||||
throw new RecoverableException("Cannot attach to the provided peripheral as it is already registered in this connector.");
|
||||
}
|
||||
else if (this.controller != null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Overwriting controller connection.");
|
||||
}
|
||||
|
||||
this.controller?.Unregister(this);
|
||||
this.controller = controller;
|
||||
this.controller.Register(this, NullRegistrationPoint.Instance);
|
||||
foreach (var gpio in controller.GetGPIOs())
|
||||
{
|
||||
if (gpio.Item1 == "HOLD")
|
||||
{
|
||||
this.holdGpio = gpio.Item2;
|
||||
}
|
||||
if (gpio.Item1 == "INTERRUPT")
|
||||
{
|
||||
this.interruptGpio = gpio.Item2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void AttachTo(IComPeripheral peripheral)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (peripheral == this.peripheral)
|
||||
{
|
||||
throw new RecoverableException("Cannot attach to the provided peripheral as it is already registered in this connector.");
|
||||
}
|
||||
else if (this.peripheral != null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Overwriting peripheral connection.");
|
||||
}
|
||||
this.peripheral = peripheral;
|
||||
foreach (var gpio in peripheral.GetGPIOs())
|
||||
{
|
||||
if (gpio.Item1 == "Hold")
|
||||
{
|
||||
gpio.Item2.Connect(this, 0);
|
||||
}
|
||||
else if (gpio.Item1 == "Interrupt")
|
||||
{
|
||||
gpio.Item2.Connect(this, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void DetachFrom(NullRegistrationPointPeripheralContainer<IComController> controller)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (controller == this.controller)
|
||||
{
|
||||
this.controller.Unregister(this);
|
||||
this.controller = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new RecoverableException("Cannot detach from the provided controller as it is not registered in this connector.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void DetachFrom(IComPeripheral peripheral)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (peripheral == this.peripheral)
|
||||
{
|
||||
foreach (var gpio in peripheral.GetGPIOs())
|
||||
{
|
||||
if (gpio.Item1 == "Hold")
|
||||
{
|
||||
gpio.Item2.Disconnect();
|
||||
}
|
||||
else if (gpio.Item1 == "Interrupt")
|
||||
{
|
||||
gpio.Item2.Disconnect();
|
||||
}
|
||||
}
|
||||
peripheral = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new RecoverableException("Cannot detach from the provided peripheral as it is not registered in this connector.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void OnGPIO(int number, bool value)
|
||||
{
|
||||
if (number == 0)
|
||||
{
|
||||
// "Hold" pin
|
||||
if (holdGpio != null)
|
||||
{
|
||||
// controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, new TimeStamp(default(TimeInterval), EmulationManager.ExternalWorld));
|
||||
controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, false);
|
||||
}
|
||||
}
|
||||
else if (number == 1)
|
||||
{
|
||||
// "Interrupt" pin
|
||||
if (interruptGpio != null)
|
||||
{
|
||||
// controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, new TimeStamp(default(TimeInterval), EmulationManager.ExternalWorld));
|
||||
controller.GetMachine().HandleTimeDomainEvent(holdGpio.Set, value, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public ushort Transmit(ushort data)
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
if (peripheral == null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Controller sent data (0x{0:X}), but peripheral is not connected.", data);
|
||||
return 0xDDDD;
|
||||
}
|
||||
// We don't use a separate time domain here because the peripheral's output is buffered and we
|
||||
// want it to operate at the same speed as the host. If we used a separate time domain then there would
|
||||
// be gaps in the buffer, whereas the real hardware will have no gaps.
|
||||
ushort result = peripheral.Transmit(data);
|
||||
|
||||
// Update the hold GPIO in this same domain. It may get updated slightly in the future
|
||||
// by the `OnGPIO` call above, but update it in this cycle to avoid latency issues.
|
||||
if (holdGpio != null)
|
||||
{
|
||||
holdGpio.Set(!peripheral.HasData());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
public void FinishTransmission()
|
||||
{
|
||||
lock (locker)
|
||||
{
|
||||
peripheral.GetMachine().HandleTimeDomainEvent<object>(_ => peripheral.FinishTransmission(), null, TimeDomainsManager.Instance.VirtualTimeStamp);
|
||||
}
|
||||
}
|
||||
|
||||
private NullRegistrationPointPeripheralContainer<IComController> controller;
|
||||
private IComPeripheral peripheral;
|
||||
private IGPIO holdGpio;
|
||||
private IGPIO interruptGpio;
|
||||
private readonly object locker = new object();
|
||||
}
|
||||
}
|
||||
196
emulation/peripherals/ComEc.cs
Normal file
196
emulation/peripherals/ComEc.cs
Normal file
|
|
@ -0,0 +1,196 @@
|
|||
//
|
||||
// Copyright (c) 2010-2021 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
using System.Collections.Generic;
|
||||
using Antmicro.Renode.Core;
|
||||
using Antmicro.Renode.Core.Structure;
|
||||
using Antmicro.Renode.Exceptions;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Time;
|
||||
using Antmicro.Renode.Utilities;
|
||||
using Antmicro.Renode.Peripherals.Bus;
|
||||
using Antmicro.Renode.Core.Structure.Registers;
|
||||
using System.Collections.Concurrent;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
public class BetrustedEcRam : IDoubleWordPeripheral, IKnownSize
|
||||
{
|
||||
public BetrustedEcRam(Machine machine, BetrustedEcCom spi, long size)
|
||||
{
|
||||
this.machine = machine;
|
||||
this.spi = spi;
|
||||
this.size = size;
|
||||
// Hardware defaults to 1280 entries
|
||||
readFifo = new ConcurrentQueue<uint>();
|
||||
writeFifo = new ConcurrentQueue<uint>();
|
||||
}
|
||||
|
||||
private Machine machine;
|
||||
private BetrustedEcCom spi;
|
||||
private long size;
|
||||
private ConcurrentQueue<uint> readFifo;
|
||||
private ConcurrentQueue<uint> writeFifo;
|
||||
public long Size { get { return size; } }
|
||||
|
||||
public bool WriteNextWord(uint value)
|
||||
{
|
||||
readFifo.Enqueue(value);
|
||||
return true;
|
||||
}
|
||||
|
||||
public bool ReadFifoHasData()
|
||||
{
|
||||
return !readFifo.IsEmpty;
|
||||
}
|
||||
|
||||
public int ReadFifoCount()
|
||||
{
|
||||
return readFifo.Count;
|
||||
}
|
||||
|
||||
public bool GetNextWord(out uint value)
|
||||
{
|
||||
bool have_data = writeFifo.TryDequeue(out value);
|
||||
return have_data;
|
||||
}
|
||||
|
||||
public int WriteFifoCount()
|
||||
{
|
||||
return writeFifo.Count;
|
||||
}
|
||||
|
||||
public bool WriteFifoHasData()
|
||||
{
|
||||
return !writeFifo.IsEmpty;
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long address, uint value)
|
||||
{
|
||||
if (address == 0)
|
||||
{
|
||||
// machine.Log(LogLevel.Error, "EC queueing word: {0:X4}", value);
|
||||
writeFifo.Enqueue(value);
|
||||
spi.Hold.Set(false);
|
||||
return;
|
||||
}
|
||||
machine.Log(LogLevel.Error, "Write to unsupported address: {}", address);
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long address)
|
||||
{
|
||||
uint ret = 0;
|
||||
if ((address == 0) && readFifo.TryDequeue(out ret))
|
||||
{
|
||||
// machine.Log(LogLevel.Error, "EC received word: {0:X4}", ret);
|
||||
}
|
||||
else
|
||||
{
|
||||
// machine.Log(LogLevel.Error, "Read double word, but have no data");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
readFifo = new ConcurrentQueue<uint>();
|
||||
writeFifo = new ConcurrentQueue<uint>();
|
||||
}
|
||||
}
|
||||
|
||||
public class BetrustedEcCom : IComPeripheral, IDoubleWordPeripheral, IKnownSize, IProvidesRegisterCollection<DoubleWordRegisterCollection>, IGPIOSender
|
||||
{
|
||||
|
||||
public BetrustedEcCom(Machine machine, uint memAddr, uint memSize)
|
||||
{
|
||||
Hold = new GPIO();
|
||||
Interrupt = new GPIO();
|
||||
EcRam = new BetrustedEcRam(machine, this, memSize);
|
||||
machine.SystemBus.Register(EcRam, new BusRangeRegistration(memAddr, memSize));
|
||||
|
||||
RegistersCollection = new DoubleWordRegisterCollection(this);
|
||||
Registers.ComControl.Define32(this)
|
||||
.WithFlag(0, FieldMode.Write, name: "CLRERR")
|
||||
.WithFlag(1, FieldMode.Write, writeCallback: (_, val) => Interrupt.Set(val), name: "HOST_INT")
|
||||
.WithFlag(2, FieldMode.Write, writeCallback: (_, val) =>
|
||||
{
|
||||
if (!val)
|
||||
return;
|
||||
machine.Log(LogLevel.Debug, "Resetting FIFO due to RESET bit being set");
|
||||
Reset();
|
||||
}, name: "RESET")
|
||||
;
|
||||
|
||||
Registers.ComStatus.Define32(this)
|
||||
.WithFlag(0, FieldMode.Read, valueProviderCallback: (_) => false, name: "TIP")
|
||||
.WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => EcRam.ReadFifoHasData(), name: "RX_AVAIL")
|
||||
.WithFlag(2, FieldMode.Read, valueProviderCallback: (_) => EcRam.ReadFifoCount() >= 1280, name: "RX_OVER")
|
||||
.WithFlag(3, FieldMode.Read, valueProviderCallback: (_) => EcRam.ReadFifoCount() == 0, name: "RX_UNDER")
|
||||
.WithValueField(4, 12, FieldMode.Read, valueProviderCallback: (_) => (uint)EcRam.ReadFifoCount(), name: "RX_LEVEL")
|
||||
.WithFlag(16, FieldMode.Read, valueProviderCallback: (_) => EcRam.WriteFifoHasData(), name: "TX_AVAIL")
|
||||
.WithFlag(17, FieldMode.Read, valueProviderCallback: (_) => EcRam.WriteFifoCount() == 0, name: "TX_EMPTY")
|
||||
.WithValueField(18, 12, FieldMode.Read, valueProviderCallback: (_) => (uint)EcRam.WriteFifoCount(), name: "TX_LEVEL")
|
||||
.WithFlag(30, FieldMode.Read, valueProviderCallback: (_) => EcRam.WriteFifoCount() >= 1280, name: "TX_OVER")
|
||||
.WithFlag(31, FieldMode.Read, valueProviderCallback: (_) => false, name: "TX_UNDER")
|
||||
;
|
||||
Reset();
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long address, uint value)
|
||||
{
|
||||
RegistersCollection.Write(address, value);
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long offset)
|
||||
{
|
||||
return RegistersCollection.Read(offset);
|
||||
}
|
||||
|
||||
public ushort Transmit(ushort value)
|
||||
{
|
||||
uint TxValue;
|
||||
if (!EcRam.GetNextWord(out TxValue))
|
||||
{
|
||||
TxValue = 0xDDDD;
|
||||
}
|
||||
this.Log(LogLevel.Noisy, "EC received:{0:X4} sent:{1:X4}", value, TxValue);
|
||||
Hold.Set(!EcRam.WriteFifoHasData());
|
||||
EcRam.WriteNextWord((ushort)value);
|
||||
// this.Log(LogLevel.Info, "EcRam.ReadFifo now contains {0} items, EcRam.WriteFifo contains {1} items", EcRam.ReadFifoCount(), EcRam.WriteFifoCount());
|
||||
return (ushort)(TxValue & 0xffff);
|
||||
}
|
||||
|
||||
public void FinishTransmission()
|
||||
{
|
||||
// this.Log(LogLevel.Info, "EC finished transmission");
|
||||
}
|
||||
|
||||
public bool HasData()
|
||||
{
|
||||
return EcRam.WriteFifoHasData();
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
EcRam.Reset();
|
||||
Hold.Set(true);
|
||||
}
|
||||
|
||||
public long Size { get { return 0x100; } }
|
||||
private uint TxValue;
|
||||
private BetrustedEcRam EcRam;
|
||||
public GPIO Hold { get; }
|
||||
public GPIO Interrupt { get; }
|
||||
public DoubleWordRegisterCollection RegistersCollection { get; private set; }
|
||||
|
||||
private enum Registers
|
||||
{
|
||||
ComControl = 0x00,
|
||||
|
||||
ComStatus = 0x04,
|
||||
}
|
||||
}
|
||||
}
|
||||
151
emulation/peripherals/ComSoC.cs
Normal file
151
emulation/peripherals/ComSoC.cs
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
//
|
||||
// Copyright (c) 2010-2021 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
using System.Collections.Generic;
|
||||
using Antmicro.Renode.Core;
|
||||
using Antmicro.Renode.Core.Structure;
|
||||
using Antmicro.Renode.Exceptions;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Time;
|
||||
using Antmicro.Renode.Utilities;
|
||||
using Antmicro.Renode.Peripherals.Bus;
|
||||
using Antmicro.Renode.Core.Structure.Registers;
|
||||
using System.Collections.Concurrent;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
public class BetrustedSocCom : NullRegistrationPointPeripheralContainer<IComController>, IDoubleWordPeripheral, IProvidesRegisterCollection<DoubleWordRegisterCollection>, IKnownSize
|
||||
{
|
||||
public BetrustedSocCom(Machine machine) : base(machine)
|
||||
{
|
||||
IRQ = new GPIO();
|
||||
HOLD = new GPIO();
|
||||
RegistersCollection = new DoubleWordRegisterCollection(this);
|
||||
|
||||
Registers.ComTx.Define32(this)
|
||||
.WithValueField(0, 16, FieldMode.Write, writeCallback: (_, val) =>
|
||||
{
|
||||
// Skip transaction if HOLD is set
|
||||
// if (AutoHold.Value && (HOLD && HOLD.IsSet)
|
||||
// {
|
||||
// return;
|
||||
// }
|
||||
Rx.Value = (uint)RegisteredPeripheral.Transmit((ushort)val);
|
||||
RegisteredPeripheral.FinishTransmission();
|
||||
machine.Log(LogLevel.Noisy, "SoC sent {0:X4} received {1:X4}", val, Rx.Value);
|
||||
if (IntEna.Value)
|
||||
{
|
||||
SpiIntStatus.Value = true;
|
||||
UpdateInterrupts();
|
||||
SpiIntStatus.Value = false;
|
||||
}
|
||||
}, name: "TX")
|
||||
;
|
||||
|
||||
Registers.ComRx.Define32(this)
|
||||
.WithValueField(0, 16, out Rx, FieldMode.Read, name: "RX")
|
||||
;
|
||||
|
||||
Registers.ComControl.Define32(this)
|
||||
.WithFlag(0, out IntEna, FieldMode.Read | FieldMode.Write, name: "IntEna")
|
||||
.WithFlag(1, out AutoHold, FieldMode.Read | FieldMode.Write, name: "AutoHold")
|
||||
;
|
||||
Registers.ComStatus.Define32(this)
|
||||
.WithFlag(0, out Tip, FieldMode.Read, name: "Tip")
|
||||
.WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => HOLD.IsSet, name: "Hold")
|
||||
;
|
||||
|
||||
Registers.ComEvStatus.Define32(this)
|
||||
.WithFlag(0, out SpiIntStatus, FieldMode.Read, name: "SpiInt")
|
||||
.WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => HOLD.IsSet, name: "SpiHold")
|
||||
;
|
||||
|
||||
Registers.ComEvPending.Define32(this)
|
||||
.WithFlag(0, out SpiIntPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "SpiInt", changeCallback: (_, __) => UpdateInterrupts())
|
||||
.WithFlag(1, out SpiHoldPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "SpiHold", changeCallback: (_, __) => UpdateInterrupts())
|
||||
;
|
||||
|
||||
Registers.ComEvEnable.Define32(this)
|
||||
.WithFlag(0, out SpiIntEnable, name: "SpiInt", changeCallback: (_, __) => UpdateInterrupts())
|
||||
.WithFlag(1, out SpiHoldEnable, name: "SpiHold", changeCallback: (_, __) => UpdateInterrupts())
|
||||
;
|
||||
|
||||
Reset();
|
||||
}
|
||||
|
||||
private void UpdateInterrupts()
|
||||
{
|
||||
// if (RegisteredPeripheral.Interrupt())
|
||||
// {
|
||||
// SpiIntPending.Value = true;
|
||||
// }
|
||||
if (HOLD.IsSet)
|
||||
{
|
||||
SpiHoldPending.Value = true;
|
||||
}
|
||||
IRQ.Set((SpiIntPending.Value && SpiIntEnable.Value)
|
||||
|| (SpiHoldPending.Value && SpiHoldEnable.Value));
|
||||
}
|
||||
|
||||
public void WriteDoubleWord(long address, uint value)
|
||||
{
|
||||
RegistersCollection.Write(address, value);
|
||||
}
|
||||
|
||||
public uint ReadDoubleWord(long offset)
|
||||
{
|
||||
return RegistersCollection.Read(offset);
|
||||
}
|
||||
|
||||
public override void Reset()
|
||||
{
|
||||
// IntEna.Value = false;
|
||||
// AutoHold.Value = false;
|
||||
// Tip.Value = false;
|
||||
// Rx.Value = 0;
|
||||
|
||||
SpiIntStatus.Value = false;
|
||||
SpiIntPending.Value = false;
|
||||
SpiHoldPending.Value = false;
|
||||
SpiIntEnable.Value = false;
|
||||
SpiHoldEnable.Value = false;
|
||||
|
||||
Tip.Value = false;
|
||||
}
|
||||
|
||||
|
||||
public long Size { get { return 0x100; } }
|
||||
|
||||
public GPIO IRQ { get; private set; }
|
||||
public GPIO HOLD { get; private set; }
|
||||
|
||||
private IFlagRegisterField IntEna;
|
||||
private IFlagRegisterField AutoHold;
|
||||
private IFlagRegisterField Tip;
|
||||
private IValueRegisterField Rx;
|
||||
|
||||
// Interrupts
|
||||
private IFlagRegisterField SpiIntStatus;
|
||||
private IFlagRegisterField SpiIntPending;
|
||||
private IFlagRegisterField SpiHoldPending;
|
||||
private IFlagRegisterField SpiIntEnable;
|
||||
private IFlagRegisterField SpiHoldEnable;
|
||||
|
||||
public DoubleWordRegisterCollection RegistersCollection { get; private set; }
|
||||
|
||||
private enum Registers
|
||||
{
|
||||
ComTx = 0x00,
|
||||
|
||||
ComRx = 0x04,
|
||||
ComControl = 0x08,
|
||||
ComStatus = 0x0c,
|
||||
ComEvStatus = 0x10,
|
||||
ComEvPending = 0x14,
|
||||
ComEvEnable = 0x18,
|
||||
}
|
||||
}
|
||||
}
|
||||
717
emulation/peripherals/MXIC_MX66UM1G45G.cs
Normal file
717
emulation/peripherals/MXIC_MX66UM1G45G.cs
Normal file
|
|
@ -0,0 +1,717 @@
|
|||
//
|
||||
// Copyright (c) 2010-2022 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
using System;
|
||||
using Antmicro.Renode.Core.Structure.Registers;
|
||||
using Antmicro.Renode.Exceptions;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Peripherals.Memory;
|
||||
using Antmicro.Renode.Peripherals.SPI.NORFlash;
|
||||
using Antmicro.Renode.Utilities;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
public class MXIC_MX66UM1G45G : ISPIPeripheral
|
||||
{
|
||||
public MXIC_MX66UM1G45G(MappedMemory underlyingMemory)
|
||||
{
|
||||
// original MT25Q supports capacity 8MB to 256MB,
|
||||
// but we extended it down to 64KB
|
||||
// to become compatible with N25Q line
|
||||
if (underlyingMemory.Size < 64.KB() || underlyingMemory.Size > 256.MB() || !Misc.IsPowerOfTwo((ulong)underlyingMemory.Size))
|
||||
{
|
||||
throw new ConstructionException("Size of the underlying memory must be a power of 2 value in range 64KB - 256MB");
|
||||
}
|
||||
|
||||
volatileConfigurationRegister = new ByteRegister(this, 0xfb).WithFlag(3, name: "XIP");
|
||||
nonVolatileConfigurationRegister = new WordRegister(this, 0xffff).WithFlag(0, out numberOfAddressBytes, name: "addressWith3Bytes");
|
||||
enhancedVolatileConfigurationRegister = new ByteRegister(this, 0xff)
|
||||
.WithValueField(0, 3, name: "Output driver strength")
|
||||
.WithReservedBits(3, 1)
|
||||
.WithTaggedFlag("Reset/hold", 4)
|
||||
//these flags are intentionally not implemented, as they described physical details
|
||||
.WithFlag(5, name: "Double transfer rate protocol")
|
||||
.WithFlag(6, name: "Dual I/O protocol")
|
||||
.WithFlag(7, name: "Quad I/O protocol");
|
||||
statusRegister = new ByteRegister(this).WithFlag(1, out enable, name: "writeEnableLatch");
|
||||
flagStatusRegister = new ByteRegister(this)
|
||||
.WithFlag(0, FieldMode.Read, valueProviderCallback: _ => numberOfAddressBytes.Value, name: "Addressing")
|
||||
//other bits indicate either protection errors (not implemented) or pending operations (they already finished)
|
||||
.WithReservedBits(3, 1)
|
||||
.WithFlag(7, FieldMode.Read, valueProviderCallback: _ => true, name: "ProgramOrErase");
|
||||
|
||||
this.underlyingMemory = underlyingMemory;
|
||||
underlyingMemory.ResetByte = EmptySegment;
|
||||
|
||||
deviceData = GetDeviceData();
|
||||
}
|
||||
|
||||
public void FinishTransmission()
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "Transmission finished");
|
||||
switch (currentOperation.State)
|
||||
{
|
||||
case DecodedOperation.OperationState.RecognizeOperation:
|
||||
case DecodedOperation.OperationState.AccumulateCommandAddressBytes:
|
||||
case DecodedOperation.OperationState.AccumulateNoDataCommandAddressBytes:
|
||||
this.Log(LogLevel.Warning, "Transmission finished in the unexpected state: {0}", currentOperation.State);
|
||||
break;
|
||||
}
|
||||
// If an operation has at least 1 data byte or more than 0 address bytes,
|
||||
// we can clear the write enable flag only when we are finishing a transmission.
|
||||
switch (currentOperation.Operation)
|
||||
{
|
||||
case DecodedOperation.OperationType.Program:
|
||||
case DecodedOperation.OperationType.Erase:
|
||||
case DecodedOperation.OperationType.WriteRegister:
|
||||
//although the docs are not clear, it seems that all register writes should clear the flag
|
||||
enable.Value = false;
|
||||
break;
|
||||
}
|
||||
currentOperation.State = DecodedOperation.OperationState.RecognizeOperation;
|
||||
currentOperation = default(DecodedOperation);
|
||||
temporaryNonVolatileConfiguration = 0;
|
||||
isFirstOpiByte = true;
|
||||
}
|
||||
|
||||
public void Reset()
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "Resetting SPI flash device. Exiting OPI mode.");
|
||||
opiMode = false;
|
||||
isFirstOpiByte = true;
|
||||
statusRegister.Reset();
|
||||
flagStatusRegister.Reset();
|
||||
volatileConfigurationRegister.Reset();
|
||||
nonVolatileConfigurationRegister.Reset();
|
||||
enhancedVolatileConfigurationRegister.Reset();
|
||||
currentOperation = default(DecodedOperation);
|
||||
FinishTransmission();
|
||||
}
|
||||
|
||||
public byte Transmit(byte data)
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "Received data 0x{0:X}, current state: {1} OPI mode? {2}", data, currentOperation.State, opiMode);
|
||||
// Eat the first byte when running in OPI mode. The second byte should be the inverse of the first byte.
|
||||
if (opiMode)
|
||||
{
|
||||
if (isFirstOpiByte)
|
||||
{
|
||||
isFirstOpiByte = false;
|
||||
firstOpiByte = data;
|
||||
return 0xff;
|
||||
}
|
||||
else if (currentOperation.State == DecodedOperation.OperationState.RecognizeOperation)
|
||||
{
|
||||
if (data != (byte)~firstOpiByte)
|
||||
{
|
||||
this.Log(LogLevel.Error, "Was in OPI mode, but 2nd byte wasn't the inverse of the first byte! (data: {0:X2} first byte: {1:X2}", data, firstOpiByte);
|
||||
}
|
||||
data = firstOpiByte;
|
||||
}
|
||||
}
|
||||
|
||||
switch (currentOperation.State)
|
||||
{
|
||||
case DecodedOperation.OperationState.RecognizeOperation:
|
||||
// When the command is decoded, depending on the operation we will either start accumulating address bytes
|
||||
// or immediately handle the command bytes
|
||||
RecognizeOperation(data);
|
||||
break;
|
||||
case DecodedOperation.OperationState.AccumulateCommandAddressBytes:
|
||||
AccumulateAddressBytes(data, DecodedOperation.OperationState.HandleCommand);
|
||||
break;
|
||||
case DecodedOperation.OperationState.AccumulateNoDataCommandAddressBytes:
|
||||
AccumulateAddressBytes(data, DecodedOperation.OperationState.HandleNoDataCommand);
|
||||
break;
|
||||
case DecodedOperation.OperationState.HandleCommand:
|
||||
// Process the remaining command bytes
|
||||
return HandleCommand(data);
|
||||
}
|
||||
|
||||
// Warning: commands without data require immediate handling after the address was accumulated
|
||||
if (currentOperation.State == DecodedOperation.OperationState.HandleNoDataCommand)
|
||||
{
|
||||
HandleNoDataCommand();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
public MappedMemory UnderlyingMemory => underlyingMemory;
|
||||
|
||||
private void AccumulateAddressBytes(byte addressByte, DecodedOperation.OperationState nextState)
|
||||
{
|
||||
if (currentOperation.TryAccumulateAddress(addressByte))
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "Address accumulated: 0x{0:X}", currentOperation.ExecutionAddress);
|
||||
currentOperation.State = nextState;
|
||||
}
|
||||
}
|
||||
|
||||
private byte[] GetDeviceData()
|
||||
{
|
||||
var data = new byte[4];
|
||||
data[0] = ManufacturerID;
|
||||
data[1] = MemoryType;
|
||||
data[2] = MemoryDensity;
|
||||
data[3] = 0;
|
||||
return data;
|
||||
}
|
||||
|
||||
private void RecognizeOperation(byte firstByte)
|
||||
{
|
||||
currentOperation.Operation = DecodedOperation.OperationType.None;
|
||||
// currentOperation.AddressLength = 0;
|
||||
currentOperation.State = DecodedOperation.OperationState.HandleCommand;
|
||||
switch (firstByte)
|
||||
{
|
||||
case (byte)Commands.ReadID:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.ReadID;
|
||||
if (opiMode)
|
||||
{
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
currentOperation.AddressLength = 4;
|
||||
}
|
||||
break;
|
||||
case (byte)Commands.PageProgram4byte:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.Program;
|
||||
currentOperation.AddressLength = 4;
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
break;
|
||||
case (byte)Commands.WriteEnable:
|
||||
this.Log(LogLevel.Noisy, "Setting write enable latch");
|
||||
currentOperation.Operation = DecodedOperation.OperationType.None;
|
||||
enable.Value = true;
|
||||
return; //return to prevent further logging
|
||||
case (byte)Commands.WriteDisable:
|
||||
this.Log(LogLevel.Noisy, "Unsetting write enable latch");
|
||||
currentOperation.Operation = DecodedOperation.OperationType.None;
|
||||
enable.Value = false;
|
||||
return; //return to prevent further logging
|
||||
|
||||
case (byte)Commands.SubsectorErase4byte4kb:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.Erase;
|
||||
currentOperation.EraseSize = DecodedOperation.OperationEraseSize.Subsector4K;
|
||||
currentOperation.AddressLength = 4;
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateNoDataCommandAddressBytes;
|
||||
break;
|
||||
|
||||
case (byte)Commands.ReadStatusRegister:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.ReadRegister;
|
||||
currentOperation.Register = (uint)Register.Status;
|
||||
if (opiMode)
|
||||
{
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
currentOperation.AddressLength = 4;
|
||||
}
|
||||
break;
|
||||
case (byte)Commands.ReadSecurityRegister:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.ReadRegister;
|
||||
currentOperation.Register = (uint)Register.SecurityRegister;
|
||||
if (opiMode)
|
||||
{
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
currentOperation.AddressLength = 4;
|
||||
}
|
||||
break;
|
||||
case (byte)Commands.WriteStatusRegister:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.WriteRegister;
|
||||
currentOperation.Register = (uint)Register.Status;
|
||||
if (opiMode)
|
||||
{
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
currentOperation.AddressLength = 4;
|
||||
}
|
||||
break;
|
||||
case (byte)Commands.WriteSecurityRegister:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.WriteRegister;
|
||||
currentOperation.Register = (uint)Register.SecurityRegister;
|
||||
if (opiMode)
|
||||
{
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
currentOperation.AddressLength = 4;
|
||||
}
|
||||
break;
|
||||
case (byte)Commands.ReadConfigurationRegister2:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.ReadRegister;
|
||||
currentOperation.Register = (uint)Register.ConfigurationRegister2;
|
||||
currentOperation.AddressLength = 4;
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
break;
|
||||
case (byte)Commands.WriteConfigurationRegister2:
|
||||
currentOperation.Operation = DecodedOperation.OperationType.WriteRegister;
|
||||
currentOperation.Register = (uint)Register.ConfigurationRegister2;
|
||||
currentOperation.AddressLength = 4;
|
||||
currentOperation.State = DecodedOperation.OperationState.AccumulateCommandAddressBytes;
|
||||
break;
|
||||
case (byte)Commands.ReleaseFromDeepPowerdown:
|
||||
return; //return to prevent further logging
|
||||
default:
|
||||
this.Log(LogLevel.Error, "Command decoding failed on byte: 0x{0:X} ({1}).", firstByte, (Commands)firstByte);
|
||||
return;
|
||||
}
|
||||
this.Log(LogLevel.Noisy, "Decoded operation: {0}, write enabled {1}", currentOperation, enable.Value);
|
||||
}
|
||||
|
||||
private byte HandleCommand(byte data)
|
||||
{
|
||||
byte result = 0;
|
||||
switch (currentOperation.Operation)
|
||||
{
|
||||
case DecodedOperation.OperationType.ReadFast:
|
||||
// handle dummy byte and switch to read
|
||||
currentOperation.Operation = DecodedOperation.OperationType.Read;
|
||||
currentOperation.CommandBytesHandled--;
|
||||
this.Log(LogLevel.Noisy, "Handling dummy byte in ReadFast operation");
|
||||
break;
|
||||
case DecodedOperation.OperationType.Read:
|
||||
result = ReadFromMemory();
|
||||
break;
|
||||
case DecodedOperation.OperationType.ReadID:
|
||||
if (currentOperation.CommandBytesHandled < deviceData.Length)
|
||||
{
|
||||
result = deviceData[currentOperation.CommandBytesHandled];
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Log(LogLevel.Error, "Trying to read beyond the length of the device ID table.");
|
||||
result = 0;
|
||||
}
|
||||
break;
|
||||
case DecodedOperation.OperationType.Program:
|
||||
if (enable.Value)
|
||||
{
|
||||
WriteToMemory(data);
|
||||
result = data;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Log(LogLevel.Error, "Memory write operations are disabled.");
|
||||
}
|
||||
break;
|
||||
case DecodedOperation.OperationType.ReadRegister:
|
||||
result = ReadRegister((Register)currentOperation.Register);
|
||||
break;
|
||||
case DecodedOperation.OperationType.WriteRegister:
|
||||
WriteRegister((Register)currentOperation.Register, data);
|
||||
break;
|
||||
case DecodedOperation.OperationType.None:
|
||||
break;
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Unhandled operation encountered while processing command bytes: {0}", currentOperation.Operation);
|
||||
break;
|
||||
}
|
||||
currentOperation.CommandBytesHandled++;
|
||||
this.Log(LogLevel.Noisy, "Handled command: {0}, returning 0x{1:X}", currentOperation, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
private void WriteRegister(Register register, byte data)
|
||||
{
|
||||
if (!enable.Value)
|
||||
{
|
||||
this.Log(LogLevel.Error, "Trying to write a register, but write enable latch is not set");
|
||||
return;
|
||||
}
|
||||
switch (register)
|
||||
{
|
||||
case Register.VolatileConfiguration:
|
||||
volatileConfigurationRegister.Write(0, data);
|
||||
break;
|
||||
case Register.NonVolatileConfiguration:
|
||||
if ((currentOperation.CommandBytesHandled) >= 2)
|
||||
{
|
||||
this.Log(LogLevel.Error, "Trying to write to register {0} with more than expected 2 bytes.", Register.NonVolatileConfiguration);
|
||||
break;
|
||||
}
|
||||
BitHelper.UpdateWithShifted(ref temporaryNonVolatileConfiguration, data, currentOperation.CommandBytesHandled * 8, 8);
|
||||
if (currentOperation.CommandBytesHandled == 1)
|
||||
{
|
||||
nonVolatileConfigurationRegister.Write(0, (ushort)temporaryNonVolatileConfiguration);
|
||||
}
|
||||
break;
|
||||
//listing all cases as other registers are not writable at all
|
||||
case Register.EnhancedVolatileConfiguration:
|
||||
enhancedVolatileConfigurationRegister.Write(0, data);
|
||||
break;
|
||||
case Register.SecurityRegister:
|
||||
return;
|
||||
case Register.ConfigurationRegister2:
|
||||
switch (currentOperation.ExecutionAddress)
|
||||
{
|
||||
case 0x00000000:
|
||||
opiMode = ((data & 3) != 0);
|
||||
if (opiMode)
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "OPI mode enabled");
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Log(LogLevel.Noisy, "OPI mode disabled");
|
||||
}
|
||||
break;
|
||||
case 0x00000200:
|
||||
break;
|
||||
case 0x00000300:
|
||||
break;
|
||||
case 0x00000400:
|
||||
break;
|
||||
case 0x00000500:
|
||||
// CRC chunk size configuration / enabled
|
||||
break;
|
||||
case 0x00000800:
|
||||
case 0x04000800:
|
||||
// ECC fail status
|
||||
break;
|
||||
case 0x00000c00:
|
||||
case 0x04000c00:
|
||||
// ECC fail
|
||||
break;
|
||||
case 0x00000d00:
|
||||
case 0x04000d00:
|
||||
// ECC fail
|
||||
break;
|
||||
case 0x00000e00:
|
||||
case 0x04000e00:
|
||||
// ECC fail
|
||||
break;
|
||||
case 0x00000f00:
|
||||
case 0x04000f00:
|
||||
// ECC fail
|
||||
break;
|
||||
case 0x40000000:
|
||||
// Enable DOPI/SOPI after reset
|
||||
break;
|
||||
case 0x80000000:
|
||||
// CRC error
|
||||
break;
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Unrecognized CR2 address: {0:X8}", currentOperation.ExecutionAddress);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case Register.Status:
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Trying to write 0x{0} to unsupported register \"{1}\"", data, register);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private byte ReadRegister(Register register)
|
||||
{
|
||||
switch (register)
|
||||
{
|
||||
case Register.Status:
|
||||
// The documentation states that at least 1 byte will be read
|
||||
// If more than 1 byte is read, the same byte is returned
|
||||
return statusRegister.Read();
|
||||
case Register.FlagStatus:
|
||||
// The documentation states that at least 1 byte will be read
|
||||
// If more than 1 byte is read, the same byte is returned
|
||||
return flagStatusRegister.Read();
|
||||
case Register.VolatileConfiguration:
|
||||
// The documentation states that at least 1 byte will be read
|
||||
// If more than 1 byte is read, the same byte is returned
|
||||
return volatileConfigurationRegister.Read();
|
||||
case Register.NonVolatileConfiguration:
|
||||
// The documentation states that at least 2 bytes will be read
|
||||
// After all 16 bits of the register have been read, 0 is returned
|
||||
if ((currentOperation.CommandBytesHandled) < 2)
|
||||
{
|
||||
return (byte)BitHelper.GetValue(nonVolatileConfigurationRegister.Read(), currentOperation.CommandBytesHandled * 8, 8);
|
||||
}
|
||||
return 0;
|
||||
case Register.SecurityRegister:
|
||||
return 0;
|
||||
case Register.EnhancedVolatileConfiguration:
|
||||
return enhancedVolatileConfigurationRegister.Read();
|
||||
case Register.ConfigurationRegister2:
|
||||
switch (currentOperation.ExecutionAddress)
|
||||
{
|
||||
case 0x00000000:
|
||||
if (opiMode)
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
case 0x00000200:
|
||||
return 0;
|
||||
case 0x00000300:
|
||||
return 0;
|
||||
case 0x00000400:
|
||||
return 0;
|
||||
case 0x00000500:
|
||||
// CRC chunk size configuration / enabled
|
||||
return 0;
|
||||
case 0x00000800:
|
||||
case 0x04000800:
|
||||
// ECC fail status
|
||||
return 0;
|
||||
case 0x00000c00:
|
||||
case 0x04000c00:
|
||||
// ECC fail
|
||||
return 0;
|
||||
case 0x00000d00:
|
||||
case 0x04000d00:
|
||||
// ECC fail
|
||||
return 0;
|
||||
case 0x00000e00:
|
||||
case 0x04000e00:
|
||||
// ECC fail
|
||||
return 0;
|
||||
case 0x00000f00:
|
||||
case 0x04000f00:
|
||||
// ECC fail
|
||||
return 0;
|
||||
case 0x40000000:
|
||||
// Enable DOPI/SOPI after reset
|
||||
return 0;
|
||||
case 0x80000000:
|
||||
// CRC error
|
||||
return 0;
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Unrecognized CR2 address: {0:X8}", currentOperation.ExecutionAddress);
|
||||
return 0;
|
||||
}
|
||||
case Register.ExtendedAddress:
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Trying to read from unsupported register \"{0}\"", register);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
private void HandleNoDataCommand()
|
||||
{
|
||||
// The documentation describes more commands that don't have any data bytes (just code + address)
|
||||
// but at the moment we have implemented just these ones
|
||||
switch (currentOperation.Operation)
|
||||
{
|
||||
case DecodedOperation.OperationType.Erase:
|
||||
if (enable.Value)
|
||||
{
|
||||
if (currentOperation.ExecutionAddress >= underlyingMemory.Size)
|
||||
{
|
||||
this.Log(LogLevel.Error, "Cannot erase memory because current address 0x{0:X} exceeds configured memory size.", currentOperation.ExecutionAddress);
|
||||
return;
|
||||
}
|
||||
switch (currentOperation.EraseSize)
|
||||
{
|
||||
case DecodedOperation.OperationEraseSize.Sector:
|
||||
EraseSector();
|
||||
break;
|
||||
case DecodedOperation.OperationEraseSize.Subsector4K:
|
||||
EraseSubsector4K();
|
||||
break;
|
||||
case DecodedOperation.OperationEraseSize.Die:
|
||||
EraseDie();
|
||||
break;
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Unsupported erase type: {0}", currentOperation.EraseSize);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Log(LogLevel.Error, "Erase operations are disabled.");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
this.Log(LogLevel.Warning, "Encountered unexpected command: {0}", currentOperation);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void EraseDie()
|
||||
{
|
||||
var position = 0;
|
||||
var segment = new byte[SegmentSize];
|
||||
for (var i = 0; i < SegmentSize; i++)
|
||||
{
|
||||
segment[i] = EmptySegment;
|
||||
}
|
||||
|
||||
while (position < underlyingMemory.Size)
|
||||
{
|
||||
var length = (int)Math.Min(SegmentSize, underlyingMemory.Size - position);
|
||||
|
||||
underlyingMemory.WriteBytes(position, segment, length);
|
||||
position += length;
|
||||
}
|
||||
}
|
||||
|
||||
private void EraseSector()
|
||||
{
|
||||
var segment = new byte[SegmentSize];
|
||||
for (var i = 0; i < SegmentSize; i++)
|
||||
{
|
||||
segment[i] = EmptySegment;
|
||||
}
|
||||
// The documentations states that on erase the operation address is
|
||||
// aligned to the segment size
|
||||
|
||||
var position = SegmentSize * (currentOperation.ExecutionAddress / SegmentSize);
|
||||
underlyingMemory.WriteBytes(position, segment);
|
||||
}
|
||||
|
||||
private void EraseSubsector4K()
|
||||
{
|
||||
var segment = new byte[4.KB()];
|
||||
for (var i = 0; i < 4.KB(); i++)
|
||||
{
|
||||
segment[i] = EmptySegment;
|
||||
}
|
||||
// The documentations states that on erase the operation address is
|
||||
// aligned to the segment size
|
||||
|
||||
var position = 4.KB() * (currentOperation.ExecutionAddress / 4.KB());
|
||||
underlyingMemory.WriteBytes(position, segment);
|
||||
}
|
||||
|
||||
private void WriteToMemory(byte val)
|
||||
{
|
||||
if (currentOperation.ExecutionAddress + currentOperation.CommandBytesHandled > underlyingMemory.Size)
|
||||
{
|
||||
this.Log(LogLevel.Error, "Cannot write to address 0x{0:X} because it is bigger than configured memory size.", currentOperation.ExecutionAddress);
|
||||
return;
|
||||
}
|
||||
|
||||
var position = currentOperation.ExecutionAddress + currentOperation.CommandBytesHandled;
|
||||
underlyingMemory.WriteByte(position, val);
|
||||
}
|
||||
|
||||
private byte ReadFromMemory()
|
||||
{
|
||||
if (currentOperation.ExecutionAddress + currentOperation.CommandBytesHandled > underlyingMemory.Size)
|
||||
{
|
||||
this.Log(LogLevel.Error, "Cannot read from address 0x{0:X} because it is bigger than configured memory size.", currentOperation.ExecutionAddress);
|
||||
return 0;
|
||||
}
|
||||
|
||||
var position = currentOperation.ExecutionAddress + currentOperation.CommandBytesHandled;
|
||||
return underlyingMemory.ReadByte(position);
|
||||
}
|
||||
|
||||
private DecodedOperation currentOperation;
|
||||
private uint temporaryNonVolatileConfiguration; //this should be an ushort, but due to C# type promotions it's easier to use uint
|
||||
|
||||
private readonly byte[] deviceData;
|
||||
private readonly int SegmentSize = 64.KB();
|
||||
private readonly IFlagRegisterField enable;
|
||||
private readonly ByteRegister statusRegister;
|
||||
private readonly ByteRegister flagStatusRegister;
|
||||
private readonly IFlagRegisterField numberOfAddressBytes;
|
||||
private readonly ByteRegister volatileConfigurationRegister;
|
||||
private readonly ByteRegister enhancedVolatileConfigurationRegister;
|
||||
private readonly WordRegister nonVolatileConfigurationRegister;
|
||||
private readonly MappedMemory underlyingMemory;
|
||||
|
||||
private const byte EmptySegment = 0xff;
|
||||
private const byte ManufacturerID = 0xC2;
|
||||
private const byte RemainingIDBytes = 0x10;
|
||||
private const byte MemoryType = 0x80;
|
||||
private const byte MemoryDensity = 0x3B;
|
||||
private const byte DeviceConfiguration = 0x0; // standard
|
||||
private const byte DeviceGeneration = 0x1; // 2nd generation
|
||||
private const byte ExtendedDeviceID = DeviceGeneration << 6;
|
||||
|
||||
private bool opiMode = false;
|
||||
private bool isFirstOpiByte = false;
|
||||
private byte firstOpiByte;
|
||||
|
||||
private enum Commands : byte
|
||||
{
|
||||
// Software RESET Operations
|
||||
ResetEnable = 0x66,
|
||||
ResetMemory = 0x99,
|
||||
|
||||
// READ ID Operations
|
||||
ReadID = 0x9F,
|
||||
ReadSerialFlashDiscoveryParameter = 0x5A,
|
||||
|
||||
// READ MEMORY Operations
|
||||
Read = 0x03,
|
||||
FastRead = 0x0B,
|
||||
|
||||
// READ MEMORY Operations with 4-Byte Address
|
||||
Read4byte = 0x13,
|
||||
FastRead4byte = 0x0C,
|
||||
|
||||
// WRITE Operations
|
||||
WriteEnable = 0x06,
|
||||
WriteDisable = 0x04,
|
||||
|
||||
// READ REGISTER Operations
|
||||
ReadStatusRegister = 0x05,
|
||||
ReadConfigurationRegister2 = 0x71,
|
||||
ReadFastBootRegister = 0x16,
|
||||
|
||||
// WRITE REGISTER Operations
|
||||
WriteStatusRegister = 0x01,
|
||||
WriteConfigurationRegister2 = 0x72,
|
||||
WriteFastBootRegister = 0x17,
|
||||
|
||||
// PROGRAM Operations
|
||||
PageProgram = 0x02,
|
||||
|
||||
// PROGRAM Operations with 4-Byte Address
|
||||
PageProgram4byte = 0x12,
|
||||
|
||||
// ERASE Operations
|
||||
SubsectorErase4kb = 0x20,
|
||||
SectorErase = 0xD8,
|
||||
DieErase = 0x60,
|
||||
EraseFastBootRegister = 0x18,
|
||||
|
||||
// ERASE Operations with 4-Byte Address
|
||||
SectorErase4byte = 0xDC,
|
||||
SubsectorErase4byte4kb = 0x21,
|
||||
SubsectorErase4byte32kb = 0x5C,
|
||||
DieErase4byte = 0xC7,
|
||||
|
||||
// SUSPEND/RESUME Operations
|
||||
ProgramEraseSuspend = 0xB0,
|
||||
ProgramEraseResume = 0x30,
|
||||
|
||||
// ONE-TIME PROGRAMMABLE (OTP) Operations
|
||||
EnterSecuredOtp = 0xB1,
|
||||
ExitSecuredOtp = 0xC1,
|
||||
|
||||
// Deep Power-Down Operations
|
||||
EnterDeepPowerDown = 0xB9,
|
||||
ReleaseFromDeepPowerdown = 0xAB,
|
||||
|
||||
// ADVANCED SECTOR PROTECTION Operations
|
||||
ReadSectorProtection = 0x2D,
|
||||
ProgramSectorProtection = 0x2C,
|
||||
ReadSpbRegister = 0xE2,
|
||||
WriteSpbRegister = 0xE3,
|
||||
EraseSpbRegister = 0xE4,
|
||||
ReadPassword = 0x27,
|
||||
WritePassword = 0x28,
|
||||
UnlockPassword = 0x29,
|
||||
|
||||
// ADVANCED SECTOR PROTECTION Operations with 4-Byte Address
|
||||
ReadDpbRegister = 0xE0,
|
||||
WriteDpbRegister = 0xE1,
|
||||
|
||||
// SECURITY REGISTER
|
||||
ReadSecurityRegister = 0x2B,
|
||||
WriteSecurityRegister = 0x2F,
|
||||
}
|
||||
|
||||
private enum Register : uint
|
||||
{
|
||||
Status = 1, //starting from 1 to leave 0 as an unused value
|
||||
ConfigurationRegister2,
|
||||
SecurityRegister,
|
||||
// The following are currently unised
|
||||
FlagStatus,
|
||||
ExtendedAddress,
|
||||
NonVolatileConfiguration,
|
||||
VolatileConfiguration,
|
||||
EnhancedVolatileConfiguration
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
//
|
||||
// Copyright (c) 2010-2021 Antmicro
|
||||
//
|
||||
// This file is licensed under the MIT License.
|
||||
// Full license text is available in 'licenses/MIT.txt'.
|
||||
//
|
||||
using System.Collections.Generic;
|
||||
using Antmicro.Renode.Core;
|
||||
using Antmicro.Renode.Core.Structure;
|
||||
using Antmicro.Renode.Exceptions;
|
||||
using Antmicro.Renode.Logging;
|
||||
using Antmicro.Renode.Time;
|
||||
|
||||
namespace Antmicro.Renode.Peripherals.SPI
|
||||
{
|
||||
public static class SPIConnectorExtensions
|
||||
{
|
||||
public static void CreateSPIConnector(this Emulation emulation, string name)
|
||||
{
|
||||
emulation.ExternalsManager.AddExternal(new SPIConnector(), name);
|
||||
}
|
||||
}
|
||||
|
||||
public class SPIConnector : IExternal, ISPIPeripheral, IConnectable<ISPIPeripheral>, IConnectable<NullRegistrationPointPeripheralContainer<ISPIPeripheral>>
|
||||
{
|
||||
public void Reset()
|
||||
{
|
||||
peripheralOutput.Clear();
|
||||
}
|
||||
|
||||
public void AttachTo(NullRegistrationPointPeripheralContainer<ISPIPeripheral> controller)
|
||||
{
|
||||
lock(locker)
|
||||
{
|
||||
if(controller == this.controller)
|
||||
{
|
||||
throw new RecoverableException("Cannot attach to the provided peripheral as it is already registered in this connector.");
|
||||
}
|
||||
else if(this.controller != null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Overwriting controller connection.");
|
||||
}
|
||||
|
||||
this.controller?.Unregister(this);
|
||||
this.controller = controller;
|
||||
this.controller.Register(this, NullRegistrationPoint.Instance);
|
||||
}
|
||||
}
|
||||
|
||||
public void AttachTo(ISPIPeripheral peripheral)
|
||||
{
|
||||
lock(locker)
|
||||
{
|
||||
if(peripheral == this.peripheral)
|
||||
{
|
||||
throw new RecoverableException("Cannot attach to the provided peripheral as it is already registered in this connector.");
|
||||
}
|
||||
else if(this.peripheral != null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Overwriting peripheral connection.");
|
||||
}
|
||||
this.peripheral = peripheral;
|
||||
}
|
||||
}
|
||||
|
||||
public void DetachFrom(NullRegistrationPointPeripheralContainer<ISPIPeripheral> controller)
|
||||
{
|
||||
lock(locker)
|
||||
{
|
||||
if(controller == this.controller)
|
||||
{
|
||||
this.controller.Unregister(this);
|
||||
this.controller = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new RecoverableException("Cannot detach from the provided controller as it is not registered in this connector.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void DetachFrom(ISPIPeripheral peripheral)
|
||||
{
|
||||
lock(locker)
|
||||
{
|
||||
if(peripheral == this.peripheral)
|
||||
{
|
||||
peripheral = null;
|
||||
peripheralOutput.Clear();
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new RecoverableException("Cannot detach from the provided peripheral as it is not registered in this connector.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public byte Transmit(byte data)
|
||||
{
|
||||
lock(locker)
|
||||
{
|
||||
if(peripheral == null)
|
||||
{
|
||||
this.Log(LogLevel.Warning, "Controller sent data (0x{0:X}), but peripheral is not connected.", data);
|
||||
return 0x0;
|
||||
}
|
||||
peripheral.GetMachine().HandleTimeDomainEvent(InnerTransmit, data, TimeDomainsManager.Instance.VirtualTimeStamp);
|
||||
return peripheralOutput.Count > 0 ? peripheralOutput.Dequeue() : (byte)0x0;
|
||||
}
|
||||
}
|
||||
|
||||
public void FinishTransmission()
|
||||
{
|
||||
lock(locker)
|
||||
{
|
||||
peripheral.GetMachine().HandleTimeDomainEvent<object>(_ => peripheral.FinishTransmission(), null, TimeDomainsManager.Instance.VirtualTimeStamp);
|
||||
}
|
||||
}
|
||||
|
||||
private void InnerTransmit(byte data)
|
||||
{
|
||||
peripheralOutput.Enqueue(peripheral.Transmit(data));
|
||||
}
|
||||
|
||||
private NullRegistrationPointPeripheralContainer<ISPIPeripheral> controller;
|
||||
private ISPIPeripheral peripheral;
|
||||
private readonly Queue<byte> peripheralOutput = new Queue<byte>();
|
||||
private readonly object locker = new object();
|
||||
}
|
||||
}
|
||||
|
|
@ -70,23 +70,263 @@ namespace Antmicro.Renode.Peripherals.Miscellaneous
|
|||
this.locked[i] = false;
|
||||
}
|
||||
|
||||
this.data[0x0] = 0x9516051b;
|
||||
this.data[0x1] = 0x315aa513;
|
||||
this.data[0x2] = 0x28417c6;
|
||||
this.data[0x3] = 0x3c6818d6;
|
||||
this.data[0x4] = 0x52d8972b;
|
||||
this.data[0x5] = 0x10e5b388;
|
||||
this.data[0x6] = 0xa2177e24;
|
||||
this.data[0x7] = 0xf84ff81f;
|
||||
this.data[0x8] = 0xf2460da1;
|
||||
this.data[0x9] = 0xf86d51b5;
|
||||
this.data[0xa] = 0x4e279ae7;
|
||||
this.data[0xb] = 0x224a7158;
|
||||
this.data[0xc] = 0x4676edb1;
|
||||
this.data[0xd] = 0x297db43b;
|
||||
this.data[0xe] = 0xeff3cd32;
|
||||
this.data[0xf] = 0xe2f39301;
|
||||
this.data[0x10] = 0x560e91d3;
|
||||
this.data[0x11] = 0xe9439e5e;
|
||||
this.data[0x12] = 0xa600629c;
|
||||
this.data[0x13] = 0x3276f5b8;
|
||||
this.data[0x14] = 0xcca5ba59;
|
||||
this.data[0x15] = 0x9cbae96e;
|
||||
this.data[0x16] = 0x96899a9c;
|
||||
this.data[0x17] = 0xa92c5624;
|
||||
this.data[0x18] = 0x1c9beae3;
|
||||
this.data[0x19] = 0x2aeac875;
|
||||
this.data[0x1a] = 0x07c18094;
|
||||
this.data[0x1a] = 0x7c18094;
|
||||
this.data[0x1b] = 0x387eff1c;
|
||||
this.data[0x1c] = 0x74614282;
|
||||
this.data[0x1d] = 0xaffd8152;
|
||||
this.data[0x1e] = 0xd871352e;
|
||||
this.data[0x1f] = 0xdf3f58bb;
|
||||
// Words are swapped on this little-endian system.
|
||||
// this.data[0x18] = 0xe3ea9b1c;
|
||||
// this.data[0x19] = 0x75c8ea2a;
|
||||
// this.data[0x1a] = 0x9480c107;
|
||||
// this.data[0x1b] = 0x1cff7e38;
|
||||
// this.data[0x1c] = 0x82426174;
|
||||
// this.data[0x1d] = 0x5281fdaf;
|
||||
// this.data[0x1e] = 0x2e3571d8;
|
||||
// this.data[0x1f] = 0xbb583fdf;
|
||||
this.data[0x20] = 0x0;
|
||||
this.data[0x21] = 0x0;
|
||||
this.data[0x22] = 0x0;
|
||||
this.data[0x23] = 0x0;
|
||||
this.data[0x24] = 0x0;
|
||||
this.data[0x25] = 0x0;
|
||||
this.data[0x26] = 0x0;
|
||||
this.data[0x27] = 0x0;
|
||||
this.data[0x28] = 0xf2460da1;
|
||||
this.data[0x29] = 0xf86d51b5;
|
||||
this.data[0x2a] = 0x4e279ae7;
|
||||
this.data[0x2b] = 0x224a7158;
|
||||
this.data[0x2c] = 0x4676edb1;
|
||||
this.data[0x2d] = 0x297db43b;
|
||||
this.data[0x2e] = 0xeff3cd32;
|
||||
this.data[0x2f] = 0xe2f39301;
|
||||
this.data[0x30] = 0x0;
|
||||
this.data[0x31] = 0x0;
|
||||
this.data[0x32] = 0x0;
|
||||
this.data[0x33] = 0x0;
|
||||
this.data[0x34] = 0x0;
|
||||
this.data[0x35] = 0x0;
|
||||
this.data[0x36] = 0x0;
|
||||
this.data[0x37] = 0x0;
|
||||
this.data[0x38] = 0x0;
|
||||
this.data[0x39] = 0x0;
|
||||
this.data[0x3a] = 0x0;
|
||||
this.data[0x3b] = 0x0;
|
||||
this.data[0x3c] = 0x0;
|
||||
this.data[0x3d] = 0x0;
|
||||
this.data[0x3e] = 0x0;
|
||||
this.data[0x3f] = 0x0;
|
||||
this.data[0x40] = 0x0;
|
||||
this.data[0x41] = 0x0;
|
||||
this.data[0x42] = 0x0;
|
||||
this.data[0x43] = 0x0;
|
||||
this.data[0x44] = 0x0;
|
||||
this.data[0x45] = 0x0;
|
||||
this.data[0x46] = 0x0;
|
||||
this.data[0x47] = 0x0;
|
||||
this.data[0x48] = 0x0;
|
||||
this.data[0x49] = 0x0;
|
||||
this.data[0x4a] = 0x0;
|
||||
this.data[0x4b] = 0x0;
|
||||
this.data[0x4c] = 0x0;
|
||||
this.data[0x4d] = 0x0;
|
||||
this.data[0x4e] = 0x0;
|
||||
this.data[0x4f] = 0x0;
|
||||
this.data[0x50] = 0x0;
|
||||
this.data[0x51] = 0x0;
|
||||
this.data[0x52] = 0x0;
|
||||
this.data[0x53] = 0x0;
|
||||
this.data[0x54] = 0x0;
|
||||
this.data[0x55] = 0x0;
|
||||
this.data[0x56] = 0x0;
|
||||
this.data[0x57] = 0x0;
|
||||
this.data[0x58] = 0x0;
|
||||
this.data[0x59] = 0x0;
|
||||
this.data[0x5a] = 0x0;
|
||||
this.data[0x5b] = 0x0;
|
||||
this.data[0x5c] = 0x0;
|
||||
this.data[0x5d] = 0x0;
|
||||
this.data[0x5e] = 0x0;
|
||||
this.data[0x5f] = 0x0;
|
||||
this.data[0x60] = 0x0;
|
||||
this.data[0x61] = 0x0;
|
||||
this.data[0x62] = 0x0;
|
||||
this.data[0x63] = 0x0;
|
||||
this.data[0x64] = 0x0;
|
||||
this.data[0x65] = 0x0;
|
||||
this.data[0x66] = 0x0;
|
||||
this.data[0x67] = 0x0;
|
||||
this.data[0x68] = 0x0;
|
||||
this.data[0x69] = 0x0;
|
||||
this.data[0x6a] = 0x0;
|
||||
this.data[0x6b] = 0x0;
|
||||
this.data[0x6c] = 0x0;
|
||||
this.data[0x6d] = 0x0;
|
||||
this.data[0x6e] = 0x0;
|
||||
this.data[0x6f] = 0x0;
|
||||
this.data[0x70] = 0x0;
|
||||
this.data[0x71] = 0x0;
|
||||
this.data[0x72] = 0x0;
|
||||
this.data[0x73] = 0x0;
|
||||
this.data[0x74] = 0x0;
|
||||
this.data[0x75] = 0x0;
|
||||
this.data[0x76] = 0x0;
|
||||
this.data[0x77] = 0x0;
|
||||
this.data[0x78] = 0x0;
|
||||
this.data[0x79] = 0x0;
|
||||
this.data[0x7a] = 0x0;
|
||||
this.data[0x7b] = 0x0;
|
||||
this.data[0x7c] = 0x0;
|
||||
this.data[0x7d] = 0x0;
|
||||
this.data[0x7e] = 0x0;
|
||||
this.data[0x7f] = 0x0;
|
||||
this.data[0x80] = 0x0;
|
||||
this.data[0x81] = 0x0;
|
||||
this.data[0x82] = 0x0;
|
||||
this.data[0x83] = 0x0;
|
||||
this.data[0x84] = 0x0;
|
||||
this.data[0x85] = 0x0;
|
||||
this.data[0x86] = 0x0;
|
||||
this.data[0x87] = 0x0;
|
||||
this.data[0x88] = 0x0;
|
||||
this.data[0x89] = 0x0;
|
||||
this.data[0x8a] = 0x0;
|
||||
this.data[0x8b] = 0x0;
|
||||
this.data[0x8c] = 0x0;
|
||||
this.data[0x8d] = 0x0;
|
||||
this.data[0x8e] = 0x0;
|
||||
this.data[0x8f] = 0x0;
|
||||
this.data[0x90] = 0x0;
|
||||
this.data[0x91] = 0x0;
|
||||
this.data[0x92] = 0x0;
|
||||
this.data[0x93] = 0x0;
|
||||
this.data[0x94] = 0x0;
|
||||
this.data[0x95] = 0x0;
|
||||
this.data[0x96] = 0x0;
|
||||
this.data[0x97] = 0x0;
|
||||
this.data[0x98] = 0x0;
|
||||
this.data[0x99] = 0x0;
|
||||
this.data[0x9a] = 0x0;
|
||||
this.data[0x9b] = 0x0;
|
||||
this.data[0x9c] = 0x0;
|
||||
this.data[0x9d] = 0x0;
|
||||
this.data[0x9e] = 0x0;
|
||||
this.data[0x9f] = 0x0;
|
||||
this.data[0xa0] = 0x0;
|
||||
this.data[0xa1] = 0x0;
|
||||
this.data[0xa2] = 0x0;
|
||||
this.data[0xa3] = 0x0;
|
||||
this.data[0xa4] = 0x0;
|
||||
this.data[0xa5] = 0x0;
|
||||
this.data[0xa6] = 0x0;
|
||||
this.data[0xa7] = 0x0;
|
||||
this.data[0xa8] = 0x0;
|
||||
this.data[0xa9] = 0x0;
|
||||
this.data[0xaa] = 0x0;
|
||||
this.data[0xab] = 0x0;
|
||||
this.data[0xac] = 0x0;
|
||||
this.data[0xad] = 0x0;
|
||||
this.data[0xae] = 0x0;
|
||||
this.data[0xaf] = 0x0;
|
||||
this.data[0xb0] = 0x0;
|
||||
this.data[0xb1] = 0x0;
|
||||
this.data[0xb2] = 0x0;
|
||||
this.data[0xb3] = 0x0;
|
||||
this.data[0xb4] = 0x0;
|
||||
this.data[0xb5] = 0x0;
|
||||
this.data[0xb6] = 0x0;
|
||||
this.data[0xb7] = 0x0;
|
||||
this.data[0xb8] = 0x0;
|
||||
this.data[0xb9] = 0x0;
|
||||
this.data[0xba] = 0x0;
|
||||
this.data[0xbb] = 0x0;
|
||||
this.data[0xbc] = 0x0;
|
||||
this.data[0xbd] = 0x0;
|
||||
this.data[0xbe] = 0x0;
|
||||
this.data[0xbf] = 0x0;
|
||||
this.data[0xc0] = 0x0;
|
||||
this.data[0xc1] = 0x0;
|
||||
this.data[0xc2] = 0x0;
|
||||
this.data[0xc3] = 0x0;
|
||||
this.data[0xc4] = 0x0;
|
||||
this.data[0xc5] = 0x0;
|
||||
this.data[0xc6] = 0x0;
|
||||
this.data[0xc7] = 0x0;
|
||||
this.data[0xc8] = 0x0;
|
||||
this.data[0xc9] = 0x0;
|
||||
this.data[0xca] = 0x0;
|
||||
this.data[0xcb] = 0x0;
|
||||
this.data[0xcc] = 0x0;
|
||||
this.data[0xcd] = 0x0;
|
||||
this.data[0xce] = 0x0;
|
||||
this.data[0xcf] = 0x0;
|
||||
this.data[0xd0] = 0x0;
|
||||
this.data[0xd1] = 0x0;
|
||||
this.data[0xd2] = 0x0;
|
||||
this.data[0xd3] = 0x0;
|
||||
this.data[0xd4] = 0x0;
|
||||
this.data[0xd5] = 0x0;
|
||||
this.data[0xd6] = 0x0;
|
||||
this.data[0xd7] = 0x0;
|
||||
this.data[0xd8] = 0x0;
|
||||
this.data[0xd9] = 0x0;
|
||||
this.data[0xda] = 0x0;
|
||||
this.data[0xdb] = 0x0;
|
||||
this.data[0xdc] = 0x0;
|
||||
this.data[0xdd] = 0x0;
|
||||
this.data[0xde] = 0x0;
|
||||
this.data[0xdf] = 0x0;
|
||||
this.data[0xe0] = 0x0;
|
||||
this.data[0xe1] = 0x0;
|
||||
this.data[0xe2] = 0x0;
|
||||
this.data[0xe3] = 0x0;
|
||||
this.data[0xe4] = 0x0;
|
||||
this.data[0xe5] = 0x0;
|
||||
this.data[0xe6] = 0x0;
|
||||
this.data[0xe7] = 0x0;
|
||||
this.data[0xe8] = 0x0;
|
||||
this.data[0xe9] = 0x0;
|
||||
this.data[0xea] = 0x0;
|
||||
this.data[0xeb] = 0x0;
|
||||
this.data[0xec] = 0x0;
|
||||
this.data[0xed] = 0x0;
|
||||
this.data[0xee] = 0x0;
|
||||
this.data[0xef] = 0x0;
|
||||
this.data[0xf0] = 0x0;
|
||||
this.data[0xf1] = 0x0;
|
||||
this.data[0xf2] = 0x0;
|
||||
this.data[0xf3] = 0x0;
|
||||
this.data[0xf4] = 0x0;
|
||||
this.data[0xf5] = 0x0;
|
||||
this.data[0xf6] = 0x0;
|
||||
this.data[0xf7] = 0x0;
|
||||
this.data[0xf8] = 0xe01133bd;
|
||||
this.data[0xf9] = 0xc0ea362;
|
||||
this.data[0xfa] = 0x9d48a555;
|
||||
this.data[0xfb] = 0x947a820;
|
||||
this.data[0xfc] = 0x0;
|
||||
this.data[0xfd] = 0x0;
|
||||
this.data[0xfe] = 0x0;
|
||||
this.data[0xff] = 0x1000008;
|
||||
|
||||
this.lockAddress = 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
4262
emulation/peripherals/vexriscv-aes.cs
Normal file
4262
emulation/peripherals/vexriscv-aes.cs
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -1,6 +1,6 @@
|
|||
// Renode Platform file generated by svd2repl
|
||||
// This file is automatically generated
|
||||
cpu: CPU.VexRiscv @ sysbus
|
||||
cpu: CPU.AesVexRiscv @ sysbus
|
||||
cpuType: "rv32imac"
|
||||
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
|
||||
PerformanceInMips: 120
|
||||
|
|
@ -54,7 +54,8 @@ ticktimer: Timers.TickTimer @ sysbus 0xf0012000
|
|||
spinor_soft_int: Miscellaneous.SpinorSoftInt @ sysbus 0xf0015000
|
||||
IRQ -> cpu @ 1011
|
||||
|
||||
// Unrecognized peripheral: spinor @ 0xf0016000
|
||||
spinor: SPI.BetrustedSpinor @ sysbus 0xf0016000
|
||||
IRQ -> cpu @ 1012
|
||||
|
||||
keyboard: Input.BetrustedKbd @ sysbus 0xf0017000
|
||||
IRQ -> cpu @ 1013
|
||||
|
|
@ -116,6 +117,9 @@ audio: Memory.MappedMemory @ sysbus 0xe0000000
|
|||
|
||||
abracom_rtc: Sensors.ABRTCMC @ i2c 0x68
|
||||
|
||||
flash: SPI.MXIC_MX66UM1G45G @ spinor
|
||||
underlyingMemory: spiflash
|
||||
|
||||
sysbus:
|
||||
init:
|
||||
ApplySVD @soc/renode.svd
|
||||
|
|
|
|||
|
|
@ -11,10 +11,16 @@ using sysbus
|
|||
i @peripherals/ABRTCMC.cs
|
||||
i @peripherals/BetrustedEcI2C.cs
|
||||
i @peripherals/BetrustedSocI2C.cs
|
||||
i @peripherals/BetrustedSpinor.cs
|
||||
i @peripherals/BetrustedWatchdog.cs
|
||||
i @peripherals/BQ24157.cs
|
||||
i @peripherals/BQ27421.cs
|
||||
i @peripherals/Com.cs
|
||||
i @peripherals/ComConnector.cs
|
||||
EnsureTypeIsLoaded "Antmicro.Renode.Peripherals.SPI.IComPeripheral"
|
||||
EnsureTypeIsLoaded "Antmicro.Renode.Peripherals.SPI.IComController"
|
||||
i @peripherals/ComSoC.cs
|
||||
i @peripherals/ComEc.cs
|
||||
i @peripherals/ComSoC.cs
|
||||
i @peripherals/ec_power.cs
|
||||
i @peripherals/engine.cs
|
||||
i @peripherals/keyboard.cs
|
||||
|
|
@ -23,6 +29,7 @@ i @peripherals/LiteX_Timer_32.cs
|
|||
i @peripherals/LM3509.cs
|
||||
i @peripherals/LSM6DS3.cs
|
||||
i @peripherals/memlcd.cs
|
||||
i @peripherals/MXIC_MX66UM1G45G.cs
|
||||
i @peripherals/sha512.cs
|
||||
i @peripherals/spinor_soft_int.cs
|
||||
i @peripherals/ticktimer.cs
|
||||
|
|
@ -31,6 +38,9 @@ i @peripherals/trng_server.cs
|
|||
i @peripherals/TUSB320LAI.cs
|
||||
i @peripherals/wfi.cs
|
||||
|
||||
EnsureTypeIsLoaded "Antmicro.Renode.Peripherals.CPU.VexRiscv"
|
||||
i @peripherals/vexriscv-aes.cs
|
||||
|
||||
# Create the COM SPI bus
|
||||
emulation CreateComConnector "com"
|
||||
|
||||
|
|
@ -57,11 +67,13 @@ sysbus Tag <0xB0000000, 0xB0006000> "Framebuffer"
|
|||
# logLevel -1 i2c
|
||||
# logLevel -1 i2c.abracom_rtc
|
||||
# logLevel -1 sha512
|
||||
# logLevel -1 sysbus.spinor.flash
|
||||
# sysbus LogPeripheralAccess spinor true
|
||||
|
||||
# Silence GPIO
|
||||
sysbus SilenceRange <0xf0003000, 0xF0003FFF>
|
||||
# sysbus SilenceRange <0xF0021000, 0xF0021FFF>
|
||||
# sysbus SilenceRange <0xF0023000, 0xF0023FFF>
|
||||
# Silence POWER
|
||||
sysbus SilenceRange <0xF0014000 100>
|
||||
|
||||
# Load the SPI flash into RAM
|
||||
sysbus LoadBinary @precursors/soc_csr.bin 0x20000000
|
||||
|
|
@ -84,7 +96,6 @@ emulation CreateServerSocketTerminal 9999 "kernel" False
|
|||
connector Connect sysbus.uart kernel
|
||||
|
||||
runMacro $reset
|
||||
sysbus.cpu InstallCustomInstructionHandlerFromFile "00ss0fdbbbbbaaaaa000ddddd0001011" @vexriscv-aes.py
|
||||
|
||||
mach clear
|
||||
|
||||
|
|
|
|||
|
|
@ -479,7 +479,7 @@ fn parse_vendor_extensions<T: BufRead>(
|
|||
fn print_header<U: Write>(out: &mut U) -> std::io::Result<()> {
|
||||
let s = r####"// Renode Platform file generated by svd2repl
|
||||
// This file is automatically generated
|
||||
cpu: CPU.VexRiscv @ sysbus
|
||||
cpu: CPU.AesVexRiscv @ sysbus
|
||||
cpuType: "rv32imac"
|
||||
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
|
||||
PerformanceInMips: 120
|
||||
|
|
@ -491,6 +491,9 @@ fn print_footer<U: Write>(out: &mut U) -> std::io::Result<()> {
|
|||
let s = r####"
|
||||
abracom_rtc: Sensors.ABRTCMC @ i2c 0x68
|
||||
|
||||
flash: SPI.MXIC_MX66UM1G45G @ spinor
|
||||
underlyingMemory: spiflash
|
||||
|
||||
sysbus:
|
||||
init:
|
||||
ApplySVD @soc/renode.svd
|
||||
|
|
@ -640,6 +643,7 @@ pub fn generate<T: Read, U: Write>(src: T, dest: &mut U) -> Result<(), ParseErro
|
|||
cs_peripherals.insert("memlcd", "Video.BetrustedLCD");
|
||||
cs_peripherals.insert("sha512", "Miscellaneous.Sha512");
|
||||
cs_peripherals.insert("spinor_soft_int", "Miscellaneous.SpinorSoftInt");
|
||||
cs_peripherals.insert("spinor", "SPI.BetrustedSpinor");
|
||||
cs_peripherals.insert("timer0", "Timers.LiteX_Timer_32");
|
||||
cs_peripherals.insert("trng_kernel", "Miscellaneous.BetrustedRNGKernel");
|
||||
cs_peripherals.insert("trng_server", "Miscellaneous.BetrustedRNGServer");
|
||||
|
|
|
|||
Loading…
Reference in a new issue