diff --git a/emulation/ec/betrusted-ec.repl b/emulation/ec/betrusted-ec.repl
index e9edc1672..bfcc3653a 100644
--- a/emulation/ec/betrusted-ec.repl
+++ b/emulation/ec/betrusted-ec.repl
@@ -3,15 +3,21 @@ cpu: CPU.VexRiscv @ sysbus
PerformanceInMips: 6
uart: UART.LiteX_UART @ {
- sysbus 0xE0001800
+ sysbus 0xE0003800
}
- -> cpu@1000
+ -> cpu@1001
timer0: Timers.LiteX_Timer_32 @ {
- sysbus 0xe0002000
+ sysbus 0xe0001000
}
frequency: 100000000
- -> cpu@1001
+ -> cpu@1000
+
+i2c: I2C.BetrustedEcI2C @ sysbus 0xE0004800
+ -> cpu @ 1002
+
+ticktimer: Timers.TickTimer @ sysbus 0xe0005000
+ -> cpu @ 1003
sram: Memory.MappedMemory @ {
sysbus 0x10000000;
@@ -19,16 +25,14 @@ sram: Memory.MappedMemory @ {
}
size: 0x00020000
-ticktimer: Timers.TickTimer @ sysbus 0xe0005000
- periodInMs: 1
- -> cpu @ 1003
-
flash_mem: Memory.MappedMemory @ {
sysbus 0x20000000;
sysbus 0xA0000000 // shadow
}
size: 0x8000000
+bq27421: Sensors.BQ27421 @ i2c 0x55
+
sysbus:
init:
ApplySVD @ec/soc.svd
diff --git a/emulation/ec/kernel.bin b/emulation/ec/kernel.bin
index 6a3586adc..8ccae6f40 100644
Binary files a/emulation/ec/kernel.bin and b/emulation/ec/kernel.bin differ
diff --git a/emulation/ec/soc.svd b/emulation/ec/soc.svd
index b2bc9e23f..2cfaf5785 100644
--- a/emulation/ec/soc.svd
+++ b/emulation/ec/soc.svd
@@ -72,8 +72,333 @@ to the Wishbone/CSR bus are working correctly. The initial reset value of
- UART
+ TIMER0
+ 0xE0001000
+ TIMER0
+
+
+ LOAD
+
+ 0x0000
+ 0x00
+ 32
+
+
+ load
+ 31
+ [31:0]
+ 0
+
+
+
+
+ RELOAD
+
+ 0x0004
+ 0x00
+ 32
+
+
+ reload
+ 31
+ [31:0]
+ 0
+
+
+
+
+ EN
+
+ 0x0008
+ 0x00
+ 32
+
+
+ en
+ 0
+ [0:0]
+ 0
+
+
+
+
+ UPDATE_VALUE
+
+ 0x000c
+ 0x00
+ 32
+
+
+ update_value
+ 0
+ [0:0]
+ 0
+
+
+
+
+ VALUE
+
+ 0x0010
+ 0x00
+ 32
+
+
+ value
+ 31
+ [31:0]
+ 0
+
+
+
+
+ EV_STATUS
+
+ 0x0014
+ 0x00
+ 32
+
+
+ zero
+ 0
+ [0:0]
+ 0
+
+
+
+
+
+ EV_PENDING
+
+ 0x0018
+ 0x00
+ 32
+
+
+ zero
+ 0
+ [0:0]
+ 0
+
+
+
+
+
+ EV_ENABLE
+
+ 0x001c
+ 0x00
+ 32
+
+
+ zero
+ 0
+ [0:0]
+ 0
+
+
+
+
+
+
+ 0
+ 0x20
+ registers
+
+
+ timer0
+ 0
+
+
+
+ CRG
0xE0001800
+ CRG
+
+
+ WATCHDOG
+ 0x0000
+ 0x00
+ 32
+
+
+ reset_code
+ 15
+ [15:0]
+ 0
+
+
+
+ enable
+ 16
+ [16:16]
+ 16
+
+
+
+
+
+
+ 0
+ 0x4
+ registers
+
+
+
+ GIT
+ 0xE0002000
+ GIT
+
+
+ GITREV
+
+ 0x0000
+ 0x3ba1c49
+ 32
+
+
+ gitrev
+ 31
+ [31:0]
+ 0
+
+
+
+
+ DIRTY
+ 0x0004
+ 0x01
+ 32
+
+
+ dirty
+ 0
+ [0:0]
+ 0
+
+
+
+
+
+
+ 0
+ 0x8
+ registers
+
+
+
+ POWER
+ 0xE0002800
+ POWER
+
+
+ POWER
+ 0x0000
+ 0x03
+ 32
+
+
+ self
+ 0
+ [0:0]
+ 0
+
+
+
+ soc_on
+ 1
+ [1:1]
+ 1
+
+
+
+ discharge
+ 2
+ [2:2]
+ 2
+
+
+
+ kbddrive
+ 3
+ [3:3]
+ 3
+
+
+
+
+
+ STATS
+ 0x0004
+ 0x00
+ 32
+
+
+ state
+ 0
+ [0:0]
+ 0
+
+
+
+ monkey
+ 2
+ [2:1]
+ 1
+
+
+
+
+
+
+ 0
+ 0x8
+ registers
+
+
+
+ UART_PHY
+ 0xE0003000
+ UART_PHY
+
+
+ TUNING_WORD
+ 0x0000
+ 0x1a36e2e
+ 32
+
+
+ tuning_word
+ 31
+ [31:0]
+ 0
+
+
+
+
+
+ 0
+ 0x4
+ registers
+
+
+
+ UART
+ 0xE0003800
UART
@@ -218,294 +543,6 @@ register to disable individual events.]]>
-
- XOVER_RXTX
- 0x0020
- 0x00
- 32
-
-
- xover_rxtx
- 7
- [7:0]
- 0
-
-
-
-
- XOVER_TXFULL
- 0x0024
- 0x00
- 32
-
-
- xover_txfull
- 0
- [0:0]
- 0
-
-
-
-
- XOVER_RXEMPTY
- 0x0028
- 0x00
- 32
-
-
- xover_rxempty
- 0
- [0:0]
- 0
-
-
-
-
- XOVER_EV_STATUS
-
- 0x002c
- 0x00
- 32
-
-
- tx
- 0
- [0:0]
- 0
-
-
-
- rx
- 1
- [1:1]
- 1
-
-
-
-
-
- XOVER_EV_PENDING
-
- 0x0030
- 0x00
- 32
-
-
- tx
- 0
- [0:0]
- 0
-
-
-
- rx
- 1
- [1:1]
- 1
-
-
-
-
-
- XOVER_EV_ENABLE
-
- 0x0034
- 0x00
- 32
-
-
- tx
- 0
- [0:0]
- 0
-
-
-
- rx
- 1
- [1:1]
- 1
-
-
-
-
-
- XOVER_TXEMPTY
- 0x0038
- 0x00
- 32
-
-
- xover_txempty
- 0
- [0:0]
- 0
-
-
-
-
- XOVER_RXFULL
- 0x003c
- 0x00
- 32
-
-
- xover_rxfull
- 0
- [0:0]
- 0
-
-
-
-
-
- 0
- 0x40
- registers
-
-
- uart
- 0
-
-
-
- TIMER0
- 0xE0002000
- TIMER0
-
-
- LOAD
-
- 0x0000
- 0x00
- 32
-
-
- load
- 31
- [31:0]
- 0
-
-
-
-
- RELOAD
-
- 0x0004
- 0x00
- 32
-
-
- reload
- 31
- [31:0]
- 0
-
-
-
-
- EN
-
- 0x0008
- 0x00
- 32
-
-
- en
- 0
- [0:0]
- 0
-
-
-
-
- UPDATE_VALUE
-
- 0x000c
- 0x00
- 32
-
-
- update_value
- 0
- [0:0]
- 0
-
-
-
-
- VALUE
-
- 0x0010
- 0x00
- 32
-
-
- value
- 31
- [31:0]
- 0
-
-
-
-
- EV_STATUS
-
- 0x0014
- 0x00
- 32
-
-
- zero
- 0
- [0:0]
- 0
-
-
-
-
-
- EV_PENDING
-
- 0x0018
- 0x00
- 32
-
-
- zero
- 0
- [0:0]
- 0
-
-
-
-
-
- EV_ENABLE
-
- 0x001c
- 0x00
- 32
-
-
- zero
- 0
- [0:0]
- 0
-
-
-
-
0
@@ -513,163 +550,10 @@ register to disable individual events.]]>
registers
- timer0
+ uart
1
-
- CRG
- 0xE0002800
- CRG
-
-
- WATCHDOG
- 0x0000
- 0x00
- 32
-
-
- reset_code
- 15
- [15:0]
- 0
-
-
-
- enable
- 16
- [16:16]
- 16
-
-
-
-
-
-
- 0
- 0x4
- registers
-
-
-
- GIT
- 0xE0003000
- GIT
-
-
- GITREV
-
- 0x0000
- 0xd167b75b
- 32
-
-
- gitrev
- 31
- [31:0]
- 0
-
-
-
-
- DIRTY
- 0x0004
- 0x01
- 32
-
-
- dirty
- 0
- [0:0]
- 0
-
-
-
-
-
-
- 0
- 0x8
- registers
-
-
-
- POWER
- 0xE0003800
- POWER
-
-
- POWER
- 0x0000
- 0x03
- 32
-
-
- self
- 0
- [0:0]
- 0
-
-
-
- soc_on
- 1
- [1:1]
- 1
-
-
-
- discharge
- 2
- [2:2]
- 2
-
-
-
- kbddrive
- 3
- [3:3]
- 3
-
-
-
-
-
- STATS
- 0x0004
- 0x00
- 32
-
-
- state
- 0
- [0:0]
- 0
-
-
-
- monkey
- 2
- [2:1]
- 1
-
-
-
-
-
-
- 0
- 0x8
- registers
-
-
PICORVSPI
0xE0004000
@@ -747,10 +631,255 @@ mitigate noise]]>
0xE0004800
I2C
+
+ PRESCALE
+
+ 0x0000
+ 0xffff
+ 32
+
+
+ prescale
+ 15
+ [15:0]
+ 0
+
+
+
+
+ CONTROL
+ 0x0004
+ 0x00
+ 32
+
+
+ Resvd
+ 5
+ [5:0]
+ 0
+
+
+
+ IEN
+ 6
+ [6:6]
+ 6
+
+
+
+ EN
+ 7
+ [7:7]
+ 7
+
+
+
+
+
+ TXR
+
+ 0x0008
+ 0x00
+ 32
+
+
+ txr
+ 7
+ [7:0]
+ 0
+
+
+
+
+ RXR
+
+ 0x000c
+ 0x00
+ 32
+
+
+ rxr
+ 7
+ [7:0]
+ 0
+
+
+
+
+ COMMAND
+ 0x0010
+ 0x00
+ 32
+
+
+ IACK
+ 0
+ [0:0]
+ 0
+
+
+
+ Resvd
+ 2
+ [2:1]
+ 1
+
+
+
+ ACK
+ 3
+ [3:3]
+ 3
+
+
+
+ WR
+ 4
+ [4:4]
+ 4
+
+
+
+ RD
+ 5
+ [5:5]
+ 5
+
+
+
+ STO
+ 6
+ [6:6]
+ 6
+
+
+
+ STA
+ 7
+ [7:7]
+ 7
+
+
+
+
+
+ STATUS
+ 0x0014
+ 0x00
+ 32
+
+
+ IF
+ 0
+ [0:0]
+ 0
+
+
+
+ TIP
+ 1
+ [1:1]
+ 1
+
+
+
+ Resvd
+ 4
+ [4:2]
+ 2
+
+
+
+ ArbLost
+ 5
+ [5:5]
+ 5
+
+
+
+ Busy
+ 6
+ [6:6]
+ 6
+
+
+
+ RxACK
+ 7
+ [7:7]
+ 7
+
+
+
+
+
+ BITBANG_MODE
+
+ 0x0018
+ 0x00
+ 32
+
+
+ bitbang_mode
+ 0
+ [0:0]
+ 0
+
+
+
+
+ BB
+ 0x001c
+ 0x03
+ 32
+
+
+ scl
+ 0
+ [0:0]
+ 0
+
+
+
+ sda_val
+ 1
+ [1:1]
+ 1
+
+
+
+ sda_dir
+ 2
+ [2:2]
+ 2
+
+
+
+
+
+ BB_R
+
+ 0x0020
+ 0x00
+ 32
+
+
+ bb_r
+ 0
+ [0:0]
+ 0
+
+
+
EV_STATUS
- 0x0000
+ 0x0024
0x00
32
@@ -787,7 +916,7 @@ mitigate noise]]>
EV_PENDING
- 0x0004
+ 0x0028
0x00
32
@@ -824,7 +953,7 @@ mitigate noise]]>
EV_ENABLE
- 0x0008
+ 0x002c
0x00
32
@@ -861,7 +990,7 @@ mitigate noise]]>
0
- 0xc
+ 0x30
registers
@@ -1131,106 +1260,12 @@ register to disable individual events.]]>
-
- EV_STATUS
-
- 0x0008
- 0x00
- 32
-
-
- spi_avail
- 0
- [0:0]
- 0
-
-
-
- spi_event
- 1
- [1:1]
- 1
-
-
-
- spi_err
- 2
- [2:2]
- 2
-
-
-
-
-
- EV_PENDING
-
- 0x000c
- 0x00
- 32
-
-
- spi_avail
- 0
- [0:0]
- 0
-
-
-
- spi_event
- 1
- [1:1]
- 1
-
-
-
- spi_err
- 2
- [2:2]
- 2
-
-
-
-
-
- EV_ENABLE
-
- 0x0010
- 0x00
- 32
-
-
- spi_avail
- 0
- [0:0]
- 0
-
-
-
- spi_event
- 1
- [1:1]
- 1
-
-
-
- spi_err
- 2
- [2:2]
- 2
-
-
-
-
0
- 0x14
+ 0x8
registers
-
- com
- 4
-
WIFI
@@ -1406,17 +1441,12 @@ operation]]>
wifi
- 5
+ 4
-
- VEXRISCV_DEBUG
- 0xF00F0000
- 0x00000100
-
SRAM
0x10000000
@@ -1427,11 +1457,6 @@ operation]]>
0x20000000
0x00100000
-
- I2C
- 0xB0000000
- 0x00000040
-
COM
0xD0000000
@@ -1444,4 +1469,4 @@ operation]]>
-
+
\ No newline at end of file
diff --git a/emulation/peripherals/BQ27421.cs b/emulation/peripherals/BQ27421.cs
new file mode 100644
index 000000000..7afd0c4bc
--- /dev/null
+++ b/emulation/peripherals/BQ27421.cs
@@ -0,0 +1,346 @@
+//
+// Copyright (c) 2010-2020 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 System.IO;
+using System.Linq;
+using Antmicro.Renode.Core;
+using Antmicro.Renode.Core.Structure.Registers;
+using Antmicro.Renode.Logging;
+using Antmicro.Renode.Peripherals.I2C;
+using Antmicro.Renode.Peripherals.Sensor;
+using Antmicro.Renode.Utilities;
+using Antmicro.Renode.Exceptions;
+
+namespace Antmicro.Renode.Peripherals.Sensors
+{
+ public class BQ27421 : II2CPeripheral, IProvidesRegisterCollection, ISensor, ITemperatureSensor
+ {
+ public BQ27421()
+ {
+ RegistersCollection = new ByteRegisterCollection(this);
+ IRQ = new GPIO();
+ DefineRegisters();
+ }
+
+ public void FinishTransmission(){}
+
+ public void Reset()
+ {
+ RegistersCollection.Reset();
+ IRQ.Set(false);
+ regAddress = 0;
+ }
+
+ public void Write(byte[] data)
+ {
+ if(data.Length == 0 || data.Length == 1)
+ {
+ this.Log(LogLevel.Warning, "Unexpected write with no data");
+ return;
+ }
+
+ // The first byte contains our address.
+ this.Log(LogLevel.Noisy, "Write with {0} bytes of data: {1}", data.Length, Misc.PrettyPrintCollectionHex(data));
+
+ // The second byte contains the register address
+ regAddress = (Registers)data[1];
+
+ if(data.Length == 2)
+ {
+ this.Log(LogLevel.Noisy, "Preparing to read register {0} (0x{0:X})", regAddress);
+ readyPending.Value = true;
+ UpdateInterrupts();
+ return;
+ }
+
+ // // skip the two bytes as they contain our address and the register address
+ // foreach(var b in data.Skip(2))
+ // {
+ // this.Log(LogLevel.Noisy, "Writing 0x{0:X} to register {1} (0x{1:X})", b, regAddress);
+ // RegistersCollection.Write((byte)regAddress, b);
+ // }
+ if (data[1] == 0x00) {
+ var cmd = (data[2] << 0) | (data[3] << 8);
+ this.Log(LogLevel.Noisy, "Issuing control command (0x{0:X})", cmd);
+ switch (cmd) {
+ case 0x0000: response = controlStatus; break;
+ case 0x0012: controlStatus &= 0xffbf; break;
+ default: this.Log(LogLevel.Error, "Unhandled Control code: 0x{0:X}", cmd); break;
+ }
+ }
+ }
+
+ public byte[] Read(int count)
+ {
+ this.Log(LogLevel.Error, "Reading {0} bytes from register {1} (0x{1:X})", count, regAddress);
+ var result = new byte[count];
+ readyPending.Value = false;
+ UpdateInterrupts();
+ if (count >= 1) {
+ result[0] = (byte)(response & 0xff);
+ }
+ if (count >= 2) {
+ result[1] = (byte)((response >> 8) & 0xff);
+ }
+ // for(var i = 0; i < result.Length; i++)
+ // {
+ // result[i] = RegistersCollection.Read((byte)regAddress);
+ // this.Log(LogLevel.Error, "Read value {0}", result[i]);
+ // RegistersAutoIncrement();
+ // }
+ return result;
+ }
+
+ // public decimal AccelerationX
+ // {
+ // get => accelarationX;
+ // set
+ // {
+ // if (!IsAccelerationOutOfRange(value))
+ // {
+ // accelarationX = value;
+ // this.Log(LogLevel.Noisy, "AccelerationX set to {0}", accelarationX);
+ // }
+ // }
+ // }
+
+ // public decimal AccelerationY
+ // {
+ // get => accelarationY;
+ // set
+ // {
+ // if (!IsAccelerationOutOfRange(value))
+ // {
+ // accelarationY = value;
+ // this.Log(LogLevel.Noisy, "AccelerationY set to {0}", accelarationY);
+ // }
+ // }
+ // }
+
+ // public decimal AccelerationZ
+ // {
+ // get => accelarationZ;
+ // set
+ // {
+ // if (!IsAccelerationOutOfRange(value))
+ // {
+ // accelarationZ = value;
+ // this.Log(LogLevel.Noisy, "AccelerationZ set to {0}", accelarationZ);
+ // }
+ // }
+ // }
+
+ public decimal Temperature { get; set; }
+
+ public GPIO IRQ { get; }
+ public ByteRegisterCollection RegistersCollection { get; }
+
+ private void DefineRegisters()
+ {
+ // Registers.WhoAmI.Define(this, 0x43);
+
+ // Registers.Control1.Define(this) //RW
+ // .WithTaggedFlag("BLOCK_DATA_UPDATE", 0)
+ // .WithFlag(1, out highFreqDataRateMode, name: "HIGH_FREQ_MODE_ENABLE")
+ // .WithValueField(2, 2, out fullScale, name: "FULL_SCALE_SELECT")
+ // .WithValueField(4, 4, out outDataRate, name: "OUTPUT_DATA_RATE");
+
+ // Registers.Control4.Define(this, 0x01) //RW
+ // .WithFlag(0, out readyEnabled, name: "DATA_READY_IRQ1_ENABLE")
+ // .WithTaggedFlag("FIFO_THRESHOLD_IRQ1_ENABLE", 1)
+ // .WithTaggedFlag("6D_RECON_IRQ1_ENABLE", 2)
+ // .WithTaggedFlag("DOUBLE_TAP_RECON_IRQ1_ENABLE", 3)
+ // .WithTaggedFlag("FREE_FALL_RECON_IRQ1_ENABLE", 4)
+ // .WithTaggedFlag("WAKEUP_RECON_IRQ1_ENABLE", 5)
+ // .WithTaggedFlag("SINGLE_TAP_RECON_IRQ1_ENABLE", 6)
+ // .WithTaggedFlag("MASTER_DATA_READY_IRQ1_ENABLE", 7)
+ // .WithWriteCallback((_, __) => UpdateInterrupts());
+
+ Registers.Temp.Define(this)
+ .WithValueField(0, 8, FieldMode.Read, name: "TEMPERATURE_SENSOR", valueProviderCallback: _ => TwoComplementSignConvert(Temperature));
+
+ // Registers.Status.Define(this) //RO
+ // .WithFlag(0, out readyPending, FieldMode.Read, name: "XYZ_DATA_AVAILABLE")
+ // .WithTaggedFlag("FREE_FALL_EVENT_DETECT", 1)
+ // .WithTaggedFlag("CHANGE_IN_POSITION_DETECT", 2)
+ // .WithTaggedFlag("SINGLE_TAP_EVENT_DETECT", 3)
+ // .WithTaggedFlag("DOUBLE_TAP_EVENT_DETECT", 4)
+ // .WithTaggedFlag("SLEEP_EVENT_DETECT", 5)
+ // .WithTaggedFlag("WAKEUP_EVENT_DETECT", 6)
+ // .WithTaggedFlag("FIFO_REACH_THRESHOLD", 7);
+
+ // Registers.DataOutXLow.Define(this)
+ // .WithValueField(0, 8, FieldMode.Read, name: "X_ACCEL_DATA[7:2]", valueProviderCallback: _ => Convert(AccelerationX, upperByte: false));
+
+ // Registers.DataOutXHigh.Define(this)
+ // .WithValueField(0, 8, FieldMode.Read, name: "X_ACCEL_DATA[15:8]", valueProviderCallback: _ => Convert(AccelerationX, upperByte: true));
+
+ // Registers.DataOutYLow.Define(this)
+ // .WithValueField(0, 8, FieldMode.Read, name: "Y_ACCEL_DATA[7:2]", valueProviderCallback: _ => Convert(AccelerationY, upperByte: false));
+
+ // Registers.DataOutYHigh.Define(this)
+ // .WithValueField(0, 8, FieldMode.Read, name: "Y_ACCEL_DATA[15:8]", valueProviderCallback: _ => Convert(AccelerationY, upperByte: true));
+
+ // Registers.DataOutZLow.Define(this)
+ // .WithValueField(0, 8, FieldMode.Read, name: "Z_ACCEL_DATA[7:2]", valueProviderCallback: _ => Convert(AccelerationZ, upperByte: false));
+
+ // Registers.DataOutZHigh.Define(this)
+ // .WithValueField(0, 8, FieldMode.Read, name: "Z_ACCEL_DATA[15:8]", valueProviderCallback: _ => Convert(AccelerationZ, upperByte: true));
+
+ // Registers.StatusEventDetection.Define(this) //RO
+ // .WithFlag(0, out readyPending, FieldMode.Read, name: "XYZ_DATA_AVAILABLE")
+ // .WithTaggedFlag("FREE_FALL_EVENT_DETECT", 1)
+ // .WithTaggedFlag("CHANGE_IN_POSITION_DETECT", 2)
+ // .WithTaggedFlag("SINGLE_TAP_EVENT_DETECT", 3)
+ // .WithTaggedFlag("DOUBLE_TAP_EVENT_DETECT", 4)
+ // .WithTaggedFlag("SLEEP_EVENT_DETECT", 5)
+ // .WithTaggedFlag("WAKEUP_EVENT_DETECT", 6)
+ // .WithTaggedFlag("FIFO_REACH_THRESHOLD", 7);
+ }
+
+ private void RegistersAutoIncrement()
+ {
+ // if(regAddress >= Registers.DataOutXLow && regAddress < Registers.DataOutZHigh)
+ // {
+ // regAddress = (Registers)((int)regAddress + 1);
+ // this.Log(LogLevel.Noisy, "Auto-incrementing to the next register 0x{0:X} - {0}", regAddress);
+ // }
+ }
+
+ private void UpdateInterrupts()
+ {
+ var status = readyEnabled.Value && readyPending.Value;
+ this.Log(LogLevel.Noisy, "Setting IRQ to {0}", status);
+ IRQ.Set(status);
+ }
+
+ // private decimal GetSenesorSensitivity()
+ // {
+ // decimal gain = SensorSensitivity;
+ // switch(fullScale.Value)
+ // {
+ // case (uint)FullScaleSelect.fullScale2g:
+ // gain = SensorSensitivity;
+ // break;
+ // case (uint)FullScaleSelect.fullScale16g:
+ // gain = 8 * SensorSensitivity;
+ // break;
+ // case (uint)FullScaleSelect.fullScale4g:
+ // gain = 2 * SensorSensitivity;
+ // break;
+ // case (uint)FullScaleSelect.fullScale8g:
+ // gain = 4 * SensorSensitivity;
+ // break;
+ // default:
+ // gain = SensorSensitivity;
+ // break;
+ // }
+ // return gain;
+ // }
+
+ // private bool IsAccelerationOutOfRange(decimal acceleration)
+ // {
+ // // This range protects from the overflow of the short variables in the 'Convert' function.
+ // if (acceleration < MinAcceleration || acceleration > MaxAcceleration)
+ // {
+ // this.Log(LogLevel.Warning, "Acceleration is out of range, use value from the range <-19.5;19.5>");
+ // return true;
+ // }
+ // return false;
+ // }
+
+ // private byte Convert(decimal value, bool upperByte)
+ // {
+ // byte result = 0;
+ // decimal gain = GetSenesorSensitivity();
+ // value = (value * 1000 / gain) / GravitationalConst;
+ // var valueAsShort = (short)value;
+
+ // if(upperByte)
+ // {
+ // result = (byte)(valueAsShort >> 8);
+ // }
+ // else
+ // {
+ // if(highFreqDataRateMode.Value &&
+ // outDataRate.Value >= (byte)DataRateModeStartRange.HighFreqDataRateStartRange &&
+ // outDataRate.Value < (byte)DataRateModeStartRange.LowPowerDataRateStartRange)
+ // {
+ // result = (byte)(valueAsShort & (byte)CoverBytes.HighFreqMode);
+ // this.Log(LogLevel.Noisy, "High frequencies mode is selected.");
+ // }
+ // else if(outDataRate.Value >= (byte)DataRateModeStartRange.LowPowerDataRateStartRange)
+ // {
+ // result = (byte)(valueAsShort & (byte)CoverBytes.LowPowerMode);
+ // this.Log(LogLevel.Noisy, "Low power mode is selected.");
+ // }
+ // else
+ // {
+ // result = (byte)(valueAsShort & (byte)CoverBytes.NoneExtraModes);
+ // this.Log(LogLevel.Noisy, "High frequencies and low power modes aren't selected.");
+ // }
+ // }
+ // return result;
+ // }
+
+ private byte TwoComplementSignConvert(decimal temp)
+ {
+ byte tempAsByte = Decimal.ToByte(temp);
+ if(temp < 0)
+ {
+ byte twoComplementTemp = (byte)(~tempAsByte + 1);
+ return twoComplementTemp;
+ }
+ return tempAsByte;
+ }
+
+ private IFlagRegisterField readyPending;
+ private IFlagRegisterField readyEnabled;
+ private IFlagRegisterField highFreqDataRateMode;
+ private IValueRegisterField outDataRate;
+ private IValueRegisterField fullScale;
+ private Registers regAddress;
+
+ private ushort controlStatus;
+ private ushort response;
+
+ private enum Registers : byte
+ {
+ Cntl = 0x00,
+ // Reserved: 0x01
+ Temp = 0x02,
+ // Reserved: 0x03
+ Volt = 0x04,
+ // Reserved: 0x05
+ Flag = 0x06,
+ // Reserved: 0x07
+ NomCap = 0x08,
+ // Reserved: 0x09
+ FullCap = 0x0A,
+ // Reserved: 0x0B
+ Rm = 0x0C,
+ // Reserved: 0x0d
+ Fcc = 0x0e,
+ // Reserved: 0x0f
+ AvgCur = 0x10,
+ // Reserved: 0x11
+ SbyCur = 0x12,
+ // Reserved: 0x13
+ MaxCur = 0x14,
+ // Reserved: 0x15 - 0x17
+ AvgPwr = 0x18,
+ // Reserved: 0x19 = 0x1b
+ Soc = 0x1c,
+ // Reserved: 0x1d
+ IntTemp = 0x1e,
+ // Reserved: 0x1f
+ Soh = 0x20,
+ }
+ }
+}
diff --git a/emulation/peripherals/BetrustedEcI2C.cs b/emulation/peripherals/BetrustedEcI2C.cs
new file mode 100644
index 000000000..be6f6dc7b
--- /dev/null
+++ b/emulation/peripherals/BetrustedEcI2C.cs
@@ -0,0 +1,344 @@
+//
+// Copyright (c) 2010-2018 Antmicro
+// Copyright (c) 2021 Precursor Project
+//
+// This file is licensed under the MIT License.
+// Full license text is available in 'licenses/MIT.txt'.
+//
+using System.Collections.Generic;
+using System;
+using Antmicro.Renode.Peripherals.Bus;
+using Antmicro.Renode.Core.Structure.Registers;
+using Antmicro.Renode.Core.Structure;
+using Antmicro.Renode.Core;
+using Antmicro.Renode.Logging;
+using Antmicro.Renode.Time;
+using System.Threading;
+
+// This project is a reimplementation of the OpenCoresI2C module.
+
+namespace Antmicro.Renode.Peripherals.I2C
+{
+ [AllowedTranslations(AllowedTranslation.ByteToDoubleWord)]
+ public class BetrustedEcI2C : SimpleContainer, IDoubleWordPeripheral, IKnownSize
+ {
+ public BetrustedEcI2C(Machine machine) : base(machine)
+ {
+ dataToSlave = new Queue();
+ dataFromSlave = new Queue();
+ IRQ = new GPIO();
+
+ irqTimeoutCallback = new ClockEntry((ulong)5, ClockEntry.FrequencyToRatio(machine, 1000), this.FinishTransaction, machine, "Irq Scheduler");
+
+ var registersMap = new Dictionary()
+ {
+ {(long)Registers.Prescale, new DoubleWordRegister(this)
+ .WithValueField(0, 16, FieldMode.Read | FieldMode.Write)
+ },
+
+ {(long)Registers.Control, new DoubleWordRegister(this)
+ .WithFlag(7, out enabled)
+ .WithTag("Interrupt enable", 6, 1)
+ .WithReservedBits(0, 6)
+ },
+
+ {(long)Registers.Txr, new DoubleWordRegister(this)
+ .WithValueField(0, 8, out transmitBuffer, FieldMode.Write)
+ },
+
+ {(long)Registers.Rxr, new DoubleWordRegister(this)
+ .WithValueField(0, 8, out receiveBuffer, FieldMode.Read)
+ },
+
+ {(long)Registers.Status, new DoubleWordRegister(this)
+ .WithFlag(7, out receivedAckFromSlaveNegated, FieldMode.Read)
+ .WithFlag(6, FieldMode.Read, valueProviderCallback: _ => false, name: "Busy")
+ .WithFlag(5, FieldMode.Read, valueProviderCallback: _ => false, name: "Arbitration lost")
+ .WithReservedBits(2, 3)
+ .WithFlag(1, FieldMode.Read, valueProviderCallback: _ => false, name: "Transfer in progress")
+ .WithFlag(0, out i2cIrqStatus, FieldMode.Read)
+ },
+
+ {(long)Registers.Command, new DoubleWordRegister(this)
+ .WithFlag(7, out generateStartCondition, FieldMode.Write)
+ .WithFlag(6, out generateStopCondition, FieldMode.Write)
+ .WithFlag(5, out readFromSlave, FieldMode.Write)
+ .WithFlag(4, out writeToSlave, FieldMode.Write)
+ .WithFlag(3, FieldMode.Read, name: "ACK", valueProviderCallback: _ => true)
+ // .WithTag("ACK", 3, 1)
+ .WithReservedBits(1, 2)
+ .WithFlag(0, FieldMode.Write, writeCallback: (_, __) => i2cIrqStatus.Value = false)
+ .WithWriteCallback((_, __) =>
+ {
+ if(!enabled.Value)
+ {
+ return;
+ }
+
+ if(generateStartCondition.Value)
+ {
+ generateStartCondition.Value = false;
+ if(transactionInProgress)
+ {
+ // repeated start - finish previous transaction first
+ SendDataToSlave();
+ }
+ else
+ {
+ transactionInProgress = true;
+ }
+
+ dataFromSlave.Clear();
+ if (selectedSlave != null) {
+ selectedSlave.FinishTransmission();
+ }
+
+ if(!TryResolveSelectedSlave(out selectedSlave))
+ {
+ return;
+ }
+ }
+
+ if(writeToSlave.Value)
+ {
+ writeToSlave.Value = false;
+ HandleWriteToSlaveCommand();
+ }
+
+ if(readFromSlave.Value)
+ {
+ readFromSlave.Value = false;
+ HandleReadFromSlaveCommand();
+ }
+
+ if (transactionInProgress && 0 == Interlocked.CompareExchange(ref irqTimeoutCallbackQueued, 1, 0)) {
+ // this.Log(LogLevel.Error, "I2C: Adding clock entry for {0}",this.irqTimeoutCallback);
+ try {
+ machine.ClockSource.AddClockEntry(irqTimeoutCallback);
+ } catch (ArgumentException ex) {
+ this.Log(LogLevel.Error, "Unable to add clock entry for timeout (queued: {0}): {1}", ex, irqTimeoutCallbackQueued);
+ // this.Log(LogLevel.Error, "I2C: Done adding clock entry for {0}",this.irqTimeoutCallback);
+ }
+ }
+
+ if(generateStopCondition.Value)
+ {
+ if (selectedSlave != null) {
+ selectedSlave.FinishTransmission();
+ }
+
+ generateStopCondition.Value = false;
+ if(!transactionInProgress)
+ {
+ return;
+ }
+
+ SendDataToSlave();
+ transactionInProgress = false;
+ }
+
+ shouldSendTxRxIrq = true;
+ })
+ },
+ {(long)Registers.EventStatus, new DoubleWordRegister(this)
+ .WithFlag(3, FieldMode.Read, name: "USBCC_INT_STATUS", valueProviderCallback: _ => usbccIrqStatus)
+ .WithFlag(2, FieldMode.Read, name: "GYRO_INT_STATUS", valueProviderCallback: _ => gyroIrqStatus)
+ .WithFlag(1, FieldMode.Read, name: "GG_INT_STATUS", valueProviderCallback: _ => ggIrqStatus)
+ .WithFlag(0, FieldMode.Read, name: "I2C_INT_STATUS", valueProviderCallback: _ => i2cIrqStatus.Value)
+ },
+
+ {(long)Registers.EventPending, new DoubleWordRegister(this)
+ .WithFlag(3, out usbccIrqPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "USBCC_INT_PENDING", changeCallback: (_, __) => UpdateInterrupts())
+ .WithFlag(2, out gyroIrqPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "GYRO_INT_PENDING", changeCallback: (_, __) => UpdateInterrupts())
+ .WithFlag(1, out ggIrqPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "GG_INT_PENDING", changeCallback: (_, __) => UpdateInterrupts())
+ .WithFlag(0, out i2cIrqPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "I2C_INT_PENDING", changeCallback: (_, __) => UpdateInterrupts())
+ },
+
+ {(long)Registers.EventEnable, new DoubleWordRegister(this)
+ .WithFlag(3, out usbccIrqEnabled, name: "USBCC_INT_ENABLE", changeCallback: (_, __) => UpdateInterrupts())
+ .WithFlag(2, out gyroIrqEnabled, name: "GYRO_INT_ENABLE", changeCallback: (_, __) => UpdateInterrupts())
+ .WithFlag(1, out ggIrqEnabled, name: "GG_INT_ENABLE", changeCallback: (_, __) => UpdateInterrupts())
+ .WithFlag(0, out i2cIrqEnabled, name: "I2C_INT_ENABLE", changeCallback: (_, __) => UpdateInterrupts())
+ }
+ };
+
+ registers = new DoubleWordRegisterCollection(this, registersMap);
+ UpdateInterrupts();
+ }
+
+ private void FinishTransaction()
+ {
+ // this.Log(LogLevel.Error, "I2C: Removing clock entry for {0}",this.irqTimeoutCallback);
+ machine.ClockSource.RemoveClockEntry(FinishTransaction);
+ irqTimeoutCallbackQueued = 0;
+ if (shouldSendTxRxIrq)
+ {
+ shouldSendTxRxIrq = false;
+ txRxDoneIrqStatus = true;
+ UpdateInterrupts();
+ txRxDoneIrqStatus = false;
+ }
+ }
+
+ public override void Reset()
+ {
+ registers.Reset();
+ dataToSlave.Clear();
+ dataFromSlave.Clear();
+ UpdateInterrupts();
+ }
+
+ public uint ReadDoubleWord(long offset)
+ {
+ return registers.Read(offset);
+ }
+
+ public void WriteDoubleWord(long offset, uint value)
+ {
+ registers.Write(offset, value);
+ }
+
+ private void UpdateInterrupts()
+ {
+ if (i2cIrqStatus.Value)
+ {
+ i2cIrqPending.Value = true;
+ }
+ if (ggIrqStatus)
+ {
+ ggIrqPending.Value = true;
+ }
+ if (gyroIrqStatus)
+ {
+ gyroIrqPending.Value = true;
+ }
+ if (usbccIrqStatus)
+ {
+ usbccIrqPending.Value = true;
+ }
+ // this.Log(LogLevel.Noisy, " Setting status: {0}, enabled: {1}, pending: {2}", txRxDoneIrqStatus, txRxDoneIrqEnabled.Value, txRxDoneIrqPending.Value);
+ IRQ.Set((i2cIrqPending.Value && i2cIrqEnabled.Value)
+ || (ggIrqPending.Value && ggIrqEnabled.Value)
+ || (gyroIrqPending.Value && gyroIrqEnabled.Value)
+ || (usbccIrqPending.Value && usbccIrqEnabled.Value)
+ );
+ }
+
+ public GPIO IRQ
+ {
+ get;
+ private set;
+ }
+
+ public long Size { get { return 0x800; } }
+
+ private bool TryResolveSelectedSlave(out II2CPeripheral selectedSlave)
+ {
+ var slaveAddress = (byte)(transmitBuffer.Value >> 1);
+ if (!ChildCollection.TryGetValue(slaveAddress, out selectedSlave))
+ {
+ this.Log(LogLevel.Warning, "Addressing unregistered slave: 0x{0:X}", slaveAddress);
+ receivedAckFromSlaveNegated.Value = true;
+ return false;
+ }
+
+ receivedAckFromSlaveNegated.Value = false;
+ return true;
+ }
+
+ private void HandleReadFromSlaveCommand()
+ {
+ if (dataFromSlave.Count == 0)
+ {
+ foreach (var b in selectedSlave.Read())
+ {
+ dataFromSlave.Enqueue(b);
+ }
+
+ if (dataFromSlave.Count == 0)
+ {
+ this.Log(LogLevel.Warning, "Trying to read from slave, but no data is available");
+ receiveBuffer.Value = 0;
+ return;
+ }
+ }
+
+ receiveBuffer.Value = dataFromSlave.Dequeue();
+ UpdateInterrupts();
+ }
+
+ private void SendDataToSlave()
+ {
+ if (dataToSlave.Count == 0 || selectedSlave == null)
+ {
+ this.Log(LogLevel.Warning, "Trying to send data to slave, but either no data is available or the slave is not selected");
+ return;
+ }
+
+ selectedSlave.Write(dataToSlave.ToArray());
+ dataToSlave.Clear();
+ }
+
+ private void HandleWriteToSlaveCommand()
+ {
+ if (!transactionInProgress)
+ {
+ this.Log(LogLevel.Warning, "Writing to slave without generating START signal");
+ return;
+ }
+
+ dataToSlave.Enqueue((byte)transmitBuffer.Value);
+ i2cIrqStatus.Value = true;
+ UpdateInterrupts();
+ }
+
+ private bool transactionInProgress;
+ private II2CPeripheral selectedSlave;
+
+ private readonly Queue dataToSlave;
+ private readonly Queue dataFromSlave;
+ private readonly IValueRegisterField receiveBuffer;
+ private readonly IValueRegisterField transmitBuffer;
+ private readonly IFlagRegisterField readFromSlave;
+ private readonly IFlagRegisterField writeToSlave;
+
+ private IFlagRegisterField i2cIrqEnabled;
+ private IFlagRegisterField ggIrqEnabled;
+ private IFlagRegisterField gyroIrqEnabled;
+ private IFlagRegisterField usbccIrqEnabled;
+ private IFlagRegisterField i2cIrqStatus;
+ private bool ggIrqStatus;
+ private bool gyroIrqStatus;
+ private bool usbccIrqStatus;
+ private IFlagRegisterField i2cIrqPending;
+ private IFlagRegisterField ggIrqPending;
+ private IFlagRegisterField gyroIrqPending;
+ private IFlagRegisterField usbccIrqPending;
+
+ private bool shouldSendTxRxIrq;
+ private bool txRxDoneIrqStatus;
+ private long irqTimeoutCallbackQueued;
+ private readonly IFlagRegisterField enabled;
+ private readonly IFlagRegisterField receivedAckFromSlaveNegated;
+ private readonly IFlagRegisterField generateStartCondition;
+ private readonly IFlagRegisterField generateStopCondition;
+ private readonly DoubleWordRegisterCollection registers;
+ private ClockEntry irqTimeoutCallback;
+
+ private enum Registers
+ {
+ Prescale = 0x0,
+ Control = 0x4,
+ Txr = 0x8,
+ Rxr = 0xC,
+ Command = 0x10,
+ Status = 0x14,
+ BitbangMode = 0x18,
+ Bb = 0x1c,
+ BbR = 0x20,
+ EventStatus = 0x24,
+ EventPending = 0x28,
+ EventEnable = 0x2c
+ }
+ }
+}
diff --git a/emulation/peripherals/BetrustedI2C.cs b/emulation/peripherals/BetrustedI2C.cs
index d9073e202..6ce69496d 100644
--- a/emulation/peripherals/BetrustedI2C.cs
+++ b/emulation/peripherals/BetrustedI2C.cs
@@ -58,6 +58,14 @@ namespace Antmicro.Renode.Peripherals.I2C
.WithFlag(0, out i2cIntIrqStatus, FieldMode.Read)
},
+ {(long)Registers.CoreReset, new DoubleWordRegister(this)
+ .WithFlag(0, FieldMode.Write, writeCallback: (_, do_it) => {
+ if (do_it) {
+ Reset();
+ }
+ })
+ },
+
{(long)Registers.EventStatus, new DoubleWordRegister(this)
.WithFlag(1, FieldMode.Read, name: "TX_RX_DONE_STATUS", valueProviderCallback: _ => txRxDoneIrqStatus)
.WithFlag(0, FieldMode.Read, name: "I2C_INT_STATUS", valueProviderCallback: _ => i2cIntIrqStatus.Value)
@@ -184,16 +192,17 @@ namespace Antmicro.Renode.Peripherals.I2C
private void UpdateInterrupts()
{
- if (i2cIntIrqStatus.Value && i2cIntIrqEnabled.Value)
+ if (i2cIntIrqStatus.Value)
{
i2cIntIrqPending.Value = true;
}
- if (txRxDoneIrqStatus && txRxDoneIrqEnabled.Value)
+ if (txRxDoneIrqStatus)
{
txRxDoneIrqPending.Value = true;
}
// this.Log(LogLevel.Noisy, " Setting status: {0}, enabled: {1}, pending: {2}", txRxDoneIrqStatus, txRxDoneIrqEnabled.Value, txRxDoneIrqPending.Value);
- IRQ.Set(i2cIntIrqPending.Value || txRxDoneIrqPending.Value);
+ IRQ.Set((i2cIntIrqPending.Value && txRxDoneIrqEnabled.Value)
+ || (txRxDoneIrqPending.Value && i2cIntIrqEnabled.Value));
}
public GPIO IRQ
@@ -295,7 +304,7 @@ namespace Antmicro.Renode.Peripherals.I2C
Receive = 0xC,
Command = 0x10,
Status = 0x14,
- Reset = 0x18,
+ CoreReset = 0x18,
EventStatus = 0x1c,
EventPending = 0x20,
EventEnable = 0x24
diff --git a/emulation/peripherals/BetrustedWatchdog.cs b/emulation/peripherals/BetrustedWatchdog.cs
new file mode 100644
index 000000000..959507fec
--- /dev/null
+++ b/emulation/peripherals/BetrustedWatchdog.cs
@@ -0,0 +1,101 @@
+//
+// Copyright (c) 2010-2018 Antmicro
+// Copyright (c) 2011-2015 Realtime Embedded
+//
+// This file is licensed under the MIT License.
+// Full license text is available in 'licenses/MIT.txt'.
+//
+using Antmicro.Renode.Core;
+using Antmicro.Renode.Core.Structure.Registers;
+using Antmicro.Renode.Peripherals.Bus;
+using Antmicro.Renode.Time;
+using System.Threading;
+using System.Collections.Generic;
+using System;
+
+namespace Antmicro.Renode.Peripherals.Timers
+{
+ public sealed class BetrustedWatchdog : BasicDoubleWordPeripheral, IKnownSize
+ {
+ public BetrustedWatchdog(Machine machine) : base(machine)
+ {
+ machine.ClockSource.AddClockEntry(new ClockEntry(10, ClockEntry.FrequencyToRatio(this, 1000), OnTick, this, String.Empty));
+ var registersMap = new Dictionary()
+ {
+ {(long)Registers.Watchdog, new DoubleWordRegister(this)
+ .WithFlag(1, FieldMode.Read | FieldMode.Write, (_, enable) => {
+ if (enable) {
+ enabled = true;
+ }
+ })
+ .WithFlag(0, FieldMode.Read | FieldMode.Write, (_, should_reset) => {
+ Interlocked.Exchange(ref counter, 0);
+ })
+ },
+ {(long)Registers.Period, new DoubleWordRegister(this)
+ .WithValueField(0, 32, FieldMode.Read | FieldMode.Write, (_, period) => {
+ this.reset_target = XilinxClockToMs(period);
+ })
+ },
+ {(long)Registers.State, new DoubleWordRegister(this)
+ .WithFlag(0, FieldMode.Read, valueProviderCallback: (_) => enabled, name: "ENABLED")
+ .WithFlag(1, FieldMode.Read, valueProviderCallback: (_) => false, name: "ARMED1")
+ .WithFlag(2, FieldMode.Read, valueProviderCallback: (_) => false, name: "ARMED2")
+ .WithFlag(3, FieldMode.Read, valueProviderCallback: (_) => false, name: "DISARMED")
+ },
+ };
+
+ registers = new DoubleWordRegisterCollection(this, registersMap);
+ Reset();
+ }
+ private void OnTick()
+ {
+ Interlocked.Increment(ref counter);
+ if (((uint)counter) >= this.reset_target) {
+ this.machine.RequestReset();
+ }
+ }
+
+ public override uint ReadDoubleWord(long offset)
+ {
+ return registers.Read(offset);
+ }
+
+ public override void WriteDoubleWord(long offset, uint value)
+ {
+ registers.Write(offset, value);
+ }
+ public override void Reset()
+ {
+ registers.Reset();
+ enabled = false;
+ counter = 0;
+ reset_target = XilinxClockToMs(325000000);
+ }
+
+ // Convert "approximately 65MHz" ticks to milliseconds
+ private uint XilinxClockToMs(uint xilinx_clocks)
+ {
+ return (uint) ((((ulong)xilinx_clocks) * 1000) / 65000000);
+ }
+
+ public long Size
+ {
+ get
+ {
+ return 0xC;
+ }
+ }
+
+ private int counter;
+ private uint reset_target;
+ private bool enabled;
+ private readonly DoubleWordRegisterCollection registers;
+ private enum Registers
+ {
+ Watchdog = 0x0,
+ Period = 0x4,
+ State = 0x8,
+ }
+ }
+}
\ No newline at end of file
diff --git a/emulation/peripherals/SPIHub.cs b/emulation/peripherals/SPIHub.cs
new file mode 100644
index 000000000..1f1c38991
--- /dev/null
+++ b/emulation/peripherals/SPIHub.cs
@@ -0,0 +1,113 @@
+//
+// Copyright (c) 2010-2018 Antmicro
+// Copyright (c) 2011-2015 Realtime Embedded
+//
+// This file is licensed under the MIT License.
+// Full license text is available in 'licenses/MIT.txt'.
+//
+using System;
+using Antmicro.Renode.Core;
+using System.Linq;
+using Antmicro.Renode.Time;
+using Antmicro.Renode.Exceptions;
+using Antmicro.Migrant.Hooks;
+using Antmicro.Renode.Peripherals.SPI;
+using System.Collections.Generic;
+
+namespace Antmicro.Renode.Peripherals.UART
+{
+ public static class SPIHubExtensions
+ {
+ public static void CreateSPIHub(this Emulation emulation, string name)
+ {
+ emulation.ExternalsManager.AddExternal(new SPIBus(), name);
+ }
+ }
+
+ public sealed class SPIBus : IExternal, IHasOwnLife, IConnectable
+ {
+ public SPIBus()
+ {
+ peripherals = new Dictionary>();
+ locker = new object();
+ }
+
+ public void AttachTo(ISPIPeripheral peripheral)
+ {
+ lock (locker)
+ {
+ if (peripherals.ContainsKey(peripheral))
+ {
+ throw new RecoverableException("Cannot attach to the provided UART as it is already registered in this hub.");
+ }
+
+ var d = (Func)(x => HandleByteTransmitted(x, peripheral));
+ peripherals.Add(peripheral, d);
+ // peripheral.CharReceived += d;
+ }
+ }
+
+ public void Start()
+ {
+ Resume();
+ }
+
+ public void Pause()
+ {
+ started = false;
+ }
+
+ public void Resume()
+ {
+ started = true;
+ }
+
+ public void DetachFrom(ISPIPeripheral peripheral)
+ {
+ lock (locker)
+ {
+ if (!peripherals.ContainsKey(peripheral))
+ {
+ throw new RecoverableException("Cannot detach the provided SPI peripheral as it is not registered in this bus.");
+ }
+
+ // uart.CharReceived -= uarts[uart];
+ peripherals.Remove(peripheral);
+ }
+ }
+
+ private byte HandleByteTransmitted(byte obj, ISPIPeripheral peripheral)
+ {
+ if (!started)
+ {
+ return 0;
+ }
+
+ lock (locker)
+ {
+ foreach (var item in uarts.Where(x => x.Key != sender).Select(x => x.Key))
+ {
+ item.GetMachine().HandleTimeDomainEvent(item.WriteChar, obj, TimeDomainsManager.Instance.VirtualTimeStamp);
+ }
+ }
+ return 0;
+ }
+
+ [PostDeserialization]
+ private void ReattachUARTsAfterDeserialization()
+ {
+ lock (locker)
+ {
+ foreach (var uart in uarts)
+ {
+ uart.Key.CharReceived += uart.Value;
+ }
+ }
+ }
+
+ private bool started;
+ private readonly Dictionary> peripherals;
+ private readonly object locker;
+ }
+}
+
diff --git a/emulation/soc/betrusted-soc.repl b/emulation/soc/betrusted-soc.repl
index 1619bba31..f8f6b39c6 100755
--- a/emulation/soc/betrusted-soc.repl
+++ b/emulation/soc/betrusted-soc.repl
@@ -5,15 +5,15 @@ cpu: CPU.VexRiscv @ sysbus
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
PerformanceInMips: 120
// Platform Peripherals
-// Unrecognized peripheral: reboot
+// Unrecognized peripheral: reboot @ 0xf0000000
timer0: Timers.LiteX_Timer_32 @ sysbus 0xf0001000
frequency: 100000000
-> cpu @ 1000
-// Unrecognized peripheral: crg
+// Unrecognized peripheral: crg @ 0xf0002000
-// Unrecognized peripheral: gpio
+// Unrecognized peripheral: gpio @ 0xf0003000
uart: UART.LiteX_UART @ sysbus 0xf0005000
-> cpu @ 1002
@@ -24,47 +24,47 @@ console: UART.LiteX_UART @ sysbus 0xf0007000
app_uart: UART.LiteX_UART @ sysbus 0xf0009000
-> cpu @ 1004
-// Unrecognized peripheral: info
+// Unrecognized peripheral: info @ 0xf000a000
-// Unrecognized peripheral: sram_ext
+// Unrecognized peripheral: sram_ext @ 0xf000b000
memlcd: Video.BetrustedLCD @ sysbus 0xf000c000
memAddr: 0xb0000000
memSize: 0x5c20
-// Unrecognized peripheral: com
+// Unrecognized peripheral: com @ 0xf000d000
i2c: I2C.BetrustedI2C @ sysbus 0xf000e000
-> cpu @ 1006
-// Unrecognized peripheral: btevents
+// Unrecognized peripheral: btevents @ 0xf000f000
-// Unrecognized peripheral: messible
+// Unrecognized peripheral: messible @ 0xf0010000
-// Unrecognized peripheral: messible2
+// Unrecognized peripheral: messible2 @ 0xf0011000
ticktimer: Timers.TickTimer @ sysbus 0xf0012000
-> cpu @ 1008
-// Unrecognized peripheral: susres
+// Unrecognized peripheral: susres @ 0xf0013000
-// Unrecognized peripheral: power
+// Unrecognized peripheral: power @ 0xf0014000
spinor_soft_int: Miscellaneous.SpinorSoftInt @ sysbus 0xf0015000
-> cpu @ 1011
-// Unrecognized peripheral: spinor
+// Unrecognized peripheral: spinor @ 0xf0016000
keyboard: Input.BetrustedKbd @ sysbus 0xf0017000
-> cpu @ 1013
-// Unrecognized peripheral: keyinject
+// Unrecognized peripheral: keyinject @ 0xf0018000
-// Unrecognized peripheral: seed
+// Unrecognized peripheral: seed @ 0xf0019000
keyrom: Miscellaneous.Keyrom @ sysbus 0xf001a000
-// Unrecognized peripheral: audio
+// Unrecognized peripheral: audio @ 0xf001b000
trng_kernel: Miscellaneous.BetrustedRNGKernel @ sysbus 0xf001c000
-> cpu @ 1015
@@ -72,7 +72,7 @@ trng_kernel: Miscellaneous.BetrustedRNGKernel @ sysbus 0xf001c000
trng_server: Miscellaneous.BetrustedRNGServer @ sysbus 0xf001d000
-> cpu @ 1016
-// Unrecognized peripheral: trng
+// Unrecognized peripheral: trng @ 0xf001e000
sha512: Miscellaneous.Sha512 @ sysbus 0xf001f000
memAddr: 0xe0002000
@@ -84,15 +84,15 @@ engine: Miscellaneous.Engine @ sysbus 0xf0020000
memSize: 0x20000
-> cpu @ 1018
-// Unrecognized peripheral: jtag
+// Unrecognized peripheral: jtag @ 0xf0021000
-// Unrecognized peripheral: wdt
+wdt: Timers.BetrustedWatchdog @ sysbus 0xf0022000
-// Unrecognized peripheral: d11ctime
+// Unrecognized peripheral: d11ctime @ 0xf0023000
wfi: Miscellaneous.BetrustedWfi @ sysbus 0xf0024000
-// Unrecognized peripheral: identifier_mem
+// Unrecognized peripheral: identifier_mem @ 0xf0025000
// Physical base addresses of memory regions
diff --git a/emulation/xous-release.resc b/emulation/xous-release.resc
index 251632e31..40b31a80d 100644
--- a/emulation/xous-release.resc
+++ b/emulation/xous-release.resc
@@ -9,7 +9,10 @@ using sysbus
# Add peripherals that are defined in C#. You must restart Renode
# if you modify these files.
i @peripherals/ABRTCMC.cs
+i @peripherals/BetrustedEcI2C.cs
i @peripherals/BetrustedI2C.cs
+i @peripherals/BetrustedWatchdog.cs
+i @peripherals/BQ27421.cs
i @peripherals/engine.cs
i @peripherals/keyboard.cs
i @peripherals/keyrom.cs
@@ -46,9 +49,9 @@ sysbus Tag <0xB0000000, 0xB0006000> "Framebuffer"
# logLevel -1 sha512
# Silence COM and WDT and WFI
-sysbus SilenceRange <0xF000D000, 0xF000DFFF>
-sysbus SilenceRange <0xF0021000, 0xF0021FFF>
-sysbus SilenceRange <0xF0023000, 0xF0023FFF>
+# sysbus SilenceRange <0xF000D000, 0xF000DFFF>
+# sysbus SilenceRange <0xF0021000, 0xF0021FFF>
+# sysbus SilenceRange <0xF0023000, 0xF0023FFF>
# The macro `reset` gets called implicitly when running `machine Reset`
macro reset
@@ -80,8 +83,7 @@ macro reset
"""
runMacro $reset
-# Silence I2C for now while we work on the driver
-sysbus SilenceRange <0xB0000000, 0xB000FFFF>
+logLevel -1 bq27421
mach clear
diff --git a/svd2repl/src/generate.rs b/svd2repl/src/generate.rs
index 305ed89e3..c448921b7 100644
--- a/svd2repl/src/generate.rs
+++ b/svd2repl/src/generate.rs
@@ -592,7 +592,7 @@ fn print_peripherals(
writeln!(out, " -> cpu @ {}", 1000 + irq.value)?;
}
} else {
- writeln!(out, "// Unrecognized peripheral: {}", lc_name)?;
+ writeln!(out, "// Unrecognized peripheral: {} @ 0x{:08x}", lc_name, peripheral.base)?;
}
writeln!(out)?;
}
@@ -645,6 +645,7 @@ pub fn generate(src: T, dest: &mut U) -> Result<(), ParseErro
cs_peripherals.insert("ticktimer", "Timers.TickTimer");
cs_peripherals.insert("uart", "UART.LiteX_UART");
cs_peripherals.insert("wfi", "Miscellaneous.BetrustedWfi");
+ cs_peripherals.insert("wdt", "Timers.BetrustedWatchdog");
print_header(dest).or(Err(ParseError::WriteError))?;
print_peripherals(