[chip, I2C, DV] Top level I2C host test

hw/top_chip/dv/env/seq_lib/top_chip_dv_base_vseq.sv

@@ -22,7 +22,7 @@ class top_chip_dv_base_vseq extends uvm_sequence;
 
   // Class specific methods
   extern function void set_handles();
-  extern task dut_init(string reset_kind = "HARD");
+  extern virtual task dut_init(string reset_kind = "HARD");
   extern task apply_reset(string kind = "HARD");
   extern task wait_for_sw_test_done();
   // Backdoor-read or override a const symbol in SW to modify the behavior of the test.

hw/top_chip/dv/env/seq_lib/top_chip_dv_i2c_host_tx_rx_vseq.sv

@@ -0,0 +1,84 @@
+// Copyright lowRISC contributors (COSMIC project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+// This vseq is going to be starting a reactive sequence.
+//
+// i2c_monitor shares an analysis port with i2c_sequencer. It sends an i2c_item which contains
+// a member "state". i2c_monitor watches the i2c_if and as soon as it sees the communication started
+// on the bus, it change the state accordingly. Based on the state received on the
+// analysis port of sequencer, i2c_base_seq initializes the start_item method to send i2c_item to
+// i2c_driver so that it can drive ack, nack or rdata to the controller.
+class top_chip_dv_i2c_host_tx_rx_vseq extends top_chip_dv_i2c_tx_rx_vseq;
+  `uvm_object_utils(top_chip_dv_i2c_host_tx_rx_vseq)
+
+  // The timing parameter in cycles used by the agent to add relevant delays before driving Ack,
+  // Nack and Rdata
+  local bit [15:0] scl_period_cycles;
+  local bit [15:0] scl_low_cycles;
+  local bit [15:0] sda_hold_cycles;
+
+  // Standard SV/UVM methods
+  extern function new(string name="");
+  extern task body();
+  extern virtual task dut_init(string reset_kind = "HARD");
+  extern local function void configure_agent_timing();
+endclass : top_chip_dv_i2c_host_tx_rx_vseq
+
+function top_chip_dv_i2c_host_tx_rx_vseq::new(string name = "");
+  super.new(name);
+endfunction : new
+
+task top_chip_dv_i2c_host_tx_rx_vseq::dut_init(string reset_kind = "HARD");
+  // Read the timing parameters through SW backdoor load
+  sw_symbol_backdoor_read("SysClkPeriodNS", sw_sys_clk_period_ns);
+  sw_symbol_backdoor_read("SCLLowTimeNs", sw_scl_low_time_ns);
+  sw_symbol_backdoor_read("HoldDataTimeNs", sw_data_hold_time_ns);
+
+  scl_period_cycles = round_up_divide({sw_scl_clk_period_ns[1], sw_scl_clk_period_ns[0]},
+                                      sw_sys_clk_period_ns[0]);
+  scl_low_cycles    = round_up_divide({sw_scl_low_time_ns[1], sw_scl_low_time_ns[0]},
+                                      sw_sys_clk_period_ns[0]);
+  sda_hold_cycles   = round_up_divide({sw_data_hold_time_ns[1], sw_data_hold_time_ns[0]},
+                                      sw_sys_clk_period_ns[0]);
+
+  super.dut_init(reset_kind);
+endtask
+
+function void top_chip_dv_i2c_host_tx_rx_vseq::configure_agent_timing();
+  // tSetupBit are going to be the cycles before SCL goes high to drive SDA. Agent should drive
+  // atleast two cycles before SCL goes high.
+  int unsigned tSetupBit = 2;
+  cfg.m_i2c_agent_cfg.timing_cfg.tSetupBit = tSetupBit;
+
+  // tHoldBit are the cycles to hold SDA after SCL goes low.
+  cfg.m_i2c_agent_cfg.timing_cfg.tHoldBit = sda_hold_cycles;
+
+  // Used by i2c_if to stretch SCL by tClockpulse before driving SDA. If tClockPulse is greater
+  // than scl_low_cycles then i2c_monitor acknowledge the Ack later and then drives Rdata when SCL
+  // is high.
+  cfg.m_i2c_agent_cfg.timing_cfg.tClockPulse = scl_low_cycles;
+
+  // tClockLow are the SCL low cycles that the i2c_driver use before driving SDA after stretching
+  // SCL by tClockPulse cycles. Drive SDA atleast tSetBit cycles earlier to avoid the chances of
+  // SDA interference.
+  cfg.m_i2c_agent_cfg.timing_cfg.tClockLow = scl_low_cycles - tSetupBit;
+endfunction
+
+task top_chip_dv_i2c_host_tx_rx_vseq::body();
+  i2c_device_response_seq seq = i2c_device_response_seq::type_id::create("seq");
+
+  configure_agent_timing();
+  print_i2c_timing_cfg();
+
+  // Configure the agent to be reactive
+  cfg.m_i2c_agent_cfg.if_mode = Device;
+
+  `DV_WAIT(cfg.sw_test_status_vif.sw_test_status == SwTestStatusInTest);
+
+  `uvm_info(`gfn, "Starting I2C Host TX-RX test", UVM_LOW)
+
+  fork
+    seq.start(p_sequencer.i2c_sqr);
+  join_none
+endtask : body

hw/top_chip/dv/env/seq_lib/top_chip_dv_i2c_tx_rx_vseq.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
+
+class top_chip_dv_i2c_tx_rx_vseq extends top_chip_dv_base_vseq;
+  `uvm_object_utils(top_chip_dv_i2c_tx_rx_vseq)
+
+  // Below variables will get assign through SW backdoor load. They are defined as byte size array
+  // as "sw_symbol_backdoor_read/overwrite" takes an array as an argument to write or read the SW
+  // symbol.
+  protected bit [7:0] sw_sys_clk_period_ns[1];
+  protected bit [7:0] sw_scl_clk_period_ns[2];
+  protected bit [7:0] sw_scl_low_time_ns[2];
+  protected bit [7:0] sw_data_hold_time_ns[2];
+
+  extern function new(string name="");
+
+  // Obtain an integer minimum of timing parameter "a" and round up to the next highest integer.
+  extern protected function int unsigned round_up_divide(int unsigned a, int unsigned b);
+  extern protected function void print_i2c_timing_cfg();
+endclass : top_chip_dv_i2c_tx_rx_vseq
+
+function top_chip_dv_i2c_tx_rx_vseq::new(string name = "");
+  super.new(name);
+endfunction
+
+function int unsigned top_chip_dv_i2c_tx_rx_vseq::round_up_divide(int unsigned a, int unsigned b);
+  return (((a - 1) / b) + 1);
+endfunction
+
+function void top_chip_dv_i2c_tx_rx_vseq::print_i2c_timing_cfg();
+  string str;
+  str = {str, $sformatf("\n    timing_cfg.tSetupStart       : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tSetupStart)};
+  str = {str, $sformatf("\n    timing_cfg.tHoldStart        : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tHoldStart)};
+  str = {str, $sformatf("\n    timing_cfg.tClockStart       : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tClockStart)};
+  str = {str, $sformatf("\n    timing_cfg.tClockLow         : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tClockLow)};
+  str = {str, $sformatf("\n    timing_cfg.tSetupBit         : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tSetupBit)};
+  str = {str, $sformatf("\n    timing_cfg.tClockPulse       : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tClockPulse)};
+  str = {str, $sformatf("\n    timing_cfg.tHoldBit          : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tHoldBit)};
+  str = {str, $sformatf("\n    timing_cfg.tClockStop        : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tClockStop)};
+  str = {str, $sformatf("\n    timing_cfg.tSetupStop        : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tSetupStop)};
+  str = {str, $sformatf("\n    timing_cfg.tHoldStop         : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tHoldStop)};
+  str = {str, $sformatf("\n    timing_cfg.tTimeOut          : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tTimeOut)};
+  str = {str, $sformatf("\n    timing_cfg.enbTimeOut        : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.enbTimeOut)};
+  str = {str, $sformatf("\n    timing_cfg.tStretchHostClock : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tStretchHostClock)};
+  str = {str, $sformatf("\n    timing_cfg.tSdaUnstable      : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tSdaUnstable)};
+  str = {str, $sformatf("\n    timing_cfg.tSdaInterference  : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tSdaInterference)};
+  str = {str, $sformatf("\n    timing_cfg.tSclInterference  : %d",
+            cfg.m_i2c_agent_cfg.timing_cfg.tSclInterference)};
+  `uvm_info(`gfn, $sformatf("%s", str), UVM_MEDIUM);
+endfunction

hw/top_chip/dv/env/seq_lib/top_chip_dv_vseq_list.sv

@@ -5,3 +5,5 @@
 `include "top_chip_dv_base_vseq.sv"
 `include "top_chip_dv_uart_base_vseq.sv"
 `include "top_chip_dv_gpio_smoke_vseq.sv"
+`include "top_chip_dv_i2c_tx_rx_vseq.sv"
+`include "top_chip_dv_i2c_host_tx_rx_vseq.sv"

hw/top_chip/dv/env/top_chip_dv_env.core

@@ -13,6 +13,7 @@ filesets:
       - lowrisc:dv:uart_agent
       - lowrisc:dv:common_ifs
       - lowrisc:mocha_dv:gpio_env
+      - lowrisc:dv:i2c_env
     files:
       - top_chip_dv_env_pkg.sv
       - mem_clear_util.sv: {is_include_file: true}
@@ -24,6 +25,8 @@ filesets:
       - seq_lib/top_chip_dv_base_vseq.sv: {is_include_file: true}
       - seq_lib/top_chip_dv_uart_base_vseq.sv: {is_include_file: true}
       - seq_lib/top_chip_dv_gpio_smoke_vseq.sv: {is_include_file: true}
+      - seq_lib/top_chip_dv_i2c_tx_rx_vseq.sv: {is_include_file: true}
+      - seq_lib/top_chip_dv_i2c_host_tx_rx_vseq.sv: {is_include_file: true}
     file_type: systemVerilogSource
 
 targets:

hw/top_chip/dv/env/top_chip_dv_env.sv

@@ -13,6 +13,7 @@ class top_chip_dv_env extends uvm_env;
 
   // Agents
   uart_agent m_uart_agent;
+  i2c_agent  m_i2c_agent;
 
   // Standard SV/UVM methods
   extern function new(string name = "", uvm_component parent = null);
@@ -67,6 +68,12 @@ function void top_chip_dv_env::build_phase(uvm_phase phase);
     `uvm_fatal(`gfn, "Cannot get sys_clk_vif")
   end
 
+  // Set I2C agent config object for I2C agent
+  uvm_config_db#(i2c_agent_cfg)::set(this, "m_i2c_agent", "cfg", cfg.m_i2c_agent_cfg);
+
+  // Create I2C agent
+  m_i2c_agent = i2c_agent::type_id::create("m_i2c_agent", this);
+
   // Instantiate UART agent
   m_uart_agent = uart_agent::type_id::create("m_uart_agent", this);
   uvm_config_db#(uart_agent_cfg)::set(this, "m_uart_agent*", "cfg", cfg.m_uart_agent_cfg);
@@ -83,6 +90,7 @@ function void top_chip_dv_env::connect_phase(uvm_phase phase);
   // Track specific agent sequencers in the virtual sequencer.
   // Allows virtual sequences to use the agents to drive RX items.
   top_vsqr.uart_sqr = m_uart_agent.sequencer;
+  top_vsqr.i2c_sqr  = m_i2c_agent.sequencer;
 
   // Connect monitor output to matching FIFO in the virtual sequencer.
   // Allows virtual sequences to check TX items.

hw/top_chip/dv/env/top_chip_dv_env_cfg.sv

@@ -18,6 +18,7 @@ class top_chip_dv_env_cfg extends uvm_object;
 
   // External interface agent configs
   rand uart_agent_cfg    m_uart_agent_cfg;
+  i2c_agent_cfg          m_i2c_agent_cfg;
 
   `uvm_object_utils_begin(top_chip_dv_env_cfg)
   `uvm_object_utils_end
@@ -45,6 +46,9 @@ function void top_chip_dv_env_cfg::initialize();
   // Configuration is required to perform meaningful monitoring
   m_uart_agent_cfg.en_tx_monitor = 0;
   m_uart_agent_cfg.en_rx_monitor = 0;
+
+  // Create I2C agent config object
+  m_i2c_agent_cfg = i2c_agent_cfg::type_id::create("m_i2c_agent_cfg");
 endfunction : initialize
 
 function void top_chip_dv_env_cfg::get_mem_image_files_from_plusargs();

hw/top_chip/dv/env/top_chip_dv_virtual_sequencer.sv

@@ -14,6 +14,7 @@ class top_chip_dv_virtual_sequencer extends uvm_sequencer;
   // Handles to specific interface agent sequencers. Used by some virtual
   // sequences to drive RX (to-chip) items.
   uart_sequencer uart_sqr;
+  i2c_sequencer  i2c_sqr;
 
   // FIFOs for monitor output. Used by some virtual sequences to check
   // TX (from-chip) items.

hw/top_chip/dv/tb/tb.sv

@@ -38,10 +38,22 @@ module tb;
   logic                                      rng_valid;
   logic [top_pkg::EntropySrcRngBusWidth-1:0] rng_bits;
 
+  // I2C connections
+  wire  scl;
+  wire  sda;
+  logic scl_en_o;
+  logic sda_en_o;
+  logic scl_o;
+  logic sda_o;
+
   // ------ Interfaces ------
   clk_rst_if sys_clk_if(.clk(clk), .rst_n(rst_n));
   uart_if uart_if();
   pins_if #(NUM_GPIOS) gpio_pins_if (.pins(gpio_pads));
+  i2c_if i2c_if (.clk_i(clk),
+                 .rst_ni(rst_n),
+                 .scl_io(scl),
+                 .sda_io(sda));
 
   // ------ Mock DRAM ------
   top_pkg::axi_dram_req_t  dram_req;
@@ -82,6 +94,13 @@ module tb;
     // UART receive and transmit.
     .uart_rx_i            (uart_if.uart_rx  ),
     .uart_tx_o            (uart_if.uart_tx  ),
+    // I2C controller/target bidirectional interface.
+    .i2c_scl_i            (scl              ),
+    .i2c_scl_o            (scl_o            ),
+    .i2c_scl_en_o         (scl_en_o         ),
+    .i2c_sda_i            (sda              ),
+    .i2c_sda_o            (sda_o            ),
+    .i2c_sda_en_o         (sda_en_o         ),
     // External Mailbox port
     .axi_mailbox_req_i    ('0               ),
     .axi_mailbox_resp_o   (                 ),
@@ -126,6 +145,10 @@ module tb;
     assign gpio_pads[i] = dut_gpio_en_o[i] ? dut_gpio_o[i] : 1'bz;
   end
 
+  // Modelling the open-drain circuit
+  assign (strong0, weak1) scl = (scl_en_o) ? scl_o : 1'b1;
+  assign (strong0, weak1) sda = (sda_en_o) ? sda_o : 1'b1;
+
   // Signals to connect the sink
   logic               sim_sram_clk;
   logic               sim_sram_rst;
@@ -260,6 +283,7 @@ module tb;
     uvm_config_db#(virtual clk_rst_if)::set(null, "*", "sys_clk_if", sys_clk_if);
     uvm_config_db#(virtual uart_if)::set(null, "*.env.m_uart_agent*", "vif", uart_if);
     uvm_config_db#(virtual pins_if #(NUM_GPIOS))::set(null, "*.env", "gpio_vif", gpio_pins_if);
+    uvm_config_db#(virtual i2c_if)::set(null, "*.env.m_i2c_agent", "vif", i2c_if);
 
     // SW logger and test status interfaces.
     uvm_config_db#(virtual sw_test_status_if)::set(

hw/top_chip/dv/top_chip_sim_cfg.hjson

@@ -151,7 +151,14 @@
       sw_images: ["i2c_host_tx_rx_test_vanilla_sram:5" "bootrom:5"]
       run_opts: ["+ChipMemSRAM_image_file={run_dir}/i2c_host_tx_rx_test_vanilla_sram.vmem",
                  "+ChipMemROM_image_file={run_dir}/bootrom.vmem"]
-      }
+    }
+    {
+      name: i2c_host_tx_rx_cheri
+      uvm_test_seq: top_chip_dv_i2c_host_tx_rx_vseq
+      sw_images: ["i2c_host_tx_rx_test_cheri_sram:5" "bootrom:5"]
+      run_opts: ["+ChipMemSRAM_image_file={run_dir}/i2c_host_tx_rx_test_cheri_sram.vmem",
+                 "+ChipMemROM_image_file={run_dir}/bootrom.vmem"]
+    }
     {
       name: i2c_device_tx_rx
       uvm_test_seq: top_chip_dv_i2c_device_tx_rx_vseq

sw/device/examples/i2c.c

@@ -15,7 +15,7 @@ int main(void)
     i2c_t i2c = mocha_system_i2c();
     uart_t uart = mocha_system_uart();
     timer_t timer = mocha_system_timer();
-    i2c_init(i2c);
+    i2c_init(i2c, i2c_speed_mode_standard);
     uart_init(uart);
     timer_init(timer);
     timer_enable_write(timer, true);
@@ -28,10 +28,13 @@ int main(void)
     while (true) {
         timer_busy_sleep_us(timer, 1000u);
 
+        uint8_t w_data = 0;
         // Read current temperature from an AS6212 I^2C-bus sensor and print the value
-        if (i2c_write_byte(i2c, 0x48u, 0u)) { // select TVAL reg; also a presence check
-            uint16_t sensor_reading = i2c_read_byte(i2c, 0x48u); // read TVAl reg
-            if (sensor_reading != 0xFF) { // only print if we get a non-error value
+        i2c_write_bytes(i2c, 0x48u, &w_data, 1);
+        if (i2c_wait_write_finish(i2c)) { // select TVAL reg; also a presence check
+            i2c_read_bytes(i2c, 0x48u, 1);
+            if (i2c_wait_read_finish(i2c)) {
+                uint16_t sensor_reading = i2c_rdata_byte(i2c); // read TVAl reg
                 uprintf(uart, "Temperature: 0x%x degC\n",
                         (sensor_reading << 1)); // no decimal printf
             }