Lecture Outline

1 © Adam Teman, 2018

 Digital VLSI Design

Lecture 2: Verilog HDL

Semester A, 2018-19
Lecturer: Dr. Adam Teman

Disclaimer: This course was prepared, in its entirety, by Adam Teman. Many materials were copied from sources freely available on the internet. When possible, these sources have been cited;
however, some references may have been cited incorrectly or overlooked. If you feel that a picture, graph, or code example has been copied from you and either needs to be cited or removed,
please feel free to email adam.teman@biu.ac.il and I will address this as soon as possible.
 What is a hardware description language?
• HDL is NOT another programming language:
• Textual representation of Hardware constructs
• All statements are executed in parallel
• Code ordering is flexible.
Example:
• a=1;b=2;c=a+b → c==3
• c=a+b;a=1;b=2 → c==3
• Execution of code is triggered by Events
• Sensitivity lists are used to define when a code section is executed
• Different simulators may yield different results
• => Coding style is required

3 © Adam Teman, 2018

 Abstraction levels
• Three coding styles:
• Structural code (GTL (Gate Level), Netlist)
• RTL (Register Transfer Level)
• Behavioral (Testbench)

• DUT (Device Under Test)

• Represents Hardware
• Usually RTL or GTL
• Testbench
• Represents System
• Usually Behavioral
• Using higher order languages (“e”/SystemVerilog)

4 © Adam Teman, 2018

 1 2 3 4 5
Introduction Verilog Simple FSM Coding Style
Syntax Examples Implementation for RTL

Verilog Syntax
 Basic Constructs
• Primitives:
• not, and, or, etc.
or(out, in1, in2);

• Signals:
• 4 states: 0,1,X,Z
• Wires: do not keep states
• Registers: keep states (i.e., outputs)
• Can represent buses or group of signals
wire in1,in2;
reg out;
wire [7:0] data;
reg [31:0] mem [0:7]; //width (bits)=32, depth (words)=8
6 © Adam Teman, 2018
 Basic Constructs
• Operators:
• Similar to primitives
• &, |, ~, &&, ||, etc. out = in1 | in2;

• Constants:
• The format is: W’Bval
• Examples:
• 1’b0 – single bit binary 0 (or decimal 0)
• 4’b0011 - 4 bit binary 0011 (or decimal 3)
• 8’hff = 8 bit hexadecimal ff (or decimal 255)
• 8’d255= 8 bit decimal 255

7 © Adam Teman, 2018

 Procedural Blocks
• Initial block
• Will be executed only once, at first time initial begin
a = 1’b0;
the unit is called (Only in testbench) b = 1’b0;
end
• Always block
• Statements will be evaluated when always @(posedge clock)
a change in sensitivity list occurs if (!nreset)
q <= 1’b0;
• Example1 - sync reset, else
rising edge triggered flop: q <= d;

• Example 2 - async reset, always @(posedge clock or negedge nreset)

rising edge triggered, if (!nreset)
load enable flop: q <= 1’b0;
else if (load_enable)
q <= d;
8 © Adam Teman, 2018
 Procedural Blocks
• There are two types of always blocks always @(posedge clock or negedge nreset)
if (!nreset)
• Sequential q <= 1’b0;
• Asserted by a clock in the sensitivity list. else if (load_enable)
q <= d;
• Translates into flip-flops/latches.
• Combinational
always @(a or b or c)
• Describes purely combinational logic, out = a & b & c;
and therefore, the sensitivity list
has (non-clock) signals.
• The Verilog 2001 standard always @(*)
allows using * instead of a out = a & b & c;
sensitivity list to reduce bugs.

9 © Adam Teman, 2018

 Assignments
Verilog has three types of assignments: assign muxout = (sel&in1) | (~sel&in0);
• Continuous assignment assign muxout = sel ? in1 : in0;

• Outside of always blocks

// assume initially a=1;
• Blocking procedural assignment “= ” a = 2;
• RHS is executed and assignment is completed b = a;
before the next statement is executed. // a=2; b=2;

• Non-blocking procedural assignment “<= ” // assume initially a=1;

• RHS is executed and assignment takes place a <= 2;
at the end of the current time step (not clock cycle) b <= a;
• To eliminate mistakes, follow these rules: // a=2; b=1;

• Combinational always block: Use blocking assignments (=)

• Sequential always block: Use non-blocking assignments (<=)
• Do not mix blocking and non-blocking in the same always block
• Do not assign to the same variable from more than one always block
10 © Adam Teman, 2018
 Hierarchy
• Modules • Instances
• Used to define a hardware block • Referencing a block at a different
module mux4 (out, in, sel); level
input [3:0] in;
input [1:0] sel; Module mux4 M0 (.out(outa),.in(a),.sel(sel));
output out; Header mux4 M1 (.out(outb),.in(b),.sel(sel));
reg out;

always @*
case (sel)
2’b00: out = in[0];
2’b01: out = in[1]; Module
2’b10: out = in[2]; Body
2’b11: out = i1[3];
default: out = 1’bx;
endcase
endmodule
11 © Adam Teman, 2018
 System Tasks
• System tasks are used to provide interface to simulation data
• Identified by a $name syntax
• Printing tasks:
• $display, $strobe: Print once the statement is executed
• $monitor: Print every time there is a change in one of the parameters
• All take the “c” style printf format

$display(“At %t Value of out is %b\n”,$time,out);

12 © Adam Teman, 2018

 1 2 3 4 5
Introduction Verilog Simple FSM Coding Style
Syntax Examples Implementation for RTL

Simple Examples
 Hello World
• Your first Verilog module:

module main;
initial
begin
$display(“Hello world!”);
$finish;
end
endmodule

14 © Adam Teman, 2018

 Combinatorial Logic
• Three ways to make a Mux
• Using an assign Statement: • Using a case statement:
wire out; reg out;
assign out = sel ? a : b; always @ (a or b or sel)
begin
case (sel)
• Using an always Block: 1’b0: out=b;
1’b1: out=a;
reg out; endcase
always @ (a or b or sel) end
if (sel)
out=a;
else
out=b;

15 © Adam Teman, 2018

 Sequential Logic
• A simple D-Flip Flop: • Be careful not to infer latches!!!:
reg q; reg q;
always @(posedge clk) always @(en)
q<= d; if (en)
q<= d;

• An asynch reset D-Flip Flop:

reg q;
always @(posedge clk or negedge reset_)
if (~reset_)
q<= 0;
else
q<= d;

16 © Adam Teman, 2018

 Arithmetic
• Verilog supports standard arithmetic operators:
• +, -, *, << (shift left), >> (shift right), etc.
• Be careful about division… (not synthesizable!)
assign a = 4’b1100;
• Concatenate signals with the {,} operator
assign b = 4’b1010;
• But… assign c = {a,b}; //c=8’b11001010

• By default, Verilog treats all vectors as unsigned binary numbers.

• To do signed (two’s complement) operations, wire signed [9:0] a,b;
declare the reg/wire as signed: wire signed [19:0] result = a*b;

• To make a constant signed, add an s: 10’sh37C

17 © Adam Teman, 2018

 reg vs. wire
• Oh no… Don’t go there!
• A reg is not necessarily an actual register, but rather a “driving signal”… (huh?)
• This is truly the most ridiculous thing in Verilog…
• But, the compiler will complain, so here is what you have to remember:

1. Inside always blocks (both sequential and combinational) only reg can be used as LHS.
2. For an assign statement, only wire can be used as LHS.
3. Inside an initial block (Testbench) only reg can be used on the LHS.
4. The output of an instantiated module can only connect to a wire.
5. Inputs of a module cannot be a reg.

reg r; reg r; module m1 (out) module m2 (in)

always @* initial output out; input in;
r = a & b; begin endmodule reg in;
r = 1’b0; endmodule
wire w; #1 reg r;
assign w = a & b; r = 1’b1; m1 m1_instance(.out(r));
end
18 © Adam Teman, 2018
 Testbench constructs
• Create a clock:
`define CLK_PERIOD 10

initial
begin //begins executing at time 0
clk = 0;
end

always //begins executing at time 0 and never stops

#(CLK_PERIOD/2) clk = ~clk;

19 © Adam Teman, 2018

 1 2 3 4 5
Introduction Verilog Simple FSM Coding Style
Syntax Examples Implementation for RTL

Verilog FSM Implementation

A simple 4-bit counter example

20
 FSM Example
• A 4-bit counter module sm
#(parameter COUNTER_WIDTH = 4)
• Receives 4 inputs: (clk,rst_n,act,up_dwn_n,count,ovflw);
• clk – the system clock input clk;
• rst_n – an active low reset input rst_n;
• act – the activate signal input act;
• up_dwn_n – count up (positive) input up_dwn_n;
or count down (negative) output [COUNTER_WIDTH-1:0] count;
reg [COUNTER_WIDTH-1:0] count;
• Outputs 2 signals: output ovflw;
• count: the current counted value reg ovflw;
• ovflw: an overflow signal reg [3:0] state, next_state;

21 © Adam Teman, 2018

 FSM Example act==1
up_dwn_n==1

• Draw the state machine: act==1

up_dwn_n==1
reset Count
Up
act==0 count++
act==1 act==1
IDLE up_dwn_n==1 up_dwn_n==0
act==0 Overflow
act==0 ovflw=1
Count
act==1
up_dwn_n==0 Down
count--

• Define (Enumerate) names for each state: act==1

up_dwn_n==0
localparam IDLE = 4'b0001;
localparam CNTUP = 4'b0010;
localparam CNTDN = 4'b0100;
localparam OVFLW = 4'b1000;
22 © Adam Teman, 2018
 FSM Example
• Combinational block
• Compute the next state:
always @* CNTUP: begin
case (state) if (act)
IDLE: begin if (up_dwn_n)
if (act) if (count==(1<<COUNTER_WIDTH)-1)
if (up_dwn_n) next_state = OVFLW;
next_state = CNTUP; else
else next_state = CNTUP;
next_state = CNTDN; else
else if (count==’b0)
next_state = IDLE; next_state=OVFLW;
end else
next_state=CNTDN;
else
next_state=IDLE;
end
23 © Adam Teman, 2018
 FSM Example
• Combinational block
• compute the next state:
CNTDN: begin
if (act)
if (up_dwn_n)
if (count==(1<<COUNTER_WIDTH)-1)
next_state = OVFLW;
else OVFLW: begin
next_state = CNTUP; next_state=OVFLW;
else end
if (count== ’b0)
next_state=OVFLW; default: begin
else next_state = ’bx;
next_state=CNTDN; $display(“%t: State machine not
else initialized\n”,$time);
next_state=IDLE; end
end endcase
24 © Adam Teman, 2018
 FSM Example
• Sequential block
• Define the state registers:
always @(posedge clk or negedge rst_n)
if (!rst_n)
state <= IDLE;
else
state <= next_state;

• Define the counter registers:

always @(posedge clk or negedge rst_n)
• Finally assign the output (Moore):
if (!rst_n) assign ovflw = (state==OVFLW) ? 1'b1 : 1'b0;
count <= ’b0;
else endmodule
if (state==CNTUP)
count <= count+1'b1;
else if (state==CNTDN)
count <= count-1'b1;
25 © Adam Teman, 2018
 Testbench Example
• Definition of signals and parameters
module sm_tb;
parameter WIDTH = 5;
reg clk;
reg rst_n;
reg act;
reg up_dwn_n;
wire [WIDTH-1:0] count;
wire ovflw;

• Instantiate the state machine:

sm #(WIDTH) DUT (.clk(clk),.rst_n(rst_n),
.act(act),.up_dwn_n(up_dwn_n),
.count( count),.ovflw(ovflw));

26 © Adam Teman, 2018

 Testbench Example • Define a clock:
always
• Set initial values, value monitoring #5 clk = ~clk;
and reset sequence: • Set stimuli:
initial begin initial begin
clk = 1'b1; // @100, Start counting up
rst_n = 1'b0; // Activate reset // until overflow
act = 1'b0; #100 act = 1'b1;
up_dwn_n = 1'b1; up_dwn_n = 1'b1;
// Reset (10 cycles pulse)
// Monitor changes #1000 rst_n = 1'b0;
$monitor("%t: rst_n=%b act=%b up_dwn_n=%b count=%d act = 1'b0;
ovflw=%b\n",$time,rst_n,act,up_dwn_n,count,ovflw); #100 rst_n = 1'b1;
// After 100 time steps, release reset // Do a count-up to 4 and
#100 rst_n = 1'b1; // then count-down to ovflw
end #100 act = 1'b1;
up_dwn_n = 1'b1;
#40 up_dwn_n = 1'b0;
end
endmodule

27 © Adam Teman, 2018

The Chip Hall of Fame
• We started with the 4004, but Intel’s real success came with

wikipedia

The IBM PC

• The chip that established the x86 architecture,

by being chosen to power the IBM PC.
• Release date: July 1979
• Transistor Count: 29,000 Process: 3 um CMOS
• Frequency: 10 MHz 16-bit x86 architecture
• A “castrated” version of the 8086, since it had an 8-bit external
bus, instead of 16-bits.
• And guess what… it was designed in Haifa!
2018 Inductee to the IEEE Chip Hall of Fame Intel
The Chip Hall of Fame
• Actually, being designed in Haifa,
I know something about this chip
that Gordon Moore may not have
known…
• Let’s zoom in on the top right corner.
• Is that Hebrew?

Mr. Rafi Retter

Designer of the Intel 8080

2018 Inductee to the IEEE Chip Hall of Fame

 1 2 3 4 5
Introduction Verilog Simple FSM Coding Style
Syntax Examples Implementation for RTL

Coding Style for RTL – Part 1

HDL is NOT another programming language!
• Well, at least it shouldn’t be…
• Verilog is a relatively “rich” programming language, with commands
and constructs that let you do many things.
• In fact, it was originally designed exclusively as a verification language.
• However, when designing hardware,
you cannot actually do whatever you want!
• Therefore, it is important to follow some simple (but strict!) rules
and adhere to a coding style.
• In the following slides:
• I will introduce you to a few guidelines and rules.
• But, we will revisit this later, after you have some hands-on experience.

© Adam Teman, 2018

 Organizing your code
• Each module should be in a separate file
• Name the file <modulename>.v
• Always connect modules by name (the .dot() form).
• Write each input/output on a separate line
• Comment what each signal is used for.
• Separate sequential and combinational logic
module fsm(...)
input ... ; fsm.v
...
always@(posedge clk or negedge rst_)
... // sequential code
always@*
... // combinational code
assign ... // simple combinational logic
endmodule
32 © Adam Teman, 2018
 Assignment
Just to make sure you got the rules I mentioned before…
• In a combinational (always@*) block:
• Always use blocking (=) assignment.
• Recommended to use (*) in your sensitivity list.
• Always use full case statements. Use default to propagate X.
• In a sequential (always@posedge) block:
• Always use non-blocking (<=) assignment.
• Prefer each flip-flop in a separate always block.
• Prefer to data enable all sampling.
• Never assign a signal (LHS) from more than one always block.
33 © Adam Teman, 2018
 Be careful not to infer latches
• A very bad mistake made by rookie HDL designers
is to describe latches by mistake.
• If an output is not explicitly assigned by every signal in the sensitivity list, a
latch will be inferred to save the previous
state of the signal.
module mux4to1 (out, a, b, c, d, sel);
output out;
input a, b, c, d;
• For example, what happens if sel==11 ? input [1:0] sel;
reg out;
• The same will happen if an output is not always @(sel or a or b or c or d)
assigned in all branches of an if-else case (sel)
2‘b00: out = a;
block. 2‘b01: out = b;
2‘b10: out = d;
• An if must have an else !!! endcase
endmodule
• Oh yeah… Stay away from tri-states, as well!
34 © Adam Teman, 2018
 Stick with one reset type
• The purpose of reset is to bring your design into a well-known state.
• It is desirable to have every flip-flop resettable, whether or not required.
• We usually use asynchronous reset: always @(posedge clk or negedge rst_)
if (!rst_)
state <= idle;
else
state <= next_state;

• But synchronous reset is also okay: always @(posedge clk)

if (!rst_)
state <= idle;
else
• Just make sure you don’t mix them state <= next_state;

in your design! assign something = a && reset ;

always@*
case (state)
• And do not put logic on your reset signal! 1’b1011: if (b || reset )
next_state =© idle;
35 Adam Teman, 2018
 Parameterize your design
• “Pretty code” is code that is completely parametrized
• Two approaches to parameterization:
• Compiler directives: `define, `include, and `ifdef
• put all `define statements in external define files.
• Parameters or localparam
• parameters can be overridden through instantiation
• localparam is better for constants, such as FSM encoding

• You can also use generate statements, but be careful of these.

• Always encode FSM states with hard coded values

• You can choose various methods, such as binary, gray code, one-hot, etc.

36 © Adam Teman, 2018

 Write readble code
• Always use indentation!!!
• You will lose points if you turn in ugly code!
• Naming Conventions
• Really useful!
• Common styles:
• C style: words with underscores, e.g., packet_addr, data_in
• Pascal style: capitalize every word, e.g., PacketAddr, DataIn
• Modula style: capitalize every word but the first, e.g., packetAddr, dataIn
• There is no “one right answer”, but two recommended styles are:
• NetFPGA VerilogCodingGuidelines
https://github.com/NetFPGA/netfpga/wiki/VerilogCodingGuidelines
• ETH-Zurich VHDL naming conventions (with emacs highlighting!):
https://www.dz.ee.ethz.ch/en/information/hdl-help/vhdl-naming-conventions.html
37 © Adam Teman, 2018
 Some helpful documents and references
• Chris Fletcher “Verilog: wire vs. reg”
• Greg Tumbush “Signed Arithmetic in Verilog 2001 – Opportunities and Hazards”
• NetFPGA wiki “VerilogCodingGuidelines”
• MIT 6.111 Lectures http://web.mit.edu/6.111/www/f2007/
• Stuart Sutherland, Don Mills “Standard Gotchas: Subtleties in the Verilog and
SystemVerilog Standards That Every Engineer Should Know”

38 © Adam Teman, 2018