mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
add vexii baremetal target for utralib
This commit is contained in:
parent
f0b7afe68a
commit
1e02746d9e
5 changed files with 1303 additions and 2 deletions
|
|
@ -53,8 +53,9 @@ cramium-fpga = []
|
|||
# Emulation for cramium
|
||||
hosted-baosec = []
|
||||
|
||||
# Arty target
|
||||
# Arty targets
|
||||
artybio = []
|
||||
artyvexii = []
|
||||
|
||||
# Specify a Precusor default so that we can pass packaging CI tests.
|
||||
default = ["hosted"]
|
||||
|
|
|
|||
591
utralib/artyvexii/soc.svd
Normal file
591
utralib/artyvexii/soc.svd
Normal file
|
|
@ -0,0 +1,591 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
|
||||
<device schemaVersion="1.1" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance" xs:noNamespaceSchemaLocation="CMSIS-SVD.xsd" >
|
||||
<vendor>litex</vendor>
|
||||
<name>SOC</name>
|
||||
<description><![CDATA[Litex SoC 2025-07-09 03:38:38]]></description>
|
||||
|
||||
<addressUnitBits>8</addressUnitBits>
|
||||
<width>32</width>
|
||||
<size>32</size>
|
||||
<access>read-write</access>
|
||||
<resetValue>0x00000000</resetValue>
|
||||
<resetMask>0xFFFFFFFF</resetMask>
|
||||
|
||||
<peripherals>
|
||||
<peripheral>
|
||||
<name>LEGACY_INT</name>
|
||||
<baseAddress>0xE0000000</baseAddress>
|
||||
<groupName>LEGACY_INT</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>MACH_MASK</name>
|
||||
<description><![CDATA[Machine IRQ mask]]></description>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>mach_mask</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>MACH_PENDING</name>
|
||||
<description><![CDATA[Machine IRQ pending]]></description>
|
||||
<addressOffset>0x0004</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>mach_pending</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>SUPER_MASK</name>
|
||||
<description><![CDATA[Supervisor IRQ mask]]></description>
|
||||
<addressOffset>0x0008</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>super_mask</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>SUPER_PENDING</name>
|
||||
<description><![CDATA[Supervisor IRQ pending]]></description>
|
||||
<addressOffset>0x000c</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>super_pending</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0x10</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
</peripheral>
|
||||
<peripheral>
|
||||
<name>RGB</name>
|
||||
<baseAddress>0xE0000800</baseAddress>
|
||||
<groupName>RGB</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>OUT</name>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>out</name>
|
||||
<msb>11</msb>
|
||||
<bitRange>[11:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0x4</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
</peripheral>
|
||||
<peripheral>
|
||||
<name>CTRL</name>
|
||||
<baseAddress>0xE0001000</baseAddress>
|
||||
<groupName>CTRL</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>RESET</name>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>soc_rst</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[Write `1` to this register to reset the full SoC (Pulse Reset)]]></description>
|
||||
</field>
|
||||
<field>
|
||||
<name>cpu_rst</name>
|
||||
<msb>1</msb>
|
||||
<bitRange>[1:1]</bitRange>
|
||||
<lsb>1</lsb>
|
||||
<description><![CDATA[Write `1` to this register to reset the CPU(s) of the SoC (Hold Reset)]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>SCRATCH</name>
|
||||
<description><![CDATA[Use this register as a scratch space to verify that software read/write accesses
|
||||
to the Wishbone/CSR bus are working correctly. The initial reset value of
|
||||
0x1234578 can be used to verify endianness.]]></description>
|
||||
<addressOffset>0x0004</addressOffset>
|
||||
<resetValue>0x12345678</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>scratch</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>BUS_ERRORS</name>
|
||||
<description><![CDATA[Total number of Wishbone bus errors (timeouts) since start.]]></description>
|
||||
<addressOffset>0x0008</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>bus_errors</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0xc</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
</peripheral>
|
||||
<peripheral>
|
||||
<name>IDENTIFIER_MEM</name>
|
||||
<baseAddress>0xE0001800</baseAddress>
|
||||
<groupName>IDENTIFIER_MEM</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>IDENTIFIER_MEM</name>
|
||||
<description><![CDATA[8 x 35-bit memory]]></description>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>identifier_mem</name>
|
||||
<msb>7</msb>
|
||||
<bitRange>[7:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0x4</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
</peripheral>
|
||||
<peripheral>
|
||||
<name>LEDS</name>
|
||||
<baseAddress>0xE0002000</baseAddress>
|
||||
<groupName>LEDS</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>OUT</name>
|
||||
<description><![CDATA[Led Output(s) Control.]]></description>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>out</name>
|
||||
<msb>3</msb>
|
||||
<bitRange>[3:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0x4</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
</peripheral>
|
||||
<peripheral>
|
||||
<name>TIMER0</name>
|
||||
<baseAddress>0xE0002800</baseAddress>
|
||||
<groupName>TIMER0</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>LOAD</name>
|
||||
<description><![CDATA[Load value when Timer is (re-)enabled. In One-Shot mode, the value written to
|
||||
this register specifies the Timer's duration in clock cycles.]]></description>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>load</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>RELOAD</name>
|
||||
<description><![CDATA[Reload value when Timer reaches ``0``. In Periodic mode, the value written to
|
||||
this register specify the Timer's period in clock cycles.]]></description>
|
||||
<addressOffset>0x0004</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>reload</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EN</name>
|
||||
<description><![CDATA[Enable flag of the Timer. Set this flag to ``1`` to enable/start the Timer. Set
|
||||
to ``0`` to disable the Timer.]]></description>
|
||||
<addressOffset>0x0008</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>en</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>UPDATE_VALUE</name>
|
||||
<description><![CDATA[Update trigger for the current countdown value. A write to this register latches
|
||||
the current countdown value to ``value`` register.]]></description>
|
||||
<addressOffset>0x000c</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>update_value</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>VALUE</name>
|
||||
<description><![CDATA[Latched countdown value. This value is updated by writing to ``update_value``.]]></description>
|
||||
<addressOffset>0x0010</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>value</name>
|
||||
<msb>31</msb>
|
||||
<bitRange>[31:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EV_STATUS</name>
|
||||
<description><![CDATA[This register contains the current raw level of the zero event trigger. Writes
|
||||
to this register have no effect.]]></description>
|
||||
<addressOffset>0x0014</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>zero</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[Level of the ``zero`` event]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EV_PENDING</name>
|
||||
<description><![CDATA[When a zero event occurs, the corresponding bit will be set in this register.
|
||||
To clear the Event, set the corresponding bit in this register.]]></description>
|
||||
<addressOffset>0x0018</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>zero</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[`1` if a `zero` event occurred. This Event is triggered on a **falling** edge.]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EV_ENABLE</name>
|
||||
<description><![CDATA[This register enables the corresponding zero events. Write a ``0`` to this
|
||||
register to disable individual events.]]></description>
|
||||
<addressOffset>0x001c</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>zero</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[Write a ``1`` to enable the ``zero`` Event]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0x20</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
<interrupt>
|
||||
<name>timer0</name>
|
||||
<value>0</value>
|
||||
</interrupt>
|
||||
</peripheral>
|
||||
<peripheral>
|
||||
<name>UART</name>
|
||||
<baseAddress>0xE0003000</baseAddress>
|
||||
<groupName>UART</groupName>
|
||||
<registers>
|
||||
<register>
|
||||
<name>RXTX</name>
|
||||
<addressOffset>0x0000</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>rxtx</name>
|
||||
<msb>7</msb>
|
||||
<bitRange>[7:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>TXFULL</name>
|
||||
<description><![CDATA[TX FIFO Full.]]></description>
|
||||
<addressOffset>0x0004</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>txfull</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>RXEMPTY</name>
|
||||
<description><![CDATA[RX FIFO Empty.]]></description>
|
||||
<addressOffset>0x0008</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>rxempty</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EV_STATUS</name>
|
||||
<description><![CDATA[This register contains the current raw level of the rx event trigger. Writes to
|
||||
this register have no effect.]]></description>
|
||||
<addressOffset>0x000c</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>tx</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[Level of the ``tx`` event]]></description>
|
||||
</field>
|
||||
<field>
|
||||
<name>rx</name>
|
||||
<msb>1</msb>
|
||||
<bitRange>[1:1]</bitRange>
|
||||
<lsb>1</lsb>
|
||||
<description><![CDATA[Level of the ``rx`` event]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EV_PENDING</name>
|
||||
<description><![CDATA[When a rx event occurs, the corresponding bit will be set in this register. To
|
||||
clear the Event, set the corresponding bit in this register.]]></description>
|
||||
<addressOffset>0x0010</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>tx</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[`1` if a `tx` event occurred. This Event is triggered on a **falling** edge.]]></description>
|
||||
</field>
|
||||
<field>
|
||||
<name>rx</name>
|
||||
<msb>1</msb>
|
||||
<bitRange>[1:1]</bitRange>
|
||||
<lsb>1</lsb>
|
||||
<description><![CDATA[`1` if a `rx` event occurred. This Event is triggered on a **falling** edge.]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>EV_ENABLE</name>
|
||||
<description><![CDATA[This register enables the corresponding rx events. Write a ``0`` to this
|
||||
register to disable individual events.]]></description>
|
||||
<addressOffset>0x0014</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>tx</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
<description><![CDATA[Write a ``1`` to enable the ``tx`` Event]]></description>
|
||||
</field>
|
||||
<field>
|
||||
<name>rx</name>
|
||||
<msb>1</msb>
|
||||
<bitRange>[1:1]</bitRange>
|
||||
<lsb>1</lsb>
|
||||
<description><![CDATA[Write a ``1`` to enable the ``rx`` Event]]></description>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>TXEMPTY</name>
|
||||
<description><![CDATA[TX FIFO Empty.]]></description>
|
||||
<addressOffset>0x0018</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>txempty</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
<register>
|
||||
<name>RXFULL</name>
|
||||
<description><![CDATA[RX FIFO Full.]]></description>
|
||||
<addressOffset>0x001c</addressOffset>
|
||||
<resetValue>0x00</resetValue>
|
||||
<size>32</size>
|
||||
<fields>
|
||||
<field>
|
||||
<name>rxfull</name>
|
||||
<msb>0</msb>
|
||||
<bitRange>[0:0]</bitRange>
|
||||
<lsb>0</lsb>
|
||||
</field>
|
||||
</fields>
|
||||
</register>
|
||||
</registers>
|
||||
<addressBlock>
|
||||
<offset>0</offset>
|
||||
<size>0x20</size>
|
||||
<usage>registers</usage>
|
||||
</addressBlock>
|
||||
<interrupt>
|
||||
<name>uart</name>
|
||||
<value>1</value>
|
||||
</interrupt>
|
||||
</peripheral>
|
||||
</peripherals>
|
||||
<vendorExtensions>
|
||||
<memoryRegions>
|
||||
<memoryRegion>
|
||||
<name>ROM</name>
|
||||
<baseAddress>0x80000000</baseAddress>
|
||||
<size>0x00010000</size>
|
||||
</memoryRegion>
|
||||
<memoryRegion>
|
||||
<name>SRAM</name>
|
||||
<baseAddress>0x01000000</baseAddress>
|
||||
<size>0x00002000</size>
|
||||
</memoryRegion>
|
||||
<memoryRegion>
|
||||
<name>MAIN_RAM</name>
|
||||
<baseAddress>0x40000000</baseAddress>
|
||||
<size>0x00020000</size>
|
||||
</memoryRegion>
|
||||
<memoryRegion>
|
||||
<name>BIO</name>
|
||||
<baseAddress>0x90000000</baseAddress>
|
||||
<size>0x00010000</size>
|
||||
</memoryRegion>
|
||||
<memoryRegion>
|
||||
<name>CSR</name>
|
||||
<baseAddress>0xE0000000</baseAddress>
|
||||
<size>0x00010000</size>
|
||||
</memoryRegion>
|
||||
</memoryRegions>
|
||||
<constants>
|
||||
<constant name="CONFIG_CLOCK_FREQUENCY" value="40000000" />
|
||||
<constant name="CONFIG_CPU_HAS_INTERRUPT" value="None" />
|
||||
<constant name="CONFIG_CPU_RESET_ADDR" value="2147483648" />
|
||||
<constant name="CONFIG_CPU_HAS_DCACHE" value="None" />
|
||||
<constant name="CONFIG_CPU_HAS_ICACHE" value="None" />
|
||||
<constant name="CONFIG_CPU_TYPE_VEXIIRISCV" value="None" />
|
||||
<constant name="CONFIG_CPU_VARIANT_STANDARD" value="None" />
|
||||
<constant name="CONFIG_CPU_HUMAN_NAME" value="VexiiRiscv" />
|
||||
<constant name="CONFIG_CPU_NOP" value="nop" />
|
||||
<constant name="CONFIG_CSR_DATA_WIDTH" value="32" />
|
||||
<constant name="CONFIG_CSR_ALIGNMENT" value="32" />
|
||||
<constant name="CONFIG_BUS_STANDARD" value="WISHBONE" />
|
||||
<constant name="CONFIG_BUS_DATA_WIDTH" value="32" />
|
||||
<constant name="CONFIG_BUS_ADDRESS_WIDTH" value="32" />
|
||||
<constant name="CONFIG_BUS_BURSTING" value="0" />
|
||||
<constant name="TIMER0_INTERRUPT" value="0" />
|
||||
<constant name="UART_INTERRUPT" value="1" />
|
||||
</constants>
|
||||
</vendorExtensions>
|
||||
</device>
|
||||
|
|
@ -90,7 +90,8 @@ fn main() {
|
|||
"atsama5d27",
|
||||
"cramium-soc",
|
||||
"cramium-fpga",
|
||||
"artybio"
|
||||
"artybio",
|
||||
"artyvexii"
|
||||
);
|
||||
|
||||
#[cfg(feature = "precursor")]
|
||||
|
|
@ -137,6 +138,11 @@ fn main() {
|
|||
#[cfg(feature = "artybio")]
|
||||
let generated_filename = "src/generated/artybio.rs";
|
||||
|
||||
#[cfg(feature = "artyvexii")]
|
||||
let svd_filenames = vec!["artyvexii/soc.svd"];
|
||||
#[cfg(feature = "artyvexii")]
|
||||
let generated_filename = "src/generated/artyvexii.rs";
|
||||
|
||||
// ----- control file generation and rebuild sequence -----
|
||||
// check and see if the configuration has changed since the last build. This should be
|
||||
// passed by the build system (e.g. xtask) if the feature is used.
|
||||
|
|
|
|||
|
|
@ -57,6 +57,13 @@ mod artybio;
|
|||
#[rustfmt::skip]
|
||||
pub use artybio::*;
|
||||
|
||||
#[cfg(feature = "artyvexii")]
|
||||
#[rustfmt::skip]
|
||||
mod artyvexii;
|
||||
#[cfg(feature = "artyvexii")]
|
||||
#[rustfmt::skip]
|
||||
pub use artyvexii::*;
|
||||
|
||||
// Hosted mode includes nothing, as it relies on the abstract host
|
||||
// architecture for I/O; so this file is empty when the "hosted"
|
||||
// configuration is selected and there are no corresponding "hosted"
|
||||
|
|
|
|||
696
utralib/src/generated/artyvexii.rs
Normal file
696
utralib/src/generated/artyvexii.rs
Normal file
|
|
@ -0,0 +1,696 @@
|
|||
|
||||
#![cfg_attr(rustfmt, rustfmt_skip)] // don't format generated files
|
||||
#![allow(dead_code)]
|
||||
use core::convert::TryInto;
|
||||
#[cfg(feature="std")]
|
||||
use core::sync::atomic::AtomicPtr;
|
||||
#[cfg(feature="std")]
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct Register {
|
||||
/// Offset of this register within this CSR
|
||||
offset: usize,
|
||||
/// Mask of SVD-specified bits for the register
|
||||
mask: usize,
|
||||
}
|
||||
impl Register {
|
||||
pub const fn new(offset: usize, mask: usize) -> Register {
|
||||
Register { offset, mask }
|
||||
}
|
||||
pub const fn offset(&self) -> usize { self.offset }
|
||||
pub const fn mask(&self) -> usize { self.mask }
|
||||
}
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct Field {
|
||||
/// A bitmask we use to AND to the value, unshifted.
|
||||
/// E.g. for a width of `3` bits, this mask would be 0b111.
|
||||
mask: usize,
|
||||
/// Offset of the first bit in this field
|
||||
offset: usize,
|
||||
/// A copy of the register address that this field
|
||||
/// is a member of. Ideally this is optimized out by the
|
||||
/// compiler.
|
||||
register: Register,
|
||||
}
|
||||
impl Field {
|
||||
/// Define a new CSR field with the given width at a specified
|
||||
/// offset from the start of the register.
|
||||
pub const fn new(width: usize, offset: usize, register: Register) -> Field {
|
||||
let mask = if width < 32 { (1 << width) - 1 } else {0xFFFF_FFFF};
|
||||
Field {
|
||||
mask,
|
||||
offset,
|
||||
register,
|
||||
}
|
||||
}
|
||||
pub const fn offset(&self) -> usize { self.offset }
|
||||
pub const fn mask(&self) -> usize { self.mask }
|
||||
pub const fn register(&self) -> Register { self.register }
|
||||
}
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct CSR<T> {
|
||||
base: *mut T,
|
||||
}
|
||||
impl<T> CSR<T>
|
||||
where
|
||||
T: core::convert::TryFrom<usize> + core::convert::TryInto<usize> + core::default::Default,
|
||||
{
|
||||
pub fn new(base: *mut T) -> Self {
|
||||
CSR { base }
|
||||
}
|
||||
/// Retrieve the raw pointer used as the base of the CSR. This is unsafe because the copied
|
||||
/// value can be used to do all kinds of awful shared mutable operations (like creating
|
||||
/// another CSR accessor owned by another thread). However, sometimes this is unavoidable
|
||||
/// because hardware is in fact shared mutable state.
|
||||
pub unsafe fn base(&self) -> *mut T {
|
||||
self.base
|
||||
}
|
||||
/// Read the contents of this register
|
||||
pub fn r(&self, reg: Register) -> T {
|
||||
// prevent re-ordering
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) };
|
||||
unsafe { usize_base.add(reg.offset).read_volatile() }
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// Read a field from this CSR
|
||||
pub fn rf(&self, field: Field) -> T {
|
||||
// prevent re-ordering
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) };
|
||||
((unsafe { usize_base.add(field.register.offset).read_volatile() } >> field.offset)
|
||||
& field.mask)
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// Read-modify-write a given field in this CSR
|
||||
pub fn rmwf(&mut self, field: Field, value: T) {
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) };
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default() << field.offset;
|
||||
let previous =
|
||||
unsafe { usize_base.add(field.register.offset).read_volatile() } & !(field.mask << field.offset);
|
||||
unsafe {
|
||||
usize_base
|
||||
.add(field.register.offset)
|
||||
.write_volatile(previous | value_as_usize)
|
||||
};
|
||||
// prevent re-ordering
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
/// Write a given field without reading it first
|
||||
pub fn wfo(&mut self, field: Field, value: T) {
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) };
|
||||
let value_as_usize: usize = (value.try_into().unwrap_or_default() & field.mask) << field.offset;
|
||||
unsafe {
|
||||
usize_base
|
||||
.add(field.register.offset)
|
||||
.write_volatile(value_as_usize)
|
||||
};
|
||||
// Ensure the compiler doesn't re-order the write.
|
||||
// We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before
|
||||
// *reads*, but this method only *writes* to the locations.
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
/// Write the entire contents of a register without reading it first
|
||||
pub fn wo(&mut self, reg: Register, value: T) {
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base) };
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default();
|
||||
unsafe { usize_base.add(reg.offset).write_volatile(value_as_usize) };
|
||||
// Ensure the compiler doesn't re-order the write.
|
||||
// We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before
|
||||
// *reads*, but this method only *writes* to the locations.
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
/// Zero a field from a provided value
|
||||
pub fn zf(&self, field: Field, value: T) -> T {
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default();
|
||||
(value_as_usize & !(field.mask << field.offset))
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// Shift & mask a value to its final field position
|
||||
pub fn ms(&self, field: Field, value: T) -> T {
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default();
|
||||
((value_as_usize & field.mask) << field.offset)
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
#[cfg(feature="std")]
|
||||
pub struct AtomicCsr<T> {
|
||||
base: Arc::<AtomicPtr<T>>,
|
||||
}
|
||||
#[cfg(feature="std")]
|
||||
impl<T> AtomicCsr<T>
|
||||
where
|
||||
T: core::convert::TryFrom<usize> + core::convert::TryInto<usize> + core::default::Default,
|
||||
{
|
||||
/// AtomicCsr wraps the CSR in an Arc + AtomicPtr, so that write operations don't require
|
||||
/// a mutable reference. This allows us to stick CSR accesses into APIs that require
|
||||
/// non-mutable references to hardware state (such as certain "standardized" USB APIs).
|
||||
/// Hiding the fact that you're tweaking hardware registers behind Arc/AtomicPtr seems a little
|
||||
/// scary, but, it does make for nicer Rust semantics.
|
||||
pub fn new(base: *mut T) -> Self {
|
||||
AtomicCsr {
|
||||
base: Arc::new(AtomicPtr::new(base))
|
||||
}
|
||||
}
|
||||
pub unsafe fn base(&self) -> *mut T {
|
||||
self.base.load(core::sync::atomic::Ordering::SeqCst) as *mut T
|
||||
}
|
||||
pub fn clone(&self) -> Self {
|
||||
AtomicCsr {
|
||||
base: self.base.clone()
|
||||
}
|
||||
}
|
||||
/// Read the contents of this register
|
||||
pub fn r(&self, reg: Register) -> T {
|
||||
// prevent re-ordering
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) };
|
||||
unsafe { usize_base.add(reg.offset).read_volatile() }
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// Read a field from this CSR
|
||||
pub fn rf(&self, field: Field) -> T {
|
||||
// prevent re-ordering
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) };
|
||||
((unsafe { usize_base.add(field.register.offset).read_volatile() } >> field.offset)
|
||||
& field.mask)
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// Read-modify-write a given field in this CSR
|
||||
pub fn rmwf(&self, field: Field, value: T) {
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) };
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default() << field.offset;
|
||||
let previous =
|
||||
unsafe { usize_base.add(field.register.offset).read_volatile() } & !(field.mask << field.offset);
|
||||
unsafe {
|
||||
usize_base
|
||||
.add(field.register.offset)
|
||||
.write_volatile(previous | value_as_usize)
|
||||
};
|
||||
// prevent re-ordering
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
/// Write a given field without reading it first
|
||||
pub fn wfo(&self, field: Field, value: T) {
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) };
|
||||
let value_as_usize: usize = (value.try_into().unwrap_or_default() & field.mask) << field.offset;
|
||||
unsafe {
|
||||
usize_base
|
||||
.add(field.register.offset)
|
||||
.write_volatile(value_as_usize)
|
||||
};
|
||||
// Ensure the compiler doesn't re-order the write.
|
||||
// We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before
|
||||
// *reads*, but this method only *writes* to the locations.
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
/// Write the entire contents of a register without reading it first
|
||||
pub fn wo(&self, reg: Register, value: T) {
|
||||
let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.load(core::sync::atomic::Ordering::SeqCst)) };
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default();
|
||||
unsafe { usize_base.add(reg.offset).write_volatile(value_as_usize) };
|
||||
// Ensure the compiler doesn't re-order the write.
|
||||
// We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before
|
||||
// *reads*, but this method only *writes* to the locations.
|
||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
/// Zero a field from a provided value
|
||||
pub fn zf(&self, field: Field, value: T) -> T {
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default();
|
||||
(value_as_usize & !(field.mask << field.offset))
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// Shift & mask a value to its final field position
|
||||
pub fn ms(&self, field: Field, value: T) -> T {
|
||||
let value_as_usize: usize = value.try_into().unwrap_or_default();
|
||||
((value_as_usize & field.mask) << field.offset)
|
||||
.try_into()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
}
|
||||
// Physical base addresses of memory regions
|
||||
pub const HW_ROM_MEM: usize = 0x80000000;
|
||||
pub const HW_ROM_MEM_LEN: usize = 65536;
|
||||
pub const HW_SRAM_MEM: usize = 0x01000000;
|
||||
pub const HW_SRAM_MEM_LEN: usize = 8192;
|
||||
pub const HW_MAIN_RAM_MEM: usize = 0x40000000;
|
||||
pub const HW_MAIN_RAM_MEM_LEN: usize = 131072;
|
||||
pub const HW_BIO_MEM: usize = 0x90000000;
|
||||
pub const HW_BIO_MEM_LEN: usize = 65536;
|
||||
pub const HW_CSR_MEM: usize = 0xe0000000;
|
||||
pub const HW_CSR_MEM_LEN: usize = 65536;
|
||||
|
||||
// Physical base addresses of registers
|
||||
pub const HW_LEGACY_INT_BASE : usize = 0xe0000000;
|
||||
pub const HW_RGB_BASE : usize = 0xe0000800;
|
||||
pub const HW_CTRL_BASE : usize = 0xe0001000;
|
||||
pub const HW_IDENTIFIER_MEM_BASE : usize = 0xe0001800;
|
||||
pub const HW_LEDS_BASE : usize = 0xe0002000;
|
||||
pub const HW_TIMER0_BASE : usize = 0xe0002800;
|
||||
pub const HW_UART_BASE : usize = 0xe0003000;
|
||||
|
||||
|
||||
pub mod utra {
|
||||
|
||||
pub mod legacy_int {
|
||||
pub const LEGACY_INT_NUMREGS: usize = 4;
|
||||
|
||||
pub const MACH_MASK: crate::Register = crate::Register::new(0, 0xffffffff);
|
||||
pub const MACH_MASK_MACH_MASK: crate::Field = crate::Field::new(32, 0, MACH_MASK);
|
||||
|
||||
pub const MACH_PENDING: crate::Register = crate::Register::new(1, 0xffffffff);
|
||||
pub const MACH_PENDING_MACH_PENDING: crate::Field = crate::Field::new(32, 0, MACH_PENDING);
|
||||
|
||||
pub const SUPER_MASK: crate::Register = crate::Register::new(2, 0xffffffff);
|
||||
pub const SUPER_MASK_SUPER_MASK: crate::Field = crate::Field::new(32, 0, SUPER_MASK);
|
||||
|
||||
pub const SUPER_PENDING: crate::Register = crate::Register::new(3, 0xffffffff);
|
||||
pub const SUPER_PENDING_SUPER_PENDING: crate::Field = crate::Field::new(32, 0, SUPER_PENDING);
|
||||
|
||||
pub const HW_LEGACY_INT_BASE: usize = 0xe0000000;
|
||||
}
|
||||
|
||||
pub mod rgb {
|
||||
pub const RGB_NUMREGS: usize = 1;
|
||||
|
||||
pub const OUT: crate::Register = crate::Register::new(0, 0xfff);
|
||||
pub const OUT_OUT: crate::Field = crate::Field::new(12, 0, OUT);
|
||||
|
||||
pub const HW_RGB_BASE: usize = 0xe0000800;
|
||||
}
|
||||
|
||||
pub mod ctrl {
|
||||
pub const CTRL_NUMREGS: usize = 3;
|
||||
|
||||
pub const RESET: crate::Register = crate::Register::new(0, 0x3);
|
||||
pub const RESET_SOC_RST: crate::Field = crate::Field::new(1, 0, RESET);
|
||||
pub const RESET_CPU_RST: crate::Field = crate::Field::new(1, 1, RESET);
|
||||
|
||||
pub const SCRATCH: crate::Register = crate::Register::new(1, 0xffffffff);
|
||||
pub const SCRATCH_SCRATCH: crate::Field = crate::Field::new(32, 0, SCRATCH);
|
||||
|
||||
pub const BUS_ERRORS: crate::Register = crate::Register::new(2, 0xffffffff);
|
||||
pub const BUS_ERRORS_BUS_ERRORS: crate::Field = crate::Field::new(32, 0, BUS_ERRORS);
|
||||
|
||||
pub const HW_CTRL_BASE: usize = 0xe0001000;
|
||||
}
|
||||
|
||||
pub mod identifier_mem {
|
||||
pub const IDENTIFIER_MEM_NUMREGS: usize = 1;
|
||||
|
||||
pub const IDENTIFIER_MEM: crate::Register = crate::Register::new(0, 0xff);
|
||||
pub const IDENTIFIER_MEM_IDENTIFIER_MEM: crate::Field = crate::Field::new(8, 0, IDENTIFIER_MEM);
|
||||
|
||||
pub const HW_IDENTIFIER_MEM_BASE: usize = 0xe0001800;
|
||||
}
|
||||
|
||||
pub mod leds {
|
||||
pub const LEDS_NUMREGS: usize = 1;
|
||||
|
||||
pub const OUT: crate::Register = crate::Register::new(0, 0xf);
|
||||
pub const OUT_OUT: crate::Field = crate::Field::new(4, 0, OUT);
|
||||
|
||||
pub const HW_LEDS_BASE: usize = 0xe0002000;
|
||||
}
|
||||
|
||||
pub mod timer0 {
|
||||
pub const TIMER0_NUMREGS: usize = 8;
|
||||
|
||||
pub const LOAD: crate::Register = crate::Register::new(0, 0xffffffff);
|
||||
pub const LOAD_LOAD: crate::Field = crate::Field::new(32, 0, LOAD);
|
||||
|
||||
pub const RELOAD: crate::Register = crate::Register::new(1, 0xffffffff);
|
||||
pub const RELOAD_RELOAD: crate::Field = crate::Field::new(32, 0, RELOAD);
|
||||
|
||||
pub const EN: crate::Register = crate::Register::new(2, 0x1);
|
||||
pub const EN_EN: crate::Field = crate::Field::new(1, 0, EN);
|
||||
|
||||
pub const UPDATE_VALUE: crate::Register = crate::Register::new(3, 0x1);
|
||||
pub const UPDATE_VALUE_UPDATE_VALUE: crate::Field = crate::Field::new(1, 0, UPDATE_VALUE);
|
||||
|
||||
pub const VALUE: crate::Register = crate::Register::new(4, 0xffffffff);
|
||||
pub const VALUE_VALUE: crate::Field = crate::Field::new(32, 0, VALUE);
|
||||
|
||||
pub const EV_STATUS: crate::Register = crate::Register::new(5, 0x1);
|
||||
pub const EV_STATUS_ZERO: crate::Field = crate::Field::new(1, 0, EV_STATUS);
|
||||
|
||||
pub const EV_PENDING: crate::Register = crate::Register::new(6, 0x1);
|
||||
pub const EV_PENDING_ZERO: crate::Field = crate::Field::new(1, 0, EV_PENDING);
|
||||
|
||||
pub const EV_ENABLE: crate::Register = crate::Register::new(7, 0x1);
|
||||
pub const EV_ENABLE_ZERO: crate::Field = crate::Field::new(1, 0, EV_ENABLE);
|
||||
|
||||
pub const TIMER0_IRQ: usize = 0;
|
||||
pub const HW_TIMER0_BASE: usize = 0xe0002800;
|
||||
}
|
||||
|
||||
pub mod uart {
|
||||
pub const UART_NUMREGS: usize = 8;
|
||||
|
||||
pub const RXTX: crate::Register = crate::Register::new(0, 0xff);
|
||||
pub const RXTX_RXTX: crate::Field = crate::Field::new(8, 0, RXTX);
|
||||
|
||||
pub const TXFULL: crate::Register = crate::Register::new(1, 0x1);
|
||||
pub const TXFULL_TXFULL: crate::Field = crate::Field::new(1, 0, TXFULL);
|
||||
|
||||
pub const RXEMPTY: crate::Register = crate::Register::new(2, 0x1);
|
||||
pub const RXEMPTY_RXEMPTY: crate::Field = crate::Field::new(1, 0, RXEMPTY);
|
||||
|
||||
pub const EV_STATUS: crate::Register = crate::Register::new(3, 0x3);
|
||||
pub const EV_STATUS_TX: crate::Field = crate::Field::new(1, 0, EV_STATUS);
|
||||
pub const EV_STATUS_RX: crate::Field = crate::Field::new(1, 1, EV_STATUS);
|
||||
|
||||
pub const EV_PENDING: crate::Register = crate::Register::new(4, 0x3);
|
||||
pub const EV_PENDING_TX: crate::Field = crate::Field::new(1, 0, EV_PENDING);
|
||||
pub const EV_PENDING_RX: crate::Field = crate::Field::new(1, 1, EV_PENDING);
|
||||
|
||||
pub const EV_ENABLE: crate::Register = crate::Register::new(5, 0x3);
|
||||
pub const EV_ENABLE_TX: crate::Field = crate::Field::new(1, 0, EV_ENABLE);
|
||||
pub const EV_ENABLE_RX: crate::Field = crate::Field::new(1, 1, EV_ENABLE);
|
||||
|
||||
pub const TXEMPTY: crate::Register = crate::Register::new(6, 0x1);
|
||||
pub const TXEMPTY_TXEMPTY: crate::Field = crate::Field::new(1, 0, TXEMPTY);
|
||||
|
||||
pub const RXFULL: crate::Register = crate::Register::new(7, 0x1);
|
||||
pub const RXFULL_RXFULL: crate::Field = crate::Field::new(1, 0, RXFULL);
|
||||
|
||||
pub const UART_IRQ: usize = 1;
|
||||
pub const HW_UART_BASE: usize = 0xe0003000;
|
||||
}
|
||||
}
|
||||
|
||||
// Litex auto-generated constants
|
||||
pub const LITEX_CONFIG_CLOCK_FREQUENCY: usize = 40000000;
|
||||
pub const LITEX_CONFIG_CPU_HAS_INTERRUPT: &str = "None";
|
||||
pub const LITEX_CONFIG_CPU_RESET_ADDR: usize = 2147483648;
|
||||
pub const LITEX_CONFIG_CPU_HAS_DCACHE: &str = "None";
|
||||
pub const LITEX_CONFIG_CPU_HAS_ICACHE: &str = "None";
|
||||
pub const LITEX_CONFIG_CPU_TYPE_VEXIIRISCV: &str = "None";
|
||||
pub const LITEX_CONFIG_CPU_VARIANT_STANDARD: &str = "None";
|
||||
pub const LITEX_CONFIG_CPU_HUMAN_NAME: &str = "VexiiRiscv";
|
||||
pub const LITEX_CONFIG_CPU_NOP: &str = "nop";
|
||||
pub const LITEX_CONFIG_CSR_DATA_WIDTH: usize = 32;
|
||||
pub const LITEX_CONFIG_CSR_ALIGNMENT: usize = 32;
|
||||
pub const LITEX_CONFIG_BUS_STANDARD: &str = "WISHBONE";
|
||||
pub const LITEX_CONFIG_BUS_DATA_WIDTH: usize = 32;
|
||||
pub const LITEX_CONFIG_BUS_ADDRESS_WIDTH: usize = 32;
|
||||
pub const LITEX_CONFIG_BUS_BURSTING: usize = 0;
|
||||
pub const LITEX_TIMER0_INTERRUPT: usize = 0;
|
||||
pub const LITEX_UART_INTERRUPT: usize = 1;
|
||||
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_legacy_int_csr() {
|
||||
use super::*;
|
||||
let mut legacy_int_csr = CSR::new(HW_LEGACY_INT_BASE as *mut u32);
|
||||
|
||||
let foo = legacy_int_csr.r(utra::legacy_int::MACH_MASK);
|
||||
legacy_int_csr.wo(utra::legacy_int::MACH_MASK, foo);
|
||||
let bar = legacy_int_csr.rf(utra::legacy_int::MACH_MASK_MACH_MASK);
|
||||
legacy_int_csr.rmwf(utra::legacy_int::MACH_MASK_MACH_MASK, bar);
|
||||
let mut baz = legacy_int_csr.zf(utra::legacy_int::MACH_MASK_MACH_MASK, bar);
|
||||
baz |= legacy_int_csr.ms(utra::legacy_int::MACH_MASK_MACH_MASK, 1);
|
||||
legacy_int_csr.wfo(utra::legacy_int::MACH_MASK_MACH_MASK, baz);
|
||||
|
||||
let foo = legacy_int_csr.r(utra::legacy_int::MACH_PENDING);
|
||||
legacy_int_csr.wo(utra::legacy_int::MACH_PENDING, foo);
|
||||
let bar = legacy_int_csr.rf(utra::legacy_int::MACH_PENDING_MACH_PENDING);
|
||||
legacy_int_csr.rmwf(utra::legacy_int::MACH_PENDING_MACH_PENDING, bar);
|
||||
let mut baz = legacy_int_csr.zf(utra::legacy_int::MACH_PENDING_MACH_PENDING, bar);
|
||||
baz |= legacy_int_csr.ms(utra::legacy_int::MACH_PENDING_MACH_PENDING, 1);
|
||||
legacy_int_csr.wfo(utra::legacy_int::MACH_PENDING_MACH_PENDING, baz);
|
||||
|
||||
let foo = legacy_int_csr.r(utra::legacy_int::SUPER_MASK);
|
||||
legacy_int_csr.wo(utra::legacy_int::SUPER_MASK, foo);
|
||||
let bar = legacy_int_csr.rf(utra::legacy_int::SUPER_MASK_SUPER_MASK);
|
||||
legacy_int_csr.rmwf(utra::legacy_int::SUPER_MASK_SUPER_MASK, bar);
|
||||
let mut baz = legacy_int_csr.zf(utra::legacy_int::SUPER_MASK_SUPER_MASK, bar);
|
||||
baz |= legacy_int_csr.ms(utra::legacy_int::SUPER_MASK_SUPER_MASK, 1);
|
||||
legacy_int_csr.wfo(utra::legacy_int::SUPER_MASK_SUPER_MASK, baz);
|
||||
|
||||
let foo = legacy_int_csr.r(utra::legacy_int::SUPER_PENDING);
|
||||
legacy_int_csr.wo(utra::legacy_int::SUPER_PENDING, foo);
|
||||
let bar = legacy_int_csr.rf(utra::legacy_int::SUPER_PENDING_SUPER_PENDING);
|
||||
legacy_int_csr.rmwf(utra::legacy_int::SUPER_PENDING_SUPER_PENDING, bar);
|
||||
let mut baz = legacy_int_csr.zf(utra::legacy_int::SUPER_PENDING_SUPER_PENDING, bar);
|
||||
baz |= legacy_int_csr.ms(utra::legacy_int::SUPER_PENDING_SUPER_PENDING, 1);
|
||||
legacy_int_csr.wfo(utra::legacy_int::SUPER_PENDING_SUPER_PENDING, baz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_rgb_csr() {
|
||||
use super::*;
|
||||
let mut rgb_csr = CSR::new(HW_RGB_BASE as *mut u32);
|
||||
|
||||
let foo = rgb_csr.r(utra::rgb::OUT);
|
||||
rgb_csr.wo(utra::rgb::OUT, foo);
|
||||
let bar = rgb_csr.rf(utra::rgb::OUT_OUT);
|
||||
rgb_csr.rmwf(utra::rgb::OUT_OUT, bar);
|
||||
let mut baz = rgb_csr.zf(utra::rgb::OUT_OUT, bar);
|
||||
baz |= rgb_csr.ms(utra::rgb::OUT_OUT, 1);
|
||||
rgb_csr.wfo(utra::rgb::OUT_OUT, baz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_ctrl_csr() {
|
||||
use super::*;
|
||||
let mut ctrl_csr = CSR::new(HW_CTRL_BASE as *mut u32);
|
||||
|
||||
let foo = ctrl_csr.r(utra::ctrl::RESET);
|
||||
ctrl_csr.wo(utra::ctrl::RESET, foo);
|
||||
let bar = ctrl_csr.rf(utra::ctrl::RESET_SOC_RST);
|
||||
ctrl_csr.rmwf(utra::ctrl::RESET_SOC_RST, bar);
|
||||
let mut baz = ctrl_csr.zf(utra::ctrl::RESET_SOC_RST, bar);
|
||||
baz |= ctrl_csr.ms(utra::ctrl::RESET_SOC_RST, 1);
|
||||
ctrl_csr.wfo(utra::ctrl::RESET_SOC_RST, baz);
|
||||
let bar = ctrl_csr.rf(utra::ctrl::RESET_CPU_RST);
|
||||
ctrl_csr.rmwf(utra::ctrl::RESET_CPU_RST, bar);
|
||||
let mut baz = ctrl_csr.zf(utra::ctrl::RESET_CPU_RST, bar);
|
||||
baz |= ctrl_csr.ms(utra::ctrl::RESET_CPU_RST, 1);
|
||||
ctrl_csr.wfo(utra::ctrl::RESET_CPU_RST, baz);
|
||||
|
||||
let foo = ctrl_csr.r(utra::ctrl::SCRATCH);
|
||||
ctrl_csr.wo(utra::ctrl::SCRATCH, foo);
|
||||
let bar = ctrl_csr.rf(utra::ctrl::SCRATCH_SCRATCH);
|
||||
ctrl_csr.rmwf(utra::ctrl::SCRATCH_SCRATCH, bar);
|
||||
let mut baz = ctrl_csr.zf(utra::ctrl::SCRATCH_SCRATCH, bar);
|
||||
baz |= ctrl_csr.ms(utra::ctrl::SCRATCH_SCRATCH, 1);
|
||||
ctrl_csr.wfo(utra::ctrl::SCRATCH_SCRATCH, baz);
|
||||
|
||||
let foo = ctrl_csr.r(utra::ctrl::BUS_ERRORS);
|
||||
ctrl_csr.wo(utra::ctrl::BUS_ERRORS, foo);
|
||||
let bar = ctrl_csr.rf(utra::ctrl::BUS_ERRORS_BUS_ERRORS);
|
||||
ctrl_csr.rmwf(utra::ctrl::BUS_ERRORS_BUS_ERRORS, bar);
|
||||
let mut baz = ctrl_csr.zf(utra::ctrl::BUS_ERRORS_BUS_ERRORS, bar);
|
||||
baz |= ctrl_csr.ms(utra::ctrl::BUS_ERRORS_BUS_ERRORS, 1);
|
||||
ctrl_csr.wfo(utra::ctrl::BUS_ERRORS_BUS_ERRORS, baz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_identifier_mem_csr() {
|
||||
use super::*;
|
||||
let mut identifier_mem_csr = CSR::new(HW_IDENTIFIER_MEM_BASE as *mut u32);
|
||||
|
||||
let foo = identifier_mem_csr.r(utra::identifier_mem::IDENTIFIER_MEM);
|
||||
identifier_mem_csr.wo(utra::identifier_mem::IDENTIFIER_MEM, foo);
|
||||
let bar = identifier_mem_csr.rf(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM);
|
||||
identifier_mem_csr.rmwf(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, bar);
|
||||
let mut baz = identifier_mem_csr.zf(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, bar);
|
||||
baz |= identifier_mem_csr.ms(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, 1);
|
||||
identifier_mem_csr.wfo(utra::identifier_mem::IDENTIFIER_MEM_IDENTIFIER_MEM, baz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_leds_csr() {
|
||||
use super::*;
|
||||
let mut leds_csr = CSR::new(HW_LEDS_BASE as *mut u32);
|
||||
|
||||
let foo = leds_csr.r(utra::leds::OUT);
|
||||
leds_csr.wo(utra::leds::OUT, foo);
|
||||
let bar = leds_csr.rf(utra::leds::OUT_OUT);
|
||||
leds_csr.rmwf(utra::leds::OUT_OUT, bar);
|
||||
let mut baz = leds_csr.zf(utra::leds::OUT_OUT, bar);
|
||||
baz |= leds_csr.ms(utra::leds::OUT_OUT, 1);
|
||||
leds_csr.wfo(utra::leds::OUT_OUT, baz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_timer0_csr() {
|
||||
use super::*;
|
||||
let mut timer0_csr = CSR::new(HW_TIMER0_BASE as *mut u32);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::LOAD);
|
||||
timer0_csr.wo(utra::timer0::LOAD, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::LOAD_LOAD);
|
||||
timer0_csr.rmwf(utra::timer0::LOAD_LOAD, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::LOAD_LOAD, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::LOAD_LOAD, 1);
|
||||
timer0_csr.wfo(utra::timer0::LOAD_LOAD, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::RELOAD);
|
||||
timer0_csr.wo(utra::timer0::RELOAD, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::RELOAD_RELOAD);
|
||||
timer0_csr.rmwf(utra::timer0::RELOAD_RELOAD, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::RELOAD_RELOAD, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::RELOAD_RELOAD, 1);
|
||||
timer0_csr.wfo(utra::timer0::RELOAD_RELOAD, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::EN);
|
||||
timer0_csr.wo(utra::timer0::EN, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::EN_EN);
|
||||
timer0_csr.rmwf(utra::timer0::EN_EN, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::EN_EN, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::EN_EN, 1);
|
||||
timer0_csr.wfo(utra::timer0::EN_EN, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::UPDATE_VALUE);
|
||||
timer0_csr.wo(utra::timer0::UPDATE_VALUE, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::UPDATE_VALUE_UPDATE_VALUE);
|
||||
timer0_csr.rmwf(utra::timer0::UPDATE_VALUE_UPDATE_VALUE, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::UPDATE_VALUE_UPDATE_VALUE, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::UPDATE_VALUE_UPDATE_VALUE, 1);
|
||||
timer0_csr.wfo(utra::timer0::UPDATE_VALUE_UPDATE_VALUE, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::VALUE);
|
||||
timer0_csr.wo(utra::timer0::VALUE, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::VALUE_VALUE);
|
||||
timer0_csr.rmwf(utra::timer0::VALUE_VALUE, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::VALUE_VALUE, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::VALUE_VALUE, 1);
|
||||
timer0_csr.wfo(utra::timer0::VALUE_VALUE, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::EV_STATUS);
|
||||
timer0_csr.wo(utra::timer0::EV_STATUS, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::EV_STATUS_ZERO);
|
||||
timer0_csr.rmwf(utra::timer0::EV_STATUS_ZERO, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::EV_STATUS_ZERO, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::EV_STATUS_ZERO, 1);
|
||||
timer0_csr.wfo(utra::timer0::EV_STATUS_ZERO, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::EV_PENDING);
|
||||
timer0_csr.wo(utra::timer0::EV_PENDING, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::EV_PENDING_ZERO);
|
||||
timer0_csr.rmwf(utra::timer0::EV_PENDING_ZERO, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::EV_PENDING_ZERO, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::EV_PENDING_ZERO, 1);
|
||||
timer0_csr.wfo(utra::timer0::EV_PENDING_ZERO, baz);
|
||||
|
||||
let foo = timer0_csr.r(utra::timer0::EV_ENABLE);
|
||||
timer0_csr.wo(utra::timer0::EV_ENABLE, foo);
|
||||
let bar = timer0_csr.rf(utra::timer0::EV_ENABLE_ZERO);
|
||||
timer0_csr.rmwf(utra::timer0::EV_ENABLE_ZERO, bar);
|
||||
let mut baz = timer0_csr.zf(utra::timer0::EV_ENABLE_ZERO, bar);
|
||||
baz |= timer0_csr.ms(utra::timer0::EV_ENABLE_ZERO, 1);
|
||||
timer0_csr.wfo(utra::timer0::EV_ENABLE_ZERO, baz);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn compile_check_uart_csr() {
|
||||
use super::*;
|
||||
let mut uart_csr = CSR::new(HW_UART_BASE as *mut u32);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::RXTX);
|
||||
uart_csr.wo(utra::uart::RXTX, foo);
|
||||
let bar = uart_csr.rf(utra::uart::RXTX_RXTX);
|
||||
uart_csr.rmwf(utra::uart::RXTX_RXTX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::RXTX_RXTX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::RXTX_RXTX, 1);
|
||||
uart_csr.wfo(utra::uart::RXTX_RXTX, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::TXFULL);
|
||||
uart_csr.wo(utra::uart::TXFULL, foo);
|
||||
let bar = uart_csr.rf(utra::uart::TXFULL_TXFULL);
|
||||
uart_csr.rmwf(utra::uart::TXFULL_TXFULL, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::TXFULL_TXFULL, bar);
|
||||
baz |= uart_csr.ms(utra::uart::TXFULL_TXFULL, 1);
|
||||
uart_csr.wfo(utra::uart::TXFULL_TXFULL, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::RXEMPTY);
|
||||
uart_csr.wo(utra::uart::RXEMPTY, foo);
|
||||
let bar = uart_csr.rf(utra::uart::RXEMPTY_RXEMPTY);
|
||||
uart_csr.rmwf(utra::uart::RXEMPTY_RXEMPTY, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::RXEMPTY_RXEMPTY, bar);
|
||||
baz |= uart_csr.ms(utra::uart::RXEMPTY_RXEMPTY, 1);
|
||||
uart_csr.wfo(utra::uart::RXEMPTY_RXEMPTY, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::EV_STATUS);
|
||||
uart_csr.wo(utra::uart::EV_STATUS, foo);
|
||||
let bar = uart_csr.rf(utra::uart::EV_STATUS_TX);
|
||||
uart_csr.rmwf(utra::uart::EV_STATUS_TX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::EV_STATUS_TX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::EV_STATUS_TX, 1);
|
||||
uart_csr.wfo(utra::uart::EV_STATUS_TX, baz);
|
||||
let bar = uart_csr.rf(utra::uart::EV_STATUS_RX);
|
||||
uart_csr.rmwf(utra::uart::EV_STATUS_RX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::EV_STATUS_RX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::EV_STATUS_RX, 1);
|
||||
uart_csr.wfo(utra::uart::EV_STATUS_RX, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::EV_PENDING);
|
||||
uart_csr.wo(utra::uart::EV_PENDING, foo);
|
||||
let bar = uart_csr.rf(utra::uart::EV_PENDING_TX);
|
||||
uart_csr.rmwf(utra::uart::EV_PENDING_TX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::EV_PENDING_TX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::EV_PENDING_TX, 1);
|
||||
uart_csr.wfo(utra::uart::EV_PENDING_TX, baz);
|
||||
let bar = uart_csr.rf(utra::uart::EV_PENDING_RX);
|
||||
uart_csr.rmwf(utra::uart::EV_PENDING_RX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::EV_PENDING_RX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::EV_PENDING_RX, 1);
|
||||
uart_csr.wfo(utra::uart::EV_PENDING_RX, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::EV_ENABLE);
|
||||
uart_csr.wo(utra::uart::EV_ENABLE, foo);
|
||||
let bar = uart_csr.rf(utra::uart::EV_ENABLE_TX);
|
||||
uart_csr.rmwf(utra::uart::EV_ENABLE_TX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::EV_ENABLE_TX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::EV_ENABLE_TX, 1);
|
||||
uart_csr.wfo(utra::uart::EV_ENABLE_TX, baz);
|
||||
let bar = uart_csr.rf(utra::uart::EV_ENABLE_RX);
|
||||
uart_csr.rmwf(utra::uart::EV_ENABLE_RX, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::EV_ENABLE_RX, bar);
|
||||
baz |= uart_csr.ms(utra::uart::EV_ENABLE_RX, 1);
|
||||
uart_csr.wfo(utra::uart::EV_ENABLE_RX, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::TXEMPTY);
|
||||
uart_csr.wo(utra::uart::TXEMPTY, foo);
|
||||
let bar = uart_csr.rf(utra::uart::TXEMPTY_TXEMPTY);
|
||||
uart_csr.rmwf(utra::uart::TXEMPTY_TXEMPTY, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::TXEMPTY_TXEMPTY, bar);
|
||||
baz |= uart_csr.ms(utra::uart::TXEMPTY_TXEMPTY, 1);
|
||||
uart_csr.wfo(utra::uart::TXEMPTY_TXEMPTY, baz);
|
||||
|
||||
let foo = uart_csr.r(utra::uart::RXFULL);
|
||||
uart_csr.wo(utra::uart::RXFULL, foo);
|
||||
let bar = uart_csr.rf(utra::uart::RXFULL_RXFULL);
|
||||
uart_csr.rmwf(utra::uart::RXFULL_RXFULL, bar);
|
||||
let mut baz = uart_csr.zf(utra::uart::RXFULL_RXFULL, bar);
|
||||
baz |= uart_csr.ms(utra::uart::RXFULL_RXFULL, 1);
|
||||
uart_csr.wfo(utra::uart::RXFULL_RXFULL, baz);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue