WIP: Made AXI read slave VC compliant

Author: LarsAsplund

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"),
+    "D:/github/vunit/vunit/vhdl/verification_components/src/.compliance_test_templates/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,29 @@ 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_memory : memory_t;
+    variable p_actor : actor_t;
+    variable p_checker : checker_t;
   begin
-    return (p_actor => new_actor,
+    p_memory := memory when memory /= null_memory else to_vc_interface(new_memory, logger);
+
+    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,
@@ -156,8 +186,15 @@ package body axi_slave_pkg is
             p_initial_write_response_stall_probability => write_response_stall_probability,
             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_memory => p_memory,
+            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);