diff --git a/hw/vendor/lowrisc_ip.vendor.hjson b/hw/vendor/lowrisc_ip.vendor.hjson index 57ff6d8..51329cf 100644 --- a/hw/vendor/lowrisc_ip.vendor.hjson +++ b/hw/vendor/lowrisc_ip.vendor.hjson @@ -8,7 +8,8 @@ upstream: { url: "https://github.com/lowRISC/opentitan" - rev: "master" + // Pinned to the lock revision so the description alone is reproducible. + rev: "012fb0fe3042a2ab97f9fa045520286486a4b98f" } mapping: [ @@ -25,6 +26,37 @@ {from: "hw/check_tool_requirements.py", to: "check_tool_requirements.py"}, {from: "hw/tool_requirements.py", to: "tool_requirements.py", patch_dir: "scripts"}, + // DV libraries for the UVM bench (hw/ip/uart16550/dv), with their dependencies + {from: "hw/dv/sv/alert_agent", to: "dv/sv/alert_agent"}, + {from: "hw/dv/sv/bus_params_pkg", to: "dv/sv/bus_params_pkg"}, + {from: "hw/dv/sv/common_ifs", to: "dv/sv/common_ifs"}, + {from: "hw/dv/sv/csr_utils", to: "dv/sv/csr_utils"}, + {from: "hw/dv/sv/dv_base_agent", to: "dv/sv/dv_base_agent"}, + {from: "hw/dv/sv/dv_base_reg", to: "dv/sv/dv_base_reg"}, + {from: "hw/dv/sv/dv_lib", to: "dv/sv/dv_lib"}, + {from: "hw/dv/sv/dv_utils", to: "dv/sv/dv_utils"}, + {from: "hw/dv/sv/mem_model", to: "dv/sv/mem_model"}, + {from: "hw/dv/sv/str_utils", to: "dv/sv/str_utils"}, + {from: "hw/dv/sv/tl_agent", to: "dv/sv/tl_agent"}, + {from: "hw/dv/sv/uart_agent", to: "dv/sv/uart_agent"}, + + // Only the DVSim/Xcelium files the smoke flow uses: the job makefile, configs imported + // by the project sim cfg, the run script with the Tcl it sources (waves for debug), and + // the coverage files referenced by xcelium.hjson and the project sim cfg. + {from: "hw/dv/tools/dvsim/sim.mk", to: "dv/tools/dvsim/sim.mk"}, + {from: "hw/dv/tools/dvsim/common_modes.hjson", to: "dv/tools/dvsim/common_modes.hjson"}, + {from: "hw/dv/tools/dvsim/fusesoc.hjson", to: "dv/tools/dvsim/fusesoc.hjson"}, + {from: "hw/dv/tools/dvsim/xcelium.hjson", to: "dv/tools/dvsim/xcelium.hjson"}, + {from: "hw/dv/tools/sim.tcl", to: "dv/tools/sim.tcl"}, + {from: "hw/dv/tools/common.tcl", to: "dv/tools/common.tcl"}, + {from: "hw/dv/tools/waves.tcl", to: "dv/tools/waves.tcl"}, + {from: "hw/dv/tools/xcelium/cover.ccf", to: "dv/tools/xcelium/cover.ccf"}, + {from: "hw/dv/tools/xcelium/common.ccf", to: "dv/tools/xcelium/common.ccf"}, + {from: "hw/dv/tools/xcelium/unr.cfg", to: "dv/tools/xcelium/unr.cfg"}, + {from: "hw/dv/tools/xcelium/common_cov_excl.tcl", to: "dv/tools/xcelium/common_cov_excl.tcl"}, + {from: "hw/dv/tools/xcelium/cov_merge.tcl", to: "dv/tools/xcelium/cov_merge.tcl"}, + {from: "hw/dv/tools/xcelium/cov_report.tcl", to: "dv/tools/xcelium/cov_report.tcl"}, + // Commit linting scripts {from: "util/lint_commits.py", to: "util/lint_commits.py"}, {from: "ci/scripts/lint-commits.sh", to: "ci/scripts/lint-commits.sh", patch_dir: "ci"}, @@ -38,5 +70,7 @@ "hw/ip/prim/util", "hw/ip/tlul/generic_dv", "hw/ip/uart/dv", + // Self-test bench of the TL agent + "hw/dv/sv/tl_agent/dv", ] } diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/README.md b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/README.md new file mode 100644 index 0000000..5206a3c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/README.md @@ -0,0 +1,14 @@ +# Alert agent + +The alert agent extends from the `dv_lib` agent classes. + +## Description + +This agent implements the alert interface protocol. +For design documentation, please refer to [alert_handler spec](../../../top_earlgrey/ip_autogen/alert_handler/README.md). +The agent can be configured to behave as an alert sender (host mode) or receiver (device mode). + +## Device Agent + +For IPs that send out alerts, it is recommended to attach alert device agents to the block level testbench. +Please refer to [cip_lib documentation](../cip_lib/README.md) regarding instructions to configure alert device agent in DV testbenches. diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent.core b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent.core new file mode 100644 index 0000000..0c5ab78 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent.core @@ -0,0 +1,37 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:alert_agent" +description: "A UVM agent that interacts with the alert interface" + +filesets: + files_dv: + depend: + - lowrisc:prim:all:0.1 + - lowrisc:dv:dv_lib + files: + - alert_if.sv + - alert_agent_pkg.sv + - alert_agent_cfg.sv: {is_include_file: true} + - alert_agent.sv: {is_include_file: true} + - alert_agent_cov.sv: {is_include_file: true} + - alert_base_driver.sv: {is_include_file: true} + - alert_sender_driver.sv: {is_include_file: true} + - alert_receiver_driver.sv: {is_include_file: true} + - alert_monitor.sv: {is_include_file: true} + - alert_seq_item.sv: {is_include_file: true} + - alert_sequencer.sv: {is_include_file: true} + - seq_lib/alert_receiver_base_seq.sv: {is_include_file: true} + - seq_lib/alert_receiver_alert_rsp_seq.sv: {is_include_file: true} + - seq_lib/alert_receiver_ping_seq.sv: {is_include_file: true} + - seq_lib/alert_receiver_seq.sv: {is_include_file: true} + - seq_lib/alert_sender_base_seq.sv: {is_include_file: true} + - seq_lib/alert_sender_ping_rsp_seq.sv: {is_include_file: true} + - seq_lib/alert_sender_seq.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent.sv new file mode 100644 index 0000000..46dea28 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent.sv @@ -0,0 +1,114 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// An agent that represents an alert interface. + +class alert_agent extends dv_reactive_agent #( + .CFG_T (alert_agent_cfg), + .DRIVER_T (alert_base_driver), + .HOST_DRIVER_T (alert_sender_driver), + .DEVICE_DRIVER_T (alert_receiver_driver), + .SEQUENCER_T (alert_sequencer), + .MONITOR_T (alert_monitor), + .COV_T (alert_agent_cov) + ); + + `uvm_component_utils(alert_agent) + + // An output port that reports alert items that have been seen. + uvm_analysis_port #(alert_seq_item) m_alert_port; + + extern function new (string name, uvm_component parent); + extern function void build_phase(uvm_phase phase); + // Create automatic response (from monitor) to ping and alert requests. + extern function void connect_phase(uvm_phase phase); + extern virtual task run_phase(uvm_phase phase); + +endclass : alert_agent + +function alert_agent::new (string name, uvm_component parent); + super.new(name, parent); +endfunction : new + +function void alert_agent::build_phase(uvm_phase phase); + alert_agent_cfg cfg; + if (!uvm_config_db#(CFG_T)::get(this, "", "cfg", cfg)) begin + `uvm_fatal(`gfn, $sformatf("failed to get %s from uvm_config_db", cfg.get_type_name())) + end + + // The reactive agent upon which we build will have a request fifo iff the agent is active. + cfg.has_req_fifo = cfg.is_active; + + super.build_phase(phase); + + m_alert_port = new("m_alert_port", this); + + void'($value$plusargs("bypass_alert_ready_to_end_check=%0b", + cfg.bypass_alert_ready_to_end_check)); + + // get alert_if handle + if (!uvm_config_db#(virtual alert_if)::get(this, "", "vif", cfg.vif)) begin + `uvm_fatal(`gfn, "failed to get alert_if handle from uvm_config_db") + end + + // set variables to alert interface + cfg.vif.is_async = cfg.is_async; + cfg.vif.is_active = cfg.is_active; + cfg.vif.if_mode = cfg.if_mode; + + // set async alert clock frequency + if (cfg.is_async) begin + cfg.vif.clk_rst_async_if.set_active(.drive_rst_n_val(0)); + if (cfg.clk_freq_mhz > 0) begin + int min_freq_mhz = (cfg.clk_freq_mhz / 10) ? (cfg.clk_freq_mhz / 10) : 1; + cfg.vif.clk_rst_async_if.set_freq_mhz($urandom_range(min_freq_mhz, cfg.clk_freq_mhz * 10)); + end else begin + cfg.vif.clk_rst_async_if.set_freq_mhz($urandom_range(10, 240)); + end + end + + // Configure the sequencer to take priorities into account. This allows alert responses to be + // scheduled over ping requests, which come from a sequence that is started with low priority. + if (sequencer != null) sequencer.set_arbitration(UVM_SEQ_ARB_STRICT_FIFO); +endfunction : build_phase + +function void alert_agent::connect_phase(uvm_phase phase); + super.connect_phase(phase); + if (cfg.has_req_fifo) begin + monitor.req_analysis_port.connect(sequencer.req_analysis_fifo.analysis_export); + end + + monitor.m_alert_port.connect(m_alert_port); +endfunction : connect_phase + +task alert_agent::run_phase(uvm_phase phase); + super.run_phase(phase); + if (cfg.is_active && cfg.start_default_rsp_seq) begin + // For host mode, run alert ping auto-response sequence. + if (cfg.if_mode == dv_utils_pkg::Host) begin + alert_sender_ping_rsp_seq m_seq = + alert_sender_ping_rsp_seq::type_id::create("m_seq", this); + uvm_config_db#(uvm_object_wrapper)::set(null, {sequencer.get_full_name(), ".run_phase"}, + "default_sequence", m_seq.get_type()); + sequencer.start_phase_sequence(phase); + end else begin + alert_receiver_alert_rsp_seq response_seq; + alert_receiver_ping_seq ping_seq; + + // For device mode, run an alert auto-response sequence, which will only have a sequence + // item when an alert is generated by the device. + response_seq = alert_receiver_alert_rsp_seq::type_id::create("response_seq", this); + uvm_config_db#(uvm_object_wrapper)::set(null, {sequencer.get_full_name(), ".run_phase"}, + "default_sequence", response_seq.get_type()); + sequencer.start_phase_sequence(phase); + + // Also run an alert ping sequence, which will send back-to-back sequence items that wait a + // while and then request a ping (stopping immediately if a genuine alert has been raised). + // The priority is low so that the response sequence will take precedence. + ping_seq = alert_receiver_ping_seq::type_id::create("ping_seq", this); + `DV_CHECK_FATAL(ping_seq.randomize()) + ping_seq.start(sequencer, .this_priority(1)); + end + end +endtask diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_cfg.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_cfg.sv new file mode 100644 index 0000000..b0950e3 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_cfg.sv @@ -0,0 +1,81 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class alert_agent_cfg extends dv_reactive_agent_cfg; + virtual alert_if vif; + + bit is_async = 0; + bit en_ping_cov = 1; + bit en_lpg_cov = 1; + bit alert_init_done = 0; + bit en_alert_lpg = 0; + + // Enabled via plusarg. + // Please only use this plusarg in top-level test. + // For IP level test, please set `exp_fatal_alert` in post_start() instead. + bit bypass_alert_ready_to_end_check = 0; + + // When this flag is set to 1, and agent in alert host mode, the sequence will automatically + // response to alert ping requests. + bit start_default_rsp_seq = 1; + + // Control if ping response will timeout or not. + bit ping_timeout = 0; + + // Monitor will set this value to 1 when the agent is under ping handshake. + bit under_ping_handshake = 0; + + // Monitor will set this value to 1 when the agent is under ping handshake phase 2. + bit under_ping_handshake_ph_2 = 0; + + // dut clk frequency, used to generate alert async_clk frequency + int clk_freq_mhz; + + // sender mode + int unsigned alert_delay_min = 0; + int unsigned alert_delay_max = 10; + + // receiver mode + int unsigned ack_delay_min = 0; + int unsigned ack_delay_max = 10; + + int unsigned ack_stable_min = 0; + int unsigned ack_stable_max = 10; + + // The minimum and maximum value that alert_receiver_ping_seq will use for ping_delay + // + // To enable a "stress test", which sends lots of back-to-back ping items, these can be made + // small. + int unsigned ping_delay_min = 10000; + int unsigned ping_delay_max = 20000; + + // When this bit is set, alert agent responds to alert without delay + // This is set by plusarg "+fast_rcvr_{alert_name}" + bit fast_rcvr = 0; + + int unsigned ping_timeout_cycle = 32; + + // Incremented by the monitor on each ping + int unsigned ping_count = 0; + // Needed for alert checks starting after a ping + // This flag is updated in the alert_monitor task `monitor_ping` when a ping is detected. + bit active_ping = 0; + + `uvm_object_utils_begin(alert_agent_cfg) + `uvm_field_int(alert_delay_min, UVM_DEFAULT) + `uvm_field_int(alert_delay_max, UVM_DEFAULT) + `uvm_field_int(ack_delay_min, UVM_DEFAULT) + `uvm_field_int(ack_delay_max, UVM_DEFAULT) + `uvm_field_int(ack_stable_min, UVM_DEFAULT) + `uvm_field_int(ack_stable_max, UVM_DEFAULT) + `uvm_field_int(ping_delay_max, UVM_DEFAULT) + `uvm_object_utils_end + + extern function new (string name=""); + +endclass : alert_agent_cfg + +function alert_agent_cfg::new (string name=""); + super.new(name); +endfunction : new diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_cov.sv new file mode 100644 index 0000000..1a7df9f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_cov.sv @@ -0,0 +1,57 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A general covergroup to track completion / alerts in an alert interface. The status input to the +// sample() function should be an alert_handshake_e enum value, but the function takes an int +// unsigned (the encoding of the enum) to avoid needing to parameterise the type. +covergroup handshake_complete_cg (int unsigned complete_status) + with function sample(int unsigned handshake_status); + option.per_instance = 1; + + cp_handshake_complete: coverpoint handshake_status { + bins complete = {complete_status}; + } +endgroup : handshake_complete_cg + +covergroup alert_trans_cg with function sample(alert_trans_type_e trans); + option.per_instance = 1; + + cp_handshake_complete: coverpoint trans { + bins alert_trans = {AlertSigTrans}; + bins ping_trans = {AlertPingTrans}; + } +endgroup : alert_trans_cg + +covergroup alert_lpg_cg with function sample(bit alert_lpg_en); + option.per_instance = 1; + cp_alert_lpg: coverpoint alert_lpg_en; +endgroup + +// If a module contains alert ports, these covergroups can check if all alerts/pings have been +// completed. +class alert_agent_cov extends dv_base_agent_cov #(alert_agent_cfg); + + handshake_complete_cg m_handshake_complete_cg; + alert_trans_cg m_alert_trans_cg; + alert_lpg_cg m_alert_lpg_cg; + + `uvm_component_utils(alert_agent_cov) + + extern function new (string name, uvm_component parent); + extern function void build_phase(uvm_phase phase); + +endclass : alert_agent_cov + +function alert_agent_cov::new (string name, uvm_component parent); + super.new(name, parent); +endfunction : new + +function void alert_agent_cov::build_phase(uvm_phase phase); + super.build_phase(phase); + + if (cfg.en_ping_cov) m_alert_trans_cg = new(); + if (cfg.en_lpg_cov) m_alert_lpg_cg = new(); + + m_handshake_complete_cg = new(AlertAckComplete); +endfunction : build_phase diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_pkg.sv new file mode 100644 index 0000000..8f8fb90 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_agent_pkg.sv @@ -0,0 +1,57 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package alert_agent_pkg; + // dep packages + import uvm_pkg::*; + import dv_base_agent_pkg::*; + import dv_lib_pkg::*; + import dv_utils_pkg::*; + import prim_alert_pkg::*; + + // 2 clock cycles between two alert handshakes, 1 clock cycle to go back to `Idle` state, + // 1 clock cycle for monitor to detect alert, and 1 for synchronizer skip. + parameter uint ALERT_B2B_DELAY = 5; + + typedef class alert_agent_cfg; + + typedef enum { + AlertPingTrans, + AlertSigTrans, + AlertIntFail + } alert_trans_type_e; + + typedef enum { + AlertPingReceived, + AlertReceived, + AlertAckReceived, + AlertComplete, + AlertAckComplete + } alert_handshake_e; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + `include "alert_seq_item.sv" + + `include "alert_agent_cfg.sv" + `include "alert_agent_cov.sv" + `include "alert_base_driver.sv" + `include "alert_sender_driver.sv" + `include "alert_receiver_driver.sv" + `include "alert_sequencer.sv" + `include "alert_monitor.sv" + + // Sequences + `include "seq_lib/alert_receiver_base_seq.sv" + `include "seq_lib/alert_receiver_alert_rsp_seq.sv" + `include "seq_lib/alert_receiver_ping_seq.sv" + `include "seq_lib/alert_receiver_seq.sv" + `include "seq_lib/alert_sender_base_seq.sv" + `include "seq_lib/alert_sender_ping_rsp_seq.sv" + `include "seq_lib/alert_sender_seq.sv" + + `include "alert_agent.sv" +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_base_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_base_driver.sv new file mode 100644 index 0000000..d1148aa --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_base_driver.sv @@ -0,0 +1,48 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Virtual base class used for alert_sender_driver and alert_receiver_driver + +virtual class alert_base_driver extends dv_base_driver#(alert_seq_item, alert_agent_cfg); + // Items that have been taken from seq_item_port and should be sent + protected uvm_tlm_analysis_fifo #(alert_seq_item) m_requests; + + extern function new (string name, uvm_component parent); + + // Take items from the sequencer and drive them. This implements a task from dv_base_driver. + extern virtual task get_and_drive(); + + // Monitor seq_item_port and add the items to the various queues + // + // This is run by get_and_drive. + extern local task get_req(); + + // Drive items that have been added to the various queues by get_req + // + // This should run forever and is started by get_and_drive. + pure virtual task drive_req(); +endclass + +function alert_base_driver::new (string name, uvm_component parent); + super.new(name, parent); + m_requests = new("m_requests", this); +endfunction : new + +task alert_base_driver::get_and_drive(); + fork + get_req(); + drive_req(); + join +endtask + +task alert_base_driver::get_req(); + wait(!cfg.in_reset); + forever begin + alert_seq_item req_clone; + seq_item_port.get(req); + `downcast(req_clone, req.clone()); + req_clone.set_id_info(req); + m_requests.write(req_clone); + end +endtask : get_req diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_if.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_if.sv new file mode 100644 index 0000000..5c29c17 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_if.sv @@ -0,0 +1,170 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +interface alert_if(input clk, input rst_n); + import uvm_pkg::*; + + wire prim_alert_pkg::alert_tx_t alert_tx; + wire prim_alert_pkg::alert_rx_t alert_rx; + + prim_alert_pkg::alert_tx_t alert_tx_sync_dly2; // sync alert_tx 2 clk cycle delay flop + prim_alert_pkg::alert_tx_t alert_tx_sync_dly1; // sync alert_tx 1 clk cycle delay flop + // final alert_tx value depends if on async and host mode + prim_alert_pkg::alert_tx_t alert_tx_final; + + prim_alert_pkg::alert_rx_t alert_rx_sync_dly2; // sync alert_rx 2 clk cycle delay flop + prim_alert_pkg::alert_rx_t alert_rx_sync_dly1; // sync alert_rx 1 clk cycle delay flop + // final alert_rx value depends if on async and device mode + prim_alert_pkg::alert_rx_t alert_rx_final; + + prim_alert_pkg::alert_tx_t alert_tx_int; // internal alert_tx + prim_alert_pkg::alert_rx_t alert_rx_int; // internal alert_rx + + wire async_clk; + bit is_async, is_active; + dv_utils_pkg::if_mode_e if_mode; + clk_rst_if clk_rst_async_if(.clk(async_clk), .rst_n(rst_n)); + + logic ping_pq; + always_ff @(posedge clk or negedge rst_n) begin + ping_pq <= alert_rx.ping_p; + end + + // Code ping_request and alert_active so they will not assert for unknown values. + logic ping_request; + always_comb ping_request = (alert_rx.ping_p ^ ping_pq) === 1'b1; + + logic alert_active; + always_comb alert_active = (alert_tx.alert_p ^ alert_tx.alert_n) === 1'b1 && alert_tx.alert_p; + + logic alert_inactive; + always_comb alert_inactive = (alert_tx.alert_p ^ alert_tx.alert_n) === 1'b1 && alert_tx.alert_n; + + typedef enum logic [1:0] { IdleSt, PingSt, AlertSt } state_e; + state_e state_d, state_q; + // Delaying the state in the same way as the alert_tx/rx signals + state_e state_q_dly1, state_q_final; + always_ff @(posedge clk or negedge rst_n) begin + if (!rst_n) begin + state_q <= IdleSt; + state_q_dly1 <= IdleSt; + state_q_final <= IdleSt; + end else begin + state_q <= state_d; + state_q_dly1 <= state_q; + state_q_final <= state_q_dly1; + end + end + + always_comb begin + state_d = state_q; + unique case (state_q) + IdleSt: if (ping_request) state_d = PingSt; + PingSt: if (alert_active) state_d = AlertSt; + AlertSt: if (alert_inactive) state_d = IdleSt; + default: state_d = IdleSt; + endcase // unique case (state_q) + end + + logic ping_pending; + always_comb ping_pending = state_q_final != IdleSt; + + // if alert sender is async mode, the clock will be driven in alert_agent, + // if it is sync mode, will assign to dut clk here + assign async_clk = (is_async) ? 'z : clk ; + + // async interface for alert_tx has two_clock cycles delay + // ICEBOX(#3275): this is not needed once the CDC module is implemented + always_ff @(posedge clk or negedge rst_n) begin + if (!rst_n) begin + alert_tx_sync_dly2 <= {2'b01}; + alert_tx_sync_dly1 <= {2'b01}; + alert_rx_sync_dly2 <= {4'b0101}; + alert_rx_sync_dly1 <= {4'b0101}; + end else begin + alert_tx_sync_dly2 <= alert_tx_sync_dly1; + alert_tx_sync_dly1 <= alert_tx; + alert_rx_sync_dly2 <= alert_rx_sync_dly1; + alert_rx_sync_dly1 <= alert_rx; + end + end + + // Used by the monitor for "symmetrical" sampling with equal delay from both sides + // This ensures correct sampling. Otherwise there can be race conditions where the monitor misses + // a ping due to a delay. + assign alert_tx_final = alert_tx_sync_dly2; + assign alert_rx_final = alert_rx_sync_dly2; + + clocking sender_cb @(posedge async_clk); + output alert_tx_int; + input alert_rx; + endclocking + + clocking receiver_cb @(posedge async_clk); + input alert_tx; + output alert_rx_int; + endclocking + + clocking monitor_cb @(posedge clk); + input alert_tx_final; + input alert_rx_final; + endclocking + + assign alert_tx = (if_mode == dv_utils_pkg::Host && is_active) ? alert_tx_int : 'z; + assign alert_rx = (if_mode == dv_utils_pkg::Device && is_active) ? alert_rx_int : 'z; + + task automatic wait_ack_complete(); + while (alert_tx_final.alert_p === 1'b1) @(monitor_cb); + while (alert_rx_final.ack_p === 1'b1) @(monitor_cb); + endtask : wait_ack_complete + + function automatic bit get_alert(); + if (alert_tx_final.alert_p === 1'b1 && ping_pending) begin + `uvm_info($sformatf("%m"), + $sformatf("This alert is a ping response: alert_p:%b, alert_n:%b, ping_pending:%p", + alert_tx_final.alert_p, alert_tx_final.alert_n, ping_pending), UVM_MEDIUM) + end + get_alert = (alert_tx_final.alert_p === 1'b1 && alert_tx_final.alert_n === 1'b0 && + ! ping_pending); + endfunction : get_alert + + bit is_alert_handshaking; + assign is_alert_handshaking = alert_tx_final.alert_p === 1'b1 || alert_rx_final.ack_p === 1'b1; + + // this task wait for alert_ping request. + // alert_ping request is detected by level triggered "alert_rx.ping_p/n" signals pairs + // and no sig_int_err + task automatic wait_alert_ping(); + do begin + logic ping_p; + wait(rst_n === 1'b1); + ping_p = alert_rx_final.ping_p; + wait(alert_rx_final.ping_p !== ping_p && alert_rx_final.ping_p === !alert_rx_final.ping_n); + end while (rst_n != 1'b1); + endtask : wait_alert_ping + + // Set the alert pins to the requested value (either 1;0 or 0;1) when the interface is active and + // configured to act as the alert sender. + // + // This uses a clocking drive to update the version of the signal in sender_cb (causing the update + // to have a lasting effect, and also to be synchronised with the next clock edge). + task automatic force_alert(bit alert_p, bit alert_n); + sender_cb.alert_tx_int.alert_p <= alert_p; + sender_cb.alert_tx_int.alert_n <= alert_n; + endtask + + // Return true if the current state is PingSt + // + // This rather trivial function is needed because we want to use the interface through a virtual + // interface handle, so cannot refer to PingSt or state_q because they are both defined in terms + // of an enum defined inside the interface. + function automatic logic in_ping_st(); + return state_q == PingSt; + endfunction + + // Check the differential alert signals have no unknown values. + `ASSERT_KNOWN(PingKnown_A, alert_rx.ping_p ^ alert_rx.ping_n, clk, !rst_n) + `ASSERT_KNOWN(AckKnown_A, alert_rx.ack_p ^ alert_rx.ack_n, clk, !rst_n) + `ASSERT_KNOWN(AlertKnown_A, alert_tx.alert_p ^ alert_tx.alert_n, clk, !rst_n) +endinterface: alert_if diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_monitor.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_monitor.sv new file mode 100644 index 0000000..fb3dddc --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_monitor.sv @@ -0,0 +1,533 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// + +// --------------------------------------------- +// Alert sender receiver interface monitor +// --------------------------------------------- + +class alert_monitor extends dv_reactive_monitor #( + .ITEM_T(alert_seq_item), + .CFG_T (alert_agent_cfg), + .COV_T (alert_agent_cov) +); + + `uvm_component_utils(alert_monitor) + + // An output port that reports alert items that have been seen. + uvm_analysis_port #(alert_seq_item) m_alert_port; + + // Flags used to know when there are pings/alerts + // This flag is updated in the task `monitor_alert` when an alert is detected. + bit active_alert = 1'b0; + + extern function new (string name, uvm_component parent); + extern function void build_phase(uvm_phase phase); + extern task run_phase(uvm_phase phase); + + // Track the rst_n signal in the interface and maintain cfg.in_reset + extern task track_resets(); + + // A task from dv_base_monitor, which sets ok_to_end to false unless {alert_p, alert_n} is {0, 1} + // (or the check is bypassed). + extern task monitor_ready_to_end(); + + // This function is run (by run_phase) when a reset is seen. It is responsible for clearing + // monitor state. + extern local function void on_reset(); + + // This task is run (by run_phase) when a reset ends. It waits for initialisation to complete, + // then watches for pings and alerts. This task will run forever but is safe to kill (so run_phase + // can do so when it sees a reset). + extern local task run_between_resets(); + + // Watch the ping signal that starts a ping transaction. When a ping is visible, report it on + // req_analysis_port. This is run by run_between_resets (so will not run when under reset) but, + // unlike monitor_alerts and monitor_ping, doesn't need to wait for the alert_p/alert_n interface + // to be initialised. + extern local task report_ping_requests(); + + // Monitor alert_p/alert_n and set active_alert if an alert is observed (a valid alert signal that + // doesn't coincide with an existing ping handshake). + extern local task monitor_alerts(); + + // Watch for "ping transactions", and set cfg.active_ping if one starts. This task ignores resets, + // but is safe to kill. + // + // A ping transaction is caused by ping_p changing value. To allow us to see a change in value + // happening on *this* cycle, initial_ping_p should be used as "the value ping_p just had". + extern local task monitor_ping(bit initial_ping_p); + + // Block until alert initialisation happens. When alert initialisation is complete, set + // cfg.alert_init_done. + // + // Alert initialisation is normally tracked by the p/n signals becoming equal and then different + // again. As a special case, we also consider alert initialisation to have happened when + // en_alert_lpg is high. In this case, alert_sender can still send alerts, and alert_handler + // should ignore the alert_tx request. + // + // This task completely ignores resets (we expect it to be killed by run_phase if one happens when + // it is running). + extern local task wait_alert_init_done(); + + // Watch a ping transaction. In the normal case (the low power group is not enabled), the alert + // receiver will receive an alert and ack it. This is tracked with monitor_ping_handshake. + // + // If the low power group is enabled, the alert sender will not respond to the ping, but the + // receiver should still ack the (nonexistent) alert. + extern local task ping_thread(); + + // Watch the internals of a ping -> alert transaction and report it through m_alert_port. Note + // that this is only called when cfg.en_alert_lpg is false (because otherwise the ping should be + // ignored). + // + // Unlike ping_thread (which calls this task), monitor_ping_handshake doesn't wait for the ack. + // + // This task ignores cfg.en_alert_lpg and cfg.in_reset: if either become true, this task will be + // killed by something further up the stack. + extern local task monitor_ping_handshake(); + + // This thread is spawned after an alert is detected if no ping is in the middle of a handshake. + extern virtual task alert_thread(); + + // Watch the core of an alert transaction (which is expected if cfg.en_alert_lpg is false). Write + // sequence items reporting that the alert has started (which is why this task was called) then, + // when the ack is complete, write a sequence item describing the transaction. + extern local task monitor_alert_handshake(); + + // Watch for signal integrity errors (alert_p == alert_n), reporting them to m_alert_port. If + // cfg.is_async, allow a single cycle of integrity error without a report, to allow for clock + // skew. + extern local task int_fail_thread(); + + // Wait for the alert_p signal to be cleared + extern local task wait_alert_complete(); + + // Wait for the ack_p signal to be asserted + extern local task wait_ack(); + + // Wait for the ack_p signal to be cleared + extern local task wait_ack_complete(); + + // Return true if alert_p and alert_n are equal + extern local function bit is_sig_int_err(); + + // Return true if {alert_p, alert_n} are {1, 0}. + extern local function bit is_valid_alert(); + + // Wait for count cycles of the slower of the two clocks (clk and async_clk) by waiting for both + // of them in parallel. + extern local task wait_slow_clocks(int unsigned count); + +endclass : alert_monitor + +function alert_monitor::new (string name, uvm_component parent); + super.new(name, parent); +endfunction : new + +function void alert_monitor::build_phase(uvm_phase phase); + super.build_phase(phase); + m_alert_port = new("m_alert_port", this); +endfunction + +task alert_monitor::run_phase(uvm_phase phase); + // Run the base class run_phase task in parallel + fork + super.run_phase(phase); + track_resets(); + forever begin + wait (!cfg.in_reset); + fork begin : isolation_fork + fork + run_between_resets(); + wait (cfg.in_reset); + join_any + disable fork; + on_reset(); + end join + end + join +endtask + +task alert_monitor::track_resets(); + // Make sure that in_reset is correct at the start of the phase, then check that we are + // genuinely in reset by the start of the loop. + cfg.in_reset = (cfg.vif.rst_n !== 1'b1); + wait(!cfg.vif.rst_n); + + forever begin + cfg.in_reset = 1; + wait (cfg.vif.rst_n); + + // reset signals at posedge rst_n to avoid race condition at negedge rst_n + cfg.under_ping_handshake = 0; + cfg.in_reset = 0; + + wait (!cfg.vif.rst_n); + end +endtask + +task alert_monitor::monitor_ready_to_end(); + if (!cfg.bypass_alert_ready_to_end_check) begin + forever begin + @(cfg.vif.monitor_cb.alert_tx_final.alert_p); + ok_to_end = ({cfg.vif.monitor_cb.alert_tx_final.alert_p, + cfg.vif.monitor_cb.alert_tx_final.alert_n} == 2'b01); + end + end +endtask : monitor_ready_to_end + +function void alert_monitor::on_reset(); + active_alert = 1'b0; + cfg.active_ping = 1'b0; + cfg.alert_init_done = 0; + cfg.under_ping_handshake = 0; + cfg.under_ping_handshake_ph_2 = 0; +endfunction + +task alert_monitor::run_between_resets(); + // We've just come out of reset. The alert_p/alert_n lines will start with an initialisation + // handshake. Take a note of the current value of ping_p though: if it changes while we're + // initialising, we still want to remember there was an edge. + logic old_ping_p = cfg.vif.monitor_cb.alert_rx_final.ping_p; + + // There are two top-level tasks running. + // + // - report_ping_requests is responsible for noticing ping requests and writing them to + // req_analysis_port (for responses from sequences or analysis from the scoreboard). + // + // - Everything else depends on the alert_p/alert_n lines to be initialised (so we run that + // first). Once that has run, the other monitor tasks are in charge of watching ping_p and + // alert_p and interpreting whether transactions are pings with responses or genuine alerts. + fork + report_ping_requests(); + begin + // Wait for the initialisation protocol to set up the alert_p/alert_n lines. + wait_alert_init_done(); + + // Now we get to the "main part of the task". Track alerts and pings (telling + // alert_and_ping_thread the initial state of ping_p so that we don't miss any ping that + // happened before the alert_p/alert_n initialisation had happened). + fork + // Detect and report signal integrity errors (alert_p == alert_n) + int_fail_thread(); + + // The two monitor_* tasks keep track of the start of a alert/ping, with active_alert and + // cfg.active_ping. These tasks only ever *set* the relevant flag, which will be cleared by + // the assocated *_thread task below. + monitor_alerts(); + monitor_ping(old_ping_p); + + // Handle the "next" alert or ping request. + begin : thread_arbiter + bit first_time = 1; + forever begin + // Wait for one of these flags to change, but don't necessarily wait the on the first + // iteration: they get set by monitor_alerts and monitor_ping and the relevant task + // might have been scheduled before our first run. + if (!first_time) @({active_alert, + cfg.active_ping, + cfg.under_ping_handshake || cfg.under_ping_handshake_ph_2}); + first_time = 0; + + if (active_alert) begin + if (! (cfg.under_ping_handshake || cfg.under_ping_handshake_ph_2)) begin + alert_thread(); + end + end else if (cfg.active_ping) begin + ping_thread(); + end + end + end : thread_arbiter + join + end + join +endtask + +task alert_monitor::monitor_alerts(); + logic ping_p; + + forever @(cfg.vif.monitor_cb) begin + if (cfg.active_ping) begin + // If we're in a ping, wait until it is done + wait (!cfg.active_ping); + end else begin + // Look for an alert request. We might be in some other part of the ping handshake. If that is + // the case, don't act on the seeming alert request yet (but we'll be able to register it on + // the next cycle). + if (is_valid_alert() && !(cfg.under_ping_handshake || + ping_p != cfg.vif.monitor_cb.alert_rx_final.ping_p)) begin + active_alert = 1; + end + end + // We've just done a "loop iteration". Before waiting for the next clock cycle, register the + // current value of ping_p (allowing us to detect edges) + ping_p = cfg.vif.monitor_cb.alert_rx_final.ping_p; + end +endtask : monitor_alerts + +task alert_monitor::monitor_ping(bit initial_ping_p); + bit old_ping_p = initial_ping_p; + + if (cfg.active_ping) `uvm_fatal(`gfn, "Cannot start monitor_ping when cfg.active_ping is set.") + + forever begin + // Wait until a ping request is sent. Note that this includes a check that active_ping is false: + // theoretically, there is nothing stopping the receiver from sending a second ping request that + // overlaps with the end of the first (because the receiver can send one immediately after + // dropping its ack signal). + wait (cfg.vif.monitor_cb.alert_rx_final.ping_p != old_ping_p && !cfg.active_ping); + + // The ping_p signal has changed value, which means that the receiver is sending a ping. If + // there is an alert in flight at the moment, wait until that finishes. (The ping request should + // be delayed, but will not be forgotten) + wait (active_alert==0); + + // At this point a ping transaction is starting. Record that by setting active_ping, which will + // be cleared on reset or at the end of the ping_thread task (the task that actually responds to + // the ping). + `uvm_info(`gfn, $sformatf("%m - Ping detected: setting 'active_ping'"), UVM_DEBUG) + cfg.active_ping = 1; + + old_ping_p = cfg.vif.monitor_cb.alert_rx_final.ping_p; + end +endtask : monitor_ping + +task alert_monitor::report_ping_requests(); + forever begin + wait(!cfg.en_alert_lpg); + fork begin : isolation_fork + fork + wait(cfg.en_alert_lpg); + begin + logic last_ping = cfg.vif.monitor_cb.alert_rx_final.ping_p; + forever @(cfg.vif.monitor_cb) begin + if (cfg.vif.monitor_cb.alert_rx_final.ping_p != last_ping) begin + alert_seq_item req = alert_seq_item::type_id::create("req"); + req.m_trans_type = AlertPingTrans; + req_analysis_port.write(req); + end + last_ping = cfg.vif.monitor_cb.alert_rx_final.ping_p; + end + end + join_any + disable fork; + end join + end +endtask + +task alert_monitor::wait_alert_init_done(); + fork begin : isolation_fork + fork + wait (cfg.en_alert_lpg); + begin + wait (cfg.vif.monitor_cb.alert_tx_final.alert_p == + cfg.vif.monitor_cb.alert_tx_final.alert_n); + wait (cfg.vif.monitor_cb.alert_tx_final.alert_p != + cfg.vif.monitor_cb.alert_tx_final.alert_n); + @(cfg.vif.monitor_cb); + `uvm_info($sformatf("%m"), "Alert init done.", UVM_HIGH) + end + join_any + disable fork; + end join + + cfg.alert_init_done = 1; +endtask : wait_alert_init_done + +task alert_monitor::ping_thread(); + // If the lower power group (lpg) is disabled, we expect an alert sender to respond to the ping. + // Watch it happen, dropping out (and killing monitor_ping_handshake) if lpg becomes enabled. + if (!cfg.en_alert_lpg) begin + fork begin : isolation_fork + fork + wait(cfg.en_alert_lpg); + monitor_ping_handshake(); + join_any + disable fork; + end join + end + wait_ack_complete(); + `uvm_info(`gfn, "ACK for ping received", UVM_DEBUG) + cfg.under_ping_handshake_ph_2 = 0; + + cfg.active_ping = 0; +endtask : ping_thread + +task alert_monitor::monitor_ping_handshake(); + alert_seq_item req = alert_seq_item::type_id::create("req"); + + // If alert_p is currently asserted, that must be the tail of a different alert. Wait for it to + // clear. + if (cfg.vif.monitor_cb.alert_tx_final.alert_p) wait_alert_complete(); + wait (active_alert==0); + + // Register the fact that we're in a ping handshake, and increment the count of pings that we have + // seen. + `uvm_info(`gfn, $sformatf("%m: Sampling ping - item will be sent after ACK"), UVM_DEBUG) + cfg.under_ping_handshake = 1; + cfg.ping_count++; + + req.m_trans_type = AlertPingTrans; + + // Track the ping transaction: the sender should respond by setting alert_p, which should then get + // acked by the receiver. + fork begin : isolation_fork + fork + begin : wait_ping_timeout + // If there is an alert handler in the design, the ping timeout is configured through a + // PING_TIMEOUT_CYC register, which the sequence configures to match cfg.ping_timeout_cycle. + // This monitor configures itself to match, waiting that long before concluding that a ping + // request has timed out. + // + // To get the timing to exactly match the alert handler, we have to be a little careful + // about flops and clocking blocks. The change to the ping output from the alert handler + // takes 3 cycles to be reflected in alert_rx_final, then one final cycle to appear through + // monitor_cb (which just triggered us). The change to the crashdump state only takes 2 + // cycles to propagate to an output. To match the timing, subtract two from the timeout. + if (cfg.ping_timeout_cycle > 2) begin + wait_slow_clocks(cfg.ping_timeout_cycle - 2); + end + req.m_ping_timeout = 1'b1; + end + begin : wait_ping_handshake + wait(cfg.vif.monitor_cb.alert_tx_final.alert_p); + req.m_alert_handshake_sta = AlertReceived; + wait_ack(); + req.m_alert_handshake_sta = AlertAckReceived; + cfg.under_ping_handshake = 0; + cfg.under_ping_handshake_ph_2 = 1; + end + join_any + disable fork; + end join + + `uvm_info(`gfn, $sformatf("%m - Sending req: \n%0s",req.sprint), UVM_DEBUG) + m_alert_port.write(req); + + if (cfg.en_cov && cfg.en_ping_cov) cov.m_alert_trans_cg.sample(req.m_trans_type); + + // It's possible that the alert_p signal went high quickly, but the ack was slow (in which case + // we'll see a ping timeout with m_alert_handshake_sta == AlertReceived). + // + // This might cause a spurious alert error. For details see the discussion on Issue #2321. + if (req.m_ping_timeout && req.m_alert_handshake_sta == AlertReceived) begin + @(cfg.vif.monitor_cb); + if (cfg.vif.monitor_cb.alert_rx_final.ack_p == 1'b1) begin + `uvm_info(`gfn, $sformatf("%m - Sending req: \n%0s",req.sprint), UVM_DEBUG) + m_alert_port.write(req); + end + end + + cfg.under_ping_handshake = 0; +endtask : monitor_ping_handshake + +task alert_monitor::alert_thread(); + if (cfg.en_lpg_cov && cfg.en_cov) begin + cov.m_alert_lpg_cg.sample(cfg.en_alert_lpg); + end + if (!cfg.en_alert_lpg) begin + fork begin : isolation_fork + fork + wait(cfg.en_alert_lpg); + monitor_alert_handshake(); + join_any + disable fork; + end join + end +endtask : alert_thread + +task alert_monitor::monitor_alert_handshake(); + alert_seq_item req = alert_seq_item::type_id::create("req"); + + req.m_trans_type = AlertSigTrans; + req.m_alert_handshake_sta = AlertReceived; + `uvm_info(`gfn, $sformatf("%m - Sending req on 'm_alert_port': \n%0s",req.sprint), + UVM_DEBUG) + // Write alert packet to scb when receiving alert signal + m_alert_port.write(req); + // Write alert packet to sequence for auto alert responses. + `uvm_info(`gfn, $sformatf("%m - Sending req on 'req_analysis_port': \n%0s",req.sprint), + UVM_DEBUG) + req_analysis_port.write(req); + + // Duplicate req for writing alert packet at the end of alert handshake + `downcast(req, req.clone()) + + req.m_alert_handshake_sta = AlertAckReceived; + wait_alert_complete(); + req.m_alert_handshake_sta = AlertComplete; + wait_ack_complete(); + req.m_alert_handshake_sta = AlertAckComplete; + + active_alert = 0; + + `uvm_info(`gfn, $sformatf("[%s]: handshake status is %s", req.m_trans_type.name(), + req.m_alert_handshake_sta.name()), UVM_HIGH) + `uvm_info(`gfn, $sformatf("%m - Sending req on 'm_alert_port': \n%0s",req.sprint), + UVM_DEBUG) + m_alert_port.write(req); + + if (cfg.en_cov) begin + cov.m_handshake_complete_cg.sample(req.m_alert_handshake_sta); + if (cfg.en_ping_cov) cov.m_alert_trans_cg.sample(req.m_trans_type); + end +endtask + +task alert_monitor::int_fail_thread(); + int unsigned skew_grace_time = cfg.is_async ? 1 : 0; + int unsigned failure_len = 0; + + forever begin + wait(!cfg.en_alert_lpg); + fork begin : isolation_fork + fork + wait(cfg.en_alert_lpg); + forever @(cfg.vif.monitor_cb) begin + if (is_sig_int_err()) begin + failure_len += 1; + if (failure_len > skew_grace_time) begin + alert_seq_item req = alert_seq_item::type_id::create("req"); + req.m_trans_type = AlertIntFail; + `uvm_info(`gfn, + $sformatf("%m - Sending req on 'm_alert_port': \n%0s", req.sprint), + UVM_DEBUG) + m_alert_port.write(req); + end + end else begin + failure_len = 0; + end + end + join_any + disable fork; + end join + end +endtask : int_fail_thread + +task alert_monitor::wait_alert_complete(); + wait (!cfg.vif.monitor_cb.alert_tx_final.alert_p); +endtask : wait_alert_complete + +task alert_monitor::wait_ack(); + wait (cfg.vif.monitor_cb.alert_rx_final.ack_p); +endtask : wait_ack + +task alert_monitor::wait_ack_complete(); + wait (!cfg.vif.monitor_cb.alert_rx_final.ack_p); +endtask : wait_ack_complete + +function bit alert_monitor::is_sig_int_err(); + return cfg.vif.monitor_cb.alert_tx_final.alert_p === cfg.vif.monitor_cb.alert_tx_final.alert_n; +endfunction : is_sig_int_err + +function bit alert_monitor::is_valid_alert(); + return cfg.vif.monitor_cb.alert_tx_final.alert_p && !cfg.vif.monitor_cb.alert_tx_final.alert_n; +endfunction : is_valid_alert + +task alert_monitor::wait_slow_clocks(int unsigned count); + fork + repeat (count) @(cfg.vif.monitor_cb); + repeat (count) @(cfg.vif.receiver_cb); + join +endtask diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_receiver_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_receiver_driver.sv new file mode 100644 index 0000000..d68beb7 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_receiver_driver.sv @@ -0,0 +1,466 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A driver that behaves as an alert_receiver. This is used in an alert_agent when configured in +// "device mode" + +class alert_receiver_driver extends alert_base_driver; + `uvm_component_utils(alert_receiver_driver) + + // The drive_req_between_resets task will consume requests from m_requests and add these requests + // to this pair of FIFOs (to be consumed by the send_pings and send_alert_rsps tasks that it + // spawns). + // + // When reset is asserted, both of those tasks will exit after flushing their respective queues. + local uvm_tlm_analysis_fifo #(alert_seq_item) m_pending_pings; + local uvm_tlm_analysis_fifo #(alert_seq_item) m_pending_alert_rsps; + + // When a ping gets an alert response or a genuine alert is sent, this driver needs to acknowledge + // the alert, but the two options need to be handled serially. The ack is handled by ack_alert, + // which uses this semaphore as a mutex. + local semaphore m_ack_semaphore; + + extern function new(string name, uvm_component parent); + + // Clear interface signals because reset has been asserted + // + // This implements a task in dv_base_driver + extern task on_enter_reset(); + + // Drive requests that have been seen by alert_base_driver::get_req. This task runs forever. + // + // This implements a task in alert_base_driver + extern task drive_req(); + + // Take items from m_requests and (depending on the type of the item) add them to m_pending_pings + // and m_pending_alert_rsps. + // + // Exits immediately on reset. + extern local task consume_requests_betwen_resets(); + + // Drive requests that have been seen by alert_base_driver::get_req, until the next reset. This is + // called by drive_req. + extern local task drive_req_between_resets(); + + // Drive any items that were added to m_pending_pings. + // + // Exits early on reset. + extern local task send_pings(); + + // Drive any items that were added to m_pending_alert_rsps. + // + // Exits early on reset. + extern local task send_alert_rsps(); + + // Send a ping described by item. + // + // This will start by waiting ping_delay cycles before sending the ping request. Once the ping has + // gone out, we wait for an alert to arrive and then acknowledge it using ack_alert (and + // passing ack_delay and ack_stable). + // + // The task allows to retract driving the ping. If there's an alert (r_alert_rsp_q.size > 0) + // before the ping delay, the ping is aborted and the driver moves to tackle the alert in + // 'rsp_alert' task. This is notified by setting `item_not_driven=1` + // + // The task exits early on reset. + extern local task send_ping(alert_seq_item item); + + // Handle a sequence item that demands an alert response + // + // An item should only be added to that queue in response to an alert being generated on the + // interface. We will wait a randomised time (in ack_alert) before acknowledging the alert. + // + // Exits early on reset. + extern local task send_alert_rsp(alert_seq_item item); + + // Wait for a short time to allow an alert to propagate through the clocking blocks in the + // interface. The max_cycles argument is the maximum number of cycles to wait. + // + // The task will stop as soon as any of these events happens: + // + // - The alert_p signal goes high in receiver_cb. + // - There have been max_cycles edges of both clocks. + // - A reset is asserted. + extern local task wait_for_alert_propagation(int unsigned max_cycles); + + // Acknowledge the next alert + // + // This task waits until an alert is signalled, then waits a short time before acknowledging the + // alert. Once the ack has been asserted, the ack stays high for a time before it, in turn, drops. + // + // This task uses m_ack_semaphore as a mutex (to serialise ping response acks and other alert + // acks). + // + // The delay before the initial ack is from the ack_delay argument. The ack then stays stable for + // the number of cycles in the ack_stable argument. + // + // Both of these times will be truncated if cfg.fast_rcvr is true. In that case, they will be + // cfg.ack_delay_min, cfg.ack_stable_min respectively. + // + // The task will exit quickly on reset (replacing the token on the semaphore) + extern local task ack_alert(int unsigned ack_delay, int unsigned ack_stable); + + // Set the ack signal to be the given boolean value (so either 0;1 or 1;0) + extern local task set_ack(bit asserted); + + // Toggle the ping state + extern local task set_ping(); + + // Set the ping state to 0;1 (the reset value) + extern task reset_ping(); + + // Perform the alert init handshake, exiting early on reset + extern task do_alert_rx_init(); + + // Wait for num_cycles positive edges of the slower of the two clocks + // + // Return early on reset. + extern task wait_slower_clock(int unsigned num_cycles); +endclass : alert_receiver_driver + +function alert_receiver_driver::new(string name, uvm_component parent); + super.new(name, parent); + m_ack_semaphore = new(1); + m_pending_pings = new("m_pending_pings", this); + m_pending_alert_rsps = new("m_pending_alert_rsps", this); +endfunction + +task alert_receiver_driver::on_enter_reset(); + // Clear ping and ack signals (both the actual signals and the clocking block values) + cfg.vif.alert_rx_int.ping_p <= 1'b0; + cfg.vif.alert_rx_int.ping_n <= 1'b1; + cfg.vif.alert_rx_int.ack_p <= 1'b0; + cfg.vif.alert_rx_int.ack_n <= 1'b1; + cfg.vif.receiver_cb.alert_rx_int.ping_p <= 1'b0; + cfg.vif.receiver_cb.alert_rx_int.ping_n <= 1'b1; + cfg.vif.receiver_cb.alert_rx_int.ack_p <= 1'b0; + cfg.vif.receiver_cb.alert_rx_int.ack_n <= 1'b1; +endtask + +task alert_receiver_driver::drive_req(); + forever begin + // Wait until we are out of reset. Until that happens, respond instantly to any sequence items + // that come in. + while (cfg.in_reset) begin + alert_seq_item item; + fork : isolation_fork begin + fork + wait (!cfg.in_reset); + m_requests.get(item); + join_any + disable fork; + end join + if (item != null) seq_item_port.put_response(item); + end + + drive_req_between_resets(); + end +endtask + +task alert_receiver_driver::consume_requests_betwen_resets(); + fork : isolation_fork begin + fork + wait (cfg.in_reset); + forever begin + alert_seq_item item; + m_requests.get(item); + + case (item.m_trans_type) + AlertSigTrans: m_pending_alert_rsps.write(item); + AlertPingTrans: m_pending_pings.write(item); + default: `uvm_fatal(get_full_name(), "Unknown transaction type") + endcase + end + join_any + disable fork; + end join +endtask + +task alert_receiver_driver::drive_req_between_resets(); + // Drive the init protocol from the receiver side. do_alert_rx_init will exit early if it sees + // reset. + do_alert_rx_init(); + if (cfg.in_reset) return; + + // Fetch items to drive and drive them. The first task takes items from the m_requests fifo and + // uses them to populate m_pending_pings and m_pending_alert_rsps. The second two tasks take (and + // drive) items from those two fifos. + // + // All three tasks exit on reset. + fork + consume_requests_betwen_resets(); + send_alert_rsps(); + send_pings(); + join + + // As a consistency check, make sure that m_pending_pings and m_pending_alert_rsps were cleared by + // send_alert_rsps and send_pings before they exited. + if (m_pending_pings.size()) + `uvm_error(get_full_name(), + $sformatf("m_pending_pings nonempty after reset: %0p", m_pending_pings)) + if (m_pending_alert_rsps.size()) + `uvm_error(get_full_name(), + $sformatf("m_pending_alert_rsps nonempty after reset: %0p", m_pending_alert_rsps)) +endtask + +task alert_receiver_driver::send_pings(); + alert_seq_item item; + + while(!cfg.in_reset) begin + // Clear the item variable (so that we can tell whether the fork below gets an item or sees a + // reset) + item = null; + + fork : isolation_fork begin + fork + wait (cfg.in_reset); + m_pending_pings.get(item); + join_any + disable fork; + end join + + // If there is an item, send it with send_ping. The task will exit early on reset. + if (item != null) begin + send_ping(item); + + // Now that the item has been sent, report this to the sequencer + seq_item_port.put_response(item); + end + end + + // When we get here, we must be in reset. m_pending_pings might be nonempty (if reset was asserted + // when there were lots of pending pings). Report all the items done (in a trivial way) before + // returning. + while(m_pending_pings.try_get(item)) seq_item_port.put_response(item); +endtask + +task alert_receiver_driver::send_alert_rsps(); + alert_seq_item item; + + while (!cfg.in_reset) begin + // Clear the item variable (so that we can tell whether the fork below gets an item or sees a + // reset) + item = null; + + fork : isolation_fork begin + fork + wait (cfg.in_reset); + m_pending_alert_rsps.get(item); + join_any + disable fork; + end join + + // If there is an item, send it with send_alert_rsp. The task will exit early on reset. + if (item != null) begin + send_alert_rsp(item); + + // Now that the item has been sent, report this to the sequencer + seq_item_port.put_response(item); + end + end + + // When we get here, we must be in reset. m_pending_alert_rsps might be nonempty. (This probably + // shouldn't actually be possible, but let's not worry too much about it). Report all the items + // done (in a trivial way) before returning. + while(m_pending_alert_rsps.try_get(item)) seq_item_port.put_response(item); +endtask + +task alert_receiver_driver::send_ping(alert_seq_item item); + `uvm_info(get_full_name(), "Sending ping", UVM_HIGH) + + if (item.m_int_err_cyc) begin + `uvm_fatal(get_full_name(), "Cannot send ping with m_int_err_cyc > 0: not supported by driver.") + end + + // Wait for item.m_ping_delay cycles (which might be quite a while) before sending the ping. There + // may be other alerts happening in the meantime, but this task doesn't need to worry about them. + // Exit early on reset + fork : isolation_fork begin + fork + wait(cfg.in_reset); + begin + repeat (item.m_ping_delay) @(cfg.vif.receiver_cb); + set_ping(); + end + join_any + disable fork; + end join + if (cfg.in_reset) return; + + // After waiting (possibly for a long time), we finally sent a ping. The alert sender should + // respond with an alert, which we ack here, treating it as the ping response. + // + // If the sender decided to send an alert at the same time as we sent the ping then we'll treat + // that alert as a ping response. But the sender will then respond to the ping with an alert that + // we'll treat as a genuine alert: the end result will be that we and the sender agree on the set + // of things that happened (one ping response and one genuine alert). + ack_alert(item.m_ack_delay, item.m_ack_stable); + + // Before responding to the item, we need to wait for the sender to complete its FSM (so that we + // don't send another ping when it's still sitting in PingHsPhase2, Pause0 or Pause1). The ack + // that we just sent has to be decoded by a prim_diff_decode (u_decode_ack), which will take at + // most 3 posedges of the sender's clock, then we take two more cycles (one in each of Pause0 and + // Pause1), for a total of 5 cycles. + // + // Wait with the slower of vif.clk and vif.async_clk. + wait_slower_clock(5); +endtask + +task alert_receiver_driver::send_alert_rsp(alert_seq_item item); + `uvm_info(get_full_name(), "Responding to alert", UVM_HIGH) + + // If we get here then something should have been pushed onto the alert queue in response to + // an alert being generated. Wait a short time to allow the alert to propagate through the + // clocking blocks (which should only take a cycle, but give it a couple more to make sure). + // The count of 7 cycles was chosen as an upper bound: an alert should be visible in at most that + // time. + // + // Either way, we stop as soon as the alert propagates through, or if we see a reset. + wait_for_alert_propagation(7); + if (cfg.in_reset) return; + + // Check that the alert really has arrived (which is a consistency check for the testbench, rather + // than a check about the dut). + if (cfg.vif.receiver_cb.alert_tx.alert_p !== 1'b1) begin + `uvm_fatal(get_full_name(), "alert_p not high, despite an item from the monitor") + end + + // Now send an ack with ack_alert. This then waits for the alert to drop, then clears the ack + // again. + // + // The task exits early on reset. + ack_alert(item.m_ack_delay, item.m_ack_stable); +endtask + +task alert_receiver_driver::wait_for_alert_propagation(int unsigned max_cycles); + fork : isolation_fork begin + fork + wait (cfg.in_reset); + fork : isolation_fork begin + bit seen_alert; + + fork + repeat (max_cycles) begin + if (cfg.vif.receiver_cb.alert_tx.alert_p) begin + seen_alert = 1; + end + if (seen_alert) break; + @(cfg.vif.receiver_cb); + end + repeat (max_cycles) begin + if (cfg.vif.monitor_cb.alert_tx_final.alert_p) begin + seen_alert = 1; + end + if (seen_alert) break; + @(cfg.vif.monitor_cb); + end + join + end join + join_any + disable fork; + end join +endtask + +task alert_receiver_driver::ack_alert(int unsigned ack_delay, int unsigned ack_stable); + if (cfg.fast_rcvr) begin + ack_delay = cfg.ack_delay_min; + ack_stable = cfg.ack_stable_min; + end + + m_ack_semaphore.get(); + + // Wait for the alert to appear (but stop early if a reset is asserted) + fork : isolation_fork1 begin + fork + wait(cfg.in_reset); + wait(cfg.vif.receiver_cb.alert_tx.alert_p); + join_any + disable fork; + end join + + // If there has been a reset, there is nothing more to do. + if (cfg.in_reset) begin + m_ack_semaphore.put(); + return; + end + + // Now wait a short time and set the ack (dropping out early on reset) + fork : isolation_fork2 begin + fork + wait(cfg.in_reset); + begin + repeat (ack_delay + 1) @(cfg.vif.receiver_cb); + set_ack(1'b1); + end + join_any + disable fork; + end join + if (cfg.in_reset) begin + m_ack_semaphore.put(); + return; + end + + // Finally, wait for the alert to be cleared again, stopping early on reset. + fork : isolation_fork3 begin + fork + wait(cfg.in_reset); + begin + wait(!cfg.vif.receiver_cb.alert_tx.alert_p); + repeat (ack_stable) @(cfg.vif.receiver_cb); + set_ack(1'b0); + end + join_any + disable fork; + end join + + m_ack_semaphore.put(); +endtask + +task alert_receiver_driver::set_ack(bit asserted); + cfg.vif.receiver_cb.alert_rx_int.ack_p <= asserted; + cfg.vif.receiver_cb.alert_rx_int.ack_n <= !asserted; +endtask + +task alert_receiver_driver::set_ping(); + cfg.vif.receiver_cb.alert_rx_int.ping_p <= !cfg.vif.alert_rx.ping_p; + cfg.vif.receiver_cb.alert_rx_int.ping_n <= !cfg.vif.alert_rx.ping_n; +endtask + +task alert_receiver_driver::reset_ping(); + cfg.vif.receiver_cb.alert_rx_int.ping_p <= 1'b0; + cfg.vif.receiver_cb.alert_rx_int.ping_n <= 1'b1; +endtask + +task alert_receiver_driver::do_alert_rx_init(); + fork : isolation_fork begin + fork + wait(cfg.in_reset); + begin + repeat ($urandom_range(1, 10)) @(cfg.vif.receiver_cb); + cfg.vif.alert_rx_int.ack_p <= 1'b0; + cfg.vif.alert_rx_int.ack_n <= 1'b0; + + wait (cfg.vif.receiver_cb.alert_tx.alert_p == cfg.vif.receiver_cb.alert_tx.alert_n); + repeat ($urandom_range(1, 10)) @(cfg.vif.receiver_cb); + cfg.vif.alert_rx_int.ack_n <= 1'b1; + + wait (cfg.vif.receiver_cb.alert_tx.alert_p != cfg.vif.receiver_cb.alert_tx.alert_n); + end + join_any + disable fork; + end join +endtask + +task alert_receiver_driver::wait_slower_clock(int unsigned num_cycles); + fork : isolation_fork begin + fork + wait(cfg.in_reset); + fork + repeat (num_cycles) @(posedge cfg.vif.clk); + repeat (num_cycles) @(posedge cfg.vif.async_clk); + join + join_any + disable fork; + end join +endtask diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_sender_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_sender_driver.sv new file mode 100644 index 0000000..eceafe0 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_sender_driver.sv @@ -0,0 +1,268 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// + +class alert_sender_driver extends alert_base_driver; + + `uvm_component_utils(alert_sender_driver) + + // An event that can be triggered (by functions as well as tasks). This is monitored by + // maintain_alert_drive, which will call cfg.vif.force_alert with m_desired_alert_val. + uvm_event m_update_alert_val; + bit [1:0] m_desired_alert_val; + + extern function new (string name, uvm_component parent); + + // This function gets called by dv_base_driver::reset_signals when the interface enters reset. + // Clear any alert signal. + extern virtual task on_enter_reset(); + + // Drive sequence items for alerts and pings that have been retrieved by get_req (and therefore + // have started) and have been pushed to the various queues. This also does the alert init + // handshake (with no sequence item) after each reset. + // + // An implementation of alert_base_driver::drive_req + extern virtual task drive_req(); + + // Drive sequence items for alerts and pings until either a reset or a change of cfg.en_alert_lpg + extern local task drive_reqs_with_lpg_mode(bit en_alert_lpg); + + // Drive a single sequence item to send an alert, possibly responding to a ping. This task doesn't + // mark the item done in seq_item_port: the caller should do that. + // + // This exits immediately on a reset. + extern local task send_item(bit is_ping_rsp, alert_seq_item item); + + // Drive the alert_p/alert_n pins for the sequence item. There may be a delay before asserting the + // alert or before de-asserting it (once an ack has been seen). + // + // This is safe to kill. + extern local task drive_alert_pins(alert_seq_item req); + + // Assert an alert (alert_p=1; alert_n=0) after alert_delay cycles. + // + // This is safe to kill. + extern local task set_alert_pins(int alert_delay); + + // Wait for an ack from the receiver, then de-assert the alert (alert_p=0; alert_n=1) after an + // extra ack_delay cycles. Finally, wait for the receiver to de-assert ack. + // + // The handshake above has a timeout, and the task will exit if it is reached. If cfg.en_alert_lpg + // becomes false, this means that the receiver will no longer respond. We regard that as an + // immediate timeout. + // + // This is safe to kill. + extern local task reset_alert_pins(int ack_delay); + + // Send invalid alert pin values (either 11 or 00) for int_err_cyc cycles + // + // This is safe to kill. + extern local task random_drive_int_fail(int int_err_cyc); + + // Set the alert pins to be (alert_p=1; alert_n=0) if enabled=1 and (alert_p=0; alert_n=1) + // otherwise. + // + // Because the alert signals are set through a clocking block (using cfg.vif.force_alert()), this + // works by setting m_desired_alert_val and triggering the m_update_alert_val event. + extern local function void set_alert(bit enabled); + + // Set the alert pins to 11 or 00 (depending on the high argument). + // + // This task takes zero time (but needs to be a task because it uses non-blocking assignment) + extern local task drive_invalid_alert(bit high); + + // Wait for count cycles of the sender clock + // + // This is safe to kill. + extern local task wait_sender_clk(int unsigned count); + + // Handle an alert init request. + // + // After alert_receiver is reset, it will send a signal integrity fail with a non-differential ack + // signal. The alert sender has to acknowledge the init by setting the alert pins to 00 until ack + // becomes differential again. + // + // This task exits early on reset or if cfg.en_alert_lpg is asserted (in which case, the receiver + // won't reply to the init) + extern local task do_alert_tx_init(); + + // This task runs forever, calling cfg.vif.set_alert() each time the m_update_alert_val event is + // triggered. + extern local task maintain_alert_drive(); +endclass : alert_sender_driver + +function alert_sender_driver::new (string name, uvm_component parent); + super.new(name, parent); + m_update_alert_val = new("m_update_alert_val"); +endfunction : new + +task alert_sender_driver::on_enter_reset(); + set_alert(1'b0); +endtask + +task alert_sender_driver::drive_req(); + fork + maintain_alert_drive(); + forever begin + // Wait until we are out of reset. Until that happens, respond instantly to any sequence items + // that come in. + while (cfg.in_reset) begin + fork : isolation_fork begin + alert_seq_item item; + fork + wait(!cfg.in_reset); + m_requests.get(item); + join_any + disable fork; + if (item != null) seq_item_port.put_response(item); + end join + end + + while(!cfg.in_reset) begin + bit en_alert_lpg = cfg.en_alert_lpg; + + // If LPG is not enabled, initialise the alert interface + if (!en_alert_lpg) begin + do_alert_tx_init(); + end + + // Drive any requests that we see. The task will exit on reset or if the LPG flag changes, + // letting us initialise the alert interface (if LPG is disabled) and continue. + drive_reqs_with_lpg_mode(en_alert_lpg); + end + end + join +endtask + +task alert_sender_driver::drive_reqs_with_lpg_mode(bit en_alert_lpg); + forever begin + alert_seq_item item, rsp; + + // Pick an item to drive, but keep track of resets and any change to the LPG flag. + fork : isolation_fork begin + fork + wait(cfg.en_alert_lpg != en_alert_lpg); + wait(cfg.in_reset); + m_requests.get(item); + join_any + disable fork; + end join + + // If there is no item, there has been a reset or the LPG flag has changed. Return from the + // task. + if (item == null) return; + + `downcast(rsp, item.clone()); + rsp.set_id_info(item); + + // Handle the alert request or ping response. + case (item.m_trans_type) + AlertSigTrans: send_item(1'b0, rsp); + AlertPingTrans: send_item(1'b1, rsp); + default: `uvm_fatal(get_full_name(), "Unknown txn type.") + endcase + + seq_item_port.put_response(rsp); + end +endtask + +task alert_sender_driver::send_item(bit is_ping_rsp, alert_seq_item item); + + `uvm_info("driving_item", + $sformatf("starting sender item: %0s, m_int_err_cyc=%0b", + item.m_trans_type.name(), item.m_int_err_cyc), + UVM_HIGH) + fork : isolation_fork begin + fork + wait (cfg.in_reset); + if (!is_ping_rsp || !cfg.ping_timeout) begin + drive_alert_pins(item); + end else begin + wait_sender_clk(cfg.ping_timeout_cycle); + end + join_any + disable fork; + end join + `uvm_info("driving_item", + $sformatf("finished sender item: %0s, m_int_err_cyc=%0b", + item.m_trans_type.name(), item.m_int_err_cyc), + UVM_HIGH) +endtask + +task alert_sender_driver::drive_alert_pins(alert_seq_item req); + if (req.m_int_err_cyc) begin + random_drive_int_fail(req.m_int_err_cyc); + set_alert(1'b0); + end else begin + set_alert_pins(req.m_alert_delay); + reset_alert_pins(req.m_ack_delay); + end + + // There must be at least two sender clock delays before next alert_handshake + wait_sender_clk(2); +endtask + +task alert_sender_driver::set_alert_pins(int alert_delay); + wait_sender_clk(alert_delay + 1); + set_alert(1'b1); +endtask + +task alert_sender_driver::reset_alert_pins(int ack_delay); + fork : isolation_fork begin + fork + wait (cfg.en_alert_lpg); + begin : wait_alert_handshake + wait (cfg.vif.alert_rx.ack_p == 1'b1); + wait_sender_clk(1 + ack_delay); + set_alert(1'b0); + wait (cfg.vif.alert_rx.ack_p == 1'b0); + end + join_any + disable fork; + end join +endtask + +task alert_sender_driver::random_drive_int_fail(int int_err_cyc); + repeat (int_err_cyc) begin + wait_sender_clk(1); + drive_invalid_alert($urandom & 1); + end +endtask + +function void alert_sender_driver::set_alert(bit enabled); + m_desired_alert_val = {enabled, !enabled}; + m_update_alert_val.trigger(); +endfunction + +task alert_sender_driver::drive_invalid_alert(bit high); + cfg.vif.sender_cb.alert_tx_int.alert_p <= high; + cfg.vif.sender_cb.alert_tx_int.alert_n <= high; +endtask + +task alert_sender_driver::wait_sender_clk(int unsigned count); + repeat (count) @(cfg.vif.sender_cb); +endtask + +task alert_sender_driver::do_alert_tx_init(); + fork : isolation_fork begin + fork + wait (cfg.in_reset || cfg.en_alert_lpg); + begin + wait (cfg.vif.alert_rx.ack_p == cfg.vif.alert_rx.ack_n); + drive_invalid_alert(1'b0); + wait (cfg.vif.alert_rx.ack_p != cfg.vif.alert_rx.ack_n); + set_alert(1'b0); + end + join_any + disable fork; + end join +endtask + +task alert_sender_driver::maintain_alert_drive(); + forever begin + m_update_alert_val.wait_ptrigger(); + cfg.vif.force_alert(m_desired_alert_val[1], m_desired_alert_val[0]); + m_update_alert_val.reset(); + end +endtask diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_seq_item.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_seq_item.sv new file mode 100644 index 0000000..49cd6d5 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_seq_item.sv @@ -0,0 +1,111 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// An item that represents transactions on an alert interface + +class alert_seq_item extends uvm_sequence_item; + // The type of transaction represented by this item. This is set by monitors to report an alert, a + // ping request, or a signal integrity failure. + // + // When the item is being driven, this will always be a ping request or an alert (this is + // guaranteed when randomising by ping_or_alert_c) + rand alert_trans_type_e m_trans_type; + + // If this field is nonzero, the driver will cause a signal integrity error of that many cycles + // when driving this item. + rand int unsigned m_int_err_cyc; + + // A delay injected by alert_receiver_driver before it actually sends a ping request. This allows + // the driver to be sent a stream of back-to-back items without locking up the interface. + rand int unsigned m_ping_delay; + + // The number of cycles the driver should wait before acking an alert (when being an alert + // receiver) or clearing an alert after it has been acked (when being an alert sender). + rand int unsigned m_ack_delay; + + // The number of cycles a receiver should continue to assert ack after the sender has dropped + // alert_p. + // + // This only has an effect when acting as an alert receiver. + rand int unsigned m_ack_stable; + + // The number of cycles to wait before sending an alert. + // + // This only has an effect when acting as an alert sender. + rand int unsigned m_alert_delay; + + // This bit is set on items generated by a monitor that has seen a timeout caused by an + // alert/escalation sender not responding to a ping. + bit m_ping_timeout; + + // Generated by alert_monitor: this item shows the current stage of the alert handshake + alert_handshake_e m_alert_handshake_sta; + + extern function new (string name = ""); + + // Constrain delays in the generated item + extern constraint delay_c; + + // Randomised items (to be driven, rather than items generated by a monitor) should only have + // transaction types representing a ping request or an alert. + extern constraint ping_or_alert_c; + + // Constraints on m_int_err_cyc for items randomised for a driver. + // + // Normally, we don't want to generate signal integrity errors, so there's a soft constraint that + // m_int_err_cyc is zero. If this is overridden or disabled, provide a distribution for the length + // of the signal integrity error. + extern constraint int_err_cyc_c; + + // Randomised items (to be driven, rather than items generated by a monitor) to request a ping + // should not have a nonzero m_int_err_cyc: generating ping signal integrity errors is not yet + // supported by the driver. + extern constraint ping_cannot_cause_int_err_c; + + `uvm_object_utils_begin(alert_seq_item) + `uvm_field_enum(alert_trans_type_e, m_trans_type, UVM_DEFAULT) + `uvm_field_int (m_int_err_cyc, UVM_DEFAULT) + `uvm_field_int (m_ping_delay, UVM_DEFAULT) + `uvm_field_int (m_ack_delay, UVM_DEFAULT) + `uvm_field_int (m_ack_stable, UVM_DEFAULT) + `uvm_field_int (m_alert_delay, UVM_DEFAULT) + `uvm_field_int (m_ping_timeout, UVM_DEFAULT) + `uvm_field_enum(alert_handshake_e, m_alert_handshake_sta, UVM_DEFAULT) + `uvm_object_utils_end +endclass + +function alert_seq_item::new (string name = ""); + super.new(name); +endfunction + +constraint alert_seq_item::delay_c { + soft m_ack_delay <= 32; + soft m_ack_stable <= 32; + soft m_alert_delay <= 32; +} + +constraint alert_seq_item::ping_or_alert_c { + m_trans_type inside {AlertPingTrans, AlertSigTrans}; +} + +constraint alert_seq_item::int_err_cyc_c { + // Normally we constrain m_int_err_cyc to be zero. But it's a soft constraint, so the call-site + // that drives the randomisation can override it by adding a hard "m_int_err_cyc != 0" constraint. + // + // If the call-site *has* overridden the constraint (but hasn't disabled this whole constraint by + // name), we want to control the distribution of values. The obvious way to express that would be + // something like "m_int_err_cyc != 0 -> m_int_err_cyc dist {some_distribution_here};", but that + // doesn't work in EDA tools that can't solve distributions in parallel with hard constraints. + // + // Fortunately, we can cheat! The trick is to use a single distribution statement that gives a + // nonzero probability to m_int_err_cyc == 0. This allows the usual case (where the value is + // *constrained* to equal zero), and doesn't affect the special case (because the value is already + // constrained not to equal zero). + soft m_int_err_cyc == 0; + m_int_err_cyc dist {0 := 1, 1 :/ 1, [2:10] :/ 1}; +} + +constraint alert_seq_item::ping_cannot_cause_int_err_c { + m_trans_type == AlertPingTrans -> m_int_err_cyc == 0; +} diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_sequencer.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_sequencer.sv new file mode 100644 index 0000000..6d5761c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/alert_sequencer.sv @@ -0,0 +1,12 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class alert_sequencer extends dv_reactive_sequencer #(alert_seq_item, alert_agent_cfg); + `uvm_component_utils(alert_sequencer) + extern function new (string name, uvm_component parent); +endclass + +function alert_sequencer::new (string name, uvm_component parent); + super.new(name, parent); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/data/BUILD b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/data/BUILD new file mode 100644 index 0000000..395083a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/data/BUILD @@ -0,0 +1,10 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +package(default_visibility = ["//visibility:public"]) + +filegroup( + name = "doc_files", + srcs = glob(["*_testplan.hjson"]), +) diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/data/alert_agent_testplan.hjson b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/data/alert_agent_testplan.hjson new file mode 100644 index 0000000..0596742 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/data/alert_agent_testplan.hjson @@ -0,0 +1,28 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// This DV coverplan documents additional alert agent covergroups. +// To enable these covergroups, please ensure the following variables are enabled: +// `cfg.en_ping_cov` and `cfg.en_lpg_cov` +// Note that if LPG is enabled, the alert ping request handshake won't be initiated, so we cannot +// collect that coverage in this agent. +{ + covergroups: [ + { + name: alert_handshake_complete_cg + desc: '''Cover if the alert handshake completes.''' + } + { + name: alert_trans_cg + desc: '''Cover if the transaction is a ping request or an actual alert request.''' + } + { + name: alert_lpg_cg + desc: '''Covers alert lpg status during an alert request. + + Cover if its lower-power-group (lpg) is enabled or disabled during an alert request. + ''' + } + ] +} diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_alert_rsp_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_alert_rsp_seq.sv new file mode 100644 index 0000000..c7b66f9 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_alert_rsp_seq.sv @@ -0,0 +1,61 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// this sequence responses to alert pins by sending the ack pins +class alert_receiver_alert_rsp_seq extends alert_receiver_base_seq; + + `uvm_object_utils(alert_receiver_alert_rsp_seq) + + extern constraint alert_receiver_alert_rsp_seq_c; + + extern function new (string name = ""); + extern virtual task body(); + // Sends alert rsps back to host. + extern virtual task default_rsp_thread(); + +endclass : alert_receiver_alert_rsp_seq + +constraint alert_receiver_alert_rsp_seq::alert_receiver_alert_rsp_seq_c { + m_trans_type == AlertSigTrans; +} + +function alert_receiver_alert_rsp_seq::new (string name = ""); + super.new(name); +endfunction : new + +task alert_receiver_alert_rsp_seq::body(); + if (cfg.start_default_rsp_seq) begin + default_rsp_thread(); + end else begin + super.body(); + end +endtask : body + +task alert_receiver_alert_rsp_seq::default_rsp_thread(); + alert_seq_item req_q[$]; + fork + forever begin : get_req + p_sequencer.req_analysis_fifo.get(req); + if (req.m_trans_type == AlertSigTrans) req_q.push_back(req); + end : get_req + forever begin : send_rsp + if (cfg.in_reset) begin + req_q.delete(); + wait (!cfg.in_reset); + end + wait (req_q.size()); + rsp = req_q.pop_front(); + start_item(rsp); + if (!rsp.randomize() with { + m_trans_type == local::m_trans_type; + cfg.ack_delay_min <= m_ack_delay && m_ack_delay <= cfg.ack_delay_max; + cfg.ack_stable_min <= m_ack_stable && m_ack_stable <= cfg.ack_stable_max; + }) begin + `uvm_error(get_full_name(), "Failed to randomize rsp") + end + finish_item(rsp); + get_response(rsp); + end : send_rsp + join +endtask : default_rsp_thread diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_base_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_base_seq.sv new file mode 100644 index 0000000..051e799 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_base_seq.sv @@ -0,0 +1,44 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// this is a base sequence for alert_receiver side +class alert_receiver_base_seq extends dv_base_seq #( + .REQ (alert_seq_item), + .CFG_T (alert_agent_cfg), + .SEQUENCER_T (alert_sequencer) + ); + + `uvm_object_utils(alert_receiver_base_seq) + + rand alert_trans_type_e m_trans_type; + + extern function new (string name = ""); + extern task body(); + +endclass : alert_receiver_base_seq + +function alert_receiver_base_seq::new (string name = ""); + super.new(name); +endfunction : new + +task alert_receiver_base_seq::body(); + `uvm_info(`gfn, $sformatf("starting alert receiver transfer"), UVM_HIGH) + req = alert_seq_item::type_id::create("req"); + start_item(req); + + if (!req.randomize() with { + m_trans_type == local::m_trans_type; + cfg.ack_delay_min <= m_ack_delay && m_ack_delay <= cfg.ack_delay_max; + cfg.ack_stable_min <= m_ack_stable && m_ack_stable <= cfg.ack_stable_max; + m_int_err_cyc == 0; // This agent do not support alert_receiver int_err + }) begin + `uvm_fatal(get_full_name(), "Failed to randomize req") + end + + `uvm_info(`gfn, $sformatf("seq_item: %0s", m_trans_type.name()), UVM_MEDIUM) + + finish_item(req); + get_response(rsp); + `uvm_info(`gfn, "alert receiver transfer done", UVM_HIGH) +endtask : body diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_ping_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_ping_seq.sv new file mode 100644 index 0000000..b015bde --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_ping_seq.sv @@ -0,0 +1,42 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A sequence that repeatedly sends alert_seq_item items that are configured to request pings. These +// ping requests are configured with large ping_delay values. Note that if an alert is raised while +// the driver is waiting at the start of sending a ping request then the driver will complete the +// item immediately (and the sequencer will then be able to enqueue an alert response item) +class alert_receiver_ping_seq extends dv_base_seq #(.REQ (alert_seq_item), + .CFG_T (alert_agent_cfg), + .SEQUENCER_T (alert_sequencer)); + `uvm_object_utils(alert_receiver_ping_seq) + extern function new (string name=""); + extern virtual task body(); +endclass : alert_receiver_ping_seq + +function alert_receiver_ping_seq::new (string name=""); + super.new(name); +endfunction : new + +task alert_receiver_ping_seq::body(); + forever begin + // Items submitted while cfg.in_reset is asserted are discarded by the driver so there is no point + // creating a new item until reset has cleared + if (cfg.in_reset) wait (!cfg.in_reset); + req = alert_seq_item::type_id::create("req"); + start_item(req); + // Randomise the item to be a ping request. When driven, the item will "wait around" for + // ping_delay cycles before it actually sends the ping. Bound this to be at most + // cfg.ping_delay_max. + if (!req.randomize() with { + m_trans_type == AlertPingTrans; + cfg.ack_delay_min <= m_ack_delay && m_ack_delay <= cfg.ack_delay_max; + cfg.ack_stable_min <= m_ack_stable && m_ack_stable <= cfg.ack_stable_max; + cfg.ping_delay_min <= m_ping_delay && m_ping_delay <= cfg.ping_delay_max; + }) begin + `uvm_error(get_full_name(), "Failed to randomize req") + end + finish_item(req); + get_response(req); + end +endtask : body diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_seq.sv new file mode 100644 index 0000000..1d71615 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_receiver_seq.sv @@ -0,0 +1,21 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// this sequence send ping_p and ping_n to trigger ping signals +class alert_receiver_seq extends alert_receiver_base_seq; + + `uvm_object_utils(alert_receiver_seq) + + extern constraint alert_receiver_seq_c; + extern function new (string name = ""); + +endclass : alert_receiver_seq + +constraint alert_receiver_seq::alert_receiver_seq_c { + m_trans_type == AlertPingTrans; +} + +function alert_receiver_seq::new (string name = ""); + super.new(name); +endfunction : new diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_base_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_base_seq.sv new file mode 100644 index 0000000..3a27e87 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_base_seq.sv @@ -0,0 +1,56 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// this is a base sequence for alert sender side +class alert_sender_base_seq extends dv_base_seq #( + .REQ (alert_seq_item), + .CFG_T (alert_agent_cfg), + .SEQUENCER_T (alert_sequencer) + ); + + `uvm_object_utils(alert_sender_base_seq) + + rand alert_trans_type_e m_trans_type; + + rand bit int_err; + rand bit ping_timeout; + + extern function new (string name = ""); + extern virtual task body(); + +endclass : alert_sender_base_seq + +function alert_sender_base_seq::new (string name = ""); + super.new(name); +endfunction : new + +task alert_sender_base_seq::body(); + `uvm_info(`gfn, $sformatf("starting alert sender transfer"), UVM_HIGH) + req = alert_seq_item::type_id::create("req"); + start_item(req); + + if (!req.randomize() with { + m_trans_type == local::m_trans_type; + + // If int_err is true, override the soft constraint in the sequence item and request a + // nonzero time with an error. + if (local::int_err) { + m_int_err_cyc != 0; + } + + cfg.ack_delay_min <= m_ack_delay && m_ack_delay <= cfg.ack_delay_max; + cfg.alert_delay_min <= m_alert_delay && m_alert_delay <= cfg.alert_delay_max; + }) begin + `uvm_error(get_full_name(), "Failed to randomize req.") + end + + `uvm_info(get_full_name(), + $sformatf("seq_item: %0s, m_int_err_cyc=%0b", + req.m_trans_type.name(), req.m_int_err_cyc), + UVM_MEDIUM) + + finish_item(req); + get_response(rsp); + `uvm_info(`gfn, "alert sender transfer done", UVM_HIGH) +endtask : body diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_ping_rsp_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_ping_rsp_seq.sv new file mode 100644 index 0000000..ac04763 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_ping_rsp_seq.sv @@ -0,0 +1,62 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// this sequence responses to ping pins by sending the alert pins +class alert_sender_ping_rsp_seq extends alert_sender_base_seq; + + `uvm_object_utils(alert_sender_ping_rsp_seq) + + extern constraint alert_sender_ping_rsp_seq_c; + + extern function new (string name = ""); + extern virtual task body(); + // Sends random rsps (device data and ack) back to host. + extern virtual task default_rsp_thread(); + +endclass : alert_sender_ping_rsp_seq + +constraint alert_sender_ping_rsp_seq::alert_sender_ping_rsp_seq_c { + m_trans_type == AlertPingTrans; +} + +function alert_sender_ping_rsp_seq::new (string name = ""); + super.new(name); +endfunction : new + +task alert_sender_ping_rsp_seq::body(); + if (cfg.start_default_rsp_seq) begin + default_rsp_thread(); + end else begin + super.body(); + end +endtask : body + +task alert_sender_ping_rsp_seq::default_rsp_thread(); + alert_seq_item req_q[$]; + fork + forever begin : get_req + p_sequencer.req_analysis_fifo.get(req); + if (req.m_trans_type == AlertPingTrans) req_q.push_back(req); + end : get_req + forever begin : send_rsp + if (cfg.in_reset) begin + req_q.delete(); + wait (!cfg.in_reset); + end + wait (req_q.size()); + rsp = req_q.pop_front(); + start_item(rsp); + if (!rsp.randomize() with { + m_trans_type == local::m_trans_type; + m_ping_timeout == 0; + cfg.ack_delay_min <= m_ack_delay && m_ack_delay <= cfg.ack_delay_max; + cfg.alert_delay_min <= m_alert_delay && m_alert_delay <= cfg.alert_delay_max; + }) begin + `uvm_error(get_full_name(), "Failed to randomize rsp") + end + finish_item(rsp); + get_response(rsp); + end : send_rsp + join +endtask : default_rsp_thread diff --git a/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_seq.sv new file mode 100644 index 0000000..52679cc --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/alert_agent/seq_lib/alert_sender_seq.sv @@ -0,0 +1,23 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// this sequence send the alert pins to the receiver +class alert_sender_seq extends alert_sender_base_seq; + + `uvm_object_utils(alert_sender_seq) + + constraint alert_sender_seq_c; + + extern function new (string name = ""); + +endclass : alert_sender_seq + +function alert_sender_seq::new (string name = ""); + super.new(name); +endfunction : new + +constraint alert_sender_seq::alert_sender_seq_c { + m_trans_type == AlertSigTrans; + ping_timeout == 0; +} diff --git a/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/README.md b/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/README.md new file mode 100644 index 0000000..826f934 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/README.md @@ -0,0 +1,10 @@ +# bus_params_pkg + +This package provides an isolation for all common verification components under +`hw/dv/sv/` from the OpenTitan specific design constants provided in +`hw/top_earlgrey/rtl/top_pkg.sv`. This mostly includes common bus parameters +such as address and data widths. + +When vendoring the common DV code into another repo, the other repo must +provide its own implementation of `bus_params_pkg` so that the +dependency on the `top_pkg` can be avoided. diff --git a/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/bus_params_pkg.core b/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/bus_params_pkg.core new file mode 100644 index 0000000..7659f86 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/bus_params_pkg.core @@ -0,0 +1,19 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:opentitan:bus_params_pkg" +description: "Package holding common bus parameters such as widths." + +filesets: + files_dv: + depend: + - lowrisc:virtual_constants:top_pkg + files: + - bus_params_pkg.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/bus_params_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/bus_params_pkg.sv new file mode 100644 index 0000000..d4116d7 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/bus_params_pkg/bus_params_pkg.sv @@ -0,0 +1,64 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package bus_params_pkg; + + // Set the bus address width. +`ifdef BUS_AW + parameter int BUS_AW = `BUS_AW; +`else + parameter int BUS_AW = top_pkg::TL_AW; +`endif + + // Set the bus data width. +`ifdef BUS_DW + parameter int BUS_DW = `BUS_DW; +`else + parameter int BUS_DW = top_pkg::TL_DW; +`endif + + // Set the bus data mask width (# of byte lanes). +`ifdef BUS_DBW + parameter int BUS_DBW = `BUS_DBW; +`else + parameter int BUS_DBW = top_pkg::TL_DBW; +`endif + + // Set the bus transfer size width (# of bits required to select the # of bytes). +`ifdef BUS_SZW + parameter int BUS_SZW = `BUS_SZW; +`else + parameter int BUS_SZW = top_pkg::TL_SZW; +`endif + +// Set the bus address info (source) width. +`ifdef BUS_AIW + parameter int BUS_AIW = `BUS_AIW; +`else + parameter int BUS_AIW = top_pkg::TL_AIW; +`endif + +// Set the bus data info (source) width. +`ifdef BUS_DIW + parameter int BUS_DIW = `BUS_DIW; +`else + parameter int BUS_DIW = top_pkg::TL_DIW; +`endif + +// Set the bus a channel user width. +`ifdef BUS_AUW + parameter int BUS_AUW = `BUS_AUW; +`else + parameter int BUS_AUW = top_pkg::TL_AUW; +`endif + +// Set the bus d channel user width. +`ifdef BUS_DUW + parameter int BUS_DUW = `BUS_DUW; +`else + parameter int BUS_DUW = top_pkg::TL_DUW; +`endif + + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/README.md b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/README.md new file mode 100644 index 0000000..54124d2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/README.md @@ -0,0 +1,114 @@ +# Common Interfaces + +## Overview +In this directory, we provide commonly used interfaces used to construct +testbenches for DV. These interfaces are instantiated inside `tb` module for +connecting dut signals. They are described in detail below. + +### `clk_if` +This is a passive clock interface that is used to wait for clock events in +testbenches. This interface has two clocking blocks, `cb` and `cbn`, for +synchronizing to positive and negative clock edges, respectively. The interface +also has the following tasks: +* `wait_clks`: waits for specified number of positive clock edges +* `wait_n_clks`: waits for specified number of negative clock edges + +### `clk_rst_if` + +Unlike `clk_if`, this interface can generate a clock and a reset signal. These +are connected as `inout` signals and the interface observes them passively +unless the `set_active` function is called. + +Just like `clk_if`, this interface has clocking blocks `cb` and `cbn`, together +with `wait_clks` and `wait_n_clks` utility tasks. It also has +* `wait_for_reset`: wait for a reset signaled on `rst_n` + +To generate a clock signal, call `set_active` at the start of the simulation. +This is typically called from an `initial` block in the testbench. To configure +the frequency and duty cycle of the generated clock, use the following +functions: +* `set_freq_mhz` / `set_freq_khz`: set the clock frequency in MHz / KHz. This + is 50MHz by default. +* `set_period_ps`: set the clock period in picoseconds. This is 20_000ps by default + (giving a clock period of 50MHz). +* `set_duty_cycle`: set the duty cycle (as a percentage: 1 - 99). This is 50 by + default. + +The clock can also have jitter added. This is generated as an offset in +picoseconds added to randomly selected clock half-periods. It can be enabled +and configured with: +* `set_jitter_chance_pc`: set the percentage probability of adding a jitter to + a given half-period. By default, this is 0 and the clock has no jitter. +* `set_max_jitter_ps`: set the maximum jitter to add to each clock half-period + in picoseconds. This is 1000ps (1 ns) by default. + +To start and stop the clock or apply a reset, use the following tasks. These +will have no effect if `set_active` has not been called. +* `start_clk`: start the clock. The clock is started by default, so this + task is only needed after a call to `stop_clk`. +* `stop_clk`: stop / gate the clk +* `apply_reset`: signal a reset on `rst_n`. The length of this reset and + whether it is synchronous or not can be configured with arguments to the + function. + +### `pins_if` + +This parameterized interface provides the ability to drive or sample any signal +in the DUT. + +```systemverilog +interface pins_if #( + parameter int Width = 1 +) ( + inout [Width-1:0] pins +); +``` + +By default, it behaves as a passive interface. The values of the pins can be +read with the following functions: +* `sample`: sample and return all the pin values +* `sample_pin`: sample just the given pin + +The interface can also be configured to drive, pull up, or pull down its +outputs. To do this, call +* `drive` / `drive_pin`: Drive the output to the given value. +* `drive_en` / `drive_en_pin`: Configure output enable; when enabled, this + drives value previously stored by a call to `drive` or `drive_pin`. +* `set_pullup_en` / `set_pullup_en_pin`: Configure pull-up setting. If true and + output enable is false, drives the output to `1`. +* `set_pulldown_en` / `set_pulldown_en_pin`: Configure pull-down setting. If + true and both output_enable and pull-up are false, drives the output to `0`. + +The diagram below gives a schematic view of `pins_if`. The driver shown is +replicated for each bit. + +![Block diagram](pins_if.svg) + +### `entropy_subsys_fifo_exception_if` + +The IPs in the entropy subsystem (`entropy_src`, `CSRNG` and `EDN`) raise fatal alerts if they +detect that data is lost in one of the intermediate FIFOS, either through: + - Write errors (Overflow) wvalid_i asserted when full + - Read errors (Underflow) rready_i asserted when empty (i.e. rvalid_o == 0) + - State errors: Anomalous behavior rvalid_o deasserted (FIFO is not empty) when full + +Furthermore some instances of prim packer fifo's also raise recoverable alerts if firmware +tries to write data to it when it is not ready. + +The events described above need not be treated as errors in general purpose designs. +In many general designs where the fifo is capable of applying backpressure (stalling +the read or write inputs) these do not have to be an error. One could in principal +only signal an alert if it is observed that data was indeed lost (e.g., if `wvalid_i` is +deasserted or data changes before `wready_o` is high). However most of the entropy complex +fifo stages do not respond to such backpressure, and thus the conditions above do +indicate a loss of data. + +The entropy_subsys_fifo_exception_if.sv has pins that can map either to synchronous +FIFOs or to packer fifos. Though some interface ports will be unused in any case +the interface parameter `IsPackerFifo` indicates which ports to use (True for +packer FIFOs or False for synchronous FIFOs. + +The interface then generates error pulses in the `mon_cb` clocking block under +the signal `mon_cb.error_pulses`, which has one line per possible error condition. +The enumeration entropy_subsys_fifo_exception_pkg::fifo_exception_e lists the +types of exceptions and provides the mapping to the corresponding error pulse line. diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/clk_if.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/clk_if.sv new file mode 100644 index 0000000..4729a54 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/clk_if.sv @@ -0,0 +1,29 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +//----------------------------- DESCRIPTION ------------------------------------ +// +// Generic clock interface for clock events in various utilities +// +//------------------------------------------------------------------------------ + +interface clk_if(input logic clk); + + clocking cb @(posedge clk); + endclocking + + clocking cbn @(negedge clk); + endclocking + + // Wait for 'n' clocks based of positive clock edge + task automatic wait_clks(int num_clks); + repeat (num_clks) @cb; + endtask + + // Wait for 'n' clocks based of negative clock edge + task automatic wait_n_clks(int num_clks); + repeat (num_clks) @cbn; + endtask + +endinterface diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/clk_rst_if.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/clk_rst_if.sv new file mode 100644 index 0000000..27a89be --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/clk_rst_if.sv @@ -0,0 +1,362 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// +// Interface: clk_rst_if +// Generic clock and reset interface for clock events in various utilities +// It also generates o_clk and o_rst_n signals for driving clk and rst_n in the tb. The advantage is +// clk and rst_n can be completely controlled in course of the simulation. +// This interface provides methods to set freq/period, wait for clk/rst_n, apply rst_n among other +// things. See individual method descriptions below. +// inout clk +// inout rst_n + +interface clk_rst_if ( + inout clk, + inout rst_n +); + +`ifndef VERILATOR + // include macros and import pkgs + `include "dv_macros.svh" + `include "uvm_macros.svh" + import uvm_pkg::*; + import common_ifs_pkg::*; +`endif + + // Enables clock to be generated and driven by this interface. + bit drive_clk; + + // The internal output clock value. + logic o_clk; + + // Enables the rst_n to be generated and driven by this interface. + bit drive_rst_n; + + // The internal output reset value. + logic o_rst_n; + + // This event is used to start the initial block driving the clock after set_active sets + // the values of drive_clk and drive_rst_n. + event set_active_called; + + // Applies clock gating. + bit clk_gate = 1'b0; + + // The nominal (chosen) frequency (as period in ps) of the driven clock (50MHz by default). + int clk_period_ps = 20_000; + + // The variation of clock period (mimics uncalibrated clocks), to scale the nominal frequency + // down. If set to non-zero value, the clock frequency is scaled randomly on every edge. + int clk_freq_scaling_pc = 0; + + // The percentage chance of freq scaled down randomly on each edge. + int clk_freq_scaling_chance_pc = 50; + + // Clock frequency is scaled down. This enables the frequency to be randomly scaled up as well. + // + // Note: If set, the randomness of the clock frequency being scaled up or down may result in a + // bigger frequency distribution than the intended clk_freq_scaling_pc setting. For example, 50MHz + // with 10% scaling may result in pulses that are < 45MHz and > 55MHz wide as well. + bit clk_freq_scale_up = 1'b0; + + // The computed clock frequency in MHz. + real clk_freq_mhz = 50; + + // The duty cycle of the clock period as percentage. If jitter and scaling is applied, then the + // duty cycle will not be maintained. + int duty_cycle = 50; + + // Maximum jitter applied to each period of the clock - this is expected to be about 20% or less + // than the clock period. + // The jitter is divided to two values - plus-jitter and minus-jitter. + // Plus jitter is the possible time can be added to the clock period, while the minus jitter is + // the possible time can be subtracted from the clock period. + // _________ + // _____:_| : : |_:_______ + // + // The actual jitter value is picked randomly within the window + // {[-max_minus_jitter_ps:max_plus_jitter_ps]} + // and is added to the time to next edge. + int max_plus_jitter_ps = 1000; + int max_minus_jitter_ps = 1000; + + // The percentage chance of jitter occurring on each edge. If 0 (default value), then jitter is + // disabled altogether. If 100, jitter is computed and applied at every edge. + int jitter_chance_pc = 0; + + // Internal signal indicating the clock half periods need to be recomputed. + bit recompute = 1'b1; + + // Internal signal indicating the amount of time for which the clock stays high / lo in the next + // cycle. + int clk_hi_ps; + int clk_lo_ps; + real clk_hi_modified_ps; + real clk_lo_modified_ps; + + // If true, this is the only clock in the system; there is no need to add initial jitter. + bit sole_clock = 1'b0; + + string msg_id = $sformatf("[%m(clk_rst_if)]"); + + clocking cb @(posedge clk); + endclocking + + clocking cbn @(negedge clk); + endclocking + + // Wait for 'n' clocks based of postive clock edge + task automatic wait_clks(int num_clks); + repeat (num_clks) @cb; + endtask + + // Wait for 'n' clocks based of negative clock edge + task automatic wait_n_clks(int num_clks); + repeat (num_clks) @cbn; + endtask + + // Wait for 'num_clks' clocks based on the positive clock edge or reset, whichever comes first. + task automatic wait_clks_or_rst(int num_clks); + fork begin : isolation_fork + fork + wait_clks(num_clks); + wait_for_reset(.wait_negedge(1'b1), .wait_posedge(1'b0)); + join_any + disable fork; + end join + endtask + + // Wait for 'num_clks' clocks based on the negative clock edge or reset, whichever comes first. + task automatic wait_n_clks_or_rst(int num_clks); + fork begin : isolation_fork + fork + wait_n_clks(num_clks); + wait_for_reset(.wait_negedge(1'b1), .wait_posedge(1'b0)); + join_any + disable fork; + end join + endtask + + // wait for rst_n to assert and then deassert + task automatic wait_for_reset(bit wait_negedge = 1'b1, bit wait_posedge = 1'b1); + if (wait_negedge && ($isunknown(rst_n) || rst_n === 1'b1)) @(negedge rst_n); + if (wait_posedge && (rst_n === 1'b0)) @(posedge rst_n); + endtask + + // set the clk frequency in khz + function automatic void set_freq_khz(int freq_khz); + clk_freq_mhz = $itor(freq_khz) / 1000; + if (drive_clk && clk_freq_mhz <= 0) begin + `uvm_fatal(msg_id, "Since drive_clk is true, freq_mhz must be greater than zero.") + end + clk_period_ps = 1000_000 / clk_freq_mhz; + recompute = 1'b1; + endfunction + + // set the clk frequency in mhz + function automatic void set_freq_mhz(int freq_mhz); + if (drive_clk && freq_mhz <= 0) begin + `uvm_fatal(msg_id, "Since drive_clk is true, freq_mhz must be greater than zero.") + end + set_freq_khz(freq_mhz * 1000); + endfunction + + // Set the clk frequency scaling, chance in percentage and scaling up. + // + // freq_scaling_pc is a positive integer that determines by what amount (as percentage of the + // nominal frequency) is the frequency scaled (jittered) down. + // freq_scaling_chance_pc is a percentage number between 0 and 100 that determines how often is + // the scaling randomly recomputed and applied. + // freq_scale_up is a bit that enables the random scaling up of the frequency as well. + function automatic void set_freq_scaling(int freq_scaling_pc, int freq_scaling_chance_pc = 50, + bit freq_scale_up = 1'b0); + `DV_CHECK_FATAL(freq_scaling_pc >= 0, , msg_id) + `DV_CHECK_FATAL(freq_scaling_chance_pc inside {[0:100]}, , msg_id) + clk_freq_scaling_pc = freq_scaling_pc; + clk_freq_scaling_chance_pc = freq_scaling_chance_pc; + clk_freq_scale_up = freq_scale_up; + endfunction + + // Enables the clock and reset to be driven. + function automatic void set_active(bit drive_clk_val = 1'b1, bit drive_rst_n_val = 1'b1); + if (drive_clk_val && clk_freq_mhz <= 0) begin + `uvm_fatal(msg_id, "Cannot enable drive_clk unless clk_freq_mhz is greater than zero.") + end + + drive_clk = drive_clk_val; + drive_rst_n = drive_rst_n_val; + -> set_active_called; + endfunction + + // set the clk period in ps + function automatic void set_period_ps(int period_ps); + clk_period_ps = period_ps; + clk_freq_mhz = 1000_000 / clk_period_ps; + recompute = 1'b1; + endfunction + + // set the duty cycle (1-99) + function automatic void set_duty_cycle(int duty); + `DV_CHECK_FATAL(duty inside {[1:99]}, , msg_id) + duty_cycle = duty; + recompute = 1'b1; + endfunction + + // set maximum jitter in ps, separating the plus jitter and the minus jitter. + // In default the plus and minus jitters are the same. + function automatic void set_max_jitter_ps(int plus_jitter_ps, + int minus_jitter_ps = plus_jitter_ps); + max_plus_jitter_ps = plus_jitter_ps; + max_minus_jitter_ps = minus_jitter_ps; + endfunction + + // set jitter chance in percentage (0 - 100) + // 0 - dont add any jitter; 100 - add jitter on every clock edge + function automatic void set_jitter_chance_pc(int jitter_chance); + `DV_CHECK_FATAL(jitter_chance inside {[0:100]}, , msg_id) + jitter_chance_pc = jitter_chance; + endfunction + + // Set whether this is the only clock in the system. If true, various bits of timing randomisation + // are disabled. If there's no other clock to (de)synchronise with, this should not weaken the + // test at all. + function automatic void set_sole_clock(bit is_sole = 1'b1); + sole_clock = is_sole; + endfunction + + // start / ungate the clk + task automatic start_clk(bit wait_for_posedge = 1'b0); + clk_gate = 1'b0; + if (wait_for_posedge) wait_clks(1); + endtask + + // stop / gate the clk + function automatic void stop_clk(); + clk_gate = 1'b1; + endfunction + + // Scales the clock frequency up and down on every edge. + function automatic void apply_freq_scaling(); + real scaling; + real mult = $urandom_range(0, int'(clk_freq_scale_up)) ? 1.0 : -1.0; + + if ($urandom_range(1, 100) <= clk_freq_scaling_chance_pc) begin + scaling = 1.0 + mult * real'($urandom_range(0, clk_freq_scaling_pc)) / 100; + clk_hi_modified_ps = clk_hi_ps * scaling; + scaling = 1.0 + mult * real'($urandom_range(0, clk_freq_scaling_pc)) / 100; + clk_lo_modified_ps = clk_lo_ps * scaling; + end + endfunction + + // Applies jitter to clk_hi and clk_lo half periods based on jitter_chance_pc. + function automatic void apply_jitter(); + int jitter; + int plus_jitter; + int minus_jitter; + + if ($urandom_range(1, 100) <= jitter_chance_pc) begin + plus_jitter = $urandom_range(0, max_plus_jitter_ps/2); + minus_jitter = $urandom_range(0, max_minus_jitter_ps/2); + jitter = ($urandom_range(0, 1) ? plus_jitter : (-1 * minus_jitter)); + clk_hi_modified_ps = clk_hi_ps + jitter; + end + if ($urandom_range(1, 100) <= jitter_chance_pc) begin + plus_jitter = $urandom_range(0, max_plus_jitter_ps/2); + minus_jitter = $urandom_range(0, max_minus_jitter_ps/2); + jitter = ($urandom_range(0, 1) ? plus_jitter : (-1 * minus_jitter)); + clk_lo_modified_ps = clk_lo_ps + jitter; + end + endfunction + + // can be used to override clk/rst pins, e.g. at the beginning of the simulation + task automatic drive_rst_pin(logic val = 1'b0); + o_rst_n = val; + endtask + + // apply reset with specified scheme + task automatic apply_reset(int reset_width_clks = $urandom_range(50, 100), + int post_reset_dly_clks = 0, + rst_scheme_e rst_n_scheme = RstAssertAsyncDeassertSync); + if (drive_rst_n) begin + int dly_ps; + dly_ps = $urandom_range(0, clk_period_ps); + case (rst_n_scheme) + RstAssertSyncDeassertSync: begin + o_rst_n <= 1'b0; + wait_clks(reset_width_clks); + o_rst_n <= 1'b1; + end + RstAssertAsyncDeassertSync: begin + #(dly_ps * 1ps); + o_rst_n <= 1'b0; + wait_clks(reset_width_clks); + o_rst_n <= 1'b1; + end + RstAssertAsyncDeassertASync: begin + #(dly_ps * 1ps); + o_rst_n <= 1'b0; + wait_clks(reset_width_clks); + dly_ps = $urandom_range(0, clk_period_ps); + #(dly_ps * 1ps); + o_rst_n <= 1'b1; + end + default: begin + `dv_fatal($sformatf("rst_n_scheme %0d not supported", rst_n_scheme), msg_id) + end + endcase + wait_clks(post_reset_dly_clks); + end + endtask + + // clk gen when the clock is active, so this waits until the set_active function was called. + initial begin + // start driving clk only after the first por reset assertion. The fork/join means that we'll + // wait a whole number of clock periods, which means it's possible for the clock to synchronise + // with the "expected" timestamps. + bit done; + @set_active_called; + if (drive_clk) begin + fork + begin + // Only wait for reset if driving it, otherwise it may never come. + if (drive_rst_n) begin + wait_for_reset(.wait_posedge(1'b0)); + + // Wait a short time after reset before starting to drive the clock. + #1ps; + end + o_clk = 1'b0; + + done = 1'b1; + end + while (!done) #(clk_period_ps * 1ps); + join + + // If there might be multiple clocks in the system, wait another (randomised) short time to + // desynchronise. + if (!sole_clock) #($urandom_range(0, clk_period_ps) * 1ps); + + forever begin + if (recompute) begin + clk_hi_ps = clk_period_ps * duty_cycle / 100; + clk_lo_ps = clk_period_ps - clk_hi_ps; + clk_hi_modified_ps = clk_hi_ps; + clk_lo_modified_ps = clk_lo_ps; + recompute = 1'b0; + end + if (clk_freq_scaling_pc && clk_freq_scaling_chance_pc) apply_freq_scaling(); + if (jitter_chance_pc) apply_jitter(); + #(clk_lo_modified_ps * 1ps); + if (!clk_gate) o_clk = 1'b1; + #(clk_hi_modified_ps * 1ps); + o_clk = 1'b0; + end + end + end + + assign clk = drive_clk ? o_clk : 1'bz; + assign rst_n = drive_rst_n ? o_rst_n : 1'bz; + +endinterface diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/common_ifs.core b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/common_ifs.core new file mode 100644 index 0000000..e646798 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/common_ifs.core @@ -0,0 +1,22 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:common_ifs" +description: "Common interfaces used in DV" + +filesets: + files_dv: + depend: + - lowrisc:prim:assert + - lowrisc:dv:pins_if + files: + - common_ifs_pkg.sv + - clk_if.sv + - clk_rst_if.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/common_ifs_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/common_ifs_pkg.sv new file mode 100644 index 0000000..d240966 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/common_ifs_pkg.sv @@ -0,0 +1,15 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package common_ifs_pkg; + // dep packages + import uvm_pkg::*; + + // Enum representing reset scheme + typedef enum bit [1:0] { + RstAssertSyncDeassertSync, + RstAssertAsyncDeassertSync, + RstAssertAsyncDeassertASync + } rst_scheme_e; +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_if.core b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_if.core new file mode 100644 index 0000000..981934f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_if.core @@ -0,0 +1,20 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:entropy_subsys_fifo_exception_if" +description: "DV interface for detecting FIFO exceptions, particularly in entropy subsystem IPs" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_lib + files: + - entropy_subsys_fifo_exception_pkg.sv + - entropy_subsys_fifo_exception_if.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_if.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_if.sv new file mode 100644 index 0000000..07dd244 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_if.sv @@ -0,0 +1,59 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// Interface for capturing overflow/underflow/status events in +// entropy complex (entropy_src, CSRNG, EDN) fifos + + +interface entropy_subsys_fifo_exception_if#( + parameter bit IsPackerFifo = 0 +) +( + input logic clk_i, + input logic rst_ni, + + input logic wready_o, + input logic wvalid_i, + input logic rready_i, + input logic rvalid_o, + input logic full_o +); + + import entropy_subsys_fifo_exception_pkg::*; + + logic read_err_d, write_err_d, state_err_d; + logic read_err_q, write_err_q, state_err_q; + logic read_err_pulse, write_err_pulse, state_err_pulse; + logic write_forbidden; + + logic [N_FIFO_ERR_TYPES-1:0] error_pulses; + assign error_pulses[FIFO_READ_ERR] = read_err_pulse; + assign error_pulses[FIFO_WRITE_ERR] = write_err_pulse; + assign error_pulses[FIFO_STATE_ERR] = state_err_pulse; + + // Error conditions map to the types of events that cause errors in the + // entropy subsystem IPs + assign write_forbidden = IsPackerFifo ? !wready_o : full_o; + + assign write_err_d = wvalid_i && write_forbidden; + assign read_err_d = IsPackerFifo ? 1'b0 : (!rvalid_o && rready_i); + assign state_err_d = IsPackerFifo ? 1'b0 : (!rvalid_o && full_o); + + always @(posedge clk_i) begin + state_err_q <= state_err_d; + read_err_q <= read_err_d; + write_err_q <= write_err_d; + end + + clocking mon_cb @(posedge clk_i); + input write_forbidden; + input error_pulses; + endclocking + + + assign write_err_pulse = write_err_d && !write_err_q; + assign state_err_pulse = state_err_d && !state_err_q; + assign read_err_pulse = read_err_d && !read_err_q; + +endinterface : entropy_subsys_fifo_exception_if diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_pkg.sv new file mode 100644 index 0000000..700e429 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/entropy_subsys_fifo_exception_pkg.sv @@ -0,0 +1,18 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// +// Datatypes for describing FIFO exceptions in the Entropy Subsystem +// + +package entropy_subsys_fifo_exception_pkg; + + typedef enum int { + FIFO_READ_ERR = 0, + FIFO_WRITE_ERR, + FIFO_STATE_ERR, + N_FIFO_ERR_TYPES + } fifo_exception_e; + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_if.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_if.sv new file mode 100644 index 0000000..bf90c27 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_if.sv @@ -0,0 +1,116 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Interface: pins_if +// Description: Pin interface for driving and sampling individual pins such as interrupts, alerts +// and gpios. +`ifndef SYNTHESIS + +interface pins_if #( + parameter int Width = 1, + parameter bit [8*4-1:0] PullStrength = "Pull" +) ( + inout [Width-1:0] pins +); + + `include "prim_assert.sv" + + `ASSERT_INIT(PullStrengthParamValid, PullStrength inside {"Weak", "Pull"}) + + logic [Width-1:0] pins_o; // value to be driven out + bit [Width-1:0] pins_oe = '0; // output enable + bit [Width-1:0] pins_pd = '0; // pull down enable + bit [Width-1:0] pins_pu = '0; // pull up enable + + // function to set pin output enable for specific pin (useful for single pin interface) + function automatic void drive_en_pin(int idx = 0, bit val); + pins_oe[idx] = val; + endfunction + + // function to set pin output enable for all pins + function automatic void drive_en(bit [Width-1:0] val); + pins_oe = val; + endfunction + + // function to drive a specific pin with a value (useful for single pin interface) + function automatic void drive_pin(int idx = 0, logic val); + pins_oe[idx] = 1'b1; + pins_o[idx] = val; + endfunction // drive_pin + + // function to drive all pins + function automatic void drive(logic [Width-1:0] val); + pins_oe = {Width{1'b1}}; + pins_o = val; + endfunction // drive + + // function to drive all pull down values + function automatic void set_pulldown_en(bit [Width-1:0] val); + pins_pd = val; + endfunction // set_pulldown_en + + // function to drive all pull up values + function automatic void set_pullup_en(bit [Width-1:0] val); + pins_pu = val; + endfunction // set_pullup_en + + // function to drive the pull down value on a specific pin + function automatic void set_pulldown_en_pin(int idx = 0, bit val); + pins_pd[idx] = val; + endfunction // set_pulldown_en_pin + + // function to drive the pull up value on a specific pin + function automatic void set_pullup_en_pin(int idx = 0, bit val); + pins_pu[idx] = val; + endfunction // set_pullup_en_pin + + // function to sample a specific pin (useful for single pin interface) + function automatic logic sample_pin(int idx = 0); + return pins[idx]; + endfunction + + // function to sample all pins + function automatic logic [Width-1:0] sample(); + return pins; + endfunction + + // Fully disconnect this interface, including the pulls. + function automatic void disconnect(); + pins_oe = {Width{1'b0}}; + pins_pu = {Width{1'b0}}; + pins_pd = {Width{1'b0}}; + endfunction + + // make connections + for (genvar i = 0; i < Width; i++) begin : gen_each_pin +`ifdef VERILATOR + assign pins[i] = pins_oe[i] ? pins_o[i] : + pins_pu[i] ? 1'b1 : + pins_pd[i] ? 1'b0 : 1'bz; +`else + // Drive the pin based on whether pullup / pulldown is enabled. + // + // If output is not enabled, then the pin is pulled up or down with the `PullStrength` strength + // Pullup has priority over pulldown. + if (PullStrength == "Pull") begin : gen_pull_strength_pull + assign (pull0, pull1) pins[i] = ~pins_oe[i] ? (pins_pu[i] ? 1'b1 : + pins_pd[i] ? 1'b0 : 1'bz) : 1'bz; + end : gen_pull_strength_pull + else if (PullStrength == "Weak") begin : gen_pull_strength_weak + assign (weak0, weak1) pins[i] = ~pins_oe[i] ? (pins_pu[i] ? 1'b1 : + pins_pd[i] ? 1'b0 : 1'bz) : 1'bz; + end : gen_pull_strength_weak + + // If output enable is 1, strong driver assigns pin to 'value to be driven out'; + // the external strong driver can still affect pin, if exists. + // Else if output enable is 0, weak pullup or pulldown is applied to pin. + // By doing this, we make sure that weak pullup or pulldown does not override + // any 'x' value on pin, that may result due to conflicting values + // between 'value to be driven out' and the external driver's value. + assign pins[i] = pins_oe[i] ? pins_o[i] : 1'bz; +`endif + end : gen_each_pin + +endinterface +`endif diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_if.svg b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_if.svg new file mode 100644 index 0000000..0d624ff --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_if.svg @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + pins_if + + 00 + 01 + 10 + 11 + + + + + + + + + + z + 1 + 0 + 0 + 0 + 1 + + + + + pins_int + + + pu + pd + + + + + + + + + + + pins_oe + + pins_o + + + + + + + + (strong0, strong1) + (pull0, pull1) + + external driver + pins + + diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_ifs.core b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_ifs.core new file mode 100644 index 0000000..4663365 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/pins_ifs.core @@ -0,0 +1,17 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:pins_if" +description: "Common interfaces used in DV" + +filesets: + files_dv: + files: + - pins_if.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/rst_shadowed_if.core b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/rst_shadowed_if.core new file mode 100644 index 0000000..8cbbcaf --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/rst_shadowed_if.core @@ -0,0 +1,17 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:rst_shadowed_if" +description: "Shadowed reset pin interfaces used in DV" + +filesets: + files_dv: + files: + - rst_shadowed_if.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/common_ifs/rst_shadowed_if.sv b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/rst_shadowed_if.sv new file mode 100644 index 0000000..3a7e02e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/common_ifs/rst_shadowed_if.sv @@ -0,0 +1,39 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// +// Interface: rst_shadowed_if +// An interface to drive rst_shadowed_n pin +// By default, the `rst_shadowed_n` pin is directly connected to `rst_n` pin from the IP. +// This interface provide methods to drive `rst_shadowed_n` pin when `drive_shadow_rst_pin()` task is +// called, and can use `reconnect_shadowed_rst_n_to_rst_n()` to reconnect to `rst_n` pin. +interface rst_shadowed_if ( + input rst_n, + output rst_shadowed_n +); + +`ifndef VERILATOR + // include macros and import pkgs + `include "dv_macros.svh" + `include "uvm_macros.svh" + import uvm_pkg::*; +`endif + + bit drive_shadowed_rst_en; + logic shadowed_rst_n; + + // If set `drive_shadowed_rst_en` bit to 0, the `rst_shadowed_n` output will be the same as IP + // level reset pin. + function automatic void reconnect_shadowed_rst_n_to_rst_n(); + drive_shadowed_rst_en = 0; + endfunction + + task automatic drive_shadow_rst_pin(logic val); + shadowed_rst_n = val; + drive_shadowed_rst_en = 1; + endtask + + assign rst_shadowed_n = drive_shadowed_rst_en ? shadowed_rst_n : rst_n; + +endinterface diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/README.md b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/README.md new file mode 100644 index 0000000..9136e8e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/README.md @@ -0,0 +1,134 @@ +# CSR utilities + +This folder implements CSR related methods and test sequences for DV to share across all testbenches. + +## CSR utility package + +`csr_utils_pkg` provides common methods and properties to support and manage CSR accesses and CSR related test sequences. + +### Global types and variables + +All common types and variables are defined at this package level. Examples are: +```systemverilog + uint outstanding_accesses = 0; + uint default_timeout_ns = 1_000_000; +``` + +### Outstanding_accesses + +Historically, `csr_utils_pkg` has used an internal variable to count accesses (read or write) that have not yet completed. +One intended use for this was to avoid injecting resets when CSR accesses were in flight. +This didn't really work very well, so most blocks' testbenches are being ported to avoid worrying about that. +The mechanism is also unaware of register accesses that are not made through this package. + +Sequences that wish to maintain the counter can do so with the following functions: +```systemverilog + function automatic void increment_outstanding_access(); + outstanding_accesses++; + endfunction + + function automatic void decrement_outstanding_access(); + outstanding_accesses--; + endfunction + + task automatic wait_no_outstanding_access(); + wait(outstanding_accesses == 0); + endtask + + function automatic void clear_outstanding_access(); + outstanding_accesses = 0; + endfunction +``` + +### CSR spinwait + +One of the commonly used tasks in `csr_utils_pkg` is `csr_spinwait`. +This task can poll a register or field continuously or periodically until it reads out the expected value. +This task also has a timeout check to fail the test more quickly if the target never returns the expected value. +The following example uses `csr_spinwait` to wait until the `FIFO_FULL` field of the `STATUS` CSR becomes zero: +```systemverilog +csr_spinwait(.ptr(ral.status.fifo_full), .exp_data(1'b0)); +``` + +### Read and check all CSRs + +This task reads all the CSRs in a register block and checks they return their predicted values. +It is primarily intended for after reset, to check CSRs are being reset to the correct values. + +### Reset state + +Because `csr_utils_pkg` is not connected to any interface, methods inside this package are not able to get reset information. +An internal `under_reset` bit can be kept up to date with two functions: +```systemverilog +function automatic void reset_asserted(); + under_reset = 1; +endfunction + +function automatic void reset_deasserted(); + under_reset = 0; +endfunction +``` +This reset information is tracked by `dv_base_scoreboard` (using its `monitor_reset` task). +When that task sees a reset, it calls `reset_asserted` or `reset_deasserted` in its environment config. +That function, in turn, calls the `csr_utils_pkg` function. + +### Global CSR util methods +#### Global methods for CSR and MEM attributes +This package provides methods to access CSR or Memory attributes, such as address, +value, etc. Examples are: + * `get_mem_addr_ranges` + * `decode_csr_or_field` + +The CSR access methods are based on `uvm_reg` methods, such as `uvm_reg::read()`, `uvm_reg::write()`, `uvm_reg::update()`. +For all CSR methods, user can pass either a register or a field handle. +Examples are: + * `csr_rd_check`: + This task takes a register or field does a register read to get the value. + The value returned will then be compared against a prediction for the argument field or register. + To pass the prediction explicitly, leave `compare_vs_ral = 0` and set `compare_value` to the prediction. + If `compare_vs_ral` is true, the task compares against the prediction the register model. + + * `csr_update`: + Perform a register write to update a register or field to the desired value. + +These tasks can be used in blocking or non-blocking mode and also have timeouts. + * In blocking mode, the task will not finish until the CSR access completes. + * Non-blocking mode allows multiple CSR accesses to be issued back-to-back without waiting for responses. + * The tasks run with a timeout in nanoseconds. + If the time runs out, the task will disable the thread making the access and will raise a UVM error. + +## CSR sequence library + +`csr_seq_lib.sv` provides common CSR related test sequences to share across all testbenches. +These test sequences build on the standard sequences provided in UVM1.2 RAL. +The parent class (DUT-specific test or sequence class) that creates them needs to provide a RAL model. +The list of CSRs is extracted from the RAL model to perform the checks. + +In addition, the test sequences provide an ability to exclude a CSR from writes or reads (or both). +This is explained more in the [CSR exclusion methodology](#csr-exclusion-methodology) section below. +All CSR accesses in these sequences are non-blocking to ensure back-to-back scenarios are exercised. + +Supported CSR test sequences are: + * `csr_hw_reset_seq`: + Write all CSRs with random values and then reset the DUT. + After reset, read all CSRs and compare with expected values + + * `csr_rw`: + Write random values to each register in a list, then read the registers back again. + This compares against predictions from the register model. + The predictions are either generated by the sequence or by an external scoreboard. + + * `csr_bit_bash`: + Perform a bit-bash test on each register in a list. + That test, in turn, performs a bit-bash test on each bit in the register. + The bit-bash test for a bit is to write each value (0 and 1) and read it back to check the write worked. + + * `csr_aliasing`: + Perform an aliasing test for each register in a list. + This test writes a random value to the register and then reads every register back again. + The selected register should have the predicted value after the write. + All other registers should have the values they had before the write. + This checks that there is no aliasing between registers in the block. + + * `mem_walk`: + Run `uvm_mem_walk_seq` on every `dv_base_reg_block`. diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_aliasing_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_aliasing_seq.sv new file mode 100644 index 0000000..71465d5 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_aliasing_seq.sv @@ -0,0 +1,172 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// For each CSR, this sequence writes a random value to it and reads ALL CSRs back. The read value +// of the CSR that was written is checked for correctness while adhering to its access policies. The +// read value of all other CSRs are compared against their previous values. This verifies that there +// is no aliasing across the address bits within the valid CSR space. + +class csr_aliasing_seq extends csr_base_seq; + `uvm_object_utils(csr_aliasing_seq) + + // A queue of uvm_reg objects + typedef uvm_reg reg_queue_t[$]; + + // The size of "register chunk" to use in the test. + // + // The list of CSRs to test (test_csrs) is checked in chunks of this size (writing a random value + // to each register in a chunk, then reading back every register in the design to check that there + // was no aliasing). + int unsigned m_chunk_size = 10; + + // The number of registers to read after writing a chunk of registers, looking for values that + // have changed unexpectedly. + int unsigned m_reads_per_chunk = 100; + + extern function new(string name=""); + extern task body(); + + // Write a random value to csr, after applying any write exclusion that has been defined for the + // register. + extern local task randomize_register(uvm_reg csr); + + // Write random values to each register in the list, running the sequences in parallel for maximum + // throughput. + extern local task randomize_chunk(const ref uvm_reg registers[$]); + + // Read back csr using csr_rd_check and checking against the register model. Mask the comparison + // using get_mask_excl_fields (to avoid checking the values of fields that are not modelled). + extern local task read_back_register(uvm_reg csr); + + // Read back every register in the list, using csr_rd_check and checking against the register + // model. + // + // Comparisons are masked using get_mask_excl_fields (to avoid checking the values of fields that + // are not modelled). + extern local task read_back_chunk(uvm_reg registers[$]); + + // Write random values to each register in write_list, then read all the registers in read_list + extern local task test_chunk(uvm_reg write_list[$], uvm_reg read_list[$]); + + // Return a random subset of reg_queue with m_reads_per_chunk registers (or the entire list if + // there aren't that many) + extern local function reg_queue_t sample_reg_list(const ref uvm_reg reg_queue[$]); +endclass + +function csr_aliasing_seq::new(string name=""); + super.new(name); +endfunction + +task csr_aliasing_seq::body(); + uvm_reg total_list[$]; + int unsigned num_chunks; + + // The subset of test_csrs consisting of registers that do not have the CsrExclWrite exclusion. + // This will be split into chunks of size m_chunk_size. + uvm_reg regs_to_write[$]; + + // The subset of test_csrs consisting of registers that do not have the CsrExclInitCheck or + // CsrExclWriteCheck exclusion. Since test_csrs is just a section of all_csrs, this list is + // probably much larger than regs_to_write. + // + // A random sample of m_reads_per_chunk of these registers will be read back for each chunk. + uvm_reg regs_to_read[$]; + + foreach(test_csrs[i]) begin + if (!is_excl(test_csrs[i], CsrExclWrite, CsrAliasingTest)) begin + regs_to_write.push_back(test_csrs[i]); + end + end + foreach (all_csrs[i]) begin + if (!(is_excl(test_csrs[i], CsrExclInitCheck, CsrAliasingTest) || + is_excl(test_csrs[i], CsrExclWriteCheck, CsrAliasingTest))) begin + regs_to_read.push_back(test_csrs[i]); + end + end + + `uvm_info(get_full_name(), + $sformatf({"Aliasing test with list of %0d writable and %0d readable registers ", + "(from a group of %0d registers selected from the %0d that are visible)"}, + regs_to_write.size(), regs_to_read.size(), + test_csrs.size(), all_csrs.size()), + UVM_LOW) + + // The test will break the registers that get written into chunks, of size m_chunk_size. + num_chunks = (regs_to_write.size() + m_chunk_size - 1) / m_chunk_size; + + for (int unsigned i = 0; i < num_chunks; i++) begin + // The [start_idx:end_idx] range is [i*m_chunk_size, (i+1)*m_chunk_size - 1], intersected with + // the set of valid indices for regs_to_write. + int unsigned start_idx = i * m_chunk_size; + int unsigned end_idx = start_idx + m_chunk_size - 1; + + if (end_idx >= regs_to_write.size()) begin + end_idx = regs_to_write.size() - 1; + end + + `uvm_info(get_full_name(), + $sformatf("Testing aliasing with chunk %0d/%0d", i + 1, num_chunks), + UVM_LOW) + for (int unsigned j = start_idx; j <= end_idx; j++) begin + `uvm_info(get_full_name(), $sformatf(" - %0s", regs_to_write[j].get_name()), UVM_MEDIUM) + end + + test_chunk(regs_to_write[start_idx:end_idx], sample_reg_list(regs_to_read)); + end +endtask + +task csr_aliasing_seq::randomize_register(uvm_reg csr); + uvm_reg_data_t wdata; + + if (!std::randomize(wdata)) begin + `uvm_fatal(get_full_name(), "Failed to randomize wdata.") + end + + wdata = get_csr_wdata_with_write_excl(csr, wdata, CsrAliasingTest); + csr_wr(.ptr(csr), .value(wdata), .predict(!external_checker)); +endtask + +task csr_aliasing_seq::randomize_chunk(const ref uvm_reg registers[$]); + fork : isolation_fork begin + foreach (registers[i]) begin + automatic uvm_reg _reg = registers[i]; + fork + randomize_register(_reg); + join_none + end + wait fork; + end join +endtask + +task csr_aliasing_seq::read_back_register(uvm_reg csr); + csr_rd_check(.ptr (csr), + .compare (!external_checker), + .compare_vs_ral(1'b1), + .compare_mask (get_mask_excl_fields(csr, CsrExclWriteCheck, CsrAliasingTest))); +endtask + +task csr_aliasing_seq::read_back_chunk(uvm_reg registers[$]); + fork : isolation_fork begin + foreach (registers[i]) begin + automatic uvm_reg _reg = registers[i]; + fork + read_back_register(_reg); + join_none + end + wait fork; + end join +endtask + +task csr_aliasing_seq::test_chunk(uvm_reg write_list[$], uvm_reg read_list[$]); + randomize_chunk(write_list); + read_back_chunk(read_list); +endtask + +function csr_aliasing_seq::reg_queue_t + csr_aliasing_seq::sample_reg_list(const ref uvm_reg reg_queue[$]); + + uvm_reg ret[$] = reg_queue; + ret.shuffle(); + return (reg_queue.size() < m_reads_per_chunk) ? ret[0:m_reads_per_chunk - 1] : ret; +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_base_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_base_seq.sv new file mode 100644 index 0000000..396dbb8 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_base_seq.sv @@ -0,0 +1,239 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// The base class for CSR sequences, deriving from uvm_reg_sequence +// +// To use this sequence, create the object and then populate models, external_checker, and +// num_test_csrs. Run the sequence by calling the start() task. +// +// Any subclass of this sequence performs tests across a set of registers in the design. The +// complete list of available registers is computed just before the sequence body (in the pre_start +// task), but a test may wish to check a smaller subset of these registers. +// +// To make that possible there is a plusarg-based mechanism: +// +// +num_test_csrs= +// +// If num_test_csrs is a positive number, the list of CSRs in all_csrs is divided into +// contiguous chunks of that length and then the sequence operates on some randomly chosen chunk +// from that list. +// +// If max_num_test_csrs has been set to a positive number after creating the sequence, it is +// used as another upper bound on the number of CSRs in a chunk for the sequence. + +class csr_base_seq extends uvm_reg_sequence #(uvm_sequence #(uvm_reg_item)); + `uvm_object_utils(csr_base_seq) + + // A queue of register models (UVM register blocks), whose registers will be added to the lists of + // CSRs (all_csrs and test_csrs) in pre_start. + dv_base_reg_block models[$]; + + // A flag that is true if there is some external checker (scoreboard). + // + // If it is false then each register write is followed by a call to that register's predict + // function in order to update the mirrored value. Similarly, reads are checked against the + // register's mirrored value (using the by passing a true "compare" argument to the csr_rd_check + // task). + // + // If the flag is true, the sequence doesn't do predict and compare, instead leaving that to the + // scoreboard. + // + // In either case, the prediction and comparison happen as part of the register write/read, which + // means that this sequence can do completely non-blocking writes and reads. + bit external_checker; + + // An upper bound on the number of CSRs that are tested by this sequence. It can be set by the + // creator before starting the sequence. If not overridden, this will be zero (meaning there is no + // upper bound). + int unsigned max_num_test_csrs; + + // A queue holding every register across the blocks in models. + protected uvm_reg all_csrs[$]; + + // A queue of the CSR registers that have been selected for this test. These are contained in + // all_csrs, but may be a proper subset if set_csr_test_range has picked only some of them (as + // instructed by max_num_test_csrs). They will also be shuffled into a random order. + // + // The queue gets populated by set_csr_test_range, which is called by the pre_start task. It is + // then cleared by post_start, to ensure that it will be re-populated if the sequence is run + // again. + protected uvm_reg test_csrs[$]; + + extern function new (string name=""); + + // The pre_start task overrides that of uvm_sequence_base. + // + // It is run just before the body task and is in charge of selecting a subset of all_csrs on which + // the sequence will operate. This subset is written to test_csrs. + extern task pre_start(); + + // The post_start task overrides that of uvm_sequence_base. + // + // It is run just after the body task. In the body task, the sequence will have requested a stream + // of CSR accesses, but the implementation doesn't necessarily wait for the accesses to complete. + // To make sure they have actually done so, the post_start task waits for a period with no + // outstanding CSR accesses (which would mean that each access is done). + // + // The task also clears test_csrs, which means that the same sequence can be run another time and + // the randomisation in set_csr_test_range might pick a different set of test CSRs. + extern task post_start(); + + // Pick a subset of all_csrs and write that to test_csrs. The function's behaviour is described in + // the comment about plusargs before the class. + extern local function void set_csr_test_range(); + + // Return true if this is a CSR or field that has been excluded from the test described in + // csr_test_type by some exclusion (that ultimately came from the hjson register description). + extern function bit is_excl(uvm_object obj, + csr_excl_type_e csr_excl_type, + csr_test_type_e csr_test_type); + + // Return true if this CSR should be excluded by the current sequence. The base class always + // returns false, but this allows more specialised sequences to work over more evenly sized + // chunks. + extern virtual protected function bit csr_excluded(uvm_reg csr); +endclass + +function csr_base_seq::new (string name=""); + super.new(name); +endfunction + +task csr_base_seq::pre_start(); + super.pre_start(); + + // Create test_csrs list only if it is empty. Note that this won't actually do anything if the + // entries in the models array don't have any registers. + if (test_csrs.size() == 0) begin + set_csr_test_range(); + end +endtask + +task csr_base_seq::post_start(); + super.post_start(); + wait_no_outstanding_access(); + test_csrs.delete(); +endtask + +function void csr_base_seq::set_csr_test_range(); + bit has_ntc, has_tcc; + + int unsigned num_csrs; + int num_test_csrs; + + int unsigned start_idx, end_idx; + + // Extract all csrs from the model. If this sequence has specialised the csr_excluded function, + // some CSRs might be skipped. This should help to keep chunks with similar testing times. + all_csrs.delete(); + foreach (models[i]) begin + uvm_reg model_csrs[$]; + models[i].get_registers(model_csrs); + foreach (model_csrs[j]) begin + if (!csr_excluded(model_csrs[j])) begin + all_csrs.push_back(model_csrs[j]); + end else begin + `uvm_info(`gtn, + $sformatf("Skipping register %0s due to exclusion", + model_csrs[j].get_full_name()), + UVM_MEDIUM) + end + end + end + + num_csrs = all_csrs.size(); + if (!num_csrs) return; + + // Has the num_test_csrs plusarg been supplied to give the maximum size of a chunk? + if ($value$plusargs("num_test_csrs=%0d", num_test_csrs)) begin + // Check that the user hasn't requested chunks of less than one: that wouldn't make much sense. + // Generate a UVM error and ignore the plusarg. + if (num_test_csrs < 1) begin + `uvm_error(`gtn, $sformatf("+num_test_csrs=%0d, which is not positive.", num_test_csrs)) + end else begin + has_ntc = 1; + + // If num_test_csrs is greater than the total number of CSRs, clip it to what is available. + if (num_test_csrs > num_csrs) begin + num_test_csrs = num_csrs; + end + end + end + + if (has_ntc || max_num_test_csrs > 0) begin + int unsigned num_chunks, chunk_size, chunk_idx; + + // Take the smaller supplied value of num_test_csrs and max_num_test_csrs to give an upper bound + // on the size of a chunk. + int unsigned max_chunk_size; + if (max_num_test_csrs > 0) begin + if (has_ntc) begin + max_chunk_size = (max_num_test_csrs < num_test_csrs) ? max_num_test_csrs : num_test_csrs; + end else begin + max_chunk_size = max_num_test_csrs; + end + end else begin + max_chunk_size = num_test_csrs; + end + + // Now divide the total number of CSRs by that bound. Rounding up gives enough chunks to be able + // to cover the whole list. + num_chunks = (num_csrs + max_chunk_size - 1) / max_chunk_size; + + // Given the number of chunks, we can now divide the number of CSRs by that to get the size of a + // chunk. Note that this will be at most max_chunk_size but may be much smaller. + // + // For example, if max_chunk_size = 50 and num_csrs = 51 then we will get 2 = ceil(51/50) chunks + // but then assign ceil(51/2) = 26 tests to each chunk, which gets "maximum parallelism" by + // avoiding dramatic differences between the size of chunks. + chunk_size = (num_csrs + num_chunks - 1) / num_chunks; + + // Pick a chunk index (less than num_chunks) at random + chunk_idx = $urandom_range(num_chunks - 1); + + // Finally, convert that into a pair of CSR indices (where end_idx is strictly past the end) + start_idx = chunk_idx * chunk_size; + end_idx = start_idx + chunk_size - 1; + end else begin + // If neither value was provided, we work on the entire list of CSRs at once. + start_idx = 0; + end_idx = num_csrs - 1; + end + + // At this point, start_idx and end_idx should have been chosen, with start_idx < end_idx. Convert + // the end index to an inclusive limit, by clipping to the number of CSRs. + end_idx = (end_idx >= num_csrs) ? num_csrs - 1 : end_idx; + + // At this point, we should have 0 <= start_idx <= end_idx < num_csrs. If that isn't true, there + // was a bug in the code above. + `DV_CHECK_FATAL(start_idx <= end_idx && end_idx < num_csrs) + + // Replace any existing list of CSRs with the chosen chunk in a random order. + test_csrs.delete(); + for (int i = start_idx; i <= end_idx; i++) begin + test_csrs.push_back(all_csrs[i]); + `uvm_info(`gtn, $sformatf("Testing CSR %0s, reset: 0x%0x.", all_csrs[i].get_full_name(), + all_csrs[i].get_mirrored_value()), UVM_HIGH) + end + `uvm_info(`gtn, + $sformatf("Testing %0d csrs [%0d - %0d] from supplied models.", + test_csrs.size(), start_idx, end_idx), + UVM_MEDIUM) + + test_csrs.shuffle(); +endfunction + +function bit csr_base_seq::is_excl(uvm_object obj, + csr_excl_type_e csr_excl_type, + csr_test_type_e csr_test_type); + csr_excl_item csr_excl = get_excl_item(obj); + if (csr_excl == null) begin + return 0; + end else begin + return csr_excl.is_excl(obj, csr_excl_type, csr_test_type); + end +endfunction + +function bit csr_base_seq::csr_excluded(uvm_reg csr); + return 1'b0; +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_hw_reset_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_hw_reset_seq.sv new file mode 100644 index 0000000..f91003b --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_hw_reset_seq.sv @@ -0,0 +1,65 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// This sequence reads all CSRs and checks their values against the reset value provided in the RAL +// specification. Note that this does not sufficiently qualify as the CSR HW reset test. The 'full' +// CSR HW reset test is constructed externally by running csr_write_seq first, issuing reset and +// only then running this sequence. + +class csr_hw_reset_seq extends csr_base_seq; + `uvm_object_utils(csr_hw_reset_seq) + + extern function new (string name=""); + + // Read all CSRs, expecting their values to match their reset values in the register block. + extern task body(); + + // Read the given CSR if it is not excluded and check its value matches the expected reset value. + // If the register has an HDL path, use two reads, starting with a backdoor one. + extern local task test_one_csr(uvm_reg csr); + + // Return true if the CSR should be skipped by this sequence + extern protected function bit csr_excluded(uvm_reg csr); +endclass + +function csr_hw_reset_seq::new (string name=""); + super.new(name); +endfunction + +task csr_hw_reset_seq::body(); + foreach (test_csrs[i]) begin + test_one_csr(test_csrs[i]); + end +endtask + +task csr_hw_reset_seq::test_one_csr(uvm_reg csr); + uvm_reg_data_t compare_mask = get_mask_excl_fields(csr, CsrExclInitCheck, CsrHwResetTest); + + `uvm_info(`gtn, + $sformatf("Verifying reset value of register %0s", csr.get_full_name()), + UVM_MEDIUM) + + // Read CSR twice, one from backdoor (if path available), the other from frontdoor. + if (csr.has_hdl_path()) begin + // Reading from backdoor can ensure that we deposit value into the storage rather than just a + // net. If we mistakenly deposit to a net, reset can't clear it and this check will fail. + csr_rd_check(.ptr (csr), + .backdoor (1), + .compare (!external_checker), + .compare_vs_ral(1'b1), + .compare_mask (compare_mask)); + end + + // Read and check value via frontdoor. + csr_rd_check(.ptr (csr), + .backdoor (0), + .blocking (0), + .compare (!external_checker), + .compare_vs_ral(1'b1), + .compare_mask (compare_mask)); +endtask + +function bit csr_hw_reset_seq::csr_excluded(uvm_reg csr); + return is_excl(csr, CsrExclInitCheck, CsrHwResetTest); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_seq_lib.sv b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_seq_lib.sv new file mode 100644 index 0000000..0ba9fc8 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_seq_lib.sv @@ -0,0 +1,340 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// CSR suite of sequences that do writes and reads to CSRs +// includes hw_reset, rw, bit_bash and aliasing tests for CSRs, and mem_walk for uvm_mems +// The sequences perform csr writes and reads and follow the standard csr test suite. If external +// checker is enabled, then the external entity is required to update the mirrored value on +// writes. If not enabled, the sequences themselves call predict function to update the mirrored +// value. Consequently, the read values are checked against the mirrored value and not the +// previously written value. This approach is better since it takes care of special +// register and field access policies. Also, we use csr_rd_check task instead of csr_mirror to take +// field exclusions into account. +// +// Exclusions are to be provided using the csr_excl_item item (see class for more details). + +//-------------------------------------------------------------------------------------------------- +// Class: csr_write_seq +// Brief Description: This sequence writes a random value to all CSRs. It does not perform any +// checks. It is run as the first step of the CSR HW reset test. +//-------------------------------------------------------------------------------------------------- +class csr_write_seq extends csr_base_seq; + static bit test_backdoor_path_done; // only run once + bit en_rand_backdoor_write; + `uvm_object_utils(csr_write_seq) + + `uvm_object_new + + virtual task body(); + uvm_reg_data_t wdata; + + // check all hdl paths are valid + if (!test_backdoor_path_done) begin + foreach (models[i]) begin + bkdr_reg_path_e path_kind; + uvm_reg_mem_hdl_paths_seq hdl_check_seq; + + hdl_check_seq = uvm_reg_mem_hdl_paths_seq::type_id::create("hdl_check_seq"); + do begin + // Test the HDL paths for correctness if they exist. + if (models[i].has_hdl_path(path_kind.name)) begin + hdl_check_seq.abstractions.push_back(path_kind.name); + end + path_kind = path_kind.next; + end while (path_kind != path_kind.first); + hdl_check_seq.model = models[i]; + hdl_check_seq.start(null); + end + test_backdoor_path_done = 1; + end + + foreach (test_csrs[i]) begin + dv_base_reg dv_csr; + bit backdoor; + // check if parent block or register is excluded from write + if (is_excl(test_csrs[i], CsrExclWrite, CsrHwResetTest)) begin + `uvm_info(`gtn, $sformatf("Skipping register %0s due to CsrExclWrite exclusion", + test_csrs[i].get_full_name()), UVM_MEDIUM) + continue; + end + + `uvm_info(`gtn, $sformatf("Writing random data to register %0s", + test_csrs[i].get_full_name()), UVM_MEDIUM) + + `DV_CHECK_STD_RANDOMIZE_FATAL(wdata) + wdata = get_csr_wdata_with_write_excl(test_csrs[i], wdata, CsrHwResetTest); + + `downcast(dv_csr, test_csrs[i]) + if (en_rand_backdoor_write && test_csrs[i].has_hdl_path() && !dv_csr.get_is_ext_reg()) begin + `DV_CHECK_STD_RANDOMIZE_WITH_FATAL(backdoor, backdoor dist {0 :/ 7, 1 :/ 3};) + end + + if (backdoor) begin + string str_kinds[$]; + + test_csrs[i].get_hdl_path_kinds(str_kinds); + str_kinds.shuffle(); + + foreach (str_kinds[j]) begin + bkdr_reg_path_e enum_kind; + // Convert string name to an enum + `DV_CHECK_FATAL(uvm_enum_wrapper#(bkdr_reg_path_e)::from_name(str_kinds[j], enum_kind)) + + csr_poke(.ptr(test_csrs[i]), .value(wdata), .kind(enum_kind)); + + `DV_CHECK_STD_RANDOMIZE_FATAL(wdata) + wdata = get_csr_wdata_with_write_excl(test_csrs[i], wdata, CsrHwResetTest); + end + end else begin + csr_wr(.ptr(test_csrs[i]), .value(wdata), .blocking(0)); + end + end + endtask + +endclass + + +//-------------------------------------------------------------------------------------------------- +// Class: csr_rw_seq +// Brief Description: This seq writes a random value to a CSR and reads it back. The read value +// is checked for correctness while adhering to its access policies. A random choice is made between +// reading back the CSR as a whole or reading fields individually, so that partial accesses are made +// into the DUT as well. +//-------------------------------------------------------------------------------------------------- +class csr_rw_seq extends csr_base_seq; + `uvm_object_utils(csr_rw_seq) + + `uvm_object_new + + virtual task body(); + foreach (test_csrs[i]) begin + uvm_reg_data_t wdata; + uvm_reg_field test_fields[$]; + dv_base_reg test_dv_csr; + bit supports_byte_enable; + bit do_field_rd_check; + + // The test_csrs list may be jumbled from different RAL models. Hence, we find at runtime, if + // the interface supports byte_accesses. + begin + uvm_reg_map map = test_csrs[i].get_default_map(); + uvm_reg_adapter adapter = map.get_adapter(); + if (adapter != null) begin + supports_byte_enable = adapter.supports_byte_enable; + end + end + + // check if parent block or register is excluded from write + if (is_excl(test_csrs[i], CsrExclWrite, CsrRwTest)) begin + `uvm_info(`gtn, $sformatf("Skipping register %0s due to CsrExclWrite exclusion", + test_csrs[i].get_full_name()), UVM_MEDIUM) + continue; + end + + `uvm_info(`gtn, $sformatf("Verifying register read/write for %0s", + test_csrs[i].get_full_name()), UVM_MEDIUM) + + `DV_CHECK_STD_RANDOMIZE_FATAL(wdata) + wdata = get_csr_wdata_with_write_excl(test_csrs[i], wdata, CsrRwTest); + + // if external checker is not enabled and writes are made non-blocking, then we need to + // pre-predict so that the mirrored value will be updated. if we dont, then csr_rd_check task + // might pick up stale mirrored value + // the pre-predict also needs to happen after the register is being written, to make sure the + // register is getting the updated access information. + csr_wr(.ptr(test_csrs[i]), .value(wdata), .blocking(0), .predict(!external_checker)); + + // Shadow register requires two writes with the same value to write registers into DUT. + // In `csr_wr` task, the `predict` task is triggered after two shadow writes are done. + // To avoid non-blocking access where shadow register read might be triggered between two + // consecutive shadow register write, we will wait until all outstanding accesses finish, + // then issue a shadow register read. + `downcast(test_dv_csr, test_csrs[i]) + if (test_dv_csr.get_is_shadowed) wait_no_outstanding_access(); + + `DV_CHECK_STD_RANDOMIZE_WITH_FATAL(do_field_rd_check, + !supports_byte_enable -> !do_field_rd_check;) + do_check_csr_or_field_rd(.csr(test_csrs[i]), + .blocking(0), + .compare(!external_checker), + .compare_vs_ral(1), + .do_csr_field_rd_check(do_field_rd_check), + .csr_excl_type(CsrExclWriteCheck), + .csr_test_type(CsrRwTest)); + + wait_if_max_outstanding_accesses_reached(); + end + endtask + +endclass + +//-------------------------------------------------------------------------------------------------- +// Class: csr_bit_bash_seq +// Brief Description: This sequence walks a 1 through each CSR by writing one bit at a time and +// reading the CSR back. The read value is checked for correctness while adhering to its access +// policies. This verifies that there is no aliasing within the fields / bits of a CSR. +//-------------------------------------------------------------------------------------------------- +class csr_bit_bash_seq extends csr_base_seq; + `uvm_object_utils(csr_bit_bash_seq) + + `uvm_object_new + + virtual task body(); + int unsigned total_count = test_csrs.size(); + int unsigned done_count = 0; + + `uvm_info(`gtn, + $sformatf("Running bit bash sequence for %0d registers", total_count), + UVM_MEDIUM) + foreach (test_csrs[i]) begin + done_count++; + `uvm_info(`gtn, + $sformatf("Verifying register bit bash for %0s (register %0d/%0d)", + test_csrs[i].get_full_name(), done_count, total_count), + UVM_MEDIUM) + + // check if parent block or register is excluded from write + if (is_excl(test_csrs[i], CsrExclWrite, CsrBitBashTest) || + is_excl(test_csrs[i], CsrExclWriteCheck, CsrBitBashTest)) begin + `uvm_info(`gtn, $sformatf("Skipping register %0s due to CsrExclWrite/WriteCheck exclusion", + test_csrs[i].get_full_name()), UVM_MEDIUM) + continue; + end + + bash_register(test_csrs[i]); + end + + endtask + + // Run bit bash test on the given register. + // + // The basic idea is that we test each bit of the register with the bash_kth_bit task, checking + // that we can set and clear the register as expected. This task takes field exclusions and + // read/write masks into account when calculating how to run the bash_kth_bit task across the + // register. + virtual task bash_register(uvm_reg csr); + uvm_reg_field fields[$]; + string mode[`UVM_REG_DATA_WIDTH]; + uvm_reg_data_t dc_mask; // dont write or read + uvm_reg_data_t no_cmp_mask; // read but dont compare + int n_bits; + string field_access; + int next_lsb; + + n_bits = csr.get_n_bytes() * 8; + + // Let's see what kind of bits we have... + csr.get_fields(fields); + + next_lsb = 0; + dc_mask = 0; + no_cmp_mask = 0; + + foreach (fields[j]) begin + int lsb, w, dc, no_cmp; + + field_access = fields[j].get_access(csr.get_default_map()); + no_cmp = (fields[j].get_compare() == UVM_NO_CHECK); + lsb = fields[j].get_lsb_pos(); + w = fields[j].get_n_bits(); + + // Exclude write-only fields from compare because you are not supposed to read them + case (field_access) + "WO", "WOC", "WOS", "WO1", "NOACCESS", "": no_cmp = 1; + default: no_cmp = 0; + endcase + + // skip fields that are wr-excluded + if (is_excl(fields[j], CsrExclWrite, CsrBitBashTest)) begin + `uvm_info(`gtn, $sformatf("Skipping field %0s due to CsrExclWrite exclusion", + fields[j].get_full_name()), UVM_MEDIUM) + dc = 1; + end + + // ignore fields that are init or rd-excluded + no_cmp = is_excl(fields[j], CsrExclInitCheck, CsrBitBashTest) || + is_excl(fields[j], CsrExclWriteCheck, CsrBitBashTest) ; + + // Any unused bits below the LSB of this field? + while (next_lsb < lsb) mode[next_lsb++] = "RO"; + + repeat (w) begin + mode[next_lsb] = field_access; + dc_mask[next_lsb] = dc; + no_cmp_mask[next_lsb] = no_cmp; + next_lsb++; + end + end + + // Any unused bits above the top field, but that we will still look at with bash_kth_bit? + while (next_lsb < n_bits) begin + mode[next_lsb++] = "RO"; + end + + // Bash the kth bit + for (int k = 0; k < n_bits; k++) begin + // Cannot test unpredictable bit behavior + if (dc_mask[k]) continue; + bash_kth_bit(csr, k, mode[k], no_cmp_mask); + end + endtask + + // A bit bashing sequence for bit k of register rg. + // + // This works by writing the bit as one value and reading it back, then writing the other value + // and reading that back, checking that each write sets the value as expected. + // + // The mask argument gives bits that won't be compared when reading the value back. Note that this + // task is still worth running even if the k'th bit of mask is set: it might be that writes to + // that bit of the register mess up other bits/fields in the register, and this task will spot if + // that happens. + task bash_kth_bit(uvm_reg rg, + int k, + string mode, + uvm_reg_data_t mask); + + uvm_reg_data_t val; + string err_msg; + + `uvm_info(`gtn, $sformatf("bashing %0s bit #%0d", mode, k), UVM_HIGH) + repeat (2) begin + val = rg.get(); + val[k] = ~val[k]; + err_msg = $sformatf("Wrote %0s[%0d]: %0b", rg.get_full_name(), k, val[k]); + csr_wr(.ptr(rg), .value(val), .blocking(1), .predict(!external_checker)); + + // uvm_reg waits until transaction is completed, before start another read/write in same reg + csr_rd_check(.ptr (rg), + .blocking (0), + .compare (!external_checker), + .compare_vs_ral(1'b1), + .compare_mask (~mask), + .err_msg (err_msg)); + end + endtask: bash_kth_bit + +endclass + +//-------------------------------------------------------------------------------------------------- +// Class: csr_mem_walk_seq +// Brief Description: This seq walks through each address of the memory by running the default +// UVM mem walk sequence. +//-------------------------------------------------------------------------------------------------- +class csr_mem_walk_seq extends csr_base_seq; + uvm_mem_walk_seq mem_walk_seq; + + `uvm_object_utils(csr_mem_walk_seq) + + `uvm_object_new + + virtual task body(); + mem_walk_seq = uvm_mem_walk_seq::type_id::create("mem_walk_seq"); + foreach (models[i]) begin + `uvm_info(`gfn, $sformatf("Testing model %0s", models[i].get_full_name()), UVM_LOW) + mem_walk_seq.model = models[i]; + mem_walk_seq.start(null); + end + endtask : body + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_utils.core b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_utils.core new file mode 100644 index 0000000..bbe14c8 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_utils.core @@ -0,0 +1,24 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:csr_utils" +description: "CSR utilities" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_utils + - lowrisc:dv:dv_base_reg + files: + - csr_utils_pkg.sv + - csr_base_seq.sv: {is_include_file: true} + - csr_hw_reset_seq.sv: {is_include_file: true} + - csr_aliasing_seq.sv: {is_include_file: true} + - csr_seq_lib.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_utils_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_utils_pkg.sv new file mode 100644 index 0000000..1e1b4f2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/csr_utils/csr_utils_pkg.sv @@ -0,0 +1,868 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package csr_utils_pkg; + // dep packages + import uvm_pkg::*; + import dv_utils_pkg::*; + import dv_base_reg_pkg::*; + export dv_base_reg_pkg::csr_field_t, dv_base_reg_pkg::decode_csr_or_field; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + // local types and variables + uint outstanding_accesses = 0; + uint default_timeout_ns = 2_000_000; // 2ms + uint default_spinwait_timeout_ns = 10_000_000; // 10ms + bit default_csr_blocking = 1; + uvm_check_e default_csr_check = UVM_CHECK; + bit under_reset = 0; + int max_outstanding_accesses = 100; + uvm_reg_frontdoor default_user_frontdoor = null; + + function automatic void increment_outstanding_access(); + outstanding_accesses++; + `uvm_info($sformatf("%m"), $sformatf("%0d", outstanding_accesses), UVM_HIGH) + endfunction + + function automatic void decrement_outstanding_access(); + outstanding_accesses--; + `uvm_info($sformatf("%m"), $sformatf("%0d", outstanding_accesses), UVM_HIGH) + endfunction + + task automatic wait_no_outstanding_access(); + wait(outstanding_accesses == 0); + endtask + + function automatic void clear_outstanding_access(); + outstanding_accesses = 0; + endfunction + + function automatic bit has_outstanding_access(); + return outstanding_accesses > 0; + endfunction + + // timeout may happen if we issue too many non-blocking accesses at once + // limit the nonblocking items to be up to max outstanding + task automatic wait_if_max_outstanding_accesses_reached(int max = max_outstanding_accesses); + wait(outstanding_accesses <= max); + endtask + + function automatic void reset_asserted(); + under_reset = 1; + endfunction + + function automatic void reset_deasserted(); + under_reset = 0; + endfunction + + // get mem object from address + function automatic uvm_mem get_mem_by_addr(uvm_reg_block ral, uvm_reg_addr_t addr); + uvm_mem mem; + addr[1:0] = 0; + mem = ral.default_map.get_mem_by_offset(addr); + + if (mem == null) begin + `uvm_fatal($sformatf("%m"), + $sformatf("Cannot find a memory at offset 0x%0h in reg_block '%0s'.", + addr, ral.get_name())) + end + + return mem; + endfunction + + // get mem access like RW, RO + function automatic string get_mem_access_by_addr(uvm_reg_block ral, uvm_reg_addr_t addr); + uvm_mem mem = get_mem_by_addr(ral, addr); + return mem.get_access(); + endfunction + + // This function return mirrored value of reg/field of given RAL + function automatic uvm_reg_data_t get_reg_fld_mirror_value(uvm_reg_block ral, + string reg_name, + string field_name = ""); + uvm_reg csr; + uvm_reg_field fld; + uvm_reg_data_t result; + csr = ral.get_reg_by_name(reg_name); + `DV_CHECK_NE_FATAL(csr, null, "", $sformatf("%m")) + // return field mirror value if field_name is passed, else return reg mirror value + if (field_name != "") begin + fld = csr.get_field_by_name(field_name); + `DV_CHECK_NE_FATAL(fld, null, "", $sformatf("%m")) + result = fld.get_mirrored_value(); + end + else begin + result = csr.get_mirrored_value(); + end + return result; + endfunction : get_reg_fld_mirror_value + + // get updated reg value by using new specific field value + function automatic uvm_reg_data_t get_csr_val_with_updated_field(uvm_reg_field field, + uvm_reg_data_t csr_value, + uvm_reg_data_t field_value); + uvm_reg_data_t mask = (1 << field.get_n_bits()) - 1; + uint shift = field.get_lsb_pos(); + csr_value = csr_value & ~(mask << shift) | ((mask & field_value) << shift); + return csr_value; + endfunction + + // wait until current csr op is complete + task automatic csr_wait(input uvm_reg csr); + `uvm_info($sformatf("%m"), $sformatf("%0s: wait_busy: %0b", + csr.get_full_name(), csr.m_is_busy), UVM_HIGH) + wait(csr.m_is_busy == 1'b0); + `uvm_info($sformatf("%m"), $sformatf("%0s: done wait_busy: %0b", + csr.get_full_name(), csr.m_is_busy), UVM_HIGH) + endtask + + // Use `csr_wr` to construct `csr_update` to avoid replicated codes to handle nonblocking, + // shadow writes etc + task automatic csr_update(input uvm_reg csr, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input bit blocking = default_csr_blocking, + input uint timeout_ns = default_timeout_ns, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor, + input bit en_shadow_wr = 1); + uvm_reg_field fields[$]; + uvm_reg_data_t value; + + // below is partial replication of the uvm_reg_field::update() logic in UVM1.2 source code + if (!csr.needs_update()) return; + csr.get_fields(fields); + // Concatenate the write-to-update values from each field + // Fields are stored in LSB or MSB order + value = 0; + foreach (fields[i]) begin + value |= fields[i].XupdateX() << fields[i].get_lsb_pos(); + end + + csr_wr(.ptr(csr), .value(value), .check(check), .path(path), .blocking(blocking), .backdoor(0), + .timeout_ns(timeout_ns), .predict(0), .map(map), .user_ftdr(user_ftdr), + .en_shadow_wr(en_shadow_wr)); + endtask + + task automatic csr_wr(input uvm_object ptr, + input uvm_reg_data_t value, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input bit blocking = default_csr_blocking, + input bit backdoor = 0, + input uint timeout_ns = default_timeout_ns, + input bit predict = 0, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor, + input bit en_shadow_wr = 1); + if (backdoor) begin + csr_poke(ptr, value, check, predict); + end else begin + csr_field_t csr_or_fld = decode_csr_or_field(ptr); + + // if it's a field write, still do full CSR write and use mirrored value for the other fields + if (csr_or_fld.field != null) begin + // get full CSR value + value = get_csr_val_with_updated_field(csr_or_fld.field, `gmv(csr_or_fld.csr), value); + end + + if (blocking) begin + csr_wr_sub(csr_or_fld.csr, value, check, path, timeout_ns, predict, map, user_ftdr, + en_shadow_wr); + end else begin + fork + begin + csr_wr_sub(csr_or_fld.csr, value, check, path, timeout_ns, predict, map, user_ftdr, + en_shadow_wr); + end + join_none + // Add #0 to ensure that this thread starts executing before any subsequent call + #0; + end + end + endtask + + // subroutine of csr_wr, don't use it directly + task automatic csr_wr_sub(input uvm_reg csr, + input uvm_reg_data_t value, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input uint timeout_ns = default_timeout_ns, + input bit predict = 0, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor, + input bit en_shadow_wr = 1); + fork + begin : isolation_fork + fork + begin + dv_base_reg dv_reg; + `downcast(dv_reg, csr, "", fatal, $sformatf("%m")) + + increment_outstanding_access(); + csr_pre_write_sub(csr, en_shadow_wr); + + csr_wr_and_predict_sub(.csr(csr), .value(value), .check(check), .path(path), + .predict(predict), .map(map), .user_ftdr(user_ftdr)); + if (en_shadow_wr && dv_reg.get_is_shadowed()) begin + csr_wr_and_predict_sub(.csr(csr), .value(value), .check(check), .path(path), + .predict(predict), .map(map), .user_ftdr(user_ftdr)); + end + + csr_post_write_sub(csr, en_shadow_wr); + decrement_outstanding_access(); + end + begin + `DV_WAIT_TIMEOUT(timeout_ns, $sformatf("%m"), + $sformatf("Timeout waiting to csr_wr %0s (addr=0x%0h)", + csr.get_full_name(), csr.get_address())) + end + join_any + disable fork; + end : isolation_fork + join + endtask + + // internal task, don't use it directly + task automatic csr_wr_and_predict_sub(uvm_reg csr, + uvm_reg_data_t value, + uvm_check_e check, + uvm_path_e path, + bit predict, + uvm_reg_map map, + uvm_reg_frontdoor user_ftdr); + uvm_status_e status; + + if (user_ftdr != null) csr.set_frontdoor(user_ftdr); + csr.write(.status(status), .value(value), .path(path), .map(map), .prior(100)); + // TODO: need to remove the frontdoor to switch back to the default, + // but this doesn't work: if (user_ftdr != null) ptr.set_frontdoor(null); + + if (under_reset) return; + if (check == UVM_CHECK) begin + `DV_CHECK_EQ(status, UVM_IS_OK, + $sformatf("trying to write csr %0s", csr.get_full_name()), + error, $sformatf("%m")) + end + // Only update the predicted value if status is ok (otherwise the write isn't completed + // successfully and the design shouldn't have accepted the written value) + if (status == UVM_IS_OK && predict) begin + void'(csr.predict(.value(value), .kind(UVM_PREDICT_WRITE))); + end + endtask + + task automatic csr_pre_write_sub(uvm_reg csr, bit en_shadow_wr); + dv_base_reg dv_reg; + `downcast(dv_reg, csr, "", fatal, $sformatf("%m")) + if (dv_reg.get_is_shadowed() && en_shadow_wr) begin + dv_reg.atomic_en_shadow_wr.get(1); + end + endtask + + task automatic csr_post_write_sub(uvm_reg csr, bit en_shadow_wr); + dv_base_reg dv_reg; + `downcast(dv_reg, csr, "", fatal, $sformatf("%m")) + if (dv_reg.get_is_shadowed() && en_shadow_wr) begin + dv_reg.atomic_en_shadow_wr.put(1); + end + endtask + + // backdoor write csr + task automatic csr_poke(input uvm_object ptr, + input uvm_reg_data_t value, + input uvm_check_e check = default_csr_check, + input bit predict = 0, + input bkdr_reg_path_e kind = BkdrRegPathRtl); + csr_field_t csr_or_fld = decode_csr_or_field(ptr); + uvm_status_e status; + uvm_reg_data_t old_mirrored_val; + + if (csr_or_fld.field != null) begin + old_mirrored_val = csr_or_fld.field.get_mirrored_value(); + csr_or_fld.field.poke(.status(status), .value(value), .kind(kind.name)); + end else begin + old_mirrored_val = csr_or_fld.csr.get_mirrored_value(); + csr_or_fld.csr.poke(.status(status), .value(value), .kind(kind.name)); + end + if (check == UVM_CHECK && status != UVM_IS_OK) begin + string str; + uvm_hdl_path_concat paths[$]; + csr_or_fld.csr.get_full_hdl_path(paths, kind.name); + foreach (paths[0].slices[i]) str = $sformatf("%0s\n%0s", str, paths[0].slices[i].path); + `uvm_fatal($sformatf("%m"), $sformatf("poke failed for %0s, check below paths %0s", + ptr.get_full_name(), str)) + end + // poke always updates predict value, if predict == 0, revert back to old mirrored value + if (!predict || kind == BkdrRegPathRtlShadow) begin + if (csr_or_fld.field != null) begin + void'(csr_or_fld.field.predict(.value(old_mirrored_val), .kind(UVM_PREDICT_DIRECT), + .path(UVM_BACKDOOR))); + end else begin + void'(csr_or_fld.csr.predict(.value(old_mirrored_val), .kind(UVM_PREDICT_DIRECT), + .path(UVM_BACKDOOR))); + end + end + endtask + + task automatic csr_rd(input uvm_object ptr, // accept reg or field + output uvm_reg_data_t value, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input bit blocking = default_csr_blocking, + input bit backdoor = 0, + input uint timeout_ns = default_timeout_ns, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + uvm_status_e status; + if (blocking) begin + csr_rd_sub(.ptr(ptr), .value(value), .status(status), .check(check), .path(path), + .backdoor(backdoor), .timeout_ns(timeout_ns), .map(map), .user_ftdr(user_ftdr)); + end else begin + if (backdoor) `uvm_error($sformatf("%m"), "Non-blocking backdoor access doesn't make sense.") + fork + csr_rd_sub(.ptr(ptr), .value(value), .status(status), .check(check), .path(path), + .backdoor(backdoor), .timeout_ns(timeout_ns), .map(map), .user_ftdr(user_ftdr)); + join_none + // Add #0 to ensure that this thread starts executing before any subsequent call + #0; + end + endtask + + // subroutine of csr_rd, don't use it directly + task automatic csr_rd_sub(input uvm_object ptr, // accept reg or field + output uvm_reg_data_t value, + output uvm_status_e status, + input bit backdoor = 0, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input uint timeout_ns = default_timeout_ns, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + if (backdoor) begin + value = csr_peek(ptr, check); + status = UVM_IS_OK; + return; + end + fork + begin : isolation_fork + csr_field_t csr_or_fld; + fork + begin + increment_outstanding_access(); + csr_or_fld = decode_csr_or_field(ptr); + if (user_ftdr != null) csr_or_fld.csr.set_frontdoor(user_ftdr); + if (csr_or_fld.field != null) begin + csr_or_fld.field.read(.status(status), .value(value), .path(path), .map(map), + .prior(100)); + end else begin + csr_or_fld.csr.read(.status(status), .value(value), .path(path), .map(map), + .prior(100)); + end + // TODO: need to remove the frontdoor to switch back to the default, + // but this doesn't work: if (user_ftdr != null) ptr.set_frontdoor(null); + if (check == UVM_CHECK && !under_reset) begin + `DV_CHECK_EQ(status, UVM_IS_OK, + $sformatf("trying to read csr/field %0s", ptr.get_full_name()), + error, $sformatf("%m")) + end + decrement_outstanding_access(); + end + begin + `DV_WAIT_TIMEOUT(timeout_ns, $sformatf("%m"), + $sformatf("Timeout waiting to csr_rd %0s (addr=0x%0h)", + ptr.get_full_name(), csr_or_fld.csr.get_address())) + end + join_any + disable fork; + end : isolation_fork + join + endtask + + // backdoor read csr + // uvm_reg::peek() returns a 2-state value, directly get data from hdl path + function automatic uvm_reg_data_t csr_peek(uvm_object ptr, + uvm_check_e check = default_csr_check, + bkdr_reg_path_e kind = BkdrRegPathRtl); + csr_field_t csr_or_fld = decode_csr_or_field(ptr); + uvm_reg csr = csr_or_fld.csr; + uvm_reg_data_t value = 0; + + uvm_hdl_path_concat paths[$]; + csr.get_full_hdl_path(paths, kind.name); + + `DV_CHECK_FATAL(paths.size() > 0, + $sformatf("No backdoor defined for %0s path's %0s", + csr.get_full_name(), kind.name), + $sformatf("%m")) + + foreach (paths[0].slices[i]) begin + uvm_reg_data_t field_val; + `DV_CHECK_FATAL(uvm_hdl_read(paths[0].slices[i].path, field_val), + $sformatf("Failed to read %s, slice %d, at path %s", + csr.get_full_name(), i, paths[0].slices[i].path), + $sformatf("%m")) + if (check == UVM_CHECK) `DV_CHECK_EQ($isunknown(field_val), 0, "", error, $sformatf("%m")) + + value |= field_val << paths[0].slices[i].offset; + end + + // We now have the contents of the field or register in value. If ptr was a sub-field of some + // register, it will be laid out in the same way as the field is laid out in the register. + // That's no problem: we can just extract the relevant field from the laid-out value here. + if (csr_or_fld.field != null) value = get_field_val(csr_or_fld.field, value); + + return value; + endfunction + + task automatic csr_rd_check(input uvm_object ptr, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input bit blocking = default_csr_blocking, + input bit backdoor = 0, + input uint timeout_ns = default_timeout_ns, + input bit compare = 1'b1, + input bit compare_vs_ral = 1'b0, + input uvm_reg_data_t compare_mask = '1, + input uvm_reg_data_t compare_value = 0, + input string err_msg = "", + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + fork + begin : isolation_fork + fork + begin + csr_field_t csr_or_fld; + uvm_status_e status; + uvm_reg_data_t obs; + uvm_reg_data_t exp; + uvm_reg_data_t reset_val; + + csr_or_fld = decode_csr_or_field(ptr); + + csr_rd_sub(.ptr(ptr), .value(obs), .status(status), .check(check), .path(path), + .backdoor(backdoor), .timeout_ns(timeout_ns), .map(map), + .user_ftdr(user_ftdr)); + + // get mirrored value after read to make sure the read reg access is updated + if (csr_or_fld.field != null) begin + exp = csr_or_fld.field.get_mirrored_value(); + reset_val = csr_or_fld.field.get_reset(); + end else begin + exp = csr_or_fld.csr.get_mirrored_value(); + reset_val = csr_or_fld.csr.get_reset(); + end + if (compare && status == UVM_IS_OK && !under_reset) begin + obs = obs & compare_mask; + exp = (compare_vs_ral ? exp : compare_value) & compare_mask; + `DV_CHECK_EQ(obs, exp, $sformatf("Regname: %0s reset value: 0x%0h %0s", + ptr.get_full_name(), reset_val, err_msg), + error, $sformatf("%m")) + end + end + join_none + if (blocking) wait fork; + // Add #0 to ensure that this thread starts executing before any subsequent call + else #0; + end : isolation_fork + join + endtask + + // task to read all csrs and check against ral expected value. Mainly used after reset + task automatic read_and_check_all_csrs(input uvm_reg_block ral); + uvm_reg ral_csrs[$]; + ral.get_registers(ral_csrs); + ral_csrs.shuffle(); + + foreach (ral_csrs[i]) csr_rd_check(.ptr(ral_csrs[i]), .compare_vs_ral(1)); + endtask + + // Checks the csr value against predicted value by reading the whole CSR or individual CSR + // fields. + // This task will skip read check if the CSR field is excluded. + task automatic do_check_csr_or_field_rd(input uvm_reg csr, + input bit do_csr_field_rd_check = $urandom(), + input bit blocking = 0, + input bit compare = 1, + input bit compare_vs_ral = 1, + input csr_excl_type_e csr_excl_type = CsrNoExcl, + input csr_test_type_e csr_test_type = CsrRwTest, + input csr_excl_item csr_excl_item = get_excl_item(csr)); + uvm_reg_data_t compare_mask; + + // Check if parent block or register is excluded from read-check + if (csr_excl_item != null && csr_excl_item.is_excl(csr, csr_excl_type, csr_test_type)) begin + `uvm_info($sformatf("%m"), + $sformatf("Skipping register %0s due to CsrExclWriteCheck exclusion", + csr.get_full_name()), UVM_MEDIUM) + return; + end + + compare_mask = get_mask_excl_fields(csr, csr_excl_type, csr_test_type, csr_excl_item); + + if (!do_csr_field_rd_check) begin + csr_rd_check(.ptr (csr), + .blocking (blocking), + .compare (compare), + .compare_vs_ral(compare_vs_ral), + .compare_mask (compare_mask)); + end else begin + uvm_reg_field test_fields[$]; + csr.get_fields(test_fields); + test_fields.shuffle(); + foreach (test_fields[i]) begin + bit field_compare = 1; + if (csr_excl_item != null) begin + field_compare = !csr_excl_item.is_excl(test_fields[i], csr_excl_type, csr_test_type); + end + csr_rd_check(.ptr (test_fields[i]), + .blocking (blocking), + .compare (field_compare && compare), + .compare_vs_ral(compare_vs_ral)); + end + end + endtask + + // Poll a csr or csr field continuously until its value is as expected. + // + // The CSR or field is polled by performing reads at the given ptr and its current value is + // compared with exp_data using the comparison in compare_op. The task exits when the comparison + // becomes true. + // + // To avoid this task waiting forever, there is an upper bound given with timeout_ns. If the task + // does not finish for another reason in that time, the test will fail. + // + // CSR reads are performed using frontdoor access. If the backdoor argument is true, then they + // will be performed with a backdoor access instead. + // + // Successive CSR reads are back-to-back unless spinwait_delay_ns is positive. If backdoor is + // true, the delay between successive reads is made to be at least 1ns. + task automatic csr_spinwait(input uvm_object ptr, + input uvm_reg_data_t exp_data, + input uvm_check_e check = default_csr_check, + input uvm_path_e path = UVM_DEFAULT_PATH, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor, + input uint spinwait_delay_ns = 0, + input uint timeout_ns = default_spinwait_timeout_ns, + input compare_op_e compare_op = CompareOpEq, + input bit backdoor = 0, + input uvm_verbosity verbosity = UVM_HIGH); + static int count; + automatic int lcount; + + // Increment count so that each call to csr_spinwait has a different index (to help debugging) + count++; + + // Take an (automatic) copy of lcount. This will act as a snapshot of the value that the count + // had when this task started, giving the index of *this* call. + lcount = count; + + `uvm_info($sformatf("%m"), $sformatf( + "- (call_count=%0d, backdoor=%0d, exp_data=%0d, ptr=%s)", + lcount, backdoor, exp_data, ptr.get_name()), verbosity) + fork + begin : isolation_fork + csr_field_t csr_or_fld; + uvm_reg_data_t read_data; + + csr_or_fld = decode_csr_or_field(ptr); + if (backdoor && spinwait_delay_ns == 0) spinwait_delay_ns = 1; + fork + // Repeatedly do reads of the value at path and stop when the value satisfies the supplied + // comparison. If it is positive, wait spinwait_delay_ns nanoseconds between reads. If we + // enter reset, stop immediately (once the current csr_rd call has finished). + forever begin + `uvm_info($sformatf("%m"), $sformatf("In csr_spinwait - call_count = %0d", lcount), + verbosity) + + // Wait spinwait_delay_ns nanoseconds between each read (and before the first one), but + // stop waiting immediately if we see a reset. Note that we can't wait for a reset in + // parallel with the csr_rd below, because we use disable fork when a process finishes + // and csr_rd has internal state that it must clean up without being killed. + if (spinwait_delay_ns) begin + fork begin : iso_fork + fork + #(spinwait_delay_ns * 1ns); + wait (under_reset); + join_any + disable fork; + end : iso_fork join + end + + // If we are in reset, stop the wait immediately. + if (under_reset) break; + + csr_rd(.ptr(ptr), .value(read_data), .check(check), .path(path), + .blocking(1), .map(map), .user_ftdr(user_ftdr), .backdoor(backdoor)); + `uvm_info($sformatf("%m"), + $sformatf("ptr %0s == 0x%0h", ptr.get_full_name(), read_data), verbosity) + case (compare_op) + CompareOpEq: if (read_data == exp_data) break; + CompareOpCaseEq: if (read_data === exp_data) break; + CompareOpNe: if (read_data != exp_data) break; + CompareOpCaseNe: if (read_data !== exp_data) break; + CompareOpGt: if (read_data > exp_data) break; + CompareOpGe: if (read_data >= exp_data) break; + CompareOpLt: if (read_data < exp_data) break; + CompareOpLe: if (read_data <= exp_data) break; + default: begin + `uvm_fatal(ptr.get_full_name(), $sformatf("invalid operator:%0s", compare_op)) + end + endcase + end + // Wait for timeout_ns nanoseconds and then fail with an error (because this process + // should have been killed before then) + `DV_WAIT_TIMEOUT(timeout_ns, $sformatf("%m"), + $sformatf({"timeout %0s (addr=0x%0h, Comparison=%s, ", + "exp_data=0x%0h, call_count=%0d)"}, + ptr.get_full_name(), csr_or_fld.csr.get_address(), + compare_op.name, exp_data, lcount)) + join_any + disable fork; + end : isolation_fork + join + endtask + + task automatic mem_rd(input uvm_mem ptr, + input int offset, + output bit[31:0] data, + input uvm_check_e check = default_csr_check, + input bit blocking = default_csr_blocking, + input uint timeout_ns = default_timeout_ns, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + if (blocking) begin + mem_rd_sub(ptr, offset, data, check, timeout_ns, map, user_ftdr); + end else begin + fork + mem_rd_sub(ptr, offset, data, check, timeout_ns, map, user_ftdr); + join_none + // Add #0 to ensure that this thread starts executing before any subsequent call + #0; + end + endtask : mem_rd + + task automatic mem_rd_sub(input uvm_mem ptr, + input int offset, + output bit[31:0] data, + input uvm_check_e check = default_csr_check, + input uint timeout_ns = default_timeout_ns, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + fork + begin : isolating_fork + uvm_status_e status; + + fork + begin + increment_outstanding_access(); + if (user_ftdr != null) ptr.set_frontdoor(user_ftdr); + ptr.read(.status(status), .offset(offset), .value(data), .map(map), .prior(100)); + // TODO: need to remove the frontdoor to switch back to the default, + // but this doesn't work: if (user_ftdr != null) ptr.set_frontdoor(null); + if (check == UVM_CHECK && !under_reset) begin + `DV_CHECK_EQ(status, UVM_IS_OK, + $sformatf("trying to read mem %0s", ptr.get_full_name()), + error, $sformatf("%m")) + end + decrement_outstanding_access(); + end + begin : mem_rd_timeout + `DV_WAIT_TIMEOUT(timeout_ns, $sformatf("%m"), + $sformatf("Timeout waiting to mem_rd %0s (addr=0x%0h)", + ptr.get_full_name(), offset)) + end + join_any + disable fork; + end : isolating_fork + join + endtask : mem_rd_sub + + task automatic mem_wr(input uvm_mem ptr, + input int offset, + input bit[31:0] data, + input bit blocking = default_csr_blocking, + input uint timeout_ns = default_timeout_ns, + input uvm_check_e check = default_csr_check, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + if (blocking) begin + mem_wr_sub(ptr, offset, data, timeout_ns, check, map, user_ftdr); + end else begin + fork + mem_wr_sub(ptr, offset, data, timeout_ns, check, map, user_ftdr); + join_none + // Add #0 to ensure that this thread starts executing before any subsequent call + #0; + end + endtask : mem_wr + + task automatic mem_wr_sub(input uvm_mem ptr, + input int offset, + input bit[31:0] data, + input uint timeout_ns = default_timeout_ns, + input uvm_check_e check = default_csr_check, + input uvm_reg_map map = null, + input uvm_reg_frontdoor user_ftdr = default_user_frontdoor); + fork + begin : isolation_fork + uvm_status_e status; + + fork + begin + increment_outstanding_access(); + if (user_ftdr != null) ptr.set_frontdoor(user_ftdr); + ptr.write(.status(status), .offset(offset), .value(data), .map(map), .prior(100)); + // TODO: need to remove the frontdoor to switch back to the default, + // but this doesn't work: if (user_ftdr != null) ptr.set_frontdoor(null); + if (check == UVM_CHECK && !under_reset) begin + `DV_CHECK_EQ(status, UVM_IS_OK, + $sformatf("trying to write mem %0s", ptr.get_full_name()), + error, $sformatf("%m")) + end + decrement_outstanding_access(); + end + begin + `DV_WAIT_TIMEOUT(timeout_ns, $sformatf("%m"), + $sformatf("Timeout waiting to mem_wr %0s (addr=0x%0h)", + ptr.get_full_name(), offset)) + end + join_any + disable fork; + end : isolation_fork + join + endtask : mem_wr_sub + + // Fields could be excluded from writes & reads - This function zeros out the excluded fields + function automatic uvm_reg_data_t get_mask_excl_fields(uvm_reg csr, + csr_excl_type_e csr_excl_type, + csr_test_type_e csr_test_type, + csr_excl_item m_csr_excl_item = + get_excl_item(csr)); + uvm_reg_field flds[$]; + csr.get_fields(flds); + get_mask_excl_fields = '1; + + if (m_csr_excl_item != null) begin + foreach (flds[i]) begin + if (m_csr_excl_item.is_excl(flds[i], csr_excl_type, csr_test_type)) begin + csr_field_t fld_params = decode_csr_or_field(flds[i]); + `uvm_info($sformatf("%m"), $sformatf("Skipping field %0s due to %0s exclusion", + flds[i].get_full_name(), csr_excl_type.name()), UVM_HIGH) + get_mask_excl_fields &= ~(fld_params.mask << fld_params.shift); + end + end + end + endfunction + + // Returns the write data value masked with excluded fields. + // + // Some fields in the CSR may be excluded from writes. In that case, we need to revert those + // fields to their mirrored values and write the rest of the fields with the given value. + function automatic uvm_reg_data_t get_csr_wdata_with_write_excl( + uvm_reg csr, + uvm_reg_data_t wdata, + csr_test_type_e csr_test_type, + csr_excl_item m_csr_excl_item = get_excl_item(csr) + ); + uvm_reg_field flds[$]; + csr.get_fields(flds); + + foreach (flds[i]) begin + if (m_csr_excl_item.is_excl(flds[i], CsrExclWrite, csr_test_type)) begin + `uvm_info($sformatf("%m"), + $sformatf("Retain mirrored 0x%0h for field %0s due to CsrExclWrite exclusion", + `gmv(flds[i]), flds[i].get_full_name()), UVM_MEDIUM) + wdata = get_csr_val_with_updated_field(flds[i], wdata, `gmv(flds[i])); + end + end + return wdata; + endfunction + + // Returns the CSR exclusion item associated with the provided object. + // + // If an exclusion item for the immediate block (parent of the CSR if ptr is a CSR or a field) is + // not found, it recurses through the block's ancestors to find an available exclusion item. + // arg ptr: An extension of one of dv_base_reg{, _block or _field} classes. + function automatic csr_excl_item get_excl_item(uvm_object ptr); + dv_base_reg_block blk; + + // Attempt cast to blk. If it fails, then attempt to cast to CSR or field. + if (!$cast(blk, ptr)) begin + csr_field_t csr_or_fld = decode_csr_or_field(ptr); + `downcast(blk, csr_or_fld.csr.get_parent(), , , $sformatf("%m")) + end + + // Recurse through block's ancestors. + do begin + csr_excl_item csr_excl = blk.get_excl_item(); + if (csr_excl != null) return csr_excl; + `downcast(blk, blk.get_parent(), , , $sformatf("%m")) + end while (blk != null); + return null; + endfunction + + // Clone a UVM address map + function automatic uvm_reg_map clone_reg_map( + string name, uvm_reg_map map, uvm_reg_addr_t base_addr = 0, int n_bytes = 4, + uvm_endianness_e endian = UVM_LITTLE_ENDIAN, bit byte_addressing = 1); + uvm_reg_map clone; + uvm_reg_map submaps[$]; + uvm_reg regs[$]; + uvm_reg_block blk; + uvm_mem mems[$]; + + // Clone the map + blk = map.get_parent(); + clone = blk.create_map( + .name(name), + .base_addr(base_addr), + .n_bytes(n_bytes), + .endian(endian), + .byte_addressing(byte_addressing) + ); + + // Clone the submaps by calling this function recursively + map.get_submaps(submaps); + while (submaps.size()) begin + uvm_reg_map submap, submap_clone; + submap = submaps.pop_front(); + submap_clone = clone_reg_map(.name(name), .map(submap), .base_addr(submap.get_base_addr()), + // Use `UVM_NO_HIER` argument to get the n_bytes from the submap instead of the system + // level value. + .n_bytes(submap.get_n_bytes(UVM_NO_HIER)), .endian(endian)); + clone.add_submap(.child_map(submap_clone), .offset(map.get_submap_offset(submap))); + end + + // Clone the registers + map.get_registers(regs, UVM_NO_HIER); + while (regs.size()) begin + uvm_reg rg; + rg = regs.pop_front(); + clone.add_reg(.rg(rg), .offset(rg.get_offset(map)), .rights(rg.get_rights(map)), .unmapped(0), + .frontdoor(null)); + end + + // Clone the memories + map.get_memories(mems, UVM_NO_HIER); + while (mems.size()) begin + uvm_mem mem; + mem = mems.pop_front(); + clone.add_mem(.mem(mem), .offset(mem.get_offset(0, map)), .rights(mem.get_rights(map)), + .unmapped(0), .frontdoor(null)); + end + return clone; + + endfunction + + // sources + `include "csr_base_seq.sv" + `include "csr_hw_reset_seq.sv" + `include "csr_aliasing_seq.sv" + `include "csr_seq_lib.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent.core b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent.core new file mode 100644 index 0000000..5b531e6 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent.core @@ -0,0 +1,32 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_base_agent" +description: "DV base agent" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_utils + files: + - dv_base_agent_pkg.sv + + - dv_base_agent_cfg.sv: {is_include_file: true} + - dv_base_agent_cov.sv: {is_include_file: true} + - dv_base_monitor.sv: {is_include_file: true} + - dv_base_sequencer.sv: {is_include_file: true} + - dv_base_driver.sv: {is_include_file: true} + - dv_base_agent.sv: {is_include_file: true} + - dv_base_seq.sv: {is_include_file: true} + + - dv_reactive_agent_cfg.sv: {is_include_file: true} + - dv_reactive_monitor.sv: {is_include_file: true} + - dv_reactive_sequencer.sv: {is_include_file: true} + - dv_reactive_agent.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent.sv new file mode 100644 index 0000000..6845194 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent.sv @@ -0,0 +1,86 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A base agent class +// +// CFG_T: The type of the configuration object. This should be a subclass of +// dv_base_agent_cfg +// +// DRIVER_T: The type of the driver. This should be a subclass of dv_base_driver. +// +// HOST_DRIVER_T The type of the driver when the agent configured with if_mode set to Host. This +// should be a subclass of DRIVER_T. +// +// DEVICE_DRIVER_T The type of the driver when the agent configured with if_mode set to Device. +// This should be a subclass of DRIVER_T. +// +// SEQUENCER_T The type of the sequencer. This should be a subclass of dv_base_sequencer. +// +// MONITOR_T The type of the monitor. This should be a subclass of dv_base_monitor. +// +// COV_T The type of the object that monitors coverage. This should be a subclass of +// dv_base_agent_cov. + +class dv_base_agent #(type CFG_T = dv_base_agent_cfg, + type DRIVER_T = dv_base_driver, + type HOST_DRIVER_T = DRIVER_T, + type DEVICE_DRIVER_T = DRIVER_T, + type SEQUENCER_T = dv_base_sequencer, + type MONITOR_T = dv_base_monitor, + type COV_T = dv_base_agent_cov) extends uvm_agent; + + `uvm_component_param_utils(dv_base_agent #(CFG_T, DRIVER_T, HOST_DRIVER_T, DEVICE_DRIVER_T, + SEQUENCER_T, MONITOR_T, COV_T)) + + CFG_T cfg; + COV_T cov; + DRIVER_T driver; + SEQUENCER_T sequencer; + MONITOR_T monitor; + + extern function new (string name, uvm_component parent); + + extern function void build_phase(uvm_phase phase); + extern function void connect_phase(uvm_phase phase); +endclass + +function dv_base_agent::new (string name, uvm_component parent); + super.new(name, parent); +endfunction + +function void dv_base_agent::build_phase(uvm_phase phase); + super.build_phase(phase); + + if (cfg == null && !uvm_config_db#(CFG_T)::get(this, "", "cfg", cfg)) begin + `uvm_fatal(`gfn, $sformatf("failed to get %s from uvm_config_db", cfg.get_type_name())) + end + `uvm_info(`gfn, $sformatf("\n%0s", cfg.sprint()), UVM_HIGH) + + if (cfg.en_cov) begin + cov = COV_T ::type_id::create("cov", this); + cov.cfg = cfg; + end + + monitor = MONITOR_T::type_id::create("monitor", this); + monitor.cfg = cfg; + monitor.cov = cov; + + if (cfg.is_active) begin + sequencer = SEQUENCER_T::type_id::create("sequencer", this); + sequencer.cfg = cfg; + + if (cfg.has_driver) begin + if (cfg.if_mode == Host) driver = HOST_DRIVER_T::type_id::create("driver", this); + else driver = DEVICE_DRIVER_T::type_id::create("driver", this); + driver.cfg = cfg; + end + end +endfunction + +function void dv_base_agent::connect_phase(uvm_phase phase); + super.connect_phase(phase); + if (cfg.is_active && cfg.has_driver) begin + driver.seq_item_port.connect(sequencer.seq_item_export); + end +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_cfg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_cfg.sv new file mode 100644 index 0000000..bf6e54c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_cfg.sv @@ -0,0 +1,53 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// The base config object for an agent + +class dv_base_agent_cfg extends uvm_object; + + // True if this is an active agent, so has a driver and sequencer. If false, this is a passive + // agent and only uses a monitor. + bit is_active = 1'b1; + + // True if the agent should enable a monitor (perhaps for a scoreboard) + bit en_monitor = 1'b1; + + // True if the agent should collect functional coverage + bit en_cov = 1'b1; + + // Relevant for an agent that acts on a communication bus. This is the interface mode of the agent + // on the bus. If if_mode == dv_utils_pkg::Device, the dut is assumed to be a host to which the + // agent responds. If if_mode == dv_utils_pkg::Host, the dut is assumed to be a device which will + // respond to transactions from the agent. + if_mode_e if_mode; + + // True if the agent has its own driver, which should be attached to the sequencer. If this is + // false, the agent can work by connecting to some lower-level agent to send multiple items. + bit has_driver = 1'b1; + + // The minimum time in ns that the monitor expects to see ok_to_end be high before it drops an + // objection that stopped the run_phase ending. + int ok_to_end_delay_ns = 1000; + + // Indicates that the interface is under reset. The derived monitor detects and maintains it. Note + // that this is distinct from the under_reset flag in dv_base_env_cfg: the interface of an agent + // can be in reset even if the environment as a whole is not. + bit in_reset; + + `uvm_object_utils_begin(dv_base_agent_cfg) + `uvm_field_int (is_active, UVM_DEFAULT) + `uvm_field_int (en_monitor, UVM_DEFAULT) + `uvm_field_int (en_cov, UVM_DEFAULT) + `uvm_field_enum(if_mode_e, if_mode, UVM_DEFAULT) + `uvm_field_int (has_driver, UVM_DEFAULT) + `uvm_field_int (ok_to_end_delay_ns, UVM_DEFAULT) + `uvm_field_int (in_reset, UVM_DEFAULT) + `uvm_object_utils_end + + extern function new (string name=""); +endclass + +function dv_base_agent_cfg::new (string name=""); + super.new(name); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_cov.sv new file mode 100644 index 0000000..d47eaca --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_cov.sv @@ -0,0 +1,18 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A generic coverage component for an agent. An instance of some subclass will be instantiated in +// as the coverage object in the agent's monitor. + +class dv_base_agent_cov #(type CFG_T = dv_base_agent_cfg) extends uvm_component; + `uvm_component_param_utils(dv_base_agent_cov #(CFG_T)) + + CFG_T cfg; + + extern function new (string name="", uvm_component parent=null); +endclass + +function dv_base_agent_cov::new (string name="", uvm_component parent=null); + super.new(name, parent); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_pkg.sv new file mode 100644 index 0000000..b2923d4 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_agent_pkg.sv @@ -0,0 +1,33 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package dv_base_agent_pkg; + // dep packages + import uvm_pkg::*; + import dv_utils_pkg::*; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + // package variables + string msg_id = "dv_base_agent_pkg"; + + // package sources + `include "dv_base_agent_cfg.sv" + `include "dv_base_agent_cov.sv" + `include "dv_base_monitor.sv" + `include "dv_base_sequencer.sv" + `include "dv_base_driver.sv" + `include "dv_base_agent.sv" + + `include "dv_reactive_agent_cfg.sv" + `include "dv_reactive_monitor.sv" + `include "dv_reactive_sequencer.sv" + `include "dv_reactive_agent.sv" + + // base seq + `include "dv_base_seq.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_driver.sv new file mode 100644 index 0000000..f37dec5 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_driver.sv @@ -0,0 +1,91 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A base class for a driver. This drives sequence items of type ITEM_T. If the subclass is designed +// to do so, it responds with items of type RSP_ITEM_T. +// +// NOTE: This class would make more sense as an abstract base class (with a pure virtual +// implementation of get_and_drive). Unfortunately, this isn't possible at the moment because +// dv_base_agent ends up needing to instantiate a uvm_driver instance unless parameters are +// overridden. This would be reasonable except that uvm_driver::create is not implemented in +// UVM 1.2 (the version that OpenTitan currently depends on). +// +// If we bump the UVM version past 1800.2-2020, we can switch this over to an abstract base +// class. + +class dv_base_driver #(type ITEM_T = uvm_sequence_item, + type CFG_T = dv_base_agent_cfg, + type RSP_ITEM_T = ITEM_T) + extends uvm_driver #(.REQ(ITEM_T), .RSP(RSP_ITEM_T)); + + `uvm_component_param_utils(dv_base_driver #(.ITEM_T (ITEM_T), + .CFG_T (CFG_T), + .RSP_ITEM_T (RSP_ITEM_T))) + + CFG_T cfg; + + extern function new (string name, uvm_component parent); + + // The run_phase task runs reset_signals() and get_and_drive() (described below) in parallel. + // Subclasses might not need to implement run_phase directly. + extern task run_phase(uvm_phase phase); + + // A task that runs forever, monitoring the cfg.in_reset flag and calling on_enter_reset when it + // becomes true. Subclasses shouldn't normally need to override this. + extern virtual task reset_signals(); + + // The get_and_drive task should be implemented in any subclass. It must repeatedly call + // get_next_item to consume items from the sequencer and, driving each. + // + // NOTE: Any implementation must implement this or fail at runtime. See note above for why this + // can't be enforced at build time. + extern virtual task get_and_drive(); + + // A task that is run at the start of any reset. It can be implemented by any subclass to clear + // any driven signals back to their "reset value". + // + // Note that this task should not consume any simulation time: it is a task to allow it to + // interact properly with clocking blocks. + extern virtual task on_enter_reset(); + + // A function that is run at the end of any reset. It may be implemented by any subclass and gives + // the class an opportunity to set up values before the start of a run, but without a race + // condition at the start of the reset. + extern virtual function void on_leave_reset(); +endclass + +function dv_base_driver::new (string name, uvm_component parent); + super.new(name, parent); +endfunction + +task dv_base_driver::run_phase(uvm_phase phase); + super.run_phase(phase); + fork + reset_signals(); + get_and_drive(); + join +endtask + +task dv_base_driver::reset_signals(); + forever begin + `uvm_info(get_full_name(), "Driver entering reset", UVM_HIGH) + on_enter_reset(); + wait(!cfg.in_reset); + `uvm_info(get_full_name(), "Driver leaving reset", UVM_HIGH) + on_leave_reset(); + wait(cfg.in_reset); + end +endtask + +task dv_base_driver::get_and_drive(); + `uvm_fatal(get_full_name(), "This task must be implemented by base classes.") +endtask + +task dv_base_driver::on_enter_reset(); + // The default behaviour of this task is to do nothing +endtask + +function void dv_base_driver::on_leave_reset(); + // The default behaviour of this function is to do nothing +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_monitor.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_monitor.sv new file mode 100644 index 0000000..65200b6 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_monitor.sv @@ -0,0 +1,110 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_monitor #(type ITEM_T = uvm_sequence_item, + type CFG_T = dv_base_agent_cfg, + type COV_T = dv_base_agent_cov) extends uvm_monitor; + `uvm_component_param_utils(dv_base_monitor #(ITEM_T, CFG_T, COV_T)) + + CFG_T cfg; + COV_T cov; + + // Indicates activity on the interface, driven only within the `monitor_ready_to_end()` task. + protected bit ok_to_end = 1; + + // Used to ensure we run the watchdog exactly once at the end of the run phase. Cleared at start + // of run phase. Set once watchdog_ok_to_end has been started at the end of the run_phase. + protected bit phase_ready_to_end_invoked = 0; + + // Analysis port for the collected transfer. + uvm_analysis_port #(ITEM_T) analysis_port; + + `uvm_component_new + + function void build_phase(uvm_phase phase); + super.build_phase(phase); + analysis_port = new("analysis_port", this); + endfunction + + virtual task run_phase(uvm_phase phase); + super.run_phase(phase); + fork + collect_trans(); + join + endtask + + // collect transactions forever + virtual protected task collect_trans(); + // Empty - to be overridden in the child class + endtask + + // UVM callback which is invoked during phase sequencing. + virtual function void phase_ready_to_end(uvm_phase phase); + if (!phase.is(uvm_run_phase::get())) return; + if (phase_ready_to_end_invoked) return; + + phase_ready_to_end_invoked = 1; + fork + monitor_ready_to_end(); + watchdog_ok_to_end(phase); + join_none + endfunction + + // Ensures that ok_to_end when asserted, stays asserted for 1 ok_to_end_delay_ns period. + // + // If ok_to_end de-asserts before the watchdog expires, it waits for it to assert again + // and restarts the timer. This ensures that there is sufficient drain time to allow the + // simulation to end gracefully. It raises and drops the objection at the appropriate times. + virtual task watchdog_ok_to_end(uvm_phase run_phase); + bit objection_raised; + bit watchdog_done; + uint watchdog_restart_count = 1; + + forever begin + if (!objection_raised) begin + `uvm_info(`gfn, "watchdog_ok_to_end: raising objection", UVM_MEDIUM) + run_phase.raise_objection(this, {`gfn, " objection raised"}); + objection_raised = 1'b1; + end + + // Start the timer only when ok_to_end is asserted. + wait (ok_to_end); + `uvm_info(`gfn, $sformatf("watchdog_ok_to_end: starting the timer (count: %0d)", + watchdog_restart_count++), UVM_MEDIUM) + fork + begin: isolation_fork + fork + begin + watchdog_done = 1'b0; + #(cfg.ok_to_end_delay_ns * 1ns); + watchdog_done = 1'b1; + end + wait (!ok_to_end); + join_any + disable fork; + end: isolation_fork + join + + // If ok_to_end stayed high throughout the watchdog timer expiry, then drop the objection. + if (ok_to_end && watchdog_done) begin + `uvm_info(`gfn, "watchdog_ok_to_end: dropping objection", UVM_MEDIUM) + run_phase.drop_objection(this, {`gfn, " objection dropped"}); + objection_raised = 1'b0; + + // Wait for ok_to_end to de-assert again in future. + wait (!ok_to_end); + end + end + endtask + + // Asserts/de-asserts ok_to_end to indicate bus activity. + // + // This task is invoked in a forked thread within `phase_ready_to_end()`, which is callback + // invoked by UVM at the end of the phase. The forked thread does not join. Hence, the extended + // monitor needs to override this function and assert ok_to_end based on the activity on the bus + // (assert it when idle, de-assert when its not) in a forever loop. + virtual task monitor_ready_to_end(); + endtask + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_seq.sv new file mode 100644 index 0000000..616b47f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_seq.sv @@ -0,0 +1,25 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_seq #(type REQ = uvm_sequence_item, + type RSP = REQ, + type CFG_T = dv_base_agent_cfg, + type SEQUENCER_T = dv_base_sequencer) extends uvm_sequence#(REQ, RSP); + `uvm_object_param_utils(dv_base_seq #(REQ, RSP, CFG_T, SEQUENCER_T)) + `uvm_declare_p_sequencer(SEQUENCER_T) + + CFG_T cfg; + + `uvm_object_new + + task pre_start(); + super.pre_start(); + cfg = p_sequencer.cfg; + endtask + + task body(); + `uvm_fatal(`gtn, "Need to override this when you extend from this class!") + endtask : body + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_sequencer.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_sequencer.sv new file mode 100644 index 0000000..ec35114 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_base_sequencer.sv @@ -0,0 +1,18 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_sequencer #(type ITEM_T = uvm_sequence_item, + type CFG_T = dv_base_agent_cfg, + type RSP_ITEM_T = ITEM_T) + extends uvm_sequencer #(.REQ(ITEM_T), .RSP(RSP_ITEM_T)); + + `uvm_component_param_utils(dv_base_sequencer #(.ITEM_T (ITEM_T), + .CFG_T (CFG_T), + .RSP_ITEM_T (RSP_ITEM_T))) + CFG_T cfg; + + function new(string name, uvm_component parent); + super.new(name, parent); + endfunction +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_agent.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_agent.sv new file mode 100644 index 0000000..4b323be --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_agent.sv @@ -0,0 +1,59 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// An extension of the base agent class that connects the monitor to the sequencer in order to allow +// the agent to run sequences that react to items collected by the monitor. +// +// CFG_T: The type of the configuration object. This should be a subclass of +// dv_reactive_agent_cfg +// +// DRIVER_T: The type of the driver. This should be a subclass of dv_base_driver. +// +// HOST_DRIVER_T The type of the driver when the agent configured with if_mode set to Host. This +// should be a subclass of DRIVER_T. +// +// DEVICE_DRIVER_T The type of the driver when the agent configured with if_mode set to Device. +// This should be a subclass of DRIVER_T. +// +// SEQUENCER_T The type of the sequencer. This should be a subclass of dv_reactive_sequencer. +// +// MONITOR_T The type of the monitor. This should be a subclass of dv_reactive_monitor. +// +// COV_T The type of the object that monitors coverage. This should be a subclass of +// dv_base_agent_cov. + +class dv_reactive_agent #(type CFG_T = dv_reactive_agent_cfg, + type DRIVER_T = dv_base_driver, + type HOST_DRIVER_T = DRIVER_T, + type DEVICE_DRIVER_T = DRIVER_T, + type SEQUENCER_T = dv_reactive_sequencer, + type MONITOR_T = dv_reactive_monitor, + type COV_T = dv_base_agent_cov) + extends dv_base_agent #(.CFG_T(CFG_T), + .DRIVER_T(DRIVER_T), + .HOST_DRIVER_T(HOST_DRIVER_T), .DEVICE_DRIVER_T(DEVICE_DRIVER_T), + .SEQUENCER_T(SEQUENCER_T), + .MONITOR_T(MONITOR_T), + .COV_T(COV_T)); + + `uvm_component_param_utils(dv_reactive_agent #(CFG_T, DRIVER_T, HOST_DRIVER_T, DEVICE_DRIVER_T, + SEQUENCER_T, MONITOR_T, COV_T)) + + extern function new (string name, uvm_component parent); + extern function void connect_phase(uvm_phase phase); +endclass + +function dv_reactive_agent::new (string name, uvm_component parent); + super.new(name, parent); +endfunction + +function void dv_reactive_agent::connect_phase(uvm_phase phase); + super.connect_phase(phase); + if (cfg.has_req_fifo) begin + monitor.req_analysis_port.connect(sequencer.req_analysis_fifo.analysis_export); + end + if (cfg.has_rsp_fifo) begin + monitor.rsp_analysis_port.connect(sequencer.rsp_analysis_fifo.analysis_export); + end +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_agent_cfg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_agent_cfg.sv new file mode 100644 index 0000000..e41a93d --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_agent_cfg.sv @@ -0,0 +1,27 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// The base config object for a reactive agent + +class dv_reactive_agent_cfg extends dv_base_agent_cfg; + + // True if agent's sequencer has a request fifo. If so, the agent will connect its monitor's + // req_analysis_port to the sequencer's request fifo. + bit has_req_fifo = 1'b0; + + // True if agent's sequencer has a response fifo. If so, the agent will connect its monitor's + // req_analysis_port to the sequencer's response fifo. + bit has_rsp_fifo = 1'b0; + + `uvm_object_utils_begin(dv_reactive_agent_cfg) + `uvm_field_int (has_req_fifo, UVM_DEFAULT) + `uvm_field_int (has_rsp_fifo, UVM_DEFAULT) + `uvm_object_utils_end + + extern function new (string name=""); +endclass + +function dv_reactive_agent_cfg::new (string name=""); + super.new(name); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_monitor.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_monitor.sv new file mode 100644 index 0000000..c9891b1 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_monitor.sv @@ -0,0 +1,31 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_reactive_monitor #(type ITEM_T = uvm_sequence_item, + type REQ_ITEM_T = ITEM_T, + type RSP_ITEM_T = ITEM_T, + type CFG_T = dv_base_agent_cfg, + type COV_T = dv_base_agent_cov) + extends dv_base_monitor #(.ITEM_T(ITEM_T), .CFG_T(CFG_T), .COV_T(COV_T)); + + `uvm_component_param_utils(dv_reactive_monitor #(ITEM_T, REQ_ITEM_T, RSP_ITEM_T, CFG_T, COV_T)) + + // item will be sent to this port for seq when req phase is done (last is set) + uvm_analysis_port #(REQ_ITEM_T) req_analysis_port; + // item will be sent to this port for seq when rsp phase is done (rsp_done is set) + uvm_analysis_port #(RSP_ITEM_T) rsp_analysis_port; + + extern function new (string name, uvm_component parent); + extern function void build_phase(uvm_phase phase); +endclass + +function dv_reactive_monitor::new (string name, uvm_component parent); + super.new(name, parent); +endfunction + +function void dv_reactive_monitor::build_phase(uvm_phase phase); + super.build_phase(phase); + req_analysis_port = new("req_analysis_port", this); + rsp_analysis_port = new("rsp_analysis_port", this); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_sequencer.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_sequencer.sv new file mode 100644 index 0000000..95ba161 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_agent/dv_reactive_sequencer.sv @@ -0,0 +1,38 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_reactive_sequencer #(type ITEM_T = uvm_sequence_item, + type CFG_T = dv_reactive_agent_cfg, + type RSP_ITEM_T = ITEM_T) + extends dv_base_sequencer #(.ITEM_T(ITEM_T), .CFG_T(CFG_T), .RSP_ITEM_T(RSP_ITEM_T)); + + `uvm_component_param_utils(dv_reactive_sequencer #(.ITEM_T (ITEM_T), + .CFG_T (CFG_T), + .RSP_ITEM_T (RSP_ITEM_T))) + + // These FIFOs collect items when req/rsp is received, which are used to communicate between + // monitor and sequences. These FIFOs are only created if has_req_fifo / has_rsp_fifo is true in + // the agent config. + // + // When device is reactive, it gets items from req_analysis_fifo and send rsp to driver When this + // is a high-level agent, monitors put items to these 2 FIFOs for high-level seq + uvm_tlm_analysis_fifo #(ITEM_T) req_analysis_fifo; + uvm_tlm_analysis_fifo #(RSP_ITEM_T) rsp_analysis_fifo; + + extern function new(string name, uvm_component parent); + extern function void build_phase(uvm_phase phase); +endclass + +function dv_reactive_sequencer::new(string name, uvm_component parent); + super.new(name, parent); +endfunction + +function void dv_reactive_sequencer::build_phase(uvm_phase phase); + super.build_phase(phase); + + if (cfg == null) `uvm_fatal(get_full_name(), "agent cfg not provided.") + + if (cfg.has_req_fifo) req_analysis_fifo = new("req_analysis_fifo", this); + if (cfg.has_rsp_fifo) rsp_analysis_fifo = new("rsp_analysis_fifo", this); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/csr_excl_item.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/csr_excl_item.sv new file mode 100644 index 0000000..49847a9 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/csr_excl_item.sv @@ -0,0 +1,161 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Class: csr_excl_item +// Description: CSR exclusion item that holds exclusions applied for a given set of blocks / +// registers / fields provided and maintained as strings. +class csr_excl_item extends uvm_object; + `uvm_object_utils(csr_excl_item) + + typedef struct { + bit enable; + int csr_test_type; + csr_excl_type_e csr_excl_type; + } csr_excl_s; + local csr_excl_s exclusions[string]; + + `uvm_object_new + + // Adds an exclusion for an individual block, register or field. + // + // arg obj: Hierarchical path to the block, csr or field as string. Passing * and ? wildcards for + // glob style matching is allowed. User needs to take care the wildcards don't match more + // than desired. For example, for the ral.ctrl.tx field: + // obj = "ral.ctrl.tx" or "*.ctrl.tx" should work; "*.tx" might be too generic. + // arg csr_excl_type: The desired exclusion type. + // arg csr_test_type: The desired test type for which the exclusion is in effect. + virtual function void add_excl(string obj, + csr_excl_type_e csr_excl_type, + csr_test_type_e csr_test_type = CsrAllTests); + bit [2:0] val = CsrNoExcl; + bit [NUM_CSR_TESTS-1:0] test = CsrInvalidTest; + + `DV_CHECK_NE_FATAL(csr_test_type, CsrInvalidTest, + $sformatf("Test type not specified for the exclusion of %0s.", obj)) + + if (!exclusions.exists(obj)) begin + exclusions[obj] = '{enable:1'b1, csr_test_type:csr_test_type, csr_excl_type:csr_excl_type}; + return; + end + + val = csr_excl_type | exclusions[obj].csr_excl_type; + test = csr_test_type | exclusions[obj].csr_test_type; + exclusions[obj].csr_excl_type = csr_excl_type_e'(val); + exclusions[obj].csr_test_type = test; + endfunction + + // Turns exclusion on or off for a block, register or field. + // + // The originally set exclusions are untouched. This method only enables or disables the + // application of the exclusions temporarily. + // + // obj: The hierarchical path to block, register or field. + // enable: Bit indicating whether to enable or disable the application of exclusion. + // throw_error: Bit indicating whether to throw error if exclusions associated with obj do not + // exist. + virtual function void enable_excl(string obj, bit enable = 1'b1, bit throw_error = 1'b1); + string index; + if (get_excl_index(obj, index)) begin + exclusions[index].enable = enable; + return; + end + if (throw_error) begin + `uvm_fatal(`gfn, $sformatf("No exclusions found for %0s.", obj)) + end + endfunction + + // Checks if the given block, register or field is excluded. + // + // arg obj: The given block, register or field. + // arg csr_excl_type: The exclusion checked against. + // arg csr_test_type: The type of test for which the exclusion is in effect. + function bit is_excl(uvm_object obj, + csr_excl_type_e csr_excl_type, + csr_test_type_e csr_test_type); + uvm_reg_block blk; + + // Attempt cast to block. If it fails, then attempt to cast to CSR or field. + if (!$cast(blk, obj)) begin + csr_field_t csr_or_fld = decode_csr_or_field(obj); + if (csr_or_fld.field != null) begin + if (has_excl(csr_or_fld.field.`gfn, csr_excl_type, csr_test_type, is_excl)) return is_excl; + end else begin + if (has_excl(csr_or_fld.csr.`gfn, csr_excl_type, csr_test_type, is_excl)) return is_excl; + end + `downcast(blk, csr_or_fld.csr.get_parent(), , , `gfn) + end + + // Recurse through block's ancestors. + do begin + if (has_excl(blk.`gfn, csr_excl_type, csr_test_type, is_excl)) return is_excl; + blk = blk.get_parent(); + end while (blk != null); + return 1'b0; + endfunction + + // Retrieves the string index of the exclusions data structure. + // + // The provided object for lookup is a string itself. It however, may or may + // not exist verbatim as an associative array index in the `exclusions` data + // structure, since glob-style wildcards are supported when adding the + // exclusions. The provided object must hence be a fully resolved + // hierarchical path to the CSR block, register or field. + // + // Returns 1 if index is found, else 0. + // Returns the actual index as output arg. + local function bit get_excl_index(input string obj, output string index); + // If obj is a index of exclusions, return it, else loop through available + // keys to find a glob match. + if (exclusions.exists(obj)) begin + index = obj; + return 1'b1; + end else begin + foreach (exclusions[str]) begin + if (!uvm_re_match(str, obj)) begin + index = str; + return 1'b1; + end + end + end + return 1'b0; + endfunction + + // Checks if a particular exclusion for an object for a test is in effect. + // + // arg obj: The given block, register or field as string lookup. + // arg csr_excl_type: The exclusion checked against. + // arg csr_test_type: The type of test for which the exclusion is in effect. + // arg is_excl: Bit indicating the object is excluded. + // + // Returns 1 if an associated exclusion is found, else 0. + local function bit has_excl(input string obj, + input csr_excl_type_e csr_excl_type, + input csr_test_type_e csr_test_type, + output bit is_excl); + string index; + if (get_excl_index(obj, index)) begin + is_excl = exclusions[index].enable && + ((exclusions[index].csr_test_type & csr_test_type) != CsrInvalidTest) && + ((exclusions[index].csr_excl_type & csr_excl_type) != CsrNoExcl); + return 1'b1; + end + return 1'b0; + endfunction + + // Prints all exclusions for ease of debug. + virtual function void print_exclusions(uvm_verbosity verbosity = UVM_HIGH); + string test_names; + for (int i = NUM_CSR_TESTS - 1; i >= 0; i--) begin + csr_test_type_e csr_test = csr_test_type_e'(1 << i); + test_names = {test_names, csr_test.name(), (i > 0) ? " " : ""}; + end + foreach (exclusions[item]) begin + string enabled = exclusions[item].enable ? "[enabled]" : "[disabled]"; + `uvm_info(`gfn, $sformatf("CSR/field [%s] exclusion %s %s in csr_tests: {%s} = {%0b}", + item, exclusions[item].csr_excl_type.name(), enabled, test_names, + exclusions[item].csr_test_type), verbosity) + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_lockable_field_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_lockable_field_cov.sv new file mode 100644 index 0000000..62e8c9d --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_lockable_field_cov.sv @@ -0,0 +1,50 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// coverage object of lockable CSR field and its regwen +class dv_base_lockable_field_cov extends uvm_object; + // mirrored value of the lockable field, which is used to know if new value is written. + uvm_reg_data_t field_mirrored_val; + // when new written value is different from mirrored value, this will be set. + bit is_new_val_written; + // latched the regwen value when a new value is written to this lockable CSR. + bit regwen_val_when_new_value_written; + + `uvm_object_utils(dv_base_lockable_field_cov) + + // Cover these 2 cases + // 1. When regwen = 1, write a non-mirrored value to lockable CSR and read it back + // 2. When regwen = 0, write a non-mirrored value to lockable CSR and read it back + covergroup regwen_val_when_new_value_written_cg(string name) with function sample(); + option.per_instance = 1; + option.name = name; + + cp_regwen: coverpoint regwen_val_when_new_value_written; + endgroup : regwen_val_when_new_value_written_cg + + // use reg_field name as this name + function new(string name = ""); + regwen_val_when_new_value_written_cg = new($sformatf("lockable_field_cov_of_%s", name)); + endfunction : new + + virtual function void reset(uvm_reg_data_t reset_val); + field_mirrored_val = reset_val; + is_new_val_written = 0; + endfunction + + // invoke at dv_base_reg_field::post_write + virtual function void post_write(uvm_reg_data_t new_val, bit regwen_val); + if (field_mirrored_val != new_val) begin + is_new_val_written = 1; + regwen_val_when_new_value_written = regwen_val; + field_mirrored_val = new_val; + end + endfunction + + // invoke at dv_base_reg_field::post_read + virtual function void post_read(); + if (is_new_val_written) regwen_val_when_new_value_written_cg.sample(); + endfunction + +endclass : dv_base_lockable_field_cov diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_mem.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_mem.sv new file mode 100644 index 0000000..330991f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_mem.sv @@ -0,0 +1,93 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Specialised version of uvm_mem for OpenTitan +// +// The specialised version adds the possibilities that a memory: +// +// - might not support partial writes (even if the bus would otherwise support them). +// +// - might store integrity data but not check it (merely passing it through to the next read). + +class dv_base_mem extends uvm_mem; + // If true, the memory supports partial writes. If not, any partial write will get an error + // response (d_error=1 in TileLink). + local bit mem_partial_write_support; + + // If true, mem stores integrity along with data but it won't check the data integrity + local bit data_intg_passthru; + + // Create a new instance of the memory abstraction class. + // + // The only access types supported are RW, RO and WO. + extern function new(string name, + longint unsigned size, + int unsigned n_bits, + string access = "RW", + int has_coverage = UVM_NO_COVERAGE); + + extern function void set_mem_partial_write_support(bit enable); + extern function bit get_mem_partial_write_support(); + + extern function void set_data_intg_passthru(bit enable); + extern function bit get_data_intg_passthru(); + + // This overrides uvm_mem::configure (which is *not* a virtual function), removing the check that + // the requested "access" is RW or RO, because we want to support WO as well. + // + // *That* check is now done in the constructor, where we can see the requested "access". + extern function void configure(uvm_reg_block parent, string hdl_path=""); +endclass + +function dv_base_mem::new(string name, + longint unsigned size, + int unsigned n_bits, + string access = "RW", + int has_coverage = UVM_NO_COVERAGE); + super.new(name, size, n_bits, access, has_coverage); + if (!(access inside {"RW", "RO", "WO"})) + `uvm_error(`gfn, $sformatf("Memory can only be RW, RO or WO (saw %s)", access)) +endfunction + +function void dv_base_mem::set_mem_partial_write_support(bit enable); + mem_partial_write_support = enable; +endfunction + +function bit dv_base_mem::get_mem_partial_write_support(); + return mem_partial_write_support; +endfunction + +function void dv_base_mem::set_data_intg_passthru(bit enable); + data_intg_passthru = enable; +endfunction + +function bit dv_base_mem::get_data_intg_passthru(); + return data_intg_passthru; +endfunction + +// Note: This is a copied version of uvm_mem::configure, but tweaked to remove the check on m_access +// (loosened slightly and now moved to the constructor) +function void dv_base_mem::configure(uvm_reg_block parent, string hdl_path=""); + if (parent == null) + `uvm_fatal(`gfn, "configure: parent argument is null") + + set_parent(parent); + + begin + uvm_mem_mam_cfg cfg = new; + + cfg.n_bytes = ((get_n_bits() - 1) / 8) + 1; + cfg.start_offset = 0; + cfg.end_offset = get_size() - 1; + + cfg.mode = uvm_mem_mam::GREEDY; + cfg.locality = uvm_mem_mam::BROAD; + + mam = new(get_full_name(), cfg, this); + end + + parent.add_mem(this); + + if (hdl_path != "") add_hdl_path_slice(hdl_path, -1, -1); +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_mubi_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_mubi_cov.sv new file mode 100644 index 0000000..a4ce2ff --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_mubi_cov.sv @@ -0,0 +1,136 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// coverage object for a fixed width mubi +class mubi_cov #(parameter int Width = 4, + parameter int unsigned ValueTrue = prim_mubi_pkg::MuBi4True, + parameter int unsigned ValueFalse = prim_mubi_pkg::MuBi4False) extends uvm_object; + `uvm_object_param_utils(mubi_cov #(Width, ValueTrue, ValueFalse)) + + // Collect true, false and at least N other values (N = Width) + covergroup mubi_cg(string name) with function sample(bit [Width-1:0] value); + option.per_instance = 1; + option.name = name; + + cp_value: coverpoint value { + bins true = {ValueTrue}; + bins false = {ValueFalse}; + bins others[Width] = {[0:{Width{1'b1}}]} with (!(item inside {ValueTrue, ValueFalse})); + } + endgroup : mubi_cg + + // use reg_field name as this name + function new(string name = ""); + mubi_cg = new($sformatf("mubi%0d_cov_of_%s", Width, name)); + endfunction : new + + virtual function void sample(bit [Width-1:0] value); + mubi_cg.sample(value); + endfunction : sample +endclass : mubi_cov + +// TODO(#24142): This is a bit silly: it's just mubi_cov above, specialised to Width=32. But that +// doesn't work properly with VCS (tried with version 2023.03) because it ends up creating an +// enormous number of bins. Setting an explicit width here works around the problem. Fix this up +// properly if we change tool version. +class mubi32_cov extends uvm_object; + `uvm_object_utils(mubi32_cov) + + // Collect true, false and at least N other values (N = 32) + covergroup mubi_cg(string name) with function sample(bit [32-1:0] value); + option.per_instance = 1; + option.name = name; + + cp_value: coverpoint value { + bins true = {prim_mubi_pkg::MuBi32True}; + bins false = {prim_mubi_pkg::MuBi32False}; + bins others[32] = {[0:{32{1'b1}}]} with (!(item inside {prim_mubi_pkg::MuBi32True, + prim_mubi_pkg::MuBi32False})); + } + endgroup : mubi_cg + + // use reg_field name as this name + function new(string name = ""); + mubi_cg = new($sformatf("mubi%0d_cov_of_%s", 32, name)); + endfunction : new + + virtual function void sample(bit [32-1:0] value); + mubi_cg.sample(value); + endfunction : sample +endclass + +typedef mubi_cov #(.Width(4), + .ValueTrue(prim_mubi_pkg::MuBi4True), + .ValueFalse(prim_mubi_pkg::MuBi4False)) mubi4_cov; +typedef mubi_cov #(.Width(8), + .ValueTrue(prim_mubi_pkg::MuBi8True), + .ValueFalse(prim_mubi_pkg::MuBi8False)) mubi8_cov; +typedef mubi_cov #(.Width(12), + .ValueTrue(prim_mubi_pkg::MuBi12True), + .ValueFalse(prim_mubi_pkg::MuBi12False)) mubi12_cov; +typedef mubi_cov #(.Width(16), + .ValueTrue(prim_mubi_pkg::MuBi16True), + .ValueFalse(prim_mubi_pkg::MuBi16False)) mubi16_cov; +typedef mubi_cov #(.Width(20), + .ValueTrue(prim_mubi_pkg::MuBi20True), + .ValueFalse(prim_mubi_pkg::MuBi20False)) mubi20_cov; +typedef mubi_cov #(.Width(24), + .ValueTrue(prim_mubi_pkg::MuBi24True), + .ValueFalse(prim_mubi_pkg::MuBi24False)) mubi24_cov; +typedef mubi_cov #(.Width(28), + .ValueTrue(prim_mubi_pkg::MuBi28True), + .ValueFalse(prim_mubi_pkg::MuBi28False)) mubi28_cov; + +// a mubi coverage object, which allows to dynamically select the width of mubi +class dv_base_mubi_cov extends uvm_object; + int mubi_width = 0; + + // declare all mubi types, but only one will be created + mubi4_cov m_mubi4_cov; + mubi8_cov m_mubi8_cov; + mubi12_cov m_mubi12_cov; + mubi16_cov m_mubi16_cov; + mubi20_cov m_mubi20_cov; + mubi24_cov m_mubi24_cov; + mubi28_cov m_mubi28_cov; + mubi32_cov m_mubi32_cov; + + `uvm_object_utils(dv_base_mubi_cov) + `uvm_object_new + + // use reg_field name as this name + function void create_cov(int mubi_width); + string cov_name = $sformatf("mubi%0d_cov_of_%s", mubi_width, `gfn); + + // create_cov can be invoked only once + `DV_CHECK_EQ(this.mubi_width, 0) + this.mubi_width = mubi_width; + + case (mubi_width) + 4: m_mubi4_cov = mubi4_cov::type_id::create(cov_name); + 8: m_mubi8_cov = mubi8_cov::type_id::create(cov_name); + 12: m_mubi12_cov = mubi12_cov::type_id::create(cov_name); + 16: m_mubi16_cov = mubi16_cov::type_id::create(cov_name); + 20: m_mubi20_cov = mubi20_cov::type_id::create(cov_name); + 24: m_mubi24_cov = mubi24_cov::type_id::create(cov_name); + 28: m_mubi28_cov = mubi28_cov::type_id::create(cov_name); + 32: m_mubi32_cov = mubi32_cov::type_id::create(cov_name); + default: `uvm_fatal(`gfn, $sformatf("Unsupported mubi width (%0d) is used", mubi_width)) + endcase + endfunction : create_cov + + virtual function void sample(int value); + case (mubi_width) + 4: m_mubi4_cov.sample(value); + 8: m_mubi8_cov.sample(value); + 12: m_mubi12_cov.sample(value); + 16: m_mubi16_cov.sample(value); + 20: m_mubi20_cov.sample(value); + 24: m_mubi24_cov.sample(value); + 28: m_mubi28_cov.sample(value); + 32: m_mubi32_cov.sample(value); + default: `uvm_fatal(`gfn, $sformatf("Unsupported mubi width (%0d) is used", mubi_width)) + endcase + endfunction : sample +endclass : dv_base_mubi_cov diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg.core b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg.core new file mode 100644 index 0000000..b6b3cd1 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg.core @@ -0,0 +1,29 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_base_reg" +description: "DV base reg/mem library" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_utils + - lowrisc:prim:mubi_pkg + files: + - dv_base_reg_pkg.sv + - csr_excl_item.sv: {is_include_file: true} + - dv_base_reg_field.sv: {is_include_file: true} + - dv_base_reg.sv: {is_include_file: true} + - dv_base_mem.sv: {is_include_file: true} + - dv_base_reg_block.sv: {is_include_file: true} + - dv_base_reg_map.sv: {is_include_file: true} + - dv_base_lockable_field_cov.sv: {is_include_file: true} + - dv_base_shadowed_field_cov.sv: {is_include_file: true} + - dv_base_mubi_cov.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg.sv new file mode 100644 index 0000000..e3dc212 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg.sv @@ -0,0 +1,591 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// base register class which will be used to generate the reg +class dv_base_reg extends uvm_reg; + // external reg doesn't have storage in reg module, which may connect to some combinational logic + // hence, backdoor write isn't available + local bit is_ext_reg; + + local bit is_shadowed; + local bit shadow_wr_staged; // stage the first shadow reg write + local bit shadow_update_err; + local bit backdoor_write_shadow_val; // flag to avoid predict `shadow_wr_staged` + // Update internal shadow committed and shadowed values when register access is not `RW`. + local bit do_update_shadow_vals; + // In certain shadow reg (e.g. in AES), fatal error can lock write access. + local bit shadow_fatal_lock; + local string update_err_alert_name; + local string storage_err_alert_name; + + // This should be set if the register can be affected by a write even if that write also causes an + // error (because of an invalid mask, for example). + // + // TODO: This is really here as a workaround for a minor RTL bug, tracked in issue #24053. Once + // that issue is closed, remove this flag again. + bit writes_ignore_errors; + + // This is used for get_alias_name + string alias_name = ""; + // Lookup table for alias fields (used for get_field_by_name) + string field_alias_lookup[string]; + + // atomic_en_shadow_wr: semaphore to guarantee setting or resetting en_shadow_wr is unchanged + // through the 1st/2nd (or both) writes + semaphore atomic_en_shadow_wr; + + // A semaphore that's used to control processes that wish to write to the register (using + // uvm_reg::write). This was originally a workaround for a rather silly UVM bug that was only + // fixed in version 2020-2.0. It caused multiple processes to collide in a critical section if + // more than two are trying to write a register at once. + // + // Note that this semaphore controls reads as well as writes, because both operations use the + // m_is_busy flag. + // + // However, the lock is also useful if a process wishes to use predict(), in which case the + // m_is_busy flag should be false. To allow sequences to do that safely, the take_lock and + // release_lock methods that control this lock are not local. + local semaphore access_lock; + + function new(string name = "", + int unsigned n_bits, + int has_coverage); + super.new(name, n_bits, has_coverage); + atomic_en_shadow_wr = new(1); + access_lock = new(1); + endfunction : new + + // Create this register and its fields' IP-specific functional coverage. + function void create_cov(); + dv_base_reg_field fields[$]; + get_dv_base_reg_fields(fields); + foreach(fields[i]) fields[i].create_cov(); + // Create register-specific covergroups here. + endfunction + + // this is similar to get_name, but it gets the + // simple name of the aliased register instead. + function string get_alias_name (); + return this.alias_name; + endfunction: get_alias_name + + // this is similar to set_name, but it sets the + // simple name of the aliased register instead. + function void set_alias_name (string alias_name); + dv_base_reg_block reg_block; + `downcast(reg_block, get_parent()) + reg_block.register_alias_lookup[alias_name] = this.get_name(); + this.alias_name = alias_name; + endfunction: set_alias_name + + function void get_dv_base_reg_fields(ref dv_base_reg_field dv_fields[$]); + foreach (m_fields[i]) `downcast(dv_fields[i], m_fields[i]) + endfunction + + function dv_base_reg_block get_dv_base_reg_block(); + `downcast(get_dv_base_reg_block, get_parent()) + endfunction + + function uvm_reg_data_t get_predicted_mask(); + uvm_reg_data_t mask = 0; + dv_base_reg_field fields_q[$]; + this.get_dv_base_reg_fields(fields_q); + + foreach (fields_q[i]) begin + if (fields_q[i].has_prediction) begin + for (int j = 0; j < fields_q[i].get_n_bits(); j++) + mask[j+fields_q[i].get_lsb_pos()] = 1'b1; + end + end + + return mask; + endfunction + + // get_n_bits will return number of all the bits in the csr + // while this function will return actual number of bits used in reg field + function uint get_n_used_bits(); + foreach (m_fields[i]) get_n_used_bits += m_fields[i].get_n_bits(); + endfunction + + // loop all the fields to find the msb position of this reg + function uint get_msb_pos(); + foreach (m_fields[i]) begin + uint field_msb_pos = m_fields[i].get_lsb_pos() + m_fields[i].get_n_bits() - 1; + if (field_msb_pos > get_msb_pos) get_msb_pos = field_msb_pos; + end + endfunction + + virtual function dv_base_reg_field get_dv_base_reg_field_by_name(string fld_name, + bit check_fld_exist = 1'b1); + uvm_reg_field fld = get_field_by_name(fld_name); + dv_base_reg_field dv_fld; + + `downcast(dv_fld, fld) + if (check_fld_exist) begin + `DV_CHECK_NE_FATAL(dv_fld, null, + $sformatf("%0s does not exist in reg %0s", fld_name, get_full_name())) + end + return dv_fld; + endfunction + + // Return a mask of valid bits in the register. + virtual function uvm_reg_data_t get_reg_mask(); + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + foreach (flds[i]) begin + get_reg_mask |= flds[i].get_field_mask(); + end + endfunction + + // Return a mask of read-only bits in the register. + virtual function uvm_reg_data_t get_ro_mask(); + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + foreach (flds[i]) begin + get_ro_mask |= flds[i].get_ro_mask(); + end + endfunction + + // this function can only be called when this reg is intr_state reg + // Example: ral.intr_state.get_intr_pins_exp_value(). And it returns value of + // intr_state & intr_enable, which represents value of interrupt pins + virtual function uvm_reg_data_t get_intr_pins_exp_value(); + uvm_reg_block blk = get_parent(); + uvm_reg intr_enable_csr; + string intr_enable_csr_name; + bit is_intr_state_csr = !(uvm_re_match("intr_state*", get_name())); + + `DV_CHECK_EQ_FATAL(is_intr_state_csr, 1) + + // intr_enable and intr_state have the same suffix + intr_enable_csr_name = str_utils_pkg::str_replace(get_name(), "state", "enable"); + + intr_enable_csr = blk.get_reg_by_name(intr_enable_csr_name); + + // some interrupts may not have intr_enable + if (intr_enable_csr != null) begin + return get_mirrored_value() & intr_enable_csr.get_mirrored_value(); + end else begin + return get_mirrored_value(); + end + endfunction + + // Wen reg/fld can lock specific groups of fields' write access. The lockable fields are called + // lockable flds. + function void add_lockable_reg_or_fld(uvm_object lockable_obj); + dv_base_reg_field wen_fld; + `DV_CHECK_FATAL(m_fields.size(), 1, "This register has more than one field.\ + Please use register field's add_lockable_reg_or_fld() method instead.") + `downcast(wen_fld, m_fields[0]) + wen_fld.add_lockable_reg_or_fld(lockable_obj); + endfunction + + // Returns true if this register/field can lock the specified register/field, else return false. + function bit locks_reg_or_fld(uvm_object obj); + dv_base_reg_field wen_fld; + `DV_CHECK_FATAL(m_fields.size(), 1, "This register has more than one field.\ + Please use register field's locks_reg_or_fld() method instead.") + `downcast(wen_fld, m_fields[0]) + return wen_fld.locks_reg_or_fld(obj); + endfunction + + // Even though user can add lockable register or field via `add_lockable_reg_or_fld` method, the + // get_lockable_flds function will always return a queue of lockable fields. + function void get_lockable_flds(ref dv_base_reg_field lockable_flds_q[$]); + dv_base_reg_field wen_fld; + `DV_CHECK_FATAL(m_fields.size(), 1, "This register has more than one field.\ + Please use register field's get_lockable_flds() method instead.") + `downcast(wen_fld, m_fields[0]) + wen_fld.get_lockable_flds(lockable_flds_q); + endfunction + + // The register is a write enable register (wen_reg) if its fields are wen_flds. + function bit is_wen_reg(); + foreach (m_fields[i]) begin + dv_base_reg_field fld; + `downcast(fld, m_fields[i]) + if (fld.is_wen_fld()) return 1; + end + return 0; + endfunction + + function bit is_staged(); + return shadow_wr_staged; + endfunction + + // is_shadowed bit is only one-time programmable + // once this function is called in RAL auto-generated class, it cannot be changed + function void set_is_shadowed(); + is_shadowed = 1; + endfunction + + // A helper function for shadow register or field read to clear the `shadow_wr_staged` flag. + virtual function void clear_shadow_wr_staged(); + if (is_shadowed) begin + if (shadow_wr_staged) `uvm_info(`gfn, "clear shadow_wr_staged", UVM_HIGH) + shadow_wr_staged = 0; + clear_shadow_update_err(); + end + endfunction + + function bit get_is_shadowed(); + return is_shadowed; + endfunction + + function bit get_shadow_update_err(); + return shadow_update_err; + endfunction + + function bit get_shadow_storage_err(); + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + foreach (flds[i]) begin + get_shadow_storage_err |= flds[i].get_shadow_storage_err(); + end + endfunction + + virtual function void clear_shadow_update_err(); + shadow_update_err = 0; + endfunction + + // do_predict callback to handle special regs. This function doesn't update mirror values, but + // update local variables used for the special regs. + // - shadow register: shadow reg won't be updated until the second write has no error + // - lock register: if wen_fld is set to 0, change access policy to all the lockable_flds + virtual function void pre_do_predict(uvm_reg_item rw, uvm_predict_e kind); + + // Skip updating shadow value or access type if: + // 1). Access is not OK, as access is aborted. + // 2). The operation is not write. + // 3). The update is triggered by backdoor poke. + if (rw.status != UVM_IS_OK || kind != UVM_PREDICT_WRITE || backdoor_write_shadow_val) return; + + if (is_shadowed && !shadow_fatal_lock) begin + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + + foreach (flds[i]) begin + // `rw.value` is a dynamic array. + uvm_reg_data_t wr_data = get_field_val(flds[i], rw.value[0]); + + // Skip updating shadow value or access type for this field if: + // 1). A storage error is triggered, which means the field is locked to error status. + // 2). The register is "RO". This condition is used to cover enable register locks shadowed + // register's write access. + if (flds[i].get_shadow_storage_err() || flds[i].get_access() == "RO") continue; + + // first write + if (!shadow_wr_staged) begin + flds[i].update_staged_val(wr_data); + continue; + end begin + // second write + if (flds[i].get_staged_val() == wr_data) begin + flds[i].update_committed_val(wr_data); + flds[i].update_shadowed_val(~wr_data); + end else begin + shadow_update_err = 1; + flds[i].sample_shadow_field_cov(.update_err(1)); + end + end + end + if (!shadow_wr_staged) shadow_wr_staged = 1; + else shadow_wr_staged = 0; + + // Update committed and shadowed values if the field access is not "RW". + // Used for register with special access policy such as `RW1S`. + if (!shadow_wr_staged && flds[0].get_access() != "RW") do_update_shadow_vals = 1; + end + endfunction + + // shadow register read will clear its phase tracker + virtual task post_read(uvm_reg_item rw); + if (rw.status == UVM_IS_OK) clear_shadow_wr_staged(); + endtask + + virtual function void set_is_ext_reg(bit is_ext); + is_ext_reg = is_ext; + endfunction + + virtual function bit get_is_ext_reg(); + return is_ext_reg; + endfunction + + // Override do_predict function to support shadow_reg. + // Skip predict in one of the following conditions: + // 1). It is shadow_reg's first write. + // 2). The shadow_reg is locked due to fatal storage error and it is not a backdoor write. + // Note that if shadow_register write has update error, we only update the value with correct + // fields. + virtual function void do_predict(uvm_reg_item rw, + uvm_predict_e kind = UVM_PREDICT_DIRECT, + uvm_reg_byte_en_t be = -1); + pre_do_predict(rw, kind); + if (is_shadowed && kind != UVM_PREDICT_READ) begin + if (shadow_wr_staged || (shadow_fatal_lock && rw.path != UVM_BACKDOOR)) begin + `uvm_info(`gfn, $sformatf( + "skip predict %s: due to shadow_reg_first_wr=%0b, shadow_fatal_lock=%0b", + get_name(), shadow_wr_staged, shadow_fatal_lock), UVM_HIGH) + return; + end else begin + `uvm_info(`gfn, $sformatf( + "Update shadow reg %0s rw.value from %0h to %0h", + get_name(), rw.value[0], get_committed_val()), UVM_HIGH) + rw.value[0] = get_committed_val(); + end + end + super.do_predict(rw, kind, be); + + // For register with special access policies, update committed and shadowed value again with + // the actual predicted value. + if (do_update_shadow_vals) begin + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + foreach (flds[i]) begin + if (!flds[i].get_shadow_storage_err()) begin + flds[i].update_committed_val(`gmv(flds[i])); + flds[i].update_shadowed_val(~`gmv(flds[i])); + end + end + do_update_shadow_vals = 0; + end + lock_lockable_flds(rw.value[0], kind); + endfunction + + // This function is used for wen_reg to lock its lockable flds by changing the lockable flds' + // access policy. For register write via csr_wr(), this function is included in post_write(). + // For register write via tl_access(), user will need to call this function manually. + virtual function void lock_lockable_flds(uvm_reg_data_t val, uvm_predict_e kind); + if (!is_wen_reg()) return; + + foreach (m_fields[i]) begin + dv_base_reg_field fld; + `downcast(fld, m_fields[i]) + + if (fld.is_wen_fld()) begin + uvm_reg_data_t field_val = val & fld.get_field_mask(); + string field_access = fld.get_access(); + + // Check whether this field of the regwen is writeable at all (the regwen might not be + // writeable by software, in which case we can ignore it) + if (field_access == "RO") + continue; + + if (fld.get_mubi_width() == 0) begin + // This field is not encoded with a mubi value, and the only access type that we support + // is W0C. Check that it has been set up properly. + if (field_access != "W0C") begin + `uvm_fatal(`gfn, $sformatf("Field has access %0s (not W0C) and is not a mubi type.", + field_access)) + end + + // Because this field is W0C, software is allowed to clear it (disabling the write-enable) + // by writing a zero. Writing any other value will have no effect. + // + // A UVM_PREDICT_DIRECT prediction is a way for DV code to directly inform the RAL of a + // write coming through (not necessarily from software). This works by setting each bit if + // that bit of the write value is zero. + if (kind == UVM_PREDICT_WRITE && field_val == 1'b0) begin + fld.set_lockable_flds_access(1); + end else if (kind == UVM_PREDICT_DIRECT) begin + fld.set_lockable_flds_access((~field_val) & fld.get_field_mask()); + end + end else begin + // This field is encoded as a mubi value of the given width. + uvm_reg_data_t encoded_true; + + // Mubi fields only support the RW access value in UVM (because the bitwise operation to + // clear a mubi will set some bits and clear others!) + if (field_access != "RW") begin + `uvm_fatal(`gfn, $sformatf("Field has access %0s (not RW) but is a mubi type.", + field_access)) + end + + case (fld.get_mubi_width()) + 4: encoded_true = prim_mubi_pkg::MuBi4True; + 8: encoded_true = prim_mubi_pkg::MuBi8True; + 16: encoded_true = prim_mubi_pkg::MuBi16True; + 32: encoded_true = prim_mubi_pkg::MuBi32True; + default: `uvm_fatal(`gfn, $sformatf("Unknown mubi width: %0d", fld.get_mubi_width())) + endcase + + // Process the write as having locked the field if the value being written is anything + // other than encoded_true. A write of encoded_true is a nop. + if (field_val != encoded_true) begin + fld.set_lockable_flds_access(1); + end + end + end + end + endfunction + + virtual task poke(output uvm_status_e status, + input uvm_reg_data_t value, + input string kind = "BkdrRegPathRtl", + input uvm_sequence_base parent = null, + input uvm_object extension = null, + input string fname = "", + input int lineno = 0); + + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + foreach (flds[i]) begin + if (kind == "BkdrRegPathRtlShadow") begin + flds[i].update_shadowed_val(get_field_val(flds[i], value)); + backdoor_write_shadow_val = 1; + end else if (kind == "BkdrRegPathRtl") begin + flds[i].update_committed_val(get_field_val(flds[i], value)); + backdoor_write_shadow_val = 1; + end + end + take_lock(); + super.poke(status, value, kind, parent, extension, fname, lineno); + release_lock(); + backdoor_write_shadow_val = 0; + endtask + + virtual function uvm_reg_data_t get_committed_val(); + dv_base_reg_field flds[$]; + this.get_dv_base_reg_fields(flds); + foreach (flds[i]) begin + get_committed_val |= flds[i].get_committed_val() << flds[i].get_lsb_pos(); + end + endfunction + + virtual function void reset(string kind = "HARD"); + super.reset(kind); + if (is_shadowed) begin + shadow_update_err = 0; + shadow_wr_staged = 0; + shadow_fatal_lock = 0; + // Make a new copy of the shadow write semaphore, so that we don't need a shadowed write + // operation to complete if a reset happens in the middle of one. + atomic_en_shadow_wr = new(1); + end + endfunction + + function void add_update_err_alert(string name); + if (update_err_alert_name == "") update_err_alert_name = name; + endfunction + + function void add_storage_err_alert(string name); + if (storage_err_alert_name == "") storage_err_alert_name = name; + endfunction + + function string get_update_err_alert_name(); + // block level alert name is input alert name from hjson + if (get_parent().get_parent() == null) return update_err_alert_name; + + // top-level alert name is ${ip_name} + alert name from hjson + return ($sformatf("%0s_%0s", get_dv_base_reg_block().get_ip_name(), update_err_alert_name)); + endfunction + + function void lock_shadow_reg(); + shadow_fatal_lock = 1; + endfunction + + function bit shadow_reg_is_locked(); + return shadow_fatal_lock; + endfunction + + function string get_storage_err_alert_name(); + string ip_name; + + // block level alert name is input alert name from hjson + if (get_parent().get_parent() == null) return storage_err_alert_name; + + // top-level alert name is ${ip_name} + alert name from hjson + return ($sformatf("%0s_%0s", get_dv_base_reg_block().get_ip_name(), storage_err_alert_name)); + endfunction + + // this overrides the get_field_by_name function + function dv_base_reg_field get_field_by_name(string name); + dv_base_reg_field retval; + if (field_alias_lookup.exists(name)) begin + `downcast(retval, super.get_field_by_name(field_alias_lookup[name])) + end else begin + `downcast(retval, super.get_field_by_name(name)) + end + return retval; + endfunction + + // Take the register's lock (see the documentation above access_lock for more details) + // + // This is mostly used in the wrappers around read, write etc. (working around a UVM bug). But the + // task is not local, because another class might want to use the predict method, which musn't + // overlap with the m_is_busy flag in uvm_reg. Taking this lock ensures it won't. + task take_lock(); + access_lock.get(); + endtask + + // Release the register's lock (see the documentation above access_lock for more details). This + // should only be called by a process that has already taken the lock with take_lock. + function void release_lock(); + access_lock.put(); + endfunction + + // A thin wrapper around uvm_reg::write that takes access_lock. See notes above access_lock that + // explain why it's needed. + task write(output uvm_status_e status, + input uvm_reg_data_t value, + input uvm_path_e path = UVM_DEFAULT_PATH, + input uvm_reg_map map = null, + input uvm_sequence_base parent = null, + input int prior = -1, + input uvm_object extension = null, + input string fname = "", + input int lineno = 0); + take_lock(); + super.write(status, value, path, map, parent, prior, extension, fname, lineno); + release_lock(); + endtask + + // A thin wrapper around uvm_reg::read that takes access_lock. See notes above access_lock that + // explain why it's needed. + task read(output uvm_status_e status, + output uvm_reg_data_t value, + input uvm_path_e path = UVM_DEFAULT_PATH, + input uvm_reg_map map = null, + input uvm_sequence_base parent = null, + input int prior = -1, + input uvm_object extension = null, + input string fname = "", + input int lineno = 0); + take_lock(); + super.read(status, value, path, map, parent, prior, extension, fname, lineno); + release_lock(); + endtask + + // A thin wrapper around uvm_reg::peek that takes access_lock. See notes above access_lock that + // explain why it's needed. + task peek(output uvm_status_e status, + output uvm_reg_data_t value, + input string kind = "", + input uvm_sequence_base parent = null, + input uvm_object extension = null, + input string fname = "", + input int lineno = 0); + take_lock(); + super.peek(status, value, kind, parent, extension, fname, lineno); + release_lock(); + endtask + + // A thin wrapper around uvm_reg::mirror that takes access_lock. See notes above access_lock that + // explain why it's needed. + task mirror(output uvm_status_e status, + input uvm_check_e check = UVM_NO_CHECK, + input uvm_path_e path = UVM_DEFAULT_PATH, + input uvm_reg_map map = null, + input uvm_sequence_base parent = null, + input int prior = -1, + input uvm_object extension = null, + input string fname = "", + input int lineno = 0); + take_lock(); + super.mirror(status, check, path, map, parent, prior, extension, fname, lineno); + release_lock(); + endtask + + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_block.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_block.sv new file mode 100644 index 0000000..76900b2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_block.sv @@ -0,0 +1,616 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// base register block class which will be used to generate the reg blocks +class dv_base_reg_block extends uvm_reg_block; + `m_uvm_get_type_name_func(dv_base_reg_block) + + // The default addr, data and byte widths. + // + // The UVM reg data structures are built on `UVM_REG_ADDR|DATA|BYTEENABLE_WIDTH settings which + // are compile time, i.e. fixed for all RAL models across the project. What if we have multiple + // RAL models that have different width needs? The solution is to let the UVM data structures be + // created with large enough widths to accommodate a heterogeneous set of RAL models, and use + // these runtime settings below instead, to perform associated computations. Values retrieved + // for comparisons, such as uvm_reg::get_mirrored_value() may return data that is wider than + // needed. It would then be upto the testbench to cast it to the appropriate width if necessary. + // + // These are configured with build() function. + protected int unsigned m_addr_width; + protected int unsigned m_data_width; + protected int unsigned m_be_width; + + // Since an IP may contains more than one reg block we construct reg_block name as + // {ip_name}_{reg_interface_name}. + // All the reg_blocks in the IP share the same alert. In top-level, We construct the alert + // name as {ip_name}_{alert_name}. Hence, we need this ip_name in reg_block + local string ip_name; + + // CSR exclusion object that holds exclusion tags for the sub-blocks, CSRs and fields. + protected csr_excl_item csr_excl; + + // The address mask for the register block specific to a map. This will be (1 << K) - 1 for some + // K. All relative offsets in the register block have addresses less than (1 << K), so an address + // decoder that starts by discarding all higher bits will work correctly so long as the chosen + // base address of the register block has no bits in common with this mask. + // + // This is set by compute_addr_mask(), which must run after locking the model. + protected uvm_reg_addr_t addr_mask[uvm_reg_map]; + + // A list of all ranges associated with memories, ordered by increasing start address. + // + // To get the list of memory ranges, use get_mem_ranges (which is memoized). + local addr_range_t m_mem_ranges[$]; + + // A flag showing that m_mem_ranges has been computed by a previous call to get_mem_ranges + local bit m_mem_ranges_known; + + // A list of all ranges that are associated with either a memory or a register + // + // This is populated by compute_mapped_addr_ranges, which builds it from the result of + // get_mem_ranges together with the ranges formed by iterating over the registers and the range of + // each. This is sorted in ascending order based on start_addr. + addr_range_t mapped_addr_ranges[$]; + + // Indicates whether accesses to unmapped regions of this block returns an error response (0). + protected bit unmapped_access_ok; + + // Indicates whether byte writes are supported (enabled by default). + // TODO: Remove this in future - this is really a property of the physical interface that is used + // to access design through this RAL model (a.k.a, the map & adapter), and not the RAL model + // itself. This information should be sought using uvm_reg_adapter::supports_byte_enable instead. + // This is added for ease of rv_dm testbench development. + protected bit supports_byte_enable = 1'b1; + + // Indicates whether an instruction fetch is allowed from a CSR. This isn't something you'd + // normally expect, but it allows us to model a block that contains both registers and memory and + // doesn't make a distinction between read and fetch. + local bit allows_csr_fetch = 1'b0; + + // Custom RAL models may support sub-word CSR writes smaller than CSR width. + protected bit supports_sub_word_csr_writes = 1'b0; + + // Enables functional coverage of comportable IP-specific specialized registers, such as regwen + // and mubi. This flag can only be disabled before invoking `create_dv_reg_cov`. + protected bit en_dv_reg_cov = 1; + + bit has_unmapped_addrs; + + // A queue of all the unmapped address ranges. All mapped addresses for this block are between the + // base address (using the default map) and that plus the maximum address representable with the + // address mask. + // + // Unmapped addresses are the addresses in that range that don't point at a register of part of a + // memory. This variable holds those addresses, grouped into ranges and sorted in ascending order + // of start_addr. + addr_range_t unmapped_addr_ranges[$]; + + // Lookup table for alias registers and fields. + string register_alias_lookup[string]; + string field_alias_lookup[string]; + + function new (string name = "", int has_coverage = UVM_NO_COVERAGE); + super.new(name, has_coverage); + endfunction + + function void set_ip_name(string name); + ip_name = name; + endfunction + + function string get_ip_name(); + // `DV_CHECK_FATAL can't take "" as an input + string empty_str = ""; + `DV_CHECK_FATAL(ip_name != empty_str, "ip_name hasn't been set yet") + return ip_name; + endfunction + + // Returns the CSR exclusion item attached to the block. + virtual function csr_excl_item get_excl_item(); + return csr_excl; + endfunction + + function void set_unmapped_access_ok(bit ok); + unmapped_access_ok = ok; + endfunction + + function bit get_unmapped_access_ok(); + return unmapped_access_ok; + endfunction + + function void set_supports_byte_enable(bit enable); + supports_byte_enable = enable; + endfunction + + function bit get_supports_byte_enable(); + return supports_byte_enable; + endfunction + + function void set_supports_sub_word_csr_writes(bit enable); + supports_sub_word_csr_writes = enable; + endfunction + + function bit get_supports_sub_word_csr_writes(); + return supports_sub_word_csr_writes; + endfunction + + function void set_allows_csr_fetch(bit allowed); + allows_csr_fetch = allowed; + endfunction + + function bit get_allows_csr_fetch(); + return allows_csr_fetch; + endfunction + + // provide build function to supply base addr + virtual function void build(uvm_reg_addr_t base_addr, + csr_excl_item csr_excl, + int unsigned addr_width, + int unsigned data_width, + int unsigned be_width); + m_addr_width = addr_width; + m_data_width = data_width; + m_be_width = be_width; + endfunction + + // This function is invoked at the end of `build` method in uvm_reg_base.sv template to create + // IP-specific functional coverage for this block and its registers and fields. + function void create_cov(); + dv_base_reg_block blks[$]; + dv_base_reg regs[$]; + + get_dv_base_reg_blocks(blks); + foreach (blks[i]) blks[i].create_cov(); + + get_dv_base_regs(regs); + foreach (regs[i]) regs[i].create_cov(); + // Create block-specific covergroups here. + endfunction + + function void get_dv_base_reg_blocks(ref dv_base_reg_block blks[$]); + uvm_reg_block uvm_blks[$]; + this.get_blocks(uvm_blks); + foreach (uvm_blks[i]) `downcast(blks[i], uvm_blks[i]) + endfunction + + function void get_dv_base_regs(ref dv_base_reg dv_regs[$]); + uvm_reg ral_regs[$]; + // if the ral has hier, this function will recursively includes the registers in the sub-blocks + this.get_registers(ral_regs); + foreach (ral_regs[i]) `downcast(dv_regs[i], ral_regs[i]) + endfunction + + function dv_base_reg get_dv_base_reg_by_name(string csr_name, bit check_csr_exist = 1'b1); + uvm_reg csr = get_reg_by_name(csr_name); + `downcast(get_dv_base_reg_by_name, csr) + if (check_csr_exist) begin + `DV_CHECK_NE_FATAL(get_dv_base_reg_by_name, null, + $sformatf("%0s does not exist in block %0s",csr_name, get_name())) + end + endfunction + + virtual function void get_shadowed_regs(ref dv_base_reg shadowed_regs[$]); + dv_base_reg all_regs[$]; + this.get_dv_base_regs(all_regs); + foreach (all_regs[i]) begin + if (all_regs[i].get_is_shadowed()) shadowed_regs.push_back(all_regs[i]); + end + endfunction + + function bit has_shadowed_regs(); + dv_base_reg regs[$]; + get_shadowed_regs(regs); + return (regs.size() > 0); + endfunction + + // Internal function, used to compute the address mask for this register block. + // + // This is quite an expensive computation, so we memoize the results in addr_mask[map]. + // Use below to get the addr map size #3317 + // max2(biggest_reg_offset+reg_size, biggest_mem_offset+mem_size) and then round up to 2**N + protected function void compute_addr_mask(uvm_reg_map map); + uvm_reg_addr_t max_offset; + uvm_reg_block blocks[$]; + int unsigned alignment; + + // Assumption: + // Only chip-level RAL has multiple sub reg_blocks. Its addr_mask is '1 + // In block-level, we have one RAL for one TLUL interface. We don't put multiple reg_block in a + // RAL, as UVM RAL can't handle the case that each sub-block uses a different map: + // - ral.blk1 -> use map_TL1 + // - ral.blk2 -> use map_TL2 + get_blocks(blocks); + if (blocks.size > 0) begin // if true, this is a chip-level RAL + addr_mask[map] = '1; + return; + end + + max_offset = get_max_offset(map); + + // Set alignment to be ceil(log2(biggest_offset)) + alignment = 0; + while (max_offset > 0) begin + alignment++; + max_offset = max_offset >> 1; + end + + // Note that we know alignment > 0 (because we've already checked that we have at least one + // register or memory). + `DV_CHECK_GT_FATAL(alignment, 0) + + // Finally, extract a mask corresponding to the alignment + addr_mask[map] = (1 << alignment) - 1; + + // Computed mask must be non-zero. + `DV_CHECK_FATAL(addr_mask[map]) + endfunction + + // Internal function, used to get a list of all valid memory ranges + // + // Note that the block might not have any memories, in which case m_mem_ranges will be empty after + // this function. + local function void ensure_mem_ranges(); + uvm_mem mems[$]; + + if (m_mem_ranges_known) return; + + // Get any memories associated with the uvm_reg_block. (There may be none) + get_memories(mems); + + // Clear any existing contents of m_mem_ranges and then project the memories we just found to + // their start / end addresses, writing the ranges to m_mem_ranges. + m_mem_ranges.delete(); + foreach (mems[i]) begin + addr_range_t range; + range.start_addr = mems[i].get_address(); + range.end_addr = range.start_addr + mems[i].get_size() * mems[i].get_n_bytes() - 1; + m_mem_ranges.push_back(range); + end + + // Sort m_mem_ranges by start_addr, ensuring that the ordering in the list only depends on the + // addresses of the ranges (rather than the order in which they were defined in the + // configuration) + if (m_mem_ranges.size() > 0) begin + m_mem_ranges.sort() with (item.start_addr); + end + + m_mem_ranges_known = 1; + + // Add a UVM_HIGH print to report what memory ranges are in the block (which will happen once + // per call to set_base_addr because this code only runs when m_mem_ranges_known is false). + // + // This block has no effect on the simulation, so is gated by a check that the messages will be + // printed (to avoid iterating through the list of ranges if not). + if (uvm_report_enabled(UVM_HIGH, UVM_INFO, "ensure_mem_ranges()")) begin + `uvm_info("ensure_mem_ranges()", + $sformatf("%0s has %0d memory ranges%0s", + get_name(), m_mem_ranges.size(), (m_mem_ranges.size() > 0) ? ":" : "."), + UVM_HIGH) + foreach(m_mem_ranges[i]) begin + `uvm_info("ensure_mem_ranges()", + $sformatf("Range %2d: 0x%08h .. 0x%08h", + i, m_mem_ranges[i].start_addr, m_mem_ranges[i].end_addr), + UVM_HIGH) + end + end + endfunction + + // Write the list of address ranges associated with memory to the ranges output argument. + // + // This result is memoized. + function void get_mem_ranges(output addr_range_t ranges[$]); + ensure_mem_ranges(); + ranges = m_mem_ranges; + endfunction + + // Return the number of memories in this reg_block. + // + // This is quick because it uses the same memoization as get_mem_ranges. + function int unsigned get_num_memories(); + ensure_mem_ranges(); + return m_mem_ranges.size(); + endfunction + + // Compute CSR addresses, memory address ranges, and the list of all address ranges used by either + // memories or registers. + // + // This is idempotent and will re-calculate the same lists if called a second time. + local function void compute_mapped_addr_ranges(); + uvm_reg csrs[$]; + addr_range_t mem_ranges[$]; + + get_registers(csrs); + + // Compute all mem ranges known to this reg block + get_mem_ranges(mem_ranges); + + // Convert each CSR into an address range + mapped_addr_ranges.delete(); + foreach (csrs[i]) begin + addr_range_t csr_addr_range; + csr_addr_range.start_addr = csrs[i].get_address(); + csr_addr_range.end_addr = csr_addr_range.start_addr + csrs[i].get_n_bytes() - 1; + mapped_addr_ranges.push_back(csr_addr_range); + end + // Now append the ranges from memories + mapped_addr_ranges = {mapped_addr_ranges, mem_ranges}; + + // Sort the mapped address ranges in ascending order based on the start_addr of each range + mapped_addr_ranges.sort(m) with (m.start_addr); + + `uvm_info(`gfn, $sformatf("mapped_addr_ranges: %0p", mapped_addr_ranges), UVM_HIGH) + endfunction + + // Get a list of all invalid address ranges in this reg block + // + // This is idempotent and will re-calculate the same list if called a second time. + local function void compute_unmapped_addr_ranges(); + addr_range_t range; + + // convert the address mask into a relative address, + // this is the highest addressable location in the register block + uvm_reg_addr_t highest_addr = default_map.get_base_addr() + get_addr_mask(); + + unmapped_addr_ranges.delete(); + + // unmapped address ranges consist of: + // - any gaps in the address space between mapped address ranges + // - any space between the map base address and the first mapped address range + // - space between the last mapped address and the highest address mapped by the address mask + if (mapped_addr_ranges.size() == 0) begin + range.start_addr = default_map.get_base_addr(); + range.end_addr = highest_addr; + unmapped_addr_ranges.push_back(range); + end else begin + // 0 -> start_addr-1 + if (mapped_addr_ranges[0].start_addr - default_map.get_base_addr() > 0) begin + range.start_addr = default_map.get_base_addr(); + range.end_addr = mapped_addr_ranges[0].start_addr - 1; + unmapped_addr_ranges.push_back(range); + end + + // all address ranges in the "middle" - only applies if + // there are more than 1 mapped address ranges + if (mapped_addr_ranges.size() > 1) begin + for (int i = 0; i < mapped_addr_ranges.size() - 1; i++) begin + range.start_addr = mapped_addr_ranges[i].end_addr + 1; + range.end_addr = mapped_addr_ranges[i+1].start_addr - 1; + if (range.start_addr < range.end_addr) begin + unmapped_addr_ranges.push_back(range); + end + end + end + + // end_addr+1 -> highest_addr + if (mapped_addr_ranges[$].end_addr < highest_addr) begin + range.start_addr = mapped_addr_ranges[$].end_addr + 1; + range.end_addr = highest_addr; + unmapped_addr_ranges.push_back(range); + end + end + has_unmapped_addrs = (unmapped_addr_ranges.size() > 0); + `uvm_info(`gfn, $sformatf("unmapped_addr_ranges: %0p", unmapped_addr_ranges), UVM_HIGH) + endfunction + + // Return the offset of the highest byte contained in either a register or a memory + function uvm_reg_addr_t get_max_offset(uvm_reg_map map = null); + uvm_reg_addr_t max_offset; + uvm_reg regs[$]; + uvm_mem mems[$]; + + if (map == null) map = get_default_map(); + + get_registers(regs); + get_memories(mems); + `DV_CHECK_GT_FATAL(regs.size() + mems.size(), 0) + + // Walk the known registers and memories, calculating the largest byte address visible. Note + // that the get_offset() calls will return absolute addresses, including any base address in the + // specified register map. + max_offset = 0; + foreach (regs[i]) begin + max_offset = max2(regs[i].get_offset(map) + regs[i].get_n_bytes() - 1, max_offset); + end + + foreach (mems[i]) begin + uvm_reg_addr_t mem_size; + mem_size = mems[i].get_offset(.map(map)) + mems[i].get_size() * mems[i].get_n_bytes() - 1; + max_offset = max2(mem_size, max_offset); + end + + return max_offset; + endfunction + + // Get the address mask. This should only be called after locking the model (because it depends on + // the layout of registers and memories in the block). + function uvm_reg_addr_t get_addr_mask(uvm_reg_map map = null); + `DV_CHECK_FATAL(is_locked()) + if (map == null) map = get_default_map(); + if (!addr_mask.exists(map)) compute_addr_mask(map); + return addr_mask[map]; + endfunction + + // Set the base address for the given register map to a random value. + // + // The value is chosen to be aligned as required by the register block. If map is null, this sets + // the base address for the default register map. + function void set_randomized_base_addr(uvm_reg_map map = null); + uvm_reg_addr_t mask; + uvm_reg_addr_t base_addr; + + if (map == null) begin + map = get_default_map(); + end + + mask = get_addr_mask(map); + + if (!std::randomize(base_addr) with { + (base_addr & mask) == '0; + base_addr >> m_addr_width == 0; + }) begin + `uvm_fatal(get_name(), + $sformatf("Failed to randomise base address with mask 0x%0x and width %0d.", + mask, m_addr_width)) + end + + set_base_addr(base_addr, map); + endfunction + + // Set the base address for the given register map + // + // After setting the base address, this function clears m_mem_ranges_known then updates + // mapped_addr_ranges and unmapped_addr_ranges. + function void set_base_addr(uvm_reg_addr_t base_addr, uvm_reg_map map = null); + uvm_reg_addr_t mask; + + if (map == null) map = get_default_map(); + mask = get_addr_mask(map); + + // Check that the base address is appropriately aligned, based on the mask we computed from map. + if (base_addr & mask) begin + `uvm_error(get_name(), + $sformatf("Base address of 0x%0h is not aligned to mask 0x%0x.", + base_addr, mask)) + end + + // Check that the base address is actually representable with m_addr_width bits + if (base_addr >> m_addr_width) begin + `uvm_error(get_name(), + $sformatf("Base address of 0x%0h is not representable with %0d bits.", + base_addr, m_addr_width)) + end + + `uvm_info(get_name(), $sformatf("Setting register base address to 0x%0h", base_addr), UVM_HIGH) + map.set_base_addr(base_addr); + + m_mem_ranges_known = 0; + + compute_mapped_addr_ranges(); + compute_unmapped_addr_ranges(); + endfunction + + // Round the given address down to the start of the containing word. For example, if the address + // is 'h123, it will be rounded down to 'h120. + // + // This is useful if you have a possibly misaligned address and you want to know whether it hits a + // register (since get_reg_by_offset needs the aligned address for the start of the register). + function uvm_reg_addr_t get_word_aligned_addr(uvm_reg_addr_t byte_addr); + uvm_reg_addr_t shift = $clog2(m_be_width); + return (byte_addr >> shift) << shift; + endfunction + + // Get the absolute address (in the default register map) for the given offset. For example, if + // the base address is 'h100 and offset is 'h13, this will return 'h113 ('h110 if word_aligned is + // set). + function uvm_reg_addr_t get_addr_from_offset(uvm_reg_addr_t byte_offset, + bit word_aligned = 1'b1, + uvm_reg_map map = null); + if (map == null) map = get_default_map(); + return (word_aligned ? get_word_aligned_addr(byte_offset) : byte_offset) + map.get_base_addr(); + endfunction + + // The design ignores the address bits that aren't enabled by addr_mask. + // Normalize these ignored bits to enable locating which CSR/mem is at the returned address. + function uvm_reg_addr_t get_normalized_addr(uvm_reg_addr_t byte_addr, uvm_reg_map map = null); + if (map == null) map = get_default_map(); + return get_addr_from_offset(.byte_offset(byte_addr & get_addr_mask(map)), + .word_aligned(1), + .map(map)); + endfunction + + // Set default map for this block and all its sub-blocks by name. + // This function only works if user is setting default map for all blocks under the hierarchy + // with the same map name. + function void set_default_map_w_subblks_by_name(string map_name); + dv_base_reg_block subblks[$]; + uvm_reg_map map = this.get_map_by_name(map_name); + `DV_CHECK(map != null) + this.set_default_map(map); + + get_dv_base_reg_blocks(subblks); + foreach (subblks[i]) subblks[i].set_default_map_w_subblks_by_name(map_name); + endfunction + + // this overrides the get_reg_by_name function + function dv_base_reg get_reg_by_name(string name); + dv_base_reg retval; + if (register_alias_lookup.exists(name)) begin + `downcast(retval, super.get_reg_by_name(register_alias_lookup[name])) + end else begin + `downcast(retval, super.get_reg_by_name(name)) + end + return retval; + endfunction + + // this overrides the get_field_by_name function + // note however that this function is only meaningful if the fields are unique within a regblock! + function dv_base_reg_field get_field_by_name(string name); + dv_base_reg_field retval; + if (field_alias_lookup.exists(name)) begin + `downcast(retval, super.get_field_by_name(field_alias_lookup[name])) + end else begin + `downcast(retval, super.get_field_by_name(name)) + end + return retval; + endfunction + + function void set_en_dv_reg_cov(bit val); + uvm_reg csrs[$]; + get_registers(csrs); + `DV_CHECK_FATAL(!csrs.size(), + "Cannot set en_dv_base_reg_cov when covergroups are built already!") + en_dv_reg_cov = val; + endfunction + + function bit get_en_dv_reg_cov(); + return en_dv_reg_cov; + endfunction + + // Return true if there is at least one register in this reg block or a child block + // + // This is equivalent to calling get_registers with hier=UVM_HIER (so that it recurses). It is no + // more efficient, but is slightly more convenient because the call-site doesn't need to create a + // queue to be passed as a reference. + function bit has_csrs(); + uvm_reg regs[$]; + get_registers(regs, UVM_HIER); + return regs.size() > 0; + endfunction + + // Return true if a fetch from rg is allowed because the block that contains it, or one of that + // block's ancestors, has allows_csr_fetch set. + static function bit reg_allows_fetch(uvm_reg rg); + uvm_reg_block blk = rg.get_parent(); + dv_base_reg_block dv_blk; + + while (blk != null) begin + if ($cast(dv_blk, blk) && dv_blk.get_allows_csr_fetch()) return 1'b1; + blk = blk.get_parent(); + end + return 1'b0; + endfunction + + // Collect the registers in this reg block, or a child block, from which an instruction fetch is + // not allowed. + // + // Note that allows_csr_fetch is a property of the block that contains a register, so a + // hierarchical model like the one at chip level may contain a mixture of both sorts of register. + function void get_nofetch_csrs(ref uvm_reg regs[$]); + uvm_reg all_regs[$]; + + regs.delete(); + get_registers(all_regs, UVM_HIER); + foreach (all_regs[i]) begin + if (!reg_allows_fetch(all_regs[i])) regs.push_back(all_regs[i]); + end + endfunction + + // Return true if there is at least one register in this reg block or a child block from which an + // instruction fetch is not allowed. + function bit has_nofetch_csrs(); + uvm_reg regs[$]; + get_nofetch_csrs(regs); + return regs.size() > 0; + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_field.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_field.sv new file mode 100644 index 0000000..c0eae27 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_field.sv @@ -0,0 +1,381 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// base register reg class which will be used to generate the reg field +class dv_base_reg_field extends uvm_reg_field; + + // The access value that the field had when it was configured. If the field can be locked, its + // access value might change to "RO". This value can be used to restore the original access on + // reset. + local string m_original_access; + + local dv_base_reg_field lockable_flds[$]; + local bit is_intr_test_fld; + local uvm_reg_data_t staged_val, committed_val, shadowed_val; + + // if this is lockable field, here is its corresponding regwen object + // if not, below 2 object will be null + local dv_base_reg_field regwen_fld; + local dv_base_lockable_field_cov lockable_field_cov; + + // This is used for get_field_by_name + string alias_name = ""; + + // If this field encodes a mubi, this field encodes special access modes such as W1C that cannot + // be captured with the regular access configuration, since UVM does not model such access modes + // correctly for mubis. + string mubi_access = ""; + + // Default mubi_width = 0 indicates this register field is not a mubi type. + protected int mubi_width; + + // variable for mubi coverage, which is only created when this is a mubi reg + dv_base_mubi_cov mubi_cov; + + // variable for shadowed coverage, which is only created when this is a shadowed reg + local dv_base_shadowed_field_cov shadowed_cov; + + // Set to 1 if prediction is intended to be carried out in the cip_base_scoreboard + bit has_prediction = 0; + + `uvm_object_utils(dv_base_reg_field) + `uvm_object_new + + // this is similar to get_name, but it gets the + // simple name of the aliased field instead. + function string get_alias_name (); + return this.alias_name; + endfunction: get_alias_name + + // this is similar to set_name, but it sets the + // simple name of the aliased field instead. + function void set_alias_name (string alias_name); + dv_base_reg register; + dv_base_reg_block reg_block; + `downcast(register, this.get_parent()) + register.field_alias_lookup[alias_name] = this.get_name(); + // We also add the name to the lookup table inside the reg_block to enable get_field_by_name at + // that level. Note: in order for the get_field_by_name function of dv_base_reg_block to + // produce meaningful results, all field names within the reg block have to be unique - which + // cannot always guaranteed. If the fields are not unique at that level, the get_field_by_name + // of dv_base_reg should be used instead. + `downcast(reg_block, register.get_parent()) + reg_block.field_alias_lookup[alias_name] = this.get_name(); + this.alias_name = alias_name; + endfunction: set_alias_name + + // Issue #5105: UVM forces the value member to be non-randomizable for certain access policies. + // We restore it in this extended class. + virtual function void configure(uvm_reg parent, + int unsigned size, + int unsigned lsb_pos, + string access, + string mubi_access, + bit volatile, + uvm_reg_data_t reset, + bit has_reset, + bit is_rand, + bit individually_accessible); + super.configure(.parent (parent), + .size (size), + .lsb_pos (lsb_pos), + .access (access), + .volatile (volatile), + .reset (reset), + .has_reset(has_reset), + .is_rand (is_rand), + .individually_accessible(individually_accessible)); + value.rand_mode(is_rand); + this.mubi_access = mubi_access; + this.m_original_access = access; + is_intr_test_fld = !(uvm_re_match("intr_test*", get_parent().get_name())); + shadowed_val = ~committed_val; + endfunction + + virtual function dv_base_reg get_dv_base_reg_parent(); + uvm_reg csr = get_parent(); + `downcast(get_dv_base_reg_parent, csr) + endfunction + + // Local helper function to reduce code in do_predict further below. + function uvm_reg_data_t mubi_or_hi (uvm_reg_data_t a, uvm_reg_data_t b); + import prim_mubi_pkg::*; + uvm_reg_data_t out; + case (mubi_width) + 4: out = uvm_reg_data_t'(mubi4_or_hi(mubi4_t'(a), mubi4_t'(b))); + 8: out = uvm_reg_data_t'(mubi8_or_hi(mubi8_t'(a), mubi8_t'(b))); + 12: out = uvm_reg_data_t'(mubi12_or_hi(mubi12_t'(a), mubi12_t'(b))); + 16: out = uvm_reg_data_t'(mubi16_or_hi(mubi16_t'(a), mubi16_t'(b))); + default: $error("Unsupported mubi width %d.", mubi_width); + endcase + return out; + endfunction: mubi_or_hi + + // Local helper function to reduce code in do_predict further below. + function uvm_reg_data_t mubi_and_hi (uvm_reg_data_t a, uvm_reg_data_t b); + import prim_mubi_pkg::*; + uvm_reg_data_t out; + case (mubi_width) + 4: out = uvm_reg_data_t'(mubi4_and_hi(mubi4_t'(a), mubi4_t'(b))); + 8: out = uvm_reg_data_t'(mubi8_and_hi(mubi8_t'(a), mubi8_t'(b))); + 12: out = uvm_reg_data_t'(mubi12_and_hi(mubi12_t'(a), mubi12_t'(b))); + 16: out = uvm_reg_data_t'(mubi16_and_hi(mubi16_t'(a), mubi16_t'(b))); + default: $error("Unsupported mubi width: %d.", mubi_width); + endcase + return out; + endfunction: mubi_and_hi + + // Local helper function to reduce code in do_predict further below. + function uvm_reg_data_t mubi_false (); + import prim_mubi_pkg::*; + uvm_reg_data_t out; + case (mubi_width) + 4: out = uvm_reg_data_t'(MuBi4False); + 8: out = uvm_reg_data_t'(MuBi8False); + 12: out = uvm_reg_data_t'(MuBi12False); + 16: out = uvm_reg_data_t'(MuBi16False); + default: $error("Unsupported mubi width: %d.", mubi_width); + endcase + return out; + endfunction: mubi_false + + virtual function void do_predict (uvm_reg_item rw, + uvm_predict_e kind = UVM_PREDICT_DIRECT, + uvm_reg_byte_en_t be = -1); + uvm_reg_data_t field_val = rw.value[0] & ((1 << get_n_bits())-1); + string access = get_access(); + + // update intr_state mirrored value if this is an intr_test reg + // if kind is UVM_PREDICT_DIRECT or UVM_PREDICT_READ, super.do_predict can handle + if (kind == UVM_PREDICT_WRITE && is_intr_test_fld) begin + uvm_reg_field intr_state_fld = get_intr_state_field(); + uvm_reg_data_t predict_val; + if (intr_state_fld.get_access == "RO") begin // status interrupt + predict_val = field_val | intr_state_fld.get_reset(); + end else begin // regular W1C interrupt + `DV_CHECK_STREQ(intr_state_fld.get_access, "W1C") + predict_val = field_val | `gmv(intr_state_fld); + end + // use UVM_PREDICT_READ to avoid uvm_warning due to UVM_PREDICT_DIRECT + void'(intr_state_fld.predict(predict_val, .kind(UVM_PREDICT_READ))); + + end else if (kind == UVM_PREDICT_WRITE && mubi_access inside {"W1S", "W1C", "W0C"}) + begin + // Some smoke checking of the byte enables. RTL does not latch anything if not all affected + // bytes of the field are enabled. Note that we still use UVM_PREDICT_WRITE further below + // since the underlying access is set to RW in the RAL model. + if (mubi_width <= 8 && be[0] || mubi_width > 8 && mubi_width <= 16 && &be[1:0]) begin + // In case this is a clearable MUBI field, we have to interpret the write value correctly. + // ICEBOX(#9273): Note that this just uses bitwise functions to update the value and does + // not rectify incorrect mubi values. At a later point, we should discuss if and how to + // tighten this up, as discussed on the linked issue. + case (mubi_access) + "W1S": rw.value[0] = this.mubi_or_hi(rw.value[0], `gmv(this)); + "W1C": rw.value[0] = this.mubi_and_hi(~rw.value[0], `gmv(this)); + "W0C": rw.value[0] = this.mubi_and_hi(rw.value[0], `gmv(this)); + default: ; // unreachable + endcase + end + end else if (kind == UVM_PREDICT_READ && mubi_access == "RC") begin + rw.value[0] = this.mubi_false(); + end + super.do_predict(rw, kind, be); + endfunction + + // when use UVM_PREDICT_WRITE and the CSR access is WO, this function will return the default + // val of the register, rather than the written value + virtual function uvm_reg_data_t XpredictX(uvm_reg_data_t cur_val, + uvm_reg_data_t wr_val, + uvm_reg_map map); + + if (get_access(map) == "WO") return get_reset(); + else return super.XpredictX(cur_val, wr_val, map); + endfunction + + virtual function string get_original_access(); + return m_original_access; + endfunction + + // Return a mask of valid bits in the field. + virtual function uvm_reg_data_t get_field_mask(); + get_field_mask = (1'b1 << this.get_n_bits()) - 1; + get_field_mask = get_field_mask << this.get_lsb_pos(); + endfunction + + // Return a mask of read-only bits in the field. + virtual function uvm_reg_data_t get_ro_mask(); + bit is_ro = (this.get_access() == "RO"); + get_ro_mask = (is_ro << this.get_n_bits()) - is_ro; + get_ro_mask = get_ro_mask << this.get_lsb_pos(); + endfunction + + // Lock the write access to this field. + // This only pertains to a lockable field. It is invoked in the `set_lockable_flds_access()` + // method of its corresponding lock (wen) field. + local function void set_fld_access(bit lock); + if (lock) void'(this.set_access("RO")); + else void'(this.set_access(m_original_access)); + endfunction + + // If input is a reg, add all fields under the reg; if input is a field, add the specific field. + function void add_lockable_reg_or_fld(uvm_object lockable_obj); + dv_base_reg_field flds[$]; + uvm_reg_block ral = this.get_parent().get_parent(); + `DV_CHECK_EQ_FATAL(ral.is_locked(), 0, "RAL is locked, cannot add lockable reg or fld!") + get_flds_from_uvm_object(lockable_obj, `gfn, flds); + foreach (flds[i]) begin + lockable_flds.push_back(flds[i]); + flds[i].regwen_fld = this; + end + endfunction + + function void create_lockable_fld_cov(); + lockable_field_cov = dv_base_lockable_field_cov::type_id::create(`gfn); + endfunction + + function void create_mubi_cov(int width); + mubi_cov = dv_base_mubi_cov::type_id::create(`gfn); + mubi_cov.create_cov(width); + endfunction + + function void create_shadowed_fld_cov(); + shadowed_cov = dv_base_shadowed_field_cov::type_id::create(`gfn); + endfunction + + function void create_cov(); + string csr_name = this.get_parent().get_name(); + if (mubi_width > 0) create_mubi_cov(mubi_width); + if (regwen_fld != null) create_lockable_fld_cov(); + if (!uvm_re_match("*_shadowed", csr_name)) create_shadowed_fld_cov(); + endfunction + + // Returns true if this field can lock the specified register/field, else return false. + // If lockable register is partially lockable (only certain field is lockable), this method will + // still return true. + function bit locks_reg_or_fld(uvm_object obj); + dv_base_reg_field flds[$]; + get_flds_from_uvm_object(obj, `gfn, flds); + foreach (flds[i]) begin + if (flds[i] inside {lockable_flds}) return 1; + end + return 0; + endfunction + + function bit is_wen_fld(); + return (lockable_flds.size() > 0); + endfunction + + // If lock is set to 1, lockable fields access policy will be set to RO access. + // If lock resets to 0, lockable fields will be set back to their original accesses. + function void set_lockable_flds_access(bit lock); + foreach (lockable_flds[i]) lockable_flds[i].set_fld_access(lock); + endfunction + + function void get_lockable_flds(ref dv_base_reg_field lockable_flds_q[$]); + lockable_flds_q = lockable_flds; + endfunction + + // Return if the RAL block is locked or not. + function bit is_locked(); + uvm_reg_block blk = this.get_parent().get_parent(); + return blk.is_locked(); + endfunction + + // If the register field is a mubi type, set the mubi width before the RAL is locked. + function void set_mubi_width(int width); + if (is_locked()) `uvm_fatal(`gfn, "Cannot set mubi width when the block is locked") + mubi_width = width; + endfunction + + function int get_mubi_width(); + return mubi_width; + endfunction + + // shadow register field read will clear its phase tracker + virtual task post_read(uvm_reg_item rw); + if (rw.status == UVM_IS_OK) begin + dv_base_reg parent_csr = get_dv_base_reg_parent(); + parent_csr.clear_shadow_wr_staged(); + + if (lockable_field_cov != null) lockable_field_cov.post_read(); + end + endtask + + virtual task post_write(uvm_reg_item rw); + if (rw.status == UVM_IS_OK) begin + uvm_reg_data_t field_val = rw.value[0] & ((1 << get_n_bits()) - 1); + + if (lockable_field_cov != null) lockable_field_cov.post_write(field_val, `gmv(regwen_fld)); + + if (mubi_cov != null) mubi_cov.sample(field_val); + end + endtask + + function bit get_shadow_storage_err(); + uvm_reg_data_t mask = (1 << get_n_bits()) - 1; + uvm_reg_data_t shadowed_val_temp = (~shadowed_val) & mask; + uvm_reg_data_t committed_val_temp = committed_val & mask; + `uvm_info(`gfn, $sformatf("shadow_val %0h, commmit_val %0h", shadowed_val_temp, + committed_val_temp), UVM_HIGH) + sample_shadow_field_cov(.storage_err(1)); + return shadowed_val_temp != committed_val_temp; + endfunction + + function void sample_shadow_field_cov(bit update_err = 0, bit storage_err = 0); + if (shadowed_cov != null) shadowed_cov.shadow_field_errs_cg.sample(update_err, storage_err); + endfunction + + function void update_staged_val(uvm_reg_data_t val); + staged_val = val; + endfunction + + function uvm_reg_data_t get_staged_val(); + return staged_val; + endfunction + + function void update_shadowed_val(uvm_reg_data_t val); + shadowed_val = val; + endfunction + + function void update_committed_val(uvm_reg_data_t val); + committed_val = val; + endfunction + + function uvm_reg_data_t get_committed_val(); + return committed_val; + endfunction + + // override RAL's reset function to support enable registers + // when reset issued - the lockable field's access will be reset to original access + virtual function void reset(string kind = "HARD"); + super.reset(kind); + set_fld_access(0); + committed_val = get_mirrored_value(); + shadowed_val = ~committed_val; + if (lockable_field_cov != null) lockable_field_cov.reset(get_reset()); + endfunction + + // this function can only be called when this reg is intr_test reg + // Example: ral.intr_test.get_intr_state_field() + local function uvm_reg_field get_intr_state_field(); + uvm_reg_block blk = get_parent().get_parent(); + uvm_reg intr_state_csr; + uvm_reg_field fields[$]; + string intr_state_csr_name; + string intr_test_csr_name = get_parent().get_name(); + bit is_intr_state_csr = !(uvm_re_match("intr_test*", intr_test_csr_name)); + + `DV_CHECK_EQ_FATAL(is_intr_state_csr, 1) + + // intr_enable and intr_state have the same suffix + intr_state_csr_name = str_utils_pkg::str_replace(intr_test_csr_name, "test", "state"); + + intr_state_csr = blk.get_reg_by_name(intr_state_csr_name); + intr_state_csr.get_fields(fields); + + // the field location for intr_state and intr_test should be the same + return fields[get_lsb_pos()]; + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_map.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_map.sv new file mode 100644 index 0000000..ee748f5 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_map.sv @@ -0,0 +1,9 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// base register reg class which will be used to generate the reg map +class dv_base_reg_map extends uvm_reg_map; + `uvm_object_utils(dv_base_reg_map) + `uvm_object_new +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_pkg.sv new file mode 100644 index 0000000..e64f2de --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_reg_pkg.sv @@ -0,0 +1,145 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package dv_base_reg_pkg; + // dep packages + import uvm_pkg::*; + import dv_utils_pkg::*; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + // global paramters for number of csr tests (including memory test) + parameter uint NUM_CSR_TESTS = 4; + + // csr field struct - hold field specific params + typedef struct { + uvm_reg csr; + uvm_reg_field field; + uvm_reg_data_t mask; + uint shift; + } csr_field_t; + + // csr exclusion indications + typedef enum bit [2:0] { + CsrNoExcl = 3'b000, // no exclusions + CsrExclInitCheck = 3'b001, // exclude csr from init val check + CsrExclWriteCheck = 3'b010, // exclude csr from write-read check + CsrExclCheck = 3'b011, // exclude csr from init or write-read check + CsrExclWrite = 3'b100, // exclude csr from write + CsrExclAll = 3'b111 // exclude csr from init or write or write-read check + } csr_excl_type_e; + + // csr test types + typedef enum bit [NUM_CSR_TESTS-1:0] { + CsrInvalidTest = 4'h0, + // elementary test types + CsrHwResetTest = 4'h1, + CsrRwTest = 4'h2, + CsrBitBashTest = 4'h4, + CsrAliasingTest = 4'h8, + // combinational test types (combinations of the above), used for exclusion tagging + CsrNonInitTests = 4'he, // all but HwReset test + CsrAllTests = 4'hf // all tests + } csr_test_type_e; + + typedef enum bit[2:0] { + // If it's a shadow reg, BkdrRegPathRtl is the path to committed reg + BkdrRegPathRtl, // backdoor path for reg's val in RTL + BkdrRegPathRtlShadow, // backdoor path for shadow reg's shadow val in RTL + BkdrRegPathGls, // backdoor path for reg's val in GLS + BkdrRegPathGlsShdow // backdoor path for shadow reg's shadow val in GLS + } bkdr_reg_path_e; + + // Forward-declare class types for the functions below. + typedef class dv_base_reg_block; + typedef class dv_base_reg; + typedef class dv_base_reg_field; + + // This function attempts to cast a given uvm_object ptr into uvm_reg or uvm_reg_field. If cast + // is successful on either, then set the appropriate csr_field_t return values. + function automatic csr_field_t decode_csr_or_field(input uvm_object ptr); + uvm_reg csr; + uvm_reg_field fld; + csr_field_t result; + + if ($cast(csr, ptr)) begin + // return csr object with null field; set the mask to the width's all 1s and shift to 0 + result.csr = csr; + result.mask = (1 << csr.get_n_bits()) - 1; + result.shift = 0; + end + else if ($cast(fld, ptr)) begin + // return csr field object; return the appropriate mask and shift values + result.csr = fld.get_parent(); + result.field = fld; + result.mask = (1 << fld.get_n_bits()) - 1; + result.shift = fld.get_lsb_pos(); + end + else begin + `uvm_fatal($sformatf("%m"), $sformatf("ptr %0s is not of type uvm_reg or uvm_reg_field", + ptr.get_full_name())) + end + return result; + endfunction : decode_csr_or_field + + function automatic void get_flds_from_uvm_object(input uvm_object obj, + input string msg = "dv_base_reg_pkg", + ref dv_base_reg_field flds[$]); + dv_base_reg csr; + dv_base_reg_field fld; + + flds.delete(); + if ($cast(csr, obj)) begin + csr.get_dv_base_reg_fields(flds); + end else if ($cast(fld, obj)) begin + flds.push_back(fld); + end else begin + `uvm_fatal($sformatf("%m"), $sformatf("obj %0s is not of type uvm_reg or uvm_reg_field", + obj.get_full_name())) + end + endfunction : get_flds_from_uvm_object + + // mask and shift data to extract the value specific to that supplied field + function automatic uvm_reg_data_t get_field_val(uvm_reg_field field, + uvm_reg_data_t value); + uvm_reg_data_t mask = (1 << field.get_n_bits()) - 1; + uint shift = field.get_lsb_pos(); + get_field_val = (value >> shift) & mask; + endfunction : get_field_val + + // Returns a mask value from the provided fields. All fields must belong to the same CSR. + function automatic uvm_reg_data_t get_mask_from_fields(uvm_reg_field fields[$]); + uvm_reg_data_t mask = '0; + uvm_reg csr; + if (fields.size() == 0) return '1; + foreach (fields[i]) begin + uvm_reg_data_t fmask; + uint fshift; + if (csr == null) csr = fields[i].get_parent(); + else if (csr != fields[i].get_parent()) begin + `uvm_fatal($sformatf("%m") , $sformatf({"The provided fields belong to at least two" + ," different CSRs: ", + "%s, %s. All fields must belong to the same CSR"}, + fields[i-1].`gfn, fields[i].`gfn)) + end + fmask = (1 << fields[i].get_n_bits()) - 1; + fshift = fields[i].get_lsb_pos(); + mask |= fmask << fshift; + end + return mask; + endfunction + + `include "csr_excl_item.sv" + `include "dv_base_lockable_field_cov.sv" + `include "dv_base_shadowed_field_cov.sv" + `include "dv_base_mubi_cov.sv" + `include "dv_base_reg_field.sv" + `include "dv_base_reg.sv" + `include "dv_base_mem.sv" + `include "dv_base_reg_block.sv" + `include "dv_base_reg_map.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_shadowed_field_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_shadowed_field_cov.sv new file mode 100644 index 0000000..bae4a6a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_base_reg/dv_base_shadowed_field_cov.sv @@ -0,0 +1,29 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// coverage object of shadowed errors - update and storage errors. + +class dv_base_shadowed_field_cov extends uvm_object; + `uvm_object_utils(dv_base_shadowed_field_cov) + + covergroup shadow_field_errs_cg(string name) with function sample(bit update_err = 0, + bit storage_err = 0); + option.per_instance = 1; + option.name = name; + + cp_update_err: coverpoint update_err { + bins update_err = {1}; + } + + cp_storage_err: coverpoint storage_err { + bins storage_err = {1}; + } + endgroup + + // use reg_field name as this name + function new(string name = ""); + shadow_field_errs_cg = new($sformatf("%0s_shadowed_errs_cov", name)); + endfunction : new + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/README.md b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/README.md new file mode 100644 index 0000000..b2836f2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/README.md @@ -0,0 +1,52 @@ +# DV Library Classes + +# DV library classes + +## Overview +The DV library classes form the base layer / framework for constructing UVM +testbenches. These classes provide features (settings, methods, hooks and other +constructs used in verification) that are generic enough to be reused across +all testbenches. + +In this doc, we will capture some of the most salient / frequently used features +in extended classes. These classes are being updated frequently. So, for a more +detailed understanding, please read the class definitions directly. + +The DV library classes fall into 3 categories - UVM RAL (register abstraction +layer), UVM agent, and UVM environment extensions. + +### UVM RAL extensions +The RAL model generated using the [reggen](../../../../util/reggen/doc/setup_and_use.md) tool +extend from these classes. These themselves extend from the corresponding RAL +classes provided in UVM. + +#### `dv_base_reg_field` +Currently, this class does not provide any additional features. One of the +features planned for future is setting exclusion tags at the field level for the +CSR suite of tests that will be extracted automatically from the Hjson-based +IP CSR specification. + +#### `dv_base_reg` +This class provides the following functions to support verification: +* `gen_n_used_bits()`: This function returns the actual number of bits used in + the CSR (sum of all available field widths). +* `get_msb_pos()`: This function returns the MSB bit position of all available fields. + The CSR either ends at this bit or has reserved / invalid bits beyond this bit. + +#### `dv_base_reg_block` +* ` build(uvm_reg_addr_t base_addr)`: This function is implemented as a pseudo + pure virtual function (returns a fatal error if called directly). It is used + for building the complete RAL model. For a polymorphic approach, the DV user + can use this class handle to create the extended (IP specific) class instance + and call this function to build the actual RAL model. This is exactly how it + is done in [dv_base_env_cfg](#dv_base_env_cfg). + +#### `dv_base_reg_map` +Currently, this class does not provide any additional features. Having this +extension provides an opportunity to add common features in future. + +### UVM Agent extensions +TODO + +### UVM Environment extensions +TODO diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/bit_toggle_cg_wrap.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/bit_toggle_cg_wrap.sv new file mode 100644 index 0000000..d27bf01 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/bit_toggle_cg_wrap.sv @@ -0,0 +1,42 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A class wrapping a covergroup that tracks a single bit signal (and covers transitions with it +// toggling). +// +// Using a class like this allows the covergroup to be instantiated in multiple places (and in +// arrays). + +class bit_toggle_cg_wrap; + + // A covergroup that tracks the value of some single-bit value (with associated coverpoint + // cp_value). Tracking it explicitly with functional coverage allows transition bins (defined in + // cp_transitions). + // + // If toggle_cov_en is true, the transitions in cp_transitions have nonzero weight. + covergroup bit_toggle_cg(string name, bit toggle_cov_en = 1) + with function sample(bit value); + + option.per_instance = 1; + option.name = name; + + cp_value: coverpoint value; + cp_transitions: coverpoint value { + option.weight = toggle_cov_en; + bins rising = (0 => 1); + bins falling = (1 => 0); + } + endgroup : bit_toggle_cg + + function new(string name, bit toggle_cov_en = 1); + bit_toggle_cg = new(name, toggle_cov_en); + endfunction : new + + // A wrapper around bit_toggle_cg.sample, allowing code using this class to call + // the_class_instance.sample() in the same way as it would have sampled the underlying covergroup. + function void sample(bit value); + bit_toggle_cg.sample(value); + endfunction : sample + +endclass : bit_toggle_cg_wrap diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env.sv new file mode 100644 index 0000000..97716af --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env.sv @@ -0,0 +1,94 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_env #(type CFG_T = dv_base_env_cfg, + type VIRTUAL_SEQUENCER_T = dv_base_virtual_sequencer, + type SCOREBOARD_T = dv_base_scoreboard, + type COV_T = dv_base_env_cov) extends uvm_env; + `uvm_component_param_utils(dv_base_env #(CFG_T, VIRTUAL_SEQUENCER_T, SCOREBOARD_T, COV_T)) + + CFG_T cfg; + VIRTUAL_SEQUENCER_T virtual_sequencer; + SCOREBOARD_T scoreboard; + COV_T cov; + + `uvm_component_new + + virtual function void build_phase(uvm_phase phase); + string ral_models[$]; + + super.build_phase(phase); + + // Get an env_cfg. This may have actually already been supplied before this environment's + // build_phase. That might be done by the test or by higher-level environment (if this + // environment represents a block that is being used in a larger subsystem- or chip-level + // environment). If the cfg has not been supplied, look it up uvm_config_db. + if (cfg == null) begin + if (!uvm_config_db#(CFG_T)::get(this, "", "cfg", cfg)) begin + `uvm_fatal(`gfn, $sformatf("failed to get %s from uvm_config_db", cfg.get_type_name())) + end + end + + // Make sure the map in cfg from RAL name to clk_rst_if is populated. Copy the clock frequencies + // chosen by cfg to the interfaces. + ral_models = cfg.get_ral_model_names(); + if (ral_models.size() > 0) begin + string default_ral_name = cfg.ral.get_type_name(); + foreach (ral_models[i]) begin + string ral_name = ral_models[i]; + configure_clk_rst_vif(ral_name, (ral_name == default_ral_name)); + end + + // assign default clk_rst_vif + `DV_CHECK_FATAL(cfg.clk_rst_vifs.exists(default_ral_name)) + cfg.clk_rst_vif = cfg.clk_rst_vifs[default_ral_name]; + end else begin + // no RAL model, get the default clk_rst_vif for the block + // such as xbar, it doesn't has ral model, but it also needs a default clk_rst_vif + if (cfg.clk_rst_vif == null && + !uvm_config_db#(virtual clk_rst_if)::get(this, "", "clk_rst_vif", cfg.clk_rst_vif)) begin + `uvm_fatal(get_full_name(), "Failed to get clk_rst_if from uvm_config_db") + end + cfg.clk_rst_vif.set_freq_mhz(cfg.clk_freq_mhz); + end + + // create components + if (cfg.en_cov) begin + cov = COV_T::type_id::create("cov", this); + cov.cfg = cfg; + end + + if (cfg.is_active) begin + virtual_sequencer = VIRTUAL_SEQUENCER_T::type_id::create("virtual_sequencer", this); + virtual_sequencer.cfg = cfg; + virtual_sequencer.cov = cov; + end + + // scb also monitors the reset and call cfg.reset_asserted/reset_deasserted for reset + scoreboard = SCOREBOARD_T::type_id::create("scoreboard", this); + scoreboard.cfg = cfg; + scoreboard.cov = cov; + endfunction + + // If cfg doesn't already have the vif, look up a clk_rst_if for ral_name in uvm_config_db. Either + // way, copy the selected clock frequency to the interface. + // + // This should be called after the frequency has been selected for ral_name (which happens as part + // of randomisation after setup with initialize()) + local function void configure_clk_rst_vif(string ral_name, bit is_default_ral_name); + string if_name = is_default_ral_name ? "clk_rst_vif" : {"clk_rst_vif_", ral_name}; + + // If cfg doesn't already have the interface look one up in the config_db + if (!cfg.clk_rst_vifs.exists(ral_name) && + !uvm_config_db#(virtual clk_rst_if)::get(this, "", + if_name, cfg.clk_rst_vifs[ral_name])) begin + `uvm_fatal(get_full_name(), + $sformatf("No clk_rst_if for %0s (which would be called %0s) in uvm_config_db", + ral_name, if_name)) + end + + cfg.clk_rst_vifs[ral_name].set_freq_mhz(cfg.clk_freqs_mhz[ral_name]); + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env_cfg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env_cfg.sv new file mode 100644 index 0000000..d28606c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env_cfg.sv @@ -0,0 +1,347 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A base environment configuration that is used for all OpenTitan environments. + +class dv_base_env_cfg #(type RAL_T = dv_base_reg_block) extends uvm_object; + + // True if the environment is active (and thus drives sequences items to the dut). This is the + // default. + bit is_active = 1; + + // True if the scoreboard should be enabled. If it is false, the scoreboard still runs, but should + // ignore its checks. + bit en_scb = 1; + + // True if the scoreboard should check memory read transactions and predict memory updates from + // write transactions. + bit en_scb_mem_chk = 1; + + // Enable functional coverage collection. This causes monitors and scoreboards to collect coverage + // (through a dv_base_env_cov object). + bit en_cov = 0; + + // Enable CDC instrumentation + bit en_dv_cdc = 0; + + // A bit that is true if the environment is currently under reset. This should controlled by + // calling the reset_asserted and reset_deasserted functions. By default, + // dv_base_scoreboard::monitor_reset maintains this value. + bit under_reset = 0; + + // A flag to show that the initialize_ral method has been called. This is protected (rather than + // local) to allow specialised environments to set it to avoid the initialize_ral method being + // called. + protected bit is_initialized = 0; + + // The scope and runtime of a existing test can be reduced by setting this variable. This is + // useful to keep the runtime down especially in time-sensitive runs such as CI, which is meant + // to check the code health and not find design bugs. It is set via plusarg and retrieved in + // `dv_base_test`. + bit smoke_test = 0; + + // If this is true, all UVCs should run with zero delays, which creates a high bandwidth test. + rand bit zero_delays; + + // The type_name of the base RAL type (RAL_T). This is exposed explicitly, rather than being + // accessed through RAL_T::type_name, because this allows subclasses of dv_base_env_cfg to + // override the base RAL type without messing up the parameterized class type. + // + // This string will be added to ral_model_names at the start of the initialize function (which is + // after a derived class can have overridden it). + protected string ral_type_name = RAL_T::type_name; + + // The set of the names of RAL models that should exist by the end of `initialize_ral`. + // Related agents and adapters will be created in the environment as well as connecting them with + // the scoreboard. + // + // The set is implemented as an associative array whose keys are elements of the set (and whose + // values contain no information). + // + // The model names (keys of ral_model_names) are used as indices into associative arrays for + // ral_models, clk_rst_vifs and clk_freqs_mhz. + // + // To add another RAL model, a subclass of dv_base_env_cfg must make sure that the model's name is + // added to this set before running dv_base_env_cfg::initialize_ral. One way to do this is to + // implement the function itself and update the set before calling super.initialize_ral(). + protected bit ral_model_names[string]; + + typedef string string_queue_t[$]; + + function string_queue_t get_ral_model_names(); + string_queue_t ret; + foreach (ral_model_names[name]) ret.push_back(name); + return ret; + endfunction + + // A RAL model for each name in ral_model_names. + dv_base_reg_block ral_models[string]; + + // A clock and reset interface for each name in ral_model_names. An item is the clock and reset + // that should be used for the associated TL interface. + virtual clk_rst_if clk_rst_vifs[string]; + + // Clock frequencies for the TL interfaces indexed by the keys of ral_model_names. + rand uint clk_freqs_mhz[string]; + + // The "default" RAL's register model. This corresponds to RAL_T::type_name as a model name, and + // the variable is of type RAL_T (a more specialised class) to simplify access. + RAL_T ral; + + // The interface for the clock and reset assoicated with the default RAL. + virtual clk_rst_if clk_rst_vif; + + // The frequency of the clock and reset assoicated with the default RAL. + rand uint clk_freq_mhz; + + // Set zero_delays 40% of the time + extern constraint zero_delays_c; + + // Constrain frequencies of the various clocks. + extern constraint clk_freq_mhz_c; + + `uvm_object_param_utils_begin(dv_base_env_cfg #(RAL_T)) + `uvm_field_int (is_active, UVM_DEFAULT) + `uvm_field_int (en_scb, UVM_DEFAULT) + `uvm_field_int (en_scb_mem_chk, UVM_DEFAULT) + `uvm_field_int (en_cov, UVM_DEFAULT) + `uvm_field_int (en_dv_cdc, UVM_DEFAULT) + `uvm_field_int (smoke_test, UVM_DEFAULT) + `uvm_field_int (zero_delays, UVM_DEFAULT) + `uvm_field_aa_int_string (ral_model_names, UVM_DEFAULT) + `uvm_field_aa_object_string (ral_models, UVM_DEFAULT) + `uvm_field_aa_int_string (clk_freqs_mhz, UVM_DEFAULT) + `uvm_object_utils_end + + extern function new (string name=""); + + extern function void pre_randomize(); + extern function void post_randomize(); + + // Configure whether this env_cfg is active + // + // Use this, rather than directly setting is_active, in order that any agents' configurations are + // also updated. + extern virtual function void set_is_active(bit active); + + // Initialise the object with RAL models and set it up for randomisation + // + // The addr_width, data_width and be_width arguments are used to configure the analogous fields of + // the dv_base_reg_block instances that are created. + // + // If inherit_ral_models is true, the object is already expected to have the RAL models (possibly + // from a higher level of the testbench). If so, csr_base_addr should be ignored, but the other + // initialisation for the object is still done. + // + // This function is virtual, allowing subclasses to set up list_of_alerts and num_interrupts. + extern virtual function void initialize_ral(int unsigned addr_width, + int unsigned data_width, + int unsigned be_width, + bit inherit_ral_models); + + // Set pre-build RAL knobs. + // + // This method enables setting pre-build config knobs that can be used to control how the RAL + // sub-structures are created. + extern protected virtual function void pre_build_ral_settings(dv_base_reg_block ral); + + // Perform post-build, pre-lock modifications to the RAL. + // + // For some registers / fields, the correct access policies or reset values may not be set. Fixes + // like those can be made with this method. + extern protected virtual function void post_build_ral_settings(dv_base_reg_block ral); + + // Update the under_reset flag to match the fact that reset has been asserted. This is currently + // driven by dv_base_scoreboard::monitor_reset. + extern virtual function void reset_asserted(); + + // Update the under_reset flag to match the fact that reset is no longer asserted. This is + // currently driven by dv_base_scoreboard::monitor_reset. + extern virtual function void reset_deasserted(); + + // Create missing RAL models and set their base addresses based on the supplied arg. + // + // The addr_width, data_width and be_width arguments are used to configure the analogous fields of + // the dv_base_reg_block instances that are created. + extern local function void make_ral_models(int unsigned addr_width, + int unsigned data_width, + int unsigned be_width); + + // Create the named RAL model and give it a randomised base address. + // + // The addr_width, data_width and be_width arguments are used to configure the analogous fields of + // the dv_base_reg_block that is created. + extern local function void make_ral_model(string ral_model_name, + int unsigned addr_width, + int unsigned data_width, + int unsigned be_width); + + // Create the named register block. This protected function is virtual to allow subclasses to + // customise how the register block is created. + extern protected virtual function dv_base_reg_block create_ral_by_name(string name); +endclass + +constraint dv_base_env_cfg::zero_delays_c { + zero_delays dist {1'b0 := 6, 1'b1 := 4}; +} + +constraint dv_base_env_cfg::clk_freq_mhz_c { + `DV_COMMON_CLK_CONSTRAINT(clk_freq_mhz) + foreach (clk_freqs_mhz[i]) { + `DV_COMMON_CLK_CONSTRAINT(clk_freqs_mhz[i]) + } +} + +function dv_base_env_cfg::new (string name=""); + super.new(name); +endfunction + +function void dv_base_env_cfg::pre_randomize(); + if (!is_initialized) `uvm_fatal(`gfn, "Run initialize_ral() before randomizing this object.") +endfunction + +function void dv_base_env_cfg::post_randomize(); + if (clk_freqs_mhz.size > 0) begin + `DV_CHECK_FATAL(clk_freqs_mhz.exists(ral_type_name)) + clk_freqs_mhz[ral_type_name] = clk_freq_mhz; + end +endfunction + +function void dv_base_env_cfg::set_is_active(bit active); + is_active = active; +endfunction + +function void dv_base_env_cfg::initialize_ral(int unsigned addr_width, + int unsigned data_width, + int unsigned be_width, + bit inherit_ral_models); + if (is_initialized) `uvm_fatal(`gfn, "Cannot call initialize_ral when already initialized") + + // Add ral_type_name to ral_model_names (we just need the key in the array; the value has no + // meaning) + ral_model_names[ral_type_name] = 1'b0; + + is_initialized = 1'b1; + + if (inherit_ral_models) begin + // If inherit_ral_models is true then there should already be a RAL model associated with each + // name (including ral_type_name). Check that there is. + foreach (ral_model_names[ral_name]) begin + if (!ral_models.exists(ral_name)) begin + `uvm_fatal(get_name(), + $sformatf("inherit_ral_models is true but there is no RAL model at %0s.", + ral_name)) + end + end + end else begin + // As inherit_ral_models is false, we need to build them here. + make_ral_models(addr_width, data_width, be_width); + end + + // At this point, each RAL model will exist in the ral_models associative array. As a convenience, + // set the "ral" class variable to the ral model defined for this type. This should have been + // created with some subtype of RAL_T. + if (!$cast(ral, ral_models[ral_type_name])) begin + `uvm_fatal(get_name(), + $sformatf("The register model stored under %0s cannot be cast to type RAL_T.", + ral_type_name)) + end + + // add items to clk_freqs_mhz before randomizing it + foreach (ral_model_names[name]) begin + clk_freqs_mhz[name] = 0; + end +endfunction + +function void dv_base_env_cfg::pre_build_ral_settings(dv_base_reg_block ral); + // This is an empty function that a subclass can override +endfunction + +function void dv_base_env_cfg::post_build_ral_settings(dv_base_reg_block ral); + // This is an empty function that a subclass can override +endfunction + +function void dv_base_env_cfg::reset_asserted(); + this.under_reset = 1; + csr_utils_pkg::reset_asserted(); +endfunction + +function void dv_base_env_cfg::reset_deasserted(); + this.under_reset = 0; + csr_utils_pkg::reset_deasserted(); +endfunction + +function void dv_base_env_cfg::make_ral_models(int unsigned addr_width, + int unsigned data_width, + int unsigned be_width); + foreach (ral_model_names[name]) begin + make_ral_model(name, addr_width, data_width, be_width); + end + + if (!ral_models.exists(ral_type_name)) begin + `uvm_fatal(get_name(), + $sformatf("The generated RAL models don't include ral_type_name=%0s.", + ral_type_name)) + end +endfunction + +function void dv_base_env_cfg::make_ral_model(string ral_model_name, + int unsigned addr_width, + int unsigned data_width, + int unsigned be_width); + dv_base_reg_block reg_blk; + + if (ral_models.exists(ral_model_name)) begin + // If there is already a model for this name, there's nothing to do (probably because the + // env_cfg has already been initialised) + return; + end + + // If a model for this name doesn't already exist, we should make one. + reg_blk = create_ral_by_name(ral_model_name); + + // Build the register block with an arbitrary base address. We'll randomize it once we've locked + // the model (and thus know the alignment requirements). + pre_build_ral_settings(reg_blk); + reg_blk.build(.base_addr(0), + .csr_excl(null), + .addr_width(addr_width), + .data_width(data_width), + .be_width(be_width)); + post_build_ral_settings(reg_blk); + + // Lock the model. One side effect is that this will compute an initial address map (with offset + // zero). + reg_blk.lock_model(); + + // Now pick a randomized base address. This has alignment requirements. Round up the largest + // address in the initial address map to the next power of two: the base address must be divisible + // by that power of two, ensuring that addresses within the block have predictable low bits. + reg_blk.set_randomized_base_addr(); + + if (reg_blk.get_name() == ral_type_name) `downcast(ral, reg_blk) + + ral_models[ral_model_name] = reg_blk; +endfunction + +function dv_base_reg_block dv_base_env_cfg::create_ral_by_name(string name); + uvm_object obj; + uvm_factory factory; + dv_base_reg_block ral; + + factory = uvm_factory::get(); + obj = factory.create_object_by_name(.requested_type_name(name), .name(name)); + if (obj == null) begin + // print factory overrides to help debug + factory.print(); + `uvm_fatal(`gfn, + $sformatf({"Could not create %0s as a RAL model. ", + "See above for a list of type/instance overrides"}, + name)) + end + if (!$cast(ral, obj)) begin + `uvm_fatal(`gfn, $sformatf("Cast failed - %0s is not a dv_base_reg_block", name)) + end + return ral; +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env_cov.sv new file mode 100644 index 0000000..5e9bb28 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_env_cov.sv @@ -0,0 +1,16 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A base class for coverage collection. This base class only really contains the CFG_T handle, that +// points to the config for the environment in use. + +class dv_base_env_cov #(type CFG_T = dv_base_env_cfg) extends uvm_component; + `uvm_component_param_utils(dv_base_env_cov #(CFG_T)) + + CFG_T cfg; + + function new(string name, uvm_component parent); + super.new(name, parent); + endfunction +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_scoreboard.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_scoreboard.sv new file mode 100644 index 0000000..a9a5b6c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_scoreboard.sv @@ -0,0 +1,81 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_scoreboard #(type RAL_T = dv_base_reg_block, + type CFG_T = dv_base_env_cfg, + type COV_T = dv_base_env_cov) extends uvm_component; + `uvm_component_param_utils(dv_base_scoreboard #(RAL_T, CFG_T, COV_T)) + + CFG_T cfg; + RAL_T ral; + COV_T cov; + + bit obj_raised = 1'b0; + bit under_pre_abort = 1'b0; + + `uvm_component_new + + virtual function void build_phase(uvm_phase phase); + super.build_phase(phase); + ral = cfg.ral; + endfunction + + virtual task run_phase(uvm_phase phase); + super.run_phase(phase); + fork + monitor_reset(); + sample_resets(); + join_none + endtask + + virtual task monitor_reset(); + forever begin + if (!cfg.clk_rst_vif.rst_n) begin + `uvm_info(`gfn, "reset occurred", UVM_HIGH) + cfg.reset_asserted(); + @(posedge cfg.clk_rst_vif.rst_n); + reset(); + cfg.reset_deasserted(); + csr_utils_pkg::clear_outstanding_access(); + `uvm_info(`gfn, "out of reset", UVM_HIGH) + end + else begin + // wait for a change to rst_n + @(cfg.clk_rst_vif.rst_n); + end + end + endtask + + virtual task sample_resets(); + // Do nothing, actual coverage collection is under extended classes. + endtask + + virtual function void reset(string kind = "HARD"); + // reset the ral model + foreach (cfg.ral_models[i]) cfg.ral_models[i].reset(kind); + endfunction + + virtual function void pre_abort(); + super.pre_abort(); + + // In UVM, a fatal error normally aborts the test completely and skips the check phase. However, + // it's sometimes helpful to run that phase on the scoreboard anyway (it might make it easier to + // debug whatever went wrong), so we do that here. + // + // We only run the check phase if we were in the run phase: if something went wrong in the build + // or connect phase, there's not much point in "checking the run" further. We also have to be + // careful to avoid an infinite loop, so we set a flag to avoid doing this a second time if we + // have errors in the check phase. + if (has_uvm_fatal_occurred() && + !under_pre_abort && + m_current_phase != null && + m_current_phase.is(uvm_run_phase::get())) begin + + under_pre_abort = 1; + check_phase(m_current_phase); + under_pre_abort = 0; + end + endfunction : pre_abort + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_test.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_test.sv new file mode 100644 index 0000000..953a1ea --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_test.sv @@ -0,0 +1,163 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_test #(type CFG_T = dv_base_env_cfg, + type ENV_T = dv_base_env) extends uvm_test; + `uvm_component_param_utils(dv_base_test #(CFG_T, ENV_T)) + + ENV_T env; + CFG_T cfg; + bit run_test_seq = 1'b1; + string test_seq_s; + + uint max_quit_count = 1; + uint64 test_timeout_ns = 200_000_000; // 200ms + uint drain_time_ns = 2_000; // 2us + bit poll_for_stop = 1'b0; + uint poll_for_stop_interval_ns = 1000; + bit print_topology = 1'b0; + + `uvm_component_new + + virtual function void build_phase(uvm_phase phase); + uvm_object_wrapper cfg_type; + uvm_object base_cfg; + + dv_report_server m_dv_report_server = new(); + dv_report_catcher m_report_catcher; + uvm_report_server::set_server(m_dv_report_server); + + // Message catcher/demoter + `uvm_create_obj(dv_report_catcher, m_report_catcher) + // Add demoted messages - we need to do this here to catch build warnings + add_message_demotes(m_report_catcher); + // Register catcher + uvm_report_cb::add(null, m_report_catcher); + + super.build_phase(phase); + + env = ENV_T::type_id::create("env", this); + + // Check whether there is a type for the environment config that has been registered in + // config_db. Doing so is a way that a (templated) test can pass a specific type, allowing the + // test class not to depend on that type. + // + // If the class hasn't chosen to do so, we can just use the type for CFG_T (part of the type of + // this test) + if (!uvm_config_db#(uvm_object_wrapper)::get(this, "env", "cfg_type", cfg_type)) begin + cfg_type = CFG_T::get_type(); + end + + // Now we know the config type, see whether one has been created by the testbench, configured + // and supplied through uvm_config_db. + // + // Note that we do the lookup through CFG_T rather than cfg_type, because the latter is only + // known at runtime. If there isn't a cfg object that has been provided, we create one ourselves + // and call its initialize() method. + if (!uvm_config_db#(CFG_T)::get(this, "env", "cfg", cfg)) begin + base_cfg = cfg_type.create_object("cfg"); + if (!base_cfg) begin + `uvm_fatal(`gfn, $sformatf("Failed to create object of type %p", cfg_type)) + end + + // At this point, we will normally have just created an object of type CFG_T, but have a + // handle to it with a weaker type. But we might have got an instance of some extension class + // if one is passed as cfg_type. Either way, we should be able to cast the result to a CFG_T. + if (!$cast(cfg, base_cfg)) begin + `uvm_fatal(`gfn, + $sformatf("Failed to cast object of type %p to expected CFG_T class.", cfg_type)) + end + + initialize_env_cfg(); + end + + `DV_CHECK_RANDOMIZE_FATAL(cfg) + uvm_config_db#(CFG_T)::set(this, "env", "cfg", cfg); + + // Enable scoreboard (and sub-scoreboard checks) via plusarg. + void'($value$plusargs("en_scb=%0b", cfg.en_scb)); + void'($value$plusargs("en_scb_mem_chk=%0b", cfg.en_scb_mem_chk)); + // Enable fastest design performance by configuring zero delays in all agents. + void'($value$plusargs("zero_delays=%0b", cfg.zero_delays)); + + // Enable coverage collection. + void'($value$plusargs("en_cov=%0b", cfg.en_cov)); + + // Enable reduced runtime test. + void'($value$plusargs("smoke_test=%0b", cfg.smoke_test)); + + // Enable print_topology + void'($value$plusargs("print_topology=%0b", print_topology)); + uvm_top.enable_print_topology = print_topology; + + void'($value$plusargs("cdc_instrumentation_enabled=%d", cfg.en_dv_cdc)); + + // Register cfg in the config db. This might already have been registered, but that shouldn't + // matter. + uvm_config_db#(CFG_T)::set(this, "*", "cfg", cfg); + + endfunction : build_phase + + // Initialize an env_cfg that has been created in build_phase + // + // This virtual function allows classes that extend dv_base_test to configure the env_cfg before + // or after calling dv_base_test::initialize_env_cfg (which calls initialize on the cfg object). + // + // The function is not called for cfg objects that are supplied through uvm_config_db (since they + // are assumed to have been initialized in the testbench already). + virtual function void initialize_env_cfg(); + cfg.initialize(); + endfunction + + virtual function void end_of_elaboration_phase(uvm_phase phase); + super.end_of_elaboration_phase(phase); + void'($value$plusargs("max_quit_count=%0d", max_quit_count)); + set_max_quit_count(max_quit_count); + void'($value$plusargs("test_timeout_ns=%0d", test_timeout_ns)); + uvm_top.set_timeout((test_timeout_ns * 1ns)); + endfunction : end_of_elaboration_phase + + virtual task run_phase(uvm_phase phase); + super.run_phase(phase); + void'($value$plusargs("drain_time_ns=%0d", drain_time_ns)); + phase.phase_done.set_drain_time(this, (drain_time_ns * 1ns)); + void'($value$plusargs("poll_for_stop=%0b", poll_for_stop)); + void'($value$plusargs("poll_for_stop_interval_ns=%0d", poll_for_stop_interval_ns)); + if (poll_for_stop) dv_utils_pkg::poll_for_stop(.interval_ns(poll_for_stop_interval_ns)); + void'($value$plusargs("UVM_TEST_SEQ=%0s", test_seq_s)); + if (run_test_seq) begin + run_seq(test_seq_s, phase); + end + endtask : run_phase + + // Add message demotes here - hook to use by extended tests + virtual function void add_message_demotes(dv_report_catcher catcher); + endfunction + + virtual task run_seq(string test_seq_s, uvm_phase phase); + uvm_sequence test_seq = create_seq_by_name(test_seq_s); + + configure_sequence(test_seq); + + `DV_CHECK_RANDOMIZE_FATAL(test_seq) + + `uvm_info(`gfn, {"Starting test sequence ", test_seq_s}, UVM_MEDIUM) + phase.raise_objection(this, $sformatf("%s objection raised", `gn)); + test_seq.start(env.virtual_sequencer); + phase.drop_objection(this, $sformatf("%s objection dropped", `gn)); + `uvm_info(`gfn, {"Finished test sequence ", test_seq_s}, UVM_MEDIUM) + endtask + + // A virtual function that allows the test to set up the sequence to know about the sequencer + // where it should run. This runs before the sequence is randomised, which allows the sequence to + // constrain its randomisation using the environment's cfg handle (getting it through p_sequencer). + // + // The base class version of this function registers env.virtual_sequencer. If a testbench wishes + // to register multiple sequencers with a virtual sequence, it can do so by overriding this + // function. + virtual function void configure_sequence(uvm_sequence seq); + seq.set_sequencer(env.virtual_sequencer); + endfunction + +endclass : dv_base_test diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_virtual_sequencer.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_virtual_sequencer.sv new file mode 100644 index 0000000..1fc4c7d --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_virtual_sequencer.sv @@ -0,0 +1,32 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_virtual_sequencer #(type CFG_T = dv_base_env_cfg, + type COV_T = dv_base_env_cov) extends uvm_sequencer; + `uvm_component_param_utils(dv_base_virtual_sequencer #(CFG_T, COV_T)) + + CFG_T cfg; + COV_T cov; + + function new(string name, uvm_component parent); + super.new(name, parent); + endfunction + + // Dynamic associative array to store sub-sequencers + uvm_sequencer_base sub_sequencers[string]; + + // Method to dynamically register a sub-sequencer + function void register_sequencer(string name, uvm_sequencer_base sequencer); + // Check if the sub_sequencer name does not exists before register it. + `DV_CHECK_FATAL(!sub_sequencers.exists(name)) + sub_sequencers[name] = sequencer; + endfunction + + // Method to retrieve a sequencer by name + function uvm_sequencer_base get_sequencer(string name); + // Check if the sub_sequencer name is registered before return it. + `DV_CHECK_FATAL(sub_sequencers.exists(name)) + return sub_sequencers[name]; + endfunction +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_vseq.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_vseq.sv new file mode 100644 index 0000000..40e3435 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_vseq.sv @@ -0,0 +1,291 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class dv_base_vseq #(type RAL_T = dv_base_reg_block, + type CFG_T = dv_base_env_cfg, + type COV_T = dv_base_env_cov, + type VIRTUAL_SEQUENCER_T = dv_base_virtual_sequencer) extends uvm_sequence; + `uvm_object_param_utils(dv_base_vseq #(RAL_T, CFG_T, COV_T, VIRTUAL_SEQUENCER_T)) + `uvm_declare_p_sequencer(VIRTUAL_SEQUENCER_T) + + // number of iterations to run the test seq - please override constraint in extended vseq + // randomization for this is disabled in pre_start since we don't want to re-randomize it again + rand uint num_trans; + + constraint num_trans_c { + num_trans inside {[1:20]}; + } + + // handles for ease of op + CFG_T cfg; + RAL_T ral; + COV_T cov; + + // knobs to enable pre_start routines + bit do_dut_init = 1'b1; + bit do_apply_reset = 1'b1; + bit do_wait_for_reset = 1'b0; + + // knobs to enable post_start routines + bit do_dut_shutdown = 1'b1; + + // various knobs to enable certain routines + // this knob allows user to disable assertions in csr_hw_reset before random write sequence, + // the assertions will turn back on after the hw reset deasserted + bit enable_asserts_in_hw_reset_rand_wr = 1'b1; + + `uvm_object_new + + virtual function void set_handles(); + `DV_CHECK_NE_FATAL(p_sequencer, null, "Did you forget to call `set_sequencer()`?") + cfg = p_sequencer.cfg; + cov = p_sequencer.cov; + ral = cfg.ral; + endfunction + + // This function is invoked in pre_randomize(). Override it in the extended classes to configure + // / control the randomization of this sequence. + virtual function void configure_vseq(); + endfunction + + function void pre_randomize(); + // Set the handles in pre_randomize(), so that the knobs in cfg are available during sequence + // randomization. This forces `p_sequencer` handle to be set before the randomization - users + // are required to call `set_sequencer()` right after creating the sequence and before + // randomizing it. + if (cfg == null) set_handles(); + configure_vseq(); + endfunction + + task pre_start(); + super.pre_start(); + if (cfg == null) set_handles(); + if (do_dut_init) dut_init("HARD"); + num_trans.rand_mode(0); + endtask + + task post_start(); + super.post_start(); + if (do_dut_shutdown) dut_shutdown(); + endtask + + /* + * startup, reset and shutdown related tasks + */ + virtual task dut_init(string reset_kind = "HARD"); + if (do_apply_reset) begin + apply_reset(reset_kind); + post_apply_reset(reset_kind); + end else if (do_wait_for_reset) wait_for_reset(reset_kind); + // delay after reset for tl agent check seq_item_port empty + #1ps; + endtask + + virtual task apply_reset(string kind = "HARD"); + if (kind == "HARD") begin + if (cfg.clk_rst_vifs.size() > 0) begin + fork + begin : isolation_fork + foreach (cfg.clk_rst_vifs[i]) begin + automatic string ral_name = i; + fork + cfg.clk_rst_vifs[ral_name].apply_reset(); + join_none + end + wait fork; + end : isolation_fork + join + end else begin // no ral model and only has default clk_rst_vif + cfg.clk_rst_vif.apply_reset(); + end + end // if (kind == "HARD") + endtask + + // Apply all resets in the DUT concurrently to generate a random in-test reset scenario. + // + // - Assert resets concurrently to make sure all resets are issued. + // - Deassert resets concurrently is a specific requirement of the `stress_all_with_rand_reset` + // sequence, which will randomly issue resets and terminate the parallel sequence once all DUT + // resets are deasserted. If DUT resets are deasserted at different time, the parallel sequence + // might send a transaction request to driver between different resets are deasserting. Then when + // `stress_all_with_rand_reset` sequence tries to terminate the parallel sequence, an UVM_ERROR + // will be thrown by the sequencer saying `task responsible for requesting a wait_for_grant has + // been killed`. + // In order to ensure all resets at least being asserted for one clock cycle, this task takes an + // optional input `reset_duration_ps` if the DUT has additional resets. The task uses this input + // to compute the minimal time required to keep all resets asserted. + virtual task apply_resets_concurrently(int reset_duration_ps = 0); + int slowest_clk_period_ps = 0; + int reset_duration_from_clks_ps; + + // Calculate the slowest clock that we see with a RAL model or fall back to the default + // clk_rst_if if there is no RAL model. + if (cfg.clk_rst_vifs.size() > 0) begin + foreach (cfg.clk_rst_vifs[i]) begin + slowest_clk_period_ps = max2(slowest_clk_period_ps, cfg.clk_rst_vifs[i].clk_period_ps); + end + end else begin + slowest_clk_period_ps = cfg.clk_rst_vif.clk_period_ps; + end + + // Pick the reset duration by picking a random number of (slowest) clock cycles, taking at least + // two. Then use the maximum of that value and the reset_duration_ps argument. + reset_duration_from_clks_ps = $urandom_range(2, 10) * slowest_clk_period_ps; + reset_duration_ps = max2(reset_duration_ps, reset_duration_from_clks_ps); + + // Now apply the reset by driving any reset pins to zero, waiting a while, and then driving the + // back to one. + if (cfg.clk_rst_vifs.size() > 0) begin + foreach (cfg.clk_rst_vifs[i]) cfg.clk_rst_vifs[i].drive_rst_pin(0); + #(reset_duration_ps * 1ps); + foreach (cfg.clk_rst_vifs[i]) cfg.clk_rst_vifs[i].drive_rst_pin(1); + end else begin + cfg.clk_rst_vif.drive_rst_pin(0); + #(reset_duration_ps * 1ps); + cfg.clk_rst_vif.drive_rst_pin(1); + end + endtask + + // This is called after apply_reset in this class and after apply_resets_concurrently + // in cip_base_vseq::run_seq_with_rand_reset_vseq. + virtual task post_apply_reset(string reset_kind = "HARD"); + endtask + + virtual task wait_for_reset(string reset_kind = "HARD", + bit wait_for_assert = 1, + bit wait_for_deassert = 1); + if (wait_for_assert) begin + `uvm_info(`gfn, "waiting for rst_n assertion...", UVM_MEDIUM) + @(negedge cfg.clk_rst_vif.rst_n); + end + if (wait_for_deassert) begin + `uvm_info(`gfn, "waiting for rst_n de-assertion...", UVM_MEDIUM) + @(posedge cfg.clk_rst_vif.rst_n); + end + `uvm_info(`gfn, "wait_for_reset done", UVM_HIGH) + endtask + + // dut shutdown - this is called in post_start if do_dut_shutdown bit is set + virtual task dut_shutdown(); + csr_utils_pkg::wait_no_outstanding_access(); + endtask + + // wrapper task around run_csr_vseq - the purpose is to be able to call this directly for actual + // csr tests (as opposed to higher level stress test that could also run csr seq as a fork by + // calling run_csr_vseq(..) task) + virtual task run_csr_vseq_wrapper(int num_times = 1, dv_base_reg_block models[$] = {}); + string csr_test_type; + + // Env needs to have a ral instance. + if (models.size() == 0) begin + `DV_CHECK_GE_FATAL(cfg.ral_models.size(), 1) + end + + // Get csr_test_type from plusarg + void'($value$plusargs("csr_%0s", csr_test_type)); + + // run the csr seq + for (int i = 1; i <= num_times; i++) begin + `uvm_info(`gfn, $sformatf("Running csr %0s vseq iteration %0d/%0d.", + csr_test_type, i, num_times), UVM_LOW) + run_csr_vseq(.csr_test_type(csr_test_type), .models(models)); + end + endtask + + // capture the entire csr seq as a task that can be overridden if desired + // arg csr_test_type: what csr test to run {hw_reset, rw, bit_bash, aliasing} + // arg num_test_csrs:instead of testing the entire ral model or passing test chunk info via + // plusarg, provide ability to set a random number of csrs to test from higher level sequence + // `models` is the list of RAL models to run the common sequences on. + // `ral_name` is the string name of the RAL to run the common sequences on. + // Both of these inputs are 'null' by default. If externally set, `models` takes precedence over + // `ral_name`. + virtual task run_csr_vseq(string csr_test_type, + int num_test_csrs = 0, + bit do_rand_wr_and_reset = 1, + dv_base_reg_block models[$] = {}, + string ral_name = ""); + csr_base_seq m_csr_seq; + + // env needs to have at least one ral instance + `DV_CHECK_GE_FATAL(cfg.ral_models.size(), 1) + + // Filter out the RAL blocks under test with the supplied name, if available. + if (models.size() == 0) begin + if (ral_name != "") begin + `DV_CHECK_FATAL(cfg.ral_models.exists(ral_name)) + models.push_back(cfg.ral_models[ral_name]); + end else begin + foreach (cfg.ral_models[i]) models.push_back(cfg.ral_models[i]); + end + end + + // check which csr test type + case (csr_test_type) + "hw_reset": csr_base_seq::type_id::set_type_override(csr_hw_reset_seq::get_type()); + "rw" : csr_base_seq::type_id::set_type_override(csr_rw_seq::get_type()); + "bit_bash": csr_base_seq::type_id::set_type_override(csr_bit_bash_seq::get_type()); + "aliasing": csr_base_seq::type_id::set_type_override(csr_aliasing_seq::get_type()); + "mem_walk": csr_base_seq::type_id::set_type_override(csr_mem_walk_seq::get_type()); + default : `uvm_fatal(`gfn, $sformatf("specified opt is invalid: +csr_%0s", csr_test_type)) + endcase + + // Print the list of available exclusions that are in effect for debug. + foreach (models[i]) begin + csr_excl_item csr_excl = csr_utils_pkg::get_excl_item(models[i]); + if (csr_excl != null) csr_excl.print_exclusions(); + end + + // if hw_reset test, then write all CSRs first and reset the whole dut + if (csr_test_type == "hw_reset" && do_rand_wr_and_reset) begin + string reset_type = "HARD"; + csr_write_seq m_csr_write_seq; + + // Writing random values to CSRs might trigger assertion errors. So we disable in the entire + // DUT hierarchy and re-enable after resetting the DUT. See DV_ASSERT_CTRL macro defined in + // hw/dv/sv/dv_utils/dv_macros.svh for more details. + if (!enable_asserts_in_hw_reset_rand_wr) begin + `DV_ASSERT_CTRL_REQ("dut_assert_en", 1'b0) + end + + // run write-only sequence to randomize the csr values + m_csr_write_seq = csr_write_seq::type_id::create("m_csr_write_seq"); + m_csr_write_seq.models = models; + m_csr_write_seq.external_checker = cfg.en_scb; + m_csr_write_seq.en_rand_backdoor_write = 1'b1; + m_csr_write_seq.start(null); + + // run dut_shutdown before asserting reset + dut_shutdown(); + // issue reset + void'($value$plusargs("do_reset=%0s", reset_type)); + dut_init(reset_type); + if (!enable_asserts_in_hw_reset_rand_wr) begin + `DV_ASSERT_CTRL_REQ("dut_assert_en", 1'b1) + end + end + + // create base csr seq and pass our ral + m_csr_seq = csr_base_seq::type_id::create("m_csr_seq"); + m_csr_seq.models = models; + m_csr_seq.external_checker = cfg.en_scb; + m_csr_seq.max_num_test_csrs = num_test_csrs; + m_csr_seq.start(null); + endtask + + // enable/disable csr_assert + virtual function void set_csr_assert_en(bit enable, string path = "*"); + uvm_config_db#(bit)::set(null, path, "csr_assert_en", enable); + endfunction + + // Use the factory to create a sequence by name and return the resulting uvm_sequence. + // + // The created sequence should be an instance of the class where this function is defined. + // Creating the sequence through this method rather than the underlying function, + // dv_utils_pkg::create_seq_by_name, allows subclasses of dv_base_seq to copy information about + // themselves (such as sequencers or other configuration) to the new sequence. + virtual function uvm_sequence create_seq_by_name(string name); + return dv_utils_pkg::create_seq_by_name(name); + endfunction +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_lib.core b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_lib.core new file mode 100644 index 0000000..4190323 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_lib.core @@ -0,0 +1,32 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_lib" +description: "DV base class UVM library" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_utils + - lowrisc:dv:csr_utils + - lowrisc:dv:dv_base_reg + - lowrisc:dv:dv_base_agent + - lowrisc:dv:common_ifs + files: + - dv_lib_pkg.sv + + - dv_base_env_cfg.sv: {is_include_file: true} + - bit_toggle_cg_wrap.sv: {is_include_file: true} + - dv_base_env_cov.sv: {is_include_file: true} + - dv_base_virtual_sequencer.sv: {is_include_file: true} + - dv_base_scoreboard.sv: {is_include_file: true} + - dv_base_env.sv: {is_include_file: true} + - dv_base_vseq.sv: {is_include_file: true} + - dv_base_test.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_lib_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_lib_pkg.sv new file mode 100644 index 0000000..9d9bc32 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_lib/dv_lib_pkg.sv @@ -0,0 +1,36 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package dv_lib_pkg; + // dep packages + import uvm_pkg::*; + import dv_utils_pkg::*; + import csr_utils_pkg::*; + import dv_base_reg_pkg::*; + import dv_base_agent_pkg::*; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + // package variables + string msg_id = "dv_lib_pkg"; + + // package sources + + // base env + `include "dv_base_env_cfg.sv" + `include "bit_toggle_cg_wrap.sv" + `include "dv_base_env_cov.sv" + `include "dv_base_virtual_sequencer.sv" + `include "dv_base_scoreboard.sv" + `include "dv_base_env.sv" + + // base test vseq + `include "dv_base_vseq.sv" + + // base test + `include "dv_base_test.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/README.md b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/README.md new file mode 100644 index 0000000..e69de29 diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_fcov_macros.core b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_fcov_macros.core new file mode 100644 index 0000000..4542886 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_fcov_macros.core @@ -0,0 +1,17 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_fcov_macros" +description: "DV FCOV macros" + +filesets: + files_fcov: + files: + - dv_fcov_macros.svh: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_fcov diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_fcov_macros.svh b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_fcov_macros.svh new file mode 100644 index 0000000..eaae393 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_fcov_macros.svh @@ -0,0 +1,112 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Include FCOV RTL by default. Disable it for synthesis and where explicitly requested (by defining +// DV_FCOV_DISABLE). +`ifdef SYNTHESIS + `define DV_FCOV_DISABLE +`elsif YOSYS + `define DV_FCOV_DISABLE +`endif + +// Disable instantiations of FCOV coverpoints or covergroups. +`ifdef VERILATOR + `define DV_FCOV_DISABLE_CP +`elsif DV_FCOV_DISABLE + `define DV_FCOV_DISABLE_CP +`endif + +// Instantiates a covergroup in an interface or module. +// +// This macro assumes that a covergroup of the same name as the NAME_ arg is defined in the +// interface or module. It just adds some extra signals and logic to control the creation of the +// covergroup instance with ~bit en_~. This defaults to 0. It is ORed with the external +// COND_ signal. The testbench can modify it at t = 0 based on the test being run. +// NOTE: This is not meant to be invoked inside a class. +// +// NAME_ : Name of the covergroup. +// COND_ : External condition / expr that controls the creation of the covergroup. +// ARGS_ : Arguments to covergroup instance, if any. Args MUST BE wrapped in (..). +`ifndef DV_FCOV_INSTANTIATE_CG +`ifdef DV_FCOV_DISABLE_CP + `define DV_FCOV_INSTANTIATE_CG(NAME_, COND_ = 1'b1, ARGS_ = ()) +`else + `define DV_FCOV_INSTANTIATE_CG(NAME_, COND_ = 1'b1, ARGS_ = ()) \ + bit en_``NAME_ = 1'b0; \ + NAME_ NAME_``_inst; \ + initial begin \ + /* The #1 delay below allows any part of the tb to control the conditions first at t = 0. */ \ + #1; \ + if ((en_``NAME_) || (COND_)) begin \ + $display("%0t: (%0s:%0d) [%m] %0s", $time, `__FILE__, `__LINE__, \ + {"Creating covergroup ", `"NAME_`"}); \ + NAME_``_inst = new``ARGS_; \ + end \ + end +`endif +`endif + +// Creates a coverpoint for an expression where only the expression true case is of interest for +// coverage (e.g. where the expression indicates an event has occurred). +`ifndef DV_FCOV_EXPR_SEEN +`ifdef DV_FCOV_DISABLE_CP + `define DV_FCOV_EXPR_SEEN(NAME_, EXPR_) +`else + `define DV_FCOV_EXPR_SEEN(NAME_, EXPR_) cp_``NAME_: coverpoint EXPR_ { bins seen = {1}; } +`endif +`endif + +// Creates a SVA cover that can be used in a covergroup. +// +// This macro creates an unnamed SVA cover from the property (or an expression) `PROP_` and an event +// with the name `EV_NAME_`. When the SVA cover is hit, the event is triggered. A coverpoint can +// cover the `triggered` property of the event. +`ifndef DV_FCOV_SVA +`ifdef DV_FCOV_DISABLE + `define DV_FCOV_SVA(EV_NAME_, PROP_, CLK_ = clk_i, RST_ = rst_ni) +`else + `define DV_FCOV_SVA(EV_NAME_, PROP_, CLK_ = clk_i, RST_ = rst_ni) \ + event EV_NAME_; \ + cover property (@(posedge CLK_) disable iff (RST_ == 0) (PROP_)) begin \ + -> EV_NAME_; \ + end +`endif +`endif + +// Coverage support is not always available but it's useful to include extra fcov signals for +// linting purposes. They need to be marked as unused to avoid warnings. +`ifndef DV_FCOV_MARK_UNUSED + `define DV_FCOV_MARK_UNUSED(TYPE_, NAME_) \ + TYPE_ unused_fcov_``NAME_; \ + assign unused_fcov_``NAME_ = fcov_``NAME_; +`endif + +// Define a signal and expression in the design for capture in functional coverage +`ifndef DV_FCOV_SIGNAL +`ifdef DV_FCOV_DISABLE + `define DV_FCOV_SIGNAL(TYPE_, NAME_, EXPR_) +`else + `define DV_FCOV_SIGNAL(TYPE_, NAME_, EXPR_) \ + TYPE_ fcov_``NAME_; \ + assign fcov_``NAME_ = EXPR_; \ + `DV_FCOV_MARK_UNUSED(TYPE_, NAME_) +`endif +`endif + +// Define a signal and expression in the design for capture in functional coverage depending on +// design configuration. The input GEN_COND_ must be a constant or parameter. +`ifndef DV_FCOV_SIGNAL_GEN_IF +`ifdef DV_FCOV_DISABLE + `define DV_FCOV_SIGNAL_GEN_IF(TYPE_, NAME_, EXPR_, GEN_COND_, DEFAULT_ = '0) +`else + `define DV_FCOV_SIGNAL_GEN_IF(TYPE_, NAME_, EXPR_, GEN_COND_, DEFAULT_ = '0) \ + TYPE_ fcov_``NAME_; \ + if (GEN_COND_) begin : g_fcov_``NAME_ \ + assign fcov_``NAME_ = EXPR_; \ + end else begin : g_no_fcov_``NAME_ \ + assign fcov_``NAME_ = DEFAULT_; \ + end \ + `DV_FCOV_MARK_UNUSED(TYPE_, NAME_) +`endif +`endif diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.core b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.core new file mode 100644 index 0000000..61a236b --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.core @@ -0,0 +1,17 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_macros" +description: "A collection of macros used in DV." + +filesets: + files_dv: + files: + - dv_macros.svh: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: &default_target + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.svh b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.svh new file mode 100644 index 0000000..a239b1e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.svh @@ -0,0 +1,651 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +`ifdef UVM + `include "uvm_macros.svh" +`endif + +// UVM speficic macros +`ifndef gfn +`ifdef UVM + // verilog_lint: waive macro-name-style + `define gfn get_full_name() +`else + // verilog_lint: waive macro-name-style + `define gfn $sformatf("%m") +`endif +`endif + +`ifndef gtn + // verilog_lint: waive macro-name-style + `define gtn get_type_name() +`endif + +`ifndef gn + // verilog_lint: waive macro-name-style + `define gn get_name() +`endif + +`ifndef gmv + // verilog_lint: waive macro-name-style + `define gmv(csr) csr.get_mirrored_value() +`endif + +// cast base class obj holding extended class handle to extended class handle; +// throw error if cast fails +`ifndef downcast + // verilog_lint: waive macro-name-style + `define downcast(EXT_, BASE_, MSG_="", SEV_=fatal, ID_=`gfn) \ + begin \ + if (!$cast(EXT_, BASE_)) begin \ + `dv_``SEV_($sformatf({"Cast failed: base class variable %0s ", \ + "does not hold extended class %0s handle %s"}, \ + `"BASE_`", `"EXT_`", MSG_), ID_) \ + end \ + end +`endif + +// Note, UVM provides a macro `uvm_new_func -- which only applies to uvm_components +`ifndef uvm_object_new + `define uvm_object_new \ + function new (string name=""); \ + super.new(name); \ + endfunction : new +`endif + +`ifndef uvm_create_obj + `define uvm_create_obj(_type_name_, _inst_name_) \ + _inst_name_ = _type_name_::type_id::create(`"_inst_name_`"); +`endif + +`ifndef uvm_component_new + `define uvm_component_new \ + function new (string name, uvm_component parent); \ + super.new(name, parent); \ + endfunction : new +`endif + +`ifndef uvm_create_comp + `define uvm_create_comp(_type_name_, _inst_name_) \ + _inst_name_ = _type_name_::type_id::create(`"_inst_name_`", this); +`endif + +// Convert arbitrary text / expression to string. +`ifndef DV_STRINGIFY + `define DV_STRINGIFY(I_) `"I_`" +`endif + +`ifndef DUT_HIER_STR + `define DUT_HIER_STR `DV_STRINGIFY(`DUT_HIER) +`endif + +// Common check macros used by DV_CHECK error and fatal macros. +// Note: Should not be called by user code +`ifndef DV_CHECK + `define DV_CHECK(T_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if (T_) ; else begin \ + `dv_``SEV_($sformatf("Check failed (%s) %s ", `"T_`", MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_EQ + `define DV_CHECK_EQ(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) == (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s == %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_NE + `define DV_CHECK_NE(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) != (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s != %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_CASE_EQ + `define DV_CHECK_CASE_EQ(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) === (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s === %s (0x%0h [%0b] vs 0x%0h [%0b]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_CASE_NE + `define DV_CHECK_CASE_NE(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) !== (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s !== %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_LT + `define DV_CHECK_LT(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) < (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s < %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_GT + `define DV_CHECK_GT(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) > (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s > %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_LE + `define DV_CHECK_LE(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) <= (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s <= %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_GE + `define DV_CHECK_GE(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) >= (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed %s >= %s (%0d [0x%0h] vs %0d [0x%0h]) %s", \ + `"ACT_`", `"EXP_`", ACT_, ACT_, EXP_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_STREQ + `define DV_CHECK_STREQ(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) == (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed \"%s\" == \"%s\" %s", ACT_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_STRNE + `define DV_CHECK_STRNE(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + if ((ACT_) != (EXP_)) ; else begin \ + `dv_``SEV_($sformatf("Check failed \"%s\" != \"%s\" %s", ACT_, EXP_, MSG_), ID_) \ + end \ + end +`endif + +`ifndef DV_CHECK_Q_EQ + `define DV_CHECK_Q_EQ(ACT_, EXP_, MSG_="", SEV_=error, ID_=`gfn) \ + begin \ + `DV_CHECK_EQ(ACT_.size(), EXP_.size(), MSG_, SEV_, ID_) \ + foreach (ACT_[i]) begin \ + `DV_CHECK_EQ(ACT_[i], EXP_[i], $sformatf("for i = %0d %s", i, MSG_), SEV_, ID_) \ + end \ + end +`endif + +// Fatal version of the checks +`ifndef DV_CHECK_FATAL + `define DV_CHECK_FATAL(T_, MSG_="", ID_=`gfn) \ + `DV_CHECK(T_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_EQ_FATAL + `define DV_CHECK_EQ_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_EQ(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_NE_FATAL + `define DV_CHECK_NE_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_NE(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_LT_FATAL + `define DV_CHECK_LT_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_LT(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_GT_FATAL + `define DV_CHECK_GT_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_GT(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_LE_FATAL + `define DV_CHECK_LE_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_LE(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_GE_FATAL + `define DV_CHECK_GE_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_GE(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_STREQ_FATAL + `define DV_CHECK_STREQ_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_STREQ(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +`ifndef DV_CHECK_STRNE_FATAL + `define DV_CHECK_STRNE_FATAL(ACT_, EXP_, MSG_="", ID_=`gfn) \ + `DV_CHECK_STRNE(ACT_, EXP_, MSG_, fatal, ID_) +`endif + +// Shorthand for common foo.randomize() + fatal check +`ifndef DV_CHECK_RANDOMIZE_FATAL + `define DV_CHECK_RANDOMIZE_FATAL(VAR_, MSG_="Randomization failed!", ID_=`gfn) \ + `DV_CHECK_FATAL(VAR_.randomize(), MSG_, ID_) +`endif + +// Shorthand for common foo.randomize() with { } + fatal check +`ifndef DV_CHECK_RANDOMIZE_WITH_FATAL + `define DV_CHECK_RANDOMIZE_WITH_FATAL(VAR_, WITH_C_, MSG_="Randomization failed!", ID_=`gfn) \ + `DV_CHECK_FATAL(VAR_.randomize() with {WITH_C_}, MSG_, ID_) +`endif + +// Shorthand for common std::randomize(foo) + fatal check +`ifndef DV_CHECK_STD_RANDOMIZE_FATAL + `define DV_CHECK_STD_RANDOMIZE_FATAL(VAR_, MSG_="Randomization failed!", ID_=`gfn) \ + `DV_CHECK_FATAL(std::randomize(VAR_), MSG_, ID_) +`endif + +// Shorthand for common std::randomize(foo) with { } + fatal check +`ifndef DV_CHECK_STD_RANDOMIZE_WITH_FATAL + `define DV_CHECK_STD_RANDOMIZE_WITH_FATAL(VAR_, WITH_C_, MSG_="Randomization failed!",ID_=`gfn) \ + `DV_CHECK_FATAL(std::randomize(VAR_) with {WITH_C_}, MSG_, ID_) +`endif + +// Shorthand for common cls_inst.randomize(member) + fatal check +// Randomizes a specific member of a class instance. +`ifndef DV_CHECK_MEMBER_RANDOMIZE_FATAL + `define DV_CHECK_MEMBER_RANDOMIZE_FATAL(VAR_, CLS_INST_=this, MSG_="Randomization failed!", ID_=`gfn) \ + `DV_CHECK_FATAL(CLS_INST_.randomize(VAR_), MSG_, ID_) +`endif + +// Shorthand for common cls_inst.randomize(member) with { } + fatal check +// Randomizes a specific member of a class instance with inline constraints. +`ifndef DV_CHECK_MEMBER_RANDOMIZE_WITH_FATAL + `define DV_CHECK_MEMBER_RANDOMIZE_WITH_FATAL(VAR_, C_, CLS_INST_=this, MSG_="Randomization failed!", ID_=`gfn) \ + `DV_CHECK_FATAL(CLS_INST_.randomize(VAR_) with {C_}, MSG_, ID_) +`endif + +// print static/dynamic 1d array or queue +`ifndef DV_PRINT_ARR_CONTENTS +`define DV_PRINT_ARR_CONTENTS(ARR_, V_=uvm_pkg::UVM_MEDIUM, ID_=`gfn) \ + begin \ + foreach (ARR_[i]) begin \ + `dv_info($sformatf("%s[%0d] = %0d (0x%0h)", `"ARR_`", i, ARR_[i], ARR_[i]), V_, ID_) \ + end \ + end +`endif + +// print non-empty tlm FIFOs that were uncompared at end of test +`ifndef DV_EOT_PRINT_TLM_FIFO_CONTENTS +`define DV_EOT_PRINT_TLM_FIFO_CONTENTS(TYP_, FIFO_, SEV_=error, ID_=`gfn) \ + forever begin \ + TYP_ item; \ + int res = FIFO_.try_get(item); \ + if (res == 0) break; \ + if (res < 0) `dv_fatal($sformatf("Cannot read item from %s (type mismatch)", `"FIFO_`"), ID_) \ + `dv_``SEV_($sformatf("%s item uncompared:\n%s", `"FIFO_`", item.sprint()), ID_) \ + end +`endif + +// print non-empty tlm FIFOs that were uncompared at end of test +`ifndef DV_EOT_PRINT_TLM_FIFO_ARR_CONTENTS +`define DV_EOT_PRINT_TLM_FIFO_ARR_CONTENTS(TYP_, FIFO_, SEV_=error, ID_=`gfn) \ + begin \ + foreach (FIFO_[i]) begin \ + while (!FIFO_[i].is_empty()) begin \ + TYP_ item; \ + void'(FIFO_[i].try_get(item)); \ + `dv_``SEV_($sformatf("%s[%0d] item uncompared:\n%s", `"FIFO_`", i, item.sprint()), ID_) \ + end \ + end \ + end +`endif + +// print non-empty tlm FIFOs that were uncompared at end of test +`ifndef DV_EOT_PRINT_Q_CONTENTS +`define DV_EOT_PRINT_Q_CONTENTS(TYP_, Q_, SEV_=error, ID_=`gfn) \ + begin \ + while (Q_.size() != 0) begin \ + TYP_ item = Q_.pop_front(); \ + `dv_``SEV_($sformatf("%s item uncompared:\n%s", `"Q_`", item.sprint()), ID_) \ + end \ + end +`endif + +// print non-empty tlm FIFOs that were uncompared at end of test +`ifndef DV_EOT_PRINT_Q_ARR_CONTENTS +`define DV_EOT_PRINT_Q_ARR_CONTENTS(TYP_, Q_, SEV_=error, ID_=`gfn) \ + begin \ + foreach (Q_[i]) begin \ + while (Q_[i].size() != 0) begin \ + TYP_ item = Q_[i].pop_front(); \ + `dv_``SEV_($sformatf("%s[%0d] item uncompared:\n%s", `"Q_`", i, item.sprint()), ID_) \ + end \ + end \ + end +`endif + +// check for non-empty mailbox and print items that were uncompared at end of test +`ifndef DV_EOT_PRINT_MAILBOX_CONTENTS +`define DV_EOT_PRINT_MAILBOX_CONTENTS(TYP_, MAILBOX_, SEV_=error, ID_=`gfn) \ + begin \ + while (MAILBOX_.num() != 0) begin \ + TYP_ item; \ + void'(MAILBOX_.try_get(item)); \ + `dv_``SEV_($sformatf("%s item uncompared:\n%s", `"MAILBOX_`", item.sprint()), ID_) \ + end \ + end +`endif + +// get parity - implemented as a macro so that it can be invoked in constraints as well +`ifndef GET_PARITY + `define GET_PARITY(val, odd=0) (^val ^ odd) +`endif + +// Wait for a statement but stop early if the EXIT statement completes. +// +// Example usage: +// +// `DV_SPINWAIT_EXIT(do_something_time_consuming();, +// wait(stop_now_flag);, +// "The stop flag was set when we were working") +`ifndef DV_SPINWAIT_EXIT +`define DV_SPINWAIT_EXIT(WAIT_, EXIT_, MSG_ = "exit condition occurred!", ID_ =`gfn) \ + begin \ + fork begin \ + fork \ + begin \ + WAIT_ \ + end \ + begin \ + EXIT_ \ + if (MSG_ != "") begin \ + `dv_info(MSG_, uvm_pkg::UVM_HIGH, ID_) \ + end \ + end \ + join_any \ + disable fork; \ + end join \ + end +`endif + +// Wait for one of two statements but stop early if the EXIT statement completes. +// +// Example usage: +// +// `DV_SPINWAIT_EXIT_MULTI(do_something_time_consuming();, +// do_something_else_time_consuming();, +// wait(stop_now_flag);, +// "The stop flag was set when we were working") +`ifndef DV_SPINWAIT_EXIT_MULTI +`define DV_SPINWAIT_EXIT_MULTI(WAIT_1_, WAIT_2_, EXIT_, MSG_ = "exit condition occurred!", ID_ =`gfn) \ + `DV_SPINWAIT_EXIT(fork begin \ + fork \ + begin WAIT_1_ end \ + begin WAIT_2_ end \ + join_any \ + disable fork; \ + end join, \ + EXIT_, MSG_, ID_) +`endif + +// macro that waits for a given delay and then reports an error +`ifndef DV_WAIT_TIMEOUT +`define DV_WAIT_TIMEOUT(TIMEOUT_NS_, ID_ = `gfn, ERROR_MSG_ = "timeout occurred!", REPORT_FATAL_ = 1) \ + begin \ + #(TIMEOUT_NS_ * 1ns); \ + if (REPORT_FATAL_) begin \ + `dv_fatal(ERROR_MSG_, ID_) \ + end else begin \ + `dv_error(ERROR_MSG_, ID_) \ + end \ + end +`endif + +// Wait for a statement, but exit early after a timeout +`ifndef DV_SPINWAIT +`define DV_SPINWAIT(WAIT_, MSG_ = "timeout occurred!", TIMEOUT_NS_ = default_spinwait_timeout_ns, ID_ =`gfn, REPORT_FATAL_ = 1) \ + `DV_SPINWAIT_EXIT(WAIT_, `DV_WAIT_TIMEOUT(TIMEOUT_NS_, ID_, MSG_, REPORT_FATAL_);, "", ID_) +`endif + +// a shorthand of `DV_SPINWAIT(wait(...)) +`ifndef DV_WAIT +`define DV_WAIT(WAIT_COND_, MSG_ = "wait timeout occurred!", TIMEOUT_NS_ = default_spinwait_timeout_ns, ID_ =`gfn, REPORT_FATAL_ = 1) \ + `DV_SPINWAIT(wait (WAIT_COND_);, MSG_, TIMEOUT_NS_, ID_, REPORT_FATAL_) +`endif + +// Wait for one of two statements, but exit early after a timeout +`ifndef DV_WAIT_MULTI +`define DV_WAIT_MULTI(WAIT_COND_1_, WAIT_COND_2_, MSG_ = "wait timeout occurred!", TIMEOUT_NS_ = default_spinwait_timeout_ns, ID_ =`gfn, REPORT_FATAL_ = 1) \ + `DV_SPINWAIT_EXIT_MULTI(WAIT_COND_1_, WAIT_COND_2_, `DV_WAIT_TIMEOUT(TIMEOUT_NS_, ID_, MSG_, REPORT_FATAL_);, "", ID_) +`endif + +// Control assertions in the DUT. +// +// This macro is invoked in top level testbench that instantiates the DUT. It spawns off an initial +// block that forever waits for a resource of type bit named by the string arg ~LABEL_~ that +// can be set by any entity in the testbench. Based on the value set, it enables or disables the +// assertions at the hierarchy of the provided path. The entity setting the resource value invokes +// uvm_config_db#(bit)::set(...) and this macro calls the corresponding get. +// +// LABEL_ : Name of the assertion control resource bit (string). +// HIER_ : Path to the module within which the assertion is controlled. +// LEVELS_: Number of levels within the module to control the assertions. +// SCOPE_ : Hierarchical string path to the testbench where this macro is invoked, example: %m. +// ID_ : Identifier string used for UVM logs. +`ifndef DV_ASSERT_CTRL +`define DV_ASSERT_CTRL(LABEL_, HIER_, LEVELS_ = 0, SCOPE_ = "", ID_ = $sformatf("%m")) \ + initial begin \ + bit assert_en; \ + forever begin \ + uvm_config_db#(bit)::wait_modified(null, SCOPE_, LABEL_); \ + if (!uvm_config_db#(bit)::get(null, SCOPE_, LABEL_, assert_en)) begin \ + `uvm_fatal(ID_, $sformatf("Failed to get \"%0s\" from uvm_config_db", LABEL_)) \ + end \ + if (assert_en) begin \ + `uvm_info(ID_, $sformatf("Enabling assertions: %0s", `DV_STRINGIFY(HIER_)), UVM_LOW) \ + $asserton(LEVELS_, HIER_); \ + end else begin \ + `uvm_info(ID_, $sformatf("Disabling assertions: %0s", `DV_STRINGIFY(HIER_)), UVM_LOW) \ + $assertoff(LEVELS_, HIER_); \ + $assertkill(LEVELS_, HIER_); \ + end \ + end \ + end +`endif + +// Retrieves a plusarg value representing an enum literal. +// +// The plusarg is parsed as a string, which needs to be converted into the enum literal whose name +// matches the string. This functionality is provided by the UVM helper function below. +// +// ENUM_: The enum type. +// VAR_: The enum variable to which the plusarg value will be set (must be declared already). +// PLUSARG_: the name of the plusarg (as a string). This is typically the same as the enum variable. +`ifndef DV_GET_ENUM_PLUSARG +`define DV_GET_ENUM_PLUSARG(ENUM_, VAR_, PLUSARG_, ID_ = `gfn) \ + begin \ + string str; \ + if ($value$plusargs({PLUSARG_, "=%0s"}, str)) begin \ + if (!uvm_enum_wrapper#(ENUM_)::from_name(str, VAR_)) begin \ + `uvm_fatal(ID_, $sformatf(`"Cannot find %s from enum ``ENUM_```", VAR_.name())) \ + end \ + end \ + end +`endif + +// Enable / disable assertions at a module hierarchy identified by LABEL_. +// +// This goes in conjunction with `DV_ASSERT_CTRL() macro above, but is invoked in the entity that is +// sending the req to turn on / off the assertions. Note that piece of code invoking this macro +// does not have the information on the actual hierarchical path to the module or the levels - this +// is 'wrapped' into the LABEL_ instead. DV user needs to uniquify the label sufficiently enough to +// reflect it. +// +// LABEL_ : Name of the assertion control resource bit (string). +// VALUE_ : Value of the control bit - 1 - enable assertions, 0 - disable assertions. +// SCOPE_ : Hierarchical string path to the testbench where this macro is invoked, example: %m. +`ifndef DV_ASSERT_CTRL_REQ +`define DV_ASSERT_CTRL_REQ(LABEL_, VALUE_, SCOPE_="") \ + begin \ + uvm_config_db#(bit)::set(null, SCOPE_, LABEL_, VALUE_); \ + end +`endif + +// Macros for logging (info, warning, error and fatal severities). +// +// These are meant to be invoked in modules and interfaces that are shared between DV and Verilator +// testbenches. We waive the lint requirement for these to be in uppercase, since they are +// UVM-adjacent. +`ifdef UVM +`ifndef dv_info + // verilog_lint: waive macro-name-style + `define dv_info(MSG_, VERBOSITY_ = uvm_pkg::UVM_LOW, ID_ = $sformatf("%m")) \ + if (uvm_pkg::uvm_report_enabled(VERBOSITY_, uvm_pkg::UVM_INFO, ID_)) begin \ + uvm_pkg::uvm_report_info(ID_, MSG_, VERBOSITY_, `uvm_file, `uvm_line, "", 1); \ + end +`endif + +`ifndef dv_warning + // verilog_lint: waive macro-name-style + `define dv_warning(MSG_, ID_ = $sformatf("%m")) \ + if (uvm_pkg::uvm_report_enabled(uvm_pkg::UVM_NONE, uvm_pkg::UVM_WARNING, ID_)) begin \ + uvm_pkg::uvm_report_warning(ID_, MSG_, uvm_pkg::UVM_NONE, `uvm_file, `uvm_line, "", 1); \ + end +`endif + +`ifndef dv_error + // verilog_lint: waive macro-name-style + `define dv_error(MSG_, ID_ = $sformatf("%m")) \ + if (uvm_pkg::uvm_report_enabled(uvm_pkg::UVM_NONE, uvm_pkg::UVM_ERROR, ID_)) begin \ + uvm_pkg::uvm_report_error(ID_, MSG_, uvm_pkg::UVM_NONE, `uvm_file, `uvm_line, "", 1); \ + end +`endif + +`ifndef dv_fatal + // verilog_lint: waive macro-name-style + `define dv_fatal(MSG_, ID_ = $sformatf("%m")) \ + if (uvm_pkg::uvm_report_enabled(uvm_pkg::UVM_NONE, uvm_pkg::UVM_FATAL, ID_)) begin \ + uvm_pkg::uvm_report_fatal(ID_, MSG_, uvm_pkg::UVM_NONE, `uvm_file, `uvm_line, "", 1); \ + end +`endif + +`else // UVM + +`ifndef dv_info + // verilog_lint: waive macro-name-style + `define dv_info(MSG_, VERBOSITY = DUMMY_, ID_ = $sformatf("%m")) \ + $display("%0t: (%0s:%0d) [%0s] %0s", $time, `__FILE__, `__LINE__, ID_, MSG_); +`endif + +`ifndef dv_warning + // verilog_lint: waive macro-name-style + `define dv_warning(MSG_, ID_ = $sformatf("%m")) \ + $warning("%0t: (%0s:%0d) [%0s] %0s", $time, `__FILE__, `__LINE__, ID_, MSG_); +`endif + +`ifndef dv_error + // verilog_lint: waive macro-name-style + `define dv_error(MSG_, ID_ = $sformatf("%m")) \ + $error("%0t: (%0s:%0d) [%0s] %0s", $time, `__FILE__, `__LINE__, ID_, MSG_); +`endif + +`ifndef dv_fatal + // verilog_lint: waive macro-name-style + `define dv_fatal(MSG_, ID_ = $sformatf("%m")) \ + $fatal(1, "%0t: (%0s:%0d) [%0s] %0s", $time, `__FILE__, `__LINE__, ID_, MSG_); +`endif + +`endif // UVM + +// Macros for constrain clk with common frequencies +// +// Nominal clock frequency range is 24Mhz - 100Mhz and use higher weights on 24, 25, 48, 50, 100, +// To mimic manufacturing conditions (when clocks are uncalibrated), we need to be able to go as +// low as 5MHz. +`ifndef DV_COMMON_CLK_CONSTRAINT +`define DV_COMMON_CLK_CONSTRAINT(FREQ_) \ + FREQ_ dist { \ + [5:23] :/ 2, \ + [24:25] :/ 2, \ + [26:47] :/ 1, \ + [48:50] :/ 2, \ + [51:95] :/ 1, \ + 96 :/ 1, \ + [97:99] :/ 1, \ + 100 :/ 1 \ + }; +`endif + +// Enables build-time randomization of fixed design constants. +// +// This is meant to be overridden externally by passing `+define+BUILD_SEED=`. +`ifndef BUILD_SEED + `define BUILD_SEED 1 +`endif + +// Max value out of 2 given expressions. +// +// Duplicate of dv_utils_pkg::max2() function, but this is better because +// it can consume different data types directly without the need for casting. +`ifndef DV_MAX2 + `define DV_MAX2(a, b) ((a) > (b) ? (a) : (b)) +`endif + +// Creates a signal probe function to sample / force / release an internal signal. +// +// If there is a need to sample / force an internal signal, then it must be done in the testbench, +// or in an interface bound to the DUT. This macro creates a standardized signal probe function +// to be defined in an interface. The generated function can then be invoked in test sequences +// or other UVM classes. The macro takes 2 arguments - name of the function and the hierarchical +// path to the signal. If invoked in an interface which is bound to the DUT, the signal can be a +// partial hierarchical path within the DUT. The generated function accepts 2 arguments - the first +// indicates the probe action (sample, force or release) of type dv_utils_pkg::signal_probe_e. The +// second argument is the value to be forced. If sample action is chosen, then it returns the +// sampled value (for other actions as well). +// +// The suggested naming convention for the function is: +// signal_probe__ +// +// This macro must be invoked in an interface or module. +`ifndef DV_CREATE_SIGNAL_PROBE_FUNCTION +`define DV_CREATE_SIGNAL_PROBE_FUNCTION(FUNC_NAME_, SIGNAL_PATH_, SIGNAL_WIDTH_ = uvm_pkg::UVM_HDL_MAX_WIDTH) \ + function static logic [SIGNAL_WIDTH_-1:0] FUNC_NAME_(dv_utils_pkg::signal_probe_e kind, \ + logic [SIGNAL_WIDTH_-1:0] value = '0); \ + case (kind) \ + dv_utils_pkg::SignalProbeSample: ; \ + dv_utils_pkg::SignalProbeForce: force SIGNAL_PATH_ = value; \ + dv_utils_pkg::SignalProbeRelease: release SIGNAL_PATH_; \ + default: `uvm_fatal(`"FUNC_NAME_`", $sformatf("Bad value: %0d", kind)) \ + endcase \ + return SIGNAL_PATH_; \ + endfunction +`endif + +// Usage:`OTDBG(( string )) +// This macro has unique keyword 'OTDBG' and timestamp only. +// Use for the temporary print to distinguish from `uvm_info. +// Do not leave this macro in other source files in the remote repo. +`ifndef OTDBG + `define OTDBG(x) \ + $write($sformatf("%t:OTDBG:%s:%d:",$time,`__FILE__, `__LINE__));\ + $display($sformatf x); +`endif diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_report_catcher.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_report_catcher.sv new file mode 100644 index 0000000..4f96279 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_report_catcher.sv @@ -0,0 +1,46 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// Report catcher/demoter +class dv_report_catcher extends uvm_report_catcher; + + // Stores a new severity indexed by the ID and + // the regular expression to match the message + protected uvm_severity m_changed_sev[string][string]; + + `uvm_object_utils(dv_report_catcher) + `uvm_object_new + + // Called for all report messages - defined in uvm_report_catcher + virtual function action_e catch(); + string id = get_id(); + if (m_changed_sev.exists(id)) begin + string report_msg = get_message(); + foreach (m_changed_sev[id, msg]) begin + if (uvm_re_match(msg, report_msg)) begin + set_severity(m_changed_sev[id][msg]); + end + end + end + return THROW; + endfunction + + // Change severity of a message with ID == id and message text + // matching msg which is treated as a regular expression + virtual function void add_change_sev(string id, string msg, uvm_severity sev); + m_changed_sev[id][msg] = sev; + endfunction + + // Remove a change entry + // If msg == "" then remove all changes for a given id + virtual function void remove_change_sev(string id, string msg = ""); + if (m_changed_sev.exists(id)) + if (msg == "") begin + // Delete all with id if message is blank + m_changed_sev.delete(id); + end else if (m_changed_sev[id].exists(msg)) begin + m_changed_sev[id].delete(msg); + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_report_server.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_report_server.sv new file mode 100644 index 0000000..fcfe25c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_report_server.sv @@ -0,0 +1,66 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Standardize look & feel of report phase and uvm logging messages. +class dv_report_server extends uvm_default_report_server; + `uvm_object_utils(dv_report_server) + + bit show_file_line = 1'b1; + // if enabled, show the relative path of the file. By default only show file name + bit show_file_path = 1'b0; + bit use_default_uvm_report_message_format = 1'b0; + + function new (string name = ""); + super.new(name); + // provide ability to override these knobs over cli + void'($value$plusargs("show_file_line=%0b", show_file_line)); + void'($value$plusargs("show_file_path=%0b", show_file_path)); + void'($value$plusargs("use_default_uvm_report_message_format=%0b", + use_default_uvm_report_message_format)); + endfunction + + function void report_summarize(UVM_FILE file = 0); + int num_uvm_warning; + int num_uvm_error; + int num_uvm_fatal; + + num_uvm_warning = get_severity_count(UVM_WARNING); + num_uvm_error = get_severity_count(UVM_ERROR); + num_uvm_fatal = get_severity_count(UVM_FATAL); + + // Print default summary report + super.report_summarize(file); + + // Print final test pass-fail - external tool can use this signature for test status + // Treat UVM_WARNINGs as a sign of test failure since it could silently result in false pass + dv_test_status_pkg::dv_test_status((num_uvm_warning + num_uvm_error + num_uvm_fatal) == 0); + endfunction + + // Override default messaging format to standard "pretty" format for all testbenches + virtual function string compose_report_message(uvm_report_message report_message, + string report_object_name = ""); + + if (use_default_uvm_report_message_format) begin + return (super.compose_report_message(report_message, report_object_name)); + end else begin + uvm_severity severity = report_message.get_severity(); + string filename = report_message.get_filename(); + int line = report_message.get_line(); + string obj_name = report_message.get_report_object().get_full_name(); + string id = report_message.get_id(); + string message = report_message.get_message(); + string file_line; + + if (show_file_line && filename != "") begin + if (!show_file_path) filename = str_utils_pkg::str_path_basename(filename); + file_line = $sformatf("(%0s:%0d) ", filename, line); + end + obj_name = {obj_name, ((obj_name != "") ? " " : "")}; + compose_report_message = $sformatf({"%0s @ %t: ", file_line, obj_name, "[%0s] %0s"}, + severity.name(), $realtime, id, message); + return compose_report_message; + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_test_status.core b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_test_status.core new file mode 100644 index 0000000..fdeea3e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_test_status.core @@ -0,0 +1,19 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_test_status" +description: "DV test status reporting utilities" + +filesets: + files_dv: + depend: + - lowrisc:prim:util + files: + - dv_test_status_pkg.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_test_status_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_test_status_pkg.sv new file mode 100644 index 0000000..d1516a2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_test_status_pkg.sv @@ -0,0 +1,38 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package dv_test_status_pkg; + + // Prints the test status signature & banner. + // + // This function takes a boolean arg indicating whether the test passed or failed and prints the + // signature along with a banner. The signature can be used by external scripts to determine if + // the test passed or failed. + function automatic void dv_test_status(bit passed); +`ifdef INC_ASSERT + if (prim_util_pkg::end_of_simulation) begin + // The first arg '1' is the error code, arbitrarily set to 1. + $fatal(1, "prim_util_pkg::end_of_simulation was already signaled!"); + end + prim_util_pkg::end_of_simulation = 1'b1; +`endif + if (passed) begin + $display("\nTEST PASSED CHECKS"); + $display(" _____ _ _ _ "); + $display("|_ _|__ ___| |_ _ __ __ _ ___ ___ ___ __| | |"); + $display(" | |/ _ \\/ __| __| | '_ \\ / _` / __/ __|/ _ \\/ _` | |"); + $display(" | | __/\\__ \\ |_ | |_) | (_| \\__ \\__ \\ __/ (_| |_|"); + $display(" |_|\\___||___/\\__| | .__/ \\__,_|___/___/\\___|\\__,_(_)"); + $display(" |_| \n"); + end else begin + $display("\nTEST FAILED CHECKS"); + $display(" _____ _ __ _ _ _ _ "); + $display("|_ _|__ ___| |_ / _| __ _(_) | ___ __| | |"); + $display(" | |/ _ \\/ __| __| | |_ / _` | | |/ _ \\/ _` | |"); + $display(" | | __/\\__ \\ |_ | _| (_| | | | __/ (_| |_|"); + $display(" |_|\\___||___/\\__| |_| \\__,_|_|_|\\___|\\__,_(_)\n"); + end + endfunction + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_utils.core b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_utils.core new file mode 100644 index 0000000..84bd52c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_utils.core @@ -0,0 +1,27 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:dv_utils" +description: "DV utilities" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_macros + - lowrisc:dv:dv_fcov_macros + - lowrisc:dv:common_ifs + - lowrisc:prim:assert:0.1 + - lowrisc:opentitan:bus_params_pkg + - lowrisc:dv:str_utils + - lowrisc:dv:dv_test_status + files: + - dv_utils_pkg.sv + - dv_report_catcher.sv: {is_include_file: true} + - dv_report_server.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_utils_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_utils_pkg.sv new file mode 100644 index 0000000..692b471 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/dv_utils/dv_utils_pkg.sv @@ -0,0 +1,350 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package dv_utils_pkg; + // dep packages + import uvm_pkg::*; + import bus_params_pkg::*; + + // macro includes + `include "dv_macros.svh" +`ifdef UVM + `include "uvm_macros.svh" +`endif + + // common parameters used across all benches + parameter int NUM_MAX_INTERRUPTS = 32; + typedef logic [NUM_MAX_INTERRUPTS-1:0] interrupt_t; + + parameter int NUM_MAX_ALERTS = 32; + typedef logic [NUM_MAX_ALERTS-1:0] alert_t; + + // types & variables + typedef bit [31:0] uint; + typedef bit [7:0] uint8; + typedef bit [15:0] uint16; + typedef bit [31:0] uint32; + typedef bit [63:0] uint64; + + // TODO: The above typedefs violate the name rule, which is fixed below. Cleanup the codebase to + // use the typedefs below and remove the ones above. + typedef bit [7:0] uint8_t; + typedef bit [15:0] uint16_t; + typedef bit [31:0] uint32_t; + typedef bit [63:0] uint64_t; + + // typedef parameterized pins_if for ease of implementation for interrupts and alerts + typedef virtual pins_if #(NUM_MAX_INTERRUPTS) intr_vif; + + // Interface direction / mode + typedef enum bit [1:0] { + Host, // The interface is active and is driving signals as a host + Device, // The interface is active and is driving signals as a device + Monitor // The interface is passive and drives no signals + } if_mode_e; + + // compare operator types + typedef enum { + CompareOpEq, + CompareOpCaseEq, + CompareOpNe, + CompareOpCaseNe, + CompareOpGt, + CompareOpGe, + CompareOpLt, + CompareOpLe + } compare_op_e; + + // mem address struct + typedef struct { + uvm_reg_addr_t start_addr; + uvm_reg_addr_t end_addr; + } addr_range_t; + + // Enum representing a bus operation type - read or write. + typedef enum bit { + BusOpWrite = 1'b0, + BusOpRead = 1'b1 + } bus_op_e; + + // Enum representing a probe operation on an internal signal. + typedef enum { + SignalProbeSample, // Sample the signal. + SignalProbeForce, // Force the signal with some value. + SignalProbeRelease // Release the previous force. + } signal_probe_e; + + // Enum representing a type of host requests - read only, write only or random read & write + typedef enum int { + HostReqNone = 0, + HostReqReadOnly = 1, + HostReqWriteOnly = 2, + HostReqReadWrite = 3 + } host_req_type_e; + + // Enum representing clock frequency difference on 2 clocks + typedef enum bit [1:0] { + ClkFreqDiffNone, + ClkFreqDiffSmall, + ClkFreqDiffBig, + ClkFreqDiffAny + } clk_freq_diff_e; + + // return the smaller value of 2 inputs + function automatic int min2(int a, int b); + return (a < b) ? a : b; + endfunction + + // return the bigger value of 2 inputs + function automatic int max2(int a, int b); + return (a > b) ? a : b; + endfunction + + // return the biggest value within the given queue of integers. + function automatic int max(const ref int int_q[$]); + `DV_CHECK_GT_FATAL(int_q.size(), 0, "max function cannot accept an empty queue of integers!", + $sformatf("%m")) + // Assign the first value from the queue in case of negative integers. + max = int_q[0]; + foreach (int_q[i]) max = max2(max, int_q[i]); + return max; + endfunction + + // get absolute value of the input. Usage: absolute(val) or absolute(a - b) + function automatic uint absolute(int val); + return val >= 0 ? val : -val; + endfunction + + // endian swaps a 32-bit data word + function automatic logic [31:0] endian_swap(logic [31:0] data); + return {<<8{data}}; + endfunction + + // endian swaps bytes at a word granularity, while preserving overall word ordering. + // + // e.g. if `arr[] = '{'h0, 'h1, 'h2, 'h3, 'h4, 'h5, 'h6, 'h7}`, this function will produce: + // `'{'h3, 'h2, 'h1, 'h0, 'h7, 'h6, 'h5, 'h4}` + function automatic void endian_swap_byte_arr(ref bit [7:0] arr[]); + arr = {<< byte {arr}}; + arr = {<< 32 {arr}}; + endfunction + +`ifdef UVM + // Simple function to set max errors before quitting sim + function automatic void set_max_quit_count(int n); + uvm_report_server report_server = uvm_report_server::get_server(); + report_server.set_max_quit_count(n); + endfunction + + // return if uvm_fatal occurred + function automatic bit has_uvm_fatal_occurred(); + uvm_report_server report_server = uvm_report_server::get_server(); + return report_server.get_severity_count(UVM_FATAL) > 0; + endfunction + + // create a sequence by name and return the handle of uvm_sequence + function automatic uvm_sequence create_seq_by_name(string seq_name); + uvm_object obj; + uvm_factory factory; + uvm_sequence seq; + + factory = uvm_factory::get(); + obj = factory.create_object_by_name(seq_name, "", seq_name); + if (obj == null) begin + // print factory overrides to help debug + factory.print(1); + `uvm_fatal($sformatf("%m"), $sformatf("could not create %0s seq", seq_name)) + end + if (!$cast(seq, obj)) begin + `uvm_fatal($sformatf("%m"), $sformatf("cast failed - %0s is not a uvm_sequence", seq_name)) + end + return seq; + endfunction +`endif + + // Returns the hierarchical path to the interface / module N levels up. + // + // Meant to be invoked inside a module or interface. + // hier: String input of the interface / module, typically $sformatf("%m"). + // n_levels_up: Integer number of levels up the hierarchy to omit. + // Example: if (hier = tb.dut.foo.bar, n_levels_up = 2), then return tb.dut + function automatic string get_parent_hier(string hier, int n_levels_up = 1); + int idx; + int level; + if (n_levels_up <= 0) return hier; + for (idx = hier.len() - 1; idx >= 0; idx--) begin + if (hier[idx] == ".") level++; + if (level == n_levels_up) break; + end + return (hier.substr(0, idx - 1)); + endfunction + + // Periodically check for the existence of a magic file (dv.stop). Exit if it exists. This + // provides a mechanism to gracefully kill a simulation without direct access to the process. + task automatic poll_for_stop(uint interval_ns = 10_000, string filename = "dv.stop"); + fork + while (1) begin + #(interval_ns * 1ns); + if (!$system($sformatf("test -f %0s", filename))) begin + $system($sformatf("rm %0s", filename)); + `dv_fatal($sformatf("Found %0s file. Exiting!", filename), "poll_for_stop") + end + end + join_none + endtask : poll_for_stop + + // Extracts the address and size of a const symbol in a SW test (supplied as an ELF file). + // + // Used by a testbench to modify the given symbol in an executable (elf) generated for an embedded + // CPU within the DUT. This function only returns the extracted address and size of the symbol + // using the readelf utility. Readelf comes with binutils, a package typically available on linux + // machines. If not available, the assumption is, it can be relatively easily installed. + // The actual job of writing the new value into the symbol is handled externally (often via a + // backdoor mechanism to write the memory). + // Return 1 on success and 0 on failure. + function automatic bit sw_symbol_get_addr_size(input string elf_file, + input string symbol, + input bit does_not_exist_ok, + output longint unsigned addr, + output longint unsigned size); + + string escaped_symbol = ""; + string symbol_for_filename = ""; + + if (elf_file == "") `uvm_fatal($sformatf("%m"), "'elf_file' argument cannot be an empty string") + if (symbol == "") `uvm_fatal($sformatf("%m"), "'symbol' argument cannot be an empty string") + + // If the symbol has special characters, such as '$', escape it for the cmd below, but when + // creating the file, omit the special characters entirely. + foreach (symbol[i]) begin + if (symbol[i] == "$") begin + escaped_symbol = {escaped_symbol, "\\", symbol[i]}; + end else begin + escaped_symbol = {escaped_symbol, symbol[i]}; + symbol_for_filename = {symbol_for_filename, symbol[i]}; + end + end + + begin + int ret; + string line; + int out_file_d = 0; + string out_file = $sformatf("%0s.dat", symbol_for_filename); + string cmd = $sformatf( + // use `--wide` to avoid truncating the output, in case of long symbol name + // `\s%0s$` ensures we are looking for an exact match, with no pre- or postfixes. + "/usr/bin/readelf -s --wide %0s | grep \"\\s%0s$\" | awk \'{print $2\" \"$3}\' > %0s", + elf_file, escaped_symbol, out_file); + + // TODO #3838: shell pipes are bad 'mkay? + ret = $system(cmd); + `DV_CHECK_EQ_FATAL(ret, 0, $sformatf("Command \"%0s\" failed with exit code %0d", cmd, ret), + $sformatf("%m")) + + out_file_d = $fopen(out_file, "r"); + `DV_CHECK_FATAL(out_file_d, $sformatf("Failed to open \"%0s\"", out_file), $sformatf("%m")) + + ret = $fgets(line, out_file_d); + + // If the symbol did not exist in the elf (empty file), and we are ok with that, then return. + if (!ret && does_not_exist_ok) return 0; + + `DV_CHECK_FATAL(ret, $sformatf("Failed to read line from \"%0s\"", out_file), $sformatf("%m")) + + // The first line should have the addr in hex followed by its size as integer. + ret = $sscanf(line, "%h %d", addr, size); + `DV_CHECK_EQ_FATAL(ret, 2, $sformatf("Failed to extract {addr size} from line \"%0s\"", line), + $sformatf("%m")) + + // Attempt to read the next line should be met with EOF. + void'($fgets(line, out_file_d)); + ret = $feof(out_file_d); + `DV_CHECK_FATAL(ret, $sformatf("EOF expected to be reached for \"%0s\"", out_file), + $sformatf("%m")) + $fclose(out_file_d); + + ret = $system($sformatf("rm -rf %0s", out_file)); + `DV_CHECK_EQ_FATAL(ret, 0, $sformatf("Failed to delete \"%0s\"", out_file), $sformatf("%m")) + return 1; + end + endfunction + + // Reads VMEM file contents into a queue of data. + // + // TODO: Add support for non-contiguous memory. + // TODO: Add support for ECC bits. + // TODO: Add support for non-BUS_DW sized VMEM data. + // vmem_file: Path to VMEM image, compatible with $readmemh mathod. + // vmem_data: A queue of BUS_DW sized data returned to the caller. + function automatic void read_vmem(input string vmem_file, + output logic [bus_params_pkg::BUS_DW-1:0] vmem_data[$]); + int fd; + uvm_reg_addr_t last_addr; + string text, msg = "\n", lines[$]; + + fd = $fopen(vmem_file, "r"); + `DV_CHECK_FATAL(fd, $sformatf("Failed to open \"%0s\"", vmem_file), $sformatf("%m")) + while (!$feof(fd)) begin + string line; + void'($fgets(line, fd)); + line = str_utils_pkg::str_strip(line); + if (line == "") continue; + text = {text, line, "\n"}; + end + $fclose(fd); + `DV_CHECK_STRNE_FATAL(text, "", , $sformatf("%m")) + + // Remove all block and single comments. + text = str_utils_pkg::str_remove_sections(.s(text), .start_delim("/*"), .end_delim("*/")); + text = str_utils_pkg::str_remove_sections(.s(text), .start_delim("//"), .end_delim("\n"), + .remove_end_delim(0)); + + vmem_data.delete(); + str_utils_pkg::str_split(text, lines, "\n"); + foreach (lines[i]) begin + string tokens[$]; + uvm_reg_addr_t addr; + + // Split the line by space. The first item must be the address that starts with '@'. + str_utils_pkg::str_split(lines[i], tokens, " "); + `DV_CHECK_FATAL(tokens.size() >= 2, + $sformatf("Line \"%s\" in VMEM file %s appears to be malformed", + lines[i], vmem_file), $sformatf("%m")) + if (!str_utils_pkg::str_starts_with(tokens[0], "@")) begin + `uvm_fatal($sformatf("%m"), $sformatf({"The first word \"%s\" on line \"%s\" in the VMEM", + " file %s does not appear to be a valid address"}, + tokens[0], lines[i], vmem_file)) + end + tokens[0] = tokens[0].substr(1, tokens[0].len() - 1); + `DV_CHECK_FATAL(tokens[0].len() <= bus_params_pkg::BUS_AW / 8 * 2, + $sformatf("Address width > %0d bytes is not supported: 0x%0s", + bus_params_pkg::BUS_AW / 8, tokens[0]), $sformatf("%m")) + addr = tokens[0].atohex(); + tokens = tokens[1:$]; + if (i > 0) begin + `DV_CHECK_FATAL(addr == last_addr, + $sformatf("Non-contiguous data unsupported - last_addr: 0x%0h, addr: 0x%0h", + last_addr, addr), $sformatf("%m")) + end + foreach (tokens[i]) begin + logic [bus_params_pkg::BUS_DW-1:0] data; + `DV_CHECK_FATAL(tokens[i].len() <= bus_params_pkg::BUS_DW / 8 * 2, + $sformatf("Data width > %0d bytes is not supported: 0x%0s", + bus_params_pkg::BUS_DW / 8, tokens[i]), $sformatf("%m")) + data = tokens[i].atohex(); + msg = {msg, $sformatf("[0x%0h] = 0x%0h\n", addr + i, data)}; + vmem_data.push_back(data); + end + last_addr = addr + tokens.size(); + end + `uvm_info($sformatf("%m"), $sformatf("Contents of VMEM file %s:%s", vmem_file, msg), UVM_HIGH) + endfunction + + // sources +`ifdef UVM + `include "dv_report_catcher.sv" + `include "dv_report_server.sv" +`endif + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/mem_model/README.md b/hw/vendor/lowrisc_ip/dv/sv/mem_model/README.md new file mode 100644 index 0000000..68d0f6f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/mem_model/README.md @@ -0,0 +1,27 @@ +# Memory Model + +The memory model UVC models a memory device which any host interface can read +from or write to. It is implemented as a `uvm_object`, and instantiates an +associative array of bytes `system_memory`. This class is parameterized by both +the address width and the data width, and creates two `typedefs` to represent +both, `mem_addr_t` and `mem_data_t`. +The `mem_model` class has four main functions, which are detailed below. + +### `read_byte(mem_addr_t addr)` +This function looks up the byte of data corresponding to the memory address +passed in, and returns it. If the address does not exist in `system_memory`, it +will randomize the returned data and throw a `UVM_ERROR`. + +### `write_byte(mem_addr_t addr, bit [7:0] data)` +This function simply assigns the given data to the specified memory address +location in `system_memory`. + +### `write(input mem_addr_t addr, mem_data_t data)` +This function writes a full memory word of width `mem_data_t` to the specified +address, breaking it down into a series of back-to-back calls to `write_byte()` +to correctly byte-address the memory. + +### `read(mem_addr_t addr)` +This function reads a full memory word of width `mem_data_t` from the specified +address, breaking it down into a series of back-to-back calls to `read_byte()` +to correctly byte-address the memory. diff --git a/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model.core b/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model.core new file mode 100644 index 0000000..a7abbf3 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model.core @@ -0,0 +1,21 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:mem_model" +description: "DV Memory Model" + +filesets: + files_dv: + depend: + - lowrisc:opentitan:bus_params_pkg + - lowrisc:dv:dv_macros + files: + - mem_model_pkg.sv + - mem_model.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model.sv b/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model.sv new file mode 100644 index 0000000..f4579b8 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model.sv @@ -0,0 +1,99 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class mem_model #(int AddrWidth = bus_params_pkg::BUS_AW, + int DataWidth = bus_params_pkg::BUS_DW) extends uvm_object; + + localparam int MaskWidth = DataWidth / 8; + + typedef logic [AddrWidth-1:0] mem_addr_t; + typedef logic [DataWidth-1:0] mem_data_t; + typedef logic [MaskWidth-1:0] mem_mask_t; + + logic [7:0] system_memory[mem_addr_t]; + + `uvm_object_param_utils(mem_model#(AddrWidth, DataWidth)) + + `uvm_object_new + + function void init(); + system_memory.delete(); + endfunction + + function int get_written_bytes(); + return system_memory.size(); + endfunction + + function bit [7:0] read_byte(mem_addr_t addr); + bit [7:0] data; + if (addr_exists(addr)) begin + data = system_memory[addr]; + `uvm_info(`gfn, $sformatf("Read Mem : Addr[0x%0h], Data[0x%0h]", addr, data), UVM_HIGH) + end else begin + `DV_CHECK_STD_RANDOMIZE_FATAL(data) + `uvm_error(`gfn, $sformatf("read from uninitialized addr 0x%0h", addr)) + end + return data; + endfunction + + function void write_byte(mem_addr_t addr, logic [7:0] data); + `uvm_info(`gfn, $sformatf("Write Mem : Addr[0x%0h], Data[0x%0h]", addr, data), UVM_HIGH) + system_memory[addr] = data; + endfunction + + function void compare_byte(mem_addr_t addr, logic [7:0] act_data); + `uvm_info(`gfn, $sformatf("Compare Mem : Addr[0x%0h], Act Data[0x%0h], Exp Data[0x%0h]", + addr, act_data, system_memory[addr]), UVM_HIGH) + `DV_CHECK_CASE_EQ(act_data, system_memory[addr], + $sformatf("addr 0x%0h read out mismatch", addr)) + endfunction + + function void write(input mem_addr_t addr, mem_data_t data, mem_mask_t mask = '1); + bit [7:0] byte_data; + for (int i = 0; i < DataWidth / 8; i++) begin + if (mask[0]) begin + byte_data = data[7:0]; + write_byte(addr + i, byte_data); + end + data = data >> 8; + mask = mask >> 1; + end + endfunction + + function mem_data_t read(mem_addr_t addr, mem_mask_t mask = '1); + mem_data_t data; + for (int i = DataWidth / 8 - 1; i >= 0; i--) begin + data = data << 8; + if (mask[MaskWidth - 1]) data[7:0] = read_byte(addr + i); + else data[7:0] = 0; + mask = mask << 1; + end + return data; + endfunction + + function void compare(mem_addr_t addr, mem_data_t act_data, mem_mask_t mask = '1, + bit compare_exist_addr_only = 1); + bit [7:0] byte_data; + for (int i = 0; i < DataWidth / 8; i++) begin + mem_addr_t byte_addr = addr + i; + byte_data = act_data[7:0]; + if (mask[0]) begin + if (addr_exists(byte_addr)) begin + compare_byte(byte_addr, byte_data); + end else if (!compare_exist_addr_only) begin + `uvm_error(`gfn, $sformatf("address 0x%0x not exists", byte_addr)) + end + end else begin + // Nothing to do here: since this byte wasn't selected by the mask, there are no + // requirements about what data came back. + end + act_data = act_data>> 8; + mask = mask >> 1; + end + endfunction + + function bit addr_exists(mem_addr_t addr); + return system_memory.exists(addr); + endfunction +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model_pkg.sv new file mode 100644 index 0000000..975e3bd --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/mem_model/mem_model_pkg.sv @@ -0,0 +1,13 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package mem_model_pkg; + + import uvm_pkg::*; + + `include "uvm_macros.svh" + `include "dv_macros.svh" + `include "mem_model.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/str_utils/README.md b/hw/vendor/lowrisc_ip/dv/sv/str_utils/README.md new file mode 100644 index 0000000..b13afd1 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/str_utils/README.md @@ -0,0 +1,6 @@ +# str_utils_pkg + +This package provides some basic string and path manipulation utility functions that +can be used across the project. It can be imported in non-UVM testbenches as +well. Please see the package for the list of available functions and their +descriptions. diff --git a/hw/vendor/lowrisc_ip/dv/sv/str_utils/str_utils.core b/hw/vendor/lowrisc_ip/dv/sv/str_utils/str_utils.core new file mode 100644 index 0000000..14eebda --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/str_utils/str_utils.core @@ -0,0 +1,19 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:str_utils" +description: "String manipulation utilities" + +filesets: + files_dv: + depend: + - lowrisc:dv:dv_macros + files: + - str_utils_pkg.sv + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/str_utils/str_utils_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/str_utils/str_utils_pkg.sv new file mode 100644 index 0000000..5bd5ac9 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/str_utils/str_utils_pkg.sv @@ -0,0 +1,236 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package str_utils_pkg; + `include "dv_macros.svh" + + string msg_id = "str_utils_pkg"; + + // Returns 1 if string 's' has substring 'sub' within the given index range. 0 Otherwise. + function automatic bit str_has_substr(string s, string sub, int range_lo = 0, int range_hi = -1); + if (range_hi < 0 || range_hi >= s.len()) range_hi = s.len() - 1; + for (int i = range_lo; i <= (range_hi - sub.len() + 1); i++) begin + if (s.substr(i, i + sub.len() - 1) == sub) begin + return 1; + end + end + return 0; + endfunction : str_has_substr + + // Returns 1 when string 's' starts with substring 'sub'. + function automatic bit str_starts_with(string s, string sub); + return s.substr(0, sub.len() - 1) == sub; + endfunction + + // Returns 1 when string 's' ends with substring 'sub'. + function automatic bit str_ends_with(string s, string sub); + return s.substr(s.len() - sub.len(), s.len() - 1) == sub; + endfunction + + // Returns the index of first occurrence of string 'sub' within string 's''s given index range. + // Returns -1 otherwise. + function automatic int str_find(string s, string sub, int range_lo = 0, int range_hi = -1); + if (range_hi < 0 || range_hi >= s.len()) range_hi = s.len() - 1; + for (int i = range_lo; i <= (range_hi - sub.len() + 1); i++) begin + if (s.substr(i, i + sub.len() - 1) == sub) begin + return i; + end + end + return -1; + endfunction : str_find + + // Returns the index of last occurrence of string 'sub' within string 's''s given index range. + // Returns -1 otherwise. + function automatic int str_rfind(string s, string sub, int range_lo = 0, int range_hi = -1); + if (range_hi < 0 || range_hi >= s.len()) range_hi = s.len() - 1; + for (int i = (range_hi - sub.len() + 1); i >= range_lo; i--) begin + if (s.substr(i, i + sub.len() - 1) == sub) begin + return i; + end + end + return -1; + endfunction : str_rfind + + // Find the first match string 'sub' in 's' and replace it with 'new_sub'. + // TODO: Add support for global replacement. + function automatic string str_replace(string s, string sub, string new_sub); + string str_before_sub, str_after_sub; + int lo_idx = str_find(s, sub); + + // check sub string exists + `DV_CHECK_NE_FATAL(lo_idx, -1, $sformatf("sub string %s doesn't exist in %s", sub, s), msg_id) + + // the new_str contains 3 portions {str_before_sub, new_sub, str_after_sub} + if (lo_idx > 0) str_before_sub = s.substr(0, lo_idx - 1); + if (lo_idx + sub.len() < s.len()) str_after_sub = s.substr(lo_idx + sub.len(), s.len() - 1); + + return {str_before_sub, new_sub, str_after_sub}; + endfunction : str_replace + + // Strips a given set of characters in string 's'. + // + // The set of characters to strip is provided as a string. If not set, all whitespace characters + // are stripped by default. Stripping is done at both ends, unless the user turns off the + // stripping from one of the ends. + function automatic string str_strip(string s, + string chars = " \t\n", + bit lstrip = 1'b1, + bit rstrip = 1'b1); + byte chars_q[$]; + if (chars == "") return s; + foreach (chars[i]) chars_q.push_back(chars.getc(i)); + + if (lstrip) begin + int i = 0; + while (s.getc(i) inside {chars_q}) i++; + s = s.substr(i, s.len() - 1); + end + + if (rstrip) begin + int i = s.len() - 1; + while (s.getc(i) inside {chars_q}) i--; + s = s.substr(0, i); + end + return s; + endfunction : str_strip + + // Splits the input `string` on the given single-character delimiter `delim`. + // + // The split tokens are pushed into the `result` queue. The whitespaces on each split token are + // stripped by default, which can be turned off. + // TODO: allow arbitrary length delimiter. + function automatic void str_split(input string s, + output string result[$], + input byte delim = " ", + input bit strip_whitespaces = 1'b1); + string sub; + bit in_quotes; + result = {}; + foreach (s[i]) begin + if (s[i] == "\"") begin + in_quotes = !in_quotes; + end + if ((s.getc(i) == delim) && !in_quotes) begin + if (strip_whitespaces) sub = str_strip(sub); + if (sub != "") result.push_back(sub); + sub = ""; + end else begin + sub = {sub, s[i]}; + end + if (i == s.len() - 1) begin + if (strip_whitespaces) sub = str_strip(sub); + if (sub != "") result.push_back(sub); + end + end + endfunction : str_split + + // Returns a string concatenated from the provided queue of strings 's'. + // + // The concatenation is performed using the 'delim' arg as the delimiter. + function automatic string str_join(string s[$], string delim = " "); + string str; + foreach (s[i]) begin + str = {str, s[i], delim}; + end + if (str != "") begin + str = str.substr(0, str.len() - delim.len() - 1); + end + return str; + endfunction : str_join + + // Cuts sections (such as comments) from string s starting and ending with provided substrings. + // + // start_delim: substring representing the start of section to be removed (e.g. "//", "/*"). + // end_delim: substring representing the end of the section to be removed (e.g. "\n", "*/"). + // remove_start_delim: include the start_delim substring in the removal. + // remove_end_delim: include the end_delim substring in the removal. + function automatic string str_remove_sections(string s, + string start_delim, + string end_delim, + bit remove_start_delim = 1, + bit remove_end_delim = 1); + int start_idx, end_idx; + start_idx = str_utils_pkg::str_find(s, start_delim); + while (start_idx != -1) begin + int rm_start_idx, rm_end_idx; + rm_start_idx = remove_start_delim ? start_idx : start_idx + start_delim.len() - 1; + end_idx = str_utils_pkg::str_find(s, end_delim, .range_lo(start_idx + start_delim.len())); + if (end_idx == -1) break; + rm_end_idx = remove_end_delim ? end_idx + end_delim.len() - 1 : end_idx - 1; + s = str_utils_pkg::str_replace(s, s.substr(rm_start_idx, rm_end_idx), ""); + start_idx = str_utils_pkg::str_find(s, start_delim, .range_lo(end_idx + end_delim.len())); + end + return s; + endfunction + + // Converts a string to an array of bytes. + function automatic void str_to_bytes(string s, output byte bytes[]); + bytes = new[s.len()]; + foreach (bytes[i]) begin + bytes[i] = s.getc(i); + end + endfunction : str_to_bytes + + // Converts an array of bytes to a string. + function automatic string bytes_to_str(byte bytes[]); + string s; + foreach (bytes[i]) begin + s = {s, string'(bytes[i])}; + end + return s; + endfunction + + /************************/ + /* File path functions. */ + /************************/ + + // Returns the dirname of the file. + // + // Examples: + // path/to/foo.bar => path/to + // path/to/foo/bar => path/to/foo + // path/to/foo/bar/ => path/to/foo + // path/to/foo/bar/. => path/to/foo/bar + // / => / + function automatic string str_path_dirname(string filename); + int idx; + string dirname; + + if (filename == "/") return filename; + filename = str_strip(.s(filename), .chars("/"), .lstrip(1'b0)); + idx = str_rfind(.s(filename), .sub("/")); + if (idx == -1) idx = filename.len(); + if (idx == 0) idx++; + dirname = filename.substr(0, idx - 1); + return dirname; + endfunction : str_path_dirname + + // Returns the basename of the file. + // + // Optionally, it takes a bit flag to drop the extension from the basename if desired. + // Examples: + // path/to/foo.bar => (foo.bar, foo) + // path/to/foo/bar => (bar, bar) + // path/to/foo/bar/ => (bar, bar) + // path/to/foo/bar/. => (., .) + // / => (/, /) + function automatic string str_path_basename(string filename, bit drop_extn = 1'b0); + int idx; + string basename; + + if (filename == "/") return filename; + filename = str_strip(.s(filename), .chars("/"), .lstrip(1'b0)); + idx = str_rfind(.s(filename), .sub("/")); + basename = filename.substr(idx + 1, filename.len() - 1); + + if (basename == ".") return basename; + if (drop_extn) begin + idx = str_find(.s(basename), .sub(".")); + if (idx == -1) idx = basename.len(); + basename = basename.substr(0, idx - 1); + end + return basename; + endfunction : str_path_basename + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/README.md b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/README.md new file mode 100644 index 0000000..844d014 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/README.md @@ -0,0 +1,3 @@ +# TileLink UVM Agent + +**TODO** diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_device_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_device_seq.sv new file mode 100644 index 0000000..1c8e7e2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_device_seq.sv @@ -0,0 +1,187 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A forever running sequence that responds to a TL request. +// +// This sequence supports in-order and out-of-order responses. It maintains a +// memory to record the write requests, so that when the same address is read, +// the originally written data is returned. This sequence runs forever, i.e. +// it needs to be forked off as a separate thread. It can be stopped gracefully +// by invoking the seq_stop() method. +class tl_device_seq #(type REQ = tl_seq_item, int unsigned AddrWidth = 32) extends dv_base_seq #( + .REQ (REQ), + .CFG_T (tl_agent_cfg), + .SEQUENCER_T(tl_sequencer)); + + // if enabled, rsp will be aborted if it's not accepted after given valid length + rand bit rsp_abort_after_d_valid_len; + // chance to abort rsp + int rsp_abort_pct = 0; + + int min_rsp_delay = 0; + int max_rsp_delay = 10; + mem_model_pkg::mem_model#(.AddrWidth(AddrWidth)) mem; + REQ req_q[$]; + bit out_of_order_rsp = 0; + + // Stops running this sequence. + protected bit stop; + + // chance to set d_error + int d_error_pct = 0; + + `uvm_object_param_utils(tl_device_seq #(REQ, AddrWidth)) + `uvm_object_new + + constraint en_req_abort_after_d_valid_len_c { + rsp_abort_after_d_valid_len dist { + 1 :/ rsp_abort_pct, + 0 :/ 100 - rsp_abort_pct + }; + } + + virtual task body(); + fork + begin: isolation_thread + fork + collect_request_thread(); + send_response_thread(); + join_any + // Wait for all requests to be serviced. + wait (req_q.size() == 0); + disable fork; + end + join + + // Clear the stop flag. It must be set (because collect_request_thread and send_response_thread + // don't stop otherwise). Clear it to allow a virtual sequence to start the same sequence object + // again if it wishes. + stop = 0; + endtask + + // A blocking task that retrieves a request from the TLM fifo, unless the seq is stopped. + // + // req: A req item retrieved from the TLM fifo and returned back to the caller. + protected virtual task get_a_chan_req(output REQ req); + fork + begin: isolation_thread + fork + begin + tl_seq_item item; + p_sequencer.a_chan_req_fifo.get(item); + `downcast(req, item) + end + wait (stop); + join_any + // Allow the rest of the statements in the same time-step to finish executing in the "other" + // thread, before disabling the fork. + #0; + disable fork; + end + join + endtask + + // A perpetually running task that collects and enqueues the incoming TL requests. + // + // The task finishes when the sequence is stopped, which is done be invoking the seq_stop() + // method. + protected virtual task collect_request_thread(); + int req_cnt; + forever begin + REQ req; + get_a_chan_req(req); + if (req != null) begin + req_q.push_back(req); + `uvm_info(`gfn, $sformatf("Received req[%0d] : %0s", + req_cnt, req.convert2string()), UVM_HIGH) + req_cnt++; + end + if (stop) break; + end + endtask + + // A perpetually running task that pops requests from the collected request queue and sends + // randomized responses. + protected virtual task send_response_thread(); + int rsp_cnt; + forever begin + REQ req, rsp; + wait(req_q.size > 0); + if (out_of_order_rsp) req_q.shuffle(); + + // peek at the front of the queue, but don't pop it: we want to see it again if the + // rsp_completed flag doesn't get set. + req = req_q[0]; + `downcast(rsp, req.clone()) + + randomize_rsp(rsp); + post_randomize_rsp(rsp); + update_mem(rsp); + start_item(rsp); + finish_item(rsp); + get_response(rsp); + + // Remove from req_q if response is completed. + if (rsp.rsp_completed) begin + void'(req_q.pop_front()); + `uvm_info(`gfn, $sformatf("Sent rsp[%0d] : %0s, req: %0s", + rsp_cnt, rsp.convert2string(), req.convert2string()), UVM_HIGH) + rsp_cnt++; + end + end + endtask + + // User-overridable function to randomize the response. The response is already cloned from the + // request, so the request (a_channel) information is already present. + virtual function void randomize_rsp(REQ rsp); + rsp.disable_a_chan_randomization(); + if (d_error_pct > 0) rsp.no_d_error_c.constraint_mode(0); + if (!(rsp.randomize() with + {rsp.d_valid_delay inside {[min_rsp_delay : max_rsp_delay]}; + if (rsp.a_opcode == tlul_pkg::Get) { + rsp.d_opcode == tlul_pkg::AccessAckData; + } else { + rsp.d_opcode == tlul_pkg::AccessAck; + } + rsp.d_size == rsp.a_size; + rsp.d_source == rsp.a_source; + d_error dist {0 :/ (100 - d_error_pct), 1 :/ d_error_pct}; + })) begin + `uvm_fatal(`gfn, "Cannot randomize rsp") + end + endfunction + + // callback after randomize seq, extended seq can override it to handle some non-rand variables + virtual function void post_randomize_rsp(REQ rsp); + `DV_CHECK_MEMBER_RANDOMIZE_FATAL(rsp_abort_after_d_valid_len) + rsp.rsp_abort_after_d_valid_len = rsp_abort_after_d_valid_len; + endfunction + + virtual function void update_mem(REQ rsp); + if (mem != null) begin + if (rsp.a_opcode inside {PutFullData, PutPartialData}) begin + bit [tl_agent_pkg::DataWidth-1:0] data; + data = rsp.a_data; + for (int i = 0; i < $bits(rsp.a_mask); i++) begin + if (rsp.a_mask[i]) begin + mem.write_byte(rsp.a_addr + i, data[7:0]); + end + data = data >> 8; + end + end else begin + for (int i = 2**rsp.a_size - 1; i >= 0; i--) begin + rsp.d_data = rsp.d_data << 8; + rsp.d_data[7:0] = mem.read_byte(rsp.a_addr+i); + end + end + end + endfunction + + // Stop running this seq and wait until it has finished gracefully. + virtual task seq_stop(); + stop = 1'b1; + wait_for_sequence_state(UVM_FINISHED); + endtask + +endclass : tl_device_seq diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_base_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_base_seq.sv new file mode 100644 index 0000000..20a9c60 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_base_seq.sv @@ -0,0 +1,86 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Default base class sequence that overrides base UVM functions. +// +// This sequence is not meant to be run standalone by itself (fatal error will be thrown if you +// do). It is instead meant to provide base utilities to construct different flavors of host +// sequences on top of it. These are as follows: +// +// 1. Provide late randomization for a_source +// a_source value needs to be randomized such that it does not equal to an in-flight request that +// has not yet returned. This means at the time of randomization, the DUT must already be ready to +// consume the req and apply it to the interface immediately. The tl_host_seq::randomize_req() +// performs exactly this function. However, it does not cater to the next bullet - driving TL +// transactions over the RAL model, which is done completely within the RAL layers. We need to +// ensure that the a_source value is randomized right before the DUT is ready to consume it, so we +// override the finish_item() to do so instead. +// +// 2. Serve as the parent_sequence for the RAL adapter +// The RAL map uses a dummy sequence to synchronize with the driver, after creating the bus req +// using the adapter. It does not provide any ability to perform "late randomization" of +// request. This causes our a_source constraints to be violated. Since we need this to ensure that +// the a_source is set taking into account the most up-to-date DUT state, we supply this sequence +// as the adapter's parent_sequence instead (see tl_reg_adapter for more details). The UVM map then +// uses this sequence instead of the dummy one to invoke start_item(), finish_item() and +// get_response() instead. So, instead of doing the late randomization in randomize_req(), we do it +// in finish_item() instead. +// +// 3. Provide ability to override and "fix" the a_source to a particular value. +// This is done to satisfy the use case where the TL host sends ALL requests with the same source +// ID. +class tl_host_base_seq #(type REQ_T = tl_seq_item) extends dv_base_seq #( + .REQ (REQ_T), + .CFG_T (tl_agent_cfg), + .SEQUENCER_T(tl_sequencer)); + + // The knob below allows the user to fix a_source in the reqs from a higher level sequence. It is + // the responsibility of the higher level sequence to ensure that the overridden_a_source_val is + // not illegal. To avoid painful debug, refrain from changing override_a_source_val while the + // sequence is still running. + bit override_a_source_val = 0; + bit [SourceWidth-1:0] overridden_a_source_val; + + `uvm_object_param_utils_begin(tl_host_base_seq #(REQ_T)) + `uvm_field_int(override_a_source_val, UVM_DEFAULT | UVM_NOCOMPARE | UVM_NOPACK) + `uvm_field_int(overridden_a_source_val, UVM_DEFAULT | UVM_NOCOMPARE | UVM_NOPACK) + `uvm_object_utils_end + + `uvm_object_new + + virtual function void get_cfg(uvm_sequence_item item); + if (p_sequencer != null) begin + cfg = p_sequencer.cfg; + end else begin + tl_sequencer seqr; + `downcast(seqr, item.get_sequencer()) + cfg = seqr.cfg; + end + endfunction + + // Overrides the base class implementation to late randomize / set a_source. + virtual task finish_item(uvm_sequence_item item, int set_priority = -1); + REQ req; + + `downcast(req, item) + if (cfg == null) get_cfg(req); + if (override_a_source_val) begin + req.a_source = overridden_a_source_val; + cfg.add_to_a_source_pend_q(req.a_source); + end else begin + cfg.randomize_a_source_in_req(req); + end + super.finish_item(item, set_priority); + endtask + + // Called after the rsp is received. + virtual task get_base_response(output uvm_sequence_item response, input int transaction_id = -1); + REQ rsp; + super.get_base_response(response, transaction_id); + `downcast(rsp, response) + if (cfg == null) get_cfg(rsp); + cfg.remove_from_a_source_pend_q(rsp.d_source); + endtask + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_custom_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_custom_seq.sv new file mode 100644 index 0000000..f5ffa3f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_custom_seq.sv @@ -0,0 +1,20 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Disable TL protocol related constraint on a_chan to create a fully customized tl_item for error +// cases +class tl_host_custom_seq #(type REQ_T = tl_seq_item) extends tl_host_single_seq #(REQ_T); + + `uvm_object_param_utils(tl_host_custom_seq #(REQ_T)) + `uvm_object_new + + virtual function void randomize_req(REQ req, int idx); + control_addr_alignment = 1; + control_rand_size = 1; + control_rand_opcode = 1; + req.disable_a_chan_protocol_constraint(); + super.randomize_req(req, idx); + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_protocol_err_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_protocol_err_seq.sv new file mode 100644 index 0000000..919844a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_protocol_err_seq.sv @@ -0,0 +1,18 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// This seq will send an item that triggers d_error due to protocol violation +class tl_host_protocol_err_seq #(type REQ_T = tl_seq_item) extends tl_host_single_seq #(REQ_T); + + `uvm_object_param_utils(tl_host_protocol_err_seq #(REQ_T)) + `uvm_object_new + + // forever randomize the item until we find one that violates the TL protocol + virtual function void randomize_req(REQ req, int idx); + req.a_valid_delay = $urandom_range(min_req_delay, max_req_delay); + req.a_valid_delay.rand_mode(0); + req.randomize_a_chan_with_protocol_error(); + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_seq.sv new file mode 100644 index 0000000..1e9a7c7 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_seq.sv @@ -0,0 +1,104 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// TL host sequence supports multiple outstanding requests +// It generates 'req_cnt' number of completely random requests +class tl_host_seq #(type REQ_T = tl_seq_item) extends tl_host_base_seq #(REQ_T); + + rand int unsigned req_cnt; + // if enabled, req will be aborted if it's not accepted after given valid length + rand bit req_abort_after_a_valid_len; + // chance to abort req + int req_abort_pct = 0; + + REQ pending_req[$]; + int min_req_delay = 0; + int max_req_delay = 10; + + // The number of requests that have been started so far in body(). Even if there is contention for + // the sequencer, this will only be incremented when a sequence item gets granted. + int unsigned reqs_started = 0; + + `uvm_object_param_utils(tl_host_seq #(REQ_T)) + `uvm_object_new + + constraint req_abort_after_a_valid_len_c { + req_abort_after_a_valid_len dist { + 1 :/ req_abort_pct, + 0 :/ 100 - req_abort_pct + }; + } + + virtual task body(); + set_response_queue_depth(-1); + fork + begin : wait_response_thread + for (int i = 0; i < req_cnt; i++) begin + REQ req; + bit found_req; + get_response(rsp); + `uvm_info(`gfn, $sformatf("Received rsp[%0d] : %0s", + i, rsp.convert2string()), UVM_HIGH) + // in case of out of order rsp, find req that has same source as rsp + foreach (pending_req[i]) begin + if (rsp.d_source == pending_req[i].a_source) begin + req = pending_req[i]; + pending_req.delete(i); + process_response(req, rsp); + found_req = 1; + break; + end + end // foreach + if (!found_req && !csr_utils_pkg::under_reset) begin + `uvm_error(`gfn, $sformatf("fail to find matching req for rsp[%0d]: %0s", + i, rsp.convert2string())) + end + end // for + end : wait_response_thread + begin : request_thread + `uvm_info(`gfn, $sformatf("Start sending %0d host requests", req_cnt), UVM_HIGH) + for (int i = 0; i < req_cnt; i++) begin + req = REQ::type_id::create("req"); + pre_start_item(req); + start_item(req); + reqs_started++; + randomize_req(req, i); + post_randomize_req(req, i); + pending_req.push_back(req); // in case of device same cycle response + finish_item(req); + `uvm_info(`gfn, $sformatf("Sent req[%0d] : %0s", + i, req.convert2string()), UVM_HIGH) + end + end : request_thread + join + `uvm_info(`gfn, $sformatf("Finished sending %0d host requests", req_cnt), UVM_HIGH) + endtask + + // Invoked after creating the req and before invoking start_item(req). Suitable for inserting + // delays before start_item(). Example: avoid running out of source IDs. + virtual task pre_start_item(REQ req); + endtask + + // Request randomization, override this function to do custom request generation. Invoked after + // start_item(). Not suitable for setting a_source, since that is handled in + // `tl_host_base_seq::finish_item()` instead, to facilitate late randomization when accesses are + // initiated from UVM RAL. + virtual function void randomize_req(REQ req, int idx); + if (!(req.randomize() with { + a_valid_delay inside {[min_req_delay:max_req_delay]};})) begin + `uvm_fatal(`gfn, "Cannot randomize req") + end + endfunction + + // callback after randomize seq, extened seq can override it to handle some non-rand variables + virtual function void post_randomize_req(REQ req, int idx); + `DV_CHECK_MEMBER_RANDOMIZE_FATAL(req_abort_after_a_valid_len) + req.req_abort_after_a_valid_len = req_abort_after_a_valid_len; + endfunction + + // A reserved function that can be extended to process response packet + virtual function void process_response(REQ req, REQ rsp); + endfunction + +endclass : tl_host_seq diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_single_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_single_seq.sv new file mode 100644 index 0000000..1bfa784 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_host_single_seq.sv @@ -0,0 +1,50 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Extend host seq to send single specific item constructed by the caller +class tl_host_single_seq #(type REQ_T = tl_seq_item) extends tl_host_seq #(REQ_T); + rand bit write; + rand bit [AddrWidth-1:0] addr; + rand bit [OpcodeWidth-1:0] opcode; + rand bit [SizeWidth-1:0] size; + rand bit [SourceWidth-1:0] source; + rand bit [MaskWidth-1:0] mask; + rand bit [DataWidth-1:0] data; + + // for most cases, upper seq just needs to provide addr[$:2], data, mask value, write. + // addr[1:0]/size/source/opcode can be randomized in tl_seq_item based on mask value + bit control_addr_alignment = 0; + bit control_rand_size = 0; + bit control_rand_source = 0; + bit control_rand_opcode = 0; + + `uvm_object_param_utils(tl_host_single_seq #(REQ_T)) + `uvm_object_new + + constraint req_cnt_eq_1_c { req_cnt == 1; } + + virtual function void randomize_req(REQ req, int idx); + if (!(req.randomize() with { + a_valid_delay inside {[min_req_delay:max_req_delay]}; + a_data == data; + a_mask == mask; + a_addr[AddrWidth-1:2] == addr[AddrWidth-1:2]; + control_addr_alignment -> a_addr[1:0] == addr[1:0]; + control_rand_size -> a_size == size; + control_rand_source -> a_source == source; + if (control_rand_opcode) { + a_opcode == opcode; + } else { + if (write) { + a_opcode inside {tlul_pkg::PutPartialData, tlul_pkg::PutFullData}; + } else { + a_opcode == tlul_pkg::Get; + } + } + })) begin + `uvm_fatal(`gfn, "Cannot randomize req") + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_seq_list.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_seq_list.sv new file mode 100644 index 0000000..cc99fbf --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/seq_lib/tl_seq_list.sv @@ -0,0 +1,10 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +`include "tl_host_base_seq.sv" +`include "tl_host_seq.sv" +`include "tl_host_single_seq.sv" +`include "tl_host_custom_seq.sv" +`include "tl_host_protocol_err_seq.sv" +`include "tl_device_seq.sv" diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent.core b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent.core new file mode 100644 index 0000000..c6e6caf --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent.core @@ -0,0 +1,40 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:tl_agent" +description: "TileLink Uncached Lite (TL-UL) DV UVM agent" + +filesets: + files_dv: + depend: + - lowrisc:tlul:headers:0.1 + - lowrisc:prim:secded + - lowrisc:dv:mem_model + - lowrisc:dv:dv_lib + - lowrisc:opentitan:bus_params_pkg + files: + - tl_if.sv + - tl_agent_pkg.sv + - tl_seq_item.sv: {is_include_file: true} + - tl_agent_cfg.sv: {is_include_file: true} + - tl_agent_cov.sv: {is_include_file: true} + - tl_device_driver.sv: {is_include_file: true} + - tl_host_driver.sv: {is_include_file: true} + - tl_sequencer.sv: {is_include_file: true} + - tl_monitor.sv: {is_include_file: true} + - tl_agent.sv: {is_include_file: true} + - tl_reg_adapter.sv: {is_include_file: true} + - seq_lib/tl_seq_list.sv: {is_include_file: true} + - seq_lib/tl_host_base_seq.sv: {is_include_file: true} + - seq_lib/tl_host_seq.sv: {is_include_file: true} + - seq_lib/tl_host_single_seq.sv: {is_include_file: true} + - seq_lib/tl_host_custom_seq.sv: {is_include_file: true} + - seq_lib/tl_host_protocol_err_seq.sv: {is_include_file: true} + - seq_lib/tl_device_seq.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent.sv new file mode 100644 index 0000000..b2a5fdc --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent.sv @@ -0,0 +1,41 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// --------------------------------------------- +// TileLink agent +// --------------------------------------------- +class tl_agent extends dv_base_agent#( + .CFG_T (tl_agent_cfg), + .DRIVER_T (tl_base_driver), + .HOST_DRIVER_T (tl_host_driver), + .DEVICE_DRIVER_T (tl_device_driver), + .SEQUENCER_T (tl_sequencer), + .MONITOR_T (tl_monitor), + .COV_T (tl_agent_cov) + ); + + `uvm_component_utils(tl_agent) + + `uvm_component_new + + function void build_phase(uvm_phase phase); + super.build_phase(phase); + // get tl_if handle if it is not already supplied + if (cfg.vif == null && !uvm_config_db#(virtual tl_if)::get(this, "", "vif", cfg.vif)) begin + `uvm_fatal(`gfn, "failed to get tl_if handle from uvm_config_db") + end + cfg.vif.if_mode = cfg.if_mode; + endfunction + + function void connect_phase(uvm_phase phase); + super.connect_phase(phase); + if (cfg.if_mode == dv_utils_pkg::Device) begin + if (cfg.device_can_rsp_on_same_cycle) begin + monitor.a_chan_same_cycle_rsp_port.connect(sequencer.a_chan_req_fifo.analysis_export); + end else begin + monitor.a_chan_port.connect(sequencer.a_chan_req_fifo.analysis_export); + end + end + endfunction +endclass : tl_agent diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_cfg.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_cfg.sv new file mode 100644 index 0000000..ef4630f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_cfg.sv @@ -0,0 +1,251 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// + +// --------------------------------------------- +// Configuration class for TileLink agent +// --------------------------------------------- +class tl_agent_cfg extends dv_base_agent_cfg; + + virtual tl_if vif; + // TileLink conformance level supported by this agent + // Right now only TL-UL is supported + tl_level_e tl_level = kTLUL; + + // Maximum number of outstanding transactions supported by the DUT. + // 0: Unlimited from the host perspective, might be back-pressured by the device + // 1: Only single transaction at a time + // n: Number of maximum outstanding requests + + // This is initialized to an arbitrary value. The DUT may actually support higher or lower than + // this number. Calculating exactly how many outstanding transactions the DUT supports is hard to + // determine. For most comportable IPs, it will likely be less than 16. The testbench attempts to + // pump the DUT with as many transactions as possible. The missing coverage in + // `tl_agent_cov::max_outstanding_cfg` will then indicate what the design actually supported. + // The designer must then confirm if that looks correct (in the coverage report), and then this + // value is updated accordingly in the DUT's test / env class. + // + // Note that this is a device constant. It should only be set within the scope of the test class' + // build_phase. Once set, it MUST NOT BE modified whatsoever. + int unsigned max_outstanding_req = 16; + + // If allow_a_valid_drop_wo_a_ready then the host can de-assert valid if there is no response from + // the device on the A channel. The other knobs control how this works. Each transaction has a + // "valid_len". If the host hasn't seen a ready after holding valid high for that many cycles, it + // will de-assert valid for a time before retrying. + // + // If use_seq_item_a_valid_len is true then valid_len will be read from the sequence item (field + // a_valid_len). If not, it will be picked uniformly between a_valid_len_min and a_valid_len_max. + bit allow_a_valid_drop_wo_a_ready = 1; + bit use_seq_item_a_valid_len; + int unsigned a_valid_len_min = 1; + int unsigned a_valid_len_max = 10; + + // Knobs controlling when we de-assert valid in device mode: see above for the host mode + // equivalent. + bit use_seq_item_d_valid_len; + bit allow_d_valid_drop_wo_d_ready; + int unsigned d_valid_len_min = 1; + int unsigned d_valid_len_max = 10; + + // TileLink channel valid delay (host mode) + bit use_seq_item_a_valid_delay; + int unsigned a_valid_delay_min = 0; + int unsigned a_valid_delay_max = 10; + + // TileLink channel ready delay (host mode) + int unsigned d_ready_delay_min = 0; + int unsigned d_ready_delay_max = 10; + + // TileLink channel ready delay (device mode) + int unsigned a_ready_delay_min = 0; + int unsigned a_ready_delay_max = 10; + + // TileLink channel ready delay (device mode) + bit use_seq_item_d_valid_delay; + int unsigned d_valid_delay_min = 0; + int unsigned d_valid_delay_max = 10; + + // TL spec requires host to set d_ready = 1 when a_valid = 1, but some design may not follow this + // rule. Details at #3208. Use below knob to control + bit host_can_stall_rsp_when_a_valid_high = 0; + + // knob for device to enable/disable same cycle response + bit device_can_rsp_on_same_cycle = 0; + + // A configuration flag for the monitor that configures whether it should synchronise concurrent A + // and D transactions or not. See note above the definition of channel_dir_port in tl_monitor.sv + // for details. + bit synchronise_ports = 1'b0; + + // for same cycle response, need to know when a_valid and other data/control are available, so + // that monitor can sample it, then send to sequence to get data for response in the same cycle + // 10 means 10% of TL clock period. This var is only use when device_can_rsp_on_same_cycle = 1 + time time_a_valid_avail_after_sample_edge = 1ns; + + // Sets the valid a_source width. The DUT may support fewer bits than the whole SourceWidth bits. + int unsigned valid_a_source_width = SourceWidth; + + // Maintains a queue of a_source values used in previous TL requests. + // + // The queue size maxes out at max_outstanding_req value, beyond which the a_source values can + // be recycled. The a_source value for a new request is randomized such that it does not match any + // in this queue. The new a_source is pushed into the back of the queue and the oldest one is + // popped from the front when the max size is reached. + // + // NOTE: If a tl_seq_item is being constructed for a new host request (whether in the TL + // sequences, adapter or elsewhere), it is mandatory to constrain the tl_seq_item::a_source to NOT + // match what already exists in the queue. Otherwise, it will violate the spec and the design will + // end up throwing assertion errors. It is recommended to use the `randomize_a_source_in_req()` + // function below to achieve this. + bit [SourceWidth-1:0] a_source_pend_q[$]; + + // Records the a_source value that was last released from the `a_source_pend_q` pool. + // We influence the randomization of a new req's a_source to reuse this 20% (also a knob) of the + // time. The initial value is randomized (see post_randomize()). + protected bit [SourceWidth-1:0] last_a_source_released; + + // Sets the randomization dist weight for a new a_source value to be constrained to the last + // a_source released. This only ATTEMPTS to set the a_source to the last_a_source_released value - + // it is not always guaranteed even at 100%, especially if the test does non-blocking accesses. + rand int unsigned use_last_a_source_released_pct = 20; + + constraint a_source_eq_last_a_source_released_pct_c { + use_last_a_source_released_pct <= 100; + use_last_a_source_released_pct dist { + [0:19] :/ 1, + [20:59] :/ 1, + [60:99] :/ 1, + 100 :/ 1 + }; + } + + // TLUL allows host to switch content if the item isn't accepted. RAL doesn't provide interface + // to control this. Use this knob to allow tl_reg_adapter to randomize req_abort_after_a_valid_len + // Note: below set the chance to abort after a_valid_len in tl_reg_adapter. if > 0, csr access may + // return UVM_NOT_OK when the item is aborted without accepted. + int unsigned csr_access_abort_pct_in_adapter = 0; + + // Indicate whether to check TLUL errors. + // Added to allow some TLUL checks to be ignored on certain scenarios. + bit check_tl_errs = 1'b1; + + // Invalidate drive option + // Setting these to '1', make driver send 'x' during invalidate cycle. + // Setting these to '0', make driver send 'random value' during invalidate cycle. + rand bit invalidate_a_x; + rand bit invalidate_d_x; + + constraint invalidate_a_channel_op_c { + invalidate_a_x dist { 1 := 7, 0 := 3}; + } + constraint invalidate_d_channel_op_c { + invalidate_d_x dist { 1 := 7, 0 := 3}; + } + + + `uvm_object_utils_begin(tl_agent_cfg) + `uvm_field_int(max_outstanding_req, UVM_DEFAULT) + `uvm_field_enum(tl_level_e, tl_level, UVM_DEFAULT) + `uvm_field_int(a_ready_delay_min, UVM_DEFAULT) + `uvm_field_int(a_ready_delay_max, UVM_DEFAULT) + `uvm_field_int(d_ready_delay_min, UVM_DEFAULT) + `uvm_field_int(d_ready_delay_max, UVM_DEFAULT) + `uvm_field_int(host_can_stall_rsp_when_a_valid_high, UVM_DEFAULT) + `uvm_field_int(device_can_rsp_on_same_cycle, UVM_DEFAULT) + `uvm_field_int(time_a_valid_avail_after_sample_edge, UVM_DEFAULT) + `uvm_field_int(csr_access_abort_pct_in_adapter, UVM_DEFAULT) + `uvm_object_utils_end + `uvm_object_new + + function void post_randomize(); + // We want to randomize the initial value of last_a_source_released, while respecting any + // constraints on a_source in the tl_seq_item (and its extensions). So we do it here instead. + tl_seq_item dummy = tl_seq_item::type_id::create("dummy"); + `DV_CHECK_RANDOMIZE_FATAL(dummy) + randomize_a_source_in_item(.item(dummy), .use_last_a_source_released(1'b0)); + last_a_source_released = dummy.a_source; + endfunction + + // Randomizes a_source within an item (protected function). + // + // This function takes the tl_seq_item object to specifically randomize the a_source such that it + // does not match an existing one in the a_source_q. This randomization also takes into account + // any existing constraints on a_source that may exist in the class definition. The new a_source + // value is randomized to be equal to the last a_source released from the a_source_pend_q + // 20% of the time (weight is configurable). + // + // For actual reqs made out to the DUT, use randomize_a_source_in_req(). + protected function void randomize_a_source_in_item(tl_seq_item item, + bit use_last_a_source_released); + bit [SourceWidth - 1 : 0] a_source; + + // Use std::randomize instead of calling item.randomize(a_source). item.randomize will invoke + // post_randomize. If user does sth after post_randomize before calling finish_item, invoking + // post_randomize may override that. + // For example, if we use item.randomize(a_source) + // item.randomize(); // in post_randomize, instr_type is set to False + // item.instr_type = True; + // finish_item(item); // finish_item will call randomize_a_source_in_item. + // // item.randomize(a_source) will invoke post_randomize, instr_type is set + // // to False again. + `DV_CHECK_STD_RANDOMIZE_WITH_FATAL(a_source, + // use soft constraint as seq may still send req when all the valid a_source are used + (!in_reset) -> soft !(a_source inside {a_source_pend_q}); + // Set the upper a_source bits that are unused to 0. + (a_source >> valid_a_source_width) == 0; + // We cannot guarantee that last_a_source_released is not in a_source_pend_q, + // especially if the test does non-blocking accesses. If the a_source for the new req + // needs to be equal to last_a_source_released, we will need the bottom constraint to be a + // soft one to *potentially* avoid violating the previous constraint. Only way to guarantee + // that the new a_source == last_a_source_released is to ensure the test only does blocking + // accesses. + use_last_a_source_released && !(last_a_source_released inside {a_source_pend_q}) + -> soft (a_source == last_a_source_released);) + item.a_source = a_source; + `uvm_info(`gfn, $sformatf("a_source_pend_q: %p a_source: %0h", a_source_pend_q, item.a_source), UVM_DEBUG) + endfunction + + // Randomizes the a_source for a 'real' req (public version of the above function). + // + // Invokes randomize_a_source_in_item() and adds the a_source for the new req to the queue. + virtual function void randomize_a_source_in_req(tl_seq_item item); + bit use_last_a_source_released; + use_last_a_source_released = ($urandom_range(1, 100) <= use_last_a_source_released_pct); + randomize_a_source_in_item(item, use_last_a_source_released); + add_to_a_source_pend_q(item.a_source); + endfunction + + // Adds a_source to the a_source_pend_q. + // + // Ensures that the queue does not exceed the max outstanding req size. Pops the oldest a_source + // used to last_a_source_released. + virtual function void add_to_a_source_pend_q(bit [SourceWidth-1:0] a_source); + if (in_reset) return; + if (a_source_pend_q.size() == max_outstanding_req) begin + last_a_source_released = a_source_pend_q.pop_front(); + end + a_source_pend_q.push_back(a_source); + `uvm_info(`gfn, $sformatf("a_source_pend_q: %p", a_source_pend_q), UVM_DEBUG) + endfunction + + // Removes the last used a_source from a_source_pend_q. + // + // Invoked by the tl_host_base_seq::get_base_response() which overrides the default UVM + // implementation. It is recommended that all TL host sequence flavors that do not extended from + // tl_host_base_seq invoke this function similarly to avoid running out of a_source IDs when + // creating non-blocking requests. + virtual function void remove_from_a_source_pend_q(bit [SourceWidth-1:0] a_source); + int result[$]; + + // Responses can return out of order, so the a_source can be anywhere in the queue. + result = a_source_pend_q.find_first_index with (item == a_source); + if (result.size() == 1) begin + a_source_pend_q.delete(result.pop_front()); + last_a_source_released = a_source; + `uvm_info(`gfn, $sformatf("a_source_pend_q: %p", a_source_pend_q), UVM_DEBUG) + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_cov.sv new file mode 100644 index 0000000..17a0ff1 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_cov.sv @@ -0,0 +1,131 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Covergroup: pending_req_on_rst_cg +// define bins for having pending request while on reset +covergroup pending_req_on_rst_cg(string name, string path) with function + sample(bit req_pending); + option.per_instance = 1; + option.name = {path, "::", name}; + + cp_req_pending: coverpoint req_pending { + bins values[] = {0, 1}; + } +endgroup + +// coverage for sampling all the values of outstanding req, up to its max +covergroup max_outstanding_cg(string name, int max_outstanding, string path) with function + sample(int num_outstanding); + option.per_instance = 1; + option.name = {path, "::", name}; + + cp_num_of_outstanding: coverpoint num_outstanding { + bins values[] = {[1:max_outstanding]}; + } +endgroup : max_outstanding_cg + +covergroup tl_a_chan_cov_cg(string name, int valid_source_width, string path) with function + sample(tl_seq_item item); + option.per_instance = 1; + option.name = {path, "::", name}; + + cp_opcode: coverpoint item.a_opcode { + bins values[] = {Get, PutFullData, PutPartialData}; + } + cp_mask: coverpoint item.a_mask { + bins all_enables = {{MaskWidth{1'b1}}}; + bins others = default; + } + cp_size: coverpoint item.a_size { + bins biggest_size = {$clog2(DataWidth >> 3)}; + bins others = default; + } + cp_source: coverpoint item.a_source { + bins valid_sources[] = {[0 : 2 << (valid_source_width - 1) - 1]}; + } + cross cp_opcode, cp_mask, cp_size; +endgroup : tl_a_chan_cov_cg + +covergroup tl_d_chan_cov_cg(string name, string path) with function sample(tl_seq_item item); + option.per_instance = 1; + option.name = {path, "::", name}; + + cp_opcode: coverpoint item.d_opcode { + bins values[] = {AccessAckData, AccessAckData}; + } + cp_size: coverpoint item.a_size { + bins biggest_size = {$clog2(DataWidth >> 3)}; + bins others = default; + } + cp_error: coverpoint item.d_error; + cross cp_opcode, cp_size; +endgroup : tl_d_chan_cov_cg + +class tl_agent_cov extends dv_base_agent_cov #(tl_agent_cfg); + // sample these at proper location, for example, m_pending_req_on_rst_cg called after reset + pending_req_on_rst_cg m_pending_req_on_rst_cg; + max_outstanding_cg m_max_outstanding_cg; + bit_toggle_cg_wrap m_outstanding_item_w_same_addr_cov_obj; + + // knob to create m_outstanding_item_w_same_addr_cov_obj, even design supports more than + // 1 outstanding items, but may not support they use the same address + // TODO(#16840): may need to disable it for spi_device and hmac even they support 2 outstanding + // items + bit en_cov_outstanding_item_w_same_addr = 1; + + // item coverage, call sample(item) at the end of transaction to sample them + tl_a_chan_cov_cg m_tl_a_chan_cov_cg; // host mode + tl_d_chan_cov_cg m_tl_d_chan_cov_cg; // device mode + bit_toggle_cg_wrap m_tl_error_cov_objs[string]; // host mode + + `uvm_component_utils(tl_agent_cov) + `uvm_component_new + + function void build_phase(uvm_phase phase); + string tl_error_names[] = {"invalid_a_opcode", + "PutFullData_mask_not_match_size", + "addr_not_align_mask", + "addr_not_align_size", + "mask_not_in_active_lanes", + "size_over_max"}; + super.build_phase(phase); + m_pending_req_on_rst_cg = new("m_pending_req_on_rst_cg", `gfn); + m_max_outstanding_cg = new("m_max_outstanding_cg", cfg.max_outstanding_req, `gfn); + + if (cfg.max_outstanding_req > 1 && en_cov_outstanding_item_w_same_addr) begin + m_outstanding_item_w_same_addr_cov_obj = + new({`gfn, "::m_outstanding_item_w_same_addr_cov_obj"}); + end + + if (cfg.if_mode == dv_utils_pkg::Host) begin + m_tl_a_chan_cov_cg = new("m_tl_a_chan_cov_cg", cfg.valid_a_source_width, `gfn); + foreach (tl_error_names[i]) begin + m_tl_error_cov_objs[tl_error_names[i]] = new({`gfn, "::", tl_error_names[i]}); + end + end else begin // device mode + m_tl_d_chan_cov_cg = new("m_tl_d_chan_cov_cg", `gfn); + end + endfunction : build_phase + + // sample info that is within the seq_item, this will be called at the end of transaction + virtual function void sample(tl_seq_item item); + if (cfg.if_mode == dv_utils_pkg::Host) begin + if (!item.get_exp_d_error()) begin // no error + m_tl_a_chan_cov_cg.sample(item); + end else begin // error cases + m_tl_error_cov_objs["invalid_a_opcode"].sample(item.get_error_a_opcode_invalid()); + m_tl_error_cov_objs["PutFullData_mask_not_match_size"].sample( + item.get_error_PutFullData_mask_size_mismatched()); + m_tl_error_cov_objs["addr_not_align_mask"].sample(item.get_error_addr_size_misaligned()); + m_tl_error_cov_objs["addr_not_align_size"].sample(item.get_error_addr_size_misaligned()); + m_tl_error_cov_objs["mask_not_in_active_lanes"].sample( + item.get_error_mask_not_in_active_lanes()); + m_tl_error_cov_objs["size_over_max"].sample(item.get_error_size_over_max()); + end + end else begin // device mode + m_tl_d_chan_cov_cg.sample(item); + end + endfunction : sample + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_pkg.sv new file mode 100644 index 0000000..adfd0c0 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_agent_pkg.sv @@ -0,0 +1,89 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// + +package tl_agent_pkg; + // dep packages + import uvm_pkg::*; + import bus_params_pkg::*; + import tlul_pkg::*; + import mem_model_pkg::*; + import dv_base_agent_pkg::*; + import dv_lib_pkg::*; + import dv_base_reg_pkg::*; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + parameter int AddrWidth = bus_params_pkg::BUS_AW; + parameter int DataWidth = bus_params_pkg::BUS_DW; + parameter int SizeWidth = bus_params_pkg::BUS_SZW; + parameter int MaskWidth = bus_params_pkg::BUS_DBW; + parameter int SourceWidth = bus_params_pkg::BUS_AIW; + parameter int AUserWidth = bus_params_pkg::BUS_AUW; + parameter int DUserWidth = bus_params_pkg::BUS_DUW; + parameter int OpcodeWidth = 3; + parameter int InstrTypeLsbPos = get_instr_type_lsb_pos(); + parameter int InstrTypeMsbPos = get_instr_type_msb_pos(); + + typedef class tl_seq_item; + typedef class tl_agent_cfg; + // reuse dv_base_driver as is with the right parameter set + typedef dv_base_driver #(tl_seq_item, tl_agent_cfg) tl_base_driver; + + // TileLink conformance level + typedef enum bit [1:0] { + kTLUL, + kTLUH, + kTLC + } tl_level_e; + + typedef enum { + AddrChannel, + DataChannel + } tl_channels_e; + + function automatic void enable_logging(string file_name="tl_agent.log"); + int log_fd = $fopen(file_name,"w"); + `uvm_info($sformatf("%m"), $sformatf("The TL agent transaction log will be saved to %0s", + file_name), UVM_LOW) + uvm_top.set_report_id_verbosity_hier("tl_logging", UVM_HIGH); + uvm_top.set_report_id_file_hier("tl_logging", log_fd); + uvm_top.set_report_id_verbosity_hier("tl_logging", UVM_HIGH); + // Always save in a separate log file and disable printing on the screen + uvm_top.set_report_severity_id_action_hier(UVM_INFO, "tl_logging", UVM_LOG); + uvm_top.set_report_severity_id_action_hier(UVM_WARNING, + "tl_logging", UVM_DISPLAY | UVM_LOG); + uvm_top.set_report_severity_id_action_hier(UVM_ERROR, + "tl_logging", UVM_DISPLAY | UVM_LOG | UVM_COUNT); + uvm_top.set_report_severity_id_action_hier(UVM_FATAL, + "tl_logging", UVM_DISPLAY | UVM_LOG | UVM_EXIT); + endfunction + + // Extract the LSB position of the instr_type field from struct tl_a_user_t + function automatic int get_instr_type_lsb_pos(); + tl_a_user_t tl_a_user = '0; + tl_a_user.instr_type = prim_mubi_pkg::mubi4_t'(1); + return $clog2(tl_a_user); + endfunction : get_instr_type_lsb_pos + + // Extract the MSB position of the instr_type field from struct tl_a_user_t + function automatic int get_instr_type_msb_pos(); + tl_a_user_t tl_a_user = '0; + return get_instr_type_lsb_pos()+$size(tl_a_user.instr_type)-1; + endfunction : get_instr_type_msb_pos + + `include "tl_seq_item.sv" + `include "tl_agent_cfg.sv" + `include "tl_agent_cov.sv" + `include "tl_host_driver.sv" + `include "tl_device_driver.sv" + `include "tl_sequencer.sv" + `include "tl_monitor.sv" + `include "tl_agent.sv" + `include "tl_reg_adapter.sv" + `include "tl_seq_list.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_device_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_device_driver.sv new file mode 100644 index 0000000..ca17738 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_device_driver.sv @@ -0,0 +1,128 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// + +// --------------------------------------------- +// TileLink device driver +// --------------------------------------------- +class tl_device_driver extends tl_base_driver; + + `uvm_component_utils(tl_device_driver) + `uvm_component_new + + virtual task get_and_drive(); + // Wait for initial reset to pass. + wait(cfg.vif.rst_n === 1'b0); + wait(cfg.vif.rst_n === 1'b1); + fork + a_channel_thread(); + d_channel_thread(); + join_none + endtask + + task on_enter_reset(); + invalidate_d_channel(); + cfg.vif.d2h_int.a_ready <= 1'b0; + + // Make sure that seq_item_port FIFO will be empty when coming out of reset + `DV_CHECK_EQ(seq_item_port.has_do_available(), 0); + endtask + + virtual task a_channel_thread(); + int unsigned ready_delay; + + forever begin + ready_delay = $urandom_range(cfg.a_ready_delay_min, cfg.a_ready_delay_max); + repeat(ready_delay) @(cfg.vif.device_cb); + cfg.vif.device_cb.d2h.a_ready <= 1'b1; + @(cfg.vif.device_cb); + cfg.vif.device_cb.d2h.a_ready <= 1'b0; + end + endtask + + virtual task d_channel_thread(); + bit req_found; + tl_seq_item rsp; + + forever begin + int unsigned d_valid_delay, d_valid_len, d_valid_cnt; + bit rsp_done, rsp_abort; + seq_item_port.get_next_item(rsp); + + while (!rsp_done && !rsp_abort && cfg.vif.rst_n) begin + if (cfg.use_seq_item_d_valid_delay) begin + d_valid_delay = rsp.d_valid_delay; + end else begin + d_valid_delay = $urandom_range(cfg.d_valid_delay_min, cfg.d_valid_delay_max); + end + + if (cfg.allow_d_valid_drop_wo_d_ready || rsp.rsp_abort_after_d_valid_len) begin + if (cfg.use_seq_item_d_valid_len) begin + d_valid_len = rsp.d_valid_len; + end else begin + d_valid_len = $urandom_range(cfg.d_valid_len_min, cfg.d_valid_len_max); + end + end + + // break delay loop if reset asserted to release blocking + repeat (d_valid_delay) begin + if (!cfg.vif.rst_n) break; + else @(cfg.vif.device_cb); + end + if (cfg.vif.rst_n) begin + cfg.vif.d2h_int.d_valid <= 1'b1; + cfg.vif.d2h_int.d_opcode <= tl_d_op_e'(rsp.d_opcode); + cfg.vif.d2h_int.d_data <= rsp.d_data; + cfg.vif.d2h_int.d_source <= rsp.d_source; + cfg.vif.d2h_int.d_param <= rsp.d_param; + cfg.vif.d2h_int.d_error <= rsp.d_error; + cfg.vif.d2h_int.d_sink <= rsp.d_sink; + cfg.vif.d2h_int.d_user <= rsp.d_user; + cfg.vif.d2h_int.d_size <= rsp.d_size; + end + + // wait for ready or reaching d_valid_len + d_valid_cnt = 0; + while (cfg.vif.rst_n) begin + @(cfg.vif.device_cb); + d_valid_cnt++; + if (cfg.vif.device_cb.h2d.d_ready) begin + rsp_done = 1; + break; + end else if ((cfg.allow_d_valid_drop_wo_d_ready || rsp.rsp_abort_after_d_valid_len) + && d_valid_cnt >= d_valid_len) begin + if (rsp.rsp_abort_after_d_valid_len) rsp_abort = 1; + invalidate_d_channel(); + if (!cfg.vif.rst_n) @(cfg.vif.device_cb); + break; + end + end // while (!cfg.vif.rst_n) + end // while (!rsp_done && cfg.vif.rst_n) + invalidate_d_channel(); + rsp.rsp_completed = !rsp_abort; + seq_item_port.item_done(); + seq_item_port.put_response(rsp); + end + endtask : d_channel_thread + + function void invalidate_d_channel(); + if (cfg.invalidate_d_x) begin + cfg.vif.d2h_int.d_opcode <= tlul_pkg::tl_d_op_e'('x); + cfg.vif.d2h_int.d_param <= '{default:'x}; + cfg.vif.d2h_int.d_size <= '{default:'x}; + cfg.vif.d2h_int.d_source <= '{default:'x}; + cfg.vif.d2h_int.d_sink <= '{default:'x}; + cfg.vif.d2h_int.d_data <= '{default:'x}; + cfg.vif.d2h_int.d_user <= '{default:'x}; + cfg.vif.d2h_int.d_error <= 1'bx; + cfg.vif.d2h_int.d_valid <= 1'b0; + end else begin // if (cfg.invalidate_d_x) + tlul_pkg::tl_d2h_t d2h; + `DV_CHECK_STD_RANDOMIZE_FATAL(d2h) + d2h.d_valid = 1'b0; + cfg.vif.d2h_int <= d2h; + end + endfunction : invalidate_d_channel + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_host_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_host_driver.sv new file mode 100644 index 0000000..9be3489 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_host_driver.sv @@ -0,0 +1,381 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// A TileLink driver that behaves as a host, initiating TileLink transactions +class tl_host_driver extends tl_base_driver; + `uvm_component_utils(tl_host_driver) + + // A queue of sequence items corresponding to the requests have been sent on the A channel but + // haven't yet had a response on the D channel. + protected tl_seq_item pending_a_req[$]; + + extern function new (string name, uvm_component parent); + + // Drive items received from the sequencer. This implements a task declared in dv_base_driver. + extern task get_and_drive(); + + // Called at the start of a reset. Clear output signals and internal state. This implements a task + // declared in dv_base_driver. + extern task on_enter_reset(); + + // Called at the end of a reset. Make sure that all sequence items have been properly flushed + // while we were in reset. + extern function void on_leave_reset(); + + // Wait for the next edge of host_cb. Stops early if reset is asserted. + extern protected task wait_clk_or_rst(); + + // Get items from the sequencer and drive them on the A channel. This runs forever and runs + // synchronised with the TL clock. + // + // If we go into reset, this will flush all pending items from the sequencer, and continue + // flushing items until reset is deasserted. + extern protected task a_channel_thread(); + + // Send a request, req, on the A channel + // + // The steps to drive the request: + // + // - Wait until there is no pending response for req.a_source. + // - Call send_a_request_body to assert a_valid and similar signals, looping if + // send_a_request_body reports a timeout. + // + // Once the request has been driven call seq_item_port.item_done(), causing the sequencer to allow + // the item to finish. + // + // If a reset is asserted at any point, the task will stop driving the request and send a response + // as well as calling seq_item_port.item_done() (representing the D channel message that would + // normally come back). + extern protected task send_a_channel_request(tl_seq_item req); + + // Send the body of a request on the A channel. + // + // To do so, this writes a_valid and the other A signals and then waits for a clock edge where we + // see a_ready true, at which point the A channel transaction has been made. + // + // If a_ready doesn't go high, it's possible that there will be a timeout after a_valid_len + // cycles. If this is enabled and the timeout happens then remove the item from pendng_a_req, + // and invalidate the channel. + // + // req: The request whose body should be sent. + // + // a_valid_delay: The number of host clock cycles to wait before asserting a_valid. + // + // a_valid_len: The number of host clock cycles a_valid is held high waiting for a_ready to go + // high and accept the request. If req has req_abort_after_a_valid_len set, or if + // the cfg has allow_a_valid_drop_wo_a_ready, then the driver will drop a_valid + // again after that time, write 'x values to the A channel and exit. + // + // req_done [out] This is set to 1'b1 if a_ready has gone high on the host clock. + // + // req_abort [out] This is set to 1'b1 if the host decides to drop a_valid because the receiver + // hasn't responded with a_ready. + extern local task send_a_request_body(tl_seq_item req, + int unsigned a_valid_delay, + int unsigned a_valid_len, + output bit req_done, + output bit req_abort); + + // Drive the d_ready pin (as the host) forever to allow a device to send responses back + // + // This waits a random number of host clock cycles (between cfg.d_ready_delay_min and + // cfg.d_ready_delay_max) and then pulses d_ready high for a cycle before dropping again. + // + // If cfg.host_can_stall_rsp_when_a_valid_high is false then the driver setting a_valid high will + // cause this task to skip any wait period with d_ready low and hold it high. + extern protected task d_ready_rsp(); + + // Collect responses on the D channel + // + // A response is signalled by the device setting d_valid when we (the host) have set d_ready. The + // request to which this is a response is found by searching for d_source in the queue of pending + // requests. + // + // When a match is found, this task puts a response to seq_item_port (sending it back to the + // sequencer), then deletes the pending request. + // + // If the cfg.in_reset is high, this task responds to all pending requests (with potentially silly + // data values) + extern protected task d_channel_thread(); + + // Return true if the given source is the a_source value of some pending request. + extern protected function bit is_source_in_pending_req(bit [SourceWidth-1:0] source); + + // Set a_valid to zero and write rubbish to the A channel to invalidate it. + // + // If direct is true, this directly drives the vif.h2d_int signal as well as setting signals in + // host_cb (meaning that this will have immediate effect, even if the clock is not running). + // + // If cfg.invalidate_a_x is true then all fields other than a_valid will be set to 'x. If it is + // false then all the fields will be randomised. + extern local task invalidate_a_channel(bit direct); +endclass : tl_host_driver + +function tl_host_driver::new (string name, uvm_component parent); + super.new(name, parent); +endfunction + +task tl_host_driver::get_and_drive(); + // Wait for initial reset to pass. + wait(cfg.vif.rst_n === 1'b1); + @(cfg.vif.host_cb); + fork + a_channel_thread(); + d_channel_thread(); + d_ready_rsp(); + join_none +endtask + +task tl_host_driver::on_enter_reset(); + // Since we've just started a period of reset, invalidate all signals and mark ourselves as not + // ready on the D channel (both directly and through the clocking block) + invalidate_a_channel(1'b1); + cfg.vif.h2d_int.d_ready <= 1'b0; + cfg.vif.host_cb.h2d.d_ready <= 1'b0; +endtask + +function void tl_host_driver::on_leave_reset(); + // We should have flushed all sequence items immediately when we were in reset. To check this has + // worked correctly, the following things should be true when we leave reset: + // + // - The pending_a_req queue should be empty (d_channel_thread should have sent responses and + // flushed the requests). + // + // - The sequencer shouldn't have any items available through seq_item_port. If an item had been + // available, we should have taken it immediately in get_and_drive. + `DV_CHECK_EQ(pending_a_req.size(), 0) + `DV_CHECK_EQ(seq_item_port.has_do_available(), 0) +endfunction + +task tl_host_driver::wait_clk_or_rst(); + `DV_SPINWAIT_EXIT(@(cfg.vif.host_cb);, wait(cfg.in_reset);) +endtask + +task tl_host_driver::a_channel_thread(); + wait_clk_or_rst(); + + forever begin + // At the start of the loop, either the interface is in reset or we are either aligned with a + // clock edge. Look to see whether there is a request ready to be sent. + seq_item_port.try_next_item(req); + + // If there was not a request ready, use get_next_item(). Since that task blocks, we then have + // to resynchronise with the clock edge (or see a reset) before starting to drive the item. + if (req == null) begin + seq_item_port.get_next_item(req); + wait_clk_or_rst(); + end + + // At this point, we have a request to send and either the interface is in reset or we are + // aligned with a clock edge. Send that request. + send_a_channel_request(req); + end +endtask + +task tl_host_driver::send_a_channel_request(tl_seq_item req); + int unsigned a_valid_delay, a_valid_len; + bit req_done = 1'b0, req_abort = 1'b0; + + // Seq may override the a_source or all valid sources are used but still send req, in which case + // it is possible that it might not have factored + // This wait is only needed in xbar test as xbar can use all valid sources and xbar_stress runs + // all seq in parallel, which needs driver to stall when the source is currently being used + // in the a_source values from pending requests that have not yet completed. If that is true, we + // need to insert additional delays to ensure we do not end up sending the new request whose + // a_source matches one of the pending requests. + `DV_SPINWAIT_EXIT(while (is_source_in_pending_req(req.a_source)) @(cfg.vif.host_cb);, + wait(cfg.in_reset);) + + while (!req_done && !req_abort && !cfg.in_reset) begin + if (cfg.use_seq_item_a_valid_delay) begin + a_valid_delay = req.a_valid_delay; + end else begin + a_valid_delay = $urandom_range(cfg.a_valid_delay_min, cfg.a_valid_delay_max); + end + + if (req.req_abort_after_a_valid_len || cfg.allow_a_valid_drop_wo_a_ready) begin + if (cfg.use_seq_item_a_valid_len) begin + a_valid_len = req.a_valid_len; + end else begin + a_valid_len = $urandom_range(cfg.a_valid_len_min, cfg.a_valid_len_max); + end + end + + fork : isolation_fork begin + fork + begin + wait(cfg.in_reset); + req_abort = 1; + end + send_a_request_body(req, a_valid_delay, a_valid_len, req_done, req_abort); + join_any + disable fork; + end join + end + seq_item_port.item_done(); + if (req_abort || cfg.in_reset) begin + req.req_completed = 0; + // Just wire the d_source back to a_source to avoid errors in upstream logic. + req.d_source = req.a_source; + seq_item_port.put_response(req); + end else begin + req.req_completed = 1; + end + `uvm_info(get_full_name(), $sformatf("Req %0s: %0s", req_abort ? "aborted" : "sent", + req.convert2string()), UVM_HIGH) +endtask + +task tl_host_driver::send_a_request_body(tl_seq_item req, + int unsigned a_valid_delay, + int unsigned a_valid_len, + output bit req_done, + output bit req_abort); + int unsigned a_valid_cnt = 0; + req_done = 1'b0; + req_abort = 1'b0; + + // If there is a delay before sending the item, wait that number of cycles + repeat (a_valid_delay) @(cfg.vif.host_cb); + + // Set signals on the A channel and add the request to pending_a_req, then wait for one clock + // edge, which causes the signals to actually be presented as signals on the interface. + pending_a_req.push_back(req); + cfg.vif.host_cb.h2d.a_address <= req.a_addr; + cfg.vif.host_cb.h2d.a_opcode <= tl_a_op_e'(req.a_opcode); + cfg.vif.host_cb.h2d.a_size <= req.a_size; + cfg.vif.host_cb.h2d.a_param <= req.a_param; + cfg.vif.host_cb.h2d.a_data <= req.a_data; + cfg.vif.host_cb.h2d.a_mask <= req.a_mask; + cfg.vif.host_cb.h2d.a_user <= req.a_user; + cfg.vif.host_cb.h2d.a_source <= req.a_source; + cfg.vif.host_cb.h2d.a_valid <= 1'b1; + + forever begin + @(cfg.vif.host_cb); + a_valid_cnt++; + if (cfg.vif.host_cb.d2h.a_ready) begin + req_done = 1; + break; + end else if ((req.req_abort_after_a_valid_len || cfg.allow_a_valid_drop_wo_a_ready) && + a_valid_cnt >= a_valid_len) begin + if (req.req_abort_after_a_valid_len) req_abort = 1; + // remove unaccepted item + void'(pending_a_req.pop_back()); + break; + end + end + + // Finally, clear up the A channel signals (because the transaction has either happened or been + // aborted). The cleared signals will be visible on the interface on the next clock edge. + invalidate_a_channel(1'b0); +endtask + +task tl_host_driver::d_ready_rsp(); + int unsigned d_ready_delay; + tl_seq_item rsp; + + forever begin + bit req_found; + d_ready_delay = $urandom_range(cfg.d_ready_delay_min, cfg.d_ready_delay_max); + // if a_valid high then d_ready must be high, exit the delay when a_valid is set + repeat (d_ready_delay) begin + if (!cfg.host_can_stall_rsp_when_a_valid_high && cfg.vif.h2d.a_valid) break; + @(cfg.vif.host_cb); + end + + cfg.vif.host_cb.h2d.d_ready <= 1'b1; + @(cfg.vif.host_cb); + cfg.vif.host_cb.h2d.d_ready <= 1'b0; + end +endtask + +task tl_host_driver::d_channel_thread(); + int unsigned d_ready_delay; + tl_seq_item rsp; + + forever begin + if ((cfg.vif.host_cb.d2h.d_valid && cfg.vif.h2d.d_ready && !cfg.in_reset) || + ((pending_a_req.size() != 0) & cfg.in_reset)) begin + // Use the source ID to find the matching request + foreach (pending_a_req[i]) begin + if ((pending_a_req[i].a_source == cfg.vif.host_cb.d2h.d_source) | cfg.in_reset) begin + rsp = pending_a_req[i]; + rsp.d_opcode = cfg.vif.host_cb.d2h.d_opcode; + rsp.d_data = cfg.vif.host_cb.d2h.d_data; + rsp.d_param = cfg.vif.host_cb.d2h.d_param; + rsp.d_sink = cfg.vif.host_cb.d2h.d_sink; + rsp.d_size = cfg.vif.host_cb.d2h.d_size; + rsp.d_user = cfg.vif.host_cb.d2h.d_user; + // set d_error = 0 and rsp_completed = 0 when reset occurs + rsp.d_error = cfg.in_reset ? 0 : cfg.vif.host_cb.d2h.d_error; + // make sure every req has a rsp with same source even during reset + if (cfg.in_reset) rsp.d_source = rsp.a_source; + else rsp.d_source = cfg.vif.host_cb.d2h.d_source; + seq_item_port.put_response(rsp); + pending_a_req.delete(i); + `uvm_info(get_full_name(), $sformatf("Got response %0s, pending req:%0d", + rsp.convert2string(), pending_a_req.size()), UVM_HIGH) + rsp.rsp_completed = !cfg.in_reset; + break; + end + end + + // If there was a matching request, we responded to it above. If not, the device seems to + // have sent a response without a request (and we won't have done anything yet). + // + // If we're in reset, we might have forgotten the request (and can ignore the response). If + // not, we wouldn't normally expect this to happen. This is a property that is checked in + // the tlul_assert module, which should be bound in. But it *might* happen if we're doing + // fault injection and disabling assertions in that module. + // + // Ignore the response either way: we're a driver and there is definitely no sequence that + // is waiting for the response here. If there's a bug in the design and we're generating + // spurious responses, we expect something to fail in tlul_assert. + end else if (cfg.in_reset) begin + wait(!cfg.in_reset); + end + wait_clk_or_rst(); + end +endtask + +function bit tl_host_driver::is_source_in_pending_req(bit [SourceWidth-1:0] source); + foreach (pending_a_req[i]) begin + if (pending_a_req[i].a_source == source) return 1; + end + return 0; +endfunction + +task tl_host_driver::invalidate_a_channel(bit direct); + // To invalidate the A channel, we will drive a_valid to zero and drive all the other A channel + // signals to either 'x or to a random value. Since there's just one signal on the D channel, the + // easiest way to do this is to drive all the signals, but make sure to set the d_ready signal to + // the value it had before. + // + // If either current d_ready value is not known, consider it to be 0. + bit cb_d_ready = cfg.vif.mon_cb.h2d.d_ready; + bit raw_d_ready = cfg.vif.mon_cb.h2d.d_ready; + + if (cfg.invalidate_a_x) begin + cfg.vif.host_cb.h2d <= tl_h2d_t'('x); + cfg.vif.host_cb.h2d.a_valid <= 1'b0; + cfg.vif.host_cb.h2d.d_ready <= cb_d_ready; + + if (direct) begin + cfg.vif.h2d_int <= tl_h2d_t'('x); + cfg.vif.h2d_int.a_valid <= 1'b0; + cfg.vif.h2d_int.d_ready <= raw_d_ready; + end + end else begin + tlul_pkg::tl_h2d_t h2d; + if (!std::randomize(h2d) with { h2d.a_valid == 1'b0; h2d.d_ready == cb_d_ready; }) begin + `uvm_fatal(get_full_name(), "Failed to randomize h2d.") + end + + cfg.vif.host_cb.h2d <= h2d; + if (direct) begin + h2d.d_ready = raw_d_ready; + cfg.vif.h2d_int <= h2d; + end + end +endtask diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_if.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_if.sv new file mode 100644 index 0000000..c202036 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_if.sv @@ -0,0 +1,45 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +// --------------------------------------------- +// TileLink interface +// --------------------------------------------- +interface tl_if(input clk, input rst_n); + + wire tlul_pkg::tl_h2d_t h2d; // req + wire tlul_pkg::tl_d2h_t d2h; // rsp + + tlul_pkg::tl_h2d_t h2d_int; // req (internal) + tlul_pkg::tl_d2h_t d2h_int; // rsp (internal) + + dv_utils_pkg::if_mode_e if_mode; // interface mode - Host or Device + + modport dut_host_mp(output h2d_int, input d2h_int); + modport dut_device_mp(input h2d_int, output d2h_int); + + clocking host_cb @(posedge clk); + input rst_n; + output h2d = h2d_int; + input d2h; + endclocking + modport host_mp(clocking host_cb); + + clocking device_cb @(posedge clk); + input rst_n; + input h2d; + output d2h = d2h_int; + endclocking + modport device_mp(clocking device_cb); + + clocking mon_cb @(posedge clk); + input rst_n; + input h2d; + input d2h; + endclocking + modport mon_mp(clocking mon_cb); + + assign h2d = (if_mode == dv_utils_pkg::Host) ? h2d_int : 'z; + assign d2h = (if_mode == dv_utils_pkg::Device) ? d2h_int : 'z; + +endinterface : tl_if diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_monitor.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_monitor.sv new file mode 100644 index 0000000..a776f82 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_monitor.sv @@ -0,0 +1,293 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// + +// --------------------------------------------- +// TileLink interface monitor +// --------------------------------------------- +class tl_monitor extends dv_base_monitor#( + .ITEM_T (tl_seq_item), + .CFG_T (tl_agent_cfg), + .COV_T (tl_agent_cov) + ); + + tl_seq_item pending_a_req[bit [SourceWidth - 1 : 0]]; + string agent_name; + + // Sequence items for transactions on the A and D channels. Sampled on the positive clock edge. + // + // If cfg.synchronise_ports (disabled by default), use these by waiting on channel_dir_port. This + // gets updated just after we push to a_chan_port or d_chan_port, telling the reader which channel + // to read. That way, the reader can guarantee a sample order if an A and D transaction both + // appear at the same time. + // + // Otherwise, wait on a_chan_port and d_chan_port with two concurrent processes. A and D + // transactions that happen at the same time will be popped from the FIFOs in an indeterminate + // order. + uvm_analysis_port #(tl_channels_e) channel_dir_port; + uvm_analysis_port #(tl_seq_item) a_chan_port; + uvm_analysis_port #(tl_seq_item) d_chan_port; + + // Sequence items for transactions on the A channel, sampled shortly after the positive clock + // edge. This is only used if cfg.device_can_rsp_on_same_cycle, in which case a sequence item for + // a transaction will appear on this port when sampled and on a_chan_port on the following clock + // edge. + uvm_analysis_port #(tl_seq_item) a_chan_same_cycle_rsp_port; + + `uvm_component_utils(tl_monitor) + + `uvm_component_new + + function void build_phase(uvm_phase phase); + super.build_phase(phase); + if (cfg.synchronise_ports) begin + channel_dir_port = new("channel_dir_port", this); + end + + a_chan_port = new("a_chan_port", this); + d_chan_port = new("d_chan_port", this); + + if (cfg.device_can_rsp_on_same_cycle) begin + a_chan_same_cycle_rsp_port = new("a_chan_same_cycle_rsp_port", this); + end + endfunction : build_phase + + // Watch the reset signal and maintain cfg.in_reset + local task monitor_reset(); + // At the start of the task, we don't know whether we are in reset. Set cfg.in_reset to be true + // unless rst_n is known and asserted. + cfg.in_reset = (cfg.vif.rst_n !== 1'b1); + + // Now wait until rst_n has a known value + wait(!$isunknown(cfg.vif.rst_n)); + + forever begin + // We maintain the invariant that cfg.vif.rst_n has a known value at the start of each loop + // iteration, which ensures that we can safely convert it to a bit in cfg.in_reset. Note that + // the wait statement below will only complete when cfg.vif.rst_n has a known value. + cfg.in_reset = !cfg.vif.rst_n; + wait(cfg.vif.rst_n != !cfg.in_reset); + end + endtask + + virtual task run_phase(uvm_phase phase); + super.run_phase(phase); + fork + monitor_reset(); + ad_channels_thread(); + join + endtask + + local task ad_channels_thread(); + forever begin + wait(!cfg.in_reset); + + // As we come out of reset, clear the pending_a_req and cfg.a_source_pend_q associative + // arrays. + pending_a_req.delete(); + cfg.a_source_pend_q.delete(); + + // Watch the interface for A and D channel requests, but stop immediately if we see a reset. + // Note that ad_channels_thread is safe to kill at any time. + fork begin : isolation_fork + fork + ad_channels_thread_(); + wait(cfg.in_reset); + join_any + disable fork; + end join + + // We have just entered reset. If coverage is enabled, take a note of whether there was a + // pending request as we did so. + if (cfg.en_cov) cov.m_pending_req_on_rst_cg.sample(pending_a_req.size() != 0); + end + endtask + + // Check the A and D channels for transactions. When a transaction is seen, push it to a_chan_port + // or d_chan_port, respectively. If cfg.synchronise_ports, also push the channel to + // channel_dir_port. If transactions are seen for both channels on a clock edge, push D then A. + // + // If the device isn't expected to respond combinatorially (cfg.device_can_rsp_on_same_cycle = 0), + // then both channels are sampled on the posedge of the clock. If the device *can* respond + // combinatorially, we delay sampling on the A side by a short time. The idea is that the A + // transaction will be asserted just after a clock edge and then D will be asserted some time + // afterwards. Sampling A in the middle of the cycle and then D at the following clock ensures + // that we see A before D (the order in which the events happened). + local task ad_channels_thread_(); + + // The most recently seen request on the A channel. Set to something non-null by successful + // calls to check_a_channel. Cleared back to null when the item is written to a_chan_port. + tl_seq_item a_chan_req_item; + + forever begin + @(cfg.vif.mon_cb); + // This is just after the clock edge, so time to sample D and A channels. + + // Handle the D side. + check_d_channel(); + + // Handle the A side. If cfg.device_can_rsp_on_same_cycle then we've actually done the + // sampling already. Otherwise, we should check now. + if (!cfg.device_can_rsp_on_same_cycle) begin + a_chan_req_item = check_a_channel(.immediate(1'b0)); + end + if (a_chan_req_item != null) begin + a_chan_port.write(a_chan_req_item); + if (cfg.synchronise_ports) channel_dir_port.write(AddrChannel); + a_chan_req_item = null; + end + + // We're done with this clock edge. If cfg.device_can_rsp_on_same_cycle, we now wait a short + // time afterwards and sample a little after the clockedge. + if (cfg.device_can_rsp_on_same_cycle) begin + `DV_SPINWAIT_EXIT( + #(cfg.time_a_valid_avail_after_sample_edge);, + @(cfg.vif.mon_cb) `uvm_fatal(`gfn, $sformatf( + "time_a_valid_avail_after_sample_edge (%0t) is over one cycle", + cfg.time_a_valid_avail_after_sample_edge))) + + // It's a short time afterwards. Do the sampling! + a_chan_req_item = check_a_channel(.immediate(1'b1)); + if (a_chan_req_item != null) begin + a_chan_same_cycle_rsp_port.write(a_chan_req_item); + end + end + end + endtask + + // Check the A channel for a transaction + // + // If immediate is true, this is running just after a posedge of the clock, to allow us to capture + // same-cycle responses. In this case, it samples the immediate values of the signals. + // + // Otherwise, this is running on the posedge. It samples signals through the mon_cb clocking + // block. + // + // In either case, if a transaction is found then it returns a sequence item. Otherwise, it + // returns null. + function tl_seq_item check_a_channel(bit immediate); + logic a_valid = immediate ? cfg.vif.h2d.a_valid : cfg.vif.mon_cb.h2d.a_valid; + logic a_ready = immediate ? cfg.vif.d2h.a_ready : cfg.vif.mon_cb.d2h.a_ready; + + if (a_valid && a_ready) begin + tl_seq_item req = tl_seq_item::type_id::create("req"); + tl_seq_item cloned_req; + tlul_pkg::tl_h2d_t h2d = immediate ? cfg.vif.h2d : cfg.vif.mon_cb.h2d; + + // Create a sequence item. Note: this is a field in the class, which ad_channels_thread() uses + // to pass the transaction to the relevant analysis port/ports. + req.a_addr = h2d.a_address; + req.a_opcode = h2d.a_opcode; + req.a_size = h2d.a_size; + req.a_param = h2d.a_param; + req.a_data = h2d.a_data; + req.a_mask = h2d.a_mask; + req.a_source = h2d.a_source; + req.a_user = h2d.a_user; + `uvm_info(`gfn, $sformatf("[%0s][a_chan] : %0s", agent_name, req.convert2string()), UVM_HIGH) + + if (cfg.en_cov) sample_outstanding_cov(req); + + `downcast(cloned_req, req.clone()); + `DV_CHECK_EQ_FATAL(cloned_req.a_source >> cfg.valid_a_source_width, 0) + `DV_CHECK_EQ_FATAL(pending_a_req.exists(cloned_req.a_source), 0) + pending_a_req[cloned_req.a_source] = cloned_req; + + if (cfg.max_outstanding_req > 0 && cfg.vif.rst_n === 1) begin + if (pending_a_req.size() > cfg.max_outstanding_req) begin + `uvm_error(`gfn, + $sformatf("Number of pending a_req exceeds limit %0d", pending_a_req.size())) + end + if (cfg.en_cov) cov.m_max_outstanding_cg.sample(pending_a_req.size()); + end + return req; + end + + return null; + endfunction + + // Checks the D channel for a transaction + // + // If a transaction is found, writes it to d_chan_port and clears the corresponding pending + // request. + function void check_d_channel(); + if (cfg.vif.mon_cb.d2h.d_valid && cfg.vif.mon_cb.h2d.d_ready) begin + tl_seq_item rsp; + + // We expect a matching request to exist. If it doesn't, this is a "spurious response" that + // the dut has generated itself. We don't expect that to happen (a property that is checked in + // the tlul_assert module, which should be bound in), but it *might* happen if we're doing + // fault injection and disabling assertions in that module. In that case, print a debug + // message and ignore the response in the monitor: we would normally expect the error to be + // caught in tlul_assert. + if (!pending_a_req.exists(cfg.vif.mon_cb.d2h.d_source)) begin + `uvm_info(`gfn, + $sformatf("Ignoring TL response with no matching request (d_source 0x%0x)", + cfg.vif.mon_cb.d2h.d_source), + UVM_HIGH) + return; + end + + rsp = pending_a_req[cfg.vif.mon_cb.d2h.d_source]; + pending_a_req.delete(cfg.vif.mon_cb.d2h.d_source); + + rsp.d_opcode = cfg.vif.mon_cb.d2h.d_opcode; + rsp.d_data = cfg.vif.mon_cb.d2h.d_data; + rsp.d_source = cfg.vif.mon_cb.d2h.d_source; + rsp.d_param = cfg.vif.mon_cb.d2h.d_param; + rsp.d_error = cfg.vif.mon_cb.d2h.d_error; + rsp.d_sink = cfg.vif.mon_cb.d2h.d_sink; + rsp.d_size = cfg.vif.mon_cb.d2h.d_size; + rsp.d_user = cfg.vif.mon_cb.d2h.d_user; + + `uvm_info(`gfn, $sformatf("[%0s][d_chan] : %0s", agent_name, rsp.convert2string()), UVM_HIGH) + + d_chan_port.write(rsp); + if (cfg.synchronise_ports) channel_dir_port.write(DataChannel); + + if (cfg.en_cov) cov.sample(rsp); + end + endfunction + + // update ok_to_end to prevent sim finish when there is any pending item + virtual task monitor_ready_to_end(); + forever begin + ok_to_end = (pending_a_req.size() == 0); + if (ok_to_end) wait(pending_a_req.size() > 0); + else wait(pending_a_req.size() == 0); + end + endtask + + virtual function void report_phase(uvm_phase phase); + super.report_phase(phase); + if (pending_a_req.size() > 0) begin + `uvm_error(get_full_name(), $sformatf( + "%0d items left at the end of sim", pending_a_req.size())) + foreach (pending_a_req[i]) begin + `uvm_info(get_full_name(), $sformatf("pending_a_req[%0d] = %0s", + i, pending_a_req[i].convert2string()), UVM_LOW) + end + end + endfunction : report_phase + + // sample outstanding related coverage + virtual function void sample_outstanding_cov(tl_seq_item item); + bit is_outstanding_item_w_same_addr; + + // check if same address has been used in more than 1 outstanding_item + foreach (pending_a_req[i]) begin + if (pending_a_req[i].a_addr == item.a_addr) begin + is_outstanding_item_w_same_addr = 1; + break; + end + end + + // sample a same address used in more than 1 outstanding items, if it's null, design doesn't + // support outstanding items use the same address + if (cov.m_outstanding_item_w_same_addr_cov_obj != null) begin + cov.m_outstanding_item_w_same_addr_cov_obj.sample(is_outstanding_item_w_same_addr); + end + endfunction : sample_outstanding_cov + +endclass : tl_monitor diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_reg_adapter.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_reg_adapter.sv new file mode 100644 index 0000000..ec85e72 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_reg_adapter.sv @@ -0,0 +1,185 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +typedef class tl_host_base_seq; + +// A register adapter parameterized with the default tl_seq_item type. The idea is to extend +// tl_seq_item for further constraints or customizations if required and create the tl_reg_adapter +// instance with the overridden type. + +class tl_reg_adapter #(type ITEM_T = tl_seq_item) extends uvm_reg_adapter; + `uvm_object_param_utils(tl_reg_adapter#(ITEM_T)) + + // Ensure that when an instance of this adapter is created, the cfg handle below is initialized to + // the `tl_agent_cfg` instance associated with this adapter instance. + tl_agent_cfg cfg; + + // Information about how to represent RACL role and uid values in the TL item. This has to be + // configured from the test environment (which can see the dut) because it depends on the + // top-level that is being modelled. + // + // The default is not to support either (so role and uid are both signalled as zero) + local int unsigned role_lsb, role_nbits; + local int unsigned uid_lsb, uid_nbits; + + extern function new(string name = ""); + + // Standard uvm_reg_adapter functions + extern function uvm_sequence_item reg2bus(const ref uvm_reg_bus_op rw); + extern function void bus2reg(uvm_sequence_item bus_item, ref uvm_reg_bus_op rw); + + // Configure and randomise a bus request for a register read or write + extern local function void fill_bus_rd(const ref uvm_reg_bus_op rw, ref ITEM_T bus_req); + extern local function void fill_bus_wr(const ref uvm_reg_bus_op rw, ref ITEM_T bus_req); + + // Return the highest bit index in the target of a uvm_reg_item. This will be the highest bit in a + // field of a register, or will be the bus width if item is a memory. + extern local function int unsigned get_tgt_msb(uvm_reg_item item); + + // Check that the requested bit indices for something will fit in the A channel's user field. + extern local function bit check_user_bit_idx(string field_name, + int unsigned lsb, + int unsigned nbits); + + // Configure how to represent RACL roles and uids + extern function void configure_racl_bits(int unsigned role_lsb, + int unsigned role_nbits, + int unsigned uid_lsb, + int unsigned uid_nbits); +endclass + +function tl_reg_adapter::new(string name = ""); + super.new(name); + // Force the uvm_reg_map to use this sequence to sync with the driver instead. + parent_sequence = tl_host_base_seq#(ITEM_T)::type_id::create("parent_sequence"); + supports_byte_enable = 1; + provides_responses = 1; +endfunction + +function uvm_sequence_item tl_reg_adapter::reg2bus(const ref uvm_reg_bus_op rw); + ITEM_T bus_req = ITEM_T::type_id::create("bus_req"); + + if (rw.kind == UVM_READ) begin + fill_bus_rd (rw, bus_req); + end else begin + fill_bus_wr (rw, bus_req); + end + + if (cfg.csr_access_abort_pct_in_adapter > $urandom_range(0, 100)) begin + bus_req.req_abort_after_a_valid_len = 1; + `uvm_info(`gfn, $sformatf("tl reg req item is allowed to be aborted"), UVM_MEDIUM) + end + `uvm_info(`gfn, {"tl_reg_adapter::reg2bus: ", bus_req.convert2string()}, UVM_HIGH) + return bus_req; +endfunction + +function void tl_reg_adapter::bus2reg(uvm_sequence_item bus_item, ref uvm_reg_bus_op rw); + ITEM_T bus_rsp; + `downcast(bus_rsp, bus_item) + rw.kind = bus_rsp.is_write() ? UVM_WRITE : UVM_READ; + rw.addr = bus_rsp.a_addr; + rw.data = (rw.kind == UVM_WRITE) ? bus_rsp.a_data : bus_rsp.d_data; + rw.byte_en = bus_rsp.a_mask; + `DV_CHECK_EQ(bus_rsp.d_source, bus_rsp.a_source) + // indicate if the item is completed successfully for upper level to update predict value + rw.status = !bus_rsp.req_completed ? UVM_NOT_OK : UVM_IS_OK; + `uvm_info(`gfn, {"tl_reg_adapter::bus2reg: ", bus_rsp.convert2string()}, UVM_HIGH) +endfunction + +function void tl_reg_adapter::fill_bus_rd(const ref uvm_reg_bus_op rw, ref ITEM_T bus_req); + // The tl_seq_item::mask_in_active_lanes_c constraint ensures that a_mask is only asserted in + // active byte lanes. For 50% of CSR full reads (with element_kind == UVM_REG and all bits set in + // byte_en), we ask mask to be asserted for a strict subset of the lanes. + bit is_csr_full_read = (rw.byte_en == '1 && get_item().element_kind == UVM_REG); + + if (!bus_req.randomize() with { + bus_req.a_opcode == tlul_pkg::Get; + bus_req.a_addr[AddrWidth-1:2] == local::rw.addr[AddrWidth-1:2]; + if (local::is_csr_full_read) { + $countones(bus_req.a_mask) dist {MaskWidth :/ 1, [0:MaskWidth-1] :/ 1}; + } else { + bus_req.a_mask == rw.byte_en[MaskWidth-1:0]; + } + }) begin + `uvm_fatal(get_name(), "Failed to randomize bus request for read") + end +endfunction + +function void tl_reg_adapter::fill_bus_wr(const ref uvm_reg_bus_op rw, ref ITEM_T bus_req); + // The TL bus may support byte-enable values, which might be given by allowing some bits of a_mask + // to be zero. Since CSRs in OpenTitan don't support partial accesses, the reg adapter wants to + // choose an a_mask which is true for every byte that exists in the target. + // + // The tl_seq_item::mask_contiguous_c constraint means that we can require that the bytes + // containing bits 0..msb are enabled by just requiring the ends to be enabled. These are the + // bytes with indices 0 and msb / 8. + int unsigned msb = supports_byte_enable ? get_tgt_msb(get_item()) : (DataWidth - 1); + + if (!bus_req.randomize() with { + bus_req.a_opcode inside {PutFullData, PutPartialData}; + bus_req.a_addr == AddrWidth'(rw.addr); + bus_req.a_data == DataWidth'(rw.data); + bus_req.a_mask[0] == 1; + bus_req.a_mask[msb/8] == 1; + }) begin + `uvm_fatal(get_name(), "Failed to randomize bus request for write") + end +endfunction + +function int unsigned tl_reg_adapter::get_tgt_msb(uvm_reg_item item); + case (item.element_kind) + UVM_REG: begin + // We only support registers that are instances of dv_base_reg. These registers have an msb + // position pre-calculated, which gives the highest bit that is contained in any field. + dv_base_reg csr; + if (!$cast(csr, item.element)) begin + `uvm_fatal(get_name(), "Cannot cast UVM_REG item to a dv_base_reg.") + end + return csr.get_msb_pos(); + end + + UVM_FIELD: begin + uvm_reg_field field; + if (!$cast(field, item.element)) begin + `uvm_fatal(get_name(), "Cannot cast UVM_FIELD item to a uvm_reg_field.") + end + return field.get_lsb_pos() + field.get_n_bits() - 1; + end + + UVM_MEM: begin + // Set msb to be the top bit of a_data, forcing all of the a_mask bits to be set. + return DataWidth - 1; + end + + default: + `uvm_fatal(get_name(), $sformatf("Unknown element_kind: %0p", item.element_kind)) + endcase +endfunction + +function bit tl_reg_adapter::check_user_bit_idx(string field_name, + int unsigned lsb, + int unsigned nbits); + if (nbits > 0 && lsb + nbits >= AUserWidth) begin + `uvm_error(this.get_name(), + $sformatf("Cannot represent RACL %s with lsb %0d and %0d bits: AUserWidth is %0d", + field_name, lsb, nbits, AUserWidth)) + return 0; + end + return 1; +endfunction + +function void tl_reg_adapter::configure_racl_bits(int unsigned role_lsb, + int unsigned role_nbits, + int unsigned uid_lsb, + int unsigned uid_nbits); + // Check that both sides can fit in the USER field for the A channel, zeroing out their width if + // not. If either doesn't fit, its call to check_user_bit_idx will have reported a uvm_error. + if (!check_user_bit_idx("role", role_lsb, role_nbits)) role_nbits = 0; + if (!check_user_bit_idx("uid", uid_lsb, uid_nbits)) uid_nbits = 0; + + this.role_lsb = role_lsb; + this.role_nbits = role_nbits; + this.uid_lsb = uid_lsb; + this.uid_nbits = uid_nbits; +endfunction diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_seq_item.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_seq_item.sv new file mode 100644 index 0000000..6c8eb50 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_seq_item.sv @@ -0,0 +1,472 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// --------------------------------------------- +// TileLink sequence item +// --------------------------------------------- + +// An expression that is true if a_opcode is a valid opcode. Using a macro instead of a function +// means that this can be used by the constraint solver. +`define A_OPCODE_IS_VALID(a_opcode) (a_opcode inside {Get, PutFullData, PutPartialData}) + +// An expression that is true if a_mask is true for every active byte lane. (This is required by the +// PutFullData operation). +// +// Note that the expression actually works by checking there are the right *number* of bits set in +// the mask. The alignment requirement is handled separately. +`define MASK_IS_FULL(a_mask, a_size) ($countones(a_mask) == (1 << a_size)) + +// The mask must always be LOW for all inactive byte lanes (see TL specification 1.8.1, p26) +// +// To evaluate this, notice that (1 << a_size) gives the number of active byte lanes. Exponentiating +// again gives ((1 << (1 << a_size)) - 1), which is a pattern of bits that are true for the active +// byte lanes, starting at index zero. +// +// Shifting this left by a_addr[SizeWidth-1:0] gives the pattern of bits for the active byte lanes, +// starting at the correct index. +// +// Invert this and then AND with a_mask. Any bits high in the result are inactive byte lanes that +// are HIGH in the mask. +`define MASK_LOW_IN_INACTIVE_LANES(a_mask, a_addr, a_size) \ + ((a_mask & ~(((1 << (1 << a_size)) - 1) << a_addr[SizeWidth-1:0])) == 0) + +// Addresses should be naturally aligned. The operation addresses (1 << a_size) bytes, so the +// address should be divisible by that. Equivalently, the bottom a_size bits of a_addr should be +// zero. +`define ADDR_ALIGNED_TO_SIZE(a_addr, a_size) ((a_addr & ((1 << a_size) - 1)) == 0) + +// The maximum allowed a_size is 2 (corresponding to a 4-byte / 32-bit operation) +`define BELOW_MAX_A_SIZE(a_size) (a_size <= 2) + +class tl_seq_item extends uvm_sequence_item; + + // This block of variables is the fields that are sent on the A side of the transaction + rand bit [AddrWidth - 1 : 0] a_addr; + rand bit [DataWidth - 1 : 0] a_data; + rand bit [MaskWidth - 1 : 0] a_mask; + rand bit [SizeWidth - 1 : 0] a_size; + rand bit [2:0] a_param; + rand bit [SourceWidth - 1 : 0] a_source; + rand bit [OpcodeWidth - 1 : 0] a_opcode; + rand bit [AUserWidth - 1 : 0] a_user; + + // This block of variables is the fields that are sent on the D side of the transaction + rand bit [2:0] d_param; + rand bit [DataWidth - 1 : 0] d_data; + rand bit [SourceWidth - 1 : 0] d_source; + rand bit [SizeWidth - 1 : 0] d_size; + rand bit [OpcodeWidth - 1 : 0] d_opcode; + rand bit d_error; + rand bit [DUserWidth - 1 : 0] d_user; + rand bit d_sink; + + // When this item is sent by a host-mode driver, this gives the number of cycles that the driver + // will wait before asserting a_valid (the VALID signal for a message on the A channel). + rand int unsigned a_valid_delay; + + // A TileLink message is sent by asserting the VALID signal and waiting for the receiver to assert + // READY. On the A channel, the signals are a_valid and a_ready. When the driver is configured to + // abort early (either by req_abort_after_a_valid_len or cfg.allow_a_valid_drop_wo_a_ready), this + // variable gives the number of cycles that it will assert a_valid before (if a_ready has been low + // throughout) aborting the message by dropping a_valid again. + rand int unsigned a_valid_len; + + // When this item is sent by a device-mode driver, this gives the number of cycles that the driver + // will wait before asserting d_valid (the VALID signal for a message on the D channel). + rand int unsigned d_valid_delay; + + // A TileLink message is sent by asserting the VALID signal and waiting for the receiver to assert + // READY. On the D channel, the signals are d_valid and d_ready. When the driver is configured to + // abort early (either by rsp_abort_after_d_valid_len or cfg.allow_d_valid_drop_wo_d_ready), this + // variable gives the number of cycles that it will assert d_valid before (if d_ready has been low + // throughout) aborting the message by dropping d_valid again. + rand int unsigned d_valid_len; + + // If this flag is true, a host-mode driver will abort sending a message on the A channel after + // waiting a_valid_len cycles for a_ready to be asserted by the other end. + bit req_abort_after_a_valid_len; + + // If this flag is true, a host-mode driver will abort sending a message on the D channel after + // waiting d_valid_len cycles for a_ready to be asserted by the other end. + bit rsp_abort_after_d_valid_len; + + // This signal is filled in by a host-mode driver after it stops sending the item on the A + // channel. It is set to true if the message was accepted and to false if the request was aborted + // (either because of timeout or because a reset was asserted). + bit req_completed; + + // This signal is filled in by a device-mode driver after it stops sending the item on the D + // channel. It is set to true if the message was accepted and to false if the request was aborted + // (either because of timeout or because a reset was asserted). + bit rsp_completed; + + // The a_param and d_param message fields are reserved in the spec for future use. Force them to + // be zero in items that we generate. + extern constraint param_c; + + // Constrain d_error to be false (so the message on the D channel does not report an error). This + // is a soft constraint, and is overridden in e.g. tl_device_seq, which can inject a nonzero + // number of error responses. + extern constraint no_d_error_c; + + // A bound on the time to wait before dropping a_valid if there is no a_ready response. + extern constraint a_valid_len_c; + + // A bound on the time to wait before dropping d_valid if there is no d_ready response. + extern constraint d_valid_len_c; + + // A bound on the time to wait before dropping asserting a_valid / d_valid on the A / D channels, + // respectively. + extern constraint valid_delay_c; + + // Constrain d_opcode to be a valid one for the D channel. + extern constraint d_opcode_c; + + // Constrain a_opcode to be a valid one for the A channel. + extern constraint a_opcode_c; + + // Constrain the mask to be contiguous. Technically, this avoids generating some PutPartialData + // messages that we should probably allow (e.g. a mask of 4'b1001). As a result, that behaviour + // won't be tested by randomised testing. + extern constraint mask_contiguous_c; + + // Require that the mask is high for all active byte lanes for a PutFullData message. + extern constraint mask_w_PutFullData_c; + + // Require that the mask is only high in active lanes. + extern constraint mask_in_active_lanes_c; + + // Require that a_addr is naturally aligned for an operation touching (1 << a_size) bytes. + extern constraint addr_size_align_c; + + // Require that a_size is at most 2 (this constrains messages to be at most 32 bits, so disallows + // multi-beat messages). + extern constraint max_size_c; + + `uvm_object_utils_begin(tl_seq_item) + `uvm_field_int (a_addr, UVM_DEFAULT) + `uvm_field_int (a_data, UVM_DEFAULT) + `uvm_field_int (a_mask, UVM_DEFAULT) + `uvm_field_int (a_size, UVM_DEFAULT) + `uvm_field_int (a_param, UVM_DEFAULT) + `uvm_field_int (a_source, UVM_DEFAULT) + `uvm_field_int (a_opcode, UVM_DEFAULT) + `uvm_field_int (a_user, UVM_DEFAULT) + `uvm_field_int (d_param, UVM_DEFAULT) + `uvm_field_int (d_source, UVM_DEFAULT) + `uvm_field_int (d_data, UVM_DEFAULT) + `uvm_field_int (d_size, UVM_DEFAULT) + `uvm_field_int (d_opcode, UVM_DEFAULT) + `uvm_field_int (d_error, UVM_DEFAULT) + `uvm_field_int (d_sink, UVM_DEFAULT) + `uvm_field_int (d_user, UVM_DEFAULT) + `uvm_field_int (a_valid_delay, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (d_valid_delay, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (a_valid_len, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (d_valid_len, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (req_abort_after_a_valid_len, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (rsp_abort_after_d_valid_len, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (req_completed, UVM_DEFAULT | UVM_NOPACK) + `uvm_field_int (rsp_completed, UVM_DEFAULT | UVM_NOPACK) + `uvm_object_utils_end + + extern function new (string name = ""); + extern function string convert2string(); + extern function bit do_compare(uvm_object rhs, uvm_comparer comparer); + + // Set rand_mode(0) for all fields relating to the A channel. This is used when re-randomising an + // item that has already been populated with data from that channel. + extern function void disable_a_chan_randomization(); + + // The expected value of d_error based on the fields from the A channel item + extern function bit get_exp_d_error(); + + // Return true if a_opcode is not a valid opcode for the A channel. + extern function bit get_error_a_opcode_invalid(); + + // Return the data that is being written by this transaction on the A channel. This is the + // contents of a_data, but masked by zeroing the bytes where a_mask is false. + extern function automatic logic [DataWidth-1:0] get_written_data(); + + // Return true if the A channel for this item is a PutFullData message and the a_mask field is not + // high for all the active byte lanes. + extern function bit get_error_PutFullData_mask_size_mismatched(); + + // Return true if the A channel message for this item has an a_addr that is not naturally aligned + // for the operation size implied by a_size. + extern function bit get_error_addr_size_misaligned(); + + // Return true if the A channel message for this item has bits in a_mask that are high in lanes + // that are inactive (based on a_addr and a_size). + extern function bit get_error_mask_not_in_active_lanes(); + + // Return true if the A channel message for this item gives an a_size larger than the biggest + // allowed by OpenTitan tilelink (32 bits, so 4 bytes, so a_size of 2) + extern function bit get_error_size_over_max(); + + // Disable the constraints that apply to the A channel fields. This can be used to generate + // sequence items that will (almost certainly) cause protocol errors. + extern function void disable_a_chan_protocol_constraint(); + + // Randomise the A channel fields, ensuring that at least one constraint is disabled and the + // protocol is violated. + extern function void randomize_a_chan_with_protocol_error(); + + // Return true if this sequence item is a write (as opposed to a read). + extern function bit is_write(); + + // Return true if the values in the fields of the D channel message are appropriate as a response + // to the A channel message. + extern function bit is_ok(); + + // Compute and check the integrity of the a_channel payload. + // + // The TL agent is generic and adheres to the TLUL spec, which does not define + // how the integrity of the payload on each channel is computed / checked. That + // is up to the chip implementation. Typically, parity / ECC scheme is used, with + // the redundant bits transmitted through *_user. + // + // Returns 1 if the integrity of a_channel is maintained, 0 otherwise. This base + // class implementation vacuously returns 1. + extern virtual function bit is_a_chan_intg_ok(bit throw_error = 1'b1); + + // d_channel version of the function above + extern virtual function bit is_d_chan_intg_ok(bit en_rsp_intg_chk = 1, + bit en_data_intg_chk = 1, + bit throw_error = 1'b1); +endclass + +constraint tl_seq_item::param_c { + a_param == 0; + d_param == 0; +} + +constraint tl_seq_item::no_d_error_c { + soft d_error == 0; +} + +constraint tl_seq_item::a_valid_len_c { + a_valid_len inside {[1:10]}; +} + +constraint tl_seq_item::d_valid_len_c { + d_valid_len inside {[1:10]}; +} + +constraint tl_seq_item::valid_delay_c { + a_valid_delay inside {[0:50]}; + d_valid_delay inside {[0:50]}; +} + +constraint tl_seq_item::d_opcode_c { + d_opcode inside {AccessAckData, AccessAck}; +} + +constraint tl_seq_item::a_opcode_c { + `A_OPCODE_IS_VALID(a_opcode); +} + +constraint tl_seq_item::mask_contiguous_c { + $countones(a_mask ^ {a_mask[MaskWidth-2:0], 1'b0}) <= 2; +} + +constraint tl_seq_item::mask_w_PutFullData_c { + a_opcode == PutFullData -> `MASK_IS_FULL(a_mask, a_size); +} + +constraint tl_seq_item::mask_in_active_lanes_c { + `MASK_LOW_IN_INACTIVE_LANES(a_mask, a_addr, a_size); +} + +constraint tl_seq_item::addr_size_align_c { + `ADDR_ALIGNED_TO_SIZE(a_addr, a_size); +} + +constraint tl_seq_item::max_size_c { + `BELOW_MAX_A_SIZE(a_size); +} + +function tl_seq_item::new (string name = ""); + super.new(name); +endfunction + +function string tl_seq_item::convert2string(); + string str; + string a_opcode_name, d_opcode_name; + tl_a_op_e a_op_e; + tl_d_op_e d_op_e; + if ($cast(a_op_e, a_opcode)) a_opcode_name = a_op_e.name(); + else a_opcode_name = $sformatf("Invalid, value: %0d", a_opcode); + if ($cast(d_op_e, d_opcode)) d_opcode_name = d_op_e.name(); + else d_opcode_name = $sformatf("Invalid, value: %0d", d_opcode); + + str = {$sformatf("a_addr = 0x%0h ", a_addr), + $sformatf("a_data = 0x%0h ", a_data), + $sformatf("a_mask = 0x%0h ", a_mask), + $sformatf("a_size = 0x%0h ", a_size), + $sformatf("a_param = 0x%0h ", a_param), + $sformatf("a_source = 0x%0h ", a_source), + $sformatf("a_opcode = %0s ", a_opcode_name), + $sformatf("a_user = 0x%0h ", a_user), + $sformatf("d_data = 0x%0h ", d_data), + $sformatf("d_size = 0x%0h ", d_size), + $sformatf("d_param = 0x%0h ", d_param), + $sformatf("d_source = 0x%0h ", d_source), + $sformatf("d_opcode = %0s ", d_opcode_name), + $sformatf("d_error = %0b ", d_error), + $sformatf("d_user = %0b ", d_user), + $sformatf("d_sink = %0b ", d_sink), + $sformatf("req_abort_after_a_valid_len = %0b ", req_abort_after_a_valid_len), + $sformatf("rsp_abort_after_d_valid_len = %0b ", rsp_abort_after_d_valid_len), + $sformatf("req_completed = %0b ", req_completed), + $sformatf("rsp_completed = %0b ", rsp_completed)}; + return str; +endfunction + +function void tl_seq_item::disable_a_chan_randomization(); + a_addr.rand_mode(0); + a_data.rand_mode(0); + a_mask.rand_mode(0); + a_size.rand_mode(0); + a_param.rand_mode(0); + a_source.rand_mode(0); + a_opcode.rand_mode(0); +endfunction + +function bit tl_seq_item::get_exp_d_error(); + return get_error_a_opcode_invalid() || get_error_PutFullData_mask_size_mismatched() || + get_error_addr_size_misaligned() || + get_error_mask_not_in_active_lanes() || get_error_size_over_max(); +endfunction + +function bit tl_seq_item::get_error_a_opcode_invalid(); + return !`A_OPCODE_IS_VALID(a_opcode); +endfunction + +function automatic logic [DataWidth-1:0] tl_seq_item::get_written_data(); + logic [DataWidth-1:0] masked_data = 'x; + `DV_CHECK(is_write(), "get_written_data() may only be called on a write") + for (int i = 0; i < MaskWidth; i++) begin + if (a_mask[i] == 1'b1) begin + masked_data[8*i +: 8] = a_data[8*i +: 8]; + end + end + return masked_data; +endfunction + +function bit tl_seq_item::get_error_PutFullData_mask_size_mismatched(); + return (a_opcode == PutFullData) && !(`MASK_IS_FULL(a_mask, a_size)); +endfunction + +function bit tl_seq_item::get_error_addr_size_misaligned(); + return !(`ADDR_ALIGNED_TO_SIZE(a_addr, a_size)); +endfunction + +function bit tl_seq_item::get_error_mask_not_in_active_lanes(); + return !`MASK_LOW_IN_INACTIVE_LANES(a_mask, a_addr, a_size); +endfunction + +function bit tl_seq_item::get_error_size_over_max(); + return !`BELOW_MAX_A_SIZE(a_size); +endfunction // get_error_size_over_max + +// Note: the do_compare() method should only be coded for those properties which can be compared +// that's the reason why the following fields are not part it: +// req_abort_after_a_valid_len, rsp_abort_after_d_valid_len, req_completed, rsp_completed +function bit tl_seq_item::do_compare(uvm_object rhs, uvm_comparer comparer); + tl_seq_item rhs_; + // If the cast fails, comparison has also failed + // A check for null is not needed because that is done in the compare() function which + // calls do_compare() + if (!$cast(rhs_, rhs)) begin + return 0; + end + + return (super.do_compare(rhs, comparer) && + (a_addr == rhs_.a_addr ) && + (a_data == rhs_.a_data ) && + (a_mask == rhs_.a_mask ) && + (a_size == rhs_.a_size ) && + (a_param == rhs_.a_param ) && + (a_source == rhs_.a_source ) && + (a_opcode == rhs_.a_opcode ) && + (a_user == rhs_.a_user ) && + (d_data == rhs_.d_data ) && + (d_size == rhs_.d_size ) && + (d_param == rhs_.d_param ) && + (d_source == rhs_.d_source ) && + (d_opcode == rhs_.d_opcode ) && + (d_error == rhs_.d_error ) && + (d_user == rhs_.d_user ) && + (d_sink == rhs_.d_sink )); +endfunction + +function void tl_seq_item::disable_a_chan_protocol_constraint(); + a_opcode_c.constraint_mode(0); + mask_contiguous_c.constraint_mode(0); + mask_w_PutFullData_c.constraint_mode(0); + mask_in_active_lanes_c.constraint_mode(0); + addr_size_align_c.constraint_mode(0); + max_size_c.constraint_mode(0); +endfunction + +function void tl_seq_item::randomize_a_chan_with_protocol_error(); + bit cm_a_opcode, cm_mask_w_PutFullData; + bit cm_mask_in_active_lanes, cm_addr_size_align, cm_max_size; + + // Randomly pick some constraint mode (enabled or disabled) for the various constraints, disabling + // at least one of them. + `DV_CHECK_FATAL(std::randomize(cm_a_opcode, cm_mask_w_PutFullData, + cm_mask_in_active_lanes, cm_addr_size_align, cm_max_size) with { + !(&{cm_a_opcode, cm_mask_w_PutFullData, + cm_mask_in_active_lanes, cm_addr_size_align && cm_max_size}); + }) + + // Apply the selected modes to the constraints that might be disabled + a_opcode_c.constraint_mode(cm_a_opcode); + mask_w_PutFullData_c.constraint_mode(cm_mask_w_PutFullData); + mask_in_active_lanes_c.constraint_mode(cm_mask_in_active_lanes); + addr_size_align_c.constraint_mode(cm_addr_size_align); + max_size_c.constraint_mode(cm_max_size); + + // Now randomise this object, ensuring that at least constraint we just disabled is actually being + // violated. + `DV_CHECK_FATAL(randomize() with { + (!cm_a_opcode && !`A_OPCODE_IS_VALID(a_opcode)) || + (!cm_mask_w_PutFullData && + (a_opcode == PutFullData) && !(`MASK_IS_FULL(a_mask, a_size))) || + (!cm_mask_in_active_lanes && + !(`MASK_LOW_IN_INACTIVE_LANES(a_mask, a_addr, a_size))) || + (!cm_addr_size_align && !`ADDR_ALIGNED_TO_SIZE(a_addr, a_size)) || + (!cm_max_size && !`BELOW_MAX_A_SIZE(a_size)); + }) +endfunction + +function bit tl_seq_item::is_write(); + return (a_opcode inside {PutFullData, PutPartialData}); +endfunction + +function bit tl_seq_item::is_ok(); + // For this to be an appropriate response, the D channel has to hold something that could be a + // response to the request on the A channel. For a Get, TileLink expects an AccessAckData; for a + // write or error opcode, it expects AccessAck + tl_d_op_e exp_d_opcode = (a_opcode == Get) ? tlul_pkg::AccessAckData : tlul_pkg::AccessAck; + return (d_opcode == exp_d_opcode) && (a_source == d_source); +endfunction + +function bit tl_seq_item::is_a_chan_intg_ok(bit throw_error = 1'b1); + return 1; +endfunction + +function bit tl_seq_item::is_d_chan_intg_ok(bit en_rsp_intg_chk = 1, + bit en_data_intg_chk = 1, + bit throw_error = 1'b1); + return 1; +endfunction + +`undef BELOW_MAX_A_SIZE +`undef ADDR_ALIGNED_TO_SIZE +`undef MASK_LOW_IN_INACTIVE_LANES +`undef MASK_IS_FULL +`undef A_OPCODE_IS_VALID diff --git a/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_sequencer.sv b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_sequencer.sv new file mode 100644 index 0000000..7d7557e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/tl_agent/tl_sequencer.sv @@ -0,0 +1,17 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class tl_sequencer extends dv_base_sequencer#(tl_seq_item, tl_agent_cfg); + `uvm_component_utils(tl_sequencer) + + uvm_tlm_analysis_fifo#(tl_seq_item) a_chan_req_fifo; + + `uvm_component_new + + function void build_phase(uvm_phase phase); + super.build_phase(phase); + a_chan_req_fifo = new("a_chan_req_fifo", this); + endfunction : build_phase + +endclass : tl_sequencer diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/README.md b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/README.md new file mode 100644 index 0000000..e39fe4a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/README.md @@ -0,0 +1,3 @@ +# UART Agent + +**TODO** diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_base_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_base_seq.sv new file mode 100644 index 0000000..7168cd8 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_base_seq.sv @@ -0,0 +1,18 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_base_seq extends dv_base_seq #( + .REQ (uart_item), + .CFG_T (uart_agent_cfg), + .SEQUENCER_T (uart_sequencer) + ); + `uvm_object_utils(uart_base_seq) + + `uvm_object_new + + task body(); + `uvm_error(`gfn, "Need to override this when you extend from this class!") + endtask : body + +endclass : uart_base_seq diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_default_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_default_seq.sv new file mode 100644 index 0000000..d2c07d9 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_default_seq.sv @@ -0,0 +1,18 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// drive everything 0 for testing break error +class uart_default_seq extends uart_seq; + `uvm_object_utils(uart_default_seq) + + constraint parity_err_c { + parity_err == 0; + } + constraint frame_err_c { + frame_err == 0; + } + + `uvm_object_new + +endclass : uart_default_seq diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_seq.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_seq.sv new file mode 100644 index 0000000..45502c7 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_seq.sv @@ -0,0 +1,37 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_seq extends uart_base_seq; + `uvm_object_utils(uart_seq) + + rand bit [7:0] data; + rand bit parity_err; + rand bit parity; + rand bit frame_err; + + constraint parity_c { + if (parity_err) { + parity != `GET_PARITY(data, p_sequencer.cfg.odd_parity); + } else { + parity == `GET_PARITY(data, p_sequencer.cfg.odd_parity); + } + } + `uvm_object_new + + task body(); + `uvm_info(`gfn, $sformatf("starting uart rx byte xfer seq: 0x%0h", data), UVM_HIGH) + req = uart_item::type_id::create("req"); + start_item(req); + req.stop_bit_c.constraint_mode(0); + `DV_CHECK_RANDOMIZE_WITH_FATAL(req, + data == local::data; + parity == local::parity; + stop_bit == !frame_err; + ) + finish_item(req); + get_response(rsp); + `uvm_info(`gfn, "uart rx byte xfer done", UVM_HIGH) + endtask + +endclass : uart_seq diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_seq_list.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_seq_list.sv new file mode 100644 index 0000000..994668a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/seq_lib/uart_seq_list.sv @@ -0,0 +1,7 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +`include "uart_base_seq.sv" +`include "uart_seq.sv" +`include "uart_default_seq.sv" diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent.core b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent.core new file mode 100644 index 0000000..f95aa93 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent.core @@ -0,0 +1,32 @@ +CAPI=2: +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +name: "lowrisc:dv:uart_agent:0.1" +description: "UART DV UVM agent" +filesets: + files_dv: + depend: + - lowrisc:dv:dv_utils + - lowrisc:dv:dv_lib + files: + - uart_if.sv + - uart_agent_pkg.sv + - uart_item.sv: {is_include_file: true} + - uart_agent_cfg.sv: {is_include_file: true} + - uart_agent_cov.sv: {is_include_file: true} + - uart_driver.sv: {is_include_file: true} + - uart_monitor.sv: {is_include_file: true} + - uart_sequencer.sv: {is_include_file: true} + - uart_logger.sv: {is_include_file: true} + - uart_agent.sv: {is_include_file: true} + - seq_lib/uart_seq_list.sv: {is_include_file: true} + - seq_lib/uart_base_seq.sv: {is_include_file: true} + - seq_lib/uart_default_seq.sv: {is_include_file: true} + - seq_lib/uart_seq.sv: {is_include_file: true} + file_type: systemVerilogSource + +targets: + default: + filesets: + - files_dv diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent.sv new file mode 100644 index 0000000..755d8d3 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent.sv @@ -0,0 +1,44 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_agent extends dv_base_agent#( + .CFG_T (uart_agent_cfg), + .DRIVER_T (uart_driver), + .SEQUENCER_T (uart_sequencer), + .MONITOR_T (uart_monitor), + .COV_T (uart_agent_cov) + ); + `uvm_component_utils(uart_agent) + + uart_logger m_logger; + + `uvm_component_new + + function void build_phase(uvm_phase phase); + super.build_phase(phase); + // get uart_if handle + if (!uvm_config_db#(virtual uart_if)::get(this, "", "vif", cfg.vif)) begin + `uvm_fatal(`gfn, "failed to get uart_if handle from uvm_config_db") + end + + // Create the logger instance. + if (cfg.en_logger) begin + m_logger = uart_logger::type_id::create("m_logger", this); + m_logger.cfg = cfg; + end + endfunction + + function void connect_phase(uvm_phase phase); + super.connect_phase(phase); + // Connect the logger TLM port to the monitor. + if (cfg.en_logger) begin + if (cfg.use_rx_for_logger) begin + monitor.rx_analysis_port.connect(m_logger.log_item_fifo.analysis_export); + end else begin + monitor.tx_analysis_port.connect(m_logger.log_item_fifo.analysis_export); + end + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_cfg.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_cfg.sv new file mode 100644 index 0000000..4614e06 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_cfg.sv @@ -0,0 +1,103 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_agent_cfg extends dv_base_agent_cfg; + + bit en_rx_checks = 1'b1; // enable RX checks (implemented in monitor) + bit en_tx_checks = 1'b1; // enable TX checks (implemented in monitor) + bit en_rx_monitor = 1'b1; // enable RX monitor + bit en_tx_monitor = 1'b1; // enable TX monitor + + // device specific cfg + baud_rate_e baud_rate; + bit en_parity; + bit odd_parity; + + // Controls upto what percentage of the clock period the RX is randomly glitched every 1ns. + // RX is glitched at the start of the clock to ensure that the design is robust enough to sample + // the correct value (typically at the center of the clock). The recommended range for this value + // is 0-10%. + local uint uart_period_glitch_pct = 10; + + // Logger settings. + bit en_logger = 1'b0; // enable logger on tx + bit use_rx_for_logger = 1'b0; // use rx instead of tx + bit write_logs_to_file = 1'b1; + + // interface handle used by driver, monitor & the sequencer + virtual uart_if vif; + + // The actual UART clock is not perfectly aligned to the baud rate. The clock btw transmitter and + // receiver can have certain difference + // driver is using perfect baud rate. Here is the max allowed clock drift for design comparing the + // ideal baud rate, This number must be less than 50 + // if set 20 here, received data must be ready to sample and stable at 30%-70% of the cycle + local uint max_drift_cycle_pct = 25; + + `uvm_object_utils_begin(uart_agent_cfg) + `uvm_field_int(en_rx_checks, UVM_DEFAULT) + `uvm_field_int(en_tx_checks, UVM_DEFAULT) + `uvm_field_int(en_tx_monitor, UVM_DEFAULT) + `uvm_field_int(en_rx_monitor, UVM_DEFAULT) + `uvm_field_int(en_parity, UVM_DEFAULT) + `uvm_field_int(odd_parity, UVM_DEFAULT) + `uvm_field_enum(baud_rate_e, baud_rate, UVM_DEFAULT) + `uvm_field_int(uart_period_glitch_pct, UVM_DEFAULT) + `uvm_object_utils_end + + `uvm_object_new + + function void set_uart_period_glitch_pct(uint pct); + `DV_CHECK_LT_FATAL(pct, 20) + uart_period_glitch_pct = pct; + endfunction + + function uint get_uart_period_glitch_pct(); + return uart_period_glitch_pct; + endfunction + + function void set_baud_rate(baud_rate_e b); + baud_rate = b; + vif.uart_clk_period = (get_baud_rate_period_ns(b) * 1ns); + endfunction + + function void set_parity(bit en_parity, bit odd_parity); + this.en_parity = en_parity; + this.odd_parity = odd_parity; + endfunction + + function void set_max_drift_cycle_pct(uint pct); + `DV_CHECK_LT_FATAL(pct, 50) + max_drift_cycle_pct = pct; + endfunction + + function int get_max_drift_cycle_pct(); + return max_drift_cycle_pct; + endfunction + + // Update dv_base_agent_cfg::in_reset to match the fact the interface has just gone into reset. + // This is needed because the uart interface doesn't have a reset pin, so its "notional reset" + // needs to be controlled from a higher level. + virtual function void reset_asserted(); + in_reset = 1; + endfunction + + // Update dv_base_agent_cfg::in_reset to match the fact the interface has just left reset. This is + // needed because the uart interface doesn't have a reset pin, so its "notional reset" needs to be + // controlled from a higher level. + // + // As well as updating in_reset, this function clears an interface and may re-enable some + // monitoring. + virtual function void reset_deasserted(bit re_enable_chk_mon = 1); + in_reset = 0; + vif.reset_uart_rx(); + if (re_enable_chk_mon) begin + en_rx_checks = 1; + en_tx_checks = 1; + en_rx_monitor = 1; + en_tx_monitor = 1; + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_cov.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_cov.sv new file mode 100644 index 0000000..a61e811 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_cov.sv @@ -0,0 +1,33 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_agent_cov extends dv_base_agent_cov #(uart_agent_cfg); + `uvm_component_utils(uart_agent_cov) + + covergroup uart_cg with function sample(uart_dir_e dir, uart_item item); + cp_dir: coverpoint dir; + cp_data: coverpoint item.data; + cp_en_parity: coverpoint cfg.en_parity; + cp_odd_parity: coverpoint cfg.odd_parity; + cp_baud_rate: coverpoint cfg.baud_rate; + cross cp_dir, cp_data, cp_en_parity, cp_odd_parity, cp_baud_rate; + endgroup + + // sample reset at every bit location in both direction + covergroup uart_reset_cg with function sample(uart_dir_e dir, int bit_position); + cp_dir: coverpoint dir; + cp_rst_pos: coverpoint bit_position { + // including parity, totally NUM_BIT_START_DATA_STOP+1 bits + bins values[] = {[0:NUM_UART_XFER_BITS_WO_PARITY]}; + } + cross cp_dir, cp_rst_pos; + endgroup + + function new(string name, uvm_component parent); + super.new(name, parent); + uart_cg = new(); + uart_reset_cg = new(); + endfunction : new + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_pkg.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_pkg.sv new file mode 100644 index 0000000..b99572b --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_agent_pkg.sv @@ -0,0 +1,63 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +package uart_agent_pkg; + // dep packages + import uvm_pkg::*; + import dv_utils_pkg::*; + import dv_base_agent_pkg::*; + import dv_lib_pkg::*; + + // macro includes + `include "uvm_macros.svh" + `include "dv_macros.svh" + + // 1 start + 8 data + 1 stop + parameter uint NUM_UART_XFER_BITS_WO_PARITY = 10; + + // local types + typedef enum bit { + UartTx, + UartRx + } uart_dir_e; + + // Max standard baudrate is 256000 bps in the link below, so 1M should be 1024000 + // Refer to www.ece.northwestern.edu/local-apps/matlabhelp/techdoc/matlab_external/baudrate.html + typedef enum int { + BaudRate9600 = 9600, + BaudRate115200 = 115200, + BaudRate230400 = 230400, + BaudRate128Kbps = 128000, + BaudRate256Kbps = 256000, + BaudRate1Mbps = 1000000, + BaudRate1p5Mbps = 1500000 + } baud_rate_e; + + // functions + function automatic real get_baud_rate_period_ns(baud_rate_e baud_rate); + // return 10^9 / baud_rate ns upto 3 decimal places + case(baud_rate) + BaudRate9600 : return 104166.667; + BaudRate115200: return 8680.556; + BaudRate230400: return 4340.278; + BaudRate128Kbps: return 7812.5; + BaudRate256Kbps: return 3906.25; + BaudRate1Mbps : return 1000; + BaudRate1p5Mbps: return 666.667; + default: `uvm_fatal("uart_agent_pkg", $sformatf("Unsupported baud_rate: %0d", baud_rate)) + endcase + endfunction + + // package sources + `include "uart_item.sv" + `include "uart_agent_cfg.sv" + `include "uart_agent_cov.sv" + `include "uart_monitor.sv" + `include "uart_driver.sv" + `include "uart_sequencer.sv" + `include "uart_logger.sv" + `include "uart_agent.sv" + `include "uart_seq_list.sv" + +endpackage diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_driver.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_driver.sv new file mode 100644 index 0000000..7cd64da --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_driver.sv @@ -0,0 +1,74 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_driver extends dv_base_driver #(uart_item, uart_agent_cfg); + `uvm_component_utils(uart_driver) + + `uvm_component_new + + task on_enter_reset(); + cfg.vif.reset_uart_rx(); + endtask + + // Sets the value of rx after randomly glitching for 10% of uart clk + task set_rx(input bit val); + uint glitch_ns = uint'(cfg.vif.uart_clk_period * cfg.get_uart_period_glitch_pct() / 100 / 1ns); + repeat (glitch_ns) begin + if (!cfg.in_reset) begin + cfg.vif.uart_rx <= $urandom_range(0, 1); + #1ns; + end + end + cfg.vif.uart_rx <= val; + endtask + + // Drives transfers. + virtual task get_and_drive(); + bit send_data[]; + forever begin + seq_item_port.get(req); + $cast(rsp, req.clone()); + rsp.set_id_info(req); + if (!cfg.in_reset) begin + `uvm_info(`gfn, $sformatf("starting to send rx item: %0s", rsp.sprint()), UVM_HIGH) + // we send parity if enabled or if overridden in the req + if (cfg.en_parity ^ req.ovrd_en_parity) begin + send_data = new[NUM_UART_XFER_BITS_WO_PARITY + 1]; // + 1 for parity bit + {<<{send_data}} = {req.stop_bit, req.parity, req.data, req.start_bit}; + end + else begin + send_data = new[NUM_UART_XFER_BITS_WO_PARITY]; + {<<{send_data}} = {req.stop_bit, req.data, req.start_bit}; + end + // send data on uart_rx + for (int i = 0; i < send_data.size(); i++) begin + set_rx(send_data[i]); + wait_uart_rx_cycle(); + end + `uvm_info(`gfn, $sformatf("finished sending rx item: %0s", rsp.sprint()), UVM_HIGH) + end + if (cfg.in_reset) begin + `uvm_info(`gfn, $sformatf("Reset happens and drop rx item: %0s", rsp.sprint()), UVM_HIGH) + end + seq_item_port.put_response(rsp); + end + endtask + + virtual task wait_uart_rx_cycle(); + fork + begin : isolation_fork + fork + begin + wait(cfg.in_reset); + end + begin + @(cfg.vif.drv_rx_mp.drv_rx_cb); + end + join_any + disable fork; + end : isolation_fork + join + endtask + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_if.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_if.sv new file mode 100644 index 0000000..43d592a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_if.sv @@ -0,0 +1,65 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +// +interface uart_if #(realtime UartDefaultClkPeriod = 104166.667ns) (); + wire uart_tx; + logic uart_rx; + + // generate local clk + realtime uart_clk_period = UartDefaultClkPeriod; + bit uart_tx_clk = 1'b1; + int uart_tx_clk_pulses = 0; + bit uart_rx_clk = 1'b1; + int uart_rx_clk_pulses = 0; + + // UART TX from the DUT when signaled over muxed IOs can experience glitches in the same + // time-step (a simulation artifact). Delaying by 1ps eliminates them. + wire uart_tx_int; + assign #1ps uart_tx_int = uart_tx; + + clocking mon_tx_cb @(negedge uart_tx_clk); + input #10ns uart_tx_int; + endclocking + modport mon_tx_mp(clocking mon_tx_cb); + + clocking drv_rx_cb @(posedge uart_rx_clk); + output uart_rx; + endclocking + modport drv_rx_mp(clocking drv_rx_cb); + + clocking mon_rx_cb @(negedge uart_rx_clk); + input #10ns uart_rx; + endclocking + modport mon_rx_mp(clocking mon_rx_cb); + + function automatic void reset_uart_rx(); + uart_rx = 1; + endfunction + + task automatic wait_for_tx_idle(); + wait(uart_tx_clk_pulses == 0); + endtask + + task automatic wait_for_rx_idle(); + wait(uart_rx_clk_pulses == 0); + endtask + + task automatic wait_for_idle(); + fork + wait_for_tx_idle(); + wait_for_rx_idle(); + join + endtask + + task automatic drive_uart_rx_glitch(int max_glitch_ps, int stable_ps_after_glitch); + uart_rx = ~uart_rx; + randcase + 1: #(max_glitch_ps * 1ps); + 1: #($urandom_range(1, max_glitch_ps) * 1ps); + endcase + uart_rx = ~uart_rx; + #(stable_ps_after_glitch * 1ps); + endtask + +endinterface diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_item.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_item.sv new file mode 100644 index 0000000..ed1b37b --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_item.sv @@ -0,0 +1,46 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_item extends uvm_sequence_item; + + // start and stop bits + rand bit start_bit = 1'b0; + rand bit stop_bit = 1'b1; + + // byte of data sent or received + rand bit [7:0] data; + + // calculated parity of data sent or received + rand bit parity; + + // allow driver to override sending parity + rand bit ovrd_en_parity = 1'b0; + + // dont override start_bit unless testing an error scenario + constraint start_bit_c { + start_bit == 1'b0; + } + + // dont override stop_bit unless testing an error scenario + constraint stop_bit_c { + stop_bit == 1'b1; + } + + // dont override parity setting unless testing an error scenario + constraint ovrd_en_parity_c { + ovrd_en_parity == 1'b0; + } + + `uvm_object_utils_begin(uart_item) + `uvm_field_int(start_bit, UVM_DEFAULT | UVM_NOCOMPARE | UVM_NOPRINT) + `uvm_field_int(data, UVM_DEFAULT) + // parity & stop_bit are checked in monitor + `uvm_field_int(parity, UVM_DEFAULT | UVM_NOCOMPARE) + `uvm_field_int(stop_bit, UVM_DEFAULT | UVM_NOCOMPARE | UVM_NOPRINT) + `uvm_field_int(ovrd_en_parity, UVM_DEFAULT | UVM_NOCOMPARE | UVM_NOPRINT) + `uvm_object_utils_end + + `uvm_object_new + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_logger.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_logger.sv new file mode 100644 index 0000000..3bf4485 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_logger.sv @@ -0,0 +1,98 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_logger extends uvm_component; + `uvm_component_utils(uart_logger) + + int logs_output_fd = 0; + + uart_agent_cfg cfg; + uvm_tlm_analysis_fifo #(uart_item) log_item_fifo; + uvm_analysis_port #(string) log_analysis_port; + + `uvm_component_new + + virtual function void build_phase(uvm_phase phase); + log_item_fifo = new("log_item_fifo", this); + log_analysis_port = new("log_analysis_port", this); + endfunction + + virtual task run_phase(uvm_phase phase); + string fname = {`gfn, ".log"}; + if (cfg.write_logs_to_file) begin + logs_output_fd = $fopen(fname, "w"); + `DV_CHECK_FATAL((logs_output_fd !=0), $sformatf("Failed to open %s for writing", fname)) + end + capture_logs(); + endtask + + virtual function void final_phase(uvm_phase phase); + if (logs_output_fd != 0) $fclose(logs_output_fd); + endfunction + + // Captures bytes received from UART TX port and constructs the logs for printing. + virtual task capture_logs(); + uart_item item; + string char; + string log; + byte lf = 8'ha; // \n + byte cr = 8'hd; // \r + + fork + forever begin + log_item_fifo.get(item); + char = string'(item.data); + `uvm_info(`gfn, $sformatf("received char: %0s", char), UVM_DEBUG) + // Continue concatenating chars into the log string until lf or cr is encountered. + if (item.data inside {lf, cr}) begin + print_log(log); + log_analysis_port.write(log); + log = ""; + end + else begin + log = {log, char}; + end + end + forever begin + // reset thread - if reset occurs, reset the log to an empty string. + @(cfg.in_reset); + if (cfg.in_reset) log = ""; + end + join + endtask + + // Print log with the right severity. Severity is extracted from the log string. + // See sw/device/lib/runtime/log.h for details on how the severity is indicated. + // TODO: Add support for verbosity when the severity is info. + virtual function void print_log(string log); + string info = "INFO: *"; + string warn = "WARNING: *"; + string error = "ERROR: *"; + string fatal = "FATAL: *"; + + if (log == "") return; + case (1) + (!uvm_re_match(info, log)): begin + `uvm_info(`gfn, log.substr(info.len() - 1, log.len() - 1), UVM_LOW) + end + (!uvm_re_match(warn, log)): begin + // verilog_lint: waive forbidden-macro + `uvm_warning(`gfn, log.substr(warn.len() - 1, log.len() - 1)) + end + (!uvm_re_match(error, log)): begin + `uvm_error(`gfn, log.substr(error.len() - 1, log.len() - 1)) + end + (!uvm_re_match(fatal, log)): begin + `uvm_fatal(`gfn, log.substr(fatal.len() - 1, log.len() - 1)) + end + default: begin + `uvm_info(`gfn, log, UVM_LOW) + end + endcase + if (logs_output_fd != 0) begin + $fwrite(logs_output_fd, "[%15t]: %0s\n", $time, log); + end + endfunction + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_monitor.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_monitor.sv new file mode 100644 index 0000000..c53e450 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_monitor.sv @@ -0,0 +1,211 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + + +class uart_monitor extends dv_base_monitor#( + .ITEM_T (uart_item), + .CFG_T (uart_agent_cfg), + .COV_T (uart_agent_cov) + ); + `uvm_component_utils(uart_monitor) + + // Analysis port for the collected transfer. + uvm_analysis_port #(uart_item) tx_analysis_port; + uvm_analysis_port #(uart_item) rx_analysis_port; + + `uvm_component_new + + function void build_phase(uvm_phase phase); + super.build_phase(phase); + tx_analysis_port = new("tx_analysis_port", this); + rx_analysis_port = new("rx_analysis_port", this); + endfunction + + task run_phase(uvm_phase phase); + forever begin + fork + collect_tx_data(); + collect_rx_data(); + drive_tx_clk(); + drive_rx_clk(); + mon_tx_stable(); + wait(cfg.in_reset); + join_any + disable fork; + + if (cfg.in_reset) process_reset(); + end + endtask + + virtual task collect_tx_data(); + uart_item item; + forever begin + if (cfg.vif.uart_tx === 1'b0 && cfg.en_tx_monitor == 1) begin + // 1 start + 8 data + 1 parity (if enabled) + 1 stop + cfg.vif.uart_tx_clk_pulses = NUM_UART_XFER_BITS_WO_PARITY + cfg.en_parity; + item = uart_item::type_id::create("item"); + // get the start bit + @(cfg.vif.mon_tx_mp.mon_tx_cb); + `uvm_info(`gfn, $sformatf("tx start bit %0b", cfg.vif.uart_tx_int), UVM_HIGH) + item.start_bit = cfg.vif.uart_tx_int; + // get the data bits + for (int i = 0; i < 8; i++) begin + @(cfg.vif.mon_tx_mp.mon_tx_cb); + `uvm_info(`gfn, $sformatf("tx data bit[%0d] %0b", i, cfg.vif.uart_tx_int), UVM_DEBUG) + item.data[i] = cfg.vif.uart_tx_int; + end + // get the parity bit + if (cfg.vif.uart_tx_clk_pulses > 2) begin + @(cfg.vif.mon_tx_mp.mon_tx_cb); + `uvm_info(`gfn, $sformatf("tx parity bit %0b", cfg.vif.uart_tx_int), UVM_DEBUG) + item.parity = cfg.vif.uart_tx_int; + if (cfg.en_tx_checks && item.parity != `GET_PARITY(item.data, cfg.odd_parity)) begin + `uvm_error(`gfn, "Parity failed") + end + end + else item.parity = 1'b0; + + // get the stop bit + @(cfg.vif.mon_tx_mp.mon_tx_cb); + `uvm_info(`gfn, $sformatf("tx stop bit %0b", cfg.vif.uart_tx_int), UVM_DEBUG) + item.stop_bit = cfg.vif.uart_tx_int; + // check stop bit + if (cfg.en_tx_checks && cfg.vif.uart_tx_int !== 1'b1) begin + `uvm_error(`gfn, "No stop bit when expected!") + end + `uvm_info(`gfn, $sformatf("collected uart tx txn:\n%0s", item.sprint()), UVM_HIGH) + tx_analysis_port.write(item); + + // wait for uart_tx_clk_pulses==0, otherwise, it may affect next transaction + cfg.vif.wait_for_tx_idle(); + + if (cfg.en_cov) cov.uart_cg.sample(UartTx, item); + end else begin + @(cfg.vif.uart_tx_int); + end + end + endtask + + virtual task collect_rx_data(); + uart_item item; + forever begin + if (cfg.vif.uart_rx === 1'b0 && cfg.en_rx_monitor == 1) begin + item = uart_item::type_id::create("item"); + cfg.vif.uart_rx_clk_pulses = NUM_UART_XFER_BITS_WO_PARITY + cfg.en_parity; + // get the start bit + @(cfg.vif.mon_rx_mp.mon_rx_cb); + `uvm_info(`gfn, $sformatf("rx start bit %0b", cfg.vif.uart_rx), UVM_DEBUG) + item.start_bit = cfg.vif.uart_rx; + // get the data bits + for (int i = 0; i < 8; i++) begin + @(cfg.vif.mon_rx_mp.mon_rx_cb); + `uvm_info(`gfn, $sformatf("rx data bit[%0d] %0b", i, cfg.vif.uart_rx), UVM_DEBUG) + item.data[i] = cfg.vif.uart_rx; + end + // get the parity bit + if (cfg.vif.uart_rx_clk_pulses > 2) begin + @(cfg.vif.mon_rx_mp.mon_rx_cb); + `uvm_info(`gfn, $sformatf("rx parity bit %0b", cfg.vif.uart_rx), UVM_DEBUG) + item.parity = cfg.vif.uart_rx; + if (cfg.en_rx_checks && item.parity != `GET_PARITY(item.data, cfg.odd_parity)) begin + `uvm_error(`gfn, "Parity failed") + end + end + else item.parity = 1'b0; + + // get the stop bit + @(cfg.vif.mon_rx_mp.mon_rx_cb); + `uvm_info(`gfn, $sformatf("rx stop bit %0b", cfg.vif.uart_rx), UVM_DEBUG) + item.stop_bit = cfg.vif.uart_rx; + // check stop bit + if (cfg.en_rx_checks && cfg.vif.uart_rx !== 1'b1) begin + `uvm_error(`gfn, "No stop bit when expected!") + end + `uvm_info(`gfn, $sformatf("collected uart rx txn:\n%0s", item.sprint()), UVM_HIGH) + rx_analysis_port.write(item); + + // wait for uart_rx_clk_pulses==0, otherwise, it may affect next transaction + cfg.vif.wait_for_rx_idle(); + + if (cfg.en_cov) cov.uart_cg.sample(UartRx, item); + end else begin + @(cfg.vif.uart_rx); + end + end + endtask + + task drive_tx_clk(); + forever begin + if (cfg.vif.uart_tx_clk_pulses > 0) begin + #(cfg.vif.uart_clk_period / 2); + cfg.vif.uart_tx_clk = ~cfg.vif.uart_tx_clk; + // last cycle only use half period as design and agent aren't using same clock. If agent + // freq is slower and design continues sending tx item, the freq diff will be accumulated. + // Ending current item after latch STOP bit to allow agent to re-establish clock to sample + // the START bit of next item + if (cfg.vif.uart_tx_clk_pulses == 1) #(cfg.vif.uart_clk_period / 4); + else #(cfg.vif.uart_clk_period / 2); + cfg.vif.uart_tx_clk = ~cfg.vif.uart_tx_clk; + cfg.vif.uart_tx_clk_pulses--; + end else begin + @(cfg.vif.uart_tx_int, cfg.vif.uart_tx_clk_pulses); + end + end + endtask + + task drive_rx_clk(); + forever begin + if (cfg.vif.uart_rx_clk_pulses > 0) begin + #(cfg.vif.uart_clk_period / 2); + cfg.vif.uart_rx_clk = ~cfg.vif.uart_rx_clk; + #(cfg.vif.uart_clk_period / 2); + cfg.vif.uart_rx_clk = ~cfg.vif.uart_rx_clk; + cfg.vif.uart_rx_clk_pulses--; + end else begin + @(cfg.vif.uart_rx, cfg.vif.uart_rx_clk_pulses); + end + end + endtask + + // actual uart clock isn't ideal, it's allowed to off less than max_drift_cycle_pct cycle as cfg + // this to check data stable from (50 - max_drift_cycle_pct) to (50 + max_drift_cycle_pct) + task mon_tx_stable(); + forever begin + @(cfg.vif.uart_tx_clk_pulses); + if (cfg.vif.uart_tx_clk_pulses == 0) continue; + + #(cfg.vif.uart_clk_period * (50 - cfg.get_max_drift_cycle_pct()) / 100); + `DV_SPINWAIT_EXIT( + begin + @(cfg.vif.uart_tx_int); + `uvm_error(`gfn, $sformatf( + "Expect uart_tx stable from %0d to %0d of the period, but it's changed", + 50 - cfg.get_max_drift_cycle_pct(), 50 + cfg.get_max_drift_cycle_pct())) + end, + // simplified from cfg.vif.uart_clk_period * max_drift_cycle_pct * 2 / 100 + #(cfg.vif.uart_clk_period * cfg.get_max_drift_cycle_pct() / 50)) + end + endtask + + // update ok_to_end to prevent sim finish when there is any activity on the bus + virtual task monitor_ready_to_end(); + forever begin + @(cfg.vif.uart_tx_clk_pulses or cfg.vif.uart_rx_clk_pulses); + ok_to_end = (cfg.vif.uart_tx_clk_pulses == 0) && (cfg.vif.uart_rx_clk_pulses == 0); + end + endtask + + virtual task process_reset(); + if (cfg.en_cov) begin + cov.uart_reset_cg.sample(UartTx, cfg.vif.uart_tx_clk_pulses); + cov.uart_reset_cg.sample(UartRx, cfg.vif.uart_rx_clk_pulses); + end + cfg.vif.uart_tx_clk_pulses = 0; + cfg.vif.uart_tx_clk = 1; + cfg.vif.uart_rx_clk_pulses = 0; + cfg.vif.uart_rx_clk = 1; + wait(!cfg.in_reset); + endtask + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_sequencer.sv b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_sequencer.sv new file mode 100644 index 0000000..89f25ca --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/sv/uart_agent/uart_sequencer.sv @@ -0,0 +1,10 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +class uart_sequencer extends dv_base_sequencer#(uart_item, uart_agent_cfg); + `uvm_component_utils(uart_sequencer) + + `uvm_component_new + +endclass diff --git a/hw/vendor/lowrisc_ip/dv/tools/common.tcl b/hw/vendor/lowrisc_ip/dv/tools/common.tcl new file mode 100644 index 0000000..7743450 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/common.tcl @@ -0,0 +1,73 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +# Commonly used globals & procs. This file must be sourced first. +set simulator "" +if {[info exists ::env(SIMULATOR)]} { + set simulator "$::env(SIMULATOR)" +} else { + puts "ERROR: tool script run without SIMULATOR environment variable." + quit +} + +set waves "none" +if {[info exists ::env(WAVES)]} { + set waves "$::env(WAVES)" +} + +set gui 0 +if {[info exists ::env(GUI)]} { + set gui "$::env(GUI)" +} + +set gui_debug 0 +# Detect when GUI debug mode has been invoked to build UVM objects by default +if {[info exists ::env(GUI_DEBUG)]} { + set gui_debug "$::env(GUI_DEBUG)" +} + +set tb_top "tb" +if {[info exists ::env(TB_TOP)]} { + set tb_top "$::env(TB_TOP)" +} else { + puts "WARNING: TB_TOP environment variable not set - using \"tb\" as the + top level testbench hierarchy." +} + +# Checks if variable is defined, else throw an error and exit. +proc checkVarExists {var} { + upvar $var var_ + if {![info exists var_]} { + puts "ERROR: Variable \"$var\" not found." + quit + } +} + +# If variable is defined, then use it, else set the default value. +proc setDefault {var value} { + upvar $var var_ + if {[info exists var_]} { + puts "INFO: \"$var\" is already set to \"$var_\"." + } else { + puts "INFO: Setting \"$var\" to \"$value\"." + set var_ $value + } + return $var_ +} + +proc checkEq {var value} { + upvar $var var_ + if {$var_ != $value} { + puts "ERROR: Check failed \"$var\" == \"$value\"!. Actual: \"$var_\"." + quit + } +} + +proc checkNe {var value} { + upvar $var var_ + if {$var_ == $value} { + puts "ERROR: Check failed \"$var\" != \"$value\"!. Actual: \"$var_\"." + quit + } +} diff --git a/hw/vendor/lowrisc_ip/dv/tools/dvsim/common_modes.hjson b/hw/vendor/lowrisc_ip/dv/tools/dvsim/common_modes.hjson new file mode 100644 index 0000000..d158c61 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/dvsim/common_modes.hjson @@ -0,0 +1,82 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +{ + // Sim modes are collection of build_opts and run_opts + // These are only set on the command line + // These are different from the build modes in the sense that these collection of + // options are appended to actual build_modes + build_modes: [ + { + name: gui + is_sim_mode: 1 + en_build_modes: ["{tool}_gui"] + } + { + name: gui_debug + is_sim_mode: 1 + en_build_modes: ["{tool}_gui_debug"] + } + { + name: waves + is_sim_mode: 1 + en_build_modes: ["{tool}_waves"] + } + { + name: waves_off + is_sim_mode: 1 + en_build_modes: ["{tool}_waves_off"] + } + { + name: cov + is_sim_mode: 1 + en_build_modes: ["{tool}_cov"] + // This plusarg is retrieved in `hw/dv/sv/dv_lib/dv_base_test.sv`. If not set, the coverage + // collection components are not created. + run_opts: ["+en_cov=1"] + } + { + name: profile + is_sim_mode: 1 + en_build_modes: ["{tool}_profile"] + } + { + name: xprop + is_sim_mode: 1 + en_build_modes: ["{tool}_xprop"] + } + { + name: loopdetect + is_sim_mode: 1 + en_build_modes: ["{tool}_loopdetect"] + } + // Enables randomization of testbench / RTL build. + // + // Build randomization is achieved by passing `--build-seed ` on the dvsim + // command-line. If not passed, the build is not randomized. Build randomization is achieved + // in two ways. One of them is setting the pre-processor macro `BUILD_SEED` to the seed value, + // which is done below. The SystemVerilog testbench sources can use the `BUILD_SEED` macro + // value to set some design constants (such as parameters) upon instantiation. The `BUILD_SEED`, + // if not set externally (by passing the --build-seed switch) is set to 1 in + // `hw/dv/sv/dv_utils/dv_macros.svh`. The other way is by passing the {seed} value to utility + // scripts that generate packages that contain randomized constants. These utility scripts can + // be invoked as a `pre_build_cmd`, wrapped within the `build_seed` sim mode in the DUT + // simulation configuration Hjson file. All forms of build randomization must be wrapped within + // this `build_seed` sim mode. They will all use the same {seed} value, which allows us to + // deterministically reproduce failures. The `--build-seed` switch is expected to be passed + // when running the nightly regressions. The `seed` value set by dvsim is a 32-bit unsigned + // integer (unless specified on the command-line). + { + name: build_seed + is_sim_mode: 1 + build_opts: ["+define+BUILD_SEED={seed}"] + } + ] + + run_modes: [ + { + name: uvm_trace + run_opts: ["+UVM_PHASE_TRACE", "+UVM_CONFIG_DB_TRACE", "+UVM_OBJECTION_TRACE"] + } + ] +} diff --git a/hw/vendor/lowrisc_ip/dv/tools/dvsim/fusesoc.hjson b/hw/vendor/lowrisc_ip/dv/tools/dvsim/fusesoc.hjson new file mode 100644 index 0000000..66e282e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/dvsim/fusesoc.hjson @@ -0,0 +1,16 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +{ + sv_flist_gen_cmd: fusesoc + fusesoc_core_: "{eval_cmd} echo \"{fusesoc_core}\" | tr ':' '_'" + sv_flist_gen_opts: ["{fusesoc_cores_root_dirs}", + "run", + "{sv_flist_gen_flags}", + "--target=sim", + "--work-root={build_dir}/fusesoc-work", + "--setup {fusesoc_core}"] + fusesoc_cores_root_dirs: ["--cores-root {proj_root}/hw"] + sv_flist_gen_dir: "{build_dir}/fusesoc-work" + sv_flist: "{sv_flist_gen_dir}/{fusesoc_core_}.scr" +} diff --git a/hw/vendor/lowrisc_ip/dv/tools/dvsim/sim.mk b/hw/vendor/lowrisc_ip/dv/tools/dvsim/sim.mk new file mode 100644 index 0000000..2a93d3b --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/dvsim/sim.mk @@ -0,0 +1,137 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +export SHELL := /usr/bin/env bash +.DEFAULT_GOAL := all + +LOCK_ROOT_DIR ?= flock --timeout 3600 ${proj_root} --command + +all: build run + +############################### +## sim build and run targets ## +############################### +build: build_result + +pre_build: + @echo -e "\n[make]: pre_build" + mkdir -p ${build_dir} +ifneq (${pre_build_cmds},) + # pre_build_cmds are likely changing the in-tree sources. We hence use FLOCK + # utility to prevent multiple builds that may be running in parallel from + # stepping on each other. TODO: Enforce the list of pre_build_cmds is + # identical across all build modes. + ${LOCK_ROOT_DIR} "cd ${build_dir} && ${pre_build_cmds}" +endif + +gen_sv_flist: pre_build + @echo -e "\n[make]: gen_sv_flist" +ifneq (${sv_flist_gen_cmd},) + cd ${build_dir} && ${sv_flist_gen_cmd} ${sv_flist_gen_opts} +endif + +do_build: gen_sv_flist + @echo -e "\n[make]: build" + cd ${sv_flist_gen_dir} && ${build_cmd} ${build_opts} + +post_build: do_build + @echo -e "\n[make]: post_build" +ifneq (${post_build_cmds},) + cd ${build_dir} && ${post_build_cmds} ${post_build_opts} +endif + +build_result: post_build + @echo -e "\n[make]: build_result" + +run: run_result + +pre_run: + @echo -e "\n[make]: pre_run" + mkdir -p ${run_dir} +ifneq (${pre_run_cmds},) + cd ${run_dir} && ${pre_run_cmds} +endif + +sw_build: pre_run + @echo -e "\n[make]: sw_build" +ifneq (${sw_images},) + cd ${proj_root} && ${sw_build_cmd} --build-seed=${build_seed} +endif + +simulate: sw_build + @echo -e "\n[make]: simulate" + cd ${run_dir} && ${run_cmd} ${run_opts} + +post_run: simulate + @echo -e "\n[make]: post_run" +ifneq (${post_run_cmds},) + cd ${run_dir} && ${post_run_cmds} +endif + +run_result: post_run + @echo -e "\n[make]: run_result" + +####################### +## Load waves target ## +####################### +debug_waves: + ${debug_waves_cmd} ${debug_waves_opts} + +############################ +## coverage rated targets ## +############################ +cov_unr_build: gen_sv_flist + @echo -e "\n[make]: cov_unr_build" + cd ${sv_flist_gen_dir} && ${cov_unr_build_cmd} ${cov_unr_build_opts} + +cov_unr_vcs: cov_unr_build + @echo -e "\n[make]: cov_unr" + cd ${sv_flist_gen_dir} && ${cov_unr_run_cmd} ${cov_unr_run_opts} + +cov_unr_xcelium: + @echo -e "\n[make]: cov_unr" + mkdir -p ${cov_unr_dir} + cd ${cov_unr_dir} && ${cov_unr_run_cmd} ${cov_unr_run_opts} + +cov_unr_merge: + @echo -e "\n[make]: cov_unr_merge" + cd ${cov_unr_dir} && ${job_prefix} ${cov_merge_cmd} -init ${cov_unr_dir}/jgproject/sessionLogs/session_0/unr_imc_coverage_merge.cmd + +ifeq (${SIMULATOR}, xcelium) + cov_unr: cov_unr_xcelium cov_unr_merge +else + cov_unr: cov_unr_vcs +endif + +# Merge coverage if there are multiple builds. +cov_merge: + @echo -e "\n[make]: cov_merge" + ${job_prefix} ${cov_merge_cmd} ${cov_merge_opts} + +# Generate coverage reports. +cov_report: + @echo -e "\n[make]: cov_report" + ${cov_report_cmd} ${cov_report_opts} + +# Open coverage tool to review and create report or exclusion file. +cov_analyze: + @echo -e "\n[make]: cov_analyze" + ${cov_analyze_cmd} ${cov_analyze_opts} + +.PHONY: build \ + pre_build \ + gen_sv_flist \ + do_build \ + post_build \ + build_result \ + run \ + pre_run \ + sw_build \ + simulate \ + post_run \ + run_result \ + debug_waves \ + cov_merge \ + cov_analyze \ + cov_report diff --git a/hw/vendor/lowrisc_ip/dv/tools/dvsim/xcelium.hjson b/hw/vendor/lowrisc_ip/dv/tools/dvsim/xcelium.hjson new file mode 100644 index 0000000..045f6b7 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/dvsim/xcelium.hjson @@ -0,0 +1,283 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 +{ + build_cmd: "{job_prefix} xrun" + run_cmd: "{job_prefix} xrun" + + build_db_dir: "{build_dir}/xcelium.d" + + build_opts: ["-elaborate -64bit -sv", + // Wait to acquire a license. + "-licqueue", + // TODO: duplicate primitives between OT and Ibex #1231 + "-ALLOWREDEFINITION", + "-messages -errormax 50", + "-timescale {timescale}", + "-f {sv_flist}", + "-uvmhome CDNS-1.2", + // Specify the library name for the run step to use. + "-xmlibdirname {build_db_dir}", + // List multiple tops for the simulation. Prepend each top level with `-top`. + "{eval_cmd} echo {sim_tops} | sed -E 's/(\\S+)/-top \\1/g'", + // Set the top level elaborated entity (snapshot name) correctly since there are + // multiple tops. + "-snapshot {tb}", + // for uvm_hdl_* used by csr backdoor + "-access +rw", + // This is to fix a timescale issue due to using `resetall to reset timescale and + // `-sv` compile option. #7178 + "-enable_strict_timescale", + // Use this to conditionally compile for Xcelium (example: LRM interpretations differ + // across tools). + "+define+XCELIUM", + // Suppress printing of the copyright banner. + "-nocopyright", + // Ignore "timescale is not specified for the package" warning + "-nowarn TSNSPK", + // Ignore "IEEE 1800-2009 SystemVerilog simulation semantics" warning + "-nowarn DSEMEL", + // Ignore hierarchial ref warnings in interfaces + "-nowarn CUVIHR", + // Ignore warning "Potentially reversed dist range may cause it to be treated as + // empty". This is thrown when and expression like `var - 1` is added to a + // randomization distribution, which can potentially be a negative value. + "-nowarn REVRNG", + // Ignore warning "Include directory given but not used". This is benign. + "-nowarn SPDUSD", + // Needed for including "secded_enc.h". + "-I{build_dir}/fusesoc-work/src/lowrisc_dv_secded_enc_0", + // This warning is thrown when a scalar enum variable is assigned to an enum array. + // Other tools (e.g., FPV) treat such assignments as an error, hence we bump it to + // an error in simulation so that this can be caught early in CI. + "-xmerror ENUMERR", + // Enables LRM compliant behavior for $asserton, $assertoff and $assertkill tasks. + "-enable_abv_asrtctrl_enh" + ] + + // We want to allow the possibility of passing no test or no test sequence. Unfortunately, + // Xcelium generates an error (*E,OPTP2ND) if you pass an empty plusarg. To avoid doing so, these + // two variables expand to e.g. "+UVM_TESTNAME=foo" if we have a test and the empty string if + // not. + uvm_testname_plusarg: "{eval_cmd} echo {uvm_test} | sed -E 's/(.+)/+UVM_TESTNAME=\\1/'" + uvm_testseq_plusarg: "{eval_cmd} echo {uvm_test_seq} | sed -E 's/(.+)/+UVM_TEST_SEQ=\\1/'" + + run_opts: ["-input {run_script}", + // Suppress printing of the copyright banner. + "-nocopyright", + // Wait to acquire a license. + "-licqueue", + "-64bit -xmlibdirname {build_db_dir}", + // Use the same snapshot name set during the build step. + "-r {tb}", + "+SVSEED={svseed}", + "{uvm_testname_plusarg}", + "{uvm_testseq_plusarg}", + // Ignore "IEEE 1800-2009 SystemVerilog simulation semantics" warning + "-nowarn DSEM2009", + ] + + // Vars that need to exported to the env. + exports: [ + // Poll for an available license in all servers. + { CDS_LIC_QUEUE_POLL: 1 }, + + // Poll for an available license every 1 min. + { CDS_LIC_QUEUE_POLL_INT: 60 }, + + // X-prop related: these were suggested by Xcelium as warnings during the build time. + // These enable array corruption when the index is out of range or invalid. + { VL_ENABLE_INVALID_IDX_XPROP: 1 }, + { VL_ENABLE_OUTOFRANGE_IDX_XPROP: 1 }, + + // Export the cov_report path so that the tcl file can read these as env vars. + { cov_merge_db_dir: "{cov_merge_db_dir}" }, + { cov_report_dir: "{cov_report_dir}" } + + // Export unr related paths for make + {cov_unr_dir: "{cov_unr_dir}" } + // Add an additional single quotation because `cov_merge_cmd` has an empty space, it will cause + // trouble when exporting the entire command in the environment. + {cov_merge_cmd: "{cov_merge_cmd}"} + + // job prefix + {job_prefix: "{job_prefix}"} + + // The Verdi FSDB dumper libraries (see xcelium_fsdb_pli_opt) depend on libIUS.so, which lives + // alongside them and has no rpath, so add their directory when dumping FSDB waves. + {LD_LIBRARY_PATH: "{xcelium_fsdb_ld_library_path}"} + + ] + + // Supported wave dumping formats (in order of preference). + supported_wave_formats: ["shm", "fsdb", "vcd"] + + // Load the Verdi FSDB dumper when dumping waves in FSDB format (requires VERDI_HOME). The PLI + // provides the $fsdb* system tasks and the CFC library provides the `call fsdb*` Tcl commands + // used by waves.tcl. Both expand to nothing for other wave formats. + xcelium_fsdb_pli_opt: "{eval_cmd} [ {waves} = fsdb ] && echo -loadpli1 $VERDI_HOME/share/PLI/IUS/linux64/boot/debpli.so:novas_pli_boot || true" + xcelium_fsdb_cfc_opt: "{eval_cmd} [ {waves} = fsdb ] && echo -loadcfc $VERDI_HOME/share/PLI/IUS/linux64/boot/debcfc.so:novas_cfc_boot || true" + xcelium_fsdb_ld_library_path: "{eval_cmd} [ {waves} = fsdb ] && echo $VERDI_HOME/share/PLI/IUS/linux64/boot:$LD_LIBRARY_PATH || echo $LD_LIBRARY_PATH" + + // Default tcl script used when running the sim. Override if needed. + run_script: "{dv_root}/tools/sim.tcl" + + // Coverage related. + // By default, collect all coverage metrics: block:expr:fsm:toggle:functional. + cov_metrics: all + + // Supply the cov configuration file. + // Note that this needs to be set as -covfile . + xcelium_cov_cfg_file: "" + + // Supply the cov exclusion tcl script - passed on to IMC using the -init switch. + xcelium_cov_excl_script: "" + + // Supply the cov refinement files - passed on to IMC using the -load_refinement switch. + xcelium_cov_refine_files: [] + + // Set the coverage directories. + cov_work_dir: "{scratch_path}/coverage" + cov_db_dir: "{cov_work_dir}/{build_mode}" + + // Individual test specific coverage data - this will be deleted if the test fails + // so that coverage from failiing tests is not included in the final report. + cov_db_test_dir_name: "{run_dir_name}.{svseed}" + cov_db_test_dir: "{cov_db_dir}/{cov_db_test_dir_name}" + + // Merging coverage. + // It is constructed by the tool itself. + cov_merge_dir: "{scratch_path}/cov_merge" + cov_merge_db_dir: "{cov_merge_dir}/merged" + cov_merge_cmd: "imc" + cov_merge_opts: ["-64bit", + "-licqueue", + "-exec {dv_root}/tools/xcelium/cov_merge.tcl"] + + // Generate covreage reports in text as well as html. + cov_report_dir: "{scratch_path}/cov_report" + cov_report_cmd: "{job_prefix} imc" + cov_report_opts: ["-64bit", + "-licqueue", + "-load {cov_merge_db_dir}", + " {eval_cmd} echo {xcelium_cov_excl_script} | sed -E 's/(\\S+)/-init \\1/g' ", + " {eval_cmd} echo {xcelium_cov_refine_files} | sed -E 's/(\\S+)/-load_refinement \\1/g' ", + "-exec {dv_root}/tools/xcelium/cov_report.tcl"] + cov_report_txt: "{cov_report_dir}/cov_report.txt" + cov_report_page: "index.html" + + // Analyzing coverage - this is done by invoking --cov-analyze switch. It opens up the + // GUI for visual analysis. + cov_analyze_dir: "{scratch_path}/cov_analyze" + cov_analyze_cmd: "{job_prefix} imc" + cov_analyze_opts: ["-64bit", + "-licqueue", + "-load {cov_merge_db_dir}", + " {eval_cmd} echo {xcelium_cov_excl_script} | sed -E 's/(\\S+)/-init \\1/g' ", + " {eval_cmd} echo {xcelium_cov_refine_files} | sed -E 's/(\\S+)/-load_refinement \\1/g' "] + + cov_unr_dir: "{scratch_path}/cov_unr" + + // not needed we can reuse the last build snapshot + cov_unr_build_opts:[] + cov_unr_build_cmd:[] + + cov_unr_run_cmd: "{job_prefix} xrun" + + + cov_unr_run_opts: [// use xrun in UNR mode + "-unr", + // JasperGold switch (use formal) + "-jg", + // use the same snapshot as used for regression + "-r {tb}", + // pointer to the merged coverage data from the regression + "-covdb {cov_merge_db_dir}", + // what metrics to use + "-jg_coverage {cov_metrics}", + "-64bit", + "-xmlibdirname {build_db_dir}", + "-jgargs '-allow_unsupported_OS'", + // overwrite previous results + "-covoverwrite", + "-inst_top {dut_instance}", + // UNR Configurations + "-input {xcelium_unr_cfg_file} "] + + + // pass and fail patterns + build_fail_patterns: ["\\*E.*$"] + run_fail_patterns: ["\\*E.*$"] // Null pointer error + + build_modes: [ + { + name: xcelium_gui + is_sim_mode: 1 + build_opts: ["-createdebugdb", "-access +c"] + run_opts: ["-gui"] + } + { + name: xcelium_gui_debug + is_sim_mode: 1 + build_opts: ["-createdebugdb", "-access +c", "-uvmlinedebug", "-linedebug", + "+uvm_set_config_int=*,recording_detail,1"] + run_opts: ["-gui", + "-input '@database -open waves -into waves.shm -default; probe -create \n" + "tb -depth all -packed 32k -unpacked 32k -all -dynamic -database waves'", + "+uvm_set_config_int=*,recording_detail,1"] + } + { + name: xcelium_waves + is_sim_mode: 1 + build_opts: ["-access +c", "{xcelium_fsdb_pli_opt}"] + run_opts: ["{xcelium_fsdb_pli_opt}", "{xcelium_fsdb_cfc_opt}"] + } + { + name: xcelium_waves_off + is_sim_mode: 1 + build_opts: [] + } + { + name: xcelium_cov + is_sim_mode: 1 + build_opts: [// Enable the required cov metrics. + "-coverage {cov_metrics}", + // Limit the scope of coverage collection to the DUT. + "-covdut {dut}", + // Set the coverage configuration file + "-covfile {xcelium_cov_cfg_file}", + // Don't warn about the switches we set that will be default in future releases. + "-nowarn COVDEF", + ] + run_opts: [// Put the coverage model (*.ucm) and the database (*.ucd) together. + "-covmodeldir {cov_db_test_dir}", + // Coverage database output location. + "-covworkdir {cov_work_dir}", + // Set the scope to the build mode name. + "-covscope {build_mode}", + // Test coverage dir name to create under cov_db_dir. + "-covtest {cov_db_test_dir_name}", + // Overwrite the coverage data of a specific test/seed if it already exists. + "-covoverwrite"] + } + // TODO support profile for xcelium + { + name: xcelium_profile + is_sim_mode: 1 + build_opts: ["-perfstat"] + run_opts: ["-perfstat", "-perflog perfstat.log"] + } + { + name: xcelium_xprop + is_sim_mode: 1 + build_opts: ["-xprop F -xverbose"] + } + { + // TODO: Add build and run options to enable zero delay loop detection. + name: xcelium_loopdetect + is_sim_mode: 1 + build_opts: [] + run_opts: [] + } + ] +} diff --git a/hw/vendor/lowrisc_ip/dv/tools/sim.tcl b/hw/vendor/lowrisc_ip/dv/tools/sim.tcl new file mode 100644 index 0000000..41e1f0b --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/sim.tcl @@ -0,0 +1,60 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +# Common TCL script invoked at run-time by the simulator. +# VCS syntax: -ucli -do +# Xcelium syntax: -input + +set dv_root "" +if {[info exists ::env(dv_root)]} { + set dv_root "$::env(dv_root)" +} else { + puts "ERROR: Script run without dv_root environment variable." + quit +} + +# Dumping waves in specific hierarchies. +# +# By default, if wave dumping is enabled, all hierarchies of the top level testbench are dumped. +# For large designs, this may slow down the simulation considerably. To bypass this and only enable +# waves in specific hierarchies, set the dump_tb_top flag to 0 (i.e. uncomment the line below), and +# specify the paths to dump on line 32. +# set dump_tb_top 0 + +source "${dv_root}/tools/common.tcl" +source "${dv_root}/tools/waves.tcl" + +global waves +global simulator +global tb_top + +# Dumping waves in specific hierarchies (example): +# wavedumpScope $waves $simulator tb.dut.foo.bar 12 +# wavedumpScope $waves $simulator tb.dut.baz 0 + +if {$simulator eq "xcelium"} { + puts "INFO: The following assertions are permamently disabled:" + assertion -list -depth all -multiline -permoff $tb_top +} + +global gui +global gui_debug +# In GUI mode, let the user take control of running the simulation. +# In GUI debug mode, run only up until the end of the UVM elaboration phase to have access to the +# dynamic objects. +if {$gui_debug == 1} { + if {$simulator eq "xcelium"} { + uvm_phase -stop_at build -end + run + } +} elseif {$gui == 0} { + run + if {$simulator eq "xcelium"} { + # Xcelium provides a `finish` tcl command instead of `quit`. The argument '2' enables the + # logging of additional resource usage information. + finish 2 + } else { + quit + } +} diff --git a/hw/vendor/lowrisc_ip/dv/tools/waves.tcl b/hw/vendor/lowrisc_ip/dv/tools/waves.tcl new file mode 100644 index 0000000..fb92bd2 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/waves.tcl @@ -0,0 +1,163 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +# This is sourced by all supported simulators. The driver scripts +# (dvsim) need to make sure that we don't ask for an unsupported +# dumping format (SHM with VCS, for example). The adjoining common.tcl +# must be sourced prior to sourcing this file. + +if {[info proc setDefault] ne "setDefault"} { + puts "ERROR: Please ensure that common.tcl is sourced." + quit +} + +# A procedure that provides a wave-format-agnostic way to enable a scope (design heirarchy). +# +# In large designs, dumping waves on the entire hierarchy can significantly slow down the +# simulation. It is useful in that case to only dump the relevant scopes of interest during debug. +# +# waves : The wave-format (fsdb, shm, vpd, vcd, evcd, etc). +# simulator : The simulator used for running the simulation (vcs, xcelium, etc). +# scope : Design / testbench hierarchy to dump waves. Defaults to $tb_top. +# depth : Levels in the hierarchy to dump waves. Defaults to 0 (dump all levels). +# fsdb_flags : Additional string flags passed to fsdbDumpVars. Defaults to "+all", which enables +# dumping of memories, MDAs, structs, unions, power, packed structs, and SVAs. +# probe_flags : Additional string flags passed to probe command (Xcelium). Defaults to "-all". +# dump_flags : Additional string flags passed to dump command (VCS). Defaults to "-aggregates", +# which enables dumping of structs and arrays. +# +# Depending on the need, more such technology specific flags can be added in future. +proc wavedumpScope {waves simulator scope {depth 0} {fsdb_flags "+all"} {probe_flags "-all"} + {dump_flags "-aggregates"}} { + + switch $waves { + "none" { + return + } + + "fsdb" { + if {$simulator eq "xcelium"} { + call fsdbDumpvars $depth $scope $fsdb_flags + call fsdbDumpSVA $depth $scope + } else { + fsdbDumpvars $depth $scope $fsdb_flags + fsdbDumpSVA $depth $scope + } + } + + "shm" { + if {$depth == 0} { + set depth "all" + } + probe "$scope" $probe_flags -depth $depth -memories -shm + } + + "vpd" { + global vpd_fid + dump -add "$scope" -fid $vpd_fid -depth $depth $dump_flags + } + + "vcd" { + if {$simulator eq "xcelium"} { + if {$depth == 0} { + set depth "all" + } + probe "$scope" $probe_flags -depth $depth -memories -vcd + } + } + + "evcd" { + if {$simulator eq "xcelium"} { + if {$depth == 0} { + set depth "all" + } + probe "$scope" $probe_flags -depth $depth -evcd + } + } + + default { + puts "ERROR: Unknown wave format: ${waves}." + quit + } + } + + puts "INFO: Dumping waves in scope \"$scope:$depth\"." +} + +# A global variable representing the file id (fid) of the waves dumped in VPD format. +setDefault vpd_fid 0 + +# The entry point to enable dumping waves. +# +# If waves are not enabled (i.e. $waves == "none"), we do nothing. If enabled, then first, we run +# the tcl command to establish the dump file. Then, we run `wavedumpScope args...` to enable dumping +# the required hierarchies. +global waves +global simulator +if {$waves ne "none"} { + set wavedump_db "waves.$waves" + puts "INFO: Dumping waves in [string toupper $waves] format to $wavedump_db." + + # If waves are enabled, then issue the necessary tcl commands to enable the generation of waves. + # To explicitly list the hierarchies to dump, use the wavedumpScope proc instead. + switch $waves { + "fsdb" { + if {$simulator eq "xcelium"} { + call fsdbDumpfile $wavedump_db + } else { + fsdbDumpfile $wavedump_db + } + } + + "shm" { + checkEq simulator "xcelium" + database -open $wavedump_db -default -shm + } + + "vpd" { + checkEq simulator "vcs" + global vpd_fid + set vpd_fid [dump -file $wavedump_db -type VPD] + } + + "vcd" { + if {$simulator eq "xcelium"} { + database -open $wavedump_db -default -vcd + } else { + puts "ERROR: Simulator $simulator does not support dumping waves in VCD." + quit + } + } + + "evcd" { + if {$simulator eq "xcelium"} { + database -open $wavedump_db -default -evcd + } else { + puts "ERROR: Simulator $simulator does not support dumping waves in EVCD." + quit + } + } + + default { + puts "ERROR: Unknown wave format: ${waves}." + quit + } + } + + # Decide whether to dump the entire testbench hierarchy by default. + # + # If this variable is not set externally, it is set to 1 by default here. When set to 1, it adds + # the entire top-level testbench instance for dumping waves. For larger designs, this may slow + # down the simulation. The user can if needed, set it to 0 in the external tcl script that sources + # this script and manually add the hierarchies of interest in there, using the wavedumpScope proc. + # See the adjoining sim.tcl for an example. + setDefault dump_tb_top 1 + + if {$dump_tb_top == 1} { + global tb_top + wavedumpScope $waves $simulator $tb_top 0 + } else { + puts "INFO: the hierarchies to be dumped are expected to be indicated externally." + } +} diff --git a/hw/vendor/lowrisc_ip/dv/tools/xcelium/common.ccf b/hw/vendor/lowrisc_ip/dv/tools/xcelium/common.ccf new file mode 100644 index 0000000..f0e6b3a --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/xcelium/common.ccf @@ -0,0 +1,56 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Common coverage commands that apply to all DUTs. +// +// This coverge config file is provided by Xcelium and is located at: +// ${XCELIUM_HOME}/tools/icc/include/all_coverage.ccf +// Xcelium recommends including it, since it bundles together the common set of commands that enable +// coverage collection on various design elements, that are otherwise turned off by default. We +// maintain it locally with minor amends. + +// Enables expression coverage of various Verilog operators. +set_expr_coverable_operators -all -event_or + +// Enables expression coverage of operators in various conditions and assignments. +set_expr_coverable_statements -procassign -event_control -misc + +// Enables scoring of Verilog modules compiled with -v/-y or -libcell option but continues to +// disable the scoring of Verilog modules defined with the 'celldefine compiler directive. +set_libcell_scoring + +// Enables scoring of SystemVerilog continuous assignments, which is by disabled by default. +set_assign_scoring + +// Scores branches together with block coverage. +set_branch_scoring + +// Scores statements within a block. +set_statement_scoring + +// Enables Toggle scoring and reporting of SystemVerilog enumerations and multidimensional static +// arrays , vectors, packed union, modport and generate blocks. +set_toggle_scoring -sv_enum enable_mda -sv_struct_with_enum -sv_modport -sv_mda 16 -sv_mda_of_struct -sv_generate -sv_packed_union + +// Enable toggle coverage only on ports. +set_toggle_portsonly + +// Enable scoring of FSM arcs (state transitions). +// TODO: re-enable this setting, temp disable due to #12544 +// set_fsm_arc_scoring + +// Include X->1|0 for toggle coverage collection. #10332 +set_toggle_includex + +// For ternary operator in default SOP mode +set_expr_scoring -vlog_short_circuit + +// Enable Constant Object Marking (COM) so that coverage items which can never be exercised because +// they are driven by constants inside the DUT are automatically detected during elaboration, marked +// IGN, and omitted from the coverage figures. It prevents statically-tied inputs (e.g. reinit +// inputs on generated register blocks that are tied to zero at integration) from showing up as +// false coverage holes. When the testbench is built, we pass -covdut, which ensures genuine DUT ports +// are considered variable. This avoids any inferred constant variables from undriven ports. +// `-log` writes the list of marked items to `icc.com` for auditing. +set_com -on -log diff --git a/hw/vendor/lowrisc_ip/dv/tools/xcelium/common_cov_excl.tcl b/hw/vendor/lowrisc_ip/dv/tools/xcelium/common_cov_excl.tcl new file mode 100644 index 0000000..f38f26e --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/xcelium/common_cov_excl.tcl @@ -0,0 +1,10 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +exclude -inst $::env(DUT_TOP) -toggle '*tl_i.a_user.rsvd' -comment "\[UNSUPPORTED\] Based on our Comportability Spec. Exercising this will result in assertion errors thrown." +exclude -inst $::env(DUT_TOP) -toggle '*tl_i.a_param' -comment "\[UNSUPPORTED\] Based on our Comportability Spec. Exercising this will result in assertion errors thrown." +exclude -inst $::env(DUT_TOP) -toggle '*tl_o.d_param' -comment "\[UNR\] Follows tl_i.a_param which is unsupported." +exclude -inst $::env(DUT_TOP) -toggle '*tl_o.d_sink' -comment "\[UNR\] Based on our Comportability Spec." +exclude -inst $::env(DUT_TOP) -toggle '*tl_o.d_user.rsp_intg'\[6\] -comment "\[UNR\] Due to the ECC logics" +exclude -inst $::env(DUT_TOP).gen_alert_tx*.u_prim_alert_sender -toggle '*alert*.ping_*' -comment "\[LOW_RISK\] Verified in prim_alert_receiver TB." diff --git a/hw/vendor/lowrisc_ip/dv/tools/xcelium/cov_merge.tcl b/hw/vendor/lowrisc_ip/dv/tools/xcelium/cov_merge.tcl new file mode 100644 index 0000000..7c4291c --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/xcelium/cov_merge.tcl @@ -0,0 +1,26 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +# Merge coverage with IMC, across tests, scopes and previous regression runs. + +# Set the input coverage directories across all available scopes and previous runs, +# using the env var 'cov_db_dirs' (which is a space separated list of directories). +# Append each of these directories with /* wildcard at the end to allow the tool to +# find all available test databases. +set cov_db_dirs_env [string trim $::env(cov_db_dirs) " \"'"] +foreach i $cov_db_dirs_env { append cov_db_dirs "[string trim $i]/* "; } +puts "Input coverage directories:\n$cov_db_dirs" + +# Set the output directory for the merged database using the env var 'cov_merge_db_dir'. +# The supplied env var may have quotes or spaces that needs to be trimmed. +puts "Output directory for merged coverage:" +set cov_merge_db_dir [string trim $::env(cov_merge_db_dir) " \"'"] + +# Run the merge command. +merge $cov_db_dirs -out $cov_merge_db_dir -overwrite -initial_model union_all + +# Create a file with the path to the cover dirs +# Replace spaces with newlines so each run is on its own line for the 'rank' command +set cov_db_dirs_rank [string map {" " "\n"} [string trim $cov_db_dirs]] +exec sh -c "cat << 'EOF' > $cov_merge_db_dir/runs.txt\n$cov_db_dirs_rank\nEOF" diff --git a/hw/vendor/lowrisc_ip/dv/tools/xcelium/cov_report.tcl b/hw/vendor/lowrisc_ip/dv/tools/xcelium/cov_report.tcl new file mode 100644 index 0000000..1585b6f --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/xcelium/cov_report.tcl @@ -0,0 +1,75 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 + +# Generate reports for the merged coverage in HTML and text format. +# +# This file is passed to IMC using the -exec switch. Ensure that the merged coverage database, the +# exclusion script and the coverage refinement files are passed to the IMC invocation using the +# -load, -init and -load_refinement switches respectively (whichever ones are applicable). + +# Generate "detachable" reports that work despite browser Cross-Origin Request Security protection. +# They have the downside that you have to select the .report file yourself in-browser. +config reports.detachable_report_data -set true + +# Set the output directory for the reports database using the env var 'cov_report_dir'. +# The supplied env var may have quotes or spaces that needs to be trimmed. +set cov_report_dir [string trim $::env(cov_report_dir) " \"'"] + +# Set the input merged coverage database directory using the env var 'cov_merge_db_dir'. +# The supplied env var may have quotes or spaces that needs to be trimmed. +set cov_merge_db_dir [string trim $::env(cov_merge_db_dir) " \"'"] + +# Set the DUT name. +set dut [string trim $::env(DUT_TOP)] +set dut_uc [string toupper $dut] + +# Generate the text report (summary is sufficient). +report -summary \ + -inst uvm_pkg $dut \ + -metrics all \ + -all \ + -cumulative on \ + -local off \ + -grading covered \ + -out $cov_report_dir/cov_report.txt + +# Generate a detailed exclusion report +# +# This is the only place the attribution appears. The HTML report below passes -exclComments as +# well, but the exported report_data carries the rule kind and nothing else, so the report here is +# what makes the attribution available. The comment is what tells a UNR exclusion apart from a hand +# written one, since IMC records both as ordinary refinement rules. +# This information is useful to better understand what the tool or the user has excluded and the +# reasons. +report -detail \ + -inst $dut \ + -metrics all \ + -excludes \ + -exclComments \ + -out $cov_report_dir/cov_excl_report.txt + +# Generate the functional coverage report for tracking. +report -summary \ + -type \ + -all \ + -metrics covergroup \ + -source off \ + -out $cov_report_dir/cov_report_cg.txt + +# Generate the HTML reports. +report_metrics \ + -out $cov_report_dir \ + -overwrite \ + -title $dut_uc \ + -detail \ + -metrics all \ + -kind aggregate \ + -source on \ + -exclComments \ + -assertionStatus \ + -allAssertionCounters \ + -all + +# rank the test runs +rank -runfile $cov_merge_db_dir/runs.txt -html -out_html $cov_report_dir/grading -overwrite diff --git a/hw/vendor/lowrisc_ip/dv/tools/xcelium/cover.ccf b/hw/vendor/lowrisc_ip/dv/tools/xcelium/cover.ccf new file mode 100644 index 0000000..3964c64 --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/xcelium/cover.ccf @@ -0,0 +1,53 @@ +// Copyright lowRISC contributors (OpenTitan project). +// Licensed under the Apache License, Version 2.0, see LICENSE for details. +// SPDX-License-Identifier: Apache-2.0 + +// Include our common coverage CCF. +include_ccf ${dv_root}/tools/xcelium/common.ccf + +// enable coverage on dut and below + +select_coverage -befts -module ${DUT_TOP}... + +// Black-box pre-verified IPs from coverage collection. +deselect_coverage -betfs -module pins_if +deselect_coverage -betfs -module clk_rst_if +deselect_coverage -betfs -module prim_alert_sender... +deselect_coverage -betfs -module prim_alert_receiver... +deselect_coverage -betfs -module prim_count... +deselect_coverage -betfs -module prim_esc_sender... +deselect_coverage -betfs -module prim_esc_receiver... +deselect_coverage -betfs -module prim_onehot_check... +deselect_coverage -betfs -module prim_prince... +deselect_coverage -betfs -module prim_lfsr... +deselect_coverage -betfs -module prim_secded_inv_64_57_dec... +deselect_coverage -betfs -module prim_secded_inv_39_32_dec... +deselect_coverage -betfs -module prim_secded_inv_64_57_enc... +deselect_coverage -betfs -module prim_secded_inv_39_32_enc... + +// Black-box DV CDC module. +deselect_coverage -betfs -module prim_cdc_rand_delay + +// csr_assert_fpv is an auto-generated csr read assertion module. So only assertion coverage is +// meaningful to collect. +deselect_coverage -betf -module *csr_assert_fpv... +select_coverage -assert -module *csr_assert_fpv + +// Only enable assertion coverage +deselect_coverage -betf -module *tlul_assert... +select_coverage -assert -module *tlul_assert + +// Only collect toggle coverage on the DUT and the black-boxed IP (above) ports. +deselect_coverage -toggle -module ${DUT_TOP}... +select_coverage -toggle -module ${DUT_TOP} + +select_coverage -toggle -module prim_alert_sender +select_coverage -toggle -module prim_alert_receiver +select_coverage -toggle -module prim_count +select_coverage -toggle -module prim_esc_sender +select_coverage -toggle -module prim_esc_receiver +select_coverage -toggle -module prim_onehot_check +select_coverage -toggle -module prim_prince +select_coverage -toggle -module prim_lfsr +select_coverage -toggle -module prim_secded_inv_64_57_dec +select_coverage -toggle -module prim_secded_inv_39_32_dec diff --git a/hw/vendor/lowrisc_ip/dv/tools/xcelium/unr.cfg b/hw/vendor/lowrisc_ip/dv/tools/xcelium/unr.cfg new file mode 100644 index 0000000..7918eff --- /dev/null +++ b/hw/vendor/lowrisc_ip/dv/tools/xcelium/unr.cfg @@ -0,0 +1,15 @@ +# Copyright lowRISC contributors (OpenTitan project). +# Licensed under the Apache License, Version 2.0, see LICENSE for details. +# SPDX-License-Identifier: Apache-2.0 +check_unr -setup + +#Setup the clock and reset the design +clock -infer +reset ~dut.rst_ni +get_reset_info + +set_prove_time_limit 5m +check_unr -prove +check_unr -list -type unreachable +database -export_unicov +report -detailed