On NanoSoC bring-up day the DMA interrupt never fires, although the DMA status register reads DONE equals 1 and the interrupt pin at the block is high. The block owner proves the DMA is correct: its irq output is indeed high, exactly as its register map promises. The software team proves the driver is correct: it enabled the right bit. Both are right and the chip is still broken, because the wire between them lands on controller input 6, a spare, instead of input 1. Nobody's block is wrong; the integration is wrong. That gap, everything true of each part but false of the whole, is the integrator's territory.
Six parties touch the chip and each owns a different truth. The architect owns the structure: partitions, the address map skeleton, clock and power domains, and the budgets each block must meet. The block owner owns one block's behaviour against its specification, with collateral to prove it. Verification owns the proof that the assembled chip does what the specification says, at block, subsystem and chip level. Physical design owns turning the netlist into geometry that closes timing and power. Software owns the drivers and images built against the hardware-software contract. The integrator owns what falls between them: the top-level wiring, the map, the decode, the crossing inventory, the reset and power sequences, the version of every shared table, and the proof that every handoff into the chip is complete.
Five duties make that concrete. First, own the shared tables: the address map, the interrupt map, the clock and reset lists, the power-state table, the pin map. Second, own the top-level structure: the interconnect configuration, the bridges, the decoders, the default slaves, the tie-offs. Third, own handoff acceptance: no block enters the chip without its collateral, checked, versioned and stamped. Fourth, own the sequences: reset release order, power-up and power-down order, clock enable order, boot order. Fifth, own the change: when any table moves, every consumer is regenerated and rechecked before the change lands.
Symptom on NanoSoC | Block view | Integration view (the integrator's fix) |
|---|---|---|
DMA irq high, controller RAW bit 1 is 0, bit 6 is 1 | DMA correct; controller correct | Wire moved to input 1; connectivity test per source |
Write to SBR CTRL corrupts the next DMA word | Both blocks correct alone | Slot decode overlap; one source map generating the decoder |
Second DMA job uses the stale KEY with no error | DMA behaves as specified | Driver rule and contract review: LEN and KEY need BUSY equals 0 first |
Chip wakes immediately after entering SLEEP | Power controller correct alone | Two missing isolation clamps on interrupt lines; UPF crossing check |
SBR read of secure SRAM errors on the first beat | Memory and bridge correct alone | Master security attribute left at reset default; per-master attribute table |
The table above is worth reading twice, because it is the whole course in miniature: each row names a real NanoSoC failure from the ten planted bugs of the course, shows both sides passing their own checks, and gives the integration-level fix. The integrator's skill is recognising the third column from the first, routing it to the right owner, and installing the check that catches the class next time.
Every shared table names one owner and one version; no table has two editors.
Every symptom has a routing: the triage table for the area exists before the bug arrives.
Block-level passing is never accepted as chip-level proof; the integration checks have their own sign-off line.
When a symptom arrives, reproduce it at the top level first, then split the difference: force the source and observe the sink, as the third lesson does with the interrupt table. If the source is right and the sink is right, the defect is in the contract between them, which belongs to the integrator. Resist the reflex to open the block RTL; the fastest evidence is usually a connectivity or table check, not a waveform inside a block that already passes its own tests.
Both, split by phase: the architect sets the skeleton and the budgets, the integrator owns the versioned table, generates every consumer from it, and says no to moves once software depends on it.