Complete ASIC Design Flow: VLSI From Idea to Silicon

Explore the fundamentals of VLSI design and the complete digital IC design flow from concept to silicon, highlighting core concepts, design considerations, and workflows.

Explore Verilog, a hardware description language used to describe digital circuits and verify functionality via simulation, not a programming language, across behavioral, RTL, and gate-level abstractions.

Explore Verilog module design from port declarations to always blocks and sensitivity lists, contrasting blocking and non-blocking assignments for combinational and sequential logic.

In lab 1.0, implement a digital circuit in verilog with three gates and three flip-flops clocked by a positive edge, using modelsim to compile.

Master blocking and non-blocking assignments in Verilog to model combinational versus sequential logic, ensuring accurate flip-flop behavior and preventing simulation mismatches with clear golden rules.

Learn how Verilog if-else statements implement decisions in hardware and synthesize into multiplexers with priority logic. Discover when to use always blocks, the final else, and case as an alternative.

Explore continuous assignment in Verilog, using the assign statement to describe simple combinational logic, watch the left-hand side update immediately with right-hand side changes, and compare to always blocks.

Design a four-bit counter in Verilog that loads from in on a clock when latch is high and decrements when dec is high, with a zero flag at zero.

Explore how Verilog numbers are written with size, signed or unsigned, base, and value; understand two's complement, truncation, and sign extension to ensure correct arithmetic.

Master Verilog simulation control in test benches, covering time scale, clock generation, and initial block. Use dump files, finish and stop, and display and monitor with format specifiers for debugging.

Explore the complete digital IC design flow from concept to silicon by building a counter RTL and its testbench in Lab 3.0.

Continue the ic design lab by running a simulation with the testbench, compiling all files, and observing waveforms to verify the latch and decrement behavior of a four-bit down counter.

Explore Verilog case statements and behavioral modeling to implement encoders and decoders, understand synthesis into multiplexers, and compare case with if-else in always blocks.

Explore Verilog operators, including bitwise, conditional, arithmetic, and logical types, and learn how they synthesize to hardware, handle vector widths, and how to use reduction operators.

Explore Verilog operators, including shift, equality/relational, and miscellaneous operators like concatenation and replication, to manipulate data, compare values, and design efficient digital circuits.

lab 3.1 demonstrates a simple combinational circuit with two-pit and three-pit signals, using or, shifts, concatenation, and duplication to yield a four-bit result in verilog.

Identify and avoid simulation races in Verilog and SystemVerilog by understanding read-write and write-to-write races, using non-blocking assignments for sequential logic and proper sensitivity lists.

Explore structural Verilog by building hierarchical designs through module instantiation and wiring with internal wires; compare named vs positional port mappings and illustrate with a 4-bit adder.

Build a top module that connects a register file, encoder, and serializer to serialize 8-bit data via internal wires, clock, reset, and write enable and read enable ports.

Model memories with multidimensional arrays in Verilog and configure reusable modules using parameters, localparam, and macros, while noting width-first, depth-second and port-passing limits.

Learn to convert a RAM module to use Verilog parameters for address width, memory depth, and memory width, replacing fixed ports with parameterized expressions and verifying successful compilation.

Discover how Verilog functions enable reusable combinational logic, reducing repetition and improving readability. Follow syntax, rules, and synthesis guidance to write clean, maintainable hardware designs.

Learn how Veriloop for loops enable memory initialization and replicated logic, then identify and fix combinational loops by inserting registers to stabilize and reliably pipelined designs.

Explains designing a locker using a Moore finite state machine with gray state encoding, including next-state logic, output logic, and a test bench.

Explore inter-assignment delay and intra-assignment delay through two practical examples, analyzing initial blocks, delays, and binary-to-decimal conversions to determine a, b, and c.

Explore TCL scripting fundamentals, including the set command and variables, and compare scripting with programming to learn how TCL enables automation in EDA tools across platforms.

create a lab0.tcl script using notepad++ and the tcl shell, employing set, variable substitution, expression substitution, curly braces, and backslash to display and compute values.

Lab1.1 guides creating a tcl script lab1.tcl to perform arithmetic operations on integers and floating values, including addition, subtraction, multiplication, division, and remainder, using a=35 and b=80 and displaying results.

Explore Tcl flow control and lists to build flexible scripts. Learn conditional statements like if/else/else if, loops, and loop control, plus Tcl lists with lappend, lindex, and lrange.

Master Tcl list manipulation and loops to automate tasks in digital design workflows. Use lappend, lsearch, join, concat, and arrays with while, for, foreach, break, and continue.

Advance through lab 2.0 to apply the complete digital IC design flow, from concept to silicon, and build practical skills in modern IC design.

Learn to create and use arrays in Tcl for lab 2.1, define Mohammed, Ahmed, and Mustafa arrays, and compute and display their GBA averages with a custom average procedure.

Master file handling in tickle with open modes, read, write, append, and close operations, and use reg sub for powerful pattern-based substitutions using regular expressions.

Lab 2.2 teaches using tcl to perform file I/O and word substitution with regsub for rtl interfaces, adding i_ and o_ prefixes, producing a tb.txt test bench.

Explore latches and flip-flops as memory elements, including the D-latch and master-slave D flip-flop. Learn how level-sensitive and edge-triggered designs enable reliable timing in STA.

Explore the path of a signal through combinational and sequential timing arcs, mastering propagation delay, transition time, setup and hold times, clock-to-queue time, and sta for reliable digital design.

Perform the setup time check to ensure data arrives before the next clock edge. Explore register-to-register, input-to-register, and register-to-output paths with tcq, tlogic delay, tsu, slack, and clock uncertainty.

Solving setup timing analysis in a two-flip-flop circuit, this lab shows calculating data arrival vs required times, using t_setup, tcq, and propagation delays to determine slack and identify setup violations.

Explore hold time analysis in lab with two flip-flop examples, calculating data arrival time (tcq + propagation delay), hold time (t hold) and slack under clock skew, and hold violations.

Master timing closure in static timing analysis by diagnosing setup and hold violations and applying targeted fixes, including logic optimization, retiming, technology mapping, clock skew, and pipelining.

Explore power-aware design in VLSI as we identify four power monsters—switching, leakage, glitch, and short-circuit powers—distinguishing dynamic vs static power and introducing the total power equation.

Explore glitch power, the unnecessary work in CMOS circuits caused by differing signal arrival times, and learn how balanced paths, pipeline registers, and gate sizing reduce dynamic power.

Explain short-circuit power in CMOS during transitions when NMOS and PMOS briefly conduct, forming a direct path from Vdd to ground. Use fast edges and proper sizing to reduce it.

Explore leakage power as a battery-draining phenomenon in shrinking transistors, nano-scale chips, accounting for up to 50% of total power, arising from sub-threshold leakage, gate oxide tunneling, and junction leakage.

Explore a latch-based clock gating design in Verilog HDL, implementing a gated clock controlled by a clock enable, simulated in ModelSim to reduce dynamic power.

Operand isolation uses per-bit registers to gate inputs into a large adder, preventing glitches and saving power, at the cost of one clock-cycle latency and extra silicon area.

Explore multi-voltage domains that cut dynamic and static power by using high voltage for timing-critical blocks and low voltage for others, bridged by level shifters.

Explore dynamic and leakage power in digital ic design, and learn how clock gating, frequency scaling, voltage scaling, and reducing gate capacitance cut switching power.

Apply multi-threshold voltage design to balance speed, leakage, and short circuit power by using high VT cells everywhere and selectively replacing critical-path cells with low VT devices.

Explore power gating as the nuclear option for leakage reduction, using PEN-controlled PMOS switches, retention flops, and isolation cells to safely shut down idle blocks.

Learn how logic synthesis translates RTL HDL designs into technology-specific gate-level netlists using libraries, constraints, and timing analyses to optimize for speed, area, and power.

Explore how PVT variations impact standard cell delays, and how worst, best, and typical corners guide synthesis and timing analysis to ensure manufacturable silicon.

Learn to synthesize a Verilog up-down counter using the design compiler shell with a TCL script, generating a technology-dependent gate-level netlist from standard cell libraries.

Map and optimize RTL to a gate-level netlist through compile, using strategy options, while performing timing analysis; produce gate-level Verilog, SDF, and SDC for the next flow.

Explore lab 2.1 of the complete digital ic design flow, using dc shell and tcl to synthesize rtl to verilog netlists, then compare compile versus compile ultra and register removal.

Learn how dynamic timing analysis uses input vectors to validate timing and functionality, then apply static timing analysis to exhaustively verify all paths under worst-case conditions with constraints.

Explore how design optimization constraints shape the digital ic design flow from concept to silicon.

Learn how timing exceptions extend or ignore timing analyses, covering false paths for clock domain crossing and multi-cycle paths that exceed a single clock, with commands for setup and hold.

Declare clock groupings to manage synchronous and asynchronous clocks, and use set clock groups and set case analysis to optimize timing in functional and test modes.

Learn to read area, power, and timing reports from synthesis, including area breakdown, interconnect estimates, power components, and setup/hold slack to validate silicon readiness.

Explore lab 3.0 within the complete digital ic design flow, tracing the path from concept to silicon.

Master clock domain crossing fundamentals, distinguishing asynchronous and synchronous clocks, and apply six CDC techniques: multi-flop, gray code synchronization, synchronized enable, synchronized multiplexing, FIFO synchronization, and ready acknowledge hand shaking.

Learn how the two-flip-flop synchronizer across clock domains stabilizes metastable inputs, detailing containment flip-flop F2 and isolation flip-flop F3, MTBF tradeoffs, and when to use three flops.

Explore why per-bit synchronization fails for multi-bit data passes across clock domains, causing data incoherence from routing delays and metastability, and learn coherent crossing techniques like gray coding and handshaking.

Learn four proven bus synchronization techniques for safe clock-domain crossing: gray coding, enable-based synchronization, synchronized multiplexer select, and ready-acknowledge handshake, with guidance on suitable data patterns.

Discover how asynchronous FIFO prevents data loss in clock domain crossings by buffering data between fast and slow clocks, with two-port memory, pointers, and empty and full flags.

Design and verify a parameterized pit synchronizer in Verilog to cross clock domains safely, mitigating metastability with a multi-flop scheme, and validate that latency matches the flip-flop stages.

Explore the five essential components of an asynchronous fifo, including a dual-port memory, write and read pointers, full and empty flags, and cross-domain synchronization using gray codes.

Explore designing an asynchronous fifo with two pointers and a memory buffer, using an extra wraparound bit and gray-code pointers to reliably detect full and empty across clock domains.

Learn how gray codes enable safe synchronization of multi-bit pointers across clock domains in an asynchronous FIFO, ensuring correct full and empty logic and preventing data incoherence.

Compute the fifo depth across three lab examples using write and read clocks, idle cycles, and transfer timing. Derive the minimum depth from write/read periods and data counts.

Learn how a two-flip-flop reset synchronizer converts asynchronous reset assertion into synchronous de-assertion, preventing metastability and ensuring clean wake-up across clock domains.

Explore controllability and observability in digital ic design, explain the control-observation trade-off, and introduce scan chains that turn flip-flops into internal test access points.

Explore how scan chains solve the controllability and observability problem by converting flip-flops to scan flip-flops with a scan input and scan enable, enabling test mode and observation of nodes.

Walk through the complete dft flow from rtl preparation to scan insertion, including test-ready compilation and dft constraints. See how to define scan architecture and prepare the design for handoff.

Engage in a hands-on lab on design-for-test (dft) within the complete digital ic design flow from concept to silicon.

Explore formal verification, proving functional equivalence between reference and implementation designs, using design equivalence checking with Snoops formality to verify RTL and gate-level netlists.

Explore formal verification components, including logic cones and compare points, and learn how design equivalence checking matches and verifies RTL against the gate-level netlist to ensure functional equivalence.

Navigate the complete end-to-end formality flow using scripts or the graphical user interface, loading guidance and svf, then verify design equivalence and generate reports for debugging.

Use formal verification to compare the post-synthesis netlist with RTL Verilog via the formality GUI, generating an SVF file and running match then verify to confirm success.

Apply formal verification to trace failures from rtl through synthesis, identifying whether issues originate in rtl, the synthesis tool, or its optimizations, illustrated by a UART transmitter case.