[rom_ctrl,rtl,dv] Adapt KMAC app interface to extended interface

This are the required changes to match the adapted KMAC app interface.

Signed-off-by: Pascal Etterli <pascal.etterli@lowrisc.org>

Author: etterli

hw/ip/rom_ctrl/dv/cov/rom_ctrl_cov_if.sv

@@ -31,15 +31,15 @@ interface rom_ctrl_cov_if (
     option.per_instance = 1;
 
     // Cover some basic stalling behavior on the kmac ready input
-    cp_kmac_ready: coverpoint kmac_data_i.ready iff (kmac_data_o.valid) {
+    cp_kmac_ready: coverpoint kmac_data_i.req_ready iff (kmac_data_o.req_valid) {
       bins zero_delay_5 = (1'b1[*5]);
       bins stall_1      = (1'b1 => 1'b0 => 1'b1);
       bins stall_long   = (1'b0[*5:10] => 1'b1);
       bins stall_repeat = (1'b0[*1:10] => 1'b1 => 1'b0[*1:10]);
     }
 
-    // Cover the different delays on the kmac done signal
-    cp_kmac_done: coverpoint {kmac_data_i.done, exp_digest_de} {
+    // Cover the different delays on the kmac response valid signal
+    cp_kmac_digest_handshake: coverpoint {kmac_data_i.rsp_valid, exp_digest_de} {
       bins kmac_first = {2'b11}; // kmac responds while still reading digest
       bins rom_first  = (2'b00 => 2'b10); // kmac responds after digest read
       bins same_cycle = (2'b01 => 2'b10); // kmac responds as digest read completes

hw/ip/rom_ctrl/dv/env/rom_ctrl_scoreboard.sv

@@ -147,7 +147,7 @@ task rom_ctrl_scoreboard::process_kmac_rsp_fifo();
     // it's a DV bug: we should already have failed when the KMAC request was sent a few cycles ago.
     `DV_CHECK_FATAL(!rom_check_complete, "Extra KMAC response seen.")
 
-    kmac_digest = kmac_rsp.rsp_digest_share0 ^ kmac_rsp.rsp_digest_share1;
+    kmac_digest = kmac_rsp.digest_s0 ^ kmac_rsp.digest_s1;
     expected_digest = get_expected_digest();
     update_ral_digests(kmac_digest, expected_digest);
     digest_good = prim_mubi_pkg::mubi4_bool_to_mubi(

hw/ip/rom_ctrl/dv/env/seq_lib/rom_ctrl_kmac_err_chk_vseq.sv

@@ -23,7 +23,7 @@ task rom_ctrl_kmac_err_chk_vseq::body();
     fork
       wait(cfg.under_reset);
       begin
-        wait(cfg.m_kmac_agent_cfg.vif.mon_cb.rsp_done);
+        wait(cfg.m_kmac_agent_cfg.vif.mon_cb.rsp_valid);
         wait_for_fatal_alert(.max_delay(4), .max_wait_cycle(7));
         `DV_CHECK_EQ(cfg.rom_ctrl_vif.pwrmgr_data.done, MuBi4False)
       end

hw/ip/rom_ctrl/dv/tb/rom_ctrl_if.sv

@@ -36,12 +36,12 @@ interface rom_ctrl_if ();
     release dut.u_mux.sel_bus_qq;
   endtask
 
-  // Override the kmac_data_i.done signal to be true for a cycle, returning on the next negedge.
-  // (This will be one cycle if we start before the posedge)
+  // Override the kmac_data_i.rsp_valid signal to be true for a cycle, returning on the next
+  // negedge. This will be one cycle if we start before the posedge.
   task static force_kmac_data_done();
-    force dut.kmac_data_i.done = 1;
+    force dut.kmac_data_i.rsp_valid = 1;
     @(negedge dut.clk_i);
-    release dut.kmac_data_i.done;
+    release dut.kmac_data_i.rsp_valid;
   endtask
 
 endinterface

hw/ip/rom_ctrl/dv/tb/tb.sv

@@ -20,7 +20,7 @@ module tb;
   kmac_pkg::app_req_t         kmac_data_out;
   rom_ctrl_pkg::pwrmgr_data_t pwrmgr_data;
   rom_ctrl_pkg::keymgr_data_t keymgr_data;
-  logic kmac_done_occured;
+  logic kmac_digest_handshake_occured;
 
   // interfaces
   clk_rst_if clk_rst_if(.clk(clk), .rst_n(rst_n));
@@ -114,19 +114,22 @@ module tb;
     run_test();
   end
   // Only get one KMAC response
-  `ASSERT(JustOneKmacResponse_A, kmac_data_in.done |=> always !kmac_data_in.done, clk, rst_n)
+  `ASSERT(JustOneKmacResponse_A, kmac_data_in.rsp_valid |=> always !kmac_data_in.rsp_valid,
+          clk, rst_n)
   // Once we signal done to pwrmgr, the done signal stays high and the good signal stays stable.
   `ASSERT(PwrmgrDoneOneWay_A, $rose(pwrmgr_data.done == prim_mubi_pkg::MuBi4True) |=>
           always $stable(pwrmgr_data), clk, rst_n)
   // Don't send any KMAC requests once we've had the response
-  `ASSERT(KmacNotOutAfterIn_A, kmac_data_in.done |=> always !kmac_data_out.valid, clk, rst_n)
+  `ASSERT(KmacNotOutAfterIn_A, kmac_data_in.rsp_valid |=> always !kmac_data_out.req_valid,
+          clk, rst_n)
   always_comb begin
-    if (!rst_n) kmac_done_occured = 0;
-    else if (kmac_data_in.done) kmac_done_occured = 1;
+    if (!rst_n) kmac_digest_handshake_occured = 0;
+    else if (kmac_data_in.rsp_valid) kmac_digest_handshake_occured = 1;
   end
   // We see a response from KMAC before we assert that we're done to pwrmgr
   `ASSERT(KmacResponseBeforePwmgrDone_A,
-          pwrmgr_data.done != prim_mubi_pkg::MuBi4False |-> kmac_done_occured, clk, rst_n)
+          pwrmgr_data.done != prim_mubi_pkg::MuBi4False |-> kmac_digest_handshake_occured,
+          clk, rst_n)
   `undef ROM_CTRL_MEM_HIER
 
 endmodule

hw/ip/rom_ctrl/rtl/rom_ctrl.sv

@@ -126,21 +126,24 @@ module rom_ctrl
     // set 4 or 5 byte enables (4 for 32bit, 5 for 39bit)!
     localparam int NumBytes = (DataWidth + 7) / 8;
 
+    // ROM ctrl operates on unshared data and and accepts digest responses immediately.
     // SEC_CM: MEM.DIGEST
-    assign kmac_data_o = '{valid: kmac_rom_vld_outer,
-                           data: kmac_rom_data,
+    assign kmac_data_o = '{req_valid: kmac_rom_vld_outer,
+                           data_s0: kmac_rom_data,
+                           data_s1: '0,
                            strb: kmac_pkg::MsgStrbW'({NumBytes{1'b1}}),
-                           last: kmac_rom_last_outer};
+                           req_last: kmac_rom_last_outer,
+                           rsp_ready: 1'b1};
 
-    assign kmac_rom_rdy_outer = kmac_data_i.ready;
-    assign kmac_done = kmac_data_i.done;
-    assign kmac_digest = kmac_data_i.digest_share0[255:0] ^ kmac_data_i.digest_share1[255:0];
+    assign kmac_rom_rdy_outer = kmac_data_i.req_ready;
+    assign kmac_done = kmac_data_i.rsp_valid;
+    assign kmac_digest = kmac_data_i.digest_s0[255:0] ^ kmac_data_i.digest_s1[255:0];
     assign kmac_err = kmac_data_i.error;
 
     logic unused_kmac_digest;
     assign unused_kmac_digest = ^{
-      kmac_data_i.digest_share0[kmac_pkg::AppDigestW-1:256],
-      kmac_data_i.digest_share1[kmac_pkg::AppDigestW-1:256]
+      kmac_data_i.digest_s0[kmac_pkg::AppDigestW-1:256],
+      kmac_data_i.digest_s1[kmac_pkg::AppDigestW-1:256]
     };
 
   end : gen_kmac_scramble_enabled
@@ -161,6 +164,10 @@ module rom_ctrl
 
   end : gen_kmac_scramble_disabled
 
+  // A static KMAC interface has no finish response.
+  logic unused_kmac_finish_rsp;
+  assign unused_kmac_finish_rsp = kmac_data_i.rsp_finish;
+
   // TL interface ==============================================================
   // This buffer ensures that when we calculate bus_rom_prince_index by snooping on
   // rom_tl_i, we get a value that's buffered from the thing that goes into both the ECC
@@ -556,17 +563,18 @@ module rom_ctrl
   `ASSERT_KNOWN_IF(KeymgrDataODataKnown_A, keymgr_data_o, keymgr_data_o.valid)
 
   // The valid signal for kmac_data_o should always be known when out of reset. The rest of the
-  // struct (data, strb and last) should be known whenever the valid signal is true.
-  `ASSERT_KNOWN(KmacDataOValidKnown_A, kmac_data_o.valid)
-  `ASSERT_KNOWN_IF(KmacDataODataKnown_A, kmac_data_o, kmac_data_o.valid)
+  // struct (data, strb and req_last) should be known whenever the valid signal is true.
+  `ASSERT_KNOWN(KmacDataOValidKnown_A, kmac_data_o.req_valid)
+  `ASSERT_KNOWN_IF(KmacDataODataKnown_A, kmac_data_o, kmac_data_o.req_valid)
 
-  // Check that kmac_data_o.last is "telling the truth": kmac_data_o.valid should drop on the cycle
-  // after the word that it decorates is transferred.
+  // Check that kmac_data_o.req_last is "telling the truth": kmac_data_o.rsp_valid should drop on
+  // the cycle after the word that it decorates is transferred.
   `ASSERT(KmacLastTrue_A,
-          kmac_data_o.valid && kmac_data_i.ready && kmac_data_o.last |=> !kmac_data_o.valid)
+          kmac_data_o.req_valid && kmac_data_i.req_ready && kmac_data_o.req_last
+          |=> !kmac_data_o.req_valid)
 
   // Check that pwrmgr_data_o.good is stable when kmac_data_o.valid is asserted
-  `ASSERT(StabilityChkKmac_A, kmac_data_o.valid && $past(kmac_data_o.valid)
+  `ASSERT(StabilityChkKmac_A, kmac_data_o.req_valid && $past(kmac_data_o.req_valid)
           |-> $stable(pwrmgr_data_o.good))
 
   // Check that pwrmgr_data_o.good is stable when keymgr_data_o.valid is asserted