RTL Design / Module 1: Complete VLSI Flow
Lesson 1.1

What is a chip, really? Idea → packaged silicon

A chip is not “magic sand.” It is a carefully planned product that moves from an idea, through design and manufacturing, into a package that sits on a board. This lesson gives you the story of that journey so every later module has a home.

Plain English

VLSI (Very Large Scale Integration) means putting millions/billions of transistors on one die — and organizing teams + tools so that complexity stays manageable.

Idea→ Spec→ Arch→ RTL→ Verify→ DFT→ Synth→ PD→ Sign-off→ Silicon

The VLSI journey — this course lives mainly in the highlighted RTL stage, with awareness of everything around it.

1

From idea to thing you can hold

  1. Need — a product goal (“talk to sensors over I2C”, “decode video”, “run Linux”).
  2. Specification — written requirements: features, speed, power, interfaces, cost.
  3. Architecture — big blocks and how they talk (still mostly diagrams).
  4. RTL design — Verilog/SystemVerilog that describes the digital behavior.
  5. Verification — prove the RTL matches the intent (tests, bugs, coverage).
  6. DFT — hooks so factories can test manufactured chips.
  7. Synthesis — RTL becomes a gate-level netlist for a chosen technology.
  8. Physical design — place gates, route wires, meet timing on a real die.
  9. Sign-off & tape-out — final checks; then manufacturing.
  10. Package & board — die in a package, soldered onto a PCB, shipping to customers.
💡 Building analogy

Spec is the building code + customer brief. Architecture is the floor plan. RTL is the detailed construction drawings for the digital “rooms.” PD is pouring concrete and running plumbing. Tape-out is when the city permits construction.

RTL is just text that describes hardware. Here is a tiny taste — a 1-bit register. You will write many like this later.

tiny_reg.v
// A 1-bit register — the simplest "chip building block"
module tiny_reg (
  input  wire clk,
  input  wire rst_n,
  input  wire d,
  output reg  q
);
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
      q <= 1'b0;
    else
      q <= d;
  end
endmodule

▶ Try in Verilog Simulator

Another taste — a simple 2:1 mux. Hardware is parallel: both inputs exist at once; sel picks which path feeds the output.

mux2_taste.v
module mux2_taste (
  input  wire a,
  input  wire b,
  input  wire sel,
  output wire y
);
  assign y = sel ? b : a;  // combo logic — no clock needed
endmodule

Each stage: artifacts, owners, and what breaks if you skip it

Every box in the flow rail produces deliverables someone signs off on. Skipping a stage does not remove the work — it moves the pain later.

StageTypical artifactsWho owns itIf skipped / rushed
SpecRequirements doc, interface tables, acceptance testsSystems / product / architectRTL rewrites, scope fights, “works on my bench”
ArchitectureBlock diagram, clock map, register outlineArchitect + leadsSpaghetti interfaces, surprise CDC, PD nightmares
RTLVerilog/SV, lint-clean, unit TBRTL designer (you)Nothing to verify or synthesize
VerifyTest plan, coverage, bug databaseDV engineer + designerSilent silicon bugs, recall risk
DFTScan chains, ATPG patterns, BIST hooksDFT engineerLow yield, expensive manual test, scrap die
SynthesisGate netlist, area/timing reportsRTL + synthesis engineerNo physical starting point, wrong timing assumptions
PDPlaced/routed layout, CTS, congestion reportsPhysical designerTiming fails, unroutable design, hot spots
Sign-offSTA, DRC, LVS, power sign-off decksPD + STA + sign-off leadFoundry reject, dead chips, schedule slip
Package / boardBGA footprint, PCB layout, bring-up planPackage + HW engineerChip works in lab sim but not on customer board
🎤 Meeting angle

When someone says “can we skip verification and fix in silicon?” — translate that to schedule + money + reputation risk. A respin can cost millions and months; a week of directed tests rarely does.

Where time and money actually go

Beginners picture “writing Verilog” as most of the job. In practice on a modern SoC:

  • Verification often consumes 50–70% of engineering hours before tape-out.
  • NRE (non-recurring engineering) for ASIC — mask sets, EDA licenses, foundry setup — can be $1M–$50M+ before unit one ships.
  • RTL + integration is intense but usually not the majority of calendar time on large chips.
  • PD + sign-off iterations can dominate the last months of a program (“timing closure hell”).

Why this matters to you: writing clean, verifiable RTL early saves verification and PD time downstream — that is how junior engineers become trusted quickly.

VLSI vocabulary (Module 1 cheat sheet)

TermOne-line meaning
DieThe silicon chip before packaging
NetlistGate-level connectivity after synthesis
Tape-outRelease design to foundry for masks
NREOne-time cost before first unit ships
Yield% of manufactured die that pass test
ECOEngineering change order — late fix

Worked mini-example — tracing one bug backward

Symptom: I2C sensor read returns 0xFF on silicon but passes in sim.

  1. Verify: Was NACK path tested? (often no → spec gap)
  2. RTL: Open-drain SDA drive strength wrong?
  3. PD: Pad cell wrong voltage domain?
  4. Board: Missing external pull-up resistor?

Notice how the flow helps you ask structured questions instead of random guessing.

2

ASIC vs FPGA (same ideas, different finish)

🏭

ASIC

Custom silicon. Long NRE cost, best power/perf/cost at volume. Flow includes foundry tape-out.

🧩

FPGA

Reconfigurable fabric. Faster bring-up, great for learning and prototypes. Still needs good RTL + timing thinking.

DimensionASICFPGA
Unit cost at volumeLowest (cents–dollars)Higher (part cost + power)
Up-front costHigh NRE (masks, tools)Low (dev board + license)
Time to first working chipMonths–yearsDays–weeks
Clock speed / powerOptimized for productGood, rarely best-in-class
Change after “ship”ECO or respin ($$$)Re-bitstream (minutes)
DFT / manufacturing testScan, ATPG, ATE mandatoryFunctional test on board
Sign-off artifactsSTA, DRC, LVS, IR dropTiming report + bitstream
RTL you writeSame synthesizable style — clarity, reset, clocks
💼 Interview angle

“When would you choose FPGA vs ASIC?” — Good answer mentions volume, power budget, time-to-market, and change frequency. Prototype on FPGA; productize in ASIC when economics justify NRE.

This course teaches RTL that is honest for both worlds. Tool screenshots may differ; the engineering thinking does not.

From die to something on your desk

A “chip” is not one object — it is a stack of physical layers:

Die package board stack

RTL describes behavior on the die; PD and IO cells connect it to the outside world.

⚠ Trap

Simulating RTL without thinking about pads, package, and board is fine for learning — but production bugs often live at the boundary (wrong IO standard, missing pull-up, reset sequencing).

3

Where YOU will live

Most of this course sits in RTL design + verification habits, with enough Spec/Arch/DFT/PD awareness that you never feel lost in meetings.

  • You will write and simulate RTL in the online Verilog simulator
  • You will learn what happens after RTL (so your code is synthesis- and PD-friendly)
  • You will finish with an I2C design you can explain Spec → waves
  • You will speak the vocabulary of meetings: STA slack, scan, floorplan, acceptance test

Mini worked example — reading the flow for one sentence of product need:

Need: “Read a temperature sensor over I2C.” That one line becomes: I2C master spec → CSR map architecture → RTL FSM → directed TB → scan-friendly flops → synthesis constraints → IO placement near sensor pins → STA on pad paths.

🎯 What to remember

  • A chip is a long pipeline of roles — Spec, Arch, RTL, Verify, DFT, Synthesis, PD, Sign-off.
  • RTL is the digital blueprint; silicon is the built house.
  • ASIC and FPGA share RTL skills; manufacturing differs.
  • Next: how to write a specification that design can actually implement.
Advertisement