Address Map, Connectivity, and Interconnect Every block in an SoC talks to other blocks over wires and decode logic that someone has to verify. A block can be perfect on its own and the chip can still be broken, if the interconnect sends a transaction to the wrong place, drops a wire between two blocks, or lets a master reach somewhere it never should have. This chapter covers that plumbing: the address map, the physical connections between blocks, and the interconnect fabric that carries every transaction.

An SoC's system address map does two jobs. It gives every peripheral a range of addresses, and it defines which masters are allowed to reach which of those ranges.

A CPU core is expected to configure the peripherals it owns. A DMA engine is expected to move data between memory and the peripherals it's wired to serve. Neither one is expected to reach everything in the chip - the spec says who can talk to whom, and connectivity verification proves the silicon actually matches that spec.

10 min read | Intermediate Level

What You'll Learn

  • Why connectivity verification checks a spec-defined matrix of legal master-slave pairs, not every master against every slave
  • How to verify data survives a protocol bridge - like an AXI master reaching an APB slave - correctly, burst and all
  • How verification catches a bus that hangs because a slave never responds
  • How the interconnect gets a response back to the right master when several masters have transactions in flight
  • How security regions restrict which masters can reach which addresses, and how that gets verified

The Spec Defines Who Can Reach Whom

Not every master needs to reach every slave. A display controller has no business writing to a UART's control register. A DMA channel dedicated to audio has no business touching the crypto block.

The SoC spec lays out a connectivity matrix - which masters can reach which address ranges - and that matrix is usually much smaller than "everyone can reach everything." Verification's job is to prove every entry in that matrix actually works, and just as importantly, that nothing outside it does.

Each master may reach only the slaves its connectivity matrix allows; a protection block in front of the secure range checks the master ID, and an unmapped address gets an error response

Proving Every Legal Path Actually Works

For each legal pair in the matrix, verification needs at least one real transaction that goes all the way from that master to that slave and back with a correct response - not just a decode check, an actual read or write that exercises the whole path.

A CPU writing a peripheral's control register and reading it back proves that path. A DMA channel moving a block of data from memory to a FIFO and back proves that one. Missing a pair in this sweep means that connection is unverified, even if every other pair works.


class master_slave_access_seq extends uvm_sequence #(axi_bus_item);
  `uvm_object_utils(master_slave_access_seq)

  typedef struct {
    string     master_name;
    bit [31:0] addr;
    bit        allowed;
  } access_case_t;

  access_case_t cases[] = '{
    '{master_name: "cpu0", addr: 32'h4000_1000, allowed: 1},   // cpu configures uart0
    '{master_name: "dma0", addr: 32'h4000_1000, allowed: 0},   // dma must not reach uart config space
    '{master_name: "dma0", addr: 32'h2000_0000, allowed: 1}    // dma moves data to memory
  };

  task body();
    foreach (cases[i]) check_access(cases[i]);
  endtask

  task check_access(access_case_t c);
    axi_bus_item req, rsp;
    req = axi_bus_item::type_id::create("req");
    start_item(req);
    req.master = c.master_name;
    req.addr   = c.addr;
    req.cmd    = AXI_WRITE;
    finish_item(req);
    get_response(rsp);
    if (c.allowed && rsp.resp !== AXI_OKAY)
      `uvm_error("ACCESS", $sformatf("%s should reach 0x%0h but got %s", c.master_name, c.addr, rsp.resp.name()))
    if (!c.allowed && rsp.resp === AXI_OKAY)
      `uvm_error("ACCESS", $sformatf("%s should NOT reach 0x%0h but the access succeeded", c.master_name, c.addr))
  endtask
endclass

The same sequence covers two jobs at once: proving legal paths work, and proving illegal ones are actually blocked - both come straight from the same matrix in the spec.

Data Integrity Across a Protocol Bridge

A transaction rarely stays on one protocol the whole way. A CPU on an AXI bus reaching a simple peripheral often crosses a bridge onto APB, and that bridge doesn't just forward bytes - it does real work.

AXI supports bursts and wide data; APB is narrower and has no burst at all, so the bridge has to split one AXI burst into several individual APB transfers, and split each wide AXI beat into narrower APB-sized pieces when the widths don't match. Any of that splitting can go wrong: a byte can land at the wrong offset, a strobe can get misaligned so the wrong bytes get written, or a burst can come back out of order on a read.

Verifying the bridge means checking the data on both sides, not just that a response came back OKAY. Write a distinct, recognizable pattern in a burst, read it back through the bridge, and compare byte-for-byte, including at the odd address offsets and partial-width cases that are the whole reason the bridge exists.

Preventing the Bus From Hanging

If a master issues a request and the slave never responds, most bus protocols have no built-in way to declare that a failure - the master will simply wait forever, and so will the simulation. This can happen with a real RTL bug, or with a testbench transaction sent to an address that has no slave configured behind it at all.

A watchdog timer in the testbench, started the moment a request goes out and cleared the moment a response comes back, catches this directly: if the timer expires, the test fails immediately with the address and master that caused it, instead of the whole regression silently hanging until someone notices.

Getting Responses Back to the Right Master

With several masters issuing transactions at once, the interconnect has to route each slave's response back to whichever master sent that specific request - and it has to get this right even when two different masters happen to use the same transaction ID for requests that are in flight at the same time.

AXI interconnects handle this by widening the ID field as a transaction passes through: the interconnect appends bits that identify which master the request came from, so the ID that reaches the slave (and comes back on the response) is unique across all masters even if it wasn't unique on its own.

Verifying this means having more than one master with outstanding transactions to the same slave at the same time, using overlapping IDs on purpose, and confirming each response finds its way back to the master that actually issued it - not just to some master.

Security Regions: Not Every Master Is Trusted Equally

Some address ranges need to be off-limits to some masters even though the address decode itself would happily route there - a secure boot ROM, a key-storage block, or a debug port that shouldn't be reachable from a peripheral's DMA channel. This is usually enforced by a dedicated protection block sitting in front of the range, checking each transaction's master ID (and sometimes a secure/non-secure attribute the master carries) before letting it through.

Arm's TrustZone architecture, for instance, uses a Security Attribution Unit to classify each address range as Secure, Non-secure, or Non-secure Callable, and blocks a non-secure master from ever completing an access to a Secure range.

Verifying this means deliberately sending a transaction from a disallowed master to a protected range and confirming it's blocked - with a clean, deterministic error response, not a hang and not a silent success - while the same range still works correctly for the masters that are supposed to reach it. Both halves matter: a protection block that blocks everyone, including the masters that are supposed to get through, is just as broken as one that blocks nobody.

Common Mistakes

Mistake: Testing every master against every slave instead of the pairs the spec actually defines.

Most master-slave pairs are illegal by design. Sweeping all of them wastes effort on combinations nobody expects to work, and can hide the fact that a genuinely illegal path was never actually confirmed to be blocked.

Mistake: Checking only the response code from a protocol bridge, not the data itself.

A bridge can return OKAY on every transfer while still delivering the wrong bytes because of a strobe or splitting bug. Only a byte-for-byte comparison across a real burst catches that.

Mistake: Testing security regions with only disallowed masters, never confirming the allowed ones still work.

A protection block that's stuck closed looks identical to a correctly working one if the test only ever checks that access is blocked. Both directions need a real transaction.

Summary

In this article, you learned:

  • The SoC spec defines a connectivity matrix of legal master-slave pairs, and verification proves every legal pair works and every illegal pair is blocked
  • A protocol bridge like AXI-to-APB splits bursts and re-aligns data, so verifying it means comparing actual bytes across a burst, not just checking the response code
  • A watchdog timer catches a bus that hangs because a slave never responds, failing the test immediately instead of letting the simulation stall
  • An interconnect widens transaction IDs so it can route each response back to the master that issued it, even when two masters use the same ID at the same time
  • Security regions block some masters from some addresses by design, and verifying them means confirming both that disallowed masters are blocked and that allowed masters still get through
Did you find what you were looking for?

Quiz

Test Your Knowledge

1 of 5 Score: 0 / 5