shodan_infrastructure/OpenTitan2_UART.cs - sim/config - Git at Google

 //
 // 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.Registers;
 using Antmicro.Renode.Logging;
 using Antmicro.Renode.Peripherals.Bus;

 namespace Antmicro.Renode.Peripherals.UART
 {
     // This model currently does not support timeout feature, rx break detection and software tx pin override
     public class OpenTitan2_UART : UARTBase, IDoubleWordPeripheral, IKnownSize
     {
         public OpenTitan2_UART(Machine machine) : base(machine)
         {
             TxWatermarkIRQ = new GPIO();
             RxWatermarkIRQ = new GPIO();
             TxEmptyIRQ = new GPIO();
             RxOverflowIRQ = new GPIO();
             RxFrameErrorIRQ = new GPIO();
             RxBreakErrorIRQ = new GPIO();
             RxTimeoutIRQ = new GPIO();
             RxParityErrorIRQ = new GPIO();

             registers = new DoubleWordRegisterCollection(this, BuildRegisterMap());
             txQueue = new Queue<byte>();
         }

         public uint ReadDoubleWord(long offset)
         {
             return registers.Read(offset);
         }

         public void WriteDoubleWord(long offset, uint value)
         {
             registers.Write(offset, value);
         }

         public override void WriteChar(byte value)
         {
             if(lineLoopbackEnabled.Value)
             {
                 txOngoing = true;
                 TransmitCharacter(value);
                 this.Log(LogLevel.Noisy, "Line Loopback Enabled, byte echoed by hardware.");
             }

             if(systemLoopbackEnabled.Value)
             {
                 this.Log(LogLevel.Warning, "Sytem Loopback Enabled, incoming byte not queued.");
                 return;
             }

             if(!rxEnabled.Value)
             {
                 this.Log(LogLevel.Warning, "CTRL.RX is unset, incoming byte not queued.");
                 return;
             }

             if(Count < rxFIFOCapacity)
             {
                 rxOverflowPending.Value = false;
                 base.WriteChar(value);
             }
             else
             {
                 rxOverflowPending.Value = true;
                 this.Log(LogLevel.Noisy, "RX FIFO overflowed, queueing incoming byte anyway.");
                 base.WriteChar(value);
             }
             UpdateInterrupts();
         }

         public override void Reset()
         {
             base.Reset();
             registers.Reset();
             txQueue.Clear();
             UpdateInterrupts();

             txOngoing = false;
             txWatermarkCrossed = false;
         }

         public long Size => 0x30;

         public GPIO TxWatermarkIRQ { get; }
         public GPIO RxWatermarkIRQ { get; }
         public GPIO TxEmptyIRQ { get; }
         public GPIO RxOverflowIRQ { get; }
         public GPIO RxFrameErrorIRQ { get; }
         public GPIO RxBreakErrorIRQ { get; }
         public GPIO RxTimeoutIRQ { get; }
         public GPIO RxParityErrorIRQ { get; }

         public override Bits StopBits => Bits.One;

         public override Parity ParityBit => parityTypeField.Value == ParityType.Odd ? Parity.Odd : Parity.Even;

         public override uint BaudRate => (uint)((baudClockRate.Value * fixedClockFrequency) >> 20);

         protected override void CharWritten()
         {
             // intentionally left empty
         }

         protected override void QueueEmptied()
         {
             // intentionally left empty
         }

         private Dictionary<long, DoubleWordRegister> BuildRegisterMap()
         {
             return new Dictionary<long, DoubleWordRegister>
             {
                 {(long)Registers.InterruptState, new DoubleWordRegister(this)
                     .WithFlag(0, out txWatermarkPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.tx_watermark")
                     .WithFlag(1, out rxWatermarkPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.rx_watermark")
                     .WithFlag(2, out txEmptyPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.tx_empty")
                     .WithFlag(3, out rxOverflowPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.rx_overflow")
                     .WithFlag(4, out rxFrameErrorPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.rx_frame_err")
                     .WithFlag(5, out rxBreakErrorPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.rx_break_err")
                     .WithFlag(6, out rxTimeoutPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.rx_timeout")
                     .WithFlag(7, out rxParityErrorPending, FieldMode.Read | FieldMode.WriteOneToClear, name: "INTR_STATE.rx_parity_err")
                     .WithReservedBits(8, 24)
                     .WithWriteCallback((_, __) => UpdateInterrupts())
                 },
                 {(long)Registers.InterruptEnable, new DoubleWordRegister(this)
                     .WithFlag(0, out txWatermarkEnabled, name: "INTR_ENABLE.tx_watermark")
                     .WithFlag(1, out rxWatermarkEnabled, name: "INTR_ENABLE.rx_watermark")
                     .WithFlag(2, out txEmptyEnabled, name: "INTR_ENABLE.tx_empty")
                     .WithFlag(3, out rxOverflowEnabled, name: "INTR_ENABLE.rx_overflow")
                     .WithFlag(4, out rxFrameErrorEnabled, name: "INTR_ENABLE.rx_frame_err")
                     .WithFlag(5, out rxBreakErrorEnabled, name: "INTR_ENABLE.rx_break_err")
                     .WithFlag(6, out rxTimeoutEnabled, name: "INTR_ENABLE.rx_timeout")
                     .WithFlag(7, out rxParityErrorEnabled, name: "INTR_ENABLE.rx_parity_err")
                     .WithReservedBits(8, 24)
                     .WithWriteCallback((_, __) => UpdateInterrupts())
                 },
                 {(long)Registers.InterruptTest, new DoubleWordRegister(this)
                     .WithFlag(0, FieldMode.Write, writeCallback: (_, val) => { txWatermarkPending.Value |= val; },  name: "INTR_TEST.tx_watermark")
                     .WithFlag(1, FieldMode.Write, writeCallback: (_, val) => { rxWatermarkPending.Value |= val; },  name: "INTR_TEST.rx_watermark")
                     .WithFlag(2, FieldMode.Write, writeCallback: (_, val) => { txEmptyPending.Value |= val; },  name: "INTR_TEST.tx_empty")
                     .WithFlag(3, FieldMode.Write, writeCallback: (_, val) => { rxOverflowPending.Value |= val; },  name: "INTR_TEST.rx_overflow")
                     .WithFlag(4, FieldMode.Write, writeCallback: (_, val) => { rxFrameErrorPending.Value |= val; },  name: "INTR_TEST.rx_frame_err")
                     .WithFlag(5, FieldMode.Write, writeCallback: (_, val) => { rxBreakErrorPending.Value |= val; },  name: "INTR_TEST.rx_break_err")
                     .WithFlag(6, FieldMode.Write, writeCallback: (_, val) => { rxTimeoutPending.Value |= val; },  name: "INTR_TEST.rx_timeout")
                     .WithFlag(7, FieldMode.Write, writeCallback: (_, val) => { rxParityErrorPending.Value |= val; },  name: "INTR_TEST.rx_parity_err")
                     .WithReservedBits(8, 24)
                     .WithWriteCallback((_, __) => UpdateInterrupts())
                 },
                 {(long)Registers.Control, new DoubleWordRegister(this)
                     .WithFlag(0, out txEnabled, name: "CTRL.TX", writeCallback: (_, val) =>
                     {
                         if(val)
                         {
                             if(!lineLoopbackEnabled.Value)
                             {
                                 foreach(byte value in txQueue)
                                 {
                                     txOngoing = true;
                                     TransmitCharacter(value);
                                 }
                             }
                             txQueue.Clear();
                             UpdateInterrupts();
                         }
                     })
                     .WithFlag(1, out rxEnabled, name: "CTRL.RX")
                     .WithFlag(2, out noiseFilterEnabled, name: "CTRL.NF")
                     .WithReservedBits(3, 1)
                     .WithFlag(4, out systemLoopbackEnabled, name: "CTRL.SLPBK")
                     .WithFlag(5, out lineLoopbackEnabled, name: "CTRL.LLPBK")
                     .WithFlag(6, out parityEnabled, name: "CTRL.PARITY_EN")
                     .WithEnumField(7, 1, out parityTypeField, name: "CTRL.PARITY_ODD")
                     .WithTag("CTRL.RXBLVL", 8, 2)
                     .WithReservedBits(10, 6)
                     .WithValueField(16, 16, out baudClockRate, name: "CTRL.NCO")
                 },
                 {(long)Registers.LiveStatus, new DoubleWordRegister(this)
                     .WithFlag(0, FieldMode.Read, valueProviderCallback: _ => txQueue.Count == txFIFOCapacity, name: "STATUS.TXFULL")
                     .WithFlag(1, FieldMode.Read, valueProviderCallback: _ => Count == rxFIFOCapacity, name: "STATUS.RXFULL")
                     .WithFlag(2, FieldMode.Read, valueProviderCallback: _ => txQueue.Count == 0, name: "STATUS.TXEMPTY")
                     .WithFlag(3, FieldMode.Read, valueProviderCallback: _ => txQueue.Count == 0, name: "STATUS.TXIDLE")
                     .WithFlag(4, FieldMode.Read, valueProviderCallback: _ => true, name: "STATUS.RXIDLE")
                     .WithFlag(5, FieldMode.Read, valueProviderCallback: _ => Count == 0, name: "STATUS.RXEMPTY")
                     .WithReservedBits(6, 26)
                 },
                 {(long)Registers.ReadData, new DoubleWordRegister(this)
                     .WithValueField(0, 8, FieldMode.Read, name: "RDATA", valueProviderCallback: _ =>
                     {
                         if(!TryGetCharacter(out var character))
                         {
                             this.Log(LogLevel.Warning, "Trying to read from an empty Rx FIFO.");
                         }
                         return character;
                     })
                     .WithReservedBits(8, 24)
                     .WithWriteCallback((_, __) => UpdateInterrupts())
                 },
                 {(long)Registers.WriteData, new DoubleWordRegister(this)
                     .WithValueField(0, 8, FieldMode.Write, name: "WDATA", writeCallback: (_, val) =>
                     {
                         if(systemLoopbackEnabled.Value)
                         {
                             base.WriteChar((byte)val);
                             return;
                         }

                         if(txEnabled.Value)
                         {
                             txOngoing = true;
                             TransmitCharacter((byte)val);
                         }
                         else if(txQueue.Count < txFIFOCapacity)
                         {
                             txQueue.Enqueue((byte)val);
                             if(txQueue.Count >= TxWatermarkValue) {
                                 txWatermarkCrossed = true;
                             }
                         }
                         else
                         {
                             this.Log(LogLevel.Warning, "Trying to write to a full Tx FIFO.");
                         }
                     })
                     .WithReservedBits(8, 24)
                     .WithWriteCallback((_, __) => UpdateInterrupts())
                 },
                 {(long)Registers.FIFOControl, new DoubleWordRegister(this)
                     .WithFlag(0, FieldMode.Write, name: "FIFO_CTRL.RXRST", writeCallback: (_, val) =>
                     {
                         if(val)
                         {
                             ClearBuffer();
                         }
                     })
                     .WithFlag(1, FieldMode.Write, name: "FIFO_CTRL.TXRST", writeCallback: (_, val) =>
                     {
                         if(val)
                         {
                             txQueue.Clear();
                             txWatermarkCrossed = false;
                         }
                     })
                     .WithEnumField(2, 3, out rxWatermarkField, name: "FIFO_CTRL.RXILVL")
                     .WithEnumField(5, 2, out txWatermarkField, name: "FIFO_CTRL.TXILVL")
                     .WithReservedBits(7, 25)
                     .WithWriteCallback((_, __) => UpdateInterrupts())
                 },
                 {(long)Registers.FIFOStatus, new DoubleWordRegister(this)
                     .WithValueField(0, 6, FieldMode.Read, valueProviderCallback: _ => (uint)txQueue.Count, name: "FIFO_STATUS.TXLVL")
                     .WithReservedBits(6, 10)
                     .WithValueField(16, 6, FieldMode.Read, valueProviderCallback: _ => (uint)Count, name: "FIFO_STATUS.RXLVL")
                     .WithReservedBits(22, 10)
                 },
                 {(long)Registers.TxPinOverrideControl, new DoubleWordRegister(this)
                     .WithTaggedFlag("OVRD.TXEN", 0)
                     .WithTaggedFlag("OVRD.TXVAL", 1)
                     .WithReservedBits(2, 30)
                 },
                 {(long)Registers.OversampledValues, new DoubleWordRegister(this)
                     .WithTag("VAL.RX", 0, 16)
                     .WithReservedBits(16, 16)
                 },
                 {(long)Registers.RxTimeoutControl, new DoubleWordRegister(this)
                     .WithTag("TIMEOUT_CTRL.VAL", 0, 24)
                     .WithReservedBits(24, 7)
                     .WithTaggedFlag("TIMEOUT_CTRL.EN", 31)
                 }
             };
         }

         private void UpdateInterrupts()
         {
             rxWatermarkPending.Value |= RxWatermarkValue <= Count;

             if (txWatermarkCrossed && txQueue.Count < TxWatermarkValue) {
                 txWatermarkPending.Value = true;
                 txWatermarkCrossed = false;
             }

             if(txOngoing && txQueue.Count == 0)
             {
                 txOngoing = false;
                 txEmptyPending.Value = true;
             }

             TxWatermarkIRQ.Set(txWatermarkPending.Value && txWatermarkEnabled.Value);
             RxWatermarkIRQ.Set(rxWatermarkPending.Value && rxWatermarkEnabled.Value);
             TxEmptyIRQ.Set(txEmptyPending.Value && txEmptyEnabled.Value);
             RxOverflowIRQ.Set(rxOverflowPending.Value && rxOverflowEnabled.Value);
             RxFrameErrorIRQ.Set(rxFrameErrorPending.Value && rxFrameErrorEnabled.Value);
             RxBreakErrorIRQ.Set(rxBreakErrorPending.Value && rxBreakErrorEnabled.Value);
             RxTimeoutIRQ.Set(rxTimeoutPending.Value && rxTimeoutEnabled.Value);
             RxParityErrorIRQ.Set(rxParityErrorPending.Value && rxParityErrorEnabled.Value);
         }

         private int RxWatermarkValue
         {
             get
             {
                 switch(rxWatermarkField.Value)
                 {
                     default:
                         this.Log(LogLevel.Error, "Unexpected state of rxWatermarkField ({0})", rxWatermarkField.Value);
                         return 1;
                     case RxWatermarkLevel.Level1:
                         return 1;
                     case RxWatermarkLevel.Level4:
                         return 4;
                     case RxWatermarkLevel.Level8:
                         return 8;
                     case RxWatermarkLevel.Level16:
                         return 16;
                     case RxWatermarkLevel.Level30:
                         return 30;
                 }
             }
         }

         private int TxWatermarkValue
         {
             get
             {
                 switch(txWatermarkField.Value)
                 {
                     default:
                         this.Log(LogLevel.Error, "Unexpected state of txWatermarkField ({0})", txWatermarkField.Value);
                         return 2;
                     case TxWatermarkLevel.Level1:
                         return 2;
                     case TxWatermarkLevel.Level4:
                         return 4;
                     case TxWatermarkLevel.Level8:
                         return 8;
                     case TxWatermarkLevel.Level16:
                         return 16;
                 }
             }
         }

         private readonly DoubleWordRegisterCollection registers;
         private readonly Queue<byte> txQueue;
         // InterruptState
         private IFlagRegisterField txWatermarkPending;
         private IFlagRegisterField rxWatermarkPending;
         private IFlagRegisterField txEmptyPending;
         private IFlagRegisterField rxOverflowPending;
         private IFlagRegisterField rxFrameErrorPending;
         private IFlagRegisterField rxBreakErrorPending;
         private IFlagRegisterField rxTimeoutPending;
         private IFlagRegisterField rxParityErrorPending;
         // InterruptEnable
         private IFlagRegisterField txWatermarkEnabled;
         private IFlagRegisterField rxWatermarkEnabled;
         private IFlagRegisterField txEmptyEnabled;
         private IFlagRegisterField rxOverflowEnabled;
         private IFlagRegisterField rxFrameErrorEnabled;
         private IFlagRegisterField rxBreakErrorEnabled;
         private IFlagRegisterField rxTimeoutEnabled;
         private IFlagRegisterField rxParityErrorEnabled;
         // Control
         private IFlagRegisterField txEnabled;
         private IFlagRegisterField rxEnabled;
         private IFlagRegisterField noiseFilterEnabled;
         private IFlagRegisterField systemLoopbackEnabled;
         private IFlagRegisterField lineLoopbackEnabled;
         private IFlagRegisterField parityEnabled;
         private IEnumRegisterField<ParityType> parityTypeField;
         private IValueRegisterField baudClockRate;
         // FIFOControl
         private IEnumRegisterField<RxWatermarkLevel> rxWatermarkField;
         private IEnumRegisterField<TxWatermarkLevel> txWatermarkField;

         private bool txOngoing;
         private bool txWatermarkCrossed;

         private const int rxFIFOCapacity = 32;
         private const int txFIFOCapacity = 32;
         private const ulong fixedClockFrequency = 50000000;

         private enum ParityType
         {
             Even = 0,
             Odd  = 1
         }

         private enum RxWatermarkLevel
         {
             Level1  = 0,
             Level4  = 1,
             Level8  = 2,
             Level16 = 3,
             Level30 = 4
         }

         private enum TxWatermarkLevel
         {
             Level1  = 0,
             Level4  = 1,
             Level8  = 2,
             Level16 = 3
         }

         private enum Registers : long
         {
             InterruptState       = 0x0,
             InterruptEnable      = 0x4,
             InterruptTest        = 0x8,
             Control              = 0xC,
             LiveStatus           = 0x10,
             ReadData             = 0x14,
             WriteData            = 0x18,
             FIFOControl          = 0x1C,
             FIFOStatus           = 0x20,
             TxPinOverrideControl = 0x24,
             OversampledValues    = 0x28,
             RxTimeoutControl     = 0x2C
         }
     }
 }
	//
	// 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.Registers;
	using Antmicro.Renode.Logging;
	using Antmicro.Renode.Peripherals.Bus;

	namespace Antmicro.Renode.Peripherals.UART
	{
	// This model currently does not support timeout feature, rx break detection and software tx pin override
	public class OpenTitan2_UART : UARTBase, IDoubleWordPeripheral, IKnownSize
	{
	public OpenTitan2_UART(Machine machine) : base(machine)
	{
	TxWatermarkIRQ = new GPIO();
	RxWatermarkIRQ = new GPIO();
	TxEmptyIRQ = new GPIO();
	RxOverflowIRQ = new GPIO();
	RxFrameErrorIRQ = new GPIO();
	RxBreakErrorIRQ = new GPIO();
	RxTimeoutIRQ = new GPIO();
	RxParityErrorIRQ = new GPIO();

	registers = new DoubleWordRegisterCollection(this, BuildRegisterMap());
	txQueue = new Queue<byte>();
	}

	public uint ReadDoubleWord(long offset)
	{
	return registers.Read(offset);
	}

	public void WriteDoubleWord(long offset, uint value)
	{
	registers.Write(offset, value);
	}

	public override void WriteChar(byte value)
	{
	if(lineLoopbackEnabled.Value)
	{
	txOngoing = true;
	TransmitCharacter(value);
	this.Log(LogLevel.Noisy, "Line Loopback Enabled, byte echoed by hardware.");
	}

	if(systemLoopbackEnabled.Value)
	{
	this.Log(LogLevel.Warning, "Sytem Loopback Enabled, incoming byte not queued.");
	return;
	}

	if(!rxEnabled.Value)
	{
	this.Log(LogLevel.Warning, "CTRL.RX is unset, incoming byte not queued.");
	return;
	}

	if(Count < rxFIFOCapacity)
	{
	rxOverflowPending.Value = false;
	base.WriteChar(value);
	}
	else
	{
	rxOverflowPending.Value = true;
	this.Log(LogLevel.Noisy, "RX FIFO overflowed, queueing incoming byte anyway.");
	base.WriteChar(value);
	}
	UpdateInterrupts();
	}

	public override void Reset()
	{
	base.Reset();
	registers.Reset();
	txQueue.Clear();
	UpdateInterrupts();

	txOngoing = false;
	txWatermarkCrossed = false;
	}

	public long Size => 0x30;

	public GPIO TxWatermarkIRQ { get; }
	public GPIO RxWatermarkIRQ { get; }
	public GPIO TxEmptyIRQ { get; }
	public GPIO RxOverflowIRQ { get; }
	public GPIO RxFrameErrorIRQ { get; }
	public GPIO RxBreakErrorIRQ { get; }
	public GPIO RxTimeoutIRQ { get; }
	public GPIO RxParityErrorIRQ { get; }

	public override Bits StopBits => Bits.One;

	public override Parity ParityBit => parityTypeField.Value == ParityType.Odd ? Parity.Odd : Parity.Even;

	public override uint BaudRate => (uint)((baudClockRate.Value * fixedClockFrequency) >> 20);

	protected override void CharWritten()
	{
	// intentionally left empty
	}

	protected override void QueueEmptied()
	{
	// intentionally left empty
	}

	private Dictionary<long, DoubleWordRegister> BuildRegisterMap()
	{
	return new Dictionary<long, DoubleWordRegister>
	{
	{(long)Registers.InterruptState, new DoubleWordRegister(this)
	.WithFlag(0, out txWatermarkPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.tx_watermark")
	.WithFlag(1, out rxWatermarkPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.rx_watermark")
	.WithFlag(2, out txEmptyPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.tx_empty")
	.WithFlag(3, out rxOverflowPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.rx_overflow")
	.WithFlag(4, out rxFrameErrorPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.rx_frame_err")
	.WithFlag(5, out rxBreakErrorPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.rx_break_err")
	.WithFlag(6, out rxTimeoutPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.rx_timeout")
	.WithFlag(7, out rxParityErrorPending, FieldMode.Read \| FieldMode.WriteOneToClear, name: "INTR_STATE.rx_parity_err")
	.WithReservedBits(8, 24)
	.WithWriteCallback((_, __) => UpdateInterrupts())
	},
	{(long)Registers.InterruptEnable, new DoubleWordRegister(this)
	.WithFlag(0, out txWatermarkEnabled, name: "INTR_ENABLE.tx_watermark")
	.WithFlag(1, out rxWatermarkEnabled, name: "INTR_ENABLE.rx_watermark")
	.WithFlag(2, out txEmptyEnabled, name: "INTR_ENABLE.tx_empty")
	.WithFlag(3, out rxOverflowEnabled, name: "INTR_ENABLE.rx_overflow")
	.WithFlag(4, out rxFrameErrorEnabled, name: "INTR_ENABLE.rx_frame_err")
	.WithFlag(5, out rxBreakErrorEnabled, name: "INTR_ENABLE.rx_break_err")
	.WithFlag(6, out rxTimeoutEnabled, name: "INTR_ENABLE.rx_timeout")
	.WithFlag(7, out rxParityErrorEnabled, name: "INTR_ENABLE.rx_parity_err")
	.WithReservedBits(8, 24)
	.WithWriteCallback((_, __) => UpdateInterrupts())
	},
	{(long)Registers.InterruptTest, new DoubleWordRegister(this)
	.WithFlag(0, FieldMode.Write, writeCallback: (_, val) => { txWatermarkPending.Value \|= val; }, name: "INTR_TEST.tx_watermark")
	.WithFlag(1, FieldMode.Write, writeCallback: (_, val) => { rxWatermarkPending.Value \|= val; }, name: "INTR_TEST.rx_watermark")
	.WithFlag(2, FieldMode.Write, writeCallback: (_, val) => { txEmptyPending.Value \|= val; }, name: "INTR_TEST.tx_empty")
	.WithFlag(3, FieldMode.Write, writeCallback: (_, val) => { rxOverflowPending.Value \|= val; }, name: "INTR_TEST.rx_overflow")
	.WithFlag(4, FieldMode.Write, writeCallback: (_, val) => { rxFrameErrorPending.Value \|= val; }, name: "INTR_TEST.rx_frame_err")
	.WithFlag(5, FieldMode.Write, writeCallback: (_, val) => { rxBreakErrorPending.Value \|= val; }, name: "INTR_TEST.rx_break_err")
	.WithFlag(6, FieldMode.Write, writeCallback: (_, val) => { rxTimeoutPending.Value \|= val; }, name: "INTR_TEST.rx_timeout")
	.WithFlag(7, FieldMode.Write, writeCallback: (_, val) => { rxParityErrorPending.Value \|= val; }, name: "INTR_TEST.rx_parity_err")
	.WithReservedBits(8, 24)
	.WithWriteCallback((_, __) => UpdateInterrupts())
	},
	{(long)Registers.Control, new DoubleWordRegister(this)
	.WithFlag(0, out txEnabled, name: "CTRL.TX", writeCallback: (_, val) =>
	{
	if(val)
	{
	if(!lineLoopbackEnabled.Value)
	{
	foreach(byte value in txQueue)
	{
	txOngoing = true;
	TransmitCharacter(value);
	}
	}
	txQueue.Clear();
	UpdateInterrupts();
	}
	})
	.WithFlag(1, out rxEnabled, name: "CTRL.RX")
	.WithFlag(2, out noiseFilterEnabled, name: "CTRL.NF")
	.WithReservedBits(3, 1)
	.WithFlag(4, out systemLoopbackEnabled, name: "CTRL.SLPBK")
	.WithFlag(5, out lineLoopbackEnabled, name: "CTRL.LLPBK")
	.WithFlag(6, out parityEnabled, name: "CTRL.PARITY_EN")
	.WithEnumField(7, 1, out parityTypeField, name: "CTRL.PARITY_ODD")
	.WithTag("CTRL.RXBLVL", 8, 2)
	.WithReservedBits(10, 6)
	.WithValueField(16, 16, out baudClockRate, name: "CTRL.NCO")
	},
	{(long)Registers.LiveStatus, new DoubleWordRegister(this)
	.WithFlag(0, FieldMode.Read, valueProviderCallback: _ => txQueue.Count == txFIFOCapacity, name: "STATUS.TXFULL")
	.WithFlag(1, FieldMode.Read, valueProviderCallback: _ => Count == rxFIFOCapacity, name: "STATUS.RXFULL")
	.WithFlag(2, FieldMode.Read, valueProviderCallback: _ => txQueue.Count == 0, name: "STATUS.TXEMPTY")
	.WithFlag(3, FieldMode.Read, valueProviderCallback: _ => txQueue.Count == 0, name: "STATUS.TXIDLE")
	.WithFlag(4, FieldMode.Read, valueProviderCallback: _ => true, name: "STATUS.RXIDLE")
	.WithFlag(5, FieldMode.Read, valueProviderCallback: _ => Count == 0, name: "STATUS.RXEMPTY")
	.WithReservedBits(6, 26)
	},
	{(long)Registers.ReadData, new DoubleWordRegister(this)
	.WithValueField(0, 8, FieldMode.Read, name: "RDATA", valueProviderCallback: _ =>
	{
	if(!TryGetCharacter(out var character))
	{
	this.Log(LogLevel.Warning, "Trying to read from an empty Rx FIFO.");
	}
	return character;
	})
	.WithReservedBits(8, 24)
	.WithWriteCallback((_, __) => UpdateInterrupts())
	},
	{(long)Registers.WriteData, new DoubleWordRegister(this)
	.WithValueField(0, 8, FieldMode.Write, name: "WDATA", writeCallback: (_, val) =>
	{
	if(systemLoopbackEnabled.Value)
	{
	base.WriteChar((byte)val);
	return;
	}

	if(txEnabled.Value)
	{
	txOngoing = true;
	TransmitCharacter((byte)val);
	}
	else if(txQueue.Count < txFIFOCapacity)
	{
	txQueue.Enqueue((byte)val);
	if(txQueue.Count >= TxWatermarkValue) {
	txWatermarkCrossed = true;
	}
	}
	else
	{
	this.Log(LogLevel.Warning, "Trying to write to a full Tx FIFO.");
	}
	})
	.WithReservedBits(8, 24)
	.WithWriteCallback((_, __) => UpdateInterrupts())
	},
	{(long)Registers.FIFOControl, new DoubleWordRegister(this)
	.WithFlag(0, FieldMode.Write, name: "FIFO_CTRL.RXRST", writeCallback: (_, val) =>
	{
	if(val)
	{
	ClearBuffer();
	}
	})
	.WithFlag(1, FieldMode.Write, name: "FIFO_CTRL.TXRST", writeCallback: (_, val) =>
	{
	if(val)
	{
	txQueue.Clear();
	txWatermarkCrossed = false;
	}
	})
	.WithEnumField(2, 3, out rxWatermarkField, name: "FIFO_CTRL.RXILVL")
	.WithEnumField(5, 2, out txWatermarkField, name: "FIFO_CTRL.TXILVL")
	.WithReservedBits(7, 25)
	.WithWriteCallback((_, __) => UpdateInterrupts())
	},
	{(long)Registers.FIFOStatus, new DoubleWordRegister(this)
	.WithValueField(0, 6, FieldMode.Read, valueProviderCallback: _ => (uint)txQueue.Count, name: "FIFO_STATUS.TXLVL")
	.WithReservedBits(6, 10)
	.WithValueField(16, 6, FieldMode.Read, valueProviderCallback: _ => (uint)Count, name: "FIFO_STATUS.RXLVL")
	.WithReservedBits(22, 10)
	},
	{(long)Registers.TxPinOverrideControl, new DoubleWordRegister(this)
	.WithTaggedFlag("OVRD.TXEN", 0)
	.WithTaggedFlag("OVRD.TXVAL", 1)
	.WithReservedBits(2, 30)
	},
	{(long)Registers.OversampledValues, new DoubleWordRegister(this)
	.WithTag("VAL.RX", 0, 16)
	.WithReservedBits(16, 16)
	},
	{(long)Registers.RxTimeoutControl, new DoubleWordRegister(this)
	.WithTag("TIMEOUT_CTRL.VAL", 0, 24)
	.WithReservedBits(24, 7)
	.WithTaggedFlag("TIMEOUT_CTRL.EN", 31)
	}
	};
	}

	private void UpdateInterrupts()
	{
	rxWatermarkPending.Value \|= RxWatermarkValue <= Count;

	if (txWatermarkCrossed && txQueue.Count < TxWatermarkValue) {
	txWatermarkPending.Value = true;
	txWatermarkCrossed = false;
	}

	if(txOngoing && txQueue.Count == 0)
	{
	txOngoing = false;
	txEmptyPending.Value = true;
	}

	TxWatermarkIRQ.Set(txWatermarkPending.Value && txWatermarkEnabled.Value);
	RxWatermarkIRQ.Set(rxWatermarkPending.Value && rxWatermarkEnabled.Value);
	TxEmptyIRQ.Set(txEmptyPending.Value && txEmptyEnabled.Value);
	RxOverflowIRQ.Set(rxOverflowPending.Value && rxOverflowEnabled.Value);
	RxFrameErrorIRQ.Set(rxFrameErrorPending.Value && rxFrameErrorEnabled.Value);
	RxBreakErrorIRQ.Set(rxBreakErrorPending.Value && rxBreakErrorEnabled.Value);
	RxTimeoutIRQ.Set(rxTimeoutPending.Value && rxTimeoutEnabled.Value);
	RxParityErrorIRQ.Set(rxParityErrorPending.Value && rxParityErrorEnabled.Value);
	}

	private int RxWatermarkValue
	{
	get
	{
	switch(rxWatermarkField.Value)
	{
	default:
	this.Log(LogLevel.Error, "Unexpected state of rxWatermarkField ({0})", rxWatermarkField.Value);
	return 1;
	case RxWatermarkLevel.Level1:
	return 1;
	case RxWatermarkLevel.Level4:
	return 4;
	case RxWatermarkLevel.Level8:
	return 8;
	case RxWatermarkLevel.Level16:
	return 16;
	case RxWatermarkLevel.Level30:
	return 30;
	}
	}
	}

	private int TxWatermarkValue
	{
	get
	{
	switch(txWatermarkField.Value)
	{
	default:
	this.Log(LogLevel.Error, "Unexpected state of txWatermarkField ({0})", txWatermarkField.Value);
	return 2;
	case TxWatermarkLevel.Level1:
	return 2;
	case TxWatermarkLevel.Level4:
	return 4;
	case TxWatermarkLevel.Level8:
	return 8;
	case TxWatermarkLevel.Level16:
	return 16;
	}
	}
	}

	private readonly DoubleWordRegisterCollection registers;
	private readonly Queue<byte> txQueue;
	// InterruptState
	private IFlagRegisterField txWatermarkPending;
	private IFlagRegisterField rxWatermarkPending;
	private IFlagRegisterField txEmptyPending;
	private IFlagRegisterField rxOverflowPending;
	private IFlagRegisterField rxFrameErrorPending;
	private IFlagRegisterField rxBreakErrorPending;
	private IFlagRegisterField rxTimeoutPending;
	private IFlagRegisterField rxParityErrorPending;
	// InterruptEnable
	private IFlagRegisterField txWatermarkEnabled;
	private IFlagRegisterField rxWatermarkEnabled;
	private IFlagRegisterField txEmptyEnabled;
	private IFlagRegisterField rxOverflowEnabled;
	private IFlagRegisterField rxFrameErrorEnabled;
	private IFlagRegisterField rxBreakErrorEnabled;
	private IFlagRegisterField rxTimeoutEnabled;
	private IFlagRegisterField rxParityErrorEnabled;
	// Control
	private IFlagRegisterField txEnabled;
	private IFlagRegisterField rxEnabled;
	private IFlagRegisterField noiseFilterEnabled;
	private IFlagRegisterField systemLoopbackEnabled;
	private IFlagRegisterField lineLoopbackEnabled;
	private IFlagRegisterField parityEnabled;
	private IEnumRegisterField<ParityType> parityTypeField;
	private IValueRegisterField baudClockRate;
	// FIFOControl
	private IEnumRegisterField<RxWatermarkLevel> rxWatermarkField;
	private IEnumRegisterField<TxWatermarkLevel> txWatermarkField;

	private bool txOngoing;
	private bool txWatermarkCrossed;

	private const int rxFIFOCapacity = 32;
	private const int txFIFOCapacity = 32;
	private const ulong fixedClockFrequency = 50000000;

	private enum ParityType
	{
	Even = 0,
	Odd = 1
	}

	private enum RxWatermarkLevel
	{
	Level1 = 0,
	Level4 = 1,
	Level8 = 2,
	Level16 = 3,
	Level30 = 4
	}

	private enum TxWatermarkLevel
	{
	Level1 = 0,
	Level4 = 1,
	Level8 = 2,
	Level16 = 3
	}

	private enum Registers : long
	{
	InterruptState = 0x0,
	InterruptEnable = 0x4,
	InterruptTest = 0x8,
	Control = 0xC,
	LiveStatus = 0x10,
	ReadData = 0x14,
	WriteData = 0x18,
	FIFOControl = 0x1C,
	FIFOStatus = 0x20,
	TxPinOverrideControl = 0x24,
	OversampledValues = 0x28,
	RxTimeoutControl = 0x2C
	}
	}
	}