From 229786e3afbddd98a819698238e096c9e4f5bde3 Mon Sep 17 00:00:00 2001
From: "joachim.schmidt" <joachim.schmidt@hesge.ch>
Date: Mon, 25 Oct 2021 09:12:24 +0200
Subject: [PATCH] Update Scalp Register Editor
---
config/scalp_fast_router_registers.json | 163 ++++++
config/scalp_router_regbank.json | 125 +++++
config/scalp_router_regbank_wd.json | 38 ++
config/scalp_safe_firmware_reg_bank.json | 29 +
config/template_regbank.json | 65 +++
.../src/hdl/scalp_fast_router_registers.vhd | 408 ++++++++++++++
src/__pycache__/regedit.cpython-37.pyc | Bin 0 -> 9858 bytes
src/__pycache__/regedit.cpython-39.pyc | Bin 0 -> 10389 bytes
src/__pycache__/utils.cpython-37.pyc | Bin 0 -> 1488 bytes
src/__pycache__/utils.cpython-39.pyc | Bin 0 -> 1512 bytes
src/regedit.py | 499 ++++++++++++++++++
src/regedit.pyc | Bin 0 -> 5323 bytes
src/regedit_creator.py | 121 +++++
src/templates/hdl/template_regbank.vhd | 310 +++++++++++
src/utils.py | 47 ++
src/utils.pyc | Bin 0 -> 1808 bytes
16 files changed, 1805 insertions(+)
create mode 100644 config/scalp_fast_router_registers.json
create mode 100644 config/scalp_router_regbank.json
create mode 100644 config/scalp_router_regbank_wd.json
create mode 100644 config/scalp_safe_firmware_reg_bank.json
create mode 100644 config/template_regbank.json
create mode 100644 output/scalp_fast_router_registers/1.4/src/hdl/scalp_fast_router_registers.vhd
create mode 100644 src/__pycache__/regedit.cpython-37.pyc
create mode 100644 src/__pycache__/regedit.cpython-39.pyc
create mode 100644 src/__pycache__/utils.cpython-37.pyc
create mode 100644 src/__pycache__/utils.cpython-39.pyc
create mode 100644 src/regedit.py
create mode 100644 src/regedit.pyc
create mode 100755 src/regedit_creator.py
create mode 100644 src/templates/hdl/template_regbank.vhd
create mode 100644 src/utils.py
create mode 100644 src/utils.pyc
diff --git a/config/scalp_fast_router_registers.json b/config/scalp_fast_router_registers.json
new file mode 100644
index 0000000..a9f357b
--- /dev/null
+++ b/config/scalp_fast_router_registers.json
@@ -0,0 +1,163 @@
+{
+ "config" : {
+ "entity_name" : "scalp_fast_router_registers",
+ "entity_version" : "1.4",
+ "entity_reg_io_access" : true,
+ "block_name" : "ScalpFastRouterRegisters",
+ "bd_name" : "/scalp_axi4lite_0/SAXILitexDIO",
+ "bd_interface" : "SAXILitexDIO",
+ "bd_slave_segment" : "SAXILiteAddr",
+ "bd_master_base_address" : "0x43C00000",
+ "bd_range" : "4K"
+ },
+ "register_bank" : [
+ {
+ "register_status_active" : true,
+ "register_name" : "LocalNetAddr",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "rw",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "RGBLed0",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "rw",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "RGBLed1",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "rw",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "DMAFifoTXWrDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "DMAFifoTXRrDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "DMAFifoTXStatus",
+ "register_size" : "32",
+ "register_type" : "stat",
+ "register_access_mode" : "ro",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "TX_PROG_EMPTY" : 1,
+ "TX_PROG_FULL" : 1,
+ "RESERVED" : 30
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "DMAFifoRXWrDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "DMAFifoRXRrDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "DMAFifoRXStatus",
+ "register_size" : "32",
+ "register_type" : "stat",
+ "register_access_mode" : "ro",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "RX_PROG_EMPTY" : 1,
+ "RX_PROG_FULL" : 1,
+ "RESERVED" : 30
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "QoSPhyStatus",
+ "register_size" : "32",
+ "register_type" : "stat",
+ "register_access_mode" : "ro",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "NORTH" : 1,
+ "EAST" : 1,
+ "SOUTH" : 1,
+ "WEST" : 1,
+ "TOP" : 1,
+ "BOTTOM" : 1,
+ "LOCAL" : 1,
+ "RESERVED" : 25
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "QoSDMAInitOcpCtrl",
+ "register_size" : "32",
+ "register_type" : "ocp",
+ "register_access_mode" : "wo",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "NORTH" : 1,
+ "EAST" : 1,
+ "SOUTH" : 1,
+ "WEST" : 1,
+ "TOP" : 1,
+ "BOTTOM" : 1,
+ "LOCAL" : 1,
+ "RESERVED" : 25
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "QoSDMAInitStatus",
+ "register_size" : "32",
+ "register_type" : "stat",
+ "register_access_mode" : "ro",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "NORTH" : 1,
+ "EAST" : 1,
+ "SOUTH" : 1,
+ "WEST" : 1,
+ "TOP" : 1,
+ "BOTTOM" : 1,
+ "LOCAL" : 1,
+ "RESERVED" : 25
+ }
+ }
+ ]
+}
diff --git a/config/scalp_router_regbank.json b/config/scalp_router_regbank.json
new file mode 100644
index 0000000..1455881
--- /dev/null
+++ b/config/scalp_router_regbank.json
@@ -0,0 +1,125 @@
+{
+ "config" : {
+ "entity_name" : "scalp_router_regbank",
+ "entity_version" : "0.1",
+ "entity_reg_io_access" : true,
+ "block_name" : "ScalpRouterRegBank",
+ "bd_name" : "/scalp_axi4lite_0/SAXILitexDIO",
+ "bd_interface" : "SAXILitexDIO",
+ "bd_slave_segment" : "SAXILiteAddr",
+ "bd_master_base_address" : "0x43C00000",
+ "bd_range" : "4K"
+ },
+ "register_bank" : [
+ {
+ "register_status_active" : true,
+ "register_name" : "ScalpPacketWriteData",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "rw",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "ScalpPacketReadData",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "ScalpPacketCtrl",
+ "register_size" : "32",
+ "register_type" : "ctrl",
+ "register_access_mode" : "wo",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "WRITE_VALID" : 1,
+ "WRITE_LAST" : 1,
+ "WRITE_READY" : 1,
+ "WRITE_NEXT" : 1,
+ "RESET_ALL_FIFO" : 1,
+ "WRITE_H0" : 1,
+ "WRITE_H1" : 1,
+ "WRITE_H2" : 1,
+ "WRITE_PLD" : 1,
+ "WRITE_NEW_PACKET" : 1,
+ "READ_NEXT" : 1,
+ "READ_NEW_PACKET" : 1,
+ "RESERVED" : 20
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "ScalpPacketStatus",
+ "register_size" : "32",
+ "register_type" : "stat",
+ "register_access_mode" : "ro",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "READ_VALID" : 1,
+ "READ_LAST" : 1,
+ "TX_PROG_FULL" : 1,
+ "RX_PROG_FULL" : 1,
+ "READ_WAIT_NEXT" : 1,
+ "RESERVED" : 27
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "TXWrDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "TXRdDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "RXWrDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "RXRdDataCnt",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "ro",
+ "register_multifield" : false,
+ "register_initial_value" : 0
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "LocNetAddr",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "rw",
+ "register_multifield" : false,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "SCALP_ADDR_X" : 8,
+ "SCALP_ADDR_Y" : 8,
+ "SCALP_ADDR_Z" : 8,
+ "RESERVED" : 8
+ }
+ }
+ ]
+}
diff --git a/config/scalp_router_regbank_wd.json b/config/scalp_router_regbank_wd.json
new file mode 100644
index 0000000..6822ed6
--- /dev/null
+++ b/config/scalp_router_regbank_wd.json
@@ -0,0 +1,38 @@
+{
+ "reg1" :
+ [
+ {
+ "bits" : 16,
+ "name" : "ScalpPacketWriteData",
+ "type" : 1,
+ "attr" : [
+ "reg_type : data",
+ "reg_access_mode : rw",
+ "reg_address: 0x43C00000"
+ ]
+ },
+ {
+ "bits" : 16,
+ "name" : "ScalpPacketWriteData",
+ "type" : 1
+ }
+ ],
+ "reg2" :
+ [
+ {
+ "bits" : 16,
+ "name" : "ScalpPacketReadData",
+ "type" : 1,
+ "attr" : [
+ "reg_type : data",
+ "reg_access_mode : ro",
+ "reg_address: 0x43C00004"
+ ]
+ },
+ {
+ "bits" : 16,
+ "name" : "ScalpPacketReadData",
+ "type" : 1
+ }
+ ]
+}
diff --git a/config/scalp_safe_firmware_reg_bank.json b/config/scalp_safe_firmware_reg_bank.json
new file mode 100644
index 0000000..a089a2d
--- /dev/null
+++ b/config/scalp_safe_firmware_reg_bank.json
@@ -0,0 +1,29 @@
+{
+ "config" : {
+ "entity_name" : "scalp_safe_firmware_reg_bank",
+ "entity_version" : "0.2",
+ "entity_reg_io_access" : true,
+ "block_name" : "ScalpSafeFirmwareRegBank",
+ "bd_name" : "/scalp_axi4lite_0/SAXILitexDIO",
+ "bd_interface" : "SAXILitexDIO",
+ "bd_slave_segment" : "SAXILiteAddr",
+ "bd_master_base_address" : "0x43C10000",
+ "bd_range" : "4K"
+ },
+ "register_bank" : [
+ {
+ "register_status_active" : true,
+ "register_name" : "RgbLedsCtrl",
+ "register_size" : "32",
+ "register_type" : "ctrl",
+ "register_access_mode" : "rw",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "RgbLed1" : 3,
+ "RgbLed2" : 3,
+ "Unused" : 26
+ }
+ }
+ ]
+}
diff --git a/config/template_regbank.json b/config/template_regbank.json
new file mode 100644
index 0000000..9e89085
--- /dev/null
+++ b/config/template_regbank.json
@@ -0,0 +1,65 @@
+{
+ "config" : {
+ "entity_name" : "scalp_safe_firmware_reg_bank",
+ "entity_version" : "0.1",
+ "entity_reg_io_access" : true,
+ "block_name" : "ScalpSafeFirmwareRegBank",
+ "bd_name" : "/scalp_axi4lite_0/SAXILitexDIO",
+ "bd_interface" : "SAXILitexDIO",
+ "bd_slave_segment" : "SAXILiteAddr",
+ "bd_master_base_address" : "0x43C00000",
+ "bd_range" : "256"
+ },
+ "register_bank" : [
+ {
+ "register_status_active" : true,
+ "register_name" : "RgbLedsCtrl",
+ "register_size" : "32",
+ "register_type" : "ctrl",
+ "register_access_mode" : "rw",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "RgbLed1" : 3,
+ "RgbLed2" : 3,
+ "Unused" : 26
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "Ctrl1",
+ "register_size" : "32",
+ "register_type" : "ctrl",
+ "register_access_mode" : "wo",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "f0" : 1,
+ "f1" : 1,
+ "f2" : 30
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "Status",
+ "register_size" : "32",
+ "register_type" : "stat",
+ "register_access_mode" : "ro",
+ "register_multifield" : true,
+ "register_initial_value" : 0,
+ "register_fields" : {
+ "f0" : 1,
+ "f1" : 31
+ }
+ },
+ {
+ "register_status_active" : true,
+ "register_name" : "Data1",
+ "register_size" : "32",
+ "register_type" : "data",
+ "register_access_mode" : "rw",
+ "register_multifield" : false,
+ "register_initial_value" : 255
+ }
+ ]
+}
diff --git a/output/scalp_fast_router_registers/1.4/src/hdl/scalp_fast_router_registers.vhd b/output/scalp_fast_router_registers/1.4/src/hdl/scalp_fast_router_registers.vhd
new file mode 100644
index 0000000..77109ca
--- /dev/null
+++ b/output/scalp_fast_router_registers/1.4/src/hdl/scalp_fast_router_registers.vhd
@@ -0,0 +1,408 @@
+-- THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+-- scalp_regedit v0.1 - 05.2021
+-- Author : Joachim Schmidt <joachim.schmidt@hesge.ch>
+
+library ieee;
+use ieee.std_logic_1164.all;
+use ieee.numeric_std.all;
+use ieee.std_logic_unsigned.all;
+use ieee.std_logic_arith.all;
+use ieee.std_logic_misc.all;
+
+library unisim;
+use unisim.vcomponents.all;
+
+entity scalp_fast_router_registers is
+
+ generic (
+ C_AXI4_ARADDR_SIZE : integer range 0 to 32 := 32;
+ C_AXI4_RDATA_SIZE : integer range 0 to 32 := 32;
+ C_AXI4_RRESP_SIZE : integer range 0 to 2 := 2;
+ C_AXI4_AWADDR_SIZE : integer range 0 to 32 := 32;
+ C_AXI4_WDATA_SIZE : integer range 0 to 32 := 32;
+ C_AXI4_WSTRB_SIZE : integer range 0 to 4 := 4;
+ C_AXI4_BRESP_SIZE : integer range 0 to 2 := 2;
+ C_AXI4_ADDR_SIZE : integer range 0 to 32 := 12;
+ C_AXI4_DATA_SIZE : integer range 0 to 32 := 32);
+
+ port (
+ -- Clock and reset
+ SAxiClkxCI : in std_ulogic;
+ SAxiRstxRANI : in std_ulogic;
+ -- AXI4 Lite
+ -- Read Channel
+ -- Read Address Channel
+ SAxiARAddrxDI : in std_ulogic_vector((C_AXI4_ARADDR_SIZE - 1) downto 0);
+ SAxiARValidxSI : in std_ulogic;
+ SAxiARReadyxSO : out std_ulogic;
+ -- Read Data Channel
+ SAxiRDataxDO : out std_ulogic_vector((C_AXI4_RDATA_SIZE - 1) downto 0);
+ SAxiRRespxDO : out std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0);
+ SAxiRValidxSO : out std_ulogic;
+ SAxiRReadyxSI : in std_ulogic;
+ -- Write Channel
+ -- Write Address Channel
+ SAxiAWAddrxDI : in std_ulogic_vector((C_AXI4_AWADDR_SIZE - 1) downto 0);
+ SAxiAWValidxSI : in std_ulogic;
+ SAxiAWReadyxSO : out std_ulogic;
+ -- Write Data Channel
+ SAxiWDataxDI : in std_ulogic_vector((C_AXI4_WDATA_SIZE - 1) downto 0);
+ SAxiWStrbxDI : in std_ulogic_vector((C_AXI4_WSTRB_SIZE - 1) downto 0);
+ SAxiWValidxSI : in std_ulogic;
+ SAxiWReadyxSO : out std_ulogic;
+ -- Write Response Channel
+ SAxiBRespxDO : out std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0);
+ SAxiBValidxSO : out std_ulogic;
+ SAxiBReadyxSI : in std_ulogic;
+ -- Registers list IO
+ LocalNetAddrxDO : out std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ RGBLed0xDO : out std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ RGBLed1xDO : out std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ DMAFifoTXWrDataCntxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ DMAFifoTXRrDataCntxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ DMAFifoTXStatusxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ DMAFifoRXWrDataCntxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ DMAFifoRXRrDataCntxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ DMAFifoRXStatusxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ QoSPhyStatusxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ QoSDMAInitOcpCtrlxDO : out std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0);
+ QoSDMAInitStatusxDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0));
+
+end scalp_fast_router_registers;
+
+architecture behavioral of scalp_fast_router_registers is
+
+ -- Constants
+ constant C_AXI4_RRESP_OKAY : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "00";
+ constant C_AXI4_RRESP_EXOKAY : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "01";
+ constant C_AXI4_RRESP_SLVERR : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "10";
+ constant C_AXI4_RRESP_DECERR : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "11";
+ constant C_AXI4_BRESP_OKAY : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "00";
+ constant C_AXI4_BRESP_EXOKAY : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "01";
+ constant C_AXI4_BRESP_SLVERR : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "10";
+ constant C_AXI4_BRESP_DECERR : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "11";
+
+ -- Signals
+ -- Clock and reset
+ signal SAxiClkxC : std_ulogic := '0';
+ signal SAxiRstxRAN : std_ulogic := '0';
+ -- AXI4 Lite
+ signal SAxiARReadyxS : std_ulogic := '0';
+ signal SAxiRValidxS : std_ulogic := '0';
+ signal SAxiBValidxS : std_ulogic := '0';
+ signal SAxiWReadyxS : std_ulogic := '0';
+ signal SAxiAWReadyxS : std_ulogic := '0';
+ signal WrAddrxDN : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ signal WrAddrxDP : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ -- Signals of access to the register bank
+ signal RdAddrxD : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ signal RdDataxD : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := (others => '0');
+ signal RdValidxS : std_ulogic := '0';
+ signal WrAddrxD : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ signal WrDataxD : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := (others => '0');
+ signal WrValidxS : std_ulogic := '0';
+ -- Registers list
+ signal LocalNetAddrPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal LocalNetAddrPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal RGBLed0PortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal RGBLed0PortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal RGBLed1PortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal RGBLed1PortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoTXWrDataCntPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoTXWrDataCntPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoTXRrDataCntPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoTXRrDataCntPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoTXStatusPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoTXStatusPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoRXWrDataCntPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoRXWrDataCntPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoRXRrDataCntPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoRXRrDataCntPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoRXStatusPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal DMAFifoRXStatusPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal QoSPhyStatusPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal QoSPhyStatusPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal QoSDMAInitOcpCtrlPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal QoSDMAInitOcpCtrlPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal QoSDMAInitStatusPortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+ signal QoSDMAInitStatusPortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x"00000000";
+
+ -- Attributes
+ attribute mark_debug : string;
+ attribute keep : string;
+ --
+ -- attribute mark_debug of : signal is "true";
+ -- attribute keep of : signal is "true";
+
+begin
+
+ assert C_AXI4_RDATA_SIZE = C_AXI4_DATA_SIZE
+ report "RDATA and DATA vectors must be the same" severity failure;
+
+ assert C_AXI4_ARADDR_SIZE >= C_AXI4_ADDR_SIZE
+ report "ARADDR and ADDR vectors must be the same" severity failure;
+
+ assert C_AXI4_WDATA_SIZE = C_AXI4_DATA_SIZE
+ report "WDATA and DATA vectors must be the same" severity failure;
+
+ assert C_AXI4_AWADDR_SIZE >= C_AXI4_ADDR_SIZE
+ report "AWADDR and ADDR vectors must be the same" severity failure;
+
+ EntityIOxB : block is
+ begin -- block EntityIOxB
+
+ -- Clock and reset
+ SAxiClkxAS : SAxiClkxC <= SAxiClkxCI;
+ SAxiRstxAS : SAxiRstxRAN <= SAxiRstxRANI;
+ -- Read Channel
+ SAxiARReadyxAS : SAxiARReadyxSO <= SAxiARReadyxS;
+ SAxiRValidxAS : SAxiRValidxSO <= SAxiRValidxS;
+ SAxiRDataxAS : SAxiRDataxDO <= RdDataxD;
+ RdValidxAS : RdValidxS <= SAxiARValidxSI;
+ RdAddrxAS : RdAddrxD((C_AXI4_ADDR_SIZE - 1) downto 0) <= SAxiARAddrxDI((C_AXI4_ADDR_SIZE - 1) downto 0);
+ SAxiRRespxAS : SAxiRRespxDO <= C_AXI4_RRESP_OKAY;
+ -- Write Channel
+ SAxiBRespxAS : SAxiBRespxDO <= C_AXI4_BRESP_OKAY;
+ SAxiBValidxAS : SAxiBValidxSO <= SAxiBValidxS;
+ SAxiWReadyxAS : SAxiWReadyxSO <= SAxiWReadyxS;
+ SAxiAWReadyxAS : SAxiAWReadyxSO <= SAxiAWReadyxS;
+ WrValidxAS : WrValidxS <= SAxiWValidxSI;
+ WrDataxAS : WrDataxD <= SAxiWDataxDI;
+ WrAddrOutxAS : WrAddrxD <= WrAddrxDP;
+ WrAddrxAS : WrAddrxDN((C_AXI4_ADDR_SIZE - 1) downto 0) <= SAxiAWAddrxDI((C_AXI4_ADDR_SIZE - 1) downto 0) when
+ SAxiAWValidxSI = '1' else
+ WrAddrxDP((C_AXI4_ADDR_SIZE - 1) downto 0);
+
+ end block EntityIOxB;
+
+ AXI4LitexB : block is
+ begin -- block AXI4LitexB
+
+ ReadChannelxB : block is
+ begin -- block ReadChannelxB
+
+ ReadAddrChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+
+ variable StateAfterResetxS : boolean := true;
+
+ begin -- process ReadAddrChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiARReadyxS <= '0';
+ StateAfterResetxS := true;
+ elsif rising_edge(SAxiClkxC) then
+ if StateAfterResetxS = true then
+ SAxiARReadyxS <= '1';
+ StateAfterResetxS := false;
+ else
+ SAxiARReadyxS <= SAxiARReadyxS;
+ end if;
+
+ if SAxiARValidxSI = '1' then
+ SAxiARReadyxS <= '0';
+ end if;
+
+ if SAxiARReadyxS <= '0' and SAxiRReadyxSI = '1' then
+ SAxiARReadyxS <= '1';
+ end if;
+ end if;
+ end process ReadAddrChanxP;
+
+ ReadDataChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process ReadDataChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiRValidxS <= '0';
+ elsif rising_edge(SAxiClkxC) then
+ SAxiRValidxS <= SAxiRValidxS;
+
+ if SAxiARValidxSI = '1' and SAxiARReadyxS = '1' then
+ SAxiRValidxS <= '1';
+ end if;
+
+ if SAxiRValidxS = '1' and SAxiRReadyxSI = '1' then
+ SAxiRValidxS <= '0';
+ end if;
+ end if;
+ end process ReadDataChanxP;
+
+ end block ReadChannelxB;
+
+ WriteChannelxB : block is
+ begin --block WriteChannelxB
+
+ WrAddrRegxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process WrAddrRegxP
+ if SAxiRstxRAN = '0' then
+ WrAddrxDP <= (others => '0');
+ elsif rising_edge(SAxiClkxC) then
+ WrAddrxDP <= WrAddrxDN;
+ end if;
+ end process WrAddrRegxP;
+
+ WriteAddrChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+
+ variable StateAfterResetxS : boolean := true;
+
+ begin -- process WriteAddrChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiAWReadyxS <= '0';
+ StateAfterResetxS := true;
+ elsif rising_edge(SAxiClkxC) then
+ if StateAfterResetxS = true then
+ SAxiAWReadyxS <= '1';
+ StateAfterResetxS := false;
+ else
+ SAxiAWReadyxS <= SAxiAWReadyxS;
+ end if;
+
+ if SAxiAWValidxSI = '1' then
+ SAxiAWReadyxS <= '0';
+ end if;
+
+ if SAxiWValidxSI = '1' then
+ SAxiAWReadyxS <= '1';
+ end if;
+ end if;
+ end process WriteAddrChanxP;
+
+ WriteDataChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process WriteDataChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiWReadyxS <= '0';
+ elsif rising_edge(SAxiClkxC) then
+ SAxiWReadyxS <= SAxiWReadyxS;
+
+ if SAxiAWValidxSI = '1' and SAxiAWReadyxS = '1' then
+ SAxiWReadyxS <= '1';
+ end if;
+
+ if SAxiWValidxSI = '1' and SAxiWReadyxS = '1' then
+ SAxiWReadyxS <= '0';
+ end if;
+ end if;
+ end process WriteDataChanxP;
+
+ WriteRespChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process WriteRespChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiBValidxS <= '0';
+ elsif rising_edge(SAxiClkxC) then
+ SAxiBValidxS <= SAxiBValidxS;
+
+ if SAxiWValidxSI = '1' and SAxiWReadyxS = '1' then
+ SAxiBValidxS <= '1';
+ end if;
+
+ if SAxiBValidxS = '1' and SAxiBReadyxSI = '1' then
+ SAxiBValidxS <= '0';
+ end if;
+ end if;
+ end process WriteRespChanxP;
+
+ end block WriteChannelxB;
+
+ end block AXI4LitexB;
+
+ ScalpFastRouterRegistersxB : block is
+ begin -- block ScalpFastRouterRegistersxB
+
+ WriteRegPortxP : process (DMAFifoRXRrDataCntxDI, DMAFifoRXStatusxDI,
+ DMAFifoRXWrDataCntxDI, DMAFifoTXRrDataCntxDI,
+ DMAFifoTXStatusxDI, DMAFifoTXWrDataCntxDI,
+ LocalNetAddrPortxDP,
+ QoSDMAInitOcpCtrlPortxDP,
+ QoSDMAInitStatusxDI, QoSPhyStatusxDI,
+ RGBLed0PortxDP, RGBLed1PortxDP, WrAddrxD,
+ WrDataxD, WrValidxS) is
+ begin -- process WriteRegPortxP
+ LocalNetAddrPortxDN <= LocalNetAddrPortxDP;
+ LocalNetAddrxDO <= LocalNetAddrPortxDP;
+ RGBLed0PortxDN <= RGBLed0PortxDP;
+ RGBLed0xDO <= RGBLed0PortxDP;
+ RGBLed1PortxDN <= RGBLed1PortxDP;
+ RGBLed1xDO <= RGBLed1PortxDP;
+ DMAFifoTXWrDataCntPortxDN <= DMAFifoTXWrDataCntxDI;
+ DMAFifoTXRrDataCntPortxDN <= DMAFifoTXRrDataCntxDI;
+ DMAFifoTXStatusPortxDN <= DMAFifoTXStatusxDI;
+ DMAFifoRXWrDataCntPortxDN <= DMAFifoRXWrDataCntxDI;
+ DMAFifoRXRrDataCntPortxDN <= DMAFifoRXRrDataCntxDI;
+ DMAFifoRXStatusPortxDN <= DMAFifoRXStatusxDI;
+ QoSPhyStatusPortxDN <= QoSPhyStatusxDI;
+ QoSDMAInitOcpCtrlPortxDN <= (others => '0');
+ QoSDMAInitOcpCtrlxDO <= QoSDMAInitOcpCtrlPortxDP;
+ QoSDMAInitStatusPortxDN <= QoSDMAInitStatusxDI;
+
+ if WrValidxS = '1' then
+ case WrAddrxD is
+ when x"000" => LocalNetAddrPortxDN <= WrDataxD;
+ when x"004" => RGBLed0PortxDN <= WrDataxD;
+ when x"008" => RGBLed1PortxDN <= WrDataxD;
+ when x"028" => QoSDMAInitOcpCtrlPortxDN <= WrDataxD;
+
+ when others => null;
+ end case;
+ end if;
+ end process WriteRegPortxP;
+
+ ReadRegPortxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process ReadRegPortxP
+ if SAxiRstxRAN = '0' then
+ RdDataxD <= (others => '0');
+ elsif rising_edge(SAxiClkxC) then
+ RdDataxD <= RdDataxD;
+
+ if RdValidxS = '1' then
+ case RdAddrxD is
+ when x"000" => RdDataxD <= LocalNetAddrPortxDP;
+ when x"004" => RdDataxD <= RGBLed0PortxDP;
+ when x"008" => RdDataxD <= RGBLed1PortxDP;
+ when x"00C" => RdDataxD <= DMAFifoTXWrDataCntPortxDP;
+ when x"010" => RdDataxD <= DMAFifoTXRrDataCntPortxDP;
+ when x"014" => RdDataxD <= DMAFifoTXStatusPortxDP;
+ when x"018" => RdDataxD <= DMAFifoRXWrDataCntPortxDP;
+ when x"01C" => RdDataxD <= DMAFifoRXRrDataCntPortxDP;
+ when x"020" => RdDataxD <= DMAFifoRXStatusPortxDP;
+ when x"024" => RdDataxD <= QoSPhyStatusPortxDP;
+ when x"02C" => RdDataxD <= QoSDMAInitStatusPortxDP;
+
+ when others => RdDataxD <= (others => '0');
+ end case;
+ end if;
+ end if;
+ end process ReadRegPortxP;
+
+ UpdateRegBankxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process UpdateRegBankxP
+ if SAxiRstxRAN = '0' then
+ LocalNetAddrPortxDP <= x"00000000";
+ RGBLed0PortxDP <= x"00000000";
+ RGBLed1PortxDP <= x"00000000";
+ DMAFifoTXWrDataCntPortxDP <= x"00000000";
+ DMAFifoTXRrDataCntPortxDP <= x"00000000";
+ DMAFifoTXStatusPortxDP <= x"00000000";
+ DMAFifoRXWrDataCntPortxDP <= x"00000000";
+ DMAFifoRXRrDataCntPortxDP <= x"00000000";
+ DMAFifoRXStatusPortxDP <= x"00000000";
+ QoSPhyStatusPortxDP <= x"00000000";
+ QoSDMAInitOcpCtrlPortxDP <= x"00000000";
+ QoSDMAInitStatusPortxDP <= x"00000000";
+
+ elsif rising_edge(SAxiClkxC) then
+ LocalNetAddrPortxDP <= LocalNetAddrPortxDN;
+ RGBLed0PortxDP <= RGBLed0PortxDN;
+ RGBLed1PortxDP <= RGBLed1PortxDN;
+ DMAFifoTXWrDataCntPortxDP <= DMAFifoTXWrDataCntPortxDN;
+ DMAFifoTXRrDataCntPortxDP <= DMAFifoTXRrDataCntPortxDN;
+ DMAFifoTXStatusPortxDP <= DMAFifoTXStatusPortxDN;
+ DMAFifoRXWrDataCntPortxDP <= DMAFifoRXWrDataCntPortxDN;
+ DMAFifoRXRrDataCntPortxDP <= DMAFifoRXRrDataCntPortxDN;
+ DMAFifoRXStatusPortxDP <= DMAFifoRXStatusPortxDN;
+ QoSPhyStatusPortxDP <= QoSPhyStatusPortxDN;
+ QoSDMAInitOcpCtrlPortxDP <= QoSDMAInitOcpCtrlPortxDN;
+ QoSDMAInitStatusPortxDP <= QoSDMAInitStatusPortxDN;
+
+ end if;
+ end process UpdateRegBankxP;
+
+ end block ScalpFastRouterRegistersxB;
+
+end behavioral;
diff --git a/src/__pycache__/regedit.cpython-37.pyc b/src/__pycache__/regedit.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ffac352e8a0f7e3acd66d8249097a395639f65a2
GIT binary patch
literal 9858
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
PGcj_ou`ogOKuKl*!ux|$
literal 0
HcmV?d00001
diff --git a/src/__pycache__/regedit.cpython-39.pyc b/src/__pycache__/regedit.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba26ce636beb11fd1851799ba1e213ce91d94cb7
GIT binary patch
literal 10389
zcmYe~<>g{vU|`@4EKAJyXJB{?;vi#51_lNP1_p*=6-EYz6owSW9EK<e%^1Z9<}*bx
zfobL_W-!eX#R8^Tqu5dyQkZg>LKspRve*}Jq%fzjEM$t}g!5PzGDUHvutjmFut)Kv
za76K@a7OV#Ww}zgQ`i?WNAaidL<ywurV5BNL<y!ar0}KirwF77rU<17r--D8rii78
zr%0qorbwkor^uwprpTqprzoT-rYNN-r>LZ;&XI@`N>NKuPti!xOwmfwPSHuxP0>ry
zPccX_OfgC^PBBR_O)*O`Pq9d`OtDI_PO(X`1?v({v5OK(6-i;pWQ-Dp+iO3EB}xp+
zbC|;%CGO6U;+W#p!jR(B%oHV&!Whh;>HHEDetw#aw-~jmnDq2+u_fo{rDdkyV#_Zr
zDJU(u#avvJe2Y0FCFd4vPG(+dMHFXJVo_>tYDr?wEk?a4&XUyJf}F&X)Z!`@y|Rpy
zC;^y2d{Jt8Qes~AOGX9;hL=nrf*C}xfCyF)!3HAOK?Dbg-~<t%_<hL@V)1|oUJ$_t
zBKSds0EiF-5keqB7(|GG2vHCr1|lRF7#K7qZZR7gSwt}#nVLm0n;IHLF&TPCF&TMB
zF`0NrF<E#=F&mnBM=={4c}FpunRrLB7#dl4N3j^0nt4aDm>Pl<8u~^t8Tm#rnfOLA
zS@?o9_<}U}f;9MoHTZ%x_<}X~Mll(>zia?GfPs;LA(Md#M6iGe4iF&#A{0P`1Bhq<
z5e$qBnG6g}Ac6%%aDWH_5TO7f96&?^h+tsMWME)m0ud}Af&)YdfCvQ;;c$z|*hrJ*
z7E5wTQO+%v;*!LYTP!JwC5g9~^OFlSnQt)_<=<i|&%eb~RGtiqZDb4zZ*Y#$V_;xN
zWdP-pD5ey?6t)!h7RD&%6pj?m7KSL66s{ER7KSL+6rL2`7KSJ`aN6O&#a)z|o|=+b
z5}%%$=l6@*K+n+a7MDSVi2(!@DKIcFB!glTW+f<6K~_40GU*~_28J5O8isg=8m1bC
zc*Yv$8ishL8kQP{c;*_`8ish58nzmSc-9*B8ishb8jc!<c=j638isg|8m=0Kc+M1%
zUak`E8ishD6owjxcwR8c2PXN!q(BPDWI-?~1SW;SqzIT4O##^`1}4S9A`)Oy5==_f
zFs3k+G8Db5k|~j1AhQr;149i%7DMsA64?}%X2vGQaE3e`7KRep$~TM*wcLyhRU##F
zHQddNj11unkqjvewcK^wd0Y_MfWZKyn<s@;97HpSGeB94Abz}jl~Rd94MP@FGh>Nj
zDdPmjBCQmV@0m(uQ`n()>4EH;z*reYq-`u9_fKFf+EOJ4_W^SaLl*M{#^NR<Kfui0
zM5MW_U~`#@c#zCxsbR=snZQ_l3&UKdN-iSJWrLcVf@Cgh4MP^|1g2smEaoN=X)Zg|
z+&xI<vehtTu}xqq?!sd3F5=8BQ7Tcc;cR9~VJl^rz*O|CL@tG+hEtp&g;SgXlm<#v
z7O19hEo5Y5sNn*;fVqgNL@ouKJ`i#xaw$AD3|aC}J#s0$pfm>O@zpS7F~WKLpxA@+
z1WMFO)N2^BIGY)p5o!d%cFUy*fno%%Ru~kHaGnUr_i&zQ4MP??oF`Vpki`Mvr7#3D
zXo~w4DKjuI++rvKmE=`CuDJyzl?ufrMVWc&zZmu1s>D2t74q^+6cQDZ^7C_26Y~_x
z5_3vZtHhLDi;D7#6m%8h<1_OzOXA}-G!?8Aen}`~!Zeg6=47Tol<Vo~z5M_G|Nkl<
z?Al5)QWc6)(=&@pQi~Ko6${Lil+?7$ywnth%sd5<8c6-6kd~Q~s;8${C1<A)grX}Y
zvnVyWB)_OqK|#Sv0aHFNF*j8K3b4tSr4|)u=I4P`K;)fr@{_X_koAEj;pPWtR;4QB
zr-5CE>H{l<DlIz&$CQ+k%>2B>9EHrhwEUvnL=aCQF)6>aL?H=mc1mh-W_ljTtxhRe
zErQ$S1PX_e)S|S+WVkONu7SEWMWHw+u`E@gI5j;tHLnCB2O{C}xrxvqE>2ZQOi3w9
zEiOipFG|cyM>88Duc>j1J2kH)v!pT}6d1Sopd4t3-4cQFi&E3$GxOsUlao`6i*Ip(
zy$I34o|FP%@Fb<gXXZiuaZ4a6B_8bRc&Mvyi6y1PL);mklvtb^4|V4)j--@$u={TD
z!a_P8lvZwWf-1!L;>@blTigLbUh)2+A@MGrK~dZVMOpFrr6utxnMJqQi;I#WjEs~V
zFoP4^<^eN#lVI&0FqaQzesO$GW^u_aAyj^RvQZv}Se{YxEip88;Ea)6c1sXVJh|+a
zD27mca$X6BaAFEr7~O#KL<}>F5^qVMnF)=O%=}xdr6rj;#kY9UQ%mAYGILYoi%W`b
zafN|$GB_LGVl61j%qzLYk&;;ii6oYi%7WBeETBw(i!(VRH90#zJGJr_hm%WukfWcw
z>n-Nu%HmrrsTG-^W@JgxE#{omJWZZkEXAogX+=g13=BoaAi@Mhn1Tp15Md4?EI@=M
zh_C_?)}R82F?A(FQ8WVs!!K|BjQreG{j7X_m;B^XP&zKw4=BpdN-ZhY_ed?sOw=z<
zPRuEYF93-pmq2;Y#)^J%QL;XityfTaivw0VB{48C6t4m`Ran><u|Ouc7=ndR$Hc+N
z#K^_O#>m6S$0)}n!^FfWzzE_AFv>A;f#o<Dc^FCK2`~yUaxrl+axii+@i9W67$XOi
z#m87B0`&-}1*Qk{NHVCP2KfVoL2OW)8{FjLVq{<_VaQ@!zyzvD7BUupC}CIts=Ap$
z)l>;9s7aN@EY6U^1gQYPYC%;ca|!!GP*aKns-6R?9@L!Rz@na`gcGcu3#uMm4VJKi
znp#<0Sk-fb)$>5r^B|eegH=5*SUn$9Js*;KK7{%dmSBbw))Y`90^}<;h_6!EgBd_F
znjC&r0$j;Osfi`2piB*}o~lF@5LE<3E(KJP@I%;eb&%Rn0$y36Nmt1zxWH?g#GInk
z#FR>f)QZgFl43nQy&^+UH--NeQ-1L+mV(5Rj9Y9FxuO72O6SN;%uY?oEGjPY2XR@l
z@-y>pu?Gh^gUYNTJCGQ=hl>xGXAk0W`gr<<Mu7RC*8DAAC&wUHU)K;vh#E(bZHz^c
zpsWPSK;T?d6a&(U<o&at^sfd^GklCZj6zI8I7k*IAx0LaDo{}dYyImXyq^r}>w!!G
zVNlNwgu$s#jtQ3fN|;Mn7BbZ`fzuZ#Ewa`ymavI4EM%%>E@3a>Sio7rv4E?D9n`qb
z;*n%%W?aa)kg=JumZgRzg)y6<D5!)t1<cP|0v2H@%Bf*VVajGG$|>PZVFIbl>jI0g
z6t&f`q%dbQ6t$J`rZ9tL3cw;PMGI<JQdqJXiWZdcf*SO-EO}vI5tgD|H7qHt*$hRy
zN_bOP!Fp`KA}mE$YFJX(vKfl5l<=mofn}7yA}mGkYFJX(vl)usmGFX^?6oX;93{Lp
zEFd){d?_3?OpvBw4KpMamhdkSs9~yMUdY7AP$IZMsD?R(tA-&<cp)>K&t1ciC4$7~
zsbN9lff|aUAbtv8Eo+HbiFge|mISCN=)w?dRLfSwus{+dQo|<6P{UTkx{$e+J%zuP
zwT3-KAe&(VV^La()B@=gK~T<_z*v|Dbpxo`C<8JT$_F(ZWs&%xrlTAZAJll1N8*E;
zj|xb9kgF7t_!2b?SxQKJkQ<dj{1ky;22ClyB2Xv42-K@D0`=vKWI%~l9@Mi2v0f@L
zFfddpB<B}Y#)B$p_-F&Dy$8;}&iMtE3RNr$CHV?fyf)DK4b&d7tKznSw*o*MP@@6d
zB(SUEu|c##>_XhYc^jNZs|0LNYfQT;1vHWP<kF&|)Vz}TlKl9*)QS=;DnP;@X{buO
zDrIytAk6@%LEz@IU6mZVBB=IwsJtw?e0fo3Nh-8mWmhGGE)6P!;IdNave1yq%(v52
zDT)IHdOU~#Rf@L+LR@_Vd>lhu<DsR_EkP6!H%}keB70DA!UIwO;>Np1gxq2VH5i!k
z3U0BM6qV*B-(tzhPdB>73u_?6JNx^E6@e@GaFAW#!j7#t1Jn|^#R7`sA|H^UBB02P
zFG?-QNlZ?SFGwsYNiE8QG$3q1`ao@mTdd%AUr_`|0Nh;Q1^X8kdqtrji7*i11R_8M
zQjrUY<q9I)K!hiV@B$IupaPQvTwvbf1ltZuK~X%JdGQDyFR0y!;Bvy#(=D#F%%b9w
z_~gW#oLh{Ux0s7kOCUuqxbOv+yJ8^kVJ2bFa9pt;sN`hiV-#VMW8z@s0<{6KVI~eH
z5k?*+P#b}dQGf|lDvL0(FmW;RfyF@LP|Q@NgxpTRZgn!Kl>o9Cgh7Kg@PV2;9H4SL
zg|UROh6&cutm3O-Okt7)4T>;@GvryZFqAM?MldqevM@4KDU~p!FfU-KVF8udj11tR
z7$)eD2umFcsP0W+sAZ{R0S$_jFr=`SFhYhtASEN%Y*4Ai5YHOUkY@undmGej6;!iJ
z*cPyZhh|t2=7Wb^5T>&uy1rnOIl!*wfVp}CV<jKdYy~v4!GldW%moiTWpOk!rEr#l
zN>hsx25|WeY7KEi`~mW32?Mx$5A9Hc?dJvC&ja(>1jfn<Q2Vik8xO*Mka<Yq##I8U
z0eIjp*adX~sJ(>h0?;4=55!Gi7x05!zz25$Q>73d7x3Y60cb#i59$J@A{(d+KrJv-
z7YNiaWbr{<P{WYLlOmYSG=Zro4<wo*l+6rcmoTIVgN80Zz685c1nf!yBv<ah<4OUX
zu4G6N1*b0ol(Z`bHeC>II&-BMBSS4Kj?^m%HJ!DN7397YhFaD-R%q%KF9Fq=f-uu-
z7_tOXBuW`3Fc)nD`$H0JlQ5D^4S4(^47CYcK9K^252%gc!Vs%c%T~gWB3;8K&X6J_
z&H(nIFsQDFxnlxz;RH~wN|DHBn!r+&mm*usUc(ILF&Et_VMvh!nU*473(6mSDGJ$4
z6PSy?Kw|`?Lk+5$rAVlTJw;I*G;GN#&XA%c&QQyq2NF|86SD#9Rsq|W1lJvaqFWV<
zZm<}rty9AeGBF<1#t==BEoGblYP~UJiKeK5#X)Ti(G+zMI}79z4RHoU*r#ZUGo)z2
z<+Rb|Y8c`{`o*B;-m78A5=+qmsgDP>S(v~f!&(Hgn=b|A2M8M^2eL~Sq!Mha9*7k$
zmKOm}$*e^tAk!e_Oo~2KUIs}Fq1yl=izH_V5&@fxkP`>HlC`L%h9OHl#R#M#9@LTo
zVUTN#K_Xy1CLk7AP6DcD2dLEt)dOm6fiOsqDV7ic$w{V|WwT6RD`Ek)2WuFzBvZ^6
zGNqVhGl9fv7_wwiEWmbv`~wLkwju*~OhecpIglNe5S4kL903!vf{1}kE|INa$dYSj
zOtF?=$Yz+pR+IuZ-v*%~#Tv{8wF>1^Y(*GqIZ8n3P63owOBhNNYZ$T=K>Yzmh7yJp
zyAq`ujuJ+MXfw3m3XU23Y^DhuMWB*L9%L%mG)~Y^Yl?$71DFSDZ$nZ(Tk$)vkA$+B
zCa@PRsbR=c28Skl5vcd8oZ<*}l`>e|Nt^+jy(!KhHQ+dL0kPsCs$IdVIniB-q#BVn
z+%WWU5v9)^t`FiH_ToKY-+)pvM-ixhr2_TMl^TXDl@t%KdKEAmmv1~lYQVmMq)L!#
z`4n@IXuN#h39$K~GJ~U71Iz}690#~WhlCtQkpnoi$PGD&PdJL(z@|fdat7>TP`SWS
zG!M)s-zSiCCZA#!%%JJzSH%e*B}NR<#e?S3N{izYlS?woQmc5qQ!BwkVG33X)wPiB
zffOgKfr+YE!Bzoj2oltItP(^h1@Tc;fJP?Ws-)qg2`Ft>aKEO=0MzqAG6bXr)ez8l
z9I`baK1c;<kO(|(4sHF%=jNxRR!Jb-0~v}13oF<v6sd!nz?vZI0`NEp7GTBTvF*x&
zRE7NH0)@n)R0W7}nMpaR3i)|Cm7tON@_Yr5rFyr7;o+5Anp2XQmYJH9QYDUX3PKd*
za?lV1#O0t4Qf6Wfr0-LO6znJx3bqO%xA@^!fK4y15=Iyg5mB&JsN&@0ghoRZmx7f7
zG&GAq^Pp9HTwHFRLBSyk&W=7lTwGNW)?A#Ny1MY0gklBIn6HATe~}g_l$g0VIjd|c
zT>KTR6hMRa#U&~6r8)WOnaS~G;JF434d-~r2v3uE7sn9C_+ZZ{R|Q=KLrsO0{PMh#
zd<6r|Di)9pMH(Q}tSekR6|6vkM!Gq_7&)uhL30I(ISN%y0r^EG6)t`t-;wMh1uI*H
z3Z*J$C2OuK4o);911K_*lasTG8|F3}TZJmt3Kvgnt|}QMF^&9^jMSoH1zS4>bpv%x
zYpyCzh-`p0R~0)bs6iT8IFZZ>Pyh)*mHAn7Rq;Y~fW#}5AbomJzov?l3#1Q(qnImP
zJfqm53X3>FgUgIMMWAWwDp6PhhtGmoDHv1~sem#EsB2Wk3NnGSioHA|H4hY4tV$r~
zR*6DP^8;BMUgVNkl33wl%~iz%Rt-}NRTQ9*U!;JfND87iKp`<N1w5yQB*z9efU`;v
zY)w!K#AJ{ynyTP&!Xj`dx(3u^=71Gdx7Z*vN=3CGXM=jvMZO?b9Y~d^i>sSss82|I
zkgL0AaENOVIB6CIgXDNo#p+STLLviPi$KdAZi&FvIXXML1_#Ic`n$LmHG=GD0_ow%
zNUbn7DlRE1Y6gjcI@U$lI^gag**uUA=G^?0B5;2k-j^@(0Lg*}3JO6=IAMkw6~X)L
zn%t1?ItMKG-(t>8sVJ%d>5KwtVobcnoSj-(1aiVH7EotBiWNi}LMS7&9(qw30|SE$
zBLhRR7HB||QGkUBI_%EID8VGe1mh_%@qyU_jC_nTOhSyHp;3egSS=ng2}TY^7Px+}
zYBU}XBgiI@=^$CqaDWmM54f8T(ka2n#V7(A1_0ASOgv0Hj66&%j7<NT7+L-^foLX<
ze@skF|CpGW{xUJM`~}l29DkTtnEtS_fmBN{vcS|rX%1!{xEKdBx-1(Lh6ppr90H<H
zcd)T2F!C@V>_nK)#w^Cj!^FeP#mEH?OVC6LACm+l#B7j{gdjeGx)S6LBvB?7h(Dn;
z8#5#npn9O9Oi-GQ1&_JRcx`3Ir;~@NN)maf1*IO><nk-hVPIfz^YiobE7Ap}Owe$q
zpC&tK5(-os#mC>`iU-xhr8%kb@wa&5;|og@b09KBu^<iUAfg&XfYK*YnuQN76=^dt
zFeHM;@<9uyI2ai~@E=z;hYW`?SWZ(CGQI~M5d#+qMWFn_0-E)^#hO=|TTod9%85nr
z0l+98(448Wzn>d;ioq6SJ!mOWQ3{Ba3L?@#L>7q10TJ0CA_PQ$GHg)?h}8)qx<EuX
zhyXbgoBMBZ*yQG?l;)(`f!2!^&tYI-;9x|8%%Ev77Et<RWMLFwWMSlBW@01>zF?Cf
bNj)Re3pP0xCYJv!tWbS_*f_wfziey(d}{?(
literal 0
HcmV?d00001
diff --git a/src/__pycache__/utils.cpython-37.pyc b/src/__pycache__/utils.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f799f3b1c198f5722eca2c153a77dba09bcb219
GIT binary patch
literal 1488
zcmZ?b<>g{vU|^_e;!4=T!octt#DQTZ1_lNP1_p-W7zPH06owSW9EK<e%^1Z9<}*bx
zfobL_W-!eX#hSvD!ra0T#g@X7!rH<R#h${J!rsCV#gW31!r8(Q#hJpD!rj6U#g)R7
z!rQ_S#ht<!%%I8l5@e@eG9!p$U|;~ztPBhc&LG=e7#J8z7*ZHhm`WIH7@8SVn8g`H
z7{nQx85u$1EHw<`3@NN|K8mUoMu>O{LokCTo8K))u3wD0FWDFv7^;|cbrq_Z6?Anq
znQpNb6lLa>++xm2&C_Iz;w;H5$w`ebE-6~cP{hu_!0^jcKO;XkRX;0V-z7h}G&eP`
zq*y<oC_gK;q*&i0wIDN5zc@KDry#xnB$iwP<rSr-r>10<=oc3y>z9^f<`nA{RNmrE
z$t*6&Nvw<qTfzzQAjmlkj1r6jj71=RGBgmt6f-Oo1i+z?#jt>JA;SWu6vl<1aAWeT
z;#G}Q%~ef_SM^Z!RSni;zQvJ}Sdv<jnVTBLoR?o7#Zg>Rlm_C0eS$=AFfcIO;z>^}
zi3iDoe9H%N3@FkW7>l?W7#Na4mV;aYaup~Xz|m0vN(_uOjN%L_OyUf+%q0v97;Bgp
zGS;%xFo2?_mbHYbh9QNenW>hogsFx#g|(Tfmc2r$hHU}!LIxLxSg~4;8ukS&H7pBQ
zYnW;{7BVelWMn9`31=u_Tfkn!0OFN!Ea0qRtzlTm#K-`Rx?hYMzZf-tF)H6;EV{*5
zuE}+asVMapdvbnmL1s?sEtdR()Vy1qMX8A?IhlE>#kW|?i!w`6Z!s5_Cf#DnFTTZA
zl$x7gmU@e=I0F<HQ7j;yCTA39T4qjad_iJK#x3@O#FCQKqP!^XqSS(%#AI+1h~g>&
zOM@hCF&0E|mZatu#Dg?NF{fqbMX{vimzLaO0a=P3xFR4`@i4QXh6{oMSqK!WOgxNS
zOdO0{j9iR-Okzx2j774bKnJCLkTi$}MF2R^L76m#aRCD;c!C);nf$8Qs;vwxB5E}m
zZ?UE27v(0FXfobnElbQPO+|MGM@DLeu~BhJkpjqSX#9fM$zV1E0|N^K0|UqguvMTO
zU&2trxPS>vGM6weU@2j!VQgkx$heTPnK6Y?ngK-DGNmw;u+}g&gHi%BC?(V|FJOZ@
zkj3vM$j~b0YAb^(rifZi_FK%L9LAJa5XF+5nwb;DT2fS+mmI~Clb>#Mi@CU@s7Q{1
zfkBg{NFJ0fIg(Q1ixTtFQ*W^pXI7;~v7~`ifYKnuci_a!3G<kdGRSA(Y{aC-D8N*t
z4hl$^??5y>ASFPB9b*l{0)~YQ*=$7upyDTmDHxK<nEgWBG#PKPWT#dZYckzpNy$tu
zxy78FS_!cfY(2#0<c!qh?D*`|N-YKkhGK}#Jd7+%McN=w@DzbUvj`N`MdAz$3`LR*
z3=C1Md8N4pl|>-8g7Y~zkAdSH95Y}?gY_fXhOm;uCO1E&G$+*#<dtF(1_lNWMkr+B
OVC7)u;OAiGU<UxV`%3cw
literal 0
HcmV?d00001
diff --git a/src/__pycache__/utils.cpython-39.pyc b/src/__pycache__/utils.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..930bb0c26d9058b76a5a095ef87174e1d5b9e354
GIT binary patch
literal 1512
zcmYe~<>g{vU|^_e;!4=T!octt#6iYP3=9ko3=9m#F$@e0DGVu$ISf${nlXwI%x8*X
z0@KV<%wU=&iZz8Pg}H?xiY<jDg|&qtiamubg}sF#iX(+1g|meriZg{Pg}a3ziYtXD
zg|~$viaUidm_d{8CCFaCWJVAL#UM5-0|SFI$OSG83=Aa<DU2yhC5$x;&5S9`;tV1T
z;tb7<j39BA8U}HO6jnGNMO6wTL_CEdm_d`x?-nE1FGk&$YzzzxRm{4&3RTPsy1JT7
zw^$2`GV@AqG3TV_X);D}mSmRXq{bJQ6s=?^VrO7r_~ogek)NBYpOvrglAm0fo0?Zr
ztRGO6pOsottnZOpkeR4ooSc|b5MKZiOD=)(ic-^4Q!-2Ri;I%=OG`3yiuDRAZ}FyN
z78m3sR>p%Z;RJaQ<QxV@2}S|NA`m|r8VGQT85R-(;E>2-SircDVF6PL<3dpQG5J;T
zsz$2js;0!NdZ_xU25U0k;z&s>NiE6DO^ssC%P+shQCw1#2I7K!gG6vJFfiQWNlz__
z2g!nb%m;E1DDoK?i+C6q7?MGj!(0M#9Vk4&(UJp77>qTH;tVNF;taLSB@7D~YnT@@
z*0R(vfTF0DwS=jLA%&%xsg|vTsfIO$wVA1wy@qW8^Fjs}hFGy$jvDp_EHx|(SZkPS
zI2JN3WMpJ0v?^g+z+S@uVwZ3%;H+V-VOYq-$N-JLUyK^R7&U(}D&Jx(y2V(o$#sjV
zDD@V5a(-?>W=`rYmi&U$yjz?_sfj5$nR%(jw^+-IGD}i#F&CF6-D1iwzQtCQnwwvi
zdW)?%0~8-oEFhjHXB1~zW=?8+L1Ib9E%t)Ml9JS-yeRIX)PkJEWN<Qw;wl15gCuS-
z7DREDq~;dHgEU1kr)B0vv83gfmfT_iS&AOGA|O@qFtebB3xWb!2o$PJJd9jS9E@Cy
zT#P(SB1~M2MRK4(2c>_IGzf#(phy4*Iw;eoFfL#K1yL}ACX-(kTeX#eMMSM8<1Mzd
z{G!~%5>3WitYwKgrK#vn;mAm>Fg7YKDN+Dg4~=6*kab`-$Swv31{MYe29Paa>p&$y
z2}23v0wyrYT*A13rG%k|v6*op<3h$}#uP?r1`u7#l)_ZPTEo-~N)61Q)KJ5`fDP(M
z7QdGuL#vpptqiJ|B5F0+Z!v>%8&h6E6iaeyW=<4qNl|HDauiEWe!9^u=Hil~B6$V|
z22B>QOK))`rNkE{=B20JVkyq7N{wPk1E~O|Lx>N-iI@}SIU{9|@4#7#NsUo}sYnCe
zhalg=15^T32r||%EMQp3P{vRskir<ukirxUNpZ}6A#R$Cw^*`MD~mOmZn30fCYRh|
z&Q7g_SPXUo#P;Nj)a2~=?9@sv1_p*=i0wR#EKEf@Adm1AfkLzh6yrr83yY)}7#N~h
z^Gb6IDvMMY7#P6$9-QC6@m~ar6|lp>`jKoySjl0No1apelWGU@O0ft70|N&m6f$wJ
Naxio7b1-wT0|2OlN~{0?
literal 0
HcmV?d00001
diff --git a/src/regedit.py b/src/regedit.py
new file mode 100644
index 0000000..17ffdf0
--- /dev/null
+++ b/src/regedit.py
@@ -0,0 +1,499 @@
+#!/usr/bin/python3
+
+import os
+import sys
+import utils
+import shutil
+import time
+import numpy as np
+from utils import *
+
+# Default directories
+PRJ_CONF_DIR = os.path.join("..", "config")
+PRJ_OUT_DIR = os.path.join("..", "output")
+SRC_DIR = "src"
+HDL_DIR = "hdl"
+LINUX_DIR = "linux"
+BAREMETAL_DIR = "baremetal"
+TEMPLATE_HDL_DIR = os.path.join(".", "templates", "hdl")
+HDL_FILE_EXT = ".vhd"
+TEMPLATE_HDL_FILE = "template_regbank" + HDL_FILE_EXT
+
+BD_RANGE = {
+ "128" : 0,
+ "256" : 1,
+ "512" : 2,
+ "1K" : 3,
+ "2K" : 4,
+ "4K" : 5,
+ "8K" : 6,
+ "16K" : 7,
+ "32K" : 8,
+ "64K" : 9,
+ "128K" : 10,
+ "256K" : 11,
+ "512K" : 12,
+ "1M" : 13,
+ "2M" : 14,
+ "4M" : 15,
+ "8M" : 16,
+ "16M" : 17,
+ "32M" : 18,
+ "64M" : 19,
+ "128M" : 20,
+ "256M" : 21,
+ "512M" : 22,
+ "1G" : 24
+}
+
+BD_RANGE_CONV = {
+ "128" : 128,
+ "256" : 256,
+ "512" : 512,
+ "1K" : 1024,
+ "2K" : 2048,
+ "4K" : 4096,
+ "8K" : 8192,
+ "16K" : 16384,
+ "32K" : 32768,
+ "64K" : 65536,
+ "128K" : 131072,
+ "256K" : 262144,
+ "512K" : 524288,
+ "1M" : 1048576,
+ "2M" : 2097152,
+ "4M" : 4194304,
+ "8M" : 8388608,
+ "16M" : 16777216,
+ "32M" : 33554432,
+ "64M" : 67108864,
+ "128M" : 134217728,
+ "256M" : 268435456,
+ "512M" : 536870912,
+ "1G" : 1073741824
+}
+
+#EGISTER_STATUS_ACTIVE = {
+#}
+
+DEFAULT_REGISTER_SIZE = "32"
+REGISTER_SIZE = {
+ DEFAULT_REGISTER_SIZE : 0
+}
+
+REGISTER_TYPE = {
+ "ctrl" : 0,
+ "stat" : 1,
+ "data" : 2,
+ "ocp" : 3
+}
+
+REGISTER_ACCESS_MODE = {
+ "ro" : 0,
+ "wo" : 1,
+ "rw" : 2
+}
+
+class regedit_gen :
+ def __init__(self, entity_name = None, entity_version = "0.1", entity_reg_io_access = False, block_name = None, bd_name = None,
+ bd_interface = None, bd_slave_segment = None, bd_master_base_address = "0x40000000",
+ bd_range = "128", register_bank = None) :
+
+ self.entity_name = entity_name
+ self.entity_version = entity_version
+ self.entity_reg_io_access = entity_reg_io_access
+ self.block_name = block_name
+ self.bd_name = bd_name
+ self.bd_interface = bd_interface
+ self.bd_slave_segment = bd_slave_segment
+ self.bd_master_base_address = bd_master_base_address
+ self.bd_range = bd_range
+ self.register_bank = register_bank
+ self.data_size = "32"
+ # Directories
+ self.prj_out_dir = PRJ_OUT_DIR
+ self.src_dir = None
+ self.hdl_dir = None
+ self.linux_dir = None
+ self.baremetal_dir = None
+ # Others
+ self.registers_list = ""
+ self.registers_list_c2n = ""
+ self.registers_list_n2c = ""
+ self.registers_list_init_cv = ""
+ self.registers_list_cv = ""
+ self.registers_list_cv_cnt = 0
+ self.registers_list_ad_cnt = 0
+ self.registers_list_wa = ""
+ self.registers_list_ra = ""
+ self.registers_list_entity_io = ""
+
+ if entity_name is None :
+ try :
+ self.entity_name = utils.get_time_str()
+
+ if not self.entity_name :
+ raise ValueError("Empty string")
+ except ValueError as e :
+ print(e)
+
+ self.dir_name = self.prj_out_dir + "/" + self.entity_name + "/" + self.entity_version
+
+ try :
+ if type(self.entity_reg_io_access) is not bool :
+ self.entity_reg_io_access = False
+ raise ValueError("Is not a boolean value")
+ except ValueError as e :
+ print(e)
+
+ if block_name is None :
+ try :
+ self.block_name = utils.get_time_str()
+
+ if not self.block_name :
+ raise ValueError("Empty string")
+ except ValueError as e :
+ print(e)
+
+ if bd_name is None :
+ try :
+ self.bd_name = utils.get_time_str()
+
+ if not self.bd_name :
+ raise ValueError("Empty string")
+ except ValueError as e :
+ print(e)
+
+ if bd_interface is None :
+ try :
+ self.bd_interface = utils.get_time_str()
+
+ if not self.bd_interface :
+ raise ValueError("Empty string")
+ except ValueError as e :
+ print(e)
+
+ if bd_slave_segment is None :
+ try :
+ self.bd_slave_segment = utils.get_time_str()
+
+ if not self.bd_slave_segment :
+ raise ValueError("Empty string")
+ except ValueError as e :
+ print(e)
+
+ if check_key(BD_RANGE, bd_range) is False :
+ print("#Error - __init__() : " + bd_range + " is not a valid value...")
+ sys.exit(-1)
+
+ if register_bank is None :
+ print("#Error - __init__() : the register bank is not defined in the config file...")
+ sys.exit(-1)
+
+ print("> Register bank directory : " + self.dir_name)
+ print("> Register bank name : " + self.entity_name)
+ print("> Register bank version : " + self.entity_version)
+ print("> Block name : " + self.block_name)
+ print("> Size of the register bank : " + str(len(self.register_bank)))
+ print("> Addtional information about block design")
+ print("> Bd name : " + self.bd_name)
+ print("> Bd interface : " + self.bd_interface)
+ print("> Bd slave segment : " + self.bd_slave_segment)
+ print("> Bd master base address : " + self.bd_master_base_address)
+ print("> Bd range : " + self.bd_range)
+
+ def create_dir(self) :
+ if not os.path.exists(self.dir_name) :
+ os.makedirs(self.dir_name)
+ print("\ncreate_dir() : " + self.dir_name + " directory created...")
+
+ self.src_dir = os.path.join(self.dir_name, SRC_DIR)
+ os.makedirs(self.src_dir)
+ print("create_dir() : " + self.src_dir + " directory created...")
+
+ self.hdl_dir = os.path.join(self.src_dir, HDL_DIR)
+ os.makedirs(self.hdl_dir)
+ print("create_dir() : " + self.hdl_dir + " directory created...")
+
+ self.linux_dir = os.path.join(self.src_dir, LINUX_DIR)
+ os.makedirs(self.linux_dir)
+ print("create_dir() : " + self.linux_dir + " directory created...")
+
+ self.baremetal_dir = os.path.join(self.src_dir, BAREMETAL_DIR)
+ os.makedirs(self.baremetal_dir)
+ print("create_dir() : " + self.baremetal_dir + " directory created...")
+
+ return 0
+ else :
+ print("#Error - create_dir() : " + self.dir_name + " Directory already exists...")
+ return -1
+
+ return 0
+
+ def copy_hdl_template_file(self, file_name) :
+ in_file_name = os.path.join(TEMPLATE_HDL_DIR, TEMPLATE_HDL_FILE)
+ out_file_name = os.path.join(self.hdl_dir, file_name + HDL_FILE_EXT)
+
+ addr_size = int(np.trunc(np.log2(int(BD_RANGE_CONV[self.bd_range]))))
+
+ if addr_size < 8 :
+ addr_size = str(8)
+ elif addr_size > 8 and addr_size < 12 :
+ addr_size = str(12)
+ elif addr_size > 12 and addr_size < 16 :
+ addr_size = str(16)
+ elif addr_size > 16 and addr_size < 20 :
+ addr_size = str(20)
+ elif addr_size > 20 and addr_size < 24 :
+ addr_size = str(24)
+ elif addr_size > 24 and addr_size < 28 :
+ addr_size = str(28)
+ elif addr_size > 28 and addr_size < 32 :
+ addr_size = str(32)
+ else :
+ addr_size = str(addr_size)
+
+ print("copy_hdl_template_file() : Copy " + in_file_name + " to " + out_file_name)
+ shutil.copy(in_file_name, out_file_name)
+
+ utils.file_replace_pattern(out_file_name, "<entity_name>", self.entity_name)
+ utils.file_replace_pattern(out_file_name, "<data_size>", self.data_size)
+ utils.file_replace_pattern(out_file_name, "<addr_size>", addr_size)
+ utils.file_replace_pattern(out_file_name, "<block_name>", self.block_name)
+
+ first_call = True
+
+ for i in range(len(self.register_bank)) :
+ ret = self.read_register(self.register_bank[i], i, first_call)
+ first_call = False
+
+ if ret < 0 :
+ sys.exit(-1)
+
+ utils.file_replace_pattern(out_file_name, "<registers_list>", self.registers_list)
+ utils.file_replace_pattern(out_file_name, "<registers_list_current_to_next>", self.registers_list_c2n)
+ utils.file_replace_pattern(out_file_name, "<registers_list_next_to_current>", self.registers_list_n2c)
+ utils.file_replace_pattern(out_file_name, "<registers_list_init_current_value>", self.registers_list_init_cv)
+ utils.file_replace_pattern(out_file_name, "<registers_list_current_value>", self.registers_list_cv)
+ utils.file_replace_pattern(out_file_name, "<registers_list_write_access>", self.registers_list_wa)
+ utils.file_replace_pattern(out_file_name, "<registers_list_read_access>", self.registers_list_ra)
+ utils.file_replace_pattern(out_file_name, "<registers_list_entity_io>", self.registers_list_entity_io)
+
+ return 0
+
+ def read_register(self, register, idx, first_call) :
+ print("Register " + str(idx))
+ #addr = idx * 4
+ #print("Address : 0x" + hex32str2(addr, self.bd_range))
+
+ try :
+ self.register_status_active = register["register_status_active"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_status_active = None
+ return -1
+
+ print("\tregister_status_active = " + str(self.register_status_active))
+
+ try :
+ self.register_name = register["register_name"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_name = utils.get_time_str()
+
+ print("\tregister_name = " + self.register_name)
+
+ try :
+ self.register_size = register["register_size"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_size = DEFAULT_REGISTER_SIZE;
+
+ if check_key(REGISTER_SIZE, self.register_size) is False :
+ print("#Error - read_register() : " + self.register_size + " is not a valid value...")
+ return -1
+
+ print("\tregister_size = " + self.register_size)
+
+ try :
+ self.register_type = register["register_type"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_type = None
+ return -1
+
+ if check_key(REGISTER_TYPE, self.register_type) is False :
+ print("#Error - read_register() : " + self.register_type + " is not a valid value...")
+ return -1
+
+ print("\tregister_type = " + self.register_type)
+
+ try :
+ self.register_access_mode = register["register_access_mode"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_access_mode = None
+ return -1
+
+ if check_key(REGISTER_ACCESS_MODE, self.register_access_mode) is False :
+ print("#Error - read_register() : " + self.register_access_mode + " is not a valid value...")
+ return -1
+
+ print("\tregister_access_mode = " + self.register_access_mode)
+
+ if self.register_type == "ocp" and self.register_access_mode != "wo" :
+ print("#Error - read_register() : Registers of type ocp are accessible only in wo mode.")
+ return -1
+
+ try :
+ self.register_multifield = register["register_multifield"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_multifield = None
+ return -1
+
+ print("\tregister_multifield = " + str(self.register_multifield))
+
+ try :
+ self.register_initial_value = register["register_initial_value"]
+ except KeyError as a :
+ print("KeyError : {}".format(e))
+ self.register_initial_value = None
+ return -1
+
+ print("\tregister_initial_value = " + hex32str(self.register_initial_value))
+
+ if self.register_multifield is True :
+ try :
+ self.register_fields = register["register_fields"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ self.register_fields = None
+ return -1
+
+ print("\tregister_fields = ")
+ for key in self.register_fields :
+ print("\t\tname = " + key + " : size = " + str(self.register_fields[key]))
+
+ if self.register_status_active == True :
+ registers_list_entity_io = ""
+
+ if first_call == True :
+ print("\n\nFIRST CALL\n\n")
+ registers_list_entity_io = ";\n\t\t-- Registers list IO"
+
+ if self.register_access_mode == "rw" or self.register_access_mode == "wo" :
+ if first_call == True :
+ registers_list_entity_io = registers_list_entity_io + "\n\t\t" + self.register_name + "xDO : out std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0)"
+ else :
+ registers_list_entity_io = registers_list_entity_io + ";\n\t\t" + self.register_name + "xDO : out std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0)"
+ elif self.register_access_mode == "ro" :
+ if first_call == True :
+ registers_list_entity_io = registers_list_entity_io + "\n\t\t" + self.register_name + "xDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0)"
+ else :
+ registers_list_entity_io = registers_list_entity_io + ";\n\t\t" + self.register_name + "xDI : in std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0)"
+
+ self.registers_list_entity_io = self.registers_list_entity_io + registers_list_entity_io
+
+ if self.registers_list is not "" :
+ self.registers_list = self.registers_list + "\t"
+
+ self.registers_list = self.registers_list + \
+ "signal " + self.register_name + "PortxDN : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x\"" + \
+ hex32str(self.register_initial_value) + "\";\n" + \
+ "\tsignal " + self.register_name + "PortxDP : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := x\"" + \
+ hex32str(self.register_initial_value) + "\";\n"
+
+ if self.registers_list_c2n is not "" :
+ self.registers_list_c2n = self.registers_list_c2n + "\t\t\t"
+
+ if self.register_status_active == True and self.register_access_mode == "ro" :
+ self.registers_list_c2n = self.registers_list_c2n + \
+ self.register_name + "PortxDN <= " + self.register_name + "xDI;\n"
+ else :
+ if self.register_type == "ocp" :
+ self.registers_list_c2n = self.registers_list_c2n + \
+ self.register_name + "PortxDN <= (others => '0');\n"
+ else :
+ self.registers_list_c2n = self.registers_list_c2n + \
+ self.register_name + "PortxDN <= " + self.register_name + "PortxDP;\n"
+ self.registers_list_c2n = self.registers_list_c2n + \
+ self.register_name + "xDO <= " + self.register_name + "PortxDP;\n"
+
+ if self.registers_list_n2c is not "" :
+ self.registers_list_n2c = self.registers_list_n2c + "\t\t\t\t"
+
+ self.registers_list_n2c = self.registers_list_n2c + \
+ self.register_name + "PortxDP <= " + self.register_name + "PortxDN;\n"
+
+ if self.registers_list_init_cv is not "" :
+ self.registers_list_init_cv = self.registers_list_init_cv + "\t\t\t\t"
+
+ self.registers_list_init_cv = self.registers_list_init_cv + \
+ self.register_name + "PortxDP <= x\"" + \
+ hex32str(self.register_initial_value) + "\";\n"
+
+ if self.registers_list_cv_cnt > 0 and np.mod(self.registers_list_cv_cnt, 3) == 0 :
+ self.registers_list_cv = self.registers_list_cv + "\n\t\t\t\t\t\t\t\t"
+
+ if self.register_status_active == True and self.register_access_mode == "ro" :
+ self.registers_list_cv = self.registers_list_cv + \
+ self.register_name + "xDI"
+ else :
+ self.registers_list_cv = self.registers_list_cv + \
+ self.register_name + "PortxDP"
+
+ if self.registers_list_cv_cnt < len(self.register_bank) - 1 :
+ self.registers_list_cv = self.registers_list_cv + ","
+
+ self.registers_list_cv_cnt = self.registers_list_cv_cnt + 1
+
+
+ addr = self.registers_list_ad_cnt * 4
+ print(self.bd_range)
+ print(BD_RANGE_CONV[self.bd_range])
+ print("Register address : 0x" + hex32str2(addr, str(BD_RANGE_CONV[self.bd_range])))
+
+ if self.register_type == "ctrl" :
+ addr1 = (self.registers_list_ad_cnt + 1) * 4
+ addr2 = (self.registers_list_ad_cnt + 2) * 4
+
+ if self.register_access_mode == "rw" or self.register_access_mode == "wo" :
+ if self.registers_list_wa is not "" :
+ self.registers_list_wa = self.registers_list_wa + "\t\t\t\t\t"
+
+ self.registers_list_wa = self.registers_list_wa + \
+ "when x\"" + hex32str2(addr, str(BD_RANGE_CONV[self.bd_range])) + "\" => " + self.register_name + "PortxDN <= WrDataxD;\n"
+ self.registers_list_wa = self.registers_list_wa + \
+ "\t\t\t\t\twhen x\"" + hex32str2(addr1, str(BD_RANGE_CONV[self.bd_range])) + "\" => " + \
+ self.register_name + "PortxDN <= " + self.register_name + "PortxDP or WrDataxD;\n"
+ self.registers_list_wa = self.registers_list_wa + \
+ "\t\t\t\t\twhen x\"" + hex32str2(addr2, str(BD_RANGE_CONV[self.bd_range])) + "\" => " + \
+ self.register_name + "PortxDN <= " + self.register_name + "PortxDP and not WrDataxD;\n"
+
+ if self.register_access_mode == "rw" or self.register_access_mode == "ro" :
+ if self.registers_list_ra is not "" :
+ self.registers_list_ra = self.registers_list_ra + "\t\t\t\t\t\t"
+
+ self.registers_list_ra = self.registers_list_ra + \
+ "when x\"" + hex32str2(addr, str(BD_RANGE_CONV[self.bd_range])) + "\" => RdDataxD <= " + self.register_name + "PortxDP;\n"
+
+ self.registers_list_ad_cnt = self.registers_list_ad_cnt + 3
+ else :
+ if self.register_access_mode == "rw" or self.register_access_mode == "wo" :
+ if self.registers_list_wa is not "" :
+ self.registers_list_wa = self.registers_list_wa + "\t\t\t\t\t"
+
+ self.registers_list_wa = self.registers_list_wa + \
+ "when x\"" + hex32str2(addr, str(BD_RANGE_CONV[self.bd_range])) + "\" => " + self.register_name + "PortxDN <= WrDataxD;\n"
+
+ if self.register_access_mode == "rw" or self.register_access_mode == "ro" :
+ if self.registers_list_ra is not "" :
+ self.registers_list_ra = self.registers_list_ra + "\t\t\t\t\t\t"
+
+ self.registers_list_ra = self.registers_list_ra + \
+ "when x\"" + hex32str2(addr, str(BD_RANGE_CONV[self.bd_range])) + "\" => RdDataxD <= " + self.register_name + "PortxDP;\n"
+
+ self.registers_list_ad_cnt = self.registers_list_ad_cnt + 1
+
+ return 0
diff --git a/src/regedit.pyc b/src/regedit.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f576278b49c5bf51046c02fa66443660c3f1ba2c
GIT binary patch
literal 5323
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
literal 0
HcmV?d00001
diff --git a/src/regedit_creator.py b/src/regedit_creator.py
new file mode 100755
index 0000000..40e4871
--- /dev/null
+++ b/src/regedit_creator.py
@@ -0,0 +1,121 @@
+#!/usr/bin/python3
+
+import os
+import sys
+import getopt
+import json
+from utils import display_title
+from regedit import *
+
+VERSION = "0.1"
+# Default directories
+
+def help() :
+ print("Usage : ")
+ print("$ python3 regedit_creator <opt>")
+ print("Option : ")
+ print("\t-h || --help\tDisplay help")
+ print("\t-c || --config_file <json_file>\tUse a JSON file for the register bank configuration")
+
+if __name__ == "__main__" :
+ json_data = None
+
+ display_title(" Register Bank Creator v{} ".format(VERSION))
+
+ try :
+ opts, args = getopt.getopt(sys.argv[1:], "hc:", ["help", "config_file="])
+ except getopt.GetoptError :
+ help()
+ sys.exit(-1)
+ if not opts :
+ help()
+ sys.exit(-1)
+
+ for opt, arg in opts :
+ if opt in ("-h", "--help") :
+ help()
+ sys.exit()
+ elif opt in ("-c", "--config_file") :
+ print("> Load register bank information from " + arg)
+
+ with open(arg) as f :
+ json_data = json.load(f)
+
+ # Get config
+ #if "config" in json_data :
+ try :
+ config = json_data["config"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ sys.exit(-1)
+
+ try :
+ entity_name = config["entity_name"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ entity_version = config["entity_version"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ entity_reg_io_access = config["entity_reg_io_access"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ block_name = config["block_name"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ bd_name = config["bd_name"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ bd_interface = config["bd_interface"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ bd_slave_segment = config["bd_slave_segment"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ bd_master_base_address = config["bd_master_base_address"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ try :
+ bd_range = config["bd_range"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+
+ # Get register bank
+ try :
+ register_bank = json_data["register_bank"]
+ except KeyError as e :
+ print("KeyError : {}".format(e))
+ print("#Error - __main__() : the register bank is not defined in the config file...")
+ sys.exit(-1)
+
+ if len(register_bank) == 0 :
+ print("Error : Empty register bank");
+ sys.exit(-1)
+
+ try :
+ regedit_prj = regedit_gen(entity_name, entity_version, entity_reg_io_access, block_name,
+ bd_name, bd_interface, bd_slave_segment, bd_master_base_address,
+ bd_range, register_bank)
+ except ValueError as e :
+ print(e)
+ else :
+ ret = regedit_prj.create_dir()
+
+ if ret == 0 :
+ print("\n> " + entity_name + " register bank directory tree successfully created")
+
+ ret = regedit_prj.copy_hdl_template_file(entity_name)
diff --git a/src/templates/hdl/template_regbank.vhd b/src/templates/hdl/template_regbank.vhd
new file mode 100644
index 0000000..fa97b19
--- /dev/null
+++ b/src/templates/hdl/template_regbank.vhd
@@ -0,0 +1,310 @@
+-- THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+-- scalp_regedit v0.1 - 05.2021
+-- Author : Joachim Schmidt <joachim.schmidt@hesge.ch>
+
+library ieee;
+use ieee.std_logic_1164.all;
+use ieee.numeric_std.all;
+use ieee.std_logic_unsigned.all;
+use ieee.std_logic_arith.all;
+use ieee.std_logic_misc.all;
+
+library unisim;
+use unisim.vcomponents.all;
+
+entity <entity_name> is
+
+ generic (
+ C_AXI4_ARADDR_SIZE : integer range 0 to 32 := 32;
+ C_AXI4_RDATA_SIZE : integer range 0 to 32 := <data_size>;
+ C_AXI4_RRESP_SIZE : integer range 0 to 2 := 2;
+ C_AXI4_AWADDR_SIZE : integer range 0 to 32 := 32;
+ C_AXI4_WDATA_SIZE : integer range 0 to 32 := <data_size>;
+ C_AXI4_WSTRB_SIZE : integer range 0 to 4 := 4;
+ C_AXI4_BRESP_SIZE : integer range 0 to 2 := 2;
+ C_AXI4_ADDR_SIZE : integer range 0 to 32 := <addr_size>;
+ C_AXI4_DATA_SIZE : integer range 0 to 32 := <data_size>);
+
+ port (
+ -- Clock and reset
+ SAxiClkxCI : in std_ulogic;
+ SAxiRstxRANI : in std_ulogic;
+ -- AXI4 Lite
+ -- Read Channel
+ -- Read Address Channel
+ SAxiARAddrxDI : in std_ulogic_vector((C_AXI4_ARADDR_SIZE - 1) downto 0);
+ SAxiARValidxSI : in std_ulogic;
+ SAxiARReadyxSO : out std_ulogic;
+ -- Read Data Channel
+ SAxiRDataxDO : out std_ulogic_vector((C_AXI4_RDATA_SIZE - 1) downto 0);
+ SAxiRRespxDO : out std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0);
+ SAxiRValidxSO : out std_ulogic;
+ SAxiRReadyxSI : in std_ulogic;
+ -- Write Channel
+ -- Write Address Channel
+ SAxiAWAddrxDI : in std_ulogic_vector((C_AXI4_AWADDR_SIZE - 1) downto 0);
+ SAxiAWValidxSI : in std_ulogic;
+ SAxiAWReadyxSO : out std_ulogic;
+ -- Write Data Channel
+ SAxiWDataxDI : in std_ulogic_vector((C_AXI4_WDATA_SIZE - 1) downto 0);
+ SAxiWStrbxDI : in std_ulogic_vector((C_AXI4_WSTRB_SIZE - 1) downto 0);
+ SAxiWValidxSI : in std_ulogic;
+ SAxiWReadyxSO : out std_ulogic;
+ -- Write Response Channel
+ SAxiBRespxDO : out std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0);
+ SAxiBValidxSO : out std_ulogic;
+ SAxiBReadyxSI : in std_ulogic<registers_list_entity_io>);
+
+end <entity_name>;
+
+architecture behavioral of <entity_name> is
+
+ -- Constants
+ constant C_AXI4_RRESP_OKAY : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "00";
+ constant C_AXI4_RRESP_EXOKAY : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "01";
+ constant C_AXI4_RRESP_SLVERR : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "10";
+ constant C_AXI4_RRESP_DECERR : std_ulogic_vector((C_AXI4_RRESP_SIZE - 1) downto 0) := "11";
+ constant C_AXI4_BRESP_OKAY : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "00";
+ constant C_AXI4_BRESP_EXOKAY : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "01";
+ constant C_AXI4_BRESP_SLVERR : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "10";
+ constant C_AXI4_BRESP_DECERR : std_ulogic_vector((C_AXI4_BRESP_SIZE - 1) downto 0) := "11";
+
+ -- Signals
+ -- Clock and reset
+ signal SAxiClkxC : std_ulogic := '0';
+ signal SAxiRstxRAN : std_ulogic := '0';
+ -- AXI4 Lite
+ signal SAxiARReadyxS : std_ulogic := '0';
+ signal SAxiRValidxS : std_ulogic := '0';
+ signal SAxiBValidxS : std_ulogic := '0';
+ signal SAxiWReadyxS : std_ulogic := '0';
+ signal SAxiAWReadyxS : std_ulogic := '0';
+ signal WrAddrxDN : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ signal WrAddrxDP : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ -- Signals of access to the register bank
+ signal RdAddrxD : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ signal RdDataxD : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := (others => '0');
+ signal RdValidxS : std_ulogic := '0';
+ signal WrAddrxD : std_ulogic_vector((C_AXI4_ADDR_SIZE - 1) downto 0) := (others => '0');
+ signal WrDataxD : std_ulogic_vector((C_AXI4_DATA_SIZE - 1) downto 0) := (others => '0');
+ signal WrValidxS : std_ulogic := '0';
+ -- Registers list
+ <registers_list>
+ -- Attributes
+ attribute mark_debug : string;
+ attribute keep : string;
+ --
+ -- attribute mark_debug of : signal is "true";
+ -- attribute keep of : signal is "true";
+
+begin
+
+ assert C_AXI4_RDATA_SIZE = C_AXI4_DATA_SIZE
+ report "RDATA and DATA vectors must be the same" severity failure;
+
+ assert C_AXI4_ARADDR_SIZE >= C_AXI4_ADDR_SIZE
+ report "ARADDR and ADDR vectors must be the same" severity failure;
+
+ assert C_AXI4_WDATA_SIZE = C_AXI4_DATA_SIZE
+ report "WDATA and DATA vectors must be the same" severity failure;
+
+ assert C_AXI4_AWADDR_SIZE >= C_AXI4_ADDR_SIZE
+ report "AWADDR and ADDR vectors must be the same" severity failure;
+
+ EntityIOxB : block is
+ begin -- block EntityIOxB
+
+ -- Clock and reset
+ SAxiClkxAS : SAxiClkxC <= SAxiClkxCI;
+ SAxiRstxAS : SAxiRstxRAN <= SAxiRstxRANI;
+ -- Read Channel
+ SAxiARReadyxAS : SAxiARReadyxSO <= SAxiARReadyxS;
+ SAxiRValidxAS : SAxiRValidxSO <= SAxiRValidxS;
+ SAxiRDataxAS : SAxiRDataxDO <= RdDataxD;
+ RdValidxAS : RdValidxS <= SAxiARValidxSI;
+ RdAddrxAS : RdAddrxD((C_AXI4_ADDR_SIZE - 1) downto 0) <= SAxiARAddrxDI((C_AXI4_ADDR_SIZE - 1) downto 0);
+ SAxiRRespxAS : SAxiRRespxDO <= C_AXI4_RRESP_OKAY;
+ -- Write Channel
+ SAxiBRespxAS : SAxiBRespxDO <= C_AXI4_BRESP_OKAY;
+ SAxiBValidxAS : SAxiBValidxSO <= SAxiBValidxS;
+ SAxiWReadyxAS : SAxiWReadyxSO <= SAxiWReadyxS;
+ SAxiAWReadyxAS : SAxiAWReadyxSO <= SAxiAWReadyxS;
+ WrValidxAS : WrValidxS <= SAxiWValidxSI;
+ WrDataxAS : WrDataxD <= SAxiWDataxDI;
+ WrAddrOutxAS : WrAddrxD <= WrAddrxDP;
+ WrAddrxAS : WrAddrxDN((C_AXI4_ADDR_SIZE - 1) downto 0) <= SAxiAWAddrxDI((C_AXI4_ADDR_SIZE - 1) downto 0) when
+ SAxiAWValidxSI = '1' else
+ WrAddrxDP((C_AXI4_ADDR_SIZE - 1) downto 0);
+
+ end block EntityIOxB;
+
+ AXI4LitexB : block is
+ begin -- block AXI4LitexB
+
+ ReadChannelxB : block is
+ begin -- block ReadChannelxB
+
+ ReadAddrChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+
+ variable StateAfterResetxS : boolean := true;
+
+ begin -- process ReadAddrChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiARReadyxS <= '0';
+ StateAfterResetxS := true;
+ elsif rising_edge(SAxiClkxC) then
+ if StateAfterResetxS = true then
+ SAxiARReadyxS <= '1';
+ StateAfterResetxS := false;
+ else
+ SAxiARReadyxS <= SAxiARReadyxS;
+ end if;
+
+ if SAxiARValidxSI = '1' then
+ SAxiARReadyxS <= '0';
+ end if;
+
+ if SAxiARReadyxS <= '0' and SAxiRReadyxSI = '1' then
+ SAxiARReadyxS <= '1';
+ end if;
+ end if;
+ end process ReadAddrChanxP;
+
+ ReadDataChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process ReadDataChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiRValidxS <= '0';
+ elsif rising_edge(SAxiClkxC) then
+ SAxiRValidxS <= SAxiRValidxS;
+
+ if SAxiARValidxSI = '1' and SAxiARReadyxS = '1' then
+ SAxiRValidxS <= '1';
+ end if;
+
+ if SAxiRValidxS = '1' and SAxiRReadyxSI = '1' then
+ SAxiRValidxS <= '0';
+ end if;
+ end if;
+ end process ReadDataChanxP;
+
+ end block ReadChannelxB;
+
+ WriteChannelxB : block is
+ begin --block WriteChannelxB
+
+ WrAddrRegxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process WrAddrRegxP
+ if SAxiRstxRAN = '0' then
+ WrAddrxDP <= (others => '0');
+ elsif rising_edge(SAxiClkxC) then
+ WrAddrxDP <= WrAddrxDN;
+ end if;
+ end process WrAddrRegxP;
+
+ WriteAddrChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+
+ variable StateAfterResetxS : boolean := true;
+
+ begin -- process WriteAddrChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiAWReadyxS <= '0';
+ StateAfterResetxS := true;
+ elsif rising_edge(SAxiClkxC) then
+ if StateAfterResetxS = true then
+ SAxiAWReadyxS <= '1';
+ StateAfterResetxS := false;
+ else
+ SAxiAWReadyxS <= SAxiAWReadyxS;
+ end if;
+
+ if SAxiAWValidxSI = '1' then
+ SAxiAWReadyxS <= '0';
+ end if;
+
+ if SAxiWValidxSI = '1' then
+ SAxiAWReadyxS <= '1';
+ end if;
+ end if;
+ end process WriteAddrChanxP;
+
+ WriteDataChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process WriteDataChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiWReadyxS <= '0';
+ elsif rising_edge(SAxiClkxC) then
+ SAxiWReadyxS <= SAxiWReadyxS;
+
+ if SAxiAWValidxSI = '1' and SAxiAWReadyxS = '1' then
+ SAxiWReadyxS <= '1';
+ end if;
+
+ if SAxiWValidxSI = '1' and SAxiWReadyxS = '1' then
+ SAxiWReadyxS <= '0';
+ end if;
+ end if;
+ end process WriteDataChanxP;
+
+ WriteRespChanxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process WriteRespChanxP
+ if SAxiRstxRAN = '0' then
+ SAxiBValidxS <= '0';
+ elsif rising_edge(SAxiClkxC) then
+ SAxiBValidxS <= SAxiBValidxS;
+
+ if SAxiWValidxSI = '1' and SAxiWReadyxS = '1' then
+ SAxiBValidxS <= '1';
+ end if;
+
+ if SAxiBValidxS = '1' and SAxiBReadyxSI = '1' then
+ SAxiBValidxS <= '0';
+ end if;
+ end if;
+ end process WriteRespChanxP;
+
+ end block WriteChannelxB;
+
+ end block AXI4LitexB;
+
+ <block_name>xB : block is
+ begin -- block <block_name>xB
+
+ WriteRegPortxP : process (WrAddrxD, WrDataxD, WrValidxS,
+ <registers_list_current_value>) is
+ begin -- process WriteRegPortxP
+ <registers_list_current_to_next>
+ if WrValidxS = '1' then
+ case WrAddrxD is
+ <registers_list_write_access>
+ when others => null;
+ end case;
+ end if;
+ end process WriteRegPortxP;
+
+ ReadRegPortxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process ReadRegPortxP
+ if SAxiRstxRAN = '0' then
+ RdDataxD <= (others => '0');
+ elsif rising_edge(SAxiClkxC) then
+ RdDataxD <= RdDataxD;
+
+ if RdValidxS = '1' then
+ case RdAddrxD is
+ <registers_list_read_access>
+ when others => RdDataxD <= (others => '0');
+ end case;
+ end if;
+ end if;
+ end process ReadRegPortxP;
+
+ UpdateRegBankxP : process (SAxiClkxC, SAxiRstxRAN) is
+ begin -- process UpdateRegBankxP
+ if SAxiRstxRAN = '0' then
+ <registers_list_init_current_value>
+ elsif rising_edge(SAxiClkxC) then
+ <registers_list_next_to_current>
+ end if;
+ end process UpdateRegBankxP;
+
+ end block <block_name>xB;
+
+end behavioral;
diff --git a/src/utils.py b/src/utils.py
new file mode 100644
index 0000000..c53058a
--- /dev/null
+++ b/src/utils.py
@@ -0,0 +1,47 @@
+#!/usr/bin/python
+
+import datetime
+import re
+import os
+import shutil
+import numpy as np
+
+def display_title(title_str):
+ print("\n" + ("-" * (len(title_str) + 6)))
+ print("-- " + title_str + " --")
+ print(("-" * (len(title_str) + 6)) + "\n")
+
+def get_time_str():
+ return datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+
+def file_replace_pattern(file_path, pattern, replace_str):
+ # create the regex pattern
+ re_pattern = "(" + pattern + ")"
+ p = re.compile(re_pattern)
+ # create a temp file to apply the pattern
+ temp_file = file_path + "#"
+ fin = open(file_path, "r")
+ fout = open(temp_file, "w")
+ for line in fin.readlines():
+ # substitute the pattern
+ fout.write(p.sub(replace_str, line))
+ # replace the input file by the processed temp file
+ os.remove(file_path)
+ shutil.move(temp_file, file_path)
+
+def hex32str(value):
+ return "{:08X}".format(value)
+
+def hex32str2(value, bd_range):
+
+ size = int(np.ceil(int(np.trunc(np.log2(int(bd_range)))) / 4))
+ fstr = "{:0" + str(size) + "X}"
+
+ return fstr.format(value)
+
+def check_key(dict, key) :
+
+ if key in dict.keys() :
+ return True
+ else :
+ return False
diff --git a/src/utils.pyc b/src/utils.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a619c405da5902cadb37e8dcf7bd563c7018e5f3
GIT binary patch
literal 1808
zcmZSn%*(Z4HCsY50~9bZFfceUFfbG+GB7ZtFfgPrGUPBYM8VmN3{i|QaVCZ+CK#KU
zA&QwHg^8hsfgy^8A%z*tU}Z>Q0W;VbQdq$Zc7_x-FoOeRa<B$F0|P_m|NsC0`z13n
zFff2H3j+g#Gsp$@AQv!#3@u?`s9|7eW(1ilE+X#kk-`EJ5Km!c0CAWYP!*&wf`u6v
zf;HF}7#RGDLB?{GfJog;kVr8z0|SGut^$}=(ACudNtJ*Eb5ipl98LxXhLX&ZoYeT@
zk|GUI;DCu@PX-1C{fzwFRQ;@ceV6>?(%jU%l4AXUqWrAXl45<2)Pl@J{o>@roPziQ
zkXUjFlvk9Ro|=+bqF-E;tY2D^nNzG+P+7tY@?vIjK~7?2JlHl4kjFtzWMC9$<Yh#O
z7I2`5f!xKwkj21|#mLaiz>viR3dm+ghF}d))cF;Ij8u(O%~ef_SM^Z!RSnhv`KttE
za7toHYDs2pD%hua`Q>22;*z2?kRaH52!hHU<zZl8NKY+^2iXJ)QIIQ(K@MhMOa{3R
z6x^(^h@S=u6-I^{Mh5W|CI<0ZW>EZQF*4LJgVI1P3n=bWm>I-tSs6;0z#JBaW+sMO
zHZYeJl-598c7_UFh8i}8EM`zZxx~sd)N(M?urp+_Fx0RxWU(^TFfr6{fOIx9GB6ef
zF@%?}F=VlW3<L?3a4=+XGSskw`AiIqDe&|JPDvVIQWH!ngUKQ=S+2naiXxETic(8J
z={q?;w;(eowFH!~^9xe*N<f}1N=;13$;?YFE&+MFyeP8-5-r80NhKh?`NbumWKfiv
zn_rd+W)^3Fk`34tkeCL@6tGcgnK`NP1&JjYVA~23OG;9U@=CZF7#NCD3vv>Z!AZCT
z<f<aDI<Pb-#TS6Jm!#$v#DmNLCyTVqJg^mM`K2Xb2FQ^#OBNyw3=ANv<6$m^x?TX3
z4TM0sj){+vpNWf+pOK$Ym`Rq2ml0l0fI<nJC3qppB@0$az;Xg8{Hm=CEFx+lSsKJo
z%P-1JEP?Pr0biDwQ<_RM?}0L1MrwtzQE^F;JjhERH#0CMgD4mVdqJ83?0AqD7(r>g
zNSL97ks-K*i6I!A>_D;Q2g%5w6qS)!9G{(9367tTqS91w8gfg_DNY3!0$}l!%;XYq
zjAo}+(#(UPG?<)`nw$-CjuHa{Loq0j8JPGPS(v~HGzgUFgFrD9B+S6T5F`pBKp8#=
z<c}Z)5LX#QXfiM`Ae;$iQMm{LMTSjoeoARhsvXD$#h^sS!w7~<oUEM8ocx^307j69
AEC2ui
literal 0
HcmV?d00001
--
GitLab