SoC Verification Flow: Step-by-Step From IP to Silicon
In short: The SoC verification flow is how a team proves a chip works, one level at a time. Each IP block is verified alone, then small groups of blocks (subsystems), then the full chip with the real CPU running test code, then the design runs on an emulator or FPGA, and finally the real silicon is tested in the lab. Each level hunts a different kind of bug, and each has an exit gate you pass before the next level starts.
A System-on-Chip (SoC) puts a whole system on one piece of silicon: CPU cores, memory controllers, timers, GPIO, interfaces, all wired together on one bus fabric. Each of those blocks can be perfect on its own and the chip can still fail, because a wire landed in the wrong place or two blocks disagree about who owns the bus.
That is why the flow goes level by level. This guide walks every level, gives you a sign-off checklist, and ends with a small example you can run: an IP-level UVM env reused inside a toy SoC, with a wiring bug caught three different ways on Synopsys VCS.
The big picture: five levels, four gates
Think of building a car. Each part is bench-tested by its own team. Then parts are fitted together on a rig. Then the finished car takes a road test, then a long run on a test track, and finally it goes to customers. Nobody takes the engine apart on the road test. The road test checks that the parts work together.
| Car | Chip | What is checked |
|---|---|---|
| Engine on a test bench | IP verification | One block against its spec |
| Engine and gearbox on a rig | Subsystem verification | A few blocks sharing a bus, memory or clock |
| Road test of the finished car | SoC verification | Wiring and real jobs, with the CPU running test code |
| Long run on a test track | Emulation / FPGA | Real software at speed, for a long time |
| Cars with customers, winter and summer | Post-silicon validation | The real chip across voltage, temperature and boards |
In the diagram at the top of this page, the arrows only go down. A level starts in earnest when the gate above it is green. Most of this guide is about level 3, the full SoC, because that is where the flow differs most from block-level work.
Each level at a glance
| Level | Question it answers | Main methods | Exit gate | Bugs it is best at |
|---|---|---|---|---|
| 1. IP | Does this one block match its spec? | UVM env with active agents, scoreboard, constrained random, assertions, formal on control logic | Coverage closed, regression clean, open bugs closed or waived | Protocol corners, FSM holes, data path math, reset values |
| 2. Subsystem | Do a few blocks work together? | IP envs reused, agents passive on internal buses, a subsystem scoreboard | End-to-end paths checked, shared bus and memory stressed | Arbitration, ordering, clock domain crossings, address map overlap |
| 3. Full SoC | Does the whole chip do real jobs? | C tests on the real CPU, UVM checks around it, connectivity checks, power-aware simulation | Boot works, every use case passes, connectivity and power checks clean | Wrong wiring, wrong decode, interrupt routing, power and reset order |
| 4. Emulation / FPGA | Does it hold up with real software, at speed? | OS and driver boot, long runs, real interfaces through speed bridges | Software boots and runs target workloads with no hangs | Deadlocks after millions of cycles, performance holes, driver mismatches |
| 5. Post-silicon | Does the real chip work in the lab? | The same tests where possible, lab equipment, on-chip debug | Chip works across voltage and temperature, errata written for what is left | Timing and analog effects, events too rare to reach before |
Level 1: IP verification, prove the part
- Goal: one block matches its spec on its own.
- Analogy: the engine on a test bench.
- How: a full UVM env with active agents driving the pins, a scoreboard, functional coverage and assertions. If you are building one, start with UVM testbench architecture.
- Build for reuse now: agents that can switch to passive, checkers that only read signals, no hard-coded hierarchy paths. Reuse is cheap only if you plan it at this level.
Level 2: subsystem verification, prove the neighbours
- Goal: a group of blocks shares a bus, memory or clock correctly.
- Analogy: engine and gearbox fitted together on a test rig.
- How: the IP envs come along. Their agents switch to passive on buses that RTL now drives, and a new scoreboard checks data end to end.
- One monitor, two scoreboards: an analysis port can feed any number of subscribers, so the block scoreboard and the subsystem scoreboard both listen to the same monitor. More on that in UVM TLM explained.
- Start from the bus protocol: most subsystems talk over a standard bus such as AXI, so the shared-bus checks begin with the protocol rules. See the AXI protocol verification guide.
Level 3: full SoC verification, prove the chip
- Goal: the chip does what a user would ask of it: boot, configure a block, move data, sleep, wake.
- Analogy: the road test of the finished car.
- Scope rule: if a feature needs two or more blocks talking, it belongs here. Do not retest block internals; the IP team already did.
- C tests on the CPU: the real processor runs small test programs, the same way firmware will use the chip. The testbench watches and checks. The C side and the UVM side need a handshake, usually a mailbox register (shown in the example below).
- Connectivity first: check every route against the spec’s address map and pin list right after integration. One wrong wire makes dozens of tests fail in confusing ways. For many routes, formal tools can prove connectivity from a spreadsheet spec; a DVCon paper from Cadence reports that this cut connectivity work from about 3 months to about 1. See also formal verification: where to use it and why.
- Clocks, resets and power: check that every clock reaches its block at the right rate (clock monitors in SoC verification) and that power modes enter and exit cleanly.
- Analog parts: swap each analog macro for the designer’s digital reference model so regressions stay fast. The true analog behaviour is signed off at IP level.
- Debug: chip-level failures are slow to debug. Per-block verbosity, clear message IDs and a short debug routine save days.
For a longer list of what to cover at this level, see key areas to consider during SoC verification.
Level 4: emulation and FPGA, prove it at speed
- Goal: run real software for long enough to find what simulation never reaches.
- Analogy: a long run on the test track, not a lap around the car park.
- Emulation or FPGA: an emulator is quicker to bring up and gives much better visibility into signals. An FPGA prototype runs faster but is harder to debug and to rebuild. Many teams use both.
- What to run: OS boot, drivers, target workloads, and the same SoC C tests, so results line up with simulation.
Level 5: post-silicon validation, prove the real chip
- Goal: the manufactured chip works across voltage, temperature and real boards.
- Analogy: cars in customers’ hands, in winter and in summer.
- How: reuse the C tests and scenarios from earlier levels wherever you can. Accellera’s Portable Test and Stimulus Standard 3.0 (August 2024) exists so one test description can run in simulation, emulation, FPGA prototyping and post-silicon. Our PSS guide covers it.
- Why the earlier levels matter so much: a bug found here can mean a respin. The 2024 Siemens EDA and Wilson Research Group study found only 14% of IC/ASIC projects reached first-silicon success, the lowest in over 20 years (Siemens Verification Horizons).
Worked example: one IP env, reused inside a toy SoC
Here is the whole idea in about 300 lines. A GPIO block gets its own UVM env at IP level. Then the same env, unchanged except for one setting, sits passively inside a small SoC while a “C test” on a CPU stand-in drives the chip. A one-line +define+BUG swaps the address decode, a classic integration mistake, so you can watch it get caught.
The toy SoC (address map from its spec): 0x0xxx timer, 0x1xxx GPIO, 0xFxxx mailbox. The GPIO pins loop back on the board, so IN = OUT & DIR.
Step 1: the switch that makes reuse work
The agent builds its driver and sequencer only when it is active. The monitor is always built.
function void build_phase(uvm_phase phase);
super.build_phase(phase); // reads is_active from config_db
if (!uvm_config_db#(virtual gpio_bus_if)::get(this, "", "vif", vif))
`uvm_fatal("NOVIF", "gpio_bus_if not set")
mon = gpio_monitor::type_id::create("mon", this); mon.vif = vif;
if (get_is_active() == UVM_ACTIVE) begin
sqr = uvm_sequencer#(gpio_item)::type_id::create("sqr", this);
drv = gpio_driver::type_id::create("drv", this); drv.vif = vif;
end
endfunction
The IP test sets UVM_ACTIVE. The SoC test sets UVM_PASSIVE. Nothing else in the env changes.
Step 2: hook the agent onto an internal bus
At chip level, RTL drives the GPIO port, so the testbench copies those signals into the agent’s interface. The agent only watches.
always @* begin
gif.sel = dut.gpio_sel;
gif.we = dut.we;
gif.addr = dut.addr[11:0];
gif.wdata = dut.wdata;
gif.rdata = dut.gpio_rdata;
end
bind is the other common way to do this.
Step 3: the C test and the mailbox handshake
// On a real chip this is compiled C running on the core:
// GPIO->DIR = 0xFF; GPIO->OUT = 0xA5;
// if (GPIO->IN != 0xA5) fail(1);
// TIMER->LOAD = 8; TIMER->CTRL = 1;
// for (n = 0; TIMER->COUNT != 0; n++) if (n == 40) fail(2);
// MBOX = 0x600D;
The UVM test holds its objection until the mailbox is written, then checks the code:
phase.raise_objection(this);
mbox.wait_trigger(); // firmware writes the mailbox when it is done
$cast(m, mbox.get_trigger_data());
`uvm_info("MBOX", $sformatf("firmware reported 0x%04h", m.code), UVM_LOW)
if (m.code != 32'h600D)
`uvm_error("FW", $sformatf("firmware failed at step %0d", m.code & 32'hF))
phase.drop_objection(this);
Step 4: the connectivity check, written from the spec
The expected route comes from the address map in the spec, never from the RTL you are checking.
module soc_conn_chk (input logic clk, rst_n, sel,
input logic [15:0] addr, input logic timer_sel, gpio_sel);
a_route_timer: assert property (@(posedge clk) disable iff (!rst_n)
sel && addr[15:12] == 4'h0 |-> timer_sel && !gpio_sel)
else `uvm_error("CONN", $sformatf("addr 0x%04h should select the timer only", addr))
a_route_gpio: assert property (@(posedge clk) disable iff (!rst_n)
sel && addr[15:12] == 4'h1 |-> gpio_sel && !timer_sel)
else `uvm_error("CONN", $sformatf("addr 0x%04h should select the GPIO only", addr))
endmodule
bind mini_soc soc_conn_chk u_conn (.clk, .rst_n, .sel, .addr, .timer_sel, .gpio_sel);
Run it
vcs -full64 -sverilog -ntb_opts uvm-1.2 soc_flow_demo.sv -R +UVM_TESTNAME=ip_test
vcs -full64 -sverilog -ntb_opts uvm-1.2 +define+SOC soc_flow_demo.sv -R +UVM_TESTNAME=soc_test
vcs -full64 -sverilog -ntb_opts uvm-1.2 +define+SOC+BUG soc_flow_demo.sv -R +UVM_TESTNAME=soc_test
Real output (Synopsys VCS X-2025.06-SP1, UVM 1.2)
**Run 1, ip_test:** the agent drives the block. 40 random transfers, all checked.
UVM_INFO testbench.sv(161) @ 0: uvm_test_top.env.agt [AGT] built as ACTIVE
UVM_INFO testbench.sv(194) @ 795: uvm_test_top.env.sb [GPIO_SB] writes=16 reads=24 errors=0
UVM_ERROR : 0
**Run 2, soc_test:** the same env, now passive. The C test does the driving and the scoreboard still checks every GPIO access.
UVM_INFO testbench.sv(161) @ 0: uvm_test_top.env.agt [AGT] built as PASSIVE
UVM_INFO testbench.sv(257) @ 245: uvm_test_top [MBOX] firmware reported 0x600d
UVM_INFO testbench.sv(194) @ 245: uvm_test_top.env.sb [GPIO_SB] writes=2 reads=1 errors=0
UVM_ERROR : 0
**Run 3, soc_test with +define+BUG:** one swapped decode, caught three ways.
"testbench.sv", 87: tb.dut.u_conn.a_route_gpio: started at 45ns failed at 45ns
Offending '(gpio_sel && (!timer_sel))'
UVM_ERROR testbench.sv(89) @ 45: reporter [CONN] addr 0x1000 should select the GPIO only
UVM_ERROR testbench.sv(89) @ 65: reporter [CONN] addr 0x1004 should select the GPIO only
UVM_ERROR testbench.sv(89) @ 85: reporter [CONN] addr 0x1008 should select the GPIO only
UVM_INFO testbench.sv(257) @ 105: uvm_test_top [MBOX] firmware reported 0xbad1
UVM_ERROR testbench.sv(259) @ 105: uvm_test_top [FW] firmware failed at step 1
UVM_INFO testbench.sv(194) @ 105: uvm_test_top.env.sb [GPIO_SB] writes=0 reads=0 errors=0
UVM_ERROR testbench.sv(195) @ 105: uvm_test_top.env.sb [GPIO_SB] no GPIO traffic seen: is the block even connected?
UVM_ERROR : 5
How to read run 3:
- 45 ns, the assertion: fires on the very first GPIO write and names the exact address. Fastest and most precise.
- 105 ns, the C test: only says step 1 failed. True, but you still have to dig for the reason.
- End of test, the reused scoreboard: it saw 0 transfers. Without the
n_wr + n_rd == 0check it would have printederrors=0and looked like a pass. Make every scoreboard complain when it saw nothing.
Only one setting changed between run 1 and run 2: is_active. That is what IP-to-SoC reuse looks like when the IP env is built for it.
Full code
The whole file, ready to run with the commands above. The RTL and C-test part also runs on Verilator 5.020 if you strip the UVM classes.
// soc_flow_demo.sv : one IP verified alone, then reused inside a toy SoC
// IP level : vcs -full64 -sverilog -ntb_opts uvm-1.2 soc_flow_demo.sv -R +UVM_TESTNAME=ip_test
// SoC level: add +define+SOC and +UVM_TESTNAME=soc_test
// SoC + bug: add +define+SOC+BUG and +UVM_TESTNAME=soc_test
`timescale 1ns/1ns
`include "uvm_macros.svh"
import uvm_pkg::*;
// ===================== RTL =====================
// GPIO IP: DIR @0x0, OUT @0x4, IN @0x8 (read only)
module gpio_ip (input logic clk, rst_n, sel, we,
input logic [11:0] addr, input logic [31:0] wdata,
output logic [31:0] rdata,
input logic [7:0] pins_in, output logic [7:0] pins_out);
logic [7:0] dir, out;
always_ff @(posedge clk or negedge rst_n)
if (!rst_n) begin dir <= '0; out <= '0; end
else if (sel && we)
case (addr)
12'h000: dir <= wdata[7:0];
12'h004: out <= wdata[7:0];
default: ;
endcase
always_comb
case (addr)
12'h000: rdata = {24'b0, dir};
12'h004: rdata = {24'b0, out};
12'h008: rdata = {24'b0, pins_in};
default: rdata = '0;
endcase
assign pins_out = out & dir;
endmodule
// Timer IP: LOAD @0x0, CTRL @0x4 (bit0 = enable), COUNT @0x8 counts down to 0
module timer_ip (input logic clk, rst_n, sel, we,
input logic [11:0] addr, input logic [31:0] wdata,
output logic [31:0] rdata);
logic [31:0] count; logic en;
always_ff @(posedge clk or negedge rst_n)
if (!rst_n) begin count <= '0; en <= 0; end
else if (sel && we && addr == 12'h000) count <= wdata;
else begin
if (sel && we && addr == 12'h004) en <= wdata[0];
if (en && count != 0) count <= count - 1;
end
always_comb
case (addr)
12'h004: rdata = {31'b0, en};
12'h008: rdata = count;
default: rdata = '0;
endcase
endmodule
// Toy SoC: one bus master port (the CPU), address decode, two IPs, a mailbox
// Map from the spec: 0x0xxx timer, 0x1xxx gpio, 0xFxxx mailbox
module mini_soc (input logic clk, rst_n,
input logic sel, we, input logic [15:0] addr, input logic [31:0] wdata,
output logic [31:0] rdata,
output logic mbox_wr, output logic [31:0] mbox_data);
logic timer_sel, gpio_sel, mbox_sel;
logic [31:0] timer_rdata, gpio_rdata;
logic [7:0] pins;
`ifdef BUG
assign gpio_sel = sel && addr[15:12] == 4'h0; // integration bug: decode swapped
assign timer_sel = sel && addr[15:12] == 4'h1;
`else
assign timer_sel = sel && addr[15:12] == 4'h0;
assign gpio_sel = sel && addr[15:12] == 4'h1;
`endif
assign mbox_sel = sel && addr[15:12] == 4'hF;
timer_ip u_timer (.clk, .rst_n, .sel(timer_sel), .we, .addr(addr[11:0]), .wdata,
.rdata(timer_rdata));
gpio_ip u_gpio (.clk, .rst_n, .sel(gpio_sel), .we, .addr(addr[11:0]), .wdata,
.rdata(gpio_rdata), .pins_in(pins), .pins_out(pins)); // board loopback
assign rdata = gpio_sel ? gpio_rdata : timer_sel ? timer_rdata : '0;
assign mbox_wr = mbox_sel && we;
assign mbox_data = wdata;
endmodule
// ===================== Connectivity checker (SoC level) =====================
// The expected route comes from the address map in the spec, not from the RTL.
module soc_conn_chk (input logic clk, rst_n, sel,
input logic [15:0] addr, input logic timer_sel, gpio_sel);
a_route_timer: assert property (@(posedge clk) disable iff (!rst_n)
sel && addr[15:12] == 4'h0 |-> timer_sel && !gpio_sel)
else `uvm_error("CONN", $sformatf("addr 0x%04h should select the timer only", addr))
a_route_gpio: assert property (@(posedge clk) disable iff (!rst_n)
sel && addr[15:12] == 4'h1 |-> gpio_sel && !timer_sel)
else `uvm_error("CONN", $sformatf("addr 0x%04h should select the GPIO only", addr))
endmodule
bind mini_soc soc_conn_chk u_conn (.clk, .rst_n, .sel, .addr, .timer_sel, .gpio_sel);
// ===================== GPIO verification IP (written once, at IP level) =====================
interface gpio_bus_if (input logic clk);
logic sel, we; logic [11:0] addr; logic [31:0] wdata, rdata;
clocking drv_cb @(posedge clk); default output #1; output sel, we, addr, wdata; endclocking
clocking mon_cb @(posedge clk); default input #1step; input sel, we, addr, wdata, rdata; endclocking
endinterface
class gpio_item extends uvm_sequence_item;
`uvm_object_utils(gpio_item)
rand bit we; rand bit [11:0] addr; rand bit [31:0] data;
constraint c_addr { addr inside {12'h000, 12'h004, 12'h008}; }
function new(string name = "gpio_item"); super.new(name); endfunction
function string convert2string();
return $sformatf("%s addr=0x%03h data=0x%02h", we ? "WR" : "RD", addr, data);
endfunction
endclass
class gpio_driver extends uvm_driver #(gpio_item);
`uvm_component_utils(gpio_driver)
virtual gpio_bus_if vif;
function new(string name, uvm_component parent); super.new(name, parent); endfunction
task run_phase(uvm_phase phase);
vif.drv_cb.sel <= 0;
forever begin
seq_item_port.get_next_item(req);
@(vif.drv_cb);
vif.drv_cb.sel <= 1; vif.drv_cb.we <= req.we;
vif.drv_cb.addr <= req.addr; vif.drv_cb.wdata <= req.data;
@(vif.drv_cb);
vif.drv_cb.sel <= 0; vif.drv_cb.we <= 0;
seq_item_port.item_done();
end
endtask
endclass
class gpio_monitor extends uvm_monitor;
`uvm_component_utils(gpio_monitor)
virtual gpio_bus_if vif;
uvm_analysis_port #(gpio_item) ap;
function new(string name, uvm_component parent); super.new(name, parent); ap = new("ap", this); endfunction
task run_phase(uvm_phase phase);
forever begin
@(vif.mon_cb);
if (vif.mon_cb.sel !== 1) continue;
begin
gpio_item t = gpio_item::type_id::create("t");
t.we = vif.mon_cb.we; t.addr = vif.mon_cb.addr;
t.data = t.we ? vif.mon_cb.wdata : vif.mon_cb.rdata;
ap.write(t);
end
end
endtask
endclass
class gpio_agent extends uvm_agent;
`uvm_component_utils(gpio_agent)
uvm_sequencer #(gpio_item) sqr; gpio_driver drv; gpio_monitor mon;
virtual gpio_bus_if vif;
function new(string name, uvm_component parent); super.new(name, parent); endfunction
function void build_phase(uvm_phase phase);
super.build_phase(phase); // reads is_active from config_db
if (!uvm_config_db#(virtual gpio_bus_if)::get(this, "", "vif", vif))
`uvm_fatal("NOVIF", "gpio_bus_if not set")
mon = gpio_monitor::type_id::create("mon", this); mon.vif = vif;
if (get_is_active() == UVM_ACTIVE) begin
sqr = uvm_sequencer#(gpio_item)::type_id::create("sqr", this);
drv = gpio_driver::type_id::create("drv", this); drv.vif = vif;
end
`uvm_info("AGT", $sformatf("built as %s", get_is_active() == UVM_ACTIVE ? "ACTIVE" : "PASSIVE"), UVM_LOW)
endfunction
function void connect_phase(uvm_phase phase);
if (get_is_active() == UVM_ACTIVE) drv.seq_item_port.connect(sqr.seq_item_export);
endfunction
endclass
// Reference model of the GPIO registers; pins are looped back (IN = OUT & DIR)
class gpio_sb extends uvm_subscriber #(gpio_item);
`uvm_component_utils(gpio_sb)
bit [7:0] dir, out; int unsigned n_wr, n_rd, n_err;
function new(string name, uvm_component parent); super.new(name, parent); endfunction
function void write(gpio_item t);
bit [31:0] exp;
if (t.we) begin
n_wr++;
if (t.addr == 12'h000) dir = t.data[7:0];
if (t.addr == 12'h004) out = t.data[7:0];
return;
end
n_rd++;
case (t.addr)
12'h000: exp = dir;
12'h004: exp = out;
12'h008: exp = out & dir;
default: exp = 0;
endcase
if (t.data !== exp) begin
n_err++;
`uvm_error("GPIO_SB", $sformatf("%s expected 0x%02h", t.convert2string(), exp))
end
endfunction
function void report_phase(uvm_phase phase);
`uvm_info("GPIO_SB", $sformatf("writes=%0d reads=%0d errors=%0d", n_wr, n_rd, n_err), UVM_LOW)
if (n_wr + n_rd == 0) `uvm_error("GPIO_SB", "no GPIO traffic seen: is the block even connected?")
endfunction
endclass
class gpio_env extends uvm_env;
`uvm_component_utils(gpio_env)
gpio_agent agt; gpio_sb sb;
function new(string name, uvm_component parent); super.new(name, parent); endfunction
function void build_phase(uvm_phase phase);
agt = gpio_agent::type_id::create("agt", this);
sb = gpio_sb::type_id::create("sb", this);
endfunction
function void connect_phase(uvm_phase phase);
agt.mon.ap.connect(sb.analysis_export);
endfunction
endclass
// ===================== Tests =====================
class gpio_rand_seq extends uvm_sequence #(gpio_item);
`uvm_object_utils(gpio_rand_seq)
function new(string name = "gpio_rand_seq"); super.new(name); endfunction
task body();
repeat (40) `uvm_do(req)
endtask
endclass
class ip_test extends uvm_test; // IP level: the agent drives the GPIO directly
`uvm_component_utils(ip_test)
gpio_env env;
function new(string name, uvm_component parent); super.new(name, parent); endfunction
function void build_phase(uvm_phase phase);
uvm_config_db#(uvm_active_passive_enum)::set(this, "env.agt", "is_active", UVM_ACTIVE);
env = gpio_env::type_id::create("env", this);
endfunction
task run_phase(uvm_phase phase);
gpio_rand_seq seq = gpio_rand_seq::type_id::create("seq");
phase.raise_objection(this);
seq.start(env.agt.sqr);
phase.drop_objection(this);
endtask
endclass
class mbox_msg extends uvm_object; // carries the mailbox value from the top to the test
`uvm_object_utils(mbox_msg)
bit [31:0] code;
function new(string name = "mbox_msg"); super.new(name); endfunction
endclass
class soc_test extends uvm_test; // SoC level: firmware drives, the same env only watches
`uvm_component_utils(soc_test)
gpio_env env;
function new(string name, uvm_component parent); super.new(name, parent); endfunction
function void build_phase(uvm_phase phase);
uvm_config_db#(uvm_active_passive_enum)::set(this, "env.agt", "is_active", UVM_PASSIVE);
env = gpio_env::type_id::create("env", this);
endfunction
task run_phase(uvm_phase phase);
uvm_event mbox = uvm_event_pool::get_global("mbox");
mbox_msg m;
phase.raise_objection(this);
mbox.wait_trigger(); // firmware writes the mailbox when it is done
$cast(m, mbox.get_trigger_data());
`uvm_info("MBOX", $sformatf("firmware reported 0x%04h", m.code), UVM_LOW)
if (m.code != 32'h600D)
`uvm_error("FW", $sformatf("firmware failed at step %0d", m.code & 32'hF))
phase.drop_objection(this);
endtask
endclass
// ===================== Testbench tops =====================
module tb;
logic clk = 0, rst_n = 0;
always #5 clk = ~clk;
initial begin repeat (3) @(posedge clk); rst_n = 1; end
gpio_bus_if gif (clk);
`ifndef SOC
// ---- IP level: agent drives the GPIO pins of the block ----
logic [7:0] pins;
gpio_ip dut (.clk, .rst_n, .sel(gif.sel), .we(gif.we), .addr(gif.addr), .wdata(gif.wdata),
.rdata(gif.rdata), .pins_in(pins), .pins_out(pins));
`else
// ---- SoC level: a CPU stand-in runs the test program; the GPIO agent listens ----
logic sel = 0, we = 0; logic [15:0] addr = '0; logic [31:0] wdata = '0, rdata;
logic mbox_wr; logic [31:0] mbox_data;
mini_soc dut (.clk, .rst_n, .sel, .we, .addr, .wdata, .rdata, .mbox_wr, .mbox_data);
// Hook the reused agent onto the GPIO's internal port (passive: it only watches)
always @* begin
gif.sel = dut.gpio_sel;
gif.we = dut.we;
gif.addr = dut.addr[11:0];
gif.wdata = dut.wdata;
gif.rdata = dut.gpio_rdata;
end
always @(posedge clk) if (mbox_wr) begin
mbox_msg m;
m = new();
m.code = mbox_data;
uvm_event_pool::get_global("mbox").trigger(m);
end
task automatic wr32(input logic [15:0] a, input logic [31:0] d);
@(posedge clk); #1 sel = 1; we = 1; addr = a; wdata = d;
@(posedge clk); #1 sel = 0; we = 0;
endtask
task automatic rd32(input logic [15:0] a, output logic [31:0] d);
@(posedge clk); #1 sel = 1; we = 0; addr = a;
@(negedge clk); d = rdata;
@(posedge clk); #1 sel = 0;
endtask
// The "C test". On a real chip this is compiled C running on the core:
// GPIO->DIR = 0xFF; GPIO->OUT = 0xA5;
// if (GPIO->IN != 0xA5) fail(1);
// TIMER->LOAD = 8; TIMER->CTRL = 1;
// for (n = 0; TIMER->COUNT != 0; n++) if (n == 40) fail(2);
// MBOX = 0x600D;
initial begin : firmware
logic [31:0] v; int n;
wait (rst_n === 1);
wr32(16'h1000, 32'hFF);
wr32(16'h1004, 32'hA5);
rd32(16'h1008, v);
if (v != 32'hA5) begin wr32(16'hF000, 32'hBAD1); disable firmware; end
wr32(16'h0000, 32'd8);
wr32(16'h0004, 32'd1);
n = 0;
do begin rd32(16'h0008, v); n++; end while (v != 0 && n < 40);
if (v != 0) begin wr32(16'hF000, 32'hBAD2); disable firmware; end
wr32(16'hF000, 32'h600D);
end
`endif
initial begin
uvm_config_db#(virtual gpio_bus_if)::set(null, "uvm_test_top.env.agt", "vif", gif);
uvm_top.set_timeout(100us, 1);
run_test();
end
endmodule
The sign-off checklist, level by level
Copy this into your plan. Every line is a yes or no question a lead can ask in a review.
IP level
- Verification plan reviewed with the designer; every spec feature mapped to a test, cover point or assertion
- Functional and code coverage closed; every exclusion has a written, designer-approved reason
- Regression clean on many seeds, for a set number of nights in a row
- Agents work in passive mode; checkers do not depend on driving pins
Subsystem level
- Every end-to-end data path has a scoreboard check
- Shared bus and memory stressed with all masters active at once
- Clock domain crossings and reset sequences reviewed
SoC level
- Connectivity checked against the spec’s address map and pin list, by assertions or formal
- Boot from reset works with the real boot code
- Every use case in the plan passes as a C test with a mailbox result
- Interrupts reach the right CPU line; every power mode enters and exits cleanly
- Coverage merged across C tests and UVM tests
Emulation / FPGA
- OS and drivers boot; target workloads run with no hang over long runs
- The SoC C tests also pass here, so results match simulation
Final sign-off (tape-out)
- All levels above green; every bug closed or waived with a reason
- Known gaps written down for the post-silicon team
- Post-silicon test plan reuses the same scenarios (C tests or PSS)
Common mistakes, from real forum threads
Retold in our own words, each with more than one fix.
- The C test and the UVM side lose track of each other. An engineer running C on an Arm core in the SoC asked how the C code and SystemVerilog could signal each other (thread); a 2025 thread asked the same thing without DPI (thread).
- Fix A: a mailbox register the C code writes and the testbench watches, as in Step 3 above.
- Fix B: DPI calls, which the replies describe as far more efficient.
- Fix C: describe the scenario once in PSS and let the tool generate both sides.
- Rebuilding block checkers at chip level. A team asked how to hook a reusable AHB VIP onto a bus that is now inside the chip (thread).
- Fix A: reuse the block env and switch its agents to passive.
- Fix B: connect the interface by port, assign or
bindin the top. Only the test reads virtual interfaces from config_db and passes them down in config objects.
- Leaving an agent active on a bus that RTL now drives. Two drivers fight, and you see X or garbage on the bus.
- Fix A: set
is_activetoUVM_PASSIVEfor every agent whose pins are internal at this level. - Fix B: print the topology in
end_of_elaboration_phaseand check that no driver exists where none should.
- Fix A: set
- Connectivity assertions that cannot see the signal. A user wanted to check a path from a top pin to a signal deep inside the design (thread).
- Fix A:
bindthe checker to the lowest instance that owns the signal. - Fix B: for many routes, generate the checks from the spec with a formal connectivity tool.
- Fix A:
- Bare-metal C tests with no printf. Someone asked how to write C tests for an SoC when there is no printf (thread).
- Fix A: write codes or characters to a mailbox and let the testbench print them.
- Fix B: keep OS-level tests for emulation and prototyping, where an OS can actually run.
- Thinking one monitor can feed only one scoreboard. Asked in this thread.
- Fix: an analysis port connects to any number of subscribers, so the block scoreboard and the top scoreboard both listen.
- A scoreboard that passes when it saw nothing. Our own run 3 above: the reused scoreboard got 0 transfers and still reported
errors=0.- Fix A: report an error in
report_phasewhen the transfer count is 0. - Fix B: add a cover point on transfer count, so coverage shows the hole too.
- Fix A: report an error in
Frequently asked questions
What is the SoC verification flow?
It is how a team proves a chip works, level by level: IP, subsystem, full SoC, emulation or FPGA, then post-silicon. Each level has an exit gate you pass before moving on.
How is SoC verification different from IP verification?
IP verification checks one block alone, such as a memory controller. SoC verification checks the blocks working together: wiring, address decode, interrupts, power modes and real use cases. It does not retest block internals.
Who writes the C tests for SoC verification?
Usually the SoC verification team, often with firmware engineers. The tests run on the real CPU model in simulation and report pass or fail through a mailbox register.
Why are connectivity checks so important?
One wrong wire can make many chip-level tests fail in ways that look like functional bugs. In the example above, the connectivity assertion flagged the swapped decode at 45 ns and named the address, before the C test failed at 105 ns.
Should I use emulation or FPGA prototyping?
Emulation is quicker to bring up and easier to debug. An FPGA prototype runs faster but gives less visibility. Many teams use emulation first, then FPGA for long software runs.
What is post-silicon validation?
Testing the real manufactured chip in the lab, across voltage, temperature and boards. Teams reuse earlier tests wherever they can, which is the goal of PSS.
How do you handle analog blocks in SoC verification?
Replace each analog macro with the designer’s digital reference model at SoC level, so regressions stay fast. The true analog behaviour is signed off at IP level.
What does coverage closure mean at SoC level?
Coverage merged across all C tests and UVM tests, with a written, designer-approved reason for every exclusion. Unreachable code goes on the exclusion list only after the designer confirms it.
References
- Why first-silicon success is getting harder for system companies, Siemens Verification Horizons, September 2025
- 2024 Siemens EDA and Wilson Research Group IC/ASIC functional verification trend report
- Accellera unveils Portable Test and Stimulus Standard 3.0, August 2024
- Connecting the Dots: application of formal verification for SoC connectivity, DVCon
- Verification Academy forum threads linked in the mistakes section
Read next
- UVM testbench architecture: the env this flow reuses at every level
- UVM TLM explained: analysis ports and multi-scoreboard hookup
- Key areas to consider during SoC verification
- Clock monitors in SoC verification
- UVM interview questions: active vs passive agents, config_db and more

Hi,
Do you want to write a small article on the following SoC blocks
Clocking and clock control
Resets and reset control
SoC level bump connectivity
Subsystem connectivity
JTAG/Debug access
Register access
Embedded memory access
Interrupts
Power management
Boot sequence
Datapath
Subsystem specific features
SoC level throughput, latency checks
Debug feature connectivity
Functional DFT and BSR connectivity
X-prop and Netlist simulations
Thanks in advance
Hi Subhash,
Definitely, I would love to share maximum knowledge on the above topics but I need your support and help with all the above topics.
Thank you