WIP: Made AXI read slave VC compliant

Author: LarsAsplund

vunit/vhdl/verification_components/.vc/tb_axi_read_slave_compliance_template.vhd

@@ -0,0 +1,77 @@
+-- Read the TODOs to complete this template.
+
+library ieee;
+library vunit_lib;
+context vunit_lib.com_context;
+context vunit_lib.vc_context;
+context vunit_lib.vunit_context;
+use ieee.numeric_std.all;
+use ieee.std_logic_1164.all;
+use vunit_lib.axi_pkg.all;
+use vunit_lib.axi_slave_pkg.all;
+use vunit_lib.axi_slave_private_pkg.all;
+use vunit_lib.queue_pkg.all;
+use vunit_lib.sync_pkg.all;
+
+entity tb_axi_read_slave_compliance is
+  generic(
+    runner_cfg : string);
+end entity;
+
+architecture tb of tb_axi_read_slave_compliance is
+
+  -- TODO: Specify a value for all listed parameters. Keep all parameters on separate lines
+  constant memory : memory_t := new_memory;
+  constant axi_slave : axi_slave_t := new_axi_slave(
+    memory => memory
+  );
+
+  -- TODO: Constrain any unconstrained signal connecting to the DUT.
+  constant log_data_size : integer := 4;
+  constant data_size : integer := 2**log_data_size;
+
+  signal aclk : std_logic;
+  signal arvalid : std_logic;
+  signal arready : std_logic;
+  signal arid : std_logic_vector(3 downto 0);
+  signal araddr : std_logic_vector(31 downto 0);
+  signal arlen : axi4_len_t;
+  signal arsize : axi4_size_t;
+  signal arburst : axi_burst_type_t;
+  signal rvalid : std_logic;
+  signal rready : std_logic;
+  signal rid : std_logic_vector(arid'range);
+  signal rdata : std_logic_vector(8*data_size-1 downto 0);
+  signal rresp : axi_resp_t;
+  signal rlast : std_logic;
+
+begin
+  -- DO NOT modify the test runner process.
+  test_runner : process
+  begin
+    test_runner_setup(runner, runner_cfg);
+    test_runner_cleanup(runner);
+  end process test_runner;
+
+  -- DO NOT modify the VC instantiation.
+      vc_inst: entity vunit_lib.axi_read_slave
+        generic map(axi_slave)
+
+        port map(
+          aclk => aclk,
+      arvalid => arvalid,
+      arready => arready,
+      arid => arid,
+      araddr => araddr,
+      arlen => arlen,
+      arsize => arsize,
+      arburst => arburst,
+      rvalid => rvalid,
+      rready => rready,
+      rid => rid,
+      rdata => rdata,
+      rresp => rresp,
+      rlast => rlast
+    );
+
+end architecture;

vunit/vhdl/verification_components/run.py

@@ -136,6 +136,11 @@ def gen_avalon_master_tests(obj, *args):
 ComplianceTest(lib, "axi_lite_master", "bus_master_pkg").add_vhdl_testbench(
     test_lib, join(root, "compliance_test")
 )
+ComplianceTest(lib, "axi_read_slave", "axi_slave_pkg").add_vhdl_testbench(
+    test_lib,
+    join(root, "compliance_test"),
+    join(root, ".vc", "tb_axi_read_slave_compliance_template.vhd"),
+)
 
 ui.set_compile_option("rivierapro.vcom_flags", ["-dbg"])
 

vunit/vhdl/verification_components/src/axi_slave_pkg.vhd

@@ -9,7 +9,9 @@ use ieee.std_logic_1164.all;
 
 use work.queue_pkg.all;
 use work.logger_pkg.all;
+use work.checker_pkg.all;
 use work.memory_pkg.all;
+use work.sync_pkg.all;
 context work.com_context;
 use work.axi_statistics_pkg.all;
 
@@ -29,9 +31,12 @@ package axi_slave_pkg is
     p_actor : actor_t;
     p_memory : memory_t;
     p_logger : logger_t;
+    p_checker : checker_t;
+    p_fail_on_unexpected_msg_type : boolean;
   end record;
 
   constant axi_slave_logger : logger_t := get_logger("vunit_lib:axi_slave_pkg");
+  constant axi_slave_checker : checker_t := new_checker(axi_slave_logger);
   impure function new_axi_slave(memory : memory_t;
                                 address_fifo_depth : positive := 1;
                                 write_response_fifo_depth : positive := 1;
@@ -41,7 +46,12 @@ package axi_slave_pkg is
                                 write_response_stall_probability : probability_t := 0.0;
                                 min_response_latency : delay_length := 0 ns;
                                 max_response_latency : delay_length := 0 ns;
-                                logger : logger_t := axi_slave_logger) return axi_slave_t;
+                                logger : logger_t := axi_slave_logger;
+                                actor : actor_t := null_actor;
+                                checker : checker_t := null_checker;
+                                fail_on_unexpected_msg_type : boolean := true) return axi_slave_t;
+
+  impure function as_sync(axi_slave : axi_slave_t) return sync_handle_t;
 
   -- Get the logger used by the axi_slave
   function get_logger(axi_slave : axi_slave_t) return logger_t;
@@ -145,9 +155,26 @@ package body axi_slave_pkg is
                                 write_response_stall_probability : probability_t := 0.0;
                                 min_response_latency : delay_length := 0 ns;
                                 max_response_latency : delay_length := 0 ns;
-                                logger : logger_t := axi_slave_logger) return axi_slave_t is
+                                logger : logger_t := axi_slave_logger;
+                                actor : actor_t := null_actor;
+                                checker : checker_t := null_checker;
+                                fail_on_unexpected_msg_type : boolean := true) return axi_slave_t is
+    variable p_actor : actor_t;
+    variable p_checker : checker_t;
   begin
-    return (p_actor => new_actor,
+    p_actor := actor when actor /= null_actor else new_actor;
+
+    if checker = null_checker then
+      if logger = axi_slave_logger then
+        p_checker := axi_slave_checker;
+      else
+        p_checker := new_checker(logger);
+      end if;
+    else
+      p_checker := checker;
+    end if;
+
+    return (p_actor => p_actor,
             p_initial_address_fifo_depth => address_fifo_depth,
             p_initial_write_response_fifo_depth => write_response_fifo_depth,
             p_initial_check_4kbyte_boundary => check_4kbyte_boundary,
@@ -157,7 +184,14 @@ package body axi_slave_pkg is
             p_initial_min_response_latency => min_response_latency,
             p_initial_max_response_latency => max_response_latency,
             p_memory => to_vc_interface(memory, logger),
-            p_logger => logger);
+            p_logger => logger,
+            p_checker => p_checker,
+            p_fail_on_unexpected_msg_type => fail_on_unexpected_msg_type);
+  end;
+
+  impure function as_sync(axi_slave : axi_slave_t) return sync_handle_t is
+  begin
+    return axi_slave.p_actor;
   end;
 
   function get_logger(axi_slave : axi_slave_t) return logger_t is

vunit/vhdl/verification_components/src/axi_slave_private_pkg.vhd

@@ -47,6 +47,8 @@ package axi_slave_private_pkg is
                    max_id : natural;
                    data : std_logic_vector);
     impure function get_actor return actor_t;
+    impure function get_logger return logger_t;
+    impure function fail_on_unexpected_msg_type return boolean;
 
     procedure set_address_fifo_depth(depth : positive);
     procedure set_write_response_fifo_depth(depth : positive);
@@ -165,6 +167,16 @@ package body axi_slave_private_pkg is
       return p_axi_slave.p_actor;
     end;
 
+    impure function get_logger return logger_t is
+    begin
+      return p_axi_slave.p_logger;
+    end;
+
+    impure function fail_on_unexpected_msg_type return boolean is
+    begin
+      return p_axi_slave.p_fail_on_unexpected_msg_type;
+    end;
+
     procedure set_address_fifo_depth(depth : positive) is
     begin
       if burst_queue_length > depth then
@@ -503,6 +515,8 @@ package body axi_slave_private_pkg is
       receive(net, self.get_actor, request_msg);
       msg_type := message_type(request_msg);
 
+      handle_sync_message(net, msg_type, request_msg);
+
       if msg_type = axi_slave_set_address_fifo_depth_msg then
         self.set_address_fifo_depth(pop(request_msg));
         acknowledge(net, request_msg, true);
@@ -548,8 +562,8 @@ package body axi_slave_private_pkg is
       elsif msg_type = axi_slave_enable_well_behaved_check_msg then
         self.enable_well_behaved_check;
         acknowledge(net, request_msg, true);
-      else
-        unexpected_msg_type(msg_type);
+      elsif self.fail_on_unexpected_msg_type then
+        unexpected_msg_type(msg_type, self.get_logger);
       end if;
 
       delete(request_msg);