[kmac,dv] Add smoke test for dynamic app interface

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

Author: etterli

hw/dv/sv/kmac_app_agent/kmac_app_agent.core

@@ -26,6 +26,7 @@ filesets:
       - kmac_app_agent.sv: {is_include_file: true}
       - seq_lib/kmac_app_base_seq.sv: {is_include_file: true}
       - seq_lib/kmac_app_host_seq.sv: {is_include_file: true}
+      - seq_lib/kmac_app_xof_host_seq.sv: {is_include_file: true}
       - seq_lib/kmac_app_device_seq.sv: {is_include_file: true}
       - seq_lib/kmac_app_seq_list.sv: {is_include_file: true}
     file_type: systemVerilogSource

hw/dv/sv/kmac_app_agent/seq_lib/kmac_app_seq_list.sv

@@ -4,4 +4,5 @@
 
 `include "kmac_app_base_seq.sv"
 `include "kmac_app_host_seq.sv"
+`include "kmac_app_xof_host_seq.sv"
 `include "kmac_app_device_seq.sv"

hw/dv/sv/kmac_app_agent/seq_lib/kmac_app_xof_host_seq.sv

@@ -0,0 +1,106 @@
+// Copyright lowRISC contributors (OpenTitan project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+// Host sequence for AppDynamic (OTBN) XOF transactions.
+//
+// Transaction flow:
+//   Phase 0, Config beat:   one push_pull beat encoding mode/strength as data.
+//   Phase 1, Message beats: drive message bytes.
+//   Phase 2, Digest:        KMAC pushes req_output_len chunks (rsp_valid pulses) without
+//                            per-chunk requests.  Once all chunks are received the host
+//                            sends a single finish beat (last=1).  Any further rsp_valid
+//                            pulses are discarded until rsp_finish signals session end.
+class kmac_app_xof_host_seq extends kmac_app_base_seq;
+  `uvm_object_utils(kmac_app_xof_host_seq)
+  `uvm_object_new
+
+  // Message to hash.  Must be set before starting this sequence.
+  byte msg_q[$];
+
+  // Number of 64-bit digest chunks to request.
+  int unsigned req_output_len = 8;
+
+  virtual task body();
+    cfg.m_data_push_agent_cfg.zero_delays = cfg.zero_delays;
+
+    // Phase 0: config beat.
+    begin
+      kmac_pkg::app_ses_config_t ses_cfg;
+      ses_cfg = '{prefix_mode: '0, // dummy value
+                  en_xof:      cfg.app_en_xof,
+                  mode:        cfg.app_mode,
+                  kstrength:   cfg.app_strength};
+      send_one_beat(.data(KmacDataIfWidth'(ses_cfg)), .strb('1), .last(1'b0));
+    end
+
+    // Phase 1: message beats.
+    begin
+      byte local_msg[$] = msg_q;
+      while (1) begin
+        bit [KmacDataIfWidth-1:0]   beat_data = '0;
+        bit [KmacDataIfWidth/8-1:0] beat_strb = '0;
+        bit                         beat_last;
+        int bytes_sent = 0;
+
+        for (int i = 0; i < KmacDataIfWidth / 8; i++) begin
+          if (local_msg.size() == 0) break;
+          beat_data[i*8 +: 8] = local_msg.pop_front();
+          beat_strb[i] = 1;
+          bytes_sent++;
+        end
+
+        if (bytes_sent == 0) begin
+          // Empty message: one beat with strb='1, last=1.
+          beat_strb = '1;
+        end
+
+        beat_last = (local_msg.size() == 0);
+        send_one_beat(.data(beat_data), .strb(beat_strb), .last(beat_last));
+        if (beat_last) break;
+      end
+    end
+
+    // Phase 2: receive digest chunks pushed by KMAC, then send finish.
+    // Back pressure on rsp_ready is handled automatically by the push_pull device driver.
+    for (int i = 0; i < int'(req_output_len); i++) begin
+      wait_rsp_valid();
+    end
+
+    // Signal to KMAC that enough digest data has been received.
+    send_one_beat(.data('0), .strb('1), .last(1'b1));
+
+    // Drain any extra chunks in the pipeline before the finish response arrives.
+    wait_rsp_finish();
+  endtask
+
+  // Drive a single push-pull beat by adding to the push-pull host's user-data
+  // queue and running a one-shot push_pull_host_seq.
+  virtual task send_one_beat(
+      input bit [KmacDataIfWidth-1:0]   data,
+      input bit [KmacDataIfWidth/8-1:0] strb,
+      input bit                         last
+  );
+    push_pull_host_seq#(`CONNECT_DATA_WIDTH) host_seq;
+    `uvm_create_on(host_seq, p_sequencer.m_push_pull_sequencer)
+    `DV_CHECK_RANDOMIZE_FATAL(host_seq)
+    cfg.m_data_push_agent_cfg.add_h_user_data({data, strb, last});
+    `uvm_send(host_seq)
+  endtask
+
+  // Wait for one rsp_valid/rsp_ready handshake transfer.
+  virtual task wait_rsp_valid();
+    while (!(cfg.vif.mon_cb.rsp_valid === 1 && cfg.vif.mon_cb.rsp_ready === 1))
+      @(cfg.vif.mon_cb);
+    @(cfg.vif.mon_cb);
+  endtask
+
+  // Wait for the session-end handshake: a completed transfer with rsp_finish asserted.
+  virtual task wait_rsp_finish();
+    while (!(cfg.vif.mon_cb.rsp_valid === 1 && cfg.vif.mon_cb.rsp_ready === 1 &&
+             cfg.vif.mon_cb.rsp_finish === 1))
+      @(cfg.vif.mon_cb);
+    @(cfg.vif.mon_cb);
+  endtask
+
+endclass

hw/ip/kmac/dv/env/kmac_env.core

@@ -38,6 +38,7 @@ filesets:
       - seq_lib/kmac_burst_write_vseq.sv: {is_include_file: true}
       - seq_lib/kmac_app_vseq.sv: {is_include_file: true}
       - seq_lib/kmac_app_with_partial_data_vseq.sv: {is_include_file: true}
+      - seq_lib/kmac_app_xof_smoke_vseq.sv: {is_include_file: true}
       - seq_lib/kmac_sideload_invalid_vseq.sv: {is_include_file: true}
       - seq_lib/kmac_entropy_refresh_vseq.sv: {is_include_file: true}
       - seq_lib/kmac_mubi_vseq.sv: {is_include_file: true}

hw/ip/kmac/dv/env/seq_lib/kmac_app_xof_smoke_vseq.sv

@@ -0,0 +1,106 @@
+// Copyright lowRISC contributors (OpenTitan project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+// Smoke test for the AppDynamic interface.
+//
+// Sends a randomized message and verifies the digest against the DPI reference model.
+class kmac_app_xof_smoke_vseq extends kmac_sideload_vseq;
+  `uvm_object_utils(kmac_app_xof_smoke_vseq)
+  `uvm_object_new
+
+  // Select which app interface to test. For now fixed to OTBN app interface.
+  // TODO: Constrain this to all apps which have type dynamic (via APP_CFG?)
+  localparam kmac_app_e DutApp = AppOtbn;
+
+  constraint msg_c {
+    msg.size() inside {[1:1000]};
+  }
+
+  // AppDynamic mode and strength encoded in the config beat.
+  rand kmac_pkg::app_mode_e        dyn_mode;
+  rand sha3_pkg::keccak_strength_e dyn_strength;
+
+  // Number of 64-bit digest chunks the host will request.
+  rand int unsigned output_chunks;
+
+  // Valid mode/strength combinations under test.
+  // TODO: Test cSHAKE and KMAC
+  constraint dyn_mode_strength_c {
+    dyn_mode inside {kmac_pkg::AppShake, kmac_pkg::AppSHA3};
+    if (dyn_mode == kmac_pkg::AppShake) {
+      dyn_strength inside {sha3_pkg::L128, sha3_pkg::L256};
+    } else {
+      dyn_strength inside {sha3_pkg::L256, sha3_pkg::L512};
+    }
+  }
+
+  // SHAKE: random length covering single-squeeze and multi-squeeze.
+  // SHA3-256: 4 chunks = full output (sha3-256); 2 chunks = 128 bits
+  constraint output_chunks_c {
+    if (dyn_mode == kmac_pkg::AppShake) {
+      output_chunks inside {[1:32]};
+    } else {
+      if (dyn_strength == sha3_pkg::L256) {
+        output_chunks == 4;
+      } else {
+        output_chunks == 8; // 512 / 64 = 8
+      }
+    }
+  }
+
+  // Whether XOF mode is enabled or not.
+  rand bit en_xof;
+
+  // TODO: Flag must be set if requested responses is larger than the rate. For now always enable
+  // it for SHAKE and cSHAKE to avoid implementing this restriction for now.
+  constraint en_xof_c {
+    if (dyn_mode inside {kmac_pkg::AppShake, kmac_pkg::AppCShake, kmac_pkg::AppKMAC}) {
+      en_xof == 1'b1;
+    } else {
+      en_xof == 1'b0;
+    }
+  }
+
+  // TODO: For now do not test KMAC operations.
+  constraint kmac_en_c { kmac_en == 0; }
+
+  virtual task pre_start();
+    // TODO: remove this to test KMAC
+    en_sideload_c.constraint_mode(0);
+    cfg.m_kmac_app_agent_cfg[DutApp].app_type       = AppDynamic; // TODO: assert this?
+    cfg.m_kmac_app_agent_cfg[DutApp].app_mode       = dyn_mode;
+    cfg.m_kmac_app_agent_cfg[DutApp].app_strength   = dyn_strength;
+    cfg.m_kmac_app_agent_cfg[DutApp].app_en_xof     = en_xof;
+    cfg.m_kmac_app_agent_cfg[DutApp].req_output_len = output_chunks;
+    `uvm_info(get_type_name(),
+          $sformatf(
+              "App config: app_type=%s app_mode=%s app_strength=%s en_xof=%s req_output_len=%0d",
+              cfg.m_kmac_app_agent_cfg[DutApp].app_type.name(),
+              dyn_mode.name(),
+              dyn_strength.name(),
+              en_xof,
+              cfg.m_kmac_app_agent_cfg[DutApp].req_output_len),
+          UVM_LOW)
+    super.pre_start();
+  endtask
+
+  virtual task body();
+    kmac_app_xof_host_seq xof_seq;
+
+    kmac_init();
+    // We must provide a seed for the entropy module via SW.
+    if (cfg.enable_masking && entropy_mode == EntropyModeSw) begin
+      `uvm_info(`gfn, "providing SW entropy", UVM_HIGH)
+      provide_sw_entropy();
+    end
+
+    `uvm_create_on(xof_seq, p_sequencer.kmac_app_sequencer_h[DutApp])
+    foreach (msg[i]) xof_seq.msg_q.push_back(msg[i]);
+    xof_seq.req_output_len = output_chunks;
+    `uvm_send(xof_seq)
+
+    cfg.clk_rst_vif.wait_clks(100);
+  endtask
+
+endclass

hw/ip/kmac/dv/env/seq_lib/kmac_vseq_list.sv

@@ -15,6 +15,7 @@
 `include "kmac_burst_write_vseq.sv"
 `include "kmac_app_vseq.sv"
 `include "kmac_app_with_partial_data_vseq.sv"
+`include "kmac_app_xof_smoke_vseq.sv"
 `include "kmac_sideload_invalid_vseq.sv"
 `include "kmac_mubi_vseq.sv"
 `include "kmac_entropy_refresh_vseq.sv"

hw/ip/kmac/dv/kmac_base_sim_cfg.hjson

@@ -91,6 +91,10 @@
       name: "{name}_smoke"
       uvm_test_seq: kmac_smoke_vseq
     }
+    {
+      name: "{name}_app_xof_smoke"
+      uvm_test_seq: kmac_app_xof_smoke_vseq
+    }
     {
       name: "{name}_long_msg_and_output"
       uvm_test_seq: kmac_long_msg_and_output_vseq